"""Unified Dev15 worker with live mechanics, kinematics, and friction audits.""" from __future__ import annotations import copy import fnmatch import hashlib import json import math import sys from pathlib import Path import time from typing import Any import types import mujoco import numpy as np from physics_diagnostics import annotate_kinematics, energy_summary, mechanics_snapshot def sha256_file(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as handle: for block in iter(lambda: handle.read(1024 * 1024), b""): digest.update(block) return digest.hexdigest() def load_json(path: Path) -> dict[str, Any]: with path.open("r", encoding="utf-8") as handle: return json.load(handle) def _execute_source(path: Path, module_name: str): module = types.ModuleType(module_name) module.__file__ = str(path) module.__package__ = "" sys.modules[module_name] = module code = compile(path.read_bytes(), str(path), "exec") exec(code, module.__dict__) return module def import_class(path: Path, symbol: str): module_name = "simcode4d_dynamic_" + hashlib.sha256( (str(path) + ":" + sha256_file(path)).encode() ).hexdigest()[:16] support_names = [ name for name in ( "probe_api", "base_control", "mobile_control", "common", "dev15_common", ) if (path.parent / (name + ".py")).is_file() ] managed_names = support_names + [module_name] sentinel = object() previous_modules = { name: sys.modules.get(name, sentinel) for name in managed_names } previous_path = list(sys.path) sys.path.insert(0, str(path.parent)) try: for support_name in support_names: _execute_source(path.parent / (support_name + ".py"), support_name) module = _execute_source(path, module_name) finally: sys.path[:] = previous_path for name, previous in previous_modules.items(): if previous is sentinel: sys.modules.pop(name, None) else: sys.modules[name] = previous return getattr(module, symbol) def _named_id(model, object_type, name: str) -> int: result = mujoco.mj_name2id(model, object_type, name) if result < 0: raise KeyError(name) return int(result) def _body_free_joint(model, body_name: str) -> int | None: body_id = _named_id(model, mujoco.mjtObj.mjOBJ_BODY, body_name) first = int(model.body_jntadr[body_id]) count = int(model.body_jntnum[body_id]) for joint_id in range(first, first + count): if model.jnt_type[joint_id] == mujoco.mjtJoint.mjJNT_FREE: return joint_id return None def _set_free_pose(model, data, body_name: str, position=None, quaternion=None) -> None: joint_id = _body_free_joint(model, body_name) if joint_id is None: raise ValueError("body has no free joint: " + body_name) address = int(model.jnt_qposadr[joint_id]) if position is not None: data.qpos[address:address + 3] = np.asarray(position, dtype=float) if quaternion is not None: quat = np.asarray(quaternion, dtype=float) quat = quat / np.linalg.norm(quat) data.qpos[address + 3:address + 7] = quat def _offset_free_pose(model, data, body_name: str, xyz, yaw_rad: float = 0.0) -> None: joint_id = _body_free_joint(model, body_name) if joint_id is None: return address = int(model.jnt_qposadr[joint_id]) data.qpos[address:address + 3] += np.asarray(xyz, dtype=float) if yaw_rad: current = data.qpos[address + 3:address + 7].copy() delta = np.asarray([math.cos(yaw_rad / 2.0), 0.0, 0.0, math.sin(yaw_rad / 2.0)]) result = np.empty(4) mujoco.mju_mulQuat(result, delta, current) data.qpos[address + 3:address + 7] = result / np.linalg.norm(result) def _hfield_height(model, geom_name: str, x: float, y: float) -> float: geom_id = _named_id(model, mujoco.mjtObj.mjOBJ_GEOM, geom_name) hfield_id = int(model.geom_dataid[geom_id]) rows = int(model.hfield_nrow[hfield_id]) cols = int(model.hfield_ncol[hfield_id]) hx, hy, hz, _ = model.hfield_size[hfield_id] cx, cy, cz = model.geom_pos[geom_id] u = np.clip((x - (cx - hx)) / (2.0 * hx) * (cols - 1), 0.0, cols - 1.0) v = np.clip((y - (cy - hy)) / (2.0 * hy) * (rows - 1), 0.0, rows - 1.0) c0, r0 = int(np.floor(u)), int(np.floor(v)) c1, r1 = min(c0 + 1, cols - 1), min(r0 + 1, rows - 1) du, dv = u - c0, v - r0 address = int(model.hfield_adr[hfield_id]) values = model.hfield_data[address:address + rows * cols].reshape(rows, cols) normalized = ( (1.0 - du) * (1.0 - dv) * values[r0, c0] + du * (1.0 - dv) * values[r0, c1] + (1.0 - du) * dv * values[r1, c0] + du * dv * values[r1, c1] ) return float(cz + hz * normalized) def _initialize_hfield_vehicle(model, data, init: dict[str, Any]) -> None: body_name = init["body"] x, y = init["xy"] yaw = float(init["yaw_rad"]) wheel_xy = np.asarray(init["wheel_xy_m"], dtype=float) radius = float(init["wheel_radius_m"]) center_z = float(init["wheel_center_z_m"]) heading = np.asarray([math.cos(yaw), math.sin(yaw), 0.0]) lateral = np.asarray([-math.sin(yaw), math.cos(yaw), 0.0]) points = np.asarray([x, y]) + wheel_xy[:, :1] * heading[:2] + wheel_xy[:, 1:] * lateral[:2] heights = np.asarray([_hfield_height(model, init["hfield_geom"], px, py) for px, py in points]) matrix = np.column_stack([points, np.ones(len(points))]) a, b, c = np.linalg.lstsq(matrix, heights, rcond=None)[0] normal = np.asarray([-a, -b, 1.0]) normal /= np.linalg.norm(normal) forward = heading - np.dot(heading, normal) * normal forward /= np.linalg.norm(forward) side = np.cross(normal, forward) rotation = np.column_stack([forward, side, normal]) quaternion = np.zeros(4) mujoco.mju_mat2Quat(quaternion, rotation.reshape(-1)) ground = float(a * x + b * y + c) root = np.asarray([x, y, ground]) + normal * (radius - center_z + float(init.get("clearance_m", 0.003))) _set_free_pose(model, data, body_name, root, quaternion) def _seat_hfield_vehicle(model, data, init: dict[str, Any]) -> None: joint_id = _body_free_joint(model, init["body"]) if joint_id is None: raise ValueError("hfield vehicle has no free joint: " + init["body"]) address = int(model.jnt_qposadr[joint_id]) target_distance = float(init.get("contact_target_distance_m", -0.0001)) mujoco.mj_forward(model, data) for _ in range(64): if data.ncon: minimum_distance = min(float(data.contact[index].dist) for index in range(data.ncon)) correction = target_distance - minimum_distance if abs(correction) <= 1e-7: break data.qpos[address + 2] += correction else: data.qpos[address + 2] -= 0.001 mujoco.mj_forward(model, data) def _apply_initialization(model, data, gold: dict[str, Any], perturbation: dict[str, Any]) -> None: initialization = gold["initialization"] keyframe = initialization.get("keyframe") if keyframe: key_id = _named_id(model, mujoco.mjtObj.mjOBJ_KEY, keyframe) mujoco.mj_resetDataKeyframe(model, data, key_id) else: mujoco.mj_resetData(model, data) if "hfield_vehicle" in initialization: _initialize_hfield_vehicle(model, data, initialization["hfield_vehicle"]) for body_name, pose in initialization.get("free_body_poses", {}).items(): _set_free_pose(model, data, body_name, pose.get("position"), pose.get("quaternion_wxyz")) for joint_name, value in initialization.get("joint_positions", {}).items(): joint_id = _named_id(model, mujoco.mjtObj.mjOBJ_JOINT, joint_name) data.qpos[int(model.jnt_qposadr[joint_id])] = float(value) for body_name, offset in initialization.get("free_body_offsets_m", {}).items(): _offset_free_pose(model, data, body_name, offset) for body_name, offset in perturbation.get("body_xy_offset_m", {}).items(): _offset_free_pose(model, data, body_name, [offset[0], offset[1], 0.0]) for body_name, yaw in perturbation.get("body_yaw_offset_rad", {}).items(): _offset_free_pose(model, data, body_name, [0.0, 0.0, 0.0], float(yaw)) if "hfield_vehicle" in initialization: _seat_hfield_vehicle(model, data, initialization["hfield_vehicle"]) data.qvel[:] = 0.0 data.ctrl[:] = 0.0 mujoco.mj_forward(model, data) if "hfield_vehicle" in initialization: max_depth = max((max(0.0, -float(data.contact[i].dist)) for i in range(data.ncon)), default=0.0) if max_depth > 0.001: raise RuntimeError(f"hfield initialization penetration exceeds 1 mm: {max_depth}") def _apply_model_perturbation(model, perturbation: dict[str, Any]) -> None: for body_name, scale in perturbation.get("body_mass_scale", {}).items(): body_id = _named_id(model, mujoco.mjtObj.mjOBJ_BODY, body_name) model.body_mass[body_id] *= float(scale) model.body_inertia[body_id] *= float(scale) for geom_name, scale in perturbation.get("geom_friction_scale", {}).items(): geom_id = _named_id(model, mujoco.mjtObj.mjOBJ_GEOM, geom_name) model.geom_friction[geom_id] *= float(scale) for body_name, scale in perturbation.get("body_geom_friction_scale", {}).items(): body_id = _named_id(model, mujoco.mjtObj.mjOBJ_BODY, body_name) for geom_id in range(model.ngeom): current = int(model.geom_bodyid[geom_id]) while current > 0 and current != body_id: current = int(model.body_parentid[current]) if current == body_id: model.geom_friction[geom_id] *= float(scale) def _model_fingerprint(model) -> str: digest = hashlib.sha256() arrays = ( model.body_mass, model.body_inertia, model.geom_type, model.geom_size, model.geom_pos, model.geom_quat, model.geom_friction, model.geom_contype, model.geom_conaffinity, model.jnt_type, model.jnt_axis, model.jnt_range, model.actuator_gear, model.actuator_ctrlrange, model.eq_type, model.eq_data, ) for array in arrays: digest.update(np.asarray(array).tobytes()) return digest.hexdigest() def _object_velocity(model, data, body_id: int) -> tuple[list[float], list[float]]: velocity = np.zeros(6) mujoco.mj_objectVelocity( model, data, mujoco.mjtObj.mjOBJ_BODY, body_id, velocity, 0 ) return velocity[3:].tolist(), velocity[:3].tolist() def _contact_snapshot(model, data) -> tuple[list[dict[str, Any]], float, float]: contacts = [] maximum_depth = 0.0 maximum_force = 0.0 force = np.zeros(6) for index in range(data.ncon): contact = data.contact[index] geom1 = mujoco.mj_id2name(model, mujoco.mjtObj.mjOBJ_GEOM, contact.geom1) or "geom_" + str(contact.geom1) geom2 = mujoco.mj_id2name(model, mujoco.mjtObj.mjOBJ_GEOM, contact.geom2) or "geom_" + str(contact.geom2) body1_id = int(model.geom_bodyid[contact.geom1]) body2_id = int(model.geom_bodyid[contact.geom2]) body1 = mujoco.mj_id2name(model, mujoco.mjtObj.mjOBJ_BODY, body1_id) or "world" body2 = mujoco.mj_id2name(model, mujoco.mjtObj.mjOBJ_BODY, body2_id) or "world" mujoco.mj_contactForce(model, data, index, force) depth = max(0.0, -float(contact.dist)) normal_force = abs(float(force[0])) tangential_force = math.hypot(float(force[1]), float(force[2])) torsional_torque = abs(float(force[3])) rolling_torque = math.hypot(float(force[4]), float(force[5])) friction = [float(value) for value in contact.friction] active_friction_axes = 0 if int(contact.dim) >= 3: active_friction_axes = 2 if int(contact.dim) >= 4: active_friction_axes = 3 if int(contact.dim) >= 6: active_friction_axes = 5 normalized_friction_loads = [] if normal_force > 1e-9: for axis in range(active_friction_axes): coefficient = max(abs(friction[axis]), 1e-12) normalized_friction_loads.append( abs(float(force[axis + 1])) / (coefficient * normal_force) ) cone_is_pyramidal = int(model.opt.cone) == int( mujoco.mjtCone.mjCONE_PYRAMIDAL ) if cone_is_pyramidal: cone_utilization = sum(normalized_friction_loads) else: cone_utilization = math.sqrt( sum(value * value for value in normalized_friction_loads) ) linear1, angular1 = _object_velocity(model, data, body1_id) linear2, angular2 = _object_velocity(model, data, body2_id) point = np.asarray(contact.pos, dtype=float) velocity1 = ( np.asarray(linear1) + np.cross(np.asarray(angular1), point - data.xpos[body1_id]) ) velocity2 = ( np.asarray(linear2) + np.cross(np.asarray(angular2), point - data.xpos[body2_id]) ) normal_axis = np.asarray(contact.frame, dtype=float).reshape(3, 3)[0] relative_velocity = velocity2 - velocity1 tangential_velocity = relative_velocity - normal_axis * float(np.dot(relative_velocity, normal_axis)) slip_speed = float(np.linalg.norm(tangential_velocity)) maximum_depth = max(maximum_depth, depth) maximum_force = max(maximum_force, normal_force) contacts.append({ "geom1": geom1, "geom2": geom2, "body1": body1, "body2": body2, "distance_m": float(contact.dist), "normal_force_N": normal_force, "tangential_force_N": tangential_force, "contact_frame_force_torque": [float(value) for value in force], "torsional_torque_Nm": torsional_torque, "rolling_torque_Nm": rolling_torque, "friction_coefficients": {"sliding_1": friction[0], "sliding_2": friction[1], "torsional": friction[2], "rolling_1": friction[3], "rolling_2": friction[4]}, "contact_dimension": int(contact.dim), "friction_cone_type": "pyramidal" if cone_is_pyramidal else "elliptic", "normalized_friction_loads": normalized_friction_loads, "coulomb_cone_utilization": cone_utilization, "tangential_slip_speed_mps": slip_speed, }) return contacts, maximum_depth, maximum_force def _group_active(model, data, binding: dict[str, Any]) -> bool: condition = binding.get("active_when") if not condition: return True joint_id = _named_id(model, mujoco.mjtObj.mjOBJ_JOINT, condition["joint"]) value = float(data.qpos[int(model.jnt_qposadr[joint_id])]) if "minimum_position" in condition and value < float(condition["minimum_position"]): return False if "maximum_position" in condition and value > float(condition["maximum_position"]): return False return True def _group_matches(contact: dict[str, Any], endpoint: int, binding: dict[str, Any]) -> bool: geom_name = contact["geom" + str(endpoint)] body_name = contact["body" + str(endpoint)] return ( any(fnmatch.fnmatchcase(geom_name, pattern) for pattern in binding.get("geoms", [])) or any(fnmatch.fnmatchcase(body_name, pattern) for pattern in binding.get("bodies", [])) ) def _semantic_contacts(model, data, contacts: list[dict[str, Any]], policy: dict[str, Any], pairs: list[list[str]]) -> dict[str, dict[str, Any]]: groups = policy["groups"] matches: dict[str, dict[str, Any]] = {} for left, right in pairs: left_binding = groups[left] right_binding = groups[right] if not _group_active(model, data, left_binding) or not _group_active(model, data, right_binding): continue rule = left + "/" + right for contact in contacts: if contact["normal_force_N"] <= 0.0 and contact["distance_m"] >= 0.0: continue direct = _group_matches(contact, 1, left_binding) and _group_matches(contact, 2, right_binding) reverse = _group_matches(contact, 2, left_binding) and _group_matches(contact, 1, right_binding) if direct or reverse: matches[rule] = contact break return matches def _forbidden_contacts(model, data, contacts: list[dict[str, Any]], policy: dict[str, Any]) -> dict[str, dict[str, Any]]: return _semantic_contacts(model, data, contacts, policy, policy["forbidden"]) def _joint_limit_violations(model, data, tolerance: float = 1e-4) -> dict[str, dict[str, float]]: violations: dict[str, dict[str, float]] = {} for joint_id in range(model.njnt): if not bool(model.jnt_limited[joint_id]): continue if model.jnt_type[joint_id] not in (mujoco.mjtJoint.mjJNT_HINGE, mujoco.mjtJoint.mjJNT_SLIDE): continue position = float(data.qpos[int(model.jnt_qposadr[joint_id])]) lower, upper = (float(value) for value in model.jnt_range[joint_id]) excess = max(lower - position, position - upper, 0.0) if excess > tolerance: name = mujoco.mj_id2name(model, mujoco.mjtObj.mjOBJ_JOINT, joint_id) or "joint_" + str(joint_id) violations[name] = { "position": position, "lower": lower, "upper": upper, "excess": excess, } return violations def _qualified_trace(trace: list[set[str]], timestep_s: float, dwell_s: float) -> tuple[bool, float, list[dict[str, Any]]]: minimum_steps = max(1, int(math.ceil(dwell_s / timestep_s - 1e-12))) qualified = np.zeros(len(trace), dtype=bool) runs: list[dict[str, Any]] = [] labels = sorted(set().union(*trace)) if trace else [] for label in labels: start = None for index in range(len(trace) + 1): active = index < len(trace) and label in trace[index] if active and start is None: start = index elif not active and start is not None: count = index - start if count >= minimum_steps: qualified[start:index] = True runs.append({ "rule": label, "start_time_s": (start + 1) * timestep_s, "end_time_s": index * timestep_s, "duration_s": count * timestep_s, }) start = None ratio = float(np.count_nonzero(qualified) / len(trace)) if trace else 0.0 return bool(runs), ratio, runs def _observation(model, data, body_names: list[str], joint_names: list[str]) -> dict[str, Any]: bodies = {} for name in body_names: body_id = _named_id(model, mujoco.mjtObj.mjOBJ_BODY, name) linear, angular = _object_velocity(model, data, body_id) bodies[name] = { "position": data.xpos[body_id].tolist(), "quaternion": data.xquat[body_id].tolist(), "linear_velocity": linear, "angular_velocity": angular, } joints = {} for name in joint_names: joint_id = _named_id(model, mujoco.mjtObj.mjOBJ_JOINT, name) qpos_address = int(model.jnt_qposadr[joint_id]) dof_address = int(model.jnt_dofadr[joint_id]) joints[name] = { "position": float(data.qpos[qpos_address]), "velocity": float(data.qvel[dof_address]), } contacts, depth, force = _contact_snapshot(model, data) return { "time_s": float(data.time), "bodies": bodies, "joints": joints, "contacts": contacts, "maximum_penetration_m": depth, "maximum_contact_force_N": force, } def _apply_static_field(model, data, field: dict[str, Any] | None) -> dict[str, float]: data.xfrc_applied[:] = 0.0 if not field: return {} if field["type"] != "static_fluid": raise ValueError("unsupported static field: " + field["type"]) body_id = _named_id(model, mujoco.mjtObj.mjOBJ_BODY, field["body"]) body_position = data.xpos[body_id] linear, angular = _object_velocity(model, data, body_id) water_level = float(field["surface_z_m"]) depth_span = float(field["immersion_span_m"]) submerged = max(0.0, min(1.0, (water_level - (body_position[2] - depth_span * 0.5)) / depth_span)) density = float(field["density_kg_m3"]) volume = float(field["displaced_volume_m3"]) buoyancy = density * 9.81 * volume * submerged vx, _, vz = linear drag_x = -float(field["drag_x"]) * submerged * vx * abs(vx) drag_z = -float(field["drag_z"]) * submerged * vz * abs(vz) pitch_drag = -float(field["pitch_drag"]) * submerged * angular[1] data.xfrc_applied[body_id] = [drag_x, 0.0, buoyancy + drag_z, 0.0, pitch_drag, 0.0] return { "submerged_fraction": submerged, "buoyancy_N": buoyancy, "drag_x_N": drag_x, "drag_z_N": drag_z, } def _resolve_controls(model, requested: dict[str, float], limits: dict[str, list[float]]) -> tuple[np.ndarray, list[dict[str, Any]]]: controls = np.zeros(model.nu) violations: list[dict[str, Any]] = [] for name, raw_value in requested.items(): actuator_id = _named_id(model, mujoco.mjtObj.mjOBJ_ACTUATOR, name) value = float(raw_value) if not math.isfinite(value): raise ValueError("non-finite actuator command: " + name) if name in limits: lo, hi = limits[name] elif bool(model.actuator_ctrllimited[actuator_id]): lo, hi = model.actuator_ctrlrange[actuator_id] else: raise ValueError("missing explicit limit for actuator: " + name) lower, upper = float(lo), float(hi) if value < lower - 1e-9 or value > upper + 1e-9: violations.append({ "actuator": name, "requested": value, "lower": lower, "upper": upper, }) controls[actuator_id] = max(lower, min(upper, value)) return controls, violations def _try_grasp(model, data, api: dict[str, Any], observation: dict[str, Any]) -> tuple[bool, str]: equality_id = _named_id(model, mujoco.mjtObj.mjOBJ_EQUALITY, api["equality"]) if bool(data.eq_active[equality_id]): return True, "already_active" a = observation["bodies"][api["body_a"]]["position"] b = observation["bodies"][api["body_b"]]["position"] distance = math.sqrt(sum((x - y) ** 2 for x, y in zip(a, b))) if distance > float(api["maximum_distance_m"]): return False, "distance_gate" if api.get("contact_required", False): body_a = _named_id(model, mujoco.mjtObj.mjOBJ_BODY, api["body_a"]) body_b = _named_id(model, mujoco.mjtObj.mjOBJ_BODY, api["body_b"]) touching = False for contact in data.contact[:data.ncon]: pair = {int(model.geom_bodyid[contact.geom1]), int(model.geom_bodyid[contact.geom2])} if body_a in pair and body_b in pair: touching = True break if not touching: return False, "contact_gate" data.eq_active[equality_id] = 1 return True, "activated" def run_episode( suite_root: Path, case_spec_path: Path, case_gold_path: Path, generation_seed: int, physics_seed: int, output_dir: Path, ) -> dict[str, Any]: case_spec = load_json(case_spec_path) case_gold = load_json(case_gold_path) workspace = suite_root.parents[1] model_path = workspace / case_spec["artifacts"]["runtime_model"]["path"] expected_model_hash = case_spec["artifacts"]["runtime_model"]["sha256"] if sha256_file(model_path) != expected_model_hash: raise RuntimeError("runtime model hash mismatch") model = mujoco.MjModel.from_xml_path(str(model_path)) model.opt.timestep = float(case_spec["simulator"]["timestep_s"]) perturbation = copy.deepcopy(case_gold["perturbations"][str(physics_seed)]) _apply_model_perturbation(model, perturbation) data = mujoco.MjData(model) _apply_initialization(model, data, case_gold, perturbation) protected_hash = _model_fingerprint(model) probe_path = suite_root / case_spec["probe"]["path"] validator_path = suite_root / case_spec["validator"]["path"] ProbeClass = import_class(probe_path, "PROBE_CLASS") probe = ProbeClass() probe.reset(case_spec, case_gold) actuator_limits = case_spec["probe"]["actuator_limits"] body_names = case_spec["observation"]["bodies"] joint_names = case_spec["observation"]["joints"] field = case_spec.get("static_field") grasp_api = case_spec["probe"].get("grasp_api") contact_policy = case_gold["contact_policy"] allowed_equality_id = None if grasp_api: allowed_equality_id = _named_id(model, mujoco.mjtObj.mjOBJ_EQUALITY, grasp_api["equality"]) initial_eq_active = data.eq_active.copy() initial_observation = _observation(model, data, body_names, joint_names) initial_admissibility = { "finite": bool(np.isfinite(data.qpos).all() and np.isfinite(data.qvel).all()), "maximum_penetration_m": initial_observation["maximum_penetration_m"], "penetration_pass_1mm": initial_observation["maximum_penetration_m"] <= 0.001, } duration = float(case_spec["probe"]["episode_duration_s"]) log_hz = float(case_spec["probe"]["log_hz"]) log_period = 1.0 / log_hz next_log = 0.0 frames = [] events = [] maximum_penetration = initial_observation["maximum_penetration_m"] maximum_force = initial_observation["maximum_contact_force_N"] maximum_penetration_contact = None maximum_penetration_time_s = 0.0 penetration_samples: list[float] = [] force_samples: list[float] = [] tangential_force_samples: list[float] = [] friction_utilization_samples: list[float] = [] slip_speed_samples: list[float] = [] observed_semantic_contacts: set[str] = set() forbidden_trace: list[set[str]] = [] joint_limit_trace: list[set[str]] = [] friction_failure_trace: list[set[str]] = [] friction_examples: dict[str, dict[str, Any]] = {} forbidden_examples: dict[str, dict[str, Any]] = {} joint_limit_examples: dict[str, dict[str, float]] = {} action_bound_examples: dict[str, dict[str, Any]] = {} undeclared_equality_examples: dict[str, dict[str, Any]] = {} finite = True grasp_active = False start = time.perf_counter() while data.time < duration - model.opt.timestep * 0.5: observation = _observation(model, data, body_names, joint_names) command = probe.command(float(data.time), copy.deepcopy(observation)) resolved_controls, control_violations = _resolve_controls(model, command.controls, actuator_limits) data.ctrl[:] = resolved_controls for violation in control_violations: actuator = violation["actuator"] if actuator not in action_bound_examples: example = dict(violation) example["t"] = float(data.time) action_bound_examples[actuator] = example if command.grasp_request and grasp_api: activated, reason = _try_grasp(model, data, grasp_api, observation) if activated and not grasp_active: events.append({"event": "grasp_activated", "t": float(data.time), "reason": reason}) grasp_active = True for marker in command.markers: if not any(item["event"] == marker for item in events): events.append({"event": marker, "t": float(data.time)}) field_state = _apply_static_field(model, data, field) mujoco.mj_step(model, data) contacts, depth, force = _contact_snapshot(model, data) friction_failures: set[str] = set() for contact in contacts: penetration_samples.append(max(0.0, -float(contact["distance_m"]))) force_samples.append(float(contact["normal_force_N"])) tangential_force_samples.append(float(contact["tangential_force_N"])) friction_utilization_samples.append(float(contact["coulomb_cone_utilization"])) slip_speed_samples.append(float(contact["tangential_slip_speed_mps"])) if contact["normal_force_N"] > 1e-6 and contact["coulomb_cone_utilization"] > 1.25: label = contact["geom1"] + "/" + contact["geom2"] friction_failures.add(label) if label not in friction_examples: example = dict(contact) example["t"] = float(data.time) friction_examples[label] = example friction_failure_trace.append(friction_failures) allowed_matches = _semantic_contacts(model, data, contacts, contact_policy, contact_policy["allowed"]) for rule, contact in allowed_matches.items(): if rule not in observed_semantic_contacts: events.append({"event": "semantic_contact", "rule": rule, "t": float(data.time), "contact": contact}) observed_semantic_contacts.add(rule) forbidden_matches = _forbidden_contacts(model, data, contacts, contact_policy) forbidden_trace.append(set(forbidden_matches)) for rule, contact in forbidden_matches.items(): if rule not in forbidden_examples: example = dict(contact) example["t"] = float(data.time) forbidden_examples[rule] = example joint_limit_matches = _joint_limit_violations(model, data) joint_limit_trace.append(set(joint_limit_matches)) for joint_name, violation in joint_limit_matches.items(): if joint_name not in joint_limit_examples: example = dict(violation) example["t"] = float(data.time) joint_limit_examples[joint_name] = example for equality_id in range(model.neq): if bool(data.eq_active[equality_id]) and not bool(initial_eq_active[equality_id]) and equality_id != allowed_equality_id: equality_name = mujoco.mj_id2name(model, mujoco.mjtObj.mjOBJ_EQUALITY, equality_id) or "equality_" + str(equality_id) if equality_name not in undeclared_equality_examples: undeclared_equality_examples[equality_name] = {"equality": equality_name, "t": float(data.time)} if depth > maximum_penetration: maximum_penetration = depth maximum_penetration_time_s = float(data.time) maximum_penetration_contact = min(contacts, key=lambda item: item["distance_m"]) if contacts else None maximum_force = max(maximum_force, force) if not np.isfinite(data.qpos).all() or not np.isfinite(data.qvel).all(): finite = False events.append({"event": "non_finite_state", "t": float(data.time)}) break if data.time + 1e-9 >= next_log: frame_observation = _observation(model, data, body_names, joint_names) frames.append({ "t": float(data.time), "mechanics": mechanics_snapshot(model, data), "bodies": frame_observation["bodies"], "joints": frame_observation["joints"], "contacts": contacts, "maximum_penetration_m": depth, "maximum_contact_force_N": force, "controls": { model.actuator(i).name: float(data.ctrl[i]) for i in range(model.nu) }, "field": field_state, "grasp_active": grasp_active, }) next_log += log_period dwell_time_s = 0.010 forbidden_episode, forbidden_ratio, forbidden_runs = _qualified_trace( forbidden_trace, float(model.opt.timestep), dwell_time_s ) joint_limit_episode, joint_limit_ratio, joint_limit_runs = _qualified_trace( joint_limit_trace, float(model.opt.timestep), dwell_time_s ) friction_cone_episode, friction_cone_ratio, friction_cone_runs = _qualified_trace( friction_failure_trace, float(model.opt.timestep), dwell_time_s ) for run in forbidden_runs: run["first_observation"] = forbidden_examples[run["rule"]] events.append({ "event": "forbidden_contact_violation", "t": run["start_time_s"], "rule": run["rule"], }) for run in joint_limit_runs: run["first_observation"] = joint_limit_examples[run["rule"]] events.append({ "event": "joint_limit_violation", "t": run["start_time_s"], "joint": run["rule"], }) for run in friction_cone_runs: run["first_observation"] = friction_examples[run["rule"]] events.append({ "event": "friction_cone_failure", "t": run["start_time_s"], "contact_pair": run["rule"], }) dynamic_penetration_p95 = float(np.percentile(penetration_samples, 95)) if penetration_samples else 0.0 contact_force_p95 = float(np.percentile(force_samples, 95)) if force_samples else 0.0 tangential_force_p95 = float(np.percentile(tangential_force_samples, 95)) if tangential_force_samples else 0.0 friction_utilization_p95 = float(np.percentile(friction_utilization_samples, 95)) if friction_utilization_samples else 0.0 friction_utilization_max = max(friction_utilization_samples, default=0.0) slip_speed_p95 = float(np.percentile(slip_speed_samples, 95)) if slip_speed_samples else 0.0 slip_speed_max = max(slip_speed_samples, default=0.0) friction_warning_sample_ratio = ( sum(value > 1.05 for value in friction_utilization_samples) / len(friction_utilization_samples) if friction_utilization_samples else 0.0 ) kinematics = annotate_kinematics(frames) energy = energy_summary(frames) mutation_pass = protected_hash == _model_fingerprint(model) raw = { "schema_version": "simcode4d.dev15.episode-log.v1", "case_id": case_spec["case_id"], "world_id": case_spec["world_id"], "generation_seed": generation_seed, "physics_seed": physics_seed, "artifact_hashes": { "runtime_model_sha256": expected_model_hash, "case_spec_sha256": sha256_file(case_spec_path), "case_gold_sha256": sha256_file(case_gold_path), "probe_sha256": sha256_file(probe_path), "validator_sha256": sha256_file(validator_path), "runtime_sha256": sha256_file(Path(__file__)), "physics_diagnostics_sha256": sha256_file(Path(__file__).with_name("physics_diagnostics.py")), }, "simulator": { "name": "mujoco", "version": mujoco.__version__, "timestep_s": float(model.opt.timestep), }, "initial_admissibility": initial_admissibility, "finite_execution": finite, "model_mutation_guard_pass": mutation_pass, "integrity_audit": { "action_bound_violation": bool(action_bound_examples), "action_bound_examples": [action_bound_examples[key] for key in sorted(action_bound_examples)], "undeclared_equality_activation": bool(undeclared_equality_examples), "undeclared_equality_examples": [undeclared_equality_examples[key] for key in sorted(undeclared_equality_examples)], "integrity_violation": bool( not finite or not mutation_pass or action_bound_examples or undeclared_equality_examples ), }, "safety": { "minimum_dwell_s": dwell_time_s, "forbidden_contact_episode": forbidden_episode, "forbidden_contact_time_ratio": forbidden_ratio, "forbidden_contact_runs": forbidden_runs, "joint_limit_violation_episode": joint_limit_episode, "joint_limit_violation_time_ratio": joint_limit_ratio, "joint_limit_violation_runs": joint_limit_runs, "friction_cone_failure_episode": friction_cone_episode, "friction_cone_failure_time_ratio": friction_cone_ratio, "friction_cone_failure_runs": friction_cone_runs, "friction_warning_sample_ratio": friction_warning_sample_ratio, "friction_utilization_p95": friction_utilization_p95, "friction_utilization_max": friction_utilization_max, "tangential_slip_speed_p95_mps": slip_speed_p95, "tangential_slip_speed_max_mps": slip_speed_max, "dynamic_penetration_p95_m": dynamic_penetration_p95, "contact_force_p95_N": contact_force_p95, }, "grasp_api_used": grasp_active, "events": events, "frames": frames, "summary": { "duration_simulated_s": float(data.time), "maximum_penetration_m": maximum_penetration, "maximum_penetration_time_s": maximum_penetration_time_s, "maximum_penetration_contact": maximum_penetration_contact, "maximum_contact_force_N": maximum_force, "tangential_contact_force_p95_N": tangential_force_p95, "friction_utilization_p95": friction_utilization_p95, "friction_utilization_max": friction_utilization_max, "tangential_slip_speed_p95_mps": slip_speed_p95, "tangential_slip_speed_max_mps": slip_speed_max, "friction_warning_sample_ratio": friction_warning_sample_ratio, "friction_contact_sample_count": len(friction_utilization_samples), "slip_reporting_sample_count": sum( value > 0.02 for value in slip_speed_samples ), "dynamic_penetration_p95_m": dynamic_penetration_p95, "contact_force_p95_N": contact_force_p95, **kinematics, **energy, "wall_time_s": time.perf_counter() - start, }, } output_dir.mkdir(parents=True, exist_ok=False) raw_path = output_dir / "episode_log.json" with raw_path.open("w", encoding="utf-8") as handle: json.dump(raw, handle, indent=2, sort_keys=True) ValidatorClass = import_class(validator_path, "VALIDATOR_CLASS") validation = ValidatorClass().validate(raw, case_spec, case_gold) validation["raw_event_log_sha256"] = sha256_file(raw_path) validation["validator_sha256"] = sha256_file(validator_path) validation_path = output_dir / "validation.json" with validation_path.open("w", encoding="utf-8") as handle: json.dump(validation, handle, indent=2, sort_keys=True) return validation