NMR and MRI physics · Intermediate

Inversion recovery sequence and the null point

Written by SignalsLab

Early edition: these lessons are being reviewed.

Content

Summary

An inversion recovery sequence begins with a 180 degree pulse that flips longitudinal magnetization to the negative z axis. During the delay TI, T1 relaxation brings it back toward equilibrium, and a 90 degree pulse then reads out the current value. Tissue signal passes through zero at the null point, TI = T1 ln2, which is used to suppress fat (STIR) or fluid (FLAIR).

Intuition

Picture the magnetization as a vector that is flipped upside down and then slowly climbs back up. Because it starts at minus M0 and ends at plus M0, it must cross zero on the way. The time of that crossing depends only on T1. Tissues with short T1 recover quickly and cross zero early, while tissues with long T1 cross later. If you fire the 90 degree readout pulse exactly when one tissue crosses zero, that tissue contributes no signal, and the other tissues, which are at different points on their recovery curves, still do. The sim lets you drag TI and watch each tissue's curve and the resulting image brightness.

Key equations

Mz(TI)=M0(1−2e−TI/T1)
(1)

Longitudinal magnetization at the time of the 90 degree readout, assuming full recovery between repetitions (long TR).

TInull=T1ln⁡2≈0.693T1
(2)

Inversion time at which Mz crosses zero and that tissue gives no signal.

Mz(TI)=M0(1−2e−TI/T1+e−TR/T1)
(3)

General form when TR is finite, so recovery is incomplete.

Derivation

  1. After the 180 degree pulse, Mz(0)=−M0.
  2. T1 recovery obeys dMzdt=M0−MzT1, giving Mz(t)=M0+(Mz(0)−M0)e−t/T1.
  3. Substitute Mz(0)=−M0: Mz(t)=M0(1−2e−t/T1).
  4. Set Mz = 0: 2e^{-TI/T1} = 1, so e^{-TI/T1} = 1/2.
  5. Take logs: TI/T1 = ln2, so TI_null = T1 ln2.
  6. With finite TR, the starting value is not −M0 but −M0(1−e−TR/T1) approximately, which adds the e−TR/T1 term and shifts the null to a shorter TI.

Worked example

Problem

Fat at 1.5 T has T1 about 260 ms. Find the TI that nulls fat (STIR), assuming long TR. Then find the null for CSF with T1 about 4000 ms (FLAIR).

  1. Fat: TI = 0.693 x 260 ms = 180 ms.
  2. CSF: TI = 0.693 x 4000 ms = 2772 ms, about 2.8 s.
  3. Check fat at TI = 180 ms: 1 - 2e^{-0.692} = 1 - 2(0.5) = 0, as expected.
  4. In practice, FLAIR uses a TI near 2200 ms because finite TR shortens the null.

Answer Fat null is about 180 ms (STIR); CSF null is about 2.8 s with long TR, and roughly 2.2 s in practice with finite TR (FLAIR).

Common mistakes

  • Using TI = T1 instead of T1 ln2 for the null.
  • Forgetting that the finite-TR formula shifts the null to shorter TI.
  • Thinking the signal is negative: magnitude images show |Mz|, so tissue just before and after the null look equally dark near it, not negative.
  • Confusing TI (inversion to readout) with TR (between repetitions) or TE.
  • Assuming STIR nulls fat by chemical shift; it relies on T1, so other short-T1 tissues, such as gadolinium-enhanced ones, can also be nulled.

Animation

Animation coming soon

The animated version of this lesson is being prepared for the web. In the Signals AI app, lessons are drawn step by step.

Code

scene.py(96 lines)
from manim import *
from blocks import *
from mri_blocks import *
import numpy as np
import sys

# Physics parameters (times in ms)
T1 = 500.0
T2 = 100.0
TI = T1 * np.log(2.0)        # null point: 1 - 2 exp(-TI/T1) = 0
T_END = 1000.0
N1 = 18                      # steps from inversion to TI
DT1 = TI / N1
DT2 = 20.0


def run_sim():
    """Inversion, recovery to TI, 90 pulse, further relaxation. Returns times, M history."""
    events = [{"type": "rf", "flip": np.pi}]
    events += [{"type": "wait", "dt": DT1}] * N1
    events += [{"type": "rf", "flip": np.pi / 2}]
    n2 = int(round((T_END - TI) / DT2))
    events += [{"type": "wait", "dt": (T_END - TI) / n2}] * n2
    times, hist = bloch_simulate(events, [0.0, 0.0, 1.0], T1, T2, [0.0])
    return times, hist[0]


