scripts/asset_runtime/antonpaar_trb.py

"""CHEM128 finite-source tribology, exact path work and differential sensing."""
from pathlib import Path
import copy,json,math,importlib.util
import numpy as np
PROTOCOL_VERSION='1.0.0';SLUG='antonpaar_trb';CATALOG_ID='CHEM-128';ASSET_TYPE_ID='instrument.'+SLUG
ROOT=Path(__file__).resolve().parents[2];ASSET=ROOT/'assets/expansion_batch04/t1_thermal'/SLUG
DT=.1;G=9.80665;OMEGA_MIN=.2*2*math.pi/60;OMEGA_MAX=2000*2*math.pi/60;TORQUE_MAX=.45;FRICTION_MAX=20.
class ActionRejected(ValueError):pass
def number(unit='1',lo=None,hi=None):
 s={'type':'number','x-unit':unit}
 if lo is not None:s['minimum']=lo
 if hi is not None:s['maximum']=hi
 return s
def integer(lo=0,hi=1000000):return dict(type='integer',minimum=lo,maximum=hi,**{'x-unit':'1'})
def obj(properties):return dict(type='object',properties=properties,required=list(properties),additionalProperties=False)
def array(items,minimum=0,maximum=10000):return dict(type='array',items=items,minItems=minimum,maxItems=maximum)
def enum(items):return dict(type='string',enum=list(items))
def nullable(s):return {'anyOf':[s,{'type':'null'}]}
BOOL={'type':'boolean'};TEXT={'type':'string'};PHASE=enum(['idle','running','succeeded','failed','cancelled'])
def validate(s,v):
 if 'anyOf' in s:
  for option in s['anyOf']:
   try:validate(option,v);return
   except ActionRejected:pass
  raise ActionRejected('INVALID_ARGUMENT')
 kind=s.get('type')
 if kind in ('number','integer'):
  if isinstance(v,bool) or not isinstance(v,(int,float)) or not math.isfinite(v) or kind=='integer' and type(v) is not int or not s.get('minimum',-math.inf)<=v<=s.get('maximum',math.inf):raise ActionRejected('INVALID_ARGUMENT')
 elif kind=='boolean' and type(v) is not bool:raise ActionRejected('INVALID_ARGUMENT')
 elif kind=='string' and not isinstance(v,str):raise ActionRejected('INVALID_ARGUMENT')
 elif kind=='null' and v is not None:raise ActionRejected('INVALID_ARGUMENT')
 elif kind=='object':
  if not isinstance(v,dict) or set(v)!=set(s['properties']):raise ActionRejected('INVALID_ARGUMENT')
  for key,value in v.items():validate(s['properties'][key],value)
 elif kind=='array':
  if not isinstance(v,list) or not s.get('minItems',0)<=len(v)<=s.get('maxItems',math.inf):raise ActionRejected('INVALID_ARGUMENT')
  for value in v:validate(s['items'],value)
 if 'enum' in s and v not in s['enum']:raise ActionRejected('INVALID_ARGUMENT')
def library():
 p=ASSET/'tribology_library.json';return json.loads(p.read_text()) if p.exists() else {'substances':{}}

def sine_variation(phase):
 """Exact integral0..phase |cos(u)|du for phase>=0, including arbitrary reversals."""
 n=math.floor(phase/math.pi);r=phase-n*math.pi;return 2*n+(math.sin(r) if r<=math.pi/2 else 2-math.sin(r))
def motion(drive,radius,t):
 mode=drive['mode']
 if mode=='rotary':return dict(angle_rad=drive['angular_speed_rad_s']*t,position_m=0.,signed_speed_m_s=radius*drive['angular_speed_rad_s'],distance_m=radius*drive['angular_speed_rad_s']*t)
 phase=2*math.pi*drive['frequency_hz']*t
 if mode=='linear':amplitude=drive['stroke_m']/2;return dict(angle_rad=0.,position_m=amplitude*math.sin(phase),signed_speed_m_s=amplitude*2*math.pi*drive['frequency_hz']*math.cos(phase),distance_m=amplitude*sine_variation(phase))
 amplitude=drive['angular_amplitude_rad'];return dict(angle_rad=amplitude*math.sin(phase),position_m=0.,signed_speed_m_s=radius*amplitude*2*math.pi*drive['frequency_hz']*math.cos(phase),distance_m=radius*amplitude*sine_variation(phase))

SCALAR_BASIS='scalar_mean_friction';SPEED_BASIS='scalar_speed_series_friction';SCALAR_BASES=(SCALAR_BASIS,SPEED_BASIS)
UNBOUNDED_DOMAIN_M=1e9
SCALAR_EVIDENCE='Published scalar friction coefficient of this material pair (mean as defined by the source: steady-state or test-duration average; speed-series values interpolated in log(speed) between source speeds) replayed as a CONSTANT mu over the source sliding-distance domain. No running-in transient, stick-slip, fluctuation or wear-driven drift is represented; this is not a measured friction curve. Source specific wear rates (if any) are reference data only; wear uses the declared Archard inputs.'
def scalar_curve(reference,speed_m_s=None,accept_unknown=True,accept_transfer=True):
 """Constant-mu reference from a published scalar; returns (x,mu,info)."""
 try:rs=reference['runtime_scalars']
 except (KeyError,TypeError):raise ActionRejected('INVALID_REFERENCE')
 if not reference.get('runtime_usable') or reference.get('runtime_basis') not in SCALAR_BASES or not isinstance(rs,dict):raise ActionRejected('INVALID_REFERENCE')
 domain=rs.get('sliding_distance_domain_m');info=dict(basis=reference['runtime_basis'],domain_known=domain is not None,speed_clamped=False)
 if domain is None:
  if not accept_unknown:raise ActionRejected('UNKNOWN_REFERENCE_CONDITIONS')
  domain=UNBOUNDED_DOMAIN_M
 if isinstance(domain,bool) or not isinstance(domain,(int,float)) or not math.isfinite(domain) or domain<=0:raise ActionRejected('INVALID_REFERENCE')
 if reference['runtime_basis']==SCALAR_BASIS:mu=rs.get('friction_coefficient')
 else:
  try:v=np.asarray(rs['speeds_m_s'],float);m=np.asarray(rs['friction_coefficients'],float)
  except (KeyError,TypeError,ValueError):raise ActionRejected('INVALID_REFERENCE')
  if v.ndim!=1 or v.shape!=m.shape or len(v)<2 or np.any(~np.isfinite(v)) or np.any(v<=0) or np.any(np.diff(v)<=0) or np.any(~np.isfinite(m)):raise ActionRejected('INVALID_REFERENCE')
  s=float(v[0]) if speed_m_s is None else float(speed_m_s)
  if s<=0:raise ActionRejected('REFERENCE_CONDITIONS')
  if not v[0]*(1-1e-9)<=s<=v[-1]*(1+1e-9):
   if not accept_transfer:raise ActionRejected('REFERENCE_CONDITIONS')
   info['speed_clamped']=True
  s=min(max(s,float(v[0])),float(v[-1]));mu=float(np.interp(math.log(s),np.log(v),m));info['speed_m_s']=s
 if isinstance(mu,bool) or not isinstance(mu,(int,float)) or not math.isfinite(mu) or not 0<=mu<=2:raise ActionRejected('INVALID_REFERENCE')
 info['friction_coefficient']=float(mu)
 return np.array([0.,float(domain)]),np.array([float(mu),float(mu)]),info
def curve(reference,accept_unknown=True):
 if isinstance(reference,dict) and reference.get('runtime_basis') in SCALAR_BASES:
  x,mu,_=scalar_curve(reference,None,accept_unknown,True);return x,mu
 try:x=np.asarray(reference['values']['sliding_distance_m'],float);mu=np.asarray(reference['values']['friction_coefficient'],float)
 except (KeyError,TypeError,ValueError):raise ActionRejected('INVALID_REFERENCE')
 if not reference.get('runtime_usable') or len(x)<2 or x.shape!=mu.shape or np.any(~np.isfinite(x)) or np.any(~np.isfinite(mu)) or np.any(np.diff(x)<=0) or x[0]<0 or np.any(mu<0):raise ActionRejected('INVALID_REFERENCE')
 return x,mu

def source_mu(reference,distance_m):
 x,mu=curve(reference)
 if distance_m<x[0]-1e-12 or distance_m>x[-1]+1e-12:raise ActionRejected('REFERENCE_DISTANCE_RANGE')
 return float(np.interp(distance_m,x,mu))
def source_integral(reference,start_m,end_m):
 x,mu=curve(reference)
 if start_m<x[0]-1e-12 or end_m>x[-1]+1e-12 or end_m<start_m:raise ActionRejected('REFERENCE_DISTANCE_RANGE')
 grid=np.r_[start_m,x[(x>start_m)&(x<end_m)],end_m];return float(np.trapz(np.interp(grid,x,mu),grid))

