scripts/asset_runtime/eco_ncld822.py

"""CHEM-091 ECO PHYSICS nCLD 822 M dual-chamber chemiluminescence NO / NO2 / NOx analyzer: runtime (process model + session).

What is simulated (SI; mole fractions in mol/mol, the GUI shows ppm = 1e-6 mol/mol with 0.1 ppm resolution):

* inlet: the gas at the sample inlet is either room air (disconnected), a calibration cylinder from the template library
  (NIST SRM NO-in-N2 / O2-in-N2 / CO2-in-N2, connected by the agent) or a host-supplied sample (process truth, evaluator only);
  inlet pressure 600-1200 mbar absolute (brochure), sample flow 1.0 L/min at 101325 Pa through critical restrictors (flow ~ p_in);
* sample path: optional external sample line (host: length, inner diameter, PTFE / stainless, temperature) with wall memory of NO and
  NO2 from NASA TM X-3229 (rise / decay time per wetted area); condensation in unheated paths (sample dew point above the path
  temperature, option "h" hot tubing absent) removes soluble species by Henry's-law equilibrium with the condensate (Sander 2023);
  dark gas-phase chemistry during the residence time (IUPAC rows 53-64: 2NO+O2, NO+O3, NO+NO3, NO2+O3, N2O3 / N2O4 / N2O5
  formation and decomposition, N2O5 hydrolysis) integrated with backward Euler (N-atom conserving);
* two chambers: NO channel = NO arriving; NOx channel = after the metal converter (NO2 efficiency = host parameter, default 1.0;
  other NOy by the qualitative reducibility classes of Dunlea et al. 2007: efficient -> 1, not efficient -> 0, partial -> explicit
  host assumption); O2-dependent NOx-channel bias from NASA TM X-3229 Table VII;
* chemiluminescence: signal ~ NO x quench factor x flow, quench 1 / (1 + sum a_i x_i) with measured interference factors (CO2 0.60,
  H2O 2.1, O2 0) and, for Ar / H2 / N2O / NO2, a_i = q_i / q_N2 - 1 from the relative quenching efficiencies (upper bound: the sample
  is taken as the whole third-body bath); the instrument compensates the indicated inlet pressure (option "r" regulates it);
* dynamics: internal lag 2.0 s at 1.0 L/min (brochure: lag < 3 s), mixing tau 0.35 s (0-90 % in 0.81 s, brochure < 1 s), filter
  tau = setting; zero noise 0.06 ppm (1 sigma) at the reference filter 1 s scaled with sqrt(1 s / tau) (brochure: 0.06 ppm, LDL
  0.12 ppm "depending on filter setting"); warm-up of converter and cooled PMT (time constants and set points are assumptions);
* four freely selectable full-scale ranges 5-5000 ppm (over-range is flagged), zero / span calibration (asynchronous averaging),
  1 Hz time series of NO, NO2 = NOx - NO and NOx while measuring.

Not simulated: V1 / V2 calibration valves, the analog output box, data interfaces, fault probabilities, PMT gain drift.
Matterix bridge: RECIPES module="asset_runtime.eco_ncld822", cls="EcoNcld822Runtime", instance_in_ctor=True, advance=STEP_DT."""
from __future__ import annotations

import copy
import hashlib
import json
import math
import random
from collections import deque
from pathlib import Path

import numpy as np

from asset_runtime import _annotations as _ann

PROTOCOL_VERSION = '1.0.0'
ASSET_TYPE_ID = 'instrument.eco_ncld822'
CATALOG_ID = 'CHEM-091'
ROOT = Path(__file__).resolve().parents[2]
TEMPLATE_REL = 'assets/reactions/eco_ncld822_nox_library/templates.json'

R_GAS, K_B = 8.314462618, 1.380649e-23
P_REF, T_REF = 101325.0, 298.15
PPM = 1e-6
Q_NOM = 1.0e-3 / 60.0                  # 1.0 L/min (brochure), taken at 101325 Pa / 298.15 K (assumption: no reference state given)
P_MIN, P_MAX = 60000.0, 120000.0       # 600-1200 mbar abs (brochure)
FS_MIN, FS_MAX = 5 * PPM, 5000 * PPM   # four freely selectable ranges 5-5000 ppm (brochure)
LAG_INT_S = 2.0                        # internal transport lag at Q_NOM (assumption within the brochure's < 3 s)
TAU_MIX_S = 0.35                       # chamber / path mixing (assumption; 0-90 % = 2.303 tau = 0.81 s < 1 s brochure)
NOISE0 = 0.06 * PPM                    # zero noise 1 sigma (brochure, "depending on filter setting")
FILTER_REF_S = 1.0                     # filter setting at which NOISE0 holds (assumption)
TAU_P_SENSOR_S = 0.5                   # inlet pressure sensor lag used by the pressure compensation (assumption)
T_CONV_SET, TAU_CONV_S = 648.15, 150.0  # metal converter set point / warm-up tau (assumptions: brochure gives neither)
T_PMT_SET, TAU_PMT_S = 268.15, 90.0    # cooled PMT set point / tau (assumptions)
TAU_O3_S = 20.0                        # ozone generator ramp (assumption)
T_HOT_S = 453.15                       # option "h" hot tubing temperature (assumption)
DIGITS = 1e-7                          # 0.1 ppm display resolution (GUI screenshot)
SERIES_DT = 1.0                        # 1 Hz series while measuring (assumption; brochure: second-level signals)
SERIES_MAX = 7200
DEFAULT_FS = [5e-6, 5e-5, 5e-4, 5e-3]
STANDARD_EXTRA = {'zero_nitrogen': dict(nitrogen=1.0), 'zero_air': dict(nitrogen=0.7808, oxygen=0.2095, argon=0.0093, carbon_dioxide=0.0004)}
CHEM = ['nitric_oxide', 'nitrogen_dioxide', 'ozone', 'nitrate_radical', 'dinitrogen_pentoxide', 'nitric_acid', 'dinitrogen_trioxide',
        'dinitrogen_tetroxide', 'oxygen', 'water']
N_ATOMS = {'nitric_oxide': 1, 'nitrogen_dioxide': 1, 'nitrate_radical': 1, 'dinitrogen_pentoxide': 2, 'nitric_acid': 1, 'dinitrogen_trioxide': 2,
           'dinitrogen_tetroxide': 2, 'nitrous_acid': 1, 'ammonia': 1, 'peroxyacetyl_nitrate': 1, 'peroxynitric_acid': 1, 'methyl_nitrate': 1,
           'ethyl_nitrate': 1, 'n_propyl_nitrate': 1, 'n_butyl_nitrate': 1, 'nitrous_oxide': 2, 'hydrogen_cyanide': 1, 'acetonitrile': 1,
           'nitromethane': 1, 'particulate_nitrate': 1}
NO_PER_MOLECULE = {'nitrogen_dioxide': 1, 'nitrate_radical': 1, 'dinitrogen_pentoxide': 2, 'nitric_acid': 1, 'dinitrogen_trioxide': 2,
                   'dinitrogen_tetroxide': 2, 'methyl_nitrate': 1, 'ethyl_nitrate': 1, 'n_propyl_nitrate': 1, 'n_butyl_nitrate': 1,
                   'nitrous_acid': 1, 'ammonia': 1, 'peroxyacetyl_nitrate': 1, 'peroxynitric_acid': 1, 'nitrous_oxide': 2, 'hydrogen_cyanide': 1,
                   'acetonitrile': 1, 'nitromethane': 1, 'particulate_nitrate': 1}
CLASS_ALIAS = {'peroxyacetyl_nitrate': 'peroxy_nitrates_ro2no2', 'dinitrogen_trioxide': 'nitrogen_dioxide', 'dinitrogen_tetroxide': 'nitrogen_dioxide'}


class ActionRejected(ValueError):
    """Precondition or argument failure; the runtime state is unchanged.  Messages never disclose sample composition."""


# ------------------------------------------------------------------------------------------------------------------- template library
_LIB = None


def library():
    global _LIB
    if _LIB is None:
        path = ROOT / TEMPLATE_REL
        raw = path.read_bytes()
        data = json.loads(raw)
        _LIB = dict(sha256=hashlib.sha256(raw).hexdigest(), by_id={r['record_id']: r for r in data['templates']}, data=data)
    return _LIB


def _rec(rid):
    return library()['by_id'][rid]


def _v(rid, key):
    return _rec(rid)['values'][key]['value']


def certificate_validity(standard_id):
    c = library()['by_id'][standard_id]['conditions']
    return c.get('validity')


def certificates():
    """{standard_id: (species, certificate value, U95, value kind)} of the connectable SRM cylinders.  Individually certified lots have no
    public value: the simulated cylinder's certificate is taken at the nominal fraction (assumption, flagged in the result)."""
    out = {}
    for rid, r in library()['by_id'].items():
        if r['family'] != 'calibration_standard':
            continue
        v = r['values']
        cert = v.get('certified_mole_fraction') or v.get('example_certified_mole_fraction')
        x = (cert or v['nominal_mole_fraction'])['value']
        out[rid] = (r['substance_id'], float(x), float(v['expanded_uncertainty_U95']['value']),
                    r['conditions'].get('value_kind') if cert else 'nominal_used_individually_certified')
    return out


def standards():
    """Certificate compositions of the connectable cylinders (balance N2) + two built-in zero gases."""
    out = {rid: {sp: x, 'nitrogen': 1.0 - x} for rid, (sp, x, u, kind) in certificates().items()}
    out.update(copy.deepcopy(STANDARD_EXTRA))
    return out


def cylinder_truth(instance_id, standard_id):
    """True mole fraction of the simulated cylinder: certificate value x (1 + d), d ~ N(0, (U95 / 2) / x) drawn deterministically from the
    instance and standard ids (the cylinder content is unknown within its certified uncertainty)."""
    sp, x, u, kind = certificates()[standard_id]
    h = hashlib.sha256(f'{instance_id}|{standard_id}'.encode()).digest()
    u1, u2 = (int.from_bytes(h[:8], 'big') + 0.5) / 2 ** 64, (int.from_bytes(h[8:16], 'big') + 0.5) / 2 ** 64
    z = math.sqrt(-2.0 * math.log(u1)) * math.cos(2.0 * math.pi * u2)
    return sp, x * (1.0 + z * (u / 2.0) / x)


