Fix OVPhysX device routing for CPU-resident tensor types (#7563)

# Description

`_CPU_ONLY_TYPES` in `isaaclab_ov` is the single constant deciding
whether an `OvPhysxView` tensor buffer is allocated on, and validated
against, host or device memory. It omitted eight tensor types that are
CPU-resident even on a GPU simulation:

| tensor type | alias | shape |
|---|---|---|
| `ARTICULATION_CONTACT_OFFSET` | `CONTACT_OFFSET` | `[N, S]` |
| `ARTICULATION_REST_OFFSET` | `REST_OFFSET` | `[N, S]` |
| `RIGID_BODY_CONTACT_OFFSET` | `RIGID_BODY_CONTACT_OFFSET` | `[N, S]` |
| `RIGID_BODY_REST_OFFSET` | `RIGID_BODY_REST_OFFSET` | `[N, S]` |
| `ARTICULATION_BODY_DISABLE_GRAVITY` | `BODY_DISABLE_GRAVITY` | `[N,
L]` |
| `RIGID_BODY_DISABLE_GRAVITY` | `RIGID_BODY_DISABLE_GRAVITY` | `[N]` |
| `ARTICULATION_DOF_DRIVE_TYPE` | `DOF_DRIVE_TYPE` | `[N, D]` |
| `ARTICULATION_DOF_DRIVE_MODEL` | `DOF_DRIVE_MODEL` | `[N, D, 3]` |

Because `_native_device` consults this set, it returned the simulation
device for host-resident data. Two consequences:

1. A hidden per-call host-to-device staging copy on every access, on a
path the view believed was device-native. Silent, and not attributable
to Isaac Lab in a profile. Values are still correct — ovphysx stages the
mismatch transparently, so this is not a data-integrity bug.
2. `_check_device` rejected a **correctly** placed buffer: allocating
one of these on the host, where the data actually lives, raised
`OvPhysxView.DeviceMismatch`, whose message advises moving the buffer
yourself — precisely the advice that fails here.

No shipped Isaac Lab workflow reads these eight through the tensor path
today, so this is latent rather than a live outage. It is not an obscure
corner: Isaac Lab already authors these same properties through USD
schema writes at scene construction, and the tensor path exists to
change such values per-env at runtime.

Each of the eight is also exposed as a public alias carrying its shape,
dtype and units, taken from the wheel's own type table. This module is
the alias layer over the ovphysx enum, so referencing them raw would
have left the candidate tuple a mix of aliases and raw enum members with
no stated reason why these eight differed. Naming follows the existing
convention: the `ARTICULATION_` prefix is dropped for articulation
types, as with `DOF_STIFFNESS` and `BODY_MASS`, and retained for
rigid-body ones, as with `RIGID_BODY_MASS`.

A second, orthogonal gap surfaced during the audit: ovphysx documents
`ARTICULATION_DOF_DRIVE_TYPE` as read-only, but it was missing from
`_READ_ONLY_NAMES`, so `set_attribute` accepted writes and forwarded
them. An audit of the full classification against the wheel's type table
found this to be the only such gap — of the 21 types ovphysx documents
read-only, 20 were already classified, with no misclassified members.

## Type of change

- Bug fix (non-breaking change which fixes an issue)
- New feature (non-breaking change which adds functionality)
- **Breaking change** — writes to `articulation_dof_drive_type` now
raise `OvPhysxView.ReadOnlyAttribute` instead of being silently
forwarded. Migration: remove the write; drive type is authored through
the USD drive schema, not the tensor path.

## Release backport

- [x] <!-- backport-active-release --> Backport this pull request to the
active release branch after it merges into `develop`

## Screenshots

Not applicable.

## Checklist

- [x] I have run the [`pre-commit` checks](https://pre-commit.com/) with
`./isaaclab.sh --format`
- [x] I have made corresponding changes to the documentation
- [x] My changes generate no new warnings
- [x] I have added tests that prove my fix is effective or that my
feature works
- [x] I have updated the changelog and the corresponding version in the
extension's `config/extension.toml` file
- [x] I have added my name to the `CONTRIBUTORS.md` or my name already
exists there

## How it was tested

ovphysx exposes no residency query (`ovphysx_tensor_spec_t` carries
dtype/ndim/shape and no device field), so residency was **measured**,
not assumed: CUDA memcpys were counted via CUPTI around each binding
read into a host buffer and into a device buffer, under the DirectGPU
configuration `isaaclab_ov` itself sets (`"/physics/suppressReadback":
True`). A host read showing `DtoH` means GPU-resident; no memcpy on the
host read plus `HtoD` on the device read means CPU-resident.

Measured across every GPU sample scene in the ovphysx 0.5.11 wheel:

| scene | before | after |
|---|---|---|
| `two_articulations_gpu` | `agree=40 MISMATCH=8` | `agree=48
MISMATCH=0` |
| `links_chain_sample_gpu` | `agree=40 MISMATCH=8` | `agree=48
MISMATCH=0` |
| `mixed_base_articulations_gpu` | `agree=36 MISMATCH=8` | `agree=44
MISMATCH=0` |
| `boxes_falling_on_groundplane_gpu` | `agree=9 MISMATCH=3` | `agree=12
MISMATCH=0` |
| `volume_deformable_multi` | `MISMATCH=0` | `MISMATCH=0` |
| `surface_deformable_material` | `MISMATCH=0` | `MISMATCH=0` |

Every previously classified member measured CPU-resident as declared in
all scenes, so the set was incomplete rather than wrong — there were no
false positives to correct.

The guarding test was a tautology: it compared the view's derived set
against the canonical set it is derived from, so it could not fail for
any contents. It now asserts against an independent inventory of
measured residency, mirroring the existing `_EXPECTED_READ_ONLY_NAMES`
pattern. Both new assertions were confirmed to fail before the fix and
pass after it; the read-only case fails with `DID NOT RAISE
ReadOnlyAttribute` without the fix.

- `pytest source/isaaclab_ov/test/sim/test_ovphysx_view.py` — 81 passed
- `test_articulation_helpers`, `test_rigid_object_helpers`,
`test_deformable_object_helpers`, `test_ovphysx_scene_data_backend`,
`test_randomize_rigid_body_material_mdp` — all pass
- `uv run isaaclab -f` — passes
- `tools/changelog/cli.py check develop` — passes

`test_views_xform_prim_ovphysx.py` reports 23 failed / 28 passed both
with and without this change; every failure is the process-global device
lock covered by the `device_split` marker, which requires per-device
re-invocation. Baselined on a clean tree to confirm it is unrelated.

Environment: ovphysx 0.5.11, Linux x86_64, Python 3.12, NVIDIA RTX 5000
Ada Generation Laptop GPU.

(cherry picked from commit ec58631)

Author: AntoineRichard

source/isaaclab_ov/changelog.d/ovphysx-cpu-only-tensor-types.minor.rst

@@ -0,0 +1,30 @@
+Added
+^^^^^
+
+* Added :attr:`~isaaclab_ov.tensor_types.DOF_DRIVE_TYPE`,
+  :attr:`~isaaclab_ov.tensor_types.DOF_DRIVE_MODEL`,
+  :attr:`~isaaclab_ov.tensor_types.BODY_DISABLE_GRAVITY`,
+  :attr:`~isaaclab_ov.tensor_types.CONTACT_OFFSET`,
+  :attr:`~isaaclab_ov.tensor_types.REST_OFFSET`,
+  :attr:`~isaaclab_ov.tensor_types.RIGID_BODY_DISABLE_GRAVITY`,
+  :attr:`~isaaclab_ov.tensor_types.RIGID_BODY_CONTACT_OFFSET`, and
+  :attr:`~isaaclab_ov.tensor_types.RIGID_BODY_REST_OFFSET` tensor type aliases,
+  documenting the shape, dtype and units of each.
+
+Fixed
+^^^^^
+
+* Fixed :class:`~isaaclab_ov.sim.views.OvPhysxView` routing eight CPU-resident
+  tensor types to the simulation device. The per-collision-shape contact and rest
+  offsets, the articulation and rigid-body gravity-disable flags, and the DOF drive
+  type and drive model are CPU-resident even on a GPU simulation, but were absent
+  from the internal CPU-only classification. Reads and writes of these types
+  incurred a hidden per-call host-to-device staging copy, and a correctly placed
+  host buffer was rejected with ``OvPhysxView.DeviceMismatch``. Residency was
+  measured on a GPU simulation by counting CUDA memcpys around a binding read.
+* **Breaking:** Fixed ``articulation_dof_drive_type`` not being classified as
+  read-only. The underlying tensor type is read-only, but
+  :meth:`~isaaclab_ov.sim.views.OvPhysxView.set_attribute` previously accepted
+  writes to it and silently forwarded them. Such calls now raise
+  ``OvPhysxView.ReadOnlyAttribute``. Remove any write to this attribute; drive
+  type is authored through the USD drive schema, not the tensor path.

source/isaaclab_ov/isaaclab_ov/sim/views/ovphysx_view.py

@@ -79,6 +79,7 @@
         "articulation_body_inv_mass",
         "articulation_body_inv_inertia",
         "articulation_dof_projected_joint_force",
+        "articulation_dof_drive_type",
         "articulation_jacobian",
         "articulation_mass_center_world",
         "articulation_mass_center_local",

source/isaaclab_ov/isaaclab_ov/tensor_types.py

@@ -149,6 +149,19 @@
 Shape is ``[N, D, 3]``, dtype ``float32``.
 """
 
+DOF_DRIVE_TYPE = _TT.ARTICULATION_DOF_DRIVE_TYPE
+"""DOF drive type (0 = none, 1 = force, 2 = acceleration).
+
+Shape is ``[N, D]``, dtype ``uint8``. Read-only.
+"""
+
+DOF_DRIVE_MODEL = _TT.ARTICULATION_DOF_DRIVE_MODEL
+"""DOF performance-envelope drive model (speed-effort gradient, maximum actuator
+velocity, velocity-dependent resistance).
+
+Shape is ``[N, D, 3]``, dtype ``float32``.
+"""
+
 """
 External wrench (GPU, write-only)
 """
@@ -193,6 +206,24 @@
 Shape is ``[N, L, 9]``, dtype ``float32``.
 """
 
+BODY_DISABLE_GRAVITY = _TT.ARTICULATION_BODY_DISABLE_GRAVITY
+"""Per-link gravity disable flag (nonzero disables gravity for that link).
+
+Shape is ``[N, L]``, dtype ``uint8``.
+"""
+
+CONTACT_OFFSET = _TT.ARTICULATION_CONTACT_OFFSET
+"""Contact offset of each collision shape.
+
+Shape is ``[N, S]``, dtype ``float32`` [m].
+"""
+
+REST_OFFSET = _TT.ARTICULATION_REST_OFFSET
+"""Rest offset of each collision shape.
+
+Shape is ``[N, S]``, dtype ``float32`` [m].
+"""
+
 """
 Rigid-body TensorTypes
 
@@ -225,6 +256,16 @@
 ``(N, 9)``, row-major flatten of the 3×3 inertia matrix
 ``(Ixx, Ixy, Ixz, Iyx, Iyy, Iyz, Izx, Izy, Izz)`` [kg·m²]."""
 
+RIGID_BODY_DISABLE_GRAVITY = _TT.RIGID_BODY_DISABLE_GRAVITY
+"""Gravity disable flag — read/write, CPU. Shape ``(N,)``, dtype ``uint8``;
+nonzero disables gravity for that actor."""
+
+RIGID_BODY_CONTACT_OFFSET = _TT.RIGID_BODY_CONTACT_OFFSET
+"""Contact offset of each collision shape — read/write, CPU. Shape ``(N, S)`` [m]."""
+
+RIGID_BODY_REST_OFFSET = _TT.RIGID_BODY_REST_OFFSET
+"""Rest offset of each collision shape — read/write, CPU. Shape ``(N, S)`` [m]."""
+
 # These three aliases are pending an upcoming ovphysx wheel update.
 # When the wheel ships them, the corresponding ``hasattr`` checks below
 # in IsaacLab consumers will start returning True and the bindings will
@@ -433,15 +474,23 @@
     DOF_MAX_FORCE,
     DOF_ARMATURE,
     DOF_FRICTION_PROPERTIES,
+    DOF_DRIVE_TYPE,
+    DOF_DRIVE_MODEL,
     BODY_MASS,
     BODY_COM_POSE,
     BODY_INERTIA,
     BODY_INV_MASS,
     BODY_INV_INERTIA,
+    BODY_DISABLE_GRAVITY,
+    CONTACT_OFFSET,
+    REST_OFFSET,
     # Rigid-body CPU-only entries (always available)
     RIGID_BODY_MASS,
     RIGID_BODY_COM_POSE,
     RIGID_BODY_INERTIA,
+    RIGID_BODY_DISABLE_GRAVITY,
+    RIGID_BODY_CONTACT_OFFSET,
+    RIGID_BODY_REST_OFFSET,
     DEFORMABLE_MATERIAL_DYNAMIC_FRICTION,
     DEFORMABLE_MATERIAL_YOUNGS_MODULUS,
     DEFORMABLE_MATERIAL_POISSONS_RATIO,

source/isaaclab_ov/test/sim/test_ovphysx_view.py

@@ -54,6 +54,7 @@
         "articulation_body_inv_mass",
         "articulation_body_inv_inertia",
         "articulation_dof_projected_joint_force",
+        "articulation_dof_drive_type",
         "articulation_link_incoming_joint_force",
         "articulation_mass_center_world",
         "articulation_mass_center_local",
@@ -70,6 +71,48 @@
     }
 )
 
