| """Unqualified same-run 3D-water aspiration/dispense/rack motor candidate.
|
|
|
| Advancement requires actual liquid inventory. No phase-based water creation,
|
| object pose substitution, or automatic physics qualification is performed.
|
| """
|
| from pathlib import Path
|
| import sys,argparse,json,time,math
|
| import numpy as np,mujoco,warp as wp
|
| from scipy.spatial.transform import Rotation
|
| sys.path.insert(0,str(Path(__file__).resolve().parents[1]))
|
| from dropperlab.experimental_sph.warp_dfsph import WarpDFSPH
|
| from dropperlab.experimental_sph.bulb_fem import Cavity
|
| from dropperlab.experimental_sph.bulb_integrity import BulbIntegrity
|
| from dropperlab.dual_policy import MotorController
|
| from dropperlab.assets import ROOT
|
| from dropperlab.experiment_recording import ExperimentRecorder
|
| from dropperlab.particle_inventory import CavityInventory
|
| from dropperlab.transfer_policy import TransferPolicy
|
| from dropperlab.interval_state import IntervalState
|
| from dropperlab.accepted_checkpoint import save_checkpoint,load_checkpoint
|
| from dropperlab.grasp_support import GraspSupport
|
| from dropperlab.grasp_geometry import GraspGeometry
|
| p=argparse.ArgumentParser();p.add_argument('--source',type=Path,default=ROOT/'results/coupled_gpu_seed_smoke')
|
| p.add_argument('--out',type=Path,required=True);p.add_argument('--duration',type=float,default=60.)
|
| p.add_argument('--release-duration',type=float,default=.3);p.add_argument('--sigma',type=float,default=.072)
|
| p.add_argument('--release-gap',type=float,default=.008)
|
| p.add_argument('--fluid-dt',type=float,default=.0001)
|
| p.add_argument('--adaptive-contact',action='store_true')
|
| p.add_argument('--contact-predictor-recovery',action='store_true')
|
| p.add_argument('--paired-world-contact',action='store_true')
|
| p.add_argument('--record-water-interval',type=float,default=.02)
|
| p.add_argument('--maximum-coupling-iterations',type=int,default=24)
|
| p.add_argument('--resume',type=Path)
|
| p.add_argument('--minimum-solid-dt',type=float,default=.0000125)
|
| p.add_argument('--neighbor-cache',action='store_true')
|
| p.add_argument('--kinematics-only-prediction',action='store_true')
|
| p.add_argument('--adopt-native-result',action='store_true')
|
| p.add_argument('--gas-volume-tolerance',type=float,default=1e-11)
|
| p.add_argument('--grasp-feedback',action='store_true') |
| p.add_argument('--transport-grasp-minimum',type=float,default=.12) |
| p.add_argument('--bulb-center-z',type=float) |
| p.add_argument('--stem-preclose-gap',type=float,default=.014) |
| p.add_argument('--synchronized-motion',action='store_true')
|
| p.add_argument('--recover-solid-dt',type=float,default=0.)
|
| p.add_argument('--coupling-relaxation',type=float,default=1.)
|
| p.add_argument('--coupling-tolerance',type=float,default=5e-9)
|
| p.add_argument('--ccd-tolerance',type=float)
|
| p.add_argument('--ccd-iterations',type=int)
|
| p.add_argument('--independent-grasp-geometry',action='store_true')
|
| p.add_argument('--immersion-depth',type=float,default=.005)
|
| p.add_argument('--aspiration-timeout',type=float,default=12.)
|
| p.add_argument('--stop-request',type=Path)
|
| p.add_argument('--bimanual-stem-support',action='store_true')
|
| p.add_argument('--rack-to-rack-v1',action='store_true',help='New empty-tools dual-rack initial preparation; never reinterpret an old continuation')
|
| p.add_argument('--static-world-contact',action='store_true')
|
| p.add_argument('--world-floor-z',type=float)
|
| p.add_argument('--record-port-flux',action='store_true')
|
| p.add_argument('--substep-port-flux',action='store_true')
|
| p.add_argument('--continuous-glass-wall-table',type=Path)
|
| p.add_argument('--continuous-glass-pressure-table',type=Path)
|
| p.add_argument('--dispense-force-max',type=float,default=3.)
|
| p.add_argument('--swept-water-contact',action='store_true')
|
| p.add_argument('--continuous-floor-viscosity',action='store_true')
|
| p.add_argument('--surface-model',choices=['pair','number_density_energy','number_density_implicit'],default='pair')
|
| p.add_argument('--kernel-support',type=float,default=2.)
|
| p.add_argument('--viscosity-kernel-support',type=float)
|
| p.add_argument('--viscosity-regularization',type=float,default=.01)
|
| p.add_argument('--mirror-no-slip',action='store_true')
|
| p.add_argument('--wall-velocity-model',choices=['quadratic_mirror','adaptive_mirror'],default='quadratic_mirror')
|
| p.add_argument('--pressure-complementarity',action='store_true')
|
| p.add_argument('--pressure-tolerance',type=float,default=5e-5)
|
| p.add_argument('--maximum-pressure-iterations',type=int,default=200)
|
| p.add_argument('--number-density-area-scale',type=float,default=1.)
|
| p.add_argument('--interface-kernel-support',type=float,default=3.)
|
| p.add_argument('--discrete-interface-normalization',action='store_true')
|
| p.add_argument('--interface-epsilon',type=float,default=.05)
|
| a=p.parse_args();out=a.out.resolve();out.mkdir(parents=True,exist_ok=False);started=time.perf_counter() |
| if a.rack_to_rack_v1 and not a.bimanual_stem_support:raise ValueError('Dual-rack V1 requires bimanual support')
|
| if not .007<=a.stem_preclose_gap<=.014:raise ValueError('Stem preclose outside reviewed clearance range') |
| if a.world_floor_z is not None and (not a.static_world_contact or not np.isfinite(a.world_floor_z)):raise ValueError('A finite world floor requires fixed-world fluid contact')
|
| if a.continuous_floor_viscosity and a.world_floor_z is None:raise ValueError('Continuous floor viscosity requires the explicit physical floor')
|
| if a.substep_port_flux and not a.record_port_flux:raise ValueError('Substep flux requires the accepted port-flux ledger')
|
| model=mujoco.MjModel.from_binary_path(str(a.source/'solid/model.mjb'));data=mujoco.MjData(model)
|
| if not 3.<=a.dispense_force_max<=4.:raise ValueError('Dispense effort must remain within the original 4N gripper rating')
|
| if any(model.actuator('left_joint'+str(i)).forcerange[1]<a.dispense_force_max for i in (7,8)):raise ValueError('Requested effort exceeds source model rating')
|
| if a.ccd_tolerance is not None:
|
| if not 0<a.ccd_tolerance<=1e-6:raise ValueError('Invalid high-precision CCD tolerance')
|
| model.opt.ccd_tolerance=a.ccd_tolerance
|
| if a.ccd_iterations is not None:
|
| if a.ccd_iterations<35:raise ValueError('CCD iteration limit may not be reduced')
|
| model.opt.ccd_iterations=a.ccd_iterations
|
| initial=np.load(a.source/'solid/initial_state.npz');data.qpos[:]=initial['qpos'];data.qvel[:]=initial['qvel']
|
| robots=[MotorController(model,data,arm) for arm in ['left','right']]
|
| for r in robots:r.reference=data.qpos[r.qids].copy();r.target=r.reference.copy();data.ctrl[r.uids]=r.reference;data.ctrl[r.gids]=0.;r.grip_reference[:]=0.;r.grip_speed_limit=.03
|
| if a.rack_to_rack_v1 and not a.resume:
|
| for r in robots:r.grip=.044;r.grip_reference[:]=.044;data.ctrl[r.gids]=.044
|
| for actuator in robots[0].gids:model.actuator_forcerange[actuator]=[-3.,3.]
|
| mujoco.mj_forward(model,data);cavity=Cavity(model,data);integrity=BulbIntegrity(cavity)
|
| grasp_geometry=GraspGeometry(model,integrity) if a.independent_grasp_geometry else None
|
| names=['Beaker','Dropper','Tube'];assets=['beaker','dropper_glass','open_original_tube'];meshes=[]
|
| for asset in assets:
|
| mesh=np.load(ROOT/f'assets/generated/{asset}.npz');meshes.append((mesh['vertices'].astype(np.float32),mesh['faces'].astype(np.int32)))
|
| seed=np.load(a.source/'fluid/gpu_seed.npz');origin=seed['origin_world'];spacing=float(seed['spacing'])
|
| if a.surface_model=='number_density_energy' and a.sigma>0 and a.fluid_dt>.25*np.sqrt(998.2*spacing**3/a.sigma):
|
| raise ValueError('Explicit interface timestep exceeds the capillary stability bound')
|
| water=WarpDFSPH(seed,meshes,sigma=a.sigma,cohesion_calibration=.2074,neighbor_cache=a.neighbor_cache,
|
| surface_model=a.surface_model,kernel_support=a.kernel_support,viscosity_kernel_support=a.viscosity_kernel_support,
|
| viscosity_regularization=a.viscosity_regularization,mirror_no_slip=a.mirror_no_slip,wall_velocity_model=a.wall_velocity_model,
|
| pressure_complementarity=a.pressure_complementarity,pressure_tolerance=a.pressure_tolerance,
|
| maximum_pressure_iterations=a.maximum_pressure_iterations,number_density_area_scale=a.number_density_area_scale,interface_kernel_support=a.interface_kernel_support,discrete_interface_normalization=a.discrete_interface_normalization,interface_epsilon=a.interface_epsilon)
|
| if a.continuous_glass_wall_table:
|
| from dropperlab.experimental_sph.continuous_wall_gpu import ContinuousGlassWall
|
| water.continuous_glass_wall=ContinuousGlassWall(water,a.continuous_glass_wall_table)
|
| if a.continuous_glass_pressure_table:
|
| from dropperlab.experimental_sph.continuous_wall_pressure import ContinuousGlassPressure
|
| water.continuous_glass_pressure=ContinuousGlassPressure(water,a.continuous_glass_pressure_table)
|
| if a.swept_water_contact:
|
| from dropperlab.experimental_sph.swept_water_contact import SweptWaterAudit
|
| water.swept_water_audit=SweptWaterAudit(water)
|
| water.port_flux=None
|
| if a.record_port_flux:
|
| from dropperlab.port_flux import PortFluxLedger
|
| initial_water=np.asarray(seed['water']);beaker_local=(initial_water-seed['body_position'][0])@seed['body_rotation'][0]
|
| initial_source=(np.linalg.norm(beaker_local[:,:2],axis=1)<=.032+1e-7)&(beaker_local[:,2]>=.002-1e-7)&(beaker_local[:,2]<=.065+1e-7)
|
| if not initial_source.all():raise RuntimeError('Initial water source is not the physical beaker; source flux cannot be invented')
|
| water.port_flux=PortFluxLedger(water.nf,water.mass,initial_source,water.device,complete_history=not bool(a.resume))
|
| static_component_names=[]
|
| if a.static_world_contact:
|
| from dropperlab.experimental_sph.static_world_contact import StaticWorldContact,scene_mesh
|
| world_vertices,world_faces,static_component_names=scene_mesh(model,data,origin)
|
| planes=None if a.world_floor_z is None else [[np.array([0.,0.,a.world_floor_z])-origin,np.array([0.,0.,1.])]]
|
| water.static_world=StaticWorldContact(water,world_vertices,world_faces,planes=planes)
|
| if a.continuous_floor_viscosity:
|
| from dropperlab.experimental_sph.plane_viscosity import PlaneViscosity
|
| water.static_world.plane_viscosity=PlaneViscosity(water.static_world)
|
| void=np.load(ROOT/'assets/generated/tube_inventory_cavity.npz')
|
| tube_inventory=CavityInventory(water,void['vertices'].astype(np.float32),void['faces'].astype(np.int32))
|
| policy=TransferPolicy(model,data,robots,float(void['vertices'][:,2].max()))
|
| support=GraspSupport(model,data,robots) if a.grasp_feedback else None |
| if not .12<=a.transport_grasp_minimum<=.4:raise ValueError('Transport feedback threshold outside reviewed range') |
| if a.transport_grasp_minimum!=.12 and support is None:raise ValueError('Transport support target requires measured grasp feedback') |
| if support is not None:support.transport_minimum=a.transport_grasp_minimum |
| if a.bulb_center_z is not None: |
| if support is None or not -.01<=a.bulb_center_z<=-.003:raise ValueError('Bulb recentering requires feedback and reviewed pad target') |
| support.bulb_center_z=a.bulb_center_z |
| for r in robots:
|
| r.synchronized_motion=a.synchronized_motion
|
| if a.synchronized_motion:r.motion_speed=.5
|
| recorder=ExperimentRecorder(out,spacing,a.record_water_interval,model=model)
|
| for r,name in zip(robots,['Dropper','Tube']):
|
| sr=data.site(r.arm+'_tcp').xmat.reshape(3,3);sp=data.site(r.arm+'_tcp').xpos
|
| r.held=(name,sr.T@(data.body(name).xpos-sp),sr.T@data.body(name).xmat.reshape(3,3))
|
| if a.rack_to_rack_v1 and not a.resume:
|
| for r in robots:r.held=None
|
| dry=data.body('Dropper').xpos.copy();beaker=data.body('Beaker').xpos.copy()
|
| initial_depth=water.nf*water.volume/(np.pi*.032**2)
|
| wet=np.r_[beaker[:2],beaker[2]+.002+max(3*spacing,initial_depth-a.immersion_depth)]
|
| pred=mujoco.MjData(model);integration=np.empty(mujoco.mj_stateSize(model,mujoco.mjtState.mjSTATE_INTEGRATION));previous=np.zeros((3,6))
|
| mujoco.mj_forward(model,pred)
|
| corrected=mujoco.MjData(model);mujoco.mj_forward(model,corrected)
|
| corrected_cavity=Cavity(model,corrected);predicted_cavity=Cavity(model,pred)
|
| prediction_state=np.empty_like(integration)
|
| sealed=False;sealed_at=None;last_plan=-1.;rows=[];states=[];report={'status':'running','task_success':False,'physics_qualified':False,
|
| 'scope':'unqualified same-run 3D-water aspiration/dispense/rack candidate; initially held objects','water_particles':water.nf,'spacing_m':spacing}
|
| report['adaptive_contact_retries']=0
|
| report['coupling_recomputations']=0
|
| report['rejected_solid_intervals']=0
|
| report['initial_water_ml']=water.nf*water.volume*1e6
|
| report['immersion_depth_below_initial_surface_m']=a.immersion_depth
|
| report['wet_tip_target_m']=wet.tolist()
|
| report['neighbor_cache']=a.neighbor_cache
|
| report['kinematics_only_prediction']=a.kinematics_only_prediction
|
| report['gas_volume_tolerance_m3']=a.gas_volume_tolerance
|
| report['grasp_feedback']=a.grasp_feedback;report['synchronized_motion']=a.synchronized_motion
|
| report['recover_solid_dt_max_s']=a.recover_solid_dt
|
| if not 0.<a.coupling_relaxation<=1.:raise ValueError('Coupling relaxation must be in (0,1]')
|
| report['coupling_relaxation']=a.coupling_relaxation
|
| if not 0.<a.coupling_tolerance<=5e-8:raise ValueError('Coupling tolerance must be positive and no more than 50 nm')
|
| report['coupling_tolerance_m']=a.coupling_tolerance
|
| report['native_ccd_tolerance']=model.opt.ccd_tolerance;report['native_ccd_iterations']=model.opt.ccd_iterations
|
| report['independent_grasp_geometry']=a.independent_grasp_geometry
|
| report['static_water_world_contact']=a.static_world_contact
|
| report['static_world_collider_components']=len(static_component_names)
|
| report['record_port_flux']=a.record_port_flux
|
| report['substep_port_flux']=a.substep_port_flux
|
| report['native_commit']='copy accepted native FSI endpoint' if a.adopt_native_result else 'independent repeat integration'
|
| report['world_floor_z']=a.world_floor_z
|
| report['floor_scope']='Fixed infinite liquid support plane; native solids must remain strictly above it' if a.world_floor_z is not None else 'No ground plane'
|
| checkpoint_parameters={k:getattr(a,k) for k in ['sigma','release_duration','release_gap','fluid_dt','immersion_depth']} |
| if a.rack_to_rack_v1:checkpoint_parameters['rack_to_rack_v1']=True
|
| if a.transport_grasp_minimum!=.12:checkpoint_parameters['transport_grasp_minimum']=a.transport_grasp_minimum |
| if a.bulb_center_z is not None:checkpoint_parameters['bulb_center_z']=a.bulb_center_z |
| if a.stem_preclose_gap!=.014:checkpoint_parameters['stem_preclose_gap']=a.stem_preclose_gap |
| if a.substep_port_flux:checkpoint_parameters['substep_port_flux']=True
|
| if a.world_floor_z is not None:checkpoint_parameters['world_floor_z']=a.world_floor_z
|
| if a.dispense_force_max!=3.:checkpoint_parameters['dispense_force_max']=a.dispense_force_max
|
| if a.swept_water_contact:checkpoint_parameters['swept_water_contact']=True
|
| if a.continuous_floor_viscosity:checkpoint_parameters['continuous_floor_viscosity']=True
|
| if a.continuous_glass_wall_table:
|
| checkpoint_parameters['continuous_glass_wall_table_sha256']=water.continuous_glass_wall.sha256
|
| report['continuous_wall_scope']='Opt-in continuous annular glass adhesion potential; all native collision facets unchanged. Wall-force model migration is explicit; not inherited physical qualification.'
|
| if a.continuous_glass_pressure_table:
|
| checkpoint_parameters['continuous_glass_pressure_table_sha256']=water.continuous_glass_pressure.sha256
|
| report['continuous_pressure_scope']='Consistent continuous annular glass density/divergence/pressure/reaction operator. Native collision facets unchanged. Explicit numerical model migration, not inherited qualification.'
|
| advanced_defaults=dict(surface_model='pair',kernel_support=2.,viscosity_kernel_support=None,viscosity_regularization=.01,
|
| mirror_no_slip=False,wall_velocity_model='quadratic_mirror',pressure_complementarity=False,
|
| pressure_tolerance=5e-5,maximum_pressure_iterations=200,number_density_area_scale=1.,interface_kernel_support=3.,discrete_interface_normalization=False,interface_epsilon=.05)
|
| if any(getattr(a,k)!=v for k,v in advanced_defaults.items()):
|
| checkpoint_parameters.update({k:getattr(a,k) for k in advanced_defaults})
|
| checkpoint_parameters.update(seed_spacing_m=spacing,initial_particle_count=water.nf)
|
| report['solver_parameters']=checkpoint_parameters.copy()
|
| if a.resume:
|
| previous,logic,resume_meta=load_checkpoint(a.resume,a.source/'solid/model.mjb',model,data,water,robots,cavity,policy,checkpoint_parameters,
|
| restore_numerical_options=a.ccd_tolerance is None and a.ccd_iterations is None)
|
| sealed,sealed_at,last_plan=logic;report['resumed_accepted_state']=str(a.resume.resolve())
|
| report['resumed_physical_time']=float(data.time)
|
| if a.bimanual_stem_support:
|
| from dropperlab.bimanual_policy import BimanualPolicy
|
| if a.rack_to_rack_v1:
|
| from dropperlab.rack_to_rack_policy import RackToRackPolicy
|
| saved_policy={k:v for k,v in policy.__dict__.items() if k not in ['model','data','robots']}
|
| saved_targets=[r.target.copy() for r in robots]
|
| policy=(RackToRackPolicy if a.rack_to_rack_v1 else BimanualPolicy)(model,data,robots,float(void['vertices'][:,2].max()))
|
| if saved_policy.get('policy_kind') in ('bimanual_stem_support_v1','rack_to_rack_v1'):
|
| if a.rack_to_rack_v1 and saved_policy.get('policy_kind')!='rack_to_rack_v1':raise RuntimeError('Old held-object trajectory cannot become new cold-start V1')
|
| policy.__dict__.update(saved_policy)
|
| for r,target in zip(robots,saved_targets):r.target=target
|
| if saved_policy.get('controller_revision',1)<2:
|
| if policy.stem_secured or policy.stage not in ['await_dose','lift_after_aspiration','transfer_for_stem_support','park_above','park_seat','park_release','park_retreat']:
|
| raise RuntimeError('The reviewed grasp revision requires a checkpoint before the rigid stem grasp')
|
|
|
|
|
| policy.stem_rotation=np.diag([-1.,-1.,1.]).tolist();policy.stem_height=.080
|
| policy.controller_revision=2
|
| policy.events.append(dict(time=float(data.time),stage='reviewed_unexecuted_stem_approach_revision'))
|
| else:policy.events=saved_policy['events']+[{'time':float(data.time),'stage':'bimanual_stem_support_adaptation'}]
|
| policy.dispense_force_max=a.dispense_force_max |
| policy.stem_preclose_gap=a.stem_preclose_gap |
| if not a.resume and not a.rack_to_rack_v1:policy.stage='await_dose';policy.entered=float(data.time);policy.events=[]
|
| report['scope']='unqualified coupled 3D-water transfer with contact-only second-hand rigid glass support'
|
| report['bimanual_stem_support']=True
|
| if a.rack_to_rack_v1:report.update(scope='New cold-start V1: empty dropper on A, inverted empty tube on B, initially empty home hands',rack_to_rack_v1=True)
|
| recorder.capture(data,water.positions_numpy()+origin,water_velocity=water.velocities_numpy())
|
| print(json.dumps({'stage':'gpu_coupled_initialized','particles':water.nf,'wall_seconds':time.perf_counter()-started}),flush=True)
|
| def poses(offset,length):
|
| positions=[];rotations=[];centers=[];linear=[];angular=[]
|
| for name in names:
|
| b=data.body(name);e=pred.body(name);c0=data.xipos[b.id];c1=pred.xipos[e.id]
|
| r0=b.xmat.reshape(3,3);vector=Rotation.from_matrix(e.xmat.reshape(3,3)@r0.T).as_rotvec();fraction=np.clip(offset/length,0,1)
|
| r=Rotation.from_rotvec(vector*fraction).as_matrix()@r0;c=(1-fraction)*c0+fraction*c1
|
| positions.append(c+r@(r0.T@(b.xpos-c0))-origin);rotations.append(r);centers.append(c-origin)
|
| linear.append((c1-c0)/length);angular.append(vector/length)
|
| return np.array(positions),np.array(rotations),np.array(centers),np.array(linear),np.array(angular)
|
| def sync_current():
|
| position=[];rotation=[];com=[];linear=[];angular=[]
|
| for name in names:
|
| body=data.body(name);velocity=np.empty(6)
|
| mujoco.mj_objectVelocity(model,data,mujoco.mjtObj.mjOBJ_BODY,body.id,velocity,0)
|
| position.append(body.xpos-origin);rotation.append(body.xmat.reshape(3,3));com.append(data.xipos[body.id]-origin)
|
| linear.append(velocity[3:]);angular.append(velocity[:3])
|
| water.sync_bodies(position,rotation,com,linear,angular)
|
| def prediction_geometry(state):
|
| if a.kinematics_only_prediction:
|
| mujoco.mj_kinematics(model,state);mujoco.mj_comPos(model,state);mujoco.mj_flex(model,state)
|
| else:mujoco.mj_forward(model,state)
|
| def endpoint_geometry(state):
|
| if a.kinematics_only_prediction:prediction_geometry(state)
|
| else:mujoco.mj_fwdPosition(model,state)
|
| try:
|
| frame=0;next_step_recovery=float(data.time)+.005;controlled_stop=False
|
| while data.time<a.duration-1e-10:
|
| if water.port_flux is not None and not a.substep_port_flux:
|
|
|
|
|
| model.opt.timestep=min(model.opt.timestep,a.fluid_dt,a.recover_solid_dt if a.recover_solid_dt>0 else a.fluid_dt)
|
| t=float(data.time);dt=float(model.opt.timestep)
|
| previous_before=previous.copy()
|
| start=IntervalState(model,data,robots,cavity,policy)
|
| initial_logic=(sealed,sealed_at,last_plan)
|
| checkpoint=water.candidate_checkpoint()
|
|
|
|
|
| flux_snapshot=water.port_flux.snapshot() if water.port_flux is not None and a.substep_port_flux else None
|
| tip_before=data.body('Dropper').xpos.copy()-origin
|
| rotation_before=data.body('Dropper').xmat.reshape(3,3).copy()
|
| if water.port_flux is not None and not a.substep_port_flux and dt>a.fluid_dt+1e-15:
|
| raise RuntimeError('Port-flux measurement requires each accepted solid interval to contain at most one water step')
|
| sync_current()
|
| bore_ml=water.bore_volume()*1e6;tube_ml=tube_inventory.volume()*1e6
|
| if support and a.bimanual_stem_support:
|
| support.right_object=policy.right_object;support.left_object=getattr(policy,'left_object','Dropper')
|
| grasp_ready=support.regulate(policy) if support else True
|
| vertices=data.flexvert_xpos[cavity.start:cavity.start+integrity.total_vertices]
|
| jac_start=np.linalg.det(vertices[integrity.tetrahedra[:,1:]]-vertices[integrity.tetrahedra[:,0,None]])/integrity.reference_det
|
| if policy.stage in ['dispense','supported_dispense'] or a.bimanual_stem_support:
|
| policy.regulate_dispense(float(jac_start.min()),cavity.pressure)
|
| if a.rack_to_rack_v1:policy.measured_bulb_volume_m3=cavity.volume()
|
| policy.port_colour=float(water.port_color())
|
| active_transfer=policy.update(bore_ml,tube_ml,grasp_ready)
|
| aspiration_elapsed=t-policy.entered if a.rack_to_rack_v1 else t
|
| if not active_transfer and aspiration_elapsed>a.aspiration_timeout:raise RuntimeError('Actual 1 mL aspiration not established before timeout')
|
| if not active_transfer and t-last_plan>.02:
|
| last_plan=t;policy.command_aspiration(wet)
|
| color=water.port_color();surface=data.body('Beaker').xpos[2]+.002+water.nf*water.volume/(np.pi*.032**2)
|
| if not sealed and color>.25 and data.body('Dropper').xpos[2]<surface-spacing:sealed=True;sealed_at=t
|
| alpha=np.clip((t-((sealed_at+.03) if sealed_at is not None else float('inf')))/a.release_duration,0,1)
|
| limit=3.-2.2*alpha*alpha*(3-2*alpha)
|
| if not active_transfer:
|
| for actuator in robots[0].gids:model.actuator_forcerange[actuator]=[-limit,limit]
|
| else:limit=float(model.actuator_forcerange[robots[0].gids[0],1])
|
| joint_fraction=None
|
| if a.bimanual_stem_support and policy.stem_secured:
|
| maximum=max(float(np.max(np.abs(r.target-r.reference))) for r in robots)
|
| joint_fraction=min(1.,.5*dt/max(maximum,1e-15))
|
| for i,r in enumerate(robots):
|
| if not active_transfer:r.grip=min(a.release_gap*alpha*alpha*(3-2*alpha),policy.safe_grip_ceiling) if i==0 else (.044 if a.rack_to_rack_v1 else 0.)
|
| r.update(dt,joint_fraction=joint_fraction)
|
|
|
|
|
| vented=not sealed or (active_transfer and bore_ml<.001 and color<.1)
|
| cavity.apply(dt,vented=vented,water_volume=water.bore_volume(),apply_forces=False)
|
| data.xfrc_applied[:]=0.;cavity.apply_pressure(cavity.pressure)
|
| for i,name in enumerate(names):data.xfrc_applied[model.body(name).id]+=previous[i]
|
| mujoco.mj_getState(model,data,integration,mujoco.mjtState.mjSTATE_INTEGRATION);mujoco.mj_setState(model,pred,integration,mujoco.mjtState.mjSTATE_INTEGRATION)
|
| if not a.kinematics_only_prediction:mujoco.mj_forward(model,pred)
|
| mujoco.mj_step(model,pred);endpoint_geometry(pred)
|
| volume_start=cavity.volume()
|
| water.contact_predictor_recovery=a.contact_predictor_recovery
|
| water.paired_world_contact=a.paired_world_contact
|
| if a.paired_world_contact and not hasattr(water,'paired_contact_applied'):
|
| water.paired_contact_applied=wp.zeros(1,dtype=int,device=water.device)
|
| for coupling in range(a.maximum_coupling_iterations):
|
| if coupling:
|
| water.reject_candidate_interval(checkpoint);report['coupling_recomputations']+=1
|
| if a.substep_port_flux:water.port_flux.reject(flux_snapshot)
|
| substeps=max(1,math.ceil(dt/min(a.fluid_dt,.3*spacing/max(water.maximum_speed(),.1))));nominal_h=dt/substeps
|
| impulse=np.zeros((3,6));pressure_sum=0.;volume_end=predicted_cavity.volume()
|
| elapsed=0.;retry_limit=nominal_h;rejected_prediction=False
|
| while elapsed<dt-1e-14:
|
| h=min(retry_limit,dt-elapsed)
|
| pos,rot,com,lin,ang=poses(elapsed,dt);end_pos,end_rot,_,_,_=poses(elapsed+h,dt)
|
| water.sync_bodies(pos,rot,com,lin,ang,end_pos,end_rot)
|
| volume=volume_start+(volume_end-volume_start)*(elapsed+.5*h)/dt
|
| gas=volume+cavity.dead_volume-water.bore_volume();pressure=cavity.gas_pv/gas
|
| if gas<=1e-7 or pressure<3000:raise RuntimeError('Invalid gas state')
|
| flux_before=None
|
| if a.substep_port_flux:
|
| flux_before=wp.empty(water.nf,dtype=wp.vec3,device=water.device);wp.copy(flux_before,water.x,count=water.nf)
|
| try:liquid=water.step(h,gas_pressure=pressure-cavity.patm)
|
| except RuntimeError as e:
|
| if a.contact_predictor_recovery and 'physical CAD contact rejected' in str(e) and h<1e-6 and water.rejected_candidate_wrench is not None:
|
|
|
|
|
|
|
| trial_force,trial_torque=water.rejected_candidate_wrench
|
| seed_impulse=impulse.copy()
|
| for i,name in enumerate(names):
|
| actual_com=data.xipos[model.body(name).id]-origin
|
| seed_impulse[i]+=(dt-elapsed)*np.r_[trial_force[i],trial_torque[i]+np.cross(com[i]-actual_com,trial_force[i])]
|
| mujoco.mj_setState(model,corrected,integration,mujoco.mjtState.mjSTATE_INTEGRATION)
|
| prediction_geometry(corrected);corrected.xfrc_applied[:]=0.
|
| corrected_cavity.apply_pressure((pressure_sum+(dt-elapsed)*pressure)/dt)
|
| for i,name in enumerate(names):corrected.xfrc_applied[model.body(name).id]+=seed_impulse[i]/dt
|
| mujoco.mj_step(model,corrected);endpoint_geometry(corrected)
|
| mujoco.mj_getState(model,corrected,prediction_state,mujoco.mjtState.mjSTATE_INTEGRATION)
|
| mujoco.mj_setState(model,pred,prediction_state,mujoco.mjtState.mjSTATE_INTEGRATION);prediction_geometry(pred)
|
| rejected_prediction=True
|
| report['contact_predictor_retries']=report.get('contact_predictor_retries',0)+1
|
| print(json.dumps({'stage':'rejected_contact_predictor_retry','time':t,'coupling_iteration':coupling,'rejected_water_step':h}),flush=True)
|
| break
|
| if not a.adaptive_contact or 'physical CAD contact rejected' not in str(e) or h<1e-6:raise
|
| retry_limit=h/2;report['adaptive_contact_retries']+=1
|
| continue
|
| if a.substep_port_flux:
|
|
|
|
|
|
|
| water.port_flux.advance(flux_before,water.x,pos[1],rot[1],end_pos[1],end_rot[1])
|
| force=water.force.numpy();torque=water.torque.numpy()
|
| for i,name in enumerate(names):
|
| actual_com=data.xipos[model.body(name).id]-origin
|
| impulse[i]+=h*np.r_[force[i],torque[i]+np.cross(com[i]-actual_com,force[i])]
|
| pressure_sum+=h*pressure;elapsed+=h
|
| if rejected_prediction:
|
| endpoint_error=float('inf');volume_endpoint_error=float('inf');geometry_failures=1
|
| continue
|
|
|
|
|
| mujoco.mj_setState(model,corrected,integration,mujoco.mjtState.mjSTATE_INTEGRATION)
|
| prediction_geometry(corrected);corrected.xfrc_applied[:]=0.
|
| corrected_cavity.apply_pressure(pressure_sum/dt)
|
| for i,name in enumerate(names):corrected.xfrc_applied[model.body(name).id]+=impulse[i]/dt
|
| mujoco.mj_step(model,corrected);endpoint_geometry(corrected)
|
| endpoint_position=np.array([corrected.body(name).xpos-origin for name in names])
|
| endpoint_rotation=np.array([corrected.body(name).xmat.reshape(3,3) for name in names])
|
| geometry_failures=water.actual_geometry_failures(endpoint_position,endpoint_rotation)
|
| endpoint_error=max(float(np.linalg.norm(corrected.body(name).xpos-pred.body(name).xpos))+
|
| .15*float(np.linalg.norm(corrected.body(name).xmat-pred.body(name).xmat)) for name in names)
|
| volume_endpoint_error=abs(corrected_cavity.volume()-predicted_cavity.volume())
|
| if endpoint_error<a.coupling_tolerance and volume_endpoint_error<=a.gas_volume_tolerance and geometry_failures==0:break
|
| mujoco.mj_getState(model,corrected,prediction_state,mujoco.mjtState.mjSTATE_INTEGRATION)
|
| if a.coupling_relaxation<1.:
|
| old_qpos=pred.qpos.copy();old_qvel=pred.qvel.copy()
|
| difference=np.empty(model.nv)
|
| mujoco.mj_differentiatePos(model,difference,1.,old_qpos,corrected.qpos)
|
| mujoco.mj_setState(model,pred,prediction_state,mujoco.mjtState.mjSTATE_INTEGRATION)
|
|
|
|
|
| pred.qpos[:]=old_qpos;mujoco.mj_integratePos(model,pred.qpos,difference,a.coupling_relaxation)
|
| pred.qvel[:]=(1-a.coupling_relaxation)*old_qvel+a.coupling_relaxation*corrected.qvel
|
| else:mujoco.mj_setState(model,pred,prediction_state,mujoco.mjtState.mjSTATE_INTEGRATION)
|
| prediction_geometry(pred)
|
| else:
|
| water.reject_candidate_interval(checkpoint)
|
| if a.substep_port_flux:water.port_flux.reject(flux_snapshot)
|
| if dt<=a.minimum_solid_dt:raise RuntimeError(f'FSI candidate did not converge at minimum solid step; error={endpoint_error:g}, gas volume error={volume_endpoint_error:g}, CAD failures={geometry_failures}')
|
| start.reject(model,data,robots,cavity,policy);sealed,sealed_at,last_plan=initial_logic
|
| model.opt.timestep=max(a.minimum_solid_dt,dt/2);report['rejected_solid_intervals']+=1
|
| next_step_recovery=t+.020
|
| print(json.dumps({'stage':'rejected_coupled_interval_retry','time':t,'new_solid_dt':model.opt.timestep,
|
| 'endpoint_error_m':endpoint_error,'gas_volume_error_m3':volume_endpoint_error,'actual_cad_failures':geometry_failures}),flush=True)
|
| continue
|
| data.xfrc_applied[:]=0.;cavity.apply_pressure(pressure_sum/dt)
|
| previous=impulse/dt
|
| for i,name in enumerate(names):data.xfrc_applied[model.body(name).id]+=previous[i]
|
| if a.adopt_native_result:
|
|
|
|
|
| mujoco.mj_copyData(data,model,corrected)
|
| else:mujoco.mj_step(model,data)
|
| mujoco.mj_fwdPosition(model,data)
|
| if np.max(np.abs(data.qpos-corrected.qpos))>1e-10:raise RuntimeError('Live solid integration differs from corrected native endpoint')
|
| if any(c.dist<-.0001 for c in data.contact):raise RuntimeError('Solid contact overlap exceeds 0.1 mm')
|
| sync_current()
|
| if water.tabletop_geometry_failures(origin):raise RuntimeError('Water/table geometry guard; stationary world-fluid contacts remain unqualified')
|
| if any(w.number for w in data.warning):raise RuntimeError('Native solid warning')
|
| if a.world_floor_z is not None:
|
| moving=(model.body_weldid[model.geom_bodyid]!=0)&(model.geom_contype!=0)
|
| if np.any(data.geom_xpos[moving,2]-model.geom_rbound[moving]<=a.world_floor_z):raise RuntimeError('Native solid approached the liquid-only ground plane; native ground collision must be modeled before continuing')
|
| vertices=data.flexvert_xpos[cavity.start:cavity.start+integrity.total_vertices]
|
| jac=np.linalg.det(vertices[integrity.tetrahedra[:,1:]]-vertices[integrity.tetrahedra[:,0,None]])/integrity.reference_det
|
| if jac.min()<.5:raise RuntimeError('FEM material guard')
|
| if water.port_flux is not None and not a.substep_port_flux:
|
| water.port_flux.advance(checkpoint[0],water.x,tip_before,rotation_before,
|
| data.body('Dropper').xpos-origin,data.body('Dropper').xmat.reshape(3,3))
|
| if frame%33==0:
|
| geometry=integrity.check();row={'time':float(data.time),'stage':policy.stage if active_transfer else 'aspirate' if alpha>0 else 'immerse',
|
| 'bore_water_ml':water.bore_volume()*1e6,'bulb_volume_ml':cavity.volume()*1e6,'gas_pressure_pa':pressure_sum/dt,
|
| 'tube_water_ml':tube_inventory.volume()*1e6,
|
| 'velocity_max':water.maximum_speed(),'left_force_limit_n':limit,'left_grip_target_m':robots[0].grip,'port_color':color,**geometry}
|
| if grasp_geometry:row['independent_fem_jaw_overlap_m']=grasp_geometry.check(data)
|
| row.update(coupling_iterations=coupling+1,solid_endpoint_error_m=endpoint_error,
|
| gas_volume_endpoint_error_m3=volume_endpoint_error,actual_endpoint_cad_failures=geometry_failures)
|
| row.update(liquid)
|
| if water.port_flux is not None:row.update(water.port_flux.summary())
|
| row.update(left_joint_target_rad=robots[0].target.tolist(),
|
| left_tcp_world_m=data.site('left_tcp').xpos.tolist(),
|
| dropper_world_m=data.body('Dropper').xpos.tolist(),
|
| aspiration_arm_hold=policy.aspiration_goal_set,dispense_feedback=policy.dispense_feedback)
|
| if support:row['native_grasp_normal_forces_n']=policy.contact_support
|
| if support and policy.stage in ['home','settle']:
|
| from dropperlab.seating_measurement import measured_seats
|
| row.update(measured_seats(model,support.state_view(),robots))
|
| rows.append(row);states.append(data.qpos.copy());report['last_state']=row;report['wall_seconds']=time.perf_counter()-started
|
| if data.time-recorder.last>=a.record_water_interval-1e-10:
|
| recorder.capture(data,water.positions_numpy()+origin,water_velocity=water.velocities_numpy())
|
| save_checkpoint(out/'accepted_checkpoint.npz',a.source/'solid/model.mjb',model,data,water,robots,cavity,policy,previous,(sealed,sealed_at,last_plan),checkpoint_parameters)
|
| (out/'progress.json').write_text(json.dumps(report,indent=2));print(json.dumps(row),flush=True)
|
| if policy.done:break
|
| if a.stop_request and a.stop_request.exists():controlled_stop=True;break
|
| if a.recover_solid_dt>0 and data.time>=next_step_recovery and coupling<4:
|
| model.opt.timestep=min(a.recover_solid_dt,2*model.opt.timestep)
|
| next_step_recovery=float(data.time)+.020
|
| frame+=1
|
| report['status']='completed'
|
| report['execution_complete']=policy.done
|
| if not policy.done:report.update(status='incomplete',error='Controlled stop at an accepted coupled boundary' if controlled_stop else 'Physical time limit reached before the full sequence completed')
|
| recorder.capture(data,water.positions_numpy()+origin,force=True,water_velocity=water.velocities_numpy())
|
| save_checkpoint(out/'accepted_checkpoint.npz',a.source/'solid/model.mjb',model,data,water,robots,cavity,policy,previous,(sealed,sealed_at,last_plan),checkpoint_parameters)
|
| except Exception as e: |
| report.update(status='failed',error=str(e));print(str(e),flush=True) |
| if 'swept water path' in str(e) and getattr(water,'swept_water_audit',None) is not None: |
| report['swept_failure_detail']=water.swept_water_audit.describe_failure() |
|
|
|
|
| if 'checkpoint' in locals():
|
| water.reject_candidate_interval(checkpoint)
|
| if flux_snapshot is not None:water.port_flux.reject(flux_snapshot)
|
| start.reject(model,data,robots,cavity,policy);sealed,sealed_at,last_plan=initial_logic
|
| previous=previous_before
|
| report['failed_interval_rolled_back']=True
|
| sync_current()
|
| positions=np.array([data.body(name).xpos-origin for name in names])
|
| rotations=np.array([data.body(name).xmat.reshape(3,3) for name in names])
|
| failures=water.actual_geometry_failures(positions,rotations)
|
| report['rollback_state_cad_failures']=failures
|
| if not failures:
|
| save_checkpoint(out/'accepted_checkpoint.npz',a.source/'solid/model.mjb',model,data,water,robots,cavity,policy,previous,(sealed,sealed_at,last_plan),checkpoint_parameters)
|
| report.update(physical_seconds=float(data.time),wall_seconds=time.perf_counter()-started)
|
| report['phase_events']=policy.events
|
| if water.port_flux is not None:report.update(water.port_flux.summary())
|
| (out/'report.json').write_text(json.dumps(report,indent=2));(out/'trajectory.json').write_text(json.dumps(rows,indent=2))
|
| np.savez_compressed(out/'solid_states.npz',qpos=np.array(states))
|
| np.savez_compressed(out/'final_water.npz',position=water.positions_numpy()+origin,velocity=water.velocities_numpy(),mass=water.mass)
|
| print(json.dumps({k:v for k,v in report.items() if k!='last_state'},indent=2))
|
|
|
