scripts/gc_runtime.py

"""Synthetic GC-FID process semantics, SI units, Python standard library only.

This is NOT calibrated Agilent firmware, a pressure-flow network, or a contact
solver. The host simulator owns joints, contacts, grasping, alignment and thermal
contact. Every numerical default below is an explicit educational assumption.
"""
from __future__ import annotations

import argparse
import csv
from dataclasses import asdict, dataclass
import json
import math
from pathlib import Path

R_J_MOL_K = 8.31446261815324
PARAMETER_PROVENANCE = "synthetic_assumption_not_manufacturer_calibration"
ACTION_COMPONENTS = {
    "plug_power": "power_inlet", "power": "power_switch",
    "connect_gas": "carrier_port", "door": "oven_door",
    "set_temperature": "control_panel", "ignite": "fid_igniter",
    "extinguish": "fid_body", "start": "start_key", "stop": "stop_key",
    "aspirate": "sample_vial", "insert_syringe": "septum",
    "depress_plunger": "plunger", "retract_syringe": "syringe",
}


def component_for_action(action, **kwargs):
    """Resolve the scene component, including the selected gas supply port."""
    if action == "connect_gas":
        gas = kwargs.get("gas")
        if gas not in {"carrier", "hydrogen", "air", "makeup"}:
            raise ValueError("Unknown gas port")
        return f"{gas}_port"
    if action not in ACTION_COMPONENTS:
        raise ValueError(f"Unknown action: {action}")
    return ACTION_COMPONENTS[action]


def finite(value, name, *, positive=False):
    value = float(value)
    if not math.isfinite(value) or (value <= 0 if positive else value < 0):
        raise ValueError(f"{name} must be finite and {'positive' if positive else 'nonnegative'}")
    return value


class ActionRejected(ValueError):
    """An embodied task precondition was not satisfied; state is unchanged."""


@dataclass(frozen=True)
class Species:
    name: str
    k_ref: float
    delta_h_J_mol: float
    response_C_kg: float
    reference_temperature_K: float = 353.15

    def __post_init__(self):
        if not self.name:
            raise ValueError("Species requires an identifier")
        finite(self.k_ref, "k_ref")
        finite(self.response_C_kg, "response_C_kg")
        finite(self.reference_temperature_K, "reference_temperature_K", positive=True)
        if not math.isfinite(self.delta_h_J_mol):
            raise ValueError("delta_h_J_mol must be finite")

    def retention_factor(self, temperature_K):
        temperature_K = finite(temperature_K, "temperature_K", positive=True)
        exponent = -self.delta_h_J_mol / R_J_MOL_K * (
            1 / temperature_K - 1 / self.reference_temperature_K)
        return self.k_ref * math.exp(max(-100, min(100, exponent)))


SYNTHETIC_SPECIES = (
    Species("synthetic_A", 1.0, -30000, 1.0),
    Species("synthetic_B", 2.5, -38000, 1.2),
    Species("synthetic_C", 5.0, -45000, 0.8),
)


@dataclass(frozen=True)
class Method:
    mode: str = "split"
    split_ratio: float = 20.0
    purge_time_s: float = 30.0
    purge_flow_m3_s: float = 8.333333333333334e-7
    # Both column and liner flow use this SAME assumed representative state.
    # This omits real pressure/temperature conversion between inlet and column.
    column_flow_m3_s: float = 1.6666666666666667e-8
    septum_purge_flow_m3_s: float = 5e-8
    # Septum purge is a distinct branch, not a perfectly mixed liner outlet.
    # Zero means ideal separation of injected sample from the septum-purge path.
    septum_sample_loss_fraction: float = 0.0
    hydrogen_flow_m3_s: float = 5e-7
    air_flow_m3_s: float = 5e-6
    makeup_flow_m3_s: float = 4.166666666666667e-7
    liner_volume_m3: float = 8e-7
    column_length_m: float = 30.0
    column_inner_diameter_m: float = 2.5e-4
    column_film_thickness_m: float = 2.5e-7
    longitudinal_B_m2_s: float = 3e-5
    mass_transfer_C_s: float = 4e-4
    oven_temperature_K: float = 353.15
    inlet_temperature_K: float = 523.15
    fid_temperature_K: float = 573.15
    temperature_tolerance_K: float = 1.0
    ready_dwell_s: float = 5.0
    fid_ignition_minimum_K: float = 423.15

    def __post_init__(self):
        if self.mode not in {"split", "splitless"}:
            raise ValueError("mode must be split or splitless")
        for key, value in asdict(self).items():
            if key != "mode":
                finite(value, key)
        for key in ("liner_volume_m3", "column_length_m", "column_inner_diameter_m",
                    "column_flow_m3_s", "oven_temperature_K", "inlet_temperature_K",
                    "fid_temperature_K", "fid_ignition_minimum_K"):
            finite(getattr(self, key), key, positive=True)
        if self.septum_sample_loss_fraction > 1:
            raise ValueError("septum_sample_loss_fraction must be in [0, 1]")
        if self.column_film_thickness_m >= self.column_inner_diameter_m / 2:
            raise ValueError("Stationary film must leave an open mobile-phase core")


