With soft contacts and friction=0, enabling custom PASSIVE forces makes constraint(contact) reactions large — how to keep detection but minimize solver contact forces?

[kankanzheli]

Intro

Hi!

I am a undergrad student at Waseda, I use MuJoCo for my research on crash simulation.

My setup

MuJoCo version: 3.3.4
Python: 3.10
Renderer: glfw
Timestep / integrator: timestep=0.001, integrator="implicit"
I have a C/C++ plugin that applies forces/torques in the PASSIVE stage via mj_applyFT.

My question

Goal

I want to keep collision detection (contacts, normals, contact points) but minimize MuJoCo’s normal contact reaction, and instead drive separation purely with my own force law applied in PASSIVE.

To weaken the built-in contact, I use soft contact + zero friction:

Minimal Repro (mesh pushes a free capsule)

A sliding mesh_body (with my plugin attached to its geom) pushes a free capsule.

I drive the slider by forcing its qvel to +1.2 m/s.

I print two wrenches (world frame) on the capsule each step:

constraint(contact): accumulated from mj_contactForce(...) (contact frame → world; apply at contact point and shift to the body COM).

plugin(passive): my plugin’s force/torque applied in PASSIVE.
For observability, after calling
mj_applyFT(m, d, F, M, xicom, body_id, d->qfrc_passive);
I also mirror the same values into d->xfrc_applied[6b:6b+6] so Python can read them easily.

What I observe

Without the plugin: plugin(passive) is zero; constraint(contact) is tiny (the mesh can even pass through the capsule).

With the plugin enabled: plugin(passive) becomes sizable (as intended), but constraint(contact) also grows a lot (hundreds of N; and because the force acts at a contact point, it produces a large moment about the capsule COM, causing huge angular velocities).

Example log excerpt for the capsule body:

== [Stage1-F] free_capsule_root F=(-224.567, 0.000, 119.853)
[step t=0.202] free_capsule_root
wrench plugin(passive) F,M = (-224.567, -0.000, 119.853, -0.000, 0.000, -0.000)
wrench constraint(contact) F,M = ( 100.854, 0.000, -0.001, 0.000, -1.574, 0.000)
wrench TOTAL F,M = (-123.713, -0.000, 119.852, 0.000, -1.574, 0.000)

This increase in constraint(contact) happens without changing solref/solimp/friction.

Questions

Is this expected? With soft contact and friction=0, why does adding PASSIVE external forces substantially increase constraint(contact)? I had assumed contact forces would mainly depend on penetration/relative velocity and the solref/solimp parameters, but they seem to strongly depend on other forces present in the same step.

Is there an officially recommended way (parameters or flags) to keep contacts for detection only (i.e., surfaces and normals are reported) while making the solver’s normal reaction as small as possible?

Do you have recommended practices to “decouple” this, or to ensure the solver’s contact reactions remain negligible so that user forces can fully control the normal separation?

Thanks! Any guidance on “detection-only” style contacts or the right way to hand off normal control to user forces would be greatly appreciated.

Minimal model and/or code that explain my question

Python: reading plugin PASSIVE wrench mirrored to xfrc_applied

Code:

import numpy as np
import mujoco


def body_wrench_from_tau(model, data, body_id, tau_slice):
    """
    Map a body's generalized-force slice (tau) to a 6D wrench [Fx,Fy,Fz,Mx,My,Mz]
    at the body's COM in world coordinates via the COM Jacobian.
    Uses least squares in case dofnum != 6.
    """
    nv = model.nv
    dofadr = model.body_dofadr[body_id]
    dofnum = model.body_dofnum[body_id]

    Jp = np.zeros((3, nv), dtype=np.float64)
    Jr = np.zeros((3, nv), dtype=np.float64)
    mujoco.mj_jacBody(model, data, Jp, Jr, body_id)

    cols = slice(dofadr, dofadr + dofnum)
    A = np.vstack([Jp[:, cols], Jr[:, cols]]).T  # (dofnum, 6)
    b = np.asarray(tau_slice, dtype=np.float64).reshape(dofnum)

    x, *_ = np.linalg.lstsq(A, b, rcond=None)    # 6-vector
    return x  # [Fx, Fy, Fz, Mx, My, Mz]