PLANT_EXAMPLE=dict(accept_engineering=True,ambient_k=296.15,relative_humidity=.5,humidity_offset=0.,thermal_capacity_j_k=100.,heat_loss_w_k=1.,heater_installed=False,heater_max_w=0.,heater_gain_w_k=10.,safe_access_temperature_k=313.15,temperature_max_k=373.15,stage_mass_kg=.2,rotational_inertia_kg_m2=.0001,linear_drive_limit_n=100.,normal_force_factor=1.,normal_read_gain=1.,normal_read_offset_n=0.,friction_gain_left=1.,friction_gain_right=1.,friction_offset_left_n=0.,friction_offset_right_n=0.,common_drift_n_s=0.,thermal_common_drift_n_k=0.,force_sensor_tau_s=.002,minimum_observable_load_n=.05,wear_sensor_enabled=False,wear_gain=1.,wear_offset_m=0.,temperature_sensor_offset_k=0.)
PLANT=obj({'accept_engineering':BOOL,'ambient_k':number('K',273.15,323.15),'relative_humidity':number('1',0,1),'humidity_offset':number('1',-.5,.5),'thermal_capacity_j_k':number('J/K',.01,1e6),'heat_loss_w_k':number('W/K',0,1000),'heater_installed':BOOL,'heater_max_w':number('W',0,10000),'heater_gain_w_k':number('W/K',.001,1e6),'safe_access_temperature_k':number('K',273.15,373.15),'temperature_max_k':number('K',273.15,723.15),'stage_mass_kg':number('kg',.001,100),'rotational_inertia_kg_m2':number('kg*m^2',1e-8,10),'linear_drive_limit_n':number('N',.001,1e5),'normal_force_factor':number('1',.1,2),'normal_read_gain':number('1',.1,2),'normal_read_offset_n':number('N',-5,5),'friction_gain_left':number('1',.01,100),'friction_gain_right':number('1',.01,100),'friction_offset_left_n':number('N',-20,20),'friction_offset_right_n':number('N',-20,20),'common_drift_n_s':number('N/s',-1,1),'thermal_common_drift_n_k':number('N/K',-1,1),'force_sensor_tau_s':number('s',1e-5,100),'minimum_observable_load_n':number('N',1e-6,1),'wear_sensor_enabled':BOOL,'wear_gain':number('1',.01,100),'wear_offset_m':number('m',-.002,.002),'temperature_sensor_offset_k':number('K',-20,20)})
SAMPLE_EXAMPLE=dict(reference_id='cr100_leadbronze_dry_003',volume_m3=1e-6,density_kg_m3=7800.,hardness_pa=2e9,archard_coefficient=1e-5,wear_track_area_m2=1e-4,accept_engineering=True,accept_unknown_conditions=True,accept_condition_transfer=True)
SAMPLE=obj({'reference_id':TEXT,'volume_m3':number('m^3',1e-15,.001),'density_kg_m3':number('kg/m^3',100,25000),'hardness_pa':number('Pa',1e3,1e12),'archard_coefficient':number('1',0,1),'wear_track_area_m2':number('m^2',1e-12,.01),'accept_engineering':BOOL,'accept_unknown_conditions':BOOL,'accept_condition_transfer':BOOL})
PIN_EXAMPLE=dict(volume_m3=1e-8,density_kg_m3=7800.,hardness_pa=4e9,archard_coefficient=1e-6,radius_m=.00476,accept_engineering=True)
PIN=obj({'volume_m3':number('m^3',1e-15,.0001),'density_kg_m3':number('kg/m^3',100,25000),'hardness_pa':number('Pa',1e3,1e12),'archard_coefficient':number('1',0,1),'radius_m':number('m',.0001,.01),'accept_engineering':BOOL})
LUBRICANT_EXAMPLE=dict(identity='engineering_oil',volume_m3=1e-6,density_kg_m3=850.,loss_per_distance_m2=1e-9,accept_engineering=True)
LUBRICANT=obj({'identity':TEXT,'volume_m3':number('m^3',1e-15,1e-4),'density_kg_m3':number('kg/m^3',100,3000),'loss_per_distance_m2':number('m^2',0,1e-3),'accept_engineering':BOOL})
DRIVE_EXAMPLE=dict(mode='rotary',angular_speed_rad_s=10.,frequency_hz=1.,stroke_m=.01,angular_amplitude_rad=math.pi/6)
DRIVE=obj({'mode':enum(['rotary','linear','angular']),'angular_speed_rad_s':number('rad/s',OMEGA_MIN,OMEGA_MAX),'frequency_hz':number('Hz',.01,10),'stroke_m':number('m',.00001,.06),'angular_amplitude_rad':number('rad',math.pi/36,5*math.pi/6)})
METHOD_EXAMPLE=dict(duration_s=20.,sample_interval_s=.1,stop_distance_m=100.,source_start_distance_m=0.,temperature_tolerance_k=1.)
METHOD=obj({'duration_s':number('s',.1,3600),'sample_interval_s':number('s',.1,60),'stop_distance_m':number('m',1e-9,1e6),'source_start_distance_m':number('m',0,1e9),'temperature_tolerance_k':number('K',.01,50)})
CALIBRATION=obj({'friction_gain_correction':number('1',.001,1000),'friction_zero_n':number('N',-20,20),'normal_gain_correction':number('1',.001,1000),'normal_zero_n':number('N',-5,5),'wear_zero_m':number('m',-.002,.002),'temperature_zero_k':number('K',-20,20)})
ROW=obj({'time_s':number('s'),'elapsed_s':number('s'),'sliding_distance_m':number('m',0),'signed_speed_m_s':number('m/s'),'disk_angle_rad':number('rad'),'linear_position_m':number('m'),'normal_force_n':nullable(number('N')),'friction_force_n':nullable(number('N')),'friction_coefficient':nullable(number('1')),'sensor_left_n':nullable(number('N')),'sensor_right_n':nullable(number('N')),'wear_depth_m':nullable(number('m')),'temperature_k':nullable(number('K')),'cumulative_observed_work_j':number('J'),'unavailable_reason':nullable(TEXT)})
RESULT=obj({'operation_id':nullable(TEXT),'phase':PHASE,'elapsed_s':number('s'),'rows':array(ROW,0,40000),'sliding_distance_m':number('m',0),'observed_work_j':number('J'),'reference_id':nullable(TEXT),'template_source':nullable(TEXT),'method_json':nullable(TEXT),'evidence':TEXT,'error_code':nullable(TEXT)})
CAPS={};SLOTS={}
def cap(k,i,o,c,z,kind='device_command',visibility='agent',example=None,effects=None):CAPS[k]=dict(input_schema=i,output_schema=o,component_ids=c,function_zh=z,kind=kind,visibility=visibility,example_arguments=example or {},effects=effects or [])
def slot(k,s,u,z,origin='derived',visibility='agent',component='controller'):SLOTS[k]=dict(schema=s,unit=u,meaning=z,origin=origin,visibility=visibility,component=component,write=None)
cap('plant.configure',PLANT,obj({'configured':BOOL}),['controller'],'显式工程热/惯量/差分观测参数','configuration','evaluator',PLANT_EXAMPLE)
for k,sc,ex,c in [('specimen',SAMPLE,SAMPLE_EXAMPLE,'specimen'),('pin',PIN,PIN_EXAMPLE,'pin'),('lubricant',LUBRICANT,LUBRICANT_EXAMPLE,'sample_holder')]:
 cap(k+'.load',sc,obj({'loaded':BOOL}),[c],'装入有限'+k,'configuration','evaluator',ex);cap(k+'.remove',obj({}),obj({'removed':BOOL}),[c],'停机抬臂后回收'+k,'configuration','evaluator')
