| """SX20 standard stopped-flow; real optical references and explicit synthetic reaction states.""" |
| from __future__ import annotations |
| import copy,hashlib,importlib.util,json,math |
| from pathlib import Path |
| import numpy as np |
| from scipy.optimize import curve_fit |
| from functools import lru_cache |
| ROOT=Path(__file__).resolve().parents[2];SLUG='applied_sx20';ASSET_TYPE_ID='instrument.'+SLUG;CATALOG_ID='CHEM-074';PROTOCOL_VERSION='1.0.0' |
| TEMPLATE_REL='assets/reactions/applied_sx20_kinetics_library/templates.json' |
| BOOL={'type':'boolean'};TEXT={'type':'string'} |
| class ActionRejected(ValueError):pass |
| def number(unit,low=None,high=None): |
| s={'type':'number','x-unit':unit} |
| if low is not None:s['minimum']=low |
| if high is not None:s['maximum']=high |
| return s |
| def obj(p):return dict(type='object',properties=p,required=list(p),additionalProperties=False) |
| def arr(s,n=None): |
| x=dict(type='array',items=s) |
| if n is not None:x.update(minItems=n,maxItems=n) |
| return x |
| def integer(low,high):return dict(number('1',low,high),type='integer') |
| def validate(s,v): |
| if 'anyOf' in s: |
| if v is None and any(q.get('type')=='null' for q in s['anyOf']):return |
| return validate(next(q for q in s['anyOf'] if q.get('type')!='null'),v) |
| t=s.get('type') |
| if t in ('number','integer'): |
| if isinstance(v,bool) or not isinstance(v,(int,float)) or not math.isfinite(v):raise ActionRejected('INVALID_ARGUMENT') |
| if t=='integer' and type(v) is not int:raise ActionRejected('INVALID_ARGUMENT') |
| if not s.get('minimum',-math.inf)<=v<=s.get('maximum',math.inf):raise ActionRejected('INVALID_ARGUMENT') |
| elif t=='null' and v is not None:raise ActionRejected('INVALID_ARGUMENT') |
| elif t=='boolean' and type(v) is not bool:raise ActionRejected('INVALID_ARGUMENT') |
| elif t=='string' and not isinstance(v,str):raise ActionRejected('INVALID_ARGUMENT') |
| elif t=='object': |
| if not isinstance(v,dict) or not set(s['required'])<=v.keys():raise ActionRejected('INVALID_ARGUMENT') |
| for k,x in v.items(): |
| if k not in s['properties']:raise ActionRejected('INVALID_ARGUMENT') |
| validate(s['properties'][k],x) |
| elif t=='array': |
| if not isinstance(v,list) or not s.get('minItems',0)<=len(v)<=s.get('maxItems',math.inf):raise ActionRejected('INVALID_ARGUMENT') |
| for x in v:validate(s['items'],x) |
| if 'enum' in s and v not in s['enum']:raise ActionRejected('INVALID_ARGUMENT') |
|
|
|
|
|
|
| PHASE=dict(type='string',enum=['idle','running','succeeded','cancelled','failed']) |
| def nullable(s):return {'anyOf':[s,{'type':'null'}]} |
| PLANT=obj({'rapid_cell_installed':BOOL,'drive_b_capacity_m3':{'type':'number','enum':[2.5e-6,1e-6,.5e-6,.25e-6,.1e-6],'x-unit':'m^3'},'flow_m3_s':number('m^3/s',1e-8,1e-4),'return_flow_m3_s':number('m^3/s',1e-8,1e-4),'fluid_density_kg_m3':number('kg/m^3',500,2000),'fluor_gain_v':number('V',.001,1000),'abs_noise_sd':number('1',0,1),'fluor_noise_sd_v':number('V',0,1),'seed':integer(0,2147483647),'accept_surrogate_model':BOOL}) |
| SAMPLE=obj({'sample_id':TEXT,'template_id':TEXT,'solvent':TEXT,'stock_concentration_mol_m3':number('mol/m^3',1e-8,10),'k1_s_inv':number('1/s',.001,1e5),'k2_s_inv':number('1/s',.001,1e5),'intermediate_response':number('1',0,10),'product_response':number('1',0,10),'accept_hypothetical_kinetics':BOOL}) |
| METHOD=obj({'mode':dict(type='string',enum=['absorbance','fluorescence']),'mix_ratio_a_b':number('1',1,25),'stop_volume_m3':number('m^3',1e-9,2.5e-6),'delay_s':number('s',0,1000),'wavelength_m':number('m',190e-9,850e-9),'path_m':{'type':'number','enum':[.01,.002,.005,.001],'x-unit':'m'},'duration_s':number('s',1e-4,1000),'points':integer(6,4000),'timebase':dict(type='string',enum=['uniform','log']),'filter_low_m':number('m',300e-9,650e-9),'filter_high_m':number('m',300e-9,650e-9)}) |
| PLANT_EXAMPLE=dict(rapid_cell_installed=False,drive_b_capacity_m3=2.5e-6,flow_m3_s=2e-6,return_flow_m3_s=2e-6,fluid_density_kg_m3=1000.,fluor_gain_v=10.,abs_noise_sd=0.,fluor_noise_sd_v=0.,seed=74,accept_surrogate_model=True) |
| SAMPLE_EXAMPLE=dict(sample_id='fluorescein_demo',template_id='pcad_010',solvent='ethanol',stock_concentration_mol_m3=.002,k1_s_inv=40.,k2_s_inv=8.,intermediate_response=2.,product_response=.15,accept_hypothetical_kinetics=True) |
| METHOD_EXAMPLE=dict(mode='absorbance',mix_ratio_a_b=1.,stop_volume_m3=140e-9,delay_s=0.,wavelength_m=482.5e-9,path_m=.01,duration_s=.5,points=101,timebase='uniform',filter_low_m=505e-9,filter_high_m=535e-9) |
| FLUOR_METHOD=dict(METHOD_EXAMPLE,mode='fluorescence',wavelength_m=425e-9,path_m=.002) |
| POINT=obj({'trigger_time_s':number('s',0),'reaction_age_s':number('s',0),'sample_time_s':number('s',0),'signal':number('1'),'absorbance':nullable(number('1')),'fluorescence_v':nullable(number('V')),'unit':dict(type='string',enum=['1','V'])}) |
| MEASURE=obj({'phase':PHASE,'stage':TEXT,'elapsed_s':number('s',0),'completed_points':integer(0,4000),'signal':nullable(number('1')),'unit':TEXT,'warning':TEXT}) |
| RESULT=obj({'phase':PHASE,'complete':BOOL,'points':arr(POINT),'settings_json':TEXT,'template_source':TEXT,'evidence':TEXT,'limitations':arr(TEXT)}) |
| LEDGER=obj({'registered_volume_m3':number('m^3',0),'stock_a_volume_m3':number('m^3',0),'stock_b_volume_m3':number('m^3',0),'cell_volume_m3':number('m^3',0),'stop_volume_m3':number('m^3',0),'waste_volume_m3':number('m^3',0),'volume_residual_m3':number('m^3'),'registered_moiety_mol':number('mol',0),'stock_moiety_mol':number('mol',0),'cell_moiety_mol':number('mol',0),'stop_moiety_mol':number('mol',0),'waste_moiety_mol':number('mol',0),'moiety_residual_mol':number('mol'),'modeled_mass_residual_kg':number('kg'),'optical_state_fractions':arr(number('1',0,1),3),'template_id':nullable(TEXT),'evidence':TEXT}) |
| OBS=obj({'time_s':dict(arr(number('s',0)),minItems=6,maxItems=4000),'signal':dict(arr(number('1')),minItems=6,maxItems=4000)}) |
| TEMPLATE=obj({'substance_id':TEXT,'name':TEXT,'source':TEXT,'conditions_json':TEXT,'abs_wavelength_m':arr(number('m')),'epsilon_m2_mol':arr(number('m^2/mol')),'em_wavelength_m':arr(number('m')),'emission_relative':arr(number('1')),'quantum_yield':number('1',0,1),'kinetic_constants_s_inv':{'type':'null'},'evidence':TEXT}) |
| CAPS={} |
| def cap(k,inp,out,c,z,kind='device_command',vis='agent',ex=None):CAPS[k]=[inp,out,c,z,kind,vis,{} if ex is None else ex,[]] |
| cap('plant.configure',PLANT,obj({'configured':BOOL}),['body','drive_a','drive_b','detector'],'宿主一次声明标准/快速池、物理注射器容量和未标定流速/密度/噪声','configuration','evaluator',PLANT_EXAMPLE) |
| cap('sample.load',SAMPLE,obj({'loaded':BOOL}),['drive_a','drive_b','cell'],'仅首次外部装液；A含真实光学参考，B为无吸收触发溶剂代理；两步动力学为宿主假设','configuration','evaluator',SAMPLE_EXAMPLE) |
| cap('bath.cover',obj({'opened':BOOL}),obj({'opened':BOOL}),['bath_cover'],'外部开启恒温浴罩；绕X85°是工程铰链代理，非厂家铰链证据','device_command','evaluator',{'opened':False}) |
| cap('valves.set',obj({'drive':BOOL}),obj({'drive':BOOL}),['valve_a','valve_b'],'外部手动90°Load/Drive，非自动转阀','device_command','evaluator',{'drive':True}) |
| cap('power.set',obj({'enabled':BOOL}),obj({'enabled':BOOL}),['power_inlet','controller'],'供电逻辑；断电立即取消但不回滚液量',ex={'enabled':True}) |
| cap('gas.set',obj({'enabled':BOOL}),obj({'enabled':BOOL}),['gas_inlet','drive_ram'],'宿主确认外部气源连接；不等于实际压力传感/闭环','device_command','evaluator',{'enabled':True}) |
| cap('method.configure',METHOD,obj({'configured':BOOL}),['monochromator','detector','cell'],'混合比必须等于实装针筒容量比；换探测通道/光程须断电；所选2012手册单通道配置','configuration','agent',METHOD_EXAMPLE) |
| cap('acquisition.start',obj({}),obj({'phase':PHASE,'operation_id':TEXT}),['drive_yoke','stop_plunger','stop_valve','cell','detector'],'有限驱动、自动排空停流针筒、停流触发与毫秒死时间；不补造不可见早期样点') |
| cap('acquisition.stop',obj({}),obj({'phase':PHASE}),['drive_ram','stop_plunger'],'停止并保留已消耗试剂/已观测样点，无液量回滚') |
| cap('fluid.flush',obj({}),obj({'flushed':BOOL}),['cell','stop_plunger','waste_port'],'宿主已完成外部排液/新缓冲液装池；不是自动清洗机器人','device_command','evaluator') |
| cap('process.measure',obj({}),MEASURE,['host_screen'],'最近真实生成观测，无数据null','query') |
| cap('result.read',obj({}),RESULT,['host_screen'],'真实静态谱驱动的显式模拟时间曲线，来源身份不泄漏','query') |
| cap('kinetics.fit',OBS,obj({'k_s_inv':number('1/s',0),'k_std_s_inv':nullable(number('1/s',0)),'amplitude':number('1'),'offset':number('1'),'rmse':number('1',0),'evidence':TEXT}),['host_screen'],'仅用调用者时间/信号拟合单指数；不能将两步动力学单指数k认作机理真值','analysis','agent',{'time_s':[0.,.1,.2,.3,.4,.5],'signal':[1.,.818730753,.670320046,.548811636,.449328964,.367879441]}) |
| cap('calibration.zero',obj({'observed_blank':number('1'),'mode':dict(type='string',enum=['absorbance','fluorescence'])}),obj({'correction':number('1')}),['detector','fluor_detector'],'按mode仅修正对应吸光度或荧光电压空白；返回数码兼容旧接口，物理单位见两个修正状态槽；非原厂校准',ex={'observed_blank':.01,'mode':'absorbance'}) |
| cap('template.read',obj({'substance_id':TEXT}),TEMPLATE,['host_screen'],'公开真实参考谱；不含任何虚构真实速率','query','agent',{'substance_id':'pcad_010'}) |
| cap('product.read',obj({}),LEDGER,['cell','waste_port'],'私有体积/共同密度质量/染团守恒与光学态，非化学产物鉴定','query','evaluator') |
| cap('sequential.start',obj({}),obj({}),['drive_ram'],'SQ1四驱动针筒/双ram/老化液路未建；明确不支持，不将两步反应偷换为顺序混合') |
| cap('dual_channel.start',obj({}),obj({}),['detector','fluor_detector'],'DD1同时双通道选件未实现') |
| cap('temperature.set',obj({'temperature_k':number('K')}),obj({}),['bath'],'温控来自外部循环器，未建立温度依赖反应速率/自动恒温','device_command','agent',{'temperature_k':298.15}) |
| UNSUPPORTED={'sequential.start','dual_channel.start','temperature.set'} |
| SLOTS={};SLOT_ZH={} |
| def slot(k,s,u,z,o='derived',v='agent',c='host_screen',w=None):SLOTS[k]=(s,u,o,v,[c],w);SLOT_ZH[k]=z |
| slot('plant.configured',BOOL,'1','宿主配置已声明','setpoint',c='body') |
| slot('plant.rapid_cell_installed',BOOL,'1','快速池选件明确安装','setpoint',c='cell') |
| slot('sample.loaded',BOOL,'1','试剂已外部装载','scene',c='cell') |
| slot('power.enabled',BOOL,'1','软件供电','setpoint',c='controller',w=('power.set','enabled')) |
| slot('gas.enabled',BOOL,'1','外部气源逻辑可用','setpoint',c='gas_inlet') |
| slot('cover.opened',BOOL,'1','水浴盖开闭代理','scene',c='bath_cover') |
| slot('cover.angle_rad',number('rad',0,math.radians(85)),'rad','水浴盖工程铰链角','scene',c='bath_cover') |
| slot('valves.drive',BOOL,'1','宿主手动阀已位于Drive','scene',c='valve_a') |
| slot('valves.angle_rad',number('rad',0,math.pi/2),'rad','两只手动阀同位90°代理','scene',c='valve_a') |
| slot('drive.stroke_m',number('m',0,.08),'m','共同驱动柱塞累计位移，80mm为工程映射行程','scene',c='drive_yoke') |
| slot('stop.stroke_m',number('m',0,.08),'m','停流针筒柱塞位移，80mm工程映射','scene',c='stop_plunger') |
| slot('stop.valve_angle_rad',number('rad',0,math.pi),'rad','自动Drive/Empty阀180°','scene',c='stop_valve') |
| slot('fluid.needs_flush',BOOL,'1','再次采集前需外部完整清洗','derived',c='cell') |
| slot('scan.phase',PHASE,'1','操作生命周期') |
| slot('scan.stage',dict(type='string',enum=['idle','returning','driving','acquiring']),'1','实际排空/驱动/触发后采样阶段') |
| slot('scan.elapsed_s',number('s',0),'s','本次过程经过时间') |
| slot('scan.completed_points',integer(0,4000),'1','已实际观测样点数') |
| slot('scan.signal',nullable(number('1')),'1','最新显示数值（无量纲数码）；物理量分别在absorbance/fluorescence_v槽') |
| slot('scan.absorbance',nullable(number('1')),'1','最近观测的吸光度；荧光观测时null') |
| slot('scan.fluorescence_v',nullable(number('V')),'V','最近观测的宿主荧光电压代理；吸收观测时null') |
| slot('scan.unit',TEXT,'1','吸收无量纲或荧光宿主电压V') |
| slot('scan.last_sample_time_s',nullable(number('s')),'s','最新实际观测时刻') |
| slot('method.wavelength_m',nullable(number('m')),'m','检测/激发单色器波长','setpoint',c='monochromator') |
| slot('method.mix_ratio',nullable(number('1')),'1','物理针筒容量混合比','setpoint',c='drive_yoke') |
| slot('method.stop_volume_m3',nullable(number('m^3')),'m^3','一次驱动停止体积','setpoint',c='stop_plunger') |
| slot('cell.dead_time_s',nullable(number('s')),'s','标准约1ms/快速约0.5ms','setpoint',c='cell') |
| slot('safety.warning',TEXT,'1','无私有身份告警') |
| slot('truth.ledger',LEDGER,'1','体积/染团与模板身份仅评估器','process_truth','evaluator','cell') |
| slot('calibration.absorbance_correction',number('1'),'1','调用者空白的累计模拟吸光度修正，非原厂校准','setpoint',c='detector') |
| slot('calibration.fluorescence_correction_v',number('V'),'V','调用者空白的累计模拟荧光电压修正，非原厂校准','setpoint',c='fluor_detector') |
| @lru_cache(maxsize=1) |
| def _templates():return {t['substance_id']:t for t in json.loads((ROOT/TEMPLATE_REL).read_text())['templates']} |
|
|
| class AppliedSx20Runtime: |
| def __init__(self,instance_id='sx20_01'): |
| self.instance_id=instance_id;self.templates=_templates();self.time_s=0.;self.revision=0;self.plant=None;self.method=None;self.sample=None |
| self.powered=False;self.gas=False;self.opened=True;self.valves=False;self.needs_flush=False;self.phase='idle';self.stage='idle';self.elapsed_s=0.;self.warning='';self.points=[] |
| self.operation_id='';self._op_count=0;self._stop_time=None;self._acquire_grid=[];self._drive_volume=0.;self._registered_v=0.;self._registered_n=0. |
| self._va=0.;self._vb=0.;self._vc=0.;self._vs=0.;self._vw=0.;self._nc=0.;self._ns=0.;self._nw=0.;self._correction={'absorbance':0.,'fluorescence':0.} |
| self._principals={'__public_agent__':'agent'};self._requests={};self._owners={};self._operation_records={};self._result_method=None;self._rng=np.random.default_rng(0) |
| def register_principal(self,principal_id,visibility='agent'): |
| if visibility not in ('agent','debug','evaluator') or not isinstance(principal_id,str) or not principal_id: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 AppliedSx20Session(self,principal_id) |
| def describe(self):return self.session().describe(instance_id=self.instance_id) |
| def debug_snapshot(self): |
| return copy.deepcopy({k:v for k,v in self.__dict__.items() if k not in ['templates','_rng']})|{'_rng_state':copy.deepcopy(self._rng.bit_generator.state)} |
| @property |
| def cell_volume(self):return 5e-9 if self.plant and self.plant['rapid_cell_installed'] else 20e-9 |
| @property |
| def stop_capacity(self):return 1e-6 if self.plant and self.plant['rapid_cell_installed'] else 2.5e-6 |
| @property |
| def dead_time(self):return .0005 if self.plant and self.plant['rapid_cell_installed'] else .001 |
| @staticmethod |
| def fractions(t,k1,k2): |
| a=math.exp(-k1*t) |
| if abs(k1-k2)<=1e-7*max(k1,k2):b=k1*t*math.exp(-k1*t) |
| else: |
| |
| b=k1*(math.exp(-k2*t)-a)/(k1-k2) |
| b=max(0.,min(1.-a,b));return [a,b,max(0.,1.-a-b)] |
| def _ledger(self): |
| p=self.plant;s=self.sample;stock_n=self._va*s['stock_concentration_mol_m3'] if s else 0. |
| rv=self._registered_v-(self._va+self._vb+self._vc+self._vs+self._vw);rn=self._registered_n-(stock_n+self._nc+self._ns+self._nw) |
| age=0. if self._stop_time is None else self.dead_time+max(0.,self.time_s-self._stop_time) |
| f=self.fractions(age,s['k1_s_inv'],s['k2_s_inv']) if s else [1.,0.,0.] |
| return dict(registered_volume_m3=self._registered_v,stock_a_volume_m3=self._va,stock_b_volume_m3=self._vb,cell_volume_m3=self._vc,stop_volume_m3=self._vs,waste_volume_m3=self._vw,volume_residual_m3=rv,registered_moiety_mol=self._registered_n,stock_moiety_mol=stock_n,cell_moiety_mol=self._nc,stop_moiety_mol=self._ns,waste_moiety_mol=self._nw,moiety_residual_mol=rn,modeled_mass_residual_kg=rv*p['fluid_density_kg_m3'] if p else 0.,optical_state_fractions=f,template_id=s['template_id'] if s else None,evidence='equal-density incompressible volume and common chromophore-moiety bookkeeping; A/I/P are hypothetical optical states, not identified chemical products; no waste speciation') |
| def read(self,visibility='agent'): |
| if visibility not in ('agent','debug','evaluator'):raise ActionRejected('ACCESS_DENIED') |
| m=self.method;last=self.points[-1] if self.points else None |
| out={'plant.configured':bool(self.plant),'plant.rapid_cell_installed':bool(self.plant and self.plant['rapid_cell_installed']),'sample.loaded':bool(self.sample),'power.enabled':self.powered,'gas.enabled':self.gas,'cover.opened':self.opened,'cover.angle_rad':math.radians(85) if self.opened else 0.,'valves.drive':self.valves,'valves.angle_rad':math.pi/2 if self.valves else 0.,'drive.stroke_m':.08*(1.-self._va/2.5e-6) if self.sample else 0.,'stop.stroke_m':.08*self._vs/self.stop_capacity,'stop.valve_angle_rad':math.pi if self.stage=='returning' else 0.,'fluid.needs_flush':self.needs_flush,'scan.phase':self.phase,'scan.stage':self.stage,'scan.elapsed_s':self.elapsed_s,'scan.completed_points':len(self.points),'scan.signal':last['signal'] if last else None,'scan.absorbance':last['absorbance'] if last else None,'scan.fluorescence_v':last['fluorescence_v'] if last else None,'scan.unit':last['unit'] if last else ('1' if m['mode']=='absorbance' else 'V') if m else 'unavailable','scan.last_sample_time_s':last['sample_time_s'] if last else None,'method.wavelength_m':m['wavelength_m'] if m else None,'method.mix_ratio':m['mix_ratio_a_b'] if m else None,'method.stop_volume_m3':m['stop_volume_m3'] if m else None,'cell.dead_time_s':self.dead_time if self.plant else None,'safety.warning':self.warning} |
| out.update({'calibration.absorbance_correction':self._correction['absorbance'],'calibration.fluorescence_correction_v':self._correction['fluorescence']}) |
| if visibility!='agent':out['truth.ledger']=self._ledger() |
| return copy.deepcopy(out) |
| def invoke(self,capability_id,**arguments): |
| if capability_id not in CAPS:raise ActionRejected('UNKNOWN_CAPABILITY') |
| validate(CAPS[capability_id][0],arguments) |
| if capability_id in UNSUPPORTED:raise ActionRejected('UNSUPPORTED') |
| if CAPS[capability_id][4] in ['query','analysis']: |
| out=self._invoke(capability_id,arguments);validate(CAPS[capability_id][1],out);return copy.deepcopy(out) |
| snapshot={k:copy.deepcopy(v) for k,v in self.__dict__.items() if k!='templates'} |
| try: |
| out=self._invoke(capability_id,arguments);validate(CAPS[capability_id][1],out);self._archive_operation();self.revision+=1;return copy.deepcopy(out) |
| except Exception: |
| t=self.templates;self.__dict__.clear();self.__dict__.update(snapshot);self.templates=t;raise |
| def _idle(self): |
| if self.phase=='running':raise ActionRejected('BUSY') |
| def _archive_operation(self): |
| if self.operation_id and self.phase in ('succeeded','cancelled','failed') and self.operation_id not in self._operation_records: |
| self._operation_records[self.operation_id]=dict(operation_id=self.operation_id,status=self.phase,result=copy.deepcopy(self._invoke('process.measure',{}))) |
| def _stop(self,phase='cancelled',warning=''): |
| if self.phase=='running':self.phase=phase |
| self.stage='idle';self.warning=warning |
| def _invoke(self,k,a): |
| if k=='plant.configure': |
| if self.plant or self.powered or self.sample:raise ActionRejected('INITIALIZATION_ONLY') |
| if not a['accept_surrogate_model']:raise ActionRejected('EVIDENCE_ACK_REQUIRED') |
| self.plant=copy.deepcopy(a);self._rng=np.random.default_rng(a['seed']);return {'configured':True} |
| if k=='sample.load': |
| self._idle() |
| if not self.plant:raise ActionRejected('PLANT_REQUIRED') |
| if self.sample or self.powered or self.gas or not self.opened or self.valves:raise ActionRejected('EXTERNAL_LOAD_REQUIRED') |
| if not a['accept_hypothetical_kinetics']:raise ActionRejected('EVIDENCE_ACK_REQUIRED') |
| if not a['sample_id'] or a['template_id'] not in self.templates:raise ActionRejected('UNKNOWN_REFERENCE') |
| if a['solvent']!=self.templates[a['template_id']]['conditions']['solvent']:raise ActionRejected('SOLVENT_MISMATCH') |
| self.sample=copy.deepcopy(a);self._va=2.5e-6;self._vb=self.plant['drive_b_capacity_m3'];self._vc=self.cell_volume |
| self._registered_v=self._va+self._vb+self._vc;self._registered_n=self._va*a['stock_concentration_mol_m3'];return {'loaded':True} |
| if k=='bath.cover': |
| if a['opened']:self._stop(warning='COVER_OPEN');self.gas=False |
| self.opened=a['opened'];return {'opened':self.opened} |
| if k=='valves.set': |
| self._idle() |
| if self.gas:raise ActionRejected('ISOLATE_GAS') |
| self.valves=a['drive'];return {'drive':self.valves} |
| if k=='power.set': |
| if a['enabled'] and not self.plant:raise ActionRejected('PLANT_REQUIRED') |
| self.powered=a['enabled'] |
| if not self.powered:self._stop(warning='POWER_OFF') |
| return {'enabled':self.powered} |
| if k=='gas.set': |
| if a['enabled'] and (not self.plant or self.opened or not self.valves):raise ActionRejected('FLUID_NOT_READY') |
| self.gas=a['enabled'] |
| if not self.gas:self._stop(warning='GAS_OFF') |
| return {'enabled':self.gas} |
| if k=='method.configure': |
| self._idle() |
| if not self.plant:raise ActionRejected('PLANT_REQUIRED') |
| if self.powered and (self.method is None or a['mode']!=self.method['mode'] or a['path_m']!=self.method['path_m']):raise ActionRejected('POWER_OFF_FOR_OPTICS') |
| if not math.isclose(a['mix_ratio_a_b'],2.5e-6/self.plant['drive_b_capacity_m3'],rel_tol=1e-12):raise ActionRejected('PHYSICAL_RATIO_MISMATCH') |
| paths=[.005,.001] if self.plant['rapid_cell_installed'] else [.01,.002] |
| if a['path_m'] not in paths:raise ActionRejected('CELL_PATH_MISMATCH') |
| if a['mode']=='fluorescence' and a['path_m']!=(.005 if self.plant['rapid_cell_installed'] else .002):raise ActionRejected('FLUOR_EXCITATION_PATH') |
| if a['stop_volume_m3']<7*self.cell_volume-1e-18 or a['stop_volume_m3']>self.stop_capacity:raise ActionRejected('STOP_VOLUME_RANGE') |
| if a['filter_low_m']>=a['filter_high_m']:raise ActionRejected('FILTER_RANGE') |
| self.method=copy.deepcopy(a);return {'configured':True} |
| if k=='acquisition.start': |
| self._idle() |
| if not self.sample or not self.method:raise ActionRejected('SAMPLE_METHOD_REQUIRED') |
| if not self.powered or not self.gas or self.opened or not self.valves:raise ActionRejected('FLUID_NOT_READY') |
| if self.needs_flush:raise ActionRejected('EXTERNAL_FLUSH_REQUIRED') |
| t=self.templates[self.sample['template_id']];m=self.method;v=m['stop_volume_m3'];f=m['mix_ratio_a_b']/(1+m['mix_ratio_a_b']) |
| if v*f>self._va+1e-18 or v*(1-f)>self._vb+1e-18:raise ActionRejected('INSUFFICIENT_REAGENT') |
| if not t['abs_wavelength_m'][0]<=m['wavelength_m']<=t['abs_wavelength_m'][-1]:raise ActionRejected('SOURCE_COVERAGE') |
| if m['mode']=='fluorescence': |
| if abs(m['wavelength_m']-t['conditions']['reference_excitation_m'])>1e-15:raise ActionRejected('EXCITATION_REFERENCE_REQUIRED') |
| if m['filter_low_m']<t['em_wavelength_m'][0] or m['filter_high_m']>t['em_wavelength_m'][-1]:raise ActionRejected('SOURCE_COVERAGE') |
| self._archive_operation();self._result_method=copy.deepcopy(self.method) |
| self.phase='running';self.stage='returning' if self._vs>1e-18 else 'driving';self.elapsed_s=0.;self.points=[];self._drive_volume=0.;self._stop_time=None;self.needs_flush=True;self.warning='' |
| self._op_count+=1;self.operation_id=self.instance_id+'_op_'+str(self._op_count) |
| self._acquire_grid=(np.linspace(0,m['duration_s'],m['points']) if m['timebase']=='uniform' else np.r_[0.,np.geomspace(m['duration_s']/(m['points']-1)**2,m['duration_s'],m['points']-1)]).tolist() |
| return dict(phase=self.phase,operation_id=self.operation_id) |
| if k=='acquisition.stop':self._stop(warning='CANCELLED');return {'phase':self.phase} |
| if k=='fluid.flush': |
| self._idle() |
| if not self.sample or self.gas or self.valves or not self.opened:raise ActionRejected('EXTERNAL_FLUSH_REQUIRED') |
| self._vw+=self._vc;self._nw+=self._nc;self._vc=self.cell_volume;self._nc=0.;self._registered_v+=self.cell_volume |
| self.needs_flush=False;self._stop_time=None;return {'flushed':True} |
| if k=='process.measure': |
| s=self.read();return dict(phase=self.phase,stage=self.stage,elapsed_s=self.elapsed_s,completed_points=len(self.points),signal=s['scan.signal'],unit=s['scan.unit'],warning=self.warning) |
| if k=='result.read':return dict(phase=self.phase,complete=self.phase=='succeeded',points=self.points,settings_json=json.dumps(self._result_method if self._result_method is not None else self.method,sort_keys=True),template_source=TEMPLATE_REL,evidence='simulated stopped-flow trace from measured static optical spectrum and explicit hypothetical two-step kinetics',limitations=LIMITATIONS) |
| if k=='template.read': |
| if a['substance_id'] not in self.templates:raise ActionRejected('UNKNOWN_REFERENCE') |
| t=self.templates[a['substance_id']] |
| return dict(substance_id=t['substance_id'],name=t['name'],source=t['source'],conditions_json=json.dumps(t['conditions'],sort_keys=True),abs_wavelength_m=t['abs_wavelength_m'],epsilon_m2_mol=t['epsilon_m2_mol'],em_wavelength_m=t['em_wavelength_m'],emission_relative=t['emission_relative'],quantum_yield=t['quantum_yield'],kinetic_constants_s_inv=None,evidence=t['evidence']) |
| if k=='product.read':return self._ledger() |
| if k=='calibration.zero': |
| self._idle() |
| if not self.method or a['mode']!=self.method['mode']:raise ActionRejected('CALIBRATION_MODE') |
| self._correction[a['mode']]-=a['observed_blank'];return {'correction':self._correction[a['mode']]} |
| if k=='kinetics.fit': |
| x=np.asarray(a['time_s'],dtype=float);y=np.asarray(a['signal'],dtype=float) |
| if len(x)!=len(y) or np.any(x[1:]<=x[:-1]):raise ActionRejected('ANALYSIS_INPUT') |
| |
| |
| span=x[-1]-x[0];scale=float(np.max(np.abs(y))) |
| if scale==0:raise ActionRejected('ANALYSIS_INPUT') |
| yn=y/scale;spread=float(np.ptp(yn));anchor=yn[-1] |
| if spread==0:raise ActionRejected('ANALYSIS_INPUT') |
| xs=(x-x[0])/span;ys=(yn-anchor)/spread |
| def f(t,amplitude,k,offset):return offset+amplitude*np.exp(-k*t) |
| try: |
| with np.errstate(over='raise',invalid='raise',divide='raise'): |
| pars,cov=curve_fit(f,xs,ys,p0=[ys[0],1.,0.],bounds=([-np.inf,0.,-np.inf],[np.inf,np.inf,np.inf]),maxfev=20000) |
| if not np.isfinite(pars).all() or not np.isfinite(cov).all():raise ValueError() |
| residual=f(xs,*pars)-ys;largest=float(np.max(np.abs(residual))) |
| normalized_rmse=largest*math.sqrt(float(np.mean((residual/largest)**2))) if largest else 0. |
| wide_scale=np.longdouble(spread)*np.longdouble(scale) |
| out=dict(k_s_inv=float(np.longdouble(pars[1])/span),k_std_s_inv=float(np.longdouble(math.sqrt(max(cov[1,1],0.)))/span),amplitude=float(np.longdouble(pars[0])*wide_scale),offset=float((np.longdouble(pars[2])*spread+anchor)*scale),rmse=float(np.longdouble(normalized_rmse)*wide_scale)) |
| if not all(math.isfinite(v) for v in out.values()):raise ValueError() |
| except (RuntimeError,ValueError,ArithmeticError):raise ActionRejected('FIT_UNIDENTIFIABLE') from None |
| return dict(**out,evidence='single exponential least squares of caller observations, time zero at first supplied point; scale-normalized fit with conditional covariance, not mechanism identification; two-step traces can be poor fits') |
| raise ActionRejected('UNKNOWN_CAPABILITY') |
| def _flow(self,dv): |
| m=self.method;ca=self.sample['stock_concentration_mol_m3'];f=m['mix_ratio_a_b']/(1+m['mix_ratio_a_b']) |
| |
| |
| dv=min(dv,self._va/f,self._vb/(1-f));da=min(self._va,dv*f);db=min(self._vb,dv*(1-f));dv=da+db |
| if dv<=0:return |
| self._va-=da;self._vb-=db;incoming=ca*da;cin=incoming/dv |
| old=self._nc;new=min(old+incoming,max(0.,old+(cin*self._vc-old)*(-math.expm1(-dv/self._vc)))) |
| self._nc=new;self._ns+=old+incoming-new;self._vs+=dv;self._drive_volume+=dv |
| def _signal(self,age): |
| t=self.templates[self.sample['template_id']];s=self.sample;m=self.method |
| eps=max(0.,float(np.interp(m['wavelength_m'],t['abs_wavelength_m'],t['epsilon_m2_mol']))) |
| f=self.fractions(age,s['k1_s_inv'],s['k2_s_inv']);response=f[0]+s['intermediate_response']*f[1]+s['product_response']*f[2] |
| concentration=self._nc/self._vc;absorbance=eps*concentration*m['path_m'] |
| if m['mode']=='absorbance':return absorbance*response+self._correction[m['mode']] |
| x=np.asarray(t['em_wavelength_m']);y=np.maximum(t['emission_relative'],0.);lo=m['filter_low_m'];hi=m['filter_high_m'];xx=np.r_[lo,x[(x>lo)&(x<hi)],hi] |
| fraction=float(np.trapezoid(np.interp(xx,x,y),xx)/np.trapezoid(y,x)) |
| return self.plant['fluor_gain_v']*(-math.expm1(-math.log(10)*absorbance))*t['quantum_yield']*fraction*response+self._correction[m['mode']] |
| def _observe(self,t): |
| relative=self._acquire_grid[len(self.points)]+self.method['delay_s'];age=self.dead_time+relative |
| sigma=self.plant['abs_noise_sd'] if self.method['mode']=='absorbance' else self.plant['fluor_noise_sd_v'] |
| signal=self._signal(age)+(float(self._rng.normal(0,sigma)) if sigma>0 else 0.) |
| self.points.append(dict(trigger_time_s=relative,reaction_age_s=age,sample_time_s=t,signal=signal,absorbance=signal if self.method['mode']=='absorbance' else None,fluorescence_v=signal if self.method['mode']=='fluorescence' else None,unit='1' if self.method['mode']=='absorbance' else 'V')) |
| if len(self.points)==len(self._acquire_grid):self._stop('succeeded') |
| def step(self,dt_s): |
| validate(number('s',0,3600),dt_s) |
| if dt_s==0:return self.read() |
| left=dt_s;cursor=self.time_s |
| while left>1e-12 and self.phase=='running': |
| if self.stage=='returning': |
| duration=self._vs/self.plant['return_flow_m3_s'];h=min(left,duration);dv=self._vs if h>=duration else min(self._vs,h*self.plant['return_flow_m3_s']);dn=self._ns if h>=duration else self._ns*dv/self._vs if self._vs else 0. |
| self._vs-=dv;self._ns-=dn;self._vw+=dv;self._nw+=dn |
| if h>=duration:self._vs=0.;self._ns=0.;self.stage='driving' |
| elif self.stage=='driving': |
| duration=(self.method['stop_volume_m3']-self._drive_volume)/self.plant['flow_m3_s'];h=min(left,max(0.,duration));dv=min(self.method['stop_volume_m3']-self._drive_volume,h*self.plant['flow_m3_s']);self._flow(max(0.,dv)) |
| if h>=duration: |
| self._stop_time=cursor+h;self.stage='acquiring' |
| if self.method['delay_s']==0:self._observe(self._stop_time) |
| elif self.stage=='acquiring': |
| next_time=self._stop_time+self.method['delay_s']+self._acquire_grid[len(self.points)];h=min(left,max(0.,next_time-cursor)) |
| if cursor+h>=next_time-1e-12:self._observe(next_time) |
| else:raise RuntimeError('invalid stage') |
| self.elapsed_s+=h;cursor+=h;left-=h |
| self.time_s+=dt_s;self.revision+=1;self._archive_operation();return self.read() |
| class AppliedSx20Session: |
| """Only the trusted host assigns roles; returned data obey the same boundary.""" |
| 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') |
| m=export_applied_sx20_contract_metadata();return dict(protocol_version=PROTOCOL_VERSION,asset_type_id=ASSET_TYPE_ID,asset_version='1.0.1',capabilities={k:v for k,v in m['capabilities'].items() if v['visibility']=='agent' or self._role!='agent'},state_slots={k:v for k,v in m['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;v=h.read(self._role);ids=list(v) 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 v for k in ids):raise ActionRejected('ACCESS_DENIED') |
| measured=['scan.signal','scan.absorbance','scan.fluorescence_v','scan.last_sample_time_s'] |
| last=h.points[-1] if h.points else None |
| return dict(status='succeeded',instance_id=instance_id,state_revision=h.revision,clock={'domain':'simulation','time_s':h.time_s},observations={k:dict(value=v[k],unit=SLOTS[k][1],quality='unavailable' if v[k] is None else 'estimated' if SLOTS[k][2]=='derived' else 'valid',sample_time_s=last['sample_time_s'] if last and k in measured else h.time_s,sample_window_s=None) for k in ids}) |
| def invoke(self,*,instance_id,capability_id,arguments,request_id): |
| h=self._host |
| try: |
| self._target(instance_id) |
| 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) |
| result=h.invoke(capability_id,**arguments);op=result.get('operation_id') |
| if op:h._owners[op]=self._principal |
| response=dict(protocol_version=PROTOCOL_VERSION,instance_id=instance_id,request_id=request_id,operation_id=op,status='accepted' if op else 'succeeded',state_revision=h.revision,clock={'domain':'simulation','time_s':h.time_s},result=result,observations={},error=None);h._requests[key]=(digest,copy.deepcopy(response));return response |
| except ActionRejected as exc:return dict(protocol_version=PROTOCOL_VERSION,instance_id=instance_id,request_id=request_id,operation_id=None,status='unsupported' if str(exc)=='UNSUPPORTED' else 'rejected',state_revision=h.revision,clock={'domain':'simulation','time_s':h.time_s},result={},observations={},error=dict(code=str(exc),message=str(exc),retryable=False,side_effects='none')) |
| 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 h._owners.get(operation_id)!=self._principal:raise ActionRejected('ACCESS_DENIED') |
| if operation_id in h._operation_records:return copy.deepcopy(h._operation_records[operation_id]) |
| if operation_id!=h.operation_id:raise ActionRejected('ACCESS_DENIED') |
| return dict(operation_id=operation_id,status=h.phase,result=h.invoke('process.measure')) |
| def cancel(self,operation_id,request_id): |
| snapshot=self.poll(operation_id);h=self._host |
| if not isinstance(request_id,str) or not request_id:raise ActionRejected('INVALID_ARGUMENT') |
| key=(self._principal,h.instance_id,request_id);digest=json.dumps(['acquisition.cancel',operation_id]) |
| if key in h._requests: |
| old,response=h._requests[key] |
| if old!=digest:raise ActionRejected('REQUEST_CONFLICT') |
| return copy.deepcopy(response) |
| result=h.invoke('acquisition.stop') if snapshot['status']=='running' else {'phase':snapshot['status']} |
| response=dict(protocol_version=PROTOCOL_VERSION,instance_id=h.instance_id,request_id=request_id,operation_id=operation_id,status='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 |
|
|
|
|
|
|
| LIMITATIONS=[ |
| 'Manufacturer body dimensions and mass unknown; minimum installation area is not a body bounding box. All geometry sizes are explicit task-layout proxies.', |
| 'Standard20uL/10and2mm/approximately1ms; rapid5uL/5and1mm/approximately0.5ms requires explicit option. Manual also states0.45ms, conflict retained.', |
| 'Absorption R928185–900nm; implemented conservative monochromator190–850nm and source overlap. Fluorescence R6095300–650nm with integrated optical filter, no emission scan.', |
| 'Selected 2012 manual single-channel configuration; not a claim about current SX-series standard equipment. Concurrent abs/fluorescence DD1 and sequential mixing SQ1 four drive syringes/two rams/aging lines are unsupported in this asset.', |
| '63 real PhotochemCAD static optical records, not63 real reaction time curves. Rates/intermediate/product optical factors are explicit hypothetical host parameters.', |
| 'A→I→P conserves one chromophore moiety; these are optical states, not chemically identified species. No predicted chemical stoichiometry, pH, temperature or solvent-change effects.', |
| 'Independent published AA/DCPI rate56.5±0.6m³/(mol*s) retained as reference only; abstract lacks full conditions, never applied automatically.', |
| 'Volume is incompressible, common host density; cell washout is a CSTR proxy, not true turbulent T-mixer CFD. >=7 cell volumes is model guard, not universal factory limit.', |
| 'Finite drive/return rates and80mm visual strokes are engineering assumptions. Gas pressure and pneumatic transients are not simulated or calibrated.', |
| 'Dead time is an unobserved chemical-age offset at trigger, not a second world-clock increment. Delay contributes to age; first observation cannot precede trigger.', |
| 'Cell kinetic age is idealized uniform at stop; pre-stop residence-age distribution/reaction and bubble/scattering/dispersion artifacts are not modeled.', |
| 'Source solvent/reference excitation and actual spectral coverage enforced. Signed source data retained; response clips negative baselines; no source-width deconvolution.', |
| 'Fluorescence rectangular-filter integration and host voltage gain are uncalibrated; source quantum yield retained. Intermediate/product multipliers are hypothetical response factors.', |
| 'Sampling is ideal instantaneous uniform/log timebase, no real ADC bandwidth, detector convolution or factory count limits;6–4000points and duration limits are host resources.', |
| 'Noise is optional explicit Gaussian assumption, not OEM noise. Caller blank correction is not factory calibration; legacy observed_blank/correction numbers represent absorbance or volts according to mode, with explicit unit-specific correction slots.', |
| 'Single-exponential fit uses caller observations with normalized time/signal and t=0 at the first supplied observation; finite output and covariance required. Fitting a two-step trace does not identify mechanism; covariance is not measurement uncertainty. Legacy signal/amplitude/offset numeric aliases follow caller units.', |
| 'External load/valve/cover/flush are trusted-host events, not robotic or autonomous physical manipulations. Flushing retains stop-syringe contents for next automatic empty.', |
| 'External bath circulation and temperature kinetics unsupported. Component mass, friction, true inertia and failure probabilities unknown; URDF0.1kg proxies disclosed.', |
| 'Bath cover X85deg hinge is an engineering proxy; real cover hinging not verified. Separate simulation telemetry board is not OEM LCD.', |
| 'Result points retain the acquisition-time method after reconfiguration until the next start. Owned terminal poll summaries and request dedup persist only in memory, not full historical traces. Session roles are not OS/filesystem isolation; no native async Matterix envelope, real robot, safety certification or hardware/HIL.' |
| ] |
| def export_applied_sx20_contract_metadata(): |
| caps={};slots={} |
| observations=['scan.completed_points','scan.signal','scan.absorbance','scan.fluorescence_v','scan.unit','scan.last_sample_time_s'] |
| stop=['scan.phase','scan.stage','stop.valve_angle_rad','safety.warning'] |
| corrections=['calibration.absorbance_correction','calibration.fluorescence_correction_v'] |
| immediate={ |
| 'plant.configure':['plant.configured','plant.rapid_cell_installed','cell.dead_time_s'], |
| 'sample.load':['sample.loaded','truth.ledger'], |
| 'bath.cover':['cover.opened','cover.angle_rad','gas.enabled',*stop], |
| 'valves.set':['valves.drive','valves.angle_rad'], |
| 'power.set':['power.enabled',*stop],'gas.set':['gas.enabled',*stop], |
| 'method.configure':['method.wavelength_m','method.mix_ratio','method.stop_volume_m3','scan.unit'], |
| 'acquisition.start':['scan.phase','scan.stage','scan.elapsed_s',*observations,'stop.valve_angle_rad','fluid.needs_flush','safety.warning','truth.ledger'], |
| 'acquisition.stop':stop,'fluid.flush':['fluid.needs_flush','truth.ledger'], |
| 'calibration.zero':corrections, |
| } |
| on_step={'acquisition.start':['drive.stroke_m','stop.stroke_m','stop.valve_angle_rad','scan.phase','scan.stage','scan.elapsed_s',*observations,'truth.ledger']} |
| on_completion={'acquisition.start':['scan.phase','scan.stage']} |
| observed={ |
| 'plant.configure':['plant.configured'],'sample.load':['sample.loaded'], |
| 'bath.cover':['cover.opened'],'valves.set':['valves.drive'],'power.set':['power.enabled'],'gas.set':['gas.enabled'], |
| 'acquisition.start':['scan.phase'],'acquisition.stop':['scan.phase'], |
| 'process.measure':['scan.phase','scan.stage','scan.elapsed_s','scan.completed_points','scan.signal','scan.unit','safety.warning'], |
| 'result.read':['scan.phase',*observations],'calibration.zero':corrections,'product.read':['truth.ledger'], |
| } |
| def effects_for(key): |
| descriptions={'immediate':'经检查的外部事件、配置、操作初始化或取消；不推进时间，也不回滚已转移液量','on_step':'后续宿主step实际排空/驱动、触发和采样；仅移交现存液体与染团','on_completion':'最后调度样点完成后设置succeeded和idle，保留实际观测与液体账本'} |
| return [dict(state_id=state,timing=timing,description_zh='仅mode对应的模拟空白修正改变；另一路保持不变，非原厂校准' if key=='calibration.zero' else descriptions[timing]) for timing,mapping in [('immediate',immediate),('on_step',on_step),('on_completion',on_completion)] for state in mapping.get(key,[])] |
| for k,(s,u,o,v,c,w) in SLOTS.items(): |
| slots[k]=dict(meaning_zh=SLOT_ZH[k],component_ids=c,value_schema=copy.deepcopy(s),unit=u,reference_conditions=None,origin=o,visibility=v,access='read_write' if w else 'read_only',read_binding=dict(backend='host',artifact_id='runtime',accessor=f'AppliedSx20Session.read(state_ids=[{k!r}])'),write_via=dict(capability_id=w[0],argument=w[1],fixed_arguments={}) if w else None,sampling=dict(mode='instant',time_domain='simulation',window_description=None),source_ids=['simulation_assumption']) |
| errors=['INVALID_ARGUMENT','UNKNOWN_INSTANCE','UNKNOWN_CAPABILITY','UNSUPPORTED','ACCESS_DENIED','REQUEST_CONFLICT','UNKNOWN_REFERENCE','INITIALIZATION_ONLY','EVIDENCE_ACK_REQUIRED','BUSY','PLANT_REQUIRED','EXTERNAL_LOAD_REQUIRED','ISOLATE_GAS','FLUID_NOT_READY','POWER_OFF_FOR_OPTICS','PHYSICAL_RATIO_MISMATCH','CELL_PATH_MISMATCH','FLUOR_EXCITATION_PATH','STOP_VOLUME_RANGE','FILTER_RANGE','SAMPLE_METHOD_REQUIRED','EXTERNAL_FLUSH_REQUIRED','INSUFFICIENT_REAGENT','SOURCE_COVERAGE','EXCITATION_REFERENCE_REQUIRED','SOLVENT_MISMATCH','ANALYSIS_INPUT','FIT_UNIDENTIFIABLE','CALIBRATION_MODE'] |
| for k,(inp,out,c,z,kind,vis,ex,effects) in CAPS.items(): |
| asynchronous=k=='acquisition.start';query=kind in ['query','analysis'];unsupported=k in UNSUPPORTED |
| caps[k]=dict(function_zh=z,kind=kind,visibility=vis,component_ids=c,availability='unsupported' if unsupported else 'implemented',input_schema=copy.deepcopy(inp),output_schema=copy.deepcopy(out),implementation=dict(process='absent' if unsupported else 'implemented',scene='absent',robot='absent',hardware='absent',host='absent' if unsupported else 'implemented'),binding=None if unsupported else dict(backend='host',artifact_id='runtime',entrypoint='asset_runtime.applied_sx20.AppliedSx20Session.invoke',invocation=f'session.invoke(instance_id="sx20_01",capability_id={k!r},arguments={ex!r},request_id="unique")'), |
| preconditions=[] if query or unsupported else [dict(description_zh='宿主配置、外部装液/阀位、供电气源、单通道、池选件、物理混合比、清洗和实测波段；原子拒绝',state_ids=['power.enabled','gas.enabled','cover.opened','valves.drive','fluid.needs_flush','scan.phase'],enforced_by='runtime',check='Runtime._invoke and trusted-principal Session')], |
| state_effects=[] if query or unsupported else effects_for(k), |
| observes=observed.get(k,[]),model_effects=dict(mode='none',description_zh='明确未实现' if unsupported else '待独立场景验证',binding_ids=[]), |
| execution=dict(mode='asynchronous' if asynchronous else 'synchronous',time_domain='simulation',completion_criterion='驱动至停止体积，经历延迟并完成所有真实调度样点' if asynchronous else '事务返回，不额外推进世界时钟',completion_state_ids=['scan.phase'] if asynchronous else [],timeout_s=None,cancellation='supported' if asynchronous else 'unsupported',retry='same_request_id',resources=['host_clock','fluid_circuit','request_cache'],partial_failure_zh='取消、开盖、断电或断气保留实际液量/染团和已取得观测，必须外部清洗才允许下一次；旧曲线绑定采集时method，后续启动才清空；终态poll公开摘要受原身份保护，取消历史终态不干扰新采集；历史与去重限进程内'), |
| errors=[dict(code=e,meaning_zh=e,side_effects='none') for e in errors],example_arguments=copy.deepcopy(ex),verification=[],limitations=LIMITATIONS,source_ids=['manufacturer_primary','simulation_assumption']) |
| mech=dict(component_ids=['drive_a','drive_b','drive_yoke','drive_ram','valve_a','valve_b','cell','stop_plunger','stop_valve','detector','fluor_detector','monochromator','waste_port'],state_ids=list(slots),meaning_zh='标准两液停流、有限体积和死时间、真实静态光学谱与显式两步光学态速率；不把SQ1顺序混合偷换为两步机理',implementation='lumped',equations=[ |
| 'fA=capacityA/(capacityA+capacityB); mixed input c=cA*fA; both plungers share fractional stroke.', |
| 'Cell washout n_new=c*V+(n_old-c*V)*exp(-dV/V), evaluated with expm1; stop gains n_old+n_in-n_new. Both actual liquid transfers are stock-bounded and n_in=c_stock*dV_A; no negative reagent at floating-point exhaustion.', |
| 'V_registered=V_A+V_B+V_cell+V_stop+V_waste; common-density mass residual=rho*volume residual. This is not complete chemical species or energy conservation.', |
| 'Automatic return moves stop contents to waste; external flush moves cell to waste and adds one cell volume of fresh blank, retaining stop contents.', |
| 'A=exp(-k1*t); I=k1*(exp(-k2*t)-exp(-k1*t))/(k1-k2), equal-rate limit=k1*t*exp(-k1*t); P=1-A-I.', |
| 'Reaction age=nominal cell dead time+delay+scheduled time after delay; step sole simulation clock. No observable points before trigger.', |
| 'Absorbance=epsilon(lambda)*c_cell*path*(A+rI*I+rP*P). epsilon[M^-1cm^-1]*0.1 => m^2/mol, c in mol/m^3, path in m.', |
| 'Fluor voltage=host_gain*(1-10^(-epsilon*c_cell*excitation_path))*QY*integral(filter_band,source_em)/integral(source_em)*(A+rI*I+rP*P). Ideal rectangular filter and response factors uncalibrated.', |
| 'Source emission negative baselines clipped for integration; original signed arrays preserved. Standard fluorescence path2mm, rapid5mm per manual.', |
| 'Noise independently Normal(0,host_sigma); observed blank correction is additive and supplied by caller, not hidden ground truth.', |
| 'Single-exponential fit: y=offset+amplitude*exp(-k*t), nonnegative k; fit only supplied observations and report residual.', |
| 'Standard drive2.5mL+2.5mL; asymmetric installed B1/.5/.25/.1mL yields ratios2.5/5/10/25; no software-only continuous ratio change.' |
| ],parameters={},source_ids=['manufacturer_primary','photochemcad','simulation_assumption'],limitations=LIMITATIONS) |
| spec=importlib.util.spec_from_file_location('_sx20_annotations',ROOT/'scripts/asset_runtime/_annotations.py');ann=importlib.util.module_from_spec(spec);spec.loader.exec_module(ann);ann.KEY_ZH.update(SLOT_ZH);ann.TRUTH_ZH.update(SLOT_ZH) |
| ann.annotate_export(SLUG,caps,slots,{'stopped_flow_kinetics':mech},inputs={'plant.configure':(PLANT,PLANT_EXAMPLE),'sample.load':(SAMPLE,SAMPLE_EXAMPLE),'method.configure':(METHOD,METHOD_EXAMPLE)}) |
| for k,v in slots.items():v['meaning_zh']=SLOT_ZH[k]+'；来源='+v['origin']+'；非原厂标定。' |
| mech['parameters']={k.lower():v for k,v in mech['parameters'].items()} |
| return dict(asset_type_id=ASSET_TYPE_ID,catalog_id=CATALOG_ID,capabilities=caps,state_slots=slots,mechanisms={'stopped_flow_kinetics':mech}) |
|
|
|
|
