@renderer(
    domain="magnetics",
    subject="plasma_current",
    view="time",
    quantity="",
    model=LineSeries,
    description="Measured plasma current history from the Rogowski coil.",
    ids=("magnetics",),
    required_paths=(
        "magnetics.ip.0.time",
        "magnetics.ip.0.data",
    ),
    optional_paths=(),
)
def plasma_current_time(
    model: LineSeries,
    *,
    ax: Axes | None = None,
    show: bool = False,
    **style: Any,
) -> tuple[Figure, Axes]:
    """Measured plasma current history from the Rogowski coil.

    Interpretation
    --------------
    The toroidal plasma current against time.  It is the first trace read for
    any discharge: breakdown and current rise, flat-top, termination and
    current quench, and the time windows other analyses use.  It normalizes
    many derived quantities (normalized beta, the Greenwald density, q
    estimates) and compares discharges at a glance.

    Options
    -------
    ``synthetic=`` overlays, as markers at each equilibrium slice, the value
    the reconstruction predicts for this signal, so measurement and fit can be
    compared where the fit exists.  ``orientation=`` draws the current positive
    whatever the stored sign; ``x=`` replaces time by the sample index, for
    checking acquisition rather than physics.

    Convention
    ----------
    The stored sign follows the machine's current direction in the IMAS
    convention.  The default display draws the dominant polarity positive and
    says "sign flipped" in the title when it did; ``orientation="canonical"``
    keeps the stored sign, which is what tells the current direction.

    Limitations
    -----------
    A Rogowski coil measures all current threading it.  Depending on where it
    sits and on the processing that produced the stored waveform, currents
    induced in the vessel and passive structure may be included; they matter
    most at breakdown and during the current quench.

    See Also
    --------
    equilibrium_time_plasma_current : the current the reconstruction fitted.
    current_overview : plasma, coil and eddy currents together.
    """
    return render_line_series(model, ax=ax, show=show, **style)

@renderer(
    domain="magnetics",
    subject="diamagnetic_flux",
    view="time",
    quantity="",
    model=LineSeries,
    description="Measured diamagnetic flux history.",
    ids=("magnetics",),
    required_paths=(
        "magnetics.time",
        "magnetics.diamagnetic_flux.0.data",
    ),
    optional_paths=(),
)
def diamagnetic_flux_time(
    model: LineSeries,
    *,
    ax: Axes | None = None,
    show: bool = False,
    **style: Any,
) -> tuple[Figure, Axes]:
    """Measured diamagnetic flux history.

    Interpretation
    --------------
    The change in toroidal flux through the plasma cross-section caused by the
    plasma.  Through radial pressure balance it measures the perpendicular
    pressure relative to the poloidal field: in the large-aspect-ratio limit a
    plasma with poloidal beta above 1 expels toroidal flux (diamagnetic), one
    below it draws flux in (paramagnetic).  It is the main magnetic measurement of stored energy and
    poloidal beta, and the one that separates beta_p from l_i in a
    reconstruction.

    Options
    -------
    ``synthetic=`` overlays, as markers at each equilibrium slice, the value
    the reconstruction predicts for this signal, so measurement and fit can be
    compared where the fit exists.  By default the dominant polarity is
    drawn positive, so a diamagnetic shot, whose stored flux is negative, is
    drawn positive too and the title says "sign flipped";
    ``orientation="canonical"`` keeps the stored sign and is needed to read
    para- or diamagnetism from the plot.

    Convention
    ----------
    In VEST products a positive stored flux is a paramagnetic plasma (#1196),
    a negative one a diamagnetic plasma.  The sign carries that meaning only
    under ``orientation="canonical"``.

    Limitations
    -----------
    The plasma's contribution is small beside the vacuum toroidal flux, so the
    trace depends on how the toroidal-field pickup and vessel currents were
    compensated, and integrated signals can drift.  Turning it into beta or
    stored energy needs the plasma shape, i.e. a reconstruction.

    See Also
    --------
    equilibrium_time_beta_p : the reconstruction's poloidal beta.
    equilibrium_time_diamagnetic_flux : measured against reconstructed constraint.
    """
    return render_line_series(model, ax=ax, show=show, **style)

@renderer(
    domain="core_profiles",
    subject="electron_density",
    view="time",
    quantity="",
    model=LineSeries,
    description="Volume-averaged electron density history.",
    ids=("core_profiles",),
    required_paths=(
        "core_profiles.time",
        "core_profiles.profiles_1d.{i}.electrons.density",
    ),
    optional_paths=("core_profiles.profiles_1d.{i}.grid.volume",),
)
def electron_density_time(
    model: LineSeries,
    *,
    ax: Axes | None = None,
    show: bool = False,
    **style: Any,
) -> tuple[Figure, Axes]:
    """Volume-averaged electron density history."""
    return render_line_series(model, ax=ax, show=show, **style)