cap('power.set',obj({'enabled':BOOL}),obj({'enabled':BOOL}),['controller','power_switch'],'供电；实际运动与热由宿主step推进',example={'enabled':True})
cap('normal_load.set',obj({'force_n':number('N',0,60)}),obj({'force_n':number('N',0,60)}),['deadweight','lever_arm'],'抬臂静止时更换死重；非主动载荷伺服',example={'force_n':5.})
cap('radius.set',obj({'radius_m':number('m',0,.04)}),obj({'radius_m':number('m',0,.04)}),['pin_holder'],'抬臂停机手动设轨道半径',example={'radius_m':.01})
cap('drive.configure',DRIVE,DRIVE,['disk','linear_stage'],'选择互斥旋转/线性/角往复工程波形','configuration',example=DRIVE_EXAMPLE)
cap('motion.home',obj({}),obj({'homing':BOOL}),['disk','linear_stage'],'抬臂后以工程低速真实回中，非瞬移')
cap('contact.set',obj({'engaged':BOOL}),obj({'engaged':BOOL}),['lever_arm','pin'],'停机手动抬起或放下测量臂',example={'engaged':True})
cap('thermal.set_temperature',obj({'temperature_k':number('K',273.15,723.15)}),obj({'temperature_k':number('K',273.15,723.15)}),['sample_holder'],'可选工程加热模块目标；未装不能加热',example={'temperature_k':298.15})
cap('sensor.calibrate',CALIBRATION,CALIBRATION,['friction_sensor_left','friction_sensor_right'],'外部标定常数，不能免费读取真值','configuration',example={'friction_gain_correction':1.,'friction_zero_n':0.,'normal_gain_correction':1.,'normal_zero_n':0.,'wear_zero_m':0.,'temperature_zero_k':0.})
cap('sensor.zero',obj({}),obj({'zeroed':BOOL}),['friction_sensor_left','friction_sensor_right'],'抬臂静止无接触的差分零点')
cap('method.configure',METHOD,METHOD,['controller'],'设置有限时间/距离和原曲线起点','configuration',example=METHOD_EXAMPLE)
cap('acquisition.start',obj({}),obj({'operation_id':TEXT}),['controller','disk','linear_stage','friction_sensor_left','friction_sensor_right'],'异步三模式试验；精确运动距离/模板摩擦功积分')
cap('acquisition.stop',obj({}),obj({'phase':enum(['cancelled'])}),['controller','disk','linear_stage'],'取消保留真实磨耗/碎屑/温度与部分曲线')
cap('acquisition.result',obj({}),RESULT,['controller'],'纯读冻结历史，不返回真实摩擦系数或库存','query')
cap('reference.query',obj({'reference_id':TEXT}),obj({'reference_json':TEXT,'template_source':TEXT,'evidence':TEXT}),['controller'],'原始成对材料曲线与来源工况','query',example={'reference_id':SAMPLE_EXAMPLE['reference_id']})
cap('lid.set',obj({'opened':BOOL}),obj({'opened':BOOL}),['lid'],'停机透明安全罩',example={'opened':True})
cap('emergency.stop',obj({}),obj({'latched':BOOL}),['estop'],'本地工程安全锁存停止，非厂家认证急停；保留实际温度和磨耗')
cap('emergency.reset',obj({}),obj({'latched':BOOL}),['estop'],'停机后明确复位，不自动续行')
PROFILE=obj({'x_m':array(number('m'),3,10000),'height_m':array(number('m'),3,10000),'baseline_m':array(number('m'),3,10000),'geometry':enum(['linear','circular']),'track_length_m':number('m',1e-6,10),'radius_m':number('m',0,.04),'accept_uniform_profile':BOOL})
cap('analysis.wear_profile',PROFILE,obj({'loss_volume_m3':number('m^3',0),'pileup_volume_m3':number('m^3',0),'net_volume_m3':number('m^3'),'evidence':TEXT}),['controller'],'独立外部截面基线：损失、堆积、带符号净量分别积分','analysis',example={'x_m':[-.001,0.,.001],'height_m':[0.,-.0001,0.],'baseline_m':[0.,0.,0.],'geometry':'circular','track_length_m':.01,'radius_m':.01,'accept_uniform_profile':True})
HERTZ=obj({'normal_force_n':number('N',1e-6,60),'radius_m':number('m',1e-5,.1),'young_sample_pa':number('Pa',1e5,1e12),'poisson_sample':number('1',-.9,.49),'young_pin_pa':number('Pa',1e5,1e12),'poisson_pin':number('1',-.9,.49),'accept_elastic_homogeneous':BOOL})
cap('analysis.hertz',HERTZ,obj({'effective_modulus_pa':number('Pa'),'contact_radius_m':number('m'),'indentation_m':number('m'),'peak_pressure_pa':number('Pa'),'evidence':TEXT}),['controller'],'小接触、均匀弹性无黏附Hertz分析，不冒充涂层/塑性解','analysis',example={'normal_force_n':5.,'radius_m':.00476,'young_sample_pa':1e11,'poisson_sample':.3,'young_pin_pa':2e11,'poisson_pin':.3,'accept_elastic_homogeneous':True})
LEDGER=obj({k:number(u) for k,u in [('specimen_loaded_kg','kg'),('specimen_remaining_kg','kg'),('specimen_debris_kg','kg'),('specimen_recovered_kg','kg'),('specimen_debris_recovered_kg','kg'),('specimen_error_kg','kg'),('pin_loaded_kg','kg'),('pin_remaining_kg','kg'),('pin_debris_kg','kg'),('pin_recovered_kg','kg'),('pin_debris_recovered_kg','kg'),('pin_error_kg','kg'),('lubricant_loaded_kg','kg'),('lubricant_remaining_kg','kg'),('lubricant_dragout_kg','kg'),('lubricant_recovered_kg','kg'),('lubricant_error_kg','kg'),('friction_input_j','J'),('heater_input_j','J'),('ambient_loss_j','J'),('stored_thermal_energy_j','J'),('thermal_error_j','J'),('specimen_wear_volume_m3','m^3'),('pin_wear_volume_m3','m^3')]})
cap('debris.collect',obj({}),obj({'collected':BOOL}),['sample_holder'],'开罩抬臂后回收有限双方磨屑','configuration','evaluator')
cap('ledger.read',obj({}),LEDGER,['controller'],'双方试片/销→磨屑、润滑剂与摩擦功/热账本','query','evaluator')
cap('sim.step',obj({'dt_s':number('s',0,3600)}),obj({'time_s':number('s')}),['controller'],'唯一宿主时钟，固定0.1秒含转向/观测内部细分','simulation','evaluator',{'dt_s':.1})
UNSUPPORTED=['wear.atomic_morphology','friction.molecular_dynamics','hardware.connect','robot.sample_change','noise.empirical','accuracy.certification','humidity.control','vacuum.control','electrical_contact_resistance.measure','astm.certification']
for k in UNSUPPORTED:cap(k,obj({}),obj({}),['controller'],'未实现：'+k)
for k,z,c in [('plant.configured','显式工程参数已接受','controller'),('power.enabled','供电','controller'),('lid.open','透明罩开启','lid'),('emergency.latched','急停锁存','estop'),('contact.engaged','死重臂接触样片','lever_arm'),('specimen.present','有限试片存在','specimen'),('pin.present','有限销/球存在','pin'),('lubricant.present','润滑剂已加载','sample_holder'),('motion.homing','抬臂低速回中中','disk')]:slot(k,BOOL,'1',z,component=c)
for k,lo,hi,u,z,c in [('disk.angle_rad',-math.pi,math.pi,'rad','转盘实际工程姿态，显示取模不影响真实累计距离','disk'),('linear.position_m',-.03,.03,'m','独立线性附件实际位置，主旋转几何不声称此变体','linear_stage'),('radius.position_m',0.,.04,'m','手动轨道半径','radius_carriage'),('arm.angle_rad',0,.22,'rad','手动接触臂铰接0接触/.22抬起','lever_arm'),('lid.angle_rad',0,1.55,'rad','透明罩手动铰接','lid'),('power.angle_rad',0,.28,'rad','电源工程姿态','power_switch'),('estop.press_m',0,.003,'m','照片红按钮的本地工程安全锁存姿态，厂家功能未确证','estop')]:slot(k,number(u,lo,hi),u,z,'scene',component=c)
slot('drive.mode',enum(['rotary','linear','angular']),'1','互斥运动配置','setpoint',component='disk');slot('normal.setting_n',number('N',0,60),'N','人工死重名义载荷','setpoint',component='deadweight');slot('thermal.target_k',number('K',273.15,723.15),'K','可选工程加热目标','setpoint',component='sample_holder')
for k,u,z,c in [('normal.indicated_n','N','名义死重独立观测校准，不是主动伺服真值','deadweight'),('friction.indicated_n','N','双传感器差分校正摩擦力，反转/过载不可用','friction_sensor_left'),('friction.coefficient','1','观测摩擦力幅值除观测载荷；低载不可用','controller'),('friction.left_n','N','左侧力传感器工程读数','friction_sensor_left'),('friction.right_n','N','右侧力传感器工程读数','friction_sensor_right'),('wear.indicated_m','m','可选在线位移观测代理，非来源实测磨损','sample_holder'),('thermal.indicated_k','K','独立校准温度显示','sample_holder')]:slot(k,nullable(number(u)),u,z,component=c)
slot('motion.signed_speed_m_s',number('m/s'),'m/s','规定波形瞬时带符号滑动速度，反转时为零',component='disk');slot('motion.distance_m',number('m',0),'m','实际累计路径积分，不能由姿态差替代',component='disk');slot('friction.unavailable_reason',nullable(TEXT),'1','低载/反转/传感器量程不可用原因')
for k,u,z in [('truth.normal_force_n','N','接触实际法向死重力'),('truth.friction_coefficient','1','经验源曲线代理摩擦响应'),('truth.specimen_volume_m3','m^3','有限试片剩余体积'),('truth.pin_volume_m3','m^3','有限销剩余体积'),('truth.debris_kg','kg','磨屑质量'),('truth.lubricant_volume_m3','m^3','有限润滑剂剩余量'),('truth.temperature_k','K','集中热容实际温度'),('truth.friction_work_j','J','经验曲线沿真实滑程的摩擦耗散')]:slot(k,number(u,0),u,z,'process_truth','evaluator')
slot('clock.time_s',number('s',0),'s','宿主时钟');slot('acquisition.phase',PHASE,'1','异步终态');slot('acquisition.elapsed_s',number('s',0),'s','实际试验经过时间');slot('acquisition.points',integer(),'1','已采集曲线点')

def profile_analysis(a):
 x=np.array(a['x_m']);h=np.array(a['height_m']);base=np.array(a['baseline_m'])
 if not a['accept_uniform_profile']:raise ActionRejected('MODEL_NOT_ACCEPTED')
 if x.shape!=h.shape or x.shape!=base.shape or np.any(np.diff(x)<=0):raise ActionRejected('PROFILE_GRID')
 if a['geometry']=='circular' and np.any(a['radius_m']+x<=0):raise ActionRejected('PROFILE_RADIUS')
 loss=pile=0.
 for i in range(len(x)-1):
  x0,x1=x[i:i+2];d0,d1=(base-h)[i:i+2];cuts=[0.,1.]
  if d0*d1<0:cuts.insert(1,float(-d0/(d1-d0)))
  for t0,t1 in zip(cuts,cuts[1:]):
   # Exact product of linear deficit and linear ring circumference on each signed piece.
   dd=d1-d0;dx=x1-x0
   if a['geometry']=='linear':v=dx*a['track_length_m']*(d0*(t1-t0)+dd*(t1*t1-t0*t0)/2)
   else:
    r0=a['radius_m']+x0;v=2*math.pi*dx*(d0*r0*(t1-t0)+(d0*dx+dd*r0)*(t1*t1-t0*t0)/2+dd*dx*(t1**3-t0**3)/3)
   if v>=0:loss+=v
   else:pile-=v
 return dict(loss_volume_m3=float(loss),pileup_volume_m3=float(pile),net_volume_m3=float(loss-pile),evidence='External user-supplied profile inputs and explicit uniform-track assumption. Baseline must be independently supplied; deficit and pile-up are integrated separately with exact zero crossings. Circular volume retains radial2pi(r+x) weight. Net signed volume can be negative; no automatic claim of true material loss.')
def hertz_analysis(a):
 if not a['accept_elastic_homogeneous']:raise ActionRejected('MODEL_NOT_ACCEPTED')
 e=1/((1-a['poisson_sample']**2)/a['young_sample_pa']+(1-a['poisson_pin']**2)/a['young_pin_pa']);r=(3*a['normal_force_n']*a['radius_m']/(4*e))**(1/3)
 if r/a['radius_m']>.1:raise ActionRejected('HERTZ_MODEL_DOMAIN')
 return dict(effective_modulus_pa=e,contact_radius_m=r,indentation_m=r*r/a['radius_m'],peak_pressure_pa=3*a['normal_force_n']/(2*math.pi*r*r),evidence='Homogeneous nonadhesive elastic sphere-flat Hertz approximation; not a layered coating, plasticity or roughness solution.')

