mink 0.0.10__tar.gz → 0.0.12__tar.gz

{mink-0.0.10 → mink-0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mink
-Version: 0.0.10
+Version: 0.0.12
 Summary: mink: MuJoCo inverse kinematics.
 Keywords: inverse,kinematics,mujoco
 Author-email: Kevin Zakka <zakka@berkeley.edu>
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
 License-File: LICENSE
 Requires-Dist: mujoco >= 3.1.6
@@ -27,7 +28,6 @@ Requires-Dist: black ; extra == "dev"
 Requires-Dist: mink[test] ; extra == "dev"
 Requires-Dist: mypy ; extra == "dev"
 Requires-Dist: ruff ; extra == "dev"
-Requires-Dist: dm_control >= 1.0.20 ; extra == "examples"
 Requires-Dist: loop-rate-limiters >= 0.1.0 ; extra == "examples"
 Requires-Dist: qpsolvers[daqp] >= 4.3.1 ; extra == "examples"
 Requires-Dist: osqp >=0.6.2,<1 ; extra == "examples"
@@ -59,6 +59,7 @@ Features include:
 * Task specification in configuration or operational space;
 * Limits on joint positions and velocities;
 * Collision avoidance between any geom pair;
+* Support for closed-chain kinematics (loop closures) via [equality constraints](https://mujoco.readthedocs.io/en/stable/computation/index.html#coequality);
 * Lie group interface for rigid body transformations.
 
 For usage and API reference, see the [documentation](https://kevinzakka.github.io/mink/).
@@ -66,14 +67,14 @@ For usage and API reference, see the [documentation](https://kevinzakka.github.i
 If you use mink in your research, please cite it as follows:
 
 ```bibtex
-@software{Zakka_Mink_Python_inverse_2024,
+@software{Zakka_Mink_Python_inverse_2025,
   author = {Zakka, Kevin},
-  license = {Apache-2.0},
-  month = jul,
   title = {{Mink: Python inverse kinematics based on MuJoCo}},
+  year = {2025},
+  month = may,
+  version = {0.0.11},
   url = {https://github.com/kevinzakka/mink},
-  version = {0.0.4},
-  year = {2024}
+  license = {Apache-2.0}
 }
 ```
 

{mink-0.0.10 → mink-0.0.12}/README.md

@@ -12,6 +12,7 @@ Features include:
 * Task specification in configuration or operational space;
 * Limits on joint positions and velocities;
 * Collision avoidance between any geom pair;
+* Support for closed-chain kinematics (loop closures) via [equality constraints](https://mujoco.readthedocs.io/en/stable/computation/index.html#coequality);
 * Lie group interface for rigid body transformations.
 
 For usage and API reference, see the [documentation](https://kevinzakka.github.io/mink/).
@@ -19,14 +20,14 @@ For usage and API reference, see the [documentation](https://kevinzakka.github.i
 If you use mink in your research, please cite it as follows:
 
 ```bibtex
-@software{Zakka_Mink_Python_inverse_2024,
+@software{Zakka_Mink_Python_inverse_2025,
   author = {Zakka, Kevin},
-  license = {Apache-2.0},
-  month = jul,
   title = {{Mink: Python inverse kinematics based on MuJoCo}},
+  year = {2025},
+  month = may,
+  version = {0.0.11},
   url = {https://github.com/kevinzakka/mink},
-  version = {0.0.4},
-  year = {2024}
+  license = {Apache-2.0}
 }
 ```
 

{mink-0.0.10 → mink-0.0.12}/mink/__init__.py

@@ -9,11 +9,20 @@ from .constants import (
     SUPPORTED_FRAMES,
 )
 from .exceptions import (
+    IntegrationTimestepNotSet,
+    InvalidConstraint,
+    InvalidDamping,
     InvalidFrame,
+    InvalidGain,
     InvalidKeyframe,
     InvalidMocapBody,
+    InvalidTarget,
+    LimitDefinitionError,
     MinkError,
+    NoSolutionFound,
     NotWithinConfigurationLimits,
+    TargetNotSet,
+    TaskDefinitionError,
     UnsupportedFrame,
 )
 from .lie import SE3, SO3, MatrixLieGroup
@@ -30,10 +39,10 @@ from .tasks import (
     DampingTask,
     EqualityConstraintTask,
     FrameTask,
+    KineticEnergyRegularizationTask,
     Objective,
     PostureTask,
     RelativeFrameTask,
-    TargetNotSet,
     Task,
 )
 from .utils import (
@@ -55,6 +64,7 @@ __all__ = (
     "RelativeFrameTask",
     "PostureTask",
     "Task",
+    "KineticEnergyRegularizationTask",
     "EqualityConstraintTask",
     "Objective",
     "ConfigurationLimit",
@@ -72,6 +82,14 @@ __all__ = (
     "NotWithinConfigurationLimits",
     "TargetNotSet",
     "InvalidMocapBody",
+    "InvalidConstraint",
+    "InvalidDamping",
+    "InvalidGain",
+    "InvalidTarget",
+    "LimitDefinitionError",
+    "TaskDefinitionError",
+    "IntegrationTimestepNotSet",
+    "NoSolutionFound",
     "SUPPORTED_FRAMES",
     "FRAME_TO_ENUM",
     "FRAME_TO_JAC_FUNC",

{mink-0.0.10 → mink-0.0.12}/mink/configuration.py

@@ -30,6 +30,7 @@ class Configuration:
     * Running forward kinematics to update the state.
     * Checking configuration limits.
     * Computing Jacobians for different frames.
+    * Computing the joint-space inertia matrix.
     * Retrieving frame transforms relative to the world frame.
     * Integrating velocities to update configurations.
     """
@@ -84,6 +85,10 @@ class Configuration:
             safety_break: If True, stop execution and raise an exception if the current
                 configuration is outside limits. If False, print a warning and continue
                 execution.
+
+        Raises:
+            NotWithinConfigurationLimits: If the current configuration is outside
+                the joint limits.
         """
         for jnt in range(self.model.njnt):
             jnt_type = self.model.jnt_type[jnt]
@@ -237,6 +242,24 @@ class Configuration:
         mujoco.mj_integratePos(self.model, self.data.qpos, velocity, dt)
         self.update()
 
+    def get_inertia_matrix(self) -> np.ndarray:
+        r"""Return the joint-space inertia matrix at the current configuration.
+
+        Returns:
+            The joint-space inertia matrix :math:`M(\mathbf{q})`.
+        """
+        # Run the composite rigid body inertia (CRB) algorithm to populate the joint
+        # space inertia matrix data.qM.
+        if mujoco.mj_version() >= 334:
+            mujoco.mj_makeM(self.model, self.data)
+        else:
+            mujoco.mj_crb(self.model, self.data)
+        # data.qM is stored in a custom sparse format and can be converted to dense
+        # format using mujoco.mj_fullM.
+        M = np.empty((self.nv, self.nv), dtype=np.float64)
+        mujoco.mj_fullM(self.model, M, self.data.qM)
+        return M
+
     # Aliases.
 
     @property

{mink-0.0.10 → mink-0.0.12}/mink/exceptions.py

@@ -9,6 +9,13 @@ class MinkError(Exception):
     """Base class for Mink exceptions."""
 
 
+class NoSolutionFound(MinkError):
+    """Exception raised when the QP solver fails to find a solution."""
+
+    def __init__(self, solver_name: str):
+        super().__init__(f"QP solver {solver_name} failed to find a solution.")
+
+
 class UnsupportedFrame(MinkError):
     """Exception raised when a frame type is unsupported."""
 
@@ -96,3 +103,43 @@ class NotWithinConfigurationLimits(MinkError):
             f"{lower} <= {value} <= {upper}"
         )
         super().__init__(message)
+
+
+class TaskDefinitionError(MinkError):
+    """Exception raised when a task definition is ill-formed."""
+
+
+class IntegrationTimestepNotSet(MinkError):
+    """Exception raised when the integration timestep is not set."""
+
+    def __init__(self, cls_name: str):
+        message = f"No integration timestep set for {cls_name}"
+        super().__init__(message)
+
+
+class TargetNotSet(MinkError):
+    """Exception raised when attempting to use a task with an unset target."""
+
+    def __init__(self, cls_name: str):
+        message = f"No target set for {cls_name}"
+        super().__init__(message)
+
+
+class InvalidTarget(MinkError):
+    """Exception raised when the target is invalid."""
+
+
+class InvalidGain(MinkError):
+    """Exception raised when the gain is outside the valid range."""
+
+
+class InvalidDamping(MinkError):
+    """Exception raised when the damping is outside the valid range."""
+
+
+class InvalidConstraint(MinkError):
+    """Exception raised when a constraint is invalid."""
+
+
+class LimitDefinitionError(MinkError):
+    """Exception raised when a limit definition is ill-formed."""

{mink-0.0.10 → mink-0.0.12}/mink/lie/se3.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from typing import Tuple
 
 import mujoco
 import numpy as np
@@ -221,6 +222,36 @@ class SE3(MatrixLieGroup):
         ljacinv_se3[3:, 3:] = ljacinv_so3
         return ljacinv_se3
 
+    def clamp(
+        self,
+        x_translation: Tuple[float, float] = (-np.inf, np.inf),
+        y_translation: Tuple[float, float] = (-np.inf, np.inf),
+        z_translation: Tuple[float, float] = (-np.inf, np.inf),
+        roll_radians: Tuple[float, float] = (-np.inf, np.inf),
+        pitch_radians: Tuple[float, float] = (-np.inf, np.inf),
+        yaw_radians: Tuple[float, float] = (-np.inf, np.inf),
+    ) -> SE3:
+        """Clamp a SE3 within translation and RPY limits.
+
+        Args:
+            x_translation: The (lower, upper) limits for translation along the x axis.
+            y_translation: The (lower, upper) limits for translation along the y axis.
+            z_translation: The (lower, upper) limits for translation along the z axis.
+            roll_radians: The (lower, upper) limits for the roll.
+            pitch_radians: The (lower, upper) limits for the pitch.
+            yaw_radians: The (lower, upper) limits for the yaw.
+
+        Returns:
+            A SE3 within the translation and RPY limits.
+        """
+        translation_limits = np.array([x_translation, y_translation, z_translation])
+        return SE3.from_rotation_and_translation(
+            rotation=self.rotation().clamp(roll_radians, pitch_radians, yaw_radians),
+            translation=np.clip(
+                self.translation(), translation_limits[:, 0], translation_limits[:, 1]
+            ),
+        )
+
 
 # Eqn 180.
 def _getQ(c) -> np.ndarray:

{mink-0.0.10 → mink-0.0.12}/mink/lie/so3.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import NamedTuple
+from typing import NamedTuple, Tuple
 
 import mujoco
 import numpy as np
@@ -260,3 +260,25 @@ class SO3(MatrixLieGroup):
         ljacinv[1, 1] += 1.0
         ljacinv[2, 2] += 1.0
         return ljacinv
+
+    def clamp(
+        self,
+        roll_radians: Tuple[float, float] = (-np.inf, np.inf),
+        pitch_radians: Tuple[float, float] = (-np.inf, np.inf),
+        yaw_radians: Tuple[float, float] = (-np.inf, np.inf),
+    ) -> SO3:
+        """Clamp a SO3 within RPY limits.
+
+        Args:
+            roll_radians: The (lower, upper) limits for the roll.
+            pitch_radians: The (lower, upper) limits for the pitch.
+            yaw_radians: The (lower, upper) limits for the yaw.
+
+        Returns:
+            A SO3 within the RPY limits.
+        """
+        return SO3.from_rpy_radians(
+            roll=np.clip(self.compute_roll_radians(), *roll_radians),
+            pitch=np.clip(self.compute_pitch_radians(), *pitch_radians),
+            yaw=np.clip(self.compute_yaw_radians(), *yaw_radians),
+        )

{mink-0.0.10 → mink-0.0.12}/mink/limits/__init__.py

@@ -2,7 +2,6 @@
 
 from .collision_avoidance_limit import CollisionAvoidanceLimit
 from .configuration_limit import ConfigurationLimit
-from .exceptions import LimitDefinitionError
 from .limit import Constraint, Limit
 from .velocity_limit import VelocityLimit
 
@@ -12,5 +11,4 @@ __all__ = (
     "Constraint",
     "Limit",
     "VelocityLimit",
-    "LimitDefinitionError",
 )

{mink-0.0.10 → mink-0.0.12}/mink/limits/configuration_limit.py

@@ -7,7 +7,7 @@ import numpy as np
 
 from ..configuration import Configuration
 from ..constants import dof_width, qpos_width
-from .exceptions import LimitDefinitionError
+from ..exceptions import LimitDefinitionError
 from .limit import Constraint, Limit
 
 
@@ -98,7 +98,7 @@ class ConfigurationLimit(Limit):
             return Constraint()
 
         # Upper.
-        delta_q_max = np.zeros((self.model.nv,))
+        delta_q_max = np.empty((self.model.nv,))
         mujoco.mj_differentiatePos(
             m=self.model,
             qvel=delta_q_max,
@@ -108,7 +108,7 @@ class ConfigurationLimit(Limit):
         )
 
         # Lower.
-        delta_q_min = np.zeros((self.model.nv,))
+        delta_q_min = np.empty((self.model.nv,))
         mujoco.mj_differentiatePos(
             m=self.model,
             qvel=delta_q_min,

{mink-0.0.10 → mink-0.0.12}/mink/limits/velocity_limit.py

@@ -8,7 +8,7 @@ import numpy.typing as npt
 
 from ..configuration import Configuration
 from ..constants import dof_width
-from .exceptions import LimitDefinitionError
+from ..exceptions import LimitDefinitionError
 from .limit import Constraint, Limit
 
 

{mink-0.0.10 → mink-0.0.12}/mink/solve_ik.py

@@ -6,12 +6,13 @@ import numpy as np
 import qpsolvers
 
 from .configuration import Configuration
+from .exceptions import NoSolutionFound
 from .limits import ConfigurationLimit, Limit
-from .tasks import Objective, Task
+from .tasks import BaseTask, Objective
 
 
 def _compute_qp_objective(
-    configuration: Configuration, tasks: Sequence[Task], damping: float
+    configuration: Configuration, tasks: Sequence[BaseTask], damping: float
 ) -> Objective:
     H = np.eye(configuration.model.nv) * damping
     c = np.zeros(configuration.model.nv)
@@ -42,18 +43,31 @@ def _compute_qp_inequalities(
 
 def build_ik(
     configuration: Configuration,
-    tasks: Sequence[Task],
+    tasks: Sequence[BaseTask],
     dt: float,
     damping: float = 1e-12,
     limits: Optional[Sequence[Limit]] = None,
 ) -> qpsolvers.Problem:
-    """Build quadratic program from current configuration and tasks.
+    r"""Build the quadratic program given the current configuration and tasks.
+
+    The quadratic program is defined as:
+
+    .. math::
+
+        \begin{align*}
+            \min_{\Delta q} & \frac{1}{2} \Delta q^T H \Delta q + c^T \Delta q \\
+            \text{s.t.} \quad & G \Delta q \leq h
+        \end{align*}
+
+    where :math:`\Delta q = v / dt` is the vector of joint displacements.
 
     Args:
         configuration: Robot configuration.
         tasks: List of kinematic tasks.
         dt: Integration timestep in [s].
-        damping: Levenberg-Marquardt damping.
+        damping: Levenberg-Marquardt damping. Higher values improve numerical
+            stability but slow down task convergence. This value applies to all
+            dofs, including floating-base coordinates.
         limits: List of limits to enforce. Set to empty list to disable. If None,
             defaults to a configuration limit.
 
@@ -67,7 +81,7 @@ def build_ik(
 
 def solve_ik(
     configuration: Configuration,
-    tasks: Sequence[Task],
+    tasks: Sequence[BaseTask],
     dt: float,
     solver: str,
     damping: float = 1e-12,
@@ -75,7 +89,7 @@ def solve_ik(
     limits: Optional[Sequence[Limit]] = None,
     **kwargs,
 ) -> np.ndarray:
-    """Solve the differential inverse kinematics problem.
+    r"""Solve the differential inverse kinematics problem.
 
     Computes a velocity tangent to the current robot configuration. The computed
     velocity satisfies at (weighted) best the set of provided kinematic tasks.
@@ -85,7 +99,9 @@ def solve_ik(
         tasks: List of kinematic tasks.
         dt: Integration timestep in [s].
         solver: Backend quadratic programming (QP) solver.
-        damping: Levenberg-Marquardt damping.
+        damping: Levenberg-Marquardt damping applied to all tasks. Higher values
+            improve numerical stability but slow down task convergence. This
+            value applies to all dofs, including floating-base coordinates.
         safety_break: If True, stop execution and raise an exception if
             the current configuration is outside limits. If False, print a
             warning and continue execution.
@@ -93,13 +109,20 @@ def solve_ik(
             defaults to a configuration limit.
         kwargs: Keyword arguments to forward to the backend QP solver.
 
+    Raises:
+        NotWithinConfigurationLimits: If the current configuration is outside
+            the joint limits and `safety_break` is True.
+        NoSolutionFound: If the QP solver fails to find a solution.
+
     Returns:
-        Velocity `v` in tangent space.
+        Velocity :math:`v` in tangent space.
     """
     configuration.check_limits(safety_break=safety_break)
     problem = build_ik(configuration, tasks, dt, damping, limits)
     result = qpsolvers.solve_problem(problem, solver=solver, **kwargs)
-    dq = result.x
-    assert dq is not None
-    v: np.ndarray = dq / dt
+    if not result.found:
+        raise NoSolutionFound(solver)
+    delta_q = result.x
+    assert delta_q is not None
+    v: np.ndarray = delta_q / dt
     return v

{mink-0.0.10 → mink-0.0.12}/mink/tasks/__init__.py

@@ -3,20 +3,14 @@
 from .com_task import ComTask
 from .damping_task import DampingTask
 from .equality_constraint_task import EqualityConstraintTask
-from .exceptions import (
-    InvalidConstraint,
-    InvalidDamping,
-    InvalidGain,
-    InvalidTarget,
-    TargetNotSet,
-    TaskDefinitionError,
-)
 from .frame_task import FrameTask
+from .kinetic_energy_regularization_task import KineticEnergyRegularizationTask
 from .posture_task import PostureTask
 from .relative_frame_task import RelativeFrameTask
-from .task import Objective, Task
+from .task import BaseTask, Objective, Task
 
 __all__ = (
+    "BaseTask",
     "ComTask",
     "FrameTask",
     "Objective",
@@ -24,11 +18,6 @@ __all__ = (
     "PostureTask",
     "RelativeFrameTask",
     "Task",
-    "TargetNotSet",
-    "InvalidTarget",
-    "TaskDefinitionError",
-    "InvalidConstraint",
-    "InvalidGain",
-    "InvalidDamping",
     "EqualityConstraintTask",
+    "KineticEnergyRegularizationTask",
 )

mink-0.0.12/mink/tasks/com_task.py

@@ -0,0 +1,159 @@
+"""Center-of-mass task implementation."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import mujoco
+import numpy as np
+import numpy.typing as npt
+
+from ..configuration import Configuration
+from ..exceptions import InvalidTarget, TargetNotSet, TaskDefinitionError
+from .task import Task
+
+
+class ComTask(Task):
+    """Regulate the center-of-mass (CoM) of a robot.
+
+    Attributes:
+        target_com: Target position of the CoM.
+
+    Example:
+
+    .. code-block:: python
+
+        com_task = ComTask(model, cost=1.0)
+
+        # Update the target CoM directly.
+        com_desired = np.zeros(3)
+        com_task.set_target(com_desired)
+
+        # Or from a keyframe defined in the model.
+        configuration.update_from_keyframe("home")
+        com_task.set_target_from_configuration(configuration)
+    """
+
+    k: int = 3
+    target_com: Optional[np.ndarray]
+
+    def __init__(
+        self,
+        cost: npt.ArrayLike,
+        gain: float = 1.0,
+        lm_damping: float = 0.0,
+    ):
+        super().__init__(cost=np.zeros((self.k,)), gain=gain, lm_damping=lm_damping)
+        self.target_com = None
+
+        self.set_cost(cost)
+
+    def set_cost(self, cost: npt.ArrayLike) -> None:
+        """Set the cost of the CoM task.
+
+        Args:
+            cost: A vector of shape (1,) (aka identical cost for all coordinates),
+                or (3,) (aka different costs for each coordinate).
+        """
+        cost = np.atleast_1d(cost)
+        if cost.ndim != 1 or cost.shape[0] not in (1, self.k):
+            raise TaskDefinitionError(
+                f"{self.__class__.__name__} cost must be a vector of shape (1,) "
+                f"(aka identical cost for all coordinates) or ({self.k},). "
+                f"Got {cost.shape}"
+            )
+        if not np.all(cost >= 0.0):
+            raise TaskDefinitionError(f"{self.__class__.__name__} cost must be >= 0")
+        self.cost[:] = cost
+
+    def set_target(self, target_com: npt.ArrayLike) -> None:
+        """Set the target CoM position in the world frame.
+
+        Args:
+            target_com: A vector of shape (3,) representing the desired
+                center-of-mass position in the world frame.
+        """
+        target_com = np.atleast_1d(target_com)
+        if target_com.ndim != 1 or target_com.shape[0] != (self.k):
+            raise InvalidTarget(
+                f"Expected target CoM to have shape ({self.k},) but got "
+                f"{target_com.shape}"
+            )
+        self.target_com = target_com.copy()
+
+    def set_target_from_configuration(self, configuration: Configuration) -> None:
+        """Set the target CoM from a given robot configuration.
+
+        Args:
+            configuration: Robot configuration :math:`q`.
+        """
+        self.set_target(configuration.data.subtree_com[1])
+
+    def compute_error(self, configuration: Configuration) -> np.ndarray:
+        r"""Compute the CoM task error.
+
+        The center of mass :math:`c(q)` for a collection of bodies :math:`\mathcal{B}`
+        is the mass-weighted average of their individual centers of mass. After running
+        forward kinematics, in particular after calling ``mj_comPos``, MuJoCo stores
+        the CoM of each subtree in ``data.subtree_com``. This task uses the CoM of the
+        subtree starting from body 1, which is the entire robot excluding the world
+        body (body 0).
+
+        The task error :math:`e(q)` is the difference between the current CoM
+        :math:`c(q)` and the target CoM :math:`c^*`:
+
+        .. math::
+
+            e(q) = c(q) - c^*
+
+        Args:
+            configuration: Robot configuration :math:`q`.
+
+        Returns:
+            Center-of-mass task error vector :math:`e(q)`.
+        """
+        if self.target_com is None:
+            raise TargetNotSet(self.__class__.__name__)
+        # Note: body 0 is the world body, so we start from body 1 (the robot).
+        # TODO(kevin): Don't hardcode subtree index.
+        return configuration.data.subtree_com[1] - self.target_com
+
+    def compute_jacobian(self, configuration: Configuration) -> np.ndarray:
+        r"""Compute the Jacobian of the CoM task error :math:`e(q)`.
+
+        The Jacobian is the derivative of this error with respect to the
+        generalized coordinates :math:`q`. Since the target :math:`c^*` is
+        constant, the Jacobian of the error simplifies to the Jacobian of the
+        CoM position :math:`c(q)`:
+
+        .. math::
+
+            J(q) = \frac{\partial e(q)}{\partial q} = \frac{\partial c(q)}{\partial q}
+
+        MuJoCo's ``mj_jacSubtreeCom`` function computes this Jacobian using the
+        formula:
+
+        .. math::
+
+            \frac{\partial c(q)}{\partial q} =
+            \frac{1}{M} \sum_{i \in \mathcal{B}} m_i \frac{\partial p_i(q)}{\partial q}
+            = \frac{1}{M} \sum_{i \in \mathcal{B}} m_i J_i(q)
+
+        where :math:`M = \sum_{i \in \mathcal{B}} m_i` is the total mass of the subtree,
+        :math:`m_i` is the mass of body :math:`i`, :math:`p_i(q)` is the position
+        of the origin of body frame :math:`i` in the world frame, :math:`J_i(q) =
+        \frac{\partial p_i(q)}{\partial q}` is the Jacobian mapping joint velocities to
+        the linear velocity of the origin of body frame :math:`i`, and the sum is over
+        all bodies :math:`\mathcal{B}` in the specified subtree (body 1 and its
+        descendants).
+
+        Args:
+            configuration: Robot configuration :math:`q`.
+
+        Returns:
+            Jacobian of the center-of-mass task error :math:`J(q)`.
+        """
+        # NOTE: We don't need a target CoM to compute this Jacobian.
+        jac = np.empty((self.k, configuration.nv))
+        mujoco.mj_jacSubtreeCom(configuration.model, configuration.data, jac, 1)
+        return jac