def flat_profile_from_resistive(zeff_resistive: float, state: Any, *, assumption: str) -> np.ndarray:
    """A flat Z_eff profile from a resistive scalar -- only under the stated flat assumption.

    Parameters
    ----------
    zeff_resistive : float
        A resistive scalar (Lane Z), at least 1 [-].
    state : FluxSurfaceState
        The surfaces to put it on [any].
    assumption : str
        Must be ``"flat"``: the caller states the modelling assumption [-].

    Returns
    -------
    np.ndarray
        ``Z_eff(psi_N) = zeff_resistive`` on every surface [-].

    Raises
    ------
    ValueError
        Any assumption other than ``"flat"``, or a scalar below 1.

    Convention
    ----------
    #1566 Sec. 6: a modelling assumption, never a measurement or an
    inference of the profile; nothing here writes it to ``core_profiles``.

    Applicability
    -------------
    Machine-independent.

    Provenance
    ----------
    .. [issue] #1566 Sec. 6.
    """
    if assumption != "flat":
        raise ValueError("a profile from a resistive scalar needs assumption='flat', stated explicitly")
    value = float(zeff_resistive)
    if not value >= 1.0:
        raise ValueError(f"zeff_resistive must be at least 1, got {zeff_resistive!r}")
    return np.full(np.shape(state.psi_norm), value)

def profile_conductivity_model(
    zeff_profile: Any,
    *,
    base_model: str = "redl",
    ln_lambda: Union[float, str] = "sauter",
) -> Callable:
    """A conductivity-model callable that evaluates Lane Z's model at a radially varying Z_eff.

    Parameters
    ----------
    zeff_profile : array-like
        Z_eff on the state's ``psi_norm`` surfaces, at least 1 [-].
    base_model : str, optional
        One of :data:`vaft.process.resistive_zeff.CONDUCTIVITY_MODELS` [-].
    ln_lambda : float or str, optional
        Coulomb logarithm as :func:`~vaft.process.resistive_zeff.parallel_conductivity`
        takes it [-].

    Returns
    -------
    callable
        ``model(state, z, lnl) -> sigma(psi_N)`` for
        :func:`~vaft.process.resistive_zeff.model_resistance`; the scalar
        ``z`` it is handed is ignored [any].

    Raises
    ------
    ValueError
        At call time: a profile that does not match the state's surfaces, or
        that is non-finite or below 1.

    Convention
    ----------
    Surface ``i`` gets ``parallel_conductivity(state, Z_eff[i])[i]``: the
    unmodified scalar model, so a flat profile reproduces it exactly and no
    kernel is copied.  ``model_resistance`` records ``z_eff = 1`` for this
    route; the profile is the record of what was used.  The ``ln_lambda`` it
    is built with must be the one ``model_resistance`` is called with; a
    mismatch is refused, not silently overridden.

    Applicability
    -------------
    Machine-independent.

    Provenance
    ----------
    .. [issue] #1566 Sec. 3 (the Redl/Sauter projection through Lane Z's
               conductivity models), #1214 (the models), #1486 (Lane Z).
    """
    from vaft.process.resistive_zeff import _ln_lambda_profile, parallel_conductivity

    profile = np.asarray(zeff_profile, dtype=float)

    def model(state, _z, lnl):
        z = _profile(state, profile)
        own, _ = _ln_lambda_profile(state, ln_lambda)
        if not np.allclose(np.asarray(lnl, dtype=float), own, rtol=1e-12, atol=0.0):
            raise ValueError(
                "model_resistance was given a different ln_lambda from the one this profile model was "
                f"built with ({ln_lambda!r}); build it with the same ln_lambda"
            )
        sigma = np.empty(z.shape)
        for value in np.unique(z):
            at = z == value
            sigma[at] = parallel_conductivity(state, float(value), model=base_model, ln_lambda=ln_lambda)[at]
        return sigma

    model.zeff_profile = profile
    model.base_model = base_model
    model.__name__ = f"profile_{base_model}"
    return model

