microstructure-tpw 0.3.0__py3-none-any.whl

odas_tpw/rsi/binning.py

@@ -0,0 +1,193 @@
+"""Depth binning for dissipation and chi estimates (L5)."""
+
+from __future__ import annotations
+
+import numpy as np
+import xarray as xr
+
+# CF attributes (units/long_name/standard_name) for the variables that flow
+# through the rsi L5/L6 products.  Defect: bin_by_depth previously attached only
+# cell_methods, so epsilon/chi/K_T/Gamma/K_rho/P_mean/speed/N2/dTdz reached
+# L5_binned.nc / L6_combined.nc with no units — uncatalogued, non-CF-compliant
+# headline products.  Keyed by the variable names passed from
+# rsi/pipeline.py:bin_by_depth(...); unknown names are left metadata-free.
+_VAR_CF_ATTRS: dict[str, dict[str, str]] = {
+    "epsilon": {
+        "units": "W kg-1",
+        "long_name": "TKE dissipation rate",
+        "standard_name": (
+            "specific_turbulent_kinetic_energy_dissipation_in_sea_water"
+        ),
+    },
+    "chi": {
+        "units": "K2 s-1",
+        "long_name": "thermal variance dissipation rate",
+    },
+    "P_mean": {
+        "units": "dbar",
+        "long_name": "mean pressure within bin",
+        "standard_name": "sea_water_pressure",
+    },
+    "speed": {
+        "units": "m s-1",
+        "long_name": "profiling speed",
+    },
+    "N2": {
+        "units": "s-2",
+        "long_name": "buoyancy frequency squared",
+        "standard_name": "square_of_brunt_vaisala_frequency_in_sea_water",
+    },
+    "dTdz": {
+        "units": "K m-1",
+        "long_name": "background temperature gradient (positive down)",
+    },
+    "K_T": {
+        "units": "m2 s-1",
+        "long_name": "Osborn-Cox eddy diffusivity of heat",
+    },
+    "K_rho": {
+        "units": "m2 s-1",
+        "long_name": "Osborn diapycnal diffusivity",
+    },
+    "Gamma": {
+        "units": "1",
+        "long_name": "mixing coefficient",
+    },
+}
+
+
+def bin_by_depth(
+    pres: np.ndarray,
+    values: dict[str, np.ndarray],
+    bin_size: float = 1.0,
+    pres_range: tuple[float, float] | None = None,
+    log_mean_vars: set[str] | None = None,
+) -> xr.Dataset:
+    """Bin estimates by depth (pressure).
+
+    Parameters
+    ----------
+    pres : ndarray, shape (N,)
+        Pressure per estimate [dbar].
+    values : dict of str -> ndarray
+        Variables to bin. Each value has shape (N,) or (M, N) where M is
+        the number of probes. 2-D arrays are reduced across probes first
+        (geometric mean for log_mean_vars, arithmetic mean otherwise).
+    bin_size : float
+        Bin size [dbar]. Default: 1.0.
+    pres_range : tuple of (min, max), optional
+        Pressure range for binning. Default: data range.
+    log_mean_vars : set of str, optional
+        Variables to average using the geometric (log-space) mean. Default:
+        ``None`` → empty, i.e. EVERY variable is averaged arithmetically.
+
+        This matches the perturb pipeline, which depth-bins epsilon/chi with
+        ``np.nanmean`` (arithmetic). For lognormally distributed dissipation the
+        arithmetic mean is the unbiased estimator of the true mean — the
+        flux-relevant quantity, and what the diapycnal diffusivities (K_T, K_rho,
+        Gamma) computed from these estimates require. The geometric mean instead
+        estimates the MEDIAN and biases binned dissipation low. Pass an explicit
+        set here to opt specific variables back into geometric averaging.
+
+    Returns
+    -------
+    xr.Dataset with dimension ``depth_bin``.
+    """
+    if log_mean_vars is None:
+        log_mean_vars = set()
+
+    pres = np.asarray(pres, dtype=np.float64)
+    valid = np.isfinite(pres)
+    if not valid.any():
+        return xr.Dataset()
+
+    if pres_range is None:
+        p_min = np.floor(np.nanmin(pres) / bin_size) * bin_size
+        p_max = np.ceil(np.nanmax(pres) / bin_size) * bin_size
+    else:
+        p_min, p_max = pres_range
+
+    bin_edges = np.arange(p_min, p_max + bin_size, bin_size)
+    bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
+    n_bins = len(bin_centers)
+
+    # Assign samples to bins.  Samples with NaN pressure (np.digitize
+    # returns len(edges)) or outside [p_min, p_max] are EXCLUDED — the
+    # previous np.clip silently dumped them into the shallowest/deepest
+    # bin, contaminating the edge bins.  Bins are half-open [lo, hi)
+    # except the last, which includes its upper edge.
+    with np.errstate(invalid="ignore"):
+        bin_idx = np.digitize(pres, bin_edges) - 1  # 0-indexed
+        bin_idx = np.where(pres == bin_edges[-1], n_bins - 1, bin_idx)
+    in_range = np.isfinite(pres) & (bin_idx >= 0) & (bin_idx < n_bins)
+    bin_idx = np.where(in_range, bin_idx, 0)  # placeholder; masked below
+
+    data_vars = {}
+    for name, arr in values.items():
+        arr = np.asarray(arr, dtype=np.float64)
+
+        # Reduce 2-D arrays (probes x time) → 1-D
+        if arr.ndim == 2:
+            if name in log_mean_vars:
+                with np.errstate(divide="ignore"):
+                    arr = np.exp(np.nanmean(np.log(np.where(arr > 0, arr, np.nan)), axis=0))
+            else:
+                arr = np.nanmean(arr, axis=0)
+
+        # Vectorize per-bin reduction with bincount.  Log-mean uses
+        # log(x) accumulators with strictly-positive values; arithmetic
+        # mean uses values directly.  Both paths drop NaN (and ≤0 for
+        # log-mean) up front, then accumulate sums and counts in one
+        # linear pass.
+        if name in log_mean_vars:
+            valid = in_range & np.isfinite(arr) & (arr > 0)
+            log_vals = np.log(arr, where=valid, out=np.full_like(arr, np.nan))
+            idx_v = bin_idx[valid]
+            log_v = log_vals[valid]
+            counts_v = np.bincount(idx_v, minlength=n_bins)
+            sums_v = np.bincount(idx_v, weights=log_v, minlength=n_bins)
+            with np.errstate(invalid="ignore", divide="ignore"):
+                binned = np.where(
+                    counts_v > 0, np.exp(sums_v / np.maximum(counts_v, 1)), np.nan
+                )
+            attrs = {
+                "cell_methods": "depth_bin: geometric mean",
+                "comment": (
+                    "Geometric (log-space) mean within each depth bin. For "
+                    "lognormally distributed dissipation this estimates the "
+                    "MEDIAN, not the arithmetic mean; use the arithmetic mean "
+                    "for budget (flux) calculations."
+                ),
+            }
+        else:
+            valid = in_range & np.isfinite(arr)
+            idx_v = bin_idx[valid]
+            vals_v = arr[valid]
+            counts_v = np.bincount(idx_v, minlength=n_bins)
+            sums_v = np.bincount(idx_v, weights=vals_v, minlength=n_bins)
+            with np.errstate(invalid="ignore", divide="ignore"):
+                binned = np.where(counts_v > 0, sums_v / np.maximum(counts_v, 1), np.nan)
+            attrs = {"cell_methods": "depth_bin: mean"}
+
+        # Defect fix: merge CF units/long_name/standard_name so the binned
+        # products are cataloged.  cell_methods stays authoritative; CF attrs
+        # only fill in for known variables (unknown names stay metadata-free).
+        attrs = {**_VAR_CF_ATTRS.get(name, {}), **attrs}
+
+        data_vars[name] = (["depth_bin"], binned, attrs)
+
+    ds = xr.Dataset(
+        data_vars,
+        coords={"depth_bin": bin_centers},
+    )
+    ds.coords["depth_bin"].attrs.update(
+        {
+            "units": "dbar",
+            "long_name": "depth bin center pressure",
+            "standard_name": "sea_water_pressure",
+            "positive": "down",
+        }
+    )
+    ds.attrs["bin_size"] = bin_size
+
+    return ds