def quench_coefficients(phi=0.0):
    """a_i in S/S0 = 1 / (1 + sum a_i x_i), relative to a nitrogen bath.  CO2 / H2O / O2: measured interference factors (NASA TM X-3229).
    Ar / H2 / N2O / NO2: relative quenching efficiencies (Clyne et al. via the same report) scaled by phi = the fraction of the chamber's third
    bodies contributed by the sample; phi is an explicit host assumption (default 0: the measured O2 factor ~0 contradicts phi = 1, which would
    give O2 +11 % over N2)."""
    a = {}
    for rid in ('quench_if_carbon_dioxide', 'quench_if_water', 'quench_if_oxygen'):
        a[_rec(rid)['substance_id']] = 0.0 - float(_v(rid, 'dlnS_dx'))
    q_n2 = float(_v('quench_rel_nitrogen', 'relative_quenching_efficiency_k3M_over_k3O2'))
    for rid in ('quench_rel_argon', 'quench_rel_hydrogen', 'quench_rel_nitrous_oxide', 'quench_rel_nitrogen_dioxide'):
        sid = _rec(rid)['substance_id']
        a.setdefault(sid, phi * (float(_v(rid, 'relative_quenching_efficiency_k3M_over_k3O2')) / q_n2 - 1.0))
    return a


def converter_class(sid):
    rid = 'converter_' + CLASS_ALIAS.get(sid, sid)
    r = library()['by_id'].get(rid)
    return r['values']['reducibility_class']['value'] if r else None


def henry_constant(sid, T):
    r = library()['by_id'].get('henry_' + sid)
    if r is None:
        return None
    h = float(r['values']['Hscp_298']['value'])
    b = r['values'].get('temperature_coefficient_B', {}).get('value')
    return h * math.exp(float(b) * (1.0 / T - 1.0 / 298.15)) if b is not None else h


def adsorption_tau(sid, material, area_m2):
    """(tau_rise_s, tau_decay_s) of the line wall memory: time per wetted area x area / ln(1000) (0.1 % criterion of the report)."""
    r = library()['by_id'].get(f"line_adsorption_{sid}_{ {'ptfe': 'teflon'}.get(material, material)}")
    if r is None or area_m2 <= 0:
        return 0.0, 0.0
    rise = r['values']['rise_time_per_area']['value']
    decay = r['values']['decay_time_per_area']['value']
    rise = decay if rise is None else rise
    return float(rise) * area_m2 / math.log(1000.0), float(decay) * area_m2 / math.log(1000.0)


def o2_converter_bias(x_o2):
    v = _rec('converter_o2_effect_stainless_800c')['values']
    xs, es = v['oxygen_mole_fraction']['value'], v['nox_mode_relative_error']['value']
    if x_o2 <= xs[0]:
        return es[0]
    for i in range(1, len(xs)):
        if x_o2 <= xs[i]:
            return es[i - 1] + (es[i] - es[i - 1]) * (x_o2 - xs[i - 1]) / (xs[i] - xs[i - 1])
    return es[-1]


def p_sat_water(T):
    """Saturation vapour pressure of water over liquid (Magnus-Tetens / Alduchov-Eskridge 1996 form; engineering formula)."""
    tc = T - 273.15
    return 610.94 * math.exp(17.625 * tc / (tc + 243.04))


# ------------------------------------------------------------------------------------------------------------------- dark chemistry
def _arr(v, T, key='A', ekey='E_over_R'):
    return float(v[key]['value']) * math.exp(-float(v[ekey]['value']) / T)


def _clamp(T, rng):
    return min(max(T, rng[0]), rng[1]) if rng else T


def _troe(v, T, n_m, clamped=None, row=None):
    """IUPAC Troe falloff; k0 and kinf are each evaluated with T clamped into their own evaluated range."""
    k0p, kip = v['k0_prefactor'], v['kinf_prefactor']
    T0, Ti = _clamp(T, k0p.get('T_range_K')), _clamp(T, kip.get('T_range_K'))
    if clamped is not None and (T0 != T or Ti != T):
        clamped.append(row)
    k0 = float(k0p['value']) * (T0 / 300.0) ** float(k0p['T_exponent_n'])
    if k0p.get('exp_minus_E_over_RT_K'):
        k0 *= math.exp(-float(k0p['exp_minus_E_over_RT_K']) / T0)
    ki = float(kip['value']) * (Ti / 300.0) ** float(kip['T_exponent_n'])
    if kip.get('exp_minus_E_over_RT_K'):
        ki *= math.exp(-float(kip['exp_minus_E_over_RT_K']) / Ti)
    k0m = k0 * n_m
    fc = float(v['Fc']['value'])
    nn = 0.75 - 1.27 * math.log10(fc)
    logf = math.log10(fc) / (1.0 + (math.log10(k0m / ki) / nn) ** 2)
    return k0m * ki / (k0m + ki) * 10 ** logf


def t_range(v):
    return v['T_range']['value'] if isinstance(v.get('T_range'), dict) else None


def rate_constants(T, n_m, clamped=None):
    """SI rate coefficients (molecule, m^3, s) of IUPAC rows 53-64 at T and bath number density n_m; T is clamped into each record's
    evaluated temperature range (the clamped rows are appended to `clamped`)."""
    k = {}
    T0 = T
    for i in range(53, 65):
        r = _rec(f'kinetics_iupac_{i}')
        law, v = r['conditions']['rate_law'], r['values']
        if law.startswith('troe'):
            k[i] = _troe(v, T0, n_m, clamped, i)
            continue
        T = _clamp(T0, t_range(v))
        if clamped is not None and T != T0:
            clamped.append(i)
        if law in ('termolecular_arrhenius', 'bimolecular_arrhenius'):
            k[i] = _arr(v, T)
        else:
            k[i] = float(v['k']['value'])
    return k


def _rates(n, k):
    no, no2, o3, no3, n2o5, hno3, n2o3, n2o4, o2, h2o = n
    return np.array([k[53] * no * no * o2, k[54] * no * o3, k[55] * no * no2, k[56] * n2o3, k[57] * no * no3, k[58] * no2 * o3,
                     k[59] * no2 * no2, k[60] * n2o4, k[61] * no2 * no3, k[62] * n2o5, k[63] * n2o5 * h2o, k[64] * n2o5 * h2o * h2o])


# stoichiometry: rows = species (CHEM order), columns = reactions 53..64
_S = np.zeros((10, 12))
_REACTIONS = [{0: -2, 8: -1, 1: 2}, {0: -1, 2: -1, 1: 1, 8: 1}, {0: -1, 1: -1, 6: 1}, {6: -1, 0: 1, 1: 1}, {0: -1, 3: -1, 1: 2},
              {1: -1, 2: -1, 3: 1, 8: 1}, {1: -2, 7: 1}, {7: -1, 1: 2}, {1: -1, 3: -1, 4: 1}, {4: -1, 1: 1, 3: 1}, {4: -1, 9: -1, 5: 2},
              {4: -1, 9: -1, 5: 2}]
for _j, _nu in enumerate(_REACTIONS):
    for _i, _c in _nu.items():
        _S[_i, _j] = _c


def integrate_dark_chemistry(x, T, p, t_res, clamped=None):
    """Mole fractions of the CHEM species after t_res seconds at (T, p): backward Euler + Newton on number densities, geometric substeps.
    Linear invariants (N atoms, O atoms) are preserved by construction up to the Newton tolerance."""
    n_m = p / (K_B * T)
    n0 = np.array([x.get(s, 0.0) for s in CHEM]) * n_m
    if t_res <= 0 or (n0[0] <= 0 and n0[1] <= 0 and n0[3] <= 0 and n0[4] <= 0 and n0[6] <= 0 and n0[7] <= 0):
        return {s: float(v / n_m) for s, v in zip(CHEM, n0)}
    k = rate_constants(T, n_m, clamped)
    n = n0.copy()
    t, h = 0.0, min(1e-7, t_res)
    while t < t_res - 1e-15:
        h = min(h, t_res - t)
        y = n.copy()
        for _ in range(30):
            f = y - n - h * (_S @ _rates(y, k))
            J = np.eye(10)
            for i in range(10):                                  # finite-difference Jacobian of the rates (10 x 10)
                d = max(abs(y[i]) * 1e-7, 1e-30 * n_m + 1.0)
                yp = y.copy()
                yp[i] += d
                J[:, i] -= h * (_S @ (_rates(yp, k) - _rates(y, k))) / d
            dy = np.linalg.solve(J, -f)
            y = y + dy
            if np.all(np.abs(dy) <= 1e-10 * np.maximum(np.abs(y), 1e-12 * n_m)):
                break
        y = np.where(y < 0, np.where(y > -1e-12 * n_m, 0.0, y), y)
        n = y
        t += h
        h *= 1.6
    return {s: float(v / n_m) for s, v in zip(CHEM, n)}


def n_atoms(x):
    return sum(N_ATOMS.get(s, 0) * v for s, v in x.items())


# ------------------------------------------------------------------------------------------------------------------- schemas
def number(unit, lo=None, hi=None):
    d = {'type': 'number', 'x-unit': unit}
    if lo is not None:
        d['minimum'] = lo
    if hi is not None:
        d['maximum'] = hi
    return d


def obj(props, required=None):
    return dict(type='object', properties=props, required=list(props) if required is None else required, additionalProperties=False)


def nullable(s):
    return {'anyOf': [s, {'type': 'null'}]}


BOOL, TEXT = {'type': 'boolean'}, {'type': 'string'}
FRACTION = number('mol/mol', 0.0, 1.0)
FS_ARRAY = {'type': 'array', 'x-unit': 'mol/mol', 'items': number('mol/mol', FS_MIN, FS_MAX), 'minItems': 4, 'maxItems': 4}
STATUS = {'type': 'string', 'enum': ['off', 'warming', 'ready']}
MEAS = {'type': 'string', 'enum': ['idle', 'measuring']}
CALP = {'type': 'string', 'enum': ['idle', 'zeroing', 'spanning']}
FLAGS = {'type': 'array', 'items': {'type': 'string', 'enum': ['warming_up', 'over_range', 'inlet_pressure_out_of_range', 'ambient_out_of_range',
                                                                'no_ozone', 'calibration_running']}}
MATERIAL = {'type': 'string', 'enum': ['ptfe', 'stainless']}
COMPOSITION = {'type': 'object', 'additionalProperties': number('mol/mol', 0.0, 1.0)}
POINT = obj({'time_s': number('s', 0), 'no_mol_mol': nullable(number('mol/mol')), 'no2_mol_mol': nullable(number('mol/mol')),
             'nox_mol_mol': nullable(number('mol/mol'))})