@_profile_renderer(
    domain="core_profiles", quantity="",
    subject="electron_density",
    description="Core electron density profile.",
    ids=("core_profiles",),
    required_paths=("core_profiles.profiles_1d.{i}.electrons.density",),
    optional_paths=("core_profiles.profiles_1d.{i}.grid.rho_tor_norm",),
)
def electron_density_profile(
    model: Profile1D, *, ax: Axes | None = None, show: bool = False, **style: Any
) -> tuple[Figure, Axes]:
    """Core electron density profile.

    Interpretation
    --------------
    The electron density against the radial flux coordinate at one
    core_profiles time.  It is read for the central density, the peaking, the
    gradient regions and the edge, and for how the profile evolves with
    fuelling and confinement.

    Options
    -------
    ``coordinate=`` draws the profile against rho_tor_norm, the square root of
    the normalized toroidal flux, or against the normalized poloidal flux
    psi_N; the values do not change, but positions do, so
    profiles are compared on one coordinate.  ``rational_q=`` and
    ``resonances=`` mark rational surfaces from the equilibrium's q profile.
    ``uncertainty=`` and ``validity=`` control how stored uncertainties and
    flagged values are drawn.

    Limitations
    -----------
    A core_profiles entry may be a fit to measurements, a model or an assumed
    profile; the curve between measurement points is the fit's, not the data.
    Mapping onto a flux coordinate uses an equilibrium, whose errors move the
    points radially.

    See Also
    --------
    thomson_scattering_profile_fit : the measurements behind a fitted profile.
    electron_density_field : the same profile mapped onto the poloidal plane.
    """
    return render_profile_1d(model, ax=ax, show=show, **style)

@_profile_renderer(
    domain="core_profiles", quantity="gradient",
    subject="electron_density",
    description=(
        "Normalized logarithmic gradient of the core electron density, -L d ln f/dx, with its "
        "abscissa, gradient coordinate and reference length stated (a/L by default)."
    ),
    ids=("core_profiles", "equilibrium"),
    required_paths=(
        "core_profiles.profiles_1d.{i}.electrons.density",
        *_GRADIENT_EQUILIBRIUM_PATHS,
    ),
    optional_paths=_GRADIENT_GRID_PATHS,
)
def electron_density_profile_gradient(
    model: Profile1D, *, ax: Axes | None = None, show: bool = False, **style: Any
) -> tuple[Figure, Axes]:
    """Core electron density gradient; the model carries the values, the label and the record."""
    return render_profile_1d(model, ax=ax, show=show, **style)

@_field_renderer(
    domain="core_profiles", quantity="",
    subject="electron_density",
    description="Electron density mapped onto the poloidal plane.",
    ids=("core_profiles", "equilibrium", "wall"),
    required_paths=(
        "core_profiles.profiles_1d.{i}.electrons.density",
        "equilibrium.time_slice.{i}.profiles_2d.{j}.psi",
    ),
    optional_paths=("core_profiles.profiles_1d.{i}.grid.rho_tor_norm",),
)
def electron_density_field(
    model: Field2D, *, ax: Axes | None = None, show: bool = False, **style: Any
) -> tuple[Figure, Axes]:
    """Electron density mapped onto the poloidal plane.

    Interpretation
    --------------
    The electron density profile drawn on the poloidal (R, Z) plane through the
    equilibrium flux surfaces: each grid cell takes the profile's value at its
    own flux surface.  It shows where the density sits relative to the vessel
    and to diagnostic and heating beam paths.

    Options
    -------
    ``time_slice=`` names the equilibrium slice; the profile mapped onto it is
    the core_profiles entry stored at that slice's time.

    Limitations
    -----------
    The map holds no information beyond the 1-D profile and the equilibrium: it
    assumes the quantity is constant on each flux surface, so poloidal
    asymmetries are absent by construction.  Cells are filled wherever the
    normalized flux is below 1 and left blank elsewhere, so a private-flux
    region below an X-point, or flux that recurs near a coil, is filled
    although it is not inside the plasma.

    See Also
    --------
    electron_density_profile : the 1-D profile that is mapped.
    """
    return render_field_2d(model, ax=ax, show=show, **style)

@renderer(
    domain="core_profiles",
    subject="electron_temperature",
    view="time",
    quantity="",
    model=LineSeries,
    description="Volume-averaged electron temperature history.",
    ids=("core_profiles",),
    required_paths=(
        "core_profiles.time",
        "core_profiles.profiles_1d.{i}.electrons.temperature",
    ),
    optional_paths=("core_profiles.profiles_1d.{i}.grid.volume",),
)
def electron_temperature_time(
    model: LineSeries,
    *,
    ax: Axes | None = None,
    show: bool = False,
    **style: Any,
) -> tuple[Figure, Axes]:
    """Volume-averaged electron temperature history."""
    return render_line_series(model, ax=ax, show=show, **style)

