| """Metrohm OMNIS titrator: template-backed analytes and titrants from the shared public acid-base library. |
| |
| Library: ``assets/reactions/metrohm_omnis_acidbase_library/templates.json`` (stepwise thermodynamic pKa with ΔrH°/ΔrCp° |
| or PHREEQC analytic temperature functions, water autoprotolysis, strong volumetric titrants and NIST primary |
| standards). The same table serves the 914 pH meter. |
| |
| The trusted host loads an analyte with ``MetrohmOmnisRuntime.host_load_template_sample``; afterwards the existing |
| dosing/stability/endpoint process is unchanged except that ``MetrohmOmnisRuntime._potential`` asks this module for |
| pH: an ideal-solution charge balance over every acid system, the titrant's spectator ions and pKw(T), then the same |
| ideal Nernst electrode as the legacy model. Equivalence points are found by the existing endpoint / dynamic |
| algorithms from the observed curve, so ``titration.calculate_content`` works unchanged. Activity coefficients are 1 |
| (ideal solution — stated, not corrected). |
| """ |
| from __future__ import annotations |
|
|
| import copy |
| import math |
| from typing import Any |
|
|
| from . import _acidbase as ab |
| from ._echem_common import BOOL, F, LN10, R, T_REF, TEXT, arr, index_by_id, matches, nullable, num, number, obj, provenance, public_record |
|
|
| TEMPLATE_REL = ab.ACIDBASE_REL |
| TEMPLATE_CAPABILITY_IDS = ("template.list", "template.read", "titration.template_report") |
| LIMITATIONS = [ |
| "Ideal solution: activity coefficients = 1, mol/L used for molality; no ionic-strength correction of the I = 0 pKa values.", |
| "pKa(T) from PHREEQC analytic expressions or constant-ΔCp van 't Hoff where the library has ΔrH°; otherwise the 298.15 K value is used (flagged).", |
| "Strong titrants are assumed fully dissociated and carbonate-free; titrant concentration is the value the agent configured (no hidden titer error).", |
| "Instantaneous mixing and an ideal Nernstian glass electrode (host-set isopotential pH and potential); no electrode response time, junction potential or alkaline/acid error.", |
| "Precipitation, complexation, CO2 uptake and redox reactions are not modelled.", |
| ] |
|
|
| ANALYTE_SCHEMA = obj({ |
| "components": arr(obj({"substance_id": {"type": "string", "minLength": 1, "maxLength": 128}, |
| "amount_mol": num("mol", 0, 10.0), "mass_kg": num("kg", 0, 1.0), |
| "protons_as_added": nullable({"type": "integer", "minimum": 0, "maximum": 8, "x-unit": "1"})}, |
| required=["substance_id"]), 16), |
| "strong_acid_mol": num("mol", 0, 10.0), "strong_base_mol": num("mol", 0, 10.0), |
| "volume_m3": num("m^3", exclusive_minimum=0, maximum=1e-2), "temperature_k": num("K", 273.15, 368.15), |
| "titrant_id": {"type": "string", "minLength": 1, "maxLength": 128}, |
| "electrode_isopotential_ph": num("1", 0, 14), "electrode_isopotential_v": num("V", -1, 1), |
| }, required=["components", "volume_m3", "titrant_id"]) |
| ANALYTE_DEFAULTS = {"strong_acid_mol": 0.0, "strong_base_mol": 0.0, "temperature_k": T_REF, |
| "electrode_isopotential_ph": 7.0, "electrode_isopotential_v": 0.0} |
|
|
|
|
| def titrant(substance_id: str) -> dict[str, Any] | None: |
| rec = ab.record(substance_id) |
| return rec if rec and rec.get("record_type") == "titrant" else None |
|
|
|
|
| def build_analyte(analyte: dict[str, Any]) -> dict[str, Any]: |
| if not isinstance(analyte, dict) or not matches(ANALYTE_SCHEMA, analyte): |
| raise ValueError("analyte does not match the template analyte schema") |
| spec = {**ANALYTE_DEFAULTS, **copy.deepcopy(analyte)} |
| tit = titrant(spec["titrant_id"]) |
| if tit is None or tit.get("strength") not in ("strong_base", "strong_acid"): |
| raise ValueError("unknown titrant") |
| comps, ids = [], set() |
| for comp in spec["components"]: |
| named = ab.record(comp["substance_id"]) |
| if named is None or comp["substance_id"] in ids or ("amount_mol" in comp) == ("mass_kg" in comp): |
| raise ValueError("unknown/duplicate component or not exactly one of amount_mol / mass_kg") |
| ids.add(comp["substance_id"]) |
| if named.get("record_type") == "primary_standard": |
| |
| rec = ab.record(named["acid_base_link"]) |
| default_protons = int(named["protons_in_standard_form"]) |
| purity = float(named["certified_mass_fraction"]) |
| elif named.get("record_type") == "acid_base": |
| rec, default_protons, purity = named, int(named["protons_in_named_form"]), 1.0 |
| else: |
| raise ValueError("component must be an acid_base system or a primary_standard") |
| if "mass_kg" in comp: |
| if not number(named.get("molar_mass_kg_mol")): |
| raise ValueError("molar mass unknown for mass-based amount") |
| amount = float(comp["mass_kg"]) * purity / float(named["molar_mass_kg_mol"]) |
| else: |
| amount = float(comp["amount_mol"]) |
| protons = comp.get("protons_as_added") |
| protons = default_protons if protons is None else int(protons) |
| if not 0 <= protons <= int(rec["n_acidic_protons"]): |
| raise ValueError("protons_as_added outside the acid system") |
| comps.append({"record": rec, "named_id": named["substance_id"], "amount_mol": amount, "protons_as_added": protons}) |
| link = tit.get("acid_base_link") |
| titrant_system = ab.record(link) if link else None |
| strength = tit["strength"] |
| equivalents = sum(c["amount_mol"] * ab.titratable_steps(c["record"], c["protons_as_added"], strength) for c in comps) |
| equivalents += spec["strong_acid_mol"] if strength == "strong_base" else spec["strong_base_mol"] |
| |
| equivalents -= spec["strong_base_mol"] if strength == "strong_base" else spec["strong_acid_mol"] |
| equivalents = max(0.0, equivalents) |
| provenances = {c["record"]["substance_id"]: provenance(TEMPLATE_REL, c["record"]) for c in comps} |
| provenances.update({c["named_id"]: provenance(TEMPLATE_REL, ab.record(c["named_id"])) for c in comps}) |
| provenances[tit["substance_id"]] = provenance(TEMPLATE_REL, tit) |
| return {"spec": spec, "components": comps, "titrant": tit, "titrant_system": titrant_system, |
| "titratable_equivalents_mol": equivalents, "provenances": provenances} |
|
|
|
|
| def ph_and_potential(template: dict[str, Any], sample_volume_m3: float, dosed_volume_m3: float, |
| titrant_concentration_mol_m3: float, temperature_k: float) -> tuple[float, float, dict[str, Any]]: |
| spec, tit = template["spec"], template["titrant"] |
| total_l = (sample_volume_m3 + dosed_volume_m3) * 1000.0 |
| added_mol = titrant_concentration_mol_m3 * dosed_volume_m3 |
| components = [{"record": c["record"], "total_mol_l": c["amount_mol"] / total_l, "protons_as_added": c["protons_as_added"]} |
| for c in template["components"]] |
| strong = (spec["strong_base_mol"] - spec["strong_acid_mol"]) / total_l |
| system = template["titrant_system"] |
| if system is not None: |
| components.append({"record": system, "total_mol_l": added_mol / total_l, "protons_as_added": int(system["protons_in_named_form"])}) |
| else: |
| sign = 1.0 if tit["strength"] == "strong_base" else -1.0 |
| strong += sign * float(tit.get("equivalents_per_mol") or 1) * added_mol / total_l |
| solved = ab.solve_ph(components, strong, temperature_k) |
| ph = solved["ph"] |
| potential = spec["electrode_isopotential_v"] - LN10 * R * temperature_k / F * (ph - spec["electrode_isopotential_ph"]) |
| return ph, potential, solved |
|
|
|
|
| def expected_equivalence_volumes(template: dict[str, Any], titrant_concentration_mol_m3: float | None) -> list[float] | None: |
| """Stoichiometric equivalence volumes (cumulative proton steps) for a single acid system; evaluator-only.""" |
| if not number(titrant_concentration_mol_m3) or titrant_concentration_mol_m3 <= 0 or len(template["components"]) != 1: |
| return None |
| comp, spec, strength = template["components"][0], template["spec"], template["titrant"]["strength"] |
| eq = float(template["titrant"].get("equivalents_per_mol") or 1) |
| offset = spec["strong_acid_mol"] - spec["strong_base_mol"] if strength == "strong_base" else spec["strong_base_mol"] - spec["strong_acid_mol"] |
| steps = ab.titratable_steps(comp["record"], comp["protons_as_added"], strength) |
| return [(max(0.0, offset) + k * comp["amount_mol"]) / (titrant_concentration_mol_m3 * eq) for k in range(1, steps + 1)] |
|
|
|
|
| def load_template_sample(host, instance_id: str, analyte: dict[str, Any]) -> dict[str, Any]: |
| """Host-only fixture: legacy truth fields are filled consistently, then the template is attached.""" |
| with host._lock: |
| template = build_analyte(analyte) |
| spec = template["spec"] |
| host.host_load_sample(instance_id, {"volume_m3": spec["volume_m3"], "acid_moles": template["titratable_equivalents_mol"], |
| "temperature_k": spec["temperature_k"], "reference_ph": spec["electrode_isopotential_ph"], |
| "reference_potential_v": spec["electrode_isopotential_v"]}) |
| host._instances[instance_id]["template"] = template |
| return {"loaded": True, "template_backed": True, "synthetic": False, |
| "titratable_equivalents_mol": template["titratable_equivalents_mol"]} |
|
|
|
|
| def potential(inst: dict[str, Any]) -> tuple[float, float]: |
| template, truth = inst["template"], inst["truth"] |
| dosed = inst["steps"] * inst["quantum"] if inst["quantum"] else 0.0 |
| concentration = inst["concentration"] if number(inst["concentration"]) else 0.0 |
| ph, e, _ = ph_and_potential(template, truth["volume_m3"], dosed, concentration, truth["temperature_k"]) |
| if not number(ph) or not number(e): |
| raise ValueError("template response outside numeric domain") |
| return ph, e |
|
|
|
|
| def report(inst: dict[str, Any], *, evaluator: bool) -> dict[str, Any]: |
| template = inst.get("template") |
| backed = template is not None |
| result = {"template_backed": backed, "status": inst["status"], |
| "titrant_id": template["titrant"]["substance_id"] if backed else None, |
| "titrant_strength": template["titrant"]["strength"] if backed else None, |
| "endpoint_volume_m3": inst["endpoint"], |
| "model": "ideal charge balance over library pKa(T) and pKw(T); ideal Nernst electrode" if backed else "legacy synthetic strong-acid model", |
| "template_source": TEMPLATE_REL if backed else None, |
| "library_sha256": template["provenances"][template["titrant"]["substance_id"]]["library_sha256"] if backed else None, |
| "evidence": ({"pka": "measured_literature (NIST JPCRD / NIST SRD 46 via USGS PHREEQC)", |
| "temperature_dependence": "derived (van 't Hoff / PHREEQC analytic)", |
| "activity": "assumption: ideal solution", "electrode": "assumption: ideal Nernst", |
| "titrant": "assumption: complete dissociation, configured concentration"} if backed else None), |
| "synthetic": not backed, |
| "synthetic_parts": ["dosing, mixing, stability and endpoint algorithms (engineering assumptions)", |
| "ideal electrode response"], |
| "limitations": list(LIMITATIONS), "truth": None} |
| if evaluator and backed: |
| result["truth"] = {"analyte": copy.deepcopy(template["spec"]), "titratable_equivalents_mol": template["titratable_equivalents_mol"], |
| "component_amounts_mol": {c["named_id"]: c["amount_mol"] for c in template["components"]}, |
| "expected_equivalence_volumes_m3": expected_equivalence_volumes(template, inst["concentration"]), |
| "record_sources": {k: v["template_record_source"] for k, v in template["provenances"].items()}} |
| return result |
|
|
|
|
| READ_INPUT = obj({"substance_id": {"type": "string", "minLength": 1, "maxLength": 128}, "temperature_k": nullable(num("K", 273.15, 368.15))}, |
| required=["substance_id"]) |
| READ_OUTPUT = obj({"record": {"type": "object"}, "template_source": TEXT, "template_record_source": nullable(TEXT), |
| "evidence": nullable(TEXT), "library_sha256": TEXT, |
| "pka_at_temperature": nullable(arr(num("1"))), "pkw_at_temperature": nullable(num("1")), |
| "temperature_models": nullable(arr(TEXT))}) |
| LIST_OUTPUT = obj({"records": arr(obj({"substance_id": TEXT, "record_type": TEXT, "name": TEXT})), "template_source": TEXT, "library_sha256": TEXT}) |
| REPORT_OUTPUT = obj({"template_backed": BOOL, "status": TEXT, "titrant_id": nullable(TEXT), "titrant_strength": nullable(TEXT), |
| "endpoint_volume_m3": nullable(num("m^3", 0)), "model": TEXT, "template_source": nullable(TEXT), |
| "library_sha256": nullable(TEXT), "evidence": nullable({"type": "object", "additionalProperties": TEXT}), |
| "synthetic": BOOL, "synthetic_parts": arr(TEXT), "limitations": arr(TEXT), "truth": nullable({"type": "object"})}) |
|
|
|
|
| def read_record(substance_id: str, temperature_k: float | None) -> dict[str, Any] | None: |
| rec = ab.record(substance_id) |
| if rec is None: |
| return None |
| result = public_record(TEMPLATE_REL, rec) |
| result.update({"pka_at_temperature": None, "pkw_at_temperature": None, "temperature_models": None}) |
| t = T_REF if temperature_k is None else float(temperature_k) |
| if rec.get("record_type") == "acid_base": |
| pkas, models = ab.pka_at(rec, t) |
| result.update(pka_at_temperature=pkas, temperature_models=models) |
| elif rec.get("record_type") == "solvent_autoprotolysis": |
| pkw, model = ab.pkw_at(t) |
| result.update(pkw_at_temperature=pkw, temperature_models=[model]) |
| return result |
|
|
|
|
| def capability_metadata(binding_class: str = "MetrohmOmnisSession", components: list[str] | None = None) -> dict[str, dict[str, Any]]: |
| comps = components or ["housing"] |
| def entry(name, inputs, outputs, example, description): |
| return {"availability": "implemented", "visibility": "agent", "kind": "query", "description_zh": description, |
| "input_schema": inputs, "output_schema": outputs, "example_arguments": [example], "state_effects": [], "observes": [], |
| "component_ids": comps, "preconditions_zh": "实例可用。", |
| "binding": f"basic40_runtime_measure.{binding_class}.invoke(instance_id=..., capability_id='{name}', arguments=..., request_id=...)", |
| "completion_criterion_zh": "同步返回；不推进宿主时钟、不改变实例状态。", |
| "model_effects": {"mode": "none", "binding_ids": [], "description_zh": "只读模板或报告，不改变几何。"}, |
| "implementation": {"process": "implemented", "host": "implemented", "scene": "not_applicable", "robot": "absent", "hardware": "absent"}, |
| "error_codes": ["UNKNOWN_INSTANCE", "UNKNOWN_CAPABILITY", "INVALID_ARGUMENT", "ACCESS_DENIED", "REQUEST_CONFLICT"], |
| "retry": "same_request_id; in-memory only", "template_source": TEMPLATE_REL} |
| return { |
| "template.list": entry("template.list", obj({}), LIST_OUTPUT, {}, "列出公开酸碱参考库条目（pKa体系、水的离子积、标准滴定剂、NIST基准物）。"), |
| "template.read": entry("template.read", READ_INPUT, READ_OUTPUT, {"substance_id": "acetic_acid", "temperature_k": 298.15}, |
| "读取一条公开酸碱参考记录及来源；给定温度时返回该温度的逐级pKa或pKw及所用温度模型；不透露当前样品。"), |
| "titration.template_report": entry("titration.template_report", obj({}), REPORT_OUTPUT, {}, |
| "返回当前滴定的模板来源、证据、观测终点体积与假设清单；agent 不可见样品组成与真值。"), |
| } |
|
|
|
|
| def invoke(session, host, instance_id: str, inst: dict[str, Any], cap: str, args: dict[str, Any], request_id: str, *, evaluator: bool): |
| meta = capability_metadata()[cap] |
| if not matches(meta["input_schema"], args): |
| return session._error(instance_id, "INVALID_ARGUMENT", request_id) |
| if cap == "template.list": |
| rows = [{"substance_id": sid, "record_type": rec.get("record_type", ""), "name": rec.get("name", "")} |
| for sid, rec in index_by_id(TEMPLATE_REL).items()] |
| sha = provenance(TEMPLATE_REL, next(iter(index_by_id(TEMPLATE_REL).values())))["library_sha256"] |
| return session._envelope(instance_id, request_id, result={"records": rows, "template_source": TEMPLATE_REL, "library_sha256": sha}) |
| if cap == "template.read": |
| result = read_record(args["substance_id"], args.get("temperature_k")) |
| if result is None: |
| return session._error(instance_id, "INVALID_ARGUMENT", request_id) |
| return session._envelope(instance_id, request_id, result=result) |
| return session._envelope(instance_id, request_id, result=report(inst, evaluator=evaluator)) |
|
|
