Build the shim fixtures from the layout Newton actually reports

The fixtures described a layout that does not exist: actuators laid out
world-major with a uniform per-instance stride. MEASURED on a 2-environment
handover model, Newton reports 80 actuators across 6 articulations, 20 for
each of the four hands and none for the two objects, and identifies an
actuator by the prim path of the joint it drives.

Rebuild the fixtures around that, so the tests exercise the label join the
shim performs. Cover the case the old fixtures could not express: two hands
sharing a world, each writing mujoco.ctrl without touching the other.

Author: hujc7

source/isaaclab_newton/test/assets/test_mjc_view_compat.py

@@ -12,102 +12,130 @@
 
 pytestmark = pytest.mark.unit
 
-
-def _model(*, world_count, count_per_world, actuator_count, tendon_count=2):
-    """Build a model whose actuator rows are laid out world-major, as MuJoCo lays them out."""
-    total = world_count * count_per_world * actuator_count
-    worlds = np.repeat(np.arange(world_count), count_per_world * actuator_count)
+# Shapes below mirror what a 2-environment handover model reports: every world holds a right
+# hand, a left hand and an object, and only the hands own actuators.
+_ARTICULATIONS = [
+    "/World/envs/env_0/RightRobot",
+    "/World/envs/env_0/LeftRobot",
+    "/World/envs/env_0/Object",
+    "/World/envs/env_1/RightRobot",
+    "/World/envs/env_1/LeftRobot",
+    "/World/envs/env_1/Object",
+]
+
+
+def _model(actuators_per_hand=2, tendons_per_hand=1):
+    """Build a model whose actuator labels are prim paths under their articulation, as MuJoCo emits."""
+    labels = []
+    for path in _ARTICULATIONS:
+        if path.endswith("Object"):
+            continue  # objects own no actuators, which is why no division recovers the count
+        labels += [f"{path}/joint_{i}" for i in range(actuators_per_hand)]
     return SimpleNamespace(
+        articulation_count=len(_ARTICULATIONS),
+        articulation_label=_ARTICULATIONS,
         custom_frequency_counts={
-            "mujoco:actuator": total,
-            "mujoco:tendon": world_count * count_per_world * tendon_count,
+            "mujoco:actuator": len(labels),
+            "mujoco:tendon": tendons_per_hand * 4,
         },
         mujoco=SimpleNamespace(
-            actuator_world=worlds,
-            actuator_target_label=[f"act{i}" for i in range(total)],
-            ctrl=wp.zeros(total, dtype=wp.float32, device="cpu"),
+            actuator_target_label=labels,
+            ctrl=wp.zeros(len(labels), dtype=wp.float32, device="cpu"),
         ),
     )
 
 
-def _view(*, world_count, count_per_world):
+def _view(articulation_ids, *, world_count=2, count_per_world=1):
     return SimpleNamespace(
         device=wp.get_device("cpu"),
         world_count=world_count,
         count_per_world=count_per_world,
         count=world_count * count_per_world,
-        tendon_count=2,
-        tendon_names=["t0", "t1"],
+        # Newton reports these per world, i.e. shape (world_count, count_per_world).
+        articulation_ids=np.array(articulation_ids).reshape(world_count, count_per_world),
+        tendon_count=1,
+        tendon_names=["t0"],
     )
 
 
+def _right_hand(model=None):
+    return ensure_custom_frequency_api(_view([0, 3]), model or _model())
+
+
 def test_a_view_that_already_has_the_api_is_returned_unchanged():
     """On Newton 1.6 the wrapper must not interpose at all."""
-    view = _view(world_count=2, count_per_world=1)
-    view.custom_frequency_counts = {"mujoco:actuator": 3}
+    view = _view([0, 3])
+    view.custom_frequency_counts = {"mujoco:actuator": 2}
 
-    assert ensure_custom_frequency_api(view, _model(world_count=2, count_per_world=1, actuator_count=3)) is view
+    assert ensure_custom_frequency_api(view, _model()) is view
 
 
-def test_counts_are_per_articulation_not_scene_wide():
-    """Newton 1.6 reports per-articulation counts; the model's are scene-wide."""
-    model = _model(world_count=4, count_per_world=1, actuator_count=3)
-    adapted = ensure_custom_frequency_api(_view(world_count=4, count_per_world=1), model)
+def test_counts_come_from_the_articulations_the_view_owns():
+    """8 actuators over 6 articulations divides to neither 2 nor 4; only the join gives 2."""
+    model = _model()
 
-    assert model.custom_frequency_counts["mujoco:actuator"] == 12
-    assert adapted.custom_frequency_counts["mujoco:actuator"] == 3
+    assert model.custom_frequency_counts["mujoco:actuator"] == 8
+    assert model.articulation_count == 6
+    assert _right_hand(model).custom_frequency_counts["mujoco:actuator"] == 2
 
 
 def test_unrelated_attributes_are_delegated_to_the_wrapped_view():
-    view = _view(world_count=2, count_per_world=1)
+    view = _view([0, 3])
     view.some_newton_attribute = "delegated"
