mrpro.operators.models.CardiacFingerprinting

class mrpro.operators.models.CardiacFingerprinting[source]

Bases: SignalModel[Tensor, Tensor, Tensor]

Cardiac MR Fingerprinting signal model.

This model simulates a cardiac MR fingerprinting sequence as described in [HAMI2017] and [HAMI2020] using the extended phase graph (EPG) formalism.

It is a three-fold repetition of

Block 0          Block 1          Block 2          Block 3          Block 4
R-peak           R-peak           R-peak           R-peak           R-peak
|----------------|----------------|----------------|----------------|----------------
 [INV 30ms][ACQ]           [ACQ]   [T2-prep][ACQ]   [T2-prep][ACQ]  [T2-prep][ACQ]

Note

This model is on purpose not flexible in all design choices. Instead, consider writing a custom SignalModel based on this implementation if you need to simulate a different sequence.

References

[HAMI2017]

Hamilton, J. I. et al. (2017) MR fingerprinting for rapid quantification of myocardial T1, T2, and proton spin density. Magn. Reson. Med. 77 http://doi.wiley.com/10.1002/mrm.26216

[HAMI2020]

Hamilton, J.I. et al. (2020) Simultaneous Mapping of T1 and T2 Using Cardiac Magnetic Resonance Fingerprinting in a Cohort of Healthy Subjects at 1.5T. J Magn Reson Imaging, 52: 1044-1052. https://doi.org/10.1002/jmri.27155

__init__(acquisition_times: Tensor | Sequence[int] = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14), echo_time: float = 0.0015, repetition_time: float = 0.005, t2_prep_echo_times: tuple[float, float, float] = (0.03, 0.05, 0.08)) → None[source]

Initialize the Cardiac MR Fingerprinting signal model.

Parameters:

  • acquisition_times (Tensor | Sequence[int], default: (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)) – Times of the acquisistions in s. Either 15 values (the first acquisition of each block) or 705 values for all acquisitions. In both cases only the time of the first acquisition of each block will be used to calculate the delays.

  • echo_time (float, default: 0.0015) – TE in s

  • repetition_time (float, default: 0.005) – TR in s

  • t2_prep_echo_times (tuple[float, float, float], default: (0.03, 0.05, 0.08)) – Echo times of the three T2 preparation blocks in s

__call__(m0: Tensor, t1: Tensor, t2: Tensor) → tuple[Tensor][source]

Simulate the Cardiac MR Fingerprinting (cMRF) signal.

Parameters:

  • m0 (Tensor) – Equilibrium signal / proton density. (complex). Shape (...), for example (*other, coils, z, y, x) or (samples).

  • t1 (Tensor) – Longitudinal (T1) relaxation time in seconds. Shape (...), for example (*other, coils, z, y, x) or (samples).

  • t2 (Tensor) – Transversal (T2) relaxation time in seconds. Shape (...), for example (*other, coils, z, y, x) or (samples).

Returns:

Simulated Cardiac MR Fingerprinting signal. Shape (acquisitions ...), for example (acquisitions, *other, coils, z, y, x) or (acquisitions, samples) where acquisitions corresponds to the different acquisitions in the sequence.

forward(m0: Tensor, t1: Tensor, t2: Tensor) → tuple[Tensor][source]

Apply forward of CardiacFingerprinting.

Note

Prefer calling the instance of the CardiacFingerprinting as operator(x) over directly calling this method. See this PyTorch discussion.

__add__(other: Operator[Unpack[Tin], Tout]) → Operator[Unpack[Tin], Tout][source]
__add__(other: Tensor | complex) → Operator[Unpack[Tin], tuple[Unpack[Tin]]]

Operator addition.

Returns lambda x: self(x) + other(x) if other is a operator, lambda x: self(x) + other*x if other is a tensor

__matmul__(other: Operator[Unpack[Tin2], tuple[Unpack[Tin]]] | Operator[Unpack[Tin2], tuple[Tensor, ...]]) → Operator[Unpack[Tin2], Tout][source]

Operator composition.

Returns lambda x: self(other(x))

__mul__(other: Tensor | complex) → Operator[Unpack[Tin], Tout][source]

Operator multiplication with tensor.

Returns lambda x: self(x*other)

__radd__(other: Tensor | complex) → Operator[Unpack[Tin], tuple[Unpack[Tin]]][source]

Operator right addition.

Returns lambda x: other*x + self(x)

__rmul__(other: Tensor | complex) → Operator[Unpack[Tin], Tout][source]

Operator multiplication with tensor.

Returns lambda x: other*self(x)