PHASE_OP = {'type': 'string', 'enum': ['running', 'succeeded', 'cancelled', 'failed']}
CAL_RESULT = obj({'phase': CALP, 'operation_id': TEXT})
MEASURE = obj({'status': STATUS, 'measurement': MEAS, 'quality': {'type': 'string', 'enum': ['valid', 'invalid', 'off']},
               'no_mol_mol': nullable(number('mol/mol')), 'no2_mol_mol': nullable(number('mol/mol')), 'nox_mol_mol': nullable(number('mol/mol')),
               'no_ppm': nullable(number('ppm')), 'no2_ppm': nullable(number('ppm')), 'nox_ppm': nullable(number('ppm')),
               'range_index': {'type': 'integer', 'minimum': 0, 'maximum': 3}, 'full_scale_mol_mol': number('mol/mol', FS_MIN, FS_MAX),
               'flags': FLAGS, 'series': {'type': 'array', 'items': POINT}, 'template_source': TEXT, 'library_sha256': TEXT,
               'template_records': {'type': 'array', 'items': TEXT},
               'evidence': {'type': 'string', 'const': 'simulated_from_cited_response_parameters'}})
STANDARD_IDS = sorted(standards())
MODEL_RECORDS = sorted(library()['by_id'])     # every record family is used by the response model (static: no per-sample leak)
PLANT = obj({'hot_tubing_installed': BOOL, 'pressure_regulation_installed': BOOL, 'line_length_m': number('m', 0.0, 50.0),
             'line_inner_diameter_m': number('m', 0.001, 0.02), 'line_material': MATERIAL, 'line_temperature_k': number('K', 253.15, 473.15),
             'ambient_temperature_k': number('K', 253.15, 333.15), 'ambient_pressure_pa': number('Pa', 60000.0, 120000.0),
             'ambient_relative_humidity': number('1', 0.0, 1.0), 'converter_no2_efficiency': number('1', 0.0, 1.0),
             'partial_conversion_fraction': nullable(number('1', 0.0, 1.0)), 'quench_relative_scale': number('1', 0.0, 1.0), 'noise_enabled': BOOL, 'seed': {'type': 'integer', 'minimum': 0, 'x-unit': '1'}},
            required=[])
PLANT_EXAMPLE = dict(hot_tubing_installed=False, pressure_regulation_installed=False, line_length_m=2.0, line_inner_diameter_m=0.004,
                     line_material='ptfe', line_temperature_k=298.15, ambient_temperature_k=298.15, ambient_pressure_pa=101325.0,
                     ambient_relative_humidity=0.5, converter_no2_efficiency=1.0, partial_conversion_fraction=None, quench_relative_scale=0.0,
                     noise_enabled=True, seed=0)
INLET = obj({'composition': COMPOSITION, 'pressure_pa': number('Pa', 10000.0, 300000.0), 'temperature_k': number('K', 253.15, 773.15), 'label': TEXT})
INLET_EXAMPLE = dict(composition={'nitric_oxide': 250e-6, 'nitrogen_dioxide': 20e-6, 'oxygen': 0.06, 'carbon_dioxide': 0.08, 'water': 0.012},
                     pressure_pa=101325.0, temperature_k=298.15, label='scr_outlet')

# capability: input, output, components, meaning, kind, visibility, example, state effects
CAPS = {
    'power.set': (obj({'enabled': BOOL}), obj({'enabled': BOOL}), ['switch_power', 'power_inlet', 'touchscreen'],
                  '整机通断；断电停止测量、取消校准，转换器与PMT回到环境温度', 'device_command', 'agent', {'enabled': True},
                  ['power.enabled', 'status.phase', 'measurement.phase', 'calibration.phase']),
    'power.toggle': (obj({}), obj({'enabled': BOOL}), ['switch_power'], '电源翘板按一次切换通断（Matterix按键）', 'device_command', 'agent', {},
                     ['power.enabled', 'status.phase']),
    'range.configure': (obj({'full_scales_mol_mol': FS_ARRAY}), obj({'full_scales_mol_mol': FS_ARRAY}), ['touchscreen', 'display_digits'],
                        '四个可自由选择的满量程（5–5000 ppm，升序）', 'configuration', 'agent', {'full_scales_mol_mol': DEFAULT_FS}, ['range.full_scales_mol_mol']),
    'range.select': (obj({'index': {'type': 'integer', 'minimum': 0, 'maximum': 3, 'x-unit': '1'}}), obj({'index': {'type': 'integer', 'minimum': 0, 'maximum': 3, 'x-unit': '1'}}),
                     ['touchscreen', 'display_digits'], '选择当前量程（超量程只标记，不自动切换）', 'configuration', 'agent', {'index': 2},
                     ['range.index', 'range.active_full_scale_mol_mol']),
    'filter.set': (obj({'time_constant_s': number('s', 0.0, 60.0)}), obj({'time_constant_s': number('s', 0.0, 60.0)}), ['touchscreen', 'detector_block'],
                   '输出一阶滤波时间常数；噪声与最低可检浓度随之变化', 'configuration', 'agent', {'time_constant_s': 1.0}, ['filter.time_constant_s']),
    'measurement.start': (obj({}), obj({'phase': MEAS}), ['softkey_measure', 'detector_block', 'converter', 'vacuum_pump', 'display_digits'],
                          '开始连续测量并以1 Hz记录NO/NO2/NOx时间序列（需预热完成）', 'device_command', 'agent', {}, ['measurement.phase', 'measurement.points']),
    'measurement.stop': (obj({}), obj({'phase': MEAS}), ['softkey_measure', 'display_digits'], '停止连续测量（保留已记录序列）', 'device_command', 'agent', {},
                         ['measurement.phase']),
    'measurement.toggle': (obj({}), obj({'phase': MEAS}), ['softkey_measure'], '测量触摸键：开始/停止切换', 'device_command', 'agent', {}, ['measurement.phase']),
    'calibration.configure': (obj({'span_no_mol_mol': number('mol/mol', FS_MIN * 0.2, FS_MAX), 'span_nox_mol_mol': number('mol/mol', FS_MIN * 0.2, FS_MAX),
                                   'window_s': number('s', 5.0, 600.0)}),
                              obj({'span_no_mol_mol': number('mol/mol'), 'span_nox_mol_mol': number('mol/mol'), 'window_s': number('s')}),
                              ['touchscreen'], '输入跨度气证书浓度（NO与NOx通道）与平均窗口', 'configuration', 'agent',
                              {'span_no_mol_mol': 2954e-6, 'span_nox_mol_mol': 2954e-6, 'window_s': 30.0},
                              ['calibration.span_no_mol_mol', 'calibration.span_nox_mol_mol', 'calibration.window_s']),
    'calibration.zero': (obj({}), CAL_RESULT, ['softkey_zero', 'detector_block', 'converter'], '零点校准：在入口零气下按窗口平均两通道读数并写入零点偏置（异步）',
                         'device_command', 'agent', {}, ['calibration.phase', 'calibration.zero_offset_no_mol_mol', 'calibration.zero_offset_nox_mol_mol']),
    'calibration.span': (obj({}), CAL_RESULT, ['softkey_span', 'detector_block', 'converter'], '跨度校准：在入口跨度气下按窗口平均并按证书浓度写入增益（异步）',
                         'device_command', 'agent', {}, ['calibration.phase', 'calibration.gain_no', 'calibration.gain_nox']),
    'calibration.cancel': (obj({}), obj({'phase': CALP}), ['touchscreen'], '取消正在进行的校准，保留原校准系数', 'device_command', 'agent', {}, ['calibration.phase']),
    'inlet.connect_standard': (obj({'standard_id': {'type': 'string', 'enum': STANDARD_IDS}}),
                               obj({'standard_id': TEXT, 'source': TEXT, 'certificate_mole_fraction': nullable(number('mol/mol', 0, 1)),
                                    'expanded_uncertainty_U95': nullable(number('mol/mol', 0, 1)), 'value_kind': TEXT,
                                    'certificate_validity': nullable(TEXT), 'certificate_expired': BOOL}),
                               ['sample_inlet', 'inlet_filter'], '把标准气瓶（模板库NIST SRM或零气）经减压阀接到样气入口（101325 Pa，有放空）', 'device_command',
                               'agent', {'standard_id': 'srm_2631a'}, ['inlet.source']),
    'inlet.disconnect': (obj({}), obj({'source': TEXT}), ['sample_inlet'], '断开入口：泵抽入室内空气', 'device_command', 'agent', {}, ['inlet.source']),
    'inlet.connect': (INLET, obj({'source': TEXT}), ['sample_inlet', 'inlet_filter'], '宿主接入样品气（组成、绝压、温度为过程真值）', 'configuration',
                      'evaluator', INLET_EXAMPLE, ['inlet.source', 'inlet.composition', 'inlet.pressure_pa', 'inlet.temperature_k']),
    'plant.configure': (PLANT, obj({'configured': BOOL}), ['housing', 'converter', 'sample_inlet'],
                        '宿主配置已装选件（h热管路、r压力调节）、外部样气管、环境与转换器参数', 'configuration', 'evaluator', PLANT_EXAMPLE,
                        ['line.condensed_water_fraction']),
    'nox.measure': (obj({'max_points': {'type': 'integer', 'minimum': 0, 'maximum': SERIES_MAX, 'x-unit': '1'}}, required=[]), MEASURE,
                    ['display_digits', 'detector_block', 'converter'], '读取当前NO/NO2/NOx显示值、量程、状态标志与时间序列（纯读取，不推进时钟）', 'query',
                    'agent', {'max_points': 60}, []),
}
UNSUPPORTED = {
    'calibration.valve_select': ('V1/V2校准电磁阀选件（单阀或零/跨度双阀、2–3 bar加压校准）未建模', ['sample_inlet']),
    'analog_output.configure': ('外接模拟输出盒（0–10 V，4–20 mA）未建模', ['power_inlet']),
    'data.export': ('USB/LAN/WLAN/蓝牙/HDMI数据通信与导出未实现', ['usb_ports', 'lan_port', 'hdmi_port']),
}

