File size: 6,840 Bytes
91093de | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 | """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)
# MuJoCo reports two distinct comparison channels in solver_fwdinv:
# generalized force (qfrc) and constraint force (efc). Only qfrc is the
# forward/inverse dynamics consistency residual. The efc channel is kept
# as a solver diagnostic, but must not be folded into the mechanics gate.
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,
# Backward-compatible aliases are explicitly bound to qfrc only.
"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),
# Backward-compatible alias for consumers of the RC1 draft format.
"forward_inverse_residual_relative_max": max(generalized_force_residual, default=0.0),
}
|