[Test] Feed real ee_vel to OSC; assert on tail mean not min

OSC's task-space PD: F = kp * pose_err - kd * ee_vel. The test was
passing ee_vel = zeros, which silenced the kd damping term and made
the impedance an undamped spring. Result was a sustained oscillation
around the target with pos_min = 7-12 mm (bottom of swing) but
pos_mean = 35-44 mm. Tail-min on an oscillating envelope can pass
spuriously; tail-mean is the right regression metric.

Fix:
- Compute ee_vel_b as J . q_dot (the formal definition; backend-
  symmetric; uses bridge accessors that are already pinned). Avoids
  Newton's lazy body_vel_w buffer which can return zeros until forced
  materialization.
- Switch all four IK/OSC accuracy assertions from pos_min to pos_mean.
- Tighten OSC threshold to 5 mm (was 2 cm) to match IK.

Final accuracy on both backends:
- Newton IK: pos_mean 0.00000 m (machine precision)
- Newton OSC: pos_mean 0.00000 m (machine precision)
- PhysX  IK: pos_mean 0.00001 m (10 um)
- PhysX  OSC: pos_mean 0.00000 m (machine precision)

Author: hujc7

source/isaaclab_newton/config/extension.toml

@@ -1,7 +1,7 @@
 [package]
 
 # Note: Semantic Versioning is used: https://semver.org/
-version = "0.5.27"
+version = "0.5.28"
 
 # Description
 title = "Newton simulation interfaces for IsaacLab core package"

source/isaaclab_newton/docs/CHANGELOG.rst

@@ -1,6 +1,21 @@
 Changelog
 ---------
 
+0.5.28 (2026-05-02)
+~~~~~~~~~~~~~~~~~~~
+
+Changed
+^^^^^^^
+
+* OSC accuracy test now feeds OSC the actual end-effector velocity
+  (computed as ``J · q_dot``, not ``zeros``) so OSC's ``kd · v`` damping
+  term engages. With damping active, OSC converges to machine
+  precision on the 5 cm Cartesian step instead of oscillating around
+  the target. Both accuracy tests now assert on the tail mean rather
+  than the tail min (the latter is the bottom of any oscillation
+  envelope and can pass spuriously). OSC threshold tightened from
+  2 cm/min to 5 mm/mean.
+
 0.5.27 (2026-05-01)
 ~~~~~~~~~~~~~~~~~~~
 

source/isaaclab_newton/test/assets/test_articulation.py

@@ -424,6 +424,21 @@ def _compute_jacobian_root_frame(robot, ee_jacobi_idx, arm_joint_ids):
     return jacobian
 
 
+def _compute_ee_vel_root(jacobian_b, joint_vel):
+    """Return the EE 6D velocity in the root frame as ``J · q_dot``.
+
+    Required to make OSC's ``kd * ee_vel_b`` damping term meaningful.
+    Passing zero EE velocity (the convenient hack) leaves the impedance
+    undamped and the EE oscillates around the target. We use ``J · q_dot``
+    rather than reading ``data.body_vel_w`` because Newton's lazy
+    velocity buffers can return stale/zero values until forced
+    materialization, while ``joint_vel`` and ``J`` are already pulled
+    by the loop. ``J`` correctness is pinned independently by
+    ``test_get_jacobians_link_origin_contract``.
+    """
+    return torch.bmm(jacobian_b, joint_vel.unsqueeze(-1)).squeeze(-1)
+
+
 def _build_relative_pose_target(robot, ee_frame_idx, delta_xyz, device):
     """Build a target pose = (current EE pose) + ``delta_xyz``, preserving orientation."""
     initial_ee_pos_b, initial_ee_quat_b, _ = _compute_ee_pose_root(robot, ee_frame_idx)