+# CPU-resident on a GPU sim. Each name was measured, not assumed: with DirectGPU
+# (``suppressReadback=True``) the residency of every tensor type was determined by counting
+# CUDA memcpys around a binding read into a host buffer and into a device buffer.
+_EXPECTED_CPU_ONLY_NAMES = frozenset(
+    {
+        "articulation_body_com_pose",
+        "articulation_body_disable_gravity",
+        "articulation_body_inertia",
+        "articulation_body_inv_inertia",
+        "articulation_body_inv_mass",
+        "articulation_body_mass",
+        "articulation_contact_offset",
+        "articulation_dof_armature",
+        "articulation_dof_damping",
+        "articulation_dof_drive_model",
+        "articulation_dof_drive_type",
+        "articulation_dof_friction_properties",
+        "articulation_dof_limit",
+        "articulation_dof_max_force",
+        "articulation_dof_max_velocity",
+        "articulation_dof_stiffness",
+        "articulation_rest_offset",
+        "articulation_shape_friction_and_restitution",
+        "deformable_material_bending_damping",
+        "deformable_material_bending_stiffness",
+        "deformable_material_dynamic_friction",
+        "deformable_material_elasticity_damping",
+        "deformable_material_poissons_ratio",
+        "deformable_material_thickness",
+        "deformable_material_youngs_modulus",
+        "rigid_body_com_pose",
+        "rigid_body_contact_offset",
+        "rigid_body_disable_gravity",
+        "rigid_body_inertia",
+        "rigid_body_inv_inertia",
+        "rigid_body_inv_mass",
+        "rigid_body_mass",
+        "rigid_body_rest_offset",
+        "rigid_body_shape_friction_and_restitution",
+    }
+)
+
 # Per-type shapes used by the fakes (only the types touched by the tests).
 _SHAPES = {
     TensorType.RIGID_BODY_POSE: lambda n: (n, 7),
@@ -201,18 +244,25 @@ def test_read_only_names_are_valid_vocabulary():
 def test_read_only_and_cpu_only_classification():
     assert is_read_only("articulation_jacobian")
     assert is_read_only("rigid_body_acceleration")
+    assert is_read_only("articulation_dof_drive_type")
     assert not is_read_only("articulation_dof_stiffness")
     assert is_cpu_only("articulation_dof_stiffness")
     assert is_cpu_only("rigid_body_mass")
+    assert is_cpu_only("rigid_body_disable_gravity")
+    assert is_cpu_only("articulation_dof_drive_type")
     assert not is_cpu_only("rigid_body_pose")
 
 
 def test_cpu_only_names_match_canonical_set():
-    # The view derives its CPU-only set from tensor_types so the two cannot drift.
+    # Comparing the view's derived set against the canonical one cannot fail, since the
+    # former is built from the latter. The expected inventory is what gives this test
+    # teeth: it is measured residency, so it also rejects a set that is merely incomplete.
     from isaaclab_ov.sim.views import ovphysx_view as mod
     from isaaclab_ov.tensor_types import _CPU_ONLY_TYPES
 
-    assert frozenset(tt.name.lower() for tt in _CPU_ONLY_TYPES) == mod._CPU_ONLY_NAMES
+    assert frozenset(tt.name.lower() for tt in _CPU_ONLY_TYPES) == _EXPECTED_CPU_ONLY_NAMES
+    assert mod._CPU_ONLY_NAMES == _EXPECTED_CPU_ONLY_NAMES
+    assert set(attribute_vocabulary()) >= mod._CPU_ONLY_NAMES
 
 
 # -----------------------------------------------------------------------------