Align OvPhysxSceneDataBackend parity with PhysX/Newton

Address review feedback on PR isaac-sim#5589:

- Drop the :class: cross-ref to PhysxSceneDataBackend; the symbol is not
  re-exported from isaaclab_physx.physics, so the Sphinx target violated
  AGENTS.md's public-API-path rule. Replaced with a plain literal name.

- Document explicitly why this backend uses an explicit setup(physx,
  stage, device) call instead of PhysX's simulation_view property setter.
  The ovphysx wheel exposes a physx + stage pair rather than a single
  SimulationView, so a property-setter shape would have had to bundle
  the two or fire on the second assignment.

- Plumb device through setup() instead of mutating the backend's private
  _device attribute from _warmup_and_load. The field is only used during
  binding allocation, so it doesn't need to persist on the instance.

- Strip "[OvPhysxSceneDataBackend]" prefixes from logger.warning /
  logger.debug calls to match PhysX/Newton convention; the logger name
  already disambiguates.

Tests updated to pass "cpu" as the new setup() device argument and drop
the now-dead ``b._device = "cpu"`` lines.

Author: AntoineRichard

source/isaaclab_ovphysx/isaaclab_ovphysx/physics/ovphysx_manager.py

@@ -39,17 +39,25 @@
 class OvPhysxSceneDataBackend(SceneDataBackend):
     """Scene-data backend for the OVPhysX physics manager.
 
-    Mirrors :class:`~isaaclab_physx.physics.PhysxSceneDataBackend`'s contract
-    but adapts to the ovphysx wheel's one-pattern-per-binding API: each
-    distinct env-wildcard rigid-body prim path produces its own
-    ``TT.RIGID_BODY_POSE`` binding. ``transforms`` reads each binding into
-    its pre-allocated float32 staging buffer and concatenates them into a
-    single ``wp.transformf`` array.
+    Mirrors the contract of ``PhysxSceneDataBackend`` but adapts to the
+    ovphysx wheel's one-pattern-per-binding API: each distinct env-wildcard
+    rigid-body prim path produces its own ``TT.RIGID_BODY_POSE`` binding.
+    :attr:`transforms` reads each binding into its pre-allocated float32
+    staging buffer and concatenates them into a single ``wp.transformf``
+    array.
 
     The merged-buffer + staging-buffer separation is required because the
     wheel's ``TensorBinding.read(dst)`` writes into ``dst`` only when
     ``dst.shape == binding.shape``, so we cannot read directly into a slice
     of the merged buffer.
+
+    Unlike PhysX -- which receives a live :class:`omni.physics.tensors.SimulationView`
+    via a ``simulation_view`` property setter and discovers prims lazily --
+    OVPhysX wires bindings through an explicit :meth:`setup` call that
+    takes the live ``ovphysx.PhysX`` handle and the USD stage. The wheel
+    exposes a ``physx + stage`` pair rather than a single ``SimulationView``,
+    so a property setter would have to either bundle the two or fire on the
+    second assignment; the explicit call keeps the lifecycle obvious.
     """
 
     def __init__(self):
@@ -64,7 +72,6 @@ def __init__(self):
         self._rigid_bindings: list[dict[str, Any]] = []
         self._merged_transforms: wp.array | None = None
         self._scene_data = SceneDataFormat.Transform()
-        self._device: str = "cpu"
 
     @property
     def transform_count(self) -> int:
@@ -79,12 +86,13 @@ def transform_paths(self) -> list[str]:
             paths.extend(list(entry["pose"].prim_paths))
         return paths
 
-    def setup(self, physx, stage) -> None:
+    def setup(self, physx, stage, device: str) -> None:
         """Discover RigidBodyAPI prims, dedup by env-wildcard form, create one binding per pattern.
 
         Args:
             physx: Live ``ovphysx.PhysX`` instance (the wheel handle).
             stage: USD stage to traverse for RigidBodyAPI prims.
+            device: Warp device string used to allocate the staging and merged buffers.
         """
         from isaaclab_ovphysx import tensor_types as TT  # local: keep heavy ovphysx out of module load
 
@@ -110,20 +118,13 @@ def setup(self, physx, stage) -> None:
             try:
                 pose_binding = physx.create_tensor_binding(pattern=pattern, tensor_type=TT.RIGID_BODY_POSE)
             except Exception as exc:
-                logger.warning(
-                    "[OvPhysxSceneDataBackend] Failed to create RIGID_BODY_POSE binding for %s: %s",
-                    pattern,
-                    exc,
-                )
+                logger.warning("Failed to create RIGID_BODY_POSE binding for %s: %s", pattern, exc)
                 continue
             row_count = int(pose_binding.shape[0])
             if row_count == 0:
-                logger.debug(
-                    "[OvPhysxSceneDataBackend] Pattern %s matched 0 rigid bodies; skipping.",
-                    pattern,
-                )
+                logger.debug("Pattern %s matched 0 rigid bodies; skipping.", pattern)
                 continue
