jaxsim 0.1rc0__py3-none-any.whl → 0.2.0__py3-none-any.whl

jaxsim-0.2.0.dist-info/METADATA

@@ -0,0 +1,237 @@
+Metadata-Version: 2.1
+Name: jaxsim
+Version: 0.2.0
+Summary: A differentiable physics engine and multibody dynamics library for control and robot learning.
+Home-page: https://github.com/ami-iit/jaxsim
+Author: Diego Ferigo
+Author-email: diego.ferigo@iit.it
+License: BSD
+Project-URL: Changelog, https://github.com/ami-iit/jaxsim/releases
+Project-URL: Documentation, https://jaxsim.readthedocs.io
+Project-URL: Source, https://github.com/ami-iit/jaxsim
+Project-URL: Tracker, https://github.com/ami-iit/jaxsim/issues
+Keywords: physics,physics engine,jax,rigid body dynamics,featherstone,reinforcement learning,robot,robotics,sdf,urdf
+Platform: any
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Robot Framework
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Games/Entertainment :: Simulation
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Software Development
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: coloredlogs
+Requires-Dist: jax >=0.4.13
+Requires-Dist: jaxlib >=0.4.13
+Requires-Dist: jaxlie >=1.3.0
+Requires-Dist: jax-dataclasses >=1.4.0
+Requires-Dist: pptree
+Requires-Dist: rod >=0.2.0
+Requires-Dist: typing-extensions ; python_version < "3.12"
+Provides-Extra: all
+Requires-Dist: black[jupyter] ~=24.0 ; extra == 'all'
+Requires-Dist: isort ; extra == 'all'
+Requires-Dist: pre-commit ; extra == 'all'
+Requires-Dist: idyntree ; extra == 'all'
+Requires-Dist: pytest >=6.0 ; extra == 'all'
+Requires-Dist: pytest-icdiff ; extra == 'all'
+Requires-Dist: robot-descriptions ; extra == 'all'
+Requires-Dist: lxml ; extra == 'all'
+Requires-Dist: mediapy ; extra == 'all'
+Requires-Dist: mujoco >=3.0.0 ; extra == 'all'
+Provides-Extra: style
+Requires-Dist: black[jupyter] ~=24.0 ; extra == 'style'
+Requires-Dist: isort ; extra == 'style'
+Requires-Dist: pre-commit ; extra == 'style'
+Provides-Extra: testing
+Requires-Dist: idyntree ; extra == 'testing'
+Requires-Dist: pytest >=6.0 ; extra == 'testing'
+Requires-Dist: pytest-icdiff ; extra == 'testing'
+Requires-Dist: robot-descriptions ; extra == 'testing'
+Provides-Extra: viz
+Requires-Dist: lxml ; extra == 'viz'
+Requires-Dist: mediapy ; extra == 'viz'
+Requires-Dist: mujoco >=3.0.0 ; extra == 'viz'
+
+# JaxSim
+
+JaxSim is a **differentiable physics engine** and **multibody dynamics library** designed for applications in control and robot learning, implemented with JAX.
+
+Its design facilitates research and accelerates prototyping in the intersection of robotics and artificial intelligence. 
+
+## Features
+
+- Physics engine in reduced coordinates supporting fixed-base and floating-base robots.
+- Multibody dynamics library providing all the necessary components for developing model-based control algorithms.
+- Completely developed in Python with [`google/jax`][jax] following a functional programming paradigm.
+- Transparent support for running on CPUs, GPUs, and TPUs.
+- Full support for JIT compilation for increased performance.
+- Full support for automatic vectorization for massive parallelization of open-loop and closed-loop architectures.
+- Support for SDF models and, upon conversion with [sdformat][sdformat], URDF models.
+- Visualization based on the [passive viewer][passive_viewer_mujoco] of Mujoco.
+
+### JaxSim as a simulator
+
+- Wide range of fixed-step explicit Runge-Kutta integrators.
+- Support for variable-step integrators implemented as embedded Runge-Kutta schemes.
+- Improved stability by optionally integrating the base orientation on the $\text{SO}(3)$ manifold.
+- Soft contacts model supporting full friction cone and sticking-slipping transition.
+- Collision detection between points rigidly attached to bodies and uneven ground surfaces.
+
+### JaxSim as a multibody dynamics library
+
+- Provides rigid body dynamics algorithms (RBDAs) like RNEA, ABA, CRBA, and Jacobians. 
+- Provides all the quantities included in the Euler-Poincarè formulation of the equations of motion.
+- Supports body-fixed, inertial-fixed, and mixed [velocity representations][notation].
+- Exposes all the necessary quantities to develop controllers in centroidal coordinates.
+
+### JaxSim for robot learning
+
+- Being developed with JAX, all the RBDAs support automatic differentiation both in forward and reverse modes.
+- Support for automatically differentiating against kinematics and dynamics parameters.
+- All fixed-step integrators are forward and reverse differentiable.
+- All variable-step integrators are forward differentiable.
+- Ideal for sampling synthetic data for reinforcement learning (RL).
+- Ideal for designing physics-informed neural networks (PINNs) with loss functions requiring model-based quantities.
+- Ideal for combining model-based control with learning-based components.
+
+[jax]: https://github.com/google/jax/
+[sdformat]: https://github.com/gazebosim/sdformat
+[notation]: https://research.tue.nl/en/publications/multibody-dynamics-notation-version-2
+[passive_viewer_mujoco]: https://mujoco.readthedocs.io/en/stable/python.html#passive-viewer
+
+> [!WARNING]
+> This project is still experimental, APIs could change between releases without notice.
+
+> [!NOTE]
+> JaxSim currently focuses on locomotion applications.
+> Only contacts between bodies and smooth ground surfaces are supported.
+
+## Documentation
+
+The JaxSim API documentation is available at [jaxsim.readthedocs.io][readthedocs].
+
+[readthedocs]: https://jaxsim.readthedocs.io/
+
+## Installation
+
+<details>
+<summary>With conda</summary>
+
+You can install the project using [`conda`][conda] as follows:
+
+```bash
+conda install jaxsim -c conda-forge
+```
+
+You can enforce GPU support, if needed, by also specifying `"jaxlib = * = *cuda*"`.
+
+</details>
+
+<details>
+<summary>With pip</summary>
+
+You can install the project using [`pypa/pip`][pip], preferably in a [virtual environment][venv], as follows:
+
+```bash
+pip install jaxsim
+```
+
+Check [`setup.cfg`](setup.cfg) for the complete list of optional dependencies.
+You can obtain a full installation using `jaxsim[all]`.
+
+If you need GPU support, follow the official [installation instructions][jax_gpu] of JAX.
+
+</details>
+
+<details>
+<summary>Contributors installation</summary>
+
+If you want to contribute to the project, we recommend creating the following `jaxsim` conda environment first:
+
+```bash
+conda env create -f environment.yml
+```
+
+Then, activate the environment and install the project in editable mode:
+
+```bash
+conda activate jaxsim
+pip install --no-deps -e .
+```
+
+</details>
+
+[conda]: https://anaconda.org/
+[pip]: https://github.com/pypa/pip/
+[venv]: https://docs.python.org/3/tutorial/venv.html
+[jax_gpu]: https://github.com/google/jax/#installation
+
+## Credits
+
+The RBDAs are based on the theory of the [Rigid Body Dynamics Algorithms][RBDA]
+book by Roy Featherstone.
+The algorithms and some simulation features were inspired by its accompanying [code][spatial_v2].
+
+[RBDA]: https://link.springer.com/book/10.1007/978-1-4899-7560-7
+[spatial_v2]: http://royfeatherstone.org/spatial/index.html#spatial-software
+
+The development of JaxSim started in late 2021, inspired by early versions of [`google/brax`][brax].
+At that time, Brax was implemented in maximal coordinates, and we wanted a physics engine in reduced coordinates.
+We are grateful to the Brax team for their work and showing the potential of [JAX][jax] in this field.
+
+Brax v2 was later implemented reduced coordinates, following an approach comparable to JaxSim.
+The development then shifted to [MJX][mjx], which today provides a JAX-based implementation of the Mujoco APIs.
+
+The main differences between MJX/Brax and JaxSim are as follows:
+
+- JaxSim supports out-of-the-box all SDF models with [Pose Frame Semantics][PFS].
+- JaxSim only supports collisions between points rigidly attached to bodies and a compliant ground surface.
+  Our contact model requires careful tuning of its spring-damper parameters, but being an instantaneous  
+  function of the state $(\mathbf{q}, \boldsymbol{\nu})$, it doesn't require running any optimization algorithm
+  when stepping the simulation forward.
+- JaxSim mitigates the stiffness of the contact-aware system dynamics by providing variable-step integrators. 
+
+[brax]: https://github.com/google/brax
+[mjx]: https://mujoco.readthedocs.io/en/3.0.0/mjx.html
+[PFS]: http://sdformat.org/tutorials?tut=pose_frame_semantics
+
+## Contributing
+
+We welcome contributions from the community.
+Please read the [contributing guide](./CONTRIBUTING.md) to get started.
+
+## Citing
+
+```bibtex
+@software{ferigo_jaxsim_2022,
+  author = {Diego Ferigo and Filippo Luca Ferretti and Silvio Traversaro and Daniele Pucci},
+  title = {{JaxSim}: A Differentiable Physics Engine and Multibody Dynamics Library for Control and Robot Learning},
+  url = {http://github.com/ami-iit/jaxsim},
+  year = {2022},
+}
+```
+
+## People
+
+| Author | Maintainers |
+|:------:|:-----------:|
+| [<img src="https://avatars.githubusercontent.com/u/469199?v=4" width="40">][df] | [<img src="https://avatars.githubusercontent.com/u/102977828?v=4" width="40">][ff] [<img src="https://avatars.githubusercontent.com/u/469199?v=4" width="40">][df] |
+
+[df]: https://github.com/diegoferigo
+[ff]: https://github.com/flferretti
+
+## License
+
+[BSD3](https://choosealicense.com/licenses/bsd-3-clause/)

jaxsim-0.2.0.dist-info/RECORD

@@ -0,0 +1,64 @@
+jaxsim/__init__.py,sha256=OcrfoYS1DGcmAGqu2AqlCTiUVxcpi-IsVwcr_16x74Q,1789
+jaxsim/_version.py,sha256=H-qsvrxCpdhaQzyddR-yajEqI71hPxLa4KxzpP3uS1g,411
+jaxsim/logging.py,sha256=c4zhwBKf9eAYAHVp62kTEllqdsZgh0K-kPKVy8L3elU,1584
+jaxsim/typing.py,sha256=MeuOCQtLAr-sPkvB_sU8FtwGNRirz1auCwIgRC-QZl8,646
+jaxsim/api/__init__.py,sha256=fNTCPUeDfOAizRd4RsW3Epv0sLTu0KJGoFRSEsi75VM,162
+jaxsim/api/com.py,sha256=Qtm_6qpiK4WtDVn6JMUHa8DySgBl9CjgKCybJqZ58Lc,7379
+jaxsim/api/common.py,sha256=DV-WZG28sikXopNv458aYvpLjmiAtFr5LRscOwXusuk,6640
+jaxsim/api/contact.py,sha256=Ve4ZOWkLEBRgK3KhtICxKY7YzsxYvc3lO-pPRBjqSnY,8659
+jaxsim/api/data.py,sha256=cPFy6TTm0rNpDk1O0ZxOpvBwWVPu6V14XLRMeC7x81Q,26786
+jaxsim/api/joint.py,sha256=q31Kp3Cqv-yTcxijjzbj_QADFnGQyjb2al9fYZtzedo,4763
+jaxsim/api/kin_dyn_parameters.py,sha256=G4mtSi8fElYe0yttLgsxSOPf7vcK-yqTu06Aa5SSrYg,26012
+jaxsim/api/link.py,sha256=rypTwkMf9HJ5UuAtHRJh0LqqdJWcLKTtTjWcjduEsF0,9842
+jaxsim/api/model.py,sha256=UwjZctpQR_3F8_Cm-NmFQb14Wtw_vscs3Yg-ULpQyrs,52269
+jaxsim/api/ode.py,sha256=6l-6i2YHagsQvR8Ac-_fmO6P0hBVT6NkHhwXnrdITEg,9785
+jaxsim/api/ode_data.py,sha256=dwRFVPJ30XMmdUbPXEu7YxsQ97jZP4L4fd5ZzhrO5Ys,22184
+jaxsim/api/references.py,sha256=Lvskf17r619KKxwCJP7hAAty2kaXgDXJX1uKqoDIDgo,15483
+jaxsim/integrators/__init__.py,sha256=hxvOD-VK_mmd6v31wtC-nb28AYve1gLuZCNLV9wS-Kg,103
+jaxsim/integrators/common.py,sha256=9HXRVFo95Mpt6RcVhBrOfvOO7mDxqbkXeg_lKUibEFY,20693
+jaxsim/integrators/fixed_step.py,sha256=JXaEyEzfSiYea0GnPA7l27J3X0YPB0e25D4qfrxAvzQ,2766
+jaxsim/integrators/variable_step.py,sha256=jq3PStzFiMciU7lux6CTj4B3gVOfSpYgK2oz2yzIbdo,21380
+jaxsim/math/__init__.py,sha256=inJ9nRFkqstuGa8OyFkfWVudo5U9Ug4WgDBuKva8AIA,337
+jaxsim/math/adjoint.py,sha256=DT21izjVW497GRrgNfx8tv0ZeWW5QncWMGMhI0acUNw,4425
+jaxsim/math/cross.py,sha256=U7yEx_l75mSy5g6O-jsjBztApvxC3WaV4MpkS5tThu4,1330
+jaxsim/math/inertia.py,sha256=UAB7ym4gXFanejcs_ovZMpteHCc6poWYmt-mLmd5hhk,1640
+jaxsim/math/joint_model.py,sha256=LKLB26VMz6vx9JLdFUWhGyrElYFEQV-bJiQO5kaZUGY,10896
+jaxsim/math/quaternion.py,sha256=X9b8jHf0QemKUjIZSnXRJc3DdMr42CBhBy_mi9_X_AM,5068
+jaxsim/math/rotation.py,sha256=Z90daUjGpuNEVLfWB3SVtM9EtwAIaneVj9A9UpWXqhA,2182
+jaxsim/math/skew.py,sha256=oOGSSR8PUGROl6IJFlrmu6K3gPH-u16hUPfKIkcVv9o,1177
+jaxsim/math/transform.py,sha256=boeuN8df4Yd9NvS64g-xUYoNqG91YafYLam4iITFJVg,2917
+jaxsim/mujoco/__init__.py,sha256=Zo5GAlN1DYKvX8s1hu1j6HntKIbBMLB9Puv9ouaNAZ8,158
+jaxsim/mujoco/__main__.py,sha256=GBmB7J-zj75ZnFyuAAmpSOpbxi_HhHhWJeot3ljGDJY,5291
+jaxsim/mujoco/loaders.py,sha256=8_2jB6DjGyFGPQS6mTs_1JH37Wd6mSiWP8rlNTuB6Uo,21029
+jaxsim/mujoco/model.py,sha256=5-4KTbEbU19zjrSuvUVdLo3noWxTvlCNsFIs3rQTNDY,13506
+jaxsim/mujoco/visualizer.py,sha256=YlteqcCbeB1B6saAHKBz1IJad3N5Rp163reZrzKLAys,5065
+jaxsim/parsers/__init__.py,sha256=sonYi-bBWAoB04kp1mxT4uIORxjb7SdZ0ukGPmVx98Y,44
+jaxsim/parsers/kinematic_graph.py,sha256=_ZJr-u1m64qPCeY6BHTI56dSOWhOGfbg2HN49XbTXhA,23784
+jaxsim/parsers/descriptions/__init__.py,sha256=EbTfnrK3oCxA3pNv--YUwllJ6uICENvFgAdRbYtS9ts,238
+jaxsim/parsers/descriptions/collision.py,sha256=HUWwuRgI9KznY29FFw1_zU3bGigDEezrcPOJSxSJGNU,3382
+jaxsim/parsers/descriptions/joint.py,sha256=hpH0ANvIhbEQk-NGRmWIvPv3lXW385TBIMWNgz5rzM4,4106
+jaxsim/parsers/descriptions/link.py,sha256=hqLLitrAXnouia6ULk1BPOIEfRxrXwHmoPsi306IZW8,2859
+jaxsim/parsers/descriptions/model.py,sha256=wenuDrjoBf6prkzm9WyYT0nFWc0l6WBpKNjLoRUDPxo,8937
+jaxsim/parsers/rod/__init__.py,sha256=G2vqlLajBLUc4gyzXwsEI2Wsi4TMOIF9bLDFeT6KrGU,92
+jaxsim/parsers/rod/parser.py,sha256=mFi1baSJte6EMmWLpVjVuCpicfAAF48aFUzoKzYzPpo,12555
+jaxsim/parsers/rod/utils.py,sha256=xoxNdb4IgOePFFnblNo6UrgYCRm53mB3No3yXM6qlpw,6471
+jaxsim/rbda/__init__.py,sha256=HLwxeU-IxaRpFGUCSQv-LDv20JHTt3Xj7ELiRbRieS8,319
+jaxsim/rbda/aba.py,sha256=0OoCzHhf1v-qqr1y5PIrD7_mPwAlid0fjXxUrIa5E_s,9118
+jaxsim/rbda/collidable_points.py,sha256=4ZNJbEj2nEi15jBLR-GNbdaqKgkN58FBgqd_TXupEgg,4948
+jaxsim/rbda/crba.py,sha256=GodskOZjtrSlbQAqxRv1un_706O7BaJK-U2qa18vJk8,4741
+jaxsim/rbda/forward_kinematics.py,sha256=OHugNU7C0UxYAW0o1rqH1ZgniSwurz6L1T1MJxfxq08,3418
+jaxsim/rbda/jacobian.py,sha256=9LGGy9ya5m5U0mBmV1NFH5XYZpEMYbx74qnYBvZs7Ok,6360
+jaxsim/rbda/rnea.py,sha256=DjwkvXQVUSUclM3Uy3UPZ2tao91R5dGd4o7TsS2qObI,7650
+jaxsim/rbda/soft_contacts.py,sha256=2EZ9Lw4nFWqXTMEeYsirl17H61s82SmTZllKVsP1Yek,10759
+jaxsim/rbda/utils.py,sha256=zpbFM2Iq8cntku0BFVu9nfEqZhInCWi9D2INT6MFEI8,5003
+jaxsim/terrain/__init__.py,sha256=f7lVX-iNpH_wkkjef9Qpjh19TTAUOQw76EiLYJDVizc,78
+jaxsim/terrain/terrain.py,sha256=q0xkWqEShVq-p1j2abTLZq8sEhjyJwquxQKm80PaHhM,2161
+jaxsim/utils/__init__.py,sha256=tnQq1_CavdfeKaLYt3pmO7Jk4MU2RwwQU_qICkjyoTY,197
+jaxsim/utils/hashless.py,sha256=bFIwKeo9KiWwsY8QM55duEGGQOyyJ4jQyPcuqTLEp5k,297
+jaxsim/utils/jaxsim_dataclass.py,sha256=T8nZolb563mYJD7YvTmYW-z-hpkEiaK3cDbYHqwtqRc,11347
+jaxsim/utils/tracing.py,sha256=KDMoyVPlu2NJvFkhtZwq5AkqMMgajt3munvJom-vEjQ,650
+jaxsim-0.2.0.dist-info/LICENSE,sha256=eaYdFmdeMbiIoIiPzEK0MjP1S9wtFXjXNR5er49uLR0,1546
+jaxsim-0.2.0.dist-info/METADATA,sha256=t2ADrolAYSNA-5JfwxlYJgN-Em_Bb8SGw2vQs0Hp-8w,9773
+jaxsim-0.2.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+jaxsim-0.2.0.dist-info/top_level.txt,sha256=LxGMA8FLtXjQ6oI7N5gd_R_oSUHxpXxUEOfT1xS_ni0,7
+jaxsim-0.2.0.dist-info/RECORD,,

{jaxsim-0.1rc0.dist-info → jaxsim-0.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

jaxsim/high_level/__init__.py

@@ -1,2 +0,0 @@
-from . import common, joint, link, model
-from .common import VelRepr

jaxsim/high_level/common.py

@@ -1,11 +0,0 @@
-import enum
-
-
-class VelRepr(enum.IntEnum):
-    """
-    Enumeration of all supported 6D velocity representations.
-    """
-
-    Body = enum.auto()
-    Mixed = enum.auto()
-    Inertial = enum.auto()

jaxsim/high_level/joint.py

@@ -1,148 +0,0 @@
-import dataclasses
-import functools
-from typing import Any
-
-import jax.numpy as jnp
-import jax_dataclasses
-from jax_dataclasses import Static
-
-import jaxsim.parsers
-import jaxsim.typing as jtp
-from jaxsim.utils import Vmappable, not_tracing, oop
-
-
-@jax_dataclasses.pytree_dataclass
-class Joint(Vmappable):
-    """
-    High-level class to operate in r/o on a single joint of a simulated model.
-    """
-
-    joint_description: Static[jaxsim.parsers.descriptions.JointDescription]
-
-    _parent_model: Any = dataclasses.field(
-        default=None, repr=False, compare=False, hash=False
-    )
-
-    @property
-    def parent_model(self) -> "jaxsim.high_level.model.Model":
-        """"""
-
-        return self._parent_model
-
-    @functools.partial(oop.jax_tf.method_ro, jit=False)
-    def valid(self) -> jtp.Bool:
-        """"""
-
-        return jnp.array(self.parent_model is not None, dtype=bool)
-
-    @functools.partial(oop.jax_tf.method_ro, jit=False)
-    def index(self) -> jtp.Int:
-        """"""
-
-        return jnp.array(self.joint_description.index, dtype=int)
-
-    @functools.partial(oop.jax_tf.method_ro)
-    def dofs(self) -> jtp.Int:
-        """"""
-
-        return jnp.array(1, dtype=int)
-
-    @functools.partial(oop.jax_tf.method_ro, jit=False, vmap=False)
-    def name(self) -> str:
-        """"""
-
-        return self.joint_description.name
-
-    @functools.partial(oop.jax_tf.method_ro)
-    def position(self, dof: int | None = None) -> jtp.Float:
-        """"""
-
-        dof = dof if dof is not None else 0
-
-        return jnp.array(
-            self.parent_model.joint_positions(joint_names=(self.name(),))[dof],
-            dtype=float,
-        )
-
-    @functools.partial(oop.jax_tf.method_ro)
-    def velocity(self, dof: int | None = None) -> jtp.Float:
-        """"""
-
-        dof = dof if dof is not None else 0
-
-        return jnp.array(
-            self.parent_model.joint_velocities(joint_names=(self.name(),))[dof],
-            dtype=float,
-        )
-
-    @functools.partial(oop.jax_tf.method_ro)
-    def force_target(self, dof: int | None = None) -> jtp.Float:
-        """"""
-
-        dof = dof if dof is not None else 0
-
-        return jnp.array(
-            self.parent_model.joint_generalized_forces_targets(
-                joint_names=(self.name(),)
-            )[dof],
-            dtype=float,
-        )
-
-    @functools.partial(oop.jax_tf.method_ro)
-    def position_limit(self, dof: int | None = None) -> tuple[jtp.Float, jtp.Float]:
-        """"""
-
-        dof = dof if dof is not None else 0
-
-        if not_tracing(dof) and dof != 0:
-            msg = "Only joints with 1 DoF are currently supported"
-            raise ValueError(msg)
-
-        low, high = self.joint_description.position_limit
-
-        return jnp.array(low, dtype=float), jnp.array(high, dtype=float)
-
-    # =============
-    # Motor methods
-    # =============
-    @functools.partial(oop.jax_tf.method_ro)
-    def motor_inertia(self) -> jtp.Vector:
-        """"""
-
-        return jnp.array(self.joint_description.motor_inertia, dtype=float)
-
-    @functools.partial(oop.jax_tf.method_ro)
-    def motor_gear_ratio(self) -> jtp.Vector:
-        """"""
-
-        return jnp.array(self.joint_description.motor_gear_ratio, dtype=float)
-
-    @functools.partial(oop.jax_tf.method_ro)
-    def motor_viscous_friction(self) -> jtp.Vector:
-        """"""
-
-        return jnp.array(self.joint_description.motor_viscous_friction, dtype=float)
-
-    # =================
-    # Multi-DoF methods
-    # =================
-
-    @functools.partial(oop.jax_tf.method_ro)
-    def joint_position(self) -> jtp.Vector:
-        """"""
-
-        return self.parent_model.joint_positions(joint_names=(self.name(),))
-
-    @functools.partial(oop.jax_tf.method_ro)
-    def joint_velocity(self) -> jtp.Vector:
-        """"""
-
-        return self.parent_model.joint_velocities(joint_names=(self.name(),))
-
-    @functools.partial(oop.jax_tf.method_ro)
-    def joint_force_target(self) -> jtp.Vector:
-        """"""
-
-        return self.parent_model.joint_generalized_forces_targets(
-            joint_names=(self.name(),)
-        )