jaxsim 0.5.1.dev152__py3-none-any.whl → 0.5.1.dev162__py3-none-any.whl

jaxsim/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5.1.dev152'
-__version_tuple__ = version_tuple = (0, 5, 1, 'dev152')
+__version__ = version = '0.5.1.dev162'
+__version_tuple__ = version_tuple = (0, 5, 1, 'dev162')

jaxsim/api/model.py

@@ -736,152 +736,149 @@ def generalized_free_floating_jacobian_derivative(
     # Compute the base transform.
     W_H_B = data.base_transform()
 
-    @functools.partial(jax.vmap, in_axes=(0, None, None, 0))
-    def _compute_row(
-        B_H_L: jtp.Matrix,
-        B_J_full_WL_B: jtp.Matrix,
-        W_H_B: jtp.Matrix,
-        κb: jtp.Matrix,
-    ) -> jtp.Matrix:
+    # We add the 5 columns of ones to the Jacobian derivative to account for the
+    # base velocity and acceleration (5 + number of links = 6 + number of joints).
+    B_J̇_WL_B = (
+        jnp.hstack([jnp.ones((κb.shape[0], 5)), κb])[:, jnp.newaxis] * B_J̇_full_WX_B
+    )
+    B_J_WL_B = (
+        jnp.hstack([jnp.ones((κb.shape[0], 5)), κb])[:, jnp.newaxis] * B_J_full_WL_B
+    )
 
-        # =====================================================
-        # Compute quantities to adjust the input representation
-        # =====================================================
+    # =====================================================
+    # Compute quantities to adjust the input representation
+    # =====================================================
 
-        In = jnp.eye(model.dofs())
-        On = jnp.zeros(shape=(model.dofs(), model.dofs()))
+    In = jnp.eye(model.dofs())
+    On = jnp.zeros(shape=(model.dofs(), model.dofs()))
 
-        # Extract the link quantities using the boolean support body array.
-        B_J̇_WL_B = jnp.hstack([jnp.ones(5), κb]) * B_J̇_full_WX_B
-        B_J_WL_B = jnp.hstack([jnp.ones(5), κb]) * B_J_full_WL_B
+    match data.velocity_representation:
 
-        match data.velocity_representation:
+        case VelRepr.Inertial:
 
-            case VelRepr.Inertial:
+            B_X_W = jaxsim.math.Adjoint.from_transform(transform=W_H_B, inverse=True)
 
-                B_X_W = jaxsim.math.Adjoint.from_transform(
-                    transform=W_H_B, inverse=True
-                )
+            W_v_WB = data.base_velocity()
+            B_Ẋ_W = -B_X_W @ jaxsim.math.Cross.vx(W_v_WB)
 
-                W_v_WB = data.base_velocity()
-                B_Ẋ_W = -B_X_W @ jaxsim.math.Cross.vx(W_v_WB)
+            # Compute the operator to change the representation of ν, and its
+            # time derivative.
+            T = jax.scipy.linalg.block_diag(B_X_W, In)
+            Ṫ = jax.scipy.linalg.block_diag(B_Ẋ_W, On)
 
-                # Compute the operator to change the representation of ν, and its
-                # time derivative.
-                T = jax.scipy.linalg.block_diag(B_X_W, In)
-                Ṫ = jax.scipy.linalg.block_diag(B_Ẋ_W, On)
+        case VelRepr.Body:
 
-            case VelRepr.Body:
+            B_X_B = jaxsim.math.Adjoint.from_rotation_and_translation(
+                translation=jnp.zeros(3), rotation=jnp.eye(3)
+            )
 
-                B_X_B = jaxsim.math.Adjoint.from_rotation_and_translation(
-                    translation=jnp.zeros(3), rotation=jnp.eye(3)
-                )
+            B_Ẋ_B = jnp.zeros(shape=(6, 6))
 
-                B_Ẋ_B = jnp.zeros(shape=(6, 6))
+            # Compute the operator to change the representation of ν, and its
+            # time derivative.
+            T = jax.scipy.linalg.block_diag(B_X_B, In)
+            Ṫ = jax.scipy.linalg.block_diag(B_Ẋ_B, On)
 
-                # Compute the operator to change the representation of ν, and its
-                # time derivative.
-                T = jax.scipy.linalg.block_diag(B_X_B, In)
-                Ṫ = jax.scipy.linalg.block_diag(B_Ẋ_B, On)
+        case VelRepr.Mixed:
 
-            case VelRepr.Mixed:
+            BW_H_B = W_H_B.at[0:3, 3].set(jnp.zeros(3))
+            B_X_BW = jaxsim.math.Adjoint.from_transform(transform=BW_H_B, inverse=True)
 
-                BW_H_B = W_H_B.at[0:3, 3].set(jnp.zeros(3))
-                B_X_BW = jaxsim.math.Adjoint.from_transform(
-                    transform=BW_H_B, inverse=True
-                )
+            BW_v_WB = data.base_velocity()
+            BW_v_W_BW = BW_v_WB.at[3:6].set(jnp.zeros(3))
 
-                BW_v_WB = data.base_velocity()
-                BW_v_W_BW = BW_v_WB.at[3:6].set(jnp.zeros(3))
+            BW_v_BW_B = BW_v_WB - BW_v_W_BW
+            B_Ẋ_BW = -B_X_BW @ jaxsim.math.Cross.vx(BW_v_BW_B)
 
-                BW_v_BW_B = BW_v_WB - BW_v_W_BW
-                B_Ẋ_BW = -B_X_BW @ jaxsim.math.Cross.vx(BW_v_BW_B)
+            # Compute the operator to change the representation of ν, and its
+            # time derivative.
+            T = jax.scipy.linalg.block_diag(B_X_BW, In)
+            Ṫ = jax.scipy.linalg.block_diag(B_Ẋ_BW, On)
 
-                # Compute the operator to change the representation of ν, and its
-                # time derivative.
-                T = jax.scipy.linalg.block_diag(B_X_BW, In)
-                Ṫ = jax.scipy.linalg.block_diag(B_Ẋ_BW, On)
+        case _:
+            raise ValueError(data.velocity_representation)
 
-            case _:
-                raise ValueError(data.velocity_representation)
+    # ======================================================
+    # Compute quantities to adjust the output representation
+    # ======================================================
 
-        # ======================================================
-        # Compute quantities to adjust the output representation
-        # ======================================================
+    match output_vel_repr:
 
-        match output_vel_repr:
+        case VelRepr.Inertial:
 
-            case VelRepr.Inertial:
+            O_X_B = W_X_B = jaxsim.math.Adjoint.from_transform(transform=W_H_B)
 
-                O_X_B = W_X_B = jaxsim.math.Adjoint.from_transform(transform=W_H_B)
+            with data.switch_velocity_representation(VelRepr.Body):
+                B_v_WB = data.base_velocity()
 
-                with data.switch_velocity_representation(VelRepr.Body):
-                    B_v_WB = data.base_velocity()
+            O_Ẋ_B = W_Ẋ_B = W_X_B @ jaxsim.math.Cross.vx(B_v_WB)  # noqa: F841
 
-                O_Ẋ_B = W_Ẋ_B = W_X_B @ jaxsim.math.Cross.vx(B_v_WB)  # noqa: F841
+        case VelRepr.Body:
 
-            case VelRepr.Body:
+            O_X_B = L_X_B = jaxsim.math.Adjoint.from_transform(
+                transform=B_H_L, inverse=True
+            )
 
-                O_X_B = L_X_B = jaxsim.math.Adjoint.from_transform(
-                    transform=B_H_L, inverse=True
-                )
+            B_X_L = jaxsim.math.Adjoint.inverse(adjoint=L_X_B)
 
-                B_X_L = jaxsim.math.Adjoint.inverse(adjoint=L_X_B)
+            with data.switch_velocity_representation(VelRepr.Body):
+                B_v_WB = data.base_velocity()
+                L_v_WL = jnp.einsum(
+                    "b6j,j->b6", L_X_B @ B_J_WL_B, data.generalized_velocity()
+                )
 
-                with data.switch_velocity_representation(VelRepr.Body):
-                    B_v_WB = data.base_velocity()
-                    L_v_WL = L_X_B @ B_J_WL_B @ data.generalized_velocity()
+            O_Ẋ_B = L_Ẋ_B = -L_X_B @ jaxsim.math.Cross.vx(  # noqa: F841
+                jnp.einsum("bij,bj->bi", B_X_L, L_v_WL) - B_v_WB
+            )
 
-                O_Ẋ_B = L_Ẋ_B = -L_X_B @ jaxsim.math.Cross.vx(  # noqa: F841
-                    B_X_L @ L_v_WL - B_v_WB
-                )
+        case VelRepr.Mixed:
 
-            case VelRepr.Mixed:
+            W_H_L = W_H_B @ B_H_L
+            LW_H_L = W_H_L.at[:, 0:3, 3].set(jnp.zeros_like(W_H_L[:, 0:3, 3]))
+            LW_H_B = LW_H_L @ jaxsim.math.Transform.inverse(B_H_L)
 
-                W_H_L = W_H_B @ B_H_L
-                LW_H_L = W_H_L.at[0:3, 3].set(jnp.zeros(3))
-                LW_H_B = LW_H_L @ jaxsim.math.Transform.inverse(B_H_L)
+            O_X_B = LW_X_B = jaxsim.math.Adjoint.from_transform(transform=LW_H_B)
 
-                O_X_B = LW_X_B = jaxsim.math.Adjoint.from_transform(transform=LW_H_B)
+            B_X_LW = jaxsim.math.Adjoint.inverse(adjoint=LW_X_B)
 
-                B_X_LW = jaxsim.math.Adjoint.inverse(adjoint=LW_X_B)
+            with data.switch_velocity_representation(VelRepr.Body):
+                B_v_WB = data.base_velocity()
 
-                with data.switch_velocity_representation(VelRepr.Body):
-                    B_v_WB = data.base_velocity()
+            with data.switch_velocity_representation(VelRepr.Mixed):
+                BW_H_B = W_H_B.at[0:3, 3].set(jnp.zeros(3))
+                B_X_BW = Adjoint.from_transform(transform=BW_H_B, inverse=True)
+                LW_v_WL = jnp.einsum(
+                    "bij,bj->bi",
+                    LW_X_B,
+                    B_J_WL_B
+                    @ jax.scipy.linalg.block_diag(B_X_BW, jnp.eye(model.dofs()))
+                    @ data.generalized_velocity(),
+                )
 
-                with data.switch_velocity_representation(VelRepr.Mixed):
-                    BW_H_B = W_H_B.at[0:3, 3].set(jnp.zeros(3))
-                    B_X_BW = Adjoint.from_transform(transform=BW_H_B, inverse=True)
-                    LW_v_WL = LW_X_B @ (
-                        B_J_WL_B
-                        @ jax.scipy.linalg.block_diag(B_X_BW, jnp.eye(model.dofs()))
-                        @ data.generalized_velocity()
-                    )
-                    LW_v_W_LW = LW_v_WL.at[3:6].set(jnp.zeros(3))
+                LW_v_W_LW = LW_v_WL.at[:, 3:6].set(jnp.zeros_like(LW_v_WL[:, 3:6]))
 
-                LW_v_LW_L = LW_v_WL - LW_v_W_LW
-                LW_v_B_LW = LW_v_WL - LW_X_B @ B_v_WB - LW_v_LW_L
+            LW_v_LW_L = LW_v_WL - LW_v_W_LW
+            LW_v_B_LW = LW_v_WL - jnp.einsum("bij,j->bi", LW_X_B, B_v_WB) - LW_v_LW_L
 
-                O_Ẋ_B = LW_Ẋ_B = -LW_X_B @ jaxsim.math.Cross.vx(  # noqa: F841
-                    B_X_LW @ LW_v_B_LW
-                )
-            case _:
-                raise ValueError(output_vel_repr)
+            O_Ẋ_B = LW_Ẋ_B = -LW_X_B @ jaxsim.math.Cross.vx(  # noqa: F841
+                jnp.einsum("bij,bj->bi", B_X_LW, LW_v_B_LW)
+            )
 
-        # =============================================================
-        # Express the Jacobian derivative in the target representations
-        # =============================================================
+        case _:
+            raise ValueError(output_vel_repr)
 
-        # Sum all the components that form the Jacobian derivative in the target
-        # input/output velocity representations.
-        O_J̇_WL_I = jnp.zeros(shape=(6, 6 + model.dofs()))
-        O_J̇_WL_I += O_Ẋ_B @ B_J_WL_B @ T
-        O_J̇_WL_I += O_X_B @ B_J̇_WL_B @ T
-        O_J̇_WL_I += O_X_B @ B_J_WL_B @ Ṫ
+    # =============================================================
+    # Express the Jacobian derivative in the target representations
+    # =============================================================
 
-        return O_J̇_WL_I
+    # Sum all the components that form the Jacobian derivative in the target
+    # input/output velocity representations.
+    O_J̇_WL_I = jnp.zeros_like(B_J̇_WL_B)
+    O_J̇_WL_I += O_Ẋ_B @ B_J_WL_B @ T
+    O_J̇_WL_I += O_X_B @ B_J̇_WL_B @ T
+    O_J̇_WL_I += O_X_B @ B_J_WL_B @ Ṫ
 
-    return _compute_row(B_H_L, B_J_full_WL_B, W_H_B, κb)
+    return O_J̇_WL_I
 
 
 @functools.partial(jax.jit, static_argnames=["prefer_aba"])

jaxsim/math/adjoint.py

@@ -56,14 +56,13 @@ class Adjoint:
             The 6x6 adjoint matrix.
         """
 
-        A_H_B = jnp.array(transform).astype(float)
-        assert transform.shape == (4, 4)
+        A_H_B = jnp.reshape(transform, (-1, 4, 4))
 
         return (
             jaxlie.SE3.from_matrix(matrix=A_H_B).adjoint()
             if not inverse
             else jaxlie.SE3.from_matrix(matrix=A_H_B).inverse().adjoint()
-        )
+        ).reshape(transform.shape[:-2] + (6, 6))
 
     @staticmethod
     def from_rotation_and_translation(
@@ -145,13 +144,18 @@ class Adjoint:
         Returns:
             jtp.Matrix: The inverse adjoint matrix.
         """
-        A_X_B = adjoint
+        A_X_B = adjoint.reshape(-1, 6, 6)
 
-        A_R_B = A_X_B[0:3, 0:3]
+        A_R_B_T = jnp.swapaxes(A_X_B[..., 0:3, 0:3], -2, -1)
+        A_T_B = A_X_B[..., 0:3, 3:6]
 
-        return jnp.vstack(
+        return jnp.concatenate(
             [
-                jnp.block([A_R_B.T, -A_R_B.T @ A_X_B[0:3, 3:6] @ A_R_B.T]),
-                jnp.block([jnp.zeros(shape=(3, 3)), A_R_B.T]),
-            ]
-        )
+                jnp.concatenate(
+                    [A_R_B_T, -A_R_B_T @ A_T_B @ A_R_B_T],
+                    axis=-1,
+                ),
+                jnp.concatenate([jnp.zeros_like(A_R_B_T), A_R_B_T], axis=-1),
+            ],
+            axis=-2,
+        ).reshape(adjoint.shape)

