jaxsim 0.6.2.dev182__py3-none-any.whl → 0.6.2.dev225__py3-none-any.whl

jaxsim/rbda/contacts/soft.py

@@ -0,0 +1,448 @@
+from __future__ import annotations
+
+import dataclasses
+import functools
+
+import jax
+import jax.numpy as jnp
+import jax_dataclasses
+
+import jaxsim.api as js
+import jaxsim.math
+import jaxsim.typing as jtp
+from jaxsim import logging
+from jaxsim.terrain import Terrain
+
+from . import common
+
+try:
+    from typing import Self
+except ImportError:
+    from typing_extensions import Self
+
+
+@jax_dataclasses.pytree_dataclass
+class SoftContactsParams(common.ContactsParams):
+    """Parameters of the soft contacts model."""
+
+    K: jtp.Float = dataclasses.field(
+        default_factory=lambda: jnp.array(1e6, dtype=float)
+    )
+
+    D: jtp.Float = dataclasses.field(
+        default_factory=lambda: jnp.array(2000, dtype=float)
+    )
+
+    mu: jtp.Float = dataclasses.field(
+        default_factory=lambda: jnp.array(0.5, dtype=float)
+    )
+
+    p: jtp.Float = dataclasses.field(
+        default_factory=lambda: jnp.array(0.5, dtype=float)
+    )
+
+    q: jtp.Float = dataclasses.field(
+        default_factory=lambda: jnp.array(0.5, dtype=float)
+    )
+
+    def __hash__(self) -> int:
+
+        from jaxsim.utils.wrappers import HashedNumpyArray
+
+        return hash(
+            (
+                HashedNumpyArray.hash_of_array(self.K),
+                HashedNumpyArray.hash_of_array(self.D),
+                HashedNumpyArray.hash_of_array(self.mu),
+                HashedNumpyArray.hash_of_array(self.p),
+                HashedNumpyArray.hash_of_array(self.q),
+            )
+        )
+
+    def __eq__(self, other: SoftContactsParams) -> bool:
+
+        if not isinstance(other, SoftContactsParams):
+            return False
+
+        return hash(self) == hash(other)
+
+    @classmethod
+    def build(
+        cls: type[Self],
+        *,
+        K: jtp.FloatLike = 1e6,
+        D: jtp.FloatLike = 2_000,
+        mu: jtp.FloatLike = 0.5,
+        p: jtp.FloatLike = 0.5,
+        q: jtp.FloatLike = 0.5,
+        **kwargs,
+    ) -> Self:
+        """
+        Create a SoftContactsParams instance with specified parameters.
+
+        Args:
+            K: The stiffness parameter.
+            D: The damping parameter of the soft contacts model.
+            mu: The static friction coefficient.
+            p:
+                The exponent p corresponding to the damping-related non-linearity
+                of the Hunt/Crossley model.
+            q:
+                The exponent q corresponding to the spring-related non-linearity
+                of the Hunt/Crossley model
+            **kwargs: Additional parameters to pass to the contact model.
+
+        Returns:
+            A SoftContactsParams instance with the specified parameters.
+        """
+
+        return SoftContactsParams(
+            K=jnp.array(K, dtype=float),
+            D=jnp.array(D, dtype=float),
+            mu=jnp.array(mu, dtype=float),
+            p=jnp.array(p, dtype=float),
+            q=jnp.array(q, dtype=float),
+        )
+
+    def valid(self) -> jtp.BoolLike:
+        """
+        Check if the parameters are valid.
+
+        Returns:
+            `True` if the parameters are valid, `False` otherwise.
+        """
+
+        return jnp.hstack(
+            [
+                self.K >= 0.0,
+                self.D >= 0.0,
+                self.mu >= 0.0,
+                self.p >= 0.0,
+                self.q >= 0.0,
+            ]
+        ).all()
+
+
+@jax_dataclasses.pytree_dataclass
+class SoftContacts(common.ContactModel):
+    """Soft contacts model."""
+
+    @classmethod
+    def build(
+        cls: type[Self],
+        model: js.model.JaxSimModel | None = None,
+        **kwargs,
+    ) -> Self:
+        """
+        Create a `SoftContacts` instance with specified parameters.
+
+        Args:
+            model:
+                The robot model considered by the contact model.
+                If passed, it is used to estimate good default parameters.
+            **kwargs: Additional parameters to pass to the contact model.
+
+        Returns:
+            The `SoftContacts` instance.
+        """
+
+        if len(kwargs) != 0:
+            logging.debug(msg=f"Ignoring extra arguments: {kwargs}")
+
+        return cls(**kwargs)
+
+    @classmethod
+    def zero_state_variables(cls, model: js.model.JaxSimModel) -> dict[str, jtp.Array]:
+        """
+        Build zero state variables of the contact model.
+        """
+
+        # Initialize the material deformation to zero.
+        tangential_deformation = jnp.zeros(
+            shape=(len(model.kin_dyn_parameters.contact_parameters.body), 3),
+            dtype=float,
+        )
+
+        return {"tangential_deformation": tangential_deformation}
+
+    def update_contact_state(
+        self: type[Self], old_contact_state: dict[str, jtp.Array]
+    ) -> dict[str, jtp.Array]:
+        """
+        Update the contact state.
+
+        Args:
+            old_contact_state: The old contact state.
+
+        Returns:
+            The updated contact state.
+        """
+
+        return {"tangential_deformation": old_contact_state["m_dot"]}
+
+    def update_velocity_after_impact(
+        self: type[Self], model: js.model.JaxSimModel, data: js.data.JaxSimModelData
+    ) -> js.data.JaxSimModelData:
+        """
+        Update the velocity after an impact.
+
+        Args:
+            model: The robot model considered by the contact model.
+            data: The data of the considered model.
+
+        Returns:
+            The updated data of the considered model.
+        """
+
+        return data
+
+    @staticmethod
+    @functools.partial(jax.jit, static_argnames=("terrain",))
+    def hunt_crossley_contact_model(
+        position: jtp.VectorLike,
+        velocity: jtp.VectorLike,
+        tangential_deformation: jtp.VectorLike,
+        terrain: Terrain,
+        K: jtp.FloatLike,
+        D: jtp.FloatLike,
+        mu: jtp.FloatLike,
+        p: jtp.FloatLike = 0.5,
+        q: jtp.FloatLike = 0.5,
+    ) -> tuple[jtp.Vector, jtp.Vector]:
+        """
+        Compute the contact force using the Hunt/Crossley model.
+
+        Args:
+            position: The position of the collidable point.
+            velocity: The velocity of the collidable point.
+            tangential_deformation: The material deformation of the collidable point.
+            terrain: The terrain model.
+            K: The stiffness parameter.
+            D: The damping parameter of the soft contacts model.
+            mu: The static friction coefficient.
+            p:
+                The exponent p corresponding to the damping-related non-linearity
+                of the Hunt/Crossley model.
+            q:
+                The exponent q corresponding to the spring-related non-linearity
+                of the Hunt/Crossley model
+
+        Returns:
+            A tuple containing the computed contact force and the derivative of the
+            material deformation.
+        """
+
+        # Convert the input vectors to arrays.
+        W_p_C = jnp.array(position, dtype=float).squeeze()
+        W_ṗ_C = jnp.array(velocity, dtype=float).squeeze()
+        m = jnp.array(tangential_deformation, dtype=float).squeeze()
+
+        # Use symbol for the static friction.
+        μ = mu
+
+        # Compute the penetration depth, its rate, and the considered terrain normal.
+        δ, δ̇, 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.
+        # To avoid these issues, we introduce a small tolerance ε to their arguments
+        # and make sure that we do not check them against zero directly.
+        ε = jnp.finfo(float).eps
+
+        # Compute the powers of the penetration depth.
+        # Inject ε to address AD issues in differentiating the square root when
+        #  p and q are fractional.
+        δp = jnp.power(δ + ε, p)
+        δq = jnp.power(δ + ε, q)
+
+        # ========================
+        # Compute the normal force
+        # ========================
+
+        # Non-linear spring-damper model (Hunt/Crossley model).
+        # This is the force magnitude along the direction normal to the terrain.
+        force_normal_mag = (K * δp) * δ + (D * δq) * δ̇
+
+        # Depending on the magnitude of δ̇, the normal force could be negative.
+        force_normal_mag = jnp.maximum(0.0, force_normal_mag)
+
+        # Compute the 3D linear force in C[W] frame.
+        f_normal = force_normal_mag * n̂
+
+        # ============================
+        # Compute the tangential force
+        # ============================
+
+        # Extract the tangential component of the velocity.
+        v_tangential = W_ṗ_C - jnp.dot(W_ṗ_C, n̂) * n̂
+
+        # Extract the normal and tangential components of the material deformation.
+        m_normal = jnp.dot(m, n̂) * n̂
+        m_tangential = m - jnp.dot(m, n̂) * n̂
+
+        # Compute the tangential force in the sticking case.
+        # Using the tangential component of the material deformation should not be
+        # necessary if the sticking-slipping transition occurs in a terrain area
+        # with a locally constant normal. However, this assumption is not true in
+        # general, especially for highly uneven terrains.
+        f_tangential = -((K * δp) * m_tangential + (D * δq) * v_tangential)
+
+        # Detect the contact type (sticking or slipping).
+        # Note that if there is no contact, sticking is set to True, and this detail
+        # is exploited in the computation of the `contact_status` variable.
+        sticking = jnp.logical_or(
+            δ <= 0, f_tangential.dot(f_tangential) <= (μ * force_normal_mag) ** 2
+        )
+
+        # Compute the direction of the tangential force.
+        # To prevent dividing by zero, we use a switch statement.
+        norm = jaxsim.math.safe_norm(f_tangential)
+        f_tangential_direction = f_tangential / (
+            norm + jnp.finfo(float).eps * (norm == 0)
+        )
+
+        # Project the tangential force to the friction cone if slipping.
+        f_tangential = jnp.where(
+            sticking,
+            f_tangential,
+            jnp.minimum(μ * force_normal_mag, norm) * f_tangential_direction,
+        )
+
+        # Set the tangential force to zero if there is no contact.
+        f_tangential = jnp.where(δ <= 0, jnp.zeros(3), f_tangential)
+
+        # =====================================
+        # Compute the material deformation rate
+        # =====================================
+
+        # Compute the derivative of the material deformation.
+        # Note that we included an additional relaxation of `m_normal` in the
+        # sticking case, so that the normal deformation that could have accumulated
+        # from a previous slipping phase can relax to zero.
+        ṁ_no_contact = -(K / D) * m
+        ṁ_sticking = v_tangential - (K / D) * m_normal
+        ṁ_slipping = -(f_tangential + (K * δp) * m_tangential) / (D * δq)
+
+        # Compute the contact status:
+        # 0: slipping
+        # 1: sticking
+        # 2: no contact
+        contact_status = sticking.astype(int)
+        contact_status += (δ <= 0).astype(int)
+
+        # Select the right material deformation rate depending on the contact status.
+        ṁ = jax.lax.select_n(contact_status, ṁ_slipping, ṁ_sticking, ṁ_no_contact)
+
+        # ==========================================
+        # Compute and return the final contact force
+        # ==========================================
+
+        # Sum the normal and tangential forces.
+        CW_fl = f_normal + f_tangential
+
+        return CW_fl, ṁ
+
+    @staticmethod
+    @functools.partial(jax.jit, static_argnames=("terrain",))
+    def compute_contact_force(
+        position: jtp.VectorLike,
+        velocity: jtp.VectorLike,
+        tangential_deformation: jtp.VectorLike,
+        parameters: SoftContactsParams,
+        terrain: Terrain,
+    ) -> tuple[jtp.Vector, jtp.Vector]:
+        """
+        Compute the contact force.
+
+        Args:
+            position: The position of the collidable point.
+            velocity: The velocity of the collidable point.
+            tangential_deformation: The material deformation of the collidable point.
+            parameters: The parameters of the soft contacts model.
+            terrain: The terrain model.
+
+        Returns:
+            A tuple containing the computed contact force and the derivative of the
+            material deformation.
+        """
+
+        CW_fl, ṁ = SoftContacts.hunt_crossley_contact_model(
+            position=position,
+            velocity=velocity,
+            tangential_deformation=tangential_deformation,
+            terrain=terrain,
+            K=parameters.K,
+            D=parameters.D,
+            mu=parameters.mu,
+            p=parameters.p,
+            q=parameters.q,
+        )
+
+        # Pack a mixed 6D force.
+        CW_f = jnp.hstack([CW_fl, jnp.zeros(3)])
+
+        # Compute the 6D force transform from the mixed to the inertial-fixed frame.
+        W_Xf_CW = jaxsim.math.Adjoint.from_quaternion_and_translation(
+            translation=jnp.array(position), inverse=True
+        ).T
+
+        # Compute the 6D force in the inertial-fixed frame.
+        W_f = W_Xf_CW @ CW_f
+
+        return W_f, ṁ
+
+    @staticmethod
+    @jax.jit
+    def compute_contact_forces(
+        model: js.model.JaxSimModel,
+        data: js.data.JaxSimModelData,
+    ) -> tuple[jtp.Matrix, dict[str, jtp.PyTree]]:
+        """
+        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 a dictionary with derivative of the material deformation.
+        """
+
+        # Get the indices of the enabled collidable points.
+        indices_of_enabled_collidable_points = (
+            model.kin_dyn_parameters.contact_parameters.indices_of_enabled_collidable_points
+        )
+
+        # Compute the position and linear velocities (mixed representation) of
+        # all the collidable points belonging to the robot and extract the ones
+        # for the enabled collidable points.
+        W_p_C, W_ṗ_C = js.contact.collidable_point_kinematics(model=model, data=data)
+
+        # Extract the material deformation corresponding to the collidable points.
+        m = (
+            data.contact_state["tangential_deformation"]
+            if "tangential_deformation" in data.contact_state
+            else jnp.zeros_like(W_p_C)
+        )
+
+        m_enabled = m[indices_of_enabled_collidable_points]
+
+        # Initialize the tangential deformation rate array for every collidable point.
+        ṁ = jnp.zeros_like(m)
+
+        # Compute the contact forces only for the enabled collidable points.
+        # Since we treat them as independent, we can vmap the computation.
+        W_f, ṁ_enabled = jax.vmap(
+            lambda p, v, m: SoftContacts.compute_contact_force(
+                position=p,
+                velocity=v,
+                tangential_deformation=m,
+                parameters=model.contact_params,
+                terrain=model.terrain,
+            )
+        )(W_p_C, W_ṗ_C, m_enabled)
+
+        ṁ = ṁ.at[indices_of_enabled_collidable_points].set(ṁ_enabled)
+
+        return W_f, {"m_dot": ṁ}