# slot: schema, unit, origin, visibility, components, write (capability, argument), meaning
SLOTS = {
    'power.enabled': (BOOL, '1', 'setpoint', 'agent', ['switch_power'], ('power.set', 'enabled'), '整机电源设定'),
    'status.phase': (STATUS, '1', 'derived', 'agent', ['touchscreen'], None, '预热状态：off/warming/ready（转换器±10 K、PMT±1 K内为ready）'),
    'status.flags': (FLAGS, '1', 'derived', 'agent', ['touchscreen'], None, 'GUI状态标志（预热、超量程、入口压力越界、环境越界、无臭氧、校准中、部分转换按假设）'),
    'converter.temperature_k': (number('K', 0), 'K', 'process_truth', 'evaluator', ['converter'], None, '金属转换器温度真值（设定点648 K为假设）'),
    'pmt.temperature_k': (number('K', 0), 'K', 'process_truth', 'evaluator', ['detector_block'], None, '冷却PMT温度真值（设定点268 K为假设）'),
    'ozone.generator_fraction': (number('1', 0, 1), '1', 'process_truth', 'evaluator', ['ozone_generator'], None, '臭氧发生器相对输出（0–1）'),
    'range.full_scales_mol_mol': (FS_ARRAY, 'mol/mol', 'setpoint', 'agent', ['touchscreen'], ('range.configure', 'full_scales_mol_mol'), '四个满量程'),
    'range.index': ({'type': 'integer', 'minimum': 0, 'maximum': 3, 'x-unit': '1'}, '1', 'setpoint', 'agent', ['touchscreen'], ('range.select', 'index'), '当前量程序号'),
    'range.active_full_scale_mol_mol': (number('mol/mol', FS_MIN, FS_MAX), 'mol/mol', 'derived', 'agent', ['display_digits'], None, '当前量程满量程'),
    'filter.time_constant_s': (number('s', 0.0, 60.0), 's', 'setpoint', 'agent', ['touchscreen'], ('filter.set', 'time_constant_s'), '输出滤波时间常数'),
    'measurement.phase': (MEAS, '1', 'derived', 'agent', ['display_digits'], None, '连续测量状态'),
    'measurement.points': ({'type': 'integer', 'minimum': 0}, '1', 'derived', 'agent', ['display_digits'], None, '已记录的1 Hz序列点数'),
    'calibration.phase': (CALP, '1', 'derived', 'agent', ['touchscreen'], None, '校准状态'),
    'calibration.span_no_mol_mol': (number('mol/mol'), 'mol/mol', 'setpoint', 'agent', ['touchscreen'], None, 'NO通道跨度气证书浓度'),
    'calibration.span_nox_mol_mol': (number('mol/mol'), 'mol/mol', 'setpoint', 'agent', ['touchscreen'], None, 'NOx通道跨度气证书浓度'),
    'calibration.window_s': (number('s', 5.0, 600.0), 's', 'setpoint', 'agent', ['touchscreen'], None, '校准平均窗口'),
    'calibration.zero_offset_no_mol_mol': (number('mol/mol'), 'mol/mol', 'derived', 'agent', ['detector_block'], None, 'NO通道零点偏置（归一化信号单位）'),
    'calibration.zero_offset_nox_mol_mol': (number('mol/mol'), 'mol/mol', 'derived', 'agent', ['detector_block'], None, 'NOx通道零点偏置'),
    'calibration.gain_no': (number('1', 0), '1', 'derived', 'agent', ['detector_block'], None, 'NO通道增益（出厂1.0）'),
    'calibration.gain_nox': (number('1', 0), '1', 'derived', 'agent', ['detector_block'], None, 'NOx通道增益（出厂1.0）'),
    'inlet.source': (TEXT, '1', 'derived', 'agent', ['sample_inlet'], None, '入口接的是什么：ambient_air / standard:<id> / sample（宿主样品，标签只对evaluator可见）'),
    'inlet.indicated_pressure_pa': (number('Pa', 0), 'Pa', 'derived', 'agent', ['sample_inlet', 'touchscreen'], None, '入口绝压显示（一阶0.5 s，1 Pa分辨率）'),
    'flow.indicated_sample_m3_s': (number('m^3/s', 0), 'm^3/s', 'derived', 'agent', ['flow_restrictors', 'touchscreen'], None, '样气体积流量显示'),
    'inlet.composition': (COMPOSITION, 'mol/mol', 'process_truth', 'evaluator', ['sample_inlet'], None, '入口气体组成真值（含平衡N2）'),
    'inlet.pressure_pa': (number('Pa', 0), 'Pa', 'process_truth', 'evaluator', ['sample_inlet'], None, '入口绝压真值'),
    'inlet.temperature_k': (number('K', 0), 'K', 'process_truth', 'evaluator', ['sample_inlet'], None, '入口气体温度真值'),
    'chamber.no_mol_mol': (number('mol/mol', 0), 'mol/mol', 'process_truth', 'evaluator', ['detector_block'], None, 'NO反应室的等效NO摩尔分数真值（传输、混合后）'),
    'chamber.nox_mol_mol': (number('mol/mol', 0), 'mol/mol', 'process_truth', 'evaluator', ['detector_block', 'converter'], None, 'NOx反应室（转换后）的等效NO真值'),
    'inlet.label': (nullable(TEXT), '1', 'process_truth', 'evaluator', ['sample_inlet'], None, '宿主样品的标签（agent只看到sample）'),
    'converter.partial_assumption_applied': (BOOL, '1', 'process_truth', 'evaluator', ['converter'], None,
                                             '到达气中含“部分还原”类物种且使用了缺省0.5假设（未由宿主给定）'),
    'line.condensed_water_fraction': (number('mol/mol', 0, 1), 'mol/mol', 'process_truth', 'evaluator', ['sample_inlet'], None, '未加热路径中冷凝的水（每摩尔样气）'),
    'display.no_mol_mol': (nullable(number('mol/mol')), 'mol/mol', 'derived', 'agent', ['display_digits'], None, '屏幕NO读数（0.1 ppm分辨率；关机为null）'),
    'display.no2_mol_mol': (nullable(number('mol/mol')), 'mol/mol', 'derived', 'agent', ['display_digits'], None, '屏幕NO2读数=NOx−NO'),
    'display.nox_mol_mol': (nullable(number('mol/mol')), 'mol/mol', 'derived', 'agent', ['display_digits'], None, '屏幕NOx读数'),
}
SCENE_MIRRORED = ('display.no_mol_mol', 'display.no2_mol_mol', 'display.nox_mol_mol', 'power.enabled', 'status.phase', 'measurement.phase', 'calibration.phase')
REFERENCE_ZH = {
    'inlet.indicated_pressure_pa': '绝压（厂家进口600–1200 mbar abs.）。',
    'inlet.pressure_pa': '绝压。',
    'flow.indicated_sample_m3_s': '气体体积流量，按101325 Pa、298.15 K参考状态（假设；厂家1.0 l/min未注明参考状态）；临界限流下与入口绝压成正比。',
}
for _k in ('range.full_scales_mol_mol', 'range.active_full_scale_mol_mol', 'calibration.span_no_mol_mol', 'calibration.span_nox_mol_mol',
           'display.no_mol_mol', 'display.no2_mol_mol', 'display.nox_mol_mol', 'chamber.no_mol_mol', 'chamber.nox_mol_mol', 'inlet.composition',
           'calibration.zero_offset_no_mol_mol', 'calibration.zero_offset_nox_mol_mol'):
    REFERENCE_ZH[_k] = '摩尔分数（湿基：样气按到达状态，不干燥；1 ppm = 1e-6 mol/mol），与温压无关。'
REFERENCE_ZH['line.condensed_water_fraction'] = '每摩尔入口湿样气在未加热路径中冷凝出的水（摩尔比）。'


def validate(schema, value):
    if 'anyOf' in schema:
        for s in schema['anyOf']:
            try:
                validate(s, value)
                return
            except ActionRejected:
                continue
        raise ActionRejected('INVALID_ARGUMENT')
    typ = schema.get('type')
    if typ == 'number':
        if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value):
            raise ActionRejected('INVALID_ARGUMENT')
        if value < schema.get('minimum', -math.inf) or value > schema.get('maximum', math.inf):
            raise ActionRejected('INVALID_ARGUMENT')
    elif typ == 'integer':
        if isinstance(value, bool) or not isinstance(value, int):
            raise ActionRejected('INVALID_ARGUMENT')
        if value < schema.get('minimum', -math.inf) or value > schema.get('maximum', math.inf):
            raise ActionRejected('INVALID_ARGUMENT')
    elif typ == 'boolean' and type(value) is not bool:
        raise ActionRejected('INVALID_ARGUMENT')
    elif typ == 'null' and value is not None:
        raise ActionRejected('INVALID_ARGUMENT')
    elif typ == 'string' and not isinstance(value, str):
        raise ActionRejected('INVALID_ARGUMENT')
    elif typ == 'array':
        if not isinstance(value, list) or len(value) < schema.get('minItems', 0) or len(value) > schema.get('maxItems', 10 ** 9):
            raise ActionRejected('INVALID_ARGUMENT')
        for v in value:
            validate(schema.get('items', {}), v)
    elif typ == 'object':
        if not isinstance(value, dict):
            raise ActionRejected('INVALID_ARGUMENT')
        props = schema.get('properties', {})
        if not set(schema.get('required', [])) <= value.keys():
            raise ActionRejected('INVALID_ARGUMENT')
        for key, val in value.items():
            if not isinstance(key, str):
                raise ActionRejected('INVALID_ARGUMENT')
            sub = props.get(key, schema.get('additionalProperties', True))
            if sub is False:
                raise ActionRejected('INVALID_ARGUMENT')
            if isinstance(sub, dict):
                validate(sub, val)
    if 'enum' in schema and value not in schema['enum']:
        raise ActionRejected('INVALID_ARGUMENT')
    if 'const' in schema and value != schema['const']:
        raise ActionRejected('INVALID_ARGUMENT')


def _clean_composition(comp):
    known = set(N_ATOMS) | set(quench_coefficients()) | {'oxygen', 'nitrogen', 'water', 'ozone', 'carbon_dioxide', 'carbon_monoxide', 'methane',
                                                          'sulfur_dioxide', 'hydrogen_sulfide', 'argon', 'hydrogen'}
    if not set(comp) <= known:
        raise ActionRejected('INVALID_ARGUMENT')
    total = sum(comp.values())
    if total > 1.0 + 1e-9:
        raise ActionRejected('INVALID_ARGUMENT')
    out = {k: float(v) for k, v in comp.items() if v > 0}
    out['nitrogen'] = out.get('nitrogen', 0.0) + max(0.0, 1.0 - total)     # balance N2 (documented)
    return out