jaxsim/math/cross.py

@@ -24,13 +24,18 @@ class Cross:
         Raises:
             ValueError: If the input vector does not have a size of 6.
         """
-        v, ω = jnp.split(velocity_sixd.squeeze(), 2)
+        velocity_sixd = velocity_sixd.reshape(-1, 6)
 
-        v_cross = jnp.vstack(
+        v, ω = jnp.split(velocity_sixd, 2, axis=-1)
+
+        v_cross = jnp.concatenate(
             [
-                jnp.block([Skew.wedge(vector=ω), Skew.wedge(vector=v)]),
-                jnp.block([jnp.zeros(shape=(3, 3)), Skew.wedge(vector=ω)]),
-            ]
+                jnp.concatenate(
+                    [Skew.wedge(ω), jnp.zeros((ω.shape[0], 3, 3)).squeeze()], axis=-2
+                ),
+                jnp.concatenate([Skew.wedge(v), Skew.wedge(ω)], axis=-2),
+            ],
+            axis=-1,
         )
 
         return v_cross

jaxsim/math/skew.py

@@ -20,9 +20,20 @@ class Skew:
             jtp.Matrix: The skew-symmetric matrix corresponding to the input vector.
 
         """
-        vector = vector.squeeze()
-        x, y, z = vector
-        skew = jnp.array([[0, -z, y], [z, 0, -x], [-y, x, 0]])
+
+        vector = vector.reshape(-1, 3)
+
+        x, y, z = jnp.split(vector, 3, axis=-1)
+
+        skew = jnp.stack(
+            [
+                jnp.concatenate([jnp.zeros_like(x), -z, y], axis=-1),
+                jnp.concatenate([z, jnp.zeros_like(x), -x], axis=-1),
+                jnp.concatenate([-y, x, jnp.zeros_like(x)], axis=-1),
+            ],
+            axis=-2,
+        ).squeeze()
+
         return skew
 
     @staticmethod

