scripts/basic40_templates/hach_dr6000.py

"""Template-backed UV-Vis path for the Hach DR6000 runtime (CHEM-071).

Three public-data template families, addressed by one ``template_id`` namespace:
  * ``<spectral_library id>``  NIST UV/Vis curves (``spectral_library/uv_vis.json``; log10 epsilon vs wavelength,
                               31 compounds) -> Beer-Lambert spectrum A = epsilon c l.
  * ``pcad_NNN``               PhotochemCAD 2.1a molar absorption spectra reused read-only from
                               ``jasco_fp8350_fluorescence_library/templates.json`` (90 dyes/aromatics; source licence
                               not confirmed for redistribution, see that library's 说明.md) -> Beer-Lambert spectrum.
  * ``hach_prog_NNN``          Hach DR6000 stored-program method records (``hach_dr6000_colorimetric_library``):
                               program wavelength, range and the published "Sensitivity" (concentration change per
                               0.010 Abs) -> single-wavelength absorbance of a developed (reagent-reacted) sample.
A trusted host registers the cuvette contents; the agent uses the normal lid/load/scan/measure workflow.
"""
from __future__ import annotations

import json
import math
from functools import lru_cache
from typing import Any

from scripts.basic40_templates import _analytical_common as common
from scripts.template_library import index_by_id

UV_REL = common.UV_REL
PCAD_REL = "assets/reactions/jasco_fp8350_fluorescence_library/templates.json"
HACH_REL = "assets/reactions/hach_dr6000_colorimetric_library/templates.json"
WAVELENGTH_MIN_M = 190e-9
WAVELENGTH_MAX_M = 1100e-9
WAVELENGTH_TOLERANCE_M = 1e-9          # DR6000 catalog wavelength accuracy (200..900 nm)
PHOTOMETRIC_LIMIT = 3.0                # DR6000 catalog photometric range +/-3 Abs (200..900 nm)
DEFAULT_PATH_LENGTH_M = 0.01
MAX_CONCENTRATION_MOL_M3 = 1000.0

LIMITATIONS_SPECTRUM = [
    "NIST UV/Vis curves are digitized literature spectra (INEP CP RAS UV atlas via NIST); solvent/state is not recorded in the JCAMP header. PhotochemCAD spectra are for the named source solvent only; source temperatures are often unknown.",
    "Beer-Lambert A = epsilon c l with no stray light, bandwidth convolution (2 nm slit), wavelength error, noise, scattering, fluorescence or concentration-dependent deviations; points above |A| = 3 are reported but flagged as over the catalog photometric range.",
    "Output is restricted to the part of the scan grid covered by the reference curve; no extrapolation outside it.",
    "Cuvette path length is a trusted-host declaration (DR6000 path length is unknown in the catalog; default 10 mm assumption).",
    "PhotochemCAD data (pcad_*) are reused from the FP-8350 library: original authors' copyright, redistribution licence not confirmed.",
]
LIMITATIONS_METHOD = [
    "Hach method absorbance is reconstructed from the method document's published Sensitivity (concentration change per 0.010 Abs) as a straight line through the origin; the real stored program calibration, curve non-linearity, reagent blank, interferences, reaction timing and temperature are not modelled.",
    "Only the program wavelength (+/- 1 nm) has a defined absorbance; the full spectrum of the developed colour is unknown, so scans over other wavelengths are rejected.",
    "Sample cell is the one stated in the Hach document; the DR6000 cuvette geometry of this asset is not used for these records.",
    "Hach method documents are cited for numbers and conditions only (Hach copyright); no Hach text or figures are reproduced.",
]


@lru_cache(maxsize=None)
def _uv() -> dict[str, Any]:
    return common.load_json(UV_REL)["compounds"]


def _pcad() -> dict[str, dict[str, Any]]:
    return index_by_id(PCAD_REL)


def _hach() -> dict[str, dict[str, Any]]:
    try:
        return index_by_id(HACH_REL)
    except FileNotFoundError:
        return {}


def kind_of(template_id: Any) -> str | None:
    if not isinstance(template_id, str) or not template_id:
        return None
    if template_id in _hach():
        return "hach_method"
    if template_id in _pcad():
        return "photochemcad_spectrum"
    sid = common.resolve_compound_id(template_id)
    if sid is not None and common.uv_curve(sid) is not None:
        return "nist_uv_spectrum"
    return None