class AntonpaarTrbRuntime:
 def __init__(self,instance_id='trb_01'):
  self.instance_id=instance_id;self.plant=None;self.specimen=None;self.pin=None;self.lubricant=None;self.reference=None;self.ref_x=np.array([]);self.ref_mu=np.array([]);self.specimen_volume=0.;self.pin_volume=0.;self.lubricant_volume=0.;self.specimen_loaded=0.;self.pin_loaded=0.;self.lubricant_loaded=0.;self.specimen_recovered=0.;self.pin_recovered=0.;self.lubricant_recovered=0.;self.specimen_debris=0.;self.pin_debris=0.;self.specimen_debris_recovered=0.;self.pin_debris_recovered=0.;self.lubricant_dragout=0.;self.specimen_wear=0.;self.pin_wear=0.;self.sample_distance=0.;self.source_origin=None;self.power=False;self.lid_open=True;self.contact=False;self.emergency=False;self.homing=False;self.radius=.01;self.normal_setting=0.;self.disk_angle=0.;self.linear_position=0.;self.signed_speed=0.;self.temperature=296.15;self.initial_temperature=296.15;self.temperature_target=296.15;self.heater_energy=0.;self.friction_energy=0.;self.ambient_loss=0.;self.left=0.;self.right=0.;self.calibration=copy.deepcopy(CAPS['sensor.calibrate']['example_arguments']);self.drive=copy.deepcopy(DRIVE_EXAMPLE);self.method=copy.deepcopy(METHOD_EXAMPLE);self.phase='idle';self.elapsed=0.;self.rows=[];self.observed_work=0.;self.operation_distance=0.;self.operation_start=0.;self.operation_id=None;self.angle_base=0.;self.source=None;self.result_reference=None;self.operation_method=None;self.result_evidence=None;self.error=None;self._counter=0;self.records={};self.time_s=0.;self._ticks=0;self._remainder=0.;self.revision=0;self._requests={};self._cancel_operations={};self._owners={};self._principals={'agent':'agent','evaluator':'evaluator'};self.scalar_info=None
 def register_principal(self,principal_id,visibility='agent'):
  if not isinstance(principal_id,str) or not principal_id or principal_id in self._principals or visibility not in ('agent','debug','evaluator'):raise ActionRejected('REQUEST_CONFLICT')
  self._principals[principal_id]=visibility
 def session(self,principal_id='agent'):
  if principal_id not in self._principals:raise ActionRejected('ACCESS_DENIED')
  return AntonpaarTrbSession(self,principal_id)
 def describe(self):return export_antonpaar_trb_contract_metadata()
 def _normal_true(self):return self.normal_setting*self.plant['normal_force_factor'] if self.contact and self.plant else 0.
 def _normal_observed(self):
  if not self.power or not self.contact:return None
  return (self.normal_setting*self.plant['normal_read_gain']+self.plant['normal_read_offset_n']-self.calibration['normal_zero_n'])/self.calibration['normal_gain_correction']
 def _coordinate(self):return (self.source_origin if self.source_origin is not None else self.ref_x[0] if len(self.ref_x) else 0.)+self.sample_distance
 def _mu(self):return float(np.interp(self._coordinate(),self.ref_x,self.ref_mu)) if len(self.ref_x) else 0.
 def _sensing(self):
  if not self.power:return None,None,'POWER_OFF'
  if not self.contact or self.phase!='running':return None,None,'NO_SLIDING_CONTACT'
  f=(self.left-self.right-self.calibration['friction_zero_n'])/self.calibration['friction_gain_correction'];n=self._normal_observed()
  if abs(f)>FRICTION_MAX:return None,None,'FRICTION_SENSOR_OVER_RANGE'
  if abs(self.signed_speed)<1e-10:return None,None,'REVERSAL_ZERO_SPEED'
  if n is None or n<self.plant['minimum_observable_load_n']:return f,None,'LOW_LOAD'
  return f,abs(f)/n,None
 def _wear_read(self):
  if not self.plant or not self.plant['wear_sensor_enabled'] or not self.specimen or not self.power:return None
  value=self.specimen_wear/self.specimen['wear_track_area_m2']*self.plant['wear_gain']+self.plant['wear_offset_m']-self.calibration['wear_zero_m'];return value if -.002<=value<=.002 else None
 def read(self,role='evaluator'):
  f,mu,reason=self._sensing();d={'plant.configured':self.plant is not None,'power.enabled':self.power,'lid.open':self.lid_open,'emergency.latched':self.emergency,'contact.engaged':self.contact,'specimen.present':self.specimen is not None,'pin.present':self.pin is not None,'lubricant.present':self.lubricant is not None,'motion.homing':self.homing,'disk.angle_rad':self.disk_angle,'linear.position_m':self.linear_position,'radius.position_m':self.radius,'arm.angle_rad':0. if self.contact else .22,'lid.angle_rad':1.55 if self.lid_open else 0.,'power.angle_rad':.28 if self.power else 0.,'estop.press_m':.003 if self.emergency else 0.,'drive.mode':self.drive['mode'],'normal.setting_n':self.normal_setting,'thermal.target_k':self.temperature_target,'normal.indicated_n':self._normal_observed(),'friction.indicated_n':f,'friction.coefficient':mu,'friction.left_n':self.left if self.power else None,'friction.right_n':self.right if self.power else None,'wear.indicated_m':self._wear_read(),'thermal.indicated_k':self.temperature+self.plant['temperature_sensor_offset_k']-self.calibration['temperature_zero_k'] if self.power else None,'environment.relative_humidity':max(0.,min(1.,self.plant['relative_humidity']+self.plant['humidity_offset'])) if self.power else None,'motion.signed_speed_m_s':self.signed_speed,'motion.distance_m':self.operation_distance,'friction.unavailable_reason':reason,'truth.normal_force_n':self._normal_true(),'truth.friction_coefficient':self._mu(),'truth.specimen_volume_m3':self.specimen_volume,'truth.pin_volume_m3':self.pin_volume,'truth.debris_kg':self.specimen_debris+self.pin_debris,'truth.lubricant_volume_m3':self.lubricant_volume,'truth.temperature_k':self.temperature,'truth.friction_work_j':self.friction_energy,'clock.time_s':self.time_s,'acquisition.phase':self.phase,'acquisition.elapsed_s':self.elapsed,'acquisition.points':len(self.rows)}
  return copy.deepcopy({k:v for k,v in d.items() if role in ('evaluator','debug') or SLOTS[k]['visibility']=='agent'})
 def _ledger(self):
  s=self.specimen_volume*self.specimen['density_kg_m3'] if self.specimen else 0.;p=self.pin_volume*self.pin['density_kg_m3'] if self.pin else 0.;l=self.lubricant_volume*self.lubricant['density_kg_m3'] if self.lubricant else 0.;stored=self.plant['thermal_capacity_j_k']*(self.temperature-self.initial_temperature) if self.plant else 0.
  return dict(specimen_loaded_kg=self.specimen_loaded,specimen_remaining_kg=s,specimen_debris_kg=self.specimen_debris,specimen_recovered_kg=self.specimen_recovered,specimen_debris_recovered_kg=self.specimen_debris_recovered,specimen_error_kg=self.specimen_loaded-s-self.specimen_debris-self.specimen_recovered-self.specimen_debris_recovered,pin_loaded_kg=self.pin_loaded,pin_remaining_kg=p,pin_debris_kg=self.pin_debris,pin_recovered_kg=self.pin_recovered,pin_debris_recovered_kg=self.pin_debris_recovered,pin_error_kg=self.pin_loaded-p-self.pin_debris-self.pin_recovered-self.pin_debris_recovered,lubricant_loaded_kg=self.lubricant_loaded,lubricant_remaining_kg=l,lubricant_dragout_kg=self.lubricant_dragout,lubricant_recovered_kg=self.lubricant_recovered,lubricant_error_kg=self.lubricant_loaded-l-self.lubricant_dragout-self.lubricant_recovered,friction_input_j=self.friction_energy,heater_input_j=self.heater_energy,ambient_loss_j=self.ambient_loss,stored_thermal_energy_j=stored,thermal_error_j=self.friction_energy+self.heater_energy-self.ambient_loss-stored,specimen_wear_volume_m3=self.specimen_wear,pin_wear_volume_m3=self.pin_wear)
 def _result(self):
  if self.phase!='running' and self.operation_id in self.records:return copy.deepcopy(self.records[self.operation_id])
  return dict(operation_id=self.operation_id,phase=self.phase,elapsed_s=self.elapsed,rows=copy.deepcopy(self.rows),sliding_distance_m=self.operation_distance,observed_work_j=self.observed_work,reference_id=self.result_reference,template_source=self.source,method_json=self.operation_method,evidence=self.result_evidence or 'No operation; no hardware metrology validated.',error_code=self.error)
 def invoke(self,capability,**arguments):
  if capability not in CAPS:raise ActionRejected('UNKNOWN_CAPABILITY')
  validate(CAPS[capability]['input_schema'],arguments)
  if capability=='sim.step':self.step(arguments['dt_s']);return {'time_s':self.time_s}
  before=copy.deepcopy(self.__dict__)
  try:
   result=self._invoke(capability,arguments);validate(CAPS[capability]['output_schema'],result)
   if CAPS[capability]['kind'] not in ('query','analysis'):self.revision+=1
   return copy.deepcopy(result)
  except Exception:self.__dict__.clear();self.__dict__.update(before);raise
 def _stopped(self):
  if self.phase=='running' or self.homing:raise ActionRejected('BUSY')
 def _access(self):
  self._stopped()
  if self.contact:raise ActionRejected('ARM_LOADED')
  if not self.lid_open:raise ActionRejected('LID_CLOSED')
  if self.plant and self.temperature>self.plant['safe_access_temperature_k']:raise ActionRejected('HOT_SPECIMEN')
 def _check_drive(self,a):
  if a['mode']=='linear' and math.pi*a['stroke_m']*a['frequency_hz']>.370+1e-12:raise ActionRejected('LINEAR_SPEED_RANGE')
  if a['mode']=='angular' and (a['frequency_hz']>7 or not OMEGA_MIN<=2*math.pi*a['frequency_hz']*a['angular_amplitude_rad']<=OMEGA_MAX):raise ActionRejected('ANGULAR_COMBINATION_RANGE')
  if self.plant:
   if a['mode']=='linear' and self.plant['stage_mass_kg']*(2*math.pi*a['frequency_hz'])**2*a['stroke_m']/2>=self.plant['linear_drive_limit_n']:raise ActionRejected('DRIVE_INERTIA_RANGE')
   if a['mode']=='angular' and self.plant['rotational_inertia_kg_m2']*(2*math.pi*a['frequency_hz'])**2*a['angular_amplitude_rad']>=TORQUE_MAX:raise ActionRejected('DRIVE_INERTIA_RANGE')
 def _mu_limit(self):
  fn=self._normal_true()
  if fn<=0:return math.inf
  limit=FRICTION_MAX/fn
  if self.drive['mode']=='linear':limit=min(limit,(self.plant['linear_drive_limit_n']-self.plant['stage_mass_kg']*(2*math.pi*self.drive['frequency_hz'])**2*self.drive['stroke_m']/2)/fn)
  else:
   inertia=self.plant['rotational_inertia_kg_m2']*(2*math.pi*self.drive['frequency_hz'])**2*self.drive['angular_amplitude_rad'] if self.drive['mode']=='angular' else 0.;limit=min(limit,(TORQUE_MAX-inertia)/(fn*self.radius)) if self.radius>0 else limit
  return limit
 def _speed(self):return self.radius*self.drive['angular_speed_rad_s'] if self.drive['mode']=='rotary' else abs(motion(self.drive,self.radius,0.)['signed_speed_m_s'])
 def _check_conditions(self):
  s=self.specimen;c=self.reference.get('conditions',{});speed=self._speed();pairs=[('normal_force_n',self._normal_true()),('sliding_speed_m_s',speed),('temperature_k',self.temperature),('relative_humidity',self.plant['relative_humidity']),('track_radius_m',self.radius),('counterbody_radius_m',self.pin['radius_m'])]
  if self.reference.get('runtime_basis')==SPEED_BASIS:pairs=[x for x in pairs if x[0]!='sliding_speed_m_s']
  if any(c.get(k) is None for k,_ in pairs) and not s['accept_unknown_conditions']:raise ActionRejected('UNKNOWN_REFERENCE_CONDITIONS')
  for k,v in pairs:
   if c.get(k) is not None and abs(float(c[k])-v)>(self.method['temperature_tolerance_k'] if k=='temperature_k' else max(1e-10,abs(v)*1e-6)) and not s['accept_condition_transfer']:raise ActionRejected('REFERENCE_CONDITIONS')
  if c.get('motion_mode') is not None and c['motion_mode']!=self.drive['mode'] and not s['accept_condition_transfer']:raise ActionRejected('REFERENCE_CONDITIONS')
  if self.lubricant and not s['accept_condition_transfer']:raise ActionRejected('REFERENCE_LUBRICATION')
 def _invoke(self,k,a):
  if k in UNSUPPORTED:raise ActionRejected('UNSUPPORTED')
  if k=='acquisition.result':return self._result()
  if k=='ledger.read':return self._ledger()
  if k=='analysis.wear_profile':return profile_analysis(a)
  if k=='analysis.hertz':return hertz_analysis(a)
  if k=='reference.query':
   rec=library()['substances'].get(a['reference_id'])
   if rec is None:raise ActionRejected('INVALID_REFERENCE')
   return dict(reference_json=json.dumps(rec,ensure_ascii=False),template_source=json.dumps(rec.get('source'),ensure_ascii=False),evidence=json.dumps(rec.get('evidence'),ensure_ascii=False))
  if k=='plant.configure':
   if self.plant or self.time_s:raise ActionRejected('INITIALIZATION_ONLY')
   if not a['accept_engineering']:raise ActionRejected('MODEL_NOT_ACCEPTED')
   if a['temperature_max_k']<a['ambient_k'] or not a['heater_installed'] and a['heater_max_w']>0:raise ActionRejected('THERMAL_CONFIGURATION')
   self.plant=copy.deepcopy(a);self.temperature=self.initial_temperature=self.temperature_target=a['ambient_k'];return {'configured':True}
  if k=='power.set':
   self._stopped()
   if a['enabled'] and (not self.plant or self.emergency):raise ActionRejected('NOT_READY')
   self.power=a['enabled'];return a
  if k=='lid.set':self._stopped();self.lid_open=a['opened'];return a
  if k=='emergency.stop':
   self.emergency=True;self.homing=False
   if self.phase=='running':self._finish('failed','EMERGENCY_STOP')
   self.signed_speed=0.;return {'latched':True}
  if k=='emergency.reset':self._stopped();self.emergency=False;return {'latched':False}
  if k=='normal_load.set':
   self._access()
   if not self.plant:raise ActionRejected('NOT_READY')
   if a['force_n']*self.plant['normal_force_factor']>60:raise ActionRejected('NORMAL_FORCE_RANGE')
   self.normal_setting=a['force_n'];return a
  if k=='radius.set':self._access();self.radius=a['radius_m'];return a
  if k=='drive.configure':self._access();self._check_drive(a);self.drive=copy.deepcopy(a);return a
  if k=='motion.home':
   self._access()
   if not self.power or self.emergency:raise ActionRejected('NOT_READY')
   self.homing=True;return {'homing':True}
  if k=='contact.set':
   self._stopped()
   if not self.lid_open:raise ActionRejected('LID_CLOSED')
   if a['engaged'] and (not self.specimen or not self.pin):raise ActionRejected('NO_CONTACT_PAIR')
   self.contact=a['engaged'];return a
  if k in ('specimen.load','pin.load','lubricant.load'):
   self._access()
   if not self.plant:raise ActionRejected('NOT_READY')
   if not a['accept_engineering']:raise ActionRejected('MODEL_NOT_ACCEPTED')
   name=k.split('.')[0]
   if getattr(self,name) is not None:raise ActionRejected('ALREADY_LOADED')
   if name=='specimen':
    rec=copy.deepcopy(library()['substances'].get(a['reference_id'],{}));x,mu=curve(rec,a['accept_unknown_conditions']);self.reference=rec;self.ref_x=x;self.ref_mu=mu;self.specimen_wear=0.;self.sample_distance=0.;self.source_origin=None
   if name=='pin':self.pin_wear=0.
   if name=='lubricant' and (self.temperature>423.15 or self.temperature_target>423.15):raise ActionRejected('LIQUID_TEMPERATURE_RANGE')
   setattr(self,name,copy.deepcopy(a));setattr(self,name+'_volume',a['volume_m3']);setattr(self,name+'_loaded',getattr(self,name+'_loaded')+a['volume_m3']*a['density_kg_m3']);return {'loaded':True}
  if k in ('specimen.remove','pin.remove','lubricant.remove'):
   self._access();name=k.split('.')[0];item=getattr(self,name)
   if item is None:raise ActionRejected('NOT_LOADED')
   setattr(self,name+'_recovered',getattr(self,name+'_recovered')+getattr(self,name+'_volume')*item['density_kg_m3']);setattr(self,name+'_volume',0.);setattr(self,name,None)
   if name=='specimen':self.ref_x=np.array([]);self.ref_mu=np.array([]);self.reference=None;self.source_origin=None;self.sample_distance=0.;self.specimen_wear=0.
   if name=='pin':self.pin_wear=0.
   return {'removed':True}
  if k=='debris.collect':
   self._access();self.specimen_debris_recovered+=self.specimen_debris;self.pin_debris_recovered+=self.pin_debris;self.specimen_debris=0.;self.pin_debris=0.;return {'collected':True}
  if k=='thermal.set_temperature':
   self._stopped()
   if not self.plant:raise ActionRejected('NOT_READY')
   t=a['temperature_k']
   if t<self.plant['ambient_k']:raise ActionRejected('NO_ACTIVE_COOLING')
   if t>self.plant['ambient_k'] and not self.plant['heater_installed']:raise ActionRejected('HEATER_NOT_INSTALLED')
   if t>self.plant['temperature_max_k']:raise ActionRejected('THERMAL_MODEL_RANGE')
   if self.lubricant and t>423.15:raise ActionRejected('LIQUID_TEMPERATURE_RANGE')
   self.temperature_target=t;return a
  if k=='sensor.calibrate':self._stopped();self.calibration=copy.deepcopy(a);return a
  if k=='sensor.zero':
   self._access()
   if not self.power:raise ActionRejected('NOT_READY')
   self.calibration['friction_zero_n']=self.left-self.right;return {'zeroed':True}
  if k=='method.configure':
   self._stopped()
   if abs(a['sample_interval_s']/DT-round(a['sample_interval_s']/DT))>1e-8:raise ActionRejected('SAMPLING_GRID')
   if self.source_origin is not None and a['source_start_distance_m']!=self.source_origin:raise ActionRejected('SOURCE_ORIGIN_LOCKED')
   self.method=copy.deepcopy(a);return a
  if k=='acquisition.start':
   self._stopped()
   if not self.power or self.emergency or self.lid_open or not self.contact or not self.specimen or not self.pin:raise ActionRejected('NOT_READY')
   if self.specimen_volume<=0 or self.pin_volume<=0:raise ActionRejected('SPECIMEN_EXHAUSTED')
   if self.drive['mode']=='linear' and abs(self.linear_position)>1e-12:raise ActionRejected('HOME_REQUIRED')
   if self.drive['mode']!='linear' and self.radius<=0:raise ActionRejected('ZERO_TRACK_RADIUS')
   self._check_drive(self.drive)
   if self.reference.get('runtime_basis') in SCALAR_BASES:self.ref_x,self.ref_mu,self.scalar_info=scalar_curve(self.reference,self._speed(),self.specimen['accept_unknown_conditions'],self.specimen['accept_condition_transfer'])
   self._check_conditions();coordinate=self.method['source_start_distance_m']+self.sample_distance
   if not self.ref_x[0]<=coordinate<self.ref_x[-1]:raise ActionRejected('REFERENCE_DISTANCE_RANGE')
   if float(np.interp(coordinate,self.ref_x,self.ref_mu))>self._mu_limit():raise ActionRejected('DRIVE_FORCE_RANGE')
   if abs(self.temperature-self.temperature_target)>self.method['temperature_tolerance_k']:raise ActionRejected('TEMPERATURE_NOT_READY')
   self.source_origin=self.method['source_start_distance_m'];self._counter+=1;self.operation_id=self.instance_id+':'+str(self._counter);self.phase='running';self.elapsed=0.;self.rows=[];self.observed_work=0.;self.operation_distance=0.;self.operation_start=self.time_s;self.angle_base=self.disk_angle;self.error=None;self.result_reference=self.specimen['reference_id'];self.source=json.dumps(self.reference.get('source'),ensure_ascii=False);self.operation_method=json.dumps({'method':self.method,'drive':self.drive,'radius_m':self.radius,'nominal_deadweight_force_n':self.normal_setting},sort_keys=True);self.result_evidence=(SCALAR_EVIDENCE+' Scalar replay: '+json.dumps(self.scalar_info,sort_keys=True)+'. ' if self.reference.get('runtime_basis') in SCALAR_BASES else 'Original positive empirical mu(distance) response transplanted under explicitly accepted conditions; source CSV preserved and source-node subsampling is not native resolution. ')+'Deadweight not servo; prescribed waveform not validated motor/contact dynamics. Wear uses explicit Archard inputs; differential sensors, heating/cooling and online wear proxy are engineering assumptions, not measured accuracy/noise. True private coefficients and inventories remain evaluator-only. Sources: '+json.dumps(self.reference.get('evidence'),ensure_ascii=False);self._record();return {'operation_id':self.operation_id}
  if k=='acquisition.stop':
   if self.phase!='running':raise ActionRejected('NOT_RUNNING')
   self._finish('cancelled');return {'phase':'cancelled'}
  raise ActionRejected('UNKNOWN_CAPABILITY')
 def _heat(self,dt,friction_j=0.):
  if not self.plant or dt<=0:return
  p=self.plant;c=p['thermal_capacity_j_k'];g=p['heat_loss_w_k'];ambient=p['ambient_k'];q=friction_j/dt;gain=p['heater_gain_w_k'] if self.power and not self.emergency and p['heater_installed'] else 0.;maximum=p['heater_max_w'] if gain else 0.;target=self.temperature_target;remaining=dt;loops=0
  while remaining>1e-14:
   loops+=1
   if loops>10:raise RuntimeError('thermal event partition did not converge')
   t0=self.temperature;rate0=q-g*(t0-ambient);low=target-maximum/gain if gain else -math.inf
   if gain and maximum>0 and (t0<low-1e-10 or abs(t0-low)<=1e-10 and rate0+maximum<=0):a=g;b=q+maximum+g*ambient;bounds=[low]
   elif gain and maximum>0 and (t0<target-1e-10 or abs(t0-target)<=1e-10 and rate0<0):a=g+gain;b=q+gain*target+g*ambient;bounds=[low,target]
   else:a=g;b=q+g*ambient;bounds=[target] if gain and maximum>0 else []
   rate=(b-a*t0)/c
   if abs(rate)<1e-14:integral=t0*remaining;t1=t0;duration=remaining
   else:
    equilibrium=b/a if a else 0.;predict=equilibrium+(t0-equilibrium)*math.exp(-a*remaining/c) if a else t0+b*remaining/c;duration=remaining
    for boundary in bounds:
     if (boundary-t0)*rate>1e-10 and min(t0,predict)<boundary<max(t0,predict):
      ratio=(boundary-equilibrium)/(t0-equilibrium) if a else 0.;cross=-c/a*math.log(ratio) if a else (boundary-t0)*c/b
      if 0<cross<duration:duration=cross
    if a:
     decay=math.exp(-a*duration/c);t1=equilibrium+(t0-equilibrium)*decay;integral=equilibrium*duration+(t0-equilibrium)*c/a*(-math.expm1(-a*duration/c))
    else:t1=t0+b*duration/c;integral=(t0+t1)*duration/2
   loss=g*(integral-ambient*duration);heat=c*(t1-t0)-q*duration+loss
   if gain==0 or maximum==0:heat=0.;loss=q*duration-c*(t1-t0)
   self.ambient_loss+=loss;self.heater_energy+=heat;self.temperature=t1;remaining-=duration
 def _reference_work(self,ds):
  start=self._coordinate();end=start+ds;lo=int(np.searchsorted(self.ref_x,start,side='right'));hi=int(np.searchsorted(self.ref_x,end,side='left'));x=np.r_[start,self.ref_x[lo:hi],end];return float(np.trapz(np.interp(x,self.ref_x,self.ref_mu),x))*self._normal_true()
 def _allowed_distance(self,ds):
  limit=ds;reason=None
  candidates=[(self.method['stop_distance_m']-self.operation_distance,'STOP_DISTANCE'),(self.ref_x[-1]-self._coordinate(),'REFERENCE_DISTANCE_RANGE')];fn=self._normal_true()
  if fn>0:
   for item,volume,label in [(self.specimen,self.specimen_volume,'SPECIMEN_EXHAUSTED'),(self.pin,self.pin_volume,'PIN_EXHAUSTED')]:
    if item['archard_coefficient']>0:candidates.append((volume*item['hardness_pa']/(item['archard_coefficient']*fn),label))
  if self.lubricant and self.lubricant['loss_per_distance_m2']>0:candidates.append((self.lubricant_volume/self.lubricant['loss_per_distance_m2'],'LUBRICANT_EXHAUSTED'))
  for distance,label in candidates:
   if distance<=limit:limit=max(0.,distance);reason=label
  start=self._coordinate();end=start+limit;lo=int(np.searchsorted(self.ref_x,start,side='right'));hi=int(np.searchsorted(self.ref_x,end,side='left'));x=np.r_[start,self.ref_x[lo:hi],end];mu=np.interp(x,self.ref_x,self.ref_mu);bound=self._mu_limit()
  for i in range(len(x)-1):
   if mu[i]>bound:limit=max(0.,x[i]-start);reason='DRIVE_FORCE_RANGE';break
   if mu[i+1]>bound:
    crossing=x[i]+(x[i+1]-x[i])*(bound-mu[i])/(mu[i+1]-mu[i]);limit=max(0.,crossing-start);reason='DRIVE_FORCE_RANGE';break
  return limit,reason
 def _sensors(self,dt,mean_force,ds_signed):
  p=self.plant;common=p['common_drift_n_s']*self.time_s+p['thermal_common_drift_n_k']*(self.temperature-p['ambient_k']);target1=.5*mean_force*p['friction_gain_left']+p['friction_offset_left_n']+common;target2=-.5*mean_force*p['friction_gain_right']+p['friction_offset_right_n']+common;tau=p['force_sensor_tau_s'];one=-math.expm1(-dt/tau)
  int1=target1*dt+(self.left-target1)*tau*one;int2=target2*dt+(self.right-target2)*tau*one;self.left+=one*(target1-self.left);self.right+=one*(target2-self.right)
  if dt>0:self.observed_work+=(int1-int2-self.calibration['friction_zero_n']*dt)/self.calibration['friction_gain_correction']*ds_signed/dt
 def _advance_motion(self,elapsed_end):
  elapsed_start=self.time_s-self.operation_start;begin=motion(self.drive,self.radius,elapsed_start);end=motion(self.drive,self.radius,elapsed_end);requested=max(0.,end['distance_m']-begin['distance_m']);ds,reason=self._allowed_distance(requested)
  if ds<requested:
   lo=elapsed_start;hi=elapsed_end
   for _ in range(55):
    mid=(lo+hi)/2
    if motion(self.drive,self.radius,mid)['distance_m']-begin['distance_m']<ds:lo=mid
    else:hi=mid
   elapsed_end=(lo+hi)/2;end=motion(self.drive,self.radius,elapsed_end)
  dt=max(0.,elapsed_end-elapsed_start)
  if dt>1e-14:
   energy=self._reference_work(ds);fn=self._normal_true();signed=math.copysign(ds,motion(self.drive,self.radius,(elapsed_start+elapsed_end)/2)['signed_speed_m_s']);mean_force=energy/ds*math.copysign(1.,signed) if ds>0 else 0.;self.friction_energy+=energy;self._heat(dt,energy)
   for name in ['specimen','pin']:
    item=getattr(self,name);old=getattr(self,name+'_volume');wear=min(old,item['archard_coefficient']*fn*ds/item['hardness_pa']);setattr(self,name+'_volume',old-wear);setattr(self,name+'_wear',getattr(self,name+'_wear')+wear);setattr(self,name+'_debris',getattr(self,name+'_debris')+wear*item['density_kg_m3'])
   if self.lubricant:
    loss=min(self.lubricant_volume,self.lubricant['loss_per_distance_m2']*ds);self.lubricant_volume-=loss;self.lubricant_dragout+=loss*self.lubricant['density_kg_m3']
   self.sample_distance+=ds;self.operation_distance+=ds;self.time_s=self.operation_start+elapsed_end;self.elapsed=elapsed_end;self.disk_angle=(self.angle_base+end['angle_rad']+math.pi)%(2*math.pi)-math.pi;self.linear_position=end['position_m'];self.signed_speed=end['signed_speed_m_s'];self._sensors(dt,mean_force,signed)
  if self.temperature>self.plant['temperature_max_k']:reason='THERMAL_MODEL_RANGE'
  if self.lubricant and self.temperature>423.15:reason='LIQUID_TEMPERATURE_RANGE'
  if self._sensing()[2]=='FRICTION_SENSOR_OVER_RANGE':reason='FRICTION_SENSOR_OVER_RANGE'
  if not self.specimen['accept_condition_transfer']:
   try:self._check_conditions()
   except ActionRejected as exc:reason=str(exc)
  if reason:self._finish('succeeded' if reason=='STOP_DISTANCE' else 'failed',None if reason=='STOP_DISTANCE' else reason)
 def _record(self):
  if self.rows and abs(self.rows[-1]['time_s']-self.time_s)<=1e-12:return
  f,mu,reason=self._sensing();self.rows.append(dict(time_s=self.time_s,elapsed_s=self.time_s-self.operation_start,sliding_distance_m=self.operation_distance,signed_speed_m_s=self.signed_speed,disk_angle_rad=self.disk_angle,linear_position_m=self.linear_position,normal_force_n=self._normal_observed(),friction_force_n=f,friction_coefficient=mu,sensor_left_n=self.left if self.power else None,sensor_right_n=self.right if self.power else None,wear_depth_m=self._wear_read(),temperature_k=self.temperature+self.plant['temperature_sensor_offset_k']-self.calibration['temperature_zero_k'] if self.power else None,cumulative_observed_work_j=self.observed_work,unavailable_reason=reason))
 def _finish(self,phase,error=None):
  self.elapsed=self.time_s-self.operation_start;self._record();self.phase=phase;self.error=error;self.signed_speed=0.
  if self.operation_id:self.records[self.operation_id]=self._result()
 def _tick(self):
  start=(self._ticks-1)*DT;end=self._ticks*DT;self.time_s=start
  while self.time_s<end-1e-12:
   if self.phase=='running':
    phase_time=self.time_s-self.operation_start;interval=.01
    if self.drive['mode']!='rotary':
     f=self.drive['frequency_hz'];interval=min(interval,1/(64*f));next_turn=(math.floor((phase_time*f-.25)/.5+1e-10)+1)*.5/f+.25/f
     if next_turn>phase_time+1e-12:interval=min(interval,next_turn-phase_time)
    endpoint=min(end-self.operation_start,phase_time+interval,self.method['duration_s']);before=self.time_s;self._advance_motion(endpoint)
    if self.phase=='running' and self.elapsed>=self.method['duration_s']-1e-10:self._finish('succeeded')
    if self.phase=='running' and self.time_s<=before+1e-14:raise RuntimeError('motion integration made no progress')
   else:
    dt=end-self.time_s;self._heat(dt)
    if self.plant and self.power:self._sensors(dt,0.,0.)
    if self.power and not self.emergency and self.homing:
     self.linear_position+=max(-.03*dt,min(.03*dt,-self.linear_position));self.disk_angle+=max(-1.*dt,min(1.*dt,-self.disk_angle));self.homing=abs(self.linear_position)>1e-12 or abs(self.disk_angle)>1e-12
    self.time_s=end
  self.time_s=end
  if self.phase=='running' and (self._ticks-round(self.operation_start/DT))%round(self.method['sample_interval_s']/DT)==0:self._record()
 def step(self,dt_s):
  validate(number('s',0,3600),dt_s);total=self._remainder+dt_s;n=int((total+1e-12)/DT);self._remainder=total-n*DT
  for _ in range(n):self._ticks+=1;self._tick()
  self.revision+=n