jaxsim/math/transform.py

@@ -92,7 +92,11 @@ class Transform:
             The 4x4 inverse transformation matrix.
         """
 
-        A_H_B = jnp.array(transform).astype(float)
-        assert A_H_B.shape == (4, 4)
+        A_H_B = jnp.reshape(transform, (-1, 4, 4))
 
-        return jaxlie.SE3.from_matrix(matrix=A_H_B).inverse().as_matrix()
+        return (
+            jaxlie.SE3.from_matrix(matrix=A_H_B)
+            .inverse()
+            .as_matrix()
+            .reshape(transform.shape[:-2] + (4, 4))
+        )

jaxsim/parsers/rod/parser.py

@@ -184,21 +184,16 @@ def extract_model_data(
             msg = "Found more/less than one joint connecting a fixed-base model to the world"
             raise ValueError(msg + f": {[j.name for j in joints_with_world_parent]}")
 
+        base_link_name = joints_with_world_parent[0].child.name
+
         msg = "Combining the pose of base link '{}' with the pose of joint '{}'"
-        logging.info(
-            msg.format(
-                joints_with_world_parent[0].child.name, joints_with_world_parent[0].name
-            )
-        )
+        logging.info(msg.format(base_link_name, joints_with_world_parent[0].name))
 
         # Combine the pose of the base link (child of the found fixed joint)
         # with the pose of the fixed joint connecting with the world.
         # Note: we assume it's a fixed joint and ignore any joint angle.
-        links_dict[joints_with_world_parent[0].child.name].mutable(
-            validate=False
-        ).pose = (
-            joints_with_world_parent[0].pose
-            @ links_dict[joints_with_world_parent[0].child.name].pose
+        links_dict[base_link_name].mutable(validate=False).pose = (
+            joints_with_world_parent[0].pose @ links_dict[base_link_name].pose
         )
 
     # ============

{jaxsim-0.5.1.dev152.dist-info → jaxsim-0.5.1.dev162.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: jaxsim
-Version: 0.5.1.dev152
+Version: 0.5.1.dev162
 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.5.1.dev152.dist-info → jaxsim-0.5.1.dev162.dist-info}/RECORD

@@ -1,5 +1,5 @@
 jaxsim/__init__.py,sha256=_8rbKOf3bwx-2ChEbspZxs_rZY0RqUcmWAftnEw1bfM,3401
-jaxsim/_version.py,sha256=lQMt9-pwwpq6SlxCWPFxr7iHlew8qJBtqHeCoTcanQ8,428
+jaxsim/_version.py,sha256=8QuGLnqz-kXxxCP-wBdBXg6CoA7Wuusf_61wf2qVq2s,428
 jaxsim/exceptions.py,sha256=qjfTjE9lXvD3-JCPQcxxiX2XSS8QegawzQ6ZuC2tc0Y,2638
 jaxsim/logging.py,sha256=STI-D_upXZYX-ZezLrlJJ0UlD5YspST0vZ_DcIwkzO4,1553
 jaxsim/typing.py,sha256=7msl8t5Jt09RNYfKdPJtpjLfWurldcycDappb045Eso,761
@@ -12,7 +12,7 @@ jaxsim/api/frame.py,sha256=d6pa6vywGDqfaJU76F_-yjLJs6R3mrjZ6B-KXPu6f3Q,14595
 jaxsim/api/joint.py,sha256=AnqlNWmBOay-gsoo0y4AbfFQ2OCJm-8T1E0IMhZeLoY,7457
 jaxsim/api/kin_dyn_parameters.py,sha256=BaOp7ICxWosDIdWVjh8-cdlX8mXM9IM8wzy2fHz8Ufc,30444
 jaxsim/api/link.py,sha256=nHjffhNdi_xGkteMsqdb_hC9mdV9rNw7k3pl89Uhw_8,12798
-jaxsim/api/model.py,sha256=LSdPk1NrBHEP4avKh3K0ANIXkPHVF1AyzZj8TfDiQ00,80162
+jaxsim/api/model.py,sha256=27U_3JxEvbCyPox76h2uxIKnpFHahxsGZCYZQy1vXf4,79859
 jaxsim/api/ode.py,sha256=XFi3gGRU2s-hqOpZEAuk7o4cxEa871V1LmGcvT5wf10,16056
 jaxsim/api/ode_data.py,sha256=ggF1AVaLW5QuXrfpNsFs-voVcW6gZkxK2Xe9GiDmou0,13755
 jaxsim/api/references.py,sha256=YkdZhRv8NoBC94qvpwn1w9_alVuxrfiZV5w5NHQIt-g,20737
@@ -21,14 +21,14 @@ jaxsim/integrators/common.py,sha256=sXc0HLmqiGluU-ffsNcAxVO-UA4QzS96pjef5N-5rHI,
 jaxsim/integrators/fixed_step.py,sha256=roiRR1evnQMPmdvY5D_iRHTYlbOvkG4CM6JDSqlmTAU,4034
 jaxsim/integrators/variable_step.py,sha256=pMYiMbaqQTlq2VF4Ca78ovxU06lMF1mrnrfzAahtvcg,24577
 jaxsim/math/__init__.py,sha256=2T1WUU_chNBCvyvkKSdiesPlckbo-gXVbCZEGoF-W0I,381
-jaxsim/math/adjoint.py,sha256=AT1iDFnryGxpulSZUpzl0kmm85fYo_3fN_smK_29mSc,4808
-jaxsim/math/cross.py,sha256=ihL1Ss2XCqf6IiaRFfu5IvAVE4txrNZt0CZEYdf_UvM,1378
+jaxsim/math/adjoint.py,sha256=ccXuF9jnMLpGhQ3vg1hu7V6zUz8D3rVMhj-bongdk9c,5019
+jaxsim/math/cross.py,sha256=brlzoThCzQAHmuHubh1N_CLtvP5asR4iWXp-I1HAYFc,1522
 jaxsim/math/inertia.py,sha256=Bh92FlJvJMMZg8825mzEzV3sHAAufJOSaQST1ZnzgSQ,1631
 jaxsim/math/joint_model.py,sha256=EzAveaG5B6ZnCFNUzN30KEQUVesd83lfWXJarYR-kUw,9989
 jaxsim/math/quaternion.py,sha256=fO3VNrIoZrcchCXCv_Zn2Ad6-rcgrNzysRrn5raQWJE,4595
 jaxsim/math/rotation.py,sha256=bl9WCbYyLKg6RyRkMaEBBTmARBs8pB-FGR0JVbfbaNE,2187
-jaxsim/math/skew.py,sha256=FeyKPMxrGzf6c4fohLR-24deYutetT1jw2r43q2yJEo,1151
-jaxsim/math/transform.py,sha256=ZIhcHa9KCxBWyDj_UTiy8qOfhavOtIaDK6aAofyx28M,3267
+jaxsim/math/skew.py,sha256=P82yeQs9Fzb7Ri_MAikcb54_06cE_syi9yPssSg4ydw,1426
+jaxsim/math/transform.py,sha256=We0ChLajSckxGINiJsP1a5Ur3yjg3JuweQ3kK4Woix4,3332
 jaxsim/math/utils.py,sha256=2id1F6QOvkHkIF3Nuxuj_tz_kI0IYlrlgVQrETmXFfI,1058
 jaxsim/mujoco/__init__.py,sha256=fZyRWre49pIhOrYdf6yJk_hOax8qWGe8OCmoq-dMVq8,201
 jaxsim/mujoco/__main__.py,sha256=GBmB7J-zj75ZnFyuAAmpSOpbxi_HhHhWJeot3ljGDJY,5291
@@ -45,7 +45,7 @@ jaxsim/parsers/descriptions/link.py,sha256=Eh0W5qL7_Uw0GV-BkNKXhm9Q2dRTfIWCX5D-8
 jaxsim/parsers/descriptions/model.py,sha256=G7nYy4CTppj2NM7hTXP6xGJ2h5dwT41N1fsy0EYSIBk,9860
 jaxsim/parsers/rod/__init__.py,sha256=G2vqlLajBLUc4gyzXwsEI2Wsi4TMOIF9bLDFeT6KrGU,92
 jaxsim/parsers/rod/meshes.py,sha256=yAXefG73_zqbVKRUdlcz9yFmypjDIpiP9cO96PeAozE,2842
-jaxsim/parsers/rod/parser.py,sha256=9s2wImok8X-s6F8nPFq2vVZ2Ph_o6Q0q9c-HrZ0Z6LU,14498
+jaxsim/parsers/rod/parser.py,sha256=2AxRimQeYHHrdWLJrzXxPX9TUMOhuv10lqptfvG6wMQ,14405
 jaxsim/parsers/rod/utils.py,sha256=Wb1TsZ2v0VgmswYqI5hHRtGQx4ttWK8luWO9cvllTEk,8117
 jaxsim/rbda/__init__.py,sha256=kmy4G9aMkrqPNGdLSaSV3k15dpF52vBEUQXDFDuKIxU,337
 jaxsim/rbda/aba.py,sha256=w7ciyxB0IsmueatT0C7PcBQEl9dyiH9oqJgIi3xeTUE,8983
@@ -67,8 +67,8 @@ jaxsim/utils/__init__.py,sha256=Y5zyoRevl3EMVQadhZ4EtSwTEkDt2vcnFoRhPJjKTZ0,215
 jaxsim/utils/jaxsim_dataclass.py,sha256=Fxa555u14VUsVlKU1rBQFurrVzBp7BNsIaVoNko0lrI,11261
 jaxsim/utils/tracing.py,sha256=Btwxdfhb7fJLk3r5PlQkGYj60Y2KbFT1gANGIA697FU,530
 jaxsim/utils/wrappers.py,sha256=3IMwydqFgmSPqeuUQ3PRmdhDc1IoT6XC23jPC_LjWXs,4175
-jaxsim-0.5.1.dev152.dist-info/LICENSE,sha256=eaYdFmdeMbiIoIiPzEK0MjP1S9wtFXjXNR5er49uLR0,1546
-jaxsim-0.5.1.dev152.dist-info/METADATA,sha256=DDO-Gs3iNzDegC301s_FgjcFRDx5pnRUqKuGou0Jilg,20201
-jaxsim-0.5.1.dev152.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-jaxsim-0.5.1.dev152.dist-info/top_level.txt,sha256=LxGMA8FLtXjQ6oI7N5gd_R_oSUHxpXxUEOfT1xS_ni0,7
-jaxsim-0.5.1.dev152.dist-info/RECORD,,
+jaxsim-0.5.1.dev162.dist-info/LICENSE,sha256=eaYdFmdeMbiIoIiPzEK0MjP1S9wtFXjXNR5er49uLR0,1546
+jaxsim-0.5.1.dev162.dist-info/METADATA,sha256=wTvjnAVIQsrTkLMobZelHHT00X4EEGn85JfeLx9MTi0,20201
+jaxsim-0.5.1.dev162.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+jaxsim-0.5.1.dev162.dist-info/top_level.txt,sha256=LxGMA8FLtXjQ6oI7N5gd_R_oSUHxpXxUEOfT1xS_ni0,7
+jaxsim-0.5.1.dev162.dist-info/RECORD,,