SolverCoupledADMM: Kamino+VBD cross-solver joint coupling breaks with 2+ attachment points (works fine with MuJoCo, works fine with exactly 1 VBD attachment)

[dougrag-hmc]

Body:

Environment

• newton 1.5.0 (pip package newton)
• warp-lang 1.16.0
• CUDA Toolkit 12.9, Driver 13.0
• GPU: NVIDIA RTX A4000
• OS: Windows

Summary

SolverCoupledADMM's joint_proximal_bodies mechanism (auto-detecting a "free"/unowned BALL/REVOLUTE/FIXED joint whose parent and child belong to two different entries, and turning it into a cross-solver ADMM attachment) works correctly for a single cross-solver joint between a SolverKamino entry and a SolverVBD entry. It breaks as soon as there are two or more such joints between the same Kamino/VBD entry pair.

The same pattern (2+ cross-solver joints) works fine when the non-Kamino entry is SolverMuJoCo instead of SolverVBD — both in a minimal repro and in Newton's own example_kamino_mujoco_admm_solver.py (which uses 4 cross-solver REVOLUTE joints). This suggests the bug is specific to the Kamino↔VBD pairing, not a general limitation on the number of cross-solver joints.

Two failure modes observed

1. Minimal model (2 free-floating Kamino boxes + a short VBD rod, 2 cross-solver FIXED joints): fails at SolverCoupledADMM(...) construction time with:
   ValueError: SolverKamino cannot simulate this model due to unsupported features:

   • joint types: CABLE (3 instances)
     This happens even though the CABLE joints belong entirely to the "vbd" entry and are never in the "kamino" entry's joints=[...] list. It looks like per-entry compaction falls back to an uncompacted view for the Kamino entry once there are 2+ cross-solver joints, and SolverKamino._validate_model_compatibility then sees the full (uncompacted) joint_type array, including the VBD entry's own CABLE joints.

2. Larger model (a 14-body URDF-imported robot arm with a closed kinematic loop as the Kamino entry, ~45-segment Cosserat rod as the VBD entry, 2-3 cross-solver FIXED joints): construction succeeds, but the first solver.step(...) call crashes with:
   RuntimeError: Error launching kernel: _apply_dual_preconditioner_to_state on device cuda:0:
   Warp CUDA error 700: an illegal memory access was encountered
   raised from inside SolverKamino's own PADMM solve (kamino/_src/solvers/padmm/solver.py:_update_solution).

Routing each attachment through a small intermediate "anchor" rigid body (added to the VBD entry, internally jointed to the rod with a normal owned joint, with only the anchor cross-jointed to Kamino) does not avoid either failure — same crash, just confirming it isn't specifically about which VBD body is targeted.

Minimal repro (fails at construction with the CABLE ValueError above)

import warp as wp
import newton
import newton.utils
from newton.solvers import SolverKamino, SolverVBD
from newton.solvers.experimental.coupled import SolverCoupled, SolverCoupledADMM

builder = newton.ModelBuilder(gravity=(0.0, 0.0, -9.81))
SolverKamino.register_custom_attributes(builder)
SolverVBD.register_custom_attributes(builder)

# Kamino entry: two free-floating boxes.
box_a = builder.add_link(xform=wp.transform((0.0, 0.0, 1.0), wp.quat_identity()), label="box_a")
builder.add_shape_box(box_a, hx=0.05, hy=0.05, hz=0.05)
joint_a = builder.add_joint_free(child=box_a, label="box_a_free")
builder.add_articulation([joint_a], label="box_a_art")

box_b = builder.add_link(xform=wp.transform((1.0, 0.0, 1.0), wp.quat_identity()), label="box_b")
builder.add_shape_box(box_b, hx=0.05, hy=0.05, hz=0.05)
joint_b = builder.add_joint_free(child=box_b, label="box_b_free")
builder.add_articulation([joint_b], label="box_b_art")

kamino_bodies = [box_a, box_b]
kamino_joints = [joint_a, joint_b]

# VBD entry: a short Cosserat-rod cable spanning between the two boxes.
cable_body_start, cable_joint_start = builder.body_count, builder.joint_count
points, quats = newton.utils.create_straight_cable_points_and_quaternions(
 start=wp.vec3(0.0, 0.0, 1.0), direction=wp.vec3(1.0, 0.0, 0.0), length=1.0, num_segments=4
)
rod_bodies, rod_joints = builder.add_rod(positions=points, quaternions=quats, radius=0.02, body_frame_origin="start")
vbd_bodies = list(range(cable_body_start, builder.body_count))
vbd_joints = list(range(cable_joint_start, builder.joint_count))

# Two "free" (unowned) cross-solver FIXED joints -- rely on
# SolverCoupledADMM.Config.joint_proximal_bodies auto-detection.
builder.add_joint_fixed(parent=box_a, child=rod_bodies[0], label="cross_fix_a")
builder.add_joint_fixed(parent=box_b, child=rod_bodies[-1], label="cross_fix_b")

builder.add_ground_plane()
builder.color()
model = builder.finalize(skip_validation_joints=True)

kamino_config = SolverKamino.Config()
kamino_config.use_collision_detector = False
kamino_config.use_fk_solver = False

# Raises ValueError("SolverKamino cannot simulate this model due to unsupported
# features: - joint types: CABLE (3 instances)") -- with EXACTLY ONE cross-solver
# joint instead of two, this constructs and steps fine.
solver = SolverCoupledADMM(
 model=model,
 entries=[
     SolverCoupled.Entry(
         name="kamino",
         solver=lambda v: SolverKamino(model=v, config=kamino_config),
         bodies=kamino_bodies,
         joints=kamino_joints,
     ),
     SolverCoupled.Entry(
         name="vbd",
         solver=lambda v: SolverVBD(model=v, iterations=10),
         bodies=vbd_bodies,
         joints=vbd_joints,
     ),
 ],
 coupling=SolverCoupledADMM.Config(
     iterations=5, rho=100.0, gamma=0.05, baumgarte=0.1,
     joint_stiffness=1e5, joint_angular_stiffness=1e5,
 ),
)

Expected behavior

Two (or more) cross-solver FIXED joints between a Kamino entry and a VBD entry should construct and step correctly, the same way multiple cross-solver joints already work between Kamino and MuJoCo entries.

Additional notes

- With joint_proximal_bodies=False I have not tried disabling the mechanism entirely (that would remove the cross-solver coupling I actually need), so I can't say whether the bug is in the proxy-visibility computation itself or somewhere downstream in Kamino's own step.
- Happy to share the full stack traces for both failure modes, or a more complete repro using an actual URDF-imported robot, if useful.