jaxsim/rbda/forward_kinematics.py

@@ -111,32 +111,3 @@ def forward_kinematics_model(
     )
 
     return jax.vmap(Adjoint.to_transform)(W_X_i), W_v_Wi
-
-
-def forward_kinematics(
-    model: js.model.JaxSimModel,
-    link_index: jtp.Int,
-    base_position: jtp.VectorLike,
-    base_quaternion: jtp.VectorLike,
-    joint_positions: jtp.VectorLike,
-) -> jtp.Matrix:
-    """
-    Compute the forward kinematics of a specific link.
-
-    Args:
-        model: The model to consider.
-        link_index: The index of the link to consider.
-        base_position: The position of the base link.
-        base_quaternion: The quaternion of the base link.
-        joint_positions: The positions of the joints.
-
-    Returns:
-        The SE(3) transform of the link.
-    """
-
-    return forward_kinematics_model(
-        model=model,
-        base_position=base_position,
-        base_quaternion=base_quaternion,
-        joint_positions=joint_positions,
-    )[link_index]

jaxsim/rbda/utils.py

@@ -132,10 +132,10 @@ def process_inputs(
     if W_Q_B.shape != (4,):
         raise ValueError(W_Q_B.shape, (4,))
 
-    # Check that the quaternion does not contain NaNs.
+    # Check that the quaternion does not contain NaN values.
     exceptions.raise_value_error_if(
         condition=jnp.isnan(W_Q_B).any(),
-        msg="A RBDA received a quaternion that contains NaNs.",
+        msg="A RBDA received a quaternion that contains NaN values.",
     )
 
     # Check that the quaternion is unary since our RBDAs make this assumption in order

jaxsim/terrain/terrain.py

@@ -59,7 +59,7 @@ class Terrain(abc.ABC):
             [(h_xm - h_xp) / (2 * self.delta), (h_ym - h_yp) / (2 * self.delta), 1.0]
         )
 