class AntonpaarTrbSession:
 def __init__(self,host,principal_id):self._host=host;self._principal=principal_id
 @property
 def _role(self):return self._host._principals[self._principal]
 def _target(self,instance_id):
  if instance_id!=self._host.instance_id:raise ActionRejected('UNKNOWN_INSTANCE')
 def describe(self,*,instance_id=None,asset_type_id=None):
  if (instance_id is None)==(asset_type_id is None):raise ActionRejected('INVALID_ARGUMENT')
  if instance_id is not None:self._target(instance_id)
  if asset_type_id is not None and asset_type_id!=ASSET_TYPE_ID:raise ActionRejected('UNKNOWN_INSTANCE')
  meta=export_antonpaar_trb_contract_metadata();return dict(protocol_version=PROTOCOL_VERSION,asset_type_id=ASSET_TYPE_ID,asset_version='1.1.0',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;values=h.read(self._role);ids=list(values) 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 values for k in ids):raise ActionRejected('ACCESS_DENIED')
  return dict(instance_id=instance_id,status='succeeded',state_revision=h.revision,clock={'domain':'simulation','time_s':h.time_s},observations={k:dict(value=values[k],unit=SLOTS[k]['unit'],quality='unavailable' if values[k] is None else 'estimated' if SLOTS[k]['origin']=='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):
  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]['visibility']!='agent':raise ActionRejected('ACCESS_DENIED')
   if not isinstance(request_id,str) or not request_id:raise ActionRejected('INVALID_ARGUMENT')
   validate(CAPS[capability_id]['input_schema'],arguments);key=(self._principal,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)
   if capability_id in ('acquisition.stop','acquisition.result') and self._role=='agent' and h.operation_id is not None and h._owners.get(h.operation_id)!=self._principal:raise ActionRejected('ACCESS_DENIED')
   result=h.invoke(capability_id,**arguments);operation=result.get('operation_id') if capability_id=='acquisition.start' else None
   if operation:h._owners[operation]=self._principal
   response=dict(protocol_version=PROTOCOL_VERSION,instance_id=instance_id,request_id=request_id,operation_id=operation,status='accepted' if operation 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);entry=SLOTS.get(state_id)
  if not entry or not entry['write']:raise ActionRejected('ACCESS_DENIED')
  capability,argument=entry['write'];return self.invoke(instance_id=instance_id,capability_id=capability,arguments={argument: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')
  result=h._result() if operation_id==h.operation_id and h.phase=='running' else h.records.get(operation_id)
  if result is None:raise ActionRejected('UNKNOWN_OPERATION')
  return dict(operation_id=operation_id,status=result['phase'],result=copy.deepcopy(result))
 def cancel(self,operation_id,request_id):
  self.poll(operation_id);h=self._host
  if not isinstance(request_id,str) or not request_id:raise ActionRejected('INVALID_ARGUMENT')
  key=(self._principal,request_id)
  if key in h._cancel_operations:
   if h._cancel_operations[key]!=operation_id:raise ActionRejected('REQUEST_CONFLICT')
   return copy.deepcopy(h._requests[key][1])
  if key in h._requests:raise ActionRejected('REQUEST_CONFLICT')
  if operation_id!=h.operation_id:raise ActionRejected('NOT_RUNNING')
  result=self.invoke(instance_id=h.instance_id,capability_id='acquisition.stop',arguments={},request_id=request_id)
  if result['status']=='succeeded':h._cancel_operations[key]=operation_id
  return result

slot('environment.relative_humidity',nullable(number('1',0,1)),'1','显式环境RH与校准偏置后的限幅读数；不声称湿度控制附件已实现',component='controller')
EFFECTS={
 'plant.configure':['plant.configured','truth.temperature_k','thermal.target_k'],
 'specimen.load':['specimen.present','truth.specimen_volume_m3','truth.friction_coefficient','wear.indicated_m'],
 'specimen.remove':['specimen.present','truth.specimen_volume_m3','truth.friction_coefficient','wear.indicated_m'],
 'pin.load':['pin.present','truth.pin_volume_m3'],'pin.remove':['pin.present','truth.pin_volume_m3'],
 'lubricant.load':['lubricant.present','truth.lubricant_volume_m3'],'lubricant.remove':['lubricant.present','truth.lubricant_volume_m3'],
 'debris.collect':['truth.debris_kg'],
 'power.set':['power.enabled','power.angle_rad','normal.indicated_n','friction.indicated_n','friction.coefficient','friction.left_n','friction.right_n','wear.indicated_m','thermal.indicated_k','friction.unavailable_reason','environment.relative_humidity'],
 'normal_load.set':['normal.setting_n'],'radius.set':['radius.position_m'],'drive.configure':['drive.mode'],
 'contact.set':['contact.engaged','arm.angle_rad','normal.indicated_n','truth.normal_force_n','friction.unavailable_reason'],
 'lid.set':['lid.open','lid.angle_rad'],'motion.home':['motion.homing'],
 'emergency.stop':['emergency.latched','estop.press_m','motion.homing','acquisition.phase','acquisition.elapsed_s','acquisition.points','motion.signed_speed_m_s','friction.indicated_n','friction.coefficient','friction.unavailable_reason'],
 'emergency.reset':['emergency.latched','estop.press_m'],'thermal.set_temperature':['thermal.target_k'],
 'sensor.calibrate':['normal.indicated_n','friction.indicated_n','friction.coefficient','wear.indicated_m','thermal.indicated_k','friction.unavailable_reason'],'sensor.zero':[],
 'acquisition.start':['acquisition.phase','acquisition.elapsed_s','acquisition.points','motion.distance_m','friction.indicated_n','friction.coefficient','friction.unavailable_reason','truth.friction_coefficient'],
 'acquisition.stop':['acquisition.phase','acquisition.elapsed_s','acquisition.points','motion.signed_speed_m_s','friction.indicated_n','friction.coefficient','friction.unavailable_reason'],
 'sim.step':list(SLOTS)
}
for k,v in EFFECTS.items():CAPS[k]['effects']=v
PHYSICS_EFFECTS=['disk.angle_rad','linear.position_m','motion.homing','normal.indicated_n','friction.indicated_n','friction.coefficient','friction.left_n','friction.right_n','wear.indicated_m','thermal.indicated_k','motion.signed_speed_m_s','motion.distance_m','friction.unavailable_reason','truth.friction_coefficient','truth.specimen_volume_m3','truth.pin_volume_m3','truth.debris_kg','truth.lubricant_volume_m3','truth.temperature_k','truth.friction_work_j','clock.time_s','acquisition.phase','acquisition.elapsed_s','acquisition.points']

def export_antonpaar_trb_contract_metadata():
 slots={};caps={}
 for k,v in SLOTS.items():slots[k]=dict(meaning_zh=v['meaning'],component_ids=[v['component']],value_schema=copy.deepcopy(v['schema']),unit=v['unit'],reference_conditions='SI. Positive prescribed direction; friction observation is signed, mu=absolute indicated friction/positive indicated load. Linear stage exists only in separate engineering variant. Normal load is manual deadweight. Inputs are explicitly declared engineering coefficients.',origin=v['origin'],visibility=v['visibility'],access='read_only',read_binding=dict(backend='host',artifact_id='runtime',accessor=f'AntonpaarTrbSession.read(state_ids=[{k!r}])'),write_via=None,sampling=dict(mode='instant',time_domain='simulation',window_description='Host0.1s ticks, internal<=10ms and64steps/reciprocation with exact reversal events. Instant sampled readings can alias; exact cumulative distance/work uses full path. No empirical noise claim.'),source_ids=['simulation_assumption'])
 errors=['UNKNOWN_CAPABILITY','UNKNOWN_INSTANCE','UNKNOWN_OPERATION','INVALID_ARGUMENT','UNSUPPORTED','ACCESS_DENIED','REQUEST_CONFLICT','BUSY','NOT_RUNNING','NOT_READY','INITIALIZATION_ONLY','MODEL_NOT_ACCEPTED','ARM_LOADED','LID_CLOSED','HOT_SPECIMEN','ALREADY_LOADED','NOT_LOADED','INVALID_REFERENCE','NO_CONTACT_PAIR','NORMAL_FORCE_RANGE','LINEAR_SPEED_RANGE','ANGULAR_COMBINATION_RANGE','DRIVE_INERTIA_RANGE','DRIVE_FORCE_RANGE','ZERO_TRACK_RADIUS','HOME_REQUIRED','REFERENCE_DISTANCE_RANGE','UNKNOWN_REFERENCE_CONDITIONS','REFERENCE_CONDITIONS','REFERENCE_LUBRICATION','SOURCE_ORIGIN_LOCKED','SPECIMEN_EXHAUSTED','PIN_EXHAUSTED','LUBRICANT_EXHAUSTED','FRICTION_SENSOR_OVER_RANGE','EMERGENCY_STOP','THERMAL_CONFIGURATION','THERMAL_MODEL_RANGE','LIQUID_TEMPERATURE_RANGE','NO_ACTIVE_COOLING','HEATER_NOT_INSTALLED','TEMPERATURE_NOT_READY','SAMPLING_GRID','PROFILE_GRID','PROFILE_RADIUS','HERTZ_MODEL_DOMAIN']
 for k,c in CAPS.items():
  un=k in UNSUPPORTED;async_=k=='acquisition.start';caps[k]={key:copy.deepcopy(c[key]) for key in ['input_schema','output_schema','component_ids','function_zh','kind','visibility','example_arguments']};caps[k].update(availability='unsupported' if un else 'implemented',implementation={layer:'absent' if un or layer in ['scene','robot','hardware'] else 'implemented' for layer in ['process','scene','robot','hardware','host']},binding=None if un else dict(backend='host',artifact_id='runtime',entrypoint='asset_runtime.antonpaar_trb.AntonpaarTrbSession.invoke',invocation=f'session.invoke(instance_id="trb_01",capability_id={k!r},arguments={c["example_arguments"]!r},request_id="unique")'),preconditions=[] if c['kind'] in ['query','analysis'] or un else [dict(description_zh='有限试片/销/润滑剂、源距离域、停机抬臂死重/半径/装卸、安全罩、驱动组合、温区前提；拒绝原子',state_ids=['power.enabled','lid.open','contact.engaged','emergency.latched','specimen.present','pin.present','acquisition.phase'],enforced_by='runtime',check='atomic invoke and registered Session')],state_effects=[dict(state_id=x,timing='immediate',description_zh='实际命令改变的状态') for x in c['effects']],observes=[],model_effects=dict(mode='none',description_zh='主旋转/角往复与独立linear附件几何另验证；此处不声称PhysX摩擦/磨耗接触求解',binding_ids=[]),execution=dict(mode='asynchronous' if async_ else 'synchronous',time_domain='simulation',completion_criterion='真实时间/累计路径达到方法终点；失败/取消保留部分物理效果' if async_ else '命令返回不隐式推进物理时间',completion_state_ids=['acquisition.phase'] if async_ else [],timeout_s=None,cancellation='supported' if async_ else 'unsupported',retry='same_request_id',resources=['host_clock','contact_pair','motion_module','differential_force_sensors'],partial_failure_zh='摩擦功、升温、磨耗和磨屑不回滚；取消冻结来源/曲线，停止运动；温度继续按宿主时间冷却'),errors=[dict(code=x,meaning_zh=x,side_effects='partial' if async_ and x in ['DRIVE_FORCE_RANGE','REFERENCE_DISTANCE_RANGE','SPECIMEN_EXHAUSTED','PIN_EXHAUSTED','LUBRICANT_EXHAUSTED','THERMAL_MODEL_RANGE','FRICTION_SENSOR_OVER_RANGE','EMERGENCY_STOP','REFERENCE_CONDITIONS'] else 'none') for x in errors],verification=[],limitations=['源经验摩擦响应与未知Archard/传感器/热参数分开','硬件范围不是已验证精度或全部上限可同时满足','主Matterix构型仅旋转/角往复；linear单独工程变体'],source_ids=['manufacturer_specs','simulation_assumption'])
  if k in ['acquisition.start','motion.home','thermal.set_temperature','power.set']:caps[k]['state_effects'] += [dict(state_id=x,timing='on_step',description_zh='宿主推进运动/热/观测/有限磨损') for x in PHYSICS_EFFECTS if x!='clock.time_s']
 mechanism=dict(component_ids=['disk','linear_stage','specimen','pin','lever_arm','deadweight','friction_sensor_left','friction_sensor_right','sample_holder'],state_ids=list(slots),meaning_zh='有限材料对经验摩擦、精确滑程、差分观测及热/磨耗账本',implementation='lumped',equations=[
 'Rotary s=r*omega*t. Linear x=stroke/2*sin(2pi*f*t); angular theta=amplitude*sin(2pi*f*t). Exact s integrates |cos| across every reversal, not endpoint displacement. Linear vmax=pi*stroke*f<=.370m/s; angular peakomega in.2..2000rpm andf<=7Hz is an explicit peak-speed interpretation, allowing zero instantaneous speed at reversals.',
 'Empirical positive mu(s) uses original source-node piecewise linear interpolation. Friction work=Fn*integral mu(s)ds exactly across source knots; original signal resolution and transfer of material-pair conditions are disclosed. Negative empirical coefficients are not silently made dissipative truth.',
 'Records with runtime_basis=scalar_mean_friction (published mean mu of the pair) or scalar_speed_series_friction (published mu at several speeds, interpolated in log(speed) at the actual drive speed; outside the source range only with accepted condition transfer, clamped to the end value) are replayed as a CONSTANT mu(s) over [0, source sliding distance]; if the source does not report the distance the domain is unbounded and requires accept_unknown_conditions. Result evidence labels the scalar replay.',
 'Deadweight nominal Fn set only at stopped raised arm. Actual Fn=nominal*explicit mechanical factor; indicated load uses separately supplied observation gain/offset. No active load servo.',
 'Conservative combined envelope: Fn*mu*r + J*angular_acceleration_peak <=.45Nm; linear Fn*mu + moving_mass*acceleration_peak <=explicit engineering drive force. Friction force<=20N. First empirical threshold crossing/finite inventory/source endpoint stops with actual partial effects.',
 'Dual sensing targets y1=+F/2*g1+offset1+common_drift(t,T), y2=-F/2*g2+offset2+common_drift(t,T). Identical first-order response cancels common component. ObservedF=(y1-y2-external_zero)/external_gain; observedmu=abs(Fobs)/Fn_obs. Low load, zero velocity and sensor overrange yield null with reason.',
 'Internal sensor forcing uses distance-mean empirical friction on each monotonic segment. Exact exponential sensor update and its time integral times segment mean signed velocity estimate observed work. This is an explicit piecewise-constant observation approximation; true friction work is independently exact along source distance.',
 'Archard dV=k*Fn*ds/H separately for specimen and pin, with explicit coefficients/hardness. Removed volumes times individual densities exactly enter separate debris reservoirs. Finite lubricant dragout=declared loss_per_distance*ds enters a catch inventory, not invented evaporation.',
 'C*dT/dt=Pfriction_interval+clamp(K*(Ttarget-T),0,Pmax)-G*(T-Tambient). Piecewise exact exponential thermal regimes preserve heater+friction-ambient=stored heat. Heater characteristics are supplied engineering assumptions; not OEM power/ramp calibration. No active cooling or flash-contact-temperature prediction.',
 'External wear profile integrates positive baseline-height deficit and negative pile-up separately. Circular track integrates2pi*(r+x)*depth(x), retaining radial weight and signed net. Uniform-track assumption is explicit. Hertz sphere-flat a=(3FnR/(4E*))^(1/3),1/E*=(1-v1^2)/E1+(1-v2^2)/E2,small-contact a/R<=.1.'
 ],parameters={},source_ids=['manufacturer_specs','simulation_assumption'],limitations=['Default curve is another tribometer material-pair experiment, not current TRB3native raw acquisition; scalar TRB3 and literature means are replayed only as labelled constant mu, never as synthetic transient curves.','Constant-mu scalar replay has no running-in, stick-slip, fluctuation, humidity/temperature or wear-driven drift; mean definitions (steady-state vs whole-test) follow each source.','Concentration/grade/load/speed/temperature variants do not count as50independent pure substances.','No empirical noise distribution, achieved.06mN force resolution, ASTM certification or true wear calibration.','The photographed red button is bound to a local engineering stop/reset interlock; original button function and certified emergency-stop behavior are not confirmed.','Predetermined motion has no acceleration ramp or motor/contact dynamics; peak-inertia envelope is conservative and explicitly engineering.','Online wear depth proxy derives declared uniform track from engineering Archard wear; original source wear data not fabricated frommu.','Strict source-condition mode terminates with partial effects if friction heating moves outside its explicitly configured source-temperature tolerance.','Thermal forcing uses exact interval work but interval-mean heat power; no flash-temperature, radiation/nonlinear property or insert/remove enthalpy model.','Linear geometry exists separately and is not silently overlaid on rotary main variant; actual scene tests determine availability there.'])
 caps['acquisition.start']['source_ids'].append('mendeley_leadbronze');caps['reference.query']['source_ids'].append('mendeley_leadbronze');mechanism['source_ids'].append('mendeley_leadbronze');caps['analysis.hertz']['source_ids'].append('nist_elastic_contact');caps['analysis.wear_profile']['source_ids'].append('nist_wear_method');mechanism['source_ids']+=['nist_elastic_contact','nist_wear_method']
 spec=importlib.util.spec_from_file_location('_trb_local_annotations',ROOT/'scripts/asset_runtime/_annotations.py');ann=importlib.util.module_from_spec(spec);spec.loader.exec_module(ann);ann.KEY_ZH.update({k:v['meaning'] for k,v in SLOTS.items()});ann.annotate_export(SLUG,caps,slots,{'tribology':mechanism},inputs={'plant.configure':(PLANT,PLANT_EXAMPLE),'specimen.load':(SAMPLE,SAMPLE_EXAMPLE),'pin.load':(PIN,PIN_EXAMPLE),'lubricant.load':(LUBRICANT,LUBRICANT_EXAMPLE),'drive.configure':(DRIVE,DRIVE_EXAMPLE),'method.configure':(METHOD,METHOD_EXAMPLE)})
 return dict(asset_type_id=ASSET_TYPE_ID,catalog_id=CATALOG_ID,capabilities=caps,state_slots=slots,mechanisms={'tribology':mechanism})