@dataclass
class ThermalZone:
    temperature_K: float
    setpoint_K: float
    heat_capacity_J_K: float
    conductance_W_K: float
    maximum_power_W: float
    control_gain_W_K: float
    heater_power_W: float = 0.0

    def advance(self, dt_s, ambient_K, enabled, open_door=False):
        conductance = self.conductance_W_K * (12 if open_door else 1)
        demand = (self.control_gain_W_K * (self.setpoint_K - self.temperature_K)
                  + conductance * (self.setpoint_K - ambient_K))
        self.heater_power_W = min(self.maximum_power_W, max(0, demand)) if enabled else 0.0
        equilibrium = ambient_K + self.heater_power_W / conductance
        decay = math.exp(-conductance * dt_s / self.heat_capacity_J_K)
        self.temperature_K = equilibrium + (self.temperature_K - equilibrium) * decay


@dataclass
class Band:
    species: str
    injected_mass_kg: float
    sigma_progress: float
    progress: float = 0.0
    released_fraction: float = 0.0

    def advance(self, progress_delta):
        self.progress += progress_delta
        # Gaussian residence-time kernel conditioned on nonnegative residence.
        sigma = self.sigma_progress
        initial = .5 * math.erfc(1 / (sigma * math.sqrt(2)))
        cdf = .5 * math.erfc((1 - self.progress) / (sigma * math.sqrt(2)))
        released = min(1.0, max(self.released_fraction, (cdf - initial) / (1 - initial)))
        mass = self.injected_mass_kg * (released - self.released_fraction)
        self.released_fraction = released
        return mass


