jaxsim 0.4.3.dev12__py3-none-any.whl → 0.4.3.dev18__py3-none-any.whl

jaxsim/rbda/contacts/rigid.py

@@ -0,0 +1,478 @@
+from __future__ import annotations
+
+import dataclasses
+from typing import Any
+
+import jax
+import jax.numpy as jnp
+import jax_dataclasses
+
+import jaxsim.api as js
+import jaxsim.typing as jtp
+from jaxsim import math
+from jaxsim.api.common import ModelDataWithVelocityRepresentation, VelRepr
+from jaxsim.terrain import FlatTerrain, Terrain
+
+from .common import ContactModel, ContactsParams, ContactsState
+
+
+@jax_dataclasses.pytree_dataclass
+class RigidContactsParams(ContactsParams):
+    """Parameters of the rigid contacts model."""
+
+    # Static friction coefficient
+    mu: jtp.Float = dataclasses.field(
+        default_factory=lambda: jnp.array(0.5, dtype=float)
+    )
+
+    # Baumgarte proportional term
+    K: jtp.Float = dataclasses.field(
+        default_factory=lambda: jnp.array(0.0, dtype=float)
+    )
+
+    # Baumgarte derivative term
+    D: jtp.Float = dataclasses.field(
+        default_factory=lambda: jnp.array(0.0, dtype=float)
+    )
+
+    def __hash__(self) -> int:
+        from jaxsim.utils.wrappers import HashedNumpyArray
+
+        return hash(
+            (
+                HashedNumpyArray.hash_of_array(self.mu),
+                HashedNumpyArray.hash_of_array(self.K),
+                HashedNumpyArray.hash_of_array(self.D),
+            )
+        )
+
+    def __eq__(self, other: RigidContactsParams) -> bool:
+        return hash(self) == hash(other)
+
+    @classmethod
+    def build(
+        cls,
+        mu: jtp.FloatLike | None = None,
+        K: jtp.FloatLike | None = None,
+        D: jtp.FloatLike | None = None,
+    ) -> RigidContactsParams:
+        """Create a `RigidContactParams` instance"""
+        return RigidContactsParams(
+            mu=mu or cls.__dataclass_fields__["mu"].default,
+            K=K or cls.__dataclass_fields__["K"].default,
+            D=D or cls.__dataclass_fields__["D"].default,
+        )
+
+    def valid(self) -> bool:
+        return bool(
+            jnp.all(self.mu >= 0.0)
+            and jnp.all(self.K >= 0.0)
+            and jnp.all(self.D >= 0.0)
+        )
+
+
+@jax_dataclasses.pytree_dataclass
+class RigidContactsState(ContactsState):
+    """Class storing the state of the rigid contacts model."""
+
+    def __eq__(self, other: RigidContactsState) -> bool:
+        return hash(self) == hash(other)
+
+    @staticmethod
+    def build(**kwargs) -> RigidContactsState:
+        """Create a `RigidContactsState` instance"""
+
+        return RigidContactsState()
+
+    @staticmethod
+    def zero(**kwargs) -> RigidContactsState:
+        """Build a zero `RigidContactsState` instance from a `JaxSimModel`."""
+        return RigidContactsState.build()
+
+    def valid(self, **kwargs) -> bool:
+        return True
+
+
+@jax_dataclasses.pytree_dataclass
+class RigidContacts(ContactModel):
+    """Rigid contacts model."""
+
+    parameters: RigidContactsParams = dataclasses.field(
+        default_factory=RigidContactsParams
+    )
+
+    terrain: jax_dataclasses.Static[Terrain] = dataclasses.field(
+        default_factory=FlatTerrain
+    )
+
+    @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,
+        M: jtp.MatrixLike,
+        J_WC: jtp.MatrixLike,
+        data: js.data.JaxSimModelData,
+    ) -> jtp.Vector:
+        """Returns the new velocity of the system after a potential impact.
+
+        Args:
+            inactive_collidable_points: The activation state of the collidable points.
+            M: The mass matrix of the system.
+            J_WC: The Jacobian matrix of the collidable points.
+            data: The `JaxSimModelData` instance.
+        """
+
+        def impact_velocity(
+            inactive_collidable_points: jtp.ArrayLike,
+            nu_pre: jtp.ArrayLike,
+            M: jtp.MatrixLike,
+            J_WC: jtp.MatrixLike,
+            data: js.data.JaxSimModelData,
+        ):
+            # Compute system velocity after impact maintaining zero linear velocity of active points
+            with data.switch_velocity_representation(VelRepr.Mixed):
+                sl = jnp.s_[:, 0:3, :]
+                Jl_WC = J_WC[sl]
+                # Zero out the jacobian rows of inactive points
+                Jl_WC = jnp.vstack(
+                    jnp.where(
+                        inactive_collidable_points[:, jnp.newaxis, jnp.newaxis],
+                        jnp.zeros_like(Jl_WC),
+                        Jl_WC,
+                    )
+                )
+
+                A = jnp.vstack(
+                    [
+                        jnp.hstack([M, -Jl_WC.T]),
+                        jnp.hstack(
+                            [Jl_WC, jnp.zeros((Jl_WC.shape[0], Jl_WC.shape[0]))]
+                        ),
+                    ]
+                )
+                b = jnp.hstack([M @ nu_pre, jnp.zeros(Jl_WC.shape[0])])
+                x = jnp.linalg.lstsq(A, b)[0]
+                nu_post = x[0 : M.shape[0]]
+
+                return nu_post
+
+        with data.switch_velocity_representation(VelRepr.Mixed):
+            BW_ν_pre_impact = data.generalized_velocity()
+
+            BW_ν_post_impact = impact_velocity(
+                data=data,
+                inactive_collidable_points=inactive_collidable_points,
+                nu_pre=BW_ν_pre_impact,
+                M=M,
+                J_WC=J_WC,
+            )
+
+        return BW_ν_post_impact
+
+    def compute_contact_forces(
+        self,
+        position: jtp.Vector,
+        velocity: jtp.Vector,
+        model: js.model.JaxSimModel,
+        data: js.data.JaxSimModelData,
+        link_forces: jtp.MatrixLike | None = None,
+        regularization_term: jtp.FloatLike = 1e-6,
+    ) -> tuple[jtp.Vector, tuple[Any, ...]]:
+        """
+        Compute the contact forces.
+
+        Args:
+            position: The position of the collidable point.
+            velocity: The linear velocity of the collidable point.
+            model: The `JaxSimModel` instance.
+            data: The `JaxSimModelData` instance.
+            link_forces:
+                Optional `(n_links, 6)` matrix of external forces acting on the links,
+                expressed in the same representation of data.
+            regularization_term:
+                The regularization term to add to the diagonal of the Delassus
+                matrix for better numerical conditioning.
+
+        Returns:
+            A tuple containing the contact forces.
+        """
+
+        # Import qpax just in this method
+        import qpax
+
+        link_forces = (
+            link_forces
+            if link_forces is not None
+            else jnp.zeros((model.number_of_links(), 6))
+        )
+
+        # Compute kin-dyn quantities used in the contact model
+        with data.switch_velocity_representation(VelRepr.Mixed):
+            M = js.model.free_floating_mass_matrix(model=model, data=data)
+            J_WC = js.contact.jacobian(model=model, data=data)
+            W_H_C = js.contact.transforms(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]
+
+        # Compute the activation state of the collidable points
+        inactive_collidable_points, h = RigidContacts.detect_contacts(
+            W_p_C=position,
+            terrain_height=terrain_height,
+        )
+
+        delassus_matrix = RigidContacts._delassus_matrix(M=M, J_WC=J_WC)
+
+        # Add regularization for better numerical conditioning
+        delassus_matrix = delassus_matrix + regularization_term * jnp.eye(
+            delassus_matrix.shape[0]
+        )
+
+        references = js.references.JaxSimModelReferences.build(
+            model=model,
+            data=data,
+            velocity_representation=data.velocity_representation,
+            link_forces=link_forces,
+        )
+
+        with references.switch_velocity_representation(VelRepr.Mixed):
+            BW_ν̇_free = RigidContacts._compute_mixed_nu_dot_free(
+                model, data, references=references
+            )
+
+        free_contact_acc = RigidContacts._linear_acceleration_of_collidable_points(
+            model,
+            data,
+            BW_ν̇_free,
+        ).flatten()
+
+        # Compute stabilization term
+        ḣ = velocity[:, 2].squeeze()
+        baumgarte_term = RigidContacts._compute_baumgarte_stabilization_term(
+            inactive_collidable_points=inactive_collidable_points,
+            h=h,
+            ḣ=ḣ,
+            K=self.parameters.K,
+            D=self.parameters.D,
+        ).flatten()
+
+        free_contact_acc -= baumgarte_term
+
+        # Setup optimization problem
+        Q = delassus_matrix
+        q = free_contact_acc
+        G = RigidContacts._compute_ineq_constraint_matrix(
+            inactive_collidable_points=inactive_collidable_points, mu=self.parameters.mu
+        )
+        h_bounds = RigidContacts._compute_ineq_bounds(
+            n_collidable_points=n_collidable_points
+        )
+        A = jnp.zeros((0, 3 * n_collidable_points))
+        b = jnp.zeros((0,))
+
+        # Solve the optimization problem
+        solution, *_ = qpax.solve_qp(Q=Q, q=q, A=A, b=b, G=G, h=h_bounds)
+
+        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)),
+            )
+        )
+
+        # Transform the contact forces 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,
+            ),
+        )(
+            CW_f_C,
+            W_H_C,
+        )
+
+        return W_f_C, ()
+
+    @staticmethod
+    def _delassus_matrix(
+        M: jtp.MatrixLike,
+        J_WC: jtp.MatrixLike,
+    ) -> jtp.Matrix:
+        sl = jnp.s_[:, 0:3, :]
+        J_WC_lin = jnp.vstack(J_WC[sl])
+
+        delassus_matrix = J_WC_lin @ jnp.linalg.pinv(M) @ J_WC_lin.T
+        return delassus_matrix
+
+    @staticmethod
+    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
+            Rows 0-3: enforce the friction pyramid constraint,
+            Row 4: last one is for the non negativity of the vertical force
+            Row 5: contact complementarity condition
+            """
+            G_single_point = jnp.array(
+                [
+                    [1, 0, -mu],
+                    [0, 1, -mu],
+                    [-1, 0, -mu],
+                    [0, -1, -mu],
+                    [0, 0, -1],
+                    [0, 0, c],
+                ]
+            )
+            return G_single_point
+
+        G = jax.vmap(compute_G_single_point, in_axes=(None, 0))(
+            mu, inactive_collidable_points
+        )
+        G = jax.scipy.linalg.block_diag(*G)
+        return G
+
+    @staticmethod
+    def _compute_ineq_bounds(n_collidable_points: jtp.FloatLike) -> jtp.Vector:
+        n_constraints = 6 * n_collidable_points
+        return jnp.zeros(shape=(n_constraints,))
+
+    @staticmethod
+    def _compute_mixed_nu_dot_free(
+        model: js.model.JaxSimModel,
+        data: js.data.JaxSimModelData,
+        references: js.references.JaxSimModelReferences | None = None,
+    ) -> jtp.Array:
+        references = (
+            references
+            if references is not None
+            else js.references.JaxSimModelReferences.zero(model=model, data=data)
+        )
+
+        with (
+            data.switch_velocity_representation(VelRepr.Mixed),
+            references.switch_velocity_representation(VelRepr.Mixed),
+        ):
+            BW_v_WB = data.base_velocity()
+            W_ṗ_B, W_ω_WB = jnp.split(BW_v_WB, 2)
+            W_v̇_WB, s̈ = js.ode.system_acceleration(
+                model=model,
+                data=data,
+                joint_forces=references.joint_force_references(model=model),
+                link_forces=references.link_forces(model=model, data=data),
+            )
+
+        # Convert the inertial-fixed base acceleration to a mixed base acceleration.
+        W_H_B = data.base_transform()
+        W_H_BW = W_H_B.at[0:3, 0:3].set(jnp.eye(3))
+        BW_X_W = math.Adjoint.from_transform(W_H_BW, inverse=True)
+        term1 = BW_X_W @ W_v̇_WB
+        term2 = jnp.zeros(6).at[0:3].set(jnp.cross(W_ṗ_B, W_ω_WB))
+        BW_v̇_WB = term1 - term2
+
+        BW_ν̇ = jnp.hstack([BW_v̇_WB, s̈])
+
+        return BW_ν̇
+
+    @staticmethod
+    def _linear_acceleration_of_collidable_points(
+        model: js.model.JaxSimModel,
+        data: js.data.JaxSimModelData,
+        mixed_nu_dot: jtp.ArrayLike,
+    ) -> jtp.Matrix:
+        with data.switch_velocity_representation(VelRepr.Mixed):
+            CW_J_WC_BW = js.contact.jacobian(
+                model=model,
+                data=data,
+                output_vel_repr=VelRepr.Mixed,
+            )
+            CW_J̇_WC_BW = js.contact.jacobian_derivative(
+                model=model,
+                data=data,
+                output_vel_repr=VelRepr.Mixed,
+            )
+
+            BW_ν = data.generalized_velocity()
+            BW_ν̇ = mixed_nu_dot
+
+        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)
+
+        return CW_a_WC[:, 0:3].squeeze()
+
+    @staticmethod
+    def _compute_baumgarte_stabilization_term(
+        inactive_collidable_points: jtp.ArrayLike,
+        h: jtp.ArrayLike,
+        ḣ: jtp.ArrayLike,
+        K: jtp.FloatLike,
+        D: jtp.FloatLike,
+    ) -> jtp.Array:
+        def baumgarte_stabilization(
+            inactive: jtp.BoolLike,
+            h: jtp.FloatLike,
+            ḣ: jtp.FloatLike,
+            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,
+                ),
+            )
+            return baumgarte_term
+
+        baumgarte_term = jax.vmap(
+            baumgarte_stabilization, in_axes=(0, 0, 0, None, None)
+        )(inactive_collidable_points, h, ḣ, K, D)
+
+        return baumgarte_term

jaxsim/rbda/rnea.py

@@ -1,5 +1,3 @@
-from typing import Tuple
-
 import jax
 import jax.numpy as jnp
 import jaxlie
@@ -25,7 +23,7 @@ def rnea(
     joint_accelerations: jtp.Vector | None = None,
     link_forces: jtp.Matrix | None = None,
     standard_gravity: jtp.FloatLike = StandardGravity,
-) -> Tuple[jtp.Vector, jtp.Vector]:
+) -> tuple[jtp.Vector, jtp.Vector]:
     """
     Compute inverse dynamics using the Recursive Newton-Euler Algorithm (RNEA).
 
