| """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 |
| |
| |
| column_flow_m3_s: float = 1.6666666666666667e-8 |
| septum_purge_flow_m3_s: float = 5e-8 |
| |
| |
| 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 |
| |
| 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 |
| |
| |
| 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) |
| |
| 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)) |
|
|