@_profile_renderer(
    domain="core_profiles", quantity="",
    subject="electron_temperature",
    description="Core electron temperature profile.",
    ids=("core_profiles",),
    required_paths=("core_profiles.profiles_1d.{i}.electrons.temperature",),
    optional_paths=("core_profiles.profiles_1d.{i}.grid.rho_tor_norm",),
)
def electron_temperature_profile(
    model: Profile1D, *, ax: Axes | None = None, show: bool = False, **style: Any
) -> tuple[Figure, Axes]:
    """Core electron temperature profile.

    Interpretation
    --------------
    The electron temperature against the radial flux coordinate at one
    core_profiles time.  It is read for the central temperature, the peaking,
    the regions of steep gradient and a pedestal if there is one, and for how
    the profile changes between times or discharges.

    Options
    -------
    ``coordinate=`` draws the profile against rho_tor_norm, the square root of
    the normalized toroidal flux, or against the normalized poloidal flux
    psi_N; the values do not change, but positions do, so
    profiles are compared on one coordinate.  ``rational_q=`` and
    ``resonances=`` mark rational surfaces from the equilibrium's q profile.
    ``uncertainty=`` and ``validity=`` control how stored uncertainties and
    flagged values are drawn.

    Limitations
    -----------
    A core_profiles entry may be a fit to measurements, a model or an assumed
    profile; the curve between measurement points is the fit's, not the data.
    Mapping onto a flux coordinate uses an equilibrium, whose errors move the
    points radially.

    See Also
    --------
    thomson_scattering_profile_fit : the measurements behind a fitted profile.
    electron_temperature_field : the same profile mapped onto the poloidal plane.
    """
    return render_profile_1d(model, ax=ax, show=show, **style)

@_profile_renderer(
    domain="core_profiles", quantity="gradient",
    subject="electron_temperature",
    description=(
        "Normalized logarithmic gradient of the core electron temperature, -L d ln f/dx, with its "
        "abscissa, gradient coordinate and reference length stated (a/L by default)."
    ),
    ids=("core_profiles", "equilibrium"),
    required_paths=(
        "core_profiles.profiles_1d.{i}.electrons.temperature",
        *_GRADIENT_EQUILIBRIUM_PATHS,
    ),
    optional_paths=_GRADIENT_GRID_PATHS,
)
def electron_temperature_profile_gradient(
    model: Profile1D, *, ax: Axes | None = None, show: bool = False, **style: Any
) -> tuple[Figure, Axes]:
    """Core electron temperature gradient; the model carries the values, the label and the record."""
    return render_profile_1d(model, ax=ax, show=show, **style)

@_field_renderer(
    domain="core_profiles", quantity="",
    subject="electron_temperature",
    description="Electron temperature mapped onto the poloidal plane.",
    ids=("core_profiles", "equilibrium", "wall"),
    required_paths=(
        "core_profiles.profiles_1d.{i}.electrons.temperature",
        "equilibrium.time_slice.{i}.profiles_2d.{j}.psi",
    ),
    optional_paths=("core_profiles.profiles_1d.{i}.grid.rho_tor_norm",),
)
def electron_temperature_field(
    model: Field2D, *, ax: Axes | None = None, show: bool = False, **style: Any
) -> tuple[Figure, Axes]:
    """Electron temperature mapped onto the poloidal plane.

    Interpretation
    --------------
    The electron temperature profile drawn on the poloidal (R, Z) plane through
    the equilibrium flux surfaces: each grid cell takes the profile's value at
    its own flux surface.  It shows where the hot core sits relative to the
    vessel and the diagnostics' lines of sight.

    Options
    -------
    ``time_slice=`` names the equilibrium slice; the profile mapped onto it is
    the core_profiles entry stored at that slice's time.

    Limitations
    -----------
    The map holds no information beyond the 1-D profile and the equilibrium: it
    assumes the quantity is constant on each flux surface, so poloidal
    asymmetries are absent by construction.  Cells are filled wherever the
    normalized flux is below 1 and left blank elsewhere, so a private-flux
    region below an X-point, or flux that recurs near a coil, is filled
    although it is not inside the plasma.

    See Also
    --------
    electron_temperature_profile : the 1-D profile that is mapped.
    """
    return render_field_2d(model, ax=ax, show=show, **style)

@_profile_renderer(
    domain="core_profiles", quantity="",
    subject="ion_temperature",
    description="Core ion temperature profile.",
    ids=("core_profiles",),
    required_paths=("core_profiles.profiles_1d.{i}.ion.{j}.temperature",),
    optional_paths=("core_profiles.profiles_1d.{i}.grid.rho_tor_norm",),
)
def ion_temperature_profile(
    model: Profile1D, *, ax: Axes | None = None, show: bool = False, **style: Any
) -> tuple[Figure, Axes]:
    """Core ion temperature profile."""
    return render_profile_1d(model, ax=ax, show=show, **style)

