| """E916 six-cell conservative extraction teaching model, NOT hardware control. |
| |
| 1.1: the firmware functions behind the front-panel menus (positions, preheat setpoint / EcoMode, method editor fields and the method store, |
| SKIP and the three STOP presses, leak test, flush, instrument settings, solvent list, service functions) and the front panel itself |
| (panel.press / turn / switch / capture / frame; panel_ui.json beside the contract, generic engine _panel_ui.py).""" |
| from __future__ import annotations |
| import copy,json,math |
| from asset_runtime import _annotations as _ann |
| from pathlib import Path |
| from asset_runtime.mt_hx204 import ActionRejected,number,obj,BOOL,TEXT |
| from asset_runtime.antonpaar_abbematadvanced import validate |
| ROOT=Path(__file__).resolve().parents[2];ASSET_TYPE_ID='instrument.buchi_speedextractore';CATALOG_ID='CHEM-028';PROTOCOL_VERSION='1.0.0';TEMPLATE_REL='assets/reactions/buchi_speedextractore_extraction_library/templates.json';LIB=ROOT/Path(TEMPLATE_REL).parent |
| PHASE={'type':'string','enum':['idle','running','succeeded','cancelled','failed']} |
| def arr(s):return {'type':'array','items':s} |
| def nullable(s):return {'anyOf':[s,{'type':'null'}]} |
| MASS=number('kg',0);VOL=number('m^3',0);PRESS=number('Pa',0);TEMP=number('K',273.15,473.15);FRAC=number('1',0,1) |
| SOLVENTS=['acetone','ethanol','methanol','n_hexane'];INT=lambda lo,hi:{'type':'integer','minimum':lo,'maximum':hi,'x-unit':'1'} |
| PLANT=obj({'ambient_k':number('K',288.15,303.15),'ambient_pa':number('Pa',80000,110000),'reservoir_m3':arr(number('m^3',0,.02)),'nitrogen_gauge_pa':number('Pa',6e5,1e6),'nitrogen_mol':number('mol',.001,1000),'nitrogen_mol_s_per_cell':number('mol/s',1e-6,.01),'exhaust_connected':BOOL,'dry_matrix_reviewed':BOOL,'thermal_tau_s':number('s',.5,300),'pressure_tau_s':number('s',.1,30),'discharge_m3_s_per_cell':number('m^3/s',1e-9,1e-5),'residual_holdup_fraction':number('1',0,.2),'vial_capacity_m3':number('m^3',60e-6,240e-6),'coefficient_evidence':TEXT}) |
| EXAMPLE=dict(ambient_k=295.15,ambient_pa=101325.,reservoir_m3=[.001]*4,nitrogen_gauge_pa=7e5,nitrogen_mol=10.,nitrogen_mol_s_per_cell=.001,exhaust_connected=True,dry_matrix_reviewed=True,thermal_tau_s=10.,pressure_tau_s=1.,discharge_m3_s_per_cell=2e-6,residual_holdup_fraction=.02,vial_capacity_m3=240e-6,coefficient_evidence='synthetic_host_heat_hydraulic_transfer_and_holdup; NOT factory calibration') |
| METHOD=obj({'temperature_k':number('K',303.15,473.15),'pressure_gauge_pa':number('Pa',5e6,15e6),'cycles':INT(1,10),'hold_s':number('s',0,3600),'discharge_s':number('s',0,3600),'pump_total_m3_s':number('m^3/s',1e-6/60,50e-6/60),'solvent_fractions':arr(FRAC),'solvent_flush_s':number('s',0,540),'nitrogen_flush_s':number('s',60,1800)}) |
| METHOD_EXAMPLE=dict(temperature_k=373.15,pressure_gauge_pa=10e6,cycles=2,hold_s=30.,discharge_s=30.,pump_total_m3_s=50e-6/60,solvent_fractions=[.5,.5,0.,0.],solvent_flush_s=0.,nitrogen_flush_s=60.) |
| SAMPLE=obj({'position':INT(0,5),'sample_id':TEXT,'substance_id':TEXT,'cell_volume_m3':{'type':'number','enum':[10e-6,20e-6,40e-6],'x-unit':'m^3'},'matrix_mass_kg':number('kg',1e-9,.1),'matrix_solid_volume_m3':number('m^3',1e-10,39e-6),'target_mass_kg':number('kg',1e-15,.001),'kd_m3_kg_by_solvent':arr(number('m^3/kg',1e-8,1e3)),'mass_transfer_s_inv':number('1/s',1e-6,10),'activation_energy_j_mol':number('J/mol',0,1e5),'adsorption_energy_j_mol':number('J/mol',0,1e5),'solubility_kg_m3':number('kg/m^3',1e-9,1000),'degradation_s_inv':number('1/s',0,1),'gripper_confirmed':BOOL,'parameters_evidence':TEXT}) |
| SAMPLE_EXAMPLE=dict(position=0,sample_id='soil_1',substance_id='phenol',cell_volume_m3=20e-6,matrix_mass_kg=.005,matrix_solid_volume_m3=5e-6,target_mass_kg=1e-6,kd_m3_kg_by_solvent=[.0001,.0002,.00015,.01],mass_transfer_s_inv=.02,activation_energy_j_mol=10000.,adsorption_energy_j_mol=5000.,solubility_kg_m3=10.,degradation_s_inv=0.,gripper_confirmed=True,parameters_evidence='synthetic_host_soil_partition_transfer; NOT measured E916 recovery') |
| RESULT=obj({'phase':PHASE,'stage':TEXT,'fault':TEXT,'temperature_k':nullable(TEMP),'max_pressure_gauge_pa':nullable(PRESS),'cycle':INT(0,10),'stage_elapsed_s':number('s',0),'evidence':TEXT,'template_source':TEXT}) |
| ITEM=obj({'position':INT(0,5),'sample_id':TEXT,'substance_id':TEXT,'extract_target_kg':MASS,'residual_target_kg':MASS,'degraded_target_kg':MASS,'matrix_mass_kg':MASS,'extract_solvent_m3':VOL,'residual_solvent_m3':VOL,'modeled_absolute_recovery_fraction':FRAC,'measured_e916_recovery_fraction':{'type':'null'},'reference_ase_soxtec_ratio':number('1',0),'reference_instrument':TEXT}) |
| PRODUCT=obj({'items':arr(ITEM),'evidence':TEXT,'template_source':TEXT}) |
| REFERENCE=obj({'substance_id':TEXT,'name':TEXT,'ase_soxtec_ratio':number('1',0),'measured_e916_recovery_fraction':{'type':'null'},'source':TEXT,'conditions':TEXT,'evidence':TEXT,'template_source':TEXT}) |
| |
| |
| |
| |
| |
| MLMIN=1e-6/60;BAR=1e5 |
| CELL_VOLUMES=[10e-6,20e-6,40e-6];VIALS={'60':60e-6,'150':150e-6,'220':220e-6,'240':240e-6,'unspecified':None,'waste':None} |
| DEFAULT_SOLVENTS=['Acetone','Acetonitrile','Cyclohexane','Dichloromethane','Hexane','Isopropyl alcohol','Methanol','Petrolether','Toluene','Water'] |
| LANGUAGES=['English','Deutsch','Francais','Italiano','Espanol'] |
| SETTINGS={'language':dict(type='enum',options=LANGUAGES,default='English'),'contrast':dict(type='int',min=10,max=100,default=70), |
| 'beep_key':dict(type='bool',default=False),'beep_end':dict(type='bool',default=True),'preheat_demand':dict(type='bool',default=False)} |
| DEFAULT_METHOD=dict(temperature_k=373.15,pressure_gauge_pa=10e6,cycles=1,hold_s=120.,discharge_s=120.,pump_total_m3_s=50*MLMIN,solvent_fractions=[1.,0.,0.,0.], |
| solvent_flush_s=60.,nitrogen_flush_s=180.,vial='240',cell_volume_m3=20e-6,solvent_names=['Acetone','Ethanol','Methanol','Hexane'], |
| cycle_steps=[dict(hold_s=120.,discharge_s=120.,vial_change=False,port=0)]) |
| LEAK_DEFAULT=dict(temperature_k=373.15,pressure_gauge_pa=10e6,solvent_fractions=[1.,0.,0.,0.],hold_s=240.,flush_into='vial',gas_flush_s=120.) |
| FLUSH_DEFAULT=dict(solvent_s=120.,flush_into='waste',flow_m3_s=50*MLMIN,gas_s=180.,solvent_fractions=[1.,0.,0.,0.]) |
| FLOW_DEFAULT=dict(flush_into='vial',port=1,position=1) |
| VALVES=['solvent_1','solvent_2','solvent_3','solvent_4','media_solvent','media_gas']+['position_%d'%i for i in range(1,7)]+['outlet_vial','outlet_waste','solvent_all','position_all'] |
| LIFT_SPEED=.01;LIFT_CURRENT_A=.35;OVERALL_HOLD=.97;BACK_PA_PER_M3S=3*BAR/(50*MLMIN) |
| FAN_FACTORY=30;FAN_LOSS=.1 |
| |
| NAME_CHARS=set('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 .,-+*:%&/()=?!_') |
| UNIT_INFO=dict(line_voltage='230V',firmware='01.03',serial='') |
| FRAC4={'type':'array','items':FRAC,'minItems':4,'maxItems':4};POS6={'type':'array','items':BOOL,'minItems':6,'maxItems':6};FREE={'type':'object'} |
| VIAL_ENUM={'type':'string','enum':list(VIALS)};INTO={'type':'string','enum':['vial','waste']};CELL_ENUM={'type':'number','enum':CELL_VOLUMES,'x-unit':'m^3'} |
| STEP=obj({'hold_s':number('s',0,3600),'discharge_s':number('s',0,3600),'vial_change':BOOL,'port':INT(0,4)}) |
| METHOD_EXTRA={'vial':VIAL_ENUM,'cell_volume_m3':CELL_ENUM,'solvent_names':{'type':'array','items':TEXT,'minItems':4,'maxItems':4},'cycle_steps':{'type':'array','items':STEP,'minItems':1,'maxItems':10}} |
| NAMED=obj({'slot':INT(1,100),'name':TEXT});SLOT_ONLY=obj({'slot':INT(1,100)}) |
| LEAK=obj({'temperature_k':number('K',303.15,473.15),'pressure_gauge_pa':number('Pa',5e6,15e6),'solvent_fractions':FRAC4,'hold_s':number('s',60,1800),'flush_into':INTO,'gas_flush_s':number('s',60,1800)},optional=('temperature_k','pressure_gauge_pa','solvent_fractions','hold_s','flush_into','gas_flush_s')) |
| FLUSH=obj({'solvent_s':number('s',0,540),'flush_into':INTO,'flow_m3_s':number('m^3/s',1*MLMIN,50*MLMIN),'gas_s':number('s',60,1800),'solvent_fractions':FRAC4},optional=('solvent_s','flush_into','flow_m3_s','gas_s','solvent_fractions')) |
| FLOW=obj({'flush_into':INTO,'port':INT(1,4),'position':INT(1,6)},optional=('flush_into','port','position')) |
| STATUS_OUT=obj({'status':FREE}) |
| POSITIONS=[f'position_valve_{i}' for i in range(6)];SENSORS=[f'pressure_sensor_{i}' for i in range(6)];CELLS=[f'cell_{i}' for i in range(6)] |
| DEVICE_CAPS={ |
| 'positions.set':(obj({'active':POS6,'position':INT(1,6),'enabled':BOOL},optional=('active','position','enabled')),obj({'active':POS6}),POSITIONS,'激活/停用萃取位置（OCCUPIED POSITIONS：全部、或单个位置；停用位置的位置阀全程关闭，只冲洗激活位置；om p.40-41）','device_command','agent',{'active':[True]*6},['positions.active']), |
| 'method.save':(NAMED,obj({'slot':INT(1,100),'name':TEXT}),['panel'],'把当前方法存入方法表（1–100号，名称≤16字符；覆盖已占用号；之后主屏标题为该名且不再划掉；om p.55）','configuration','agent',{'slot':1,'name':'PAH-01'},['method.library','method.name','method.modified']), |
| 'method.open':(SLOT_ONLY,obj({'slot':INT(1,100),'name':TEXT}),['panel','pump','heater_lift'],'打开方法表中的方法作为当前方法（与method.configure同样的前提：装样与首次运行之前；om p.57）','configuration','agent',{'slot':1},['method.configured','thermal.target_k','method.current','method.name','method.modified']), |
| 'method.delete':(SLOT_ONLY,obj({'slot':INT(1,100)}),['panel'],'删除方法表中的一个方法（当前方法不变；om p.27）','configuration','agent',{'slot':1},['method.library']), |
| 'thermal.set_eco_mode':(obj({'enabled':BOOL}),obj({'enabled':BOOL}),['heater_lift'],'EcoMode：下一次萃取结束后自动关加热；关机再开机自动取消（om p.45）','device_command','agent',{'enabled':True},['thermal.eco_mode']), |
| 'acquisition.skip':(obj({}),obj({'stage':TEXT}),['pump','media_valve','outlet_valve'],'SKIP：跳过当前萃取步骤（Hold→排液、溶剂冲洗→氮吹；氮吹在至少60 s安全期且压力≤1 bar后才可跳到结束；om p.28、58）','device_command','agent',{},['cycle.stage','cycle.stage_elapsed_s']), |
| 'acquisition.halt':(obj({}),obj({'phase':PHASE,'stage':TEXT}),['pump','media_valve','outlet_valve','heater_lift','collection_rack'],'第三次按STOP：立即停止，各组件停在当时位置（压力、液体与升降架保持；之后只能用服务菜单手动泄压、降架；om p.26、59）','device_command','agent',{},['cycle.phase','cycle.stage']), |
| 'leak_test.configure':(LEAK,obj({'settings':FREE}),['panel'],'检漏参数（上次所用值保存在仪器中）：温度、压力、四溶剂比例、保持时间、冲洗去向（瓶/废液）、氮吹时间（om p.41-43）','configuration','agent',{'hold_s':240.},['leak_test.settings']), |
| 'leak_test.start':(obj({'start_anyway':BOOL},optional=('start_anyway',)),STATUS_OUT,['pump','heater_lift','collection_rack','outlet_valve']+SENSORS,'检漏（功能键START，不是绿色START）：密封、氮气7 bar气密检查、泵入溶剂升到设定压力、关阀保持观察各位压力、排液与氮吹、降架；结果按手册判据（各位差≤15 bar、≥95 %设定）给出（om p.41-43）','device_command','agent',{},['leak_test.status','service.counters']), |
| 'leak_test.stop':(obj({}),STATUS_OUT,['outlet_valve'],'检漏中按SKIP：提前结束，出液阀打开排液、氮吹，测得压力保留在屏上（om p.42）','device_command','agent',{},['leak_test.status']), |
| 'flush.configure':(FLUSH,obj({'settings':FREE}),['panel'],'冲洗参数：溶剂冲洗时间、去向（废液/收集瓶）、流量1–50 mL/min、氮吹时间、四溶剂比例（om p.44-45）','configuration','agent',{'flush_into':'waste'},['flush.settings']), |
| 'flush.start':(obj({}),STATUS_OUT,['pump','mixer','media_valve','outlet_valve','heater_lift'],'冲洗（功能键START）：密封、气密检查池是否在位、按设定总流量冲洗激活位置（停用位置不降低流量）、氮吹、降架（om p.44-45）','device_command','agent',{},['flush.status']), |
| 'flush.stop':(obj({}),STATUS_OUT,['pump','heater_lift'],'冲洗菜单中按STOP：停止冲洗，泵停、降架（池内残液保留；om p.45）','device_command','agent',{},['flush.status']), |
| 'flow_test.configure':(FLOW,obj({'settings':FREE}),['panel'],'流动测试参数：去向、溶剂口1–4、位置1–6（om p.86）','configuration','agent',{'position':1},['flow_test.settings']), |
| 'flow_test.start':(obj({}),STATUS_OUT,['pump']+POSITIONS+SENSORS,'流动测试：泵以50 mL/min经所选位置送入空池并排出，显示背压与时间（未堵约3 bar，手册上限8 bar）；须先用LIFT手动关闭池与瓶升降架（om p.86-87）','device_command','agent',{},['flow_test.status']), |
| 'flow_test.stop':(obj({}),STATUS_OUT,['pump'],'停止流动测试','device_command','agent',{},['flow_test.status']), |
| 'pump.run':(obj({'enabled':BOOL,'flow_m3_s':number('m^3/s',1*MLMIN,50*MLMIN)},optional=('flow_m3_s',)),obj({'pump':FREE}),['pump'],'服务菜单泵：独立于方法以1–50 mL/min运行（实际值收敛到设定）；必须有通路（溶剂阀、介质阀溶剂位、位置阀、出液阀），否则泵压过高（Error 51）停泵（om p.85）','device_command','agent',{'enabled':True,'flow_m3_s':10*MLMIN},['service.pump']), |
| 'valve.set':(obj({'valve':{'type':'string','enum':VALVES},'open':BOOL}),obj({'valves':FREE}),['mixer','media_valve','outlet_valve']+POSITIONS,'服务菜单阀门：溶剂阀1–4、介质旋转阀（溶剂/氮气）、位置阀1–6、出液旋转阀（收集瓶/废液），可单开单关或全开全关（om p.84）；开位置阀与出液阀可手动泄压','device_command','agent',{'valve':'solvent_1','open':True},['service.valves']), |
| 'valve.calibrate':(obj({'valve':{'type':'string','enum':['media','outlet']}}),obj({'valves':FREE}),['media_valve','outlet_valve'],'旋转阀回到定义的初始位置（关闭；om p.83-84）','device_command','agent',{'valve':'media'},['service.valves']), |
| 'pressure.calibrate':(obj({}),obj({'sensors':FREE}),['divider']+SENSORS,'压力传感器校零：把七个传感器当前读数记为0 bar（必须先打开加热块与位置阀使仪器不带压，否则零点被记错；om p.85）','device_command','agent',{},['pressure.sensors']), |
| 'sensor.configure_error':(obj({'sensor':INT(0,6),'offset_pa':number('Pa',-2e6,2e6)}),obj({'sensors':FREE}),['divider']+SENSORS,'评测者：压力传感器偏差（0为泵压，1–6为位置；默认0即理想；之后由校零修正）','configuration','evaluator',{'sensor':1,'offset_pa':0.},['pressure.sensors']), |
| 'seal.configure_leak':(obj({'position':INT(1,6),'leak_pa_s':number('Pa/s',0,1e6)}),obj({'position':INT(1,6),'leak_pa_s':number('Pa/s',0)}),[f'lower_seal_{i}' for i in range(6)],'评测者：某位杯形密封的泄漏率（默认0即密封完好；检漏保持阶段该位压力按此下降）','configuration','evaluator',{'position':1,'leak_pa_s':0.},['leak_test.status']), |
| 'lift.move':(obj({'lift':{'type':'string','enum':['cell','vial']},'direction':{'type':'string','enum':['up','down','stop']}}),obj({'lifts':FREE}),['heater_lift','collection_rack'],'服务菜单：池升降（加热块）或瓶升降（收集架）上升/下降/停止；保护屏未关不动（Error 10），加热块不在中位不动（Error 9）；带压降下加热块会泄压喷出池内液体（om p.88）','device_command','agent',{'lift':'cell','direction':'up'},['service.lifts','heater.lift_m','rack.lift_m']), |
| 'service.reset_current_max':(obj({}),obj({'counters':FREE}),['heater_lift','collection_rack'],'运行时间页Reset：清除升降电机最大电流记录（om p.88）','device_command','agent',{},['service.counters']), |
| 'fan.set':(obj({'fan':{'type':'string','enum':['extraction','electronic']},'percent':INT(0,100)}),obj({'fans':FREE}),['rear_fan','tower_fan'],'风扇功率（出厂30 %；手册不建议改，会影响加热块温度；om p.88）','device_command','agent',{'fan':'extraction','percent':30},['service.fans']), |
| 'settings.configure':(obj({'key':{'type':'string','enum':list(SETTINGS)},'value':{'anyOf':[TEXT,{'type':'number','x-unit':'1'},BOOL]}}),obj({'settings':FREE}),['panel'],'仪器设定：语言、显示对比度、按键蜂鸣、结束蜂鸣、开机预热询问（om p.40）','configuration','agent',{'key':'preheat_demand','value':True},['device.settings']), |
| 'solvents.set_name':(obj({'index':INT(1,20),'name':TEXT}),obj({'solvents':{'type':'array','items':TEXT}}),['panel'],'溶剂表（20条）改名或新增；空名删除该条（om p.38-39）','configuration','agent',{'index':11,'name':'Chlorobenzene'},['solvents.list']), |
| 'solvents.load_default':(obj({}),obj({'solvents':{'type':'array','items':TEXT}}),['panel'],'DEFAULT：前10条恢复为出厂溶剂表，011–020不变（om p.39）','configuration','agent',{},['solvents.list']), |
| 'vials.exchange':(obj({'gripper_confirmed':BOOL}),obj({'exchanged':BOOL}),['collection_rack']+[f'collection_vial_{i}' for i in range(6)],'宿主换收集瓶（瓶架降下时；换瓶暂停或运行结束后）：取走瓶中萃取液，放入空瓶（om p.54）','configuration','evaluator',{'gripper_confirmed':True},['truth.removed_target_kg','truth.removed_solvent_m3','truth.extract_solvent_m3']), |
| 'cell.insert_empty':(obj({'position':INT(1,6),'cell_volume_m3':CELL_ENUM,'gripper_confirmed':BOOL}),obj({'occupancy':{'type':'array','items':nullable(TEXT)}}),['heater_lift']+CELLS,'宿主放入空萃取池（检漏、冲洗、流动测试与停用位置用；开屏抽块，夹具确认；om p.41、44、49）','configuration','evaluator',{'position':1,'cell_volume_m3':20e-6,'gripper_confirmed':True},['cells.occupancy']), |
| 'cell.remove_empty':(obj({'position':INT(1,6),'gripper_confirmed':BOOL}),obj({'occupancy':{'type':'array','items':nullable(TEXT)}}),['heater_lift']+CELLS,'宿主取出空池（不带压、开屏抽块；池内残液随池取走）','configuration','evaluator',{'position':1,'gripper_confirmed':True},['cells.occupancy','truth.removed_solvent_m3'])} |
| DEVICE_ERRORS={'NO_POSITION_SELECTED':'没有激活位置（Error 58）','SHIELD_OPEN':'保护屏未关（Error 10）','HEATER_NOT_IN_POSITION':'加热块不在中位（Error 9）', |
| 'HEATER_TEMPERATURE_OUT_OF_RANGE':'加热块温度与设定差超过30 °C（Error 2）','HEATER_TOO_HOT':'加热块比设定高3 °C以上，须确认仍要开始（Error 3）', |
| 'PUMP_PRESSURE_TOO_HIGH':'泵对着关闭的阀运行（Error 51）','NO_CELL':'所选位置没有萃取池（Error 45–50）','LIFT_OPEN':'池或瓶升降架未关闭','SLOT_EMPTY':'方法表该号为空', |
| 'SKIP_NOT_AVAILABLE':'当前步骤不能跳过','RATIO_SUM':'溶剂比例之和不是100 %','SETTING_INVALID':'设定值不在范围或选项内','NAME_INVALID':'名称为空、超过16字符或含不可输入字符'} |
| NEW_PRE={'positions.set':('不在萃取/检漏/冲洗过程中',['cycle.phase','cycle.stage']),'method.open':('与method.configure相同：装样与首次运行之前，方法完整且通过液相检查',['sample.configured','cycle.phase']), |
| 'method.save':('名称1–16个可输入字符',[]),'thermal.set_eco_mode':('通电',['power.enabled']),'acquisition.skip':('萃取运行中且处于Hold、溶剂冲洗或（≥60 s且压力≤1 bar的）氮吹',['cycle.stage','cycle.stage_elapsed_s','pressure.max_gauge_pa']), |
| 'acquisition.halt':('萃取过程已开始且未结束/未急停',['cycle.stage']),'leak_test.start':('通电、无萃取过程、屏关、加热块中位、有激活位置；加热块温度与检漏温度差≤30 °C，高于3 °C以上须start_anyway',['power.enabled','shield.lift_m','drawer.extension_m','positions.active','thermal.indicated_k']), |
| 'leak_test.stop':('检漏处于气密、升压或保持阶段',['leak_test.status']),'flush.start':('通电、无萃取过程、屏关、加热块中位、有激活位置',['power.enabled','shield.lift_m','drawer.extension_m','positions.active']), |
| 'flush.stop':('冲洗进行中',['flush.status']),'flow_test.start':('通电、空闲、池与瓶升降架已关闭、所选位置有池',['power.enabled','heater.lift_m','rack.lift_m','cells.occupancy']),'flow_test.stop':('流动测试进行中',['flow_test.status']), |
| 'pump.run':('通电、空闲；开泵时必须有通路',['power.enabled','service.valves']),'valve.set':('通电、萃取未在运行、无检漏/冲洗/流动测试',['power.enabled','cycle.phase']),'valve.calibrate':('通电、空闲',['power.enabled']), |
| 'pressure.calibrate':('通电、空闲（零点记为当前读数）',['power.enabled']),'lift.move':('通电、空闲；上升须屏关（池升降另需加热块中位）',['power.enabled','shield.lift_m','drawer.extension_m']), |
| 'vials.exchange':('瓶架降下、萃取未在运行',['rack.lift_m','cycle.phase']),'cell.insert_empty':('屏全开、加热块抽出、该位空、夹具确认',['shield.lift_m','drawer.extension_m','cells.occupancy']), |
| 'cell.remove_empty':('屏全开、加热块抽出、该位为空池、不带压、夹具确认',['shield.lift_m','drawer.extension_m','cells.occupancy'])} |
| NEW_CAP_ERRORS={'positions.set':['BUSY','PRECONDITION_FAILED'],'method.save':['NAME_INVALID'],'method.open':['SLOT_EMPTY','PRECONDITION_FAILED','LIQUID_PHASE_GUARD','BUSY'],'method.delete':['SLOT_EMPTY'], |
| 'thermal.set_eco_mode':['PRECONDITION_FAILED'],'acquisition.skip':['SKIP_NOT_AVAILABLE'],'acquisition.halt':['PRECONDITION_FAILED'],'leak_test.configure':['BUSY'], |
| 'leak_test.start':['BUSY','PRECONDITION_FAILED','NO_POSITION_SELECTED','SHIELD_OPEN','HEATER_NOT_IN_POSITION','HEATER_TEMPERATURE_OUT_OF_RANGE','HEATER_TOO_HOT','RATIO_SUM'], |
| 'leak_test.stop':['PRECONDITION_FAILED'],'flush.configure':['BUSY'],'flush.start':['BUSY','PRECONDITION_FAILED','NO_POSITION_SELECTED','SHIELD_OPEN','HEATER_NOT_IN_POSITION','RATIO_SUM'], |
| 'flush.stop':['PRECONDITION_FAILED'],'flow_test.configure':['BUSY'],'flow_test.start':['BUSY','PRECONDITION_FAILED','LIFT_OPEN','NO_CELL'],'flow_test.stop':['PRECONDITION_FAILED'], |
| 'pump.run':['BUSY','PRECONDITION_FAILED','PUMP_PRESSURE_TOO_HIGH'],'valve.set':['BUSY','PRECONDITION_FAILED'],'valve.calibrate':['BUSY','PRECONDITION_FAILED'],'pressure.calibrate':['BUSY','PRECONDITION_FAILED'], |
| 'sensor.configure_error':[],'seal.configure_leak':[],'lift.move':['BUSY','PRECONDITION_FAILED','SHIELD_OPEN','HEATER_NOT_IN_POSITION'],'service.reset_current_max':[],'fan.set':['PRECONDITION_FAILED'], |
| 'settings.configure':['SETTING_INVALID'],'solvents.set_name':['NAME_INVALID'],'solvents.load_default':[],'vials.exchange':['PRECONDITION_FAILED'],'cell.insert_empty':['PRECONDITION_FAILED'],'cell.remove_empty':['PRECONDITION_FAILED']} |
| CHANGES_PROCESS={'fan.set','thermal.set_eco_mode','thermal.preheat','valve.set','valve.calibrate','pump.run','lift.move','pressure.calibrate'} |
| RUN_OK={'power.set','acquisition.stop','acquisition.abort','acquisition.skip','acquisition.halt','method.save','method.delete','settings.configure','solvents.set_name','solvents.load_default', |
| 'sensor.configure_error','seal.configure_leak','thermal.set_eco_mode','leak_test.stop','flush.stop','flow_test.stop','fan.set','service.reset_current_max'} |
| STAGE_TEXT={'standby':'Ready','sealing':'Close lift','tightness':'Tightness','fill':'Fill','heatup_1':'Heat up','heatup_2':'Heat up','heatup_3':'Heat up','hold':'Hold', |
| 'discharge':'Discharge','solvent_flush':'Flush solv.','nitrogen_flush':'Flush gas','release':'Open lift','complete':'Ready','vial_change':'Vial change','halted':'Stop', |
| 'pump':'Pump','solvent':'Flush solv.','gas':'Flush gas','running':'Running'} |
|
|
|
|
| def _name_ok(name,empty=False): |
| return isinstance(name,str) and (bool(name.strip()) or empty) and len(name)<=16 and set(name)<=NAME_CHARS |
|
|
|
|
| class _E916Device: |
| """State and commands of the E-916 firmware functions reached from the menus (mixed into BuchiSpeedextractoreRuntime).""" |
| def _device_init(self): |
| self.positions=None;self.blanks={};self.method_name='DEFAULT';self.method_modified=False;self.library={};self.preheat_k=None;self.eco=False |
| self.aux=None;self.aux_last={};self.leak=copy.deepcopy(LEAK_DEFAULT);self.flush_set=copy.deepcopy(FLUSH_DEFAULT);self.flow_set=copy.deepcopy(FLOW_DEFAULT) |
| self.valves=dict(solvent=[False]*4,media=None,position=[False]*6,outlet=None);self.calibrations=dict(media=0,outlet=0) |
| self.pump=dict(on=False,set_m3_s=1*MLMIN,actual_m3_s=0.);self.pump_p=0.;self.lift_cmd=dict(cell=None,vial=None);self.current_max=dict(cell=0.,vial=0.) |
| self.fans=dict(extraction=30,electronic=30);self.counters=dict(extractions=0,leak_tests=0,operating_s=0.,heater_s=0.,max_temperature_k=None,max_pressure_pa=0.) |
| self.sensor_error=[0.]*7;self.sensor_zero=[0.]*7;self.seal_leak=[0.]*6;self.settings={k:v['default'] for k,v in SETTINGS.items()} |
| self.solvent_list=list(DEFAULT_SOLVENTS)+['']*10;self.notice=None;self._notices=0;self.end_beeps=0;self.exchanged=[0.]*4;self.removed_blank=[0.]*4;self.power_epoch=0 |
|
|
| |
| def _free(self,c):return c['volume'] if c.get('blank') else c['spec']['cell_volume_m3']-c['spec']['matrix_solid_volume_m3'] |
| def _records(self): |
| out={i:c for i,c in self.blanks.items() if not c['removed']};out.update({i:c for i,c in self.cells.items() if not c['removed']});return out |
| def _active(self): |
| if self.positions is None:return sorted(i for i,c in self.cells.items() if not c['removed']) |
| return [i for i,on in enumerate(self.positions) if on] |
| def _run_cells(self): |
| r=self._records();return [r[i] for i in self._active() if i in r] |
| def _missing(self): |
| r=self._records();return [i for i in self._active() if i not in r] |
| def _occupancy(self): |
| r=self._records();return [None if i not in r else ('empty' if r[i].get('blank') else 'sample') for i in range(6)] |
| def _notify(self,code): |
| self._notices+=1;self.notice=dict(id=self._notices,code=code,time_s=self.time_s) |
| def _in_operation(self): |
| return self._operation_count>0 and self.stage not in ('complete','standby') |
| def _idle(self): |
| return self.phase!='running' and self.aux is None |
|
|
| |
| def _full_method(self): |
| m=copy.deepcopy(self.method or DEFAULT_METHOD) |
| m.setdefault('vial','unspecified');m.setdefault('cell_volume_m3',None);m.setdefault('solvent_names',list(DEFAULT_METHOD['solvent_names'])) |
| m.setdefault('cycle_steps',[dict(hold_s=m['hold_s'],discharge_s=m['discharge_s'],vial_change=False,port=0) for _ in range(m['cycles'])]);return m |
| def _step(self,key): |
| steps=(self.method or {}).get('cycle_steps') |
| return steps[min(max(self.cycle,1),len(steps))-1][key] if steps else self.method[key] |
| def _fractions(self): |
| steps=(self.method or {}).get('cycle_steps') |
| port=steps[min(max(self.cycle,1),len(steps))-1]['port'] if steps else 0 |
| return [1. if i==port-1 else 0. for i in range(4)] if port else self.method['solvent_fractions'] |
| def _cell_volume(self,cells): |
| if self.method and self.method.get('cell_volume_m3'):return self.method['cell_volume_m3'] |
| c=cells[0] if cells else next(iter(self.cells.values())) |
| return c['volume'] if c.get('blank') else c['spec']['cell_volume_m3'] |
| def _vial_change_due(self,cells): |
| steps=self.method.get('cycle_steps') |
| if steps and steps[min(self.cycle,len(steps))-1]['vial_change']:return True |
| cap=VIALS.get(self.method.get('vial')) |
| return bool(cap) and any(sum(c['vial'])+self._free(c)>cap+1e-12 for c in cells) |
| def _overflow_possible(self): |
| m=self._full_method();cap=VIALS.get(m['vial']);cell=m['cell_volume_m3'] |
| if not cap or not cell:return False |
| n=0 |
| for s in m['cycle_steps'][:m['cycles']]: |
| n+=1 |
| if n*cell>cap+1e-12:return True |
| if s['vial_change']:n=0 |
| return False |
| def _check_method_extras(self,a): |
| n=a['cycles'] |
| if 'cycle_steps' in a: |
| if len(a['cycle_steps'])!=n:raise ActionRejected('PRECONDITION_FAILED') |
| for s in a['cycle_steps']: |
| if isinstance(s['port'],bool) or not isinstance(s['port'],int) or not 0<=s['port']<=4:raise ActionRejected('INVALID_ARGUMENT') |
| if s['port'] and a['pressure_gauge_pa']/3+101325<1.1*self.saturation_pressure(a['temperature_k'],[1. if i==s['port']-1 else 0. for i in range(4)]):raise ActionRejected('LIQUID_PHASE_GUARD') |
| if 'solvent_names' in a and any(len(x)>20 for x in a['solvent_names']):raise ActionRejected('INVALID_ARGUMENT') |
|
|
| |
| def _device_invoke(self,cap,a): |
| if cap=='positions.set': |
| if self.aux or self._in_operation():raise ActionRejected('BUSY' if self.phase=='running' or self.aux else 'PRECONDITION_FAILED') |
| if ('active' in a)==('position' in a) or ('position' in a)!=('enabled' in a):raise ActionRejected('INVALID_ARGUMENT') |
| act=list(a['active']) if 'active' in a else list(self.positions or [i in self._active() for i in range(6)]) |
| if 'position' in a:act[a['position']-1]=a['enabled'] |
| self.positions=act;return dict(active=list(act)) |
| if cap=='method.save': |
| if not _name_ok(a['name']):raise ActionRejected('NAME_INVALID') |
| self.library[a['slot']]=dict(name=a['name'],method=copy.deepcopy(self.method or DEFAULT_METHOD));self.method_name=a['name'];self.method_modified=False |
| return dict(slot=a['slot'],name=a['name']) |
| if cap=='method.open': |
| e=self.library.get(a['slot']) |
| if e is None:raise ActionRejected('SLOT_EMPTY') |
| self.invoke('method.configure',**e['method']);self.method_name=e['name'];self.method_modified=False;return dict(slot=a['slot'],name=e['name']) |
| if cap=='method.delete': |
| if a['slot'] not in self.library:raise ActionRejected('SLOT_EMPTY') |
| del self.library[a['slot']];return dict(slot=a['slot']) |
| if cap=='thermal.set_eco_mode': |
| if not self.powered:raise ActionRejected('PRECONDITION_FAILED') |
| self.eco=a['enabled'];return dict(enabled=self.eco) |
| if cap=='acquisition.skip': |
| if self.phase!='running' or self.stage not in ('hold','solvent_flush','nitrogen_flush') or (self.stage=='nitrogen_flush' and (self.stage_elapsed<60 or self._measured_max()>BAR)):raise ActionRejected('SKIP_NOT_AVAILABLE') |
| self._next({'hold':'discharge','solvent_flush':'nitrogen_flush','nitrogen_flush':'release'}[self.stage]);return dict(stage=self.stage) |
| if cap=='acquisition.halt': |
| if not self._operation_count or self.stage in ('standby','complete','halted'):raise ActionRejected('PRECONDITION_FAILED') |
| self.phase='cancelled';self.aborting=False;self._next('halted');return dict(phase=self.phase,stage=self.stage) |
| if cap in ('leak_test.configure','flush.configure','flow_test.configure'): |
| if not a:raise ActionRejected('INVALID_ARGUMENT') |
| for k in ('port','position'): |
| if k in a and (isinstance(a[k],bool) or not isinstance(a[k],int)):raise ActionRejected('INVALID_ARGUMENT') |
| store={'leak_test.configure':self.leak,'flush.configure':self.flush_set,'flow_test.configure':self.flow_set}[cap] |
| if self.aux and self.aux['settings'] is store:raise ActionRejected('BUSY') |
| store.update(copy.deepcopy(a));return dict(settings=copy.deepcopy(store)) |
| if cap in ('leak_test.start','flush.start'): |
| self._check_aux_start() |
| if abs(sum((self.leak if cap=='leak_test.start' else self.flush_set)['solvent_fractions'])-1)>1e-9:raise ActionRejected('RATIO_SUM') |
| if cap=='leak_test.start': |
| dt=self.temperature-self.leak['temperature_k'] |
| if abs(dt)>30:raise ActionRejected('HEATER_TEMPERATURE_OUT_OF_RANGE') |
| if dt>3 and not a.get('start_anyway'):raise ActionRejected('HEATER_TOO_HOT') |
| self.counters['leak_tests']+=1 |
| kind='leak_test' if cap=='leak_test.start' else 'flush' |
| self.aux=dict(kind=kind,stage='sealing',stage_elapsed=0.,elapsed=0.,settings=self.leak if kind=='leak_test' else self.flush_set,fault=None,result=None,hold_elapsed=0., |
| owner=self.__dict__.get('_caller')) |
| self.valves=dict(solvent=[False]*4,media=None,position=[False]*6,outlet=None);self.pump['on']=False |
| return dict(status=self._aux_status()) |
| if cap=='leak_test.stop': |
| if not self.aux or self.aux['kind']!='leak_test' or self.aux['stage'] not in ('tightness','pump','hold'):raise ActionRejected('PRECONDITION_FAILED') |
| if self.aux['stage']=='hold':self._leak_result(stopped=True) |
| self._aux_next('discharge');return dict(status=self._aux_status()) |
| if cap=='flush.stop': |
| if not self.aux or self.aux['kind']!='flush':raise ActionRejected('PRECONDITION_FAILED') |
| self.aux['stopped']=True;self._aux_next('release');return dict(status=self._aux_status()) |
| if cap=='flow_test.start': |
| if not self.powered or not self.plant:raise ActionRejected('PRECONDITION_FAILED') |
| if self.phase=='running' or self.aux:raise ActionRejected('BUSY') |
| if self._in_operation():raise ActionRejected('PRECONDITION_FAILED') |
| if self.heater<.035-1e-9 or self.rack<.035-1e-9:raise ActionRejected('LIFT_OPEN') |
| if self.flow_set['position']-1 not in self._records():raise ActionRejected('NO_CELL') |
| self.aux=dict(kind='flow_test',stage='running',stage_elapsed=0.,elapsed=0.,settings=self.flow_set,fault=None,result=None,owner=self.__dict__.get('_caller'));self.pump['on']=False |
| return dict(status=self._aux_status()) |
| if cap=='flow_test.stop': |
| if not self.aux or self.aux['kind']!='flow_test':raise ActionRejected('PRECONDITION_FAILED') |
| self._aux_done();return dict(status=self._aux_status()) |
| if cap=='pump.run': |
| self._check_service() |
| if 'flow_m3_s' in a:self.pump['set_m3_s']=a['flow_m3_s'] |
| if a['enabled'] and not self._pump_path():raise ActionRejected('PUMP_PRESSURE_TOO_HIGH') |
| self.pump['on']=a['enabled'] |
| if not a['enabled']:self.pump['actual_m3_s']=0. |
| return dict(pump=copy.deepcopy(self.pump)) |
| if cap=='valve.set': |
| self._check_service();v,op=a['valve'],a['open'];V=self.valves |
| if v=='solvent_all':V['solvent']=[op]*4 |
| elif v=='position_all':V['position']=[op]*6 |
| elif v.startswith('solvent_'):V['solvent'][int(v[-1])-1]=op |
| elif v.startswith('position_'):V['position'][int(v[-1])-1]=op |
| elif v.startswith('media_'):V['media']=v[6:] if op else (None if V['media']==v[6:] else V['media']) |
| else:V['outlet']=v[7:] if op else (None if V['outlet']==v[7:] else V['outlet']) |
| if self.pump['on'] and not self._pump_path():self.pump.update(on=False,actual_m3_s=0.);self._notify('pump_pressure_too_high') |
| return dict(valves=copy.deepcopy(V)) |
| if cap=='valve.calibrate': |
| self._check_service();self.valves[a['valve']]=None;self.calibrations[a['valve']]+=1 |
| if self.pump['on'] and not self._pump_path():self.pump.update(on=False,actual_m3_s=0.);self._notify('pump_pressure_too_high') |
| return dict(valves=copy.deepcopy(self.valves)) |
| if cap=='pressure.calibrate': |
| self._check_service();self.sensor_zero=self._raw_pressures();return dict(sensors=self._sensors()) |
| if cap=='sensor.configure_error': |
| self.sensor_error[a['sensor']]=float(a['offset_pa']);return dict(sensors=self._sensors()) |
| if cap=='seal.configure_leak': |
| self.seal_leak[a['position']-1]=float(a['leak_pa_s']);return dict(position=a['position'],leak_pa_s=float(a['leak_pa_s'])) |
| if cap=='lift.move': |
| self._check_service() |
| if a['direction']=='up': |
| if self.shield>1e-9:raise ActionRejected('SHIELD_OPEN') |
| if a['lift']=='cell' and self.drawer>1e-9:raise ActionRejected('HEATER_NOT_IN_POSITION') |
| self.lift_cmd[a['lift']]=None if a['direction']=='stop' else a['direction'];return dict(lifts=self._lifts()) |
| if cap=='service.reset_current_max': |
| self.current_max=dict(cell=0.,vial=0.);return dict(counters=self._counters()) |
| if cap=='fan.set': |
| if not self.powered:raise ActionRejected('PRECONDITION_FAILED') |
| self.fans[a['fan']]=a['percent'];return dict(fans=dict(self.fans)) |
| if cap=='settings.configure': |
| f=SETTINGS[a['key']];v=a['value'] |
| ok=(isinstance(v,bool) if f['type']=='bool' else v in f['options'] if f['type']=='enum' else |
| (not isinstance(v,bool) and isinstance(v,(int,float)) and float(v).is_integer() and f['min']<=v<=f['max'])) |
| if not ok:raise ActionRejected('SETTING_INVALID') |
| self.settings[a['key']]=int(v) if f['type']=='int' else v;return dict(settings=dict(self.settings)) |
| if cap=='solvents.set_name': |
| if len(a['name'])>20 or not set(a['name'])<=NAME_CHARS:raise ActionRejected('NAME_INVALID') |
| self.solvent_list[a['index']-1]=a['name'].strip();return dict(solvents=list(self.solvent_list)) |
| if cap=='solvents.load_default': |
| self.solvent_list[:10]=list(DEFAULT_SOLVENTS);return dict(solvents=list(self.solvent_list)) |
| if cap=='vials.exchange': |
| if self.rack>1e-9 or self.phase=='running' or not a['gripper_confirmed']:raise ActionRejected('PRECONDITION_FAILED') |
| for c in list(self.cells.values())+list(self.blanks.values()): |
| for i in range(4):self.exchanged[i]+=c['vial'][i];c['vial'][i]=0. |
| c['collected']+=c['extract'];c['extract']=0. |
| return dict(exchanged=True) |
| if cap=='cell.insert_empty': |
| i=a['position']-1 |
| if self.shield<.179 or self.drawer<.159 or not a['gripper_confirmed'] or i in self._records():raise ActionRejected('PRECONDITION_FAILED') |
| self.blanks[i]=dict(blank=True,volume=a['cell_volume_m3'],liquid=[0.]*4,vial=[0.]*4,pressure=0.,dissolved=0.,extract=0.,wasted=0.,collected=0.,removed=False) |
| return dict(occupancy=self._occupancy()) |
| if cap=='cell.remove_empty': |
| i=a['position']-1;c=self.blanks.get(i) |
| if self.shield<.179 or self.drawer<.159 or not a['gripper_confirmed'] or c is None or c['removed'] or c['pressure']>BAR:raise ActionRejected('PRECONDITION_FAILED') |
| for k in range(4):self.removed_blank[k]+=c['liquid'][k]+c['vial'][k] |
| del self.blanks[i];return dict(occupancy=self._occupancy()) |
| raise ActionRejected('UNKNOWN_CAPABILITY') |
|
|
| def _check_service(self): |
| if not self.powered or not self.plant:raise ActionRejected('PRECONDITION_FAILED') |
| if self.phase=='running' or self.aux:raise ActionRejected('BUSY') |
| def _check_aux_start(self): |
| if not self.powered or not self.plant:raise ActionRejected('PRECONDITION_FAILED') |
| if self.phase=='running' or self.aux:raise ActionRejected('BUSY') |
| if self._in_operation():raise ActionRejected('PRECONDITION_FAILED') |
| if self.shield>1e-9:raise ActionRejected('SHIELD_OPEN') |
| if self.drawer>1e-9:raise ActionRejected('HEATER_NOT_IN_POSITION') |
| if not self._active():raise ActionRejected('NO_POSITION_SELECTED') |
|
|
| |
| def _supply(self,c,vol,f): |
| v=min([vol]+[self.reservoir[i]/x for i,x in enumerate(f) if x>0]) |
| for i,x in enumerate(f):self.reservoir[i]-=v*x;c['liquid'][i]+=v*x |
| return v+1e-15>=vol |
| def _gas_use(self,n,h): |
| req=self.plant['nitrogen_mol_s_per_cell']*n*h;x=min(self.nitrogen,req);self.nitrogen-=x;self.nitrogen_out+=x;return x+1e-12>=req |
| def _drain_to(self,c,vol,holdup,target): |
| if target=='waste': |
| v=sum(c['liquid']);x=min(max(0.,v-holdup),vol);frac=x/v if v else 0.;m=c['dissolved']*frac;c['dissolved']-=m;c['wasted']+=m |
| for i in range(4):y=c['liquid'][i]*frac;c['liquid'][i]-=y;self.waste[i]+=y |
| return True |
| v=sum(c['liquid']);x=min(max(0.,v-holdup),vol);space=self.plant['vial_capacity_m3']-sum(c['vial']);ok=x<=space+1e-15;x=min(x,max(0.,space)) |
| frac=x/v if v else 0.;m=c['dissolved']*frac;c['dissolved']-=m;c['extract']+=m |
| for i in range(4):y=c['liquid'][i]*frac;c['liquid'][i]-=y;c['vial'][i]+=y |
| return ok |
| def _spill(self,c): |
| """The cell lift opens on a pressurised cell (no safety checks in the service menu): the content sprays out (to the waste ledger).""" |
| self._drain_to(c,sum(c['liquid']),0.,'waste');c['pressure']=0. |
|
|
| |
| def _aux_next(self,stage): |
| self.aux['stage']=stage;self.aux['stage_elapsed']=0. |
| def _aux_fail(self,code): |
| self.aux['fault']=code;self._notify(code);self._aux_next('release' if self.aux['kind']!='flow_test' else 'done') |
| if self.aux['kind']=='flow_test':self._aux_done() |
| def _aux_done(self): |
| a=self.aux;self.aux_last[a['kind']]=self._aux_status();self.aux=None |
| if self.settings['beep_end']:self.end_beeps+=1 |
| def _aux_status(self,a=None): |
| a=a or self.aux |
| if a is None:return dict(active=False) |
| return dict(active=True,kind=a['kind'],stage=a['stage'],stage_elapsed_s=a['stage_elapsed'],elapsed_s=a['elapsed'],fault=a['fault'],result=copy.deepcopy(a['result']), |
| hold_elapsed_s=a.get('hold_elapsed',0.),pressures_pa=self._readings()[1:],pump_pressure_pa=self._readings()[0]) |
| def _leak_result(self,stopped=False): |
| rd=self._readings();act=self._active();pos=[rd[1+i] for i in act];setp=self.leak['pressure_gauge_pa'] |
| diff=max(pos)-min(pos) if pos else 0.;low=min(pos+[rd[0]])/setp if pos else 0. |
| self.aux['result']=dict(positions=[i+1 for i in act],pressures_pa=pos,overall_pa=rd[0],max_pa=max(pos) if pos else 0.,max_difference_pa=diff,min_fraction_of_set=low, |
| passed=bool(pos) and diff<=15*BAR+1e-6 and low>=.95-1e-12,completed=not stopped) |
| def _aux_tick(self,h): |
| a=self.aux;p=self.plant;s=a['settings'];cells=self._run_cells();n=max(1,len(cells)) |
| a['elapsed']+=h;a['stage_elapsed']+=h;st=a['stage'] |
| if a['kind']=='flow_test': |
| c=self._records().get(s['position']-1);v=50*MLMIN*h;f=[1. if i==s['port']-1 else 0. for i in range(4)] |
| if c is None:return self._aux_fail('position_pressure_too_low:'+str(s['position'])) |
| ok=self._supply(c,v,f);self._drain_to(c,v,0.,s['flush_into']);c['pressure']=BACK_PA_PER_M3S*50*MLMIN;self.pump_p=c['pressure'] |
| if not ok:self._aux_fail('solvent_supply_empty') |
| return |
| if st=='sealing': |
| self.heater=min(.035,self.heater+.01*h);self.rack=min(.035,self.rack+.01*h) |
| if self.heater>=.035 and self.rack>=.035:self._aux_next('tightness') |
| elif st=='tightness': |
| if not self._gas_use(n,h):return self._aux_fail('nitrogen_supply_empty') |
| for c in cells:c['pressure']+=(7*BAR-c['pressure'])*-math.expm1(-h/p['pressure_tau_s']) |
| if a['stage_elapsed']>=10: |
| miss=self._missing() |
| if miss:return self._aux_fail('position_pressure_too_low:'+str(miss[0]+1)) |
| self._aux_next('pump' if a['kind']=='leak_test' else 'solvent') |
| elif st=='pump': |
| for c in cells: |
| if not self._supply(c,min(50*MLMIN/6*h,max(0.,self._free(c)-sum(c['liquid']))),s['solvent_fractions']):return self._aux_fail('solvent_supply_empty') |
| if all(abs(sum(c['liquid'])-self._free(c))<1e-12 for c in cells): |
| idx=self._run_indexed() |
| for i,c in idx:c['pressure']+=(max(0.,s['pressure_gauge_pa']-self._offset(i))-c['pressure'])*-math.expm1(-h/p['pressure_tau_s']) |
| self.pump_p=max(c['pressure'] for c in cells);rd=self._readings() |
| if all(abs(rd[1+i]-s['pressure_gauge_pa'])<1e4 for i,_ in idx):self._aux_next('hold') |
| elif st=='hold': |
| a['hold_elapsed']=a['stage_elapsed'] |
| for i,c in self._records().items(): |
| if i in self._active():c['pressure']=max(0.,c['pressure']-self.seal_leak[i]*h) |
| if a['stage_elapsed']>=s['hold_s']:self._leak_result();self._aux_next('discharge') |
| elif st=='discharge': |
| for c in cells:c['pressure']*=math.exp(-h/p['pressure_tau_s']);self._drain_to(c,p['discharge_m3_s_per_cell']*h,self._free(c)*p['residual_holdup_fraction'],s['flush_into']) |
| if a['stage_elapsed']>=10 and self._measured_max()<=BAR and all(sum(c['liquid'])<=self._free(c)*p['residual_holdup_fraction']+1e-12 for c in cells):self._aux_next('gas') |
| elif st=='solvent': |
| v=s['flow_m3_s']/n*h |
| for c in cells: |
| fill=max(0.,self._free(c)-sum(c['liquid'])) |
| if not self._supply(c,v,s['solvent_fractions']):return self._aux_fail('solvent_supply_empty') |
| self._drain_to(c,max(0.,v-fill),0.,s['flush_into']) |
| if a['stage_elapsed']>=s['solvent_s']:self._aux_next('gas') |
| elif st=='gas': |
| if not self._gas_use(n,h):return self._aux_fail('nitrogen_supply_empty') |
| gas_s=s['gas_flush_s'] if a['kind']=='leak_test' else s['gas_s'] |
| for c in cells:self._drain_to(c,p['discharge_m3_s_per_cell']*h,0.,s['flush_into']);c['pressure']*=math.exp(-h/p['pressure_tau_s']) |
| if a['stage_elapsed']>=gas_s and self._measured_max()<=BAR:self._aux_next('release') |
| elif st=='release': |
| for c in self._records().values(): |
| if c['pressure']>BAR and self.heater<.035:self._spill(c) |
| self.heater=max(0.,self.heater-.01*h);self.rack=max(0.,self.rack-.01*h) |
| if self.heater<=1e-12 and self.rack<=1e-12:self.heater=self.rack=0.;self._aux_done() |
| if self.aux is not None and st=='hold': |
| self.pump_p+=(OVERALL_HOLD*s['pressure_gauge_pa']-self.pump_p)*-math.expm1(-h/60.) |
| elif self.aux is not None and st!='pump':self.pump_p*=math.exp(-h/p['pressure_tau_s']) |
|
|
| |
| def _pump_path(self): |
| V=self.valves;return any(V['solvent']) and V['media']=='solvent' and any(V['position']) and V['outlet'] is not None |
| def _service_tick(self,h): |
| p=self.plant;V=self.valves;recs=self._records();sealed=self.heater>=.035-1e-9 |
| for lift in ('cell','vial'): |
| cmd=self.lift_cmd[lift];attr='heater' if lift=='cell' else 'rack';x=getattr(self,attr) |
| if cmd: |
| nx=min(.035,x+LIFT_SPEED*h) if cmd=='up' else max(0.,x-LIFT_SPEED*h);setattr(self,attr,nx);self.current_max[lift]=max(self.current_max[lift],LIFT_CURRENT_A) |
| if nx in (0.,.035):self.lift_cmd[lift]=None |
| if self.heater<.035-1e-9: |
| for c in recs.values(): |
| if c['pressure']>BAR:self._spill(c) |
| open_pos=[i for i in range(6) if V['position'][i]] |
| if V['outlet'] and sealed: |
| gas=V['media']=='gas' |
| if gas and open_pos and not self._gas_use(len(open_pos),h):self._notify('nitrogen_supply_empty');V['media']=None |
| for i in open_pos: |
| c=recs.get(i) |
| if c is None:continue |
| c['pressure']*=math.exp(-h/p['pressure_tau_s']);self._drain_to(c,p['discharge_m3_s_per_cell']*h,0. if gas else self._free(c)*p['residual_holdup_fraction'],V['outlet']) |
| P=self.pump |
| if P['on']: |
| if not self._pump_path():P.update(on=False,actual_m3_s=0.);self._notify('pump_pressure_too_high');return |
| P['actual_m3_s']+=(P['set_m3_s']-P['actual_m3_s'])*-math.expm1(-h/2.) |
| opn=[i for i in range(4) if V['solvent'][i]];f=[1./len(opn) if i in opn else 0. for i in range(4)];per=P['actual_m3_s']/len(open_pos)*h |
| for i in open_pos: |
| c=recs.get(i) |
| if c is not None and sealed: |
| ok=self._supply(c,per,f);fill=max(0.,self._free(c)-sum(c['liquid']));self._drain_to(c,per,0.,V['outlet']) if not fill else None |
| c['pressure']=BACK_PA_PER_M3S*P['actual_m3_s']/len(open_pos) |
| else: |
| tmp=dict(liquid=[0.]*4,dissolved=0.,wasted=0.);ok=self._supply(tmp,per,f);self._drain_to(tmp,per,0.,'waste') |
| if not ok:P.update(on=False,actual_m3_s=0.);self._notify('solvent_supply_empty');break |
| self.pump_p=BACK_PA_PER_M3S*P['actual_m3_s']/max(1,len(open_pos)) |
| else: |
| self.pump_p*=math.exp(-h/p['pressure_tau_s']) |
|
|
| |
| def _raw_pressures(self): |
| r=self._records();true=[self.pump_p]+[r[i]['pressure'] if i in r else 0. for i in range(6)] |
| return [t+e for t,e in zip(true,self.sensor_error)] |
| def _readings(self): |
| return [x-z for x,z in zip(self._raw_pressures(),self.sensor_zero)] |
| def _offset(self,i): |
| """Reading minus true pressure of the sensor of position i (0-5): evaluator error minus the stored service zero.""" |
| return self.sensor_error[1+i]-self.sensor_zero[1+i] |
| def _measured_max(self): |
| """Highest position pressure as the instrument measures it (sensors 1-6 with error and zero, not below 0): the display, pressure.max_gauge_pa, |
| extraction.measure, the operating-hours peak and the device's own decisions (skip, release, control) use it; _maxp() stays the true cell |
| pressure (physics, host interlocks and the truth slot).""" |
| return max(0.,max(self._readings()[1:])) |
| def _run_indexed(self): |
| r=self._records();return [(i,r[i]) for i in self._active() if i in r] |
| def _sensors(self): |
| return dict(readings_pa=self._readings(),zero_pa=list(self.sensor_zero)) |
| def _lifts(self): |
| return dict(cell=self.heater,vial=self.rack,moving=dict(self.lift_cmd),current_a={k:(LIFT_CURRENT_A if v else 0.) for k,v in self.lift_cmd.items()}) |
| def _counters(self): |
| return dict(self.counters,current_max_a=dict(self.current_max)) |
| def _counters_tick(self,h,heat): |
| c=self.counters |
| if self.powered: |
| c['operating_s']+=h |
| if heat:c['heater_s']+=h |
| c['max_temperature_k']=max(c['max_temperature_k'] or 0.,self.temperature) |
| c['max_pressure_pa']=max(c['max_pressure_pa'],self._measured_max()) |
| def _valve_view(self): |
| """Valves as the STATUS diagram shows them: the automatic sequence while a process runs, else the service-menu states.""" |
| st=self.aux['stage'] if self.aux else (self.stage if self.phase=='running' else None) |
| if st is None:return copy.deepcopy(self.valves) |
| kind=self.aux['kind'] if self.aux else 'extraction';act=self._active() |
| f=self.aux['settings'].get('solvent_fractions',[0.]*4) if self.aux else self._fractions() if self.method else [0.]*4 |
| if kind=='flow_test': |
| s=self.aux['settings'];return dict(solvent=[i==s['port']-1 for i in range(4)],media='solvent',position=[i==s['position']-1 for i in range(6)],outlet=s['flush_into']) |
| liquid=st in ('fill','heatup_1','heatup_2','heatup_3','solvent_flush','pump','solvent');gas=st in ('tightness','nitrogen_flush','gas') |
| into=(self.aux['settings']['flush_into'] if self.aux else ('waste' if (self.method or {}).get('vial')=='waste' else 'vial')) |
| return dict(solvent=[liquid and f[i]>0 for i in range(4)],media='solvent' if liquid else 'gas' if gas else None, |
| position=[i in act and st not in ('hold','sealing','release') for i in range(6)], |
| outlet=into if st in ('discharge','solvent_flush','nitrogen_flush','solvent','gas') else None) |
| def _pumping(self): |
| st=self.aux['stage'] if self.aux else (self.stage if self.phase=='running' else None) |
| return self.pump['on'] or st in ('fill','heatup_1','heatup_2','heatup_3','solvent_flush','pump','solvent','running') |
| def _status_text(self): |
| if not self.powered:return '' |
| if self.aux:return {'leak_test':'Leak test','flush':'Flush','flow_test':'Flow test'}[self.aux['kind']] |
| if self.phase=='failed':return 'Error' |
| if self._operation_count and self.stage not in ('standby','complete'): |
| if self.stage=='halted':return 'Stop' |
| if self.phase=='cancelled':return 'Vial change' if self.stage=='vial_change' else 'Pause' |
| if self.aborting:return 'Abort' |
| return STAGE_TEXT.get(self.stage,self.stage) |
| tgt=self.preheat_k if self.preheat_k is not None else (self.method['temperature_k'] if self.method else None) |
| return 'Preheat' if self.preheat and tgt is not None and abs(self.temperature-tgt)>1 else 'Ready' |
| def _plan(self): |
| """Rough stage plan of the current method for the remaining-time displays (the device also estimates; om p.52).""" |
| m=self._full_method();cells=self._run_cells() or list(self.cells.values());n=max(1,len(cells)) |
| free=max([self._free(c) for c in cells] or [(m['cell_volume_m3'] or 20e-6)*.75]);vol=m['cell_volume_m3'] or (self._cell_volume(cells) if cells else 20e-6) |
| fill=free/(m['pump_total_m3_s']/6);dwell=10*vol/20e-6;plan=[('sealing',0,3.5),('tightness',0,10.)] |
| for k in range(1,m['cycles']+1): |
| s=m['cycle_steps'][k-1];plan+=[('fill',k,fill),('heatup_1',k,dwell),('heatup_2',k,dwell),('heatup_3',k,dwell),('hold',k,s['hold_s']),('discharge',k,max(s['discharge_s'],free*n/(self.plant['discharge_m3_s_per_cell'] if self.plant else 2e-6)/n))] |
| if k<m['cycles'] and s['vial_change']:plan.append(('vial_change',k,7.)) |
| if m['solvent_flush_s']>0:plan.append(('solvent_flush',m['cycles'],m['solvent_flush_s'])) |
| return plan+[('nitrogen_flush',m['cycles'],m['nitrogen_flush_s']),('release',m['cycles'],3.5)] |
| def _times(self): |
| """(time to the end of the cycle, time to the next vial change, time to the end) in s; None when nothing runs.""" |
| if not (self._operation_count and self.stage not in ('standby','complete','halted')) or self.method is None:return None,None,None |
| plan=self._plan();cyc=max(1,self.cycle) |
| idx=next((j for j,(s,k,_) in enumerate(plan) if s==self.stage and (k==cyc or k==0 or s in ('solvent_flush','nitrogen_flush','release'))),None) |
| if idx is None:return None,None,None |
| rest=[max(0.,plan[idx][2]-self.stage_elapsed)]+[d for _,_,d in plan[idx+1:]];names=[s for s,_,_ in plan[idx:]];cycles=[k for _,k,_ in plan[idx:]] |
| total=sum(rest);end_c=sum(d for d,s,k in zip(rest,names,cycles) if k<=cyc and s not in ('solvent_flush','nitrogen_flush','release','vial_change')) |
| vc=next((sum(rest[:j]) for j,s in enumerate(names) if s=='vial_change' and j>0),None) |
| return end_c,vc,total |
|
|
|
|
| CAPS={ |
| 'power.set':(obj({'enabled':BOOL}),obj({'enabled':BOOL}),['power_inlet'],'电源；断电关闭主动阀，不消除残压','device_command','agent',{'enabled':True},['power.enabled','cycle.phase','thermal.indicated_k','pressure.max_gauge_pa','thermal.eco_mode','service.pump','service.lifts','leak_test.status','flush.status','flow_test.status']), |
| 'shield.set_lift':(obj({'lift_m':number('m',0,.18)}),obj({'lift_m':number('m',0,.18)}),['shield'],'上推屏；只在非运行、脱压、两升降架降下时移动','device_command','agent',{'lift_m':.18},['shield.lift_m']), |
| 'drawer.set_extension':(obj({'extension_m':number('m',0,.16)}),obj({'extension_m':number('m',0,.16)}),['heater_drawer'],'上推屏后向前抽加热块','device_command','agent',{'extension_m':.16},['drawer.extension_m']), |
| 'plant.configure':(PLANT,obj({'configured':BOOL}),['pump','mixer','nitrogen_inlet','exhaust'],'有限四溶剂/氮气、宿主工程系数；仅首次','configuration','evaluator',EXAMPLE,['plant.configured']), |
| 'method.configure':(METHOD,obj({'configured':BOOL}),['panel','pump','heater_lift'],'温压循环时间、单泵总流量、四溶剂体积分数、氮吹；可选vial（收集瓶60/150/220/240 mL、unspecified、waste）、cell_volume_m3、solvent_names与cycle_steps（各周期保持/排液/换瓶/溶剂口，EDIT METHOD，om p.52-56）','configuration','agent',METHOD_EXAMPLE,['method.configured','thermal.target_k','method.current','method.modified']), |
| 'thermal.preheat':(obj({'temperature_k':number('K',303.15,473.15),'enabled':BOOL},optional=('temperature_k','enabled')),obj({'enabled':BOOL}),['heater_lift'],'装池前预热；step推进，不能装冷池后密封加热；可选temperature_k（PREHEAT菜单的预热温度，缺省跟随方法温度）与enabled=false（OFF，随时可关；带temperature_k只存设定）','device_command','agent',{},['thermal.preheat_enabled','thermal.preheat_target_k']), |
| 'sample.configure':(SAMPLE,obj({'configured':BOOL,'attachment_event':TEXT}),['heater_lift','cell_0','cell_1','cell_2','cell_3','cell_4','cell_5'],'宿主装入干燥/已审查固体；六位置必须同容量','configuration','evaluator',SAMPLE_EXAMPLE,['sample.configured','cells.occupancy']), |
| 'acquisition.start':(obj({}),obj({'phase':PHASE,'operation_id':TEXT}),['pump','media_valve','outlet_valve','heater_lift','collection_rack'],'密封、气密代理、充液、分级升压、保持、排液、最终冲洗/氮吹、解封','device_command','agent',{},['cycle.phase','cycle.stage','service.valves','service.pump']), |
| 'acquisition.stop':(obj({}),obj({'phase':PHASE}),['media_valve','pump'],'暂停/取消主动动作；保留残压/库存，热和传质继续','device_command','agent',{},['cycle.phase']), |
| 'acquisition.abort':(obj({}),obj({'phase':PHASE}),['media_valve','outlet_valve'],'宿主有序终止：排液、氮吹、解封；不是第三次急停固件','device_command','agent',{},['cycle.phase','cycle.stage']), |
| 'extraction.measure':(obj({}),RESULT,['display_digits','pressure_sensor_0'],'仪器读数及阶段：压力为位置传感器读数的最大值（含评测者偏差与服务校零，默认理想）；不是校准仪表','query','agent',{},[]), |
| 'product.read':(obj({}),PRODUCT,['collection_rack','heater_lift'],'宿主条件回收率与真实跨仪器参考比值分开','query','evaluator',{},[]), |
| 'reference.lookup':(obj({'substance_id':TEXT}),REFERENCE,['display_digits'],'54真实ASE/Soxtec比较数据，不能当本机绝对回收率','query','agent',{'substance_id':'phenol'},[]), |
| 'sample.unload':(obj({'position':INT(0,5),'sample_id':TEXT,'gripper_confirmed':BOOL}),obj({'unloaded':BOOL,'attachment_event':TEXT}),['heater_lift','collection_rack'],'完整或有序终止后，开屏抽块，用夹具取池','configuration','evaluator',{'position':0,'sample_id':'soil_1','gripper_confirmed':True},['truth.removed_target_kg','cells.occupancy'])} |
| METHOD['properties'].update(METHOD_EXTRA);CAPS.update(DEVICE_CAPS) |
| SLOTS={} |
| def slot(k,s,u,o='derived',v='agent',c='display_digits',w=None):SLOTS[k]=(s,u,o,v,[c],w) |
| slot('power.enabled',BOOL,'1','setpoint',c='power_inlet',w=('power.set','enabled'));slot('shield.lift_m',number('m',0,.18),'m','scene',c='shield',w=('shield.set_lift','lift_m'));slot('drawer.extension_m',number('m',0,.16),'m','scene',c='heater_drawer',w=('drawer.set_extension','extension_m')) |
| for k,c in [('heater.lift_m','heater_lift'),('rack.lift_m','collection_rack')]:slot(k,number('m',0,.035),'m','scene',c=c) |
| for k,s,u in [('plant.configured',BOOL,'1'),('sample.configured',BOOL,'1'),('method.configured',BOOL,'1'),('thermal.preheat_enabled',BOOL,'1'),('thermal.target_k',nullable(TEMP),'K'),('thermal.indicated_k',nullable(TEMP),'K'),('pressure.max_gauge_pa',nullable(PRESS),'Pa'),('cycle.phase',PHASE,'1'),('cycle.stage',TEXT,'1'),('cycle.fault',TEXT,'1'),('cycle.index',INT(0,10),'1'),('cycle.elapsed_s',number('s',0),'s'),('cycle.stage_elapsed_s',number('s',0),'s')]:slot(k,s,u) |
| for k,u in [('initial_target_kg','kg'),('sorbed_target_kg','kg'),('dissolved_target_kg','kg'),('extract_target_kg','kg'),('degraded_target_kg','kg'),('removed_target_kg','kg'),('initial_solvent_m3','m^3'),('reservoir_solvent_m3','m^3'),('cell_solvent_m3','m^3'),('extract_solvent_m3','m^3'),('waste_solvent_m3','m^3'),('removed_solvent_m3','m^3'),('initial_nitrogen_mol','mol'),('remaining_nitrogen_mol','mol'),('exhaust_nitrogen_mol','mol'),('max_pressure_gauge_pa','Pa')]:slot('truth.'+k,number(u,0),u,'process_truth','evaluator','heater_lift') |
| NEW_SLOT_ZH={'positions.active':'激活位置（6个布尔；null=从未设定，1.0接口：装了样品池的位置都参与）','cells.occupancy':'各位置所放的池：sample样品池、empty空池或无', |
| 'method.current':'当前方法全部参数（未设定时为DEFAULT方法；含瓶、池、溶剂名与各周期参数）','method.name':'当前方法名（主屏标题）','method.modified':'当前方法改过且未保存（主屏标题划掉）', |
| 'method.library':'方法表（号与名称，最多100个）','thermal.preheat_target_k':'PREHEAT菜单的预热温度（null=跟随方法温度）','thermal.eco_mode':'EcoMode：下一次萃取结束后关加热', |
| 'leak_test.settings':'检漏参数（上次所用）','leak_test.status':'检漏状态：阶段、保持时间、各位压力读数、结果（各位最大差、最低占设定比例、是否符合手册判据）', |
| 'flush.settings':'冲洗参数','flush.status':'冲洗状态','flow_test.settings':'流动测试参数','flow_test.status':'流动测试状态（背压、时间）', |
| 'service.valves':'服务菜单阀门状态（溶剂阀、介质阀、位置阀、出液阀）','service.pump':'服务菜单泵：开关、设定与实际流量','service.lifts':'池/瓶升降位置、运动方向与电机电流', |
| 'service.fans':'两个风扇的功率设定（%）','service.counters':'运行次数与时间：萃取、检漏、运行/加热时间、最高温度/压力、升降电机最大电流','pressure.sensors':'七个压力传感器读数与零点（泵压+6位置）', |
| 'device.settings':'仪器设定：语言、对比度、按键蜂鸣、结束蜂鸣、开机预热询问','solvents.list':'溶剂表（20条名称）'} |
| for k,s,u,o,c,w in [('positions.active',nullable(POS6),'1','setpoint','heater_lift',None),('cells.occupancy',{'type':'array','items':nullable(TEXT)},'1','scene','heater_lift',None), |
| ('method.current',FREE,'1','setpoint','panel',None),('method.name',TEXT,'1','setpoint','panel',None),('method.modified',BOOL,'1','derived','panel',None), |
| ('method.library',{'type':'array','items':FREE},'1','setpoint','panel',None),('thermal.preheat_target_k',nullable(TEMP),'K','setpoint','heater_lift',None), |
| ('thermal.eco_mode',BOOL,'1','setpoint','heater_lift',('thermal.set_eco_mode','enabled')),('leak_test.settings',FREE,'1','setpoint','panel',None), |
| ('leak_test.status',FREE,'1','derived','pressure_sensor_0',None),('flush.settings',FREE,'1','setpoint','panel',None),('flush.status',FREE,'1','derived','pump',None), |
| ('flow_test.settings',FREE,'1','setpoint','panel',None),('flow_test.status',FREE,'1','derived','pump',None),('service.valves',FREE,'1','setpoint','media_valve',None), |
| ('service.pump',FREE,'1','derived','pump',None),('service.lifts',FREE,'1','derived','heater_lift',None),('service.fans',FREE,'1','setpoint','rear_fan',None), |
| ('service.counters',FREE,'1','derived','panel',None),('pressure.sensors',FREE,'Pa','derived','pressure_sensor_0',None),('device.settings',FREE,'1','setpoint','panel',None), |
| ('solvents.list',{'type':'array','items':TEXT},'1','setpoint','panel',None)]:slot(k,s,u,o,c=c,w=w) |
| NEW_SLOTS=list(NEW_SLOT_ZH) |
|
|
| |
| ASSET_VERSION='1.2.0';ASSET_DIR=ROOT/'assets/expansion_batch03/t2_vacuum/buchi_speedextractore' |
| NOTICE_TEXT={'solvent_supply_empty':('Error 66',['Pressure not reached. Pump timeout.','Please check solvent reservoir.','Please refer to user manual.']), |
| 'nitrogen_supply_empty':('Error 59',['Nitrogen inlet pressure out of range.','Please check nitrogen supply.','']), |
| 'collection_vial_full':('Error 4',['Change vials.','','']),'change_vials':('Error 4',['Change vials.','Press START to continue.','']), |
| 'pump_pressure_too_high':('Error 51',['Pump pressure too high.','Please refer to user manual.',''])} |
|
|
|
|
| def _notice_text(code): |
| if code.startswith('position_pressure_too_low:'): |
| n=int(code.split(':')[1]);return f'Error {44+n}',[f'Position {n}: Pressure too low.','Please check whether a cell','is inserted.'] |
| return NOTICE_TEXT.get(code,('Error',[code,'',''])) |
|
|
|
|
| def _panel_engine(): |
| try: |
| from . import _panel_ui as engine |
| return engine |
| except ImportError: |
| import importlib.util,sys |
| if '_chemsim_panel_ui' not in sys.modules: |
| spec=importlib.util.spec_from_file_location('_chemsim_panel_ui',Path(__file__).with_name('_panel_ui.py'));sys.modules['_chemsim_panel_ui']=importlib.util.module_from_spec(spec);spec.loader.exec_module(sys.modules['_chemsim_panel_ui']) |
| return sys.modules['_chemsim_panel_ui'] |
|
|
|
|
| |
| LOCKED=[{'do':'set_var','var':'msg','value':{'const':'locked'}},{'do':'goto','screen':'message'}] |
| def _write_method(panel,m,ctx): |
| return panel._invoke('method.configure',m,{'PRECONDITION_FAILED':LOCKED},ctx) |
| def _hook_method_set(panel,ctx,a): |
| h=panel.host;m=h._method_args();v=panel._src(a['value'],ctx);f=a['field'] |
| if f=='cycles': |
| n=int(round(v));steps=m['cycle_steps'];m['cycle_steps']=(steps+[copy.deepcopy(steps[-1]) for _ in range(n)])[:n];m['cycles']=n |
| elif v is None:m.pop(f,None) |
| else:m[f]=v |
| return _write_method(panel,h._sync_steps(m),ctx) |
| def _hook_method_default(panel,ctx,a): |
| return _write_method(panel,copy.deepcopy(DEFAULT_METHOD),ctx) |
| def _hook_cycle_value(panel,ctx,s): |
| k=int(panel.ui['vars'].get('cyc') or 1);steps=panel.host._full_method()['cycle_steps'];return steps[min(k,len(steps))-1][s['param']] |
| def _hook_cycle_set(panel,ctx,a): |
| h=panel.host;m=h._method_args();k=int(panel.ui['vars'].get('cyc') or 1);v=panel._src(a['value'],ctx) |
| if k>m['cycles']:return False |
| m['cycle_steps'][k-1][a['key']]=int(v) if a['key']=='port' else bool(v) if a['key']=='vial_change' else float(v) |
| return _write_method(panel,h._sync_steps(m),ctx) |
| def _hook_cycle_paste(panel,ctx,a): |
| h=panel.host;m=h._method_args();src=panel.ui['vars'].get('clip');it=panel._current_item()[0] |
| if not src or not it or it.get('cycle',99)>m['cycles'] or src>m['cycles']:return False |
| m['cycle_steps'][it['cycle']-1]=copy.deepcopy(m['cycle_steps'][src-1]);return _write_method(panel,h._sync_steps(m),ctx) |
| def _hook_solvent_open(panel,ctx,a): |
| m=panel.host._full_method();V=panel.ui['vars'] |
| for k in range(4):V[f'sol_n{k+1}']=m['solvent_names'][k];V[f'sol_r{k+1}']=int(round(m['solvent_fractions'][k]*100)) |
| return True |
| def _write_solvents(panel,ctx): |
| V=panel.ui['vars'];r=[V[f'sol_r{k}'] for k in range(1,5)] |
| if sum(r)!=100:return True |
| h=panel.host;m=h._method_args();m['solvent_fractions']=[x/100. for x in r];m['solvent_names']=[V[f'sol_n{k}'] for k in range(1,5)] |
| return _write_method(panel,h._sync_steps(m),ctx) |
| def _hook_solvent_store(panel,ctx,a): |
| V=panel.ui['vars'] |
| for fid,val in (ctx.get('buffer') or {}).items(): |
| if fid.startswith('type'):V['sol_n'+fid[4:]]=val |
| elif fid.startswith('ratio'):V['sol_r'+fid[5:]]=int(round(val)) |
| return _write_solvents(panel,ctx) |
| def _hook_solvent_name(panel,ctx,s): |
| return panel.ui['vars'].get(f"sol_n{panel.ui['vars'].get('name_port') or 1}",'') |
| def _hook_solvent_rename(panel,ctx,a): |
| V=panel.ui['vars'];V[f"sol_n{V.get('name_port') or 1}"]=V.get('name_buf') or '';return _write_solvents(panel,ctx) |
| def _hook_list_name(panel,ctx,s): |
| return panel.host.solvent_list[int(panel.ui['vars'].get('list_index') or 1)-1] |
| def _hook_slot_name(panel,ctx,s): |
| it=panel._current_item()[0];h=panel.host |
| return h.library[it['slot']]['name'] if it and it.get('slot') in h.library else h.method_name |
| def _hook_grid_select(panel,ctx,a): |
| V=panel.ui['vars'];ch=a['chars'][int(V.get('grid_pos') or 0)];buf=V.get('name_buf') or '' |
| limit=16 if V.get('name_target')=='method' else 20 |
| if ch=='BACKSPACE':V['name_buf']=buf[:-1];return True |
| if len(buf)>=limit:panel._accepted=False;return True |
| V['name_buf']=buf+ch;return True |
| def _hook_aux_ratio(panel,ctx,a): |
| cap=a['capability'];h=panel.host;store=h.leak if cap=='leak_test.configure' else h.flush_set |
| f=list(store['solvent_fractions']);f[a['port']-1]=max(0.,min(1.,panel._src(a['value'],ctx)/100.)) |
| return panel._invoke(cap,dict(solvent_fractions=f),None,ctx) |
| PANEL_HOOKS={k[6:]:v for k,v in dict(globals()).items() if k.startswith('_hook_')} |
|
|
| _panel_ui=_panel_engine() |
| PANEL_SPEC=_panel_ui.load_spec(ASSET_DIR/'panel_ui.json',capabilities=set(CAPS)) if (ASSET_DIR/'panel_ui.json').is_file() else None |
| PANEL_CAPS=_panel_ui.capability_definitions(PANEL_SPEC) if PANEL_SPEC else {} |
| _PANEL_FX=list(dict.fromkeys(e for c in (_panel_ui.spec_capabilities(PANEL_SPEC) if PANEL_SPEC else []) for e in CAPS[c][7])) |
| for _k,_d in PANEL_CAPS.items(): |
| CAPS[_k]=(_d['input_schema'],_d['output_schema'],_d['component_ids'],_d['function_zh'],_d['kind'],_d['visibility'],_d['example_arguments'],[] if _d['kind']=='query' else list(_PANEL_FX)) |
|
|
|
|
| def _hms(s): |
| if s is None:return '--:--:--' |
| s=int(round(s));return f'{s//3600:02d}:{s%3600//60:02d}:{s%60:02d}' |
| def _bar(pa):return f'{max(0.,pa)/BAR:.1f} bar' |
|
|
|
|
| class _E916Panel: |
| """Panel-host protocol of the engine: what the controller firmware shows, and the panel.* commands.""" |
| def _method_args(self): |
| m=self._full_method();return {k:v for k,v in m.items() if v is not None} |
| def _sync_steps(self,m): |
| s=m['cycle_steps'][0];m['hold_s']=float(s['hold_s']);m['discharge_s']=float(s['discharge_s']);return m |
| def panel_time(self):return self.time_s |
| def panel_invoke(self,capability_id,arguments): |
| try: |
| validate(CAPS[capability_id][0],arguments);return self.invoke(capability_id,**arguments) |
| except ActionRejected as exc: |
| raise _panel_ui.PanelRejected(str(exc)) from None |
| def _panel_cmd(self,cap,a): |
| err=_panel_ui.check_arguments(CAPS[cap][0],a) |
| if err:raise ActionRejected('INVALID_ARGUMENT') |
| if cap=='panel.frame':return dict(frame=self.panel.frame()) |
| if cap=='panel.capture': |
| import hashlib,tempfile |
| data,w,h=self.panel.png_bytes(a['display_id']);sha=hashlib.sha256(data).hexdigest() |
| d=Path(self.panel_capture_dir) if self.panel_capture_dir else Path(tempfile.gettempdir())/'chemistry_sim_panel'/self.instance_id;d.mkdir(parents=True,exist_ok=True) |
| path=d/f"{a['display_id']}_{sha[:16]}.png" |
| if not path.exists():path.write_bytes(data) |
| return dict(display_id=a['display_id'],time_s=self.time_s,image=dict(path=str(path),format='png',width=w,height=h,sha256=sha)) |
| try: |
| if cap=='panel.press':ok=self.panel.press(a['input_id'],float(a.get('duration_s',.1))) |
| elif cap=='panel.turn':ok=self.panel.turn(a['input_id'],int(a['detents'])) |
| else:ok=self.panel.switch(a['input_id'],a['position']) |
| except _panel_ui.PanelError: |
| raise ActionRejected('INVALID_ARGUMENT') from None |
| if ok and cap=='panel.press' and self.settings['beep_key']:self.key_beeps+=1 |
| return dict(accepted=bool(ok)) |
| def panel_read(self): |
| out=self.read('agent');m=self._full_method();rd=self._readings();act=self._active();occ=self._occupancy() |
| end_c,vc,total=self._times() if self.plant else (None,None,None) |
| V=self._valve_view();on=lambda b:'[x]' if b else '[ ]' |
| skip=(self.phase=='running' and (self.stage in ('hold','solvent_flush') or (self.stage=='nitrogen_flush' and self.stage_elapsed>=60 and self._measured_max()<=BAR))) |
| skip_leak=bool(self.aux and self.aux['kind']=='leak_test' and self.aux['stage'] in ('tightness','pump','hold')) |
| cells=self._run_cells();vol=self._cell_volume(cells) if (cells or self.cells or (self.method or {}).get('cell_volume_m3')) else (m['cell_volume_m3'] or 20e-6) |
| rows=[] |
| for k in range(1,11): |
| if k>m['cycles']:rows.append(f'{k:>3} n/a n/a n/a n/a Mix');continue |
| s=m['cycle_steps'][k-1];mn=lambda x:(f'{x/60:.0f} min' if abs(x/60-round(x/60))<1e-9 else f'{x/60:.1f} min') |
| rows.append(f"{k:>3} {max(1,math.ceil(10*vol/20e-6/60)):>3} min {mn(s['hold_s']):>7} {mn(s['discharge_s']):>9} {on(s['vial_change'])} {'P'+str(s['port']) if s['port'] else 'Mix'}") |
| lt=self.aux if (self.aux and self.aux['kind']=='leak_test') else None;last=self.aux_last.get('leak_test') |
| lr_pos=[rd[1+i] for i in range(6)] |
| names=[n for n in self.solvent_list if n]+[n for n in m['solvent_names'] if n and n not in self.solvent_list] |
| notice=None |
| if self.notice: |
| t,ls=_notice_text(self.notice['code']);notice=dict(id=self.notice['id'],title=t,lines=ls) |
| c=self.counters;hm=lambda s:f'{int(s)//3600}:{int(s)%3600//60:02d} h:m' |
| lifts=self._lifts();amb=self.plant['ambient_k'] if self.plant else 295.15 |
| stage=(STAGE_TEXT.get(lt['stage'],lt['stage']) if lt else ('Finished' if last else 'Ready')) |
| out.update({ |
| 'host.power_epoch':self.power_epoch,'host.head':f"{self.cycle} / {m['cycles']}",'host.name':self.method_name,'host.modified':self.method_modified, |
| 'host.remain':_hms(total),'host.status':self._status_text(),'host.heating':bool(self.powered and self.preheat),'host.pumping':bool(self.powered and self._pumping()), |
| 'host.active':[i in act for i in range(6)],'host.any_active':bool(act),'host.temp_c':round(self.temperature-273.15) if self.powered else None, |
| 'host.max_bar':max(0.,max(rd[1:]))/BAR,'host.skip':bool(skip or skip_leak),'host.skip_leak':skip_leak,'host.in_operation':self._in_operation(), |
| 'host.aborting':bool(self.aborting),'host.ready':bool(self.method and abs(self.temperature-self.method['temperature_k'])<=1), |
| 'host.progress':[_hms(end_c),_hms(vc),_hms(total)],'host.overflow':self._overflow_possible(),'host.cycle_rows':rows, |
| 'host.heatup_text':f'{max(1,math.ceil(10*vol/20e-6/60))}min','host.library':[self.library[k]['name'] if k in self.library else '' for k in range(1,101)], |
| 'host.library_slots':sorted(self.library),'host.solvent_options':[{'name':n} for n in names], |
| 'host.diagram':[ |
| 'Solvent valves '+' '.join(f'{i+1}{on(V["solvent"][i])}' for i in range(4)), |
| 'Media valve '+{'solvent':'Solvent','gas':'Gas',None:'closed'}[V['media']], |
| 'Pump '+(f"on {round((self.pump['actual_m3_s'] if self.pump['on'] else (self.method or m)['pump_total_m3_s'])*6e7)} mL/min" if self._pumping() else 'off'), |
| 'Position valves '+' '.join(f'{i+1}{on(V["position"][i])}' for i in range(6)), |
| 'Cells '+' '.join({'sample':'S','empty':'E',None:'-'}[occ[i]] for i in range(6)), |
| 'Pressure [bar] '+' '.join(f'{max(0.,x)/BAR:.0f}' for x in rd[1:]), |
| 'Outlet valve '+{'vial':'Vial','waste':'Waste',None:'closed'}[V['outlet']], |
| 'Total pressure '+_bar(rd[0]),'',''], |
| 'host.leak_run':dict(stage=stage,overall=f'{max(0.,rd[0])/BAR:.0f}',cells=' '.join(f'[{i+1}]' if i in act else ' -- ' for i in range(6)), |
| pressures=' '.join(f'{max(0.,x)/BAR:3.0f}' if i in act else ' ' for i,x in enumerate(lr_pos)), |
| hold=(f"{int(lt['hold_elapsed'])//60:02d}:{int(lt['hold_elapsed'])%60:02d}" if lt else '00:00'), |
| max=f'{max([lr_pos[i] for i in act] or [0.])/BAR:.0f} bar'), |
| 'host.valve_text':{**{f'solvent_{i+1}':'[open]' if self.valves['solvent'][i] else '[close]' for i in range(4)}, |
| **{f'position_{i+1}':'[open]' if self.valves['position'][i] else '[close]' for i in range(6)}, |
| 'media_solvent':'[open]' if self.valves['media']=='solvent' else '[close]','media_gas':'[open]' if self.valves['media']=='gas' else '[close]', |
| 'outlet_vial':'[open]' if self.valves['outlet']=='vial' else '[close]','outlet_waste':'[open]' if self.valves['outlet']=='waste' else '[close]'}, |
| 'host.lights':{'cell_upper':'[X]' if self.heater>=.035-1e-9 else '[ ]','cell_lower':'[X]' if self.heater<=1e-9 else '[ ]', |
| 'vial_upper':'[X]' if self.rack>=.035-1e-9 else '[ ]','vial_lower':'[X]' if self.rack<=1e-9 else '[ ]', |
| 'heater_middle':'[X]' if self.drawer<=1e-9 else '[ ]','shield_upper':'[X]' if self.shield>=.179 else '[ ]', |
| 'shield_lower':'[X]' if self.shield<=1e-9 else '[ ]','rack_present':'[X]'}, |
| 'host.pressures':[_bar(x) for x in rd],'host.temps':dict(heater=f'{self.temperature-273.15:.0f}°C',electronic=f'{amb-273.15+5:.0f}°C' if self.powered else '---'), |
| 'host.pump':dict(actual=f"{self.pump['actual_m3_s']*6e7:.0f} mL/min",pressure=_bar(rd[0])), |
| 'host.flow':dict(pressure=_bar(rd[self.flow_set['position']]) if (self.aux and self.aux['kind']=='flow_test') else _bar(0.), |
| time=f"{int(self.aux['elapsed'])} s" if (self.aux and self.aux['kind']=='flow_test') else '0 s'), |
| 'host.lift_current':f"{max(lifts['current_a'].values()):.3f} A", |
| 'host.counters':dict(extractions=str(c['extractions']),leak_tests=str(c['leak_tests']),operating=hm(c['operating_s']),heater=hm(c['heater_s']), |
| cell_ma=f"{self.current_max['cell']*1000:.0f} mA",vial_ma=f"{self.current_max['vial']*1000:.0f} mA", |
| max_t=f"{c['max_temperature_k']-273.15:.0f} °C" if c['max_temperature_k'] else '---',max_p=_bar(c['max_pressure_pa'])), |
| 'host.unit':dict(UNIT_INFO),'host.notice':notice}) |
| return out |
|
|
|
|
| class BuchiSpeedextractoreRuntime(_E916Device,_E916Panel): |
| def __init__(self,instance_id='speedextractor_01'): |
| self.instance_id=instance_id;self.time_s=0.;self.revision=0;self.powered=False;self.shield=0.;self.drawer=0.;self.heater=0.;self.rack=0.;self.plant=None;self.method=None;self.cells={};self.phase='idle';self.stage='standby';self.fault='';self.elapsed_s=0.;self.stage_elapsed=0.;self.cycle=0;self.operation_id=None;self._operation_count=0;self.preheat=False;self.temperature=295.15;self.reservoir=[0.]*4;self.waste=[0.]*4;self.nitrogen=0.;self.nitrogen_out=0.;self.aborting=False;self.history=[];self.next_sample=0.;self.templates={x['substance_id']:x for x in json.loads((ROOT/TEMPLATE_REL).read_text())['templates']};self.solvents={x['substance_id']:x for x in json.loads((LIB/'solvents.json').read_text())['solvents']};self._principals={'__public_agent__':'agent'};self._requests={};self._owners={};self._caller=None |
| self._device_init();self.key_beeps=0;self.panel_capture_dir=None;self.panel=_panel_ui.PanelUI(PANEL_SPEC,self,PANEL_HOOKS) if PANEL_SPEC else None |
| 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 BuchiSpeedextractoreSession(self,principal_id) |
| def describe(self):return self.session().describe(instance_id=self.instance_id) |
| def _maxp(self):return max((c['pressure'] for c in self._records().values()),default=0.) |
| def _inventory(self): |
| active=[c for c in self.cells.values() if not c['removed']];removed=[c for c in self.cells.values() if c['removed']];blanks=list(self.blanks.values()) |
| return dict(initial_target_kg=sum(c['spec']['target_mass_kg'] for c in self.cells.values()),sorbed_target_kg=sum(c['sorbed'] for c in active),dissolved_target_kg=sum(c['dissolved'] for c in active),extract_target_kg=sum(c['extract'] for c in active),degraded_target_kg=sum(c['degraded'] for c in active),removed_target_kg=sum(c['sorbed']+c['dissolved']+c['extract']+c['degraded'] for c in removed)+sum(c['wasted']+c['collected'] for c in self.cells.values()),initial_solvent_m3=sum(self.plant['reservoir_m3']) if self.plant else 0.,reservoir_solvent_m3=sum(self.reservoir),cell_solvent_m3=sum(sum(c['liquid']) for c in active+blanks),extract_solvent_m3=sum(sum(c['vial']) for c in active+blanks),waste_solvent_m3=sum(self.waste),removed_solvent_m3=sum(sum(c['liquid'])+sum(c['vial']) for c in removed)+sum(self.exchanged)+sum(self.removed_blank),initial_nitrogen_mol=self.plant['nitrogen_mol'] if self.plant else 0.,remaining_nitrogen_mol=self.nitrogen,exhaust_nitrogen_mol=self.nitrogen_out,max_pressure_gauge_pa=self._maxp()) |
| def _values(self): |
| v={'power.enabled':self.powered,'shield.lift_m':self.shield,'drawer.extension_m':self.drawer,'heater.lift_m':self.heater,'rack.lift_m':self.rack,'plant.configured':self.plant is not None,'sample.configured':bool(self.cells),'method.configured':self.method is not None,'thermal.preheat_enabled':self.preheat,'thermal.target_k':self.method['temperature_k'] if self.method else None,'thermal.indicated_k':self.temperature if self.powered else None,'pressure.max_gauge_pa':self._measured_max() if self.powered else None,'cycle.phase':self.phase,'cycle.stage':self.stage,'cycle.fault':self.fault,'cycle.index':self.cycle,'cycle.elapsed_s':self.elapsed_s,'cycle.stage_elapsed_s':self.stage_elapsed};v.update({'truth.'+k:x for k,x in self._inventory().items()});v.update(self._device_values());return v |
| def _device_values(self): |
| return {'positions.active':list(self.positions) if self.positions is not None else None,'cells.occupancy':self._occupancy(),'method.current':self._full_method(),'method.name':self.method_name, |
| 'method.modified':self.method_modified,'method.library':[dict(slot=k,name=e['name']) for k,e in sorted(self.library.items())],'thermal.preheat_target_k':self.preheat_k, |
| 'thermal.eco_mode':self.eco,'leak_test.settings':copy.deepcopy(self.leak),'leak_test.status':self._aux_status(self.aux if self.aux and self.aux['kind']=='leak_test' else None) if self.aux and self.aux['kind']=='leak_test' else dict(self.aux_last.get('leak_test',dict(active=False)),active=False), |
| 'flush.settings':copy.deepcopy(self.flush_set),'flush.status':self._aux_status() if self.aux and self.aux['kind']=='flush' else dict(self.aux_last.get('flush',dict(active=False)),active=False), |
| 'flow_test.settings':copy.deepcopy(self.flow_set),'flow_test.status':self._aux_status() if self.aux and self.aux['kind']=='flow_test' else dict(self.aux_last.get('flow_test',dict(active=False)),active=False), |
| 'service.valves':copy.deepcopy(self.valves),'service.pump':copy.deepcopy(self.pump),'service.lifts':self._lifts(),'service.fans':dict(self.fans),'service.counters':self._counters(), |
| 'pressure.sensors':self._sensors(),'device.settings':dict(self.settings),'solvents.list':list(self.solvent_list)} |
| def read(self,visibility='agent'):return copy.deepcopy({k:v for k,v in self._values().items() if visibility!='agent' or SLOTS[k][3]=='agent'}) |
| def _measure(self):return dict(phase=self.phase,stage=self.stage,fault=self.fault,temperature_k=self.temperature if self.powered else None,max_pressure_gauge_pa=self._measured_max() if self.powered else None,cycle=self.cycle,stage_elapsed_s=self.stage_elapsed,evidence='synthetic_host_lumped_partition_and_control; NOT validated recovery or safety',template_source=TEMPLATE_REL) |
| def _product(self): |
| items=[] |
| for i,c in self.cells.items(): |
| s=c['spec'];ref=self.templates[s['substance_id']];items.append(dict(position=i,sample_id=s['sample_id'],substance_id=s['substance_id'],extract_target_kg=c['extract']+c['collected'],residual_target_kg=c['sorbed']+c['dissolved'],degraded_target_kg=c['degraded'],matrix_mass_kg=s['matrix_mass_kg'],extract_solvent_m3=sum(c['vial']),residual_solvent_m3=sum(c['liquid']),modeled_absolute_recovery_fraction=min(1.,(c['extract']+c['collected'])/s['target_mass_kg']),measured_e916_recovery_fraction=None,reference_ase_soxtec_ratio=ref['values']['ase_to_soxtec_recovery_ratio'],reference_instrument=ref['conditions']['instrument'])) |
| return dict(items=items,evidence='synthetic_absolute_yield_from_host_Kd_transfer; measured_literature_relative_ASE200_to_Soxtec_is_NOT_E916_yield',template_source=TEMPLATE_REL) |
| def saturation_pressure(self,temperature,volume_fractions): |
| total=0.;parts=[] |
| for sid,f in zip(SOLVENTS,volume_fractions): |
| s=self.solvents[sid];points=s['vapor_pressure_reference_points'];t=temperature |
| if not points[0]['temperature_k']<=t<=points[-1]['temperature_k']:raise ActionRejected('TEMPLATE_RANGE_UNAVAILABLE') |
| j=min(len(points)-2,int((t-points[0]['temperature_k'])/5));lo,hi=points[j:j+2];weight=(t-lo['temperature_k'])/(hi['temperature_k']-lo['temperature_k']);ps=math.exp((1-weight)*math.log(lo['pressure_pa'])+weight*math.log(hi['pressure_pa']));moles=f*s['density_298_15_kg_m3']/s['molar_mass_kg_mol'];parts.append((moles,ps));total+=moles |
| return sum(n*p for n,p in parts)/total if total else 0. |
| def invoke(self,capability,**a): |
| if capability not in CAPS:raise ActionRejected('UNKNOWN_CAPABILITY') |
| validate(CAPS[capability][0],a) |
| if capability in PANEL_CAPS: |
| out=self._panel_cmd(capability,a) |
| if CAPS[capability][4]!='query':self.revision+=1 |
| return out |
| if capability in DEVICE_CAPS: |
| if _panel_ui.check_arguments(CAPS[capability][0],a):raise ActionRejected('INVALID_ARGUMENT') |
| else: |
| for k in ('position','cycles'): |
| if k in a and (isinstance(a[k],bool) or not isinstance(a[k],int) or not (1<=a[k]<=10 if k=='cycles' else 0<=a[k]<=5)):raise ActionRejected('INVALID_ARGUMENT') |
| if self._foreign_process(capability,a):raise ActionRejected('ACCESS_DENIED') |
| if self.phase=='running' and CAPS[capability][4]!='query' and capability not in RUN_OK:raise ActionRejected('BUSY') |
| if capability in DEVICE_CAPS: |
| out=self._device_invoke(capability,a);self.revision+=1;return copy.deepcopy(out) |
| if capability=='power.set': |
| if a['enabled'] and not self.powered:self.power_epoch+=1 |
| if not a['enabled'] and self.powered: |
| self.eco=False;self.pump.update(on=False,actual_m3_s=0.);self.lift_cmd=dict(cell=None,vial=None) |
| if self.aux:self.aux['fault']='power_off';self.aux_last[self.aux['kind']]=self._aux_status();self.aux=None |
| self.powered=a['enabled'] |
| if not self.powered and self.phase=='running':self.phase='cancelled' |
| out=a |
| elif capability in ('shield.set_lift','drawer.set_extension'): |
| if self._maxp()>1e5 or self.heater>1e-9 or self.rack>1e-9:raise ActionRejected('PRECONDITION_FAILED') |
| if capability=='shield.set_lift': |
| if a['lift_m']<.179 and self.drawer>1e-9:raise ActionRejected('PRECONDITION_FAILED') |
| self.shield=a['lift_m'] |
| else: |
| if self.shield<.179:raise ActionRejected('PRECONDITION_FAILED') |
| self.drawer=a['extension_m'] |
| out=a |
| elif capability=='plant.configure': |
| if self.plant or not a['exhaust_connected'] or not a['dry_matrix_reviewed'] or len(a['reservoir_m3'])!=4 or not a['coefficient_evidence']:raise ActionRejected('PRECONDITION_FAILED') |
| self.plant=copy.deepcopy(a);self.reservoir=list(a['reservoir_m3']);self.nitrogen=a['nitrogen_mol'];self.temperature=a['ambient_k'];out={'configured':True} |
| elif capability=='method.configure': |
| f=a['solvent_fractions'] |
| if self._operation_count or self.cells or len(f)!=4 or abs(sum(f)-1)>1e-9 or self.aux:raise ActionRejected('PRECONDITION_FAILED') |
| if a['pressure_gauge_pa']/3+101325<1.1*self.saturation_pressure(a['temperature_k'],f):raise ActionRejected('LIQUID_PHASE_GUARD') |
| self._check_method_extras(a) |
| self.method=copy.deepcopy(a);self.method_modified=True;out={'configured':True} |
| elif capability=='thermal.preheat': |
| if not a.get('enabled',True): |
| if 'temperature_k' in a:self.preheat_k=a['temperature_k'] |
| self.preheat=False;out={'enabled':False} |
| else: |
| if not self.powered or not self.plant or (not self.method and 'temperature_k' not in a) or self.cells or self.heater>0:raise ActionRejected('PRECONDITION_FAILED') |
| self.preheat_k=a.get('temperature_k');self.preheat=True;out={'enabled':True} |
| elif capability=='sample.configure': |
| if not self.plant or not self.method or not self.preheat or abs(self.temperature-self.method['temperature_k'])>1 or self.shield<.179 or self.drawer<.159 or not a['gripper_confirmed'] or self._operation_count or a['position'] in self.cells or a['position'] in self.blanks or not a['sample_id'] or any(c['spec']['sample_id']==a['sample_id'] for c in self.cells.values()) or a['matrix_solid_volume_m3']>=a['cell_volume_m3']*.9 or a['target_mass_kg']>a['matrix_mass_kg']*.01 or len(a['kd_m3_kg_by_solvent'])!=4 or not a['parameters_evidence']:raise ActionRejected('PRECONDITION_FAILED') |
| if a['substance_id'] not in self.templates:raise ActionRejected('TEMPLATE_RANGE_UNAVAILABLE') |
| if any(c['spec']['cell_volume_m3']!=a['cell_volume_m3'] for c in self.cells.values()):raise ActionRejected('PRECONDITION_FAILED') |
| self.cells[a['position']]=dict(spec=copy.deepcopy(a),pressure=0.,liquid=[0.]*4,vial=[0.]*4,sorbed=a['target_mass_kg'],dissolved=0.,extract=0.,degraded=0.,removed=False,wasted=0.,collected=0.);out=dict(configured=True,attachment_event='host_attach:'+a['sample_id']) |
| elif capability=='acquisition.start': |
| if not self.powered or not self.plant or not self.method or not self.cells or any(c['removed'] for c in self.cells.values()) or self.shield>1e-9 or self.drawer>1e-9 or self.phase not in ('idle','cancelled') or self.stage in ('complete','halted') or abs(self.temperature-self.method['temperature_k'])>1 or not self._active():raise ActionRejected('PRECONDITION_FAILED') |
| if self.aux:raise ActionRejected('BUSY') |
| if not self._operation_count:self._next('sealing');self.cycle=1;self.counters['extractions']+=1 |
| self.valves=dict(solvent=[False]*4,media=None,position=[False]*6,outlet=None);self.pump.update(on=False,actual_m3_s=0.);self.lift_cmd=dict(cell=None,vial=None) |
| self.phase='running';self._operation_count+=1;self.operation_id=self.instance_id+':'+str(self._operation_count);out=dict(phase=self.phase,operation_id=self.operation_id) |
| elif capability=='acquisition.stop': |
| if self.phase!='running':raise ActionRejected('PRECONDITION_FAILED') |
| self.phase='cancelled';out=dict(phase=self.phase) |
| elif capability=='acquisition.abort': |
| if not self.powered or not self._operation_count or self.phase not in ('running','cancelled') or self.stage in ('complete','halted'):raise ActionRejected('PRECONDITION_FAILED') |
| self.aborting=True;self.phase='running';self._next('discharge');out=dict(phase=self.phase) |
| elif capability=='extraction.measure':return self._measure() |
| elif capability=='product.read':return self._product() |
| elif capability=='reference.lookup': |
| q=self.templates.get(a['substance_id']) |
| if q is None:raise ActionRejected('TEMPLATE_RANGE_UNAVAILABLE') |
| return dict(substance_id=q['substance_id'],name=q['name'],ase_soxtec_ratio=q['values']['ase_to_soxtec_recovery_ratio'],measured_e916_recovery_fraction=None,source=q['source'],conditions=json.dumps(q['conditions'],ensure_ascii=False),evidence=q['evidence'],template_source=TEMPLATE_REL) |
| elif capability=='sample.unload': |
| c=self.cells.get(a['position']) |
| if not c or c['spec']['sample_id']!=a['sample_id'] or c['removed'] or self.stage not in ('complete','halted') or self._maxp()>1e5 or self.shield<.179 or self.drawer<.159 or not a['gripper_confirmed']:raise ActionRejected('PRECONDITION_FAILED') |
| c['removed']=True;out=dict(unloaded=True,attachment_event='host_release:'+a['sample_id']) |
| self.revision+=1;return copy.deepcopy(out) |
| def _fan_percent(self): |
| """Extraction fan performance: the service setting, 100 % while a fault event is active (om p.88: to get rid of leaking solvent).""" |
| return 100 if (self.phase=='failed' or (self.aux is not None and self.aux['fault'])) else self.fans['extraction'] |
| def _foreign_process(self,k,a): |
| """An agent may not stop, skip, resume or change (heater, fan, EcoMode, service valves / pump / lifts / sensor zero) another agent's |
| extraction (in progress, also while paused) or its leak test / flush / flow test: direct calls and the same commands from the panel keys (the |
| session sets _caller around the call); unowned processes and evaluators are not restricted. 1.2.0 (lead rule 10-19): the green mains rocker |
| switch (and power.set, which models it) is a hard switch - a physical action that is never refused; switching off acts as a power loss.""" |
| c=self.__dict__.get('_caller') |
| if c is None or self._principals.get(c)!='agent':return False |
| off=False;change=k in CHANGES_PROCESS |
| if self._in_operation() and (off or change or k in ('acquisition.start','acquisition.stop','acquisition.abort','acquisition.halt','acquisition.skip')): |
| o=self._owners.get(self.operation_id) |
| if o is not None and o!=c:return True |
| if self.aux and (off or change or k in ('leak_test.stop','flush.stop','flow_test.stop')): |
| o=self.aux.get('owner') |
| if o is not None and o!=c:return True |
| return False |
| def _next(self,stage): |
| self.stage=stage;self.stage_elapsed=0.;self.history.append(dict(time_s=self.time_s,stage=stage,cycle=self.cycle)) |
| def _fail(self,reason):self.phase='failed';self.fault=reason;self._notify(reason) |
| def _feed(self,c,vol): |
| f=self._fractions();v=min([vol]+[self.reservoir[i]/x for i,x in enumerate(f) if x>0]) |
| for i,x in enumerate(f):self.reservoir[i]-=v*x;c['liquid'][i]+=v*x |
| if v+1e-15<vol:self._fail('solvent_supply_empty') |
| def _drain(self,c,vol,holdup=0.): |
| if (self.method or {}).get('vial')=='waste':return self._drain_to(c,vol,holdup,'waste') |
| v=sum(c['liquid']);x=min(max(0.,v-holdup),vol);space=self.plant['vial_capacity_m3']-sum(c['vial']) |
| if x>space+1e-15:self._fail('collection_vial_full');x=max(0.,space) |
| frac=x/v if v else 0.;m=c['dissolved']*frac;c['dissolved']-=m;c['extract']+=m |
| for i in range(4):x=c['liquid'][i]*frac;c['liquid'][i]-=x;c['vial'][i]+=x |
| def _transfer(self,c,h): |
| if c['removed']:return |
| s=c['spec'];v=sum(c['liquid']);t=self.temperature;total=c['sorbed']+c['dissolved'] |
| if v>1e-15: |
| kd=math.exp(sum(c['liquid'][i]/v*math.log(s['kd_m3_kg_by_solvent'][i]) for i in range(4)))*math.exp(s['adsorption_energy_j_mol']/8.314462618*(1/t-1/298.15));eq=min(total*v/(v+kd*s['matrix_mass_kg']),s['solubility_kg_m3']*v);k=s['mass_transfer_s_inv']*math.exp(s['activation_energy_j_mol']/8.314462618*(1/298.15-1/t));delta=(eq-c['dissolved'])*-math.expm1(-k*h);delta=max(-c['dissolved'],min(c['sorbed'],delta));c['sorbed']-=delta;c['dissolved']+=delta |
| d=-math.expm1(-s['degradation_s_inv']*h) |
| for key in ('sorbed','dissolved'):x=c[key]*d;c[key]-=x;c['degraded']+=x |
| def _gas(self,h): |
| requested=self.plant['nitrogen_mol_s_per_cell']*len(self._run_cells())*h;x=min(self.nitrogen,requested);self.nitrogen-=x;self.nitrogen_out+=x |
| if x+1e-12<requested:self._fail('nitrogen_supply_empty') |
| def _tick(self,h): |
| p=self.plant;m=self.method;heat=bool(self.powered and self.preheat and (self.preheat_k is not None or m)) |
| target=(self.preheat_k if self.preheat_k is not None else m['temperature_k']) if heat else p['ambient_k'] |
| g=FAN_LOSS*(self._fan_percent()-FAN_FACTORY)/100. if self.powered else 0. |
| t_ss=(target+g*p['ambient_k'])/(1+g);self.temperature+=(t_ss-self.temperature)*-math.expm1(-h*(1+g)/p['thermal_tau_s']) |
| self._counters_tick(h,heat);running=self.powered and self.phase=='running' |
| if running:self._extraction_tick(h) |
| elif self.stage=='vial_change':self.rack=max(0.,self.rack-.01*h) |
| if self.powered and self.aux:self._aux_tick(h) |
| elif self.powered and not running:self._service_tick(h) |
| for c in self.cells.values():self._transfer(c,h) |
| self.time_s+=h |
| def _extraction_tick(self,h): |
| p=self.plant;m=self.method;cells=self._run_cells() |
| self.elapsed_s+=h;self.stage_elapsed+=h |
| if self.stage=='sealing': |
| self.heater=min(.035,self.heater+.01*h);self.rack=min(.035,self.rack+.01*h) |
| if self.heater>=.035 and self.rack>=.035:self._next('tightness') |
| elif self.stage=='tightness': |
| self._gas(h) |
| if self.stage_elapsed>=10 and self.phase=='running': |
| miss=self._missing() |
| if miss:self._fail('position_pressure_too_low:'+str(miss[0]+1)) |
| else:self._next('fill') |
| elif self.stage=='fill': |
| for c in cells:self._feed(c,min(m['pump_total_m3_s']/6*h,max(0.,self._free(c)-sum(c['liquid'])))) |
| if self.phase=='running' and all(abs(sum(c['liquid'])-self._free(c))<1e-12 for c in cells):self._next('heatup_1') |
| elif self.stage.startswith('heatup_') or self.stage=='hold': |
| fraction={'heatup_1':1/3,'heatup_2':2/3,'heatup_3':1.,'hold':1.}[self.stage] |
| idx=self._run_indexed() |
| for i,c in idx:c['pressure']+=(max(0.,m['pressure_gauge_pa']*fraction-self._offset(i))-c['pressure'])*-math.expm1(-h/p['pressure_tau_s']) |
| self.pump_p=self.pump_p+(OVERALL_HOLD*m['pressure_gauge_pa']-self.pump_p)*-math.expm1(-h/60.) if self.stage=='hold' else max([c['pressure'] for c in cells]+[0.]) |
| dwell=10*self._cell_volume(cells)/20e-6;rd=self._readings() |
| if self.stage.startswith('heatup_') and self.stage_elapsed>=dwell and all(abs(rd[1+i]-m['pressure_gauge_pa']*fraction)<1e4 for i,_ in idx) and abs(self.temperature-m['temperature_k'])<=1:self._next({'heatup_1':'heatup_2','heatup_2':'heatup_3','heatup_3':'hold'}[self.stage]) |
| elif self.stage=='hold' and self.stage_elapsed>=self._step('hold_s'):self._next('discharge') |
| elif self.stage=='discharge': |
| self.rack=min(.035,self.rack+.01*h) |
| for c in cells: |
| c['pressure']*=math.exp(-h/p['pressure_tau_s']);free=self._free(c);self._drain(c,p['discharge_m3_s_per_cell']*h,free*p['residual_holdup_fraction']) |
| drained=all(sum(c['liquid'])<=self._free(c)*p['residual_holdup_fraction']+1e-12 for c in cells) |
| if self.phase=='running' and drained and self._measured_max()<=1e5 and self.stage_elapsed>=self._step('discharge_s'): |
| if self.cycle<m['cycles'] and not self.aborting: |
| if self._vial_change_due(cells):self._next('vial_change');self.phase='cancelled';self._notify('change_vials') |
| else:self.cycle+=1;self._next('fill') |
| else:self._next('solvent_flush' if m['solvent_flush_s']>0 and not self.aborting else 'nitrogen_flush') |
| elif self.stage=='vial_change': |
| self.rack=min(.035,self.rack+.01*h) |
| if self.rack>=.035:self.cycle+=1;self._next('fill') |
| elif self.stage=='solvent_flush': |
| for c in cells: |
| v=m['pump_total_m3_s']/6*h;self._feed(c,v);self._drain(c,v) |
| if self.stage_elapsed>=m['solvent_flush_s'] and self.phase=='running':self._next('nitrogen_flush') |
| elif self.stage=='nitrogen_flush': |
| self.rack=min(.035,self.rack+.01*h);self._gas(h) |
| for c in cells:self._drain(c,p['discharge_m3_s_per_cell']*h);c['pressure']*=math.exp(-h/p['pressure_tau_s']) |
| if self.stage_elapsed>=m['nitrogen_flush_s'] and self.phase=='running' and all(sum(c['liquid'])<1e-15 for c in cells) and self._measured_max()<=1e5:self._next('release') |
| elif self.stage=='release': |
| self.heater=max(0.,self.heater-.01*h);self.rack=max(0.,self.rack-.01*h) |
| if self.heater<=1e-12 and self.rack<=1e-12:self.heater=self.rack=0.;self._next('complete');self.phase='cancelled' if self.aborting else 'succeeded';self._run_end() |
| if not (self.stage.startswith('heatup_') or self.stage=='hold'):self.pump_p*=math.exp(-h/p['pressure_tau_s']) |
| def _run_end(self): |
| if self.eco:self.preheat=False;self.eco=False |
| if self.settings['beep_end']:self.end_beeps+=1 |
| def step(self,dt): |
| if isinstance(dt,bool) or not isinstance(dt,(int,float)) or not math.isfinite(dt) or not 0<dt<=3600:raise ActionRejected('INVALID_ARGUMENT') |
| n=math.ceil(dt/.25);h=dt/n |
| for _ in range(n): |
| if self.plant:self._tick(h) |
| else:self.time_s+=h |
| self.revision+=1;return self.read() |
|
|
| class BuchiSpeedextractoreSession: |
| """Host registers principals; public calls have no visibility override.""" |
| 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,i): |
| if i!=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_buchi_speedextractore_contract_metadata() |
| return dict(protocol_version=PROTOCOL_VERSION,asset_type_id=ASSET_TYPE_ID,asset_version=ASSET_VERSION, |
| capabilities={k:v for k,v in meta['capabilities'].items() if v['visibility']=='agent' or self._role!='agent'}, |
| state_slots={k:v for k,v in meta['state_slots'].items() if v['visibility']=='agent' or self._role!='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='unavailable' if vals[k] is None else ('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: raise ActionRejected('INVALID_ARGUMENT') |
| validate(CAPS[capability_id][0],arguments) |
| key=(self._principal,instance_id,request_id); digest=json.dumps([capability_id,arguments],sort_keys=True,allow_nan=False) |
| if key in h._requests: |
| old,result=h._requests[key] |
| if old!=digest: raise ActionRejected('REQUEST_CONFLICT') |
| return copy.deepcopy(result) |
| before=h.operation_id; h._caller=self._principal |
| try: result=h.invoke(capability_id,**arguments) |
| finally: h._caller=None |
| op=result.get('operation_id') |
| if op: h._owners[op]=self._principal |
| elif capability_id in PANEL_CAPS and h.operation_id and h.operation_id!=before: h._owners[h.operation_id]=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) |
| 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._measure()) |
|
|
| def cancel(self,operation_id,request_id): |
| self.poll(operation_id) |
| response=self.invoke(instance_id=self._host.instance_id,capability_id='acquisition.stop',arguments={},request_id=request_id) |
| return dict(operation_id=operation_id,status=self._host.phase,result=response['result']) |
|
|
| def export_buchi_speedextractore_contract_metadata(): |
| caps={}; slots={} |
| for key,(schema,unit,origin,visibility,components,write) in SLOTS.items(): |
| slots[key]=dict(component_ids=components,value_schema=copy.deepcopy(schema),unit=unit,reference_conditions=None, |
| meaning_zh=None,origin=origin,visibility=visibility,access='read_write' if write else 'read_only', |
| read_binding=dict(backend='host',artifact_id='runtime',accessor=f'BuchiSpeedextractoreSession.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=['simulation_assumption']) |
| if key in NEW_SLOT_ZH:slots[key]['meaning_zh']=NEW_SLOT_ZH[key];slots[key]['source_ids']=['manufacturer_manual_menus','simulation_assumption'] |
| for key,(inp,out,components,meaning,kind,vis,example,effects) in CAPS.items(): |
| async_=key=='acquisition.start'; pre=[] |
| conditions={ |
| 'acquisition.start':('供电、预热达温、已装同容量池，屏/滑轨闭合，首次或暂停续作',['power.enabled','sample.configured','thermal.indicated_k','shield.lift_m','drawer.extension_m','cycle.phase'],'powered and loaded and preheated and closed and resumable'), |
| 'sample.configure':('装池前预热，开屏抽块，夹具确认，首次且同容量，目标量<=基质1%',['thermal.preheat_enabled','thermal.indicated_k','shield.lift_m','drawer.extension_m'],'preheated_before_loading and gripper and equal_cell_capacity'), |
| 'method.configure':('装样/运行前，四比例合计1，整数周期，分级升压保守液相检查',['sample.configured','cycle.phase'],'before_loading and ratios_sum_one and liquid_guard'), |
| 'sample.unload':('完整或有序终止后，残压<=1bar、开屏抽块，夹具和身份确认',['cycle.stage','pressure.max_gauge_pa','shield.lift_m','drawer.extension_m'],'complete and depressurized and open and matching_identity')} |
| if key in conditions: |
| description,states,check=conditions[key] |
| pre=[dict(description_zh=description,state_ids=states,enforced_by='runtime',check=check)] |
| caps[key]=dict(function_zh=meaning,kind=kind,visibility=vis,component_ids=components,availability='implemented', |
| input_schema=copy.deepcopy(inp),output_schema=copy.deepcopy(out), |
| implementation=dict(process='implemented',scene='absent',robot='absent',hardware='absent',host='implemented'), |
| binding=dict(backend='host',artifact_id='runtime',entrypoint='asset_runtime.buchi_speedextractore.BuchiSpeedextractoreSession.invoke',invocation=f'session.invoke(instance_id="speedextractor_01", capability_id={key!r}, arguments={example!r}, request_id="unique")'), |
| preconditions=pre,state_effects=[dict(state_id=k,timing='immediate',description_zh=meaning) for k in effects],observes=[], |
| model_effects=dict(mode='none',description_zh='此处仅声明运行过程；几何联动由宿主另行绑定验证。',binding_ids=[]), |
| execution=dict(mode='asynchronous' if async_ else 'synchronous',time_domain='simulation', |
| completion_criterion='cycle.phase=succeeded且完成排液/氮吹/降架；暂停保留库存和残压' if async_ else '设定或查询不推进时钟', |
| completion_state_ids=['cycle.phase'] if async_ else effects,timeout_s=None,cancellation='supported' if async_ else 'unsupported', |
| retry='same_request_id',resources=['target_instance','principal_request_cache'],partial_failure_zh='拒绝无修改；暂停关闭主动阀但不冻结热/传质/降解，有限供应或满瓶失败保留物料；不是实机安全认证。去重仅进程内有效'), |
| 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']], |
| example_arguments=copy.deepcopy(example),verification=[],limitations=['工程代理，无真实硬件连接；进程内过滤不能替代文件和进程部署隔离。'],source_ids=['manufacturer_primary','simulation_assumption']) |
| evolving=[k for k in slots if k not in ('power.enabled','shield.lift_m','drawer.extension_m') and (k not in NEW_SLOT_ZH or k in ('pressure.sensors','service.counters','service.lifts'))] |
| for key in ['acquisition.start','plant.configure','sample.configure','sample.unload','acquisition.abort','thermal.preheat','leak_test.start','flush.start','flow_test.start','pump.run','valve.set','lift.move','acquisition.skip','acquisition.halt']: |
| caps[key]['state_effects'] += [dict(state_id=k,timing='on_step' if key in ('acquisition.start','acquisition.abort','thermal.preheat','leak_test.start','flush.start','flow_test.start','pump.run','valve.set','lift.move','acquisition.skip','acquisition.halt') else 'immediate',description_zh='六位置守恒传质与阶段过程') for k in evolving if k not in [e['state_id'] for e in caps[key]['state_effects']]] |
| for key in ['shield.set_lift','drawer.set_extension']: |
| caps[key]['preconditions'].append(dict(description_zh='非运行、表压<=1bar、热块和瓶架降下；抽块另需屏完全上推',state_ids=['cycle.phase','pressure.max_gauge_pa','heater.lift_m','rack.lift_m','shield.lift_m'],enforced_by='runtime',check='not_running and pressure_low and lifts_down and clearance')) |
| for key in ['reference.lookup','sample.configure']:caps[key]['errors'].append(dict(code='TEMPLATE_RANGE_UNAVAILABLE',meaning_zh='参考物质或纯溶剂公式范围不可用',side_effects='none')) |
| caps['method.configure']['errors'].append(dict(code='LIQUID_PHASE_GUARD',meaning_zh='保守液相模型范围：目标表压1/3+大气压需高于理想蒸气压1.1倍',side_effects='none')) |
| for key,(desc,states) in NEW_PRE.items():caps[key]['preconditions']=[dict(description_zh=desc,state_ids=states,enforced_by='runtime',check='BuchiSpeedextractoreRuntime._device_invoke guards')] |
| for key,codes in NEW_CAP_ERRORS.items(): |
| have={e['code'] for e in caps[key]['errors']} |
| caps[key]['errors']+=[dict(code=c,meaning_zh=DEVICE_ERRORS.get(c,c),side_effects='none') for c in codes if c not in have] |
| for key in DEVICE_CAPS: |
| caps[key]['source_ids']=['manufacturer_manual_menus','simulation_assumption'] |
| caps[key]['limitations']=['菜单背后的固件功能，按操作手册093218的最小模型实现；系数（背压、电机电流、升降速度）为教学假设，未按厂家标定。'] |
| for key in ('leak_test.start','flush.start','flow_test.start','pump.run'): |
| caps[key]['execution']['completion_criterion']='命令立即返回；过程随step演化，状态见对应status槽（检漏/冲洗结束后自动降架）' |
| for key,d in PANEL_CAPS.items(): |
| e=caps[key];e['source_ids']=['manufacturer_manual_menus','simulation_assumption'] |
| if d['kind']!='query': |
| e['preconditions']=[dict(description_zh='通电后按键与旋钮才起作用（断电时只有主开关）；每个界面规则按panel_ui.json（手册页码证据）',state_ids=['power.enabled'],enforced_by='runtime',check='panel_ui.json gates')] |
| e['execution']['completion_criterion']='手势瞬时完成（不推进仿真时钟）：界面状态与被调用能力的效果立即生效；结果只说明是否被仪器接受，屏幕须用panel.capture查看' |
| e['limitations']=['前面板只调用本运行层的同名能力（没有第二份仪器逻辑）；画面按手册图以5x7文字近似绘制，不是像素级屏幕。'] |
| called=_panel_ui.spec_capabilities(PANEL_SPEC) if PANEL_SPEC else [] |
| fx=list(dict.fromkeys(e['state_id'] for c in called for e in caps[c]['state_effects'])) |
| for key,d in PANEL_CAPS.items(): |
| if d['kind']!='query':caps[key]['state_effects']=[dict(state_id=k,timing='immediate',description_zh='手势按界面规则调用的能力所改变的状态') for k in fx] |
| mechanism=dict(component_ids=['pump','mixer','heater_lift','media_valve','outlet_valve','collection_rack'],state_ids=evolving,meaning_zh='同容量六池有限溶剂与目标物守恒、条件分配与传质',implementation='lumped',equations=['four stock liquid volume ledgers: initial=reservoir+cell+vial+waste+removed; reference density fixed, thermal expansion neglected','target_initial=sorbed+dissolved+extract+degraded+removed, independently per cell','one total pump1..50mL/min divided by6; inactive positions reduce effective method flow, exact factory algorithm unknown','ideal Raoult vapor pressure: x_i=(volume_fraction*rho_i/M_i)/sum; p=sum(x_i*log_interpolated_35point_CoolProp7.2.0_EOS_i(T))','q_solid=Kd*C_liquid; M_liquid_eq=min(M_total*V/(V+Kd*matrix_mass),solubility*V)','mixture Kd=geometric_volume_mean(Kd_i)*exp(Eads/R*(1/T-1/298.15)); k=k_ref*exp(Ea/R*(1/298.15-1/T))','delta_M=(M_liquid_eq-M_liquid)*(1-exp(-k*dt)); clamp to available material','host degradation first order conservatively moves sorbed/dissolved target to degraded ledger; extract cooled proxy no degradation','preheat first; seal3.5s, nitrogen tightness proxy10s, finite fill, staged pressure1/3,2/3,full; intrinsic dwell proxy10s*(cell_volume/20mL)','hold and discharge each0..3600s;1..10cycles; discharge NO nitrogen, final optional solvent0..540s and mandatory N2 60..1800s','finite host nitrogen molar stock flows only tightness/final nitrogen, never creates liquid; nitrogen push moves residual liquid to collection not evaporation','pressure hydraulic first-order target and discharge decay, not mass-derived compressible EOS; pressure<=1bar before automatic release','pause closes active flows but thermal/partition/degradation continue; ordered abort drains/purges/releases then cancelled complete'],parameters={},source_ids=['manufacturer_manual','simulation_assumption'],limitations=['54measured AN317 ratios compare Dionex ASE200 with Soxtec and may exceed1; NOT E916 absolute recoveries,partition coefficients or transfer constants. No measured E916 calibration available.','54names have unresolved CAS; two ambiguous source names excluded. Original DCM/acetone reference recipe is not the four-solvent runtime subset.','Host supplies Kd,transfer,activation,solubility,degradation,thermal lag,pressure lag,discharge and holdup. These are synthetic assumptions,not inferred from recovery ratios.','Four-port E916 selected,10/20/40mL equal-capacity runtime groups; current geometry only20mL proxy and separately purchased240mL bottles. Mixed capacities and changing vials between cycles absent.','140pure-solvent EOS nodes and136heldout midpoint log-interpolation tests; ideal mole-fraction Raoult only; nonideal mixing,boiling,gas dissolution,thermal expansion and complete energy balance not implemented. Fill/discharge transient two-phase behavior absent; model does not certify real safety.','Pressure lag is independent of fluid compressibility; per-cell pressure sensors ideal by default (evaluator offsets settable, zeroed by the service CALIBRATE), not manufacturer accuracy/noise calibration. The initial nitrogen tightness test only checks that the active positions hold cells; the separate LEAK TEST (pump to set pressure, hold, discharge, gas flush) is implemented with ideal seals unless an evaluator seal leak is set.','Six cells equal nominal division total/6 is an explicit flow assumption; factory active-position flow algorithm not independently known. The stand-alone FLUSH uses the set total flow (1-50 mL/min) for the active positions without reduction; the service pump and flow test use an assumed line back pressure of 3 bar at 50 mL/min per line (no clogging modelled).','All product-directed liquid captured in the bottle until its finite capacity, or sent to the waste ledger when the method vial is waste, a flush / leak test goes to waste, or the service outlet valve is set to waste; a declared vial size triggers the vial-change stop (Error 4). N2 transports residual liquid,not solvent evaporation or aerosol entrainment.','No cell cleaning,wet-sample drying,polymer precipitation,clogging,needle puncture,thread torque,real pressure seal contact,robot pickup or hardware USB/control. One batch per instance.','STOP once pauses, twice runs the ordered abort, three times stops immediately with every assembly left in place (recovery only through the service valves and lifts); the presses are counted by state, not by a firmware time window. No automatic recovery from failed supply/vial/pressure safety guards.','Cold loading forbidden; hot unload requires host gripper confirmation only,not a simulated thermal-contact safety guarantee. All safety interlocks are teaching subset,not certified.','Four joint strokes and all local component dimensions/masses unknown estimates. 90kg/98kg and datasheet dimension conflicts retained; actual total mass null.','Agent truth filtering and nativeSession async are tested separately from Matterix outer ack; no deployment isolation or robot constraint.']) |
| _ann.annotate_export('buchi_speedextractore',caps,slots,{'pressurized_extraction':mechanism},inputs={'plant.configure':(PLANT,EXAMPLE)}) |
| return dict(asset_type_id=ASSET_TYPE_ID,catalog_id=CATALOG_ID,capabilities=caps,state_slots=slots,mechanisms={'pressurized_extraction':mechanism}) |
|
|
