| """CHEM-094 Agilent 1260 Infinity III SFC system (G4301A SFC Control Module, G4782A SFC Binary Pump, G4767A SFC Multisampler, |
| G7116A Multicolumn Thermostat, G7115A DAD WR with SFC flow cell, solvent cabinet) - process runtime. |
| |
| Physics (SI; the host's step(dt_s) is the only clock): |
| * CO2 path: host-connected cylinder (40-70 bar documented supply) -> control-module chiller (first order to a 278.15 K target inside the |
| documented -20...9 degC range) -> booster -> pump channel A; modifier from bottle B1/B2 on channel B (high-pressure binary mixing). |
| * Hydraulics: pump pressure = BPR set pressure + Kozeny-Carman column drop (log-blended CO2/modifier viscosity) + extra-column drop; |
| 600 bar pump limit trips the pump (documented 600 bar); BPR 100-400 bar, 40-70 degC (documented G4301A ranges). |
| * Column oven: first-order heating / cooling with time constants derived from the documented MCT rates (ambient->40 degC ~5 min, |
| 40->20 degC ~10 min). |
| * Retention: per analyte, column and modifier the intercept a of log10 k = a - m log10(phi) comes from the measured CC BY 4.0 |
| retention times of the template library (back-solved, evidence 'derived'); the run integrates band migration |
| dz/dt = 1 / (t0 (1 + k(phi(t - t_D - z t0)))) for the configured program, with t0 = eps_T * column volume / flow, the documented |
| 600-900 uL pump delay volume, and a density correction from a Peng-Robinson CO2 equation of state (NIST critical constants). |
| * Detection: DAD absorbance A = eps(lambda) * 10 mm * c(t) (documented SFC flow cell 10 mm / 13 uL); eps from NIST UV curves where the |
| library holds one, else an assumed 1e3 m^2/mol (flagged); documented +-0.7e-5 AU noise and 0.9e-3 AU/h drift. |
| * Ledgers: vial volume and species moles (vial -> column -> waste/exhaust), modifier volume (bottle -> waste), CO2 mass (cylinder -> vent). |
| |
| Sessions filter visibility: agents never see the vial composition, process truths or ledgers; template.read only returns public reference |
| data. Matterix bridge: RECIPES module="asset_runtime.agilent_1260infinity", cls="Agilent1260infinityRuntime", instance_in_ctor=True, advance=STEP_DT. |
| """ |
| from __future__ import annotations |
|
|
| import copy |
| import hashlib |
| import json |
| import math |
| from functools import lru_cache |
| from pathlib import Path |
|
|
| import numpy as np |
|
|
| try: |
| from asset_runtime import _annotations as _ann |
| except ImportError: |
| _ann = None |
|
|
| PROTOCOL_VERSION = '1.0.0' |
| ASSET_TYPE_ID = 'instrument.agilent_1260infinity' |
| CATALOG_ID = 'CHEM-094' |
| ROOT = Path(__file__).resolve().parents[2] |
| LIBRARY_REL = 'assets/reactions/agilent_1260infinity_sfc_retention_library/sfc_retention_library.json' |
|
|
| |
| FLOW_MIN, FLOW_MAX = 0.001e-6 / 60, 5.0e-6 / 60 |
| PUMP_MAX_PA = 600e5 |
| BPR_MIN_PA, BPR_MAX_PA = 100e5, 400e5 |
| BPR_T_MIN, BPR_T_MAX = 313.15, 343.15 |
| SUPPLY_MIN_PA, SUPPLY_MAX_PA = 40e5, 70e5 |
| CHILLER_TARGET_K = 278.15 |
| INJ_MIN, INJ_MAX, INJ_STEP = 0.1e-9, 90e-9, 0.1e-9 |
| INJECT_CYCLE_S = 13.0 |
| COL_T_MAX = 358.15 |
| COL_T_ABS_MIN = 277.15 |
| N_COLUMN_POSITIONS = 4 |
| N_DRAWERS, N_VIAL_POSITIONS = 4, 108 |
| VIAL_CAPACITY_M3 = 2e-6 |
| LAMBDA_MIN, LAMBDA_MAX = 190e-9, 950e-9 |
| FLOW_CELL_PATH_M, FLOW_CELL_VOLUME_M3, FLOW_CELL_MAX_PA = 0.010, 13e-9, 400e5 |
| DAD_NOISE_AU, DAD_DRIFT_AU_S = 0.7e-5, 0.9e-3 / 3600.0 |
| DELAY_MIN_M3, DELAY_MAX_M3 = 600e-9, 900e-9 |
| MAX_PROGRAM_ROWS = 20 |
| |
| COL_TAU_HEAT_S = 300.0 / math.log(15.0 / 0.5) |
| COL_TAU_COOL_S = 600.0 / math.log(20.0 / 0.5) |
|
|
| |
| TOTAL_POROSITY = 0.65 |
| BED_POROSITY = 0.40 |
| LOGLOG_SLOPE_M = 1.5 |
| PHI_MIN = 0.01 |
| DENSITY_COEFF = 2.0 |
| REF_FLOW_M3_S = 1.5e-6 / 60 |
| REF_DWELL_S = 18.0 |
| REF_COLUMN_K, REF_BPR_PA = 313.15, 13.0e6 |
| PLATE_HEIGHT_DP = 3.0 |
| ETA_CO2_PA_S = 6.5e-5 |
| ETA_MEOH_PA_S = 5.44e-4 |
| EXTRA_COLUMN_R = 4.0e13 |
| PRESSURE_TAU_S, FLOW_TAU_S, BPR_HEAT_TAU_S, CHILLER_TAU_S = 3.0, 1.0, 60.0, 300.0 |
| ASSUMED_EPSILON_M2_MOL = 1.0e3 |
| VIAL_DEAD_VOLUME_M3 = 10e-9 |
| READY_TOL_PA, READY_TOL_K, READY_FLOW_FRACTION = 5e5, 1.0, 0.98 |
| CO2_PUMP_DENSITY_KG_M3 = 900.0 |
|
|
| |
| CO2_TC, CO2_PC, CO2_OMEGA, CO2_M = 304.1282, 7.3773e6, 0.22394, 0.0440095 |
| R_GAS = 8.314462618 |
|
|
| MODULES = ('control', 'pump', 'sampler', 'mct', 'dad') |
| MODIFIERS = ('methanol', 'methanol_ammonia_10mM', 'methanol_water_2pct') |
| PHASES = ('idle', 'injecting', 'running', 'succeeded', 'cancelled', 'failed') |
| MECH = { |
| 'sampler_door': ('sampler_door.angle_rad', 'rad', 1.75, 'sampler_door'), |
| 'drawer_1': ('drawer_1.position_m', 'm', 0.30, 'drawer_1'), |
| 'drawer_2': ('drawer_2.position_m', 'm', 0.30, 'drawer_2'), |
| 'drawer_3': ('drawer_3.position_m', 'm', 0.30, 'drawer_3'), |
| 'drawer_4': ('drawer_4.position_m', 'm', 0.30, 'drawer_4'), |
| 'mct_door': ('mct_door.angle_rad', 'rad', 1.50, 'mct_door'), |
| } |
|
|
|
|
| class ActionRejected(ValueError): |
| """Precondition / argument failure; the runtime state is unchanged. Messages never disclose sample identity.""" |
|
|
|
|
| |
| def number(unit, lo=None, hi=None): |
| d = {'type': 'number', 'x-unit': unit} |
| if lo is not None: |
| d['minimum'] = lo |
| if hi is not None: |
| d['maximum'] = hi |
| return d |
|
|
|
|
| def integer(lo, hi): |
| return {'type': 'integer', 'x-unit': '1', 'minimum': lo, 'maximum': hi} |
|
|
|
|
| def obj(props, required=None): |
| return {'type': 'object', 'properties': props, 'required': list(props) if required is None else required, 'additionalProperties': False} |
|
|
|
|
| def arr(items, lo=None, hi=None): |
| d = {'type': 'array', 'items': items} |
| if lo is not None: |
| d['minItems'] = lo |
| if hi is not None: |
| d['maxItems'] = hi |
| return d |
|
|
|
|
| def nullable(s): |
| return {'anyOf': [s, {'type': 'null'}]} |
|
|
|
|
| def enum(values): |
| return {'type': 'string', 'enum': list(values)} |
|
|
|
|
| BOOL, TEXT = {'type': 'boolean'}, {'type': 'string'} |
| COLUMN_IDS = ('silica', 'bridged_ethylene_hybrid', 'diol', 'c18_hss_sb', 'pfp_csh', 'pgc') |
| PROGRAM_ROW = obj({'time_s': number('s', 0, 3600), 'modifier_fraction': number('1', 0.0, 1.0)}) |
| METHOD = obj({ |
| 'flow_m3_s': number('m^3/s', FLOW_MIN, FLOW_MAX), 'modifier_channel': enum(['B1', 'B2']), |
| 'program': arr(PROGRAM_ROW, 1, MAX_PROGRAM_ROWS), 'bpr_pa': number('Pa', BPR_MIN_PA, BPR_MAX_PA), |
| 'bpr_temperature_k': number('K', BPR_T_MIN, BPR_T_MAX), 'column_temperature_k': number('K', COL_T_ABS_MIN, COL_T_MAX), |
| 'column_position': integer(1, N_COLUMN_POSITIONS), 'injection_volume_m3': number('m^3', INJ_MIN, INJ_MAX), |
| 'wavelength_m': number('m', LAMBDA_MIN, LAMBDA_MAX), 'run_time_s': number('s', 10, 3600), 'data_rate_hz': number('Hz', 0.5, 10)}) |
| METHOD_EXAMPLE = dict(flow_m3_s=REF_FLOW_M3_S, modifier_channel='B1', |
| program=[dict(time_s=0.0, modifier_fraction=0.02), dict(time_s=60.0, modifier_fraction=0.02), |
| dict(time_s=300.0, modifier_fraction=0.45), dict(time_s=360.0, modifier_fraction=0.45)], |
| bpr_pa=REF_BPR_PA, bpr_temperature_k=333.15, column_temperature_k=REF_COLUMN_K, column_position=1, |
| injection_volume_m3=2e-9, wavelength_m=254e-9, run_time_s=420.0, data_rate_hz=5.0) |
| SUPPLY = obj({'connected': BOOL, 'supply_pa': number('Pa', 0, 80e5), 'cylinder_co2_kg': number('kg', 0, 60), 'ambient_k': number('K', 288.15, 303.15)}) |
| SUPPLY_EXAMPLE = dict(connected=True, supply_pa=57e5, cylinder_co2_kg=10.0, ambient_k=298.15) |
| BOTTLE = obj({'channel': enum(['B1', 'B2']), 'modifier': enum(MODIFIERS), 'volume_m3': number('m^3', 0, 2e-3)}) |
| BOTTLE_EXAMPLE = dict(channel='B1', modifier='methanol', volume_m3=1e-3) |
| COLUMN_INSTALL = obj({'position': integer(1, N_COLUMN_POSITIONS), 'column': enum(list(COLUMN_IDS) + ['none'])}) |
| VIAL = obj({'drawer': integer(1, N_DRAWERS), 'position': integer(1, N_VIAL_POSITIONS), 'volume_m3': number('m^3', 1e-8, VIAL_CAPACITY_M3), |
| 'composition_mol_m3': {'type': 'object', 'additionalProperties': number('mol/m^3', 0, 1000), 'maxProperties': 16}}) |
| VIAL_EXAMPLE = dict(drawer=1, position=1, volume_m3=1e-6, composition_mol_m3={'caffeine': 0.257, 'vanillin': 0.329}) |
| VIAL_REF = obj({'drawer': integer(1, N_DRAWERS), 'position': integer(1, N_VIAL_POSITIONS)}) |
| PEAK = obj({'retention_time_s': number('s', 0), 'area_au_s': number('AU*s'), 'height_au': number('AU'), 'width_half_height_s': number('s', 0)}) |
| CHROM = obj({'run_id': TEXT, 'phase': enum(PHASES), 'elapsed_s': number('s', 0), 'time_s': arr(number('s', 0)), |
| 'absorbance_au': arr(number('AU')), 'peaks': arr(PEAK), 'complete': BOOL, 'wavelength_m': nullable(number('m')), |
| 'template_source': TEXT, 'evidence': TEXT, 'warnings': arr(TEXT)}) |
| QUANT_IN = obj({'calibration': arr(obj({'concentration_mol_m3': number('mol/m^3', 0, 1000), 'area_au_s': number('AU*s')}), 2, 20), |
| 'retention_window_s': arr(number('s', 0, 3600), 2, 2)}) |
| QUANT_OUT = obj({'slope_au_s_m3_mol': number('AU*s*m^3/mol'), 'intercept_au_s': number('AU*s'), 'r_squared': number('1', 0, 1), |
| 'peak_area_au_s': nullable(number('AU*s')), 'concentration_mol_m3': nullable(number('mol/m^3')), 'quality': TEXT}) |
| TEMPLATE_OUT = obj({'substance_id': TEXT, 'name': TEXT, 'cas': nullable(TEXT), 'molecular_weight_g_mol': nullable(number('g/mol')), |
| 'reference_retention_s': {'type': 'object', 'additionalProperties': {'type': 'object', 'additionalProperties': nullable(number('s', 0))}}, |
| 'uv_curve': BOOL, 'template_source': TEXT, 'evidence': TEXT, 'licence': TEXT}) |
| LEDGER = obj({'vial_volume_m3': number('m^3', 0), 'injected_volume_m3': number('m^3', 0), 'volume_residual_m3': number('m^3'), |
| 'species_residual_mol': number('mol'), 'injected_mol': number('mol', 0), 'column_mol': number('mol', 0), 'eluted_mol': number('mol', 0), |
| 'modifier_drawn_m3': number('m^3', 0), 'modifier_residual_m3': number('m^3'), 'co2_used_kg': number('kg', 0), 'co2_residual_kg': number('kg'), |
| 'waste_m3': number('m^3', 0)}) |
| EMPTY = obj({}) |
|
|
| |
| CAPS = {} |
|
|
|
|
| def _cap(key, inp, out, comps, meaning, kind='device_command', vis='agent', example=None, effects=()): |
| CAPS[key] = (inp, out, list(comps), meaning, kind, vis, example if example is not None else {}, list(effects)) |
|
|
|
|
| _cap('power.set', obj({'enabled': BOOL}), obj({'enabled': BOOL}), ['pump_power_switch', 'sampler_power_switch', 'mct_power_switch', 'dad_power_switch', 'control_power_switch'], |
| '整套五个模块统一通断电（软件/机器人整体操作）；断电停泵、取消运行，保留已注入物质', example={'enabled': True}, |
| effects=['power.enabled', 'pump.enabled', 'run.phase'] + [f'power.{m}' for m in MODULES]) |
| _cap('power.toggle', obj({'module': enum(MODULES)}), obj({'module': enum(MODULES), 'enabled': BOOL}), |
| ['pump_power_switch', 'sampler_power_switch', 'mct_power_switch', 'dad_power_switch', 'control_power_switch'], |
| '单个模块前面板（控制模块为背面）电源开关翻转；任一模块断电取消进行中的运行，仅泵或控制模块断电清除泵运行目标', example={'module': 'pump'}, |
| effects=['power.enabled', 'pump.enabled', 'run.phase'] + [f'power.{m}' for m in MODULES]) |
| _cap('supply.configure', SUPPLY, obj({'configured': BOOL}), ['co2_inlet', 'control_housing'], |
| '宿主连接CO2气瓶：供气表压、可用CO2质量与环境温度（实验室管路边界，非机器人动作）', 'configuration', 'evaluator', SUPPLY_EXAMPLE, |
| ['supply.connected', 'supply.pressure_pa', 'co2.ready']) |
| _cap('solvent.configure', BOTTLE, obj({'configured': BOOL}), ['bottle_b1', 'bottle_b2', 'solvent_cabinet'], |
| '宿主在溶剂柜放置改性剂瓶B1/B2（甲醇、甲醇+10 mmol/L氨、甲醇+2%水）及体积', 'configuration', 'evaluator', BOTTLE_EXAMPLE, ['solvent.b1', 'solvent.b2']) |
| _cap('column.install', COLUMN_INSTALL, obj({'position': integer(1, N_COLUMN_POSITIONS), 'column': enum(list(COLUMN_IDS) + ['none'])}), |
| ['column_1', 'column_2', 'column_3', 'column_4', 'mct_door'], |
| '在柱温箱四个柱位安装/拆下模板库六种固定相之一（100×3.0 mm）；要求柱温箱门打开且泵停', 'configuration', 'evaluator', |
| {'position': 1, 'column': 'silica'}, ['column.installed']) |
| _cap('sample.register_vial', VIAL, obj({'registered': BOOL}), ['drawer_1', 'drawer_2', 'drawer_3', 'drawer_4', 'vial_tray_1'], |
| '宿主登记已放入抽屉托盘的样品瓶：体积与真值组成（物质为模板库substance_id）；要求该抽屉拉出', 'configuration', 'evaluator', VIAL_EXAMPLE, |
| ['sample.vial_count']) |
| _cap('sample.remove_vial', VIAL_REF, obj({'returned_m3': number('m^3', 0)}), ['drawer_1', 'drawer_2', 'drawer_3', 'drawer_4'], |
| '取走样品瓶（返还剩余液体，已注入部分留在账本中）；要求抽屉拉出', 'configuration', 'evaluator', {'drawer': 1, 'position': 1}, ['sample.vial_count']) |
| _cap('method.configure', METHOD, obj({'configured': BOOL, 'delay_volume_m3': number('m^3', DELAY_MIN_M3, DELAY_MAX_M3)}), |
| ['pump_head_a', 'pump_head_b', 'column_valve', 'bpr_unit', 'flow_cell', 'sampler_housing'], |
| '写入方法目标：流量、改性剂通道与梯度表、背压与背压阀温度、柱温、柱位、进样体积、检测波长、运行时间与采样率；只写目标，实际值随step演化', |
| 'configuration', 'agent', METHOD_EXAMPLE, |
| ['method.configured', 'pump.flow_target_m3_s', 'bpr.target_pa', 'bpr.temperature_target_k', 'column.target_k', 'column.selected', 'detector.wavelength_m']) |
| _cap('pump.set', obj({'enabled': BOOL}), obj({'enabled': BOOL}), ['pump_head_a', 'pump_head_b', 'booster_unit'], |
| '泵运行目标（平衡/冲洗按方法初始组成）；需全部模块通电、CO2就绪、已配置方法且所选柱位有柱', example={'enabled': True}, effects=['pump.enabled']) |
| for _m, (_sid, _unit, _hi, _comp) in MECH.items(): |
| _arg = 'angle_rad' if _unit == 'rad' else 'position_m' |
| _cap(f'{_m}.set', obj({_arg: number(_unit, 0, _hi)}), obj({_arg: number(_unit, 0, _hi)}), [_comp], |
| '宿主/场景权威机构位置（0=关闭）；运行或进样中拒绝打开进样器门、抽屉与柱温箱门', example={_arg: 0.0}, effects=[_sid]) |
| _cap('run.start', VIAL_REF, obj({'phase': enum(PHASES), 'operation_id': TEXT}), ['needle_assembly', 'sampler_housing', 'column_valve', 'flow_cell'], |
| '从指定抽屉/瓶位进样并开始采集：系统就绪（流量、背压、柱温在容差内）、门和该抽屉关闭、瓶内余量足够；异步，按step推进到运行时间结束', |
| example={'drawer': 1, 'position': 1}, effects=['run.phase', 'run.elapsed_s', 'sample.vial_count']) |
| _cap('run.abort', EMPTY, obj({'phase': enum(PHASES)}), ['needle_assembly', 'flow_cell'], '取消当前进样/采集，保留已采集数据与物料账本', |
| effects=['run.phase']) |
| _cap('chromatogram.read', obj({'max_points': integer(10, 40000)}, required=[]), CHROM, ['flow_cell', 'dad_housing'], |
| '读取最近一次运行已采集的色谱图与峰表（无物质身份）；纯读取，不推进时钟', 'query', example={'max_points': 2000}) |
| _cap('peaks.quantify', QUANT_IN, QUANT_OUT, ['flow_cell'], |
| '用调用者提供的外标点（浓度-峰面积）线性拟合，并对最近完成运行中保留时间窗内最大峰定量；不访问样品真值', 'analysis', example=dict( |
| calibration=[dict(concentration_mol_m3=0.1, area_au_s=0.01), dict(concentration_mol_m3=0.5, area_au_s=0.05)], retention_window_s=[100.0, 200.0])) |
| _cap('template.read', obj({'substance_id': TEXT}), TEMPLATE_OUT, ['flow_cell'], |
| '查询公开的SFC保留时间模板（参考方法下六种柱×三种改性剂的实测首次进样保留时间）；与样品身份无关', 'query', example={'substance_id': 'caffeine'}) |
| _cap('ledger.read', EMPTY, LEDGER, ['vial_tray_1', 'column_1', 'waste_port', 'co2_inlet'], |
| '私有物料账本：样品瓶体积与物质（瓶→柱→废液/排气）、改性剂、CO2与废液守恒残差', 'query', 'evaluator') |
| UNSUPPORTED = ('chiral.separate', 'ms.detect', 'hardware.connect', 'sample_thermostat.set') |
| for _k, _z in (('chiral.separate', '手性柱与对映体分离：模板库无手性固定相实测数据，未实现'), |
| ('ms.detect', '质谱联用：本配置只有DAD，MS未实现'), |
| ('hardware.connect', '真实仪器（OpenLab CDS/RC.NET）连接未实现'), |
| ('sample_thermostat.set', '进样器样品恒温器为选配件，本配置未建模')): |
| _cap(_k, EMPTY, EMPTY, ['sampler_housing' if 'sample' in _k else 'control_housing'], _z) |
|
|
| |
| SLOTS = {} |
|
|
|
|
| def _slot(key, schema, unit, origin, vis, comps, write=None, meaning=''): |
| SLOTS[key] = (schema, unit, origin, vis, list(comps), write, meaning) |
|
|
|
|
| _slot('power.enabled', BOOL, '1', 'derived', 'agent', ['pump_power_switch'], None, '五个模块全部通电时为true') |
| for _m in MODULES: |
| _slot(f'power.{_m}', BOOL, '1', 'setpoint', 'agent', [f'{_m}_power_switch'], None, f'{_m}模块电源开关状态') |
| _slot(f'status.{_m}', enum(['off', 'not_ready', 'ready', 'run', 'error']), '1', 'derived', 'agent', [f'{_m}_status_led'], None, |
| f'{_m}模块状态指示灯代理（off/not_ready黄/ready绿/run/error红）') |
| _slot('supply.connected', BOOL, '1', 'scene', 'agent', ['co2_inlet'], None, 'CO2气瓶是否接到控制模块进口') |
| _slot('supply.pressure_pa', number('Pa', 0), 'Pa', 'derived', 'agent', ['co2_inlet'], None, 'CO2供气表压（气瓶空时为0）') |
| _slot('co2.ready', BOOL, '1', 'derived', 'agent', ['chiller_unit'], None, '供气压力在40–70 bar且冷却器≤9 °C时CO2调理就绪') |
| _slot('chiller.temperature_k', number('K', 0), 'K', 'process_truth', 'evaluator', ['chiller_unit'], None, 'CO2再液化冷却器温度真值') |
| _slot('booster.pressure_pa', number('Pa', 0), 'Pa', 'process_truth', 'evaluator', ['booster_unit'], None, '增压泵出口表压真值（略低于柱头压力）') |
| _slot('method.configured', BOOL, '1', 'setpoint', 'agent', ['sampler_housing']) |
| _slot('pump.enabled', BOOL, '1', 'setpoint', 'agent', ['pump_head_a'], ('pump.set', 'enabled')) |
| _slot('pump.flow_target_m3_s', nullable(number('m^3/s', FLOW_MIN, FLOW_MAX)), 'm^3/s', 'setpoint', 'agent', ['pump_head_a']) |
| _slot('pump.flow_m3_s', number('m^3/s', 0), 'm^3/s', 'derived', 'agent', ['pump_head_a'], None, '泵实际总体积流量（泵头条件，未作压缩性换算）') |
| _slot('pump.modifier_fraction', number('1', 0, 1), '1', 'derived', 'agent', ['pump_head_b'], None, '泵出口改性剂体积分数（梯度表当前值）') |
| _slot('pump.pressure_pa', number('Pa', 0), 'Pa', 'process_truth', 'evaluator', ['pump_head_a'], None, '泵出口表压真值') |
| _slot('pump.indicated_pressure_pa', number('Pa', 0), 'Pa', 'derived', 'agent', ['pump_head_a'], None, '泵压力显示（0.1 bar量化）') |
| _slot('bpr.target_pa', nullable(number('Pa', BPR_MIN_PA, BPR_MAX_PA)), 'Pa', 'setpoint', 'agent', ['bpr_unit']) |
| _slot('bpr.pressure_pa', number('Pa', 0), 'Pa', 'process_truth', 'evaluator', ['bpr_unit'], None, '背压阀入口表压真值（系统出口压力）') |
| _slot('bpr.indicated_pressure_pa', number('Pa', 0), 'Pa', 'derived', 'agent', ['bpr_unit'], None, '背压显示（±0.25 bar精度代理，0.01 bar量化）') |
| _slot('bpr.temperature_target_k', nullable(number('K', BPR_T_MIN, BPR_T_MAX)), 'K', 'setpoint', 'agent', ['bpr_unit']) |
| _slot('bpr.temperature_k', number('K', 0), 'K', 'process_truth', 'evaluator', ['bpr_unit'], None, '背压阀加热头温度真值') |
| _slot('column.target_k', nullable(number('K', COL_T_ABS_MIN, COL_T_MAX)), 'K', 'setpoint', 'agent', ['mct_housing']) |
| _slot('column.temperature_k', number('K', 0), 'K', 'process_truth', 'evaluator', ['mct_housing'], None, '柱温箱温区温度真值（单节点）') |
| _slot('column.indicated_k', number('K', 0), 'K', 'derived', 'agent', ['mct_housing'], None, '柱温显示（0.1 K量化）') |
| _slot('column.selected', nullable(integer(1, N_COLUMN_POSITIONS)), '1', 'setpoint', 'agent', ['column_valve']) |
| _slot('column.installed', {'type': 'array', 'items': enum(list(COLUMN_IDS) + ['none']), 'minItems': 4, 'maxItems': 4}, '1', 'scene', 'agent', |
| ['column_1', 'column_2', 'column_3', 'column_4'], None, '四个柱位安装的固定相类型（实验室配置，agent可见）') |
| _slot('mobile_phase.co2_density_kg_m3', nullable(number('kg/m^3', 0)), 'kg/m^3', 'process_truth', 'evaluator', ['column_1'], None, |
| '柱温与背压下纯CO2密度（Peng-Robinson）') |
| _slot('detector.wavelength_m', nullable(number('m', LAMBDA_MIN, LAMBDA_MAX)), 'm', 'setpoint', 'agent', ['flow_cell']) |
| _slot('detector.absorbance_au', number('AU'), 'AU', 'derived', 'agent', ['flow_cell'], None, '流通池当前吸光度（含噪声与漂移）') |
| _slot('system.ready', BOOL, '1', 'derived', 'agent', ['control_status_led'], None, '流量、背压、柱温均到达方法目标容差内') |
| _slot('system.fault', TEXT, '1', 'derived', 'agent', ['control_status_led'], None, '最近故障代码（空串=无）') |
| _slot('run.phase', enum(PHASES), '1', 'derived', 'agent', ['dad_status_led']) |
| _slot('run.elapsed_s', number('s', 0), 's', 'derived', 'agent', ['dad_status_led'], None, '自进样阀切换（采集零点）起的运行时间') |
| _slot('run.count', integer(0, 10 ** 9), '1', 'derived', 'agent', ['dad_status_led'], None, '已启动的运行次数') |
| _slot('sample.vial_count', integer(0, N_DRAWERS * N_VIAL_POSITIONS), '1', 'scene', 'agent', ['vial_tray_1'], None, '已登记样品瓶数') |
| for _m, (_sid, _unit, _hi, _comp) in MECH.items(): |
| _slot(_sid, number(_unit, 0, _hi), _unit, 'scene', 'agent', [_comp], (f'{_m}.set', 'angle_rad' if _unit == 'rad' else 'position_m')) |
| _slot('solvent.b1', nullable(enum(MODIFIERS)), '1', 'scene', 'agent', ['bottle_b1'], None, 'B1瓶改性剂类型') |
| _slot('solvent.b2', nullable(enum(MODIFIERS)), '1', 'scene', 'agent', ['bottle_b2'], None, 'B2瓶改性剂类型') |
| _slot('truth.bottle_b1_m3', number('m^3', 0), 'm^3', 'process_truth', 'evaluator', ['bottle_b1'], None, 'B1瓶剩余改性剂体积') |
| _slot('truth.bottle_b2_m3', number('m^3', 0), 'm^3', 'process_truth', 'evaluator', ['bottle_b2'], None, 'B2瓶剩余改性剂体积') |
| _slot('truth.cylinder_co2_kg', number('kg', 0), 'kg', 'process_truth', 'evaluator', ['co2_inlet'], None, '气瓶剩余CO2质量') |
| _slot('truth.vented_co2_kg', number('kg', 0), 'kg', 'process_truth', 'evaluator', ['exhaust_port'], None, '经背压阀排出的CO2累计质量') |
| _slot('truth.waste_m3', number('m^3', 0), 'm^3', 'process_truth', 'evaluator', ['waste_port'], None, '废液（改性剂+样品溶剂）累计体积') |
| _slot('truth.column_mol', number('mol', 0), 'mol', 'process_truth', 'evaluator', ['column_1'], None, '已注入但尚未流出色谱柱的物质总量') |
| _slot('truth.eluted_mol', number('mol', 0), 'mol', 'process_truth', 'evaluator', ['waste_port'], None, '已流出到废液/排气的物质总量') |
|
|
| REFERENCE_ZH = { |
| 'supply.pressure_pa': '表压；CO2供气相对环境大气压。厂家40–70 bar（580–1000 psi）按表压解释，这是本资产的假设。', |
| 'booster.pressure_pa': '表压；相对环境大气压。', 'pump.pressure_pa': '表压；相对环境大气压，=背压+柱压降+柱外压降。', |
| 'pump.indicated_pressure_pa': '表压；相对环境大气压。厂家600 bar上限按表压解释。', |
| 'bpr.target_pa': '表压；背压阀设定相对环境大气压（厂家100–400 bar）。', 'bpr.pressure_pa': '表压；相对环境大气压。', |
| 'bpr.indicated_pressure_pa': '表压；相对环境大气压。', |
| 'pump.flow_target_m3_s': '泵头条件下的总体积流量（CO2+改性剂），与厂家mL/min设定一致；未作可压缩性换算。', |
| 'pump.flow_m3_s': '泵头条件下的总体积流量（CO2+改性剂）；色谱模型按柱内体积流量近似使用。', |
| 'mobile_phase.co2_density_kg_m3': '纯CO2在柱温与背压（绝压=表压+101325 Pa）下的Peng-Robinson密度；忽略改性剂对密度的影响。', |
| } |
|
|
|
|
| |
| def co2_density(temperature_k, pressure_abs_pa): |
| """Peng-Robinson density of pure CO2 (dense root). NIST critical constants; ~5-10 % below reference data in the dense region.""" |
| a = 0.45724 * R_GAS ** 2 * CO2_TC ** 2 / CO2_PC |
| b = 0.07780 * R_GAS * CO2_TC / CO2_PC |
| kappa = 0.37464 + 1.54226 * CO2_OMEGA - 0.26992 * CO2_OMEGA ** 2 |
| alpha = (1 + kappa * (1 - math.sqrt(temperature_k / CO2_TC))) ** 2 |
| A = a * alpha * pressure_abs_pa / (R_GAS * temperature_k) ** 2 |
| B = b * pressure_abs_pa / (R_GAS * temperature_k) |
| roots = np.roots([1.0, -(1 - B), A - 3 * B ** 2 - 2 * B, -(A * B - B ** 2 - B ** 3)]) |
| real = sorted(r.real for r in roots if abs(r.imag) < 1e-9 and r.real > B) |
| z = real[0] |
| return float(pressure_abs_pa * CO2_M / (z * R_GAS * temperature_k)) |
|
|
|
|
| @lru_cache(maxsize=1) |
| def _rho_ref(): |
| return co2_density(REF_COLUMN_K, REF_BPR_PA + 101325.0) |
|
|
|
|
| def void_time_s(length_m, inner_diameter_m, flow_m3_s): |
| return TOTAL_POROSITY * math.pi * (inner_diameter_m / 2) ** 2 * length_m / flow_m3_s |
|
|
|
|
| def delay_volume_m3(bpr_pa): |
| """Documented 600-900 uL 'depending on back pressure'; linear in the 100-400 bar BPR range (mapping is an assumption).""" |
| f = min(1.0, max(0.0, (bpr_pa - BPR_MIN_PA) / (BPR_MAX_PA - BPR_MIN_PA))) |
| return DELAY_MIN_M3 + f * (DELAY_MAX_M3 - DELAY_MIN_M3) |
|
|
|
|
| def mixture_viscosity(phi): |
| phi = min(1.0, max(0.0, phi)) |
| return math.exp(phi * math.log(ETA_MEOH_PA_S) + (1 - phi) * math.log(ETA_CO2_PA_S)) |
|
|
|
|
| def column_pressure_drop(flow_m3_s, phi, column): |
| """Kozeny-Carman drop over the packed bed (Pa).""" |
| area = math.pi * (column['inner_diameter_m'] / 2) ** 2 |
| u_s = flow_m3_s / area |
| e = BED_POROSITY |
| return 180.0 * mixture_viscosity(phi) * u_s * column['length_m'] * (1 - e) ** 2 / (e ** 3 * column['particle_m'] ** 2) |
|
|
|
|
| def program_value(program, t): |
| """Piecewise-linear modifier fraction; holds the first value before t=0 and the last after the table.""" |
| times = np.array([p[0] for p in program], float) |
| vals = np.array([p[1] for p in program], float) |
| return np.interp(t, times, vals) |
|
|
|
|
| def migrate(a, m, program, t0_s, delay_s, t_end_s, dt_s=0.05, extra_ln_k=0.0): |
| """Vectorised band migration under a gradient. a: array of log10 k at phi = 1. Returns (t_R, k at elution, phi at elution); |
| NaN where the band has not left the column by t_end_s.""" |
| a = np.atleast_1d(np.asarray(a, float)) |
| z = np.zeros_like(a) |
| tr = np.full_like(a, np.nan) |
| ke = np.full_like(a, np.nan) |
| pe = np.full_like(a, np.nan) |
| times = np.array([p[0] for p in program], float) |
| vals = np.array([p[1] for p in program], float) |
| t = 0.0 |
| while t < t_end_s and np.isnan(tr).any(): |
| phi = np.interp(t - delay_s - z * t0_s, times, vals) |
| k = 10.0 ** (a - m * np.log10(np.maximum(phi, PHI_MIN))) * math.exp(extra_ln_k) |
| v = 1.0 / (t0_s * (1.0 + k)) |
| z_new = z + v * dt_s |
| done = (z_new >= 1.0) & np.isnan(tr) |
| if done.any(): |
| frac = (1.0 - z[done]) / (z_new[done] - z[done]) |
| tr[done] = t + frac * dt_s |
| ke[done] = k[done] |
| pe[done] = phi[done] |
| z = np.where(np.isnan(tr), z_new, z) |
| t += dt_s |
| return tr, ke, pe |
|
|
|
|
| @lru_cache(maxsize=1) |
| def library(): |
| data = json.loads((ROOT / LIBRARY_REL).read_text(encoding='utf-8')) |
| return data |
|
|
|
|
| @lru_cache(maxsize=1) |
| def library_sha256(): |
| return hashlib.sha256((ROOT / LIBRARY_REL).read_bytes()).hexdigest() |
|
|
|
|
| @lru_cache(maxsize=1) |
| def columns(): |
| """Stationary phases of the source data by id (stored as a list in the library so that column ids are never mistaken for compound ids).""" |
| return {c['column_id']: c for c in library()['columns']} |
|
|
|
|
| @lru_cache(maxsize=1) |
| def templates(): |
| return {r['substance_id']: r for r in library()['templates']} |
|
|
|
|
| def epsilon(sid, wavelength_m): |
| """(epsilon m^2/mol, evidence) at the wavelength: NIST curve when the library has one covering it, else the flagged assumption.""" |
| uv = templates()[sid].get('uv_vis') |
| if uv and uv['wavelength_m'][0] <= wavelength_m <= uv['wavelength_m'][-1]: |
| log_eps = float(np.interp(wavelength_m, uv['wavelength_m'], uv['log10_epsilon_l_mol_cm'])) |
| return 10.0 ** log_eps * 0.1, 'measured_nist_uv' |
| return ASSUMED_EPSILON_M2_MOL, 'assumption' |
|
|
|
|
| def baseline(time_s, signal, segment_s=30.0): |
| """Slowly varying baseline: 20th percentile of each segment, linearly interpolated (removes detector drift before peak picking).""" |
| t = np.asarray(time_s, float) |
| y = np.asarray(signal, float) |
| if len(t) < 3: |
| return np.zeros_like(y) |
| edges = np.arange(t[0], t[-1] + segment_s, segment_s) |
| cx, cy = [], [] |
| for lo, hi in zip(edges[:-1], edges[1:]): |
| sel = (t >= lo) & (t < hi) |
| if sel.sum() >= 3: |
| cx.append(float(t[sel].mean())) |
| cy.append(float(np.percentile(y[sel], 20))) |
| if not cx: |
| return np.full_like(y, float(np.percentile(y, 20))) |
| return np.interp(t, cx, cy) |
|
|
|
|
| def detect_peaks(time_s, signal, threshold): |
| """Baseline-corrected local maxima above threshold; area by trapezoid between the neighbouring minima (or the trace ends).""" |
| t = np.asarray(time_s, float) |
| y = np.asarray(signal, float) - baseline(time_s, signal) |
| peaks = [] |
| if len(y) < 5: |
| return peaks |
| i = 1 |
| while i < len(y) - 1: |
| if y[i] >= threshold and y[i] >= y[i - 1] and y[i] > y[i + 1]: |
| lo = i |
| while lo > 0 and y[lo - 1] <= y[lo] and y[lo - 1] > threshold * 0.2: |
| lo -= 1 |
| hi = i |
| while hi < len(y) - 1 and y[hi + 1] <= y[hi] and y[hi + 1] > threshold * 0.2: |
| hi += 1 |
| seg_t, seg_y = t[max(0, lo - 1):hi + 2], y[max(0, lo - 1):hi + 2] |
| area = float(np.trapezoid(seg_y, seg_t)) if len(seg_t) > 1 else 0.0 |
| half = y[i] / 2 |
| above = np.where(seg_y >= half)[0] |
| width = float(seg_t[above[-1]] - seg_t[above[0]]) if len(above) > 1 else 0.0 |
| peaks.append(dict(retention_time_s=float(t[i]), area_au_s=area, height_au=float(y[i]), width_half_height_s=width)) |
| i = hi + 1 |
| else: |
| i += 1 |
| return peaks |
|
|
|
|
| def validate(schema, value): |
| if 'anyOf' in schema: |
| for s in schema['anyOf']: |
| try: |
| validate(s, value) |
| return |
| except ActionRejected: |
| pass |
| raise ActionRejected('INVALID_ARGUMENT') |
| t = schema.get('type') |
| if t in ('number', 'integer'): |
| if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value): |
| raise ActionRejected('INVALID_ARGUMENT') |
| if t == 'integer' and (not isinstance(value, int)): |
| raise ActionRejected('INVALID_ARGUMENT') |
| if value < schema.get('minimum', -math.inf) or value > schema.get('maximum', math.inf): |
| raise ActionRejected('INVALID_ARGUMENT') |
| elif t == 'boolean': |
| if type(value) is not bool: |
| raise ActionRejected('INVALID_ARGUMENT') |
| elif t == 'string': |
| if not isinstance(value, str): |
| raise ActionRejected('INVALID_ARGUMENT') |
| elif t == 'null': |
| if value is not None: |
| raise ActionRejected('INVALID_ARGUMENT') |
| elif t == 'array': |
| if not isinstance(value, list) or not schema.get('minItems', 0) <= len(value) <= schema.get('maxItems', math.inf): |
| raise ActionRejected('INVALID_ARGUMENT') |
| for v in value: |
| validate(schema['items'], v) |
| elif t == 'object': |
| if not isinstance(value, dict) or not set(schema.get('required', [])) <= set(value): |
| raise ActionRejected('INVALID_ARGUMENT') |
| if len(value) > schema.get('maxProperties', math.inf): |
| raise ActionRejected('INVALID_ARGUMENT') |
| props = schema.get('properties', {}) |
| for k, v in value.items(): |
| if not isinstance(k, str): |
| raise ActionRejected('INVALID_ARGUMENT') |
| sub = props.get(k, schema.get('additionalProperties', True)) |
| if sub is False: |
| raise ActionRejected('INVALID_ARGUMENT') |
| if isinstance(sub, dict): |
| validate(sub, v) |
| if 'enum' in schema and value not in schema['enum']: |
| raise ActionRejected('INVALID_ARGUMENT') |
|
|
|
|
| |
| class Agilent1260infinityRuntime: |
| """Process model of one SFC system instance (host-owned clock).""" |
|
|
| def __init__(self, instance_id='sfc_01'): |
| self.instance_id = instance_id |
| self.time_s = 0.0 |
| self.revision = 0 |
| self.ambient_k = 298.15 |
| self.power = {m: False for m in MODULES} |
| self.supply = dict(connected=False, supply_pa=0.0, cylinder_co2_kg=0.0) |
| self.co2_initial_kg = 0.0 |
| self.vented_co2_kg = 0.0 |
| self.bottles = {'B1': None, 'B2': None} |
| self.modifier_loaded_m3 = 0.0 |
| self.modifier_drawn_m3 = 0.0 |
| self.waste_m3 = 0.0 |
| self.columns = {p: 'none' for p in range(1, N_COLUMN_POSITIONS + 1)} |
| self.mech = {m: 0.0 for m in MECH} |
| self.vials = {} |
| self.vial_loaded_m3 = 0.0 |
| self.vial_returned_m3 = 0.0 |
| self.injected_m3 = 0.0 |
| self.method = None |
| self.pump_enabled = False |
| self.chiller_k = 298.15 |
| self.booster_pa = 0.0 |
| self.flow = 0.0 |
| self.pump_pa = 0.0 |
| self.bpr_pa = 0.0 |
| self.bpr_k = 298.15 |
| self.column_k = 298.15 |
| self.fault = '' |
| self.phase = 'idle' |
| self.run = None |
| self.run_count = 0 |
| self.operation_id = None |
| self.bands = [] |
| self.injected_mol = 0.0 |
| self.eluted_mol = 0.0 |
| self.absorbance = 0.0 |
| self._principals = {'__public_agent__': 'agent'} |
| self._requests = {} |
| self._owners = {} |
|
|
| |
| def register_principal(self, principal_id, visibility='agent'): |
| if visibility not in ('agent', 'evaluator', 'debug'): |
| raise ActionRejected('INVALID_ARGUMENT') |
| if principal_id in self._principals: |
| raise ActionRejected('REQUEST_CONFLICT') |
| self._principals[principal_id] = visibility |
|
|
| def session(self, principal_id='__public_agent__'): |
| if principal_id not in self._principals: |
| raise ActionRejected('ACCESS_DENIED') |
| return Agilent1260infinitySession(self, principal_id) |
|
|
| def describe(self): |
| return self.session().describe(instance_id=self.instance_id) |
|
|
| |
| def _column(self): |
| if not self.method: |
| return None |
| cid = self.columns[self.method['column_position']] |
| return None if cid == 'none' else dict(columns()[cid], id=cid) |
|
|
| def _program(self): |
| return [(r['time_s'], r['modifier_fraction']) for r in self.method['program']] |
|
|
| def _phi_now(self): |
| if not self.method: |
| return 0.0 |
| prog = self._program() |
| if self.phase == 'running' and self.run: |
| return float(program_value(prog, self.run['elapsed'])) |
| return float(prog[0][1]) |
|
|
| def _all_powered(self): |
| return all(self.power.values()) |
|
|
| def _co2_ready(self): |
| return (self.supply['connected'] and SUPPLY_MIN_PA <= self.supply['supply_pa'] <= SUPPLY_MAX_PA + 1e5 |
| and self.supply['cylinder_co2_kg'] > 0 and self.chiller_k <= 282.15 and self.power['control']) |
|
|
| def _ready(self): |
| if not (self.method and self.pump_enabled and self._all_powered() and self._co2_ready() and not self.fault): |
| return False |
| m = self.method |
| return (self.flow >= READY_FLOW_FRACTION * m['flow_m3_s'] and abs(self.bpr_pa - m['bpr_pa']) <= READY_TOL_PA |
| and abs(self.column_k - m['column_temperature_k']) <= READY_TOL_K) |
|
|
| def _status(self, module): |
| if not self.power[module]: |
| return 'off' |
| if self.fault: |
| return 'error' |
| if self.phase in ('injecting', 'running'): |
| return 'run' |
| return 'ready' if self._ready() else 'not_ready' |
|
|
| def _density(self): |
| if not self.method: |
| return None |
| return co2_density(self.column_k, max(self.bpr_pa, 1e5) + 101325.0) |
|
|
| def _values(self): |
| m = self.method or {} |
| v = {'power.enabled': self._all_powered()} |
| for mod in MODULES: |
| v[f'power.{mod}'] = self.power[mod] |
| v[f'status.{mod}'] = self._status(mod) |
| v.update({ |
| 'supply.connected': self.supply['connected'], |
| 'supply.pressure_pa': self.supply['supply_pa'] if self.supply['connected'] and self.supply['cylinder_co2_kg'] > 0 else 0.0, |
| 'co2.ready': bool(self._co2_ready()), 'chiller.temperature_k': self.chiller_k, 'booster.pressure_pa': self.booster_pa, |
| 'method.configured': self.method is not None, 'pump.enabled': self.pump_enabled, |
| 'pump.flow_target_m3_s': m.get('flow_m3_s'), 'pump.flow_m3_s': self.flow, |
| 'pump.modifier_fraction': self._phi_now() if self.pump_enabled else 0.0, |
| 'pump.pressure_pa': self.pump_pa, 'pump.indicated_pressure_pa': round(self.pump_pa / 1e4) * 1e4, |
| 'bpr.target_pa': m.get('bpr_pa'), 'bpr.pressure_pa': self.bpr_pa, 'bpr.indicated_pressure_pa': round(self.bpr_pa / 1e3) * 1e3, |
| 'bpr.temperature_target_k': m.get('bpr_temperature_k'), 'bpr.temperature_k': self.bpr_k, |
| 'column.target_k': m.get('column_temperature_k'), 'column.temperature_k': self.column_k, |
| 'column.indicated_k': round(self.column_k * 10) / 10, 'column.selected': m.get('column_position'), |
| 'column.installed': [self.columns[p] for p in range(1, N_COLUMN_POSITIONS + 1)], |
| 'mobile_phase.co2_density_kg_m3': self._density(), 'detector.wavelength_m': m.get('wavelength_m'), |
| 'detector.absorbance_au': self.absorbance, 'system.ready': self._ready(), 'system.fault': self.fault, |
| 'run.phase': self.phase, 'run.elapsed_s': self.run['elapsed'] if self.run else 0.0, 'run.count': self.run_count, |
| 'sample.vial_count': len(self.vials), |
| 'solvent.b1': (self.bottles['B1'] or {}).get('modifier'), 'solvent.b2': (self.bottles['B2'] or {}).get('modifier'), |
| 'truth.bottle_b1_m3': (self.bottles['B1'] or {}).get('volume_m3', 0.0), 'truth.bottle_b2_m3': (self.bottles['B2'] or {}).get('volume_m3', 0.0), |
| 'truth.cylinder_co2_kg': self.supply['cylinder_co2_kg'], 'truth.vented_co2_kg': self.vented_co2_kg, 'truth.waste_m3': self.waste_m3, |
| 'truth.column_mol': sum(b['mol'] for b in self.bands if not b['eluted']), 'truth.eluted_mol': self.eluted_mol}) |
| for name, (sid, *_r) in MECH.items(): |
| v[sid] = self.mech[name] |
| return v |
|
|
| def read(self, visibility='agent'): |
| return copy.deepcopy({k: val for k, val in self._values().items() if SLOTS[k][3] == 'agent' or visibility in ('evaluator', 'debug')}) |
|
|
| def _ledger(self): |
| vial = sum(x['volume_m3'] for x in self.vials.values()) |
| species_in_vials = sum(x['volume_m3'] * sum(x['composition'].values()) for x in self.vials.values()) |
| column = sum(b['mol'] for b in self.bands if not b['eluted']) |
| bottles = sum((b or {}).get('volume_m3', 0.0) for b in self.bottles.values()) |
| return dict(vial_volume_m3=vial, injected_volume_m3=self.injected_m3, |
| volume_residual_m3=self.vial_loaded_m3 - vial - self.injected_m3 - self.vial_returned_m3, |
| species_residual_mol=self._species_loaded - species_in_vials - self.injected_mol - self._species_returned, |
| injected_mol=self.injected_mol, column_mol=column, eluted_mol=self.eluted_mol, |
| modifier_drawn_m3=self.modifier_drawn_m3, modifier_residual_m3=self.modifier_loaded_m3 - bottles - self.modifier_drawn_m3, |
| co2_used_kg=self.vented_co2_kg, co2_residual_kg=self.co2_initial_kg - self.supply['cylinder_co2_kg'] - self.vented_co2_kg, |
| waste_m3=self.waste_m3) |
|
|
| _species_loaded = 0.0 |
| _species_returned = 0.0 |
|
|
| |
| def invoke(self, capability, **a): |
| if capability not in CAPS: |
| raise ActionRejected('UNKNOWN_CAPABILITY') |
| if capability in UNSUPPORTED: |
| raise ActionRejected('UNSUPPORTED') |
| validate(CAPS[capability][0], a) |
| if CAPS[capability][4] in ('query', 'analysis'): |
| result = self._invoke(capability, a) |
| validate(CAPS[capability][1], result) |
| return copy.deepcopy(result) |
| before = copy.deepcopy({k: v for k, v in self.__dict__.items() if k not in ('_principals', '_requests', '_owners')}) |
| try: |
| result = self._invoke(capability, a) |
| validate(CAPS[capability][1], result) |
| except Exception: |
| self.__dict__.update(before) |
| raise |
| self.revision += 1 |
| return copy.deepcopy(result) |
|
|
| def _busy(self): |
| return self.phase in ('injecting', 'running') |
|
|
| def _invoke(self, k, a): |
| if k == 'chromatogram.read': |
| return self._chromatogram(a.get('max_points', 2000)) |
| if k == 'ledger.read': |
| return self._ledger() |
| if k == 'template.read': |
| return self._template(a['substance_id']) |
| if k == 'peaks.quantify': |
| return self._quantify(a) |
| if k == 'power.set': |
| for m in MODULES: |
| self.power[m] = a['enabled'] |
| if not a['enabled']: |
| self._power_lost('control') |
| return {'enabled': a['enabled']} |
| if k == 'power.toggle': |
| self.power[a['module']] = not self.power[a['module']] |
| if not self.power[a['module']]: |
| self._power_lost(a['module']) |
| return {'module': a['module'], 'enabled': self.power[a['module']]} |
| if k == 'supply.configure': |
| if self.pump_enabled: |
| raise ActionRejected('PRECONDITION_FAILED') |
| if a['connected'] and not (SUPPLY_MIN_PA <= a['supply_pa'] <= SUPPLY_MAX_PA): |
| raise ActionRejected('INVALID_ARGUMENT') |
| self.supply = dict(connected=a['connected'], supply_pa=a['supply_pa'] if a['connected'] else 0.0, cylinder_co2_kg=a['cylinder_co2_kg']) |
| self.co2_initial_kg = a['cylinder_co2_kg'] + self.vented_co2_kg |
| if self.ambient_k != a['ambient_k'] and not any(self.power.values()): |
| self.chiller_k = self.bpr_k = self.column_k = a['ambient_k'] |
| self.ambient_k = a['ambient_k'] |
| return {'configured': True} |
| if k == 'solvent.configure': |
| if self.pump_enabled: |
| raise ActionRejected('PRECONDITION_FAILED') |
| old = (self.bottles[a['channel']] or {}).get('volume_m3', 0.0) |
| self.modifier_loaded_m3 += a['volume_m3'] - old |
| self.bottles[a['channel']] = dict(modifier=a['modifier'], volume_m3=a['volume_m3']) |
| return {'configured': True} |
| if k == 'column.install': |
| if self.pump_enabled or self._busy() or self.mech['mct_door'] < 0.5: |
| raise ActionRejected('PRECONDITION_FAILED') |
| self.columns[a['position']] = a['column'] |
| return dict(a) |
| if k == 'sample.register_vial': |
| if self.mech[f"drawer_{a['drawer']}"] < 0.15 or (a['drawer'], a['position']) in self.vials: |
| raise ActionRejected('PRECONDITION_FAILED') |
| comp = a['composition_mol_m3'] |
| if not comp or any(s not in templates() for s in comp): |
| raise ActionRejected('INVALID_ARGUMENT') |
| self.vials[(a['drawer'], a['position'])] = dict(volume_m3=a['volume_m3'], composition=dict(comp)) |
| self.vial_loaded_m3 += a['volume_m3'] |
| self._species_loaded += a['volume_m3'] * sum(comp.values()) |
| return {'registered': True} |
| if k == 'sample.remove_vial': |
| key = (a['drawer'], a['position']) |
| if key not in self.vials or self.mech[f"drawer_{a['drawer']}"] < 0.15: |
| raise ActionRejected('PRECONDITION_FAILED') |
| v = self.vials.pop(key) |
| self.vial_returned_m3 += v['volume_m3'] |
| self._species_returned += v['volume_m3'] * sum(v['composition'].values()) |
| return {'returned_m3': v['volume_m3']} |
| if k == 'method.configure': |
| if self._busy(): |
| raise ActionRejected('BUSY') |
| prog = a['program'] |
| if prog[0]['time_s'] != 0.0 or any(prog[i + 1]['time_s'] <= prog[i]['time_s'] for i in range(len(prog) - 1)): |
| raise ActionRejected('INVALID_ARGUMENT') |
| if a['column_temperature_k'] < max(COL_T_ABS_MIN, self.ambient_k - 10.0): |
| raise ActionRejected('INVALID_ARGUMENT') |
| n = a['injection_volume_m3'] / INJ_STEP |
| if abs(n - round(n)) > 1e-6: |
| raise ActionRejected('INVALID_ARGUMENT') |
| if self.pump_enabled: |
| bottle = self.bottles[a['modifier_channel']] |
| if not bottle or bottle['volume_m3'] <= 0 or self.columns[a['column_position']] == 'none': |
| raise ActionRejected('PRECONDITION_FAILED') |
| self.method = copy.deepcopy(a) |
| return {'configured': True, 'delay_volume_m3': delay_volume_m3(a['bpr_pa'])} |
| if k == 'pump.set': |
| if a['enabled']: |
| if not (self._all_powered() and self._co2_ready() and self.method and self._column()): |
| raise ActionRejected('PRECONDITION_FAILED') |
| bottle = self.bottles[self.method['modifier_channel']] |
| if not bottle or bottle['volume_m3'] <= 0: |
| raise ActionRejected('PRECONDITION_FAILED') |
| self.fault = '' |
| elif self._busy(): |
| self._finish('cancelled') |
| self.pump_enabled = a['enabled'] |
| return {'enabled': a['enabled']} |
| if k.endswith('.set') and k[:-4] in MECH: |
| name = k[:-4] |
| arg = 'angle_rad' if MECH[name][1] == 'rad' else 'position_m' |
| opening = a[arg] > 1e-6 |
| if opening and self._busy(): |
| raise ActionRejected('BUSY') |
| self.mech[name] = a[arg] |
| return dict(a) |
| if k == 'run.start': |
| return self._start(a) |
| if k == 'run.abort': |
| if self._busy(): |
| self._finish('cancelled') |
| return {'phase': self.phase} |
| raise ActionRejected('UNKNOWN_CAPABILITY') |
|
|
| def _power_lost(self, module): |
| """A module lost power: any run in progress is cancelled (every module takes part in a run); the pump target is cleared only when |
| the pump itself or the control module (CO2 conditioning, BPR) is off - the other modules are independent of the pump.""" |
| if self._busy(): |
| self._finish('cancelled') |
| if module in ('pump', 'control'): |
| self.pump_enabled = False |
|
|
| def _start(self, a): |
| if self._busy(): |
| raise ActionRejected('BUSY') |
| key = (a['drawer'], a['position']) |
| if not self._ready() or self.mech['sampler_door'] > 1e-6 or self.mech[f"drawer_{a['drawer']}"] > 1e-6: |
| raise ActionRejected('PRECONDITION_FAILED') |
| vial = self.vials.get(key) |
| m = self.method |
| if vial is None or vial['volume_m3'] < m['injection_volume_m3'] + VIAL_DEAD_VOLUME_M3: |
| raise ActionRejected('PRECONDITION_FAILED') |
| bottle = self.bottles[m['modifier_channel']] |
| if not bottle or self._column() is None: |
| raise ActionRejected('PRECONDITION_FAILED') |
| need = sum(m['flow_m3_s'] * float(program_value(self._program(), t)) * 1.0 for t in np.arange(0, m['run_time_s'] + INJECT_CYCLE_S, 1.0)) |
| if bottle['volume_m3'] < need: |
| raise ActionRejected('PRECONDITION_FAILED') |
| self.run_count += 1 |
| self.operation_id = f'{self.instance_id}:run:{self.run_count}' |
| self.run = dict(run_id=self.operation_id, vial=key, elapsed=0.0, inject_left=INJECT_CYCLE_S, t=[], y=[], peaks=[], warnings=[], |
| wavelength=m['wavelength_m'], next_sample=0.0, rng=np.random.default_rng( |
| int(hashlib.sha256(self.operation_id.encode()).hexdigest()[:12], 16)), drift0=0.0) |
| self.phase = 'injecting' |
| return {'phase': self.phase, 'operation_id': self.operation_id} |
|
|
| def _inject(self): |
| """End of the injection cycle: draw the volume, create the bands from the measured templates and the current conditions.""" |
| m, run = self.method, self.run |
| vial = self.vials[run['vial']] |
| vol = m['injection_volume_m3'] |
| vial['volume_m3'] -= vol |
| self.injected_m3 += vol |
| self.waste_m3 += vol |
| col = self._column() |
| modifier = self.bottles[m['modifier_channel']]['modifier'] |
| t0 = void_time_s(col['length_m'], col['inner_diameter_m'], m['flow_m3_s']) |
| delay = delay_volume_m3(m['bpr_pa']) / m['flow_m3_s'] |
| rho = co2_density(self.column_k, m['bpr_pa'] + 101325.0) |
| extra = -DENSITY_COEFF * (rho / _rho_ref() - 1.0) |
| n_plates = col['length_m'] / (PLATE_HEIGHT_DP * col['particle_m']) |
| extra_var = ((FLOW_CELL_VOLUME_M3 / m['flow_m3_s']) ** 2 + (vol / m['flow_m3_s']) ** 2) / 12.0 |
| sids, a_vals, mols = [], [], [] |
| for sid, c in vial['composition'].items(): |
| moles = c * vol |
| self.injected_mol += moles |
| entry = templates()[sid]['retention'][col['id']][modifier] |
| if entry['status'] != 'eluted' or 'model_fit' not in entry: |
| self.bands.append(dict(sid=sid, mol=moles, t_r=None, sigma=None, eps=0.0, eluted=False, done=True, run=run['run_id'], |
| evidence='not_eluted_in_source_data' if entry['status'] != 'eluted' else 'outside_reference_program')) |
| continue |
| sids.append(sid) |
| a_vals.append(entry['model_fit']['log10_k_at_phi_1']) |
| mols.append(moles) |
| if sids: |
| tr, ke, _ = migrate(np.array(a_vals), LOGLOG_SLOPE_M, self._program(), t0, delay, m['run_time_s'] + 600.0, dt_s=0.05, extra_ln_k=extra) |
| for sid, t_r, k_e, moles in zip(sids, tr, ke, mols): |
| eps, ev = epsilon(sid, m['wavelength_m']) |
| if np.isnan(t_r): |
| self.bands.append(dict(sid=sid, mol=moles, t_r=None, sigma=None, eps=eps, eluted=False, done=True, run=run['run_id'], |
| evidence='retained_beyond_run')) |
| continue |
| sigma = math.sqrt((t0 * (1.0 + float(k_e))) ** 2 / n_plates + extra_var) |
| |
| |
| self.bands.append(dict(sid=sid, mol=moles, t_r=float(t_r), sigma=sigma, eps=eps, wl=m['wavelength_m'], eluted=False, done=False, |
| flow_s=0.0, flow_ref=m['flow_m3_s'], evidence=ev, run=run['run_id'])) |
| run['t0'] = t0 |
| run['delay_s'] = delay |
| run['flow'] = m['flow_m3_s'] |
|
|
| def _signal(self, t): |
| """Absorbance at run time t (inside the current step): every migrating band, including carry-over from earlier runs.""" |
| run = self.run |
| total = 0.0 |
| lag = run['elapsed'] - t |
| for b in self.bands: |
| if b['t_r'] is None or b['done']: |
| continue |
| fs = b['flow_s'] - lag * (self.flow / b['flow_ref']) |
| dz = (fs - b['t_r']) / b['sigma'] |
| if abs(dz) < 8: |
| eps = b['eps'] if b['wl'] == run['wavelength'] else epsilon(b['sid'], run['wavelength'])[0] |
| c = b['mol'] / (run['flow'] * b['sigma'] * math.sqrt(2 * math.pi)) * math.exp(-0.5 * dz * dz) |
| total += eps * FLOW_CELL_PATH_M * c |
| noise = float(run['rng'].normal(0.0, DAD_NOISE_AU / 2.5)) |
| return total + noise + DAD_DRIFT_AU_S * t |
|
|
| def _finish(self, phase): |
| run = self.run |
| self.phase = phase |
| if run is not None: |
| thr = 10 * DAD_NOISE_AU |
| run['peaks'] = detect_peaks(run['t'], run['y'], thr) if phase == 'succeeded' else [] |
| self.absorbance = 0.0 |
|
|
| def _chromatogram(self, max_points): |
| run = self.run |
| if run is None: |
| return dict(run_id='', phase=self.phase, elapsed_s=0.0, time_s=[], absorbance_au=[], peaks=[], complete=False, wavelength_m=None, |
| template_source=LIBRARY_REL, evidence='no run', warnings=[]) |
| n = len(run['t']) |
| step = max(1, math.ceil(n / max_points)) |
| return dict(run_id=run['run_id'], phase=self.phase, elapsed_s=run['elapsed'], time_s=list(run['t'][::step]), absorbance_au=list(run['y'][::step]), |
| peaks=copy.deepcopy(run['peaks']), complete=self.phase == 'succeeded', wavelength_m=run['wavelength'], |
| template_source=f'{LIBRARY_REL}#sha256={library_sha256()[:16]}', |
| evidence='retention: measured CC BY 4.0 SFC data (Waters UPC2) transferred with a derived migration model; ' |
| 'absorbance: NIST UV curves where available, else assumed; peak shape: assumed plate height', |
| warnings=list(run['warnings']) + ['retention transferred from another SFC system; dwell volume and column lot effects are modelled, not measured', |
| 'peak responses use NIST UV curves where the template library holds one, otherwise an assumed molar ' |
| 'absorptivity; per-peak response evidence is evaluator-only', |
| 'quantitation requires the caller\'s own external calibration']) |
|
|
| def _template(self, sid): |
| rec = templates().get(sid) |
| if rec is None: |
| raise ActionRejected('UNKNOWN_REFERENCE') |
| ref = {c: {m: v['t_r_first_s'] for m, v in mods.items()} for c, mods in rec['retention'].items()} |
| return dict(substance_id=sid, name=rec['name'], cas=rec['cas'], molecular_weight_g_mol=rec['molecular_weight_g_mol'], reference_retention_s=ref, |
| uv_curve=rec['uv_vis'] is not None, template_source=f'{LIBRARY_REL}#{sid}', evidence=rec['evidence'], |
| licence=rec['source']['licence']) |
|
|
| def _quantify(self, a): |
| x = np.array([p['concentration_mol_m3'] for p in a['calibration']], float) |
| y = np.array([p['area_au_s'] for p in a['calibration']], float) |
| if np.ptp(x) <= 0: |
| raise ActionRejected('INVALID_CALIBRATION') |
| slope, intercept = np.polyfit(x, y, 1) |
| ss = float(np.sum((y - y.mean()) ** 2)) |
| r2 = 1.0 - float(np.sum((y - (slope * x + intercept)) ** 2)) / ss if ss > 0 else 0.0 |
| if slope <= 0: |
| raise ActionRejected('INVALID_CALIBRATION') |
| lo, hi = sorted(a['retention_window_s']) |
| peaks = [p for p in (self.run['peaks'] if self.run and self.phase == 'succeeded' else []) if lo <= p['retention_time_s'] <= hi] |
| if not peaks: |
| return dict(slope_au_s_m3_mol=float(slope), intercept_au_s=float(intercept), r_squared=max(0.0, min(1.0, r2)), peak_area_au_s=None, |
| concentration_mol_m3=None, quality='no_peak_in_window_or_no_completed_run') |
| p = max(peaks, key=lambda q: q['area_au_s']) |
| conc = (p['area_au_s'] - intercept) / slope |
| quality = 'ok' if x.min() <= conc <= x.max() and r2 >= 0.99 else 'extrapolated_or_poor_fit' |
| return dict(slope_au_s_m3_mol=float(slope), intercept_au_s=float(intercept), r_squared=max(0.0, min(1.0, r2)), peak_area_au_s=p['area_au_s'], |
| concentration_mol_m3=float(conc), quality=quality) |
|
|
| |
| def step(self, dt_s): |
| if isinstance(dt_s, bool) or not isinstance(dt_s, (int, float)) or not math.isfinite(dt_s) or dt_s <= 0: |
| raise ValueError('dt_s must be finite and positive') |
| left = float(dt_s) |
| while left > 1e-12: |
| h = min(left, 0.1 if self._busy() else 1.0) |
| self._advance(h) |
| left -= h |
| self.revision += 1 |
| return self.read('evaluator') |
|
|
| def _advance(self, h): |
| amb = self.ambient_k |
| m = self.method |
| |
| target = CHILLER_TARGET_K if (self.power['control'] and self.supply['connected']) else amb |
| self.chiller_k = target + (self.chiller_k - target) * math.exp(-h / CHILLER_TAU_S) |
| |
| bt = m['bpr_temperature_k'] if (m and self.power['control']) else amb |
| self.bpr_k = bt + (self.bpr_k - bt) * math.exp(-h / BPR_HEAT_TAU_S) |
| ct = m['column_temperature_k'] if (m and self.power['mct']) else amb |
| if self.mech['mct_door'] > 0.05 and self.power['mct']: |
| ct = amb + 0.5 * (ct - amb) |
| tau = COL_TAU_HEAT_S if ct > self.column_k else COL_TAU_COOL_S |
| self.column_k = ct + (self.column_k - ct) * math.exp(-h / tau) |
| |
| running = self.pump_enabled and m is not None and self._all_powered() |
| if running and not self._co2_ready(): |
| self.fault = 'CO2_SUPPLY' |
| self.pump_enabled = running = False |
| if self._busy(): |
| self._finish('failed') |
| col = self._column() |
| f_target = m['flow_m3_s'] if running and col else 0.0 |
| self.flow = f_target + (self.flow - f_target) * math.exp(-h / FLOW_TAU_S) |
| phi = self._phi_now() |
| if running and col: |
| bpr_target = m['bpr_pa'] |
| drop = column_pressure_drop(self.flow, phi, col) + EXTRA_COLUMN_R * (mixture_viscosity(phi) / 1e-4) * self.flow |
| self.bpr_pa = bpr_target + (self.bpr_pa - bpr_target) * math.exp(-h / PRESSURE_TAU_S) |
| p_target = self.bpr_pa + drop |
| self.pump_pa = p_target + (self.pump_pa - p_target) * math.exp(-h / PRESSURE_TAU_S) |
| self.booster_pa = max(0.0, 0.95 * self.pump_pa) |
| if self.pump_pa > PUMP_MAX_PA: |
| self.fault = 'OVERPRESSURE' |
| self.pump_enabled = False |
| if self._busy(): |
| self._finish('failed') |
| |
| vol = self.flow * h |
| bottle = self.bottles[m['modifier_channel']] or {'volume_m3': 0.0} |
| mod = min(bottle['volume_m3'], vol * phi) |
| bottle['volume_m3'] -= mod |
| self.modifier_drawn_m3 += mod |
| self.waste_m3 += mod |
| co2 = min(self.supply['cylinder_co2_kg'], vol * (1 - phi) * CO2_PUMP_DENSITY_KG_M3) |
| self.supply['cylinder_co2_kg'] -= co2 |
| self.vented_co2_kg += co2 |
| for b in self.bands: |
| if b['t_r'] is None or b['done']: |
| continue |
| b['flow_s'] += h * self.flow / b['flow_ref'] |
| if not b['eluted'] and b['flow_s'] >= b['t_r'] + 4 * b['sigma']: |
| b['eluted'] = True |
| self.eluted_mol += b['mol'] |
| if b['flow_s'] >= b['t_r'] + 8 * b['sigma']: |
| b['done'] = True |
| if bottle['volume_m3'] <= 0.0 and (phi > 0 or self.bottles[m['modifier_channel']] is None): |
| self.fault = 'MODIFIER_EMPTY' |
| self.pump_enabled = False |
| if self._busy(): |
| self._finish('failed') |
| else: |
| for attr in ('bpr_pa', 'pump_pa', 'booster_pa'): |
| setattr(self, attr, getattr(self, attr) * math.exp(-h / 30.0)) |
| |
| if self.phase == 'injecting': |
| self.run['inject_left'] -= h |
| if self.run['inject_left'] <= 1e-9: |
| self._inject() |
| self.phase = 'running' |
| elif self.phase == 'running': |
| run = self.run |
| run['elapsed'] += h |
| period = 1.0 / m['data_rate_hz'] |
| while run['next_sample'] <= run['elapsed'] + 1e-9 and run['next_sample'] <= m['run_time_s'] + 1e-9: |
| y = self._signal(run['next_sample']) |
| run['t'].append(round(run['next_sample'], 6)) |
| run['y'].append(y) |
| self.absorbance = y |
| run['next_sample'] += period |
| if run['elapsed'] >= m['run_time_s'] - 1e-9: |
| self._finish('succeeded') |
| self.time_s += h |
|
|
|
|
| class Agilent1260infinitySession: |
| """Principal-bound protocol session: describe / read / invoke / write / poll / cancel with visibility filtering.""" |
|
|
| def __init__(self, host, principal_id): |
| self._host = host |
| self._principal = principal_id |
|
|
| @property |
| def _role(self): |
| return self._host._principals[self._principal] |
|
|
| def _target(self, instance_id): |
| if instance_id != self._host.instance_id: |
| raise ActionRejected('UNKNOWN_INSTANCE') |
|
|
| def describe(self, *, instance_id=None, asset_type_id=None): |
| if (instance_id is None) == (asset_type_id is None): |
| raise ActionRejected('INVALID_ARGUMENT') |
| if instance_id is not None: |
| self._target(instance_id) |
| if asset_type_id is not None and asset_type_id != ASSET_TYPE_ID: |
| raise ActionRejected('UNKNOWN_INSTANCE') |
| meta = export_agilent_1260infinity_contract_metadata() |
| agent = self._role == 'agent' |
| return dict(protocol_version=PROTOCOL_VERSION, asset_type_id=ASSET_TYPE_ID, asset_version='1.0.0', |
| capabilities={k: v for k, v in meta['capabilities'].items() if v['visibility'] == 'agent' or not agent}, |
| state_slots={k: v for k, v in meta['state_slots'].items() if v['visibility'] == 'agent' or not agent}) |
|
|
| def read(self, *, instance_id, state_ids=None): |
| self._target(instance_id) |
| h = self._host |
| vals = h.read(self._role) |
| ids = list(vals) if state_ids is None else state_ids |
| if not isinstance(ids, list) or any(not isinstance(k, str) for k in ids): |
| raise ActionRejected('INVALID_ARGUMENT') |
| if any(k not in vals for k in ids): |
| raise ActionRejected('ACCESS_DENIED') |
| return dict(status='succeeded', instance_id=instance_id, state_revision=h.revision, clock={'domain': 'simulation', 'time_s': h.time_s}, |
| observations={k: dict(value=copy.deepcopy(vals[k]), unit=SLOTS[k][1], quality='estimated' if SLOTS[k][2] == 'derived' else 'valid', |
| sample_time_s=h.time_s, sample_window_s=None) for k in ids}) |
|
|
| def invoke(self, *, instance_id, capability_id, arguments, request_id): |
| try: |
| return self._invoke(instance_id=instance_id, capability_id=capability_id, arguments=arguments, request_id=request_id) |
| except ActionRejected as exc: |
| return dict(protocol_version=PROTOCOL_VERSION, instance_id=instance_id, request_id=request_id, operation_id=None, status='rejected', |
| state_revision=self._host.revision, clock={'domain': 'simulation', 'time_s': self._host.time_s}, result={}, observations={}, |
| error=dict(code=str(exc), message=str(exc), retryable=False, side_effects='none')) |
|
|
| def _invoke(self, *, instance_id, capability_id, arguments, request_id): |
| self._target(instance_id) |
| h = self._host |
| if not isinstance(capability_id, str) or capability_id not in CAPS: |
| raise ActionRejected('UNKNOWN_CAPABILITY') |
| if self._role == 'agent' and CAPS[capability_id][5] != 'agent': |
| raise ActionRejected('ACCESS_DENIED') |
| if not isinstance(request_id, str) or not request_id or not isinstance(arguments, dict): |
| raise ActionRejected('INVALID_ARGUMENT') |
| key = (self._principal, instance_id, request_id) |
| try: |
| digest = json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False) |
| except (TypeError, ValueError): |
| raise ActionRejected('INVALID_ARGUMENT') |
| if key in h._requests: |
| old, result = h._requests[key] |
| if old != digest: |
| raise ActionRejected('REQUEST_CONFLICT') |
| return copy.deepcopy(result) |
| result = h.invoke(capability_id, **arguments) |
| op = result.get('operation_id') if capability_id == 'run.start' else None |
| if op: |
| h._owners[op] = self._principal |
| response = dict(protocol_version=PROTOCOL_VERSION, instance_id=instance_id, request_id=request_id, operation_id=op, |
| status='accepted' if op else 'succeeded', state_revision=h.revision, clock={'domain': 'simulation', 'time_s': h.time_s}, |
| result=result, observations={}, error=None) |
| if CAPS[capability_id][4] not in ('query', 'analysis'): |
| h._requests[key] = (digest, copy.deepcopy(response)) |
| return response |
|
|
| def write(self, *, instance_id, state_id, value, request_id): |
| self._target(instance_id) |
| if state_id not in SLOTS or not SLOTS[state_id][5]: |
| raise ActionRejected('ACCESS_DENIED') |
| cap, arg = SLOTS[state_id][5] |
| return self.invoke(instance_id=instance_id, capability_id=cap, arguments={arg: value}, request_id=request_id) |
|
|
| def poll(self, operation_id): |
| h = self._host |
| if operation_id != h.operation_id or h._owners.get(operation_id) != self._principal: |
| raise ActionRejected('ACCESS_DENIED') |
| return dict(operation_id=operation_id, status=h.phase, result=h._chromatogram(2000)) |
|
|
| def cancel(self, operation_id, request_id): |
| self.poll(operation_id) |
| response = self.invoke(instance_id=self._host.instance_id, capability_id='run.abort', arguments={}, request_id=request_id) |
| return dict(operation_id=operation_id, status=self._host.phase, result=response['result']) |
|
|
|
|
| |
| PRECONDITIONS = { |
| 'pump.set': ('开泵：五模块通电、CO2就绪（供气40–70 bar且冷却器≤9 °C）、已配置方法、所选柱位已装柱、所用改性剂瓶有液', |
| ['power.enabled', 'co2.ready', 'method.configured', 'column.installed', 'solvent.b1'], 'all_powered and co2_ready and method and column and bottle>0'), |
| 'run.start': ('系统就绪（流量≥98%目标、背压±5 bar、柱温±1 K）、进样器门与该抽屉关闭、瓶内余量≥进样体积+10 µL、改性剂足够本次运行', |
| ['system.ready', 'sampler_door.angle_rad', 'drawer_1.position_m', 'run.phase'], 'ready and door==0 and drawer==0 and vial>=inj+dead and phase not busy'), |
| 'method.configure': ('运行中锁定方法；梯度表时间从0递增；柱温≥环境−10 K且≥4 °C；进样体积为0.1 µL整数倍；泵运行时不得切换到无液改性剂瓶或空柱位', |
| ['run.phase', 'pump.enabled', 'solvent.b1', 'column.installed'], 'phase not busy and (not pump or (bottle>0 and column installed))'), |
| 'column.install': ('柱温箱门打开（≥0.5 rad）、泵停且不在运行', ['mct_door.angle_rad', 'pump.enabled', 'run.phase'], 'mct_door>=0.5 and not pump and not busy'), |
| 'sample.register_vial': ('目标抽屉拉出≥0.15 m、瓶位空、物质在模板库', ['drawer_1.position_m', 'sample.vial_count'], 'drawer>=0.15 and free and sid in library'), |
| 'sample.remove_vial': ('目标抽屉拉出≥0.15 m且瓶位有瓶', ['drawer_1.position_m'], 'drawer>=0.15 and occupied'), |
| 'supply.configure': ('泵停时才能更换气瓶；连接时供气40–70 bar', ['pump.enabled'], 'not pump and 40e5<=supply<=70e5'), |
| 'solvent.configure': ('泵停时才能换瓶', ['pump.enabled'], 'not pump'), |
| 'sampler_door.set': ('进样/采集中不得打开进样器门', ['run.phase'], 'opening -> phase not busy'), |
| 'mct_door.set': ('进样/采集中不得打开柱温箱门（保留在进样时按当时条件计算）', ['run.phase'], 'opening -> phase not busy'), |
| } |
| for _i in range(1, 5): |
| PRECONDITIONS[f'drawer_{_i}.set'] = ('进样/采集中不得拉出抽屉', ['run.phase'], 'opening -> phase not busy') |
|
|
|
|
| def export_agilent_1260infinity_contract_metadata(): |
| caps, slots = {}, {} |
| for key, (schema, unit, origin, vis, comps, write, meaning) in SLOTS.items(): |
| slots[key] = dict(component_ids=comps, value_schema=copy.deepcopy(schema), unit=unit, reference_conditions=REFERENCE_ZH.get(key), |
| meaning_zh=meaning or None, origin=origin, visibility=vis, access='read_write' if write else 'read_only', |
| read_binding=dict(backend='host', artifact_id='runtime', accessor=f'Agilent1260infinitySession.read(state_ids=[{key!r}])'), |
| write_via=dict(capability_id=write[0], argument=write[1], fixed_arguments={}) if write else None, |
| sampling=dict(mode='instant', time_domain='simulation', window_description=None), |
| source_ids=['manufacturer_specs', 'simulation_assumption']) |
| for key, (inp, out, comps, meaning, kind, vis, example, effects) in CAPS.items(): |
| unsupported = key in UNSUPPORTED |
| is_async = key == 'run.start' |
| pre = [] |
| if key in PRECONDITIONS: |
| d, states, check = PRECONDITIONS[key] |
| pre = [dict(description_zh=d, state_ids=states, enforced_by='runtime', check=check)] |
| caps[key] = dict( |
| function_zh=meaning, kind=kind, visibility=vis, component_ids=comps, availability='unsupported' if unsupported else 'implemented', |
| input_schema=copy.deepcopy(inp), output_schema=copy.deepcopy(out), |
| implementation=dict(process='absent' if unsupported else 'implemented', scene='absent', robot='absent', hardware='absent', |
| host='absent' if unsupported else 'implemented'), |
| binding=None if unsupported else dict(backend='host', artifact_id='runtime', entrypoint='asset_runtime.agilent_1260infinity.Agilent1260infinitySession.invoke', |
| invocation=f'session.invoke(instance_id="sfc_01", capability_id={key!r}, arguments={example!r}, request_id="unique")'), |
| preconditions=pre, state_effects=[dict(state_id=s, timing='on_completion' if is_async else 'immediate', description_zh=meaning) for s in effects], |
| observes=[], model_effects=dict(mode='none', description_zh='过程层能力；几何联动由宿主另行绑定并在Matterix场景中验证。', binding_ids=[]), |
| execution=dict(mode='asynchronous' if is_async else 'synchronous', time_domain='simulation', |
| completion_criterion='run.phase=succeeded（运行时间结束）；取消/失败保留已采集数据与物料账本' if is_async else |
| ('返回只读结果，不推进时钟' if kind in ('query', 'analysis') else '设定写入；物理量只随step演化'), |
| completion_state_ids=['run.phase'] if is_async else list(effects), timeout_s=None, |
| cancellation='supported' if is_async else 'unsupported', retry='same_request_id', |
| resources=['target_instance', 'principal_request_cache'], |
| partial_failure_zh='拒绝时状态不变；取消/断电/故障不回滚已注入样品、已消耗改性剂与CO2。请求去重只在当前进程内存有效。'), |
| errors=[dict(code=e, meaning_zh=e, side_effects='none') for e in |
| ['UNKNOWN_INSTANCE', 'UNKNOWN_CAPABILITY', 'ACCESS_DENIED', 'INVALID_ARGUMENT', 'PRECONDITION_FAILED', 'BUSY', 'REQUEST_CONFLICT', |
| 'UNKNOWN_REFERENCE', 'INVALID_CALIBRATION', 'UNSUPPORTED']], |
| example_arguments=copy.deepcopy(example), verification=[], |
| limitations=['仿真过程模型，无真实硬件连接；进程内会话过滤不能替代文件与进程级部署隔离。'] if not unsupported else ['未实现；调用返回UNSUPPORTED。'], |
| source_ids=['manufacturer_specs', 'sfc_retention_data', 'simulation_assumption']) |
| p = lambda v, u, z, ev='assumption', src=('simulation_assumption',): dict(value=v, unit=u, meaning_zh=z, evidence=ev, source_ids=list(src), uncertainty=None) |
| mechanisms = { |
| 'retention': dict( |
| component_ids=['column_1', 'column_2', 'column_3', 'column_4', 'column_valve', 'mct_housing'], |
| state_ids=['column.temperature_k', 'mobile_phase.co2_density_kg_m3', 'run.phase', 'truth.column_mol', 'truth.eluted_mol'], |
| meaning_zh='梯度SFC谱带迁移：模板库实测保留时间反解的log-log保留截距，按配置梯度、流量、延迟体积、柱温与背压（CO2密度）积分出峰时间', |
| implementation='lumped', |
| equations=['log10 k = a - m*log10(max(phi, phi_min)) - c_rho*(rho/rho_ref - 1)/ln(10)', |
| 'dz/dt = 1/(t0*(1+k(phi(t - t_D - z*t0))))，z=1时出峰', |
| 't0 = eps_T*pi*r^2*L/F；t_D = V_delay(BPR)/F，V_delay 600–900 µL', |
| 'sigma_t^2 = (t0*(1+k_e))^2/N + ((V_cell/F)^2 + (V_inj/F)^2)/12，N = L/(h*dp)'], |
| parameters={'loglog_slope_m': p(LOGLOG_SLOPE_M, '1', 'log k–log φ斜率，所有物质同一值'), |
| 'total_porosity': p(TOTAL_POROSITY, '1', '柱总孔隙率（死时间）'), |
| 'density_coefficient': p(DENSITY_COEFF, '1', 'ln k对CO2相对密度的系数'), |
| 'reference_dwell_s': p(REF_DWELL_S, 's', '源数据UPC2系统梯度延迟（未公开，假设）'), |
| 'reduced_plate_height': p(PLATE_HEIGHT_DP, '1', '折合塔板高度h'), |
| 'phi_min': p(PHI_MIN, '1', '保留律中改性剂分数下限'), |
| 'delay_volume_range': p([DELAY_MIN_M3, DELAY_MAX_M3], 'm^3', 'G4782A延迟体积600–900 µL（随背压，线性映射为假设）', 'documented', ['manufacturer_specs']), |
| 'reference_method_flow': p(REF_FLOW_M3_S, 'm^3/s', '源数据方法流量1.5 mL/min', 'documented', ['sfc_retention_data'])}, |
| source_ids=['sfc_retention_data', 'manufacturer_specs', 'simulation_assumption'], |
| limitations=['m、ε_T、密度系数与UPC2延迟为假设；参考方法下保留时间复现实测（残差<0.5 s），其它方法为外推。', |
| '保留时间与峰宽在进样时按当时流量/梯度/柱温/背压一次算定；运行中条件变化不改变已进样谱带（运行中门与方法均锁定）。' |
| '运行结束后泵继续输液时谱带继续迁移（按流量折算），晚出峰进入废液，或在下一次运行中作为残留峰出现。', |
| '源数据中未出峰/未检出、或晚于文献运行终点（2条，未拟合）的组合，按“留在柱上”处理，不代表真实色谱行为已知。', |
| '未建模柱老化（库中有12个月漂移数据但未驱动运行层）、对映体选择性、过载与峰拖尾。']), |
| 'hydraulics': dict( |
| component_ids=['pump_head_a', 'pump_head_b', 'booster_unit', 'chiller_unit', 'bpr_unit', 'column_1'], |
| state_ids=['pump.pressure_pa', 'bpr.pressure_pa', 'pump.flow_m3_s', 'chiller.temperature_k', 'booster.pressure_pa'], |
| meaning_zh='泵压=背压+Kozeny-Carman柱压降+柱外压降；600 bar跳泵；CO2经冷却再液化与增压后供泵A，改性剂由泵B高压混合', |
| implementation='lumped', |
| equations=['dP_col = 180*eta_mix*u_s*L*(1-e)^2/(e^3*dp^2)', 'eta_mix = exp(phi*ln eta_MeOH + (1-phi)*ln eta_CO2)', |
| 'P_pump -> P_BPR + dP_col + R_extra*(eta/1e-4)*F（一阶，tau=3 s）', 'P_pump > 600 bar -> OVERPRESSURE 停泵'], |
| parameters={'pump_max_pa': p(PUMP_MAX_PA, 'Pa', '系统/泵最高压力600 bar', 'documented', ['manufacturer_specs']), |
| 'bpr_range_pa': p([BPR_MIN_PA, BPR_MAX_PA], 'Pa', 'BPR可设100–400 bar', 'documented', ['manufacturer_specs']), |
| 'supply_range_pa': p([SUPPLY_MIN_PA, SUPPLY_MAX_PA], 'Pa', 'CO2供气40–70 bar', 'documented', ['manufacturer_specs']), |
| 'eta_co2_pa_s': p(ETA_CO2_PA_S, 'Pa*s', 'CO2黏度（工程值）'), 'eta_methanol_pa_s': p(ETA_MEOH_PA_S, 'Pa*s', '甲醇25 °C黏度（常用手册值，本资产未列来源，按假设登记）'), |
| 'bed_porosity': p(BED_POROSITY, '1', '床层孔隙率'), 'extra_column_resistance': p(EXTRA_COLUMN_R, 'Pa*s/m^3', '柱外阻力（每1e-4 Pa s）'), |
| 'pressure_tau_s': p(PRESSURE_TAU_S, 's', '压力一阶时间常数'), 'chiller_target_k': p(CHILLER_TARGET_K, 'K', '冷却器目标（厂家范围−20…9 °C内取5 °C）')}, |
| source_ids=['manufacturer_specs', 'simulation_assumption'], |
| limitations=['流量按泵头条件体积计，未做压缩性补偿；改性剂对CO2密度的影响忽略。']), |
| 'thermal': dict( |
| component_ids=['mct_housing', 'mct_door', 'bpr_unit', 'chiller_unit'], state_ids=['column.temperature_k', 'bpr.temperature_k', 'chiller.temperature_k'], |
| meaning_zh='柱温箱一阶升降温，时间常数由厂家速率换算；门打开时只能维持目标与环境差的一半（假设）', implementation='lumped', |
| equations=['T -> T_target，升温tau=300 s/ln(30)，降温tau=600 s/ln(40)'], |
| parameters={'tau_heat_s': p(COL_TAU_HEAT_S, 's', '由厂家“环境→40 °C约5 min”换算（一阶到0.5 K以内）', 'documented', ['manufacturer_specs']), |
| 'tau_cool_s': p(COL_TAU_COOL_S, 's', '由厂家“40→20 °C约10 min”换算（一阶到0.5 K以内）', 'documented', ['manufacturer_specs'])}, |
| source_ids=['manufacturer_specs'], limitations=['单节点温区；两个独立温区按同一温度处理。']), |
| 'detection': dict( |
| component_ids=['flow_cell', 'dad_housing'], state_ids=['detector.absorbance_au', 'detector.wavelength_m'], |
| meaning_zh='DAD吸光度=ε(λ)·10 mm·c(t)，高斯谱带；噪声与漂移取厂家规格', implementation='lumped', |
| equations=['c(t) = n/(F*sigma*sqrt(2pi))*exp(-(t-tR)^2/(2 sigma^2))', 'A = eps*l*c + N(0, 0.7e-5/2.5) + drift*t'], |
| parameters={'flow_cell_path_m': p(FLOW_CELL_PATH_M, 'm', 'SFC流通池光程10 mm', 'documented', ['manufacturer_specs']), |
| 'noise_au': p(DAD_NOISE_AU, 'AU', '噪声<±0.7e-5 AU', 'documented', ['manufacturer_specs']), |
| 'assumed_epsilon_m2_mol': p(ASSUMED_EPSILON_M2_MOL, 'm^2/mol', '无NIST紫外曲线时的假设摩尔吸光系数')}, |
| source_ids=['manufacturer_specs', 'nist_uv', 'simulation_assumption'], |
| limitations=['多数物质无NIST紫外曲线，响应为假设（结果warnings中标出）；无检测器饱和与带宽效应。']), |
| } |
| if _ann is not None: |
| _ann.annotate_export('agilent_1260infinity', caps, slots, mechanisms, inputs={'method.configure': (METHOD, METHOD_EXAMPLE), 'supply.configure': (SUPPLY, SUPPLY_EXAMPLE)}) |
| return dict(asset_type_id=ASSET_TYPE_ID, catalog_id=CATALOG_ID, capabilities=caps, state_slots=slots, mechanisms=mechanisms) |
|
|