-    adapted = ensure_custom_frequency_api(view, _model(world_count=2, count_per_world=1, actuator_count=3))
+    adapted = ensure_custom_frequency_api(view, _model())
 
     assert adapted.some_newton_attribute == "delegated"
     assert adapted.world_count == 2
 
 
-def test_actuator_rows_are_read_back_per_world():
-    """``get_attribute`` reshapes the flat rows into the view's (world, instance, value) shape."""
-    model = _model(world_count=3, count_per_world=1, actuator_count=2)
-    model.mujoco.actuator_trntype = np.arange(6, dtype=np.int32)
-    adapted = ensure_custom_frequency_api(_view(world_count=3, count_per_world=1), model)
+def test_labels_name_the_actuators_this_view_owns():
+    labels = _right_hand().custom_frequency_labels["mujoco:actuator"]
 
-    got = adapted.get_attribute("mujoco.actuator_trntype", model).numpy()
+    assert labels == ["/World/envs/env_0/RightRobot/joint_0", "/World/envs/env_0/RightRobot/joint_1"]
 
-    assert got.shape == (3, 1, 2)
-    # World-major layout: world w owns rows [2w, 2w+1].
-    np.testing.assert_array_equal(got[:, 0, :], [[0, 1], [2, 3], [4, 5]])
 
+def test_two_articulations_in_one_world_do_not_claim_each_others_actuators():
+    """The handover scene puts two hands in each world, and each view must take only its own."""
+    model = _model()
+    right = ensure_custom_frequency_api(_view([0, 3]), model)
+    left = ensure_custom_frequency_api(_view([1, 4]), model)
 
-def test_ctrl_writes_land_on_the_rows_that_world_owns():
-    model = _model(world_count=3, count_per_world=1, actuator_count=2)
-    adapted = ensure_custom_frequency_api(_view(world_count=3, count_per_world=1), model)
-    values = wp.array(
-        np.array([[[1.0, 2.0]], [[3.0, 4.0]], [[5.0, 6.0]]], dtype=np.float32), dtype=wp.float32, device="cpu"
+    right.set_attribute(
+        "mujoco.ctrl", model, wp.array(np.array([[[1.0, 2.0]], [[5.0, 6.0]]], dtype=np.float32), device="cpu")
+    )
+    left.set_attribute(
+        "mujoco.ctrl", model, wp.array(np.array([[[3.0, 4.0]], [[7.0, 8.0]]], dtype=np.float32), device="cpu")
     )
 
-    adapted.set_attribute("mujoco.ctrl", model, values)
+    # Right owns rows 0-1 and 4-5, left owns 2-3 and 6-7; neither overwrote the other.
+    np.testing.assert_array_equal(model.mujoco.ctrl.numpy(), [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0])
+
+
+def test_actuator_rows_are_read_back_in_view_shape():
+    model = _model()
+    model.mujoco.actuator_trntype = np.arange(8, dtype=np.int32)
+
+    got = _right_hand(model).get_attribute("mujoco.actuator_trntype", model).numpy()
 
-    np.testing.assert_array_equal(model.mujoco.ctrl.numpy(), [1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
+    assert got.shape == (2, 1, 2)
+    # The right hand owns rows 0-1 in world 0 and 4-5 in world 1.
+    np.testing.assert_array_equal(got[:, 0, :], [[0, 1], [4, 5]])
 
 
 def test_a_mismatched_command_shape_is_refused():
     """Silently broadcasting the wrong shape would drive arbitrary actuators."""
-    model = _model(world_count=2, count_per_world=1, actuator_count=2)
-    adapted = ensure_custom_frequency_api(_view(world_count=2, count_per_world=1), model)
-    values = wp.zeros((2, 1, 3), dtype=wp.float32, device="cpu")
+    model = _model()
 
     with pytest.raises(ValueError, match="Expected values shaped"):
-        adapted.set_attribute("mujoco.ctrl", model, values)
+        _right_hand(model).set_attribute("mujoco.ctrl", model, wp.zeros((2, 1, 3), dtype=wp.float32, device="cpu"))
 
 
-def test_a_world_short_of_actuator_rows_is_refused():
-    """Deriving a layout from too few rows would alias instances onto each other."""
-    model = _model(world_count=2, count_per_world=1, actuator_count=2)
-    # World 1 is one row short of the 2 actuators its instance needs.
-    model.mujoco.actuator_world = np.array([0, 0, 0, 1])
-    adapted = ensure_custom_frequency_api(_view(world_count=2, count_per_world=1), model)
+def test_articulations_owning_different_actuator_counts_are_refused():
+    """No view-shaped buffer can represent a ragged selection, so say so rather than truncate."""
+    model = _model()
+    model.mujoco.actuator_target_label = model.mujoco.actuator_target_label + [
+        "/World/envs/env_0/RightRobot/joint_extra"
+    ]
 
-    with pytest.raises(ValueError, match="actuator rows"):
-        adapted.get_attribute("mujoco.ctrl", model)
+    with pytest.raises(ValueError, match="differing actuator counts"):
+        ensure_custom_frequency_api(_view([0, 3]), model)