def _curve(template_id: str) -> dict[str, Any]:
    kind = kind_of(template_id)
    if kind == "nist_uv_spectrum":
        curve = common.uv_curve(common.resolve_compound_id(template_id))
        return {"wavelength_m": curve["wavelength_m"], "epsilon_m2_mol": curve["epsilon_m2_mol"], "source": curve["source"],
                "evidence": curve["evidence"], "conditions": {"origin": curve["origin"], "solvent": None, "nist_index": curve["nist_index"]},
                "library": UV_REL}
    record = _pcad()[template_id]
    pairs = sorted(zip(record["abs_wavelength_m"], record["epsilon_m2_mol"]))
    wavelengths, eps = [], []
    for wavelength, value in pairs:
        if wavelengths and wavelength <= wavelengths[-1]:
            continue
        wavelengths.append(wavelength)
        eps.append(value)
    return {"wavelength_m": wavelengths, "epsilon_m2_mol": eps, "source": record["source"], "evidence": record["evidence"],
            "conditions": {"solvent": record["conditions"].get("solvent"), "temperature_k": record["conditions"].get("temperature_k")},
            "library": PCAD_REL}


def template_read(template_id: Any) -> dict[str, Any] | None:
    kind = kind_of(template_id)
    if kind is None:
        return None
    if kind == "hach_method":
        record = _hach()[template_id]
        keys = ("name", "cas", "analyte", "reported_as", "method_number", "program_number", "program_name", "chemistry",
                "wavelength_m", "range_kg_m3", "range_as_published", "sample_cell", "path_length_m", "sensitivity", "reaction_time_s",
                "source", "evidence")
        body = {key: record.get(key) for key in keys}
        return {"template_id": template_id, "template_kind": kind, "spectrum": None, "method": body,
                "conditions_json": json.dumps(record.get("conditions"), ensure_ascii=False),
                **common.provenance([HACH_REL], "measured_literature (Hach method document figures)", [], LIMITATIONS_METHOD)}
    curve = _curve(template_id)
    if kind == "nist_uv_spectrum":
        compound = common.compounds()[common.resolve_compound_id(template_id)]
        name, cas = compound["name_en"], compound["cas"]
    else:
        name, cas = _pcad()[template_id]["name"], None
    return {"template_id": template_id, "template_kind": kind, "method": None,
            "spectrum": {"name": name, "cas": cas, "wavelength_m": curve["wavelength_m"], "epsilon_m2_mol": curve["epsilon_m2_mol"],
                         "source": curve["source"], "evidence": curve["evidence"]},
            "conditions_json": json.dumps(curve["conditions"], ensure_ascii=False),
            **common.provenance([curve["library"]], curve["evidence"] + " molar absorption spectrum", ["host-declared path length"], LIMITATIONS_SPECTRUM)}


def validate_sample(template_id: Any, *, concentration_mol_m3: float | None = None, concentration_kg_m3: float | None = None,
                    path_length_m: float = DEFAULT_PATH_LENGTH_M) -> dict[str, Any]:
    kind = kind_of(template_id)
    if kind is None:
        raise ValueError(f"{template_id!r} is not a DR6000 template id (spectral_library UV id, pcad_*, hach_prog_*)")
    if kind == "hach_method":
        record = _hach()[template_id]
        if concentration_mol_m3 is not None or not common.finite(concentration_kg_m3) or concentration_kg_m3 < 0:
            raise ValueError("Hach method samples need concentration_kg_m3 >= 0 (analyte, in the record's reported_as form)")
        if record.get("wavelength_m") is None or not record.get("sensitivity"):
            raise ValueError(f"{template_id} has no published wavelength/sensitivity; it is reference-only")
        return {"template_id": template_id, "template_kind": kind, "library": HACH_REL, "concentration_kg_m3": float(concentration_kg_m3)}
    if concentration_kg_m3 is not None or not common.finite(concentration_mol_m3) or not 0 <= concentration_mol_m3 <= MAX_CONCENTRATION_MOL_M3:
        raise ValueError(f"spectrum samples need concentration_mol_m3 in [0, {MAX_CONCENTRATION_MOL_M3}]")
    if not common.finite(path_length_m) or not 1e-4 <= path_length_m <= 0.1:
        raise ValueError("path_length_m must be within 0.1..100 mm")
    return {"template_id": template_id, "template_kind": kind, "library": _curve(template_id)["library"],
            "concentration_mol_m3": float(concentration_mol_m3), "path_length_m": float(path_length_m), "path_length_evidence": "assumption"}


