"""Template-backed FTIR path for the JASCO FT/IR-4700 runtime (CHEM-072). Library (shared): ``assets/reactions/spectral_library/ir_spectra.json`` — up to four NIST WebBook IR spectra per compound, each resampled to a 400-4000 cm^-1, 4 cm^-1 grid of absorbance normalised to 1 (null outside the measured range) with state/sampling/resolution metadata. Since the 2026-10-14 decoder fix (scripts/spectral_library/jcamp.py) the shared file itself carries the corrected spectra that this asset used to overlay from ``assets/reactions/jasco_ftir4700_ir_library`` (24 records: DELTAX sign, optical-constant k block, reflectance log10(1/R)); the overlay library is retired. Corrected records are recognisable by their ``y_transform`` / ``x_step_note`` fields and are reported with ``corrected_by``. A trusted host registers a cuvette/ATR sample as one spectral_library compound id (+ phase). ``measure`` selects a reference spectrum whose physical state matches the sample (condensed phase: neat liquid > solution > solid; gas: gas/vapour), broadens it to the configured resolution (Gaussian, FWHM^2 = R_req^2 - R_src^2), resamples it on the configured range and scales the normalised band to a host-chosen peak absorbance. NIST spectra are transmission spectra (gas cell, neat film, CCl4/CS2 solution, KBr/mull); none is an ATR spectrum and no ATR penetration-depth correction is applied. """ from __future__ import annotations import copy import math import re from functools import lru_cache from typing import Any from scripts.basic40_templates import _analytical_common as common LIB_REL = common.SPECTRAL + "/ir_spectra.json" DECODER_FIX = "scripts/spectral_library/jcamp.py (2026-10-14 decoder fix; replaces the retired jasco_ftir4700_ir_library overlay)" SOURCES = [LIB_REL] GRID_START_CM = 400.0 GRID_STEP_CM = 4.0 CM_TO_M_INV = 100.0 PHASES = ("solid", "liquid", "gas") MAX_PEAK_ABSORBANCE = 3.0 INTERFEROGRAM_POINTS = 257 LIMITATIONS = [ "NIST WebBook IR spectra are transmission spectra (gas cells, neat liquid films, CCl4/CS2 solutions, KBr/mull); none is an ATR spectrum and no ATR penetration-depth, refractive-index or anomalous-dispersion correction is applied, so ATR relative band intensities will differ.", "Library absorbance is normalised to 1 at the strongest band; absolute absorbance (path length x concentration) is unknown, so the host chooses the peak absorbance (default 1.0).", "Effective resolution is max(requested, source resolution, 4 cm^-1 library grid); finer requested resolution cannot be recovered (no deconvolution).", "Gas-phase and condensed-phase spectra differ (rotational structure, hydrogen bonding); when no reference spectrum matches the sample phase the closest available one is used and phase_matched=false is reported.", "Solution spectra contain CCl4/CS2 solvent-compensated regions; no noise, water-vapour/CO2 background, baseline drift or scan-averaging model.", "Only one compound per sample; mixtures are not supported.", ] SYNTHETIC_PARTS = ["host-chosen peak absorbance scale", "Gaussian instrument line shape", "cosine-synthesized interferogram"] @lru_cache(maxsize=None) def _table() -> dict[str, Any]: """Shared spectra; records corrected by the 2026-10-14 decoder fix are tagged with corrected_by / correction.""" table = copy.deepcopy(common.load_json(LIB_REL)["compounds"]) for spectra in table.values(): for spectrum in spectra: note = spectrum.get("y_transform") or spectrum.get("x_step_note") if note: spectrum["corrected_by"] = DECODER_FIX spectrum["correction"] = note return table def state_class(spectrum: dict[str, Any]) -> str: text = (spectrum.get("state") or "").upper() if "GAS" in text or "VAPOR" in text or "VAPOUR" in text: return "gas" if "SOLUTION" in text: return "solution" if "LIQUID" in text or "NEAT" in text: return "liquid" if "SOLID" in text or "KBR" in text or "MULL" in text or "NUJOL" in text: return "solid" return "unknown" def source_resolution_cm(spectrum: dict[str, Any]) -> float: match = re.search(r"[0-9]+(?:\.[0-9]+)?", str(spectrum.get("resolution") or "")) value = float(match.group(0)) if match else GRID_STEP_CM return max(value, GRID_STEP_CM) PREFERENCE = {"liquid": ("liquid", "solution", "solid"), "solid": ("solid", "solution", "liquid"), "gas": ("gas",)} def select_spectrum(substance_id: str, phase: str) -> tuple[int, dict[str, Any], bool] | None: spectra = _table().get(substance_id) or [] if not spectra: return None for wanted in PREFERENCE[phase]: for index, spectrum in enumerate(spectra): if state_class(spectrum) == wanted: return index, spectrum, True return 0, spectra[0], False def template_read(substance_id: Any) -> dict[str, Any] | None: sid = common.resolve_compound_id(substance_id) spectra = _table().get(sid) if sid else None if not spectra: return None compound = common.compounds()[sid] listing = [] for index, spectrum in enumerate(spectra): values = spectrum["absorbance_normalized"] covered = [i for i, v in enumerate(values) if v is not None] listing.append({"index": index, "state": spectrum.get("state"), "state_class": state_class(spectrum), "sampling": spectrum.get("sampling"), "source_resolution_m_inv": source_resolution_cm(spectrum) * CM_TO_M_INV, "coverage_m_inv": [(GRID_START_CM + covered[0] * GRID_STEP_CM) * CM_TO_M_INV, (GRID_START_CM + covered[-1] * GRID_STEP_CM) * CM_TO_M_INV], "peaks_m_inv": [[p[0] * CM_TO_M_INV, p[1]] for p in spectrum.get("peaks_cm-1") or []], "evidence": spectrum.get("evidence"), "source": spectrum.get("source"), "corrected_by": spectrum.get("corrected_by")}) return {"substance_id": sid, "name": compound["name_en"], "name_zh": compound["name_zh"], "cas": compound["cas"], "spectra": listing, **common.provenance(SOURCES, "measured (NIST WebBook IR JCAMP-DX, transmission), normalised and resampled; records corrected by the 2026-10-14 decoder fix are flagged corrected_by", SYNTHETIC_PARTS, LIMITATIONS)} def validate_sample(substance_id: Any, *, phase: str, peak_absorbance: float = 1.0) -> dict[str, Any]: if phase not in PHASES: raise ValueError("phase must be solid, liquid or gas") sid = common.resolve_compound_id(substance_id) if sid is None or not _table().get(sid): raise ValueError(f"{substance_id!r} has no IR spectrum in {LIB_REL}") if not common.finite(peak_absorbance) or not 0 < peak_absorbance <= MAX_PEAK_ABSORBANCE: raise ValueError(f"peak_absorbance must be in (0, {MAX_PEAK_ABSORBANCE}]") index, spectrum, matched = select_spectrum(sid, phase) return {"library": LIB_REL, "substance_id": sid, "phase": phase, "spectrum_index": index, "phase_matched": matched, "state": spectrum.get("state"), "peak_absorbance": float(peak_absorbance)} def _broadened(values: list[float | None], extra_fwhm_cm: float) -> tuple[list[float], float, float]: covered = [i for i, v in enumerate(values) if v is not None] lo, hi = covered[0], covered[-1] data = [float(values[i]) for i in range(lo, hi + 1)] if extra_fwhm_cm > 1e-9: sigma = extra_fwhm_cm / (2 * math.sqrt(2 * math.log(2))) / GRID_STEP_CM half = max(1, int(math.ceil(4 * sigma))) kernel = [math.exp(-0.5 * (j / sigma) ** 2) for j in range(-half, half + 1)] out = [] for i in range(len(data)): num = den = 0.0 for j, weight in zip(range(i - half, i + half + 1), kernel): if 0 <= j < len(data): num += weight * data[j] den += weight out.append(num / den) data = out return data, GRID_START_CM + lo * GRID_STEP_CM, GRID_START_CM + hi * GRID_STEP_CM def spectrum(template: dict[str, Any], state: dict[str, Any]) -> dict[str, Any] | None: """Agent-visible spectrum; None when the configured range does not overlap the reference coverage.""" reference = _table()[template["substance_id"]][template["spectrum_index"]] requested_cm = state["method.resolution_m_inv"] / CM_TO_M_INV source_cm = source_resolution_cm(reference) effective_cm = max(requested_cm, source_cm) extra = math.sqrt(max(0.0, effective_cm ** 2 - source_cm ** 2)) data, first_cm, last_cm = _broadened(reference["absorbance_normalized"], extra) start_cm = max(state["method.start_wavenumber_m_inv"] / CM_TO_M_INV, first_cm) stop_cm = min(state["method.stop_wavenumber_m_inv"] / CM_TO_M_INV, last_cm) step_cm = max(GRID_STEP_CM, effective_cm / 2) if stop_cm - start_cm < step_cm: return None count = int(math.floor((stop_cm - start_cm) / step_cm + 1e-9)) + 1 grid_cm = [first_cm + i * GRID_STEP_CM for i in range(len(data))] top = max(data) or 1.0 axis, absorbance = [], [] for i in range(count): x = start_cm + i * step_cm value = common.interp(x, grid_cm, data) axis.append(x * CM_TO_M_INV) absorbance.append(max(0.0, value) / top * template["peak_absorbance"]) transmittance = [10.0 ** -a for a in absorbance] top_m = axis[-1] opd = [(index - (INTERFEROGRAM_POINTS - 1) // 2) / (2 * top_m) for index in range(INTERFEROGRAM_POINTS)] interferogram = [sum(t * math.cos(2 * math.pi * nu * path) for nu, t in zip(axis, transmittance)) / len(axis) for path in opd] return {"wavenumber_m_inv": axis, "absorbance": absorbance, "transmittance": transmittance, "interferogram": {"optical_path_difference_m": opd, "relative_intensity": interferogram, "synthetic": True, "axis_unit": "m", "signal_unit": "1"}, "reported_mode": state["method.output_mode"], "quality": "estimated", "axis_unit": "m^-1", "signal_unit": "1", "resolution_m_inv": state["method.resolution_m_inv"], "effective_resolution_m_inv": effective_cm * CM_TO_M_INV, "point_spacing_m_inv": step_cm * CM_TO_M_INV, "scan_count": state["method.scan_count"], "spectral_resolution_applied": True, "scan_averaging_applied": False, "measurement_duration_s": None, "requested_range_m_inv": [state["method.start_wavenumber_m_inv"], state["method.stop_wavenumber_m_inv"]], "coverage_m_inv": [axis[0], axis[-1]], "reference_state": template["state"], "phase_matched": template["phase_matched"], "accessory_mode": state["accessory.mode"], "atr_correction_applied": False, **common.provenance(SOURCES, "measured (NIST WebBook IR, transmission) -> normalised, broadened to the configured resolution and resampled", 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": 2, "maxItems": 901} pair = lambda unit: {"type": "array", "items": n(unit, 0), "minItems": 2, "maxItems": 2} interferogram = obj({"optical_path_difference_m": {"type": "array", "items": n("m"), "minItems": INTERFEROGRAM_POINTS, "maxItems": INTERFEROGRAM_POINTS}, "relative_intensity": {"type": "array", "items": n("1"), "minItems": INTERFEROGRAM_POINTS, "maxItems": INTERFEROGRAM_POINTS}, "synthetic": {"type": "boolean", "const": True}, "axis_unit": {"type": "string", "const": "m"}, "signal_unit": {"type": "string", "const": "1"}}) return obj({"wavenumber_m_inv": series("m^-1", 0), "absorbance": series("1", 0), "transmittance": series("1", 0), "interferogram": interferogram, "reported_mode": {"type": "string", "enum": ["absorbance", "transmittance", "interferogram"]}, "quality": {"type": "string", "const": "estimated"}, "axis_unit": {"type": "string", "const": "m^-1"}, "signal_unit": {"type": "string", "const": "1"}, "resolution_m_inv": n("m^-1", 40), "effective_resolution_m_inv": n("m^-1", 400), "point_spacing_m_inv": n("m^-1", 400), "scan_count": {"type": "integer", "minimum": 1, "maximum": 1024, "x-unit": "1"}, "spectral_resolution_applied": {"type": "boolean", "const": True}, "scan_averaging_applied": {"type": "boolean", "const": False}, "measurement_duration_s": {"type": "null"}, "requested_range_m_inv": pair("m^-1"), "coverage_m_inv": pair("m^-1"), "reference_state": nullable(common.TEXT), "phase_matched": {"type": "boolean"}, "accessory_mode": {"type": "string", "enum": ["atr", "transmission"]}, "atr_correction_applied": {"type": "boolean", "const": False}, **common.provenance_schema()}) def template_read_schema() -> dict[str, Any]: n, obj, nullable = common.number, common.obj, common.nullable item = obj({"index": {"type": "integer", "minimum": 0, "x-unit": "1"}, "state": nullable(common.TEXT), "state_class": {"type": "string", "enum": ["gas", "solution", "liquid", "solid", "unknown"]}, "sampling": nullable(common.TEXT), "source_resolution_m_inv": n("m^-1", 0), "coverage_m_inv": {"type": "array", "items": n("m^-1", 0), "minItems": 2, "maxItems": 2}, "peaks_m_inv": {"type": "array", "items": {"type": "array", "items": n("1"), "minItems": 2, "maxItems": 2}}, "evidence": common.TEXT, "source": common.TEXT, "corrected_by": nullable(common.TEXT)}) return obj({"substance_id": common.TEXT, "name": common.TEXT, "name_zh": common.TEXT, "cas": nullable(common.TEXT), "spectra": {"type": "array", "items": item, "minItems": 1}, **common.provenance_schema()}) def extend_metadata(metadata: dict[str, Any]) -> dict[str, Any]: legacy = metadata["capabilities"]["measure"]["output_schema"]["properties"]["spectrum"] template = spectrum_schema() metadata["capabilities"]["measure"]["output_schema"]["properties"]["spectrum"] = {"anyOf": [legacy, template]} metadata["capabilities"]["measure"]["preconditions"] = metadata["capabilities"]["measure"]["preconditions"] + [ "Template-backed sample only: the configured wavenumber range must overlap the reference spectrum coverage by at least one output step."] metadata["state_slots"]["measurement.spectrum"]["value_schema"] = {"anyOf": [legacy, template, {"type": "null"}]} cap = common.template_read_capability( "JascoFTIR4700", "ethyl_acetate", template_read_schema(), ["optical_module"], "spectral_library compound id (NIST IR reference spectra); does not refer to the loaded sample") cap["errors"] = ["UNKNOWN_INSTANCE", "UNKNOWN_CAPABILITY", "INVALID_ARGUMENT", "REQUEST_CONFLICT"] metadata["capabilities"]["template.read"] = cap metadata["parameters"]["template_library"] = {"value": SOURCES, "unit": "1", "evidence": "measured", "conditions": "NIST WebBook IR transmission spectra, normalised absorbance on a 400-4000 cm^-1, 4 cm^-1 grid; not ATR"} metadata["parameters"]["template_grid_step_m_inv"] = {"value": GRID_STEP_CM * CM_TO_M_INV, "unit": "m^-1", "evidence": "derived", "conditions": "library resampling grid; output spacing = max(grid, effective resolution / 2)"} metadata["limits"] = metadata["limits"] + [ "Template-backed samples (host register_template_sample) return NIST transmission IR spectra broadened to the configured resolution; no ATR correction. The synthetic Gaussian fixture path is unchanged and remains the default."] return metadata