NMR and MRI physics · Intermediate

Fast (turbo) spin echo: echo train and k-space segments

Written by SignalsLab

Early edition: these lessons are being reviewed.

Content

Summary

Fast (turbo) spin echo acquires several phase-encoding lines per excitation by applying multiple 180-degree refocusing pulses and encoding each echo differently. The number of echoes per excitation is the echo train length (ETL), which divides the scan time by ETL. The ordering of echoes in k-space sets the effective TE and contrast, and T2 decay across the train causes blurring.

Intuition

In conventional spin echo, one excitation gives one echo and so one k-space line, and then we wait a full TR. That wastes time. In turbo spin echo, after one 90-degree pulse we fire a train of 180-degree pulses, each producing an echo. Before each echo we change the phase-encoding gradient, so every echo fills a different k-space line, and a rewinder gradient returns the phase afterwards. The echoes decay with T2, so later echoes are weaker. Lines acquired early are strong and those acquired late are weak. The echo placed near the k-space centre dominates contrast, so its time is the effective TE. Edges of k-space hold detail; if they are weak because of T2 decay, the image blurs. Fat also stays bright because rapid refocusing pulses reduce J-coupling modulation.

Key equations

Nshots=NPEETL
(1)

Number of excitations (TR periods) needed to fill all phase-encoding lines.

Tacq=TR⋅NPE⋅NEXETL
(2)

Scan time is reduced by a factor equal to the echo train length.

TEeff=nc⋅ESP
(3)

Effective TE is the time of the echo that fills the central k-space line, the n_c-th echo with echo spacing ESP.

Sn∝e−nESP/T2
(4)

Signal amplitude of the n-th echo in the train, which weights k-space lines.

Derivation

  1. Conventional SE: one echo per TR, so time = TR × N_PE × NEX.
  2. In TSE, each excitation is followed by ETL refocusing pulses, each generating one echo.
  3. Each echo gets a different phase-encoding step, so one TR fills ETL lines.
  4. Shots needed = N_PE / ETL, so time = TR × (N_PE/ETL) × NEX.
  5. Echo n occurs at n × ESP and has amplitude set by e^(-n ESP/T2).
  6. Assigning the central line to echo n_c gives TE_eff = n_c × ESP.
  7. Segmenting k-space: each shot's echoes cover an interleaved or contiguous set of lines, so the amplitude modulation across k-space becomes a filter on the image, which causes blurring along phase-encode.

Worked example

Problem

A 2D TSE has 256 phase-encoding lines, TR = 4000 ms, NEX = 1, ETL = 16, echo spacing 10 ms. The central line is filled by echo 8. Find the scan time and the effective TE, and compare to conventional SE.

  1. Shots = 256/16 = 16.
  2. Scan time = 16 × 4000 ms = 64 s (per slice-set in the interleaved multislice acquisition).
  3. Conventional SE time = 256 × 4000 ms = 1024 s, about 17 min.
  4. TE_eff = 8 × 10 ms = 80 ms.
  5. Last echo at 16 × 10 = 160 ms; with T2 = 80 ms its signal is e^-2 ≈ 14% of the initial signal.

Answer Scan time is 64 s (16 times faster than 1024 s), with effective TE of 80 ms.

Common mistakes

  • Thinking TSE shortens TR rather than reducing the number of TR periods.
  • Treating TE_eff as the first echo time rather than the echo filling central k-space.
  • Ignoring T2 blurring and SAR increase when ETL is long.
  • Assuming all echoes in the train contribute equal signal.
  • Confusing echo spacing with TE_eff.

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(112 lines)
from manim import *
from blocks import *
from mri_blocks import *
import numpy as np
import sys

# ---------- sequence parameters (ms for diagram, s for physics) ----------
T_MAX = 90.0                 # ms shown in diagram
ESP = 20.0                   # echo spacing, ms
ETL = 4                      # echo train length
RF180 = [10.0, 30.0, 50.0, 70.0]
ECHOES = [20.0, 40.0, 60.0, 80.0]
NY = 8
ROWS = [6, 4, 2, 0]          # k-space line filled by each echo (shot 1)
T1, T2 = 1.0, 0.08           # s


def ky_of_row(r, ny=NY):
    """Normalised ky of phase-encode line r (0 = bottom)."""
    return -1 + (2 * r + 1) / ny


def simulate_train(n_iso=40, spread_hz=30.0, seed=0):
    """CPMG echo train with 1 ms steps; return times (ms) and |Mxy| signal."""
    dfs = isochromat_offsets(n_iso, spread_hz, "lorentzian", seed)
    events = [{"type": "rf", "flip": np.pi / 2, "phase": 0.0}]
    for ms in range(int(T_MAX)):
        if float(ms) in RF180:
            events.append({"type": "rf", "flip": np.pi, "phase": np.pi / 2})
        events.append({"type": "wait", "dt": 0.001})
    times, hist = bloch_simulate(events, [0, 0, 1.0], T1, T2, dfs)
    sig = np.abs(np.mean(hist[:, :, 0] + 1j * hist[:, :, 1], axis=0))
    return times * 1000.0, sig


