def compute_time_match_atol(time_array: ndarray, base_atol: float = _DEFAULT_TIME_MATCH_ATOL) -> float:
    """An absolute time-matching tolerance adapted to the native time spacing.

    ``max(base_atol, 0.25 * min(diff(unique_finite_times)))``, which absorbs
    floating-point drift in a time coordinate without ever matching an
    adjacent physical slice.

    Parameters
    ----------
    time_array : np.ndarray
        The time coordinate to be matched against [s].
    base_atol : float, optional
        Floor on the tolerance [s].

    Returns
    -------
    float
        The tolerance; ``base_atol`` when fewer than two distinct finite times
        exist [s].

    Raises
    ------
    ValueError
        ``base_atol`` non-finite or negative.

    Defaults
    --------
    ``base_atol = 1e-6`` s and the factor ``0.25`` are numerical conveniences:
    a quarter of the smallest spacing can never reach the neighbouring slice.

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

    if not np.isfinite(base_atol) or base_atol < 0.0:
        raise ValueError("base_atol must be finite and non-negative")

    arr = np.asarray(time_array, dtype=float).reshape(-1)
    arr = arr[np.isfinite(arr)]
    if arr.size < 2:
        return float(base_atol)
    positive = np.diff(np.unique(np.sort(arr)))
    positive = positive[positive > 0.0]
    return float(max(base_atol, 0.25 * float(np.min(positive)))) if positive.size else float(base_atol)

def find_time_match_index(time_array: ndarray, target_time: float) -> Optional[int]:
    """Index of the time closest to ``target_time``, within the adaptive tolerance.

    Parameters
    ----------
    time_array : np.ndarray
        The time coordinate [s].
    target_time : float
        The time to match [s].

    Returns
    -------
    int or None
        Index of the closest time within :func:`compute_time_match_atol`;
        ``None`` for an empty array, a non-finite target, or no candidate within
        tolerance [-].

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

    arr = np.asarray(time_array, dtype=float).reshape(-1)
    if arr.size == 0 or not np.isfinite(target_time):
        return None
    close = np.where(np.isclose(arr, float(target_time), rtol=0.0, atol=compute_time_match_atol(arr)))[0]
    if close.size == 0:
        return None
    return int(close[np.argmin(np.abs(arr[close] - float(target_time)))])

def integrate_emissivity_profile(
    emissivity_profile: ndarray,
    volume_profile: Optional[ndarray],
    total_volume: float,
) -> float:
    """Integrate an emissivity profile to a total radiated power.

    Parameters
    ----------
    emissivity_profile : np.ndarray
        Local emissivity on the radial grid [W/m^3].
    volume_profile : np.ndarray or None
        Cumulative enclosed volume on the same grid, or ``None`` [m^3].
    total_volume : float
        Total plasma volume, for the fallback [m^3].

    Returns
    -------
    float
        ``P = int epsilon dV``, or the fallback, or ``0`` [W].

    Processing steps
    ----------------
    1. If ``volume_profile`` is given, matches the emissivity's shape and has at
       least two finite points spanning a non-zero volume: trapezoidal
       integration of ``epsilon`` against ``V``, in volume order.
    2. Else, if ``total_volume`` is finite and positive:
       ``nanmean(epsilon) * total_volume``.
    3. Else ``0``.

    Convention
    ----------
    ``volume_profile`` is the *cumulative enclosed* volume ``V(rho)``, so
    ``dV`` is its difference; it is not a shell volume.

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

    Limitations
    -----------
    The two fallbacks are silent: a volume profile of the wrong length drops to
    the mean-times-volume estimate, and a missing volume to zero, with no
    warning from this function.
    """

    emissivity = np.asarray(emissivity_profile, dtype=float)
    finite_emissivity = np.isfinite(emissivity)
    if not np.any(finite_emissivity):
        return 0.0
    if volume_profile is not None:
        volume = np.asarray(volume_profile, dtype=float)
        if volume.shape == emissivity.shape:
            finite = finite_emissivity & np.isfinite(volume)
            if np.count_nonzero(finite) >= 2:
                volume_finite, emissivity_finite = volume[finite], emissivity[finite]
                order = np.argsort(volume_finite)
                volume_finite, emissivity_finite = volume_finite[order], emissivity_finite[order]
                if np.ptp(volume_finite) > 0.0:
                    return float(trapz_compat(emissivity_finite, x=volume_finite))
    if np.isfinite(total_volume) and total_volume > 0.0:
        return float(np.nanmean(emissivity[finite_emissivity]) * total_volume)
    return 0.0

def normalize_atomic_symbol(label: Any) -> Optional[str]:
    """Normalize an element or ion label to a supported atomic symbol.

    Full English names and charge-decorated labels are accepted --
    ``carbon6+`` gives ``C``, ``neon`` gives ``Ne``.

    Parameters
    ----------
    label : str, bytes or None
        The label as found in an ODS ``ion.label`` or a species list [-].

    Returns
    -------
    str or None
        The symbol, or ``None`` for an unrecognized label so the caller decides
        whether absence is fatal [-].

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

    Limitations
    -----------
    Only the elements in the module's table are recognized (H through W, the
    common tokamak species); isotopes D and T map to their own symbols.
    """

    if label is None:
        return None
    text = label.decode("utf-8", errors="ignore") if isinstance(label, bytes) else str(label)
    match = re.match(r"([A-Za-z]+)", text.strip())
    if not match:
        return None
    token = match.group(1)
    named = _ELEMENT_NAMES.get(token.lower())
    if named is not None:
        return named
    exact = token[0].upper() + token[1:].lower()
    if exact in _ATOMIC_NUMBERS:
        return exact
    return None