simulation/README.md

Simulation

Isaac Lab / Isaac Sim workspace for v2d.

This tree is self-contained. Scripts under simulation/scripts/ must not import Dream or other project trees. The layout matches reconstruction/.

Layout

simulation/
├── run_isaaclab.sh
├── setup.sh                 # isolated venv (no conda)
├── config/paths.sh          # data + modules; uses simulation/.venv
├── scripts/                 # first-party stages
├── setup/
│   ├── 00_init_modules.sh   # clone IsaacLab if missing
│   └── 02_relocate_venv.sh  # rewrite paths after a move
├── modules/IsaacLab/        # Isaac Lab source
└── runs/                    # outputs (gitignored)

The existing Dream venv (env_isaaclab) lives here as simulation/.venv. Isaac Lab source lives in simulation/modules/IsaacLab.

Setup

One isolated venv under simulation/.venv. No conda.

cd simulation
./setup.sh
source .venv/bin/activate

Isaac Sim 6.0.1 and Isaac Lab 3.0.0-beta2 are already installed in .venv (Python 3.12). ./setup.sh only clones Isaac Lab if modules/IsaacLab is missing, then rewrites venv shebangs / editable install paths.

Run

cd simulation
source .venv/bin/activate
./run_isaaclab.sh --help

Replay G1 Inspire + object + MANO

Same idea as NVIDIA robotic_grounding/scripts/replay_motion.py: teleport a floating Inspire hand and the tracked object each physics step (no contact forces). Data comes from retarget/export_isaaclab.sh (Z-up isaaclab_replay.npz), not from motion_v1 parquet.

cd retarget
./export_isaaclab.sh --video-dir ../reconstruction/runs/20200709_141754_836212060125

cd ../simulation
source .venv/bin/activate
./replay_v2d.sh --npz ../reconstruction/runs/20200709_141754_836212060125/obj_tracking_out/isaaclab_replay.npz --headless

Plays once: physics settle (object XY fixed, Z/rotation fall onto the table; hand stays glued to the object as in the video), then the clip, then writes obj_tracking_out/isaaclab_replay.mp4 and exits.

--table-z (default 0.75 m), --settle-sec (default 2), --no-settle to skip the drop. Gold/robot is the URDF articulation; green spheres are HaWoR MANO joints; the coffee-can is a dynamic rigid on a cuboid table.

SONIC whole-body (G1 29-DoF)

Frozen GEAR-SONIC v1.1 ONNX from checkpoints/sonic/sonic_v1_1. This is not G1_MINIMAL_CFG (locomotion USD). SONIC uses the 29-DoF G1 (G1_29DOF_CFG): three waist joints and three wrist joints per arm, no Inspire fingers.

The DexYCB clip is a tabletop right hand. Play uses teleop encoder mode: standing legs + reconstructed hand root as the right-wrist target. The object is translated into the reachable wrist band (same layout as g1_sonic_manip), not left at the capture's table centre.

cd simulation
source .venv/bin/activate
./replay_sonic.sh --headless --hands inspire \
  --npz ../reconstruction/runs/20200709_142553_836212060125/obj_tracking_out/isaaclab_replay.npz

Writes obj_tracking_out/sonic_replay.mp4 next to isaaclab_replay.npz. --mode g1 tracks a standing 29-DoF pose only (smoke test). GPU node; onnxruntime-gpu is in simulation/.venv.

The robot has more than 29 joints

SONIC drives 29 body joints; everything else is fingers, free to use as a separate grasp action channel. Anything reading or writing joints must resolve SONIC's 29 by name (play_sonic.py:_joint_ids), never by assuming they are indices 0..28.

--hands	USD	fingers	total joints
dex3 (default)	stock g1.usd	3 per hand, 7 DoF	43
inspire	local mirror	5 per hand, 12 DoF	53 + root
wuji	CoordEx g1_wuji_no_merge.usd	5 per hand, 20 DoF	69