class EcoNcld822Runtime:
    """Process model + host clock state for one analyzer instance (the host is the clock authority: step(dt_s) only)."""

    def __init__(self, instance_id='ncld822_01'):
        self.instance_id = instance_id
        self.time_s, self.revision = 0.0, 0
        self.powered = False
        self.t_conv = self.t_pmt = T_REF
        self.o3_frac = 0.0
        self.full_scales = list(DEFAULT_FS)
        self.range_index = 2
        self.filter_tau = 1.0
        self.measuring = False
        self.cal_phase, self.cal_op, self._cal_t, self._cal_sum = 'idle', None, 0.0, [0.0, 0.0]
        self.cal_last = None
        self.span_no = self.span_nox = 2954e-6                   # SRM 2631a lot value (valid certificate)
        self.cal_window = 30.0
        self.zero_no = self.zero_nox = 0.0
        self.gain_no = self.gain_nox = 1.0
        self.plant = dict(PLANT_EXAMPLE, line_length_m=0.0)
        self.source = 'ambient_air'
        self.comp = self._ambient_air()
        self.p_in, self.T_in = self.plant['ambient_pressure_pa'], self.plant['ambient_temperature_k']
        self.p_ind = self.p_in
        self.wall = dict(no_ch=0.0, no=0.0, no2=0.0)                     # channel parts after the line wall memory
        self.queue = deque()                                                # (arrival time, chamber NO, chamber NOx, quench, condensed)
        self.ch = [0.0, 0.0]                                                # mixed chamber equivalents (NO, NOx), quench applied
        self.ch_true = [0.0, 0.0]
        self.cond = 0.0
        self.y = [0.0, 0.0]                                                 # filtered indicated (raw units, before calibration)
        self.noise = [0.0, 0.0]
        self.series = []
        self._next_sample_t = 0.0
        self._rng = random.Random(f'{instance_id}:0')
        self._cache = {}
        self._operation_count = 0
        self._last_event = 0.0
        self.label = None
        self._principals = {'__public_agent__': 'agent'}
        self._requests, self._owners = {}, {}
        self._arrived = self._transport(self.comp)
        self.queue.append((0.0, self._arrived))                           # the line is already filled with room air

    # -------------------------------------------------------------------------------------------------------------- helpers
    def _ambient_air(self):
        T, p, rh = self.plant['ambient_temperature_k'], self.plant['ambient_pressure_pa'], self.plant['ambient_relative_humidity']
        xw = min(0.2, rh * p_sat_water(T) / p)
        base = {'nitrogen': 0.7808, 'oxygen': 0.2095, 'argon': 0.0093, 'carbon_dioxide': 0.0004}
        return _clean_composition({k: v * (1 - xw) for k, v in base.items()} | {'water': xw})

    def _flow(self):
        return Q_NOM * self.p_in / P_REF

    def _path_temperature(self):
        return T_HOT_S if self.plant['hot_tubing_installed'] else min(self.plant['line_temperature_k'] if self.plant['line_length_m'] > 0 else 1e9,
                                                                       self.plant['ambient_temperature_k'])

    def _line_volume(self):
        return math.pi * self.plant['line_inner_diameter_m'] ** 2 / 4.0 * self.plant['line_length_m']

    def _residence(self):
        q = max(self._flow(), 1e-12)
        return LAG_INT_S * Q_NOM / q + self._line_volume() * (self.p_in / P_REF) / q

    def _transport(self, comp):
        """Inlet composition -> (NO channel eq., NOx channel eq., quench factor, condensed water, used records); cached."""
        key = json.dumps([sorted(comp.items()), self.p_in, self.T_in, sorted(self.plant.items())], sort_keys=True, default=str)
        if key in self._cache:
            return self._cache[key]
        used = set()
        x = dict(comp)
        cond = 0.0
        T_path = self._path_temperature()
        xw = x.get('water', 0.0)
        ps = p_sat_water(T_path)
        if xw * self.p_in > ps:                                             # condensation in an unheated path: Henry partition
            x_sat = ps / self.p_in
            cond = (xw - x_sat) / (1.0 - x_sat)                             # mol water condensed per mol wet inlet gas
            v_l_per_v_g = cond * (0.018015 / 997.0) / (R_GAS * T_path / self.p_in)
            for sid in list(x):
                h = henry_constant(sid, T_path)
                if h is None or sid in ('water',):
                    continue
                f = 1.0 / (1.0 + h * R_GAS * T_path * v_l_per_v_g)
                x[sid] *= f
                used.add('henry_' + sid)
            x['water'] = x_sat * (1.0 - cond)
            tot = sum(x.values())
            x = {k: v / tot for k, v in x.items()}
        chem_in = {s: x.get(s, 0.0) for s in CHEM}
        clamped = []
        out = integrate_dark_chemistry(chem_in, T_path if T_path < 1e8 else self.T_in, self.p_in, self._residence(), clamped)
        if any(chem_in[s] > 0 for s in ('nitric_oxide', 'nitrogen_dioxide', 'ozone', 'nitrate_radical', 'dinitrogen_pentoxide')):
            used.update(f'kinetics_iupac_{i}' for i in range(53, 65))
        for s in CHEM:
            x[s] = out[s]
        no_ch = x.get('nitric_oxide', 0.0)
        eff = self.plant['converter_no2_efficiency']
        part = self.plant['partial_conversion_fraction']
        nox_no2, nox_other, partial_used = 0.0, 0.0, False
        for sid, v in x.items():
            if sid == 'nitric_oxide' or v <= 0 or sid not in NO_PER_MOLECULE:
                continue
            cls = converter_class(sid)
            if cls is None:
                continue
            used.add('converter_' + CLASS_ALIAS.get(sid, sid))
            if cls == 'efficient':
                frac = eff if sid in ('nitrogen_dioxide', 'dinitrogen_trioxide', 'dinitrogen_tetroxide') else 1.0
            elif cls == 'not_efficient':
                frac = 0.0
            else:
                frac = 0.5 if part is None else part
                partial_used = True
            if sid in ('nitrogen_dioxide', 'dinitrogen_trioxide', 'dinitrogen_tetroxide'):
                nox_no2 += frac * NO_PER_MOLECULE[sid] * v
            else:
                nox_other += frac * NO_PER_MOLECULE[sid] * v
        bias = 1.0 + o2_converter_bias(x.get('oxygen', 0.0))
        parts = dict(no=no_ch * bias, no2=nox_no2 * bias, other=nox_other * bias)       # NOx channel = NO-, NO2- and other-NOy-derived NO
        nox_ch = sum(parts.values())
        used.add('converter_o2_effect_stainless_800c')
        a = quench_coefficients(self.plant['quench_relative_scale'])
        qf = 1.0 / (1.0 + sum(a.get(s, 0.0) * v for s, v in x.items()))
        used.update({'quench_if_carbon_dioxide', 'quench_if_water', 'quench_if_oxygen', 'quench_rel_nitrogen'})
        if self.plant['quench_relative_scale'] > 0:
            used.update('quench_rel_' + s for s in ('argon', 'hydrogen', 'nitrous_oxide', 'nitrogen_dioxide') if x.get(s, 0) > 0)
        res = dict(no=no_ch, nox=nox_ch, nox_parts=parts, quench=qf, cond=cond, used=sorted(used), partial=partial_used, after=x,
                   kinetics_clamped=clamped)
        if len(self._cache) > 256:
            self._cache.clear()
        self._cache[key] = res
        return res

    def _ready(self):
        return self.powered and abs(self.t_conv - T_CONV_SET) < 10.0 and abs(self.t_pmt - T_PMT_SET) < 1.0

    def _status(self):
        return 'off' if not self.powered else ('ready' if self._ready() else 'warming')

    def _indicated(self):
        """(NO, NOx) indicated mole fractions after calibration (None when off)."""
        if not self.powered:
            return None
        return [self.gain_no * (self.y[0] + self.noise[0] - self.zero_no), self.gain_nox * (self.y[1] + self.noise[1] - self.zero_nox)]

    def _display(self):
        ind = self._indicated()
        if ind is None:
            return None, None, None
        no, nox = (round(v / DIGITS) * DIGITS for v in ind)
        return no, round((nox - no) / DIGITS) * DIGITS, nox

    def _flags(self):
        f = []
        if self.powered and not self._ready():
            f.append('warming_up')
        no, no2, nox = self._display()
        fs = self.full_scales[self.range_index]
        if nox is not None and max(abs(no), abs(nox)) > fs:
            f.append('over_range')
        if not (P_MIN <= self.p_ind <= P_MAX):                              # the analyzer only knows its indicated inlet pressure
            f.append('inlet_pressure_out_of_range')
        if not (278.15 <= self.plant['ambient_temperature_k'] <= 313.15):
            f.append('ambient_out_of_range')
        if self.powered and self.o3_frac < 0.5:
            f.append('no_ozone')
        if self.cal_phase != 'idle':
            f.append('calibration_running')
        return f

    def _values(self):
        no, no2, nox = self._display()
        return {'power.enabled': self.powered, 'status.phase': self._status(), 'status.flags': self._flags(),
                'converter.temperature_k': self.t_conv, 'pmt.temperature_k': self.t_pmt, 'ozone.generator_fraction': self.o3_frac,
                'range.full_scales_mol_mol': list(self.full_scales), 'range.index': self.range_index,
                'range.active_full_scale_mol_mol': self.full_scales[self.range_index], 'filter.time_constant_s': self.filter_tau,
                'measurement.phase': 'measuring' if self.measuring else 'idle', 'measurement.points': len(self.series),
                'calibration.phase': self.cal_phase, 'calibration.span_no_mol_mol': self.span_no, 'calibration.span_nox_mol_mol': self.span_nox,
                'calibration.window_s': self.cal_window, 'calibration.zero_offset_no_mol_mol': self.zero_no,
                'calibration.zero_offset_nox_mol_mol': self.zero_nox, 'calibration.gain_no': self.gain_no, 'calibration.gain_nox': self.gain_nox,
                'inlet.source': self.source, 'inlet.indicated_pressure_pa': float(round(self.p_ind)),
                'flow.indicated_sample_m3_s': self._flow() if self.powered else 0.0, 'inlet.composition': dict(self.comp), 'inlet.pressure_pa': self.p_in,
                'inlet.temperature_k': self.T_in, 'chamber.no_mol_mol': self.ch_true[0], 'chamber.nox_mol_mol': self.ch_true[1],
                'line.condensed_water_fraction': self._arrived['cond'], 'inlet.label': self.label,
                'converter.partial_assumption_applied': bool(self._arrived.get('partial') and self.plant['partial_conversion_fraction'] is None), 'display.no_mol_mol': no, 'display.no2_mol_mol': no2, 'display.nox_mol_mol': nox}

    def read(self, visibility='agent'):
        return copy.deepcopy({k: v for k, v in self._values().items() if SLOTS[k][3] == 'agent' or visibility in ('evaluator', 'debug')})

    # -------------------------------------------------------------------------------------------------------------- protocol
    def register_principal(self, principal_id, visibility='agent'):
        if visibility not in ('agent', 'evaluator', 'debug'):
            raise ActionRejected('INVALID_ARGUMENT')
        if principal_id in self._principals:
            raise ActionRejected('REQUEST_CONFLICT')
        self._principals[principal_id] = visibility

    def session(self, principal_id='__public_agent__'):
        if principal_id not in self._principals:
            raise ActionRejected('ACCESS_DENIED')
        return EcoNcld822Session(self, principal_id)

    def describe(self):
        return self.session().describe(instance_id=self.instance_id)

    def debug_snapshot(self):
        return copy.deepcopy(dict(state=self.read('evaluator'), queue=list(self.queue), ch=self.ch, y=self.y, noise=self.noise, series=self.series,
                                  wall=self.wall, cal=(self.cal_phase, self.cal_op, self._cal_t, self._cal_sum),
                                  records_used=self._arrived['used'], kinetics_clamped=self._arrived.get('kinetics_clamped')))

    def _measure(self, max_points=60):
        no, no2, nox = self._display()
        flags = self._flags()
        quality = 'off' if not self.powered else ('valid' if not flags else 'invalid')
        lib = library()
        ppm = (lambda v: None if v is None else round(v / PPM, 1))
        return dict(status=self._status(), measurement='measuring' if self.measuring else 'idle', quality=quality,
                    no_mol_mol=no, no2_mol_mol=no2, nox_mol_mol=nox, no_ppm=ppm(no), no2_ppm=ppm(no2), nox_ppm=ppm(nox),
                    range_index=self.range_index, full_scale_mol_mol=self.full_scales[self.range_index], flags=flags,
                    series=copy.deepcopy(self.series[-max_points:] if max_points else []), template_source=TEMPLATE_REL, library_sha256=lib['sha256'],
                    template_records=MODEL_RECORDS, evidence='simulated_from_cited_response_parameters')

    def invoke(self, capability, **a):
        if capability in UNSUPPORTED:
            raise ActionRejected('UNSUPPORTED_OPTION')
        if capability not in CAPS:
            raise ActionRejected('UNKNOWN_CAPABILITY')
        validate(CAPS[capability][0], a)
        if capability == 'nox.measure':
            return self._measure(a.get('max_points', 60))
        if capability in ('range.configure', 'calibration.configure', 'plant.configure') and self.cal_phase != 'idle':
            raise ActionRejected('BUSY')
        if capability == 'power.set' or capability == 'power.toggle':
            on = a['enabled'] if capability == 'power.set' else not self.powered
            self.powered = on
            if not on:
                self.measuring = False
                if self.cal_phase != 'idle':
                    self.cal_phase, self.cal_last = 'idle', dict(operation_id=self.cal_op, status='cancelled')
            result = {'enabled': on}
        elif capability == 'range.configure':
            fs = [float(v) for v in a['full_scales_mol_mol']]
            if any(b <= c for c, b in zip(fs, fs[1:])):
                raise ActionRejected('INVALID_ARGUMENT')
            self.full_scales = fs
            result = {'full_scales_mol_mol': list(fs)}
        elif capability == 'range.select':
            self.range_index = a['index']
            result = {'index': a['index']}
        elif capability == 'filter.set':
            self.filter_tau = float(a['time_constant_s'])
            result = {'time_constant_s': self.filter_tau}
        elif capability in ('measurement.start', 'measurement.stop', 'measurement.toggle'):
            start = capability == 'measurement.start' or (capability == 'measurement.toggle' and not self.measuring)
            if start:
                if not self._ready():
                    raise ActionRejected('PRECONDITION_FAILED')
                if not self.measuring:
                    self.measuring, self.series, self._next_sample_t = True, [], self.time_s
                    self._record()
            else:
                self.measuring = False
            result = {'phase': 'measuring' if self.measuring else 'idle'}
        elif capability == 'calibration.configure':
            self.span_no, self.span_nox, self.cal_window = float(a['span_no_mol_mol']), float(a['span_nox_mol_mol']), float(a['window_s'])
            result = dict(span_no_mol_mol=self.span_no, span_nox_mol_mol=self.span_nox, window_s=self.cal_window)
        elif capability in ('calibration.zero', 'calibration.span'):
            if self.cal_phase != 'idle':
                raise ActionRejected('BUSY')
            if not self._ready():
                raise ActionRejected('PRECONDITION_FAILED')
            self._operation_count += 1
            kind = 'zeroing' if capability == 'calibration.zero' else 'spanning'
            self.cal_phase, self.cal_op = kind, f'{self.instance_id}:{kind}:{self._operation_count}'
            self._cal_t, self._cal_sum = 0.0, [0.0, 0.0]
            result = {'phase': kind, 'operation_id': self.cal_op}
        elif capability == 'calibration.cancel':
            if self.cal_phase != 'idle':
                self.cal_phase, self.cal_last = 'idle', dict(operation_id=self.cal_op, status='cancelled')
            result = {'phase': self.cal_phase}
        elif capability in ('inlet.connect_standard', 'inlet.disconnect', 'inlet.connect'):
            if capability == 'inlet.connect_standard':
                sid = a['standard_id']
                if sid in STANDARD_EXTRA:
                    comp = _clean_composition(STANDARD_EXTRA[sid])
                else:
                    sp, xt = cylinder_truth(self.instance_id, sid)
                    comp = _clean_composition({sp: xt, 'nitrogen': 1.0 - xt})
                p, T, src = P_REF, self.plant['ambient_temperature_k'], 'standard:' + sid
            elif capability == 'inlet.disconnect':
                comp, p, T, src = self._ambient_air(), self.plant['ambient_pressure_pa'], self.plant['ambient_temperature_k'], 'ambient_air'
            else:
                if not a['label'] or len(a['label']) > 64:
                    raise ActionRejected('INVALID_ARGUMENT')
                comp, p, T, src = _clean_composition(a['composition']), float(a['pressure_pa']), float(a['temperature_k']), 'sample'
                self.label = a['label']
            if capability != 'inlet.connect':
                self.label = None
            self.comp, self.p_in, self.T_in, self.source = comp, p, T, src
            self._arrived = self._transport(comp)
            self._enqueue()
            if capability == 'inlet.connect_standard':
                if a['standard_id'] in STANDARD_EXTRA:
                    cert = dict(certificate_mole_fraction=None, expanded_uncertainty_U95=None, value_kind='built_in_zero_gas', certificate_validity=None,
                                certificate_expired=False)
                else:
                    sp, x, u, kind = certificates()[a['standard_id']]
                    validity = certificate_validity(a['standard_id'])
                    cert = dict(certificate_mole_fraction=x, expanded_uncertainty_U95=u, value_kind=kind, certificate_validity=validity,
                                certificate_expired=bool(validity and 'expired' in validity))
                result = dict(standard_id=a['standard_id'], source=src, **cert)
            else:
                result = {'source': src}
        elif capability == 'plant.configure':
            new = dict(self.plant)
            new.update(a)
            if new['line_length_m'] > 0 and new['line_material'] not in ('ptfe', 'stainless'):
                raise ActionRejected('INVALID_ARGUMENT')
            self.plant = new
            if self.source == 'ambient_air':
                self.comp, self.p_in, self.T_in = self._ambient_air(), new['ambient_pressure_pa'], new['ambient_temperature_k']
            self._cache.clear()
            if 'seed' in a:                                                  # re-seed only when a seed is given
                self._rng = random.Random(f'{self.instance_id}:{new["seed"]}')
            self._arrived = self._transport(self.comp)
            self._enqueue()
            result = {'configured': True}
        self.revision += 1
        self._last_event = self.time_s
        return copy.deepcopy(result)

    def _enqueue(self):
        self.queue.append((self.time_s + self._residence(), self._arrived))

    def _record(self):
        no, no2, nox = self._display()
        self.series.append(dict(time_s=self.time_s, no_mol_mol=no, no2_mol_mol=no2, nox_mol_mol=nox))
        if len(self.series) > SERIES_MAX:
            del self.series[0]

    # -------------------------------------------------------------------------------------------------------------- physics
    def step(self, dt_s):
        if isinstance(dt_s, bool) or not isinstance(dt_s, (int, float)) or not math.isfinite(dt_s) or dt_s <= 0:
            raise ValueError('dt_s must be finite and positive')
        left = float(dt_s)
        while left > 1e-12:
            quiet = self.time_s - self._last_event > 30.0                    # all first-order updates are exact for any h; only the
            h = min(left, 0.5 if quiet else 0.05)                            # arrival of the delayed gas needs fine steps after a change
            self._advance(h)
            left -= h
        self.revision += 1
        return self.read('evaluator')

    def _advance(self, h):
        t1 = self.time_s + h
        amb = self.plant['ambient_temperature_k']
        tc, tp = (T_CONV_SET, T_PMT_SET) if self.powered else (amb, amb)
        self.t_conv = tc + (self.t_conv - tc) * math.exp(-h / TAU_CONV_S)
        self.t_pmt = tp + (self.t_pmt - tp) * math.exp(-h / TAU_PMT_S)
        o3t = 1.0 if self.powered else 0.0
        self.o3_frac = o3t + (self.o3_frac - o3t) * math.exp(-h / TAU_O3_S)
        # inlet pressure sensor (compensation input); option r regulates the chamber feed, so no transient error
        self.p_ind = self.p_in + (self.p_ind - self.p_in) * math.exp(-h / TAU_P_SENSOR_S)
        # delayed arrival at the chambers, then the external-line wall memory (NASA TM X-3229 rise / decay times per wetted area) on the
        # NO-derived and NO2-derived parts of each channel (linear filters commute with the plug-flow delay; species without wall data pass)
        while len(self.queue) > 1 and self.queue[1][0] <= t1:
            self.queue.popleft()
        arr = self.queue[0][1] if self.queue and self.queue[0][0] <= t1 else None
        area = math.pi * self.plant['line_inner_diameter_m'] * self.plant['line_length_m']
        raw = dict(no_ch=0.0, no=0.0, no2=0.0, other=0.0) if arr is None else dict(no_ch=arr['no'], **arr['nox_parts'])
        for key, sid in (('no_ch', 'nitric_oxide'), ('no', 'nitric_oxide'), ('no2', 'nitrogen_dioxide')):
            tr, td = adsorption_tau(sid, self.plant['line_material'], area)
            tau = tr if raw[key] > self.wall[key] else td
            self.wall[key] = raw[key] if tau <= 0 else raw[key] + (self.wall[key] - raw[key]) * math.exp(-h / tau)
        truth = [self.wall['no_ch'], self.wall['no'] + self.wall['no2'] + raw['other']]
        if arr is not None:
            p_comp = 1.0 if self.plant['pressure_regulation_installed'] else (self.p_in / max(self.p_ind, 1.0))
            target = [v * arr['quench'] * self.o3_frac * p_comp for v in truth]
        else:
            target = [0.0, 0.0]
        a_mix = 1.0 - math.exp(-h / TAU_MIX_S)
        for c in (0, 1):
            self.ch[c] += (target[c] - self.ch[c]) * a_mix
            self.ch_true[c] += (truth[c] - self.ch_true[c]) * a_mix
        # output filter and correlated zero noise (Ornstein-Uhlenbeck with the filter's correlation time)
        tau_f = self.filter_tau
        a_f = 1.0 if tau_f <= 0 else 1.0 - math.exp(-h / tau_f)
        tau_n = max(tau_f, 0.1)
        sig = NOISE0 * math.sqrt(FILTER_REF_S / tau_n) if (self.plant['noise_enabled'] and self.powered) else 0.0
        rho = math.exp(-h / tau_n)
        for c in (0, 1):
            self.y[c] += (self.ch[c] - self.y[c]) * a_f
            self.noise[c] = self.noise[c] * rho + sig * math.sqrt(max(0.0, 1.0 - rho * rho)) * self._rng.gauss(0.0, 1.0)
        self.time_s = t1
        # calibration averaging
        if self.cal_phase != 'idle' and self.powered:
            for c in (0, 1):
                self._cal_sum[c] += (self.y[c] + self.noise[c]) * h
            self._cal_t += h
            if self._cal_t >= self.cal_window - 1e-9:
                m = [s / self._cal_t for s in self._cal_sum]
                if self.cal_phase == 'zeroing':
                    self.zero_no, self.zero_nox = m
                    self.cal_last = dict(operation_id=self.cal_op, status='succeeded', kind='zero', mean_raw=m)
                else:
                    resp = [m[0] - self.zero_no, m[1] - self.zero_nox]
                    if resp[0] < 0.2 * self.span_no or resp[1] < 0.2 * self.span_nox:
                        self.cal_last = dict(operation_id=self.cal_op, status='failed', kind='span', reason='SPAN_RESPONSE_TOO_LOW')
                    else:
                        self.gain_no, self.gain_nox = self.span_no / resp[0], self.span_nox / resp[1]
                        self.cal_last = dict(operation_id=self.cal_op, status='succeeded', kind='span', mean_raw=m)
                self.cal_phase = 'idle'
        if self.measuring:
            while self._next_sample_t + SERIES_DT <= self.time_s + 1e-9:
                self._next_sample_t += SERIES_DT
                self._record()


