jaxsim 0.4.3.dev231__py3-none-any.whl → 0.4.3.dev245__py3-none-any.whl

jaxsim/rbda/contacts/common.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import abc
 import functools
-from typing import Any
 
 import jax
 import jax.numpy as jnp
@@ -10,6 +9,7 @@ import jax.numpy as jnp
 import jaxsim.api as js
 import jaxsim.terrain
 import jaxsim.typing as jtp
+from jaxsim.api.common import ModelDataWithVelocityRepresentation
 from jaxsim.utils import JaxsimDataclass
 
 try:
@@ -131,7 +131,7 @@ class ContactModel(JaxsimDataclass):
         model: js.model.JaxSimModel,
         data: js.data.JaxSimModelData,
         **kwargs,
-    ) -> tuple[jtp.Matrix, tuple[Any, ...]]:
+    ) -> tuple[jtp.Matrix, dict[str, jtp.PyTree]]:
         """
         Compute the contact forces.
 
@@ -142,11 +142,145 @@ class ContactModel(JaxsimDataclass):
         Returns:
             A tuple containing as first element the computed 6D contact force applied to
             the contact points and expressed in the world frame, and as second element
-            a tuple of optional additional information.
+            a dictionary of optional additional information.
         """
 
         pass
 
+    def compute_link_contact_forces(
+        self,
+        model: js.model.JaxSimModel,
+        data: js.data.JaxSimModelData,
+        **kwargs,
+    ) -> tuple[jtp.Matrix, dict[str, jtp.PyTree]]:
+        """
+        Compute the link contact forces.
+
+        Args:
+            model: The robot model considered by the contact model.
+            data: The data of the considered model.
+
+        Returns:
+            A tuple containing as first element the 6D contact force applied to the
+            links and expressed in the frame of the velocity representation of data,
+            and as second element a dictionary of optional additional information.
+        """
+
+        # Compute the contact forces expressed in the inertial frame.
+        # This function, contrarily to `compute_contact_forces`, already handles how
+        # the optional kwargs should be passed to the specific contact models.
+        W_f_C, aux_dict = js.contact.collidable_point_dynamics(
+            model=model, data=data, **kwargs
+        )
+
+        # Compute the 6D forces applied to the links equivalent to the forces applied
+        # to the frames associated to the collidable points.
+        with data.switch_velocity_representation(jaxsim.VelRepr.Inertial):
+
+            W_f_L = self.link_forces_from_contact_forces(
+                model=model, data=data, contact_forces=W_f_C
+            )
+
+        # Store the link forces in the references object for easy conversion.
+        references = js.references.JaxSimModelReferences.build(
+            model=model,
+            data=data,
+            link_forces=W_f_L,
+            velocity_representation=jaxsim.VelRepr.Inertial,
+        )
+
+        # Convert the link forces to the frame corresponding to the velocity
+        # representation of data.
+        with references.switch_velocity_representation(data.velocity_representation):
+            f_L = references.link_forces(model=model, data=data)
+
+        return f_L, aux_dict
+
+    @staticmethod
+    def link_forces_from_contact_forces(
+        model: js.model.JaxSimModel,
+        data: js.data.JaxSimModelData,
+        *,
+        contact_forces: jtp.MatrixLike,
+    ) -> jtp.Matrix:
+        """
+        Compute the link forces from the contact forces.
+
+        Args:
+            model: The robot model considered by the contact model.
+            data: The data of the considered model.
+            contact_forces: The contact forces computed by the contact model.
+
+        Returns:
+            The 6D contact forces applied to the links and expressed in the frame of
+            the velocity representation of data.
+        """
+
+        # Convert the contact forces to a JAX array.
+        f_C = jnp.atleast_2d(jnp.array(contact_forces, dtype=float).squeeze())
+
+        # Get the pose of the enabled collidable points.
+        W_H_C = js.contact.transforms(model=model, data=data)
+
+        # Convert the contact forces to inertial-fixed representation.
+        W_f_C = jax.vmap(
+            lambda f_C, W_H_C: (
+                ModelDataWithVelocityRepresentation.other_representation_to_inertial(
+                    array=f_C,
+                    other_representation=data.velocity_representation,
+                    transform=W_H_C,
+                    is_force=True,
+                )
+            )
+        )(f_C, W_H_C)
+
+        # Get the object storing the contact parameters of the model.
+        contact_parameters = model.kin_dyn_parameters.contact_parameters
+
+        # Extract the indices corresponding to the enabled collidable points.
+        indices_of_enabled_collidable_points = (
+            contact_parameters.indices_of_enabled_collidable_points
+        )
+
+        # 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
+        # attached to the same link.
+        parent_link_index_of_collidable_points = jnp.array(
+            contact_parameters.body, dtype=int
+        )[indices_of_enabled_collidable_points]
+
+        # Create the mask that associate each collidable point to their parent link.
+        # We use this mask to sum the collidable points to the right link.
+        mask = parent_link_index_of_collidable_points[:, jnp.newaxis] == jnp.arange(
+            model.number_of_links()
+        )
+
+        # Sum the forces of all collidable points rigidly attached to a body.
+        # Since the contact forces W_f_C are expressed in the world frame,
+        # we don't need any coordinate transformation.
+        W_f_L = mask.T @ W_f_C
+
+        # Compute the link transforms.
+        W_H_L = (
+            js.model.forward_kinematics(model=model, data=data)
+            if data.velocity_representation is not jaxsim.VelRepr.Inertial
+            else jnp.zeros(shape=(model.number_of_links(), 4, 4))
+        )
+
+        # Convert the inertial-fixed link forces to the velocity representation of data.
+        f_L = jax.vmap(
+            lambda W_f_L, W_H_L: (
+                ModelDataWithVelocityRepresentation.inertial_to_other_representation(
+                    array=W_f_L,
+                    other_representation=data.velocity_representation,
+                    transform=W_H_L,
+                    is_force=True,
+                )
+            )
+        )(W_f_L, W_H_L)
+
+        return f_L
+
     @classmethod
     def zero_state_variables(cls, model: js.model.JaxSimModel) -> dict[str, jtp.Array]:
         """

jaxsim/rbda/contacts/relaxed_rigid.py

@@ -120,19 +120,44 @@ class RelaxedRigidContactsParams(common.ContactsParams):
 
         return cls(
             time_constant=jnp.array(
-                time_constant or default("time_constant"), dtype=float
+                (
+                    time_constant
+                    if time_constant is not None
+                    else default("time_constant")
+                ),
+                dtype=float,
             ),
             damping_coefficient=jnp.array(
-                damping_coefficient or default("damping_coefficient"), dtype=float
+                (
+                    damping_coefficient
+                    if damping_coefficient is not None
+                    else default("damping_coefficient")
+                ),
+                dtype=float,
+            ),
+            d_min=jnp.array(
+                d_min if d_min is not None else default("d_min"), dtype=float
+            ),
+            d_max=jnp.array(
+                d_max if d_max is not None else default("d_max"), dtype=float
+            ),
+            width=jnp.array(
+                width if width is not None else default("width"), dtype=float
+            ),
+            midpoint=jnp.array(
+                midpoint if midpoint is not None else default("midpoint"), dtype=float
             ),
-            d_min=jnp.array(d_min or default("d_min"), dtype=float),
-            d_max=jnp.array(d_max or default("d_max"), dtype=float),
-            width=jnp.array(width or default("width"), dtype=float),
-            midpoint=jnp.array(midpoint or default("midpoint"), dtype=float),
-            power=jnp.array(power or default("power"), dtype=float),
-            stiffness=jnp.array(stiffness or default("stiffness"), dtype=float),
-            damping=jnp.array(damping or default("damping"), dtype=float),
-            mu=jnp.array(mu or default("mu"), dtype=float),
+            power=jnp.array(
+                power if power is not None else default("power"), dtype=float
+            ),
+            stiffness=jnp.array(
+                stiffness if stiffness is not None else default("stiffness"),
+                dtype=float,
+            ),
+            damping=jnp.array(
+                damping if damping is not None else default("damping"), dtype=float
+            ),
+            mu=jnp.array(mu if mu is not None else default("mu"), dtype=float),
         )
 
     def valid(self) -> jtp.BoolLike:
@@ -210,7 +235,9 @@ class RelaxedRigidContacts(common.ContactModel):
 
         # Create the solver options to set by combining the default solver options
         # with the user-provided solver options.
-        solver_options = default_solver_options | (solver_options or {})
+        solver_options = default_solver_options | (
+            solver_options if solver_options is not None else {}
+        )
 
         # Make sure that the solver options are hashable.
         # We need to check this because the solver options are static.
@@ -223,9 +250,15 @@ class RelaxedRigidContacts(common.ContactModel):
 
         return cls(
             parameters=(
-                parameters or cls.__dataclass_fields__["parameters"].default_factory()
+                parameters
+                if parameters is not None
+                else cls.__dataclass_fields__["parameters"].default_factory()
+            ),
+            terrain=(
+                terrain
+                if terrain is not None
+                else cls.__dataclass_fields__["terrain"].default_factory()
             ),
-            terrain=terrain or cls.__dataclass_fields__["terrain"].default_factory(),
             _solver_options_keys=tuple(solver_options.keys()),
             _solver_options_values=tuple(solver_options.values()),
         )
@@ -238,7 +271,7 @@ class RelaxedRigidContacts(common.ContactModel):
         *,
         link_forces: jtp.MatrixLike | None = None,
         joint_force_references: jtp.VectorLike | None = None,
-    ) -> tuple[jtp.Matrix, tuple]:
+    ) -> tuple[jtp.Matrix, dict[str, jtp.PyTree]]:
         """
         Compute the contact forces.
 