Dex3 joints are {left,right}_hand_{index,middle}_{0,1}_joint and _thumb_{0,1,2}_joint. Inspire joints are [LR]_<finger>_<link>_joint. Wuji joints are {left,right}_finger<1-5>_joint<1-4> (finger1 = thumb), which is the naming written by g1_wuji_retarget.npz.

wuji is the hand the g1_sonic_manip task now uses. Its USD carries all 29 SONIC body joints under identical names, so SONIC's body control is unaffected by the choice, and it has no mimic joints at all. The reason to prefer it over inspire is not the mechanism but the software: matching CoordEx's hardware is what lets its pretrained hand VAE prior be reused as an initialization. Finger actuator gains for wuji are copied from CoordEx's wuji_hands actuator (_HAND_GAINS in sonic/robot_cfg.py) so finger dynamics match what that prior was trained against.

Isaac Lab's stock g1_29dof_inspire_hand.usd cannot be spawned as-is; it is authored for a fixed-base manipulation rig and has two independent faults. Both report the same misleading symptom, because either one stops PhysX creating the articulation and the real complaints scroll past far above it:

Pattern '/World/Robot/root_joint' did not match any articulations

1. Mimic joints. The finger linkages are physxMimicJoint:* properties (gearing -1.0 on the four fingers, -1.6 and -2.4 on the thumb) that this PhysX build cannot resolve: failed to find internal joint object for PhysxMimicJointAPI. Both the properties and the applied PhysxMimicJointAPI schema have to go. Dropping only the properties leaves the API applied with no referenceJoint, which spawns fine but logs must have exactly 1 "referenceJoint" relationship defined once per joint per articulation -- 12 lines per robot, 48 for four environments, enough to bury the error you actually care about.
2. Fixed base. PhysicsArticulationRootAPI sits on root_joint, a PhysicsFixedJoint anchoring the pelvis to the world. Spawning with fix_root_link=False disables that joint and removes the articulation root along with it. Stock g1.usd has no root joint and puts the API on /g1/pelvis instead.

scripts/fetch_inspire_hand.py mirrors the asset into assets/g1/ (gitignored, ~39 MB) and fixes both in its 19 KB physics layer, leaving the 39 MB mesh layer untouched. It is idempotent and self-verifying.

Stripping the mimic leaves the six coupled joints per hand independently actuated. If you want the real linkage back, re-impose the gearing in software and mind the sign: index_intermediate is limited to [-19.48, 116.88] deg while gearing -1.0 on a [0, 97.4] deg proximal would imply [-97.4, 0], so the two joint frames are oppositely oriented.

Conventions that are easy to get wrong

Both of these produce a robot that thrashes rather than an obvious crash, so check them first if SONIC misbehaves. A standing reference should yield max|action| < 0.5; if it is ~4-5, one of these is wrong.

1. Joint order. SONIC reads observations and emits actions in Isaac Lab joint order, while default_angles / kps / g1_action_scale in policy_parameters.hpp are in MuJoCo order. constants.py keeps both name lists and reindexes by name, so everything downstream is Isaac Lab order. Deploy bridges them in CreatePolicyCommand.
2. 6D rotations flatten row-wise, [m00, m01, m10, m11, m20, m21] -- this is matrix_from_quat(q)[..., :2].reshape(-1), not the first two columns stacked. The identity is [1,0,0,1,0,0], not [1,0,0,0,1,0].

VR 3-point targets (vr_3point_local_target) are relative to the reference motion pelvis, not the robot pelvis, and the third point is torso_link offset by +0.35 m, not a head link. Proprioception history is oldest-first.

Batched SONIC (for RL rollouts)

The shipped ONNX pair is traced at batch 1, so an RL rollout would need one inference call per environment per tick. Re-export graphs that take any batch:

python scripts/export_sonic_dynamic_batch.py   # writes model_*_batch.onnx
./jobs/sonic_bench.sh                          # GPU node: equivalence + throughput