class GC:
    """Agilent 7890B-inspired, single SSL/FID task state and process abstraction."""

    def __init__(self, method=None, species=SYNTHETIC_SPECIES, vial_masses_kg=None):
        self.method = method or Method()
        species = tuple(species)
        self.species = {item.name: item for item in species}
        if not species or len(self.species) != len(species):
            raise ValueError("Species identifiers must be nonempty and unique")
        self.ambient_K = 298.15
        self.zones = {
            "oven": ThermalZone(self.ambient_K, self.method.oven_temperature_K, 6000, 3, 2000, 200),
            "inlet": ThermalZone(self.ambient_K, self.method.inlet_temperature_K, 100, .4, 200, 8),
            "fid": ThermalZone(self.ambient_K, self.method.fid_temperature_K, 150, .35, 200, 8),
        }
        self.power_connected = False
        self.powered = False
        self.gases = {gas: False for gas in ("carrier", "hydrogen", "air", "makeup")}
        self.door_open = False
        self.flame_lit = False
        self.syringe_inserted = False
        self.running = False
        self.time_s = self.run_time_s = self.stable_time_s = 0.0
        self.injection_time_s = None
        self.fid_current_A = self.fid_integral_C = 0.0
        self.vial = self._masses(vial_masses_kg if vial_masses_kg is not None else
                                 {name: 1e-7 for name in self.species})
        self.syringe = self._masses({})
        self.liner = self._masses({})
        self.ledger = {name: dict(injected_kg=0.0, split_vent_kg=0.0,
                                 septum_purge_kg=0.0, column_loaded_kg=0.0,
                                 eluted_kg=0.0, flame_off_eluted_kg=0.0)
                       for name in self.species}
        self.bands = []
        self.events = []

    def _masses(self, mapping):
        if set(mapping) - set(self.species):
            raise ValueError("Unknown species in mass mapping")
        return {name: finite(mapping.get(name, 0), name) for name in self.species}

    def flows(self):
        m = self.method
        carrier = self.powered and self.gases["carrier"]
        split_open = m.mode == "split" or self.injection_time_s is None or (
            self.time_s - self.injection_time_s >= m.purge_time_s - 1e-10)
        split = m.split_ratio * m.column_flow_m3_s if m.mode == "split" else m.purge_flow_m3_s
        return {
            "column": m.column_flow_m3_s if carrier else 0.0,
            "split_vent": split if carrier and split_open else 0.0,
            "septum_purge": m.septum_purge_flow_m3_s if carrier else 0.0,
            "hydrogen": m.hydrogen_flow_m3_s if self.powered and self.gases["hydrogen"] else 0.0,
            "air": m.air_flow_m3_s if self.powered and self.gases["air"] else 0.0,
            "makeup": m.makeup_flow_m3_s if self.powered and self.gases["makeup"] else 0.0,
        }

    def _thermal_ready(self):
        return all(abs(z.temperature_K - z.setpoint_K) <= self.method.temperature_tolerance_K
                   for z in self.zones.values())

    def not_ready_reasons(self):
        reasons = []
        if not self.powered:
            reasons.append("POWER_OFF")
        if self.door_open:
            reasons.append("OVEN_DOOR_OPEN")
        flow = self.flows()
        for gas, key in (("carrier", "column"), ("hydrogen", "hydrogen"), ("air", "air")):
            if flow[key] <= 0:
                reasons.append(f"NO_{gas.upper()}_FLOW")
        if self.method.makeup_flow_m3_s > 0 and flow["makeup"] <= 0:
            reasons.append("NO_MAKEUP_FLOW")
        if not self._thermal_ready() or self.stable_time_s < self.method.ready_dwell_s:
            reasons.append("TEMPERATURE_NOT_READY")
        if not self.flame_lit:
            reasons.append("FID_FLAME_OFF")
        return reasons

    def perform(self, action, **kwargs):
        """Apply a semantic event AFTER the host has verified its physical contact.

        Insert/retract are symbolic acknowledgments, never collision detection.
        All booleans are explicit; arguments with the wrong type are rejected.
        """
        def boolean(key):
            value = kwargs[key]
            if type(value) is not bool:
                raise ValueError(f"{key} must be bool")
            return value

        def fraction():
            value = finite(kwargs.get("fraction", 1.0), "fraction", positive=True)
            if value > 1:
                raise ValueError("fraction must be <= 1")
            return value

        if action == "plug_power":
            self.power_connected = boolean("connected")
            if not self.power_connected:
                self.powered = self.running = self.flame_lit = False
        elif action == "power":
            enabled = boolean("enabled")
            if enabled and not self.power_connected:
                raise ActionRejected("Connect power_inlet first")
            self.powered = enabled
            if not enabled:
                self.running = self.flame_lit = False
        elif action == "connect_gas":
            gas = kwargs["gas"]
            if gas not in self.gases:
                raise ValueError("Unknown gas port")
            self.gases[gas] = boolean("connected")
            if gas in {"hydrogen", "air"} and not self.gases[gas]:
                self.flame_lit = False
        elif action == "door":
            self.door_open = boolean("open")
        elif action == "set_temperature":
            if kwargs["zone"] not in self.zones:
                raise ValueError("Unknown thermal zone")
            temperature = finite(kwargs["temperature_K"], "temperature_K", positive=True)
            if not 273.15 <= temperature <= 723.15:
                raise ValueError("Outside synthetic model's supported thermal interval")
            self.zones[kwargs["zone"]].setpoint_K = temperature
            self.stable_time_s = 0.0
        elif action == "ignite":
            flow = self.flows()
            if not self.powered or flow["hydrogen"] <= 0 or flow["air"] <= 0:
                raise ActionRejected("FID ignition requires power, hydrogen and air")
            if self.zones["fid"].temperature_K < self.method.fid_ignition_minimum_K:
                raise ActionRejected("FID below synthetic ignition readiness temperature")
            self.flame_lit = True
        elif action == "extinguish":
            self.flame_lit = False
        elif action == "start":
            if self.running:
                raise ActionRejected("A run is already acquiring")
            reasons = self.not_ready_reasons()
            if reasons:
                raise ActionRejected(", ".join(reasons))
            self.running = True
            self.run_time_s = self.fid_integral_C = 0.0
            self.injection_time_s = None
        elif action == "stop":
            self.running = False
        elif action == "aspirate":
            f = fraction()
            if self.syringe_inserted:
                raise ActionRejected("Syringe must be at the vial, not inside the inlet")
            if not any(self.vial.values()):
                raise ActionRejected("Sample vial is empty")
            for name in self.species:
                amount = self.vial[name] * f
                self.vial[name] -= amount
                self.syringe[name] += amount
        elif action == "insert_syringe":
            if self.syringe_inserted:
                raise ActionRejected("Syringe is already inserted")
            self.syringe_inserted = True
        elif action == "depress_plunger":
            f = fraction()
            reasons = self.not_ready_reasons()
            if not self.running or not self.syringe_inserted or reasons:
                raise ActionRejected("Injection requires acquiring, aligned syringe and ready state: "
                                     + ", ".join(reasons))
            if not any(self.syringe.values()):
                raise ActionRejected("Syringe is empty")
            for name in self.species:
                amount = self.syringe[name] * f
                purge_loss = amount * self.method.septum_sample_loss_fraction
                self.syringe[name] -= amount
                self.liner[name] += amount - purge_loss
                self.ledger[name]["injected_kg"] += amount
                self.ledger[name]["septum_purge_kg"] += purge_loss
            if self.injection_time_s is None:
                self.injection_time_s = self.time_s
        elif action == "retract_syringe":
            self.syringe_inserted = False
        else:
            raise ValueError(f"Unknown action: {action}")
        if not self.powered or self.door_open or not self._thermal_ready():
            self.stable_time_s = 0.0
        if not self.flame_lit:
            self.fid_current_A = 0.0
        self.events.append({"time_s": self.time_s, "action": action,
                            "component_id": component_for_action(action, **kwargs), "arguments": kwargs})
        return self.observe()

    def _advance(self, dt_s):
        for name, zone in self.zones.items():
            zone.advance(dt_s, self.ambient_K, self.powered and not (name == "oven" and self.door_open),
                         open_door=name == "oven" and self.door_open)
        if self.powered and not self.door_open and self._thermal_ready():
            self.stable_time_s += dt_s
        else:
            self.stable_time_s = 0.0
        flow = self.flows()
        if not self.powered or flow["hydrogen"] <= 0 or flow["air"] <= 0:
            self.flame_lit = False
        if self.zones["fid"].temperature_K < self.method.fid_ignition_minimum_K:
            self.flame_lit = False
        m = self.method
        core_diameter = m.column_inner_diameter_m - 2 * m.column_film_thickness_m
        velocity = flow["column"] / (math.pi * core_diameter ** 2 / 4)
        charge = 0.0
        survivors = []
        for band in self.bands:
            k = self.species[band.species].retention_factor(self.zones["oven"].temperature_K)
            eluted = band.advance(dt_s * velocity / (m.column_length_m * (1 + k)))
            self.ledger[band.species]["eluted_kg"] += eluted
            if self.flame_lit:
                charge += eluted * self.species[band.species].response_C_kg
            else:
                self.ledger[band.species]["flame_off_eluted_kg"] += eluted
            if band.released_fraction < 1:
                survivors.append(band)
        self.bands = survivors
        # A well-mixed vapor compartment transfers mass by competing outflows.
        # Newly transferred bands enter at the END of this small numerical step.
        total = flow["column"] + flow["split_vent"]
        if total > 0:
            fraction_out = -math.expm1(-total * dt_s / m.liner_volume_m3)
            column_fraction = flow["column"] / total
            H = m.longitudinal_B_m2_s / velocity + m.mass_transfer_C_s * velocity
            sigma = math.sqrt(max(H / m.column_length_m, 1e-12))
            for name, mass in self.liner.items():
                out = mass * fraction_out
                loaded = out * column_fraction
                self.liner[name] -= out
                self.ledger[name]["column_loaded_kg"] += loaded
                self.ledger[name]["split_vent_kg"] += out - loaded
                if loaded > 0:
                    self.bands.append(Band(name, loaded, sigma))
        self.time_s += dt_s
        if self.running:
            self.run_time_s += dt_s
            self.fid_integral_C += charge
        return charge

    def step(self, dt_s):
        """Advance time; returned current is the average over this whole step."""
        dt_s = finite(dt_s, "dt_s", positive=True)
        remaining = dt_s
        charge = 0.0
        while remaining > 1e-12:
            h = min(.5, remaining)
            # Align the numerical grid with the splitless purge transition.
            if self.method.mode == "splitless" and self.injection_time_s is not None:
                until_purge = self.injection_time_s + self.method.purge_time_s - self.time_s
                if until_purge > 1e-10:
                    h = min(h, until_purge)
            charge += self._advance(h)
            remaining -= h
        self.fid_current_A = charge / dt_s
        return self.observe()

    def mass_balance(self):
        result = {}
        for name, ledger in self.ledger.items():
            remaining = sum(b.injected_mass_kg * (1 - b.released_fraction)
                            for b in self.bands if b.species == name)
            accounted = (self.liner[name] + remaining + ledger["split_vent_kg"]
                         + ledger["septum_purge_kg"] + ledger["eluted_kg"])
            result[name] = dict(ledger, liner_kg=self.liner[name], column_remaining_kg=remaining,
                               residual_kg=ledger["injected_kg"] - accounted)
        return result

    def observe(self):
        reasons = self.not_ready_reasons()
        flow = self.flows()
        return {
            "parameter_provenance": PARAMETER_PROVENANCE, "time_s": self.time_s,
            "run_time_s": self.run_time_s, "powered": self.powered,
            "door_open": self.door_open, "syringe_inserted": self.syringe_inserted,
            "flame_lit": self.flame_lit, "running": self.running,
            "ready": not reasons, "not_ready_reasons": reasons,
            "temperatures_K": {name: z.temperature_K for name, z in self.zones.items()},
            "heater_power_W": {name: z.heater_power_W for name, z in self.zones.items()},
            "flows_m3_s": flow,
            "carrier_total_flow_m3_s": sum(flow[name] for name in ("column", "split_vent", "septum_purge")),
            "fid_current_A": self.fid_current_A, "fid_integral_C": self.fid_integral_C,
            "mass_balance_kg": self.mass_balance(),
            "vial_masses_kg": dict(self.vial), "syringe_masses_kg": dict(self.syringe),
        }


