jaxsim 0.4.3.dev17__py3-none-any.whl → 0.4.3.dev18__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.dev17'
-__version_tuple__ = version_tuple = (0, 4, 3, 'dev17')
+__version__ = version = '0.4.3.dev18'
+__version_tuple__ = version_tuple = (0, 4, 3, 'dev18')

jaxsim/api/contact.py

@@ -114,19 +114,24 @@ def collidable_point_forces(
 
 @jax.jit
 def collidable_point_dynamics(
-    model: js.model.JaxSimModel, data: js.data.JaxSimModelData
-) -> tuple[jtp.Matrix, jtp.Matrix]:
+    model: js.model.JaxSimModel,
+    data: js.data.JaxSimModelData,
+    link_forces: jtp.MatrixLike | None = None,
+) -> tuple[jtp.Matrix, dict[str, jtp.Array]]:
     r"""
-    Compute the 6D force applied to each collidable point and the corresponding
-    material deformation rate.
+    Compute the 6D force applied to each collidable point.
 
     Args:
         model: The model to consider.
         data: The data of the considered model.
+        link_forces:
+            The 6D external forces to apply to the links expressed in the same
+            representation of data.
 
     Returns:
-        The 6D force applied to each collidable point and the corresponding
-        material deformation rate.
+        The 6D force applied to each collidable point and additional data based on the contact model configured:
+        - Soft: the material deformation rate.
+        - Rigid: nothing.
 
     Note:
         The material deformation rate is always returned in the mixed frame
@@ -138,7 +143,8 @@ def collidable_point_dynamics(
     # all collidable points belonging to the robot.
     W_p_Ci, W_ṗ_Ci = js.contact.collidable_point_kinematics(model=model, data=data)
 
-    # Import privately the soft contacts classes.
+    # Import privately the contacts classes.
+    from jaxsim.rbda.contacts.rigid import RigidContacts, RigidContactsState
     from jaxsim.rbda.contacts.soft import SoftContacts, SoftContactsState
 
     # Build the soft contact model.
@@ -161,6 +167,28 @@ def collidable_point_dynamics(
             W_f_Ci, (CW_ṁ,) = jax.vmap(soft_contacts.compute_contact_forces)(
                 W_p_Ci, W_ṗ_Ci, data.state.contact.tangential_deformation
             )
+            aux_data = dict(m_dot=CW_ṁ)
+
+        case RigidContacts():
+            assert isinstance(model.contact_model, RigidContacts)
+            assert isinstance(data.state.contact, RigidContactsState)
+
+            # Build the contact model.
+            rigid_contacts = RigidContacts(
+                parameters=data.contacts_params, terrain=model.terrain
+            )
+
+            # Compute the 6D force expressed in the inertial frame and applied to each
+            # collidable point.
+            W_f_Ci, _ = rigid_contacts.compute_contact_forces(
+                position=W_p_Ci,
+                velocity=W_ṗ_Ci,
+                model=model,
+                data=data,
+                link_forces=link_forces,
+            )
+
+            aux_data = dict()
 
         case _:
             raise ValueError(f"Invalid contact model {model.contact_model}")
@@ -175,7 +203,7 @@ def collidable_point_dynamics(
         )
     )(W_f_Ci)
 
-    return f_Ci, CW_ṁ
+    return f_Ci, aux_data
 
 
 @functools.partial(jax.jit, static_argnames=["link_names"])

jaxsim/api/model.py

@@ -14,6 +14,7 @@ import rod
 from jax_dataclasses import Static
 
 import jaxsim.api as js
+import jaxsim.exceptions
 import jaxsim.terrain
 import jaxsim.typing as jtp
 from jaxsim.math import Adjoint, Cross
@@ -1890,6 +1891,8 @@ def step(
         and the new state of the integrator.
     """
 
+    from jaxsim.rbda.contacts.rigid import RigidContacts
+
     # Extract the integrator kwargs.
     # The following logic allows using integrators having kwargs colliding with the
     # kwargs of this step function.