class EcoNcld822Session:
    """Identity-filtered protocol facade (registered principals; public calls have no visibility override)."""

    def __init__(self, host, principal_id):
        self._host, self._principal = host, principal_id

    @property
    def _role(self):
        return self._host._principals[self._principal]

    def _target(self, i):
        if i != self._host.instance_id:
            raise ActionRejected('UNKNOWN_INSTANCE')

    def describe(self, *, instance_id=None, asset_type_id=None):
        if (instance_id is None) == (asset_type_id is None):
            raise ActionRejected('INVALID_ARGUMENT')
        if instance_id is not None:
            self._target(instance_id)
        if asset_type_id is not None and asset_type_id != ASSET_TYPE_ID:
            raise ActionRejected('UNKNOWN_INSTANCE')
        meta = export_eco_ncld822_contract_metadata()
        return dict(protocol_version=PROTOCOL_VERSION, asset_type_id=ASSET_TYPE_ID, asset_version='1.0.0',
                    capabilities={k: v for k, v in meta['capabilities'].items() if v['visibility'] == 'agent' or self._role != 'agent'},
                    state_slots={k: v for k, v in meta['state_slots'].items() if v['visibility'] == 'agent' or self._role != 'agent'})

    def read(self, *, instance_id, state_ids=None):
        self._target(instance_id)
        h = self._host
        vals = h.read(self._role)
        ids = list(vals) if state_ids is None else state_ids
        if not isinstance(ids, list) or any(not isinstance(k, str) for k in ids):
            raise ActionRejected('INVALID_ARGUMENT')
        if any(k not in vals for k in ids):
            raise ActionRejected('ACCESS_DENIED')
        quality = {'derived': 'estimated', 'setpoint': 'valid', 'process_truth': 'valid'}
        return dict(status='succeeded', instance_id=instance_id, state_revision=h.revision, clock={'domain': 'simulation', 'time_s': h.time_s},
                    observations={k: dict(value=copy.deepcopy(vals[k]), unit=SLOTS[k][1], quality=quality.get(SLOTS[k][2], 'valid'),
                                          sample_time_s=h.time_s, sample_window_s=None) for k in ids})

    def invoke(self, *, instance_id, capability_id, arguments, request_id):
        try:
            return self._invoke(instance_id=instance_id, capability_id=capability_id, arguments=arguments, request_id=request_id)
        except ActionRejected as exc:
            return dict(protocol_version=PROTOCOL_VERSION, instance_id=instance_id, request_id=request_id, operation_id=None, status='rejected',
                        state_revision=self._host.revision, clock={'domain': 'simulation', 'time_s': self._host.time_s}, result={}, observations={},
                        error=dict(code=str(exc), message=str(exc), retryable=False, side_effects='none'))

    def _invoke(self, *, instance_id, capability_id, arguments, request_id):
        self._target(instance_id)
        h = self._host
        if not isinstance(capability_id, str) or (capability_id not in CAPS and capability_id not in UNSUPPORTED):
            raise ActionRejected('UNKNOWN_CAPABILITY')
        if capability_id in UNSUPPORTED:
            raise ActionRejected('UNSUPPORTED_OPTION')
        if self._role == 'agent' and CAPS[capability_id][5] != 'agent':
            raise ActionRejected('ACCESS_DENIED')
        if not isinstance(request_id, str) or not request_id:
            raise ActionRejected('INVALID_ARGUMENT')
        validate(CAPS[capability_id][0], arguments)
        key = (self._principal, instance_id, request_id)
        digest = json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False)
        if key in h._requests:
            old, result = h._requests[key]
            if old != digest:
                raise ActionRejected('REQUEST_CONFLICT')
            return copy.deepcopy(result)
        result = h.invoke(capability_id, **arguments)
        op = result.get('operation_id') if isinstance(result, dict) else None
        if op:
            h._owners[op] = self._principal
        response = dict(protocol_version=PROTOCOL_VERSION, instance_id=instance_id, request_id=request_id, operation_id=op,
                        status='accepted' if op else 'succeeded', state_revision=h.revision, clock={'domain': 'simulation', 'time_s': h.time_s},
                        result=result, observations={}, error=None)
        h._requests[key] = (digest, copy.deepcopy(response))
        return response

    def write(self, *, instance_id, state_id, value, request_id):
        self._target(instance_id)
        if state_id not in SLOTS or not SLOTS[state_id][5]:
            raise ActionRejected('ACCESS_DENIED')
        cap, arg = SLOTS[state_id][5]
        return self.invoke(instance_id=instance_id, capability_id=cap, arguments={arg: value}, request_id=request_id)

    def poll(self, operation_id):
        h = self._host
        if h._owners.get(operation_id) != self._principal:
            raise ActionRejected('ACCESS_DENIED')
        if operation_id == h.cal_op and h.cal_phase != 'idle':
            return dict(operation_id=operation_id, status='running', result=dict(phase=h.cal_phase, elapsed_s=h._cal_t))
        last = h.cal_last if (h.cal_last and h.cal_last.get('operation_id') == operation_id) else None
        if last is None:
            raise ActionRejected('ACCESS_DENIED')
        return dict(operation_id=operation_id, status=last['status'], result=copy.deepcopy(last))

    def cancel(self, operation_id, request_id):
        self.poll(operation_id)
        r = self.invoke(instance_id=self._host.instance_id, capability_id='calibration.cancel', arguments={}, request_id=request_id)
        return dict(operation_id=operation_id, status=self.poll(operation_id)['status'], result=r['result'])