@@ -3049,15 +3064,17 @@ def test_franka_ik_tracking_accuracy(sim, device, articulation_type, gravity_ena
     # Print metrics every run for stress-test capture.
     print(f"IK_METRIC pos_min={pos_min:.5f} pos_mean={pos_mean:.5f} rot_min={rot_min:.5f} rot_mean={rot_mean:.5f}")
 
-    # Regression sentinel: 5 mm best-of-tail. With the configured home
-    # pose and scene gravity off, Newton converges to machine precision
-    # (sub-mm) on this 5 cm Cartesian step. The 5 mm bound absorbs any
-    # CUDA-kernel-ordering noise while remaining well below the "totally
-    # broken" regime: a bridge regression (wrong-frame Jacobian, missing
-    # COM->origin shift, DoF mis-ordering) would push the steady-state
-    # error well past this bound.
-    assert pos_min < 5e-3, f"IK pos_min {pos_min:.5f} > 5 mm — bridge regression?"
-    assert rot_min < 5e-2, f"IK rot_min {rot_min:.5f} > 0.05 rad — bridge regression?"
+    # Regression sentinel: assert on tail mean rather than min. Tail
+    # min is the bottom of any oscillation envelope and can be tiny
+    # while the actual tracking error is much larger. With the
+    # configured home pose and scene gravity off, Newton converges to
+    # machine precision (sub-mm). The 5 mm bound absorbs any CUDA-
+    # kernel-ordering noise while remaining well below the "totally
+    # broken" regime: a bridge regression (wrong-frame Jacobian,
+    # missing COM->origin shift, DoF mis-ordering) would push the
+    # steady-state error well past this bound.
+    assert pos_mean < 5e-3, f"IK pos_mean {pos_mean:.5f} > 5 mm — bridge regression?"
+    assert rot_mean < 5e-2, f"IK rot_mean {rot_mean:.5f} > 0.05 rad — bridge regression?"
 
 
 @pytest.mark.parametrize("device", ["cuda:0"])
@@ -3104,12 +3121,13 @@ def test_franka_osc_tracking_accuracy(sim, device, articulation_type, gravity_en
 
     pos_history: list[float] = []
     rot_history: list[float] = []
-    ee_vel_b = torch.zeros(1, 6, device=device)  # OSC needs vel; use zero (works at low speed).
     for _ in range(800):
         jacobian_b = _compute_jacobian_root_frame(robot, ee_jacobi_idx, arm_joint_ids)
         mass_matrix = wp.to_torch(robot.get_mass_matrix())[:, arm_joint_ids, :][:, :, arm_joint_ids]
         ee_pos_b, ee_quat_b, _ = _compute_ee_pose_root(robot, ee_frame_idx)
         ee_pose_b = torch.cat([ee_pos_b, ee_quat_b], dim=-1)
+        joint_vel = robot.data.joint_vel.torch[:, arm_joint_ids]
+        ee_vel_b = _compute_ee_vel_root(jacobian_b, joint_vel)
 
         osc.set_command(target_pose_b, current_ee_pose_b=ee_pose_b)
         joint_efforts = osc.compute(
@@ -3134,18 +3152,16 @@ def test_franka_osc_tracking_accuracy(sim, device, articulation_type, gravity_en
 
     print(f"OSC_METRIC pos_min={pos_min:.5f} pos_mean={pos_mean:.5f} rot_min={rot_min:.5f} rot_mean={rot_mean:.5f}")
 
-    # Regression sentinel: 2 cm best-of-tail (matches the PhysX-side
-    # test). With the home pose start, zero actuator PD, and no
-    # gravity, both backends settle into a sustained sub-cm oscillation
-    # around the target driven by the critically damped impedance
-    # against ``current_ee_vel_b = 0``. Tighter bounds would require
-    # non-zero ee-velocity feedback or a larger ``motion_stiffness_task``,
-    # neither of which is part of the bridge-pinning contract. A bridge
-    # regression (wrong J, wrong mass matrix, DoF mis-ordering) pushes
-    # the error well past 2 cm because OSC consumes both
-    # ``get_jacobians`` and ``get_mass_matrix`` per step.
-    assert pos_min < 2e-2, f"OSC pos_min {pos_min:.5f} > 2 cm — bridge regression?"
-    assert rot_min < 2e-1, f"OSC rot_min {rot_min:.5f} > 0.2 rad — bridge regression?"
+    # Regression sentinel: assert on tail mean rather than min. With
+    # ``current_ee_vel_b = J · q_dot`` providing OSC's damping term and
+    # the actuator PD zeroed, the impedance settles to machine
+    # precision -- same ballpark as the IK test. The 5 mm bound is a
+    # bridge regression sentinel: a wrong J, wrong mass matrix, or
+    # DoF mis-ordering pushes the steady-state error well past it
+    # because OSC consumes both ``get_jacobians`` and
+    # ``get_mass_matrix`` per step.
+    assert pos_mean < 5e-3, f"OSC pos_mean {pos_mean:.5f} > 5 mm — bridge regression?"
+    assert rot_mean < 5e-2, f"OSC rot_mean {rot_mean:.5f} > 0.05 rad — bridge regression?"
 
 
 if __name__ == "__main__":

source/isaaclab_physx/config/extension.toml

@@ -1,7 +1,7 @@
 [package]
 
 # Note: Semantic Versioning is used: https://semver.org/
-version = "0.5.29"
+version = "0.5.30"
 
 # Description
 title = "PhysX simulation interfaces for IsaacLab core package"

source/isaaclab_physx/docs/CHANGELOG.rst

@@ -1,6 +1,17 @@
 Changelog
 ---------
 
+0.5.30 (2026-05-02)
+~~~~~~~~~~~~~~~~~~~
+
+Changed
+^^^^^^^
+
+* Mirrors the same OSC-test fix from ``isaaclab_newton`` 0.5.28: feed
+  OSC ``J · q_dot`` for the end-effector velocity so its damping term
+  engages, and assert on the tail mean (not min). Threshold tightened
+  to 5 mm.
+
 0.5.29 (2026-05-01)
 ~~~~~~~~~~~~~~~~~~~
 

source/isaaclab_physx/test/assets/test_articulation.py

@@ -252,6 +252,20 @@ def _compute_jacobian_root_frame(robot, ee_jacobi_idx, arm_joint_ids):
     return jacobian
 
 
+def _compute_ee_vel_root(jacobian_b, joint_vel):
+    """Return the EE 6D velocity in the root frame as ``J · q_dot``.
+
+    Required to make OSC's ``kd * ee_vel_b`` damping term meaningful.
+    Passing zero EE velocity (the convenient hack) leaves the impedance
+    undamped and the EE oscillates around the target. ``J · q_dot``
+    avoids relying on ``data.body_vel_w`` (Newton's lazy velocity
+    buffers can return stale/zero values until forced materialization),
+    keeping the helper backend-symmetric. ``J`` correctness is pinned
+    independently by ``test_get_jacobians_link_origin_contract``.
+    """
+    return torch.bmm(jacobian_b, joint_vel.unsqueeze(-1)).squeeze(-1)
+
+
 def _build_relative_pose_target(robot, ee_frame_idx, delta_xyz, device):
     """Build a target pose = (current EE pose) + ``delta_xyz``, preserving orientation."""
     initial_ee_pos_b, initial_ee_quat_b, _ = _compute_ee_pose_root(robot, ee_frame_idx)
@@ -2609,11 +2623,11 @@ def test_franka_ik_tracking_accuracy(sim, device, articulation_type, gravity_ena
 
     print(f"IK_METRIC pos_min={pos_min:.5f} pos_mean={pos_mean:.5f} rot_min={rot_min:.5f} rot_mean={rot_mean:.5f}")
 
-    # Threshold matched to the Newton-side test (5 mm / 0.05 rad). PhysX
-    # historically achieves sub-mm here; the slightly looser bound just
-    # absorbs run-to-run variance.
-    assert pos_min < 5e-3, f"IK pos_min {pos_min:.5f} > 5 mm — bridge regression?"
-    assert rot_min < 5e-2, f"IK rot_min {rot_min:.5f} > 0.05 rad — bridge regression?"
+    # Assert on tail mean (not min) so an oscillating envelope can't
+    # squeeze through. Threshold matched to the Newton-side test
+    # (5 mm / 0.05 rad).
+    assert pos_mean < 5e-3, f"IK pos_mean {pos_mean:.5f} > 5 mm — bridge regression?"
+    assert rot_mean < 5e-2, f"IK rot_mean {rot_mean:.5f} > 0.05 rad — bridge regression?"
 
 
 @pytest.mark.parametrize("device", ["cuda:0"])
@@ -2649,12 +2663,13 @@ def test_franka_osc_tracking_accuracy(sim, device, articulation_type, gravity_en
 
     pos_history: list[float] = []
     rot_history: list[float] = []
-    ee_vel_b = torch.zeros(1, 6, device=device)
     for _ in range(800):
         jacobian_b = _compute_jacobian_root_frame(robot, ee_jacobi_idx, arm_joint_ids)
         mass_matrix = wp.to_torch(robot.get_mass_matrix())[:, arm_joint_ids, :][:, :, arm_joint_ids]
         ee_pos_b, ee_quat_b, _ = _compute_ee_pose_root(robot, ee_frame_idx)
         ee_pose_b = torch.cat([ee_pos_b, ee_quat_b], dim=-1)
+        joint_vel = robot.data.joint_vel.torch[:, arm_joint_ids]
+        ee_vel_b = _compute_ee_vel_root(jacobian_b, joint_vel)
 
         osc.set_command(target_pose_b, current_ee_pose_b=ee_pose_b)
         joint_efforts = osc.compute(
@@ -2679,9 +2694,11 @@ def test_franka_osc_tracking_accuracy(sim, device, articulation_type, gravity_en
 
     print(f"OSC_METRIC pos_min={pos_min:.5f} pos_mean={pos_mean:.5f} rot_min={rot_min:.5f} rot_mean={rot_mean:.5f}")
 
-    # Threshold matches the Newton-side test (2 cm / 0.2 rad).
-    assert pos_min < 2e-2, f"OSC pos_min {pos_min:.5f} > 2 cm — bridge regression?"
-    assert rot_min < 2e-1, f"OSC rot_min {rot_min:.5f} > 0.2 rad — bridge regression?"
+    # Assert on tail mean. Threshold matched to the Newton-side test
+    # (5 mm / 0.05 rad). Both backends converge to machine precision
+    # with proper ee-velocity feedback (``J · q_dot``).
+    assert pos_mean < 5e-3, f"OSC pos_mean {pos_mean:.5f} > 5 mm — bridge regression?"
+    assert rot_mean < 5e-2, f"OSC rot_mean {rot_mean:.5f} > 0.05 rad — bridge regression?"
 
 
 if __name__ == "__main__":