@_profile_renderer(
    domain="core_profiles", quantity="gradient",
    subject="ion_temperature",
    description=(
        "Normalized logarithmic gradient of the core ion temperature, -L d ln f/dx, with its "
        "abscissa, gradient coordinate and reference length stated (a/L by default)."
    ),
    ids=("core_profiles", "equilibrium"),
    required_paths=(
        "core_profiles.profiles_1d.{i}.ion.{j}.temperature",
        *_GRADIENT_EQUILIBRIUM_PATHS,
    ),
    optional_paths=_GRADIENT_GRID_PATHS,
)
def ion_temperature_profile_gradient(
    model: Profile1D, *, ax: Axes | None = None, show: bool = False, **style: Any
) -> tuple[Figure, Axes]:
    """Core ion temperature gradient; the model carries the values, the label and the record."""
    return render_profile_1d(model, ax=ax, show=show, **style)

@_profile_renderer(
    domain="core_profiles", quantity="",
    subject="thermal_pressure",
    description="Core total pressure profile.",
    ids=("core_profiles",),
    required_paths=("core_profiles.profiles_1d.{i}.pressure_thermal",),
    optional_paths=("core_profiles.profiles_1d.{i}.grid.rho_tor_norm",),
)
def thermal_pressure_profile(
    model: Profile1D, *, ax: Axes | None = None, show: bool = False, **style: Any
) -> tuple[Figure, Axes]:
    """Core total pressure profile."""
    return render_profile_1d(model, ax=ax, show=show, **style)

@_panel_renderer(
    domain="magnetics",
    subject="limiter_current",
    view="time",
    quantity="",
    description="Lower-corner, upper-corner and midplane limiter currents in three panels.",
    ids=("magnetics",),
    required_paths=(
        "magnetics.shunt.{i}.voltage.data",
        "magnetics.shunt.{i}.resistance",
    ),
    optional_paths=(
        "magnetics.shunt.{i}.voltage.time",
        "magnetics.shunt.{i}.name",
        "magnetics.shunt.{i}.identifier",
    ),
)
def limiter_current_time(
    model: Panels, *, ax: Any = None, show: bool = False, **style: Any
) -> tuple[Figure, np.ndarray]:
    """Lower-corner, upper-corner and midplane limiter-current histories."""
    return render_panels(model, ax=ax, show=show, **style)

@renderer(
    domain="magnetics",
    subject="flux_loop",
    view="time",
    quantity="flux",
    model=LineSeries,
    description="Poloidal flux measured by each selected flux loop.",
    ids=("magnetics",),
    required_paths=("magnetics.flux_loop.{i}.flux.data",),
    optional_paths=(
        "magnetics.flux_loop.time",
        "magnetics.time",
        "magnetics.flux_loop.{i}.position.0.r",
        "magnetics.flux_loop.{i}.position.0.z",
    ),
)
def flux_loop_time_flux(
    model: LineSeries,
    *,
    ax: Axes | None = None,
    show: bool = False,
    **style: Any,
) -> tuple[Figure, Axes]:
    """Poloidal flux measured by each selected flux loop.

    Interpretation
    --------------
    The poloidal flux linked by each flux loop against time.  Flux loops sample
    psi at fixed points outside the plasma: their common rise follows the
    ohmic-coil and plasma flux, and the differences between loops carry the
    plasma's position and shape.  They are primary constraints of a magnetic
    equilibrium reconstruction, and the loop voltage is their time derivative.

    Options
    -------
    ``selection=`` / ``channels=`` choose the sensors and ``layout=`` whether
    they share one axes or are split into panels or groups.  ``validity=``
    decides what happens to channels the data flag as invalid: drawn but
    demoted (the default, so a reader sees them), removed, or treated as valid.
    ``synthetic=`` overlays, as markers at each equilibrium slice, the value
    the reconstruction predicts for this signal, so measurement and fit can be
    compared where the fit exists.

    Convention
    ----------
    Flux is in full weber, not weber per radian.

    Limitations
    -----------
    Each trace is the total flux at the loop -- coils, vessel currents and
    plasma together -- so the plasma's own contribution needs the vacuum
    response subtracted.  Integrated signals can drift, and a flagged channel
    is still drawn unless ``validity=`` says otherwise.

    See Also
    --------
    flux_loop_spatial_flux : the same loops against position at one time.
    magnetics_overview_plasma_residual : the signal left after the vacuum response.
    """
    return render_line_series(model, ax=ax, show=show, **style)

@renderer(
    domain="magnetics",
    subject="flux_loop",
    view="time",
    quantity="voltage",
    model=LineSeries,
    description="Loop voltage measured by each selected flux loop.",
    ids=("magnetics",),
    required_paths=("magnetics.flux_loop.{i}.voltage.data",),
    optional_paths=(
        "magnetics.flux_loop.time",
        "magnetics.time",
    ),
)
def flux_loop_time_voltage(
    model: LineSeries,
    *,
    ax: Axes | None = None,
    show: bool = False,
    **style: Any,
) -> tuple[Figure, Axes]:
    """Loop voltage measured by each selected flux loop.

    Interpretation
    --------------
    The voltage induced in each flux loop, the rate of change of the poloidal
    flux it links.  It shows the inductive drive applied to the plasma -- the
    breakdown voltage, the ramp-up and flat-top loop voltage -- and its spatial
    variation between loops.

    Options
    -------
    ``selection=`` / ``channels=`` choose the sensors and ``layout=`` whether
    they share one axes or are split into panels or groups.  ``validity=``
    decides what happens to channels the data flag as invalid: drawn but
    demoted (the default, so a reader sees them), removed, or treated as valid.

    Limitations
    -----------
    The voltage at a loop is not the voltage at the plasma surface or on axis,
    and it contains the inductive change of the plasma's own flux; the
    resistive part needs the inductive correction.

    See Also
    --------
    flux_loop_time_flux : the integrated flux of the same loops.
    summary_time_voltage_consumption : resistive and inductive flux consumption.
    """
    return render_line_series(model, ax=ax, show=show, **style)