def contact_wrench_from_contacts(model, data, body_id):
    """
    Aggregate all contact forces on a body into a 6D wrench at its COM using mj_contactForce.
    Includes frictional torques (torsion/rolling) if present.
    """
    F = np.zeros(3)
    M = np.zeros(3)
    xcom = np.array(data.xipos[3*body_id:3*body_id+3], dtype=np.float64)

    for i in range(data.ncon):
        con = data.contact[i]
        cf = np.zeros(6, dtype=np.float64)
        mujoco.mj_contactForce(model, data, i, cf)  # [fn, ft1, ft2, torsion, roll1, roll2]
        if not np.any(cf):
            continue

        n  = np.array(con.frame[0:3])
        t1 = np.array(con.frame[3:6])
        t2 = np.array(con.frame[6:9])

        f_world = cf[0]*n + cf[1]*t1 + cf[2]*t2
        m_world = cf[3]*n + cf[4]*t1 + cf[5]*t2

        bodyA = model.geom_bodyid[con.geom1]
        bodyB = model.geom_bodyid[con.geom2]
        if body_id == bodyA:
            s = -1.0
        elif body_id == bodyB:
            s = +1.0
        else:
            continue

        p = np.array(con.pos, dtype=np.float64)
        F += s * f_world
        M += np.cross(p - xcom, s * f_world) + s * m_world

    return np.concatenate([F, M])


def compute_body_wrench_breakdown(model, data, body_id):
    """
    Returns 6D wrenches at COM for:
      - 'passive'     (plugins, gravity, etc.)
      - 'constraint'  (contacts, joint/limit constraints)
      - 'applied'     (externally applied forces, if any)
      - 'total'       (sum of the above)
      - 'contact_sum' (direct sum from mj_contactForce for cross-check)
    """
    dofadr = model.body_dofadr[body_id]
    dofnum = model.body_dofnum[body_id]
    cols = slice(dofadr, dofadr + dofnum)

    tau_pass = np.array(data.qfrc_passive[cols], dtype=np.float64)
    tau_con  = np.array(data.qfrc_constraint[cols], dtype=np.float64)
    tau_appl = np.array(data.qfrc_applied[cols], dtype=np.float64)
    tau_tot  = tau_pass + tau_con + tau_appl

    W_pass = body_wrench_from_tau(model, data, body_id, tau_pass)
    W_con  = body_wrench_from_tau(model, data, body_id, tau_con)
    W_appl = body_wrench_from_tau(model, data, body_id, tau_appl)
    W_tot  = body_wrench_from_tau(model, data, body_id, tau_tot)

    W_contact_sum = contact_wrench_from_contacts(model, data, body_id)

    return {
        "passive": W_pass,
        "constraint": W_con,
        "applied": W_appl,
        "total": W_tot,
        "contact_sum": W_contact_sum,
    }


def print_body_force_breakdown(model, data, body):
    """
    Print the force breakdown for a body (name or id). Call after mj_step.
    """
    if isinstance(body, str):
        body_id = mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_BODY, body)
        if body_id < 0:
            raise ValueError(f"Body not found: {body}")
    else:
        body_id = int(body)

    # COM linear and angular velocity (context only)
    nv = model.nv
    Jp = np.zeros((3, nv), dtype=np.float64)
    Jr = np.zeros((3, nv), dtype=np.float64)
    mujoco.mj_jacBody(model, data, Jp, Jr, body_id)
    vcom = Jp @ data.qvel
    w    = Jr @ data.qvel

    W = compute_body_wrench_breakdown(model, data, body_id)

    def fmt6(x): return "(" + ", ".join(f"{v: .3f}" for v in x) + ")"

    name = model.names[model.name_bodyadr[body_id]:].split('\x00', 1)[0]
    print(f"[step t={data.time: .6f}] {name}"
          f"  v_com=({vcom[0]: .3f}, {vcom[1]: .3f}, {vcom[2]: .3f})"
          f"  w=({w[0]: .3f}, {w[1]: .3f}, {w[2]: .3f})")
    print(f"    wrench passive(plugin)     F,M = {fmt6(W['passive'])}")
    print(f"    wrench constraint(contact) F,M = {fmt6(W['constraint'])}")
    print(f"    wrench applied             F,M = {fmt6(W['applied'])}")
    print(f"    wrench TOTAL               F,M = {fmt6(W['total'])}")
    print(f"    wrench CONTACT sum (cf)    F,M = {fmt6(W['contact_sum'])}")

Confirmations

• I searched the latest documentation thoroughly before posting.
• I searched previous Issues and Discussions, I am certain this has not been raised before.