def echo_amp(times, sig, te):
    """Signal value at the last sample with time te (ms)."""
    idx = np.where(np.abs(times - te) < 1e-6)[0][-1]
    return float(sig[idx])


TIMES, SIG = simulate_train()
AMPS = [echo_amp(TIMES, SIG, te) for te in ECHOES]


class Main(Scene):
    def construct(self):
        TitleCard(self, "Fast (turbo) spin echo", "one excitation, many echoes, many k-space lines")

        # ---- timing diagram (upper part) ----
        psd = PulseSequenceDiagram(rows=("RF", "Gz", "Gy", "Gx", "ADC"), t_max=T_MAX, width=12, height=3.3)
        psd.move_to([0, 0.95, 0])
        parts = VGroup()
        parts.add(psd.add_rf(0, 4, label="90°"))
        parts.add(psd.add_gradient("Gz", 0, 4, amp=0.8))
        for t in RF180:
            parts.add(psd.add_rf(t - 2, t + 2, label="180°"))
            parts.add(psd.add_gradient("Gz", t - 2, t + 2, amp=0.8))
        for te, r in zip(ECHOES, ROWS):
            ky = ky_of_row(r)
            parts.add(psd.add_gradient("Gy", te - 7, te - 5, amp=ky, shape="rect", color=C_ACCENT))
            parts.add(psd.add_gradient("Gy", te + 5, te + 7, amp=-ky, shape="rect", color=C_DIM))
            parts.add(psd.add_gradient("Gx", te - 4, te + 4, amp=0.7))
            parts.add(psd.add_adc(te - 4, te + 4))
        te_eff = psd.add_marker(ECHOES[1], "TE_eff = 40 ms", color=C_GOOD)
        self.play(FadeIn(psd), run_time=0.8)
        self.play(LaggedStart(*[FadeIn(p) for p in parts], lag_ratio=0.05), run_time=2)
        self.play(Create(te_eff), run_time=0.6)

        # ---- lower part: signal + k-space ----
        sp = SignalPlot(x_range=(0, 90, 30), y_range=(0, 1, 0.5), x_label="t (ms)", y_label="|S|",
                        width=5, height=1.4)
        sp.move_to([-3.0, -2.25, 0])
        ks = KSpacePlot(nx=8, ny=NY, size=1.5)
        ks.move_to([3.4, -2.35, 0])
        self.play(FadeIn(sp), FadeIn(ks), run_time=0.7)
        cursor = psd.time_cursor()
        self.add(cursor)
        StepCaption(self, "Each 180° refocuses an echo; Gy blip picks its k-space line")

        # ---- play the echo train in step with simulated time ----
        prev = 0.0
        for k, te in enumerate(ECHOES):
            m = (TIMES >= prev) & (TIMES <= te)
            seg = sp.plot(TIMES[m], SIG[m])
            self.play(psd.cursor_to(te, rate_func=linear), Create(seg, rate_func=linear), run_time=1.6)
            col = C_GOOD if k == 1 else C_ACCENT
            self.play(FadeIn(sp.dot_at(te, AMPS[k], color=col)), ks.mark_line(ROWS[k], color=col),
                      run_time=0.5)
            prev = te
        m = TIMES >= prev
        self.play(psd.cursor_to(T_MAX, rate_func=linear),
                  Create(sp.plot(TIMES[m], SIG[m]), rate_func=linear), run_time=0.8)

        StepCaption(self, "ETL lines per TR: scan ~ETL times faster; centre line sets contrast")
        self.wait(1.2)


if __name__ == "__main__" and "--selftest" in sys.argv:
    # echoes refocus off-resonance: amplitude equals pure T2 decay exp(-TE/T2)
    for te, a in zip(ECHOES, AMPS):
        assert abs(a - np.exp(-te / 1000.0 / T2)) < 1e-6, (te, a)
    assert all(AMPS[i] > AMPS[i + 1] for i in range(len(AMPS) - 1))
    # dephased between echoes (just before each 180°)
    assert echo_amp(TIMES, SIG, 9.0) < AMPS[0]
    # signal right after 90° is full
    assert abs(SIG[1] - 1.0) < 1e-9
    # echo 2 fills the line closest to k-space centre
    kys = [abs(ky_of_row(r)) for r in ROWS]
    assert int(np.argmin(kys)) == 1
    assert ECHOES == [ESP * (k + 1) for k in range(ETL)]
    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.