def rf_from_lib_data(self, lib_data):
"""
Construct RF object from `lib_data`.
Parameters
----------
lib_data : list
RF envelope.
Returns
-------
rf : SimpleNamespace
RF object constructed from lib_data.
"""
rf = SimpleNamespace()
rf.type = 'rf'
amplitude, mag_shape, phase_shape = lib_data[0], lib_data[1], lib_data[2]
shape_data = self.shape_library.data[mag_shape]
compressed = SimpleNamespace()
compressed.num_samples = shape_data[0]
compressed.data = shape_data[1:]
mag = decompress_shape(compressed)
shape_data = self.shape_library.data[phase_shape]
compressed.num_samples = shape_data[0]
compressed.data = shape_data[1:]
phase = decompress_shape(compressed)
rf.signal = 1j * 2 * np.pi * phase
rf.signal = amplitude * mag * np.exp(rf.signal)
rf.t = np.arange(1, max(mag.shape) + 1) * self.rf_raster_time
if max(lib_data.shape) < 6:
rf.delay = 0
rf.freq_offset = lib_data[3]
rf.phase_offset = lib_data[4]
lib_data = np.append(lib_data, 0)
else:
rf.delay = lib_data[3]
rf.freq_offset = lib_data[4]
rf.phase_offset = lib_data[5]
if max(lib_data.shape) < 7:
lib_data = np.append(lib_data, 0)
rf.dead_time = lib_data[6]
if max(lib_data.shape) < 8:
lib_data = np.append(lib_data, 0)
rf.ringdown_time = lib_data[7]
if max(lib_data.shape) < 9:
lib_data = np.append(lib_data, 0)
use_cases = {1: 'excitation', 2: 'refocusing', 3: 'inversion'}
if lib_data[8] in use_cases:
rf.use = use_cases[lib_data[8]]
return rf
def get_block(self, block_index: int) -> SimpleNamespace:
"""
Returns Pulseq block at `block_index` position in `self.block_events`.
Parameters
----------
block_index : int
Index of Pulseq block to be retrieved from `self.block_events`.
Returns
-------
block : SimpleNamespace
Pulseq block at 'block_index' position in `self.block_events`.
"""
block = SimpleNamespace()
event_ind = self.block_events[block_index]
if event_ind[0] > 0:
delay = SimpleNamespace()
delay.type = 'delay'
delay.delay = self.delay_library.data[event_ind[0]][0]
block.delay = delay
elif event_ind[1] > 0:
block.rf = self.rf_from_lib_data(self.rf_library.data[event_ind[1]])
grad_channels = ['gx', 'gy', 'gz']
for i in range(1, len(grad_channels) + 1):
if event_ind[2 + (i - 1)] > 0:
grad, compressed = SimpleNamespace(), SimpleNamespace()
type = self.grad_library.type[event_ind[2 + (i - 1)]]
lib_data = self.grad_library.data[event_ind[2 + (i - 1)]]
grad.type = 'trap' if type == 't' else 'grad'
grad.channel = grad_channels[i - 1][1]
if grad.type == 'grad':
amplitude = lib_data[0]
shape_id = lib_data[1]
delay = lib_data[2]
shape_data = self.shape_library.data[shape_id]
compressed.num_samples = shape_data[0]
compressed.data = shape_data[1:]
g = decompress_shape(compressed)
grad.waveform = amplitude * g
grad.t = np.arange(g.size) * self.grad_raster_time
grad.delay = delay
if len(lib_data) > 4:
grad.first = lib_data[3]
grad.last = lib_data[4]
else:
grad.first = grad.waveform[0]
grad.last = grad.waveform[-1]
else:
grad.amplitude, grad.rise_time, grad.flat_time, grad.fall_time, grad.delay = [
lib_data[x] for x in range(5)
]
grad.area = grad.amplitude * (
grad.flat_time + grad.rise_time / 2 + grad.fall_time / 2)
grad.flat_area = grad.amplitude * grad.flat_time
setattr(block, grad_channels[i - 1], grad)
if event_ind[5] > 0:
lib_data = self.adc_library.data[event_ind[5]]
if max(lib_data.shape) < 6:
lib_data = np.append(lib_data, 0)
adc = SimpleNamespace()
adc.num_samples, adc.dwell, adc.delay, adc.freq_offset, adc.phase_offset, adc.dead_time = [
lib_data[x] for x in range(6)
]
adc.num_samples = int(adc.num_samples)
adc.type = 'adc'
block.adc = adc
return block
def get_block(self, block_index: int) -> SimpleNamespace:
"""
Returns PyPulseq block at `block_index` position in `self.dict_block_events`.
Parameters
----------
block_index : int
Index of PyPulseq block to be retrieved from `self.dict_block_events`.
Returns
-------
block : SimpleNamespace
PyPulseq block at 'block_index' position in `self.dict_block_events`.
Raises
------
ValueError
If a trigger event of an unsupported control type is encountered.
If a label object of an unknown extension ID is encountered.
"""
block = SimpleNamespace()
event_ind = self.dict_block_events[block_index]
if event_ind[0] > 0: # Delay
delay = SimpleNamespace()
delay.type = 'delay'
delay.delay = self.delay_library.data[event_ind[0]][0]
block.delay = delay
if event_ind[1] > 0: # RF
block.rf = self.rf_from_lib_data(self.rf_library.data[event_ind[1]])
# Gradients
grad_channels = ['gx', 'gy', 'gz']
for i in range(1, len(grad_channels) + 1):
if event_ind[2 + (i - 1)] > 0:
grad, compressed = SimpleNamespace(), SimpleNamespace()
grad_type = self.grad_library.type[event_ind[2 + (i - 1)]]
lib_data = self.grad_library.data[event_ind[2 + (i - 1)]]
grad.type = 'trap' if grad_type == 't' else 'grad'
grad.channel = grad_channels[i - 1][1]
if grad.type == 'grad':
amplitude = lib_data[0]
shape_id = lib_data[1]
delay = lib_data[2]
shape_data = self.shape_library.data[shape_id]
compressed.num_samples = shape_data[0]
compressed.data = shape_data[1:]
g = decompress_shape(compressed)
grad.waveform = amplitude * g
grad.t = np.arange(g.size) * self.grad_raster_time
grad.delay = delay
if len(lib_data) > 4:
grad.first = lib_data[3]
grad.last = lib_data[4]
else:
grad.first = grad.waveform[0]
grad.last = grad.waveform[-1]
else:
if max(lib_data.shape) < 5: # added by GT
grad.amplitude, grad.rise_time, grad.flat_time, grad.fall_time = [
lib_data[x] for x in range(4)
]
grad.delay = 0
else:
grad.amplitude, grad.rise_time, grad.flat_time, grad.fall_time, grad.delay = [
lib_data[x] for x in range(5)
]
grad.area = grad.amplitude * (
grad.flat_time + grad.rise_time / 2 + grad.fall_time / 2)
grad.flat_area = grad.amplitude * grad.flat_time
setattr(block, grad_channels[i - 1], grad)
# ADC
if event_ind[5] > 0:
lib_data = self.adc_library.data[event_ind[5]]
if len(lib_data) < 6:
lib_data = np.append(lib_data, 0)
adc = SimpleNamespace()
adc.num_samples, adc.dwell, adc.delay, adc.freq_offset, adc.phase_offset, adc.dead_time = [
lib_data[x] for x in range(6)
]
adc.num_samples = int(adc.num_samples)
adc.type = 'adc'
block.adc = adc
# Triggers
if event_ind[6] > 0:
# We have extensions - triggers, labels, etc.
next_ext_id = event_ind[6]
while next_ext_id != 0:
ext_data = self.extensions_library.data[next_ext_id]
# Format: ext_type, ext_id, next_ext_id
ext_type = self.get_extension_type_string(ext_data[0])
if ext_type == 'TRIGGERS':
trigger_types = ['output', 'trigger']
data = self.trigger_library.data[ext_data[1]]
trigger = SimpleNamespace()
trigger.type = trigger_types[int(data[0])]
if data[0] == 0:
trigger_channels = ['osc0', 'osc1', 'ext1']
trigger.channel = trigger_channels[int(data[1])]
elif data[0] == 1:
trigger_channels = ['physio1', 'physio2']
trigger.channel = trigger_channels[int(data[1])]
else:
raise ValueError('Unsupported trigger event type')
trigger.delay = data[2]
trigger.duration = data[3]
# Allow for multiple triggers per block
if hasattr(block, 'trigger'):
block.trigger[len(block.trigger)] = trigger
else:
block.trigger = {0: trigger}
elif ext_type == 'LABELSET' or ext_type == 'LABELINC':
label = SimpleNamespace()
label.type = ext_type.lower()
supported_labels = get_supported_labels()
if ext_type == 'LABELSET':
data = self.label_set_library.data[ext_data[1]]
else:
data = self.label_inc_library.data[ext_data[1]]
label.label = supported_labels[data[1] - 1]
label.value = data[0]
# Allow for multiple labels per block
if hasattr(block, 'label'):
block.label[len(block.label)] = label
else:
block.label = {0: label}
else:
raise RuntimeError(f'Unknown extension ID {ext_data[0]}')
next_ext_id = ext_data[2]
return block