# ------------------------------------------------------------------------------------------------------------------- contract metadata
def _p(value, unit, meaning, evidence='assumption', sources=('simulation_assumption',), uncertainty=None):
    return dict(value=value, unit=unit, meaning_zh=meaning, evidence=evidence, source_ids=list(sources), uncertainty=uncertainty)


def export_eco_ncld822_contract_metadata():
    caps, slots = {}, {}
    for key, (schema, unit, origin, visibility, components, write, meaning) in SLOTS.items():
        slots[key] = dict(component_ids=components, value_schema=copy.deepcopy(schema), unit=unit, reference_conditions=REFERENCE_ZH.get(key),
                          meaning_zh=meaning, origin=origin, visibility=visibility, access='read_write' if write else 'read_only',
                          read_binding=dict(backend='host', artifact_id='runtime', accessor=f'EcoNcld822Session.read(state_ids=[{key!r}])'),
                          write_via=dict(capability_id=write[0], argument=write[1], fixed_arguments={}) if write else None,
                          sampling=dict(mode='instant', time_domain='simulation', window_description=None),
                          source_ids=['manufacturer_primary', 'simulation_assumption'] if origin != 'process_truth' else ['simulation_assumption'])
    conditions = {
        'measurement.start': ('预热完成（转换器、冷却PMT到位）', ['status.phase'], 'status.phase == ready'),
        'measurement.toggle': ('开始时要求预热完成；停止无前提', ['status.phase', 'measurement.phase'], 'measuring or status.phase == ready'),
        'calibration.zero': ('预热完成且无校准在进行；入口应接零气（运行层不检查气体身份）', ['status.phase', 'calibration.phase'], 'ready and calibration.phase == idle'),
        'calibration.span': ('预热完成且无校准在进行；窗口平均响应须≥0.2×设定跨度，否则失败且不改增益', ['status.phase', 'calibration.phase'],
                             'ready and calibration.phase == idle'),
        'range.configure': ('四值升序且在5–5000 ppm；校准中锁定', ['calibration.phase'], 'strictly ascending and calibration.phase == idle'),
        'calibration.configure': ('校准中锁定', ['calibration.phase'], 'calibration.phase == idle'),
        'plant.configure': ('校准中锁定', ['calibration.phase'], 'calibration.phase == idle'),
        'inlet.connect': ('组成键须为模板库/基质已知物种，总和≤1（余量补N2）', [], 'known species and sum <= 1'),
    }
    for key, (inp, out, components, meaning, kind, vis, example, effects) in CAPS.items():
        async_ = key in ('calibration.zero', 'calibration.span')
        pre = []
        if key in conditions:
            d, states, check = conditions[key]
            pre = [dict(description_zh=d, state_ids=states, enforced_by='runtime', check=check)]
        src = ['manufacturer_primary', 'simulation_assumption']
        if key in ('nox.measure', 'inlet.connect', 'inlet.connect_standard', 'calibration.span'):
            src += ['template_library']
        caps[key] = dict(function_zh=meaning, kind=kind, visibility=vis, component_ids=components, availability='implemented',
                         input_schema=copy.deepcopy(inp), output_schema=copy.deepcopy(out),
                         implementation=dict(process='implemented', scene='absent', robot='absent', hardware='absent', host='implemented'),
                         binding=dict(backend='host', artifact_id='runtime', entrypoint='asset_runtime.eco_ncld822.EcoNcld822Session.invoke',
                                      invocation=f'session.invoke(instance_id="ncld822_01", capability_id={key!r}, arguments={example!r}, request_id="unique")'),
                         preconditions=pre, state_effects=[dict(state_id=k, timing='on_completion' if async_ else 'immediate', description_zh=meaning)
                                                           for k in effects],
                         observes=[], model_effects=dict(mode='none', description_zh='过程能力；屏幕读数与按键联动由Matterix桥接另行验证。', binding_ids=[]),
                         execution=dict(mode='asynchronous' if async_ else 'synchronous', time_domain='simulation',
                                        completion_criterion='calibration.phase回到idle；poll给出succeeded/failed/cancelled' if async_ else
                                        '设定写入或观测返回；不推进物理时钟',
                                        completion_state_ids=['calibration.phase'] if async_ else effects, timeout_s=None,
                                        cancellation='supported' if async_ else 'unsupported', retry='same_request_id',
                                        resources=['target_instance', 'principal_request_cache'],
                                        partial_failure_zh='拒绝不改状态；取消/断电保留原校准系数；去重只在当前进程内存有效。'),
                         errors=[dict(code=e, meaning_zh=e, side_effects='none') for e in
                                 ['UNKNOWN_INSTANCE', 'UNKNOWN_CAPABILITY', 'ACCESS_DENIED', 'INVALID_ARGUMENT', 'PRECONDITION_FAILED', 'BUSY',
                                  'REQUEST_CONFLICT']],
                         example_arguments=copy.deepcopy(example), verification=[],
                         limitations=['工程过程模型，无真实硬件连接；进程内身份过滤不能替代部署隔离。'], source_ids=src)
    for key, (meaning, components) in UNSUPPORTED.items():
        caps[key] = dict(function_zh=meaning, kind='device_command', visibility='agent', component_ids=components, availability='unsupported',
                         input_schema=obj({}), output_schema=obj({}),
                         implementation=dict(process='absent', scene='absent', robot='absent', hardware='absent', host='absent'),
                         binding=None, preconditions=[], state_effects=[], observes=[],
                         model_effects=dict(mode='none', description_zh='未实现', binding_ids=[]),
                         execution=dict(mode='synchronous', time_domain='simulation', completion_criterion='始终返回UNSUPPORTED_OPTION', completion_state_ids=[],
                                        timeout_s=None, cancellation='unsupported', retry='never_automatic', resources=[], partial_failure_zh='无副作用'),
                         errors=[dict(code='UNSUPPORTED_OPTION', meaning_zh='选件或接口未实现', side_effects='none')], example_arguments={},
                         verification=[], limitations=[meaning], source_ids=['manufacturer_primary'])
    lib = 'template_library'
    mechanisms = {
        'chemiluminescence_detection': dict(
            component_ids=['detector_block', 'ozone_generator', 'converter', 'display_digits'],
            state_ids=['chamber.no_mol_mol', 'chamber.nox_mol_mol', 'display.no_mol_mol', 'display.no2_mol_mol', 'display.nox_mol_mol'],
            meaning_zh='双反应室：NO通道直接、NOx通道经金属转换器；NO+O3化学发光信号按第三体猝灭校正前的比例给出，读数=增益×(滤波信号+噪声−零点)，NO2=NOx−NO',
            implementation='lumped',
            equations=['S_c = x_c,eq * Q_f * O3_frac * p_in / p_ind (option r: p_in / p_ind = 1)', 'Q_f = 1 / (1 + sum_i a_i x_i)',
                       'a_CO2 = 0.60, a_H2O = 2.1, a_O2 = 0 (measured interference factors); a_M = phi (q_M / q_N2 - 1) for Ar, H2, N2O, NO2 (phi host assumption, default 0)',
                       'x_NOx,eq = x_NO + eta_NO2 * x_NO2 + sum_j f_class(j) * nu_j * x_j; f: efficient 1, not_efficient 0, partial host assumption',
                       'x_NOx,eq *= 1 + bias_O2(x_O2) (stainless 800 C table)',
                       'reading_c = gain_c * (y_c + n_c - z_c); y: first-order filter tau_f; n: OU noise sigma = 0.06 ppm * sqrt(1 s / max(tau_f, 0.1 s))'],
            parameters={'noise_zero_1sigma': _p(NOISE0, 'mol/mol', '零点噪声1σ（厂家0.06 ppm，依滤波设定）', 'documented', ['manufacturer_primary']),
                        'min_detectable': _p(0.12 * PPM, 'mol/mol', '最低可检浓度（厂家0.12 ppm=2σ，依滤波设定）', 'documented', ['manufacturer_primary']),
                        'noise_reference_filter_s': _p(FILTER_REF_S, 's', '厂家噪声值对应的滤波时间常数（厂家未给，假设1 s）'),
                        'full_scale_limits': _p([FS_MIN, FS_MAX], 'mol/mol', '四个满量程可选5–5000 ppm', 'documented', ['manufacturer_primary']),
                        'display_resolution': _p(DIGITS, 'mol/mol', 'GUI一位小数ppm（手册截图）', 'documented', ['manufacturer_primary']),
                        'quench_co2': _p(0.60, '1', 'CO2干扰因子 −0.60 %/%（NASA TM X-3229）', 'documented', [lib]),
                        'quench_h2o': _p(2.1, '1', 'H2O干扰因子 −2.1 %/%（NASA TM X-3229）', 'documented', [lib]),
                        'converter_no2_efficiency_default': _p(1.0, '1', 'NO2转换效率缺省1.0（Dunlea 2007 “efficiently reduce”类别映射；宿主可改）'),
                        'partial_conversion_default': _p(0.5, '1', '“部分还原”类（HONO、NH3、PAN、HO2NO2、颗粒硝酸盐）缺省0.5为显式假设，无文献数值；宿主可改'),
                        'quench_relative_scale_default': _p(0.0, '1', '相对猝灭效率的换算系数φ（样气占反应室第三体的份额）缺省0：同一来源实测O2干扰≈0与φ=1矛盾；宿主可设'),
                        'converter_temperature_set': _p(T_CONV_SET, 'K', '金属转换器设定温度（厂家未给，假设375 °C）'),
                        'pmt_temperature_set': _p(T_PMT_SET, 'K', '冷却PMT设定温度（厂家未给，假设−5 °C）')},
            source_ids=['manufacturer_primary', lib, 'simulation_assumption'],
            limitations=['Ar/H2/N2O/NO2的猝灭只在宿主给定φ>0时生效（缺省只用CO2、H2O、O2实测干扰因子）；转换器材料与温度未公开，借用钼转换器分类与不锈钢转换器氧效应表；无PMT增益漂移与故障概率。']),
        'sample_transport': dict(
            component_ids=['sample_inlet', 'inlet_filter', 'flow_restrictors', 'vacuum_pump'],
            state_ids=['inlet.composition', 'inlet.pressure_pa', 'flow.indicated_sample_m3_s', 'line.condensed_water_fraction', 'chamber.no_mol_mol'],
            meaning_zh='入口→（外部样气管）→过滤与限流→两反应室：临界限流流量∝入口绝压；内部滞后2.0 s、混合τ0.35 s；样气管壁吸附记忆（NO、NO2，作为延迟之后的一阶滤波，按通道中NO与NO2来源部分分别取上升/衰减时间）；未加热路径冷凝的亨利定律洗除；停留时间内的暗反应（IUPAC 53–64，N原子守恒，温度夹在各反应评估范围内）；标准气瓶真值=证书值±U95/2的确定性偏离',
            implementation='lumped',
            equations=['Q = 1.0 L/min * p_in / 101325 Pa', 't_res = 2.0 s * Q_nom / Q + V_line * (p_in / p_ref) / Q',
                       'tau_wall = (t/A)_record * A_wetted / ln(1000) (rise for increasing, decay for decreasing), applied after the delay to the NO- and NO2-derived channel parts',
                       'x_cond = (x_w - p_sat(T_path)/p) / (1 - p_sat/p); f_i = 1 / (1 + Hscp_i(T) R T V_l / V_g)',
                       'dn/dt = S r(n), r from IUPAC rows 53-64 (Troe falloff with [M] = p / kT), backward Euler + Newton'],
            parameters={'sample_flow_nominal': _p(Q_NOM, 'm^3/s', '样气流量1.0 l/min（厂家；参考状态假设101325 Pa/298.15 K）', 'documented', ['manufacturer_primary']),
                        'inlet_pressure_range': _p([P_MIN, P_MAX], 'Pa', '进口绝压600–1200 mbar（厂家）', 'documented', ['manufacturer_primary']),
                        'lag_time_bound': _p(3.0, 's', '厂家滞后<3 s（上界）', 'documented', ['manufacturer_primary']),
                        'rise_time_bound': _p(1.0, 's', '厂家0–90%上升<1 s（上界）', 'documented', ['manufacturer_primary']),
                        'internal_lag': _p(LAG_INT_S, 's', '内部传输滞后（假设，满足<3 s）'),
                        'mixing_tau': _p(TAU_MIX_S, 's', '混合时间常数（假设；无滤波时0–90% 0.81 s）'),
                        'hot_tubing_temperature': _p(T_HOT_S, 'K', 'h选件加热管路温度（厂家未给，假设180 °C）')},
            source_ids=['manufacturer_primary', lib, 'simulation_assumption'],
            limitations=['单级平衡冷凝洗除（真实管路有累积冷凝液与传质限制）；管壁记忆只对NO、NO2有数据；外部样气管由宿主配置。']),
        'warmup': dict(
            component_ids=['converter', 'detector_block', 'ozone_generator'], state_ids=['converter.temperature_k', 'pmt.temperature_k', 'ozone.generator_fraction',
                                                                                          'status.phase'],
            meaning_zh='上电后转换器、冷却PMT、臭氧发生器一阶趋近设定（时间常数为假设）；转换器±10 K、PMT±1 K内为ready',
            implementation='lumped', equations=['T_next = T_set + (T - T_set) exp(-dt/tau)', 'O3_next = 1 + (O3 - 1) exp(-dt/20 s)'],
            parameters={'converter_tau': _p(TAU_CONV_S, 's', '转换器预热时间常数（假设）'), 'pmt_tau': _p(TAU_PMT_S, 's', 'PMT冷却时间常数（假设）'),
                        'ozone_tau': _p(TAU_O3_S, 's', '臭氧发生器响应（假设）')},
            source_ids=['simulation_assumption'], limitations=['厂家未给预热时间；温度不对外显示。']),
    }
    _ann.annotate_export('eco_ncld822', caps, slots, mechanisms, inputs={'plant.configure': (PLANT, PLANT_EXAMPLE), 'inlet.connect': (INLET, INLET_EXAMPLE)})
    return dict(asset_type_id=ASSET_TYPE_ID, catalog_id=CATALOG_ID, capabilities=caps, state_slots=slots, mechanisms=mechanisms)