@@ -458,7 +491,7 @@ class RelaxedRigidContacts(common.ContactModel):
             ),
         )(CW_fl_C, W_H_C)
 
-        return W_f_C, ()
+        return W_f_C, {}
 
     @staticmethod
     def _regularizers(

jaxsim/rbda/contacts/rigid.py

@@ -66,9 +66,17 @@ class RigidContactsParams(ContactsParams):
         """Create a `RigidContactParams` instance"""
 
         return cls(
-            mu=mu or cls.__dataclass_fields__["mu"].default,
-            K=K or cls.__dataclass_fields__["K"].default,
-            D=D or cls.__dataclass_fields__["D"].default,
+            mu=jnp.array(
+                mu
+                if mu is not None
+                else cls.__dataclass_fields__["mu"].default_factory()
+            ).astype(float),
+            K=jnp.array(
+                K if K is not None else cls.__dataclass_fields__["K"].default_factory()
+            ).astype(float),
+            D=jnp.array(
+                D if D is not None else cls.__dataclass_fields__["D"].default_factory()
+            ).astype(float),
         )
 
     def valid(self) -> jtp.BoolLike:
@@ -147,7 +155,9 @@ class RigidContacts(ContactModel):
 
         # Create the solver options to set by combining the default solver options
         # with the user-provided solver options.
-        solver_options = default_solver_options | (solver_options or {})
+        solver_options = default_solver_options | (
+            solver_options if solver_options is not None else {}
+        )
 
         # Make sure that the solver options are hashable.
         # We need to check this because the solver options are static.
@@ -160,12 +170,19 @@ class RigidContacts(ContactModel):
 
         return cls(
             parameters=(
-                parameters or cls.__dataclass_fields__["parameters"].default_factory()
+                parameters
+                if parameters is not None
+                else cls.__dataclass_fields__["parameters"].default_factory()
+            ),
+            terrain=(
+                terrain
+                if terrain is not None
+                else cls.__dataclass_fields__["terrain"].default_factory()
             ),
-            terrain=terrain or cls.__dataclass_fields__["terrain"].default_factory(),
             regularization_delassus=float(
                 regularization_delassus
-                or cls.__dataclass_fields__["regularization_delassus"].default
+                if regularization_delassus is not None
+                else cls.__dataclass_fields__["regularization_delassus"].default
             ),
             _solver_options_keys=tuple(solver_options.keys()),
             _solver_options_values=tuple(solver_options.values()),
@@ -242,7 +259,7 @@ class RigidContacts(ContactModel):
         *,
         link_forces: jtp.MatrixLike | None = None,
         joint_force_references: jtp.VectorLike | None = None,
-    ) -> tuple[jtp.Matrix, tuple]:
+    ) -> tuple[jtp.Matrix, dict[str, jtp.PyTree]]:
         """
         Compute the contact forces.
 
@@ -402,7 +419,7 @@ class RigidContacts(ContactModel):
             ),
         )(CW_fl_C, W_H_C)
 
-        return W_f_C, ()
+        return W_f_C, {}
 
     @staticmethod
     def _delassus_matrix(

jaxsim/rbda/contacts/soft.py

@@ -237,9 +237,13 @@ class SoftContacts(common.ContactModel):
                 else cls.__dataclass_fields__["parameters"].default_factory()
             )
 
-        return SoftContacts(
+        return cls(
             parameters=parameters,
-            terrain=terrain or cls.__dataclass_fields__["terrain"].default_factory(),
+            terrain=(
+                terrain
+                if terrain is not None
+                else cls.__dataclass_fields__["terrain"].default_factory()
+            ),
         )
 
     @classmethod
@@ -423,7 +427,7 @@ class SoftContacts(common.ContactModel):
         self,
         model: js.model.JaxSimModel,
         data: js.data.JaxSimModelData,
-    ) -> tuple[jtp.Matrix, tuple[jtp.Matrix]]:
+    ) -> tuple[jtp.Matrix, dict[str, jtp.PyTree]]:
         """
         Compute the contact forces.
 
