| """Benchmark-owned mechanics and kinematics diagnostics for episode logs.""" |
| from __future__ import annotations |
|
|
| import math |
| from typing import Any |
|
|
| import mujoco |
| import numpy as np |
|
|
|
|
| def mechanics_snapshot(model: mujoco.MjModel, data: mujoco.MjData) -> dict[str, Any]: |
| """Return energy and forward/inverse consistency without changing state.""" |
| mujoco.mj_energyPos(model, data) |
| mujoco.mj_energyVel(model, data) |
| mujoco.mj_compareFwdInv(model, data) |
| |
| |
| |
| |
| residual_components = [float(value) for value in data.solver_fwdinv] |
| generalized_force_residual = abs(residual_components[0]) |
| constraint_force_residual = abs(residual_components[1]) |
| generalized_force_scale = max(1.0, float(np.linalg.norm(data.qfrc_inverse))) |
| constraint_force_scale = max(1.0, float(np.linalg.norm(data.efc_force))) |
| generalized_force_relative = generalized_force_residual / generalized_force_scale |
| constraint_force_relative = constraint_force_residual / constraint_force_scale |
| return { |
| "potential_energy_J": float(data.energy[0]), |
| "kinetic_energy_J": float(data.energy[1]), |
| "total_energy_J": float(data.energy[0] + data.energy[1]), |
| "forward_inverse_residual_components": residual_components, |
| "generalized_force_residual_absolute": generalized_force_residual, |
| "generalized_force_residual_relative": generalized_force_relative, |
| "constraint_force_residual_absolute": constraint_force_residual, |
| "constraint_force_residual_relative": constraint_force_relative, |
| |
| "forward_inverse_residual_max": generalized_force_residual, |
| "forward_inverse_residual_relative": generalized_force_relative, |
| } |
|
|
|
|
| def _norm(values: list[float]) -> float: |
| return math.sqrt(sum(float(value) ** 2 for value in values)) |
|
|
|
|
| def annotate_kinematics(frames: list[dict[str, Any]]) -> dict[str, float]: |
| """Add finite-difference acceleration/jerk to logged body observations.""" |
| maximum_linear_acceleration = 0.0 |
| maximum_angular_acceleration = 0.0 |
| maximum_linear_jerk = 0.0 |
| maximum_angular_jerk = 0.0 |
| maximum_quaternion_norm_error = 0.0 |
| previous_velocity: dict[str, tuple[np.ndarray, np.ndarray]] = {} |
| previous_acceleration: dict[str, tuple[np.ndarray, np.ndarray]] = {} |
| previous_time: float | None = None |
|
|
| for frame in frames: |
| current_time = float(frame["t"]) |
| dt = current_time - previous_time if previous_time is not None else 0.0 |
| for body_name, body in frame["bodies"].items(): |
| linear_velocity = np.asarray(body["linear_velocity"], dtype=float) |
| angular_velocity = np.asarray(body["angular_velocity"], dtype=float) |
| if dt > 0.0 and body_name in previous_velocity: |
| old_linear, old_angular = previous_velocity[body_name] |
| linear_acceleration = (linear_velocity - old_linear) / dt |
| angular_acceleration = (angular_velocity - old_angular) / dt |
| else: |
| linear_acceleration = np.zeros(3) |
| angular_acceleration = np.zeros(3) |
| if dt > 0.0 and body_name in previous_acceleration: |
| old_linear_acceleration, old_angular_acceleration = previous_acceleration[body_name] |
| linear_jerk = (linear_acceleration - old_linear_acceleration) / dt |
| angular_jerk = (angular_acceleration - old_angular_acceleration) / dt |
| else: |
| linear_jerk = np.zeros(3) |
| angular_jerk = np.zeros(3) |
|
|
| body["linear_acceleration"] = linear_acceleration.tolist() |
| body["angular_acceleration"] = angular_acceleration.tolist() |
| body["linear_jerk"] = linear_jerk.tolist() |
| body["angular_jerk"] = angular_jerk.tolist() |
| maximum_linear_acceleration = max(maximum_linear_acceleration, float(np.linalg.norm(linear_acceleration))) |
| maximum_angular_acceleration = max(maximum_angular_acceleration, float(np.linalg.norm(angular_acceleration))) |
| maximum_linear_jerk = max(maximum_linear_jerk, float(np.linalg.norm(linear_jerk))) |
| maximum_angular_jerk = max(maximum_angular_jerk, float(np.linalg.norm(angular_jerk))) |
| maximum_quaternion_norm_error = max( |
| maximum_quaternion_norm_error, |
| abs(_norm(body["quaternion"]) - 1.0), |
| ) |
| previous_velocity[body_name] = (linear_velocity, angular_velocity) |
| previous_acceleration[body_name] = (linear_acceleration, angular_acceleration) |
| previous_time = current_time |
|
|
| maximum_joint_speed = max( |
| (abs(float(joint["velocity"])) for frame in frames for joint in frame["joints"].values()), |
| default=0.0, |
| ) |
| return { |
| "maximum_linear_acceleration_mps2": maximum_linear_acceleration, |
| "maximum_angular_acceleration_radps2": maximum_angular_acceleration, |
| "maximum_linear_jerk_mps3": maximum_linear_jerk, |
| "maximum_angular_jerk_radps3": maximum_angular_jerk, |
| "maximum_joint_speed": maximum_joint_speed, |
| "maximum_quaternion_norm_error": maximum_quaternion_norm_error, |
| } |
|
|
|
|
| def energy_summary(frames: list[dict[str, Any]]) -> dict[str, float]: |
| total = [float(frame["mechanics"]["total_energy_J"]) for frame in frames] |
| potential = [float(frame["mechanics"]["potential_energy_J"]) for frame in frames] |
| kinetic = [float(frame["mechanics"]["kinetic_energy_J"]) for frame in frames] |
| generalized_force_residual = [ |
| float(frame["mechanics"]["generalized_force_residual_relative"]) |
| for frame in frames |
| ] |
| constraint_force_residual = [ |
| float(frame["mechanics"]["constraint_force_residual_relative"]) |
| for frame in frames |
| ] |
| return { |
| "initial_total_energy_J": total[0] if total else 0.0, |
| "final_total_energy_J": total[-1] if total else 0.0, |
| "total_energy_range_J": max(total) - min(total) if total else 0.0, |
| "potential_energy_range_J": max(potential) - min(potential) if potential else 0.0, |
| "kinetic_energy_max_J": max(kinetic, default=0.0), |
| "generalized_force_residual_relative_max": max(generalized_force_residual, default=0.0), |
| "constraint_force_residual_relative_max": max(constraint_force_residual, default=0.0), |
| |
| "forward_inverse_residual_relative_max": max(generalized_force_residual, default=0.0), |
| } |
|
|