@renderer(
    domain="magnetics",
    subject="flux_loop",
    view="spatial",
    quantity="flux",
    model=Profile1D,
    description="Flux-loop flux against sensor position at one time: height (inboard and outboard panels) or poloidal angle about the layout centre.",
    ids=("magnetics",),
    required_paths=("magnetics.flux_loop.{i}.flux.data",),
    optional_paths=_SENSOR_POSITIONS["flux_loop"] + ("magnetics.flux_loop.{i}.flux.time", "magnetics.time"),
)
def flux_loop_spatial_flux(model: Profile1D, *, ax: Axes | None = None, show: bool = False, **style: Any) -> tuple[Figure, Axes]:
    """Flux-loop flux against sensor position at one time (issue #486).

    Interpretation
    --------------
    The flux of every loop at one instant, against where the loop sits.  It
    shows the spatial pattern behind the time traces: an up-down asymmetry can
    reflect a vertical plasma displacement or asymmetric coil currents, an
    inboard-outboard difference the radial position and current.

    Options
    -------
    ``time=`` picks the stored sample nearest the requested instant; nothing is
    interpolated.  ``coordinate=`` draws the sensors either against height,
    with inboard and outboard sensors in separate panels, or against their
    poloidal angle about the centre of the sensor layout (``centre=`` moves
    it). ``validity=`` treats flagged channels as in the time view.

    Limitations
    -----------
    The values include the vacuum field.  Sensors are sparse: whatever is drawn
    between them is not measured.

    See Also
    --------
    flux_loop_time_flux : the same loops against time.
    """
    return render_profile_1d(model, ax=ax, show=show, **style)

@renderer(
    domain="magnetics",
    subject="b_field_probe",
    view="time",
    quantity="field",
    model=LineSeries,
    description="Poloidal field measured by each selected B-field probe.",
    ids=("magnetics",),
    required_paths=("magnetics.b_field_pol_probe.{i}.field.data",),
    optional_paths=(
        "magnetics.b_field_pol_probe.time",
        "magnetics.time",
        "magnetics.b_field_pol_probe.{i}.position.r",
        "magnetics.b_field_pol_probe.{i}.position.z",
    ),
)
def b_field_probe_time_field(
    model: LineSeries,
    *,
    ax: Axes | None = None,
    show: bool = False,
    **style: Any,
) -> tuple[Figure, Axes]:
    """Poloidal field measured by each selected B-field probe.

    Interpretation
    --------------
    The poloidal field each magnetic probe measures along its own orientation,
    against time.  Probes around the vessel sample the field at the boundary of
    the plasma region, which depends on the plasma current, its position and
    the current distribution; they are, with the flux loops, the main
    constraints of a magnetic reconstruction.

    Options
    -------
    ``selection=`` / ``channels=`` choose the sensors and ``layout=`` whether
    they share one axes or are split into panels or groups.  ``validity=``
    decides what happens to channels the data flag as invalid: drawn but
    demoted (the default, so a reader sees them), removed, or treated as valid.
    ``synthetic=`` overlays, as markers at each equilibrium slice, the value
    the reconstruction predicts for this signal, so measurement and fit can be
    compared where the fit exists.

    Limitations
    -----------
    Each probe measures one component, along its axis, of the total field --
    coils, vessel currents and plasma together.  Probe signals are integrated
    from induced voltages and can drift.

    See Also
    --------
    b_field_probe_spatial_field : the same probes against position at one time.
    mirnov_spectrogram : the fluctuating part of the probe signals.
    """
    return render_line_series(model, ax=ax, show=show, **style)