@@ -132,12 +130,12 @@ def rnea(
     # Pass 1
     # ======
 
-    ForwardPassCarry = Tuple[jtp.Matrix, jtp.Matrix, jtp.Matrix, jtp.Matrix]
+    ForwardPassCarry = tuple[jtp.Matrix, jtp.Matrix, jtp.Matrix, jtp.Matrix]
     forward_pass_carry: ForwardPassCarry = (v, a, i_X_0, f)
 
     def forward_pass(
         carry: ForwardPassCarry, i: jtp.Int
-    ) -> Tuple[ForwardPassCarry, None]:
+    ) -> tuple[ForwardPassCarry, None]:
 
         ii = i - 1
         v, a, i_X_0, f = carry
@@ -186,12 +184,12 @@ def rnea(
 
     τ = jnp.zeros_like(s)
 
-    BackwardPassCarry = Tuple[jtp.Vector, jtp.Matrix]
+    BackwardPassCarry = tuple[jtp.Vector, jtp.Matrix]
     backward_pass_carry: BackwardPassCarry = (τ, f)
 
     def backward_pass(
         carry: BackwardPassCarry, i: jtp.Int
-    ) -> Tuple[BackwardPassCarry, None]:
+    ) -> tuple[BackwardPassCarry, None]:
 
         ii = i - 1
         τ, f = carry