def spitzer_resistive_equivalent_zeff(state: Any, zeff_profile: Any, *, ln_lambda: Union[float, str] = "sauter") -> float:
    """Analytic resistive equivalent of a Z_eff profile under Spitzer (NRL) resistivity.

    Parameters
    ----------
    state : FluxSurfaceState
        One slice (``bootstrap = none``) [any].
    zeff_profile : array-like
        Z_eff on the state's ``psi_norm`` surfaces [-].
    ln_lambda : float or str, optional
        Coulomb logarithm [-].

    Returns
    -------
    float
        ``int Z w dV / int w dV`` with ``w = eta(Z=1) <J.B>^2/<B^2>``, the
        Ohmic-dissipation weight [-].

    Raises
    ------
    ValueError
        A profile off the state's surfaces, a state carrying a bootstrap
        current (the weight is then not linear in Z), or a zero weight.

    Convention
    ----------
    NRL Spitzer resistivity is linear in Z_eff, so ``P_Ohm`` is a weighted
    integral of Z_eff and the equivalent scalar is that weighted mean -- the
    weight is the dissipation ``eta_1 j^2``, not the volume or the density.
    Integrated with the same trapezoid rule on the enclosed volume as
    :func:`~vaft.process.resistive_zeff.model_resistance`.

    Applicability
    -------------
    Machine-independent.

    Provenance
    ----------
    .. [issue] #1566 Sec. 2 (the Spitzer reference projection).
    """
    from scipy.integrate import trapezoid

    from vaft.process.resistive_zeff import parallel_conductivity

    if getattr(state, "j_bootstrap_dot_b", None) is not None:
        raise ValueError("the analytic Spitzer projection needs a state without bootstrap current")
    z = _profile(state, zeff_profile)
    sigma_1 = parallel_conductivity(state, 1.0, model="spitzer_nrl", ln_lambda=ln_lambda)
    jb = np.asarray(state.j_dot_b, dtype=float)
    weight = jb**2 / np.asarray(state.b2_average, dtype=float) / sigma_1
    volume = np.asarray(state.volume, dtype=float)
    denominator = trapezoid(weight, volume)
    if not denominator > 0.0:
        raise ValueError("the dissipation weight integrates to zero")
    return float(trapezoid(weight * z, volume) / denominator)

def zeff_profile_for_state(state: Any, elemental_weights: Mapping[str, float], **options: Any):
    """The atomic-data Z_eff profile on a flux-surface state's own surfaces.

    Parameters
    ----------
    state : FluxSurfaceState
        One slice; its ``T_e``, ``n_e`` and enclosed volume are used [any].
    elemental_weights : mapping
        Relative elemental densities, e.g. ``{"C": 1, "O": 1}``; further
        keyword arguments go to
        :func:`vaft.process.impurity.resolve_radial_composition`
        (``normalization``, ``target_zeff``, ``ionization``, ``plasma_age_s``,
        ``projection``/``resistive_target``, ``tables``...) [-].

    Returns
    -------
    RadialImpurityComposition
        On ``psi_norm``, with ``dV`` from the state's volume [any].

    Raises
    ------
    ValueError
        As ``resolve_radial_composition``.

    Convention
    ----------
    The profile is built from the very T_e and n_e the conductivity model
    uses, so composition and resistance share one state.

    Applicability
    -------------
    Machine-independent.

    Provenance
    ----------
    .. [issue] #1566 Sec. 5 (connect #1565 profiles to #1214).
    """
    from vaft.process.impurity import resolve_radial_composition

    volume = np.asarray(state.volume, dtype=float)
    edges = np.concatenate(([volume[0]], 0.5 * (volume[1:] + volume[:-1]), [volume[-1]]))
    return resolve_radial_composition(state.T_e, state.n_e, state.psi_norm, elemental_weights,
                                      volume_weights=np.diff(edges), time=float(state.time), **options)