Particle-set total mass not fully transferred to rigid body

Omniverse Isaac Sim
1

Important: Isaac Sim support

Note: For Isaac Sim support, the community is gradually transitioning from this forum to the Isaac Sim GitHub repository so that questions and issues can be tracked, searched, and resolved more efficiently in one place. Whenever possible, please create a GitHub Discussion or Issue there instead of starting a new forum topic.

Note: For any Isaac Lab topics, please submit your topic to its GitHub repo ( GitHub - isaac-sim/IsaacLab: Unified framework for robot learning built on NVIDIA Isaac Sim · GitHub ) following the instructions provided on Isaac Lab’s Contributing Guidelines ( Contribution Guidelines — Isaac Lab Documentation ).

Please provide all relevant details below before submitting your post. This will help the community provide more accurate and timely assistance. After submitting, you can check the appropriate boxes. Remember, you can always edit your post later to include additional information if needed.

6.0.0
5.1.0
5.0.0
4.5.0
4.2.0
4.1.0
4.0.0
4.5.0
2023.1.1
2023.1.0-hotfix.1
Other (please specify):

Operating System

Ubuntu 24.04
Ubuntu 22.04
Ubuntu 20.04
Windows 11
Windows 10
Other (please specify):

GPU Information

  • Model: NVIDIA GeForce RTX 5080
  • Driver Version: 580.159.03

Topic Description

A rigid body in contact with a particle set only experiences a fraction of the assigned total particle-set mass. As a result, the lifting force required does not match the assigned total particle-set mass.

Detailed Description

I am testing the interaction between a rigid-body ground plane and PBD particles in Isaac Sim / Omniverse PhysX.

Setup

  • A ground plane created from a cube mesh, with a Rigid Body, a Collider (collider preset), and mass = 1 kg.

  • Particles placed on top of the plane using the Particle Sampler from a cube mesh, which automatically creates a Particle System and a Particle Set.

  • The Particle Set is assigned a total mass = 10 kg (Mass component on the particle set).

Experiment
I apply an upward force in the +Z direction to the ground plane and measure the threshold force required to start lifting it.

What I expected
The force needed to lift the plane should be roughly constant regardless of particle count, since the total supported mass (plane 1 kg + particles 10 kg = 11 kg) does not change. I expected a lift threshold of about (1 + 10) · 9.81 ≈ 107.9 N in every case.

What actually happened
The required lifting force decreases as the particle count increases, following the pattern of plane weight + only ONE particle’s share of the total particle-set mass:

  • No particles: plane lifts at > 9.81 N → (1 kg) · 9.81 as expected.

  • 1 particle: plane lifts at > 108 N → (1 + 10) · 9.81 ≈ 107.9 (full 10 kg felt).

  • 4 particles: plane lifts at ≈ 34.33 N → (1 + 10/4) · 9.81 (only 2.5 kg of the 10 kg felt).

So the measured threshold is (m_plane + M/N) · 9.81, where M = total particle-set mass and N = particle count. The total set mass stays 10 kg, but only one particle’s worth of mass ever loads the rigid plane.

I later found that the PhysX docs define particle-set mass as computedMass = mass / numParticles, which explains the per-particle scaling. However, even accounting for that, I would still expect the sum of all particles contact reactions on the plane to equal the full 10 kg when all particles are in contact, which it does not.

Steps to Reproduce

  1. Create a ground plane from a cube mesh. Apply Rigid Body + Collider (collider preset). Set its mass to 1 kg.

  2. Use the Particle Sampler on a cube mesh placed above the plane to generate a Particle System and Particle Set.

  3. On the Particle Set, add a Mass component and set the total mass = 10 kg.

  4. Press Play and let the particles settle on the plane.

  5. Apply an upward force in +Z to the ground plane and increase it until the plane starts to lift; record the threshold force.

  6. Repeat steps 2–5 with different particle counts (e.g. N = 1, then N = 4), keeping the particle-set total mass fixed at 10 kg.

  7. Observe that the lift threshold drops as N increases: ≈ 108 N for N = 1, but ≈ 34 N for N = 4.

Screenshots or Videos

Additional Information

What I’ve Tried

  • Spread particles into a single flat layer so that every particle is in direct contact with the plane. This did not change the result — the plane still only feels one particle’s worth of load, which rules out a stacked-column / force-chain propagation issue.

  • Replaced the particles with N small rigid bodies (e.g. 4 spheres at 2.5 kg each). This works exactly as expected: the plane requires > 108 N to lift, i.e. rigid-rigid contacts correctly sum to the full 10 kg. This isolates the issue specifically to the particle → rigid-body coupling / particle-set mass handling, not to the rigid solver or my force measurement.

  • Verified the mass formula in the docs: Omniverse Physics documentation states under “Particle-Set Mass Computation” that computedMass = mass / numParticles, confirming the per-particle division of the assigned set mass.

  • Checked precedence of mass sources (default density < scene material density < system material density < mass-component density < mass-component mass).

Additional Context

