RosetteProjectionReadout

class pypulseqpp.sequences.RosetteProjectionReadout

Bases: NonCartesianReadout

Rosette petals turned over a sphere.

Parameters:

• system (Opts) – System limits.

• rf (RfEvent) – The pulse that opens the repetition.

• gz (GradEvent, default=None) – A selection gradient played in the same block as rf.

• gz_reph (GradEvent, default=None) – The rephaser that unwinds gz, played left-aligned in the first block after the pulse. Accepted only on an axis that the loop’s rotation leaves unchanged.

• fov (float) – Isotropic field of view (m).

• matrix (int) – In-plane matrix size.

• petals (int, default=5) – Centre-to-centre radial lobes in one interleaf, not shots.

• angular_frequency_ratio (float, default=3.0 / 5.0) – Positive angular-to-radial frequency ratio.

• echo_spacing_s (float, default=None) – Requested centre-crossing interval (s). The waveform is stretched when necessary; requests shorter than the time-optimal spacing are rejected.

• oversampling (float, default=1.0) – ADC oversampling factor, at least one.

• readout_bandwidth_hz (float, default=250000.0) – Requested ADC sampling rate (Hz), not bandwidth per pixel.

• derate (bool, default=True) – Apply the package’s system derates before solving.

• fov_z (float, default=None) – Partition field of view (m). Stacks only.

• matrix_z (int, default=None) – Partition count. Stacks only.

• te (float, default=None) – Echo time (s) from the RF isodelay to the path’s nearest k = 0 crossing. None is as short as possible.

• tr (float, default=None) – Repetition time (s). None is as short as possible.

• spoiling_cycles (float, default=0.0) – Dephasing left at the end of the TR, in cycles across voxel_size_m. Zero leaves the path rewound.

• voxel_size_m (float, default=None) – Length the spoiling is counted over (m); the trajectory’s resolution by default.

• spoiling_axis ({'z', 'x', 'y'}, default='z') – Axis the spoiler is played on.

• n_echoes (int, default=1) – Path traversals per repetition, separated by echo_spacing, each with its own ECO label and joined by rewinders and prewinders.

• explicit (bool, default=False) – Write out one interleaf per entry of angles instead of one base interleaf.

• angles (ArrayLike, default=None) – In-plane rotations (rad). Required when explicit and rejected otherwise.

• labels (Sequence[str], default=None) – Counters emitted on the acquisition block.

• trigger (TriggerEvent, default=None) – A trigger or digital output armed on the block that opens the readout.

Attributes:

• rf (RfEvent) – The pulse the module was given.

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

• gz_reph (GradEvent) – Its rephaser, if one was given, left-aligned in whichever block follows the pulse.

• gx, gy (GradEvent) – The interleaf. Lists of one entry per angle when explicit.

• gx_pre, gy_pre (GradEvent) – Prewinding gradients reaching the start of the path, when it is not k = 0.

• gx_rew, gy_rew (GradEvent) – Rewinding gradients returning to k = 0, when the path does not end there.

• gz_pre, gz_rew (TrapEvent) – Partition encode and its rewinder. Stacks only.

• gz_spoil (GradEvent) – End-of-TR spoiler, when spoiling_cycles is nonzero.

• adc (AdcEvent) – The acquisition window.

• adc_labels (LabelEvent | list[LabelEvent]) – One per name in labels; a bare event when there is one.

• wait_te, wait_tr (DelayEvent) – Present only when a TE or TR longer than the minimum was asked for.

• wait_pre, wait_rew (DelayEvent) – Pads setting the span of the prewinder and rewinder blocks, which can outlast their gradients. Absent when that block is not played.

• trajectory (NonCartesianGradient) – The designed interleaf, for its trajectory array and timings.

• echo_spacing (float) – Time between consecutive echoes (s), zero for a single-echo readout.

Examples

>>> import pypulseqpp.sequences as design
>>> import pypulseqpp as pp
>>> system = pp.Opts(max_grad=40, grad_unit="mT/m",
...                  max_slew=150, slew_unit="T/m/s")
>>> hard = design.NonSelectiveExcitation(system, 10.0, 0.5e-3)
>>> readout = design.RosetteProjectionReadout(
...     system, hard.rf, fov=0.22, matrix=64
... )
>>> int(readout.adc.num_samples) > 0
True

One interleaf of a spherical rosette acquisition, before the loop turns it:

(svg)

(svg)

Methods

arm	Block layout of one arm, as the module built it.
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.