jaxsim 0.4.3.dev312__py3-none-any.whl → 0.4.3.dev350__py3-none-any.whl

jaxsim/mujoco/utils.py

@@ -1,7 +1,14 @@
+from __future__ import annotations
+
+import dataclasses
+from collections.abc import Sequence
+
 import mujoco as mj
 import numpy as np
+import numpy.typing as npt
+from scipy.spatial.transform import Rotation
 
-from . import MujocoModelHelper
+from .model import MujocoModelHelper
 
 
 def mujoco_data_from_jaxsim(
@@ -99,3 +106,118 @@ def mujoco_data_from_jaxsim(
     mj.mj_forward(mujoco_model, model_helper.data)
 
     return model_helper.data
+
+
+@dataclasses.dataclass
+class MujocoCamera:
+    """
+    Helper class storing parameters of a Mujoco camera.
+
+    Refer to the official documentation for more details:
+    https://mujoco.readthedocs.io/en/stable/XMLreference.html#body-camera
+    """
+
+    mode: str = "fixed"
+
+    target: str | None = None
+    fovy: str = "45"
+    pos: str = "0 0 0"
+
+    quat: str | None = None
+    axisangle: str | None = None
+    xyaxes: str | None = None
+    zaxis: str | None = None
+    euler: str | None = None
+
+    name: str | None = None
+
+    @classmethod
+    def build(cls, **kwargs) -> MujocoCamera:
+
+        if not all(isinstance(value, str) for value in kwargs.values()):
+            raise ValueError(f"Values must be strings: {kwargs}")
+
+        return cls(**kwargs)
+
+    @staticmethod
+    def build_from_target_view(
+        camera_name: str,
+        lookat: Sequence[float | int] | npt.NDArray = (0, 0, 0),
+        distance: float | int | npt.NDArray = 3,
+        azimut: float | int | npt.NDArray = 90,
+        elevation: float | int | npt.NDArray = -45,
+        fovy: float | int | npt.NDArray = 45,
+        degrees: bool = True,
+        **kwargs,
+    ) -> MujocoCamera:
+        """
+        Create a custom camera that looks at a target point.
+
+        Note:
+            The choice of the parameters is easier if we imagine to consider a target
+            frame `T` whose origin is located over the lookat point and having the same
+            orientation of the world frame `W`. We also introduce a camera frame `C`
+            whose origin is located over the lower-left corner of the image, and having
+            the x-axis pointing right and the y-axis pointing up in image coordinates.
+            The camera renders what it sees in the -z direction of frame `C`.
+
+        Args:
+            camera_name: The name of the camera.
+            lookat: The target point to look at (origin of `T`).
+            distance:
+                The distance from the target point (displacement between the origins
+                of `T` and `C`).
+            azimut:
+                The rotation around z of the camera. With an angle of 0, the camera
+                would loot at the target point towards the positive x-axis of `T`.
+            elevation:
+                The rotation around the x-axis of the camera frame `C`. Note that if
+                you want to lift the view angle, the elevation is negative.
+            fovy: The field of view of the camera.
+            degrees: Whether the angles are in degrees or radians.
+            **kwargs: Additional camera parameters.
+
+        Returns:
+            The custom camera.
+        """
+
+        # Start from a frame whose origin is located over the lookat point.
+        # We initialize a -90 degrees rotation around the z-axis because due to
+        # the default camera coordinate system (x pointing right, y pointing up).
+        W_H_C = np.eye(4)
+        W_H_C[0:3, 3] = np.array(lookat)
+        W_H_C[0:3, 0:3] = Rotation.from_euler(
+            seq="ZX", angles=[-90, 90], degrees=True
+        ).as_matrix()
+
+        # Process the azimut.
+        R_az = Rotation.from_euler(seq="Y", angles=azimut, degrees=degrees).as_matrix()
+        W_H_C[0:3, 0:3] = W_H_C[0:3, 0:3] @ R_az
+
+        # Process elevation.
+        R_el = Rotation.from_euler(
+            seq="X", angles=elevation, degrees=degrees
+        ).as_matrix()
+        W_H_C[0:3, 0:3] = W_H_C[0:3, 0:3] @ R_el
+
+        # Process distance.
+        tf_distance = np.eye(4)
+        tf_distance[2, 3] = distance
+        W_H_C = W_H_C @ tf_distance
+
+        # Extract the position and the quaternion.
+        p = W_H_C[0:3, 3]
+        Q = Rotation.from_matrix(W_H_C[0:3, 0:3]).as_quat(scalar_first=True)
+
+        return MujocoCamera.build(
+            name=camera_name,
+            mode="fixed",
+            fovy=f"{fovy if degrees else np.rad2deg(fovy)}",
+            pos=" ".join(p.astype(str).tolist()),
+            quat=" ".join(Q.astype(str).tolist()),
+            **kwargs,
+        )
+
+    def asdict(self) -> dict[str, str]:
+
+        return {k: v for k, v in dataclasses.asdict(self).items() if v is not None}

jaxsim/parsers/descriptions/joint.py

@@ -100,32 +100,7 @@ class JointDescription(JaxsimDataclass):
         if not isinstance(other, JointDescription):
             return False
 
-        if not (
-            self.name == other.name
-            and self.jtype == other.jtype
-            and self.child == other.child
-            and self.parent == other.parent
-            and self.index == other.index
-            and all(
-                np.allclose(getattr(self, attr), getattr(other, attr))
-                for attr in [
-                    "axis",
-                    "pose",
-                    "friction_static",
-                    "friction_viscous",
-                    "position_limit_damper",
-                    "position_limit_spring",
-                    "position_limit",
-                    "initial_position",
-                    "motor_inertia",
-                    "motor_viscous_friction",
-                    "motor_gear_ratio",
-                ]
-            ),
-        ):
-            return False
-
-        return True
+        return hash(self) == hash(other)
 
     def __hash__(self) -> int:
 

jaxsim/parsers/kinematic_graph.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import copy
 import dataclasses
 import functools
-from collections.abc import Callable, Iterable, Sequence
+from collections.abc import Callable, Iterable, Iterator, Sequence
 from typing import Any
 
 import numpy as np
@@ -82,7 +82,7 @@ class KinematicGraph(Sequence[LinkDescription]):
         default_factory=list, hash=False, compare=False
     )
 
-    root_pose: RootPose = dataclasses.field(default_factory=lambda: RootPose())
+    root_pose: RootPose = dataclasses.field(default_factory=RootPose)
 
     # Private attribute storing optional additional info.
     _extra_info: dict[str, Any] = dataclasses.field(
@@ -700,7 +700,7 @@ class KinematicGraph(Sequence[LinkDescription]):
     # Sequence protocol
     # =================
 
-    def __iter__(self) -> Iterable[LinkDescription]:
+    def __iter__(self) -> Iterator[LinkDescription]:
         yield from KinematicGraph.breadth_first_search(root=self.root)
 
     def __reversed__(self) -> Iterable[LinkDescription]:

jaxsim/parsers/rod/parser.py

@@ -85,10 +85,7 @@ def extract_model_data(
 
     # Log type of base link.
     logging.debug(
-        msg="Model '{}' is {}".format(
-            sdf_model.name,
-            "fixed-base" if sdf_model.is_fixed_base() else "floating-base",
-        )
+        msg=f"Model '{sdf_model.name}' is {'fixed-base' if sdf_model.is_fixed_base() else 'floating-base'}"
     )
 
     # Log detected base link.
@@ -175,7 +172,7 @@ def extract_model_data(
             for j in sdf_model.joints()
             if j.type == "fixed"
             and j.parent == "world"
-            and j.child in links_dict.keys()
+            and j.child in links_dict
             and j.pose.relative_to in {"__model__", "world", None}
         ]
 
@@ -287,7 +284,7 @@ def extract_model_data(
         for j in sdf_model.joints()
         if j.type in {"revolute", "continuous", "prismatic", "fixed"}
         and j.parent != "world"
-        and j.child in links_dict.keys()
+        and j.child in links_dict
     ]
 
     # Create a dictionary to find the parent joint of the links.

jaxsim/parsers/rod/utils.py

@@ -179,7 +179,7 @@ def create_sphere_collision(
 
     r = collision.geometry.sphere.radius
     sphere_points = r * fibonacci_sphere(
-        samples=int(os.getenv(key="JAXSIM_COLLISION_SPHERE_POINTS", default="250"))
+        samples=int(os.getenv(key="JAXSIM_COLLISION_SPHERE_POINTS", default="50"))
     )
 
     H = collision.pose.transform() if collision.pose is not None else np.eye(4)

jaxsim/rbda/collidable_points.py

@@ -21,7 +21,7 @@ def collidable_points_pos_vel(
 ) -> tuple[jtp.Matrix, jtp.Matrix]:
     """
 
-    Compute the position and linear velocity of collidable points in the world frame.
+    Compute the position and linear velocity of the enabled collidable points in the world frame.
 
     Args:
         model: The model to consider.
@@ -35,10 +35,23 @@ def collidable_points_pos_vel(
         joint_velocities: The velocities of the joints.
 
     Returns:
-        A tuple containing the position and linear velocity of collidable points.
+        A tuple containing the position and linear velocity of the enabled collidable points.
     """
 
-    if len(model.kin_dyn_parameters.contact_parameters.body) == 0:
+    # Get the indices of the enabled collidable points.
+    indices_of_enabled_collidable_points = (
+        model.kin_dyn_parameters.contact_parameters.indices_of_enabled_collidable_points
+    )
+
+    parent_link_idx_of_enabled_collidable_points = jnp.array(
+        model.kin_dyn_parameters.contact_parameters.body, dtype=int
+    )[indices_of_enabled_collidable_points]
+
+    L_p_Ci = model.kin_dyn_parameters.contact_parameters.point[
+        indices_of_enabled_collidable_points
+    ]
+
+    if len(indices_of_enabled_collidable_points) == 0:
         return jnp.array(0).astype(float), jnp.empty(0).astype(float)
 
     W_p_B, W_Q_B, s, W_v_WB, ṡ, _, _, _, _, _ = utils.process_inputs(
@@ -136,8 +149,8 @@ def collidable_points_pos_vel(
 
     # Process all the collidable points in parallel.
     W_p_Ci, CW_vl_WC = jax.vmap(process_point_kinematics)(
-        model.kin_dyn_parameters.contact_parameters.point,
-        jnp.array(model.kin_dyn_parameters.contact_parameters.body),
+        L_p_Ci,
+        parent_link_idx_of_enabled_collidable_points,
     )
 
     return W_p_Ci, CW_vl_WC

jaxsim/rbda/contacts/common.py

@@ -216,11 +216,21 @@ class ContactModel(JaxsimDataclass):
             the velocity representation of data.
         """
 
+        # 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
+        )
+
         # 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)
+        W_H_C = js.contact.transforms(model=model, data=data)[
+            indices_of_enabled_collidable_points
+        ]
 
         # Convert the contact forces to inertial-fixed representation.
         W_f_C = jax.vmap(
@@ -234,14 +244,6 @@ class ContactModel(JaxsimDataclass):
             )
         )(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.

jaxsim/rbda/contacts/relaxed_rigid.py

@@ -357,13 +357,15 @@ class RelaxedRigidContacts(common.ContactModel):
 
             Jl_WC = jnp.vstack(
                 jax.vmap(lambda J, height: J * (height < 0))(
-                    js.contact.jacobian(model=model, data=data)[:, :3, :], δ
+                    js.contact.jacobian(model=model, data=data)[:, :3, :],
+                    δ,
                 )
             )
 
             J̇_WC = jnp.vstack(
                 jax.vmap(lambda J̇, height: J̇ * (height < 0))(
-                    js.contact.jacobian_derivative(model=model, data=data)[:, :3], δ
+                    js.contact.jacobian_derivative(model=model, data=data)[:, :3],
+                    δ,
                 ),
             )
 
@@ -530,6 +532,15 @@ class RelaxedRigidContacts(common.ContactModel):
             )
         )
 
+        # Get the indices of the enabled collidable points.
+        indices_of_enabled_collidable_points = (
+            model.kin_dyn_parameters.contact_parameters.indices_of_enabled_collidable_points
+        )
+
+        parent_link_idx_of_enabled_collidable_points = jnp.array(
+            model.kin_dyn_parameters.contact_parameters.body, dtype=int
+        )[indices_of_enabled_collidable_points]
+
         # Compute the 6D inertia matrices of all links.
         M_L = js.model.link_spatial_inertia_matrices(model=model)
 
@@ -595,9 +606,7 @@ class RelaxedRigidContacts(common.ContactModel):
             f=jnp.concatenate,
             tree=(
                 *jax.vmap(compute_row)(
-                    link_idx=jnp.array(
-                        model.kin_dyn_parameters.contact_parameters.body
-                    ),
+                    link_idx=parent_link_idx_of_enabled_collidable_points,
                     penetration=penetration,
                     velocity=velocity,
                 ),

jaxsim/rbda/contacts/rigid.py

@@ -285,6 +285,13 @@ class RigidContacts(ContactModel):
         # Import qpax privately just in this method.
         import qpax
 
+        # Get the indices of the enabled collidable points.
+        indices_of_enabled_collidable_points = (
+            model.kin_dyn_parameters.contact_parameters.indices_of_enabled_collidable_points
+        )
+
+        n_collidable_points = len(indices_of_enabled_collidable_points)
+
         link_forces = jnp.atleast_2d(
             jnp.array(link_forces, dtype=float).squeeze()
             if link_forces is not None
@@ -299,7 +306,6 @@ class RigidContacts(ContactModel):
 
         # Compute kin-dyn quantities used in the contact model.
         with data.switch_velocity_representation(VelRepr.Mixed):
-
             BW_ν = data.generalized_velocity()
 
             M = js.model.free_floating_mass_matrix(model=model, data=data)
@@ -310,14 +316,11 @@ class RigidContacts(ContactModel):
             W_H_C = js.contact.transforms(model=model, data=data)
 
         # Compute the position and linear velocities (mixed representation) of
-        # all collidable points belonging to the robot.
+        # all enabled collidable points belonging to the robot.
         position, velocity = js.contact.collidable_point_kinematics(
             model=model, data=data
         )
 
-        # Get the number of collidable points.
-        n_collidable_points = len(model.kin_dyn_parameters.contact_parameters.body)
-
         # Compute the penetration depth and velocity of the collidable points.
         # Note that this function considers the penetration in the normal direction.
         δ, δ_dot, n̂ = jax.vmap(common.compute_penetration_data, in_axes=(0, 0, None))(
@@ -460,7 +463,7 @@ class RigidContacts(ContactModel):
         return G
 
     @staticmethod
-    def _compute_ineq_bounds(n_collidable_points: jtp.FloatLike) -> jtp.Vector:
+    def _compute_ineq_bounds(n_collidable_points: int) -> jtp.Vector:
 
         n_constraints = 6 * n_collidable_points
         return jnp.zeros(shape=(n_constraints,))

jaxsim/rbda/contacts/soft.py

@@ -445,16 +445,27 @@ class SoftContacts(common.ContactModel):
         # contact parameters are not compatible.
         model, data = self.initialize_model_and_data(model=model, data=data)
 
+        # Get the indices of the enabled collidable points.
+        indices_of_enabled_collidable_points = (
+            model.kin_dyn_parameters.contact_parameters.indices_of_enabled_collidable_points
+        )
+
         # Compute the position and linear velocities (mixed representation) of
-        # all collidable points belonging to the robot.
+        # all the collidable points belonging to the robot and extract the ones
+        # for the enabled collidable points.
         W_p_C, W_ṗ_C = js.contact.collidable_point_kinematics(model=model, data=data)
 
         # Extract the material deformation corresponding to the collidable points.
         m = data.state.extended["tangential_deformation"]
 
-        # Compute the contact forces for all collidable points.
+        m_enabled = m[indices_of_enabled_collidable_points]
+
+        # Initialize the tangential deformation rate array for every collidable point.
+        ṁ = jnp.zeros_like(m)
+
+        # Compute the contact forces only for the enabled collidable points.
         # Since we treat them as independent, we can vmap the computation.
-        W_f, ṁ = jax.vmap(
+        W_f, ṁ_enabled = jax.vmap(
             lambda p, v, m: SoftContacts.compute_contact_force(
                 position=p,
                 velocity=v,
@@ -462,6 +473,8 @@ class SoftContacts(common.ContactModel):
                 parameters=data.contacts_params,
                 terrain=model.terrain,
             )
-        )(W_p_C, W_ṗ_C, m)
+        )(W_p_C, W_ṗ_C, m_enabled)
+
+        ṁ = ṁ.at[indices_of_enabled_collidable_points].set(ṁ_enabled)
 
         return W_f, dict(m_dot=ṁ)

jaxsim/rbda/jacobian.py

@@ -205,7 +205,7 @@ def jacobian_full_doubly_left(
     # Convert adjoints to SE(3) transforms.
     # Returning them here prevents calling FK in case the output representation
     # of the Jacobian needs to be changed.
-    B_H_L = jax.vmap(lambda B_X_L: Adjoint.to_transform(B_X_L))(B_X_i)
+    B_H_L = jax.vmap(Adjoint.to_transform)(B_X_i)
 
     # Adjust shape of doubly-left free-floating full Jacobian.
     B_J_full_WL_B = J.squeeze().astype(float)
@@ -322,7 +322,7 @@ def jacobian_derivative_full_doubly_left(
     # Convert adjoints to SE(3) transforms.
     # Returning them here prevents calling FK in case the output representation
     # of the Jacobian needs to be changed.
-    B_H_L = jax.vmap(lambda B_X_L: Adjoint.to_transform(B_X_L))(B_X_i)
+    B_H_L = jax.vmap(Adjoint.to_transform)(B_X_i)
 
     # Adjust shape of doubly-left free-floating full Jacobian derivative.
     B_J̇_full_WL_B = J̇.squeeze().astype(float)

jaxsim/rbda/utils.py

@@ -135,7 +135,7 @@ def process_inputs(
     # Check that the quaternion is unary since our RBDAs make this assumption in order
     # to prevent introducing additional normalizations that would affect AD.
     exceptions.raise_value_error_if(
-        condition=jnp.logical_not(jnp.allclose(W_Q_B.dot(W_Q_B), 1.0)),
+        condition=~jnp.allclose(W_Q_B.dot(W_Q_B), 1.0),
         msg="A RBDA received a quaternion that is not normalized.",
     )
 

jaxsim/terrain/terrain.py

@@ -8,6 +8,7 @@ import jax_dataclasses
 import numpy as np
 
 import jaxsim.typing as jtp
+from jaxsim import exceptions
 
 
 class Terrain(abc.ABC):
@@ -108,7 +109,9 @@ class PlaneTerrain(FlatTerrain):
             _normal=tuple(normal.tolist()),
         )
 
-    def normal(self, x: jtp.FloatLike, y: jtp.FloatLike) -> jtp.Vector:
+    def normal(
+        self, x: jtp.FloatLike | None = None, y: jtp.FloatLike | None = None
+    ) -> jtp.Vector:
         """
         Compute the normal vector of the terrain at a specific (x, y) location.
 
@@ -141,6 +144,11 @@ class PlaneTerrain(FlatTerrain):
         # Get the plane equation coefficients from the terrain normal.
         A, B, C = self._normal
 
+        exceptions.raise_value_error_if(
+            condition=jnp.allclose(C, 0.0),
+            msg="The z component of the normal cannot be zero.",
+        )
+
         # Compute the final coefficient D considering the terrain height.
         D = -C * self._height
 

jaxsim/utils/tracing.py

@@ -8,15 +8,9 @@ import jax.interpreters.partial_eval
 def tracing(var: Any) -> bool | jax.Array:
     """Returns True if the variable is being traced by JAX, False otherwise."""
 
-    return jax.numpy.array(
-        [
-            isinstance(var, t)
-            for t in (
-                jax._src.core.Tracer,
-                jax.interpreters.partial_eval.DynamicJaxprTracer,
-            )
-        ]
-    ).any()
+    return isinstance(
+        var, jax._src.core.Tracer | jax.interpreters.partial_eval.DynamicJaxprTracer
+    )
 
 
 def not_tracing(var: Any) -> bool | jax.Array:

jaxsim/utils/wrappers.py

@@ -49,7 +49,7 @@ class CustomHashedObject(Generic[T]):
 
     obj: T
 
-    hash_function: Callable[[T], int] = dataclasses.field(default=lambda obj: hash(obj))
+    hash_function: Callable[[T], int] = hash
 
     def get(self: CustomHashedObject[T]) -> T:
         return self.obj

{jaxsim-0.4.3.dev312.dist-info → jaxsim-0.4.3.dev350.dist-info}/METADATA

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

{jaxsim-0.4.3.dev312.dist-info → jaxsim-0.4.3.dev350.dist-info}/RECORD

@@ -1,25 +1,25 @@
 jaxsim/__init__.py,sha256=opgtbhhd1kDsHI4H1vOd3loMPDRi884yQ3tohfFGfNc,3382
-jaxsim/_version.py,sha256=9z77SzRrCM879hIhLDP1NmKCeIFIGYz6uMLtbgugzcQ,428
+jaxsim/_version.py,sha256=56tTuqXBlX9UQVJyJ_A9hRmvozgLzRGJ-9ZCppehae8,428
 jaxsim/exceptions.py,sha256=vSoScaRD4nvh6jltgK9Ry5pKnE0O5hb4_yI_pk_fvR8,2175
 jaxsim/logging.py,sha256=STI-D_upXZYX-ZezLrlJJ0UlD5YspST0vZ_DcIwkzO4,1553
 jaxsim/typing.py,sha256=2HXy9hgazPXjofi1vLQ09ZubPtgVmg80U9NKmZ6NYiI,761
 jaxsim/api/__init__.py,sha256=8eV22t2S3UwNyCg8karPetG1dmX1VDBXkyv28_FwNQA,210
 jaxsim/api/com.py,sha256=m-p3EJDhpnMTlXKplfbZE_aH9NqX_VyLlAE3vUhc6l4,13642
 jaxsim/api/common.py,sha256=SNgxq42r6eF_-aPszvOjUYkGwXOzz4hKmhDwEUkscFQ,6650
-jaxsim/api/contact.py,sha256=EM2pCPpFgbk0sjWBWZFYweRHfDNPa2jfnOZP6qjg-XY,24108
+jaxsim/api/contact.py,sha256=D6RucrH9gnoUFLdmAEYwLGrimU0wLmuoDeOONu4ni74,25658
 jaxsim/api/data.py,sha256=ThRpoBlbdwf1N3xs8SWrY5d8RbfdYRwFcmkdIPgtee4,29004
 jaxsim/api/frame.py,sha256=yPSgNygHkvWlln4wShNt7vZm_fFobVEm7phsklNNyH8,12922
-jaxsim/api/joint.py,sha256=Vl9VJs66_es88zjBBXqPzKkA3oAktV-DNiTkXwxOSsI,7562
-jaxsim/api/kin_dyn_parameters.py,sha256=fRB7LPGTIwqunJGSq5YfMwSuy2yM_c5gZbsjN1K19Jw,29482
-jaxsim/api/link.py,sha256=au47jV7bNdH2itvZ4qngKZyLi0UTIKzqVjjKosnlMsU,12858
-jaxsim/api/model.py,sha256=ynzI2Us2XNVgcz_rasxVjE5575MC04YINsAxNP-B5sU,79472
+jaxsim/api/joint.py,sha256=8rCIxRMeAidsaBbw7kkGp6z3-UmBPtqmYmV_arHDQJ8,7365
+jaxsim/api/kin_dyn_parameters.py,sha256=Y9wnMshz83Zm4UEPOAOTINdtfkBZ86w853c8Yi2qaVs,29670
+jaxsim/api/link.py,sha256=nHjffhNdi_xGkteMsqdb_hC9mdV9rNw7k3pl89Uhw_8,12798
+jaxsim/api/model.py,sha256=A88AaBZpWvQ-L9blFyl1GHvTWI05rvVFKbSaHzD77_k,79563
 jaxsim/api/ode.py,sha256=_t18avoCJngQk6eMFTGpaeahbpchQP20qJnUOCPkz8s,15360
 jaxsim/api/ode_data.py,sha256=1SD-x-lYk_YSEnVpxTLd69uOKC0mFUj44ZqpSmEDOxw,20190
-jaxsim/api/references.py,sha256=crPzgUCDHkTKUuXQcj9ygFAI0pewIx-fTPEsU8fBiU4,20555
+jaxsim/api/references.py,sha256=eIOk3MAOc9LJSKfI8M4WA8gGD-meo50vRfhXdea4sNI,20539
 jaxsim/integrators/__init__.py,sha256=hxvOD-VK_mmd6v31wtC-nb28AYve1gLuZCNLV9wS-Kg,103
-jaxsim/integrators/common.py,sha256=8Y3PGVOydPBJrqYtH33rtng48T12ySWfXTk-ED_2wao,18297
+jaxsim/integrators/common.py,sha256=ohISUnUWTaNHt2kweg1JyzwYGZgIH_wc-01qJWJsO80,18281
 jaxsim/integrators/fixed_step.py,sha256=KpjRd6hHtapxDoo6D1kyDrVDSHnke2TepI5grFH7_bM,2693
-jaxsim/integrators/variable_step.py,sha256=hGYKG3Sq3QITgzIePmCVCrrirwagqsKnB3aYifAcKR4,22848
+jaxsim/integrators/variable_step.py,sha256=Tqz5ySSgyKak_k6cTXpmtqdPNaFlO7N6zj7jBIlChyM,22681
 jaxsim/math/__init__.py,sha256=8oPITEoGwgRcOeG8KxtqxPQ8b5uku1HNRMokpCoi9Tc,352
 jaxsim/math/adjoint.py,sha256=V7r5VrTCKPLEL5gavNSx9U7xSsrb11a5e4gWqJ2MuRo,4375
 jaxsim/math/cross.py,sha256=U7yEx_l75mSy5g6O-jsjBztApvxC3WaV4MpkS5tThu4,1330
@@ -31,42 +31,42 @@ jaxsim/math/skew.py,sha256=oOGSSR8PUGROl6IJFlrmu6K3gPH-u16hUPfKIkcVv9o,1177
 jaxsim/math/transform.py,sha256=KXzQgOnCfAtbXCwxhplpJ3F0JT3oEyeLVby1_uRAryQ,2892
 jaxsim/mujoco/__init__.py,sha256=fZyRWre49pIhOrYdf6yJk_hOax8qWGe8OCmoq-dMVq8,201
 jaxsim/mujoco/__main__.py,sha256=GBmB7J-zj75ZnFyuAAmpSOpbxi_HhHhWJeot3ljGDJY,5291
-jaxsim/mujoco/loaders.py,sha256=CkFGydgOku5P_Pz7wdWlM2SCJRs71ePF-vsY9i90-I0,25350
+jaxsim/mujoco/loaders.py,sha256=_CZekIqZNe8oFeH7zSv4gGZAZENRISwMd8dt640zjRI,20860
 jaxsim/mujoco/model.py,sha256=5_7rWk_WBkNKDHqeewIFj0t2ZGqJpE6RDXHSbRvw4e4,16493
-jaxsim/mujoco/utils.py,sha256=bGbLMSzcdqbinIwHHJHt8ZN1uup_6DLdB2dWqKiXwO4,3955
+jaxsim/mujoco/utils.py,sha256=vZ8afASNOSxnxVW9p_1U1J_n-9nVhnBDqlV5k8c1GkM,8256
 jaxsim/mujoco/visualizer.py,sha256=nD6SNWmn-nxjjjIY9oPAHvL2j8q93DJDjZeepzke_DQ,6988
 jaxsim/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jaxsim/parsers/kinematic_graph.py,sha256=wT2bgaCS8VQJTHy2H9sENkVPDOiMkRikxEF1t_WaahQ,34748
+jaxsim/parsers/kinematic_graph.py,sha256=MJkJ7AW1TdLZmxibuiVrTfn6jHjh3OVhEF20DqwsCnM,34748
 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/joint.py,sha256=2KWLP4ILPMV8q1X0J7aS3GGFeZn4zXan0dqGOWc7XuQ,4365
 jaxsim/parsers/descriptions/link.py,sha256=Eh0W5qL7_Uw0GV-BkNKXhm9Q2dRTfIWCX5D-87zQkxA,3711
 jaxsim/parsers/descriptions/model.py,sha256=I2Vsbv8Josl4Le7b5rIvhqA2k9Bbv5JxMqwytayxds0,9833
 jaxsim/parsers/rod/__init__.py,sha256=G2vqlLajBLUc4gyzXwsEI2Wsi4TMOIF9bLDFeT6KrGU,92
-jaxsim/parsers/rod/parser.py,sha256=UAL6vkAab2y6PgIv3tAL8UodNbq-mmNBuBotxHJOSVU,14035
-jaxsim/parsers/rod/utils.py,sha256=5DsF3OeePZGidOJ5GiFSZx-51uIdnFvMW9EK6SgOW6Q,5698
+jaxsim/parsers/rod/parser.py,sha256=EXcbtr_vMjAaUzQjfQlD1zLLYLAZXrNeFHaiZVlLwFI,13976
+jaxsim/parsers/rod/utils.py,sha256=czQ2Y1_I9zGO0y2XDotHSqDorVH6zEcPhkuelApjs3k,5697
 jaxsim/rbda/__init__.py,sha256=kmy4G9aMkrqPNGdLSaSV3k15dpF52vBEUQXDFDuKIxU,337
 jaxsim/rbda/aba.py,sha256=w7ciyxB0IsmueatT0C7PcBQEl9dyiH9oqJgIi3xeTUE,8983
-jaxsim/rbda/collidable_points.py,sha256=Rmf1DhflhOTYh9mDalv0agS0CGSbmfoOybwP2KzKuJ0,4883
+jaxsim/rbda/collidable_points.py,sha256=0PFLzxWKtRg8-JtfNhGlSjBMv1J98tiLymOdvlvAak4,5325
 jaxsim/rbda/crba.py,sha256=bXkXESnVbv-lxhU1Y_i0rViEcQA4z2t2_jHwdVj5CBo,5049
 jaxsim/rbda/forward_kinematics.py,sha256=2GmEoWsrioVl_SAbKRKfhOLz57pY4aR81PKRdulqStA,3458
-jaxsim/rbda/jacobian.py,sha256=p0EV_8cLzLVV-93VKznT7VPuRj8W7h7rQWkPlWJXfCA,11023
+jaxsim/rbda/jacobian.py,sha256=L6Vn4Kf9I6wj-MYcFY6o67mgIfLFaaW4i2wNQJ2PDL0,10981
 jaxsim/rbda/rnea.py,sha256=CLfqs9XFVaD-hvkLABshDAfdw5bm_AMV3UVAQ_IvURQ,7542
-jaxsim/rbda/utils.py,sha256=eeT21Y4DiiyhrdF0lUE_VvRuwru5-rR7yOlOlWzCCWE,5381
+jaxsim/rbda/utils.py,sha256=GLt7XIl1ROkx0_fnBCKUHYdB9_IBF3Yi4OnkHSX3gxA,5365
 jaxsim/rbda/contacts/__init__.py,sha256=L5MM-2pv76YPGzxExdz2EErgGBATuAjYnNHlq5QOySs,503
-jaxsim/rbda/contacts/common.py,sha256=ELASrMnkFuUZBRDPKu-HO7ymUukK3r-VZw9TjqOSZgM,11174
-jaxsim/rbda/contacts/relaxed_rigid.py,sha256=6EWTkHjixSv-9pBl7aO_abOxHrneUQKF6uUyt5Vbbuc,20512
-jaxsim/rbda/contacts/rigid.py,sha256=q9hXH2FpqAAf4UVt_BPUQ5DrLgitEARIu4j3kKr3Wpg,17005
-jaxsim/rbda/contacts/soft.py,sha256=wqwnsg0abWn64pYG7je08fsBwdgyJdd2k7dAG0Sx0_k,16432
+jaxsim/rbda/contacts/common.py,sha256=ai49HeLQOsnckG0H2tUKW2KQ0Au_v9jRuNdnqie-YBk,11234
+jaxsim/rbda/contacts/relaxed_rigid.py,sha256=tbyskONuUhC6BZnZSpNUnlCjkI7LR6mCtmU_HimOAVE,20893
+jaxsim/rbda/contacts/rigid.py,sha256=MSzkU6SFbW6CryNlyyxQ7K0-U-8k6VROGKv_DQrwqiw,17156
+jaxsim/rbda/contacts/soft.py,sha256=t6bqBfGAtV1AWoevY82LAcXy2XW8w_uu7bNywcyxF0s,17001
 jaxsim/rbda/contacts/visco_elastic.py,sha256=vQkfMuqQ3Qu8nbDTPY4jWBZjV3U7qtoRK1Aya3O3oFA,41424
 jaxsim/terrain/__init__.py,sha256=f7lVX-iNpH_wkkjef9Qpjh19TTAUOQw76EiLYJDVizc,78
-jaxsim/terrain/terrain.py,sha256=K91HEzPqTSyNrc_j1KfAAEF_5oDeuk_-jnnZGrcMEcY,5015
+jaxsim/terrain/terrain.py,sha256=_G1QS3zWycj089R8fTP5s2VjcZpEdJxREjXZJ-oXIvc,5248
 jaxsim/utils/__init__.py,sha256=Y5zyoRevl3EMVQadhZ4EtSwTEkDt2vcnFoRhPJjKTZ0,215
 jaxsim/utils/jaxsim_dataclass.py,sha256=TGmTQV2Lq7Q-2nLoAEaeNtkPa_qj0IKkdBm4COj46Os,11312
-jaxsim/utils/tracing.py,sha256=KDMoyVPlu2NJvFkhtZwq5AkqMMgajt3munvJom-vEjQ,650
-jaxsim/utils/wrappers.py,sha256=Fh82ZcaFi5fUnByyFLnmumaobsu1hJIvFdopUVzJ1ps,4052
-jaxsim-0.4.3.dev312.dist-info/LICENSE,sha256=eaYdFmdeMbiIoIiPzEK0MjP1S9wtFXjXNR5er49uLR0,1546
-jaxsim-0.4.3.dev312.dist-info/METADATA,sha256=eUJdKiR6pI1f4ulNIacZxLmSl5R8x4NiZUvvdF9buxQ,17513
-jaxsim-0.4.3.dev312.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-jaxsim-0.4.3.dev312.dist-info/top_level.txt,sha256=LxGMA8FLtXjQ6oI7N5gd_R_oSUHxpXxUEOfT1xS_ni0,7
-jaxsim-0.4.3.dev312.dist-info/RECORD,,
+jaxsim/utils/tracing.py,sha256=eEY28MZW0Lm_jJNt1NkFqZz0ek01tvhR46OXZYCo7tc,532
+jaxsim/utils/wrappers.py,sha256=ZY7olSORzZRvSzkdeNLj8yjwUIAt9L0Douwl7wItjpk,4008
+jaxsim-0.4.3.dev350.dist-info/LICENSE,sha256=eaYdFmdeMbiIoIiPzEK0MjP1S9wtFXjXNR5er49uLR0,1546
+jaxsim-0.4.3.dev350.dist-info/METADATA,sha256=qyh1wWUq5dTCw9iznLWlS4DlKa6kfMnAMqZgYbldbCA,17513
+jaxsim-0.4.3.dev350.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
+jaxsim-0.4.3.dev350.dist-info/top_level.txt,sha256=LxGMA8FLtXjQ6oI7N5gd_R_oSUHxpXxUEOfT1xS_ni0,7
+jaxsim-0.4.3.dev350.dist-info/RECORD,,