@renderer(
    domain="magnetics",
    subject="b_field_probe",
    view="spatial",
    quantity="field",
    model=Profile1D,
    description="B-probe field against sensor position at one time: height (inboard and outboard panels) or poloidal angle about the layout centre.",
    ids=("magnetics",),
    required_paths=("magnetics.b_field_pol_probe.{i}.field.data",),
    optional_paths=_SENSOR_POSITIONS["b_field_probe"] + ("magnetics.b_field_pol_probe.{i}.field.time", "magnetics.time"),
)
def b_field_probe_spatial_field(model: Profile1D, *, ax: Axes | None = None, show: bool = False, **style: Any) -> tuple[Figure, Axes]:
    """B-probe poloidal field against sensor position at one time (issue #486).

    Interpretation
    --------------
    The field of every magnetic probe at one instant, against where the probe
    sits.  It shows how the poloidal field is distributed around the plasma
    region at that time, which follows the plasma's position, shape and current
    distribution as well as the coil field.

    Options
    -------
    ``time=`` picks the stored sample nearest the requested instant; nothing is
    interpolated.  ``coordinate=`` draws the sensors either against height,
    with inboard and outboard sensors in separate panels, or against their
    poloidal angle about the centre of the sensor layout (``centre=`` moves
    it). ``validity=`` treats flagged channels as in the time view. ``angle=``
    chooses the geometric poloidal angle or the one stored with each probe.

    Limitations
    -----------
    Each probe measures one field component along its own axis, so neighbouring
    probes mounted differently are not directly comparable.  The values include
    the vacuum field, and nothing between sensors is measured.

    See Also
    --------
    b_field_probe_time_field : the same probes against time.
    """
    return render_profile_1d(model, ax=ax, show=show, **style)

@renderer(
    domain="magnetics",
    subject="mirnov",
    view="time",
    quantity="voltage",
    model=LineSeries,
    description="Raw or preprocessed Mirnov coil voltage traces.",
    ids=("magnetics",),
    required_paths=("magnetics.b_field_pol_probe.{i}.voltage.data",),
    optional_paths=(
        "magnetics.b_field_pol_probe.{i}.voltage.time",
        "magnetics.time",
    ),
)
def mirnov_time_voltage(
    model: LineSeries,
    *,
    ax: Axes | None = None,
    show: bool = False,
    **style: Any,
) -> tuple[Figure, Axes]:
    """Raw or preprocessed Mirnov coil voltage traces.

    Interpretation
    --------------
    The voltage induced in each Mirnov coil, proportional to the rate of change
    of the field through it.  The traces show when MHD activity, sawtooth-like
    crashes or other fast magnetic events happen and how strongly each coil
    responds, before any spectral analysis.

    Options
    -------
    ``selection=`` / ``channels=`` choose the coils and ``layout=`` how they
    are arranged.

    Limitations
    -----------
    A coil voltage weights each frequency by that frequency, so a fast mode
    looks stronger than a slow one of equal field amplitude.  Slow equilibrium
    changes and pickup also appear, and comparing amplitudes between coils
    requires their effective areas.  The traces are as raw or as preprocessed
    as the stored signal.

    See Also
    --------
    mirnov_spectrogram : the frequency content of one coil against time.
    mirnov_spatial_phase : toroidal phase across the coils, for mode numbers.
    """
    return render_line_series(model, ax=ax, show=show, **style)

@renderer(
    domain="magnetics",
    subject="mirnov",
    view="spatial",
    quantity="phase",
    model=Profile1D,
    description="Toroidal phase of each fluctuation band around the torus at one time, with the fitted n mode lines.",
    ids=("magnetics",),
    required_paths=("magnetics.b_field_pol_probe.{i}.voltage.data",),
    optional_paths=(
        "magnetics.b_field_pol_probe.{i}.position.phi",
        "magnetics.b_field_pol_probe.{i}.voltage.time",
        "magnetics.time",
    ),
)
def mirnov_spatial_phase(model: Profile1D, *, ax: Axes | None = None, show: bool = False, **style: Any) -> tuple[Figure, Axes]:
    """Toroidal phase per fluctuation band at one time (issue #485)."""
    return render_profile_1d(model, ax=ax, show=show, **style)

@renderer(
    domain="magnetics",
    subject="mirnov",
    view="spectrum",
    quantity="",
    model=PowerSpectrum,
    description="Power spectral density of one Mirnov coil signal.",
    ids=("magnetics",),
    required_paths=("magnetics.b_field_pol_probe.{i}.voltage.data",),
    optional_paths=("magnetics.b_field_pol_probe.{i}.voltage.time", "magnetics.time"),
)
def mirnov_spectrum(
    model: PowerSpectrum, *, ax: Axes | None = None, show: bool = False, **style: Any
) -> tuple[Figure, Axes]:
    """Power spectral density of one Mirnov coil signal."""
    return render_power_spectrum(model, ax=ax, show=show, **style)

