"""Gamry Reference 620: template-backed reversible cyclic voltammetry from the public redox-couple library. Library: ``assets/reactions/gamry_ref620_redox_library/templates.json`` (standard potentials with reference electrode and medium, electron count, aqueous diffusion coefficients linked from the USGS/PHREEQC-based pine library). The trusted host loads a cell (couple + bulk concentrations + electrode area + reference electrode, optional pH and explicitly labelled assumption inputs) with ``GamryReference620Runtime.host_load_template_cell``. The agent then calls ``electrochem.template_cv`` with a triangular scan; the result is a numerical reversible (Nernstian) CV for planar semi-infinite diffusion (semi-integral method, Grünwald–Letnikov semi-derivative) plus the analytic Randles–Sevcik forward-peak current. Kinetics (assumed reversible), uncompensated resistance and double-layer capacitance are explicit host assumptions; the real data are E°, n and D. Agent-visible results never contain the couple identity or the bulk concentrations. """ from __future__ import annotations import copy import math from typing import Any from ._echem_common import (BOOL, F, LN10, R, T_REF, TEXT, arr, get_template, index_by_id, matches, nullable, num, number, obj, provenance, public_record) TEMPLATE_REL = "assets/reactions/gamry_ref620_redox_library/templates.json" PINE_REL = "assets/expansion_batch04/t4_measure/pine_wavevortex10/diffusion_library.json" POTENTIAL_LIMIT_V = 11.0 CURRENT_LIMIT_A = 0.6 MAX_POINTS_PER_SEGMENT = 1000 DEFAULT_POINTS_PER_SEGMENT = 500 TEMPLATE_CAPABILITY_IDS = ("template.list", "template.read", "electrochem.template_cv") LIMITATIONS = [ "E° are standard potentials at 298.15 K (unit activity, SHE); no formal-potential medium data or dE°/dT are applied unless the host sets formal_potential_shift_v (assumption).", "Reversible (Nernstian) single n-electron step assumed; heterogeneous kinetics, coupled chemistry, adsorption and multi-step mechanisms are not modelled.", "Planar semi-infinite diffusion at the sample temperature using 298.15 K diffusion coefficients; no convection, migration or edge diffusion.", "Uncompensated resistance and double-layer capacitance are host-supplied assumptions (default 0); capacitive current is added as C_dl*A*dE/dt.", "Peak currents are read from zero current, not from an extrapolated baseline; IUPAC convention (anodic positive).", "The ±11 V / ±0.6 A instrument limits are checked; overload is flagged, never clipped silently.", ] def _records() -> dict[str, dict[str, Any]]: return index_by_id(TEMPLATE_REL) COUPLE_TYPES = ("redox_couple", "redox_couple_nonaqueous") NONAQUEOUS_REFERENCE_ID = "refel_sce_sat_kcl" # nonaqueous E1/2 values are reported vs aqueous SCE def couple(substance_id: str) -> dict[str, Any] | None: rec = get_template(TEMPLATE_REL, substance_id) return rec if rec and rec.get("record_type") in COUPLE_TYPES else None def reference_electrode_potential(reference_id: str) -> tuple[float, dict[str, Any] | None]: if reference_id in ("she", "SHE"): return 0.0, None rec = get_template(TEMPLATE_REL, reference_id) if not rec or rec.get("record_type") != "reference_electrode" or not number(rec.get("potential_vs_she_v")): raise ValueError("unknown reference electrode") return float(rec["potential_vs_she_v"]), rec # ----------------------------------------------------------------------------------------------- host-side cell CELL_SCHEMA = obj({ "couple_id": TEXT, "oxidant_concentration_mol_m3": num("mol/m^3", 0, 1e4), "reductant_concentration_mol_m3": num("mol/m^3", 0, 1e4), "electrode_area_m2": num("m^2", exclusive_minimum=0, maximum=1.0), "temperature_k": num("K", 273.15, 373.15), "ph": nullable(num("1", -2, 16)), "reference_electrode_id": TEXT, "diffusion_override_m2_s": nullable(obj({"oxidant": nullable(num("m^2/s", exclusive_minimum=0, maximum=1e-7)), "reductant": nullable(num("m^2/s", exclusive_minimum=0, maximum=1e-7))})), "uncompensated_resistance_ohm": num("ohm", 0, 1e6), "double_layer_capacitance_f_m2": num("F/m^2", 0, 10.0), "formal_potential_shift_v": num("V", -2, 2), }, required=["couple_id", "oxidant_concentration_mol_m3", "reductant_concentration_mol_m3", "electrode_area_m2", "reference_electrode_id"]) CELL_DEFAULTS = {"temperature_k": T_REF, "ph": None, "diffusion_override_m2_s": None, "uncompensated_resistance_ohm": 0.0, "double_layer_capacitance_f_m2": 0.0, "formal_potential_shift_v": 0.0} def build_cell(cell: dict[str, Any]) -> dict[str, Any]: """Validate a host cell description and resolve every template quantity; raises ValueError.""" if not isinstance(cell, dict) or not matches(CELL_SCHEMA, cell): raise ValueError("cell does not match the template cell schema") spec = {**CELL_DEFAULTS, **copy.deepcopy(cell)} rec = couple(spec["couple_id"]) if rec is None: raise ValueError("unknown redox couple") if not rec.get("cv_model_eligible"): raise ValueError("couple is not eligible for the soluble/soluble reversible CV model") if spec["oxidant_concentration_mol_m3"] <= 0 and spec["reductant_concentration_mol_m3"] <= 0: raise ValueError("at least one electroactive partner must be present") n = int(rec["n_electrons"]) nonaqueous = rec["record_type"] == "redox_couple_nonaqueous" proton_stoich = 0.0 if nonaqueous else float(rec.get("proton_stoich") or 0.0) if proton_stoich and spec["ph"] is None: raise ValueError("pH required for a proton-coupled couple") if nonaqueous and (spec["reference_electrode_id"] != NONAQUEOUS_REFERENCE_ID or spec["ph"] is not None): raise ValueError("nonaqueous E1/2 records are only used against the SCE they were reported on, without pH") e_ref, ref_rec = reference_electrode_potential(spec["reference_electrode_id"]) t = float(spec["temperature_k"]) diffusion = rec.get("diffusion") or {} override = spec["diffusion_override_m2_s"] or {} d_ox, d_red = diffusion.get("oxidant_m2_s"), diffusion.get("reductant_m2_s") d_source = {"oxidant": "library" if number(d_ox) else None, "reductant": "library" if number(d_red) else None} for side in ("oxidant", "reductant"): if number(override.get(side)): if side == "oxidant": d_ox = float(override[side]) else: d_red = float(override[side]) d_source[side] = "host_assumption" # Nonaqueous: E1/2 vs SCE is placed on the internal SHE-referenced axis via the same SCE record, so the # potential reported vs that SCE equals the published E1/2 (no aqueous/nonaqueous junction correction claimed). e0 = float(rec["e_half_wave_v"]) + e_ref if nonaqueous else float(rec["e_standard_v"]) slope = R * t * LN10 / F ph_term = (proton_stoich / n) * slope * float(spec["ph"]) if proton_stoich else 0.0 # Couples written with OH-: proton_stoich counts OH- produced as H+ equivalents, so E°' needs + (h/n)*k*pKw(T). hydroxide_stoich = float(rec.get("hydroxide_stoich") or 0.0) pkw = None if hydroxide_stoich: from . import _acidbase pkw = _acidbase.pkw_at(t)[0] e_formal_she = e0 - ph_term + ((hydroxide_stoich / n) * slope * pkw if hydroxide_stoich else 0.0) + float(spec["formal_potential_shift_v"]) return {"spec": spec, "couple_id": rec["substance_id"], "n": n, "e_standard_she_v": None if nonaqueous else e0, "e_reported_v": float(rec["e_half_wave_v"] if nonaqueous else rec["e_standard_v"]), "e_reported_scale": "E1/2 vs aqueous SCE (nonaqueous solvent)" if nonaqueous else "E° vs SHE", "proton_stoich": proton_stoich, "hydroxide_stoich": hydroxide_stoich, "pkw": pkw, "e_formal_she_v": e_formal_she, "reference_potential_she_v": e_ref, "reference_record_source": None if ref_rec is None else ref_rec.get("source"), "d_ox": d_ox if number(d_ox) else None, "d_red": d_red if number(d_red) else None, "d_source": d_source, "record_provenance": provenance(TEMPLATE_REL, rec)} # ----------------------------------------------------------------------------------------------- CV model def _surface_term(c_ox: float, c_red: float, sq_ox: float, sq_red: float, log_theta: float) -> float: """Semi-integral M with Nernst surface ratio theta = C_O(0)/C_R(0) = exp(log_theta).""" if log_theta > 0: inv = math.exp(-min(log_theta, 700.0)) return (c_ox * inv - c_red) / (inv / sq_ox + 1.0 / sq_red) theta = math.exp(max(log_theta, -700.0)) return (c_ox - theta * c_red) / (1.0 / sq_ox + theta / sq_red) def simulate_cv(*, n: int, e_formal_vs_ref: float, d_ox: float, d_red: float, c_ox: float, c_red: float, area_m2: float, temperature_k: float, e_start: float, e_vertex: float, scan_rate: float, ru_ohm: float = 0.0, cdl_f_m2: float = 0.0, points_per_segment: int = DEFAULT_POINTS_PER_SEGMENT) -> list[dict[str, float]]: """Reversible CV, planar semi-infinite diffusion: C_O(0)=C_O*-M/sqrt(D_O), C_R(0)=C_R*+M/sqrt(D_R), flux J = d^(1/2)M/dt^(1/2) (Grünwald–Letnikov), i = -nFA*J + C_dl*A*dE/dt (IUPAC: anodic positive).""" f = n * F / (R * temperature_k) steps = int(points_per_segment) span = e_vertex - e_start dt = abs(span) / scan_rate / steps potentials = [e_start + span * k / steps for k in range(steps + 1)] + [e_vertex - span * k / steps for k in range(1, steps + 1)] total = len(potentials) weights = [1.0] for j in range(1, total): weights.append(weights[-1] * (1.0 - 1.5 / j)) sq_ox, sq_red, root_dt = math.sqrt(d_ox), math.sqrt(d_red), math.sqrt(dt) nfa = n * F * area_m2 m_values: list[float] = [] curve = [] for k, e_app in enumerate(potentials): history = 0.0 for j in range(1, k + 1): history += weights[j] * m_values[k - j] sign = 1.0 if (k <= steps and span > 0) or (k > steps and span < 0) else -1.0 i_cap = cdl_f_m2 * area_m2 * scan_rate * sign if ru_ohm > 0: lo, hi = -c_red * sq_red, c_ox * sq_ox for _ in range(80): mid = (lo + hi) / 2 current = -nfa * (mid + history) / root_dt + i_cap residual = (c_ox - mid / sq_ox) - math.exp(min(max(f * (e_app - current * ru_ohm - e_formal_vs_ref), -700.0), 700.0)) * (c_red + mid / sq_red) if residual > 0: lo = mid else: hi = mid m_k = (lo + hi) / 2 else: m_k = _surface_term(c_ox, c_red, sq_ox, sq_red, f * (e_app - e_formal_vs_ref)) m_values.append(m_k) current = -nfa * (m_k + history) / root_dt + i_cap curve.append({"potential_v": e_app, "current_a": current, "time_s": k * dt}) return curve def randles_sevcik(n: int, area_m2: float, conc_mol_m3: float, d_m2_s: float, scan_rate: float, temperature_k: float) -> float: """ip = 0.4463 n F A C (n F v D / (R T))^(1/2), magnitude in A.""" return 0.4463 * n * F * area_m2 * conc_mol_m3 * math.sqrt(n * F * scan_rate * d_m2_s / (R * temperature_k)) def _peak(points: list[dict[str, float]], kind: str) -> dict[str, float] | None: """Interior extremum of one sweep segment (endpoints are not peaks).""" if len(points) < 3: return None pick = min if kind == "cathodic" else max best = pick(range(len(points)), key=lambda i: points[i]["current_a"]) if best in (0, len(points) - 1): return None value = points[best]["current_a"] if (kind == "cathodic" and value >= 0) or (kind == "anodic" and value <= 0): return None return {"potential_v": points[best]["potential_v"], "current_a": value} def run_template_cv(cell: dict[str, Any], scan: dict[str, Any], *, evaluator: bool) -> dict[str, Any]: spec = cell["spec"] t = float(spec["temperature_k"]) e_formal_ref = cell["e_formal_she_v"] - cell["reference_potential_she_v"] # At least one diffusion coefficient is needed for currents; a missing partner is set equal (flagged assumption). have_d = cell["d_ox"] is not None or cell["d_red"] is not None d_ox = cell["d_ox"] if cell["d_ox"] is not None else (cell["d_red"] or 1e-9) d_red = cell["d_red"] if cell["d_red"] is not None else d_ox assumed_ratio = cell["d_ox"] is None or cell["d_red"] is None points = int(scan.get("points_per_segment") or DEFAULT_POINTS_PER_SEGMENT) curve = simulate_cv(n=cell["n"], e_formal_vs_ref=e_formal_ref, d_ox=d_ox, d_red=d_red, c_ox=float(spec["oxidant_concentration_mol_m3"]), c_red=float(spec["reductant_concentration_mol_m3"]), area_m2=float(spec["electrode_area_m2"]), temperature_k=t, e_start=scan["e_start_v"], e_vertex=scan["e_vertex_v"], scan_rate=scan["scan_rate_v_s"], ru_ohm=float(spec["uncompensated_resistance_ohm"]), cdl_f_m2=float(spec["double_layer_capacitance_f_m2"]), points_per_segment=points) cathodic_first = scan["e_vertex_v"] < scan["e_start_v"] forward, reverse = curve[:points + 1], curve[points:] cathodic = _peak(forward if cathodic_first else reverse, "cathodic") anodic = _peak(reverse if cathodic_first else forward, "anodic") rs = None forward_conc = float(spec["oxidant_concentration_mol_m3"] if cathodic_first else spec["reductant_concentration_mol_m3"]) forward_d = d_ox if cathodic_first else d_red if have_d and forward_conc > 0: rs = randles_sevcik(cell["n"], float(spec["electrode_area_m2"]), forward_conc, forward_d, scan["scan_rate_v_s"], t) rs = -rs if cathodic_first else rs if not have_d: for row in curve: row["current_a"] = None cathodic = None if cathodic is None else {"potential_v": cathodic["potential_v"], "current_a": None} anodic = None if anodic is None else {"potential_v": anodic["potential_v"], "current_a": None} overload = any(row["current_a"] is not None and abs(row["current_a"]) > CURRENT_LIMIT_A for row in curve) separation = None if cathodic is None or anodic is None else anodic["potential_v"] - cathodic["potential_v"] half_wave = None if cathodic is None or anodic is None else (anodic["potential_v"] + cathodic["potential_v"]) / 2 sources = cell["d_source"] d_evidence = ("missing: currents not computed (host must supply diffusion_override_m2_s)" if not have_d else "derived_database (USGS PHREEQC -dw via pine library)" if all(v == "library" for v in sources.values()) else "host_assumption" if all(v == "host_assumption" for v in sources.values() if v) else "mixed: " + ", ".join(f"{k}={v or 'set equal to partner (assumption)'}" for k, v in sources.items())) evidence = {"standard_potential": cell["record_provenance"]["evidence"], "electron_count": cell["record_provenance"]["evidence"], "diffusion_coefficient": d_evidence, "diffusion_ratio": "assumption D_O = D_R (one partner missing)" if assumed_ratio else "library_or_host", "kinetics": "assumption: reversible (Nernstian)", "ohmic_drop": "assumption" if spec["uncompensated_resistance_ohm"] else "assumption: R_u = 0", "double_layer": "assumption" if spec["double_layer_capacitance_f_m2"] else "assumption: C_dl = 0", "formal_potential": "assumption: shift applied" if spec["formal_potential_shift_v"] else "standard potential used as formal potential (assumption)"} result = {"template_backed": True, "reference_electrode_id": spec["reference_electrode_id"], "scan": {"e_start_v": scan["e_start_v"], "e_vertex_v": scan["e_vertex_v"], "scan_rate_v_s": scan["scan_rate_v_s"], "duration_s": 2 * abs(scan["e_vertex_v"] - scan["e_start_v"]) / scan["scan_rate_v_s"], "points_per_segment": points}, "curve": [{"potential_v": row["potential_v"], "current_a": row["current_a"], "time_s": row["time_s"]} for row in curve], "cathodic_peak": cathodic, "anodic_peak": anodic, "peak_separation_v": separation, "half_wave_potential_v": half_wave, "randles_sevcik_peak_current_a": rs if have_d else None, "current_convention": "IUPAC: anodic current positive, cathodic negative", "current_overload": overload, "template_source": TEMPLATE_REL, "library_sha256": cell["record_provenance"]["library_sha256"], "evidence": evidence, "synthetic": False, "synthetic_parts": ["reversible-kinetics assumption", "ohmic drop and double layer (host assumption inputs)", "numerical semi-infinite planar diffusion model output (derived)"], "limitations": list(LIMITATIONS), "truth": None} if evaluator: result["truth"] = {"couple_id": cell["couple_id"], "cell": copy.deepcopy(spec), "e_standard_she_v": cell["e_standard_she_v"], "e_formal_she_v": cell["e_formal_she_v"], "d_oxidant_m2_s": cell["d_ox"], "d_reductant_m2_s": cell["d_red"], "diffusion_source": cell["d_source"], "record_source": cell["record_provenance"]["template_record_source"]} return result # ----------------------------------------------------------------------------------------------- capability metadata POINT = obj({"potential_v": num("V"), "current_a": nullable(num("A")), "time_s": num("s", 0)}) PEAK = nullable(obj({"potential_v": num("V"), "current_a": nullable(num("A"))})) CV_INPUT = obj({"e_start_v": num("V", -POTENTIAL_LIMIT_V, POTENTIAL_LIMIT_V), "e_vertex_v": num("V", -POTENTIAL_LIMIT_V, POTENTIAL_LIMIT_V), "scan_rate_v_s": num("V/s", maximum=1e4, exclusive_minimum=0), "points_per_segment": nullable({"type": "integer", "minimum": 20, "maximum": MAX_POINTS_PER_SEGMENT, "x-unit": "1"})}, required=["e_start_v", "e_vertex_v", "scan_rate_v_s"]) CV_OUTPUT = obj({"template_backed": BOOL, "reference_electrode_id": TEXT, "scan": obj({"e_start_v": num("V"), "e_vertex_v": num("V"), "scan_rate_v_s": num("V/s"), "duration_s": num("s", 0), "points_per_segment": {"type": "integer", "x-unit": "1"}}), "curve": arr(POINT, 2 * MAX_POINTS_PER_SEGMENT + 1), "cathodic_peak": PEAK, "anodic_peak": PEAK, "peak_separation_v": nullable(num("V")), "half_wave_potential_v": nullable(num("V")), "randles_sevcik_peak_current_a": nullable(num("A")), "current_convention": TEXT, "current_overload": BOOL, "template_source": TEXT, "library_sha256": TEXT, "evidence": {"type": "object", "additionalProperties": TEXT}, "synthetic": BOOL, "synthetic_parts": arr(TEXT), "limitations": arr(TEXT), "truth": nullable({"type": "object"})}) READ_INPUT = obj({"substance_id": {"type": "string", "minLength": 1, "maxLength": 128}}) READ_OUTPUT = obj({"record": {"type": "object"}, "template_source": TEXT, "template_record_source": nullable(TEXT), "evidence": nullable(TEXT), "library_sha256": TEXT}) LIST_OUTPUT = obj({"records": arr(obj({"substance_id": TEXT, "record_type": TEXT, "name": TEXT, "cv_model_eligible": BOOL})), "template_source": TEXT, "library_sha256": TEXT}) def capability_metadata() -> dict[str, dict[str, Any]]: """Runtime-describe entries in the GamryReference620 metadata style.""" def entry(name, inputs, outputs, example, kind, description, preconditions, components): return {"availability": "implemented", "visibility": "agent", "kind": kind, "description_zh": description, "input_schema": inputs, "output_schema": outputs, "example_arguments": [example], "state_effects": [], "observes": [], "component_ids": components, "preconditions_zh": preconditions, "binding": f"basic40_runtime_measure.GamryReference620Session.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": "absent", "robot": "absent", "hardware": "absent"}, "error_codes": ["UNKNOWN_INSTANCE", "UNKNOWN_CAPABILITY", "INVALID_ARGUMENT", "ACCESS_DENIED", "PRECONDITION_FAILED", "BUSY", "REQUEST_CONFLICT"], "retry": "same_request_id; in-memory only", "template_source": TEMPLATE_REL} return { "template.list": entry("template.list", obj({}), LIST_OUTPUT, {}, "query", "列出公开氧化还原电对参考库条目（标准电位、电子数、扩散系数来源）；不透露当前电解池。", "实例可用。", ["root"]), "template.read": entry("template.read", READ_INPUT, READ_OUTPUT, {"substance_id": "redox_fe3_fe2"}, "query", "读取一条公开参考记录（电对或参比电极）及来源证据；不透露当前电解池内容。", "实例可用；substance_id为库内条目。", ["root"]), "electrochem.template_cv": entry("electrochem.template_cv", CV_INPUT, CV_OUTPUT, {"e_start_v": 0.6, "e_vertex_v": -0.2, "scan_rate_v_s": 0.1, "points_per_segment": None}, "analysis", "对宿主装入的模板电解池计算可逆循环伏安：E°/n/D来自公开库，动力学可逆、iR与双电层为显式假设；不推进时钟。", "供电、四槽已连接、波形未播放且宿主已装入模板电解池；电位在±11 V内，扫速>0。", ["root"] + [p + "_slot" for p in ("working_electrode", "reference_electrode", "counter_electrode", "cell")]), } # ----------------------------------------------------------------------------------------------- dispatch def invoke(session, host, instance_id: str, inst: dict[str, Any], cap: str, args: dict[str, Any], request_id: str, *, evaluator: bool): fail = lambda code, status="rejected": session._error(instance_id, code, request_id, status) meta = capability_metadata()[cap] if not matches(meta["input_schema"], args): return fail("INVALID_ARGUMENT") if cap == "template.list": rows = [{"substance_id": sid, "record_type": rec.get("record_type", ""), "name": rec.get("name", ""), "cv_model_eligible": bool(rec.get("cv_model_eligible"))} for sid, rec in _records().items()] any_rec = next(iter(_records().values())) return session._envelope(instance_id, request_id, result={"records": rows, "template_source": TEMPLATE_REL, "library_sha256": provenance(TEMPLATE_REL, any_rec)["library_sha256"]}) if cap == "template.read": rec = get_template(TEMPLATE_REL, args["substance_id"]) if rec is None: return fail("INVALID_ARGUMENT") return session._envelope(instance_id, request_id, result=public_record(TEMPLATE_REL, rec)) # electrochem.template_cv if inst["running"]: return fail("BUSY") cell = inst.get("template_cell") if not inst["enabled"] or cell is None or not all(inst["connections"].values()): return fail("PRECONDITION_FAILED") if args["e_start_v"] == args["e_vertex_v"]: return fail("INVALID_ARGUMENT") try: result = run_template_cv(cell, args, evaluator=evaluator) except (ValueError, OverflowError, ZeroDivisionError): return fail("INVALID_ARGUMENT") return session._envelope(instance_id, request_id, result=result)