def _axis(state: dict[str, Any]) -> list[float]:
    start, stop, step = state["scan.start_m"], state["scan.stop_m"], state["scan.step_m"]
    count = int(math.floor((stop - start) / step + 1e-8)) + 1
    axis = [start + i * step for i in range(count)]
    if axis and abs(axis[-1] - stop) <= 1e-15:
        axis[-1] = stop
    return axis


def spectrum(template: dict[str, Any], state: dict[str, Any], sample_kind: str) -> dict[str, Any] | None:
    """Agent-visible spectrum; None when the scan does not meet the template's preconditions."""
    axis = _axis(state)
    mode = state["measurement.mode"]
    if template["template_kind"] == "hach_method":
        record = _hach()[template["template_id"]]
        if len(axis) != 1 or abs(axis[0] - record["wavelength_m"]) > WAVELENGTH_TOLERANCE_M:
            return None
        sens = record["sensitivity"]
        absorbance = [sens["delta_absorbance"] * template["concentration_kg_m3"] / sens["delta_concentration_kg_m3"]]
        low, high = record["range_kg_m3"]
        c = template["concentration_kg_m3"]
        status = "below_range" if c < low else ("above_range" if c > high else "within_range")
        rel = [HACH_REL]
        evidence = "Hach published sensitivity (measured_literature) -> linear absorbance (derived)"
        limitations, synthetic_parts, coverage = LIMITATIONS_METHOD, ["linear calibration through the origin"], [axis[0], axis[0]]
    else:
        curve = _curve(template["template_id"])
        points = [(x, common.interp(x, curve["wavelength_m"], curve["epsilon_m2_mol"])) for x in axis]
        points = [(x, e) for x, e in points if e is not None]
        if not points:
            return None
        axis = [x for x, _ in points]
        absorbance = [e * template["concentration_mol_m3"] * template["path_length_m"] for _, e in points]
        status = None
        rel = [curve["library"]]
        evidence = curve["evidence"] + " molar absorption curve x host concentration x path length (Beer-Lambert, derived)"
        limitations, synthetic_parts = LIMITATIONS_SPECTRUM, ["host-declared path length"]
        coverage = [curve["wavelength_m"][0], curve["wavelength_m"][-1]]
    transmittance = [10.0 ** -a for a in absorbance]
    over = sum(1 for x, a in zip(axis, absorbance) if abs(a) > PHOTOMETRIC_LIMIT)
    return {"wavelength_m": axis, "absorbance": absorbance, "transmittance": transmittance,
            "signal": absorbance[:] if mode == "absorbance" else transmittance[:], "reported_mode": mode,
            "quality": "estimated", "axis_unit": "m", "signal_unit": "1", "sample_kind": sample_kind, "measurement_duration_s": None,
            "template_kind": template["template_kind"], "requested_scan_m": [state["scan.start_m"], state["scan.stop_m"], state["scan.step_m"]],
            "template_coverage_m": coverage, "over_photometric_range_points": over, "method_range_status": status,
            **common.provenance(rel, evidence, synthetic_parts, limitations)}


def spectrum_schema() -> dict[str, Any]:
    n, obj, nullable = common.number, common.obj, common.nullable
    series = lambda unit, minimum=None: {"type": "array", "items": n(unit, minimum), "minItems": 1, "maxItems": 10001}
    return obj({"wavelength_m": series("m"), "absorbance": series("1"), "transmittance": series("1", 0), "signal": series("1"),
                "reported_mode": {"type": "string", "enum": ["absorbance", "transmittance"]},
                "quality": {"type": "string", "const": "estimated"}, "axis_unit": {"type": "string", "const": "m"},
                "signal_unit": {"type": "string", "const": "1"}, "sample_kind": {"type": "string", "enum": ["sample", "blank"]},
                "measurement_duration_s": {"type": "null"},
                "template_kind": {"type": "string", "enum": ["nist_uv_spectrum", "photochemcad_spectrum", "hach_method"]},
                "requested_scan_m": {"type": "array", "items": n("m", 0), "minItems": 3, "maxItems": 3},
                "template_coverage_m": {"type": "array", "items": n("m", 0), "minItems": 2, "maxItems": 2},
                "over_photometric_range_points": {"type": "integer", "minimum": 0, "x-unit": "1"},
                "method_range_status": nullable({"type": "string", "enum": ["below_range", "within_range", "above_range"]}),
                **common.provenance_schema()})