class Main(Scene):
    def construct(self):
        TitleCard(self, "Inversion Recovery", "180° pulse, wait TI, then 90° readout")
        times, M = run_sim()

        # --- timing diagram (upper part) ---
        diag = PulseSequenceDiagram(rows=("RF", "Gz", "ADC"), t_max=1100.0, width=11, height=2.4)
        diag.move_to([0, 1.3, 0])
        rf180 = diag.add_rf(0, 40, kind="hard", amp=1.0)
        rf90 = diag.add_rf(TI - 25, TI + 25, kind="sinc", amp=0.8)
        gz1 = diag.add_gradient("Gz", 0, 40, amp=0.7)
        gz2 = diag.add_gradient("Gz", TI - 25, TI + 25, amp=0.7)
        adc = diag.add_adc(TI + 40, TI + 160)
        l180 = Text("180°", font_size=24, color=C_ACCENT).next_to(rf180, RIGHT, buff=0.1)
        l90 = Text("90°", font_size=24, color=C_ACCENT).next_to(rf90, RIGHT, buff=0.1)
        ti_mark = diag.add_marker(TI, "TI")
        self.play(FadeIn(diag), run_time=0.8)
        self.play(FadeIn(rf180, gz1, l180, rf90, gz2, l90, adc, ti_mark), run_time=1.0)
        cursor = diag.time_cursor()
        self.add(cursor)

        # --- simulation views (lower part) ---
        bloch = BlochSphere2D(radius=1.0).move_to([-4.6, -1.75, 0])
        sp = SignalPlot(x_range=(0, 1000, 250), y_range=(-1, 1, 0.5), x_label="t (ms)",
                        y_label="Mz", width=6.5, height=2.2).move_to([2.2, -1.75, 0])
        zero = DashedLine(sp.axes.c2p(0, 0), sp.axes.c2p(1000, 0), color=C_DIM, stroke_width=1)
        self.play(FadeIn(bloch), FadeIn(sp), Create(zero), run_time=0.8)
        StepCaption(self, "180° pulse flips M to -z")
        vec = bloch.vector(M[1])
        self.play(GrowArrow(vec), run_time=0.5)

        # --- animate recorded states in chunks ---
        ti_idx = N1 + 1
        chunks = list(range(1, ti_idx + 1, 3))
        if chunks[-1] != ti_idx:
            chunks.append(ti_idx)
        StepCaption(self, "Mz recovers with T1 through zero")
        for a, b in zip(chunks[:-1], chunks[1:]):
            seg = sp.plot(times[a:b + 1], M[a:b + 1, 2])
            self.play(diag.cursor_to(times[b]), Create(seg),
                      Transform(vec, bloch.vector(M[b])), run_time=0.35, rate_func=linear)
        dot = sp.dot_at(TI, M[ti_idx, 2], color=C_BAD)
        StepCaption(self, "At TI = T1 ln2, Mz = 0: the 90° pulse finds nothing")
        self.play(FadeIn(dot), Transform(vec, bloch.vector(M[ti_idx + 1])), run_time=0.8)
        self.wait(0.6)
        # after the readout: continue relaxation
        rest = list(range(ti_idx + 1, len(times), 8))
        if rest[-1] != len(times) - 1:
            rest.append(len(times) - 1)
        for a, b in zip(rest[:-1], rest[1:]):
            seg = sp.plot(times[a:b + 1], M[a:b + 1, 2], color=C_GOOD)
            self.play(diag.cursor_to(times[b]), Create(seg),
                      Transform(vec, bloch.vector(M[b])), run_time=0.35, rate_func=linear)
        StepCaption(self, "Choosing TI at a tissue's null point suppresses its signal")
        self.wait(1.5)


if __name__ == "__main__" and "--selftest" in sys.argv:
    times, M = run_sim()
    assert abs(M[1, 2] + 1.0) < 1e-9                      # inverted
    ti_idx = N1 + 1
    assert abs(times[ti_idx] - TI) < 1e-9
    assert abs(M[ti_idx, 2]) < 1e-9                        # null point
    assert np.linalg.norm(M[ti_idx + 1, :2]) < 1e-9        # no transverse signal
    mid = 5
    assert abs(M[mid, 2] - (1 - 2 * np.exp(-times[mid] / T1))) < 1e-9
    assert np.all(np.diff(M[1:ti_idx + 1, 2]) > 0)         # monotone recovery
    assert abs(times[-1] - T_END) < 1e-6
    print("selftest ok")

The Manim scene code that draws this lesson's animation in the Signals AI app (Python, Manim Community).

ccBYNC© 2026 SignalsLab. Lesson text shared as is under CC BY-NC 4.0.