jaxsim 0.4.3.dev186__py3-none-any.whl → 0.4.3.dev200__py3-none-any.whl

jaxsim/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.4.3.dev186'
-__version_tuple__ = version_tuple = (0, 4, 3, 'dev186')
+__version__ = version = '0.4.3.dev200'
+__version_tuple__ = version_tuple = (0, 4, 3, 'dev200')

jaxsim/api/contact.py

@@ -36,11 +36,10 @@ def collidable_point_kinematics(
         the linear component of the mixed 6D frame velocity.
     """
 
-    from jaxsim.rbda import collidable_points
-
     # Switch to inertial-fixed since the RBDAs expect velocities in this representation.
     with data.switch_velocity_representation(VelRepr.Inertial):
-        W_p_Ci, W_ṗ_Ci = collidable_points.collidable_points_pos_vel(
+
+        W_p_Ci, W_ṗ_Ci = jaxsim.rbda.collidable_points.collidable_points_pos_vel(
             model=model,
             base_position=data.base_position(),
             base_quaternion=data.base_orientation(dcm=False),
@@ -304,6 +303,15 @@ def in_contact(
 
 
 def estimate_good_soft_contacts_parameters(
+    *args, **kwargs
+) -> jaxsim.rbda.contacts.ContactParamsTypes:
+
+    msg = "This method is deprecated, please use `{}`."
+    logging.warning(msg.format(estimate_good_contact_parameters.__name__))
+    return estimate_good_contact_parameters(*args, **kwargs)
+
+
+def estimate_good_contact_parameters(
     model: js.model.JaxSimModel,
     *,
     standard_gravity: jtp.FloatLike = jaxsim.math.StandardGravity,
@@ -312,14 +320,9 @@ def estimate_good_soft_contacts_parameters(
     damping_ratio: jtp.FloatLike = 1.0,
     max_penetration: jtp.FloatLike | None = None,
     **kwargs,
-) -> (
-    jaxsim.rbda.contacts.RelaxedRigidContactsParams
-    | jaxsim.rbda.contacts.RigidContactsParams
-    | jaxsim.rbda.contacts.SoftContactsParams
-    | jaxsim.rbda.contacts.ViscoElasticContactsParams
-):
+) -> jaxsim.rbda.contacts.ContactParamsTypes:
     """
-    Estimate good parameters for soft-like contact models.
+    Estimate good contact parameters.
 
     Args:
         model: The model to consider.
@@ -332,12 +335,19 @@ def estimate_good_soft_contacts_parameters(
         max_penetration:
             The maximum penetration allowed in steady state when the robot is
             supported by the configured number of active collidable points.
+        kwargs:
+            Additional model-specific parameters passed to the builder method of
+            the parameters class.
 
     Returns:
-        The estimated good soft contacts parameters.
+        The estimated good contacts parameters.
+
+    Note:
+        This is primarily a convenience function for soft-like contact models.
+        However, it provides with some good default parameters also for the other ones.
 
     Note:
-        This method provides a good starting point for the soft contacts parameters.
+        This method provides a good set of contacts parameters.
         The user is encouraged to fine-tune the parameters based on the
         specific application.
     """
@@ -364,6 +374,7 @@ def estimate_good_soft_contacts_parameters(
     max_δ = (
         max_penetration
         if max_penetration is not None
+        # Consider as default a 0.5% of the model height.
         else 0.005 * estimate_model_height(model=model)
     )
 
@@ -381,8 +392,11 @@ def estimate_good_soft_contacts_parameters(
                 max_penetration=max_δ,
                 number_of_active_collidable_points_steady_state=nc,
                 damping_ratio=damping_ratio,
-                p=model.contact_model.parameters.p,
-                q=model.contact_model.parameters.q,
+                **dict(
+                    p=model.contact_model.parameters.p,
+                    q=model.contact_model.parameters.q,
+                )
+                | kwargs,
             )
 
         case contacts.ViscoElasticContacts():
@@ -396,15 +410,40 @@ def estimate_good_soft_contacts_parameters(
                     max_penetration=max_δ,
                     number_of_active_collidable_points_steady_state=nc,
                     damping_ratio=damping_ratio,
-                    p=model.contact_model.parameters.p,
-                    q=model.contact_model.parameters.q,
-                    **kwargs,
+                    **dict(
+                        p=model.contact_model.parameters.p,
+                        q=model.contact_model.parameters.q,
+                    )
+                    | kwargs,
                 )
             )
 
+        case contacts.RigidContacts():
+            assert isinstance(model.contact_model, contacts.RigidContacts)
+
+            # Disable Baumgarte stabilization by default since it does not play
+            # well with the forward Euler integrator.
+            K = kwargs.get("K", 0.0)
+
+            parameters = contacts.RigidContactsParams.build(
+                mu=static_friction_coefficient,
+                **dict(
+                    K=K,
+                    D=2 * jnp.sqrt(K),
+                )
+                | kwargs,
+            )
+
+        case contacts.RelaxedRigidContacts():
+            assert isinstance(model.contact_model, contacts.RelaxedRigidContacts)
+
+            parameters = contacts.RelaxedRigidContactsParams.build(
+                mu=static_friction_coefficient,
+                **kwargs,
+            )
+
         case _:
-            logging.warning("The active contact model is not soft-like, no-op.")
-            parameters = model.contact_model.parameters
+            raise ValueError(f"Invalid contact model: {model.contact_model}")
 
     return parameters
 

jaxsim/api/data.py

@@ -34,7 +34,7 @@ class JaxSimModelData(common.ModelDataWithVelocityRepresentation):
 
     state: ODEState
 
-    gravity: jtp.Array
+    gravity: jtp.Vector
 
     contacts_params: jaxsim.rbda.contacts.ContactsParams = dataclasses.field(repr=False)
 
@@ -224,7 +224,8 @@ class JaxSimModelData(common.ModelDataWithVelocityRepresentation):
                 jaxsim.rbda.contacts.SoftContacts
                 | jaxsim.rbda.contacts.ViscoElasticContacts,
             ):
-                contacts_params = js.contact.estimate_good_soft_contacts_parameters(
+
+                contacts_params = js.contact.estimate_good_contact_parameters(
                     model=model, standard_gravity=standard_gravity
                 )
 

jaxsim/api/model.py

@@ -40,6 +40,8 @@ class JaxSimModel(JaxsimDataclass):
         default_factory=jaxsim.terrain.FlatTerrain.build, repr=False
     )
 
+    # Note that this is the default contact model.
+    # Its parameters, if any, are then overridden from those stored in JaxSimModelData.
     contact_model: jaxsim.rbda.contacts.ContactModel | None = dataclasses.field(
         default=None, repr=False
     )
@@ -2044,24 +2046,18 @@ def step(
                 M = js.model.free_floating_mass_matrix(model, data_tf)
                 W_p_C = js.contact.collidable_point_positions(model, data_tf)
 
-                # Compute the height of the terrain below each collidable point.
-                px, py, _ = W_p_C.T
-                terrain_height = jax.vmap(model.terrain.height)(px, py)
-
-                # Compute the contact state.
-                inactive_collidable_points, _ = (
-                    jaxsim.rbda.contacts.RigidContacts.detect_contacts(
-                        W_p_C=W_p_C,
-                        terrain_height=terrain_height,
-                    )
-                )
+                # Compute the penetration depth of the collidable points.
+                δ, *_ = jax.vmap(
+                    jaxsim.rbda.contacts.common.compute_penetration_data,
+                    in_axes=(0, 0, None),
+                )(W_p_C, jnp.zeros_like(W_p_C), model.terrain)
 
                 # Compute the impact velocity.
                 # It may be discontinuous in case new contacts are made.
                 BW_nu_post_impact = (
                     jaxsim.rbda.contacts.RigidContacts.compute_impact_velocity(
                         data=data_tf,
-                        inactive_collidable_points=inactive_collidable_points,
+                        inactive_collidable_points=(δ <= 0),
                         M=M,
                         J_WC=J_WC,
                     )

jaxsim/rbda/contacts/__init__.py

@@ -4,3 +4,10 @@ from .relaxed_rigid import RelaxedRigidContacts, RelaxedRigidContactsParams
 from .rigid import RigidContacts, RigidContactsParams
 from .soft import SoftContacts, SoftContactsParams
 from .visco_elastic import ViscoElasticContacts, ViscoElasticContactsParams
+
+ContactParamsTypes = (
+    SoftContactsParams
+    | RigidContactsParams
+    | RelaxedRigidContactsParams
+    | ViscoElasticContactsParams
+)

jaxsim/rbda/contacts/common.py

@@ -1,8 +1,12 @@
 from __future__ import annotations
 
 import abc
+import functools
 from typing import Any
 
+import jax
+import jax.numpy as jnp
+
 import jaxsim.api as js
 import jaxsim.terrain
 import jaxsim.typing as jtp
@@ -14,6 +18,47 @@ except ImportError:
     from typing_extensions import Self
 
 
+@functools.partial(jax.jit, static_argnames=("terrain",))
+def compute_penetration_data(
+    p: jtp.VectorLike,
+    v: jtp.VectorLike,
+    terrain: jaxsim.terrain.Terrain,
+) -> tuple[jtp.Float, jtp.Float, jtp.Vector]:
+    """
+    Compute the penetration data (depth, rate, and terrain normal) of a collidable point.
+
+    Args:
+        p: The position of the collidable point.
+        v:
+            The linear velocity of the point (linear component of the mixed 6D velocity
+            of the implicit frame `C = (W_p_C, [W])` associated to the point).
+        terrain: The considered terrain.
+
+    Returns:
+        A tuple containing the penetration depth, the penetration velocity,
+        and the considered terrain normal.
+    """
+
+    # Pre-process the position and the linear velocity of the collidable point.
+    W_ṗ_C = jnp.array(v).squeeze()
+    px, py, pz = jnp.array(p).squeeze()
+
+    # Compute the terrain normal and the contact depth.
+    n̂ = terrain.normal(x=px, y=py).squeeze()
+    h = jnp.array([0, 0, terrain.height(x=px, y=py) - pz])
+
+    # Compute the penetration depth normal to the terrain.
+    δ = jnp.maximum(0.0, jnp.dot(h, n̂))
+
+    # Compute the penetration normal velocity.
+    δ_dot = -jnp.dot(W_ṗ_C, n̂)
+
+    # Enforce the penetration rate to be zero when the penetration depth is zero.
+    δ_dot = jnp.where(δ > 0, δ_dot, 0.0)
+
+    return δ, δ_dot, n̂
+
+
 class ContactsParams(JaxsimDataclass):
     """
     Abstract class representing the parameters of a contact model.
@@ -86,7 +131,7 @@ class ContactModel(JaxsimDataclass):
         model: js.model.JaxSimModel,
         data: js.data.JaxSimModelData,
         **kwargs,
-    ) -> tuple[jtp.Vector, tuple[Any, ...]]:
+    ) -> tuple[jtp.Matrix, tuple[Any, ...]]:
         """
         Compute the contact forces.
 
@@ -95,8 +140,9 @@ class ContactModel(JaxsimDataclass):
             data: The data of the considered model.
 
         Returns:
-            A tuple containing as first element the computed 6D contact force applied to the contact point and expressed in the world frame,
-            and as second element a tuple of optional additional information.
+            A tuple containing as first element the computed 6D contact force applied to
+            the contact points and expressed in the world frame, and as second element
+            a tuple of optional additional information.
         """
 
         pass