def template_read_schema() -> dict[str, Any]:
    n, obj, nullable = common.number, common.obj, common.nullable
    sensitivity = obj({"portion_of_curve": nullable(common.TEXT), "delta_absorbance": n("1", 0), "delta_concentration_kg_m3": n("kg/m^3", 0)})
    method = obj({"name": common.TEXT, "cas": nullable(common.TEXT), "analyte": nullable(common.TEXT), "reported_as": nullable(common.TEXT),
                  "method_number": nullable(common.TEXT), "program_number": {"type": "integer", "minimum": 1, "x-unit": "1"},
                  "program_name": nullable(common.TEXT), "chemistry": nullable(common.TEXT), "wavelength_m": nullable(n("m", 0)),
                  "range_kg_m3": {"type": "array", "items": n("kg/m^3", 0), "minItems": 2, "maxItems": 2},
                  "range_as_published": nullable(common.TEXT), "sample_cell": nullable(common.TEXT), "path_length_m": nullable(n("m", 0)),
                  "sensitivity": nullable(sensitivity), "reaction_time_s": nullable(n("s", 0)), "source": common.TEXT, "evidence": common.TEXT})
    spectrum = obj({"name": common.TEXT, "cas": nullable(common.TEXT),
                    "wavelength_m": {"type": "array", "items": n("m", 0), "minItems": 2},
                    "epsilon_m2_mol": {"type": "array", "items": n("m^2/mol"), "minItems": 2},
                    "source": common.TEXT, "evidence": common.TEXT})
    return obj({"template_id": common.TEXT, "template_kind": {"type": "string", "enum": ["nist_uv_spectrum", "photochemcad_spectrum", "hach_method"]},
                "spectrum": nullable(spectrum), "method": nullable(method), "conditions_json": common.TEXT, **common.provenance_schema()})


def extend_metadata(metadata: dict[str, Any]) -> dict[str, Any]:
    caps, slots = metadata["capabilities"], metadata["state_slots"]
    legacy = caps["spectroscopy.measure"]["output_schema"]["properties"]["spectrum"]
    caps["spectroscopy.measure"]["output_schema"]["properties"]["spectrum"] = {"anyOf": [legacy, spectrum_schema()]}
    caps["spectroscopy.measure"]["preconditions"] = caps["spectroscopy.measure"]["preconditions"] + [
        "Template-backed cuvette only: spectrum templates need at least one scan point inside the reference curve; Hach method samples need a single-wavelength scan within 1e-9 m of the program wavelength."]
    slots["measurement.spectrum"]["value_schema"] = {"anyOf": [legacy, spectrum_schema(), {"type": "null"}]}
    cap = common.template_read_capability(
        "HachDR6000", "hach_prog_490", template_read_schema(), ["display"],
        "Template id: spectral_library compound id (NIST UV curve), pcad_NNN (PhotochemCAD) or hach_prog_NNN (Hach program); does not refer to the loaded cuvette")
    cap["errors"] = ["UNKNOWN_INSTANCE", "UNKNOWN_CAPABILITY", "INVALID_ARGUMENT", "REQUEST_CONFLICT"]
    caps["template.read"] = cap
    metadata["parameters"]["template_libraries"] = {"value": [UV_REL, PCAD_REL, HACH_REL], "unit": "1", "evidence": "measured+measured_literature",
        "conditions": "NIST UV/Vis curves; PhotochemCAD molar absorption (FP-8350 library, licence unconfirmed); Hach method documents (numbers only)"}
    metadata["parameters"]["template_default_path_length_m"] = {"value": DEFAULT_PATH_LENGTH_M, "unit": "m", "evidence": "assumption",
        "conditions": "Used only when the trusted host does not declare a cuvette path for a spectrum template"}
    metadata["limits"] = metadata["limits"] + [
        "Template-backed cuvettes (host register_template_sample) return Beer-Lambert spectra from NIST/PhotochemCAD molar absorptivities or Hach-sensitivity absorbances; the synthetic Gaussian fixture path is unchanged and remains the default."]
    return metadata