odas_tpw/rsi/channels.py

@@ -0,0 +1,376 @@
+# Mar-2026, Claude and Pat Welch, pat@mousebrains.com
+"""
+Channel conversion functions: raw counts -> physical units.
+
+Ported from the ODAS MATLAB Library convert_odas.m.
+"""
+
+import warnings
+from typing import Any
+
+import numpy as np
+
+
+def _safe_float(s: Any, default: float = 0.0) -> float:
+    """Convert *s* to float, returning *default* on failure."""
+    try:
+        return float(s)
+    except (ValueError, TypeError):
+        return default
+
+
+def _require_float(params: dict[str, Any], key: str, default: float, sensor: str) -> float:
+    """Like _safe_float, but warn loudly when a sensor-specific calibration
+    coefficient is missing from the channel config.
+
+    ODAS convert_odas.m errors outright in this situation; silently
+    substituting a generic default would produce plausible-looking but
+    wrong physical units (e.g. a missing shear ``sens`` scales epsilon by
+    the square of the sensitivity error).
+    """
+    if key not in params or params.get(key) in (None, ""):
+        warnings.warn(
+            f"{sensor}: calibration coefficient '{key}' missing from channel "
+            f"config; using default {default} — physical units are suspect",
+            stacklevel=3,
+        )
+        return default
+    return _safe_float(params[key], default)
+
+
+def _adis_14bit(data: np.ndarray) -> np.ndarray:
+    """Extract 14-bit data from ADIS16209 inclinometer words.
+
+    Matches ODAS ``adis.m``: clears status bits (15 = new-data,
+    14 = error), then applies 14-bit two's complement.  The
+    inclination X/Y channels use 14-bit signed data; the
+    temperature channel uses 12-bit unsigned, which passes through
+    the two's complement step unchanged.
+
+    Note: the strict ``< -2**14`` test (kept to match ``adis.m:48``)
+    mis-decodes error-flagged words 0xC000-0xDFFF (bit14+bit13 set). This is a
+    faithful port of an ODAS quirk; it touches only the auxiliary inclinometer
+    channels, never shear/temperature, and no such words occur in the ARCTERX
+    data (verified across all 29 files). Left as-is for ODAS parity (#1).
+    """
+    val = data.copy().astype(np.float64)
+    # Bit 15 set → new-data flag.  Clear it.
+    mask = val < -(2**14)
+    val[mask] += 2**15
+    # Bit 14 set → error flag.  Clear it.
+    mask = val >= 2**14
+    val[mask] -= 2**14
+    # Two's complement for the upper half of the 14-bit range.
+    mask = val >= 2**13
+    val[mask] -= 2**14
+    return val
+
+
+def _unsigned_16bit(data: np.ndarray) -> np.ndarray:
+    """Convert signed int16 to unsigned by wrapping negative values.
+
+    The caller may pass already-unsigned data (the PFile loader's
+    upstream wrap step views int16 channels as uint16 in place); in that
+    case the negative-mask is empty and the array is returned as-is
+    (with a copy to keep the existing contract that callers may safely
+    mutate the result).
+    """
+    if data.dtype.kind == "u":
+        return data.copy()
+    if data.dtype.kind == "i" and data.dtype.itemsize <= 2:
+        # Native +2**16 would overflow int16; promote first.
+        d = data.astype(np.int32)
+    else:
+        d = data.copy()
+    d[d < 0] += 2**16
+    return d
+
+
+def _deglitch_rs232(d: np.ndarray) -> np.ndarray:
+    """Forward-fill obvious RS232-receiver glitches (RINKO FT sensors).
+
+    Faithful port of the "Temporary fix of a buggy RS232 receiver" in ODAS
+    ``convert_odas.m`` (odas_aroft_o2_internal / odas_aroft_t_internal): any
+    sample sitting at/near the unsigned rails (``<= 50`` or ``>= 2^16 - 50``)
+    is replaced by the preceding sample. The first sample is never replaced
+    (ODAS loops from index 2, 1-based), and a run of consecutive glitches all
+    inherit the last good value. Applied to the UNSIGNED-wrapped values, i.e.
+    after :func:`_unsigned_16bit`, matching the ODAS ordering. (#104 U1-2.)
+    """
+    out = np.asarray(d, dtype=np.float64).copy()
+    if out.size == 0:
+        return out
+    glitch = (out <= 50) | (out >= 2**16 - 50)
+    glitch[0] = False  # ODAS keeps the first sample regardless
+    # Standard forward-fill: map each glitch to the last non-glitch index.
+    idx = np.where(glitch, 0, np.arange(out.size))
+    np.maximum.accumulate(idx, out=idx)
+    return out[idx]
+
+
+def convert_therm(data: np.ndarray, params: dict[str, Any]) -> tuple[np.ndarray, str]:
+    """FP07 thermistor via Steinhart-Hart equation and half-bridge circuit.
+
+    Uses coefficients T_0, beta_1 (and optional beta_2, beta_3) from the
+    channel config.  Matches ODAS ``convert_odas.m`` therm path.
+    """
+    a = _safe_float(params.get("a", "0"))
+    b = _safe_float(params.get("b", "1"))
+    adc_fs = _safe_float(params.get("adc_fs", "4.096"))
+    adc_bits = _safe_float(params.get("adc_bits", "16"))
+    # g (gain) and e_b (bridge excitation) scale the bridge resistance and thus
+    # temperature directly — warn if the config omits them rather than silently
+    # using a default that may not match the instrument (as t_0 already does).
+    G = _require_float(params, "g", 6.0, "therm")
+    E_B = _require_float(params, "e_b", 0.68, "therm")
+    T_0 = _require_float(params, "t_0", 289.0, "therm")
+    # `beta` and `beta_1` are mutually exclusive alternatives for the linear
+    # Steinhart-Hart term (beta = legacy single-coeff form, beta_1 = newer
+    # multi-coeff form; beta_2/beta_3 are additive higher-order terms applied
+    # regardless). ODAS convert_odas.m:501-507 checks `beta` FIRST; match that
+    # precedence rather than preferring beta_1 (#4).
+    if "beta" in params:
+        beta_1 = _safe_float(params["beta"], 3000.0)
+    elif "beta_1" in params:
+        beta_1 = _safe_float(params["beta_1"], 3000.0)
+    else:
+        beta_1 = _require_float(params, "beta_1", 3000.0, "therm")
+    beta_2 = params.get("beta_2")
+
+    Z = ((data - a) / b) * (adc_fs / 2**adc_bits) * 2 / (G * E_B)
+    Z = np.clip(Z, -0.6, 0.6)
+    R_ratio = (1 - Z) / (1 + Z)
+    log_R = np.log(R_ratio)
+
+    inv_T = 1.0 / T_0 + (1.0 / beta_1) * log_R
+    if beta_2 is not None:
+        inv_T += (1.0 / _safe_float(beta_2)) * log_R**2
+        beta_3 = params.get("beta_3")
+        if beta_3 is not None:
+            inv_T += (1.0 / _safe_float(beta_3)) * log_R**3
+    return 1.0 / inv_T - 273.15, "deg_C"
+
+
+def convert_shear(data: np.ndarray, params: dict[str, Any]) -> tuple[np.ndarray, str]:
+    """Shear probe: raw counts to velocity shear [s⁻¹].
+
+    Formula: ``(adc_fs / 2^adc_bits * data + offset) / (2*sqrt(2)*diff_gain*sens)``.
+    """
+    adc_fs = _safe_float(params.get("adc_fs", "4.096"))
+    adc_bits = _safe_float(params.get("adc_bits", "16"))
+    diff_gain = _require_float(params, "diff_gain", 1.0, "shear")
+    sens = _require_float(params, "sens", 1.0, "shear")
+    adc_zero = _safe_float(params.get("adc_zero", "0"))
+    sig_zero = _safe_float(params.get("sig_zero", "0"))
+    phys = (adc_fs / 2**adc_bits) * data + (adc_zero - sig_zero)
+    phys = phys / (2 * np.sqrt(2) * diff_gain * sens)
+    # NB: this is the ODAS intermediate — still MISSING the /speed^2 fall-rate
+    # normalization that makes it true physical shear (applied exactly once
+    # downstream in helpers.py + adapter). The units stay the UDUNITS-valid
+    # "s-1" so CF-declared per-profile files remain compliant; the
+    # pre-normalization caveat is surfaced CF-legally via the sh1/sh2 ``comment``
+    # attribute (set during channel conversion in PFile._read), not baked into
+    # ``units``. (#104 U1-1.)
+    return phys, "s-1"
+
+
+def convert_poly(data: np.ndarray, params: dict[str, Any]) -> tuple[np.ndarray, str]:
+    """Polynomial conversion (pressure, etc.): coef0 + coef1*x + coef2*x² + …"""
+    coeffs = []
+    for i in range(10):
+        key = f"coef{i}"
+        if key in params:
+            coeffs.append(_safe_float(params[key]))
+        else:
+            break
+    if not coeffs:
+        return data, "counts"
+    phys = np.polyval(coeffs[::-1], data)
+    units = params.get("units", "").strip("[]")
+    return phys, units or "unknown"
+
+
+def convert_voltage(data: np.ndarray, params: dict[str, Any]) -> tuple[np.ndarray, str]:
+    """Generic voltage channel: ``(adc_zero + data * adc_fs / 2^adc_bits) / gain`` → Volts."""
+    # adc_fs/adc_bits set the absolute voltage scale; a missing adc_bits used to
+    # default to 0 -> 2**0 = 1, silently mis-scaling the result by 2**16. Route
+    # through _require_float so omission warns loudly (default 16-bit ADC).
+    adc_fs = _require_float(params, "adc_fs", 1.0, "voltage")
+    adc_bits = _require_float(params, "adc_bits", 16.0, "voltage")
+    gain = _safe_float(params.get("g", "1"))
+    adc_zero = _safe_float(params.get("adc_zero", "0"))
+    phys = (adc_zero + data * adc_fs / 2**adc_bits) / gain
+    return phys, "V"
+
+
+def convert_piezo(data: np.ndarray, params: dict[str, Any]) -> tuple[np.ndarray, str]:
+    """Piezo accelerometer: subtract zero-offset ``a_0``."""
+    a_0 = _safe_float(params.get("a_0", "0"))
+    return data - a_0, "counts"
+
+
+def convert_accel(data: np.ndarray, params: dict[str, Any]) -> tuple[np.ndarray, str]:
+    """Linear (DC-response) accelerometer → m/s².
+
+    Matches ODAS ``convert_odas.m`` ``odas_accel_internal``:
+      ``x = data*adc_fs/2^adc_bits + adc_zero - sig_zero``
+      ``physical = 9.81 * (x - coef0) / coef1``
+
+    Used by older VMPs with calibrated accelerometers (in place of the
+    piezo type, whose output stays in counts).
+    """
+    adc_zero = _safe_float(params.get("adc_zero", "0"))
+    # ODAS odas_accel_internal defaults adc_bits to 0 (2**0 = 1) and adc_fs to 1
+    # for the counts-based coef0/coef1 calibration used by legacy calibrated
+    # accelerometers that omit the ADC params. (Unlike convert_voltage, whose
+    # ODAS default IS 16 — do NOT copy that here: the 2026-06-19 audit
+    # disconfirmed a 16 default for accel, and PR #74's 16.0 mis-scaled such
+    # configs by 2**16. SN479 configs carry adc_bits=16 explicitly, so this
+    # default does not change the campaign output.)
+    adc_fs = _safe_float(params.get("adc_fs", "1"))
+    adc_bits = _safe_float(params.get("adc_bits", "0"))
+    sig_zero = _safe_float(params.get("sig_zero", "0"))
+    coef0 = _require_float(params, "coef0", 0.0, "accel")
+    coef1 = _require_float(params, "coef1", 1.0, "accel")
+    x = data * adc_fs / 2**adc_bits + adc_zero - sig_zero
+    return 9.81 * (x - coef0) / coef1, "m_s-2"
+
+
+def convert_magn(data: np.ndarray, params: dict[str, Any]) -> tuple[np.ndarray, str]:
+    """Magnetometer → µT.
+
+    Matches ODAS ``convert_odas.m`` ``odas_magn_internal``:
+      ``physical = (data - coef0) / coef1``
+    """
+    coef0 = _require_float(params, "coef0", 0.0, "magn")
+    coef1 = _require_float(params, "coef1", 1.0, "magn")
+    return (data - coef0) / coef1, "uT"
+
+
+def convert_inclxy(data: np.ndarray, params: dict[str, Any]) -> tuple[np.ndarray, str]:
+    """ADIS inclinometer X or Y: 14-bit two's complement → degrees."""
+    val = _adis_14bit(data)
+    # ODAS odas_inclxy_internal has no default for coef1 — MATLAB errors on a
+    # missing scale rather than fabricating one. Route through _require_float so
+    # a missing coefficient WARNS (house style: shear/voltage/accel/magn) instead
+    # of silently substituting the ADIS16209 nominal 0.025 deg/LSB. (#104 U1-3.)
+    coef0 = _require_float(params, "coef0", 0.0, "inclxy")
+    coef1 = _require_float(params, "coef1", 0.025, "inclxy")
+    return coef1 * val + coef0, "deg"
+
+
+def convert_inclt(data: np.ndarray, params: dict[str, Any]) -> tuple[np.ndarray, str]:
+    """ADIS inclinometer temperature: 14-bit two's complement → °C."""
+    val = _adis_14bit(data)
+    coef0 = _safe_float(params.get("coef0", "624"))
+    coef1 = _safe_float(params.get("coef1", "-0.47"))
+    return coef1 * val + coef0, "deg_C"
+
+
+def convert_jac_c(data: np.ndarray, params: dict[str, Any]) -> tuple[np.ndarray, str]:
+    """JAC conductivity: ratio of I/V parts from 32-bit combined word → mS/cm."""
+    i_part = np.floor(data / 2**16)
+    v_part = np.mod(data, 2**16)
+    # NaN (not 1) for a zero voltage part: a v_part==0 sample is corrupt, so
+    # flag it rather than fabricating a finite ratio that looks like real data.
+    with np.errstate(divide="ignore", invalid="ignore"):
+        ratio = np.where(v_part == 0, np.nan, i_part / v_part)
+    a = _safe_float(params.get("a"))
+    b = _safe_float(params.get("b"))
+    c = _safe_float(params.get("c"))
+    return np.polyval([c, b, a], ratio), "mS_cm-1"
+
+
+def convert_jac_t(data: np.ndarray, params: dict[str, Any]) -> tuple[np.ndarray, str]:
+    """JAC temperature: unsigned 16-bit wrapping + 5th-order polynomial → °C."""
+    d = _unsigned_16bit(data)
+    a = _safe_float(params.get("a"))
+    b = _safe_float(params.get("b"))
+    c = _safe_float(params.get("c"))
+    d_coef = _safe_float(params.get("d"))
+    e = _safe_float(params.get("e"))
+    f = _safe_float(params.get("f"))
+    return np.polyval([f, e, d_coef, c, b, a], d), "deg_C"
+
+
+def convert_raw(data: np.ndarray, params: dict[str, Any]) -> tuple[np.ndarray, str]:
+    """Passthrough: return raw counts unchanged."""
+    return data, "counts"
+
+
+def convert_aroft_o2(data: np.ndarray, params: dict[str, Any]) -> tuple[np.ndarray, str]:
+    """RINKO FT dissolved oxygen: unsigned 16-bit wrapping / 100 → µmol/L."""
+    d = _deglitch_rs232(_unsigned_16bit(data))
+    return d / 100.0, "umol_L-1"
+
+
+def convert_aroft_t(data: np.ndarray, params: dict[str, Any]) -> tuple[np.ndarray, str]:
+    """RINKO FT temperature: unsigned 16-bit wrapping / 1000 - 5 -> deg C."""
+    d = _deglitch_rs232(_unsigned_16bit(data))
+    return d / 1000.0 - 5.0, "deg_C"
+
+
+def convert_aem1g_a(data: np.ndarray, params: dict[str, Any]) -> tuple[np.ndarray, str]:
+    """AEM1-G electromagnetic current meter, analog output → m/s.
+
+    Matches ODAS ``convert_odas.m`` ``odas_aem1g_a_internal``:
+      1. Convert raw counts to voltage: ``V = adc_zero + data * (adc_fs / 2^adc_bits)``
+      2. Apply calibration: ``V = a/100 + b/100 * V``  (cm/s → m/s)
+      3. Subtract bias: ``physical = V - bias``
+    """
+    adc_fs = _safe_float(params.get("adc_fs", "4.096"))
+    adc_bits = _safe_float(params.get("adc_bits", "16"))
+    adc_zero = _safe_float(params.get("adc_zero", str(adc_fs / 2)))
+    a = _safe_float(params.get("a", "0")) / 100.0
+    b = _safe_float(params.get("b", "1")) / 100.0
+    bias = _safe_float(params.get("bias", "0"))
+    V = adc_zero + data * (adc_fs / 2**adc_bits)
+    V = a + b * V
+    return V - bias, "m_s-1"
+
+
+def convert_aem1g_d(data: np.ndarray, params: dict[str, Any]) -> tuple[np.ndarray, str]:
+    """AEM1-G electromagnetic current meter, digital/RS232 output → m/s.
+
+    Matches ODAS ``convert_odas.m`` ``odas_aem1g_d_internal``:
+      1. Convert signed int16 to unsigned (wrap negatives)
+      2. Apply calibration: ``physical = a/100 + b/100 * data``  (cm/s → m/s)
+    """
+    d = _unsigned_16bit(data)
+    a = _safe_float(params.get("a", "0")) / 100.0
+    b = _safe_float(params.get("b", "1")) / 100.0
+    return a + b * d, "m_s-1"
+
+
+def convert_alec_emc(data: np.ndarray, params: dict[str, Any]) -> tuple[np.ndarray, str]:
+    """Alec Electronics electromagnetic current meter → m/s.
+
+    Matches ODAS ``convert_odas.m`` ``odas_Alec_EMC_internal``:
+      ``physical = coef1 * data + coef0``
+    """
+    coef0 = _safe_float(params.get("coef0", "0"))
+    coef1 = _safe_float(params.get("coef1", "1"))
+    return np.polyval([coef1, coef0], data), "m_s-1"
+
+
+CONVERTERS = {
+    "therm": convert_therm,
+    "shear": convert_shear,
+    "poly": convert_poly,
+    "voltage": convert_voltage,
+    "piezo": convert_piezo,
+    "accel": convert_accel,
+    "magn": convert_magn,
+    "inclxy": convert_inclxy,
+    "inclt": convert_inclt,
+    "jac_c": convert_jac_c,
+    "jac_t": convert_jac_t,
+    "raw": convert_raw,
+    "aroft_o2": convert_aroft_o2,
+    "aroft_t": convert_aroft_t,
+    "gnd": convert_raw,
+    "aem1g_a": convert_aem1g_a,
+    "aem1g_d": convert_aem1g_d,
+    "alec_emc": convert_alec_emc,
+    "jac_emc": convert_aem1g_a,  # deprecated alias
+}