BssfpReadout3D

class pypulseqpp.sequences.BssfpReadout3D

Bases: SequenceModule

Slab-selective balanced SSFP, encoded along y and z.

fov and matrix take three values, readout first. Add each scaled partition encode to the slice rephaser whose window it shares (gz_partition to gz_pre, gz_partition_rew to gz_rew), for example with pypulseqpp.add_gradients(), rather than playing it alone.

Every axis is balanced between consecutive RF centres. The slice rephasers are part of that balance and are built here, so pass an excitation built with rephase=False.

The module’s blocks are excitation, acquisition, rewind. A loop plays each shot as the previous shot’s rewind, excitation, acquisition, and writes the transients itself: the half-flip pulse (rf at half amplitude, opposite in phase to the first excitation) then wait_prep; wait_rewind with gz_rew in place of the first rewind; and a last rewind block to ramp down.

Parameters:

• system (pypulseqpp.Opts) – System limits.

• rf (RfEvent) – The excitation.

• gz (GradEvent, default=None) – Its selection gradient without a rephaser, played in the excitation block. None for a hard pulse.

• fov (float or sequence of float) – Field of view (m), per encoded axis, readout first.

• matrix (int or sequence of int) – Matrix size, per encoded axis.

• tr (float, default=None) – Repetition time (s). None is as short as possible; a longer one is padded evenly either side of the echo, so TE stays at TR/2.

• half_flip_prep (bool, default=True) – Publish wait_prep. This requires the acquisition block after the echo to be at least as long as the excitation block after the pulse centre. Turn it off to ramp the train in with dummy repetitions.

• oversampling (float, default=1.0) – Read oversampling.

• readout_bandwidth_hz (float, default=250000.0) – Requested ADC sampling rate (Hz). bandwidth_hz reports the achieved raster-compatible rate.

• labels (sequence of str, default=None) – Counters emitted on the acquisition block.

• trigger (event, default=None) – A trigger or digital output armed on the rewind block.

Attributes:

• rf (RfEvent) – The excitation, replayed every repetition with the phase and amplitude the loop sets.

• gz (GradEvent) – Its selection gradient, if one was given.

• gx, gx_rew (GradEvent) – gx ramps up from zero, prephases and holds the readout plateau to the end of the acquisition block; gx_rew ramps down from the plateau and rewinds the read axis.

• gy_pre, gy_rew (TrapEvent) – In-plane encode at its largest step, and the same negated, to be scaled per shot.

• gz_pre, gz_rew (TrapEvent) – The slice rephasers: gz_pre in the acquisition block after the pulse, gz_rew in the rewind block before the next one. Absent for a hard pulse.

• gz_partition, gz_partition_rew (TrapEvent) – Partition encode at its largest step, and the same negated, sharing the window of gz_pre and gz_rew respectively. 3D only.

• adc (AdcEvent) – The acquisition window, spanning the readout plateau.

• adc_labels (LabelSetEvent or list of LabelSetEvent) – One per name in labels; a bare event when there is one.

• prep_labels, train_labels, end_labels (list of LabelSetEvent) – ONCE set to 1, 0 and 2, for the half-flip block, the block after it and the final rewind.

• wait_prep (DelayEvent) – Played after the half-flip block; with the wait_rewind block it puts the half-flip pulse half a repetition before the first excitation. Absent under half_flip_prep=False.

• wait_rewind (DelayEvent) – The rewind block’s duration, for the first repetition.

• tr, te (float) – Repetition and echo time (s); te is always half of tr.

• bandwidth_hz (float) – Achieved ADC sampling rate (Hz).

• n_samples (int) – Samples per repetition.

• delta_kx (float) – Read-axis k-space step (1/m).

• readout_duration (float) – Sampling window (s).

Raises:

ValueError – If a size or rate is out of range, the half_flip_prep condition fails, or the requested TR is shorter than the module can achieve.

Examples

>>> import pypulseqpp.sequences as design
>>> import pypulseqpp as pp
>>> system = pp.Opts()
>>> excitation = design.SpatialSelectiveExcitation(
...     system, 25.0, 0.12, 1e-3, is_slab=True, rephase=False
... )
>>> readout = design.BssfpReadout3D(
...     system, excitation.rf, excitation.gz,
...     fov=(0.28, 0.28, 0.12), matrix=(64, 64, 32),
...     readout_bandwidth_hz=50_000,
... )
>>> readout.gz_partition.channel, readout.gz_pre.channel
('z', 'z')

One repetition of the slab acquisition. The partition encode is published separately and is not played in the layout drawn here:

(svg)

(svg)

Methods

init_module	Build the module's block layout; implemented by the subclass.
publish	Publish events from the caller's locals and register keyword aliases.
register	Publish named events without requiring prior block registration.

Attributes

blocks	Return block tuples in play order, retaining the original event objects.
duration	Duration of the module in seconds.
seq	Sequence holding the module's construction-time block layout.