jaxsim/rbda/contacts/relaxed_rigid.py

@@ -12,11 +12,10 @@ import optax
 import jaxsim.api as js
 import jaxsim.typing as jtp
 from jaxsim import logging
-from jaxsim.api.common import VelRepr
-from jaxsim.math import Adjoint
+from jaxsim.api.common import ModelDataWithVelocityRepresentation, VelRepr
 from jaxsim.terrain.terrain import FlatTerrain, Terrain
 
-from .common import ContactModel, ContactsParams
+from . import common
 
 try:
     from typing import Self
@@ -25,7 +24,7 @@ except ImportError:
 
 
 @jax_dataclasses.pytree_dataclass
-class RelaxedRigidContactsParams(ContactsParams):
+class RelaxedRigidContactsParams(common.ContactsParams):
     """Parameters of the relaxed rigid contacts model."""
 
     # Time constant
@@ -116,14 +115,24 @@ class RelaxedRigidContactsParams(ContactsParams):
     ) -> Self:
         """Create a `RelaxedRigidContactsParams` instance"""
 
+        def default(name: str):
+            return cls.__dataclass_fields__[name].default_factory()
+
         return cls(
-            **{
-                field: jnp.array(locals().get(field, default), dtype=default.dtype)
-                for field, default in map(
-                    lambda f: (f, cls.__dataclass_fields__[f].default),
-                    filter(lambda f: f != "__mutability__", cls.__dataclass_fields__),
-                )
-            }
+            time_constant=jnp.array(
+                time_constant or default("time_constant"), dtype=float
+            ),
+            damping_coefficient=jnp.array(
+                damping_coefficient or default("damping_coefficient"), dtype=float
+            ),
+            d_min=jnp.array(d_min or default("d_min"), dtype=float),
+            d_max=jnp.array(d_max or default("d_max"), dtype=float),
+            width=jnp.array(width or default("width"), dtype=float),
+            midpoint=jnp.array(midpoint or default("midpoint"), dtype=float),
+            power=jnp.array(power or default("power"), dtype=float),
+            stiffness=jnp.array(stiffness or default("stiffness"), dtype=float),
+            damping=jnp.array(damping or default("damping"), dtype=float),
+            mu=jnp.array(mu or default("mu"), dtype=float),
         )
 
     def valid(self) -> jtp.BoolLike:
@@ -142,7 +151,7 @@ class RelaxedRigidContactsParams(ContactsParams):
 
 
 @jax_dataclasses.pytree_dataclass
-class RelaxedRigidContacts(ContactModel):
+class RelaxedRigidContacts(common.ContactModel):
     """Relaxed rigid contacts model."""
 
     parameters: RelaxedRigidContactsParams = dataclasses.field(
@@ -229,7 +238,7 @@ class RelaxedRigidContacts(ContactModel):
         *,
         link_forces: jtp.MatrixLike | None = None,
         joint_force_references: jtp.VectorLike | None = None,
-    ) -> tuple[jtp.Vector, tuple[Any, ...]]:
+    ) -> tuple[jtp.Matrix, tuple]:
         """
         Compute the contact forces.
 
@@ -243,22 +252,23 @@ class RelaxedRigidContacts(ContactModel):
                 Optional `(n_joints,)` vector of joint forces.
 
         Returns:
-            A tuple containing the contact forces.
+            A tuple containing as first element the computed contact forces.
         """
 
         # Initialize the model and data this contact model is operating on.
         # This will raise an exception if either the contact model or the
         # contact parameters are not compatible.
         model, data = self.initialize_model_and_data(model=model, data=data)
+        assert isinstance(data.contacts_params, RelaxedRigidContactsParams)
 
-        link_forces = (
-            link_forces
+        link_forces = jnp.atleast_2d(
+            jnp.array(link_forces, dtype=float).squeeze()
             if link_forces is not None
             else jnp.zeros((model.number_of_links(), 6))
         )
 
-        joint_force_references = (
-            joint_force_references
+        joint_force_references = jnp.atleast_1d(
+            jnp.array(joint_force_references, dtype=float).squeeze()
             if joint_force_references is not None
             else jnp.zeros(model.number_of_joints())
         )
@@ -271,10 +281,10 @@ class RelaxedRigidContacts(ContactModel):
             joint_force_references=joint_force_references,
         )
 
-        def _detect_contact(x: jtp.Array, y: jtp.Array, z: jtp.Array) -> jtp.Array:
+        def detect_contact(x: jtp.Array, y: jtp.Array, z: jtp.Array) -> jtp.Array:
             x, y, z = jax.tree.map(jnp.squeeze, (x, y, z))
 
-            n̂ = self.terrain.normal(x=x, y=y).squeeze()
+            n̂ = model.terrain.normal(x=x, y=y).squeeze()
             h = jnp.array([0, 0, z - model.terrain.height(x=x, y=y)])
 
             return jnp.dot(h, n̂)
@@ -286,19 +296,19 @@ class RelaxedRigidContacts(ContactModel):
         )
 
         # Compute the activation state of the collidable points
-        δ = jax.vmap(_detect_contact)(*position.T)
+        δ = jax.vmap(detect_contact)(*position.T)
+
+        # Compute the transforms of the implicit frames corresponding to the
+        # collidable points.
+        W_H_C = js.contact.transforms(model=model, data=data)
 
         with (
             references.switch_velocity_representation(VelRepr.Mixed),
             data.switch_velocity_representation(VelRepr.Mixed),
         ):
-            M = js.model.free_floating_mass_matrix(model=model, data=data)
-            Jl_WC = jnp.vstack(
-                jax.vmap(lambda J, height: J * (height < 0))(
-                    js.contact.jacobian(model=model, data=data)[:, :3, :], δ
-                )
-            )
-            W_H_C = js.contact.transforms(model=model, data=data)
+
+            BW_ν = data.generalized_velocity()
+
             BW_ν̇_free = jnp.hstack(
                 js.ode.system_acceleration(
                     model=model,
@@ -309,20 +319,31 @@ class RelaxedRigidContacts(ContactModel):
                     ),
                 )
             )
-            BW_ν = data.generalized_velocity()
+
+            M = js.model.free_floating_mass_matrix(model=model, data=data)
+
+            Jl_WC = jnp.vstack(
+                jax.vmap(lambda J, height: J * (height < 0))(
+                    js.contact.jacobian(model=model, data=data)[:, :3, :], δ
+                )
+            )
+
             J̇_WC = jnp.vstack(
                 jax.vmap(lambda J̇, height: J̇ * (height < 0))(
                     js.contact.jacobian_derivative(model=model, data=data)[:, :3], δ
                 ),
             )
 
-            a_ref, R, K, D = self._regularizers(
-                model=model,
-                penetration=δ,
-                velocity=velocity,
-                parameters=self.parameters,
-            )
+        # Compute the regularization terms.
+        a_ref, R, K, D = self._regularizers(
+            model=model,
+            penetration=δ,
+            velocity=velocity,
+            parameters=data.contacts_params,
+        )
 
+        # Compute the Delassus matrix and the free mixed linear acceleration of
+        # the collidable points.
         G = Jl_WC @ jnp.linalg.lstsq(M, Jl_WC.T)[0]
         CW_al_free_WC = Jl_WC @ BW_ν̇_free + J̇_WC @ BW_ν
 
@@ -330,26 +351,40 @@ class RelaxedRigidContacts(ContactModel):
         A = G + R
         b = CW_al_free_WC - a_ref
 
+        # Create the objective function to minimize as a lambda computing the cost
+        # from the optimized variables x.
         objective = lambda x, A, b: jnp.sum(jnp.square(A @ x + b))
 
+        # ========================================
+        # Helper function to run the L-BFGS solver
+        # ========================================
+
         def run_optimization(
-            init_params: jtp.Array,
+            init_params: jtp.Vector,
             fun: Callable,
-            opt: optax.GradientTransformation,
-            maxiter: jtp.Int,
-            tol: jtp.Float,
-            **kwargs,
-        ):
+            opt: optax.GradientTransformationExtraArgs,
+            maxiter: int,
+            tol: float,
+        ) -> tuple[jtp.Vector, optax.OptState]:
+
+            # Get the function to compute the loss and the gradient w.r.t. its inputs.
             value_and_grad_fn = optax.value_and_grad_from_state(fun)
 
-            def step(carry):
+            # Initialize the carry of the following loop.
+            OptimizationCarry = tuple[jtp.Vector, optax.OptState]
+            init_carry: OptimizationCarry = (init_params, opt.init(params=init_params))
+
+            def step(carry: OptimizationCarry) -> OptimizationCarry:
+
                 params, state = carry
+
                 value, grad = value_and_grad_fn(
                     params,
                     state=state,
                     A=A,
                     b=b,
                 )
+
                 updates, state = opt.update(
                     updates=grad,
                     state=state,
@@ -360,22 +395,32 @@ class RelaxedRigidContacts(ContactModel):
                     A=A,
                     b=b,
                 )
+
                 params = optax.apply_updates(params, updates)
+
                 return params, state
 
-            def continuing_criterion(carry):
+            def continuing_criterion(carry: OptimizationCarry) -> jtp.Bool:
+
                 _, state = carry