-            pose_buf = wp.zeros(pose_binding.shape, dtype=wp.float32, device=self._device)
+            pose_buf = wp.zeros(pose_binding.shape, dtype=wp.float32, device=device)
             # Zero-copy reinterpret of the (N, 7) float32 staging buffer as (N,) wp.transformf.
             # Same pointer + layout; transformf is 7 float32s (pos.xyz + quat.xyzw). Cached
             # so per-step ``transforms`` reads don't reallocate the view object.
@@ -147,7 +148,7 @@ def setup(self, physx, stage) -> None:
             total_count += row_count
 
         if total_count > 0:
-            self._merged_transforms = wp.zeros((total_count,), dtype=wp.transformf, device=self._device)
+            self._merged_transforms = wp.zeros((total_count,), dtype=wp.transformf, device=device)
 
     @property
     def transforms(self) -> SceneDataFormat.Transform:
@@ -173,11 +174,7 @@ def transforms(self) -> SceneDataFormat.Transform:
             try:
                 entry["pose"].read(entry["pose_buf"])
             except Exception as exc:
-                logger.warning(
-                    "[OvPhysxSceneDataBackend] RIGID_BODY_POSE read failed for %s: %s",
-                    entry["pattern"],
-                    exc,
-                )
+                logger.warning("RIGID_BODY_POSE read failed for %s: %s", entry["pattern"], exc)
                 continue
             wp.copy(
                 self._merged_transforms,
@@ -480,8 +477,7 @@ def _warmup_and_load(cls) -> None:
         # via :meth:`get_scene_data_backend`.
         if cls._scene_data_backend is None:
             cls._scene_data_backend = OvPhysxSceneDataBackend()
-        cls._scene_data_backend._device = PhysicsManager._device
-        cls._scene_data_backend.setup(cls._physx, sim.stage)
+        cls._scene_data_backend.setup(cls._physx, sim.stage, PhysicsManager._device)
 
         cls.dispatch_event(PhysicsEvent.MODEL_INIT, payload={})
         cls._warmup_done = True

source/isaaclab_ovphysx/test/physics/test_ovphysx_scene_data_backend.py

@@ -88,15 +88,14 @@ def test_transform_paths_empty_when_no_bindings():
 
 
 def test_setup_creates_one_binding_per_distinct_pattern(monkeypatch):
-    """``setup(physx, stage)`` buckets RigidBodyAPI prims by env-wildcard form.
+    """``setup(physx, stage, device)`` buckets RigidBodyAPI prims by env-wildcard form.
 
     For cartpole-shaped scenes (``cart``, ``pole``), expect 2 bindings — one
     per distinct env-relative prim path.
     """
     from isaaclab_ovphysx.physics.ovphysx_manager import OvPhysxSceneDataBackend
 
     b = OvPhysxSceneDataBackend()
-    b._device = "cpu"
 
     # Stage stub: traversal yields four RigidBodyAPI prims (cart/pole across two envs).
     paths = [
@@ -136,7 +135,7 @@ def create_tensor_binding(self, pattern, tensor_type):
 
     monkeypatch.setattr(om_mod, "UsdPhysics", SimpleNamespace(RigidBodyAPI=object()))
 
-    b.setup(FakePhysX(), stage)
+    b.setup(FakePhysX(), stage, "cpu")
 
     # Cartpole = 2 distinct env-wildcard patterns -> 2 bindings.
     assert len(created) == 2
@@ -161,7 +160,6 @@ def test_transforms_reads_each_binding_and_returns_transform_format():
     from isaaclab_ovphysx.physics.ovphysx_manager import OvPhysxSceneDataBackend
 
     b = OvPhysxSceneDataBackend()
-    b._device = "cpu"
     b._merged_transforms = _wp.zeros((3,), dtype=_wp.transformf, device="cpu")
 
     # Two bindings: first with 2 rows, second with 1 row.
@@ -260,7 +258,6 @@ def test_setup_continues_when_create_tensor_binding_raises(monkeypatch, caplog):
     from isaaclab_ovphysx.physics.ovphysx_manager import OvPhysxSceneDataBackend
 
     b = OvPhysxSceneDataBackend()
-    b._device = "cpu"
 
     paths = [
         "/World/envs/env_0/Robot/cart",
@@ -289,7 +286,7 @@ def create_tensor_binding(self, pattern, tensor_type):
     monkeypatch.setattr(om_mod, "UsdPhysics", SimpleNamespace(RigidBodyAPI=object()))
 
     with caplog.at_level(logging.WARNING, logger=om_mod.logger.name):
-        b.setup(FlakyPhysX(), stage)
+        b.setup(FlakyPhysX(), stage, "cpu")
 
     # The pole pattern survived; the cart pattern was logged and skipped.
     assert len(b._rigid_bindings) == 1
@@ -308,7 +305,6 @@ def test_transforms_logs_warning_when_a_binding_read_fails(caplog):
     from isaaclab_ovphysx.physics.ovphysx_manager import OvPhysxSceneDataBackend
 
     b = OvPhysxSceneDataBackend()
-    b._device = "cpu"
     b._merged_transforms = _wp.zeros((2,), dtype=_wp.transformf, device="cpu")
 
     buf_good = _wp.zeros((1, 7), dtype=_wp.float32, device="cpu")