How to retrieve contact forces for rigid-deformable contacts?

[zhanglepy]

Hi Newton team,

Thank you for developing and open-sourcing Newton. I am currently evaluating Newton for robotics simulation tasks involving contact-rich interaction, especially rigid-body end-effectors interacting with deformable or soft objects.

For rigid-rigid contacts, I understand that physics engines usually provide contact information such as contact points, normals, penetration depth, impulses, or contact forces through contact-related data structures or APIs.

I would like to ask about rigid-deformable contact in Newton:

1. Does Newton currently support retrieving contact forces or contact impulses between a rigid body and a deformable/soft body?

2. If this is supported, is there an existing API, data structure, or example that exposes:

   • contact points,
   • contact normals,
   • penetration depth,
   • normal contact force or impulse,
   • tangential/friction force or impulse,
   • total contact force acting on the rigid body?

3. If direct contact force output is not currently supported for rigid-deformable interaction, what is the recommended way to estimate or compute it?
   For example, should users infer it from constraint impulses, nodal forces, deformation energy, penalty contact terms, or rigid-body dynamics?

4. Are there any planned features or examples for rigid-deformable contact force reporting, similar to rigid-rigid contact reporting?

My application is similar to a robot probe or end-effector pressing against a soft object, where I need to record the force-displacement curve and the total contact force during interaction.

Thank you very much for your help.

[jumyungc]

Hello @zhanglepy,

Unfortunately, Newton currently does not support contact force/impulse queries between rigid bodies and soft bodies.

Geometric contact data is available through the collision pipeline, but force- or impulse-related information is not exposed there. These quantities are computed inside the solver, and while some solvers compute the relevant rigid-soft contact forces or impulses internally, there is currently no public API to query them.

For now, the best workaround would likely be to compute them in a post-step query using the same internal contact force/impulse formulation or kernel used by the solver.

If you have a specific solver in mind, we may be able to advise better.

Thank you.

[AnkaChan]

Thanks @jumyungc for answering. Allow me to add some complement to JC's answer:

wp.launch(
                    kernel=accumulate_particle_body_contact_force_and_hessian,
                    dim=contacts.soft_contact_max,
                    inputs=[
                        dt,
                        color,
                        self.particle_q_prev,
                        state_in.particle_q,
                        model.particle_colors,
                        # body-particle contact
                        self.friction_epsilon,
                        model.particle_radius,
                        contacts.soft_contact_particle,
                        contacts.soft_contact_count,
                        contacts.soft_contact_max,
                        self.body_particle_contact_penalty_k,
                        self.body_particle_contact_material_ke,
                        self.body_particle_contact_material_kd,
                        self.body_particle_contact_material_mu,
                        model.shape_material_mu,
                        model.shape_body,
                        body_q_for_particles,
                        body_q_prev_for_particles,
                        body_qd_for_particles,
                        model.body_com,
                        contacts.soft_contact_shape,
                        contacts.soft_contact_body_pos,
                        contacts.soft_contact_body_vel,
                        contacts.soft_contact_normal,
                        model.shape_margin,
                    ],
                    outputs=[
                        self.particle_forces,
                        self.particle_hessians,
                    ],
                    device=self.device,
                )

If you look into solver_vbd.py you would find this piece of code. This is where the soft-rigid contact force is computed. If you record self.particle_forces before and afterwards, the difference will be the contact force. Note that this computes contact force for only one color (defined by input argument color).

You can call it yourself out of the vbd_solver.step() function, and pass a trivial coloring, i.e., one color for all the particles to evaluated force for all particles, as suggested by JC.