My questions for confirmation:

  1. Is it by design that the total particle-set mass is divided evenly across particles (mass / numParticles) and that this per-particle mass, rather than the summed contact load, governs the two-way coupling reaction on a rigid body?

  2. When many particles are simultaneously in contact with a rigid body, are their individual contact impulses summed onto the rigid body, or is the coupling effectively limited so that the rigid body only experiences a single particle’s worth of reaction?

  3. What is the recommended way to make a rigid body feel the full particle-set mass independent of particle count?

  4. Are there known limitations or planned improvements for particle → rigid-body load transfer fidelity?

3

Hi, the results you got are unexpected. Can you try:

  1. Raise the solver budget:
    • On PhysxSchema.PhysxSceneAPI: more substeps and a higher TimeStepsPerSecond (e.g. 240+).
    • On the particle system: increase its solver position iteration count.
    • On the rigid body: higher SolverPositionIterationCount.
  2. Tune the offsets — particleContactOffset / restOffset. If particles rest with gaps or interpenetrate, contacts are missed or softened and the transferred load drops.
  3. Avoid large particle-to-body mass ratios. Keeping per-particle mass comparable to (or below) the rigid body’s mass gives the solver a much easier, more accurate contact to resolve.
  4. switch to Newton physics backend
4

Thanks the detailed suggestions! I’ve systematically tested each of them:

1. Solver Budget Adjustments

What I tried:

  • PhysxSceneAPI:
    • Increased TimeStepsPerSecond from 60 to 400 (tested at 60, 120, 240, 360, and 400)
  • Particle System:
    • Increased solverPositionIterationCount from 32 to 255 (32 showed minor improvement; values above 64 had diminishing returns)
  • Rigid Body:
    • Increased physxRigidBody:solverPositionIterationCount from 16 to 255 (no observable effect on particle-rigid body interactions)

2. Contact Offsets

What I tried:

  • Adjusted particleContactOffset and restOffset for both the particle system and rigid body plane (Tested values: Default (0.05), 0.1, 0.2, and 0.5) with no measurable improvement in force transfer or stability

3. Mass Ratio Sensitivity

What I tried:

  • Original setup:
    • Particle set mass: 10 kg
    • Rigid body plane mass: 1 kg
    • Result: Force needed to lift the plane was substantially lower as expected
  • Revised setup:
    • Particle set mass: 1 kg
    • Rigid body plane mass: 10 kg
    • Result: Correct force needed to lift the combined plane an particles mass

Seems that this is the most impactful solution and the PhysX solver struggles significantly with large particle-body mass disparities where the particle mass is substantially higher than the rigid body mass

4. Newton Physics Backend

What I tried:

  • I switched to the experimental Newton physics backend:

    • I reviewed the standalone Newton particle example scripts, which rely on SolverImplicitMPM for implicit material point method (MPM) simulations

    • Seems that this solver is not yet exposed in Isaac Sim 6.0.0 Python API

    • After checking the Isaac Sim Python API and documentation, it seems that no other Newton-specific particle solver is currently supported in Isaac Sim 6.0.0

Seems that for now, PhysX remains the only viable backend for particle systems in Isaac Sim 6.0.0

Summary of Recommendations

Table

Issue Solution Effectiveness
Solver instability Increase TimeStepsPerSecond (240+) and particle solverPositionIterationCount (32–64) Minor improvement
Contact offsets No adjustment needed if particles already contact the rigid body No effect
Mass ratio sensitivity Ensure particle mass < rigid body mass (e.g., 1 kg particles, 10 kg body) Resolved the issue
Newton backend Not available in Isaac Sim 6.0.0. Use PhysX for now Not applicable

Open Questions

  1. Why does the solver fail with heavy particles + light rigid body?
    • Is this a limitation of PhysX’s particle-rigid body contact model, or is there a hidden parameter that could help?
  2. Are there plans to expose SolverImplicitMPM or other advanced solvers in future Isaac Sim releases?

Thanks again for the guidance!

5

Hi, Thanks for the update, very useful!
For your questions:

  1. Changing the particle-to-body mass ratios improves both the correction sharing and the conditioning of the contact, so the solver converges and the load transfers correctly.
    The mass-ratio sensitivity is inherent to PBD’s position-projection contact solve with a finite iteration budget. As covered, the contact is conditioned by the reduced mass and the correction is split by inverse mass; a large ratio makes the contact stiff and ill-conditioned, and a fixed number of iterations can’t converge it. There is no parameter that makes the mass ratio not matter —
    and, unlike PhysX rigid-rigid contact (which got the TGS solver that tolerates high mass ratios far better than PGS), the particle↔rigid coupling goes through the PBD particle solver, which has no TGS-equivalent. So at the model level, yes, this is a limitation.
  2. Yes, there’s plan to expose more solvers in future Isaac Sim releases, stay tuned!
6

To summarize for anyone who finds this thread: the behavior is a known limitation of the PBD position-projection contact solver — keeping per-particle mass at or below the rigid body mass is the recommended workaround for now. We’re closing this topic, if you have further questions feel free to open new topics.