@@ -433,7 +437,7 @@ class SoftContacts(common.ContactModel):
 
         Returns:
             A tuple containing as first element the computed contact forces, and as
-            second element the derivative of the material deformation.
+            second element a dictionary with derivative of the material deformation.
         """
 
         # Initialize the model and data this contact model is operating on.
@@ -460,4 +464,4 @@ class SoftContacts(common.ContactModel):
             )
         )(W_p_C, W_ṗ_C, m)
 
-        return W_f, (ṁ,)
+        return W_f, dict(m_dot=ṁ)

jaxsim/rbda/contacts/visco_elastic.py

@@ -13,6 +13,7 @@ import jaxsim.api as js
 import jaxsim.exceptions
 import jaxsim.typing as jtp
 from jaxsim import logging
+from jaxsim.api.common import ModelDataWithVelocityRepresentation
 from jaxsim.math import StandardGravity
 from jaxsim.terrain import FlatTerrain, Terrain
 
@@ -235,11 +236,17 @@ class ViscoElasticContacts(common.ContactModel):
                 else cls.__dataclass_fields__["parameters"].default_factory()
             )
 
-        return ViscoElasticContacts(
+        return cls(
             parameters=parameters,
-            terrain=terrain or cls.__dataclass_fields__["terrain"].default_factory(),
+            terrain=(
+                terrain
+                if terrain is not None
+                else cls.__dataclass_fields__["terrain"].default_factory()
+            ),
             max_squarings=int(
-                max_squarings or cls.__dataclass_fields__["max_squarings"].default
+                max_squarings
+                if max_squarings is not None
+                else cls.__dataclass_fields__["max_squarings"].default
             ),
         )
 
@@ -266,7 +273,7 @@ class ViscoElasticContacts(common.ContactModel):
         dt: jtp.FloatLike | None = None,
         link_forces: jtp.MatrixLike | None = None,
         joint_force_references: jtp.VectorLike | None = None,
-    ) -> tuple[jtp.Matrix, tuple[jtp.Matrix, jtp.Matrix]]:
+    ) -> tuple[jtp.Matrix, dict[str, jtp.PyTree]]:
         """
         Compute the contact forces.
 