+
                 iter_num = optax.tree_utils.tree_get(state, "count")
                 grad = optax.tree_utils.tree_get(state, "grad")
                 err = optax.tree_utils.tree_l2_norm(grad)
+
                 return (iter_num == 0) | ((iter_num < maxiter) & (err >= tol))
 
-            init_carry = (init_params, opt.init(init_params))
             final_params, final_state = jax.lax.while_loop(
                 continuing_criterion, step, init_carry
             )
+
             return final_params, final_state
 
+        # ======================================
+        # Compute the contact forces with L-BFGS
+        # ======================================
+
+        # Initialize the optimized forces with a linear Hunt/Crossley model.
         init_params = (
             K[:, jnp.newaxis] * jnp.zeros_like(position).at[:, 2].set(δ)
             + D[:, jnp.newaxis] * velocity
@@ -390,28 +435,30 @@ class RelaxedRigidContacts(ContactModel):
         maxiter = solver_options.pop("maxiter")
 
         # Compute the 3D linear force in C[W] frame.
-        CW_f_Ci, _ = run_optimization(
+        solution, _ = run_optimization(
             init_params=init_params,
-            A=A,
-            b=b,
-            maxiter=maxiter,
-            opt=optax.lbfgs(**solver_options),
             fun=objective,
+            opt=optax.lbfgs(**solver_options),
             tol=tol,
+            maxiter=maxiter,
         )
 
-        CW_f_Ci = CW_f_Ci.reshape((-1, 3))
-
-        def mixed_to_inertial(W_H_C: jax.Array, CW_fl: jax.Array) -> jax.Array:
-            W_Xf_CW = Adjoint.from_transform(
-                W_H_C.at[0:3, 0:3].set(jnp.eye(3)),
-                inverse=True,
-            ).T
-            return W_Xf_CW @ jnp.hstack([CW_fl, jnp.zeros(3)])
-
-        W_f_C = jax.vmap(mixed_to_inertial)(W_H_C, CW_f_Ci)
+        # Reshape the optimized solution to be a matrix of 3D contact forces.
+        CW_fl_C = solution.reshape(-1, 3)
+
+        # Convert the contact forces from mixed to inertial-fixed representation.
+        W_f_C = jax.vmap(
+            lambda CW_fl_C, W_H_C: (
+                ModelDataWithVelocityRepresentation.other_representation_to_inertial(
+                    array=jnp.zeros(6).at[0:3].set(CW_fl_C),
+                    transform=W_H_C,
+                    other_representation=VelRepr.Mixed,
+                    is_force=True,
+                )
+            ),
+        )(CW_fl_C, W_H_C)
 
-        return W_f_C, (None,)
+        return W_f_C, ()
 
     @staticmethod
     def _regularizers(
@@ -433,13 +480,28 @@ class RelaxedRigidContacts(ContactModel):
             A tuple containing the reference acceleration, the regularization matrix, the stiffness, and the damping.
         """
 
-        Ω, ζ, ξ_min, ξ_max, width, mid, p, K, D, μ, *_ = jax_dataclasses.astuple(
-            parameters
+        # Extract the parameters of the contact model.
+        Ω, ζ, ξ_min, ξ_max, width, mid, p, K, D, μ = (
+            getattr(parameters, field)
+            for field in (
+                "time_constant",
+                "damping_coefficient",
+                "d_min",
+                "d_max",
+                "width",
+                "midpoint",
+                "power",
+                "stiffness",
+                "damping",
+                "mu",
+            )
         )
 
-        def _imp_aref(
-            penetration: jtp.Array,
-            velocity: jtp.Array,
+        # Compute the 6D inertia matrices of all links.
+        M_L = js.model.link_spatial_inertia_matrices(model=model)
+
+        def imp_aref(
+            penetration: jtp.Array, velocity: jtp.Array
         ) -> tuple[jtp.Array, jtp.Array]:
             """
             Calculates impedance and offset acceleration in constraint frame.
@@ -474,7 +536,7 @@ class RelaxedRigidContacts(ContactModel):
 
             return imp, a_ref, jnp.atleast_1d(K_f), jnp.atleast_1d(D_f)
 
-        def _compute_row(
+        def compute_row(
             *,
             link_idx: jtp.Float,
             penetration: jtp.Array,
@@ -482,7 +544,7 @@ class RelaxedRigidContacts(ContactModel):
         ) -> tuple[jtp.Array, jtp.Array]:
 
             # Compute the reference acceleration.
-            ξ, a_ref, K, D = _imp_aref(
+            ξ, a_ref, K, D = imp_aref(
                 penetration=penetration,
                 velocity=velocity,
             )
@@ -496,12 +558,10 @@ class RelaxedRigidContacts(ContactModel):
 
             return jax.tree.map(lambda x: x * (penetration < 0), (a_ref, R, K, D))
 
-        M_L = js.model.link_spatial_inertia_matrices(model=model)
-
         a_ref, R, K, D = jax.tree.map(
-            jnp.concatenate,
-            (
-                *jax.vmap(_compute_row)(
+            f=jnp.concatenate,
+            tree=(
+                *jax.vmap(compute_row)(
                     link_idx=jnp.array(
                         model.kin_dyn_parameters.contact_parameters.body
                     ),
@@ -510,4 +570,5 @@ class RelaxedRigidContacts(ContactModel):
                 ),
             ),
         )
+
         return a_ref, jnp.diag(R), K, D

jaxsim/rbda/contacts/rigid.py

@@ -13,6 +13,7 @@ from jaxsim import logging
 from jaxsim.api.common import ModelDataWithVelocityRepresentation, VelRepr
 from jaxsim.terrain import FlatTerrain, Terrain
 
+from . import common
 from .common import ContactModel, ContactsParams
 
 try:
@@ -170,46 +171,6 @@ class RigidContacts(ContactModel):
             _solver_options_values=tuple(solver_options.values()),
         )
 
-    @staticmethod
-    def detect_contacts(
-        W_p_C: jtp.ArrayLike,
-        terrain_height: jtp.ArrayLike,
-    ) -> tuple[jtp.Vector, jtp.Vector]:
-        """
-        Detect contacts between the collidable points and the terrain.
-
-        Args:
-            W_p_C: The position of the collidable points.
-            terrain_height: The height of the terrain at the collidable point position.
-
-        Returns:
-            A tuple containing the activation state of the collidable points
-            and the contact penetration depth h.
-        """
-
-        # TODO: reduce code duplication with js.contact.in_contact
-        def detect_contact(
-            W_p_C: jtp.ArrayLike,
-            terrain_height: jtp.FloatLike,
-        ) -> tuple[jtp.Bool, jtp.Float]:
-            """
-            Detect contacts between the collidable points and the terrain.
-            """
-
-            # Unpack the position of the collidable point.
-            _, _, pz = W_p_C.squeeze()
-
-            inactive = pz > terrain_height
-
-            # Compute contact penetration depth
-            h = jnp.maximum(0.0, terrain_height - pz)
-
-            return inactive, h
-
-        inactive_collidable_points, h = jax.vmap(detect_contact)(W_p_C, terrain_height)
-
-        return inactive_collidable_points, h
-
     @staticmethod
     def compute_impact_velocity(
         inactive_collidable_points: jtp.ArrayLike,
@@ -281,7 +242,7 @@ class RigidContacts(ContactModel):
         *,
         link_forces: jtp.MatrixLike | None = None,
         joint_force_references: jtp.VectorLike | None = None,
-    ) -> tuple[jtp.Vector, tuple[Any, ...]]:
+    ) -> tuple[jtp.Matrix, tuple]:
         """
         Compute the contact forces.
 
@@ -295,36 +256,41 @@ class RigidContacts(ContactModel):
                 Optional `(n_joints,)` vector of joint forces.
 
         Returns:
-            A tuple containing the contact forces.
+            A tuple containing as first element the computed contact forces.
         """
 
         # Initialize the model and data this contact model is operating on.
         # This will raise an exception if either the contact model or the
         # contact parameters are not compatible.
         model, data = self.initialize_model_and_data(model=model, data=data)
+        assert isinstance(data.contacts_params, RigidContactsParams)
 
-        # Import qpax just in this method
+        # Import qpax privately just in this method.
         import qpax
 
-        link_forces = (
-            link_forces
+        link_forces = jnp.atleast_2d(
+            jnp.array(link_forces, dtype=float).squeeze()
             if link_forces is not None
             else jnp.zeros((model.number_of_links(), 6))
         )
 
-        joint_force_references = (
-            joint_force_references
+        joint_force_references = jnp.atleast_1d(
+            jnp.array(joint_force_references, dtype=float).squeeze()
             if joint_force_references is not None
             else jnp.zeros((model.number_of_joints(),))
         )
 
-        # Compute kin-dyn quantities used in the contact model
+        # Compute kin-dyn quantities used in the contact model.
         with data.switch_velocity_representation(VelRepr.Mixed):
+
+            BW_ν = data.generalized_velocity()
+
             M = js.model.free_floating_mass_matrix(model=model, data=data)
+
             J_WC = js.contact.jacobian(model=model, data=data)
+            J̇_WC = js.contact.jacobian_derivative(model=model, data=data)
+
             W_H_C = js.contact.transforms(model=model, data=data)
-            J̇_WC_BW = js.contact.jacobian_derivative(model=model, data=data)
-            BW_ν = data.generalized_velocity()
 
         # Compute the position and linear velocities (mixed representation) of
         # all collidable points belonging to the robot.
@@ -332,23 +298,16 @@ class RigidContacts(ContactModel):
             model=model, data=data
         )
 
-        terrain_height = jax.vmap(self.terrain.height)(position[:, 0], position[:, 1])
-        n_collidable_points = model.kin_dyn_parameters.contact_parameters.point.shape[0]
+        # Get the number of collidable points.
+        n_collidable_points = len(model.kin_dyn_parameters.contact_parameters.body)
 
-        # Compute the activation state of the collidable points
-        inactive_collidable_points, h = RigidContacts.detect_contacts(
-            W_p_C=position,
-            terrain_height=terrain_height,
-        )
-
-        # Compute the Delassus matrix.
-        delassus_matrix = RigidContacts._delassus_matrix(M=M, J_WC=J_WC)
-
-        # Add regularization for better numerical conditioning.
-        delassus_matrix = delassus_matrix + self.regularization_delassus * jnp.eye(
-            delassus_matrix.shape[0]
+        # Compute the penetration depth and velocity of the collidable points.
+        # Note that this function considers the penetration in the normal direction.
+        δ, δ_dot, n̂ = jax.vmap(common.compute_penetration_data, in_axes=(0, 0, None))(
+            position, velocity, model.terrain
         )
 
+        # Build a references object to simplify converting link forces.
         references = js.references.JaxSimModelReferences.build(
             model=model,
             data=data,
@@ -357,10 +316,12 @@ class RigidContacts(ContactModel):
             joint_force_references=joint_force_references,
         )
 
+        # Compute the generalized free acceleration.
         with (
             references.switch_velocity_representation(VelRepr.Mixed),
             data.switch_velocity_representation(VelRepr.Mixed),
         ):
+
             BW_ν̇_free = jnp.hstack(
                 js.ode.system_acceleration(
                     model=model,
@@ -372,64 +333,74 @@ class RigidContacts(ContactModel):
                 )
             )
 
+        # Compute the free linear acceleration of the collidable points.
+        # Since we use doubly-mixed jacobian, this corresponds to W_p̈_C.
         free_contact_acc = RigidContacts._linear_acceleration_of_collidable_points(
             BW_nu=BW_ν,
             BW_nu_dot=BW_ν̇_free,
             CW_J_WC_BW=J_WC,
-            CW_J_dot_WC_BW=J̇_WC_BW,
+            CW_J_dot_WC_BW=J̇_WC,
         ).flatten()
 
-        # Compute stabilization term
-        ḣ = velocity[:, 2].squeeze()
+        # Compute stabilization term.
         baumgarte_term = RigidContacts._compute_baumgarte_stabilization_term(
-            inactive_collidable_points=inactive_collidable_points,
-            h=h,
-            ḣ=ḣ,
-            K=self.parameters.K,
-            D=self.parameters.D,
+            inactive_collidable_points=(δ <= 0),
+            δ=δ,
+            δ_dot=δ_dot,
+            n=n̂,
+            K=data.contacts_params.K,
+            D=data.contacts_params.D,
         ).flatten()
 
-        free_contact_acc -= baumgarte_term
+        # Compute the Delassus matrix.
+        delassus_matrix = RigidContacts._delassus_matrix(M=M, J_WC=J_WC)
+
+        # Initialize regularization term of the Delassus matrix for
+        # better numerical conditioning.
+        Iε = self.regularization_delassus * jnp.eye(delassus_matrix.shape[0])
+
+        # Construct the quadratic cost function.
+        Q = delassus_matrix + Iε
+        q = free_contact_acc - baumgarte_term
 
-        # Setup optimization problem
-        Q = delassus_matrix
-        q = free_contact_acc
+        # Construct the inequality constraints.
         G = RigidContacts._compute_ineq_constraint_matrix(
-            inactive_collidable_points=inactive_collidable_points, mu=self.parameters.mu
+            inactive_collidable_points=(δ <= 0), mu=data.contacts_params.mu
         )
         h_bounds = RigidContacts._compute_ineq_bounds(
             n_collidable_points=n_collidable_points
         )
+
+        # Construct the equality constraints.
         A = jnp.zeros((0, 3 * n_collidable_points))
         b = jnp.zeros((0,))
 
-        # Solve the optimization problem
-        solution, *_ = qpax.solve_qp(
+        # Solve the following optimization problem with qpax:
+        #
+        # min_{x} 0.5 x⊤ Q x + q⊤ x
+        #
+        # s.t. A x = b
+        #      G x ≤ h
+        #
+        # TODO: add possibility to notify if the QP problem did not converge.
+        solution, _, _, _, converged, _ = qpax.solve_qp(  # noqa: F841
             Q=Q, q=q, A=A, b=b, G=G, h=h_bounds, **self.solver_options
         )
 
-        f_C_lin = solution.reshape(-1, 3)
-
-        # Transform linear contact forces to 6D
-        CW_f_C = jnp.hstack(
-            (
-                f_C_lin,
-                jnp.zeros((f_C_lin.shape[0], 3)),
-            )
-        )
+        # Reshape the optimized solution to be a matrix of 3D contact forces.
+        CW_fl_C = solution.reshape(-1, 3)
 
-        # Transform the contact forces to inertial-fixed representation
+        # Convert the contact forces from mixed to inertial-fixed representation.
         W_f_C = jax.vmap(
-            lambda CW_f_C, W_H_C: ModelDataWithVelocityRepresentation.other_representation_to_inertial(
-                array=CW_f_C,
-                transform=W_H_C,
-                other_representation=VelRepr.Mixed,
-                is_force=True,
+            lambda CW_fl_C, W_H_C: (
+                ModelDataWithVelocityRepresentation.other_representation_to_inertial(
+                    array=jnp.zeros(6).at[0:3].set(CW_fl_C),
+                    transform=W_H_C,
+                    other_representation=VelRepr.Mixed,
+                    is_force=True,
+                )
             ),
-        )(
-            CW_f_C,
-            W_H_C,
-        )
+        )(CW_fl_C, W_H_C)
 
         return W_f_C, ()
 
@@ -438,6 +409,7 @@ class RigidContacts(ContactModel):
         M: jtp.MatrixLike,
         J_WC: jtp.MatrixLike,
     ) -> jtp.Matrix:
+
         sl = jnp.s_[:, 0:3, :]
         J_WC_lin = jnp.vstack(J_WC[sl])
 
@@ -448,6 +420,7 @@ class RigidContacts(ContactModel):
     def _compute_ineq_constraint_matrix(
         inactive_collidable_points: jtp.Vector, mu: jtp.FloatLike
     ) -> jtp.Matrix:
+
         def compute_G_single_point(mu: float, c: float) -> jtp.Matrix:
             """
             Compute the inequality constraint matrix for a single collidable point
@@ -475,6 +448,7 @@ class RigidContacts(ContactModel):
 
     @staticmethod
     def _compute_ineq_bounds(n_collidable_points: jtp.FloatLike) -> jtp.Vector:
+
         n_constraints = 6 * n_collidable_points
         return jnp.zeros(shape=(n_constraints,))
 
@@ -485,45 +459,50 @@ class RigidContacts(ContactModel):
         CW_J_WC_BW: jtp.MatrixLike,
         CW_J_dot_WC_BW: jtp.MatrixLike,
     ) -> jtp.Matrix:
-        CW_J̇_WC_BW = CW_J_dot_WC_BW
+
         BW_ν = BW_nu
         BW_ν̇ = BW_nu_dot
+        CW_J̇_WC_BW = CW_J_dot_WC_BW
 
+        # Compute the linear acceleration of the collidable points.
+        # Since we use doubly-mixed jacobians, this corresponds to W_p̈_C.
         CW_a_WC = jnp.vstack(CW_J̇_WC_BW) @ BW_ν + jnp.vstack(CW_J_WC_BW) @ BW_ν̇
-        CW_a_WC = CW_a_WC.reshape(-1, 6)
 
+        CW_a_WC = CW_a_WC.reshape(-1, 6)
         return CW_a_WC[:, 0:3].squeeze()
 
     @staticmethod
     def _compute_baumgarte_stabilization_term(
         inactive_collidable_points: jtp.ArrayLike,
-        h: jtp.ArrayLike,
-        ḣ: jtp.ArrayLike,
+        δ: jtp.ArrayLike,
+        δ_dot: jtp.ArrayLike,
+        n: jtp.ArrayLike,
         K: jtp.FloatLike,
         D: jtp.FloatLike,
     ) -> jtp.Array:
-        def baumgarte_stabilization(
+
+        def baumgarte_stabilization_of_single_point(
             inactive: jtp.BoolLike,
-            h: jtp.FloatLike,
-            ḣ: jtp.FloatLike,
+            δ: jtp.FloatLike,
+            δ_dot: jtp.FloatLike,
+            n: jtp.ArrayLike,
             k_baumgarte: jtp.FloatLike,
             d_baumgarte: jtp.FloatLike,
         ) -> jtp.Array:
+
             baumgarte_term = jax.lax.cond(
                 inactive,
-                lambda h, ḣ, K, D: jnp.zeros(shape=(3,)),
-                lambda h, ḣ, K, D: jnp.zeros(shape=(3,)).at[2].set(K * h + D * ḣ),
-                *(
-                    h,
-                    ḣ,
-                    k_baumgarte,
-                    d_baumgarte,
-                ),
+                lambda δ, δ_dot, n, K, D: jnp.zeros(3),
+                # This is equivalent to: K*(pT - p)⋅n̂ + D*(0 - v)⋅n̂,
+                # where pT is the point on the terrain surface vertical to p.
+                lambda δ, δ_dot, n, K, D: (K * δ + D * δ_dot) * n,
+                *(δ, δ_dot, n, k_baumgarte, d_baumgarte),
             )
+
             return baumgarte_term
 
         baumgarte_term = jax.vmap(
-            baumgarte_stabilization, in_axes=(0, 0, 0, None, None)
-        )(inactive_collidable_points, h, ḣ, K, D)
+            baumgarte_stabilization_of_single_point, in_axes=(0, 0, 0, 0, None, None)
+        )(inactive_collidable_points, δ, δ_dot, n, K, D)
 
         return baumgarte_term

jaxsim/rbda/contacts/soft.py

@@ -14,7 +14,7 @@ from jaxsim import logging
 from jaxsim.math import StandardGravity
 from jaxsim.terrain import FlatTerrain, Terrain
 
-from .common import ContactModel, ContactsParams
+from . import common
 
 try:
     from typing import Self
@@ -23,7 +23,7 @@ except ImportError:
 
 
 @jax_dataclasses.pytree_dataclass
-class SoftContactsParams(ContactsParams):
+class SoftContactsParams(common.ContactsParams):
     """Parameters of the soft contacts model."""
 
     K: jtp.Float = dataclasses.field(
@@ -161,7 +161,9 @@ class SoftContactsParams(ContactsParams):
         f_average = m * g / number_of_active_collidable_points_steady_state
 
         # Compute the stiffness to get the desired steady-state penetration.
-        K = f_average / jnp.power(δ_max, 3 / 2)
+        # Note that this is dependent on the non-linear exponent used in
+        # the damping term of the Hunt/Crossley model.
+        K = f_average / jnp.power(δ_max, 1 + p)
 
         # Compute the damping using the damping ratio.
         critical_damping = 2 * jnp.sqrt(K * m)
@@ -189,7 +191,7 @@ class SoftContactsParams(ContactsParams):
 
 
 @jax_dataclasses.pytree_dataclass
-class SoftContacts(ContactModel):
+class SoftContacts(common.ContactModel):
     """Soft contacts model."""
 
     parameters: SoftContactsParams = dataclasses.field(
@@ -277,9 +279,7 @@ class SoftContacts(ContactModel):
         μ = mu
 
         # Compute the penetration depth, its rate, and the considered terrain normal.
-        δ, δ̇, n̂ = SoftContacts.compute_penetration_data(
-            p=W_p_C, v=W_ṗ_C, terrain=terrain
-        )
+        δ, δ̇, n̂ = common.compute_penetration_data(p=W_p_C, v=W_ṗ_C, terrain=terrain)
 
         # There are few operations like computing the norm of a vector with zero length
         # or computing the square root of zero that are problematic in an AD context.
@@ -423,7 +423,18 @@ class SoftContacts(ContactModel):
         self,
         model: js.model.JaxSimModel,
         data: js.data.JaxSimModelData,
-    ) -> tuple[jtp.Vector, tuple[jtp.Vector]]:
+    ) -> tuple[jtp.Matrix, tuple[jtp.Matrix]]:
+        """
+        Compute the contact forces.
+
+        Args:
+            model: The model to consider.
+            data: The data of the considered model.
+
+        Returns:
+            A tuple containing as first element the computed contact forces, and as
+            second element the derivative of the material deformation.
+        """
 
         # Initialize the model and data this contact model is operating on.
         # This will raise an exception if either the contact model or the
@@ -444,36 +455,9 @@ class SoftContacts(ContactModel):
                 position=p,
                 velocity=v,
                 tangential_deformation=m,
-                parameters=self.parameters,
-                terrain=self.terrain,
+                parameters=data.contacts_params,
+                terrain=model.terrain,
             )
         )(W_p_C, W_ṗ_C, m)
 
         return W_f, (ṁ,)
-
-    @staticmethod
-    @jax.jit
-    def compute_penetration_data(
-        p: jtp.VectorLike,
-        v: jtp.VectorLike,
-        terrain: jaxsim.terrain.Terrain,
-    ) -> tuple[jtp.Float, jtp.Float, jtp.Vector]:
-
-        # Pre-process the position and the linear velocity of the collidable point.
-        W_ṗ_C = jnp.array(v).squeeze()
-        px, py, pz = jnp.array(p).squeeze()
-
-        # Compute the terrain normal and the contact depth.
-        n̂ = terrain.normal(x=px, y=py).squeeze()
-        h = jnp.array([0, 0, terrain.height(x=px, y=py) - pz])
-
-        # Compute the penetration depth normal to the terrain.
-        δ = jnp.maximum(0.0, jnp.dot(h, n̂))
-
-        # Compute the penetration normal velocity.
-        δ̇ = -jnp.dot(W_ṗ_C, n̂)
-
-        # Enforce the penetration rate to be zero when the penetration depth is zero.
-        δ̇ = jnp.where(δ > 0, δ̇, 0.0)
-
-        return δ, δ̇, n̂

jaxsim/rbda/contacts/visco_elastic.py

@@ -195,7 +195,7 @@ class ViscoElasticContacts(common.ContactModel):
         default_factory=FlatTerrain
     )
 
-    max_squarings: jax_dataclasses.Static[int] = 25
+    max_squarings: jax_dataclasses.Static[int] = dataclasses.field(default=25)
 
     @classmethod
     def build(
@@ -239,7 +239,7 @@ class ViscoElasticContacts(common.ContactModel):
             parameters=parameters,
             terrain=terrain or cls.__dataclass_fields__["terrain"].default_factory(),
             max_squarings=int(
-                max_squarings or cls.__dataclass_fields__["max_squarings"].default()
+                max_squarings or cls.__dataclass_fields__["max_squarings"].default
             ),
         )
 
@@ -266,7 +266,7 @@ class ViscoElasticContacts(common.ContactModel):
         dt: jtp.FloatLike | None = None,
         link_forces: jtp.MatrixLike | None = None,
         joint_force_references: jtp.VectorLike | None = None,
-    ) -> tuple[jtp.Vector, tuple[Any, ...]]:
+    ) -> tuple[jtp.Matrix, tuple[jtp.Matrix, jtp.Matrix]]:
         """
         Compute the contact forces.
 

{jaxsim-0.4.3.dev186.dist-info → jaxsim-0.4.3.dev200.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaxsim
-Version: 0.4.3.dev186
+Version: 0.4.3.dev200
 Summary: A differentiable physics engine and multibody dynamics library for control and robot learning.
 Author-email: Diego Ferigo <dgferigo@gmail.com>
 Maintainer-email: Diego Ferigo <dgferigo@gmail.com>, Filippo Luca Ferretti <filippo.ferretti@iit.it>

{jaxsim-0.4.3.dev186.dist-info → jaxsim-0.4.3.dev200.dist-info}/RECORD

@@ -1,18 +1,18 @@
 jaxsim/__init__.py,sha256=opgtbhhd1kDsHI4H1vOd3loMPDRi884yQ3tohfFGfNc,3382
-jaxsim/_version.py,sha256=K0Qt3IiihQ28Vnsxow16UNJNyDGyw4M94790Je5aXw8,428
+jaxsim/_version.py,sha256=WDziMJEeSmuE81cozOtxmazlb4qAX6VPTrKOR0f3akg,428
 jaxsim/exceptions.py,sha256=vSoScaRD4nvh6jltgK9Ry5pKnE0O5hb4_yI_pk_fvR8,2175
 jaxsim/logging.py,sha256=STI-D_upXZYX-ZezLrlJJ0UlD5YspST0vZ_DcIwkzO4,1553
 jaxsim/typing.py,sha256=2HXy9hgazPXjofi1vLQ09ZubPtgVmg80U9NKmZ6NYiI,761
 jaxsim/api/__init__.py,sha256=8eV22t2S3UwNyCg8karPetG1dmX1VDBXkyv28_FwNQA,210
 jaxsim/api/com.py,sha256=m-p3EJDhpnMTlXKplfbZE_aH9NqX_VyLlAE3vUhc6l4,13642
 jaxsim/api/common.py,sha256=SNgxq42r6eF_-aPszvOjUYkGwXOzz4hKmhDwEUkscFQ,6650
-jaxsim/api/contact.py,sha256=2qBIStXWxIJTrW3Eyx6UPQcTXDXalOyasgD7Pk1_v1E,24486
-jaxsim/api/data.py,sha256=sfu_uJtYRQIf_sg9IWzR95McRdZgtHwArAuzF6KD-1A,28939
+jaxsim/api/contact.py,sha256=Egc62310ljn5goXlswwJYSB-LyW6M5gmPoT_a3mkd7U,25812
+jaxsim/api/data.py,sha256=gQX6hfEaw0ooJYvpr5f8UvEJwqhtflEK_NHWn9XgTZY,28935
 jaxsim/api/frame.py,sha256=KS8A5wRfjxhe9NgcVo2QA516iP5zky7UVnWxG7nTa7c,12911
 jaxsim/api/joint.py,sha256=lksT1Doxz2jknHyhb4ls20z6f6dofpZSzBJtVacZXAE,7129
 jaxsim/api/kin_dyn_parameters.py,sha256=thJbz9XhpXgom23S6MXX2ugxGoAD-k947ZMAHDisy2w,29620
 jaxsim/api/link.py,sha256=LAA6ZMQXkWomXeptURBtc7z3_xDZ2BBnBMhVrohh0bE,18621
-jaxsim/api/model.py,sha256=-Au3Xdm3TJLyKN_r06pr9G99zmzjNhDI4KZz4xox7iE,69783
+jaxsim/api/model.py,sha256=s2i4obxMjZ_XntJgT0dEV57LCo0GIC7VppUnxsqC1fc,69704
 jaxsim/api/ode.py,sha256=J_WuaoPl3ZY-yvTrCQun-rQoIAv_duynSXAGxqx93sg,14211
 jaxsim/api/ode_data.py,sha256=1SD-x-lYk_YSEnVpxTLd69uOKC0mFUj44ZqpSmEDOxw,20190
 jaxsim/api/references.py,sha256=fW77LitZ8DYgT6ZmUInJfm5luBV1mTcqcNRiC_i79og,20862
@@ -53,20 +53,20 @@ jaxsim/rbda/forward_kinematics.py,sha256=2GmEoWsrioVl_SAbKRKfhOLz57pY4aR81PKRdul
 jaxsim/rbda/jacobian.py,sha256=p0EV_8cLzLVV-93VKznT7VPuRj8W7h7rQWkPlWJXfCA,11023
 jaxsim/rbda/rnea.py,sha256=CLfqs9XFVaD-hvkLABshDAfdw5bm_AMV3UVAQ_IvURQ,7542
 jaxsim/rbda/utils.py,sha256=eeT21Y4DiiyhrdF0lUE_VvRuwru5-rR7yOlOlWzCCWE,5381
-jaxsim/rbda/contacts/__init__.py,sha256=8-JvjjuCkGf-ORMNnTe641zfamagmiFqZWzNO3cneWE,362
-jaxsim/rbda/contacts/common.py,sha256=_yrxTM16Je9ck5aM95ndk8Kwu_oijxG9Jaf1jEjHEYw,4332
-jaxsim/rbda/contacts/relaxed_rigid.py,sha256=Ob5LdKe3D7tGlIdT4LamJ6_F0j5pzUmWNYoWqy8Di98,17169
-jaxsim/rbda/contacts/rigid.py,sha256=1TTiGXSOipO8l5FDTtxqRNo1ArCNtDg-Yr3olPgBLGs,17588
-jaxsim/rbda/contacts/soft.py,sha256=TMCUDtFmNIae04LCla57iXMjdt9F5qTFjYEnP5NdLFg,16809
-jaxsim/rbda/contacts/visco_elastic.py,sha256=tfcH4_JFox6_6PyR29kLlqc8pYN8WCslYnClxV7TnSU,39780
+jaxsim/rbda/contacts/__init__.py,sha256=L5MM-2pv76YPGzxExdz2EErgGBATuAjYnNHlq5QOySs,503
+jaxsim/rbda/contacts/common.py,sha256=iywCQtesrnrwywRQv8cjyot2bG11dT_iONyF8OJztIA,5798
+jaxsim/rbda/contacts/relaxed_rigid.py,sha256=TR81tJ4ipcpvPnwlfkpyNDhvWizpEG542SFVu_CwHRU,19614
+jaxsim/rbda/contacts/rigid.py,sha256=3aDPFrIm2_QpKKRpTqJJk8qBK-W63gq7Arc8WDVAcHc,17382
+jaxsim/rbda/contacts/soft.py,sha256=6eFgV2hJK793RZfoY8oSqw-zC1UqFldaE0hfGHELnmU,16325
+jaxsim/rbda/contacts/visco_elastic.py,sha256=wATvBhLrV-7IyVLJhW7OaMg_HDAmczl_8MnYm3wuqSc,39819
 jaxsim/terrain/__init__.py,sha256=f7lVX-iNpH_wkkjef9Qpjh19TTAUOQw76EiLYJDVizc,78
 jaxsim/terrain/terrain.py,sha256=K91HEzPqTSyNrc_j1KfAAEF_5oDeuk_-jnnZGrcMEcY,5015
 jaxsim/utils/__init__.py,sha256=Y5zyoRevl3EMVQadhZ4EtSwTEkDt2vcnFoRhPJjKTZ0,215
 jaxsim/utils/jaxsim_dataclass.py,sha256=TGmTQV2Lq7Q-2nLoAEaeNtkPa_qj0IKkdBm4COj46Os,11312
 jaxsim/utils/tracing.py,sha256=KDMoyVPlu2NJvFkhtZwq5AkqMMgajt3munvJom-vEjQ,650
 jaxsim/utils/wrappers.py,sha256=Fh82ZcaFi5fUnByyFLnmumaobsu1hJIvFdopUVzJ1ps,4052
-jaxsim-0.4.3.dev186.dist-info/LICENSE,sha256=eaYdFmdeMbiIoIiPzEK0MjP1S9wtFXjXNR5er49uLR0,1546
-jaxsim-0.4.3.dev186.dist-info/METADATA,sha256=YYb7FonjyOeyop0Ni-0dB0ijfk215c0-PZo6k9v6JAo,17276
-jaxsim-0.4.3.dev186.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-jaxsim-0.4.3.dev186.dist-info/top_level.txt,sha256=LxGMA8FLtXjQ6oI7N5gd_R_oSUHxpXxUEOfT1xS_ni0,7
-jaxsim-0.4.3.dev186.dist-info/RECORD,,
+jaxsim-0.4.3.dev200.dist-info/LICENSE,sha256=eaYdFmdeMbiIoIiPzEK0MjP1S9wtFXjXNR5er49uLR0,1546
+jaxsim-0.4.3.dev200.dist-info/METADATA,sha256=NUJ6GXIFFK-y9-p-M2OTTdI3g7utYHa3Lsg2VXSXtoI,17276
+jaxsim-0.4.3.dev200.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
+jaxsim-0.4.3.dev200.dist-info/top_level.txt,sha256=LxGMA8FLtXjQ6oI7N5gd_R_oSUHxpXxUEOfT1xS_ni0,7
+jaxsim-0.4.3.dev200.dist-info/RECORD,,

{jaxsim-0.4.3.dev186.dist-info → jaxsim-0.4.3.dev200.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (75.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any