-        return n / jaxsim.math.safe_norm(n)
+        return n / jaxsim.math.safe_norm(n, axis=-1)
 
 
 @jax_dataclasses.pytree_dataclass

{jaxsim-0.6.2.dev182.dist-info → jaxsim-0.6.2.dev225.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: jaxsim
-Version: 0.6.2.dev182
+Version: 0.6.2.dev225
 Summary: A differentiable physics engine and multibody dynamics library for control and robot learning.
 Author-email: Diego Ferigo <dgferigo@gmail.com>, Filippo Luca Ferretti <filippoluca.ferretti@outlook.com>
 Maintainer-email: Filippo Luca Ferretti <filippo.ferretti@iit.it>, Alessandro Croci <alessandro.croci@iit.it>
@@ -89,6 +89,7 @@ Requires-Dist: mujoco>=3.0.0; extra == "viz"
 Requires-Dist: scipy>=1.14.0; extra == "viz"
 Provides-Extra: all
 Requires-Dist: jaxsim[style,testing,viz]; extra == "all"
+Dynamic: license-file
 
 # JaxSim
 

{jaxsim-0.6.2.dev182.dist-info → jaxsim-0.6.2.dev225.dist-info}/RECORD

@@ -1,41 +1,40 @@
 jaxsim/__init__.py,sha256=b8dYoVXqtHxHcF56iM2xgKk78lsvmGrfDlvdwaGasgs,3388
-jaxsim/_version.py,sha256=9vVqCpGd377pxkCsNsYmE64xHn05XG7hf09NdgSZsOA,528
+jaxsim/_version.py,sha256=SLeXvaiJ6DysB1Pv4cxctaKKJ8fxxCYci0LspPXX0Q0,528
 jaxsim/exceptions.py,sha256=MQ3LRMfVMX2-g3qYj7mUVNV9OLlIA48TANJegbcQyXI,2641
 jaxsim/logging.py,sha256=STI-D_upXZYX-ZezLrlJJ0UlD5YspST0vZ_DcIwkzO4,1553
 jaxsim/typing.py,sha256=7msl8t5Jt09RNYfKdPJtpjLfWurldcycDappb045Eso,761
-jaxsim/api/__init__.py,sha256=Yck5Cr6_6yqGKwt2KicccEiy-hzIAOFA3G0sPXWQTgg,253
+jaxsim/api/__init__.py,sha256=4skzcTTejLFfZ_JE6yEEyNxObpXnR5u-bYsn2lBEx-4,234
 jaxsim/api/actuation_model.py,sha256=L8AzxIiEquWeG8UGGJaYr2Alt4dkkOROlbsCn9hUYik,2825
-jaxsim/api/com.py,sha256=jhWcUsJtZYEQf-hnEvVuqH1KoiakBNLnTkj3PA6Cn-Q,13748
-jaxsim/api/common.py,sha256=jd3thxFUxcyoAMV3ZDMqfk2DlBdvWMZuI25Y0Pw5Dlo,7088
-jaxsim/api/contact.py,sha256=PpVtlb7Iw4mW0dCrGWorznzF2ai13N9SlV7DL5ecUfA,16795
-jaxsim/api/contact_model.py,sha256=gY7dRA6UIduD4OO1nRZ4VmnNXIOeDLulw5Am9gBjhUs,3334
-jaxsim/api/data.py,sha256=vfgzPBCbX9OUiCBKvyib2aevhZpH-MzU4ZNZsnhidQo,20790
+jaxsim/api/com.py,sha256=47a9SSaXY540RCkVnHodwLNUrodIfJIkguIYdSEQVwQ,13697
+jaxsim/api/common.py,sha256=yTaRXDYkXmISBOhZ93f9TssR0p4wq7qj7B6OsvYzRME,6942
+jaxsim/api/contact.py,sha256=dlKKDQUG-KQ5qQaYBv2NmZLDb1OnJdltZv8MWXkD_W0,20969
+jaxsim/api/data.py,sha256=aW6buyH3YszzEBqBXqBgHf6uaSilZcqU7PyP60qgLco,23336
 jaxsim/api/frame.py,sha256=4wg6GsyBQgYhSvc-ry_31JsaL66sZt3TtgwjB7NrHmk,14583
-jaxsim/api/integrators.py,sha256=O2WmwW-3lZEiA2Pp0-CsyYlnoqaz0zqqNdeCZUI5O6Q,4980
+jaxsim/api/integrators.py,sha256=DgOnzLepy45e-TM6Infk8qfPXn0r8GubCdJQZmNLP8w,5269
 jaxsim/api/joint.py,sha256=AnqlNWmBOay-gsoo0y4AbfFQ2OCJm-8T1E0IMhZeLoY,7457
 jaxsim/api/kin_dyn_parameters.py,sha256=v1ZDb-Eqn552Zb344sJYy9e5sQT--_SYGIdtNC2JVSg,29828
 jaxsim/api/link.py,sha256=bSZOYJDY9HJMgY25VzevTTsdFZTJc6yRRpslc5FhGHE,12782
-jaxsim/api/model.py,sha256=czjv_OcjIYjCzN-LHv2qSSrAkPSPcsLCEe_kD6XZnuA,69846
-jaxsim/api/ode.py,sha256=rGOswAcchEdzx8ZfMDTR2F6AjkHymZgTTdvBbjPPpd4,5358
-jaxsim/api/references.py,sha256=ywNiURwZ0niYB-AzX1eoWCfdrx7TBiRyyfi_2tz-ako,20677
-jaxsim/math/__init__.py,sha256=lWMswEnITzQ69O761CiHL-r7UrxyIqsHlk4YTNxtwAY,384
-jaxsim/math/adjoint.py,sha256=mAtCwddK1ZwpVgIp4GIY8EVAW32Z67AJl_BzREf0ih8,4731
+jaxsim/api/model.py,sha256=LkhQaN4ZgoQUOTTtDaa4y689vTF14VCeVeaqCkjB_t8,69237
+jaxsim/api/ode.py,sha256=fp20_LK9lXw2DfNkQgrfJmtd_iBXDNzZkOn0u5Pm8Qw,6190
+jaxsim/api/references.py,sha256=-vd50y3v-jkXAsILS432etIKV6e2EUE2oOeLHuUrfuQ,20399
+jaxsim/math/__init__.py,sha256=dNozvtm8WsB7nxw4uK29yQQKPcDUEczr2zcHoZfMItc,383
+jaxsim/math/adjoint.py,sha256=Pb0WAiAoN1ge8j_dPcdK307jmC5LzD1-DeUj9Z_NXkI,4667
 jaxsim/math/cross.py,sha256=AM4HauuuT09q2TN42qvdXhJ9LvtCh0e7ZyLjP-7sANs,1498
 jaxsim/math/inertia.py,sha256=T-iAjPYSD_72R0ZG8GDJhe5i3Jc3ojhlbBRSscTdCKg,1577
 jaxsim/math/joint_model.py,sha256=mV6F3SVHUxHcXMIw-hc4fG341R4rkK8MvRPn53HcEpg,6915
 jaxsim/math/quaternion.py,sha256=MSaZywzJDxs2te1ZELeIcupKSFIA9q_pdXy7fDAEqM4,4539
 jaxsim/math/rotation.py,sha256=TEUtT3X2tFieNxdlccup1pfaTgCTtfX-hTNotd8-nNk,1892
 jaxsim/math/skew.py,sha256=z_9YN-NDHL3n4KXWNbzTSMkFDZ0SDpz4RUcwwYFOaao,1402
-jaxsim/math/transform.py,sha256=We0ChLajSckxGINiJsP1a5Ur3yjg3JuweQ3kK4Woix4,3332
-jaxsim/math/utils.py,sha256=2id1F6QOvkHkIF3Nuxuj_tz_kI0IYlrlgVQrETmXFfI,1058
+jaxsim/math/transform.py,sha256=NOWBQgL_5hVr9aHA7j0Ta-Zq_EXAKguUAx78fVPZJE4,3342
+jaxsim/math/utils.py,sha256=IiH01iN54BtLnULC04pDfYe8Av99p3FGdYp2jJInm30,1166
 jaxsim/mujoco/__init__.py,sha256=1kAWzYOS7nP29S5FGyWPqiAnPf4yPSoaPW-WBGBjVV0,214
 jaxsim/mujoco/__main__.py,sha256=GBmB7J-zj75ZnFyuAAmpSOpbxi_HhHhWJeot3ljGDJY,5291
 jaxsim/mujoco/loaders.py,sha256=OCk1T11iIm3qZUibNpo_bxxLgaGSkCpLt7ae_ND0ExA,23272
 jaxsim/mujoco/model.py,sha256=bRXo1uhWDN37sP9qdejr_2vq_PXHQ7p6eyBlFff_JcE,16492
 jaxsim/mujoco/utils.py,sha256=dW3LrcM050-eVVdLuCiN3StIrTEfyk_jJyq1GiNh3fg,8396
-jaxsim/mujoco/visualizer.py,sha256=7CYxxqPZdCp9Wc77ZGe1t8Z_SIgBpoJAtYcvQMcCJvQ,7746
+jaxsim/mujoco/visualizer.py,sha256=cmI6DhFb1XC7oEtg_wl-s-U56dWHA-F7GlBD6EDYTyA,7744
 jaxsim/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jaxsim/parsers/kinematic_graph.py,sha256=YkxnykmGIXYs5fSXUX1mIi81mm7lG4HMt8LyRV-31j0,35759
+jaxsim/parsers/kinematic_graph.py,sha256=s6sKPOGj_St4dfooNhE5a4F4tO3qTODErLYx8dfZRJk,35757
 jaxsim/parsers/descriptions/__init__.py,sha256=N_hp8cGI5FyEFiuNx9a-CAGCr0F0QpYEpdMHvwB7_1g,261
 jaxsim/parsers/descriptions/collision.py,sha256=C6SekAPL2tNG62Y-lTqj1m9BblhoTZDj2F2vgspKNbI,4577
 jaxsim/parsers/descriptions/joint.py,sha256=MurLIHHmu-y_bwUcR_J1NZ-FjfRZRk166zKsn6VzIwE,4232
@@ -45,25 +44,27 @@ jaxsim/parsers/rod/__init__.py,sha256=G2vqlLajBLUc4gyzXwsEI2Wsi4TMOIF9bLDFeT6KrG
 jaxsim/parsers/rod/meshes.py,sha256=yAXefG73_zqbVKRUdlcz9yFmypjDIpiP9cO96PeAozE,2842
 jaxsim/parsers/rod/parser.py,sha256=vaOlvlvgQCEGbymFc21praHKEVq_LqqlKeRJNv7tZiE,14398
 jaxsim/parsers/rod/utils.py,sha256=wmD-wCF1lLO8pknX7A3a8CGt9wDlTS_xCqQulcZ_XlM,8242
-jaxsim/rbda/__init__.py,sha256=kmy4G9aMkrqPNGdLSaSV3k15dpF52vBEUQXDFDuKIxU,337
+jaxsim/rbda/__init__.py,sha256=nQ01ALTXm8lJAb5flCOzxfjyDZPbDrP4H3v-xlfyCss,317
 jaxsim/rbda/aba.py,sha256=QiajR4Uv06u-BX5V2kWpmFmP_kIfTxxcycdJhIbid9A,9029
 jaxsim/rbda/collidable_points.py,sha256=XyeV1I43GL22j03rkNVocaIPOGYirt3PiDHrFMndziQ,2070
 jaxsim/rbda/crba.py,sha256=DC9kBXMG1qXaoAdo8K7OCnVHT_YUaL_t6Li56sRf8ro,5093
-jaxsim/rbda/forward_kinematics.py,sha256=zoyXEZnL-hyJr3c9Jl0EfCleJtVvVsekHgUTLn5EiQ4,4640
+jaxsim/rbda/forward_kinematics.py,sha256=qem7Yp-B2oNVOsU3Q2CWV2tbfZKJOCAdDozFgaPB8tg,3838
 jaxsim/rbda/jacobian.py,sha256=EaMvf073UnLWJGXm4UZIlYd4erulFAGgj_pp89k6xic,11113
 jaxsim/rbda/rnea.py,sha256=lMU7xxdPqGGzk0QwteB-IYjL4auHOpd78C1YqAXlp9s,7588
-jaxsim/rbda/utils.py,sha256=LDm00VhNjH2STo5y48PAtO4TC75Bybi60-Viuq3Cyss,5575
-jaxsim/rbda/contacts/__init__.py,sha256=eZKSoGpWH6IQIofhXzU-q9J00PkKTovPVnxubmzoK0E,202
-jaxsim/rbda/contacts/common.py,sha256=QSvEykjN5MuRD7Vk-rM454qBYdkwH7xZAVOBeulKAUc,5042
-jaxsim/rbda/contacts/relaxed_rigid.py,sha256=BTHOr0An_6K3UIkGYakaF05gkTsKHDSinDzirlvSY8o,26742
+jaxsim/rbda/utils.py,sha256=6JwEDQqLMsBX7CUmPYEhdPEscXmGbWVYg6xEriPOgvE,5587
+jaxsim/rbda/contacts/__init__.py,sha256=resrBkTdOA-1YMdcdUH2RATEhAf_Ye6MQNtjG3ClMYQ,371
+jaxsim/rbda/contacts/common.py,sha256=qVm3Ghoytg1HAeykNrYw5-4rQJ4Mv7h0Pk75ETzGXyc,9045
+jaxsim/rbda/contacts/relaxed_rigid.py,sha256=QlRcFDscGo2Z2M33Gqb5LnYHGTSdGONoU-kqS2J5qkM,21151
+jaxsim/rbda/contacts/rigid.py,sha256=zlPXYwNf4HlJlp4t-X_dA5n1Ys-fhLiAQ-gM29fXnYo,17583
+jaxsim/rbda/contacts/soft.py,sha256=Ac9aWDdjAm55Mv9LLnEs3nj7hX_NvJMnicV35SbFLSY,15282
 jaxsim/terrain/__init__.py,sha256=f7lVX-iNpH_wkkjef9Qpjh19TTAUOQw76EiLYJDVizc,78
-jaxsim/terrain/terrain.py,sha256=TH84r2qizMmsfW7zYLViRjacCfOkqdYHsCzD1lZEY4c,6716
+jaxsim/terrain/terrain.py,sha256=so8kqVsUlPXqOKQ_UaYW6HE4XS8nTZRdFdXQyhB2tG4,6725
 jaxsim/utils/__init__.py,sha256=Y5zyoRevl3EMVQadhZ4EtSwTEkDt2vcnFoRhPJjKTZ0,215
 jaxsim/utils/jaxsim_dataclass.py,sha256=XzmZeIibcaOzaxpprsGSxH3UrM66PAO456rFV91sNXg,11453
 jaxsim/utils/tracing.py,sha256=Btwxdfhb7fJLk3r5PlQkGYj60Y2KbFT1gANGIA697FU,530
 jaxsim/utils/wrappers.py,sha256=3IMwydqFgmSPqeuUQ3PRmdhDc1IoT6XC23jPC_LjWXs,4175
-jaxsim-0.6.2.dev182.dist-info/LICENSE,sha256=eaYdFmdeMbiIoIiPzEK0MjP1S9wtFXjXNR5er49uLR0,1546
-jaxsim-0.6.2.dev182.dist-info/METADATA,sha256=jAiUH_e3tQd-cYMXURWWZFlvlLw-m2lCYOiYk1zNLlg,19991
-jaxsim-0.6.2.dev182.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
-jaxsim-0.6.2.dev182.dist-info/top_level.txt,sha256=LxGMA8FLtXjQ6oI7N5gd_R_oSUHxpXxUEOfT1xS_ni0,7
-jaxsim-0.6.2.dev182.dist-info/RECORD,,
+jaxsim-0.6.2.dev225.dist-info/licenses/LICENSE,sha256=eaYdFmdeMbiIoIiPzEK0MjP1S9wtFXjXNR5er49uLR0,1546
+jaxsim-0.6.2.dev225.dist-info/METADATA,sha256=6jlXlKkNxnbIC0H6dwcdX1qBKVL0yDamRTW9SgcCzLY,20013
+jaxsim-0.6.2.dev225.dist-info/WHEEL,sha256=tTnHoFhvKQHCh4jz3yCn0WPTYIy7wXx3CJtJ7SJGV7c,91
+jaxsim-0.6.2.dev225.dist-info/top_level.txt,sha256=LxGMA8FLtXjQ6oI7N5gd_R_oSUHxpXxUEOfT1xS_ni0,7
+jaxsim-0.6.2.dev225.dist-info/RECORD,,

{jaxsim-0.6.2.dev182.dist-info → jaxsim-0.6.2.dev225.dist-info}/WHEEL

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