| """CHEM-004: measured nD references, synthetic thermal/mixture optics, explicit calibration. |
| |
| Front panel (panel.touch / panel.switch / panel.capture / panel.frame) and device layer (settings, logon, methods, quick settings, sample |
| list, data memory, checks, adjustments, user functions): the 7 in touch screen of the M series instrument software from the Abbemat 350/550 |
| manual (panel_ui.json beside the contract), run by the generic engine _panel_ui.py and the shared Anton Paar device layer _antonpaar_touch.py |
| on top of the commands below (no second copy of the measuring logic).""" |
| from __future__ import annotations |
| import copy |
| from asset_runtime import _annotations as _ann |
| import json |
| import math |
| from pathlib import Path |
| from asset_runtime.mt_hx204 import ActionRejected,number,obj,BOOL,TEXT,PHASE |
|
|
|
|
| def _rejected(code,detail): |
| e=ActionRejected(code);e.detail=detail;return e |
| ROOT=Path(__file__).resolve().parents[2] |
| ASSET_TYPE_ID='instrument.antonpaar_abbematadvanced'; CATALOG_ID='CHEM-004'; PROTOCOL_VERSION='1.0.0' |
| TEMPLATE_REL='assets/reactions/antonpaar_abbematadvanced_refractive_library/templates.json' |
| MODE={'type':'string','enum':['refractive_index','calibrated_concentration']} |
| ND=number('1',1.26,1.72); NULL_ND={'anyOf':[ND,{'type':'null'}]} |
| FRACTION=number('1',0,1); NULL_FRACTION={'anyOf':[FRACTION,{'type':'null'}]} |
| POINT=obj({'index':ND,'mass_fraction':FRACTION}) |
| RESULT=obj({'index':NULL_ND,'temperature_k':number('K',277.15,378.15),'wavelength_m':number('m',589.3e-9,589.3e-9), |
| 'mass_fraction':NULL_FRACTION,'phase':PHASE,'quality':{'type':'string','enum':['estimated','suspect','unavailable']}, |
| 'evidence':{'type':'string','enum':['derived','synthetic','unavailable']},'concentration_evidence':{'type':'string','enum':['user_supplied_calibration','unavailable']},'template_source':TEXT}) |
| CAPS={ |
| 'power.set':(obj({'enabled':BOOL}),obj({'enabled':BOOL}),['power_inlet','display_digits'],'供电设定；断电取消进行中操作','device_command','agent',{'enabled':True},['power.enabled','cycle.phase']), |
| 'thermal.set_temperature':(obj({'temperature_k':number('K',277.15,378.15)}),obj({'temperature_k':number('K',277.15,378.15)}),['peltier','temperature_sensor'],'写温控目标，不隐式推进时间','device_command','agent',{'temperature_k':293.15},['thermal.target_k']), |
| 'lid.set_angle':(obj({'angle_rad':number('rad',0,math.pi/2)}),obj({'angle_rad':number('rad',0,math.pi/2)}),['lid','lid_handle'],'被动盖宿主位置设置，采集时锁定；不是机器人技能','device_command','agent',{'angle_rad':math.pi/2},['lid.angle_rad']), |
| 'sample.configure':(obj({'volume_fractions':{'type':'object','additionalProperties':FRACTION},'volume_m3':number('m^3',70e-9,2e-6),'matrix_id':TEXT,'contamination_fraction':number('1',0,.2)}),obj({'configured':BOOL}),['sample_well','sapphire_prism'],'受信任宿主初始化液体账本，体积在装样参考温度定义','configuration','evaluator',{'volume_fractions':{'ethanol':1.},'volume_m3':100e-9,'matrix_id':'ethanol','contamination_fraction':0.},['sample.remaining_m3','sample.input_m3','sample.filled','cycle.phase','optical.indicated_index']), |
| 'method.configure':(obj({'mode':MODE}),obj({'mode':MODE}),['display_digits'],'仅nD或专属标定浓度；不自动套Brix','configuration','agent',{'mode':'refractive_index'},['method.mode']), |
| 'calibration.configure':(obj({'matrix_id':TEXT,'temperature_k':number('K',277.15,378.15),'points':{'type':'array','items':POINT,'minItems':2,'maxItems':32},'source':TEXT}),obj({'configured':BOOL}),['display_digits','sapphire_prism'],'用户提供的特定体系标定表；要求nD与浓度严格单调，不宣称厂家校准','configuration','agent',{'matrix_id':'ethanol','temperature_k':293.15,'points':[{'index':1.35,'mass_fraction':0.},{'index':1.38,'mass_fraction':1.}],'source':'synthetic demonstration only'},['calibration.configured']), |
| 'acquisition.start':(obj({}),obj({'phase':PHASE,'operation_id':TEXT}),['sapphire_prism','led_source','detector','display_digits'],'闭盖、填样、恒温后进行10s光学读数代理','device_command','agent',{},['cycle.phase','cycle.elapsed_s']), |
| 'acquisition.stop':(obj({}),obj({'phase':PHASE}),['display_digits'],'取消测量或清洗，保留实际已发生的体积转移','device_command','agent',{},['cycle.phase']), |
| 'cleaning.start':(obj({'volume_m3':number('m^3',70e-9,1e-4)}),obj({'phase':PHASE,'operation_id':TEXT}),['sample_well','sapphire_prism'],'开盖进行30s工程清洗；清洗液和样品参考体积分别守恒','device_command','agent',{'volume_m3':1e-6},['cycle.phase','cycle.elapsed_s','cleaner.input_m3','cleaner.remaining_m3']), |
| 'refractometry.measure':(obj({}),RESULT,['sapphire_prism','detector','display_digits'],'纯读最近nD、温度及有适用标定时的浓度','query','agent',{},[]), |
| } |
| SLOTS={ |
| 'power.enabled':(BOOL,'1','setpoint','agent',['power_inlet'],('power.set','enabled')), |
| 'thermal.target_k':(number('K',277.15,378.15),'K','setpoint','agent',['peltier'],('thermal.set_temperature','temperature_k')), |
| 'thermal.temperature_k':(number('K',277.15,378.15),'K','process_truth','evaluator',['sapphire_prism'],None), |
| 'thermal.indicated_temperature_k':(number('K',277.15,378.15),'K','derived','agent',['temperature_sensor','display_digits'],None), |
| 'lid.angle_rad':(number('rad',0,math.pi/2),'rad','scene','agent',['lid'],('lid.set_angle','angle_rad')), |
| 'method.mode':(MODE,'1','setpoint','agent',['display_digits'],None), |
| 'calibration.configured':(BOOL,'1','derived','agent',['display_digits'],None), |
| 'cycle.phase':(PHASE,'1','derived','agent',['display_digits'],None), |
| 'cycle.elapsed_s':(number('s',0),'s','derived','agent',['display_digits'],None), |
| 'cycle.operation':({'type':'string','enum':['none','measurement','cleaning']},'1','derived','agent',['display_digits'],None), |
| 'sample.filled':(BOOL,'1','derived','agent',['sample_well'],None), |
| 'optical.indicated_index':(NULL_ND,'1','derived','agent',['detector','display_digits'],None), |
| 'concentration.indicated_mass_fraction':(NULL_FRACTION,'1','derived','agent',['display_digits'],None), |
| 'sample.remaining_m3':(number('m^3',0),'m^3','process_truth','evaluator',['sample_well'],None), |
| 'sample.input_m3':(number('m^3',0),'m^3','process_truth','evaluator',['sample_well'],None), |
| 'sample.waste_m3':(number('m^3',0),'m^3','process_truth','evaluator',['sample_well'],None), |
| 'cleaner.input_m3':(number('m^3',0),'m^3','process_truth','evaluator',['sample_well'],None), |
| 'cleaner.remaining_m3':(number('m^3',0),'m^3','process_truth','evaluator',['sample_well'],None), |
| 'cleaner.waste_m3':(number('m^3',0),'m^3','process_truth','evaluator',['sample_well'],None), |
| } |
| def validate(schema,value): |
| """Explicit supported JSON subset; finite numeric values, strict bool/array/const handling.""" |
| if 'anyOf' in schema: |
| for sub in schema['anyOf']: |
| try: validate(sub,value); return |
| except ActionRejected: pass |
| raise ActionRejected('INVALID_ARGUMENT') |
| typ=schema.get('type') |
| if typ=='number': |
| if isinstance(value,bool) or not isinstance(value,(int,float)) or not math.isfinite(value) or not schema.get('minimum',-math.inf)<=value<=schema.get('maximum',math.inf): raise ActionRejected('INVALID_ARGUMENT') |
| elif typ=='boolean': |
| if type(value) is not bool: raise ActionRejected('INVALID_ARGUMENT') |
| elif typ=='null': |
| if value is not None: raise ActionRejected('INVALID_ARGUMENT') |
| elif typ=='string': |
| if not isinstance(value,str): raise ActionRejected('INVALID_ARGUMENT') |
| elif typ=='array': |
| if not isinstance(value,list) or not schema.get('minItems',0)<=len(value)<=schema.get('maxItems',math.inf): raise ActionRejected('INVALID_ARGUMENT') |
| for v in value: validate(schema['items'],v) |
| elif typ=='object': |
| if not isinstance(value,dict) or not set(schema.get('required',[]))<=value.keys(): raise ActionRejected('INVALID_ARGUMENT') |
| for k,v in value.items(): |
| if not isinstance(k,str): raise ActionRejected('INVALID_ARGUMENT') |
| sub=schema.get('properties',{}).get(k,schema.get('additionalProperties',True)) |
| if sub is False: raise ActionRejected('INVALID_ARGUMENT') |
| if isinstance(sub,dict): validate(sub,v) |
| if 'enum' in schema and value not in schema['enum']: raise ActionRejected('INVALID_ARGUMENT') |
| if 'const' in schema and value!=schema['const']: raise ActionRejected('INVALID_ARGUMENT') |
|
|
|
|
| |
| from asset_runtime import _antonpaar_touch as _ap |
| ASSET_VERSION='1.1.3' |
| ASSET_DIR=ROOT/'assets/expansion_batch03/t4_measure/antonpaar_abbematadvanced' |
| SERIAL='AB5201-0001' |
| WAVELENGTH_NM=589.3 |
| ND_RANGE=(1.26,1.72) |
| ACCURACY={'Most precise':(0.005,15.,0.00001),'Precise':(0.01,10.,0.00002),'Fast Measuring':(0.03,5.,0.00006)} |
| T_UNITS=['°C','°F','K'] |
| QUANTITIES={ |
| 'nD':dict(label='Refractive Index',group='RI Basic Scales',kind='nD',unit='nD',units=['nD'],digits=5), |
| 'concentration':dict(label='Concentration (user calibration)',group='RI Basic Scales',kind='fraction',unit='% w/w',units=['% w/w','g/g','g/kg'],digits=2), |
| 'ri_temperature':dict(label='RI Temperature',group='Temperature',kind='temperature',unit='°C',units=T_UNITS,digits=2), |
| 'ri_set_temperature':dict(label='RI Set Temperature',group='Temperature',kind='temperature',unit='°C',units=T_UNITS,digits=2), |
| 'ri_wavelength':dict(label='RI Wavelength',group='System Settings',kind='number',unit='nm',units=['nm'],digits=0), |
| 'ri_condition':dict(label='RI Condition',group='Refractive Index',kind='text'), |
| 'master_condition':dict(label='Master Condition',group='System Settings',kind='text'), |
| 'sample_name':dict(label='Sample Name',group='System Settings',kind='text'), |
| 'method':dict(label='Method',group='System Settings',kind='text'), |
| 'measurement_type':dict(label='Measurement Type',group='System Settings',kind='text'), |
| 'user':dict(label='User',group='System Settings',kind='text'), |
| 'date':dict(label='Date',group='System Settings',kind='text'), |
| 'time':dict(label='Time',group='System Settings',kind='text'), |
| 'unique_id':dict(label='Unique Sample ID',group='System Settings',kind='text'), |
| 'error_state':dict(label='Sample Error State',group='System Settings',kind='text'), |
| 'data_field_1':dict(label='Data Field 1',group='System Settings',kind='text'), |
| 'data_field_2':dict(label='Data Field 2',group='System Settings',kind='text'), |
| 'data_field_3':dict(label='Data Field 3',group='System Settings',kind='text'), |
| 'last_check_name':dict(label='Last RI Check Name',group='System Settings',kind='text'), |
| 'last_check_state':dict(label='Last RI Check State',group='System Settings',kind='text'), |
| 'last_check_date':dict(label='Last RI Check Date',group='System Settings',kind='text'), |
| 'last_adjustment_date':dict(label='RI Last Adjustment Date',group='System Settings',kind='text'), |
| 'last_adjustment_user':dict(label='RI Last Adjustment User',group='System Settings',kind='text'), |
| 'serial_number':dict(label='RI Serial Number',group='System Settings',kind='text'), |
| } |
| METHOD_FIELDS=[ |
| _ap.t_enum('ri.scale','Scale',('Refractive Index','User calibration table'),'Refractive Index',('p.72-74','-'),'refractometer', |
| assumption='only nD and the user calibration of calibration.configure are loaded; the factory concentration scales of Table 11.1 are not part of the simulated instrument'), |
| _ap.t_bool('ri.temp_control','RI control temperature',True,('p.75','-'),'refractometer'), |
| _ap.t_num('ri.temperature','Temperature',4.,105.,20.,('p.72, p.75-76','-'),'refractometer',unit='°C',visible=('ri.temp_control',True)), |
| _ap.t_enum('ri.accuracy','Measurement Accuracy',tuple(ACCURACY),'Precise',('p.75','-'),'refractometer',assumption='factory accuracy not given; Precise assumed'), |
| _ap.t_num('ri.hold_s','Hold Time',0,1800,1,('p.75-76, p.133','-'),'refractometer',unit='s',integer=True), |
| _ap.t_num('ri.timeout_s','Timeout',0,3600,200,('p.76, p.133','-'),'refractometer',unit='s',integer=True,assumption='0 s = no timeout'), |
| ] |
| FAVORITE_PAGES=['messages','monitor','quick_settings','method_list','measured_data','checks_execution','one_point','two_point','air_reference', |
| 'check_management','standards','statistics','check_data','adjustment_data','audit_trail','ri_module','measurement_mode','display_layout', |
| 'result_output','limits','quick_management','method_management','method_visibility','sample_naming','data_fields','list_warnings', |
| 'mandatory_fields','functions','calculator','date_time','regional','input_units','network','instrument_name','screen_saver','beeps', |
| 'touch_calibration','keyboard_barcode','smtp','brightness','rs232_lims','security_level','audit_settings','esign','logon_settings', |
| 'increased_security','advanced_security','user_management','group_admin','printer_management','auto_printout','report_management', |
| 'select_logos','name_address','memory_settings','browser_settings','system_info','live_raw_data'] |
| CHECK_SCHEMA=_ap.obj(dict(name=_ap.NAME,kind={'type':'string','enum':['Water Check','Custom Check','Reference Standard Check']}, |
| method=_ap.nullable(_ap.STR),standard=_ap.nullable(_ap.STR),temperature={'type':'string','enum':['20 °C','Method temperature']},gxp=_ap.BOOL, |
| reminder=_ap.BOOL,interval_days=_ap.num('days',1,365,integer=True),prohibit=_ap.BOOL,max_dev=_ap.num('nD',0,0.1), |
| tolerances={'type':'array','items':_ap.obj(dict(q=_ap.nullable(_ap.STR),lower=_ap.nullable(_ap.num('1')),upper=_ap.nullable(_ap.num('1')))),'maxItems':10}), |
| optional=('method','standard','temperature','gxp','reminder','interval_days','prohibit','max_dev','tolerances')) |
| STANDARD_SCHEMA=_ap.obj(dict(name=_ap.NAME,temperature_c=_ap.num('°C',4,105),nd=_ap.num('nD',ND_RANGE[0],ND_RANGE[1]),serial={'type':'string','maxLength':30}, |
| reference={'type':'string','maxLength':30},expiry={'type':'string','maxLength':10}),optional=('serial','reference','expiry')) |
| FACTORY_ADJUST={'offset':0.,'slope':1.,'baseline':0.,'factory':True} |
| ADJUST_STANDARD=_ap.obj(dict(name=_ap.NAME,temperature_c=_ap.num('°C',4,105),nd=_ap.nullable(_ap.num('nD',ND_RANGE[0],ND_RANGE[1])))) |
| def water_nd(t_c): |
| """Water reference nD at the method temperature (abm p.65 'Water (method temp.)'); assumption: quadratic fit around 1.33299 at 20 °C.""" |
| d=t_c-20.; return round(1.33299-8.0e-5*d-1.6e-6*d*d,6) |
|
|
|
|
| def _abm_method_temperature(m): return m['settings']['ri.temperature'] |
| def _abm_apply(h,m,q): |
| """A method / quick settings change reaches the measuring cell (scale -> method.mode, temperature control and set temperature).""" |
| s=m['settings']; mode='calibrated_concentration' if s['ri.scale']=='User calibration table' else 'refractive_index' |
| target=round(min(max(q.get('ri.temperature',s['ri.temperature'])+273.15,277.15),378.15),6) |
| if mode!=h.mode or (s['ri.temp_control'] and abs(target-h.target_k)>1e-9): h.result=None |
| h.mode=mode; h.temp_control=s['ri.temp_control'] |
| if h.temp_control: h.target_k=target |
| def _abm_run_params(h,m,q,run): |
| s=m['settings']; acc=ACCURACY[q.get('ri.accuracy',s['ri.accuracy'])]; temp=q.get('ri.temperature',s['ri.temperature']) |
| control=s['ri.temp_control'] or run['type']=='TS' or run['kind'] in ('check','adjust') |
| if run['kind']=='check': |
| c=next(x for x in h.ap['checks'] if x['name']==run['check']) |
| if c['kind']=='Water Check' and c.get('temperature','20 °C')=='20 °C': temp=20. |
| if c['kind']=='Reference Standard Check': temp=next(x for x in h.ap['standards'] if x['name']==c['standard'])['temperature_c'] |
| timeout=q.get('ri.timeout_s',s['ri.timeout_s']) |
| return dict(control=control,temp_c=temp,tol_c=acc[0],stability_s=acc[1],hold_s=float(q.get('ri.hold_s',s['ri.hold_s'])),timeout_s=float(timeout) or None) |
| def _abm_precheck(h,run): |
| _ap.need(h.lid_angle<=1e-6,'LID_OPEN') |
| filled=h._values()['sample.filled'] |
| if run['kind']=='adjust' and run['adjust']['type']=='air': _ap.need(not filled,'PRISM_NOT_CLEAN') |
| if filled: |
| for t in run['temps'] if run['kind']=='sample' else [run['params']['temp_c']]: |
| for sid in h.remaining: h._check_phase(sid,t+273.15) |
| if run['kind']=='sample' and _ap.method(h.ap,run['method'])['settings']['ri.scale']=='User calibration table': |
| c=h.calibration; _ap.need(c is not None and c['matrix_id']==h.matrix_id and abs(c['temperature_k']-(run['params']['temp_c']+273.15))<=.05,'NO_CALIBRATION') |
| def _abm_begin(h,run): |
| h._operation_count+=1; h.operation_id=f'{h.instance_id}:{run["kind"]}:{h._operation_count}' |
| h.phase='running'; h.operation='measurement'; h.elapsed_s=0.; h.result=None |
| return dict(phase=h.phase,operation_id=h.operation_id) |
| def _abm_set_temperature(h,c): h.target_k=round(min(max(c+273.15,277.15),378.15),6); h.temp_control=True |
| def _abm_temperature_ok(h,tol): return abs(h.temperature_k-h.target_k)<=tol+1e-12 |
| def _abm_begin_reading(h,seconds): |
| h._reading_s=float(seconds); h.phase='running'; h.operation='measurement'; h.elapsed_s=0.; h.result=None |
| return h._values()['sample.filled'] |
| def _abm_resume(h): h.phase='running'; h.operation='measurement'; h.elapsed_s=0. |
| def _abm_values(h,index,condition,conc=None): |
| ap=h.ap; dt=_ap.device_dt(h); q=ap['quick']; c=max((x for x in ap['check_data']),key=lambda r:r['id'],default=None) |
| a=ap['adjustments'][-1] if ap['adjustments'] else None |
| return {'nD':index,'concentration':conc,'ri_temperature':round(h.temperature_k-273.15,3),'ri_set_temperature':round(h.target_k-273.15,3) if h.temp_control else None, |
| 'ri_wavelength':WAVELENGTH_NM,'ri_condition':condition,'master_condition':condition,'sample_name':q['sample_name'],'method':ap['active'], |
| 'measurement_type':_ap.MEASUREMENT_TYPES[q['type']],'user':ap['user'] or '','date':_ap.date_text(h,dt),'time':_ap.clock_text(h),'unique_id':'', |
| 'error_state':'','data_field_1':q['field1'],'data_field_2':q['field2'],'data_field_3':q['field3'],'last_check_name':c['check'] if c else '', |
| 'last_check_state':c['result'] if c else '','last_check_date':c['time'][:10] if c else '','last_adjustment_date':a['time'][:10] if a else '', |
| 'last_adjustment_user':a['user'] if a else '','serial_number':SERIAL} |
| def _abm_reading(h,empty=False): |
| """Values of a finished reading: the indicated nD of the physics result, or 'no measured data' (abm p.143) without a valid value.""" |
| if empty or not h.result or h.result['index'] is None: |
| out=dict(values=_abm_values(h,None,'no measured data'),condition='no measured data') |
| if not h._values()['sample.filled']: out['air_nd']=h._air_signal() |
| return out |
| return dict(values=_abm_values(h,h.result['index'],'valid',h.result['mass_fraction']),condition='valid') |
| def _abm_direct_done(h,reading): |
| q=h.ap['quick']; run=dict(kind='sample',method=h.ap['active'],type='S',sample_name=q['sample_name'],field1=q['field1'],field2=q['field2'],field3=q['field3'],list_index=None) |
| _ap.finish_measurement(h,run,[reading]) |
| def _abm_fill_prompt(h,run): |
| if run['kind']=='adjust': |
| st=run['adjust']['standards'][run['k']] |
| return f'Clean the prism, apply the standard "{st["name"]}" (nD {st["nd"]:.5f} at {st["temperature_c"]:.2f} °C), close the cover and tap <OK>.' |
| return f'Clean the prism, apply fill {run["k"]+1} of {run["n"]}, close the cover and tap <OK>.' |
| def _abm_evaluate_check(h,c,reading): |
| v=reading['values']; nd=v['nD'] |
| if c['kind']=='Custom Check': |
| rows=[dict(q=t['q'],value=v.get(t['q']),lower=t['lower'],upper=t['upper']) for t in c.get('tolerances',[])] |
| ok=bool(rows) and all(r['value'] is not None and r['lower']<=r['value']<=r['upper'] for r in rows) |
| return dict(result='passed' if ok else 'not passed',reference=None,measured=nd,lower=None,upper=None,rows=rows) |
| ref=1.33299 if c['kind']=='Water Check' else next(x for x in h.ap['standards'] if x['name']==c['standard'])['nd'] |
| dev=None if nd is None else nd-ref |
| ok=dev is not None and abs(dev)<=c.get('max_dev',0.0001)+1e-12 |
| return dict(result='passed' if ok else 'not passed',reference=ref,measured=nd,lower=ref-c.get('max_dev',0.0001),upper=ref+c.get('max_dev',0.0001),rows=[]) |
| def _abm_adjust_done(h,run): |
| """Adjustment proposal from the readings (abm p.65-68): old / new nD, temperature, deviations and the recommendation; applied by adjustment.decide.""" |
| ad=run['adjust']; a=h.adjust; rd=run['readings'] |
| if ad['type']=='air': |
| air=rd[-1].get('air_nd'); ok=air is not None |
| h.ap['procedure']=dict(kind='adjust_result',type='air',ok=ok,recommend='Apply' if ok else 'Reject',rows=[], |
| new=dict(a,baseline=-air,factory=False) if ok else None,temperature=rd[-1]['values']['ri_temperature'],standards=[]) |
| return |
| if any(r['values']['nD'] is None for r in rd): |
| h.ap['procedure']=dict(kind='adjust_result',type=ad['type'],ok=False,recommend='Reject',rows=[],new=None,temperature=None,standards=ad['standards']); return |
| raw=[(r['values']['nD']-a['offset']-a['baseline'])/a['slope'] for r in rd]; refs=[s['nd'] for s in ad['standards']] |
| if ad['type']=='one_point': new=dict(a,offset=a['offset']+refs[0]-rd[0]['values']['nD'],factory=False) |
| else: |
| slope=(refs[1]-refs[0])/(raw[1]-raw[0]) if abs(raw[1]-raw[0])>1e-12 else None |
| new=None if slope is None else dict(a,slope=slope,offset=refs[0]-slope*raw[0]-a['baseline'],factory=False) |
| rows=[dict(standard=s['name'],old=r['values']['nD'],new=s['nd'],temperature=r['values']['ri_temperature'],dev_abs=r['values']['nD']-s['nd'], |
| dev_rel=(r['values']['nD']-s['nd'])/s['nd']) for s,r in zip(ad['standards'],rd)] |
| ok=new is not None; rec='Apply' if ok and all(abs(x['dev_abs'])<=0.002 for x in rows) else 'Reject' |
| h.ap['procedure']=dict(kind='adjust_result',type=ad['type'],ok=ok,recommend=rec,rows=rows,new=new,temperature=rows[-1]['temperature'],standards=ad['standards']) |
| def _abm_live(h): |
| """Live values of the monitor mode (abm p.85): the current indicated nD with a sample on the prism, else no value.""" |
| ap=h.ap; run=ap['run'] |
| cond='temp. equilibration' if run and run['stage'] in ('equilibrating','hold') else 'measuring' if run and run['stage'] in ('measuring','empty') \ |
| else 'waiting for sample' if run else 'measuring' if h.phase=='running' and h.operation=='measurement' else 'monitor mode' |
| n=h._live_index(); conc=h._concentration(n) if n is not None else None |
| return _abm_values(h,n,cond,conc) |
| def _abm_run_state(h): |
| ap=h.ap; run=ap['run'] |
| if run is None: return dict(active=False,kind=None,stage=None,k=0,n=0,prompt=None,progress=0.,sample='',temperature_c=None,check=None) |
| frac=(run['k']+(min(h.elapsed_s/max(h._reading_s,1e-9),1.) if run['stage']=='measuring' else 0.))/max(run['n'],1) |
| return dict(active=True,kind=run['kind'],stage=run['stage'],k=run['k'],n=run['n'],prompt=run['prompt'],progress=round(frac,4), |
| sample=run['sample_name'] or f'Sample {ap["sample_no"]}',temperature_c=run.get('temp_c'),check=run['check'],type=run['type']) |
| def _abm_readout(h): |
| """What the main screen shows (abm p.24-27): header, the method's output fields (live in monitor mode, else the frozen last result), |
| the progress bar and the quick access status.""" |
| ap=h.ap; m=_ap.method(ap); run=ap['run'] |
| rec=ap['frozen_rec'] if ap['frozen'] is not None else None |
| vals=rec['values'] if rec else _abm_live(h) if (ap['monitor'] or run or h.phase=='running') else {} |
| fields=[] |
| for f in m['fields']: |
| if not f['q']: fields.append(dict(q='',label='',text='',unit='')); continue |
| q=QUANTITIES.get(f['q'],dict(label=f['q'][3:],kind='number')) |
| unit=(f.get('unit') or q.get('unit') or '') if q.get('kind')!='text' else '' |
| fields.append(dict(q=f['q'],label=q['label'],text=_ap.fmt_value(PROFILE,f,vals.get(f['q']),ap) if vals else '',unit=unit)) |
| rs=_abm_run_state(h); name=ap['quick']['sample_name'] or f'#{ap["sample_no"]}' |
| if run: progress=dict(text=f'{rs["sample"]}: '+{'equilibrating':'Temperature equilibration','hold':'Temperature equilibration','measuring':'Measuring', |
| 'empty':'Measuring','await_fill':'Waiting for the next fill'}[run['stage']],fraction=rs['progress'],color='red') |
| elif rec: progress=dict(text=f'{rec["sample_name"]}: Finished',fraction=1.,color='green') |
| else: progress=dict(text='',fraction=0.,color='neutral') |
| return dict(header=dict(method=m['name'],sample=rec['sample_name'] if rec and not run else name,clock=_ap.clock_text(h),user=ap['user'] or '', |
| group=_ap.public_users(ap)['group'] or ''),fields=fields,progress=progress,status=_ap.status(ap),monitor=ap['monitor'], |
| frozen=rec is not None,screen_off=_ap.screen_off(h),start_enabled=not run and h.phase!='running',sample_list_mode=ap['settings']['samples.mode']=='Sample List') |
| def _abm_raw(h): |
| """Service > Live Raw Data (abm p.106-107): live sensor values; frozen like the main screen after a measurement.""" |
| if not h.powered: return {} |
| n=h._true_index() if h._values()['sample.filled'] else None; a=h.adjust |
| raw=None if n is None else round(h._raw_nd(n),6) |
| run=h.ap['run'] |
| return {'nd_raw':'---' if raw is None else f'{raw:.6f}','nd':'---' if raw is None else f'{h._index():.6f}','prism_t':f'{h.temperature_k-273.15:.3f} °C', |
| 'set_t':f'{h.target_k-273.15:.2f} °C' if h.temp_control else 'off','control':'on' if h.temp_control else 'off','wavelength':f'{WAVELENGTH_NM} nm', |
| 'state':'measuring' if h.phase=='running' else 'stopped' if h.phase=='cancelled' else 'single measurement' if h.phase=='succeeded' else 'monitor', |
| 'substate':run['stage'] if run else ('finished' if h.phase=='succeeded' else '-'),'condition':_abm_live(h)['ri_condition'], |
| 'calc_nd':'nD = slope * raw + offset + air baseline','calc_conc':'user calibration table (calibration.configure)' if h.calibration else 'no user calibration', |
| 'calc_corr':f'slope {a["slope"]:.6f} / offset {a["offset"]:+.6f} / baseline {a["baseline"]:+.6f}'} |
| def _abm_system_info(h): |
| return [['Instrument','Abbemat 5201 (simulated)'],['Serial number',SERIAL],['Measuring range',f'{ND_RANGE[0]} nD to {ND_RANGE[1]} nD'], |
| ['Temperature range','4 °C to 105 °C'],['Wavelength',f'{WAVELENGTH_NM} nm'],['Data memory',f'{len(h.ap["data"])} / {PROFILE["memory_capacity"]} results'], |
| ['Software','M series instrument software model (manual version 2.10)'],['Adjustment','factory' if h.adjust['factory'] else 'user adjustment']] |
| def _abm_adjust_start(h,a): |
| t=a['type']; st=copy.deepcopy(a.get('standards',[])) |
| for x in st: |
| _ap.check(ADJUST_STANDARD,x) |
| if x['nd'] is None: _ap.need(x['name'].startswith('Water'),'INVALID_ARGUMENT'); x['nd']=water_nd(x['temperature_c']) |
| if t=='factory': |
| h.adjust=dict(FACTORY_ADJUST); _abm_store_adjustment(h,'Reset to Factory Adjustment',[],True); return dict(phase=h.phase,operation_id='') |
| _ap.need(len(st)==(2 if t=='two_point' else 1 if t=='one_point' else 0),'INVALID_ARGUMENT') |
| if t=='two_point': _ap.need(st[1]['nd']-st[0]['nd']>=0.05*(ND_RANGE[1]-ND_RANGE[0])-1e-12,'NOT_ALLOWED') |
| return _ap.run_start(h,dict(kind='adjust',adjust=dict(type=t,standards=copy.deepcopy(st)))) |
| def _abm_store_adjustment(h,kind,rows,applied): |
| ap=h.ap; rec=dict(id=ap['next_adj'],time=_ap.device_iso(h),type=kind,user=ap['user'] or '-',rows=copy.deepcopy(rows),applied=applied, |
| correction=dict(h.adjust)) |
| ap['next_adj']+=1; ap['adjustments'].append(rec); del ap['adjustments'][:-50] |
| _ap.audit(h,f'{kind}: {"applied" if applied else "rejected"}') |
| def _abm_adjust_decide(h,a): |
| p=h.ap['procedure']; _ap.need(p is not None and p['kind']=='adjust_result','NO_PROCEDURE') |
| _ap.need(not a['apply'] or p['ok'],'NOT_ALLOWED') |
| names={'one_point':'One-point Adjustment','two_point':'Two-point Adjustment','air':'Set Air Reference'} |
| if a['apply']: h.adjust=dict(p['new']); _abm_store_adjustment(h,names[p['type']],p['rows'],True) |
| else: _ap.audit(h,f'{names[p["type"]]}: rejected') |
| h.ap['procedure']=None |
| return dict(applied=a['apply']) |
| PROFILE=dict(settings=_ap.MSERIES_SETTINGS,method_fields=METHOD_FIELDS,quantities=QUANTITIES,factory_methods=[dict(name='Refractive Index',protected=False)], |
| layouts=[('1 large + 4 small',5),('1 large',1),('2 large',2),('1 large + 2 small',3),('6 small',6)], |
| default_fields=[dict(q='nD',unit='nD',digits=5),dict(q='ri_set_temperature',unit='°C',digits=2),dict(q='ri_temperature',unit='°C',digits=2), |
| dict(q='ri_wavelength',unit='nm',digits=0),dict(q='master_condition',unit='',digits=0)], |
| default_output=[dict(q='nD',unit='nD',digits=5),dict(q='ri_temperature',unit='°C',digits=2),dict(q='master_condition',unit='',digits=0)], |
| browser_default=['sample_name','method','nD','ri_temperature','master_condition','date','time'], |
| quick_default=['sample_name','type','ri.temperature','ri.hold_s','ri.timeout_s','ri.accuracy'],quick_fields=['ri.temperature','ri.hold_s','ri.timeout_s','ri.accuracy'], |
| quick_params=['sample_name','type','ri.temperature','ri.hold_s','ri.timeout_s','ri.accuracy','field1','field2','field3'],quick_locked=['sample_name','type'], |
| modes=('S','C','MM','MF','TS'),mf_max=5,t_min_c=4.,t_max_c=105.,max_methods=200,memory_capacity=10000,memory_reminder=9900,check_capacity=100, |
| serial=SERIAL,max_users=50,max_functions=80,password_case_sensitive=False,main_quantity='nD',temperature_quantity='ri_temperature', |
| fixed_favorites=[dict(page='messages',name='Message List'),dict(page='monitor',name='Monitor Mode')],favorite_pages=FAVORITE_PAGES, |
| factory_checks=[dict(name='Water Check',kind='Water Check',method=None,standard='Water',temperature='20 °C',gxp=False,reminder=False,interval_days=1, |
| prohibit=False,max_dev=0.0001,tolerances=[],factory=True,last=None)], |
| factory_standards=[dict(name='Water',temperature_c=20.0,nd=1.33299,serial='',reference='',expiry='')], |
| touch_targets=[[80,96],[720,96],[720,376],[80,376]],check_schema=CHECK_SCHEMA,standard_schema=STANDARD_SCHEMA,check_default=dict(method=None,standard=None,temperature='20 °C',gxp=False,reminder=False, |
| interval_days=1,prohibit=False,max_dev=0.0001,tolerances=[]),display_size=(800,480),display_component='screen', |
| rights={'adjustment.start':'adjustments','adjustment.decide':'adjustments'},handlers={'adjustment.start':_abm_adjust_start,'adjustment.decide':_abm_adjust_decide}, |
| apply_method=_abm_apply,method_temperature=_abm_method_temperature,run_params=_abm_run_params,precheck=_abm_precheck,begin=_abm_begin, |
| set_temperature=_abm_set_temperature,temperature_ok=_abm_temperature_ok,begin_reading=_abm_begin_reading,resume=_abm_resume,reading=_abm_reading, |
| direct_done=_abm_direct_done,fill_prompt=_abm_fill_prompt,adjust_done=_abm_adjust_done,evaluate_check=_abm_evaluate_check,run_state=_abm_run_state, |
| readout=_abm_readout,system_info=_abm_system_info,timeout_text='Measurement timeout: the prism temperature is not stable.') |
| PROFILE['commands']=set(_ap.DEVICE_CAPS) |
| ADJ_CAPS={ |
| 'adjustment.start':(_ap.obj(dict(type={'type':'string','enum':['one_point','two_point','air','factory']},standards={'type':'array','items':ADJUST_STANDARD,'maxItems':2}),optional=('standards',)), |
| _ap.obj(dict(phase=TEXT,operation_id=TEXT)),['screen','sapphire_prism','detector'], |
| '折光仪调整（Checks / Adjustments > Refractometer Adjustments）：单点/两点调整（逐个装标准液测量）、设空气参考（棱镜清洁干燥）、恢复出厂调整；结果待adjustment.decide确认', |
| 'device_command','agent',{'type':'one_point','standards':[{'name':'Toluene','temperature_c':20.0,'nd':1.4967}]},['run.state','adjustment.state','cycle.phase']), |
| 'adjustment.decide':(_ap.obj(dict(apply=BOOL)),_ap.obj(dict(applied=BOOL)),['screen'],'调整结果：<Apply>写入新的修正（调整数据）或<Reject>放弃','device_command','agent', |
| {'apply':True},['adjustment.state','adjustment.correction','data.adjustments']), |
| 'sensor.configure_error':(_ap.obj(dict(offset_nd=_ap.num('nD',-.01,.01),gain=_ap.num('1',-.01,.01),baseline_nd=_ap.num('nD',-.01,.01))), |
| _ap.obj(dict(offset_nd=_ap.num('nD'),gain=_ap.num('1'),baseline_nd=_ap.num('nD'))),['detector','sapphire_prism'], |
| '评测者：设定折射率读数误差（零点偏移、斜率、空气基线），默认0即理想；调整按模型修正（sim-to-real误差另行研究）','configuration','evaluator', |
| {'offset_nd':0.,'gain':0.,'baseline_nd':0.},['sensor.errors']), |
| } |
| _PANEL_SPEC_PATH=ASSET_DIR/'panel_ui.json' |
| DEVICE_TUPLES=_ap.device_cap_tuples(PROFILE,{'clock.set':['screen'],'measurement.start':['screen','sapphire_prism','detector','peltier'], |
| 'measurement.continue':['screen','sapphire_prism'],'check.start':['screen','sapphire_prism','detector']}) |
| CAPS.update(DEVICE_TUPLES); CAPS.update(ADJ_CAPS) |
| for _k,_v in _ap.device_slots(PROFILE).items(): SLOTS[_k]=_v |
| SLOTS.update({'thermal.control':(BOOL,'1','setpoint','agent',['peltier'],None),'adjustment.state':(_ap.nullable(_ap.ANYOBJ),'1','derived','agent',['screen'],None), |
| 'adjustment.correction':(_ap.obj(dict(offset=_ap.num('nD'),slope=_ap.num('1'),baseline=_ap.num('nD'),factory=BOOL)),'1','derived','agent',['detector'],None), |
| 'sensor.errors':(_ap.obj(dict(offset_nd=_ap.num('nD'),gain=_ap.num('1'),baseline_nd=_ap.num('nD'))),'1','process_truth','evaluator',['detector'],None), |
| 'display.raw':(_ap.ANYOBJ,'1','derived','agent',['screen'],None)}) |
| import os as _os |
| _engine=_ap.panel_engine() |
| PANEL_SPEC=_engine.load_spec(_PANEL_SPEC_PATH,capabilities=set(CAPS)|set(_ap.panel_caps(json.loads(_PANEL_SPEC_PATH.read_text())))) \ |
| if _PANEL_SPEC_PATH.is_file() and not _os.environ.get('G07_PANEL_BUILD') else None |
| PANEL_CAPS=_ap.panel_caps(PANEL_SPEC) if PANEL_SPEC else {} |
| CAPS.update(PANEL_CAPS) |
|
|
| class AntonpaarAbbematadvancedRuntime: |
| AP_PROFILE=PROFILE; AP_CAPS=CAPS; PANEL_SPEC=PANEL_SPEC |
| def __init__(self,instance_id='abbemat5201_01'): |
| self.instance_id=instance_id; self.time_s=0.; self.revision=0; self.powered=False |
| self.target_k=293.15; self.temperature_k=293.15; self.lid_angle=0.; self.mode='refractive_index'; self.calibration=None |
| self.phase='idle'; self.operation='none'; self.elapsed_s=0.; self.operation_id=None; self._operation_count=0 |
| self.remaining={}; self.initial_species={}; self.waste_species={}; self.matrix_id=None; self.contamination=0. |
| self.cleaner_input_m3=0.; self.cleaner_remaining_m3=0.; self.cleaner_waste_m3=0.; self._clean_start_m3=0. |
| self.result=None; self.templates=json.loads((ROOT/TEMPLATE_REL).read_text())['substances'] |
| self._principals={'__public_agent__':'agent'}; self._requests={}; self._owners={} |
| self.temp_control=True; self._reading_s=10.; self.sensor={'offset_nd':0.,'gain':0.,'baseline_nd':0.}; self.adjust=dict(FACTORY_ADJUST) |
| self.ap=_ap.new_device(PROFILE); self.panel_state=None; self.panel_capture_dir=None |
| self._panel_session=None; self._procedure_op=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 AntonpaarAbbematadvancedSession(self,principal_id) |
| def describe(self): return self.session().describe(instance_id=self.instance_id) |
| def _values(self): |
| return {'power.enabled':self.powered,'thermal.target_k':self.target_k,'thermal.temperature_k':self.temperature_k, |
| 'thermal.indicated_temperature_k':round(self.temperature_k-273.15,3)+273.15,'lid.angle_rad':self.lid_angle,'method.mode':self.mode, |
| 'calibration.configured':self.calibration is not None,'cycle.phase':self.phase,'cycle.elapsed_s':self.elapsed_s,'cycle.operation':self.operation, |
| 'sample.filled':sum(self.remaining.values())>=70e-9-1e-15, |
| 'optical.indicated_index':self.result['index'] if self.result else None, |
| 'concentration.indicated_mass_fraction':self.result['mass_fraction'] if self.result else None, |
| 'sample.remaining_m3':sum(self.remaining.values()),'sample.input_m3':sum(self.initial_species.values()),'sample.waste_m3':sum(self.waste_species.values()), |
| 'cleaner.input_m3':self.cleaner_input_m3,'cleaner.remaining_m3':self.cleaner_remaining_m3,'cleaner.waste_m3':self.cleaner_waste_m3, |
| 'thermal.control':self.temp_control,'adjustment.correction':dict(self.adjust),'sensor.errors':dict(self.sensor)} |
| def read(self,visibility='agent'): |
| vals=dict(self._values(),**_ap.device_values(self),**{'adjustment.state':copy.deepcopy(self.ap['procedure']),'display.raw':_abm_raw(self)}) |
| return copy.deepcopy({k:v for k,v in vals.items() if SLOTS[k][3]=='agent' or visibility in ('evaluator','debug')}) |
| |
| def panel_read(self): |
| """What the panel firmware sees: the agent slots plus whether the screen is live and the boot count (a reboot restarts the GUI).""" |
| out=self.read('agent'); ro=out['display.readout'] |
| out.update({'host.powered':self.powered,'host.power_epoch':self.ap['power_epoch'],'host.screen_off':ro['screen_off'],'host.rights':_ap.rights_of(self.ap), |
| 'host.logged_on':self.ap['user'] is not None,'host.running':self.phase=='running' or self.ap['run'] is not None}) |
| return out |
| def debug_snapshot(self): return dict(state=self.read('evaluator'),remaining=copy.deepcopy(self.remaining),input=copy.deepcopy(self.initial_species),waste=copy.deepcopy(self.waste_species),matrix_id=self.matrix_id) |
| def _measure(self): |
| if self.result: return copy.deepcopy(self.result) |
| return dict(index=None,temperature_k=self._values()['thermal.indicated_temperature_k'],wavelength_m=589.3e-9,mass_fraction=None,phase=self.phase, |
| quality='unavailable',evidence='unavailable',concentration_evidence='unavailable',template_source=TEMPLATE_REL) |
| def _index(self): |
| """Indicated nD: the optical model plus the evaluator-set sensor errors (default 0), corrected by the adjustment (factory: identity).""" |
| a=self.adjust |
| return round(a['slope']*self._raw_nd(self._true_index())+a['offset']+a['baseline'],6) |
| def _raw_nd(self,n): |
| """The detector's raw nD of a sample with true index n: zero offset, slope error and the air baseline signal (evaluator errors, default 0).""" |
| e=self.sensor; return n+e['offset_nd']+e['gain']*(n-1.333)+self._air_signal() |
| def _air_signal(self): |
| """Clean, dry prism (air): the detector's baseline signal in nD (the evaluator air baseline error; Set Air Reference measures it).""" |
| return self.sensor['baseline_nd'] |
| def _live_index(self): |
| if not self.powered or sum(self.remaining.values())<70e-9-1e-15: return None |
| n=self._index(); return n if ND_RANGE[0]<=n<=ND_RANGE[1] else None |
| def _true_index(self): |
| total=sum(self.remaining.values()); lorentz=0. |
| for sid,v in self.remaining.items(): |
| t=self.templates[sid]; n=t['value']-.0004*(self.temperature_k-t['temperature_k']) |
| lorentz+=v/total*(n*n-1)/(n*n+2) |
| return round(math.sqrt((1+2*lorentz)/(1-lorentz))+.001*self.contamination,6) |
| def _concentration(self,n): |
| c=self.calibration |
| if self.mode!='calibrated_concentration' or not c or c['matrix_id']!=self.matrix_id or abs(c['temperature_k']-self.temperature_k)>.05: return None |
| p=c['points'] |
| if not p[0]['index']<=n<=p[-1]['index']: return None |
| for a,b in zip(p,p[1:]): |
| if a['index']<=n<=b['index']: return a['mass_fraction']+(b['mass_fraction']-a['mass_fraction'])*(n-a['index'])/(b['index']-a['index']) |
| def _check_phase(self,sid,temp): |
| row=self.templates[sid] |
| if not row['runtime_eligible']: raise _rejected('PRECONDITION_FAILED','%s has no runtime refractive-index reference'%sid) |
| if not (row.get('melting_point_k') or 0)<temp<(row.get('boiling_point_k') or 10000): raise _rejected('PRECONDITION_FAILED','%.2f K is outside the liquid range of %s'%(temp,sid)) |
| if (row.get('melting_point_k') is None or row.get('boiling_point_k') is None) and abs(temp-row['temperature_k'])>.001: raise _rejected('PRECONDITION_FAILED','the refractive-index reference of %s exists only at %.2f K'%(sid,row['temperature_k'])) |
| def _start(self,kind): |
| self._operation_count+=1; self.operation_id=f'{self.instance_id}:{kind}:{self._operation_count}' |
| self.phase='running'; self.operation=kind; self.elapsed_s=0.; self.result=None |
| return dict(phase=self.phase,operation_id=self.operation_id) |
| def invoke(self,capability,**a): |
| if capability not in CAPS: raise ActionRejected('UNKNOWN_CAPABILITY') |
| if capability in DEVICE_TUPLES or capability in ('adjustment.start','adjustment.decide'): return _ap.device_invoke(self,capability,a) |
| if capability in PANEL_CAPS: return _ap.panel_invoke(self,capability,a) |
| validate(CAPS[capability][0],a) |
| if capability=='sensor.configure_error': |
| _ap.check(CAPS[capability][0],a); self.sensor=dict(a); self.revision+=1; return dict(a) |
| if capability not in ('power.set','acquisition.stop','refractometry.measure') and self.phase=='running': raise ActionRejected('BUSY') |
| if capability=='power.set': |
| was=self.powered; self.powered=a['enabled'] |
| if not self.powered and self.phase=='running': self.phase='cancelled' |
| if self.powered!=was: self._power_cycle(self.powered) |
| r=dict(a) |
| elif capability=='thermal.set_temperature': self.target_k=a['temperature_k']; self.result=None; r=dict(a) |
| elif capability=='lid.set_angle': self.lid_angle=a['angle_rad']; r=dict(a) |
| elif capability=='method.configure': self.mode=a['mode']; self.result=None; r=dict(a) |
| elif capability=='calibration.configure': |
| p=a['points']; delta=[b['mass_fraction']-x['mass_fraction'] for x,b in zip(p,p[1:])] |
| if not a['matrix_id'].strip() or not a['source'].strip() or any(b['index']<=x['index'] for x,b in zip(p,p[1:])) or not (all(d>0 for d in delta) or all(d<0 for d in delta)): raise ActionRejected('INVALID_ARGUMENT') |
| self.calibration=copy.deepcopy(a); self.result=None; r={'configured':True} |
| elif capability=='sample.configure': |
| f=a['volume_fractions'] |
| if not f or not set(f)<=self.templates.keys() or not math.isclose(sum(f.values()),1.,abs_tol=1e-9) or not a['matrix_id'].strip() or any(x<=0 for x in f.values()): raise ActionRejected('INVALID_ARGUMENT') |
| why=('the instrument is switched off' if not self.powered else 'the lid is not open (lid.set_angle about pi/2)' if self.lid_angle<1.4 else |
| 'sample is still on the prism; clean it first' if sum(self.remaining.values())>1e-15 else 'cleaning liquid is still on the prism; finish the cleaning first' if self.cleaner_remaining_m3>1e-15 else None) |
| if why: raise _rejected('PRECONDITION_FAILED',why) |
| for sid in f: self._check_phase(sid,self.temperature_k) |
| self.remaining={sid:fraction*a['volume_m3'] for sid,fraction in f.items()} |
| for sid,v in self.remaining.items(): self.initial_species[sid]=self.initial_species.get(sid,0.)+v; self.waste_species.setdefault(sid,0.) |
| self.matrix_id=a['matrix_id']; self.contamination=a['contamination_fraction']; self.result=None |
| self.phase='idle'; self.operation='none'; self.elapsed_s=0.; r={'configured':True} |
| if self.ap['run'] is None: self.operation_id=None |
| elif capability=='acquisition.start': |
| why=('the instrument is switched off' if not self.powered else 'the lid is not closed (lid.set_angle 0)' if self.lid_angle>1e-6 else 'no sample is on the prism' if not self._values()['sample.filled'] else |
| 'the prism temperature %.3f K has not reached the set point %.3f K within 0.05 K'%(self.temperature_k,self.target_k) if abs(self.temperature_k-self.target_k)>.05 else None) |
| if why: raise _rejected('PRECONDITION_FAILED',why) |
| for sid in self.remaining: self._check_phase(sid,self.target_k) |
| n=self._index() |
| if not 1.26<=n<=1.72: raise _rejected('PRECONDITION_FAILED','the refractive index %.4f is outside the measuring range 1.26..1.72'%n) |
| if self.mode=='calibrated_concentration' and self._concentration(n) is None: |
| raise _rejected('PRECONDITION_FAILED','no concentration calibration covers this reading (calibration.configure for this matrix, at this temperature, spanning the index)') |
| self._reading_s=10.; r=self._start('measurement') |
| elif capability=='cleaning.start': |
| if not self.powered or self.lid_angle<1.4: raise _rejected('PRECONDITION_FAILED','the instrument is switched off' if not self.powered else 'the lid is not open (lid.set_angle about pi/2)') |
| self.cleaner_input_m3+=a['volume_m3']; self.cleaner_remaining_m3+=a['volume_m3']; self._clean_start_m3=self.cleaner_remaining_m3 |
| r=self._start('cleaning') |
| elif capability=='acquisition.stop': |
| if self.phase=='running': self.phase='cancelled' |
| _ap.run_cancel(self) |
| r={'phase':self.phase} |
| else: return self._measure() |
| self.revision+=1; return copy.deepcopy(r) |
| def _power_cycle(self,on): |
| """Mains switch: the instrument boots with the auto logon user, an empty sample list and the monitor mode (abm p.23, p.33, p.82).""" |
| ap=self.ap; ap['run']=None; ap['procedure']=None |
| if on: ap['power_epoch']+=1; ap['boot_s']=self.time_s; ap['last_input_s']=self.time_s; ap['user']=_ap.auto_logon_user(ap); ap['sample_list']=[]; ap['monitor']=True; ap['frozen']=None |
| def _waiting(self): |
| run=self.ap['run']; return run is not None and run['stage'] in ('equilibrating','hold','empty') |
| def _wait_left(self): |
| run=self.ap['run'] |
| if run is None or run['stage'] not in ('hold','empty'): return 1. |
| return max(run['hold_left'] if run['stage']=='hold' else run['empty_left'],1e-6) |
| def step(self,dt_s): |
| if isinstance(dt_s,bool) or not isinstance(dt_s,(int,float)) or not math.isfinite(dt_s) or dt_s<=0: raise ValueError('finite positive dt_s required') |
| left=float(dt_s) |
| while left>1e-10: |
| active=self.phase=='running' and not self._waiting(); duration=self._reading_s if self.operation=='measurement' else 30. |
| h=min(left,1.,duration-self.elapsed_s) if active else min(left,1.,self._wait_left()); done=False |
| target=self.target_k if self.powered and self.temp_control else 293.15; self.temperature_k=target+(self.temperature_k-target)*math.exp(-h/20.) |
| if active: |
| self.elapsed_s+=h |
| if self.operation=='cleaning': |
| for sid,v in self.remaining.items(): |
| transfer=v*(1-math.exp(-h/5.)); self.remaining[sid]-=transfer; self.waste_species[sid]+=transfer |
| flush=min(self.cleaner_remaining_m3,self._clean_start_m3*h/30.); self.cleaner_remaining_m3-=flush; self.cleaner_waste_m3+=flush |
| self.contamination*=math.exp(-h/8.) |
| if self.elapsed_s>=duration-1e-9: |
| self.phase='succeeded' |
| if self.operation=='cleaning': |
| for sid,v in self.remaining.items(): self.waste_species[sid]+=v |
| self.remaining={}; self.matrix_id=None; self.cleaner_waste_m3+=self.cleaner_remaining_m3; self.cleaner_remaining_m3=0. |
| else: |
| n=self._index(); conc=self._concentration(n); valid=1.26<=n<=1.72 |
| exact=len(self.remaining)==1 and self.contamination==0 and all(abs(self.temperature_k-self.templates[s]['temperature_k'])<1e-6 for s in self.remaining) |
| self.result=dict(index=n if valid else None,temperature_k=self._values()['thermal.indicated_temperature_k'],wavelength_m=589.3e-9,mass_fraction=conc, |
| phase='succeeded',quality='suspect' if not valid or self.contamination>.002 or (self.mode=='calibrated_concentration' and conc is None) else 'estimated', |
| evidence='derived' if exact else 'synthetic',concentration_evidence='user_supplied_calibration' if conc is not None else 'unavailable',template_source=TEMPLATE_REL) |
| done=True |
| self.time_s+=h; left-=h |
| if done: _ap.run_reading_done(self,_abm_reading(self)) |
| else: _ap.run_tick(self,h) |
| _ap.tick(self) |
| self.revision+=1; return self.read('evaluator') |
|
|
| class AntonpaarAbbematadvancedSession: |
| """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_antonpaar_abbematadvanced_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=getattr(exc,'detail',None) or 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) |
| self._guard(capability_id,arguments); before=h.operation_id; h._panel_session=self if capability_id in PANEL_CAPS else None |
| try: result=h.invoke(capability_id,**arguments) |
| finally: h._panel_session=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 _guard(self,capability_id,arguments): |
| """Caller rule (direct call and the command a panel gesture calls alike): no stop / next fill / power-off of another agent's run.""" |
| _ap.owner_guard(self._host,self._principal,self._role,capability_id,arguments) |
|
|
| 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_antonpaar_abbematadvanced_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'AntonpaarAbbematadvancedSession.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']) |
| for key,(inp,out,components,meaning,kind,vis,example,effects) in CAPS.items(): |
| async_=key in ('acquisition.start','cleaning.start'); pre=[] |
| conditions={ |
| 'acquisition.start':('供电、盖闭、足量液体、恒温且方法标定适用',['power.enabled','lid.angle_rad','sample.filled','thermal.target_k','cycle.phase'],'powered and closed and filled and abs(T-target)<=0.05 and no active operation; selected calibration matches matrix and temperature'), |
| 'sample.configure':('受信任宿主、盖打开且空池，模板与相态可用',['lid.angle_rad','sample.remaining_m3','cleaner.remaining_m3'],'powered and lid>=1.4 and empty and no cleaner; fractions sum to 1; verify phase before mutation'), |
| 'calibration.configure':('无操作在运行；明确体系/来源，至少两点且nD及浓度严格单调',['cycle.phase'],'not running; n strictly increasing and concentration strictly monotonic'), |
| 'cleaning.start':('供电、盖打开、没有其他运行中的过程',['power.enabled','lid.angle_rad','cycle.phase'],'powered and lid>=1.4 and not running'), |
| 'lid.set_angle':('进行中过程锁定盖',['cycle.phase'],'not running'), |
| 'thermal.set_temperature':('运行中锁定温度',['cycle.phase'],'not running'), |
| 'method.configure':('运行中锁定方法',['cycle.phase'],'not running')} |
| 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.antonpaar_abbematadvanced.AntonpaarAbbematadvancedSession.invoke',invocation=f'session.invoke(instance_id="abbemat5201_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']) |
| mechanism=dict(component_ids=['sapphire_prism','peltier','led_source','interference_filter','detector','sample_well'], |
| state_ids=['thermal.temperature_k','optical.indicated_index','sample.remaining_m3','sample.input_m3','sample.waste_m3'], |
| meaning_zh='文献单点nD、Lorentz–Lorenz理想混合、温度/污染工程代理；参考体积账本守恒',implementation='lumped', |
| equations=['T_next=T_target+(T-T_target)*exp(-dt/20)', |
| 'n_i(T)=n_ref_i-0.0004*(T-T_ref_i); L=sum(phi_i*(n_i^2-1)/(n_i^2+2)); n=sqrt((1+2L)/(1-L))+0.001*contamination', |
| 'concentration=piecewise_linear_calibration(n) only for matching matrix and temperature; never universal Brix', |
| 'input_reference_volume_i=remaining_reference_volume_i+waste_reference_volume_i'], |
| parameters={'dn_dt':dict(value=-.0004,unit='1/K',meaning_zh='未取得实测系数的统一热光代理',evidence='assumption',source_ids=['simulation_assumption'],uncertainty=None)}, |
| source_ids=['refractive_templates','simulation_assumption'],limitations=['温度系数、混合、污染响应均未标定；未重建光线追迹/临界角成像。','无样品密度时不宣称质量守恒；本过程守恒各物质在装样参考温度定义的体积账本。','用户标定曲线仅做数学插值，实验有效性需用户证据；不外推。']) |
| for key,slot in slots.items(): |
| if key.endswith('_m3'): slot['meaning_zh']=(slot['meaning_zh'] or '')+'；装样参考温度下体积账本，不是真实膨胀后的几何体积' |
| _ann.annotate_export('antonpaar_abbematadvanced',caps,slots,{'refractometry':mechanism},inputs={}) |
| return dict(asset_type_id=ASSET_TYPE_ID,catalog_id=CATALOG_ID,capabilities=caps,state_slots=slots,mechanisms={'refractometry':mechanism}) |
|
|