@@ -291,7 +298,7 @@ class ViscoElasticContacts(common.ContactModel):
         Returns:
             A tuple containing as first element the computed 6D contact force applied to
             the contact point and expressed in the world frame, and as second element
-            a tuple of optional additional information.
+            a dictionary of optional additional information.
         """
 
         # Initialize the model and data this contact model is operating on.
@@ -315,8 +322,8 @@ class ViscoElasticContacts(common.ContactModel):
                 model=model,
                 data=data,
                 dt=jnp.array(dt).astype(float),
-                joint_force_references=joint_force_references,
                 link_forces=link_forces,
+                joint_force_references=joint_force_references,
                 indices_of_enabled_collidable_points=indices_of_enabled_collidable_points,
                 max_squarings=self.max_squarings,
             )
@@ -334,11 +341,13 @@ class ViscoElasticContacts(common.ContactModel):
 
         # Vmapped transformation from mixed to inertial-fixed representation.
         compute_forces_inertial_fixed_vmap = jax.vmap(
-            lambda CW_fl_C, W_H_C: data.other_representation_to_inertial(
-                array=jnp.zeros(6).at[0:3].set(CW_fl_C),
-                other_representation=jaxsim.VelRepr.Mixed,
-                transform=W_H_C,
-                is_force=True,
+            lambda CW_fl_C, W_H_C: (
+                ModelDataWithVelocityRepresentation.other_representation_to_inertial(
+                    array=jnp.zeros(6).at[0:3].set(CW_fl_C),
+                    other_representation=jaxsim.VelRepr.Mixed,
+                    transform=W_H_C,
+                    is_force=True,
+                )
             )
         )
 
@@ -347,7 +356,7 @@ class ViscoElasticContacts(common.ContactModel):
             lambda CW_fl: compute_forces_inertial_fixed_vmap(CW_fl, W_H_C)
         )(jnp.stack([CW_f̅l, CW_fl̿]))
 
-        return W_f̅_C, (W_f̿_C, m_tf)
+        return W_f̅_C, dict(W_f_avg2_C=W_f̿_C, m_tf=m_tf)
 
     @staticmethod
     @functools.partial(jax.jit, static_argnames=("max_squarings",))
@@ -407,8 +416,8 @@ class ViscoElasticContacts(common.ContactModel):
         A, b, A_sc, b_sc = ViscoElasticContacts._contact_points_dynamics(
             model=model,
             data=data,
-            joint_force_references=joint_force_references,
             link_forces=link_forces,
+            joint_force_references=joint_force_references,
             indices_of_enabled_collidable_points=indices,
             p_t0=p_t0,
             v_t0=v_t0,
@@ -657,8 +666,8 @@ class ViscoElasticContacts(common.ContactModel):
             BW_v̇_free_WB, s̈_free = js.ode.system_acceleration(
                 model=model,
                 data=data,
-                joint_force_references=references.joint_force_references(model=model),
                 link_forces=references.link_forces(model=model, data=data),
+                joint_force_references=references.joint_force_references(model=model),
             )
 
         # Pack the free system acceleration in mixed representation.
@@ -688,7 +697,20 @@ class ViscoElasticContacts(common.ContactModel):
         parameters: ViscoElasticContactsParams,
         terrain: Terrain,
     ) -> tuple[jtp.Matrix, jtp.Vector]:
-        """"""
+        """
+        Linearize the Hunt/Crossley contact model at the initial state.
+
+        Args:
+            position: The position of the contact point.
+            velocity: The velocity of the contact point.
+            tangential_deformation: The tangential deformation of the contact point.
+            parameters: The parameters of the contact model.
+            terrain: The considered terrain.
+
+        Returns:
+            A tuple containing the `A` matrix and the `b` vector of the linear system
+            corresponding to the contact dynamics linearized at the initial state.
+        """
 
         # Initialize the state at which the model is linearized.
         p0 = jnp.array(position, dtype=float).squeeze()
@@ -969,58 +991,67 @@ def step(
     assert isinstance(model.contact_model, ViscoElasticContacts)
     assert isinstance(data.contacts_params, ViscoElasticContactsParams)
 
+    # Compute the contact forces in inertial-fixed representation.
+    # TODO: understand what's wrong in other representations.
+    data_inertial_fixed = data.replace(
+        velocity_representation=jaxsim.VelRepr.Inertial, validate=False
+    )
+
+    # Create the references object.
+    references = js.references.JaxSimModelReferences.build(
+        model=model,
+        data=data,
+        link_forces=link_forces,
+        joint_force_references=joint_force_references,
+        velocity_representation=data.velocity_representation,
+    )
+
     # Initialize the time step.
     dt = dt if dt is not None else model.time_step
 
     # Compute the contact forces with the exponential integrator.
-    W_f̅_C, (W_f̿_C, m_tf) = model.contact_model.compute_contact_forces(
+    W_f̅_C, aux_data = model.contact_model.compute_contact_forces(
         model=model,
-        data=data,
+        data=data_inertial_fixed,
         dt=jnp.array(dt).astype(float),
-        link_forces=link_forces,
-        joint_force_references=joint_force_references,
+        link_forces=references.link_forces(model=model, data=data),
+        joint_force_references=references.joint_force_references(model=model),
     )
 
+    # Extract the final material deformation and the average of average forces
+    # from the dictionary containing auxiliary data.
+    m_tf = aux_data["m_tf"]
+    W_f̿_C = aux_data["W_f_avg2_C"]
+
     # ===============================
     # Compute the link contact forces
     # ===============================
 
-    # Extract the indices corresponding to the enabled collidable points.
-    # The visco-elastic contact model computed only their contact forces.
-    indices_of_enabled_collidable_points = (
-        model.kin_dyn_parameters.contact_parameters.indices_of_enabled_collidable_points
-    )
+    # Get the link contact forces by summing the forces of contact points belonging
+    # to the same link.
+    W_f̅_L, W_f̿_L = jax.vmap(
+        lambda W_f_C: model.contact_model.link_forces_from_contact_forces(
+            model=model, data=data_inertial_fixed, contact_forces=W_f_C
+        )
+    )(jnp.stack([W_f̅_C, W_f̿_C]))
 
     # Compute the link transforms.
-    W_H_L = js.model.forward_kinematics(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
-    # attached to the same link.
-    parent_link_index_of_collidable_points = jnp.array(
-        model.kin_dyn_parameters.contact_parameters.body, dtype=int
-    )[indices_of_enabled_collidable_points]
-
-    # Create the mask that associate each collidable point to their parent link.
-    # We use this mask to sum the collidable points to the right link.
-    mask = parent_link_index_of_collidable_points[:, jnp.newaxis] == jnp.arange(
-        model.number_of_links()
+    W_H_L = (
+        js.model.forward_kinematics(model=model, data=data)
+        if data.velocity_representation is not jaxsim.VelRepr.Inertial
+        else jnp.zeros(shape=(model.number_of_links(), 4, 4))
     )
 
-    # Sum the forces of all collidable points rigidly attached to a body.
-    # Since the contact forces W_f_C are expressed in the world frame,
-    # we don't need any coordinate transformation.
-    W_f̅_L = mask.T @ W_f̅_C
-    W_f̿_L = mask.T @ W_f̿_C
-
-    # For integration purpose, we need these average of averages expressed in
+    # For integration purpose, we need the average of average forces expressed in
     # mixed representation.
     LW_f̿_L = jax.vmap(
-        lambda W_f_L, W_H_L: data.inertial_to_other_representation(
-            array=W_f_L,
-            other_representation=jaxsim.VelRepr.Mixed,
-            transform=W_H_L,
-            is_force=True,
+        lambda W_f_L, W_H_L: (
+            ModelDataWithVelocityRepresentation.inertial_to_other_representation(
+                array=W_f_L,
+                other_representation=jaxsim.VelRepr.Mixed,
+                transform=W_H_L,
+                is_force=True,
+            )
         )
     )(W_f̿_L, W_H_L)
 
@@ -1032,10 +1063,10 @@ def step(
     data_tf: js.data.JaxSimModelData = (
         model.contact_model.integrate_data_with_average_contact_forces(
             model=model,
-            data=data,
+            data=data_inertial_fixed,
             dt=dt,
-            link_forces=link_forces,
-            joint_force_references=joint_force_references,
+            link_forces=references.link_forces(model=model, data=data),
+            joint_force_references=references.joint_force_references(model=model),
             average_link_contact_forces_inertial=W_f̅_L,
             average_of_average_link_contact_forces_mixed=LW_f̿_L,
         )
@@ -1046,10 +1077,21 @@ def step(
     # be much more accurate than the one computed with the discrete soft contacts.
     with data_tf.mutable_context():
 
+        # Extract the indices corresponding to the enabled collidable points.
+        # The visco-elastic contact model computed only their contact forces.
+        indices_of_enabled_collidable_points = (
+            model.kin_dyn_parameters.contact_parameters.indices_of_enabled_collidable_points
+        )
+
         data_tf.state.extended |= {
             "tangential_deformation": data_tf.state.extended["tangential_deformation"]
             .at[indices_of_enabled_collidable_points]
             .set(m_tf)
         }
 
+    # Restore the original velocity representation.
+    data_tf = data_tf.replace(
+        velocity_representation=data.velocity_representation, validate=False
+    )
+
     return data_tf, {}

{jaxsim-0.4.3.dev231.dist-info → jaxsim-0.4.3.dev245.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jaxsim
-Version: 0.4.3.dev231
+Version: 0.4.3.dev245
 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>