@renderer(
    domain="magnetics",
    subject="mirnov",
    view="spectrogram",
    quantity="",
    model=Spectrogram,
    description="Time-frequency map of one Mirnov coil signal.",
    ids=("magnetics",),
    required_paths=("magnetics.b_field_pol_probe.{i}.voltage.data",),
    optional_paths=("magnetics.b_field_pol_probe.{i}.voltage.time", "magnetics.time"),
)
def mirnov_spectrogram(
    model: Spectrogram, *, ax: Axes | None = None, show: bool = False, **style: Any
) -> tuple[Figure, Axes]:
    """Time-frequency map of one Mirnov coil signal.

    Interpretation
    --------------
    The spectral magnitude of one Mirnov coil's voltage in sliding windows.  A
    coherent MHD mode appears as a narrow band, and its frequency history shows
    onset, frequency chirping as rotation changes, and locking when the band
    drops to zero frequency and vanishes; broadband activity and crashes appear
    as vertical stripes.

    Options
    -------
    ``method=`` chooses the transform: a short-time Fourier transform, the
    Hann-window FFT the VEST Mirnov analyses were written against, or a
    continuous wavelet, whose resolution varies with frequency and which needs
    a named ``frequency_range=``.  Window length trades time against frequency
    resolution.  ``frequency_range=`` names the analysis band.  ``track=``
    overlays the ridge of the dominant frequency in a band, with ``max_jump=``
    limiting how far it may move between windows.

    Limitations
    -----------
    One coil gives no mode numbers: identifying m and n needs the phase across
    an array.  The coil voltage is a time derivative, so higher frequencies are
    emphasized.  The observed frequency is in the laboratory frame and includes
    the plasma rotation's Doppler shift, so it is not the mode frequency in the
    plasma frame.  A narrow band can also be pickup or aliasing.

    See Also
    --------
    mirnov_time_voltage : the coil signals themselves.
    mirnov_spatial_phase : toroidal phase per band, for the mode number n.
    """
    return render_spectrogram(model, ax=ax, show=show, **style)

@renderer(
    domain="magnetics",
    subject="impa",
    view="time",
    quantity="field",
    model=LineSeries,
    description="Calibrated field from the IMPA Hall-probe array.",
    ids=("magnetics",),
    required_paths=("magnetics.b_field_tor_probe.{i}.field.data",),
    optional_paths=(
        "magnetics.b_field_tor_probe.{i}.identifier",
        "magnetics.b_field_tor_probe.{i}.position.r",
        "magnetics.b_field_pol_probe.{i}.field.data",
    ),
)
def impa_time_field(
    model: LineSeries,
    *,
    ax: Axes | None = None,
    show: bool = False,
    **style: Any,
) -> tuple[Figure, Axes]:
    """Calibrated field from the IMPA Hall-probe array."""
    return render_line_series(model, ax=ax, show=show, **style)

@renderer(
    domain="magnetics",
    subject="impa",
    view="time",
    quantity="voltage",
    model=LineSeries,
    description="Raw IMPA Hall-probe voltages, one trace per channel.",
    ids=("magnetics",),
    required_paths=("magnetics.b_field_tor_probe.{i}.voltage.data",),
    optional_paths=(
        "magnetics.b_field_tor_probe.{i}.identifier",
        "magnetics.b_field_pol_probe.{i}.voltage.data",
    ),
)
def impa_time_voltage(
    model: LineSeries,
    *,
    ax: Axes | None = None,
    show: bool = False,
    **style: Any,
) -> tuple[Figure, Axes]:
    """Raw IMPA Hall-probe voltages."""
    return render_line_series(model, ax=ax, show=show, **style)

@renderer(
    domain="magnetics",
    subject="impa",
    view="profile",
    quantity="field",
    model=Profile1D,
    description="IMPA measured field against probe radius with the 1/R toroidal-field model.",
    ids=("magnetics", "tf"),
    required_paths=("magnetics.b_field_tor_probe.{i}.voltage.data",),
    optional_paths=(
        "magnetics.b_field_tor_probe.{i}.identifier",
        "magnetics.b_field_tor_probe.{i}.position.r",
        "magnetics.b_field_pol_probe.{i}.voltage.data",
        "tf.coil.{i}.current.data",
    ),
)
def impa_profile_field(
    model: Profile1D,
    *,
    ax: Axes | None = None,
    show: bool = False,
    **style: Any,
) -> tuple[Figure, Axes]:
    """IMPA radial profile against the 1/R toroidal-field model."""
    return render_profile_1d(model, ax=ax, show=show, **style)

@_panel_renderer(
    domain="magnetics", view="overview", quantity="",
    subject="impa",
    description="IMPA validation overview: raw voltages, compensated Bz and the 1/R position check.",
    ids=("magnetics", "tf"),
    required_paths=("magnetics.b_field_tor_probe.{i}.voltage.data",),
)
def impa_overview(
    model: Panels, *, ax: Any = None, show: bool = False, **style: Any
) -> tuple[Figure, np.ndarray]:
    """IMPA validation overview panels."""
    return render_panels(model, ax=ax, show=show, **style)

@renderer(
    domain="soft_x_rays",
    subject="soft_x_rays",
    view="time",
    quantity="power",
    model=LineSeries,
    description="Soft X-ray channel signal history.",
    ids=("soft_x_rays",),
    required_paths=("soft_x_rays.channel.{i}.brightness.data",),
    optional_paths=(
        "soft_x_rays.channel.{i}.brightness.time",
        "soft_x_rays.channel.{i}.power.data",
        "soft_x_rays.channel.{i}.power.time",
        "soft_x_rays.time",
        "soft_x_rays.channel.{i}.name",
    ),
)
def soft_x_rays_time_power(
    model: LineSeries,
    *,
    ax: Axes | None = None,
    show: bool = False,
    **style: Any,
) -> tuple[Figure, Axes]:
    """Soft X-ray channel signal history."""
    return render_line_series(model, ax=ax, show=show, **style)