@@ -1901,12 +1904,12 @@ def step(
 
     # Extract the initial resources.
     t0_ns = data.time_ns
-    state_x0 = data.state
+    state_t0 = data.state
     integrator_state_x0 = integrator_state
 
     # Step the dynamics forward.
-    state_xf, integrator_state_xf = integrator.step(
-        x0=state_x0,
+    state_tf, integrator_state_tf = integrator.step(
+        x0=state_t0,
         t0=jnp.array(t0_ns / 1e9).astype(float),
         dt=dt,
         params=integrator_state_x0,
@@ -1928,11 +1931,61 @@ def step(
         ),
     )
 
-    return (
+    data_tf = (
         # Store the new state of the model and the new time.
         data.replace(
-            state=state_xf,
+            state=state_tf,
             time_ns=t0_ns + jnp.array(dt * 1e9).astype(jnp.uint64),
-        ),
-        integrator_state_xf,
+        )
+    )
+
+    # Post process the simulation state, if needed.
+    match model.contact_model:
+
+        # Rigid contact models use an impact model that produces a discontinuous model velocity.
+        # Hence here we need to reset the velocity after each impact to guarantee that
+        # the linear velocity of the active collidable points is zero.
+        case RigidContacts():
+            # Raise runtime error for not supported case in which Rigid contacts and Baumgarte stabilization
+            # enabled are used with ForwardEuler integrator.
+            jaxsim.exceptions.raise_runtime_error_if(
+                condition=jnp.logical_and(
+                    isinstance(
+                        integrator,
+                        jaxsim.integrators.fixed_step.ForwardEuler
+                        | jaxsim.integrators.fixed_step.ForwardEulerSO3,
+                    ),
+                    jnp.array(
+                        [data_tf.contacts_params.K, data_tf.contacts_params.D]
+                    ).any(),
+                ),
+                msg="Baumgarte stabilization is not supported with ForwardEuler integrators",
+            )
+
+            with data_tf.switch_velocity_representation(VelRepr.Mixed):
+                W_p_C = js.contact.collidable_point_positions(model, data_tf)
+                M = js.model.free_floating_mass_matrix(model, data_tf)
+                J_WC = js.contact.jacobian(model, data_tf)
+                px, py, _ = W_p_C.T
+                terrain_height = jax.vmap(model.terrain.height)(px, py)
+                inactive_collidable_points, _ = RigidContacts.detect_contacts(
+                    W_p_C=W_p_C,
+                    terrain_height=terrain_height,
+                )
+                BW_nu_post_impact = RigidContacts.compute_impact_velocity(
+                    data=data_tf,
+                    inactive_collidable_points=inactive_collidable_points,
+                    M=M,
+                    J_WC=J_WC,
+                )
+                data_tf = data_tf.reset_base_velocity(BW_nu_post_impact[0:6])
+                data_tf = data_tf.reset_joint_velocities(BW_nu_post_impact[6:])
+            # Restore the input velocity representation.
+            data_tf = data_tf.replace(
+                velocity_representation=data.velocity_representation, validate=False
+            )
+
+    return (
+        data_tf,
+        integrator_state_tf,
     )

jaxsim/api/ode.py

@@ -50,7 +50,7 @@ def wrap_system_dynamics_for_integration(
     # The wrapped dynamics will hold a reference of this object.
     model_closed = model.copy()
     data_closed = data.copy().replace(
-        state=js.ode_data.ODEState.zero(model=model_closed)
+        state=js.ode_data.ODEState.zero(model=model_closed, data=data)
     )
 
     def f(x: ODEState, t: Time, **kwargs_f) -> tuple[ODEState, dict[str, Any]]:
@@ -88,7 +88,7 @@ def system_velocity_dynamics(
     *,
     joint_forces: jtp.Vector | None = None,
     link_forces: jtp.Vector | None = None,
-) -> tuple[jtp.Vector, jtp.Vector, jtp.Matrix, dict[str, Any]]:
+) -> tuple[jtp.Vector, jtp.Vector, dict[str, Any]]:
     """
     Compute the dynamics of the system velocity.
 
@@ -102,18 +102,10 @@ def system_velocity_dynamics(
 
     Returns:
         A tuple containing the derivative of the base 6D velocity in inertial-fixed
-        representation, the derivative of the joint velocities, the derivative of
-        the material deformation, and the dictionary of auxiliary data returned by
-        the system dynamics evaluation.
+        representation, the derivative of the joint velocities, and auxiliary data
+        returned by the system dynamics evaluation.
     """
 
-    # Build joint torques if not provided.
-    τ = (
-        jnp.atleast_1d(joint_forces.squeeze())
-        if joint_forces is not None
-        else jnp.zeros_like(data.joint_positions())
-    ).astype(float)
-
     # Build link forces if not provided.
     # These forces are expressed in the frame corresponding to the velocity
     # representation of data.
@@ -123,6 +115,15 @@ def system_velocity_dynamics(
         else jnp.zeros((model.number_of_links(), 6))
     ).astype(float)
 
+    # We expect that the 6D forces included in the `link_forces` argument are expressed
+    # in the frame corresponding to the velocity representation of `data`.
+    references = js.references.JaxSimModelReferences.build(
+        model=model,
+        link_forces=O_f_L,
+        data=data,
+        velocity_representation=data.velocity_representation,
+    )
+
     # ======================
     # Compute contact forces
     # ======================
@@ -131,19 +132,17 @@ def system_velocity_dynamics(
     # with the terrain.
     W_f_Li_terrain = jnp.zeros_like(O_f_L).astype(float)
 
-    # Import privately the soft contacts classes.
-    from jaxsim.rbda.contacts.soft import SoftContactsState
-
-    # Initialize the derivative of the tangential deformation ṁ ∈ ℝ^{n_c × 3}.
-    assert isinstance(data.state.contact, SoftContactsState)
-    ṁ = jnp.zeros_like(data.state.contact.tangential_deformation).astype(float)
-
+    aux_data = {}
     if len(model.kin_dyn_parameters.contact_parameters.body) > 0:
 
         # Compute the 6D forces W_f ∈ ℝ^{n_c × 6} applied to each collidable point
-        #  and the corresponding material deformation rates.
+        # along with contact-specific auxiliary states.
         with data.switch_velocity_representation(VelRepr.Inertial):
-            W_f_Ci, ṁ = js.contact.collidable_point_dynamics(model=model, data=data)
+            W_f_Ci, aux_data = js.contact.collidable_point_dynamics(
+                model=model,
+                data=data,
+                link_forces=references.link_forces(model=model, data=data),
+            )
 
         # Construct the vector defining the parent link index of each collidable point.
         # We use this vector to sum the 6D forces of all collidable points rigidly
@@ -161,6 +160,74 @@ def system_velocity_dynamics(
 
         W_f_Li_terrain = mask.T @ W_f_Ci
 
+    # ===========================
+    # Compute system acceleration
+    # ===========================
+
+    # Compute the total link forces
+    with (
+        data.switch_velocity_representation(VelRepr.Inertial),
+        references.switch_velocity_representation(VelRepr.Inertial),
+    ):
+        references = references.apply_link_forces(
+            model=model,
+            data=data,
+            forces=W_f_Li_terrain,
+            additive=True,
+        )
+    # Get the link forces in the data representation
+    with references.switch_velocity_representation(data.velocity_representation):
+        f_L_total = references.link_forces(model=model, data=data)
+
+    # The following method always returns the inertial-fixed acceleration, and expects
+    # the link_forces expressed in the inertial frame.
+    W_v̇_WB, s̈ = system_acceleration(
+        model=model, data=data, joint_forces=joint_forces, link_forces=f_L_total
+    )
+
+    return W_v̇_WB, s̈, aux_data
+
+
+def system_acceleration(
+    model: js.model.JaxSimModel,
+    data: js.data.JaxSimModelData,
+    *,
+    joint_forces: jtp.VectorLike | None = None,
+    link_forces: jtp.MatrixLike | None = None,
+) -> tuple[jtp.Vector, jtp.Vector]:
+    """
+    Compute the system acceleration in inertial-fixed representation.
+
+    Args:
+        model: The model to consider.
+        data: The data of the considered model.
+        joint_forces: The joint forces to apply.
+        link_forces:
+            The 6D forces to apply to the links expressed in the same representation of data.
+
+    Returns:
+        A tuple containing the base 6D acceleration in inertial-fixed representation
+        and the joint accelerations.
+    """
+
+    # ====================
+    # Validate input data
+    # ====================
+
+    # Build link forces if not provided.
+    f_L = (
+        jnp.atleast_2d(link_forces.squeeze())
+        if link_forces is not None
+        else jnp.zeros((model.number_of_links(), 6))
+    ).astype(float)
+
+    # Build joint torques if not provided.
+    τ = (
+        jnp.atleast_1d(joint_forces.squeeze())
+        if joint_forces is not None
+        else jnp.zeros_like(data.joint_positions())
+    ).astype(float)
+
     # ====================
     # Enforce joint limits
     # ====================
@@ -198,29 +265,25 @@ def system_velocity_dynamics(
 
     references = js.references.JaxSimModelReferences.build(
         model=model,
-        joint_force_references=τ_total,
-        link_forces=O_f_L,
         data=data,
         velocity_representation=data.velocity_representation,
+        joint_force_references=τ_total,
+        link_forces=f_L,
     )
 
-    with references.switch_velocity_representation(VelRepr.Inertial):
-        W_f_L = references.link_forces(model=model, data=data)
-
-    # Compute the total external 6D forces applied to the links.
-    W_f_L_total = W_f_L + W_f_Li_terrain
-
     # - Joint accelerations: s̈ ∈ ℝⁿ
     # - Base inertial-fixed acceleration: W_v̇_WB = (W_p̈_B, W_ω̇_B) ∈ ℝ⁶
-    with data.switch_velocity_representation(velocity_representation=VelRepr.Inertial):
+    with (
+        data.switch_velocity_representation(velocity_representation=VelRepr.Inertial),
+        references.switch_velocity_representation(VelRepr.Inertial),
+    ):
         W_v̇_WB, s̈ = js.model.forward_dynamics_aba(
             model=model,
             data=data,
-            joint_forces=τ_total,
-            link_forces=W_f_L_total,
+            joint_forces=references.joint_force_references(),
+            link_forces=references.link_forces(),
         )
-
-    return W_v̇_WB, s̈, ṁ, dict()
+    return W_v̇_WB, s̈
 
 
 @jax.jit
@@ -291,14 +354,29 @@ def system_dynamics(
         by the system dynamics evaluation.
     """
 
+    from jaxsim.rbda.contacts.rigid import RigidContacts
+    from jaxsim.rbda.contacts.soft import SoftContacts
+
     # Compute the accelerations and the material deformation rate.
-    W_v̇_WB, s̈, ṁ, aux_dict = system_velocity_dynamics(
+    W_v̇_WB, s̈, aux_dict = system_velocity_dynamics(
         model=model,
         data=data,
         joint_forces=joint_forces,
         link_forces=link_forces,
     )
 
+    ode_state_kwargs = {}
+
+    match model.contact_model:
+        case SoftContacts():
+            ode_state_kwargs["tangential_deformation"] = aux_dict["m_dot"]
+
+        case RigidContacts():
+            pass
+
+        case _:
+            raise ValueError("Unable to determine contact state class prefix.")
+
     # Extract the velocities.
     W_ṗ_B, W_Q̇_B, ṡ = system_position_dynamics(
         model=model,
@@ -317,7 +395,7 @@ def system_dynamics(
         base_linear_velocity=W_v̇_WB[0:3],
         base_angular_velocity=W_v̇_WB[3:6],
         joint_velocities=s̈,
-        tangential_deformation=ṁ,
+        **ode_state_kwargs,
     )
 
     return ode_state_derivative, aux_dict

jaxsim/api/ode_data.py

@@ -6,6 +6,7 @@ import jax_dataclasses
 import jaxsim.api as js
 import jaxsim.typing as jtp
 from jaxsim.rbda import ContactsState
+from jaxsim.rbda.contacts.rigid import RigidContacts, RigidContactsState
 from jaxsim.rbda.contacts.soft import SoftContacts, SoftContactsState
 from jaxsim.utils import JaxsimDataclass
 
@@ -133,7 +134,7 @@ class ODEState(JaxsimDataclass):
         base_quaternion: jtp.Vector | None = None,
         base_linear_velocity: jtp.Vector | None = None,
         base_angular_velocity: jtp.Vector | None = None,
-        tangential_deformation: jtp.Matrix | None = None,
+        **kwargs,
     ) -> ODEState:
         """
         Build an `ODEState` from a `JaxSimModel`.
@@ -148,9 +149,7 @@ class ODEState(JaxsimDataclass):
                 The linear velocity of the base link in inertial-fixed representation.
             base_angular_velocity:
                 The angular velocity of the base link in inertial-fixed representation.
-            tangential_deformation:
-                The matrix of 3D tangential material deformations corresponding to
-                each collidable point.
+            kwargs: Additional arguments needed to build the contact state.
 
         Returns:
             The `ODEState` built from the `JaxSimModel`.
@@ -163,6 +162,7 @@ class ODEState(JaxsimDataclass):
         # Get the contact model from the `JaxSimModel`.
         match model.contact_model:
             case SoftContacts():
+                tangential_deformation = kwargs.get("tangential_deformation", None)
                 contact = SoftContactsState.build_from_jaxsim_model(
                     model=model,
                     **(
@@ -171,6 +171,8 @@ class ODEState(JaxsimDataclass):
                         else dict()
                     ),
                 )
+            case RigidContacts():
+                contact = RigidContactsState.build()
             case _:
                 raise ValueError("Unable to determine contact state class prefix.")
 
@@ -214,7 +216,7 @@ class ODEState(JaxsimDataclass):
 
         # Get the contact model from the `JaxSimModel`.
         match contact:
-            case SoftContactsState():
+            case SoftContactsState() | RigidContactsState():
                 pass
             case None:
                 contact = SoftContactsState.zero(model=model)
@@ -224,7 +226,7 @@ class ODEState(JaxsimDataclass):
         return ODEState(physics_model=physics_model_state, contact=contact)
 
     @staticmethod
-    def zero(model: js.model.JaxSimModel) -> ODEState:
+    def zero(model: js.model.JaxSimModel, data: js.data.JaxSimModelData) -> ODEState:
         """
         Build a zero `ODEState` from a `JaxSimModel`.
 
@@ -235,7 +237,9 @@ class ODEState(JaxsimDataclass):
             A zero `ODEState` instance.
         """
 
-        model_state = ODEState.build(model=model)
+        model_state = ODEState.build(
+            model=model, contact=data.state.contact.zero(model=model)
+        )
 
         return model_state
 

jaxsim/integrators/common.py

@@ -109,11 +109,14 @@ class Integrator(JaxsimDataclass, abc.ABC, Generic[State, StateDerivative]):
             integrator.params = params
 
         with integrator.mutable_context(mutability=Mutability.MUTABLE):
-            xf = integrator(x0, t0, dt, **kwargs)
+            xf, aux_dict = integrator(x0, t0, dt, **kwargs)
 
-        return xf, integrator.params | {
-            Integrator.AfterInitKey: jnp.array(False).astype(bool)
-        }
+        return (
+            xf,
+            integrator.params
+            | {Integrator.AfterInitKey: jnp.array(False).astype(bool)}
+            | aux_dict,
+        )
 
     @abc.abstractmethod
     def __call__(self, x0: State, t0: Time, dt: TimeStep, **kwargs) -> NextState:
@@ -277,15 +280,19 @@ class ExplicitRungeKutta(Integrator[PyTreeType, PyTreeType], Generic[PyTreeType]
 
         return integrator
 
-    def __call__(self, x0: State, t0: Time, dt: TimeStep, **kwargs) -> NextState:
+    def __call__(
+        self, x0: State, t0: Time, dt: TimeStep, **kwargs
+    ) -> tuple[NextState, dict[str, Any]]:
 
         # Here z is a batched state with as many batch elements as b.T rows.
         # Note that z has multiple batches only if b.T has more than one row,
         # e.g. in Butcher tableau of embedded schemes.
-        z = self._compute_next_state(x0=x0, t0=t0, dt=dt, **kwargs)
+        z, aux_dict = self._compute_next_state(x0=x0, t0=t0, dt=dt, **kwargs)
 
         # The next state is the batch element located at the configured index of solution.
-        return jax.tree_util.tree_map(lambda l: l[self.row_index_of_solution], z)
+        next_state = jax.tree_util.tree_map(lambda l: l[self.row_index_of_solution], z)
+
+        return next_state, aux_dict
 
     @classmethod
     def integrate_rk_stage(
@@ -343,7 +350,7 @@ class ExplicitRungeKutta(Integrator[PyTreeType, PyTreeType], Generic[PyTreeType]
 
     def _compute_next_state(
         self, x0: State, t0: Time, dt: TimeStep, **kwargs
-    ) -> NextState:
+    ) -> tuple[NextState, dict[str, Any]]:
         """
         Compute the next state of the system, returning all the output states.
 
@@ -373,19 +380,21 @@ class ExplicitRungeKutta(Integrator[PyTreeType, PyTreeType], Generic[PyTreeType]
         )
 
         # Apply FSAL property by passing ẋ0 = f(x0, t0) from the previous iteration.
-        get_ẋ0 = lambda: self.params.get("dxdt0", f(x0, t0)[0])
+        get_ẋ0_and_aux_dict = lambda: self.params.get("dxdt0", f(x0, t0))
 
         # We use a `jax.lax.scan` to compile the `f` function only once.
         # Otherwise, if we compute e.g. for RK4 sequentially, the jit-compiled code
         # would include 4 repetitions of the `f` logic, making everything extremely slow.
-        def scan_body(carry: jax.Array, i: int | jax.Array) -> tuple[jax.Array, None]:
+        def scan_body(
+            carry: jax.Array, i: int | jax.Array
+        ) -> tuple[jax.Array, dict[str, Any]]:
             """"""
 
             # Unpack the carry, i.e. the stacked kᵢ vectors.
             K = carry
 
             # Define the computation of the Runge-Kutta stage.
-            def compute_ki() -> jax.Array:
+            def compute_ki() -> tuple[jax.Array, dict[str, Any]]:
 
                 # Compute ∑ⱼ aᵢⱼ kⱼ.
                 op_sum_ak = lambda k: jnp.einsum("s,s...->...", A[i], k)
@@ -398,13 +407,13 @@ class ExplicitRungeKutta(Integrator[PyTreeType, PyTreeType], Generic[PyTreeType]
                 # Compute the next time for the kᵢ evaluation.
                 ti = t0 + c[i] * Δt
 
-                # This is kᵢ = f(xᵢ, tᵢ).
-                return f(xi, ti)[0]
+                # This is kᵢ, aux_dict = f(xᵢ, tᵢ).
+                return f(xi, ti)
 
             # This selector enables FSAL property in the first iteration (i=0).
-            ki = jax.lax.cond(
+            ki, aux_dict = jax.lax.cond(
                 pred=jnp.logical_and(i == 0, self.has_fsal),
-                true_fun=get_ẋ0,
+                true_fun=get_ẋ0_and_aux_dict,
                 false_fun=compute_ki,
             )
 
@@ -413,10 +422,10 @@ class ExplicitRungeKutta(Integrator[PyTreeType, PyTreeType], Generic[PyTreeType]
             K = jax.tree_util.tree_map(op, K, ki)
 
             carry = K
-            return carry, None
+            return carry, aux_dict
 
         # Compute the state derivatives kᵢ.
-        K, _ = jax.lax.scan(
+        K, aux_dict = jax.lax.scan(
             f=scan_body,
             init=carry0,
             xs=jnp.arange(c.size),
@@ -439,7 +448,7 @@ class ExplicitRungeKutta(Integrator[PyTreeType, PyTreeType], Generic[PyTreeType]
             lambda xf: self.post_process_state(x0=x0, t0=t0, xf=xf, dt=dt)
         )(z)
 
-        return z_transformed
+        return z_transformed, aux_dict
 
     @staticmethod
     def butcher_tableau_is_valid(

jaxsim/rbda/contacts/common.py

@@ -5,6 +5,7 @@ from typing import Any
 
 import jaxsim.terrain
 import jaxsim.typing as jtp
+from jaxsim.utils import JaxsimDataclass
 
 
 class ContactsState(abc.ABC):
@@ -42,7 +43,7 @@ class ContactsState(abc.ABC):
         pass
 
 
-class ContactsParams(abc.ABC):
+class ContactsParams(JaxsimDataclass):
     """
     Abstract class representing the parameters of a contact model.
     """
@@ -67,7 +68,7 @@ class ContactsParams(abc.ABC):
         pass
 
 
-class ContactModel(abc.ABC):
+class ContactModel(JaxsimDataclass):
     """
     Abstract class representing a contact model.
 

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-0.4.3.dev17.dist-info → jaxsim-0.4.3.dev18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaxsim
-Version: 0.4.3.dev17
+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.dev17.dist-info → jaxsim-0.4.3.dev18.dist-info}/RECORD

@@ -1,23 +1,23 @@
 jaxsim/__init__.py,sha256=ixsS4dYMPex2wOUUp_rkPnwrPhYzkRh1xO_YuMj3Cr4,2626
-jaxsim/_version.py,sha256=fl1A3KE70N9IF6eJ3t04zIPwnzaTgzXV-7IhkEmXc24,426
+jaxsim/_version.py,sha256=SFJGfO84uy3oOc6jDmWWev6VuJIqHL3tI8_OvaYfdsA,426
 jaxsim/exceptions.py,sha256=8_h8iqL8DgNR754dR8SZiQ7361GR5V1sUk3ZuZCHw1Q,2069
 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=SNgxq42r6eF_-aPszvOjUYkGwXOzz4hKmhDwEUkscFQ,6650
-jaxsim/api/contact.py,sha256=Ff3rOYm-o4Atxipzd4VvsnqFVg1-lfV1zFPXJU3MZKM,19847
+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=qPRtc8qqMRjZxUCZYXJMygbB6huDXBfIT1b1b8Durkw,18631
-jaxsim/api/model.py,sha256=gU44Cvn5ceYr37jsgWC6rMiRYT7rI0D7I1jf7v-yLLw,63121
-jaxsim/api/ode.py,sha256=NnLTBvpaT4kXnbjAghXIzLv9DTMJ8bele2iOlUQDv3Q,11028
-jaxsim/api/ode_data.py,sha256=9YZX-SK_KJtoIqG-zYWZsQInb2NA_LtxDn-jtLqm_3U,19759
+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=Hg_HaFDrlDjG1zmtSTRPuw0ds8wcaLkt5PBFyKhkZWg,20143
+jaxsim/integrators/common.py,sha256=ntjflaV3qWaFH_E65pAGZ6QipdnFsgQDasKtIKpxTe4,20432
 jaxsim/integrators/fixed_step.py,sha256=KpjRd6hHtapxDoo6D1kyDrVDSHnke2TepI5grFH7_bM,2693
 jaxsim/integrators/variable_step.py,sha256=5StkFh9oQba34zlkIoXG2fUN78gbxkHePWbrpQ-QZOI,21274
 jaxsim/math/__init__.py,sha256=8oPITEoGwgRcOeG8KxtqxPQ8b5uku1HNRMokpCoi9Tc,352
@@ -53,7 +53,8 @@ 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=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
@@ -61,8 +62,8 @@ jaxsim/utils/__init__.py,sha256=Y5zyoRevl3EMVQadhZ4EtSwTEkDt2vcnFoRhPJjKTZ0,215
 jaxsim/utils/jaxsim_dataclass.py,sha256=5xJbY0G8d7C0OTNIW9T4vQxiDak6TGZT9gpNOvRykFI,11373
 jaxsim/utils/tracing.py,sha256=KDMoyVPlu2NJvFkhtZwq5AkqMMgajt3munvJom-vEjQ,650
 jaxsim/utils/wrappers.py,sha256=JhLUh1g8iU-lhjbuZRfkscPZhYlLCOorVM2Xl3ulRBI,4054
-jaxsim-0.4.3.dev17.dist-info/LICENSE,sha256=eaYdFmdeMbiIoIiPzEK0MjP1S9wtFXjXNR5er49uLR0,1546
-jaxsim-0.4.3.dev17.dist-info/METADATA,sha256=st7RonsEdp_bRhPTTjJRZVj4GISB2k_gL4T7v3tBqIw,17227
-jaxsim-0.4.3.dev17.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
-jaxsim-0.4.3.dev17.dist-info/top_level.txt,sha256=LxGMA8FLtXjQ6oI7N5gd_R_oSUHxpXxUEOfT1xS_ni0,7
-jaxsim-0.4.3.dev17.dist-info/RECORD,,
+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,,