Physics: model and checks

The rod model, the Blender add-on, the MuJoCo and Blender checks with their results, and how to check a preset against a real cable.

Physics model

• Rod. The cable is a chain of N rigid segments (length ≈ 1.5 cable widths, at most 400 per cable). Consecutive segments share a joint at their common end point with three rotational springs: twist G·J / L, bending E·I_y / L and E·I_z / L, the discrete Kirchhoff rod. E·I and G·J come from the cross-section (polygon second moments, so a flat ribbon is a hundred times softer across its thickness than across its width) and an effective modulus drawn per cable; G = E / (2 (1 + ν)), ν = 0.45. The rest shape is straight; the authored pose (slack, coiled) is a deformed state.
• Coiled cords are modelled along their axis, as a helical spring seen as a rod (Wahl's close-coiled formulas): bending 2 E I p / (π D (2 + ν)), twist E I p / (π D), and an axial spring 4 G J / (π D³ n) shared by free transX joints, limited (PhysicsLimitAPI) from 0 (a close-coiled cord does not compress: its turns touch) to the stretch at which the wire is straight. The coil itself is in the visual mesh. As on a real handset cord, each plug is on a straight lead of bare wire (4–8 cm, drawn per end, added to the coiled length): there the joints bend and twist like the wire (E I, G J), do not stretch, and the segments weigh and collide as the wire; the coil opens out of the lead over about one coil diameter.
• Masses from the linear density; connectors from the volume of their parts and an effective density; inertia tensors from the meshes.

Blender

Blender's USD importer reads geometry and materials but ignores UsdPhysics: imported as is, a cable is a heap of loose tube pieces and its connectors fall off (see the comparison below). The add-on, adapted from Quincaillerie's, sets the physics up once and for all:

1. filaire blender-addon writes filaire_physics.zip.
2. In Blender (4.4 or later): Edit > Preferences > Get Extensions > Install from Disk, pick the zip.
3. File > Import > Universal Scene Description, as usual: every segment and connector gets its rigid body, every joint its constraint. Press Play.

On import it moves each body's origin to its centre of mass (Blender uses the origin as centre of mass), makes its collision shape a compound of the USD shapes (capsules, boxes and convex hulls rebuilt from the file), sets mass, friction and small collision margins, turns the cable joints into Generic Spring constraints with the USD drives' stiffness and damping (translations locked; a coiled cord's axial spring kept) and the connectors' fixed joints into Fixed constraints, and runs the rigid body world at 4000 substeps per second for the light segments. The same file runs as a script (blender -b -P filaire_physics.py -- file.usdc) without installing.

Bullet takes a spring's rest position from the first frame, so in Blender a cable keeps the shape it was generated in (coiled, slack) as its rest shape, where the file and MuJoCo say straight: a coiled cable stays coiled.

MuJoCo checks

filaire sim-test output/<preset> reads the OpenUSD files back (not the generator's objects) and runs, on CPU:

For speed, the drop test simulates the cable with at most 60 links (groups of segments merged, springs in series, same E·I) and without the twist hinge: in generalised coordinates a chain's mass matrix is dense and a step costs the cube of its joints. Each joint gets an armature (added inertia) and critical damping so that stiff, light links stay stable with a 1 ms step; neither changes a static equilibrium, which is what the sag and coil checks compare.

Power cord, coiled handset cord, Cat 6, USB-C, 3.5 mm jack and M12 sensor cable (1.5 m; the coiled cord 35 cm of coil), dropped together onto a steel swing-set frame from different heights and in very different orientations (flat or steep, across or along the beam, turned about their own axis). The power cord and the coiled cord land across the beam and stay there, the coil stretched by its own weight; the others hit an end first, glance off the beam or a leg and pile up on the floor. Simulated in MuJoCo from the OpenUSD files (rest shape straight, up to 60 links per cable, 0.5 ms step), rendered in Blender: scripts/drop_gif.py.

A coiled handset cord hangs from its top plug, a gripper pulls the bottom plug 45 cm down and lets go. Nothing is scripted after the release: the coil springs back on its axial spring, cannot shorten past its touching turns, bounces a few times and settles on its hanging length. Simulated in MuJoCo from the OpenUSD file, rendered in Blender: scripts/coil_gif.py.

Results

filaire generate --preset <p> --count 3 (1 m cables, seed 1) then filaire sim-test output/<p> --cables 3, one CPU core; measured with MuJoCo 3.17, before 4.0 (CI runs every check on MuJoCo 4):

Every keyed connector was stopped at 90° and 180° (at most 12 % of its depth, the IDC socket's flat face entering a little before its key meets the header), every reversible one went in at 180°, the 3.5 mm jack at every angle, like the DC barrels. The sag is 0.8 % under the linear beam formula for every cable: the geometric nonlinearity of a 10 % deflection, the same for all since the sample length is scaled to the stiffness. Generation takes 1–4 s per preset (3 cables), the checks 15–30 s (a minute for the coiled cords).

Blender checks

filaire blender-test output/<preset> builds, for each tested cable, a scene that references the cable file, keeps that cable (with its selected ends), lifts it 2 cm and drops it on the ground, then simulates it in Blender (Bullet) through the add-on, in its own process:

--mode naive imports the same scene the way one would by hand (File > Import > USD, every mesh an active rigid body, the ground passive) and reports how far neighbouring pieces drift apart.

filaire generate --preset <p> --count 2 (1 m cables, seed 1), then filaire blender-test output/<p> --cables 2 and --mode naive on the first cable, Blender 5.2 (bpy), one CPU core:

Through the add-on every cable holds together and comes to rest (a coiled cord's joints stretch along its axial spring, by design). Set up by hand, the pieces are independent: they spread over the floor, and where a heavy connector or a coil's overlapping pieces push on them, they are thrown metres away. The checks found a real defect of the first beta: on tight curves the rigid segments, as long as the arc they stand for, overlapped their neighbours by up to 0.4 mm at the joints; each segment now spans the chord between its joints.

Checking a preset against a real cable

A search of the literature (November 2026) found no measured bending stiffness for USB, Ethernet, HDMI or power cords by type. What is published sits in the same range as the presets (7.6e-6 to 1.4e-2 N·m²) but does not calibrate any of them:

A ruler is enough to measure a cable yourself (Peirce's cantilever test). Straighten the cable, lay it on a table and slide it over the edge until the line from the edge to the tip points 41.5° below horizontal. With l the overhanging length and m the mass per metre:

E·I = m · g · (l / 2)³

Turn the cable half a turn and repeat, to average out the curl it keeps from its coil. The overhang each preset predicts at its central modulus (weaker bending axis for flat cables; the coiled cord is left out, the test needs a straight cable):

If your cable overhangs a length l' instead, scale the modulus by (l' / l)³ with --modulus.