"""CHEM-024 IKA RV 10 digital V: template-backed solvent evaporation (real vapour-pressure data). Library: ``assets/reactions/ika_rv10_evaporation_library/templates.json`` (81 solvents; NIST WebBook Antoine fits with validity ranges, NIST Tboil and enthalpy of vaporization, liquid density from the NIST SRD 69 reference EOS or PubChem experimental properties). Two layers are kept strictly apart in every result: * real / derived-from-real (``evidence`` measured_literature or derived): saturation pressure at the bath temperature and boiling temperature at the external vacuum pressure from the NIST Antoine fit (``log10(P/bar) = A - B/(T + C)``, evaluated only inside the published range), enthalpy of vaporization (NIST point nearest to the boiling temperature) and the charge mass ``rho * V``. * assumption (``synthetic`` list): the overall bath-to-flask heat-transfer coefficient ``UA`` [W/K] and the condensation efficiency supplied by the trusted host, the boiling-only evaporation law ``m_dot = min(UA * (T_bath - T_boil(P)), 1350 W) / dH_vap`` (no sub-boiling evaporation, no bath cooling by the evaporative load, explicit Euler at the start of each host step), and the delta-20 rule of thumb. The agent-visible ``template.read`` capability is a public reference lookup and never reveals which solvent the trusted host placed in the flask. The charge identity and rates are only in the evaluator-only ``evaporation.template_report`` and the trusted ``RV10Host.template_charge_report``. """ from __future__ import annotations import copy import math try: # scripts/ on sys.path (tests, Matterix bridge) import template_library as _tl except ImportError: # project root on sys.path from scripts import template_library as _tl TEMPLATE_REL = "assets/reactions/ika_rv10_evaporation_library/templates.json" RATED_HEATER_W = 1350.0 DELTA20_K = 20.0 CAPABILITY_IDS = ("template.read", "evaporation.template_report") EVALUATOR_CAPABILITIES = ("evaporation.template_report",) LIMITATIONS = [ "Vapour pressure and boiling temperature come from NIST WebBook Antoine fits evaluated only inside each fit's published temperature range; outside every range the result is null (no extrapolation).", "Pure solvents only: no mixtures, azeotropes, dissolved solutes, boiling-point elevation or foaming/bumping.", "Density is a single literature/EOS value near 293 K; charge mass rho*V and condensate volume ignore thermal expansion.", "Evaporation rate uses an assumed host-supplied heat-transfer coefficient UA and only the boiling regime (bath above T_boil at the external pressure); sub-boiling evaporation is set to zero.", "The evaporative heat load is capped at the 1350 W rated heater power but is not withdrawn from the lumped bath model; condenser capacity, vapour-line pressure drop and coolant temperature are not modelled.", "The delta-20 rule (bath ~ T_boil + 20 K, condenser <= T_boil - 20 K) is a practical rule of thumb, reported as an assumption, not data.", ] SYNTHETIC = [ "heat_transfer_w_k: host-supplied overall bath-to-flask UA (assumption)", "condensation_efficiency: host-supplied fraction (assumption)", "evaporation law: boiling-only m_dot = min(UA*(T_bath - T_boil(P)), 1350 W)/dH_vap, explicit Euler per host step (assumption)", "delta-20 rule of thumb (assumption)", ] EVIDENCE = "measured_literature (NIST Antoine/Tboil/dHvap, NIST EOS or PubChem density); boiling temperature, saturation pressure and charge mass derived from them; rate law assumption" _K = {"type": "number", "x-unit": "K"} _NULL_K = {"anyOf": [{"type": "number", "x-unit": "K"}, {"type": "null"}]} _NULL_PA = {"anyOf": [{"type": "number", "minimum": 0, "x-unit": "Pa"}, {"type": "null"}]} _TEXT = {"type": "string"} _TEXTS = {"type": "array", "items": {"type": "string"}} def _obj(properties): return {"type": "object", "properties": properties, "required": list(properties), "additionalProperties": False} def _nullable(schema): return {"anyOf": [schema, {"type": "null"}]} _FIT = _obj({"fit_id": _TEXT, "A": {"type": "number", "x-unit": "1"}, "B_k": {"type": "number", "x-unit": "K"}, "C_k": {"type": "number", "x-unit": "K"}, "temperature_range_k": {"type": "array", "items": {"type": "number", "x-unit": "K"}, "minItems": 2, "maxItems": 2}, "reference": _TEXT}) _DH = _obj({"value_j_mol": {"type": "number", "x-unit": "J/mol"}, "temperature_k": {"type": "number", "x-unit": "K"}, "reference": _TEXT, "source_kind": _TEXT}) TEMPLATE_SCHEMA = _obj({ "substance_id": _TEXT, "name": _TEXT, "cas": _nullable(_TEXT), "molar_mass_kg_mol": _nullable({"type": "number", "x-unit": "kg/mol"}), "normal_boiling_point_k": _NULL_K, "melting_point_k": _NULL_K, "density_kg_m3": _nullable({"type": "number", "x-unit": "kg/m^3"}), "density_temperature_k": _NULL_K, "antoine_fits": {"type": "array", "items": _FIT}, "vaporization_enthalpy_points": {"type": "array", "items": _DH}, "runtime_usable": {"type": "boolean"}, "quality_flags": _TEXTS, "source": _TEXT, "evidence": _TEXT, }) _RULE = _obj({"evidence": {"type": "string", "const": "assumption"}, "statement": _TEXT, "recommended_bath_temperature_k": _NULL_K, "recommended_condenser_max_temperature_k": _NULL_K}) TEMPLATE_READ_OUTPUT = _obj({ "template": TEMPLATE_SCHEMA, "boiling_temperature_at_pressure_k": _NULL_K, "boiling_fit_id": _nullable(_TEXT), "pressure_for_boiling_temperature_pa": _NULL_PA, "pressure_fit_id": _nullable(_TEXT), "rule_of_thumb": _RULE, "template_source": _TEXT, "library_sha256": _TEXT, "evidence": _TEXT, "synthetic": {"type": "boolean"}, "limitations": _TEXTS, }) TEMPLATE_READ_INPUT = _obj({ "substance_id": {"type": "string", "description": "Library substance_id, e.g. ethanol"}, "pressure_pa": {"anyOf": [{"type": "number", "exclusiveMinimum": 0, "maximum": 110000, "x-unit": "Pa"}, {"type": "null"}], "description": "Optional absolute pressure; returns the Antoine boiling temperature at this pressure"}, "boiling_temperature_k": {"anyOf": [{"type": "number", "exclusiveMinimum": 0, "maximum": 453.15, "x-unit": "K"}, {"type": "null"}], "description": "Optional target boiling temperature; returns the absolute pressure needed"}, }) REPORT_OUTPUT = _obj({ "template_backed": {"type": "boolean"}, "solvent_id": _nullable(_TEXT), "bath_temperature_k": _NULL_K, "pressure_pa": _NULL_PA, "boiling_temperature_at_pressure_k": _NULL_K, "saturation_pressure_at_bath_pa": _NULL_PA, "antoine_fit_id": _nullable(_TEXT), "boiling": _nullable({"type": "boolean"}), "regime": _TEXT, "vaporization_enthalpy_j_mol": _nullable({"type": "number", "x-unit": "J/mol"}), "vaporization_enthalpy_temperature_k": _NULL_K, "heat_transfer_w_k": _nullable({"type": "number", "minimum": 0, "x-unit": "W/K"}), "heat_flow_w": _nullable({"type": "number", "minimum": 0, "x-unit": "W"}), "evaporation_rate_kg_s": _nullable({"type": "number", "minimum": 0, "x-unit": "kg/s"}), "remaining_mass_kg": _nullable({"type": "number", "minimum": 0, "x-unit": "kg"}), "remaining_volume_m3": _nullable({"type": "number", "minimum": 0, "x-unit": "m^3"}), "condensate_mass_kg": _nullable({"type": "number", "minimum": 0, "x-unit": "kg"}), "condensate_volume_m3": _nullable({"type": "number", "minimum": 0, "x-unit": "m^3"}), "rule_of_thumb": _RULE, "template_source": _nullable(_TEXT), "library_sha256": _nullable(_TEXT), "evidence": _TEXT, "synthetic": {"type": "boolean"}, "synthetic_components": _TEXTS, "quality_flags": _TEXTS, "limitations": _TEXTS, }) # ----------------------------------------------------------------------------- library access def library(): return _tl.load_library(TEMPLATE_REL) def record(substance_id): return _tl.get_template(TEMPLATE_REL, substance_id) if isinstance(substance_id, str) else None def substance_ids(*, runtime_usable_only=False): return [r["substance_id"] for r in library()["templates"] if r["runtime_usable"] or not runtime_usable_only] def _in_range(fit, t_k): lo, hi = fit["temperature_range_k"] return lo <= t_k <= hi def saturation_pressure_pa(rec, t_k): """NIST Antoine P(T) with the first published fit whose range contains T; (None, None) outside all ranges.""" if t_k is None or not math.isfinite(t_k): return None, None for fit in rec["antoine_fits"]: if _in_range(fit, t_k): return 1e5 * 10 ** (fit["A"] - fit["B_k"] / (t_k + fit["C_k"])), fit["fit_id"] return None, None def boiling_temperature_k(rec, pressure_pa): """Inverse Antoine T(P) = B/(A - log10(P/bar)) - C, accepted only if T lies inside that fit's range.""" if pressure_pa is None or not math.isfinite(pressure_pa) or pressure_pa <= 0: return None, None x = math.log10(pressure_pa / 1e5) for fit in rec["antoine_fits"]: if fit["A"] - x <= 0: continue t_k = fit["B_k"] / (fit["A"] - x) - fit["C_k"] if _in_range(fit, t_k): return t_k, fit["fit_id"] return None, None def vaporization_enthalpy(rec, t_k): """NIST enthalpy-of-vaporization point whose temperature is nearest to t_k (first one on ties).""" points = rec["vaporization_enthalpy_points"] if not points or t_k is None: return None return min(points, key=lambda p: abs(p["temperature_k"] - t_k)) def rule_of_thumb(t_boil): return {"evidence": "assumption", "statement": library()["rule_of_thumb"]["statement"], "recommended_bath_temperature_k": None if t_boil is None else t_boil + DELTA20_K, "recommended_condenser_max_temperature_k": None if t_boil is None else t_boil - DELTA20_K} def public_template(rec): return {"substance_id": rec["substance_id"], "name": rec["name"], "cas": rec["cas"], "molar_mass_kg_mol": rec["molar_mass_kg_mol"], "normal_boiling_point_k": rec["normal_boiling_point_k"], "melting_point_k": rec["melting_point_k"], "density_kg_m3": rec["density_kg_m3"], "density_temperature_k": rec["density_temperature_k"], "antoine_fits": [{k: f[k] for k in ("fit_id", "A", "B_k", "C_k", "temperature_range_k", "reference")} for f in rec["antoine_fits"]], "vaporization_enthalpy_points": [{"value_j_mol": p["value_j_mol"], "temperature_k": p["temperature_k"], "reference": p["reference"], "source_kind": p.get("source_kind", "nist_phase_change_one_dimensional")} for p in rec["vaporization_enthalpy_points"]], "runtime_usable": rec["runtime_usable"], "quality_flags": list(rec["quality_flags"]), "source": rec["source"], "evidence": rec["evidence"]} # ----------------------------------------------------------------------------- capabilities def capabilities(*, include_evaluator): caps = { "template.read": { "availability": "implemented", "visibility": "agent", "kind": "query", "description_zh": "公开参考查询：按 substance_id 返回溶剂的 NIST Antoine 拟合（含适用温区）、常压沸点、汽化焓与密度；可选给定压力求沸点、给定沸点求所需压力；不透露烧瓶内实际物质", "input_schema": copy.deepcopy(TEMPLATE_READ_INPUT), "output_schema": copy.deepcopy(TEMPLATE_READ_OUTPUT), "state_effects": [], "observes": [], "example_arguments": [{"substance_id": "ethanol", "pressure_pa": 17500.0, "boiling_temperature_k": None}], "binding": "basic40_runtime_vacuum.RV10Session.invoke(instance_id=..., capability_id='template.read', arguments=..., request_id=...)"}, } if include_evaluator: caps["evaporation.template_report"] = { "availability": "implemented", "visibility": "evaluator", "kind": "query", "description_zh": "评估者查询：宿主模板装料的溶剂、外部压力下的沸点、浴温下的蒸气压、是否沸腾及假设传热系数给出的蒸发速率；真实数据与假设分列", "input_schema": _obj({}), "output_schema": copy.deepcopy(REPORT_OUTPUT), "state_effects": [], "observes": [], "example_arguments": [{}], "binding": "basic40_runtime_vacuum.RV10Session.invoke(instance_id=..., capability_id='evaporation.template_report', arguments={}, request_id=...)"} return caps def _valid_number(value, low=None, high=None, exclusive_low=None): if type(value) not in (int, float) or not math.isfinite(value): return False return (low is None or value >= low) and (high is None or value <= high) and (exclusive_low is None or value > exclusive_low) def template_read(args): """Return (result, None) or (None, error_code).""" if not isinstance(args, dict) or set(args) != {"substance_id", "pressure_pa", "boiling_temperature_k"} or not isinstance(args["substance_id"], str): return None, "INVALID_ARGUMENT" p, t = args["pressure_pa"], args["boiling_temperature_k"] if (p is not None and not _valid_number(p, high=110000, exclusive_low=0)) or (t is not None and not _valid_number(t, high=453.15, exclusive_low=0)): return None, "INVALID_ARGUMENT" rec = record(args["substance_id"]) if rec is None: return None, "UNKNOWN_REFERENCE" t_boil, boil_fit = boiling_temperature_k(rec, p) if p is not None else (None, None) p_need, p_fit = saturation_pressure_pa(rec, t) if t is not None else (None, None) prov = _tl.provenance(TEMPLATE_REL, rec) return {"template": public_template(rec), "boiling_temperature_at_pressure_k": t_boil, "boiling_fit_id": boil_fit, "pressure_for_boiling_temperature_pa": p_need, "pressure_fit_id": p_fit, "rule_of_thumb": rule_of_thumb(t_boil if t_boil is not None else t), "template_source": prov["template_source"], "library_sha256": prov["library_sha256"], "evidence": "measured_literature record; boiling temperature / pressure derived from the cited Antoine fit (null outside its range); rule of thumb is an assumption", "synthetic": False, "limitations": list(LIMITATIONS)}, None # ----------------------------------------------------------------------------- template-backed charge def configure_charge(host, instance_id, *, solvent_id, volume_m3, condensation_efficiency, heat_transfer_w_k, evidence): """Trusted host: fill the flask with a library solvent (mass = rho*V). Mirrors RV10Host.configure_evaporation.""" with host._lock: inst = host._instances[instance_id] if inst.state["rotation.running"] or inst.state["thermal.enabled"]: raise ValueError("Stop rotation and heating before configuring a charge") rec = record(solvent_id) if rec is None or not rec["runtime_usable"]: raise ValueError("solvent_id must name a runtime-usable record of " + TEMPLATE_REL) if not _valid_number(volume_m3, high=3e-3, exclusive_low=0) or not _valid_number(condensation_efficiency, 0, 1) \ or not _valid_number(heat_transfer_w_k, 0, 1e4) or not isinstance(evidence, str) or not evidence.strip(): raise ValueError("Positive volume <= 3e-3 m3, efficiency in [0,1], UA in [0,1e4] W/K and evidence required") mass = rec["density_kg_m3"] * float(volume_m3) prov = _tl.provenance(TEMPLATE_REL, rec) inst.evaporation = {"charge_mass_kg": mass, "evaporation_rate_kg_s": 0.0, "condensation_efficiency": float(condensation_efficiency), "configured_at_s": host.time_s, "template": {"solvent_id": solvent_id, "volume_m3": float(volume_m3), "density_kg_m3": rec["density_kg_m3"], "heat_transfer_w_k": float(heat_transfer_w_k), "template_source": prov["template_source"], "library_sha256": prov["library_sha256"]}} inst.configuration_evidence["evaporation"] = evidence inst.state.update({"evaporation.remaining_mass_kg": mass, "evaporation.evaporated_mass_kg": 0.0, "evaporation.uncondensed_mass_kg": 0.0, "recovery.condensate_mass_kg": 0.0}) host._refresh(inst) inst.revision += 1 return mass def _assess(template, state): rec = record(template["solvent_id"]) t_bath, p = state["thermal.temperature_k"], state["vacuum.pressure_pa"] t_boil, fit_id = boiling_temperature_k(rec, p) p_sat, _ = saturation_pressure_pa(rec, t_bath) out = {"rec": rec, "t_bath": t_bath, "p": p, "t_boil": t_boil, "fit_id": fit_id, "p_sat": p_sat, "boiling": None, "regime": "unknown", "dh": None, "q": None, "rate": 0.0} if t_bath is None or p is None: out["regime"] = "missing_bath_or_pressure" return out if t_boil is None: out["regime"] = "pressure_outside_antoine_range" return out if rec["melting_point_k"] is not None and t_bath <= rec["melting_point_k"]: out.update(boiling=False, regime="bath_below_melting_point") return out if t_bath <= t_boil: out.update(boiling=False, regime="sub_boiling_neglected") return out dh = vaporization_enthalpy(rec, t_boil) q = min(template["heat_transfer_w_k"] * (t_bath - t_boil), RATED_HEATER_W) rate = q / (dh["value_j_mol"] / rec["molar_mass_kg_mol"]) if dh and rec["molar_mass_kg_mol"] else 0.0 out.update(boiling=True, regime="boiling", dh=dh, q=q, rate=rate) return out def current_rate_kg_s(inst): """Rate used by RV10Host._refresh for a template charge; 0 unless all RV10 run conditions and boiling hold.""" s = inst.state if not (s["power.enabled"] and s["rotation.running"] and s["thermal.enabled"] and inst.bath and s["vacuum.source_instance_id"] is not None): return 0.0 return _assess(inst.evaporation["template"], s)["rate"] def report(inst): ev = inst.evaporation if not ev or "template" not in ev: return {"template_backed": False, "solvent_id": None, "bath_temperature_k": inst.state["thermal.temperature_k"], "pressure_pa": inst.state["vacuum.pressure_pa"], "boiling_temperature_at_pressure_k": None, "saturation_pressure_at_bath_pa": None, "antoine_fit_id": None, "boiling": None, "regime": "no_template_charge", "vaporization_enthalpy_j_mol": None, "vaporization_enthalpy_temperature_k": None, "heat_transfer_w_k": None, "heat_flow_w": None, "evaporation_rate_kg_s": None, "remaining_mass_kg": inst.state["evaporation.remaining_mass_kg"], "remaining_volume_m3": None, "condensate_mass_kg": inst.state["recovery.condensate_mass_kg"], "condensate_volume_m3": None, "rule_of_thumb": {"evidence": "assumption", "statement": library()["rule_of_thumb"]["statement"], "recommended_bath_temperature_k": None, "recommended_condenser_max_temperature_k": None}, "template_source": None, "library_sha256": None, "evidence": "legacy empirical charge or none: no template data used", "synthetic": True, "synthetic_components": ["legacy host-supplied constant evaporation rate"], "quality_flags": [], "limitations": list(LIMITATIONS)} tpl, s = ev["template"], inst.state a = _assess(tpl, s) rho = tpl["density_kg_m3"] running = bool(s["evaporation.running"]) regime = a["regime"] if s["evaporation.remaining_mass_kg"] <= 0: regime = "charge_exhausted" elif regime == "boiling" and not running: regime = "boiling_possible_but_rv10_not_running" return {"template_backed": True, "solvent_id": tpl["solvent_id"], "bath_temperature_k": a["t_bath"], "pressure_pa": a["p"], "boiling_temperature_at_pressure_k": a["t_boil"], "saturation_pressure_at_bath_pa": a["p_sat"], "antoine_fit_id": a["fit_id"], "boiling": a["boiling"] if s["evaporation.remaining_mass_kg"] > 0 else False, "regime": regime, "vaporization_enthalpy_j_mol": None if a["dh"] is None else a["dh"]["value_j_mol"], "vaporization_enthalpy_temperature_k": None if a["dh"] is None else a["dh"]["temperature_k"], "heat_transfer_w_k": tpl["heat_transfer_w_k"], "heat_flow_w": a["q"] if running else (0.0 if a["q"] is not None else None), "evaporation_rate_kg_s": current_rate_kg_s(inst) if running else 0.0, "remaining_mass_kg": s["evaporation.remaining_mass_kg"], "remaining_volume_m3": s["evaporation.remaining_mass_kg"] / rho, "condensate_mass_kg": s["recovery.condensate_mass_kg"], "condensate_volume_m3": s["recovery.condensate_mass_kg"] / rho, "rule_of_thumb": rule_of_thumb(a["t_boil"]), "template_source": tpl["template_source"], "library_sha256": tpl["library_sha256"], "evidence": EVIDENCE, "synthetic": False, "synthetic_components": list(SYNTHETIC), "quality_flags": list(a["rec"]["quality_flags"]), "limitations": list(LIMITATIONS)}