SonicOnnxAgent prefers model_*_batch.onnx when present and accepts either (D,) or (N, D). Two things had to be patched, both invisible at batch 1:

1. 20 Reshape targets spell the batch out as a literal 1; they become -1.
2. The encoder-mode one-hot is a ScatterND into a constant of shape [1, 3], indexed by a torch.arange(batch) that constant-folded to [0]. It can only ever fill row 0, so every environment past the first would get an all-zero one-hot and therefore a zero token. It is rebuilt as onehot[b, k] = (encoder_index[b] == k), which also allows per-env modes.

CUDA is opt-in via SONIC_ORT_CUDA=1. onnxruntime-gpu 1.29 links the CUDA 13 runtime, whose wheels sit in nvidia/cu13/lib with nothing putting them on the loader path. policy.py preloads the four it needs (libcudart, libcublas, libcublasLt, libcurand) with RTLD_LOCAL -- not LD_LIBRARY_PATH, which would shadow the CUDA 12 libs torch is built against, and not RTLD_GLOBAL, which would expose CUDA 13 cuBLAS symbols for torch to bind to.

Measured on one H100 (jobs/sonic_bench.log), encoder+decoder per control tick:

batch	CPU	CUDA
256	6.5k env-steps/s	204k env-steps/s
4096	6.2k env-steps/s	644k env-steps/s (6.4 ms/tick)

So a frozen SONIC inner loop is affordable inside an RL rollout on GPU, and is roughly 100x too slow on CPU.

Where the hand can actually go

scripts/probe_wrist_tracking.py sweeps commanded right-wrist targets in the pelvis frame and records where the hand ends up (jobs/sonic_probe.sh, results in runs/wrist_tracking.npz). This bounds anything built on top of SONIC, because a policy cannot place the hand better than the controller beneath it.

Tracking is repeatable but biased. Spread over the settling window is 1.3 mm median, so commanding the same target twice lands in the same place; but the steady-state offset is 8 cm median over a 27-point grid, and structured:

commanded	median error	signed bias on that axis
x = 0.40	0.042 m	+0.013 m
x = 0.55	0.101 m	−0.055 m (arm out of reach)
y = −0.30	0.035 m	+0.028 m
y = 0.00	0.116 m	+0.062 m (cannot cross the midline)
z = −0.05	0.032 m	+0.026 m
z = +0.25	0.105 m	+0.077 m

A smooth repeatable bias is learnable, so absolute wrist pose is still a usable action space; random 8 cm scatter would not have been. The practical envelope is x 0.30-0.42, y −0.28..−0.12, z −0.05..0.15, where error is 1-4 cm. Outside it the arm saturates. Kinematics agree: a target at x = 0.45, z = 0.03 is 0.59 m from the shoulder, about the whole arm.

This rules out replaying the DexYCB layout directly. In that clip the can sits 1.10 m in front of the pelvis and the demonstrated hand path spans x = 0.59-0.93 m, so a standing G1 cannot reach any of it — the human was leaning over the table. Worse, the capture's table is 1.2 m deep with the can at its centre, so even standing flush against the front edge leaves the can 0.60 m out. Use the clip for grasp reference; author the scene for the robot's workspace.

Physical G1 RL env

Manager-based Isaac Lab env (gravity + contacts), not kinematic replay:

simulation/source/v2d_sim/tasks/g1_table_object/ → Gym V2D-G1-TableObject-v0

Train/play wrappers are in ../rl (algorithm still a PPO stub):

cd ../rl
./play.sh --headless --steps 200
./train.sh --headless --num_envs 64

Manipulation over frozen SONIC

simulation/source/v2d_sim/tasks/g1_sonic_manip/ → Gym V2D-G1-SonicManip-v0

SONIC is frozen and owns balance and all 29 body joints. The learned policy never sees a joint: its action is a right-wrist target in the pelvis frame (3) plus a finger closure (1), and mdp/actions.py runs SONIC inside the env to turn that into joint targets. Physics 200 Hz, SONIC 50 Hz, policy 25 Hz.

