File size: 8,650 Bytes
d1292d8 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 | """Shared helpers for the t3_analytical template modules (GC 8890B, HPLC 1260, HS 8697, DR6000, FT/IR-4700, 5910 Ri).
Everything here is read-only access to public-data libraries under ``assets/reactions/``. Library files that are not
in the ``{"templates": [...]}`` layout (the shared ``spectral_library`` tables) are read directly; their provenance
block uses the same SHA-256 helper as :mod:`scripts.template_library`.
"""
from __future__ import annotations
import json
import math
from functools import lru_cache
from typing import Any
from scripts.template_library import ROOT, library_sha256
SPECTRAL = "assets/reactions/spectral_library"
COMPOUNDS_REL = SPECTRAL + "/compounds.json"
SUBSTANCES_REL = "assets/reactions/substances.json"
@lru_cache(maxsize=None)
def load_json(rel_path: str) -> Any:
path = (ROOT / rel_path).resolve()
if ROOT not in path.parents:
raise ValueError(f"library path escapes the project root: {rel_path}")
return json.loads(path.read_text(encoding="utf-8"))
def compounds() -> dict[str, dict[str, Any]]:
return load_json(COMPOUNDS_REL)["compounds"]
def resolve_compound_id(identifier: Any) -> str | None:
"""spectral_library compound id for ``identifier``.
Accepts a spectral_library id directly, or a ``substances.json`` id (reaction-ledger species) when the same id
exists in the spectral library (acetic_acid, ethanol, ethyl_acetate, water, carbon_dioxide, hydrogen_peroxide).
"""
if not isinstance(identifier, str) or not identifier:
return None
return identifier if identifier in compounds() else None
def finite(value: Any) -> bool:
if isinstance(value, bool) or not isinstance(value, (int, float)):
return False
try:
return math.isfinite(value)
except (OverflowError, ValueError):
return False
def sha256_map(*rel_paths: str) -> dict[str, str]:
return {rel: library_sha256(rel) for rel in rel_paths}
def number(unit: str, minimum: float | None = None, maximum: float | None = None) -> dict[str, Any]:
schema: dict[str, Any] = {"type": "number", "x-unit": unit}
if minimum is not None:
schema["minimum"] = minimum
if maximum is not None:
schema["maximum"] = maximum
return schema
def obj(properties: dict[str, Any], required: list[str] | None = None) -> dict[str, Any]:
return {"type": "object", "properties": properties,
"required": list(properties) if required is None else required, "additionalProperties": False}
def nullable(schema: dict[str, Any]) -> dict[str, Any]:
return {"anyOf": [schema, {"type": "null"}]}
TEXT = {"type": "string"}
TEXT_LIST = {"type": "array", "items": {"type": "string"}}
SHA_MAP = {"type": "object", "additionalProperties": {"type": "string"}}
def provenance_schema() -> dict[str, Any]:
"""Fields every template-backed result carries."""
return {"template_source": TEXT_LIST, "library_sha256": SHA_MAP, "evidence": TEXT,
"synthetic": {"type": "boolean", "const": False}, "synthetic_parts": TEXT_LIST, "limitations": TEXT_LIST}
def provenance(rel_paths: list[str], evidence: str, synthetic_parts: list[str], limitations: list[str]) -> dict[str, Any]:
return {"template_source": list(rel_paths), "library_sha256": sha256_map(*rel_paths), "evidence": evidence,
"synthetic": False, "synthetic_parts": list(synthetic_parts), "limitations": list(limitations)}
def template_read_capability(cls_name: str, example_id: str, output_schema: dict[str, Any], component_ids: list[str],
description: str) -> dict[str, Any]:
"""Runtime-metadata entry for an agent-visible ``template.read`` reference query."""
return {"input_schema": obj({"substance_id": {"type": "string", "description": description}}),
"output_schema": output_schema, "example_arguments": [{"substance_id": example_id}],
"state_ids": [], "component_ids": component_ids, "preconditions": [],
"scene_required": False, "availability": "implemented", "kind": "query",
"invocation": cls_name + ".invoke(instance_id=..., capability_id='template.read', arguments={'substance_id': ...}, request_id=...)",
"errors": ["UNKNOWN_INSTANCE", "INVALID_ARGUMENT", "REQUEST_CONFLICT"],
"rejection_side_effects": "none",
"measurement_cache_semantics": "Public reference lookup; does not read or change the loaded sample, state revision or scene."}
# ---- shared numerical helpers -------------------------------------------------------------------------------------
def interp(x: float, xs: list[float], ys: list[float]) -> float | None:
"""Linear interpolation on an ascending grid; None outside [xs[0], xs[-1]] (no extrapolation)."""
if not xs or x < xs[0] or x > xs[-1]:
return None
lo, hi = 0, len(xs) - 1
while hi - lo > 1:
mid = (lo + hi) // 2
if xs[mid] <= x:
lo = mid
else:
hi = mid
if xs[hi] == xs[lo]:
return ys[lo]
return ys[lo] + (ys[hi] - ys[lo]) * (x - xs[lo]) / (xs[hi] - xs[lo])
def detect_peaks(time_s: list[float], signal: list[float], relative_threshold: float = 1e-3) -> list[dict[str, Any]]:
"""Unlabeled peak table from a sampled trace.
Local maxima above ``relative_threshold`` x the largest value; boundaries walk down to the neighbouring valley
or baseline; trapezoid area between boundaries; apex refined by a three-point parabola; width at half height by
linear interpolation (None when the half-height crossing lies outside the sampled trace).
"""
n = len(signal)
if n < 3 or max(signal) <= 0:
return []
threshold = max(signal) * relative_threshold
peaks = []
for i in range(1, n - 1):
c = signal[i]
if c < threshold or not (c > signal[i - 1] and c >= signal[i + 1]):
continue
left = i
while left > 0 and signal[left - 1] < signal[left]:
left -= 1
right = i
while right < n - 1 and signal[right + 1] < signal[right]:
right += 1
area = sum((signal[j] + signal[j + 1]) * (time_s[j + 1] - time_s[j]) / 2 for j in range(left, right))
denom = signal[i - 1] - 2 * c + signal[i + 1]
offset = 0.5 * (signal[i - 1] - signal[i + 1]) / denom if denom < 0 else 0.0
step = (time_s[i + 1] - time_s[i - 1]) / 2
apex = time_s[i] + offset * step
half = c / 2
lo, hi = i, i
while lo > 0 and signal[lo] > half:
lo -= 1
while hi < n - 1 and signal[hi] > half:
hi += 1
width = None
if signal[lo] <= half < signal[lo + 1] and signal[hi] <= half < signal[hi - 1]:
t_lo = time_s[lo] + (half - signal[lo]) / (signal[lo + 1] - signal[lo]) * (time_s[lo + 1] - time_s[lo])
t_hi = time_s[hi - 1] + (signal[hi - 1] - half) / (signal[hi - 1] - signal[hi]) * (time_s[hi] - time_s[hi - 1])
width = t_hi - t_lo
peaks.append({"apex": apex, "area": area, "height": c, "width": width})
return peaks
# ---- NIST UV/Vis curves (spectral_library/uv_vis.json) --------------------------------------------------------------
UV_REL = SPECTRAL + "/uv_vis.json"
# NIST curves are log10(epsilon / (L mol^-1 cm^-1)); 1 L mol^-1 cm^-1 = 1e-3 m^3 / (mol * 1e-2 m) = 0.1 m^2/mol.
L_PER_MOL_CM_TO_M2_PER_MOL = 0.1
@lru_cache(maxsize=None)
def uv_curve(compound_id: str) -> dict[str, Any] | None:
"""First NIST UV/Vis curve of a spectral_library compound as SI arrays (ascending wavelength), or None."""
entry = load_json(UV_REL)["compounds"].get(compound_id) or {}
spectra = entry.get("spectra") or []
if not spectra:
return None
spectrum = spectra[0]
pairs = sorted(zip(spectrum["wavelength_nm"], spectrum["y"]))
wavelengths, eps = [], []
for nm, log_eps in pairs:
if wavelengths and nm * 1e-9 <= wavelengths[-1]:
continue
wavelengths.append(nm * 1e-9)
eps.append(10.0 ** log_eps * L_PER_MOL_CM_TO_M2_PER_MOL)
return {"compound_id": compound_id, "wavelength_m": wavelengths, "epsilon_m2_mol": eps,
"title": spectrum.get("title"), "nist_index": spectrum.get("nist_index"), "origin": spectrum.get("origin"),
"y_units_original": spectrum.get("y_units"), "source": spectrum.get("source"), "evidence": spectrum.get("evidence")}
def uv_epsilon(compound_id: str, wavelength_m: float) -> float | None:
curve = uv_curve(compound_id)
return None if curve is None else interp(wavelength_m, curve["wavelength_m"], curve["epsilon_m2_mol"])
|