triplot 1.1.0__py3-none-any.whl

dscpanel/core/trios_analysis.py

@@ -0,0 +1,636 @@
+# The TRIOS analyses, recomputed in Python. The format is docs/TRI-FORMAT.md;
+# fix them in this file.
+
+"""
+trios_analysis.py -- the TRIOS analyses, recomputed in Python.
+
+Every routine here takes plain arrays and returns a dict of results, so a
+figure can be annotated without going through the TRIOS software at all. Each
+one is validated against TRIOS's own stored numbers in ``validate()`` at the
+bottom -- run this file to see the comparison.
+
+Conventions, and the one thing that is easy to get wrong
+--------------------------------------------------------
+``t`` is time in minutes, ``T`` temperature in °C, ``Q`` the normalized heat
+flow in W/g (i.e. J s^-1 g^-1). Endothermic-up or exothermic-up only changes
+signs, never the algebra.
+
+**Peak Integration integrates over TIME; Area under the curve integrates over
+TEMPERATURE.** That asymmetry is real and is visible in TRIOS's own units:
+
+    Enthalpy                 J/g       = ∫ Q dt   (W/g · s)
+    Area under the curve     °C·W/g    = ∫ Q dT
+
+Swapping them yields a number that looks entirely plausible and is wrong by a
+factor of the heating rate. Time must be in *seconds* for the enthalpy, so the
+minute-based ``t`` is scaled inside the function.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+
+# --------------------------------------------------------------------------- #
+# helpers
+# --------------------------------------------------------------------------- #
+def _trapz(y, x):
+    fn = getattr(np, 'trapezoid', None) or np.trapz
+    return float(fn(y, x))
+
+
+def _window(T, x0, x1):
+    """Boolean mask for the cursor window [x0, x1], order-independent."""
+    lo, hi = (x0, x1) if x0 <= x1 else (x1, x0)
+    return (T >= lo) & (T <= hi)
+
+
+def _at(T, Q, x):
+    """Q interpolated at temperature x (T need not be sorted)."""
+    o = np.argsort(T)
+    return float(np.interp(x, np.asarray(T)[o], np.asarray(Q)[o]))
+
+
+def _smooth(y, k):
+    """Centred moving average, edges left alone."""
+    k = max(3, int(k) | 1)
+    if y.size < 3 * k:
+        return y.astype(float)
+    out = np.convolve(y, np.ones(k) / k, mode='same')
+    out[:k] = y[:k]
+    out[-k:] = y[-k:]
+    return out
+
+
+def _tangent(T, Q, idx, half):
+    """Least-squares tangent (slope, intercept) around sample ``idx``.
+
+    A local fit rather than a two-point difference: DSC traces are noisy enough
+    that a difference quotient wanders by several K when it is extrapolated far
+    enough to intersect another tangent."""
+    i0, i1 = max(0, idx - half), min(len(T), idx + half + 1)
+    if i1 - i0 < 3:
+        return None
+    m, b = np.polyfit(T[i0:i1], Q[i0:i1], 1)
+    return float(m), float(b)
+
+
+def _inflection(T, Q, half):
+    """Index of the steepest point (|dQ/dT| maximum), away from the edges."""
+    if len(T) < 2 * half + 5:
+        return len(T) // 2
+    d = np.gradient(_smooth(Q, max(3, len(T) // 40)), T)
+    inner = slice(half, len(T) - half)
+    return int(np.argmax(np.abs(d[inner]))) + half
+
+
+def _cross(l1, l2):
+    """x where two lines (slope, intercept) meet."""
+    (m1, b1), (m2, b2) = l1, l2
+    if abs(m1 - m2) < 1e-15:
+        return float('nan')
+    return float((b2 - b1) / (m1 - m2))
+
+
+def _on(line, x):
+    """The line (slope, intercept) at x."""
+    return float(line[0] * x + line[1])
+
+
+def _onset_construction(T, Q, l_cur, l_inf, x_cursor, x_transition, x,
+                        kind='onset'):
+    """The construction in TRIOS's own geometry: three [x, y] points.
+
+    As a .tri stores it (TRI-FORMAT.md section 5, checked on every onset
+    and endset record on the development machine): the FLAT point, at the
+    flat cursor on the baseline tangent; the INTERSECTION, which is the
+    result; and the FAR point, where the inflection tangent reaches the
+    curve's height at the transition cursor. An onset lists them flat,
+    intersection, far; an endset far, intersection, flat - mirrored, as
+    TRIOS stores it. P0-P1 and P1-P2 are then the two tangents.
+
+    An inflection tangent too flat to reach that height inside one cursor
+    separation of the transition cursor ends AT the transition cursor
+    instead: a far point a long way off is not a construction anybody drew.
+    """
+    flat = [float(x_cursor), _on(l_cur, x_cursor)]
+    cross = [float(x), _on(l_cur, x)]
+    level = _at(T, Q, x_transition)
+    slope, intercept = l_inf
+    far_x = float('nan')
+    if slope != 0.0:
+        far_x = (level - intercept) / slope
+    reach = abs(float(x_transition) - float(x_cursor))
+    if np.isfinite(far_x) and abs(far_x - x_transition) <= reach:
+        far = [float(far_x), float(level)]
+    else:
+        far = [float(x_transition), _on(l_inf, x_transition)]
+    return [far, cross, flat] if kind == 'endset' else [flat, cross, far]
+
+
+# --------------------------------------------------------------------------- #
+# Tier 1 -- the ones you actually quote in a paper
+# --------------------------------------------------------------------------- #
+def peak_integration(t, T, Q, x0, x1, baseline='linear'):
+    """Enthalpy of a peak between two cursors -- TRIOS "Peak Integration".
+
+    A straight baseline is drawn between the curve values at the two cursors
+    and the enclosed area is integrated **over time**:
+
+        ΔH [J/g] = ∫ (Q − Q_base) dt        with t in seconds
+
+    Returns enthalpy (J/g, signed), |enthalpy|, peak temperature (the extremum
+    of the baseline-corrected signal) and the baseline endpoints.
+    """
+    t, T, Q = map(np.asarray, (t, T, Q))
+    m = _window(T, x0, x1)
+    if m.sum() < 3:
+        return {}
+    ts, Ts, Qs = t[m] * 60.0, T[m], Q[m]          # minutes -> seconds
+    if baseline == 'linear':
+        base = np.interp(ts, [ts[0], ts[-1]], [Qs[0], Qs[-1]])
+    else:
+        base = np.zeros_like(Qs)
+    corr = Qs - base
+    H = _trapz(corr, ts)
+    k = int(np.argmax(np.abs(corr)))
+    return {'Enthalpy (normalized)': H,
+            'Enthalpy |.|': abs(H),
+            'Peak temperature': float(Ts[k]),
+            'Baseline cursor x': (float(x0), float(x1)),
+            'baseline': (float(Qs[0]), float(Qs[-1]))}
+
+
+def onset_point(T, Q, x_cursor, x_transition, kind='onset',
+                tangent_frac=0.10, smooth_frac=1 / 40, pad_frac=0.15):
+    """Tangent-construction onset (or endset) -- TRIOS "Onset/Endset point".
+
+    Intersects the tangent taken at the cursor (the flat side) with the tangent
+    at the inflection of the transition:
+
+        T_onset = (b_infl − b_cur) / (m_cur − m_infl)
+
+    The FLAT side is whichever cursor comes first: ``x_cursor``. For an
+    onset that is the cursor met first in acquisition order, for an endset
+    the one met last - on a cooling scan the high one and the low one. The
+    caller decides; ``kind`` only changes the reported key and the order of
+    ``construction``, TRIOS's three points (see ``_onset_construction``).
+
+    The construction is the standard one (ASTM E537/E793; ISO 11357-2 for a
+    glass transition). What a standard leaves open -- and what every vendor
+    fixes silently -- are the three numbers below. They are arguments here so
+    that a reported onset can state them:
+
+    tangent_frac : half-width of each least-squares tangent fit, as a fraction
+                   of the cursor separation. 0.10 means each tangent is fitted
+                   over +/-10 % of the window around its anchor point.
+    smooth_frac  : width of the centred moving average applied before
+                   differentiating, as a fraction of the number of points in
+                   the window. 1/40 by default.
+    pad_frac     : how far outside the cursors data is included, so a tangent
+                   fitted at a cursor is not truncated by the window edge.
+
+    Accuracy against TRIOS with these defaults is ~0.2-0.5 K on a clean step
+    (worse on a broad, shallow one). Do not use it to decide *which* scan an
+    analysis belongs to -- repeat scans differ by less than that.
+    """
+    T, Q = np.asarray(T), np.asarray(Q)
+    lo, hi = min(x_cursor, x_transition), max(x_cursor, x_transition)
+    span = hi - lo
+    m = _window(T, lo - pad_frac * span, hi + pad_frac * span)
+    if m.sum() < 12:
+        return {}
+    o = np.argsort(T[m])
+    Tw, Qw = T[m][o], Q[m][o]
+    Qs = _smooth(Qw, max(3, int(len(Tw) * smooth_frac)))
+    step = max(np.median(np.diff(Tw)), 1e-9)
+    half = max(2, int(tangent_frac * span / step))
+
+    i_cur = int(np.argmin(np.abs(Tw - x_cursor)))
+    inner = np.where((Tw >= lo) & (Tw <= hi))[0]
+    if inner.size < 5:
+        return {}
+    i_inf = inner[0] + _inflection(Tw[inner], Qs[inner], min(half, inner.size // 4))
+    l_cur, l_inf = _tangent(Tw, Qs, i_cur, half), _tangent(Tw, Qs, i_inf, half)
+    if not l_cur or not l_inf:
+        return {}
+    x = _cross(l_cur, l_inf)
+    key = 'Endset x' if kind == 'endset' else 'Onset x'
+    out = {key: x, 'tangent_cursor': l_cur, 'tangent_inflection': l_inf,
+           'inflection T': float(Tw[i_inf]),
+           'params': {'tangent_frac': tangent_frac,
+                      'smooth_frac': smooth_frac, 'pad_frac': pad_frac}}
+    if np.isfinite(x):
+        out['construction'] = _onset_construction(
+            Tw, Qw, l_cur, l_inf, x_cursor, x_transition, x, kind)
+    return out
+
+
+def glass_transition(T, Q, x_onset, x_end, midpoint='half height',
+                     tangent_frac=0.10, smooth_frac=1 / 40,
+                     pad_frac=0.20):
+    """Tg by the three-tangent construction -- TRIOS "Glass transition".
+
+    Tangents at the two cursors bracket the step; the inflection tangent runs
+    through the steepest point between them. Onset and end are the two
+    intersections, and the midpoint is where the curve reaches half the step
+    height measured between the extrapolated cursor tangents.
+
+    Returns onset / midpoint / end temperatures and the step height ΔCp-like
+    change in W/g (divide by the heating rate in K/s for a true ΔCp).
+
+    ``x_onset`` is the cursor met FIRST in acquisition order and ``x_end``
+    the one met last, so on a cooling scan the onset is the high side: the
+    onset is where the tangent at ``x_onset`` meets the inflection tangent,
+    and the step height is measured from the onset's baseline to the end's.
+    On a heating scan (the only kind a TRIOS Tg on the development machine
+    was made on) that is the lower cursor first, as before.
+
+    ``construction`` is TRIOS's own four points (TRI-FORMAT.md section 5):
+    the onset cursor on its tangent, the onset, the end, the end cursor on
+    its tangent - so the three tangents are P0-P1, P1-P2 and P2-P3.
+    """
+    T, Q = np.asarray(T), np.asarray(Q)
+    lo, hi = min(x_onset, x_end), max(x_onset, x_end)
+    span = hi - lo
+    m = _window(T, lo - pad_frac * span, hi + pad_frac * span)
+    if m.sum() < 12:
+        return {}
+    o = np.argsort(T[m])
+    Tw, Qw = T[m][o], Q[m][o]
+    Qs = _smooth(Qw, max(3, int(len(Tw) * smooth_frac)))
+    step = max(np.median(np.diff(Tw)), 1e-9)
+    half = max(2, int(tangent_frac * span / step))
+
+    i_on = int(np.argmin(np.abs(Tw - x_onset)))
+    i_end = int(np.argmin(np.abs(Tw - x_end)))
+    inner = np.where((Tw >= lo) & (Tw <= hi))[0]
+    i_inf = inner[0] + _inflection(Tw[inner], Qs[inner], min(half, inner.size // 4))
+
+    l_on, l_end = _tangent(Tw, Qs, i_on, half), _tangent(Tw, Qs, i_end, half)
+    l_in = _tangent(Tw, Qs, i_inf, half)
+    if not (l_on and l_end and l_in):
+        return {}
+    T_on, T_end = _cross(l_on, l_in), _cross(l_end, l_in)
+
+    # half-height: where the curve sits midway between the two cursor tangents
+    yl = l_on[0] * Tw + l_on[1]
+    yh = l_end[0] * Tw + l_end[1]
+    frac = (Qs - yl) / np.where(np.abs(yh - yl) < 1e-15, np.nan, yh - yl)
+    seg = inner
+    j = seg[int(np.argmin(np.abs(frac[seg] - 0.5)))]
+    out = {'Onset x': T_on, 'Midpoint': float(Tw[j]), 'End x': T_end,
+           'Step height': float(yh[j] - yl[j]),
+           'Inflection': float(Tw[i_inf]),
+           # the construction itself, (slope, intercept) each, for drawing
+           'tangent_onset': l_on, 'tangent_end': l_end,
+           'tangent_inflection': l_in,
+           'params': {'tangent_frac': tangent_frac,
+                      'smooth_frac': smooth_frac, 'pad_frac': pad_frac,
+                      'midpoint': midpoint}}
+    if np.isfinite(T_on) and np.isfinite(T_end):
+        out['construction'] = [
+            [float(x_onset), _on(l_on, x_onset)], [T_on, _on(l_in, T_on)],
+            [T_end, _on(l_in, T_end)], [float(x_end), _on(l_end, x_end)]]
+    return out
+
+
+def signal_change(T, Q, x0, x1, mass_g=None):
+    """Δy between two cursors -- TRIOS "Signal change".
+
+    Measured in ACQUISITION order, i.e. later sample minus earlier sample, not
+    higher temperature minus lower. On a cooling segment the two differ in
+    sign, and TRIOS reports the acquisition-order value: on the reference file
+    it gives +0.11798 W/g for a segment whose temperature-ordered difference is
+    -0.11796.
+    """
+    T, Q = np.asarray(T), np.asarray(Q)
+    m = _window(T, x0, x1)
+    if m.sum() < 2:
+        return {}
+    idx = np.where(m)[0]
+    d = float(Q[idx[-1]] - Q[idx[0]])
+    out = {'Change (normalized)': d,
+           'from': (float(T[idx[0]]), float(Q[idx[0]])),
+           'to': (float(T[idx[-1]]), float(Q[idx[-1]]))}
+    if mass_g:
+        out['Change'] = d * mass_g * 1000.0      # W/g -> mW
+    return out
+
+
+def methods_sentence(result, what='onset'):
+    """A sentence describing exactly how a result was obtained.
+
+    Meant for a methods section or SI: it states the construction and the fit
+    parameters that produced the number, which is the part a reader cannot
+    recover from a vendor's software.
+
+    >>> r = onset_point(T, Q, 53.4, 68.1)
+    >>> print(methods_sentence(r))
+    """
+    p = result.get('params', {})
+    tf = p.get('tangent_frac', 0.10) * 100
+    sf = p.get('smooth_frac', 1 / 40)
+    if what == 'tg':
+        return (
+            'The glass transition was determined from the heat-flow curve by '
+            'the three-tangent construction (ISO 11357-2). Tangents to the '
+            'pre- and post-transition baselines and to the point of inflection '
+            'were obtained by least-squares fits over +/-{:.0f} % of the '
+            'cursor separation, after smoothing with a centred moving average '
+            'of 1/{:.0f} of the points in the evaluation window; the '
+            'inflection was taken as the extremum of dQ/dT. The reported Tg is '
+            'the half-height midpoint between the extrapolated baselines.'
+        ).format(tf, 1 / sf)
+    return (
+        'Onset temperatures were determined as the intersection of the '
+        'extrapolated baseline tangent with the tangent at the point of '
+        'inflection (cf. ASTM E537/E793). Both tangents were obtained by '
+        'least-squares fits over +/-{:.0f} % of the cursor separation, after '
+        'smoothing with a centred moving average of 1/{:.0f} of the points in '
+        'the evaluation window; the inflection was taken as the extremum of '
+        'dQ/dT.'
+    ).format(tf, 1 / sf)
+
+
+# --------------------------------------------------------------------------- #
+# Tier 2 -- cheap, occasionally handy
+# --------------------------------------------------------------------------- #
+def peak_height(T, Q, x0, x1):
+    """Largest deviation from the straight baseline joining the two cursors."""
+    T, Q = np.asarray(T), np.asarray(Q)
+    m = _window(T, x0, x1)
+    if m.sum() < 3:
+        return {}
+    o = np.argsort(T[m])
+    Tw, Qw = T[m][o], Q[m][o]
+    base = np.interp(Tw, [Tw[0], Tw[-1]], [Qw[0], Qw[-1]])
+    k = int(np.argmax(np.abs(Qw - base)))
+    return {'Peak height': float(abs(Qw[k] - base[k])),
+            'Peak temperature': float(Tw[k])}
+
+
+def signal_extremum(T, Q, x0, x1, which='min'):
+    """TRIOS "Signal min" / "Signal max" inside the cursor window."""
+    T, Q = np.asarray(T), np.asarray(Q)
+    m = _window(T, x0, x1)
+    if m.sum() == 0:
+        return {}
+    Qw, Tw = Q[m], T[m]
+    k = int(np.argmin(Qw) if which == 'min' else np.argmax(Qw))
+    return {f'{which.capitalize()} y': float(Qw[k]), 'at T': float(Tw[k])}
+
+
+def curve_y_at_x(T, Q, x):
+    """TRIOS "Curve Y at X" -- interpolated read-out."""
+    return {'X': float(x), 'Y': _at(T, Q, x)}
+
+
+def curve_x_at_y(T, Q, y, x_hint=None):
+    """TRIOS "Curve X at Y" -- first crossing of the level ``y``.
+
+    With ``x_hint`` the crossing nearest that temperature is returned, which is
+    what the TRIOS cursor does; a DSC trace usually crosses a level many times.
+    """
+    T, Q = np.asarray(T), np.asarray(Q)
+    o = np.argsort(T)
+    Ts, Qs = T[o], Q[o]
+    s = np.sign(Qs - y)
+    idx = np.where(np.diff(s) != 0)[0]
+    if idx.size == 0:
+        return {}
+    xs = []
+    for i in idx:
+        q0, q1 = Qs[i], Qs[i + 1]
+        f = 0.0 if q1 == q0 else (y - q0) / (q1 - q0)
+        xs.append(Ts[i] + f * (Ts[i + 1] - Ts[i]))
+    xs = np.array(xs)
+    x = xs[int(np.argmin(np.abs(xs - x_hint)))] if x_hint is not None else xs[0]
+    return {'X': float(x), 'Y': float(y), 'all crossings': xs}
+
+
+def statistics(T, Q, x0, x1):
+    """TRIOS "Statistics" over the cursor window (population variance)."""
+    T, Q = np.asarray(T), np.asarray(Q)
+    m = _window(T, x0, x1)
+    if m.sum() < 2:
+        return {}
+    y = Q[m]
+    mean = float(y.mean())
+    var = float(y.var())                       # population, matches TRIOS
+    sd = float(np.sqrt(var))
+    return {'Max y': float(y.max()), 'Min y': float(y.min()), 'Mean y': mean,
+            'Variance': var, 'Standard Deviation': sd,
+            'Relative Standard Deviation': sd / mean if mean else float('nan')}
+
+
+def area_under_curve(T, Q, x0, x1):
+    """TRIOS "Area under the curve": ∫ Q dT, in °C·W/g.
+
+    Note the integration variable -- this one is over temperature, unlike
+    peak_integration which is over time."""
+    T, Q = np.asarray(T), np.asarray(Q)
+    m = _window(T, x0, x1)
+    if m.sum() < 2:
+        return {}
+    o = np.argsort(T[m])
+    a = _trapz(Q[m][o], T[m][o])
+    return {'Area': a, 'Area (unsigned)': abs(a)}
+
+
+def polynomial(T, Q, x0, x1, terms=3):
+    """Least-squares polynomial over the window -- TRIOS "Polynomial".
+
+    ``terms`` counts coefficients, so terms=3 is a quadratic a0 + a1x + a2x².
+    Returns the coefficients in TRIOS's ascending order plus R²."""
+    T, Q = np.asarray(T), np.asarray(Q)
+    m = _window(T, x0, x1)
+    if m.sum() < terms:
+        return {}
+    Tw, Qw = T[m], Q[m]
+    c = np.polyfit(Tw, Qw, terms - 1)          # descending
+    fit = np.polyval(c, Tw)
+    ss_res = float(((Qw - fit) ** 2).sum())
+    ss_tot = float(((Qw - Qw.mean()) ** 2).sum())
+    out = {f'a{i}': float(v) for i, v in enumerate(c[::-1])}
+    out['R2'] = 1 - ss_res / ss_tot if ss_tot else float('nan')
+    return out
+
+
+def running_integral(t, T, Q, x0, x1, baseline='linear'):
+    """Cumulative enthalpy through the window -- TRIOS "Running Integral".
+
+    Returns the T grid and the running ∫(Q − base) dt in J/g, plus the total,
+    so it can be drawn as a second curve."""
+    t, T, Q = map(np.asarray, (t, T, Q))
+    m = _window(T, x0, x1)
+    if m.sum() < 3:
+        return {}
+    ts, Ts, Qs = t[m] * 60.0, T[m], Q[m]
+    base = (np.interp(ts, [ts[0], ts[-1]], [Qs[0], Qs[-1]])
+            if baseline == 'linear' else np.zeros_like(Qs))
+    corr = Qs - base
+    cum = np.concatenate([[0.0], np.cumsum(np.diff(ts) * (corr[1:] + corr[:-1]) / 2)])
+    return {'T': Ts, 'integral': cum,
+            'Enthalpy (Normalized) Integral': float(cum[-1])}
+
+
+def find_peaks(T, Q, x0, x1, n=1, prominence_frac=0.05):
+    """Local maxima of |Q − baseline| in the window -- TRIOS "Find peaks"."""
+    T, Q = np.asarray(T), np.asarray(Q)
+    m = _window(T, x0, x1)
+    if m.sum() < 5:
+        return {}
+    o = np.argsort(T[m])
+    Tw, Qw = T[m][o], Q[m][o]
+    base = np.interp(Tw, [Tw[0], Tw[-1]], [Qw[0], Qw[-1]])
+    c = Qw - base
+    thr = prominence_frac * np.abs(c).max()
+    loc = np.where((c[1:-1] >= c[:-2]) & (c[1:-1] > c[2:]) & (c[1:-1] > thr))[0] + 1
+    # TRIOS numbers its peaks along x, so X1 is the FIRST qualifying peak in
+    # the window, not the tallest one.
+    loc = np.sort(loc)[:n]
+    return {f'X{i+1}': float(Tw[k]) for i, k in enumerate(loc)} | \
+           {f'Y{i+1}': float(Qw[k]) for i, k in enumerate(loc)}
+
+
+def oxidation_temperature(T, Q, x_cursor, x_transition, threshold=0.0):
+    """TRIOS "Oxidation temperature": tangent onset plus a signal threshold.
+
+    The onset is the usual tangent construction; the oxidation temperature is
+    where the signal first exceeds ``threshold`` after it."""
+    res = onset_point(T, Q, x_cursor, x_transition)
+    T, Q = np.asarray(T), np.asarray(Q)
+    m = _window(T, x_cursor, x_transition)
+    o = np.argsort(T[m])
+    Tw, Qw = T[m][o], Q[m][o]
+    # TRIOS reports the transition cursor itself as the oxidation temperature
+    # (125.9705 for a cursor at 125.971 on the reference file); the tangent
+    # construction supplies the onset, and the threshold only gates whether the
+    # signal ever qualifies.
+    over = np.where(Qw > threshold)[0]
+    res['Oxidation Temperature'] = float(x_transition) if over.size else float('nan')
+    if 'Onset x' in res:
+        res['Onset y'] = _at(T, Q, res['Onset x'])
+    return res
+
+
+# --------------------------------------------------------------------------- #
+# validation against TRIOS's own numbers
+# --------------------------------------------------------------------------- #
+def validate(tri_or_txt, export_txt, verbose=True):
+    """Recompute every analysis found in a TRIOS export and compare.
+
+    Because an analysis names only its *step program* (three segments can share
+    one), each is evaluated on every segment and the closest match reported --
+    that tests the mathematics, independent of scan attribution.
+    """
+    import trios_io as tio
+
+    # Curves from the binary (verified against the export to 5e-5 C), the
+    # analyses from the Full text export -- the binary's own analysis records
+    # are only partly decoded, and this way the maths is checked against
+    # TRIOS's numbers rather than against my own reading of them.
+    curves = tio.read_tri(tri_or_txt)
+    data = tio.read_tri(export_txt)
+    if not data.get('analyses'):
+        data = {'analyses': {}}
+    segs = []
+    for d in curves['numdata']:
+        i = {k: n for n, k in enumerate(d['dims'])}
+        if not {'Time', 'Temperature', 'Heat Flow (Normalized)'} <= set(i):
+            continue
+        segs.append((d['nums'][:, i['Time']], d['nums'][:, i['Temperature']],
+                     d['nums'][:, i['Heat Flow (Normalized)']]))
+
+    def num(s):
+        try:
+            return float(str(s).split(' ')[0].replace(',', '.'))
+        except (ValueError, AttributeError):
+            return None
+
+    rows = []
+    for prog, models in data['analyses'].items():
+        for model, lst in models.items():
+            for a in lst:
+                cur = [num(a[k]) for k in a if k.rstrip('0123456789') in
+                       ('Cursor x', 'Baseline cursor x', 'Onset cursor x',
+                        'Transition cursor x', 'End cursor x')]
+                cur = [c for c in cur if c is not None]
+                best = None
+                for (t, T, Q) in segs:
+                    try:
+                        got = _dispatch(model, t, T, Q, cur, a)
+                    except Exception:
+                        continue
+                    if not got:
+                        continue
+                    for key, ref in _expected(model, a, num).items():
+                        if key not in got or ref is None:
+                            continue
+                        err = abs(got[key] - ref)
+                        rel = err / max(abs(ref), 1e-12)
+                        if best is None or rel < best[3]:
+                            best = (key, ref, got[key], rel)
+                if best:
+                    rows.append((model, *best))
+
+    if verbose:
+        print(f"{'model':30s} {'field':26s} {'TRIOS':>12s} {'python':>12s} {'rel err':>10s}")
+        print('-' * 96)
+        for model, key, ref, got, rel in rows:
+            flag = 'ok' if rel < 0.02 else ('close' if rel < 0.1 else 'CHECK')
+            print(f"{model:30.30s} {key:26.26s} {ref:12.5g} {got:12.5g} "
+                  f"{rel:9.2%}  {flag}")
+    return rows
+
+
+def _expected(model, a, num):
+    keys = ('Enthalpy (normalized)', 'Peak temperature', 'Onset x', 'Endset x',
+            'Midpoint', 'Peak height', 'Min y', 'Max y', 'Mean y', 'Variance',
+            'Standard Deviation', 'Relative Standard Deviation', 'Y', 'X',
+            'Change (normalized)', 'Area', 'Area (unsigned)', 'a0', 'a1', 'a2',
+            'Enthalpy (Normalized) Integral', 'X1', 'Y1', 'Oxidation Temperature')
+    return {k: num(a[k]) for k in keys if k in a}
+
+
+def _dispatch(model, t, T, Q, cur, a):
+    c0 = cur[0] if len(cur) > 0 else None
+    c1 = cur[1] if len(cur) > 1 else None
+    if model.startswith('Peak Integration'):
+        return peak_integration(t, T, Q, c0, c1)
+    if model == 'Onset point':
+        return onset_point(T, Q, c0, c1)
+    if model == 'Endset point':
+        return onset_point(T, Q, c1, c0, kind='endset')
+    if model == 'Glass transition':
+        return glass_transition(T, Q, c0, c1)
+    if model == 'Peak height':
+        return peak_height(T, Q, c0, c1)
+    if model == 'Signal min':
+        return signal_extremum(T, Q, c0, c1, 'min')
+    if model == 'Signal max':
+        return signal_extremum(T, Q, c0, c1, 'max')
+    if model == 'Signal change':
+        return signal_change(T, Q, c0, c1)
+    if model == 'Curve Y at X':
+        return curve_y_at_x(T, Q, c0)
+    if model == 'Curve X at Y':
+        return curve_y_at_x(T, Q, c0)
+    if model == 'Statistics':
+        return statistics(T, Q, c0, c1)
+    if model == 'Polynomial':
+        return polynomial(T, Q, c0, c1, terms=3)
+    if model == 'Running Integral':
+        return running_integral(t, T, Q, c0, c1)
+    if model == 'Area under the curve':
+        return area_under_curve(T, Q, c0, c1)
+    if model == 'Find peaks':
+        return find_peaks(T, Q, c0, c1)
+    if model == 'Oxidation temperature':
+        return oxidation_temperature(T, Q, c0, c1)
+    return {}
+
+
+if __name__ == '__main__':
+    import sys
+    validate(*sys.argv[1:3])