def synthetic_demo(output_dir):
    """Write explicitly synthetic chromatogram, provenance and action history."""
    output_dir = Path(output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)
    gc = GC()
    gc.perform("plug_power", connected=True)
    gc.perform("power", enabled=True)
    for gas in gc.gases:
        gc.perform("connect_gas", gas=gas, connected=True)
    gc.step(1200)
    gc.perform("ignite")
    gc.perform("start")
    gc.perform("aspirate", fraction=.01)
    gc.perform("insert_syringe")
    gc.perform("depress_plunger")
    gc.perform("retract_syringe")
    rows = []
    for _ in range(1800):
        state = gc.step(.5)
        rows.append({"synthetic_run_time_s": state["run_time_s"],
                     "synthetic_fid_current_A": state["fid_current_A"],
                     "synthetic_fid_integral_C": state["fid_integral_C"],
                     "oven_temperature_K": state["temperatures_K"]["oven"]})
    csv_path = output_dir / "synthetic_chromatogram.csv"
    with csv_path.open("w", newline="", encoding="utf-8") as stream:
        writer = csv.DictWriter(stream, fieldnames=rows[0])
        writer.writeheader()
        writer.writerows(rows)
    metadata = {"parameter_provenance": PARAMETER_PROVENANCE, "method": asdict(gc.method),
                "synthetic_species": [asdict(item) for item in gc.species.values()],
                "final_state": gc.observe(), "events": gc.events,
                "integration": "Each CSV current is an interval mean; integral = sum(current * 0.5 s)."}
    (output_dir / "synthetic_run.json").write_text(json.dumps(metadata, ensure_ascii=False, indent=2), encoding="utf-8")
    return csv_path


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--demo-dir", type=Path, required=True)
    args = parser.parse_args()
    print(synthetic_demo(args.demo_dir))