Two consequences of the probe above are baked into the config. The action range is clamped to the well-tracked band rather than the arm's kinematic limit, since commanding outside it just saturates. And the scene is re-authored rather than copied from the capture: a 0.8 m deep table with the object spawning at pelvis x 0.31-0.41, y −0.27..−0.13, which is where tracking is a few centimetres.

The object is the reconstructed can with its SAM3D texture, spawned from obj_tracking_out/isaaclab_assets/object.urdf (written by retarget/export_isaaclab.sh), not a placeholder cuboid. The spawn config sets no visual_material, which is what lets the URDF's own MTL and 1024px texture survive USD conversion; setting one silently replaces the texture with a flat colour. Collision is a convex hull, which suits a can and keeps startup quick.

That mesh is y-up and the URDF applies no correction, so spawning it unrotated in a z-up world lays the can on its side. It technically balances there, but on 198 contact vertices with 1.2 cm between the support polygon and the centre of mass, so the first touch rolls it away. OBJECT_REST_ROT is the clip's tracked orientation with its 8.8° tilt removed, putting body +y at world +z: 2066 contact vertices and 6.1 cm of margin, standing on its base with the yaw the capture recorded. OBJECT_REST_H (6.94 cm) is the lowest rotated vertex in that attitude — it depends on the rotation and is not half the bounding box, so recompute both together if the clip or the mesh scale changes.

Reset spins the can with mdp.events.reset_object_on_table rather than reset_root_state_uniform, which composes its sampled rotation on the right (q_default * q_delta) and so yaws about the body z axis. With an upright can that axis points sideways, so the stock term would tip it over by up to the sampled angle. Composing on the left keeps the axis vertical in the world.

Height gained is measured from the object's resting pose, not the table top. The mesh origin is its centroid, so it already sits ~7 cm up when untouched; measuring from the table top pays a constant lift reward for doing nothing.

Because tracking is biased, the policy is given the achieved wrist pose and the object-to-hand vector, not just its own command, so it closes the loop on where the hand went instead of trusting where it aimed.

./jobs/sonic_manip_smoke.sh          # scripted reach/close/lift, no learning
cd ../rl && ./train.sh --headless --task V2D-G1-SonicManip-v0 --num_envs 32

Run the smoke test first. It answers whether the environment is sound (robot stays up, hand reaches the target, scripted grasp lifts) separately from whether the reward is learnable — after training the two are hard to tell apart.

BatchedSonicController (sonic/batched.py) is the vectorised inner loop. With a fixed standing reference nearly the whole 1751-D encoder vector is constant, so it is built once and only the heading (6) and VR 3-point target (21) are rewritten per step. Its packing is bit-exact against the single-env pack_encoder path, and vr3_local_batch against vr3_local_from_bodies.

Known limits of this first version: the wrist orientation target is held at the standing pose, so the policy controls position and grip only. Only wrist position tracking was measured; if grasping turns out to need a specific approach angle, orientation is the next thing to add to the action space.

CoordEx baseline

V2D-CoorDex-WalkGrab-Play-v0 runs CoordEx's released WalkGrab policy on a reconstructed object, as a literature baseline. This is not SONIC: the robot is CoordEx's G1-Wuji and the whole MDP is theirs. --clip picks which reconstruction goes on the table, and videos are written per clip so runs do not overwrite:

./jobs/coordex_v2d_play.sh --headless --video --clip 20200709_141754_836212060125

V2D-CoorDex-WalkGrab-Stock-v0 is the control: the same policy on CoordEx's own cylinder. Use it to separate porting bugs from genuine generalization failure — it grasps and lifts, which is how we established the port is sound. On the coffee can the same policy makes contact but lifts it only ~3 mm, so the failure is out-of-distribution object geometry, not wiring and not the hand hardware.