@_geometry_renderer(
    domain="soft_x_rays", quantity="lines_of_sight",
    subject="soft_x_rays",
    description="Soft X-ray detector lines of sight over the poloidal cross-section.",
    ids=("soft_x_rays", "wall"),
    required_paths=("soft_x_rays.channel.{i}.line_of_sight.first_point.r",
                    "soft_x_rays.channel.{i}.line_of_sight.first_point.z",
                    "soft_x_rays.channel.{i}.line_of_sight.second_point.r",
                    "soft_x_rays.channel.{i}.line_of_sight.second_point.z"),
    optional_paths=("wall.description_2d.{i}.limiter.unit.{j}.outline.r",),
)
def soft_x_rays_geometry_lines_of_sight(
    model: GeometryLayers, *, ax: Axes | None = None, show: bool = False, **style: Any
) -> tuple[Figure, Axes]:
    """Soft X-ray detector lines of sight over the poloidal cross-section."""
    return render_geometry_layers(model, ax=ax, show=show, **style)

@renderer(
    domain="soft_x_rays",
    subject="soft_x_rays",
    view="spectrum",
    model=PowerSpectrum,
    description="Power spectral density of one soft X-ray channel.",
    ids=("soft_x_rays",),
    required_paths=("soft_x_rays.channel.{i}.brightness.data",),
    optional_paths=(
        "soft_x_rays.channel.{i}.brightness.time",
        "soft_x_rays.channel.{i}.power.data",
        "soft_x_rays.channel.{i}.power.time",
        "soft_x_rays.time",
    ),
)
def soft_x_rays_spectrum(
    model: PowerSpectrum, *, ax: Axes | None = None, show: bool = False, **style: Any
) -> tuple[Figure, Axes]:
    """Power spectral density of one soft X-ray channel."""
    return render_power_spectrum(model, ax=ax, show=show, **style)

@renderer(
    domain="soft_x_rays",
    subject="soft_x_rays",
    view="spectrogram",
    model=Spectrogram,
    description="Time-frequency map of one soft X-ray channel.",
    ids=("soft_x_rays",),
    required_paths=("soft_x_rays.channel.{i}.brightness.data",),
    optional_paths=(
        "soft_x_rays.channel.{i}.brightness.time",
        "soft_x_rays.channel.{i}.power.data",
        "soft_x_rays.channel.{i}.power.time",
        "soft_x_rays.time",
    ),
)
def soft_x_rays_spectrogram(
    model: Spectrogram, *, ax: Axes | None = None, show: bool = False, **style: Any
) -> tuple[Figure, Axes]:
    """Time-frequency map of one soft X-ray channel."""
    return render_spectrogram(model, ax=ax, show=show, **style)

@_panel_renderer(
    domain="soft_x_rays",
    subject="soft_x_rays",
    view="overview",
    quantity="channels",
    description="Soft X-ray overview: lines of sight, signals and channel pattern.",
    ids=("soft_x_rays", "wall"),
    required_paths=("soft_x_rays.channel.{i}.brightness.data",),
    optional_paths=("soft_x_rays.channel.{i}.power.data",),
)
def soft_x_rays_overview(
    model: Panels, *, ax: Any = None, show: bool = False, **style: Any
) -> tuple[Figure, np.ndarray]:
    """Soft X-ray overview panels."""
    return render_panels(model, ax=ax, show=show, **style)

@renderer(
    domain="interferometer",
    subject="interferometer",
    view="time",
    quantity="n_e_line",
    model=LineSeries,
    description="Interferometer line-integrated electron density history.",
    ids=("interferometer",),
    required_paths=("interferometer.channel.{i}.n_e_line.data",),
    optional_paths=(
        "interferometer.channel.{i}.n_e_line.time",
        "interferometer.time",
        "interferometer.channel.{i}.name",
    ),
)
def interferometer_time_n_e_line(
    model: LineSeries,
    *,
    ax: Axes | None = None,
    show: bool = False,
    **style: Any,
) -> tuple[Figure, Axes]:
    """Interferometer line-integrated electron density history."""
    return render_line_series(model, ax=ax, show=show, **style)

@renderer(
    domain="interferometer",
    subject="interferometer",
    view="spectrum",
    model=PowerSpectrum,
    description="Power spectral density of one interferometer channel's line density.",
    ids=("interferometer",),
    required_paths=("interferometer.channel.{i}.n_e_line.data",),
    optional_paths=("interferometer.channel.{i}.n_e_line.time", "interferometer.time"),
)
def interferometer_spectrum(
    model: PowerSpectrum, *, ax: Axes | None = None, show: bool = False, **style: Any
) -> tuple[Figure, Axes]:
    """Power spectral density of one interferometer channel's line density."""
    return render_power_spectrum(model, ax=ax, show=show, **style)