jaxsim/utils/jaxsim_dataclass.py

@@ -2,8 +2,8 @@ import abc
 import contextlib
 import dataclasses
 import functools
-from collections.abc import Iterator
-from typing import Any, Callable, ClassVar, Sequence, Type
+from collections.abc import Callable, Iterator, Sequence
+from typing import Any, ClassVar
 
 import jax.flatten_util
 import jax_dataclasses
@@ -337,7 +337,7 @@ class JaxsimDataclass(abc.ABC):
         return self.flatten_fn()(self)
 
     @classmethod
-    def flatten_fn(cls: Type[Self]) -> Callable[[Self], jtp.Vector]:
+    def flatten_fn(cls: type[Self]) -> Callable[[Self], jtp.Vector]:
         """
         Return a function to flatten the object into a 1D vector.
 

jaxsim/utils/wrappers.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import Callable, Generic, TypeVar
+from collections.abc import Callable
+from typing import Generic, TypeVar
 
 import jax
 import jax_dataclasses

{jaxsim-0.4.3.dev12.dist-info → jaxsim-0.4.3.dev18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaxsim
-Version: 0.4.3.dev12
+Version: 0.4.3.dev18
 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>
@@ -65,6 +65,7 @@ Requires-Dist: jaxlib>=0.4.13
 Requires-Dist: jaxlie>=1.3.0
 Requires-Dist: jax-dataclasses>=1.4.0
 Requires-Dist: pptree
+Requires-Dist: qpax
 Requires-Dist: rod>=0.3.0
 Requires-Dist: typing-extensions; python_version < "3.12"
 Provides-Extra: all

{jaxsim-0.4.3.dev12.dist-info → jaxsim-0.4.3.dev18.dist-info}/RECORD

@@ -1,48 +1,48 @@
 jaxsim/__init__.py,sha256=ixsS4dYMPex2wOUUp_rkPnwrPhYzkRh1xO_YuMj3Cr4,2626
-jaxsim/_version.py,sha256=stkeCdRPEg1m48JEJ0ELYQnBLMkPDrdDg9UhIhuhJJE,426
+jaxsim/_version.py,sha256=SFJGfO84uy3oOc6jDmWWev6VuJIqHL3tI8_OvaYfdsA,426
 jaxsim/exceptions.py,sha256=8_h8iqL8DgNR754dR8SZiQ7361GR5V1sUk3ZuZCHw1Q,2069
-jaxsim/logging.py,sha256=c4zhwBKf9eAYAHVp62kTEllqdsZgh0K-kPKVy8L3elU,1584
+jaxsim/logging.py,sha256=STI-D_upXZYX-ZezLrlJJ0UlD5YspST0vZ_DcIwkzO4,1553
 jaxsim/typing.py,sha256=IbFx3UkEXi-cm7UBqMPi58rJAFV_HbZ9E_K4JwfNvVM,753
 jaxsim/api/__init__.py,sha256=8eV22t2S3UwNyCg8karPetG1dmX1VDBXkyv28_FwNQA,210
 jaxsim/api/com.py,sha256=m-p3EJDhpnMTlXKplfbZE_aH9NqX_VyLlAE3vUhc6l4,13642
-jaxsim/api/common.py,sha256=Ubi6uAw3o6qbdU0TFGzUyHg98EnoMzrnlihrvrs95Sk,6653
-jaxsim/api/contact.py,sha256=yBLfjT01BxEZ1lnC0WBSJZwCXK9DnW_DBJxmo9arStE,19855
-jaxsim/api/data.py,sha256=T6m7-NteWrm-K3491Yo76xvlWtFCKqTzEE7Ughcasi8,27197
-jaxsim/api/frame.py,sha256=Lsx9OIao_UZOQ6ibB_rramCRiYQbQv-M8C1QdoQdgcA,12902
-jaxsim/api/joint.py,sha256=Pvg_It2iYA-jAQ2nOlFZxwmITiozO_f46G13BdQtHQ0,5106
+jaxsim/api/common.py,sha256=SNgxq42r6eF_-aPszvOjUYkGwXOzz4hKmhDwEUkscFQ,6650
+jaxsim/api/contact.py,sha256=HyEAjF7BySDDOlRahN0l7V15IPB0HPXuoM0twamuEW0,20913
+jaxsim/api/data.py,sha256=CUh9lvhVk3_clNQ26BUBGpjvFSsK_PrVWVMEWpMdHRM,27206
+jaxsim/api/frame.py,sha256=KS8A5wRfjxhe9NgcVo2QA516iP5zky7UVnWxG7nTa7c,12911
+jaxsim/api/joint.py,sha256=L81bQe-noPT6_54KOSF7KBjRmEPAS433ULn2EcXI8vI,5115
 jaxsim/api/kin_dyn_parameters.py,sha256=CcfSg5Mc8qb1mZeMQ4AK_ffZIsK5yOl7tu397pFhcDA,29369
-jaxsim/api/link.py,sha256=GlnY7LMne-siFyg9J49IZGhiPQzS9Uk6rzQ0jI8cD_E,18622
-jaxsim/api/model.py,sha256=EdSjpKXd4N72wYjg5o0wGKFxjVMyrXg6LnlPEi3JqnU,63094
-jaxsim/api/ode.py,sha256=NnLTBvpaT4kXnbjAghXIzLv9DTMJ8bele2iOlUQDv3Q,11028
-jaxsim/api/ode_data.py,sha256=9YZX-SK_KJtoIqG-zYWZsQInb2NA_LtxDn-jtLqm_3U,19759
+jaxsim/api/link.py,sha256=qPRtc8qqMRjZxUCZYXJMygbB6huDXBfIT1b1b8Durkw,18631
+jaxsim/api/model.py,sha256=HXoqCtQ3KStGoxhgvFm8P_Sc-lbEM4l5No2MoHzNlOk,65558
+jaxsim/api/ode.py,sha256=Vb2sN4zwpXnaJDD9-ziz2qvfmfa4jvIQ0fONbBIRGmU,13368
+jaxsim/api/ode_data.py,sha256=U7F6TL6bENAxpQQl4PupPoDG7d7VfTTFqDAs3xwu6Hs,20003
 jaxsim/api/references.py,sha256=XOVKuQXRmjPoP-T5JWGSbqIGX5DzOkeGafqRpj0ZQEM,20771
 jaxsim/integrators/__init__.py,sha256=hxvOD-VK_mmd6v31wtC-nb28AYve1gLuZCNLV9wS-Kg,103
-jaxsim/integrators/common.py,sha256=GqiyKTrAozuR6RuvVWdPF7locZQAXSEDY2AjTKpFGYM,20149
+jaxsim/integrators/common.py,sha256=ntjflaV3qWaFH_E65pAGZ6QipdnFsgQDasKtIKpxTe4,20432
 jaxsim/integrators/fixed_step.py,sha256=KpjRd6hHtapxDoo6D1kyDrVDSHnke2TepI5grFH7_bM,2693
-jaxsim/integrators/variable_step.py,sha256=0FCmAZIFnhvQxVbAzNfZgCWN1yMRTGVdBm9UwwaXI1o,21280
+jaxsim/integrators/variable_step.py,sha256=5StkFh9oQba34zlkIoXG2fUN78gbxkHePWbrpQ-QZOI,21274
 jaxsim/math/__init__.py,sha256=8oPITEoGwgRcOeG8KxtqxPQ8b5uku1HNRMokpCoi9Tc,352
 jaxsim/math/adjoint.py,sha256=o1FCipkGwPtMbN2gFNIyUV8ADF3TX5fxElpTEXK0bIs,4377
 jaxsim/math/cross.py,sha256=U7yEx_l75mSy5g6O-jsjBztApvxC3WaV4MpkS5tThu4,1330
-jaxsim/math/inertia.py,sha256=UAB7ym4gXFanejcs_ovZMpteHCc6poWYmt-mLmd5hhk,1640
-jaxsim/math/joint_model.py,sha256=VZ3hRCgb0gsyI1wN1UdHkmaRMBxjAYQK1i_3WIvkdUA,9994
+jaxsim/math/inertia.py,sha256=_hNpoeyEpAGr9ExDQJjckbjhk39luJFF-jv0SKqefnQ,1614
+jaxsim/math/joint_model.py,sha256=EzAveaG5B6ZnCFNUzN30KEQUVesd83lfWXJarYR-kUw,9989
 jaxsim/math/quaternion.py,sha256=_WA7W3iv7px83sWO1V1n0-J78hqAlO4SL1-jofE-UZ4,4754
-jaxsim/math/rotation.py,sha256=Z90daUjGpuNEVLfWB3SVtM9EtwAIaneVj9A9UpWXqhA,2182
+jaxsim/math/rotation.py,sha256=k-nwT79zmWrys3NNAB-lGWxat7Kqm_6JnFRoimJ8rBg,2156
 jaxsim/math/skew.py,sha256=oOGSSR8PUGROl6IJFlrmu6K3gPH-u16hUPfKIkcVv9o,1177
 jaxsim/math/transform.py,sha256=KXzQgOnCfAtbXCwxhplpJ3F0JT3oEyeLVby1_uRAryQ,2892
 jaxsim/mujoco/__init__.py,sha256=Zo5GAlN1DYKvX8s1hu1j6HntKIbBMLB9Puv9ouaNAZ8,158
 jaxsim/mujoco/__main__.py,sha256=GBmB7J-zj75ZnFyuAAmpSOpbxi_HhHhWJeot3ljGDJY,5291
-jaxsim/mujoco/loaders.py,sha256=t9kWyvTJoMChBs8WMaZEPH1Y_smp_A9go6XT6rHcPEU,25301
-jaxsim/mujoco/model.py,sha256=ZqqHBDnB-y8ueHydD0Ujbg4ALyLUpB_6r_9r0sENQvI,16359
-jaxsim/mujoco/visualizer.py,sha256=XvMzGSHM-xnOSYl1Vk6bPe6j6ylQmJeLOgxHgL6I1nw,6966
+jaxsim/mujoco/loaders.py,sha256=XB-fgXuWMTFiaand5MZlLFQ5__Sh8MK5CJsxIU34MBk,25328
+jaxsim/mujoco/model.py,sha256=AQksXemXWACJ3yvefV2G5HLwwBU9ISoJrOD1wlxdY5w,16386
+jaxsim/mujoco/visualizer.py,sha256=T1vU-w4NKSmgEkZ0FqVcGmIvYrYO0len2UBSsU4MOZ0,6978
 jaxsim/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jaxsim/parsers/kinematic_graph.py,sha256=88d0EmndVJWdcyFJsW25S78Z8F04cUt08RQMyoil1Xw,34734
+jaxsim/parsers/kinematic_graph.py,sha256=KijMWKyhTLKSNUmOOk4sYQMgPh_OkA_brncL7gBRHaY,34757
 jaxsim/parsers/descriptions/__init__.py,sha256=PbIlunVfb59pB5jSX97YVpMAANRZPRkJ0X-hS14rzv4,221
 jaxsim/parsers/descriptions/collision.py,sha256=BQeIG-TKi4SVny23w6riDrQ5itC6VRwEMBX6HgAXHxA,3973
 jaxsim/parsers/descriptions/joint.py,sha256=VSb6C0FBBKMqwrHBKfc-Bbn4rl_J0RzUxMQlhIEvOPM,5185
 jaxsim/parsers/descriptions/link.py,sha256=Eh0W5qL7_Uw0GV-BkNKXhm9Q2dRTfIWCX5D-87zQkxA,3711
-jaxsim/parsers/descriptions/model.py,sha256=gWFJJlxsIw2bD0YI9Zvm4zXGceXaR8kO6AKsYuVbBfs,9824
+jaxsim/parsers/descriptions/model.py,sha256=I2Vsbv8Josl4Le7b5rIvhqA2k9Bbv5JxMqwytayxds0,9833
 jaxsim/parsers/rod/__init__.py,sha256=G2vqlLajBLUc4gyzXwsEI2Wsi4TMOIF9bLDFeT6KrGU,92
-jaxsim/parsers/rod/parser.py,sha256=B8fnnL3LFNfCNTTFhX_OeQZhTlRgwPFCNKcUVL94-rY,13528
+jaxsim/parsers/rod/parser.py,sha256=HskeCqDsbtwH2BDk3vfxvx391wUTVGLaUXNvBrdNo-4,13486
 jaxsim/parsers/rod/utils.py,sha256=5DsF3OeePZGidOJ5GiFSZx-51uIdnFvMW9EK6SgOW6Q,5698
 jaxsim/rbda/__init__.py,sha256=H7DhXpxkPOi9lpUvg31IMHFfRafke1UoJLc5GQIdyhA,387
 jaxsim/rbda/aba.py,sha256=w7ciyxB0IsmueatT0C7PcBQEl9dyiH9oqJgIi3xeTUE,8983
@@ -50,19 +50,20 @@ jaxsim/rbda/collidable_points.py,sha256=Rmf1DhflhOTYh9mDalv0agS0CGSbmfoOybwP2KzK
 jaxsim/rbda/crba.py,sha256=zJSiHKRvNU98z2tT9prrWR4VU9wIZQWFwEut7mua6as,5044
 jaxsim/rbda/forward_kinematics.py,sha256=2GmEoWsrioVl_SAbKRKfhOLz57pY4aR81PKRdulqStA,3458
 jaxsim/rbda/jacobian.py,sha256=p0EV_8cLzLVV-93VKznT7VPuRj8W7h7rQWkPlWJXfCA,11023
-jaxsim/rbda/rnea.py,sha256=LGXD6s3NigaVy4-WxoROjnbKLZcUoyFmS9UNu_4ldjo,7568
+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=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jaxsim/rbda/contacts/common.py,sha256=iMKLP30Qft9eGTiHo2iY-UoACJjg1JphA9_pW8wRdjc,2410
+jaxsim/rbda/contacts/common.py,sha256=VwAs742futAmLnDgbaOuLzNDBFiKDfYItdEZ4UcFgzE,2467
+jaxsim/rbda/contacts/rigid.py,sha256=8Vbnxng-ERZ5ka_eZGIBuhBDr2PNjc7m-Or255AfEw4,15862
 jaxsim/rbda/contacts/soft.py,sha256=_wvb5iZDjGcVg6rNQelN4LZN7qSC2NIp0HdKvZmlGfk,15647
 jaxsim/terrain/__init__.py,sha256=f7lVX-iNpH_wkkjef9Qpjh19TTAUOQw76EiLYJDVizc,78
 jaxsim/terrain/terrain.py,sha256=ctyNANIFSM3tZmamprjaEDcWgUSP0oNJbmT1zw9RjPs,4565
 jaxsim/utils/__init__.py,sha256=Y5zyoRevl3EMVQadhZ4EtSwTEkDt2vcnFoRhPJjKTZ0,215
-jaxsim/utils/jaxsim_dataclass.py,sha256=fLl1tY3DDb3lpIhG6BPqA5W34hM84oFzL-5cuz8k-68,11379
+jaxsim/utils/jaxsim_dataclass.py,sha256=5xJbY0G8d7C0OTNIW9T4vQxiDak6TGZT9gpNOvRykFI,11373
 jaxsim/utils/tracing.py,sha256=KDMoyVPlu2NJvFkhtZwq5AkqMMgajt3munvJom-vEjQ,650
-jaxsim/utils/wrappers.py,sha256=GOJQCJc5zwzoEGZB62wnWWGvUUQlXvDxz_A2Q-hFv7c,4027
-jaxsim-0.4.3.dev12.dist-info/LICENSE,sha256=eaYdFmdeMbiIoIiPzEK0MjP1S9wtFXjXNR5er49uLR0,1546
-jaxsim-0.4.3.dev12.dist-info/METADATA,sha256=leJKrHEEwVhS9EXQqgXwd0y3xcoCTHGw7yJM2C5oqso,17227
-jaxsim-0.4.3.dev12.dist-info/WHEEL,sha256=uCRv0ZEik_232NlR4YDw4Pv3Ajt5bKvMH13NUU7hFuI,91
-jaxsim-0.4.3.dev12.dist-info/top_level.txt,sha256=LxGMA8FLtXjQ6oI7N5gd_R_oSUHxpXxUEOfT1xS_ni0,7
-jaxsim-0.4.3.dev12.dist-info/RECORD,,
+jaxsim/utils/wrappers.py,sha256=JhLUh1g8iU-lhjbuZRfkscPZhYlLCOorVM2Xl3ulRBI,4054
+jaxsim-0.4.3.dev18.dist-info/LICENSE,sha256=eaYdFmdeMbiIoIiPzEK0MjP1S9wtFXjXNR5er49uLR0,1546
+jaxsim-0.4.3.dev18.dist-info/METADATA,sha256=aLpRkfa9CC7GVzXMKX3LY5DkCHEmOr4CE-u3Vbt5fx8,17247
+jaxsim-0.4.3.dev18.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+jaxsim-0.4.3.dev18.dist-info/top_level.txt,sha256=LxGMA8FLtXjQ6oI7N5gd_R_oSUHxpXxUEOfT1xS_ni0,7
+jaxsim-0.4.3.dev18.dist-info/RECORD,,

{jaxsim-0.4.3.dev12.dist-info → jaxsim-0.4.3.dev18.dist-info}/WHEEL

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