Add files using upload-large-folder tool

mplug_owl2/lib/python3.10/site-packages/sympy/physics/mechanics/actuator.py

@@ -0,0 +1,992 @@
+"""Implementations of actuators for linked force and torque application."""
+
+from abc import ABC, abstractmethod
+
+from sympy import S, sympify
+from sympy.physics.mechanics.joint import PinJoint
+from sympy.physics.mechanics.loads import Torque
+from sympy.physics.mechanics.pathway import PathwayBase
+from sympy.physics.mechanics.rigidbody import RigidBody
+from sympy.physics.vector import ReferenceFrame, Vector
+
+
+__all__ = [
+    'ActuatorBase',
+    'ForceActuator',
+    'LinearDamper',
+    'LinearSpring',
+    'TorqueActuator',
+    'DuffingSpring'
+]
+
+
+class ActuatorBase(ABC):
+    """Abstract base class for all actuator classes to inherit from.
+
+    Notes
+    =====
+
+    Instances of this class cannot be directly instantiated by users. However,
+    it can be used to created custom actuator types through subclassing.
+
+    """
+
+    def __init__(self):
+        """Initializer for ``ActuatorBase``."""
+        pass
+
+    @abstractmethod
+    def to_loads(self):
+        """Loads required by the equations of motion method classes.
+
+        Explanation
+        ===========
+
+        ``KanesMethod`` requires a list of ``Point``-``Vector`` tuples to be
+        passed to the ``loads`` parameters of its ``kanes_equations`` method
+        when constructing the equations of motion. This method acts as a
+        utility to produce the correctly-structred pairs of points and vectors
+        required so that these can be easily concatenated with other items in
+        the list of loads and passed to ``KanesMethod.kanes_equations``. These
+        loads are also in the correct form to also be passed to the other
+        equations of motion method classes, e.g. ``LagrangesMethod``.
+
+        """
+        pass
+
+    def __repr__(self):
+        """Default representation of an actuator."""
+        return f'{self.__class__.__name__}()'
+
+
+class ForceActuator(ActuatorBase):
+    """Force-producing actuator.
+
+    Explanation
+    ===========
+
+    A ``ForceActuator`` is an actuator that produces a (expansile) force along
+    its length.
+
+    A force actuator uses a pathway instance to determine the direction and
+    number of forces that it applies to a system. Consider the simplest case
+    where a ``LinearPathway`` instance is used. This pathway is made up of two
+    points that can move relative to each other, and results in a pair of equal
+    and opposite forces acting on the endpoints. If the positive time-varying
+    Euclidean distance between the two points is defined, then the "extension
+    velocity" is the time derivative of this distance. The extension velocity
+    is positive when the two points are moving away from each other and
+    negative when moving closer to each other. The direction for the force
+    acting on either point is determined by constructing a unit vector directed
+    from the other point to this point. This establishes a sign convention such
+    that a positive force magnitude tends to push the points apart, this is the
+    meaning of "expansile" in this context. The following diagram shows the
+    positive force sense and the distance between the points::
+
+       P           Q
+       o<--- F --->o
+       |           |
+       |<--l(t)--->|
+
+    Examples
+    ========
+
+    To construct an actuator, an expression (or symbol) must be supplied to
+    represent the force it can produce, alongside a pathway specifying its line
+    of action. Let's also create a global reference frame and spatially fix one
+    of the points in it while setting the other to be positioned such that it
+    can freely move in the frame's x direction specified by the coordinate
+    ``q``.
+
+    >>> from sympy import symbols
+    >>> from sympy.physics.mechanics import (ForceActuator, LinearPathway,
+    ...     Point, ReferenceFrame)
+    >>> from sympy.physics.vector import dynamicsymbols
+    >>> N = ReferenceFrame('N')
+    >>> q = dynamicsymbols('q')
+    >>> force = symbols('F')
+    >>> pA, pB = Point('pA'), Point('pB')
+    >>> pA.set_vel(N, 0)
+    >>> pB.set_pos(pA, q*N.x)
+    >>> pB.pos_from(pA)
+    q(t)*N.x
+    >>> linear_pathway = LinearPathway(pA, pB)
+    >>> actuator = ForceActuator(force, linear_pathway)
+    >>> actuator
+    ForceActuator(F, LinearPathway(pA, pB))
+
+    Parameters
+    ==========
+
+    force : Expr
+        The scalar expression defining the (expansile) force that the actuator
+        produces.
+    pathway : PathwayBase
+        The pathway that the actuator follows. This must be an instance of a
+        concrete subclass of ``PathwayBase``, e.g. ``LinearPathway``.
+
+    """
+
+    def __init__(self, force, pathway):
+        """Initializer for ``ForceActuator``.
+
+        Parameters
+        ==========
+
+        force : Expr
+            The scalar expression defining the (expansile) force that the
+            actuator produces.
+        pathway : PathwayBase
+            The pathway that the actuator follows. This must be an instance of
+            a concrete subclass of ``PathwayBase``, e.g. ``LinearPathway``.
+
+        """
+        self.force = force
+        self.pathway = pathway
+
+    @property
+    def force(self):
+        """The magnitude of the force produced by the actuator."""
+        return self._force
+
+    @force.setter
+    def force(self, force):
+        if hasattr(self, '_force'):
+            msg = (
+                f'Can\'t set attribute `force` to {repr(force)} as it is '
+                f'immutable.'
+            )
+            raise AttributeError(msg)
+        self._force = sympify(force, strict=True)
+
+    @property
+    def pathway(self):
+        """The ``Pathway`` defining the actuator's line of action."""
+        return self._pathway
+
+    @pathway.setter
+    def pathway(self, pathway):
+        if hasattr(self, '_pathway'):
+            msg = (
+                f'Can\'t set attribute `pathway` to {repr(pathway)} as it is '
+                f'immutable.'
+            )
+            raise AttributeError(msg)
+        if not isinstance(pathway, PathwayBase):
+            msg = (
+                f'Value {repr(pathway)} passed to `pathway` was of type '
+                f'{type(pathway)}, must be {PathwayBase}.'
+            )
+            raise TypeError(msg)
+        self._pathway = pathway
+
+    def to_loads(self):
+        """Loads required by the equations of motion method classes.
+
+        Explanation
+        ===========
+
+        ``KanesMethod`` requires a list of ``Point``-``Vector`` tuples to be
+        passed to the ``loads`` parameters of its ``kanes_equations`` method
+        when constructing the equations of motion. This method acts as a
+        utility to produce the correctly-structred pairs of points and vectors
+        required so that these can be easily concatenated with other items in
+        the list of loads and passed to ``KanesMethod.kanes_equations``. These
+        loads are also in the correct form to also be passed to the other
+        equations of motion method classes, e.g. ``LagrangesMethod``.
+
+        Examples
+        ========
+
+        The below example shows how to generate the loads produced by a force
+        actuator that follows a linear pathway. In this example we'll assume
+        that the force actuator is being used to model a simple linear spring.
+        First, create a linear pathway between two points separated by the
+        coordinate ``q`` in the ``x`` direction of the global frame ``N``.
+
+        >>> from sympy.physics.mechanics import (LinearPathway, Point,
+        ...     ReferenceFrame)
+        >>> from sympy.physics.vector import dynamicsymbols
+        >>> q = dynamicsymbols('q')
+        >>> N = ReferenceFrame('N')
+        >>> pA, pB = Point('pA'), Point('pB')
+        >>> pB.set_pos(pA, q*N.x)
+        >>> pathway = LinearPathway(pA, pB)
+
+        Now create a symbol ``k`` to describe the spring's stiffness and
+        instantiate a force actuator that produces a (contractile) force
+        proportional to both the spring's stiffness and the pathway's length.
+        Note that actuator classes use the sign convention that expansile
+        forces are positive, so for a spring to produce a contractile force the
+        spring force needs to be calculated as the negative for the stiffness
+        multiplied by the length.
+
+        >>> from sympy import symbols
+        >>> from sympy.physics.mechanics import ForceActuator
+        >>> stiffness = symbols('k')
+        >>> spring_force = -stiffness*pathway.length
+        >>> spring = ForceActuator(spring_force, pathway)
+
+        The forces produced by the spring can be generated in the list of loads
+        form that ``KanesMethod`` (and other equations of motion methods)
+        requires by calling the ``to_loads`` method.
+
+        >>> spring.to_loads()
+        [(pA, k*q(t)*N.x), (pB, - k*q(t)*N.x)]
+
+        A simple linear damper can be modeled in a similar way. Create another
+        symbol ``c`` to describe the dampers damping coefficient. This time
+        instantiate a force actuator that produces a force proportional to both
+        the damper's damping coefficient and the pathway's extension velocity.
+        Note that the damping force is negative as it acts in the opposite
+        direction to which the damper is changing in length.
+
+        >>> damping_coefficient = symbols('c')
+        >>> damping_force = -damping_coefficient*pathway.extension_velocity
+        >>> damper = ForceActuator(damping_force, pathway)
+
+        Again, the forces produces by the damper can be generated by calling
+        the ``to_loads`` method.
+
+        >>> damper.to_loads()
+        [(pA, c*Derivative(q(t), t)*N.x), (pB, - c*Derivative(q(t), t)*N.x)]
+
+        """
+        return self.pathway.to_loads(self.force)
+
+    def __repr__(self):
+        """Representation of a ``ForceActuator``."""
+        return f'{self.__class__.__name__}({self.force}, {self.pathway})'
+
+
+class LinearSpring(ForceActuator):
+    """A spring with its spring force as a linear function of its length.
+
+    Explanation
+    ===========
+
+    Note that the "linear" in the name ``LinearSpring`` refers to the fact that
+    the spring force is a linear function of the springs length. I.e. for a
+    linear spring with stiffness ``k``, distance between its ends of ``x``, and
+    an equilibrium length of ``0``, the spring force will be ``-k*x``, which is
+    a linear function in ``x``. To create a spring that follows a linear, or
+    straight, pathway between its two ends, a ``LinearPathway`` instance needs
+    to be passed to the ``pathway`` parameter.
+
+    A ``LinearSpring`` is a subclass of ``ForceActuator`` and so follows the
+    same sign conventions for length, extension velocity, and the direction of
+    the forces it applies to its points of attachment on bodies. The sign
+    convention for the direction of forces is such that, for the case where a
+    linear spring is instantiated with a ``LinearPathway`` instance as its
+    pathway, they act to push the two ends of the spring away from one another.
+    Because springs produces a contractile force and acts to pull the two ends
+    together towards the equilibrium length when stretched, the scalar portion
+    of the forces on the endpoint are negative in order to flip the sign of the
+    forces on the endpoints when converted into vector quantities. The
+    following diagram shows the positive force sense and the distance between
+    the points::
+
+       P           Q
+       o<--- F --->o
+       |           |
+       |<--l(t)--->|
+
+    Examples
+    ========
+
+    To construct a linear spring, an expression (or symbol) must be supplied to
+    represent the stiffness (spring constant) of the spring, alongside a
+    pathway specifying its line of action. Let's also create a global reference
+    frame and spatially fix one of the points in it while setting the other to
+    be positioned such that it can freely move in the frame's x direction
+    specified by the coordinate ``q``.
+
+    >>> from sympy import symbols
+    >>> from sympy.physics.mechanics import (LinearPathway, LinearSpring,
+    ...     Point, ReferenceFrame)
+    >>> from sympy.physics.vector import dynamicsymbols
+    >>> N = ReferenceFrame('N')
+    >>> q = dynamicsymbols('q')
+    >>> stiffness = symbols('k')
+    >>> pA, pB = Point('pA'), Point('pB')
+    >>> pA.set_vel(N, 0)
+    >>> pB.set_pos(pA, q*N.x)
+    >>> pB.pos_from(pA)
+    q(t)*N.x
+    >>> linear_pathway = LinearPathway(pA, pB)
+    >>> spring = LinearSpring(stiffness, linear_pathway)
+    >>> spring
+    LinearSpring(k, LinearPathway(pA, pB))
+
+    This spring will produce a force that is proportional to both its stiffness
+    and the pathway's length. Note that this force is negative as SymPy's sign
+    convention for actuators is that negative forces are contractile.
+
+    >>> spring.force
+    -k*sqrt(q(t)**2)
+
+    To create a linear spring with a non-zero equilibrium length, an expression
+    (or symbol) can be passed to the ``equilibrium_length`` parameter on
+    construction on a ``LinearSpring`` instance. Let's create a symbol ``l``
+    to denote a non-zero equilibrium length and create another linear spring.
+
+    >>> l = symbols('l')
+    >>> spring = LinearSpring(stiffness, linear_pathway, equilibrium_length=l)
+    >>> spring
+    LinearSpring(k, LinearPathway(pA, pB), equilibrium_length=l)
+
+    The spring force of this new spring is again proportional to both its
+    stiffness and the pathway's length. However, the spring will not produce
+    any force when ``q(t)`` equals ``l``. Note that the force will become
+    expansile when ``q(t)`` is less than ``l``, as expected.
+
+    >>> spring.force
+    -k*(-l + sqrt(q(t)**2))
+
+    Parameters
+    ==========
+
+    stiffness : Expr
+        The spring constant.
+    pathway : PathwayBase
+        The pathway that the actuator follows. This must be an instance of a
+        concrete subclass of ``PathwayBase``, e.g. ``LinearPathway``.
+    equilibrium_length : Expr, optional
+        The length at which the spring is in equilibrium, i.e. it produces no
+        force. The default value is 0, i.e. the spring force is a linear
+        function of the pathway's length with no constant offset.
+
+    See Also
+    ========
+
+    ForceActuator: force-producing actuator (superclass of ``LinearSpring``).
+    LinearPathway: straight-line pathway between a pair of points.
+
+    """
+
+    def __init__(self, stiffness, pathway, equilibrium_length=S.Zero):
+        """Initializer for ``LinearSpring``.
+
+        Parameters
+        ==========
+
+        stiffness : Expr
+            The spring constant.
+        pathway : PathwayBase
+            The pathway that the actuator follows. This must be an instance of
+            a concrete subclass of ``PathwayBase``, e.g. ``LinearPathway``.
+        equilibrium_length : Expr, optional
+            The length at which the spring is in equilibrium, i.e. it produces
+            no force. The default value is 0, i.e. the spring force is a linear
+            function of the pathway's length with no constant offset.
+
+        """
+        self.stiffness = stiffness
+        self.pathway = pathway
+        self.equilibrium_length = equilibrium_length
+
+    @property
+    def force(self):
+        """The spring force produced by the linear spring."""
+        return -self.stiffness*(self.pathway.length - self.equilibrium_length)
+
+    @force.setter
+    def force(self, force):
+        raise AttributeError('Can\'t set computed attribute `force`.')
+
+    @property
+    def stiffness(self):
+        """The spring constant for the linear spring."""
+        return self._stiffness
+
+    @stiffness.setter
+    def stiffness(self, stiffness):
+        if hasattr(self, '_stiffness'):
+            msg = (
+                f'Can\'t set attribute `stiffness` to {repr(stiffness)} as it '
+                f'is immutable.'
+            )
+            raise AttributeError(msg)
+        self._stiffness = sympify(stiffness, strict=True)
+
+    @property
+    def equilibrium_length(self):
+        """The length of the spring at which it produces no force."""
+        return self._equilibrium_length
+
+    @equilibrium_length.setter
+    def equilibrium_length(self, equilibrium_length):
+        if hasattr(self, '_equilibrium_length'):
+            msg = (
+                f'Can\'t set attribute `equilibrium_length` to '
+                f'{repr(equilibrium_length)} as it is immutable.'
+            )
+            raise AttributeError(msg)
+        self._equilibrium_length = sympify(equilibrium_length, strict=True)
+
+    def __repr__(self):
+        """Representation of a ``LinearSpring``."""
+        string = f'{self.__class__.__name__}({self.stiffness}, {self.pathway}'
+        if self.equilibrium_length == S.Zero:
+            string += ')'
+        else:
+            string += f', equilibrium_length={self.equilibrium_length})'
+        return string
+
+
+class LinearDamper(ForceActuator):
+    """A damper whose force is a linear function of its extension velocity.
+
+    Explanation
+    ===========
+
+    Note that the "linear" in the name ``LinearDamper`` refers to the fact that
+    the damping force is a linear function of the damper's rate of change in
+    its length. I.e. for a linear damper with damping ``c`` and extension
+    velocity ``v``, the damping force will be ``-c*v``, which is a linear
+    function in ``v``. To create a damper that follows a linear, or straight,
+    pathway between its two ends, a ``LinearPathway`` instance needs to be
+    passed to the ``pathway`` parameter.
+
+    A ``LinearDamper`` is a subclass of ``ForceActuator`` and so follows the
+    same sign conventions for length, extension velocity, and the direction of
+    the forces it applies to its points of attachment on bodies. The sign
+    convention for the direction of forces is such that, for the case where a
+    linear damper is instantiated with a ``LinearPathway`` instance as its
+    pathway, they act to push the two ends of the damper away from one another.
+    Because dampers produce a force that opposes the direction of change in
+    length, when extension velocity is positive the scalar portions of the
+    forces applied at the two endpoints are negative in order to flip the sign
+    of the forces on the endpoints wen converted into vector quantities. When
+    extension velocity is negative (i.e. when the damper is shortening), the
+    scalar portions of the fofces applied are also negative so that the signs
+    cancel producing forces on the endpoints that are in the same direction as
+    the positive sign convention for the forces at the endpoints of the pathway
+    (i.e. they act to push the endpoints away from one another). The following
+    diagram shows the positive force sense and the distance between the
+    points::
+
+       P           Q
+       o<--- F --->o
+       |           |
+       |<--l(t)--->|
+
+    Examples
+    ========
+
+    To construct a linear damper, an expression (or symbol) must be supplied to
+    represent the damping coefficient of the damper (we'll use the symbol
+    ``c``), alongside a pathway specifying its line of action. Let's also
+    create a global reference frame and spatially fix one of the points in it
+    while setting the other to be positioned such that it can freely move in
+    the frame's x direction specified by the coordinate ``q``. The velocity
+    that the two points move away from one another can be specified by the
+    coordinate ``u`` where ``u`` is the first time derivative of ``q``
+    (i.e., ``u = Derivative(q(t), t)``).
+
+    >>> from sympy import symbols
+    >>> from sympy.physics.mechanics import (LinearDamper, LinearPathway,
+    ...     Point, ReferenceFrame)
+    >>> from sympy.physics.vector import dynamicsymbols
+    >>> N = ReferenceFrame('N')
+    >>> q = dynamicsymbols('q')
+    >>> damping = symbols('c')
+    >>> pA, pB = Point('pA'), Point('pB')
+    >>> pA.set_vel(N, 0)
+    >>> pB.set_pos(pA, q*N.x)
+    >>> pB.pos_from(pA)
+    q(t)*N.x
+    >>> pB.vel(N)
+    Derivative(q(t), t)*N.x
+    >>> linear_pathway = LinearPathway(pA, pB)
+    >>> damper = LinearDamper(damping, linear_pathway)
+    >>> damper
+    LinearDamper(c, LinearPathway(pA, pB))
+
+    This damper will produce a force that is proportional to both its damping
+    coefficient and the pathway's extension length. Note that this force is
+    negative as SymPy's sign convention for actuators is that negative forces
+    are contractile and the damping force of the damper will oppose the
+    direction of length change.
+
+    >>> damper.force
+    -c*sqrt(q(t)**2)*Derivative(q(t), t)/q(t)
+
+    Parameters
+    ==========
+
+    damping : Expr
+        The damping constant.
+    pathway : PathwayBase
+        The pathway that the actuator follows. This must be an instance of a
+        concrete subclass of ``PathwayBase``, e.g. ``LinearPathway``.
+
+    See Also
+    ========
+
+    ForceActuator: force-producing actuator (superclass of ``LinearDamper``).
+    LinearPathway: straight-line pathway between a pair of points.
+
+    """
+
+    def __init__(self, damping, pathway):
+        """Initializer for ``LinearDamper``.
+
+        Parameters
+        ==========
+
+        damping : Expr
+            The damping constant.
+        pathway : PathwayBase
+            The pathway that the actuator follows. This must be an instance of
+            a concrete subclass of ``PathwayBase``, e.g. ``LinearPathway``.
+
+        """
+        self.damping = damping
+        self.pathway = pathway
+
+    @property
+    def force(self):
+        """The damping force produced by the linear damper."""
+        return -self.damping*self.pathway.extension_velocity
+
+    @force.setter
+    def force(self, force):
+        raise AttributeError('Can\'t set computed attribute `force`.')
+
+    @property
+    def damping(self):
+        """The damping constant for the linear damper."""
+        return self._damping
+
+    @damping.setter
+    def damping(self, damping):
+        if hasattr(self, '_damping'):
+            msg = (
+                f'Can\'t set attribute `damping` to {repr(damping)} as it is '
+                f'immutable.'
+            )
+            raise AttributeError(msg)
+        self._damping = sympify(damping, strict=True)
+
+    def __repr__(self):
+        """Representation of a ``LinearDamper``."""
+        return f'{self.__class__.__name__}({self.damping}, {self.pathway})'
+
+
+class TorqueActuator(ActuatorBase):
+    """Torque-producing actuator.
+
+    Explanation
+    ===========
+
+    A ``TorqueActuator`` is an actuator that produces a pair of equal and
+    opposite torques on a pair of bodies.
+
+    Examples
+    ========
+
+    To construct a torque actuator, an expression (or symbol) must be supplied
+    to represent the torque it can produce, alongside a vector specifying the
+    axis about which the torque will act, and a pair of frames on which the
+    torque will act.
+
+    >>> from sympy import symbols
+    >>> from sympy.physics.mechanics import (ReferenceFrame, RigidBody,
+    ...     TorqueActuator)
+    >>> N = ReferenceFrame('N')
+    >>> A = ReferenceFrame('A')
+    >>> torque = symbols('T')
+    >>> axis = N.z
+    >>> parent = RigidBody('parent', frame=N)
+    >>> child = RigidBody('child', frame=A)
+    >>> bodies = (child, parent)
+    >>> actuator = TorqueActuator(torque, axis, *bodies)
+    >>> actuator
+    TorqueActuator(T, axis=N.z, target_frame=A, reaction_frame=N)
+
+    Note that because torques actually act on frames, not bodies,
+    ``TorqueActuator`` will extract the frame associated with a ``RigidBody``
+    when one is passed instead of a ``ReferenceFrame``.
+
+    Parameters
+    ==========
+
+    torque : Expr
+        The scalar expression defining the torque that the actuator produces.
+    axis : Vector
+        The axis about which the actuator applies torques.
+    target_frame : ReferenceFrame | RigidBody
+        The primary frame on which the actuator will apply the torque.
+    reaction_frame : ReferenceFrame | RigidBody | None
+        The secondary frame on which the actuator will apply the torque. Note
+        that the (equal and opposite) reaction torque is applied to this frame.
+
+    """
+
+    def __init__(self, torque, axis, target_frame, reaction_frame=None):
+        """Initializer for ``TorqueActuator``.
+
+        Parameters
+        ==========
+
+        torque : Expr
+            The scalar expression defining the torque that the actuator
+            produces.
+        axis : Vector
+            The axis about which the actuator applies torques.
+        target_frame : ReferenceFrame | RigidBody
+            The primary frame on which the actuator will apply the torque.
+        reaction_frame : ReferenceFrame | RigidBody | None
+           The secondary frame on which the actuator will apply the torque.
+           Note that the (equal and opposite) reaction torque is applied to
+           this frame.
+
+        """
+        self.torque = torque
+        self.axis = axis
+        self.target_frame = target_frame
+        self.reaction_frame = reaction_frame
+
+    @classmethod
+    def at_pin_joint(cls, torque, pin_joint):
+        """Alternate construtor to instantiate from a ``PinJoint`` instance.
+
+        Examples
+        ========
+
+        To create a pin joint the ``PinJoint`` class requires a name, parent
+        body, and child body to be passed to its constructor. It is also
+        possible to control the joint axis using the ``joint_axis`` keyword
+        argument. In this example let's use the parent body's reference frame's
+        z-axis as the joint axis.
+
+        >>> from sympy.physics.mechanics import (PinJoint, ReferenceFrame,
+        ...     RigidBody, TorqueActuator)
+        >>> N = ReferenceFrame('N')
+        >>> A = ReferenceFrame('A')
+        >>> parent = RigidBody('parent', frame=N)
+        >>> child = RigidBody('child', frame=A)
+        >>> pin_joint = PinJoint(
+        ...     'pin',
+        ...     parent,
+        ...     child,
+        ...     joint_axis=N.z,
+        ... )
+
+        Let's also create a symbol ``T`` that will represent the torque applied
+        by the torque actuator.
+
+        >>> from sympy import symbols
+        >>> torque = symbols('T')
+
+        To create the torque actuator from the ``torque`` and ``pin_joint``
+        variables previously instantiated, these can be passed to the alternate
+        constructor class method ``at_pin_joint`` of the ``TorqueActuator``
+        class. It should be noted that a positive torque will cause a positive
+        displacement of the joint coordinate or that the torque is applied on
+        the child body with a reaction torque on the parent.
+
+        >>> actuator = TorqueActuator.at_pin_joint(torque, pin_joint)
+        >>> actuator
+        TorqueActuator(T, axis=N.z, target_frame=A, reaction_frame=N)
+
+        Parameters
+        ==========
+
+        torque : Expr
+            The scalar expression defining the torque that the actuator
+            produces.
+        pin_joint : PinJoint
+            The pin joint, and by association the parent and child bodies, on
+            which the torque actuator will act. The pair of bodies acted upon
+            by the torque actuator are the parent and child bodies of the pin
+            joint, with the child acting as the reaction body. The pin joint's
+            axis is used as the axis about which the torque actuator will apply
+            its torque.
+
+        """
+        if not isinstance(pin_joint, PinJoint):
+            msg = (
+                f'Value {repr(pin_joint)} passed to `pin_joint` was of type '
+                f'{type(pin_joint)}, must be {PinJoint}.'
+            )
+            raise TypeError(msg)
+        return cls(
+            torque,
+            pin_joint.joint_axis,
+            pin_joint.child_interframe,
+            pin_joint.parent_interframe,
+        )
+
+    @property
+    def torque(self):
+        """The magnitude of the torque produced by the actuator."""
+        return self._torque
+
+    @torque.setter
+    def torque(self, torque):
+        if hasattr(self, '_torque'):
+            msg = (
+                f'Can\'t set attribute `torque` to {repr(torque)} as it is '
+                f'immutable.'
+            )
+            raise AttributeError(msg)
+        self._torque = sympify(torque, strict=True)
+
+    @property
+    def axis(self):
+        """The axis about which the torque acts."""
+        return self._axis
+
+    @axis.setter
+    def axis(self, axis):
+        if hasattr(self, '_axis'):
+            msg = (
+                f'Can\'t set attribute `axis` to {repr(axis)} as it is '
+                f'immutable.'
+            )
+            raise AttributeError(msg)
+        if not isinstance(axis, Vector):
+            msg = (
+                f'Value {repr(axis)} passed to `axis` was of type '
+                f'{type(axis)}, must be {Vector}.'
+            )
+            raise TypeError(msg)
+        self._axis = axis
+
+    @property
+    def target_frame(self):
+        """The primary reference frames on which the torque will act."""
+        return self._target_frame
+
+    @target_frame.setter
+    def target_frame(self, target_frame):
+        if hasattr(self, '_target_frame'):
+            msg = (
+                f'Can\'t set attribute `target_frame` to {repr(target_frame)} '
+                f'as it is immutable.'
+            )
+            raise AttributeError(msg)
+        if isinstance(target_frame, RigidBody):
+            target_frame = target_frame.frame
+        elif not isinstance(target_frame, ReferenceFrame):
+            msg = (
+                f'Value {repr(target_frame)} passed to `target_frame` was of '
+                f'type {type(target_frame)}, must be {ReferenceFrame}.'
+            )
+            raise TypeError(msg)
+        self._target_frame = target_frame
+
+    @property
+    def reaction_frame(self):
+        """The primary reference frames on which the torque will act."""
+        return self._reaction_frame
+
+    @reaction_frame.setter
+    def reaction_frame(self, reaction_frame):
+        if hasattr(self, '_reaction_frame'):
+            msg = (
+                f'Can\'t set attribute `reaction_frame` to '
+                f'{repr(reaction_frame)} as it is immutable.'
+            )
+            raise AttributeError(msg)
+        if isinstance(reaction_frame, RigidBody):
+            reaction_frame = reaction_frame.frame
+        elif (
+            not isinstance(reaction_frame, ReferenceFrame)
+            and reaction_frame is not None
+        ):
+            msg = (
+                f'Value {repr(reaction_frame)} passed to `reaction_frame` was '
+                f'of type {type(reaction_frame)}, must be {ReferenceFrame}.'
+            )
+            raise TypeError(msg)
+        self._reaction_frame = reaction_frame
+
+    def to_loads(self):
+        """Loads required by the equations of motion method classes.
+
+        Explanation
+        ===========
+
+        ``KanesMethod`` requires a list of ``Point``-``Vector`` tuples to be
+        passed to the ``loads`` parameters of its ``kanes_equations`` method
+        when constructing the equations of motion. This method acts as a
+        utility to produce the correctly-structred pairs of points and vectors
+        required so that these can be easily concatenated with other items in
+        the list of loads and passed to ``KanesMethod.kanes_equations``. These
+        loads are also in the correct form to also be passed to the other
+        equations of motion method classes, e.g. ``LagrangesMethod``.
+
+        Examples
+        ========
+
+        The below example shows how to generate the loads produced by a torque
+        actuator that acts on a pair of bodies attached by a pin joint.
+
+        >>> from sympy import symbols
+        >>> from sympy.physics.mechanics import (PinJoint, ReferenceFrame,
+        ...     RigidBody, TorqueActuator)
+        >>> torque = symbols('T')
+        >>> N = ReferenceFrame('N')
+        >>> A = ReferenceFrame('A')
+        >>> parent = RigidBody('parent', frame=N)
+        >>> child = RigidBody('child', frame=A)
+        >>> pin_joint = PinJoint(
+        ...     'pin',
+        ...     parent,
+        ...     child,
+        ...     joint_axis=N.z,
+        ... )
+        >>> actuator = TorqueActuator.at_pin_joint(torque, pin_joint)
+
+        The forces produces by the damper can be generated by calling the
+        ``to_loads`` method.
+
+        >>> actuator.to_loads()
+        [(A, T*N.z), (N, - T*N.z)]
+
+        Alternatively, if a torque actuator is created without a reaction frame
+        then the loads returned by the ``to_loads`` method will contain just
+        the single load acting on the target frame.
+
+        >>> actuator = TorqueActuator(torque, N.z, N)
+        >>> actuator.to_loads()
+        [(N, T*N.z)]
+
+        """
+        loads = [
+            Torque(self.target_frame, self.torque*self.axis),
+        ]
+        if self.reaction_frame is not None:
+            loads.append(Torque(self.reaction_frame, -self.torque*self.axis))
+        return loads
+
+    def __repr__(self):
+        """Representation of a ``TorqueActuator``."""
+        string = (
+            f'{self.__class__.__name__}({self.torque}, axis={self.axis}, '
+            f'target_frame={self.target_frame}'
+        )
+        if self.reaction_frame is not None:
+            string += f', reaction_frame={self.reaction_frame})'
+        else:
+            string += ')'
+        return string
+
+
+class DuffingSpring(ForceActuator):
+    """A nonlinear spring based on the Duffing equation.
+
+    Explanation
+    ===========
+
+    Here, ``DuffingSpring`` represents the force exerted by a nonlinear spring based on the Duffing equation:
+    F = -beta*x-alpha*x**3, where x is the displacement from the equilibrium position, beta is the linear spring constant,
+    and alpha is the coefficient for the nonlinear cubic term.
+
+    Parameters
+    ==========
+
+    linear_stiffness : Expr
+        The linear stiffness coefficient (beta).
+    nonlinear_stiffness : Expr
+        The nonlinear stiffness coefficient (alpha).
+    pathway : PathwayBase
+        The pathway that the actuator follows.
+    equilibrium_length : Expr, optional
+        The length at which the spring is in equilibrium (x).
+    """
+
+    def __init__(self, linear_stiffness, nonlinear_stiffness, pathway, equilibrium_length=S.Zero):
+        self.linear_stiffness = sympify(linear_stiffness, strict=True)
+        self.nonlinear_stiffness = sympify(nonlinear_stiffness, strict=True)
+        self.equilibrium_length = sympify(equilibrium_length, strict=True)
+
+        if not isinstance(pathway, PathwayBase):
+            raise TypeError("pathway must be an instance of PathwayBase.")
+        self._pathway = pathway
+
+    @property
+    def linear_stiffness(self):
+        return self._linear_stiffness
+
+    @linear_stiffness.setter
+    def linear_stiffness(self, linear_stiffness):
+        if hasattr(self, '_linear_stiffness'):
+            msg = (
+                f'Can\'t set attribute `linear_stiffness` to '
+                f'{repr(linear_stiffness)} as it is immutable.'
+            )
+            raise AttributeError(msg)
+        self._linear_stiffness = sympify(linear_stiffness, strict=True)
+
+    @property
+    def nonlinear_stiffness(self):
+        return self._nonlinear_stiffness
+
+    @nonlinear_stiffness.setter
+    def nonlinear_stiffness(self, nonlinear_stiffness):
+        if hasattr(self, '_nonlinear_stiffness'):
+            msg = (
+                f'Can\'t set attribute `nonlinear_stiffness` to '
+                f'{repr(nonlinear_stiffness)} as it is immutable.'
+            )
+            raise AttributeError(msg)
+        self._nonlinear_stiffness = sympify(nonlinear_stiffness, strict=True)
+
+    @property
+    def pathway(self):
+        return self._pathway
+
+    @pathway.setter
+    def pathway(self, pathway):
+        if hasattr(self, '_pathway'):
+            msg = (
+                f'Can\'t set attribute `pathway` to {repr(pathway)} as it is '
+                f'immutable.'
+            )
+            raise AttributeError(msg)
+        if not isinstance(pathway, PathwayBase):
+            msg = (
+                f'Value {repr(pathway)} passed to `pathway` was of type '
+                f'{type(pathway)}, must be {PathwayBase}.'
+            )
+            raise TypeError(msg)
+        self._pathway = pathway
+
+    @property
+    def equilibrium_length(self):
+        return self._equilibrium_length
+
+    @equilibrium_length.setter
+    def equilibrium_length(self, equilibrium_length):
+        if hasattr(self, '_equilibrium_length'):
+            msg = (
+                f'Can\'t set attribute `equilibrium_length` to '
+                f'{repr(equilibrium_length)} as it is immutable.'
+            )
+            raise AttributeError(msg)
+        self._equilibrium_length = sympify(equilibrium_length, strict=True)
+
+    @property
+    def force(self):
+        """The force produced by the Duffing spring."""
+        displacement = self.pathway.length - self.equilibrium_length
+        return -self.linear_stiffness * displacement - self.nonlinear_stiffness * displacement**3
+
+    @force.setter
+    def force(self, force):
+        if hasattr(self, '_force'):
+            msg = (
+                f'Can\'t set attribute `force` to {repr(force)} as it is '
+                f'immutable.'
+            )
+            raise AttributeError(msg)
+        self._force = sympify(force, strict=True)
+
+    def __repr__(self):
+        return (f"{self.__class__.__name__}("
+                f"{self.linear_stiffness}, {self.nonlinear_stiffness}, {self.pathway}, "
+                f"equilibrium_length={self.equilibrium_length})")

mplug_owl2/lib/python3.10/site-packages/sympy/physics/mechanics/body.py

@@ -0,0 +1,710 @@
+from sympy import Symbol
+from sympy.physics.vector import Point, Vector, ReferenceFrame, Dyadic
+from sympy.physics.mechanics import RigidBody, Particle, Inertia
+from sympy.physics.mechanics.body_base import BodyBase
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+__all__ = ['Body']
+
+
+# XXX: We use type:ignore because the classes RigidBody and Particle have
+# inconsistent parallel axis methods that take different numbers of arguments.
+class Body(RigidBody, Particle):  # type: ignore
+    """
+    Body is a common representation of either a RigidBody or a Particle SymPy
+    object depending on what is passed in during initialization. If a mass is
+    passed in and central_inertia is left as None, the Particle object is
+    created. Otherwise a RigidBody object will be created.
+
+    .. deprecated:: 1.13
+        The Body class is deprecated. Its functionality is captured by
+        :class:`~.RigidBody` and :class:`~.Particle`.
+
+    Explanation
+    ===========
+
+    The attributes that Body possesses will be the same as a Particle instance
+    or a Rigid Body instance depending on which was created. Additional
+    attributes are listed below.
+
+    Attributes
+    ==========
+
+    name : string
+        The body's name
+    masscenter : Point
+        The point which represents the center of mass of the rigid body
+    frame : ReferenceFrame
+        The reference frame which the body is fixed in
+    mass : Sympifyable
+        The body's mass
+    inertia : (Dyadic, Point)
+        The body's inertia around its center of mass. This attribute is specific
+        to the rigid body form of Body and is left undefined for the Particle
+        form
+    loads : iterable
+        This list contains information on the different loads acting on the
+        Body. Forces are listed as a (point, vector) tuple and torques are
+        listed as (reference frame, vector) tuples.
+
+    Parameters
+    ==========
+
+    name : String
+        Defines the name of the body. It is used as the base for defining
+        body specific properties.
+    masscenter : Point, optional
+        A point that represents the center of mass of the body or particle.
+        If no point is given, a point is generated.
+    mass : Sympifyable, optional
+        A Sympifyable object which represents the mass of the body. If no
+        mass is passed, one is generated.
+    frame : ReferenceFrame, optional
+        The ReferenceFrame that represents the reference frame of the body.
+        If no frame is given, a frame is generated.
+    central_inertia : Dyadic, optional
+        Central inertia dyadic of the body. If none is passed while creating
+        RigidBody, a default inertia is generated.
+
+    Examples
+    ========
+
+    As Body has been deprecated, the following examples are for illustrative
+    purposes only. The functionality of Body is fully captured by
+    :class:`~.RigidBody` and :class:`~.Particle`. To ignore the deprecation
+    warning we can use the ignore_warnings context manager.
+
+        >>> from sympy.utilities.exceptions import ignore_warnings
+
+    Default behaviour. This results in the creation of a RigidBody object for
+    which the mass, mass center, frame and inertia attributes are given default
+    values. ::
+
+        >>> from sympy.physics.mechanics import Body
+        >>> with ignore_warnings(DeprecationWarning):
+        ...     body = Body('name_of_body')
+
+    This next example demonstrates the code required to specify all of the
+    values of the Body object. Note this will also create a RigidBody version of
+    the Body object. ::
+
+        >>> from sympy import Symbol
+        >>> from sympy.physics.mechanics import ReferenceFrame, Point, inertia
+        >>> from sympy.physics.mechanics import Body
+        >>> mass = Symbol('mass')
+        >>> masscenter = Point('masscenter')
+        >>> frame = ReferenceFrame('frame')
+        >>> ixx = Symbol('ixx')
+        >>> body_inertia = inertia(frame, ixx, 0, 0)
+        >>> with ignore_warnings(DeprecationWarning):
+        ...     body = Body('name_of_body', masscenter, mass, frame, body_inertia)
+
+    The minimal code required to create a Particle version of the Body object
+    involves simply passing in a name and a mass. ::
+
+        >>> from sympy import Symbol
+        >>> from sympy.physics.mechanics import Body
+        >>> mass = Symbol('mass')
+        >>> with ignore_warnings(DeprecationWarning):
+        ...     body = Body('name_of_body', mass=mass)
+
+    The Particle version of the Body object can also receive a masscenter point
+    and a reference frame, just not an inertia.
+    """
+
+    def __init__(self, name, masscenter=None, mass=None, frame=None,
+                 central_inertia=None):
+        sympy_deprecation_warning(
+            """
+            Support for the Body class has been removed, as its functionality is
+            fully captured by RigidBody and Particle.
+            """,
+            deprecated_since_version="1.13",
+            active_deprecations_target="deprecated-mechanics-body-class"
+        )
+
+        self._loads = []
+
+        if frame is None:
+            frame = ReferenceFrame(name + '_frame')
+
+        if masscenter is None:
+            masscenter = Point(name + '_masscenter')
+
+        if central_inertia is None and mass is None:
+            ixx = Symbol(name + '_ixx')
+            iyy = Symbol(name + '_iyy')
+            izz = Symbol(name + '_izz')
+            izx = Symbol(name + '_izx')
+            ixy = Symbol(name + '_ixy')
+            iyz = Symbol(name + '_iyz')
+            _inertia = Inertia.from_inertia_scalars(masscenter, frame, ixx, iyy,
+                                                    izz, ixy, iyz, izx)
+        else:
+            _inertia = (central_inertia, masscenter)
+
+        if mass is None:
+            _mass = Symbol(name + '_mass')
+        else:
+            _mass = mass
+
+        masscenter.set_vel(frame, 0)
+
+        # If user passes masscenter and mass then a particle is created
+        # otherwise a rigidbody. As a result a body may or may not have inertia.
+        # Note: BodyBase.__init__ is used to prevent problems with super() calls in
+        # Particle and RigidBody arising due to multiple inheritance.
+        if central_inertia is None and mass is not None:
+            BodyBase.__init__(self, name, masscenter, _mass)
+            self.frame = frame
+            self._central_inertia = Dyadic(0)
+        else:
+            BodyBase.__init__(self, name, masscenter, _mass)
+            self.frame = frame
+            self.inertia = _inertia
+
+    def __repr__(self):
+        if self.is_rigidbody:
+            return RigidBody.__repr__(self)
+        return Particle.__repr__(self)
+
+    @property
+    def loads(self):
+        return self._loads
+
+    @property
+    def x(self):
+        """The basis Vector for the Body, in the x direction."""
+        return self.frame.x
+
+    @property
+    def y(self):
+        """The basis Vector for the Body, in the y direction."""
+        return self.frame.y
+
+    @property
+    def z(self):
+        """The basis Vector for the Body, in the z direction."""
+        return self.frame.z
+
+    @property
+    def inertia(self):
+        """The body's inertia about a point; stored as (Dyadic, Point)."""
+        if self.is_rigidbody:
+            return RigidBody.inertia.fget(self)
+        return (self.central_inertia, self.masscenter)
+
+    @inertia.setter
+    def inertia(self, I):
+        RigidBody.inertia.fset(self, I)
+
+    @property
+    def is_rigidbody(self):
+        if hasattr(self, '_inertia'):
+            return True
+        return False
+
+    def kinetic_energy(self, frame):
+        """Kinetic energy of the body.
+
+        Parameters
+        ==========
+
+        frame : ReferenceFrame or Body
+            The Body's angular velocity and the velocity of it's mass
+            center are typically defined with respect to an inertial frame but
+            any relevant frame in which the velocities are known can be supplied.
+
+        Examples
+        ========
+
+        As Body has been deprecated, the following examples are for illustrative
+        purposes only. The functionality of Body is fully captured by
+        :class:`~.RigidBody` and :class:`~.Particle`. To ignore the deprecation
+        warning we can use the ignore_warnings context manager.
+
+        >>> from sympy.utilities.exceptions import ignore_warnings
+        >>> from sympy.physics.mechanics import Body, ReferenceFrame, Point
+        >>> from sympy import symbols
+        >>> m, v, r, omega = symbols('m v r omega')
+        >>> N = ReferenceFrame('N')
+        >>> O = Point('O')
+        >>> with ignore_warnings(DeprecationWarning):
+        ...     P = Body('P', masscenter=O, mass=m)
+        >>> P.masscenter.set_vel(N, v * N.y)
+        >>> P.kinetic_energy(N)
+        m*v**2/2
+
+        >>> N = ReferenceFrame('N')
+        >>> b = ReferenceFrame('b')
+        >>> b.set_ang_vel(N, omega * b.x)
+        >>> P = Point('P')
+        >>> P.set_vel(N, v * N.x)
+        >>> with ignore_warnings(DeprecationWarning):
+        ...     B = Body('B', masscenter=P, frame=b)
+        >>> B.kinetic_energy(N)
+        B_ixx*omega**2/2 + B_mass*v**2/2
+
+        See Also
+        ========
+
+        sympy.physics.mechanics : Particle, RigidBody
+
+        """
+        if isinstance(frame, Body):
+            frame = Body.frame
+        if self.is_rigidbody:
+            return RigidBody(self.name, self.masscenter, self.frame, self.mass,
+                            (self.central_inertia, self.masscenter)).kinetic_energy(frame)
+        return Particle(self.name, self.masscenter, self.mass).kinetic_energy(frame)
+
+    def apply_force(self, force, point=None, reaction_body=None, reaction_point=None):
+        """Add force to the body(s).
+
+        Explanation
+        ===========
+
+        Applies the force on self or equal and opposite forces on
+        self and other body if both are given on the desired point on the bodies.
+        The force applied on other body is taken opposite of self, i.e, -force.
+
+        Parameters
+        ==========
+
+        force: Vector
+            The force to be applied.
+        point: Point, optional
+            The point on self on which force is applied.
+            By default self's masscenter.
+        reaction_body: Body, optional
+            Second body on which equal and opposite force
+            is to be applied.
+        reaction_point : Point, optional
+            The point on other body on which equal and opposite
+            force is applied. By default masscenter of other body.
+
+        Example
+        =======
+
+        As Body has been deprecated, the following examples are for illustrative
+        purposes only. The functionality of Body is fully captured by
+        :class:`~.RigidBody` and :class:`~.Particle`. To ignore the deprecation
+        warning we can use the ignore_warnings context manager.
+
+        >>> from sympy.utilities.exceptions import ignore_warnings
+        >>> from sympy import symbols
+        >>> from sympy.physics.mechanics import Body, Point, dynamicsymbols
+        >>> m, g = symbols('m g')
+        >>> with ignore_warnings(DeprecationWarning):
+        ...     B = Body('B')
+        >>> force1 = m*g*B.z
+        >>> B.apply_force(force1) #Applying force on B's masscenter
+        >>> B.loads
+        [(B_masscenter, g*m*B_frame.z)]
+
+        We can also remove some part of force from any point on the body by
+        adding the opposite force to the body on that point.
+
+        >>> f1, f2 = dynamicsymbols('f1 f2')
+        >>> P = Point('P') #Considering point P on body B
+        >>> B.apply_force(f1*B.x + f2*B.y, P)
+        >>> B.loads
+        [(B_masscenter, g*m*B_frame.z), (P, f1(t)*B_frame.x + f2(t)*B_frame.y)]
+
+        Let's remove f1 from point P on body B.
+
+        >>> B.apply_force(-f1*B.x, P)
+        >>> B.loads
+        [(B_masscenter, g*m*B_frame.z), (P, f2(t)*B_frame.y)]
+
+        To further demonstrate the use of ``apply_force`` attribute,
+        consider two bodies connected through a spring.
+
+        >>> from sympy.physics.mechanics import Body, dynamicsymbols
+        >>> with ignore_warnings(DeprecationWarning):
+        ...     N = Body('N') #Newtonion Frame
+        >>> x = dynamicsymbols('x')
+        >>> with ignore_warnings(DeprecationWarning):
+        ...     B1 = Body('B1')
+        ...     B2 = Body('B2')
+        >>> spring_force = x*N.x
+
+        Now let's apply equal and opposite spring force to the bodies.
+
+        >>> P1 = Point('P1')
+        >>> P2 = Point('P2')
+        >>> B1.apply_force(spring_force, point=P1, reaction_body=B2, reaction_point=P2)
+
+        We can check the loads(forces) applied to bodies now.
+
+        >>> B1.loads
+        [(P1, x(t)*N_frame.x)]
+        >>> B2.loads
+        [(P2, - x(t)*N_frame.x)]
+
+        Notes
+        =====
+
+        If a new force is applied to a body on a point which already has some
+        force applied on it, then the new force is added to the already applied
+        force on that point.
+
+        """
+
+        if not isinstance(point, Point):
+            if point is None:
+                point = self.masscenter  # masscenter
+            else:
+                raise TypeError("Force must be applied to a point on the body.")
+        if not isinstance(force, Vector):
+            raise TypeError("Force must be a vector.")
+
+        if reaction_body is not None:
+            reaction_body.apply_force(-force, point=reaction_point)
+
+        for load in self._loads:
+            if point in load:
+                force += load[1]
+                self._loads.remove(load)
+                break
+
+        self._loads.append((point, force))
+
+    def apply_torque(self, torque, reaction_body=None):
+        """Add torque to the body(s).
+
+        Explanation
+        ===========
+
+        Applies the torque on self or equal and opposite torques on
+        self and other body if both are given.
+        The torque applied on other body is taken opposite of self,
+        i.e, -torque.
+
+        Parameters
+        ==========
+
+        torque: Vector
+            The torque to be applied.
+        reaction_body: Body, optional
+            Second body on which equal and opposite torque
+            is to be applied.
+
+        Example
+        =======
+
+        As Body has been deprecated, the following examples are for illustrative
+        purposes only. The functionality of Body is fully captured by
+        :class:`~.RigidBody` and :class:`~.Particle`. To ignore the deprecation
+        warning we can use the ignore_warnings context manager.
+
+        >>> from sympy.utilities.exceptions import ignore_warnings
+        >>> from sympy import symbols
+        >>> from sympy.physics.mechanics import Body, dynamicsymbols
+        >>> t = symbols('t')
+        >>> with ignore_warnings(DeprecationWarning):
+        ...     B = Body('B')
+        >>> torque1 = t*B.z
+        >>> B.apply_torque(torque1)
+        >>> B.loads
+        [(B_frame, t*B_frame.z)]
+
+        We can also remove some part of torque from the body by
+        adding the opposite torque to the body.
+
+        >>> t1, t2 = dynamicsymbols('t1 t2')
+        >>> B.apply_torque(t1*B.x + t2*B.y)
+        >>> B.loads
+        [(B_frame, t1(t)*B_frame.x + t2(t)*B_frame.y + t*B_frame.z)]
+
+        Let's remove t1 from Body B.
+
+        >>> B.apply_torque(-t1*B.x)
+        >>> B.loads
+        [(B_frame, t2(t)*B_frame.y + t*B_frame.z)]
+
+        To further demonstrate the use, let us consider two bodies such that
+        a torque `T` is acting on one body, and `-T` on the other.
+
+        >>> from sympy.physics.mechanics import Body, dynamicsymbols
+        >>> with ignore_warnings(DeprecationWarning):
+        ...     N = Body('N') #Newtonion frame
+        ...     B1 = Body('B1')
+        ...     B2 = Body('B2')
+        >>> v = dynamicsymbols('v')
+        >>> T = v*N.y #Torque
+
+        Now let's apply equal and opposite torque to the bodies.
+
+        >>> B1.apply_torque(T, B2)
+
+        We can check the loads (torques) applied to bodies now.
+
+        >>> B1.loads
+        [(B1_frame, v(t)*N_frame.y)]
+        >>> B2.loads
+        [(B2_frame, - v(t)*N_frame.y)]
+
+        Notes
+        =====
+
+        If a new torque is applied on body which already has some torque applied on it,
+        then the new torque is added to the previous torque about the body's frame.
+
+        """
+
+        if not isinstance(torque, Vector):
+            raise TypeError("A Vector must be supplied to add torque.")
+
+        if reaction_body is not None:
+            reaction_body.apply_torque(-torque)
+
+        for load in self._loads:
+            if self.frame in load:
+                torque += load[1]
+                self._loads.remove(load)
+                break
+        self._loads.append((self.frame, torque))
+
+    def clear_loads(self):
+        """
+        Clears the Body's loads list.
+
+        Example
+        =======
+
+        As Body has been deprecated, the following examples are for illustrative
+        purposes only. The functionality of Body is fully captured by
+        :class:`~.RigidBody` and :class:`~.Particle`. To ignore the deprecation
+        warning we can use the ignore_warnings context manager.
+
+        >>> from sympy.utilities.exceptions import ignore_warnings
+        >>> from sympy.physics.mechanics import Body
+        >>> with ignore_warnings(DeprecationWarning):
+        ...     B = Body('B')
+        >>> force = B.x + B.y
+        >>> B.apply_force(force)
+        >>> B.loads
+        [(B_masscenter, B_frame.x + B_frame.y)]
+        >>> B.clear_loads()
+        >>> B.loads
+        []
+
+        """
+
+        self._loads = []
+
+    def remove_load(self, about=None):
+        """
+        Remove load about a point or frame.
+
+        Parameters
+        ==========
+
+        about : Point or ReferenceFrame, optional
+            The point about which force is applied,
+            and is to be removed.
+            If about is None, then the torque about
+            self's frame is removed.
+
+        Example
+        =======
+
+        As Body has been deprecated, the following examples are for illustrative
+        purposes only. The functionality of Body is fully captured by
+        :class:`~.RigidBody` and :class:`~.Particle`. To ignore the deprecation
+        warning we can use the ignore_warnings context manager.
+
+        >>> from sympy.utilities.exceptions import ignore_warnings
+        >>> from sympy.physics.mechanics import Body, Point
+        >>> with ignore_warnings(DeprecationWarning):
+        ...     B = Body('B')
+        >>> P = Point('P')
+        >>> f1 = B.x
+        >>> f2 = B.y
+        >>> B.apply_force(f1)
+        >>> B.apply_force(f2, P)
+        >>> B.loads
+        [(B_masscenter, B_frame.x), (P, B_frame.y)]
+
+        >>> B.remove_load(P)
+        >>> B.loads
+        [(B_masscenter, B_frame.x)]
+
+        """
+
+        if about is not None:
+            if not isinstance(about, Point):
+                raise TypeError('Load is applied about Point or ReferenceFrame.')
+        else:
+            about = self.frame
+
+        for load in self._loads:
+            if about in load:
+                self._loads.remove(load)
+                break
+
+    def masscenter_vel(self, body):
+        """
+        Returns the velocity of the mass center with respect to the provided
+        rigid body or reference frame.
+
+        Parameters
+        ==========
+
+        body: Body or ReferenceFrame
+            The rigid body or reference frame to calculate the velocity in.
+
+        Example
+        =======
+
+        As Body has been deprecated, the following examples are for illustrative
+        purposes only. The functionality of Body is fully captured by
+        :class:`~.RigidBody` and :class:`~.Particle`. To ignore the deprecation
+        warning we can use the ignore_warnings context manager.
+
+        >>> from sympy.utilities.exceptions import ignore_warnings
+        >>> from sympy.physics.mechanics import Body
+        >>> with ignore_warnings(DeprecationWarning):
+        ...     A = Body('A')
+        ...     B = Body('B')
+        >>> A.masscenter.set_vel(B.frame, 5*B.frame.x)
+        >>> A.masscenter_vel(B)
+        5*B_frame.x
+        >>> A.masscenter_vel(B.frame)
+        5*B_frame.x
+
+        """
+
+        if isinstance(body,  ReferenceFrame):
+            frame=body
+        elif isinstance(body, Body):
+            frame = body.frame
+        return self.masscenter.vel(frame)
+
+    def ang_vel_in(self, body):
+        """
+        Returns this body's angular velocity with respect to the provided
+        rigid body or reference frame.
+
+        Parameters
+        ==========
+
+        body: Body or ReferenceFrame
+            The rigid body or reference frame to calculate the angular velocity in.
+
+        Example
+        =======
+
+        As Body has been deprecated, the following examples are for illustrative
+        purposes only. The functionality of Body is fully captured by
+        :class:`~.RigidBody` and :class:`~.Particle`. To ignore the deprecation
+        warning we can use the ignore_warnings context manager.
+
+        >>> from sympy.utilities.exceptions import ignore_warnings
+        >>> from sympy.physics.mechanics import Body, ReferenceFrame
+        >>> with ignore_warnings(DeprecationWarning):
+        ...     A = Body('A')
+        >>> N = ReferenceFrame('N')
+        >>> with ignore_warnings(DeprecationWarning):
+        ...     B = Body('B', frame=N)
+        >>> A.frame.set_ang_vel(N, 5*N.x)
+        >>> A.ang_vel_in(B)
+        5*N.x
+        >>> A.ang_vel_in(N)
+        5*N.x
+
+        """
+
+        if isinstance(body,  ReferenceFrame):
+            frame=body
+        elif isinstance(body, Body):
+            frame = body.frame
+        return self.frame.ang_vel_in(frame)
+
+    def dcm(self, body):
+        """
+        Returns the direction cosine matrix of this body relative to the
+        provided rigid body or reference frame.
+
+        Parameters
+        ==========
+
+        body: Body or ReferenceFrame
+            The rigid body or reference frame to calculate the dcm.
+
+        Example
+        =======
+
+        As Body has been deprecated, the following examples are for illustrative
+        purposes only. The functionality of Body is fully captured by
+        :class:`~.RigidBody` and :class:`~.Particle`. To ignore the deprecation
+        warning we can use the ignore_warnings context manager.
+
+        >>> from sympy.utilities.exceptions import ignore_warnings
+        >>> from sympy.physics.mechanics import Body
+        >>> with ignore_warnings(DeprecationWarning):
+        ...     A = Body('A')
+        ...     B = Body('B')
+        >>> A.frame.orient_axis(B.frame, B.frame.x, 5)
+        >>> A.dcm(B)
+        Matrix([
+        [1,       0,      0],
+        [0,  cos(5), sin(5)],
+        [0, -sin(5), cos(5)]])
+        >>> A.dcm(B.frame)
+        Matrix([
+        [1,       0,      0],
+        [0,  cos(5), sin(5)],
+        [0, -sin(5), cos(5)]])
+
+        """
+
+        if isinstance(body,  ReferenceFrame):
+            frame=body
+        elif isinstance(body, Body):
+            frame = body.frame
+        return self.frame.dcm(frame)
+
+    def parallel_axis(self, point, frame=None):
+        """Returns the inertia dyadic of the body with respect to another
+        point.
+
+        Parameters
+        ==========
+
+        point : sympy.physics.vector.Point
+            The point to express the inertia dyadic about.
+        frame : sympy.physics.vector.ReferenceFrame
+            The reference frame used to construct the dyadic.
+
+        Returns
+        =======
+
+        inertia : sympy.physics.vector.Dyadic
+            The inertia dyadic of the rigid body expressed about the provided
+            point.
+
+        Example
+        =======
+
+        As Body has been deprecated, the following examples are for illustrative
+        purposes only. The functionality of Body is fully captured by
+        :class:`~.RigidBody` and :class:`~.Particle`. To ignore the deprecation
+        warning we can use the ignore_warnings context manager.
+
+        >>> from sympy.utilities.exceptions import ignore_warnings
+        >>> from sympy.physics.mechanics import Body
+        >>> with ignore_warnings(DeprecationWarning):
+        ...     A = Body('A')
+        >>> P = A.masscenter.locatenew('point', 3 * A.x + 5 * A.y)
+        >>> A.parallel_axis(P).to_matrix(A.frame)
+        Matrix([
+        [A_ixx + 25*A_mass, A_ixy - 15*A_mass,             A_izx],
+        [A_ixy - 15*A_mass,  A_iyy + 9*A_mass,             A_iyz],
+        [            A_izx,             A_iyz, A_izz + 34*A_mass]])
+
+        """
+        if self.is_rigidbody:
+            return RigidBody.parallel_axis(self, point, frame)
+        return Particle.parallel_axis(self, point, frame)

mplug_owl2/lib/python3.10/site-packages/sympy/physics/mechanics/body_base.py

@@ -0,0 +1,94 @@
+from abc import ABC, abstractmethod
+from sympy import Symbol, sympify
+from sympy.physics.vector import Point
+
+__all__ = ['BodyBase']
+
+
+class BodyBase(ABC):
+    """Abstract class for body type objects."""
+    def __init__(self, name, masscenter=None, mass=None):
+        # Note: If frame=None, no auto-generated frame is created, because a
+        # Particle does not need to have a frame by default.
+        if not isinstance(name, str):
+            raise TypeError('Supply a valid name.')
+        self._name = name
+        if mass is None:
+            mass = Symbol(f'{name}_mass')
+        if masscenter is None:
+            masscenter = Point(f'{name}_masscenter')
+        self.mass = mass
+        self.masscenter = masscenter
+        self.potential_energy = 0
+        self.points = []
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return (f'{self.__class__.__name__}({repr(self.name)}, masscenter='
+                f'{repr(self.masscenter)}, mass={repr(self.mass)})')
+
+    @property
+    def name(self):
+        """The name of the body."""
+        return self._name
+
+    @property
+    def masscenter(self):
+        """The body's center of mass."""
+        return self._masscenter
+
+    @masscenter.setter
+    def masscenter(self, point):
+        if not isinstance(point, Point):
+            raise TypeError("The body's center of mass must be a Point object.")
+        self._masscenter = point
+
+    @property
+    def mass(self):
+        """The body's mass."""
+        return self._mass
+
+    @mass.setter
+    def mass(self, mass):
+        self._mass = sympify(mass)
+
+    @property
+    def potential_energy(self):
+        """The potential energy of the body.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.mechanics import Particle, Point
+        >>> from sympy import symbols
+        >>> m, g, h = symbols('m g h')
+        >>> O = Point('O')
+        >>> P = Particle('P', O, m)
+        >>> P.potential_energy = m * g * h
+        >>> P.potential_energy
+        g*h*m
+
+        """
+        return self._potential_energy
+
+    @potential_energy.setter
+    def potential_energy(self, scalar):
+        self._potential_energy = sympify(scalar)
+
+    @abstractmethod
+    def kinetic_energy(self, frame):
+        pass
+
+    @abstractmethod
+    def linear_momentum(self, frame):
+        pass
+
+    @abstractmethod
+    def angular_momentum(self, point, frame):
+        pass
+
+    @abstractmethod
+    def parallel_axis(self, point, frame):
+        pass

mplug_owl2/lib/python3.10/site-packages/sympy/physics/mechanics/functions.py

@@ -0,0 +1,735 @@
+from sympy.utilities import dict_merge
+from sympy.utilities.iterables import iterable
+from sympy.physics.vector import (Dyadic, Vector, ReferenceFrame,
+                                  Point, dynamicsymbols)
+from sympy.physics.vector.printing import (vprint, vsprint, vpprint, vlatex,
+                                           init_vprinting)
+from sympy.physics.mechanics.particle import Particle
+from sympy.physics.mechanics.rigidbody import RigidBody
+from sympy.simplify.simplify import simplify
+from sympy import Matrix, Mul, Derivative, sin, cos, tan, S
+from sympy.core.function import AppliedUndef
+from sympy.physics.mechanics.inertia import (inertia as _inertia,
+    inertia_of_point_mass as _inertia_of_point_mass)
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+__all__ = ['linear_momentum',
+           'angular_momentum',
+           'kinetic_energy',
+           'potential_energy',
+           'Lagrangian',
+           'mechanics_printing',
+           'mprint',
+           'msprint',
+           'mpprint',
+           'mlatex',
+           'msubs',
+           'find_dynamicsymbols']
+
+# These are functions that we've moved and renamed during extracting the
+# basic vector calculus code from the mechanics packages.
+
+mprint = vprint
+msprint = vsprint
+mpprint = vpprint
+mlatex = vlatex
+
+
+def mechanics_printing(**kwargs):
+    """
+    Initializes time derivative printing for all SymPy objects in
+    mechanics module.
+    """
+
+    init_vprinting(**kwargs)
+
+mechanics_printing.__doc__ = init_vprinting.__doc__
+
+
+def inertia(frame, ixx, iyy, izz, ixy=0, iyz=0, izx=0):
+    sympy_deprecation_warning(
+        """
+        The inertia function has been moved.
+        Import it from "sympy.physics.mechanics".
+        """,
+        deprecated_since_version="1.13",
+        active_deprecations_target="moved-mechanics-functions"
+    )
+    return _inertia(frame, ixx, iyy, izz, ixy, iyz, izx)
+
+
+def inertia_of_point_mass(mass, pos_vec, frame):
+    sympy_deprecation_warning(
+        """
+        The inertia_of_point_mass function has been moved.
+        Import it from "sympy.physics.mechanics".
+        """,
+        deprecated_since_version="1.13",
+        active_deprecations_target="moved-mechanics-functions"
+    )
+    return _inertia_of_point_mass(mass, pos_vec, frame)
+
+
+def linear_momentum(frame, *body):
+    """Linear momentum of the system.
+
+    Explanation
+    ===========
+
+    This function returns the linear momentum of a system of Particle's and/or
+    RigidBody's. The linear momentum of a system is equal to the vector sum of
+    the linear momentum of its constituents. Consider a system, S, comprised of
+    a rigid body, A, and a particle, P. The linear momentum of the system, L,
+    is equal to the vector sum of the linear momentum of the particle, L1, and
+    the linear momentum of the rigid body, L2, i.e.
+
+    L = L1 + L2
+
+    Parameters
+    ==========
+
+    frame : ReferenceFrame
+        The frame in which linear momentum is desired.
+    body1, body2, body3... : Particle and/or RigidBody
+        The body (or bodies) whose linear momentum is required.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.mechanics import Point, Particle, ReferenceFrame
+    >>> from sympy.physics.mechanics import RigidBody, outer, linear_momentum
+    >>> N = ReferenceFrame('N')
+    >>> P = Point('P')
+    >>> P.set_vel(N, 10 * N.x)
+    >>> Pa = Particle('Pa', P, 1)
+    >>> Ac = Point('Ac')
+    >>> Ac.set_vel(N, 25 * N.y)
+    >>> I = outer(N.x, N.x)
+    >>> A = RigidBody('A', Ac, N, 20, (I, Ac))
+    >>> linear_momentum(N, A, Pa)
+    10*N.x + 500*N.y
+
+    """
+
+    if not isinstance(frame, ReferenceFrame):
+        raise TypeError('Please specify a valid ReferenceFrame')
+    else:
+        linear_momentum_sys = Vector(0)
+        for e in body:
+            if isinstance(e, (RigidBody, Particle)):
+                linear_momentum_sys += e.linear_momentum(frame)
+            else:
+                raise TypeError('*body must have only Particle or RigidBody')
+    return linear_momentum_sys
+
+
+def angular_momentum(point, frame, *body):
+    """Angular momentum of a system.
+
+    Explanation
+    ===========
+
+    This function returns the angular momentum of a system of Particle's and/or
+    RigidBody's. The angular momentum of such a system is equal to the vector
+    sum of the angular momentum of its constituents. Consider a system, S,
+    comprised of a rigid body, A, and a particle, P. The angular momentum of
+    the system, H, is equal to the vector sum of the angular momentum of the
+    particle, H1, and the angular momentum of the rigid body, H2, i.e.
+
+    H = H1 + H2
+
+    Parameters
+    ==========
+
+    point : Point
+        The point about which angular momentum of the system is desired.
+    frame : ReferenceFrame
+        The frame in which angular momentum is desired.
+    body1, body2, body3... : Particle and/or RigidBody
+        The body (or bodies) whose angular momentum is required.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.mechanics import Point, Particle, ReferenceFrame
+    >>> from sympy.physics.mechanics import RigidBody, outer, angular_momentum
+    >>> N = ReferenceFrame('N')
+    >>> O = Point('O')
+    >>> O.set_vel(N, 0 * N.x)
+    >>> P = O.locatenew('P', 1 * N.x)
+    >>> P.set_vel(N, 10 * N.x)
+    >>> Pa = Particle('Pa', P, 1)
+    >>> Ac = O.locatenew('Ac', 2 * N.y)
+    >>> Ac.set_vel(N, 5 * N.y)
+    >>> a = ReferenceFrame('a')
+    >>> a.set_ang_vel(N, 10 * N.z)
+    >>> I = outer(N.z, N.z)
+    >>> A = RigidBody('A', Ac, a, 20, (I, Ac))
+    >>> angular_momentum(O, N, Pa, A)
+    10*N.z
+
+    """
+
+    if not isinstance(frame, ReferenceFrame):
+        raise TypeError('Please enter a valid ReferenceFrame')
+    if not isinstance(point, Point):
+        raise TypeError('Please specify a valid Point')
+    else:
+        angular_momentum_sys = Vector(0)
+        for e in body:
+            if isinstance(e, (RigidBody, Particle)):
+                angular_momentum_sys += e.angular_momentum(point, frame)
+            else:
+                raise TypeError('*body must have only Particle or RigidBody')
+    return angular_momentum_sys
+
+
+def kinetic_energy(frame, *body):
+    """Kinetic energy of a multibody system.
+
+    Explanation
+    ===========
+
+    This function returns the kinetic energy of a system of Particle's and/or
+    RigidBody's. The kinetic energy of such a system is equal to the sum of
+    the kinetic energies of its constituents. Consider a system, S, comprising
+    a rigid body, A, and a particle, P. The kinetic energy of the system, T,
+    is equal to the vector sum of the kinetic energy of the particle, T1, and
+    the kinetic energy of the rigid body, T2, i.e.
+
+    T = T1 + T2
+
+    Kinetic energy is a scalar.
+
+    Parameters
+    ==========
+
+    frame : ReferenceFrame
+        The frame in which the velocity or angular velocity of the body is
+        defined.
+    body1, body2, body3... : Particle and/or RigidBody
+        The body (or bodies) whose kinetic energy is required.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.mechanics import Point, Particle, ReferenceFrame
+    >>> from sympy.physics.mechanics import RigidBody, outer, kinetic_energy
+    >>> N = ReferenceFrame('N')
+    >>> O = Point('O')
+    >>> O.set_vel(N, 0 * N.x)
+    >>> P = O.locatenew('P', 1 * N.x)
+    >>> P.set_vel(N, 10 * N.x)
+    >>> Pa = Particle('Pa', P, 1)
+    >>> Ac = O.locatenew('Ac', 2 * N.y)
+    >>> Ac.set_vel(N, 5 * N.y)
+    >>> a = ReferenceFrame('a')
+    >>> a.set_ang_vel(N, 10 * N.z)
+    >>> I = outer(N.z, N.z)
+    >>> A = RigidBody('A', Ac, a, 20, (I, Ac))
+    >>> kinetic_energy(N, Pa, A)
+    350
+
+    """
+
+    if not isinstance(frame, ReferenceFrame):
+        raise TypeError('Please enter a valid ReferenceFrame')
+    ke_sys = S.Zero
+    for e in body:
+        if isinstance(e, (RigidBody, Particle)):
+            ke_sys += e.kinetic_energy(frame)
+        else:
+            raise TypeError('*body must have only Particle or RigidBody')
+    return ke_sys
+
+
+def potential_energy(*body):
+    """Potential energy of a multibody system.
+
+    Explanation
+    ===========
+
+    This function returns the potential energy of a system of Particle's and/or
+    RigidBody's. The potential energy of such a system is equal to the sum of
+    the potential energy of its constituents. Consider a system, S, comprising
+    a rigid body, A, and a particle, P. The potential energy of the system, V,
+    is equal to the vector sum of the potential energy of the particle, V1, and
+    the potential energy of the rigid body, V2, i.e.
+
+    V = V1 + V2
+
+    Potential energy is a scalar.
+
+    Parameters
+    ==========
+
+    body1, body2, body3... : Particle and/or RigidBody
+        The body (or bodies) whose potential energy is required.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.mechanics import Point, Particle, ReferenceFrame
+    >>> from sympy.physics.mechanics import RigidBody, outer, potential_energy
+    >>> from sympy import symbols
+    >>> M, m, g, h = symbols('M m g h')
+    >>> N = ReferenceFrame('N')
+    >>> O = Point('O')
+    >>> O.set_vel(N, 0 * N.x)
+    >>> P = O.locatenew('P', 1 * N.x)
+    >>> Pa = Particle('Pa', P, m)
+    >>> Ac = O.locatenew('Ac', 2 * N.y)
+    >>> a = ReferenceFrame('a')
+    >>> I = outer(N.z, N.z)
+    >>> A = RigidBody('A', Ac, a, M, (I, Ac))
+    >>> Pa.potential_energy = m * g * h
+    >>> A.potential_energy = M * g * h
+    >>> potential_energy(Pa, A)
+    M*g*h + g*h*m
+
+    """
+
+    pe_sys = S.Zero
+    for e in body:
+        if isinstance(e, (RigidBody, Particle)):
+            pe_sys += e.potential_energy
+        else:
+            raise TypeError('*body must have only Particle or RigidBody')
+    return pe_sys
+
+
+def gravity(acceleration, *bodies):
+    from sympy.physics.mechanics.loads import gravity as _gravity
+    sympy_deprecation_warning(
+        """
+        The gravity function has been moved.
+        Import it from "sympy.physics.mechanics.loads".
+        """,
+        deprecated_since_version="1.13",
+        active_deprecations_target="moved-mechanics-functions"
+    )
+    return _gravity(acceleration, *bodies)
+
+
+def center_of_mass(point, *bodies):
+    """
+    Returns the position vector from the given point to the center of mass
+    of the given bodies(particles or rigidbodies).
+
+    Example
+    =======
+
+    >>> from sympy import symbols, S
+    >>> from sympy.physics.vector import Point
+    >>> from sympy.physics.mechanics import Particle, ReferenceFrame, RigidBody, outer
+    >>> from sympy.physics.mechanics.functions import center_of_mass
+    >>> a = ReferenceFrame('a')
+    >>> m = symbols('m', real=True)
+    >>> p1 = Particle('p1', Point('p1_pt'), S(1))
+    >>> p2 = Particle('p2', Point('p2_pt'), S(2))
+    >>> p3 = Particle('p3', Point('p3_pt'), S(3))
+    >>> p4 = Particle('p4', Point('p4_pt'), m)
+    >>> b_f = ReferenceFrame('b_f')
+    >>> b_cm = Point('b_cm')
+    >>> mb = symbols('mb')
+    >>> b = RigidBody('b', b_cm, b_f, mb, (outer(b_f.x, b_f.x), b_cm))
+    >>> p2.point.set_pos(p1.point, a.x)
+    >>> p3.point.set_pos(p1.point, a.x + a.y)
+    >>> p4.point.set_pos(p1.point, a.y)
+    >>> b.masscenter.set_pos(p1.point, a.y + a.z)
+    >>> point_o=Point('o')
+    >>> point_o.set_pos(p1.point, center_of_mass(p1.point, p1, p2, p3, p4, b))
+    >>> expr = 5/(m + mb + 6)*a.x + (m + mb + 3)/(m + mb + 6)*a.y + mb/(m + mb + 6)*a.z
+    >>> point_o.pos_from(p1.point)
+    5/(m + mb + 6)*a.x + (m + mb + 3)/(m + mb + 6)*a.y + mb/(m + mb + 6)*a.z
+
+    """
+    if not bodies:
+        raise TypeError("No bodies(instances of Particle or Rigidbody) were passed.")
+
+    total_mass = 0
+    vec = Vector(0)
+    for i in bodies:
+        total_mass += i.mass
+
+        masscenter = getattr(i, 'masscenter', None)
+        if masscenter is None:
+            masscenter = i.point
+        vec += i.mass*masscenter.pos_from(point)
+
+    return vec/total_mass
+
+
+def Lagrangian(frame, *body):
+    """Lagrangian of a multibody system.
+
+    Explanation
+    ===========
+
+    This function returns the Lagrangian of a system of Particle's and/or
+    RigidBody's. The Lagrangian of such a system is equal to the difference
+    between the kinetic energies and potential energies of its constituents. If
+    T and V are the kinetic and potential energies of a system then it's
+    Lagrangian, L, is defined as
+
+    L = T - V
+
+    The Lagrangian is a scalar.
+
+    Parameters
+    ==========
+
+    frame : ReferenceFrame
+        The frame in which the velocity or angular velocity of the body is
+        defined to determine the kinetic energy.
+
+    body1, body2, body3... : Particle and/or RigidBody
+        The body (or bodies) whose Lagrangian is required.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.mechanics import Point, Particle, ReferenceFrame
+    >>> from sympy.physics.mechanics import RigidBody, outer, Lagrangian
+    >>> from sympy import symbols
+    >>> M, m, g, h = symbols('M m g h')
+    >>> N = ReferenceFrame('N')
+    >>> O = Point('O')
+    >>> O.set_vel(N, 0 * N.x)
+    >>> P = O.locatenew('P', 1 * N.x)
+    >>> P.set_vel(N, 10 * N.x)
+    >>> Pa = Particle('Pa', P, 1)
+    >>> Ac = O.locatenew('Ac', 2 * N.y)
+    >>> Ac.set_vel(N, 5 * N.y)
+    >>> a = ReferenceFrame('a')
+    >>> a.set_ang_vel(N, 10 * N.z)
+    >>> I = outer(N.z, N.z)
+    >>> A = RigidBody('A', Ac, a, 20, (I, Ac))
+    >>> Pa.potential_energy = m * g * h
+    >>> A.potential_energy = M * g * h
+    >>> Lagrangian(N, Pa, A)
+    -M*g*h - g*h*m + 350
+
+    """
+
+    if not isinstance(frame, ReferenceFrame):
+        raise TypeError('Please supply a valid ReferenceFrame')
+    for e in body:
+        if not isinstance(e, (RigidBody, Particle)):
+            raise TypeError('*body must have only Particle or RigidBody')
+    return kinetic_energy(frame, *body) - potential_energy(*body)
+
+
+def find_dynamicsymbols(expression, exclude=None, reference_frame=None):
+    """Find all dynamicsymbols in expression.
+
+    Explanation
+    ===========
+
+    If the optional ``exclude`` kwarg is used, only dynamicsymbols
+    not in the iterable ``exclude`` are returned.
+    If we intend to apply this function on a vector, the optional
+    ``reference_frame`` is also used to inform about the corresponding frame
+    with respect to which the dynamic symbols of the given vector is to be
+    determined.
+
+    Parameters
+    ==========
+
+    expression : SymPy expression
+
+    exclude : iterable of dynamicsymbols, optional
+
+    reference_frame : ReferenceFrame, optional
+        The frame with respect to which the dynamic symbols of the
+        given vector is to be determined.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.mechanics import dynamicsymbols, find_dynamicsymbols
+    >>> from sympy.physics.mechanics import ReferenceFrame
+    >>> x, y = dynamicsymbols('x, y')
+    >>> expr = x + x.diff()*y
+    >>> find_dynamicsymbols(expr)
+    {x(t), y(t), Derivative(x(t), t)}
+    >>> find_dynamicsymbols(expr, exclude=[x, y])
+    {Derivative(x(t), t)}
+    >>> a, b, c = dynamicsymbols('a, b, c')
+    >>> A = ReferenceFrame('A')
+    >>> v = a * A.x + b * A.y + c * A.z
+    >>> find_dynamicsymbols(v, reference_frame=A)
+    {a(t), b(t), c(t)}
+
+    """
+    t_set = {dynamicsymbols._t}
+    if exclude:
+        if iterable(exclude):
+            exclude_set = set(exclude)
+        else:
+            raise TypeError("exclude kwarg must be iterable")
+    else:
+        exclude_set = set()
+    if isinstance(expression, Vector):
+        if reference_frame is None:
+            raise ValueError("You must provide reference_frame when passing a "
+                             "vector expression, got %s." % reference_frame)
+        else:
+            expression = expression.to_matrix(reference_frame)
+    return {i for i in expression.atoms(AppliedUndef, Derivative) if
+            i.free_symbols == t_set} - exclude_set
+
+
+def msubs(expr, *sub_dicts, smart=False, **kwargs):
+    """A custom subs for use on expressions derived in physics.mechanics.
+
+    Traverses the expression tree once, performing the subs found in sub_dicts.
+    Terms inside ``Derivative`` expressions are ignored:
+
+    Examples
+    ========
+
+    >>> from sympy.physics.mechanics import dynamicsymbols, msubs
+    >>> x = dynamicsymbols('x')
+    >>> msubs(x.diff() + x, {x: 1})
+    Derivative(x(t), t) + 1
+
+    Note that sub_dicts can be a single dictionary, or several dictionaries:
+
+    >>> x, y, z = dynamicsymbols('x, y, z')
+    >>> sub1 = {x: 1, y: 2}
+    >>> sub2 = {z: 3, x.diff(): 4}
+    >>> msubs(x.diff() + x + y + z, sub1, sub2)
+    10
+
+    If smart=True (default False), also checks for conditions that may result
+    in ``nan``, but if simplified would yield a valid expression. For example:
+
+    >>> from sympy import sin, tan
+    >>> (sin(x)/tan(x)).subs(x, 0)
+    nan
+    >>> msubs(sin(x)/tan(x), {x: 0}, smart=True)
+    1
+
+    It does this by first replacing all ``tan`` with ``sin/cos``. Then each
+    node is traversed. If the node is a fraction, subs is first evaluated on
+    the denominator. If this results in 0, simplification of the entire
+    fraction is attempted. Using this selective simplification, only
+    subexpressions that result in 1/0 are targeted, resulting in faster
+    performance.
+
+    """
+
+    sub_dict = dict_merge(*sub_dicts)
+    if smart:
+        func = _smart_subs
+    elif hasattr(expr, 'msubs'):
+        return expr.msubs(sub_dict)
+    else:
+        func = lambda expr, sub_dict: _crawl(expr, _sub_func, sub_dict)
+    if isinstance(expr, (Matrix, Vector, Dyadic)):
+        return expr.applyfunc(lambda x: func(x, sub_dict))
+    else:
+        return func(expr, sub_dict)
+
+
+def _crawl(expr, func, *args, **kwargs):
+    """Crawl the expression tree, and apply func to every node."""
+    val = func(expr, *args, **kwargs)
+    if val is not None:
+        return val
+    new_args = (_crawl(arg, func, *args, **kwargs) for arg in expr.args)
+    return expr.func(*new_args)
+
+
+def _sub_func(expr, sub_dict):
+    """Perform direct matching substitution, ignoring derivatives."""
+    if expr in sub_dict:
+        return sub_dict[expr]
+    elif not expr.args or expr.is_Derivative:
+        return expr
+
+
+def _tan_repl_func(expr):
+    """Replace tan with sin/cos."""
+    if isinstance(expr, tan):
+        return sin(*expr.args) / cos(*expr.args)
+    elif not expr.args or expr.is_Derivative:
+        return expr
+
+
+def _smart_subs(expr, sub_dict):
+    """Performs subs, checking for conditions that may result in `nan` or
+    `oo`, and attempts to simplify them out.
+
+    The expression tree is traversed twice, and the following steps are
+    performed on each expression node:
+    - First traverse:
+        Replace all `tan` with `sin/cos`.
+    - Second traverse:
+        If node is a fraction, check if the denominator evaluates to 0.
+        If so, attempt to simplify it out. Then if node is in sub_dict,
+        sub in the corresponding value.
+
+    """
+    expr = _crawl(expr, _tan_repl_func)
+
+    def _recurser(expr, sub_dict):
+        # Decompose the expression into num, den
+        num, den = _fraction_decomp(expr)
+        if den != 1:
+            # If there is a non trivial denominator, we need to handle it
+            denom_subbed = _recurser(den, sub_dict)
+            if denom_subbed.evalf() == 0:
+                # If denom is 0 after this, attempt to simplify the bad expr
+                expr = simplify(expr)
+            else:
+                # Expression won't result in nan, find numerator
+                num_subbed = _recurser(num, sub_dict)
+                return num_subbed / denom_subbed
+        # We have to crawl the tree manually, because `expr` may have been
+        # modified in the simplify step. First, perform subs as normal:
+        val = _sub_func(expr, sub_dict)
+        if val is not None:
+            return val
+        new_args = (_recurser(arg, sub_dict) for arg in expr.args)
+        return expr.func(*new_args)
+    return _recurser(expr, sub_dict)
+
+
+def _fraction_decomp(expr):
+    """Return num, den such that expr = num/den."""
+    if not isinstance(expr, Mul):
+        return expr, 1
+    num = []
+    den = []
+    for a in expr.args:
+        if a.is_Pow and a.args[1] < 0:
+            den.append(1 / a)
+        else:
+            num.append(a)
+    if not den:
+        return expr, 1
+    num = Mul(*num)
+    den = Mul(*den)
+    return num, den
+
+
+def _f_list_parser(fl, ref_frame):
+    """Parses the provided forcelist composed of items
+    of the form (obj, force).
+    Returns a tuple containing:
+        vel_list: The velocity (ang_vel for Frames, vel for Points) in
+                the provided reference frame.
+        f_list: The forces.
+
+    Used internally in the KanesMethod and LagrangesMethod classes.
+
+    """
+    def flist_iter():
+        for pair in fl:
+            obj, force = pair
+            if isinstance(obj, ReferenceFrame):
+                yield obj.ang_vel_in(ref_frame), force
+            elif isinstance(obj, Point):
+                yield obj.vel(ref_frame), force
+            else:
+                raise TypeError('First entry in each forcelist pair must '
+                                'be a point or frame.')
+
+    if not fl:
+        vel_list, f_list = (), ()
+    else:
+        unzip = lambda l: list(zip(*l)) if l[0] else [(), ()]
+        vel_list, f_list = unzip(list(flist_iter()))
+    return vel_list, f_list
+
+
+def _validate_coordinates(coordinates=None, speeds=None, check_duplicates=True,
+                          is_dynamicsymbols=True, u_auxiliary=None):
+    """Validate the generalized coordinates and generalized speeds.
+
+    Parameters
+    ==========
+    coordinates : iterable, optional
+        Generalized coordinates to be validated.
+    speeds : iterable, optional
+        Generalized speeds to be validated.
+    check_duplicates : bool, optional
+        Checks if there are duplicates in the generalized coordinates and
+        generalized speeds. If so it will raise a ValueError. The default is
+        True.
+    is_dynamicsymbols : iterable, optional
+        Checks if all the generalized coordinates and generalized speeds are
+        dynamicsymbols. If any is not a dynamicsymbol, a ValueError will be
+        raised. The default is True.
+    u_auxiliary : iterable, optional
+        Auxiliary generalized speeds to be validated.
+
+    """
+    t_set = {dynamicsymbols._t}
+    # Convert input to iterables
+    if coordinates is None:
+        coordinates = []
+    elif not iterable(coordinates):
+        coordinates = [coordinates]
+    if speeds is None:
+        speeds = []
+    elif not iterable(speeds):
+        speeds = [speeds]
+    if u_auxiliary is None:
+        u_auxiliary = []
+    elif not iterable(u_auxiliary):
+        u_auxiliary = [u_auxiliary]
+
+    msgs = []
+    if check_duplicates:  # Check for duplicates
+        seen = set()
+        coord_duplicates = {x for x in coordinates if x in seen or seen.add(x)}
+        seen = set()
+        speed_duplicates = {x for x in speeds if x in seen or seen.add(x)}
+        seen = set()
+        aux_duplicates = {x for x in u_auxiliary if x in seen or seen.add(x)}
+        overlap_coords = set(coordinates).intersection(speeds)
+        overlap_aux = set(coordinates).union(speeds).intersection(u_auxiliary)
+        if coord_duplicates:
+            msgs.append(f'The generalized coordinates {coord_duplicates} are '
+                        f'duplicated, all generalized coordinates should be '
+                        f'unique.')
+        if speed_duplicates:
+            msgs.append(f'The generalized speeds {speed_duplicates} are '
+                        f'duplicated, all generalized speeds should be unique.')
+        if aux_duplicates:
+            msgs.append(f'The auxiliary speeds {aux_duplicates} are duplicated,'
+                        f' all auxiliary speeds should be unique.')
+        if overlap_coords:
+            msgs.append(f'{overlap_coords} are defined as both generalized '
+                        f'coordinates and generalized speeds.')
+        if overlap_aux:
+            msgs.append(f'The auxiliary speeds {overlap_aux} are also defined '
+                        f'as generalized coordinates or generalized speeds.')
+    if is_dynamicsymbols:  # Check whether all coordinates are dynamicsymbols
+        for coordinate in coordinates:
+            if not (isinstance(coordinate, (AppliedUndef, Derivative)) and
+                    coordinate.free_symbols == t_set):
+                msgs.append(f'Generalized coordinate "{coordinate}" is not a '
+                            f'dynamicsymbol.')
+        for speed in speeds:
+            if not (isinstance(speed, (AppliedUndef, Derivative)) and
+                    speed.free_symbols == t_set):
+                msgs.append(
+                    f'Generalized speed "{speed}" is not a dynamicsymbol.')
+        for aux in u_auxiliary:
+            if not (isinstance(aux, (AppliedUndef, Derivative)) and
+                    aux.free_symbols == t_set):
+                msgs.append(
+                    f'Auxiliary speed "{aux}" is not a dynamicsymbol.')
+    if msgs:
+        raise ValueError('\n'.join(msgs))
+
+
+def _parse_linear_solver(linear_solver):
+    """Helper function to retrieve a specified linear solver."""
+    if callable(linear_solver):
+        return linear_solver
+    return lambda A, b: Matrix.solve(A, b, method=linear_solver)

mplug_owl2/lib/python3.10/site-packages/sympy/physics/mechanics/joint.py

@@ -0,0 +1,2188 @@
+# coding=utf-8
+
+from abc import ABC, abstractmethod
+
+from sympy import pi, Derivative, Matrix
+from sympy.core.function import AppliedUndef
+from sympy.physics.mechanics.body_base import BodyBase
+from sympy.physics.mechanics.functions import _validate_coordinates
+from sympy.physics.vector import (Vector, dynamicsymbols, cross, Point,
+                                  ReferenceFrame)
+from sympy.utilities.iterables import iterable
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+__all__ = ['Joint', 'PinJoint', 'PrismaticJoint', 'CylindricalJoint',
+           'PlanarJoint', 'SphericalJoint', 'WeldJoint']
+
+
+class Joint(ABC):
+    """Abstract base class for all specific joints.
+
+    Explanation
+    ===========
+
+    A joint subtracts degrees of freedom from a body. This is the base class
+    for all specific joints and holds all common methods acting as an interface
+    for all joints. Custom joint can be created by inheriting Joint class and
+    defining all abstract functions.
+
+    The abstract methods are:
+
+    - ``_generate_coordinates``
+    - ``_generate_speeds``
+    - ``_orient_frames``
+    - ``_set_angular_velocity``
+    - ``_set_linear_velocity``
+
+    Parameters
+    ==========
+
+    name : string
+        A unique name for the joint.
+    parent : Particle or RigidBody or Body
+        The parent body of joint.
+    child : Particle or RigidBody or Body
+        The child body of joint.
+    coordinates : iterable of dynamicsymbols, optional
+        Generalized coordinates of the joint.
+    speeds : iterable of dynamicsymbols, optional
+        Generalized speeds of joint.
+    parent_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the parent body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the parent's mass
+        center.
+    child_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the child body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the child's mass
+        center.
+    parent_axis : Vector, optional
+        .. deprecated:: 1.12
+            Axis fixed in the parent body which aligns with an axis fixed in the
+            child body. The default is the x axis of parent's reference frame.
+            For more information on this deprecation, see
+            :ref:`deprecated-mechanics-joint-axis`.
+    child_axis : Vector, optional
+        .. deprecated:: 1.12
+            Axis fixed in the child body which aligns with an axis fixed in the
+            parent body. The default is the x axis of child's reference frame.
+            For more information on this deprecation, see
+            :ref:`deprecated-mechanics-joint-axis`.
+    parent_interframe : ReferenceFrame, optional
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the parent's own frame.
+    child_interframe : ReferenceFrame, optional
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the child's own frame.
+    parent_joint_pos : Point or Vector, optional
+        .. deprecated:: 1.12
+            This argument is replaced by parent_point and will be removed in a
+            future version.
+            See :ref:`deprecated-mechanics-joint-pos` for more information.
+    child_joint_pos : Point or Vector, optional
+        .. deprecated:: 1.12
+            This argument is replaced by child_point and will be removed in a
+            future version.
+            See :ref:`deprecated-mechanics-joint-pos` for more information.
+
+    Attributes
+    ==========
+
+    name : string
+        The joint's name.
+    parent : Particle or RigidBody or Body
+        The joint's parent body.
+    child : Particle or RigidBody or Body
+        The joint's child body.
+    coordinates : Matrix
+        Matrix of the joint's generalized coordinates.
+    speeds : Matrix
+        Matrix of the joint's generalized speeds.
+    parent_point : Point
+        Attachment point where the joint is fixed to the parent body.
+    child_point : Point
+        Attachment point where the joint is fixed to the child body.
+    parent_axis : Vector
+        The axis fixed in the parent frame that represents the joint.
+    child_axis : Vector
+        The axis fixed in the child frame that represents the joint.
+    parent_interframe : ReferenceFrame
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated.
+    child_interframe : ReferenceFrame
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated.
+    kdes : Matrix
+        Kinematical differential equations of the joint.
+
+    Notes
+    =====
+
+    When providing a vector as the intermediate frame, a new intermediate frame
+    is created which aligns its X axis with the provided vector. This is done
+    with a single fixed rotation about a rotation axis. This rotation axis is
+    determined by taking the cross product of the ``body.x`` axis with the
+    provided vector. In the case where the provided vector is in the ``-body.x``
+    direction, the rotation is done about the ``body.y`` axis.
+
+    """
+
+    def __init__(self, name, parent, child, coordinates=None, speeds=None,
+                 parent_point=None, child_point=None, parent_interframe=None,
+                 child_interframe=None, parent_axis=None, child_axis=None,
+                 parent_joint_pos=None, child_joint_pos=None):
+
+        if not isinstance(name, str):
+            raise TypeError('Supply a valid name.')
+        self._name = name
+
+        if not isinstance(parent, BodyBase):
+            raise TypeError('Parent must be a body.')
+        self._parent = parent
+
+        if not isinstance(child, BodyBase):
+            raise TypeError('Child must be a body.')
+        self._child = child
+
+        if parent_axis is not None or child_axis is not None:
+            sympy_deprecation_warning(
+                """
+                The parent_axis and child_axis arguments for the Joint classes
+                are deprecated. Instead use parent_interframe, child_interframe.
+                """,
+                deprecated_since_version="1.12",
+                active_deprecations_target="deprecated-mechanics-joint-axis",
+                stacklevel=4
+            )
+            if parent_interframe is None:
+                parent_interframe = parent_axis
+            if child_interframe is None:
+                child_interframe = child_axis
+
+        # Set parent and child frame attributes
+        if hasattr(self._parent, 'frame'):
+            self._parent_frame = self._parent.frame
+        else:
+            if isinstance(parent_interframe, ReferenceFrame):
+                self._parent_frame = parent_interframe
+            else:
+                self._parent_frame = ReferenceFrame(
+                    f'{self.name}_{self._parent.name}_frame')
+        if hasattr(self._child, 'frame'):
+            self._child_frame = self._child.frame
+        else:
+            if isinstance(child_interframe, ReferenceFrame):
+                self._child_frame = child_interframe
+            else:
+                self._child_frame = ReferenceFrame(
+                    f'{self.name}_{self._child.name}_frame')
+
+        self._parent_interframe = self._locate_joint_frame(
+            self._parent, parent_interframe, self._parent_frame)
+        self._child_interframe = self._locate_joint_frame(
+            self._child, child_interframe, self._child_frame)
+        self._parent_axis = self._axis(parent_axis, self._parent_frame)
+        self._child_axis = self._axis(child_axis, self._child_frame)
+
+        if parent_joint_pos is not None or child_joint_pos is not None:
+            sympy_deprecation_warning(
+                """
+                The parent_joint_pos and child_joint_pos arguments for the Joint
+                classes are deprecated. Instead use parent_point and child_point.
+                """,
+                deprecated_since_version="1.12",
+                active_deprecations_target="deprecated-mechanics-joint-pos",
+                stacklevel=4
+            )
+            if parent_point is None:
+                parent_point = parent_joint_pos
+            if child_point is None:
+                child_point = child_joint_pos
+        self._parent_point = self._locate_joint_pos(
+            self._parent, parent_point, self._parent_frame)
+        self._child_point = self._locate_joint_pos(
+            self._child, child_point, self._child_frame)
+
+        self._coordinates = self._generate_coordinates(coordinates)
+        self._speeds = self._generate_speeds(speeds)
+        _validate_coordinates(self.coordinates, self.speeds)
+        self._kdes = self._generate_kdes()
+
+        self._orient_frames()
+        self._set_angular_velocity()
+        self._set_linear_velocity()
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return self.__str__()
+
+    @property
+    def name(self):
+        """Name of the joint."""
+        return self._name
+
+    @property
+    def parent(self):
+        """Parent body of Joint."""
+        return self._parent
+
+    @property
+    def child(self):
+        """Child body of Joint."""
+        return self._child
+
+    @property
+    def coordinates(self):
+        """Matrix of the joint's generalized coordinates."""
+        return self._coordinates
+
+    @property
+    def speeds(self):
+        """Matrix of the joint's generalized speeds."""
+        return self._speeds
+
+    @property
+    def kdes(self):
+        """Kinematical differential equations of the joint."""
+        return self._kdes
+
+    @property
+    def parent_axis(self):
+        """The axis of parent frame."""
+        # Will be removed with `deprecated-mechanics-joint-axis`
+        return self._parent_axis
+
+    @property
+    def child_axis(self):
+        """The axis of child frame."""
+        # Will be removed with `deprecated-mechanics-joint-axis`
+        return self._child_axis
+
+    @property
+    def parent_point(self):
+        """Attachment point where the joint is fixed to the parent body."""
+        return self._parent_point
+
+    @property
+    def child_point(self):
+        """Attachment point where the joint is fixed to the child body."""
+        return self._child_point
+
+    @property
+    def parent_interframe(self):
+        return self._parent_interframe
+
+    @property
+    def child_interframe(self):
+        return self._child_interframe
+
+    @abstractmethod
+    def _generate_coordinates(self, coordinates):
+        """Generate Matrix of the joint's generalized coordinates."""
+        pass
+
+    @abstractmethod
+    def _generate_speeds(self, speeds):
+        """Generate Matrix of the joint's generalized speeds."""
+        pass
+
+    @abstractmethod
+    def _orient_frames(self):
+        """Orient frames as per the joint."""
+        pass
+
+    @abstractmethod
+    def _set_angular_velocity(self):
+        """Set angular velocity of the joint related frames."""
+        pass
+
+    @abstractmethod
+    def _set_linear_velocity(self):
+        """Set velocity of related points to the joint."""
+        pass
+
+    @staticmethod
+    def _to_vector(matrix, frame):
+        """Converts a matrix to a vector in the given frame."""
+        return Vector([(matrix, frame)])
+
+    @staticmethod
+    def _axis(ax, *frames):
+        """Check whether an axis is fixed in one of the frames."""
+        if ax is None:
+            ax = frames[0].x
+            return ax
+        if not isinstance(ax, Vector):
+            raise TypeError("Axis must be a Vector.")
+        ref_frame = None  # Find a body in which the axis can be expressed
+        for frame in frames:
+            try:
+                ax.to_matrix(frame)
+            except ValueError:
+                pass
+            else:
+                ref_frame = frame
+                break
+        if ref_frame is None:
+            raise ValueError("Axis cannot be expressed in one of the body's "
+                             "frames.")
+        if not ax.dt(ref_frame) == 0:
+            raise ValueError('Axis cannot be time-varying when viewed from the '
+                             'associated body.')
+        return ax
+
+    @staticmethod
+    def _choose_rotation_axis(frame, axis):
+        components = axis.to_matrix(frame)
+        x, y, z = components[0], components[1], components[2]
+
+        if x != 0:
+            if y != 0:
+                if z != 0:
+                    return cross(axis, frame.x)
+            if z != 0:
+                return frame.y
+            return frame.z
+        else:
+            if y != 0:
+                return frame.x
+            return frame.y
+
+    @staticmethod
+    def _create_aligned_interframe(frame, align_axis, frame_axis=None,
+                                   frame_name=None):
+        """
+        Returns an intermediate frame, where the ``frame_axis`` defined in
+        ``frame`` is aligned with ``axis``. By default this means that the X
+        axis will be aligned with ``axis``.
+
+        Parameters
+        ==========
+
+        frame : BodyBase or ReferenceFrame
+            The body or reference frame with respect to which the intermediate
+            frame is oriented.
+        align_axis : Vector
+            The vector with respect to which the intermediate frame will be
+            aligned.
+        frame_axis : Vector
+            The vector of the frame which should get aligned with ``axis``. The
+            default is the X axis of the frame.
+        frame_name : string
+            Name of the to be created intermediate frame. The default adds
+            "_int_frame" to the name of ``frame``.
+
+        Example
+        =======
+
+        An intermediate frame, where the X axis of the parent becomes aligned
+        with ``parent.y + parent.z`` can be created as follows:
+
+        >>> from sympy.physics.mechanics.joint import Joint
+        >>> from sympy.physics.mechanics import RigidBody
+        >>> parent = RigidBody('parent')
+        >>> parent_interframe = Joint._create_aligned_interframe(
+        ...     parent, parent.y + parent.z)
+        >>> parent_interframe
+        parent_int_frame
+        >>> parent.frame.dcm(parent_interframe)
+        Matrix([
+        [        0, -sqrt(2)/2, -sqrt(2)/2],
+        [sqrt(2)/2,        1/2,       -1/2],
+        [sqrt(2)/2,       -1/2,        1/2]])
+        >>> (parent.y + parent.z).express(parent_interframe)
+        sqrt(2)*parent_int_frame.x
+
+        Notes
+        =====
+
+        The direction cosine matrix between the given frame and intermediate
+        frame is formed using a simple rotation about an axis that is normal to
+        both ``align_axis`` and ``frame_axis``. In general, the normal axis is
+        formed by crossing the ``frame_axis`` with the ``align_axis``. The
+        exception is if the axes are parallel with opposite directions, in which
+        case the rotation vector is chosen using the rules in the following
+        table with the vectors expressed in the given frame:
+
+        .. list-table::
+           :header-rows: 1
+
+           * - ``align_axis``
+             - ``frame_axis``
+             - ``rotation_axis``
+           * - ``-x``
+             - ``x``
+             - ``z``
+           * - ``-y``
+             - ``y``
+             - ``x``
+           * - ``-z``
+             - ``z``
+             - ``y``
+           * - ``-x-y``
+             - ``x+y``
+             - ``z``
+           * - ``-y-z``
+             - ``y+z``
+             - ``x``
+           * - ``-x-z``
+             - ``x+z``
+             - ``y``
+           * - ``-x-y-z``
+             - ``x+y+z``
+             - ``(x+y+z) × x``
+
+        """
+        if isinstance(frame, BodyBase):
+            frame = frame.frame
+        if frame_axis is None:
+            frame_axis = frame.x
+        if frame_name is None:
+            if frame.name[-6:] == '_frame':
+                frame_name = f'{frame.name[:-6]}_int_frame'
+            else:
+                frame_name = f'{frame.name}_int_frame'
+        angle = frame_axis.angle_between(align_axis)
+        rotation_axis = cross(frame_axis, align_axis)
+        if rotation_axis == Vector(0) and angle == 0:
+            return frame
+        if angle == pi:
+            rotation_axis = Joint._choose_rotation_axis(frame, align_axis)
+
+        int_frame = ReferenceFrame(frame_name)
+        int_frame.orient_axis(frame, rotation_axis, angle)
+        int_frame.set_ang_vel(frame, 0 * rotation_axis)
+        return int_frame
+
+    def _generate_kdes(self):
+        """Generate kinematical differential equations."""
+        kdes = []
+        t = dynamicsymbols._t
+        for i in range(len(self.coordinates)):
+            kdes.append(-self.coordinates[i].diff(t) + self.speeds[i])
+        return Matrix(kdes)
+
+    def _locate_joint_pos(self, body, joint_pos, body_frame=None):
+        """Returns the attachment point of a body."""
+        if body_frame is None:
+            body_frame = body.frame
+        if joint_pos is None:
+            return body.masscenter
+        if not isinstance(joint_pos, (Point, Vector)):
+            raise TypeError('Attachment point must be a Point or Vector.')
+        if isinstance(joint_pos, Vector):
+            point_name = f'{self.name}_{body.name}_joint'
+            joint_pos = body.masscenter.locatenew(point_name, joint_pos)
+        if not joint_pos.pos_from(body.masscenter).dt(body_frame) == 0:
+            raise ValueError('Attachment point must be fixed to the associated '
+                             'body.')
+        return joint_pos
+
+    def _locate_joint_frame(self, body, interframe, body_frame=None):
+        """Returns the attachment frame of a body."""
+        if body_frame is None:
+            body_frame = body.frame
+        if interframe is None:
+            return body_frame
+        if isinstance(interframe, Vector):
+            interframe = Joint._create_aligned_interframe(
+                body_frame, interframe,
+                frame_name=f'{self.name}_{body.name}_int_frame')
+        elif not isinstance(interframe, ReferenceFrame):
+            raise TypeError('Interframe must be a ReferenceFrame.')
+        if not interframe.ang_vel_in(body_frame) == 0:
+            raise ValueError(f'Interframe {interframe} is not fixed to body '
+                             f'{body}.')
+        body.masscenter.set_vel(interframe, 0)  # Fixate interframe to body
+        return interframe
+
+    def _fill_coordinate_list(self, coordinates, n_coords, label='q', offset=0,
+                              number_single=False):
+        """Helper method for _generate_coordinates and _generate_speeds.
+
+        Parameters
+        ==========
+
+        coordinates : iterable
+            Iterable of coordinates or speeds that have been provided.
+        n_coords : Integer
+            Number of coordinates that should be returned.
+        label : String, optional
+            Coordinate type either 'q' (coordinates) or 'u' (speeds). The
+            Default is 'q'.
+        offset : Integer
+            Count offset when creating new dynamicsymbols. The default is 0.
+        number_single : Boolean
+            Boolean whether if n_coords == 1, number should still be used. The
+            default is False.
+
+        """
+
+        def create_symbol(number):
+            if n_coords == 1 and not number_single:
+                return dynamicsymbols(f'{label}_{self.name}')
+            return dynamicsymbols(f'{label}{number}_{self.name}')
+
+        name = 'generalized coordinate' if label == 'q' else 'generalized speed'
+        generated_coordinates = []
+        if coordinates is None:
+            coordinates = []
+        elif not iterable(coordinates):
+            coordinates = [coordinates]
+        if not (len(coordinates) == 0 or len(coordinates) == n_coords):
+            raise ValueError(f'Expected {n_coords} {name}s, instead got '
+                             f'{len(coordinates)} {name}s.')
+        # Supports more iterables, also Matrix
+        for i, coord in enumerate(coordinates):
+            if coord is None:
+                generated_coordinates.append(create_symbol(i + offset))
+            elif isinstance(coord, (AppliedUndef, Derivative)):
+                generated_coordinates.append(coord)
+            else:
+                raise TypeError(f'The {name} {coord} should have been a '
+                                f'dynamicsymbol.')
+        for i in range(len(coordinates) + offset, n_coords + offset):
+            generated_coordinates.append(create_symbol(i))
+        return Matrix(generated_coordinates)
+
+
+class PinJoint(Joint):
+    """Pin (Revolute) Joint.
+
+    .. raw:: html
+        :file: ../../../doc/src/modules/physics/mechanics/api/PinJoint.svg
+
+    Explanation
+    ===========
+
+    A pin joint is defined such that the joint rotation axis is fixed in both
+    the child and parent and the location of the joint is relative to the mass
+    center of each body. The child rotates an angle, θ, from the parent about
+    the rotation axis and has a simple angular speed, ω, relative to the
+    parent. The direction cosine matrix between the child interframe and
+    parent interframe is formed using a simple rotation about the joint axis.
+    The page on the joints framework gives a more detailed explanation of the
+    intermediate frames.
+
+    Parameters
+    ==========
+
+    name : string
+        A unique name for the joint.
+    parent : Particle or RigidBody or Body
+        The parent body of joint.
+    child : Particle or RigidBody or Body
+        The child body of joint.
+    coordinates : dynamicsymbol, optional
+        Generalized coordinates of the joint.
+    speeds : dynamicsymbol, optional
+        Generalized speeds of joint.
+    parent_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the parent body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the parent's mass
+        center.
+    child_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the child body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the child's mass
+        center.
+    parent_axis : Vector, optional
+        .. deprecated:: 1.12
+            Axis fixed in the parent body which aligns with an axis fixed in the
+            child body. The default is the x axis of parent's reference frame.
+            For more information on this deprecation, see
+            :ref:`deprecated-mechanics-joint-axis`.
+    child_axis : Vector, optional
+        .. deprecated:: 1.12
+            Axis fixed in the child body which aligns with an axis fixed in the
+            parent body. The default is the x axis of child's reference frame.
+            For more information on this deprecation, see
+            :ref:`deprecated-mechanics-joint-axis`.
+    parent_interframe : ReferenceFrame, optional
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the parent's own frame.
+    child_interframe : ReferenceFrame, optional
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the child's own frame.
+    joint_axis : Vector
+        The axis about which the rotation occurs. Note that the components
+        of this axis are the same in the parent_interframe and child_interframe.
+    parent_joint_pos : Point or Vector, optional
+        .. deprecated:: 1.12
+            This argument is replaced by parent_point and will be removed in a
+            future version.
+            See :ref:`deprecated-mechanics-joint-pos` for more information.
+    child_joint_pos : Point or Vector, optional
+        .. deprecated:: 1.12
+            This argument is replaced by child_point and will be removed in a
+            future version.
+            See :ref:`deprecated-mechanics-joint-pos` for more information.
+
+    Attributes
+    ==========
+
+    name : string
+        The joint's name.
+    parent : Particle or RigidBody or Body
+        The joint's parent body.
+    child : Particle or RigidBody or Body
+        The joint's child body.
+    coordinates : Matrix
+        Matrix of the joint's generalized coordinates. The default value is
+        ``dynamicsymbols(f'q_{joint.name}')``.
+    speeds : Matrix
+        Matrix of the joint's generalized speeds. The default value is
+        ``dynamicsymbols(f'u_{joint.name}')``.
+    parent_point : Point
+        Attachment point where the joint is fixed to the parent body.
+    child_point : Point
+        Attachment point where the joint is fixed to the child body.
+    parent_axis : Vector
+        The axis fixed in the parent frame that represents the joint.
+    child_axis : Vector
+        The axis fixed in the child frame that represents the joint.
+    parent_interframe : ReferenceFrame
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated.
+    child_interframe : ReferenceFrame
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated.
+    joint_axis : Vector
+        The axis about which the rotation occurs. Note that the components of
+        this axis are the same in the parent_interframe and child_interframe.
+    kdes : Matrix
+        Kinematical differential equations of the joint.
+
+    Examples
+    =========
+
+    A single pin joint is created from two bodies and has the following basic
+    attributes:
+
+    >>> from sympy.physics.mechanics import RigidBody, PinJoint
+    >>> parent = RigidBody('P')
+    >>> parent
+    P
+    >>> child = RigidBody('C')
+    >>> child
+    C
+    >>> joint = PinJoint('PC', parent, child)
+    >>> joint
+    PinJoint: PC  parent: P  child: C
+    >>> joint.name
+    'PC'
+    >>> joint.parent
+    P
+    >>> joint.child
+    C
+    >>> joint.parent_point
+    P_masscenter
+    >>> joint.child_point
+    C_masscenter
+    >>> joint.parent_axis
+    P_frame.x
+    >>> joint.child_axis
+    C_frame.x
+    >>> joint.coordinates
+    Matrix([[q_PC(t)]])
+    >>> joint.speeds
+    Matrix([[u_PC(t)]])
+    >>> child.frame.ang_vel_in(parent.frame)
+    u_PC(t)*P_frame.x
+    >>> child.frame.dcm(parent.frame)
+    Matrix([
+    [1,             0,            0],
+    [0,  cos(q_PC(t)), sin(q_PC(t))],
+    [0, -sin(q_PC(t)), cos(q_PC(t))]])
+    >>> joint.child_point.pos_from(joint.parent_point)
+    0
+
+    To further demonstrate the use of the pin joint, the kinematics of simple
+    double pendulum that rotates about the Z axis of each connected body can be
+    created as follows.
+
+    >>> from sympy import symbols, trigsimp
+    >>> from sympy.physics.mechanics import RigidBody, PinJoint
+    >>> l1, l2 = symbols('l1 l2')
+
+    First create bodies to represent the fixed ceiling and one to represent
+    each pendulum bob.
+
+    >>> ceiling = RigidBody('C')
+    >>> upper_bob = RigidBody('U')
+    >>> lower_bob = RigidBody('L')
+
+    The first joint will connect the upper bob to the ceiling by a distance of
+    ``l1`` and the joint axis will be about the Z axis for each body.
+
+    >>> ceiling_joint = PinJoint('P1', ceiling, upper_bob,
+    ... child_point=-l1*upper_bob.frame.x,
+    ... joint_axis=ceiling.frame.z)
+
+    The second joint will connect the lower bob to the upper bob by a distance
+    of ``l2`` and the joint axis will also be about the Z axis for each body.
+
+    >>> pendulum_joint = PinJoint('P2', upper_bob, lower_bob,
+    ... child_point=-l2*lower_bob.frame.x,
+    ... joint_axis=upper_bob.frame.z)
+
+    Once the joints are established the kinematics of the connected bodies can
+    be accessed. First the direction cosine matrices of pendulum link relative
+    to the ceiling are found:
+
+    >>> upper_bob.frame.dcm(ceiling.frame)
+    Matrix([
+    [ cos(q_P1(t)), sin(q_P1(t)), 0],
+    [-sin(q_P1(t)), cos(q_P1(t)), 0],
+    [            0,            0, 1]])
+    >>> trigsimp(lower_bob.frame.dcm(ceiling.frame))
+    Matrix([
+    [ cos(q_P1(t) + q_P2(t)), sin(q_P1(t) + q_P2(t)), 0],
+    [-sin(q_P1(t) + q_P2(t)), cos(q_P1(t) + q_P2(t)), 0],
+    [                      0,                      0, 1]])
+
+    The position of the lower bob's masscenter is found with:
+
+    >>> lower_bob.masscenter.pos_from(ceiling.masscenter)
+    l1*U_frame.x + l2*L_frame.x
+
+    The angular velocities of the two pendulum links can be computed with
+    respect to the ceiling.
+
+    >>> upper_bob.frame.ang_vel_in(ceiling.frame)
+    u_P1(t)*C_frame.z
+    >>> lower_bob.frame.ang_vel_in(ceiling.frame)
+    u_P1(t)*C_frame.z + u_P2(t)*U_frame.z
+
+    And finally, the linear velocities of the two pendulum bobs can be computed
+    with respect to the ceiling.
+
+    >>> upper_bob.masscenter.vel(ceiling.frame)
+    l1*u_P1(t)*U_frame.y
+    >>> lower_bob.masscenter.vel(ceiling.frame)
+    l1*u_P1(t)*U_frame.y + l2*(u_P1(t) + u_P2(t))*L_frame.y
+
+    """
+
+    def __init__(self, name, parent, child, coordinates=None, speeds=None,
+                 parent_point=None, child_point=None, parent_interframe=None,
+                 child_interframe=None, parent_axis=None, child_axis=None,
+                 joint_axis=None, parent_joint_pos=None, child_joint_pos=None):
+
+        self._joint_axis = joint_axis
+        super().__init__(name, parent, child, coordinates, speeds, parent_point,
+                         child_point, parent_interframe, child_interframe,
+                         parent_axis, child_axis, parent_joint_pos,
+                         child_joint_pos)
+
+    def __str__(self):
+        return (f'PinJoint: {self.name}  parent: {self.parent}  '
+                f'child: {self.child}')
+
+    @property
+    def joint_axis(self):
+        """Axis about which the child rotates with respect to the parent."""
+        return self._joint_axis
+
+    def _generate_coordinates(self, coordinate):
+        return self._fill_coordinate_list(coordinate, 1, 'q')
+
+    def _generate_speeds(self, speed):
+        return self._fill_coordinate_list(speed, 1, 'u')
+
+    def _orient_frames(self):
+        self._joint_axis = self._axis(self.joint_axis, self.parent_interframe)
+        self.child_interframe.orient_axis(
+            self.parent_interframe, self.joint_axis, self.coordinates[0])
+
+    def _set_angular_velocity(self):
+        self.child_interframe.set_ang_vel(self.parent_interframe, self.speeds[
+            0] * self.joint_axis.normalize())
+
+    def _set_linear_velocity(self):
+        self.child_point.set_pos(self.parent_point, 0)
+        self.parent_point.set_vel(self._parent_frame, 0)
+        self.child_point.set_vel(self._child_frame, 0)
+        self.child.masscenter.v2pt_theory(self.parent_point,
+                                          self._parent_frame, self._child_frame)
+
+
+class PrismaticJoint(Joint):
+    """Prismatic (Sliding) Joint.
+
+    .. image:: PrismaticJoint.svg
+
+    Explanation
+    ===========
+
+    It is defined such that the child body translates with respect to the parent
+    body along the body-fixed joint axis. The location of the joint is defined
+    by two points, one in each body, which coincide when the generalized
+    coordinate is zero. The direction cosine matrix between the
+    parent_interframe and child_interframe is the identity matrix. Therefore,
+    the direction cosine matrix between the parent and child frames is fully
+    defined by the definition of the intermediate frames. The page on the joints
+    framework gives a more detailed explanation of the intermediate frames.
+
+    Parameters
+    ==========
+
+    name : string
+        A unique name for the joint.
+    parent : Particle or RigidBody or Body
+        The parent body of joint.
+    child : Particle or RigidBody or Body
+        The child body of joint.
+    coordinates : dynamicsymbol, optional
+        Generalized coordinates of the joint. The default value is
+        ``dynamicsymbols(f'q_{joint.name}')``.
+    speeds : dynamicsymbol, optional
+        Generalized speeds of joint. The default value is
+        ``dynamicsymbols(f'u_{joint.name}')``.
+    parent_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the parent body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the parent's mass
+        center.
+    child_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the child body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the child's mass
+        center.
+    parent_axis : Vector, optional
+        .. deprecated:: 1.12
+            Axis fixed in the parent body which aligns with an axis fixed in the
+            child body. The default is the x axis of parent's reference frame.
+            For more information on this deprecation, see
+            :ref:`deprecated-mechanics-joint-axis`.
+    child_axis : Vector, optional
+        .. deprecated:: 1.12
+            Axis fixed in the child body which aligns with an axis fixed in the
+            parent body. The default is the x axis of child's reference frame.
+            For more information on this deprecation, see
+            :ref:`deprecated-mechanics-joint-axis`.
+    parent_interframe : ReferenceFrame, optional
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the parent's own frame.
+    child_interframe : ReferenceFrame, optional
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the child's own frame.
+    joint_axis : Vector
+        The axis along which the translation occurs. Note that the components
+        of this axis are the same in the parent_interframe and child_interframe.
+    parent_joint_pos : Point or Vector, optional
+        .. deprecated:: 1.12
+            This argument is replaced by parent_point and will be removed in a
+            future version.
+            See :ref:`deprecated-mechanics-joint-pos` for more information.
+    child_joint_pos : Point or Vector, optional
+        .. deprecated:: 1.12
+            This argument is replaced by child_point and will be removed in a
+            future version.
+            See :ref:`deprecated-mechanics-joint-pos` for more information.
+
+    Attributes
+    ==========
+
+    name : string
+        The joint's name.
+    parent : Particle or RigidBody or Body
+        The joint's parent body.
+    child : Particle or RigidBody or Body
+        The joint's child body.
+    coordinates : Matrix
+        Matrix of the joint's generalized coordinates.
+    speeds : Matrix
+        Matrix of the joint's generalized speeds.
+    parent_point : Point
+        Attachment point where the joint is fixed to the parent body.
+    child_point : Point
+        Attachment point where the joint is fixed to the child body.
+    parent_axis : Vector
+        The axis fixed in the parent frame that represents the joint.
+    child_axis : Vector
+        The axis fixed in the child frame that represents the joint.
+    parent_interframe : ReferenceFrame
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated.
+    child_interframe : ReferenceFrame
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated.
+    kdes : Matrix
+        Kinematical differential equations of the joint.
+
+    Examples
+    =========
+
+    A single prismatic joint is created from two bodies and has the following
+    basic attributes:
+
+    >>> from sympy.physics.mechanics import RigidBody, PrismaticJoint
+    >>> parent = RigidBody('P')
+    >>> parent
+    P
+    >>> child = RigidBody('C')
+    >>> child
+    C
+    >>> joint = PrismaticJoint('PC', parent, child)
+    >>> joint
+    PrismaticJoint: PC  parent: P  child: C
+    >>> joint.name
+    'PC'
+    >>> joint.parent
+    P
+    >>> joint.child
+    C
+    >>> joint.parent_point
+    P_masscenter
+    >>> joint.child_point
+    C_masscenter
+    >>> joint.parent_axis
+    P_frame.x
+    >>> joint.child_axis
+    C_frame.x
+    >>> joint.coordinates
+    Matrix([[q_PC(t)]])
+    >>> joint.speeds
+    Matrix([[u_PC(t)]])
+    >>> child.frame.ang_vel_in(parent.frame)
+    0
+    >>> child.frame.dcm(parent.frame)
+    Matrix([
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1]])
+    >>> joint.child_point.pos_from(joint.parent_point)
+    q_PC(t)*P_frame.x
+
+    To further demonstrate the use of the prismatic joint, the kinematics of two
+    masses sliding, one moving relative to a fixed body and the other relative
+    to the moving body. about the X axis of each connected body can be created
+    as follows.
+
+    >>> from sympy.physics.mechanics import PrismaticJoint, RigidBody
+
+    First create bodies to represent the fixed ceiling and one to represent
+    a particle.
+
+    >>> wall = RigidBody('W')
+    >>> Part1 = RigidBody('P1')
+    >>> Part2 = RigidBody('P2')
+
+    The first joint will connect the particle to the ceiling and the
+    joint axis will be about the X axis for each body.
+
+    >>> J1 = PrismaticJoint('J1', wall, Part1)
+
+    The second joint will connect the second particle to the first particle
+    and the joint axis will also be about the X axis for each body.
+
+    >>> J2 = PrismaticJoint('J2', Part1, Part2)
+
+    Once the joint is established the kinematics of the connected bodies can
+    be accessed. First the direction cosine matrices of Part relative
+    to the ceiling are found:
+
+    >>> Part1.frame.dcm(wall.frame)
+    Matrix([
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1]])
+
+    >>> Part2.frame.dcm(wall.frame)
+    Matrix([
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1]])
+
+    The position of the particles' masscenter is found with:
+
+    >>> Part1.masscenter.pos_from(wall.masscenter)
+    q_J1(t)*W_frame.x
+
+    >>> Part2.masscenter.pos_from(wall.masscenter)
+    q_J1(t)*W_frame.x + q_J2(t)*P1_frame.x
+
+    The angular velocities of the two particle links can be computed with
+    respect to the ceiling.
+
+    >>> Part1.frame.ang_vel_in(wall.frame)
+    0
+
+    >>> Part2.frame.ang_vel_in(wall.frame)
+    0
+
+    And finally, the linear velocities of the two particles can be computed
+    with respect to the ceiling.
+
+    >>> Part1.masscenter.vel(wall.frame)
+    u_J1(t)*W_frame.x
+
+    >>> Part2.masscenter.vel(wall.frame)
+    u_J1(t)*W_frame.x + Derivative(q_J2(t), t)*P1_frame.x
+
+    """
+
+    def __init__(self, name, parent, child, coordinates=None, speeds=None,
+                 parent_point=None, child_point=None, parent_interframe=None,
+                 child_interframe=None, parent_axis=None, child_axis=None,
+                 joint_axis=None, parent_joint_pos=None, child_joint_pos=None):
+
+        self._joint_axis = joint_axis
+        super().__init__(name, parent, child, coordinates, speeds, parent_point,
+                         child_point, parent_interframe, child_interframe,
+                         parent_axis, child_axis, parent_joint_pos,
+                         child_joint_pos)
+
+    def __str__(self):
+        return (f'PrismaticJoint: {self.name}  parent: {self.parent}  '
+                f'child: {self.child}')
+
+    @property
+    def joint_axis(self):
+        """Axis along which the child translates with respect to the parent."""
+        return self._joint_axis
+
+    def _generate_coordinates(self, coordinate):
+        return self._fill_coordinate_list(coordinate, 1, 'q')
+
+    def _generate_speeds(self, speed):
+        return self._fill_coordinate_list(speed, 1, 'u')
+
+    def _orient_frames(self):
+        self._joint_axis = self._axis(self.joint_axis, self.parent_interframe)
+        self.child_interframe.orient_axis(
+            self.parent_interframe, self.joint_axis, 0)
+
+    def _set_angular_velocity(self):
+        self.child_interframe.set_ang_vel(self.parent_interframe, 0)
+
+    def _set_linear_velocity(self):
+        axis = self.joint_axis.normalize()
+        self.child_point.set_pos(self.parent_point, self.coordinates[0] * axis)
+        self.parent_point.set_vel(self._parent_frame, 0)
+        self.child_point.set_vel(self._child_frame, 0)
+        self.child_point.set_vel(self._parent_frame, self.speeds[0] * axis)
+        self.child.masscenter.set_vel(self._parent_frame, self.speeds[0] * axis)
+
+
+class CylindricalJoint(Joint):
+    """Cylindrical Joint.
+
+    .. image:: CylindricalJoint.svg
+        :align: center
+        :width: 600
+
+    Explanation
+    ===========
+
+    A cylindrical joint is defined such that the child body both rotates about
+    and translates along the body-fixed joint axis with respect to the parent
+    body. The joint axis is both the rotation axis and translation axis. The
+    location of the joint is defined by two points, one in each body, which
+    coincide when the generalized coordinate corresponding to the translation is
+    zero. The direction cosine matrix between the child interframe and parent
+    interframe is formed using a simple rotation about the joint axis. The page
+    on the joints framework gives a more detailed explanation of the
+    intermediate frames.
+
+    Parameters
+    ==========
+
+    name : string
+        A unique name for the joint.
+    parent : Particle or RigidBody or Body
+        The parent body of joint.
+    child : Particle or RigidBody or Body
+        The child body of joint.
+    rotation_coordinate : dynamicsymbol, optional
+        Generalized coordinate corresponding to the rotation angle. The default
+        value is ``dynamicsymbols(f'q0_{joint.name}')``.
+    translation_coordinate : dynamicsymbol, optional
+        Generalized coordinate corresponding to the translation distance. The
+        default value is ``dynamicsymbols(f'q1_{joint.name}')``.
+    rotation_speed : dynamicsymbol, optional
+        Generalized speed corresponding to the angular velocity. The default
+        value is ``dynamicsymbols(f'u0_{joint.name}')``.
+    translation_speed : dynamicsymbol, optional
+        Generalized speed corresponding to the translation velocity. The default
+        value is ``dynamicsymbols(f'u1_{joint.name}')``.
+    parent_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the parent body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the parent's mass
+        center.
+    child_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the child body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the child's mass
+        center.
+    parent_interframe : ReferenceFrame, optional
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the parent's own frame.
+    child_interframe : ReferenceFrame, optional
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the child's own frame.
+    joint_axis : Vector, optional
+        The rotation as well as translation axis. Note that the components of
+        this axis are the same in the parent_interframe and child_interframe.
+
+    Attributes
+    ==========
+
+    name : string
+        The joint's name.
+    parent : Particle or RigidBody or Body
+        The joint's parent body.
+    child : Particle or RigidBody or Body
+        The joint's child body.
+    rotation_coordinate : dynamicsymbol
+        Generalized coordinate corresponding to the rotation angle.
+    translation_coordinate : dynamicsymbol
+        Generalized coordinate corresponding to the translation distance.
+    rotation_speed : dynamicsymbol
+        Generalized speed corresponding to the angular velocity.
+    translation_speed : dynamicsymbol
+        Generalized speed corresponding to the translation velocity.
+    coordinates : Matrix
+        Matrix of the joint's generalized coordinates.
+    speeds : Matrix
+        Matrix of the joint's generalized speeds.
+    parent_point : Point
+        Attachment point where the joint is fixed to the parent body.
+    child_point : Point
+        Attachment point where the joint is fixed to the child body.
+    parent_interframe : ReferenceFrame
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated.
+    child_interframe : ReferenceFrame
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated.
+    kdes : Matrix
+        Kinematical differential equations of the joint.
+    joint_axis : Vector
+        The axis of rotation and translation.
+
+    Examples
+    =========
+
+    A single cylindrical joint is created between two bodies and has the
+    following basic attributes:
+
+    >>> from sympy.physics.mechanics import RigidBody, CylindricalJoint
+    >>> parent = RigidBody('P')
+    >>> parent
+    P
+    >>> child = RigidBody('C')
+    >>> child
+    C
+    >>> joint = CylindricalJoint('PC', parent, child)
+    >>> joint
+    CylindricalJoint: PC  parent: P  child: C
+    >>> joint.name
+    'PC'
+    >>> joint.parent
+    P
+    >>> joint.child
+    C
+    >>> joint.parent_point
+    P_masscenter
+    >>> joint.child_point
+    C_masscenter
+    >>> joint.parent_axis
+    P_frame.x
+    >>> joint.child_axis
+    C_frame.x
+    >>> joint.coordinates
+    Matrix([
+    [q0_PC(t)],
+    [q1_PC(t)]])
+    >>> joint.speeds
+    Matrix([
+    [u0_PC(t)],
+    [u1_PC(t)]])
+    >>> child.frame.ang_vel_in(parent.frame)
+    u0_PC(t)*P_frame.x
+    >>> child.frame.dcm(parent.frame)
+    Matrix([
+    [1,              0,             0],
+    [0,  cos(q0_PC(t)), sin(q0_PC(t))],
+    [0, -sin(q0_PC(t)), cos(q0_PC(t))]])
+    >>> joint.child_point.pos_from(joint.parent_point)
+    q1_PC(t)*P_frame.x
+    >>> child.masscenter.vel(parent.frame)
+    u1_PC(t)*P_frame.x
+
+    To further demonstrate the use of the cylindrical joint, the kinematics of
+    two cylindrical joints perpendicular to each other can be created as follows.
+
+    >>> from sympy import symbols
+    >>> from sympy.physics.mechanics import RigidBody, CylindricalJoint
+    >>> r, l, w = symbols('r l w')
+
+    First create bodies to represent the fixed floor with a fixed pole on it.
+    The second body represents a freely moving tube around that pole. The third
+    body represents a solid flag freely translating along and rotating around
+    the Y axis of the tube.
+
+    >>> floor = RigidBody('floor')
+    >>> tube = RigidBody('tube')
+    >>> flag = RigidBody('flag')
+
+    The first joint will connect the first tube to the floor with it translating
+    along and rotating around the Z axis of both bodies.
+
+    >>> floor_joint = CylindricalJoint('C1', floor, tube, joint_axis=floor.z)
+
+    The second joint will connect the tube perpendicular to the flag along the Y
+    axis of both the tube and the flag, with the joint located at a distance
+    ``r`` from the tube's center of mass and a combination of the distances
+    ``l`` and ``w`` from the flag's center of mass.
+
+    >>> flag_joint = CylindricalJoint('C2', tube, flag,
+    ...                               parent_point=r * tube.y,
+    ...                               child_point=-w * flag.y + l * flag.z,
+    ...                               joint_axis=tube.y)
+
+    Once the joints are established the kinematics of the connected bodies can
+    be accessed. First the direction cosine matrices of both the body and the
+    flag relative to the floor are found:
+
+    >>> tube.frame.dcm(floor.frame)
+    Matrix([
+    [ cos(q0_C1(t)), sin(q0_C1(t)), 0],
+    [-sin(q0_C1(t)), cos(q0_C1(t)), 0],
+    [             0,             0, 1]])
+    >>> flag.frame.dcm(floor.frame)
+    Matrix([
+    [cos(q0_C1(t))*cos(q0_C2(t)), sin(q0_C1(t))*cos(q0_C2(t)), -sin(q0_C2(t))],
+    [             -sin(q0_C1(t)),               cos(q0_C1(t)),              0],
+    [sin(q0_C2(t))*cos(q0_C1(t)), sin(q0_C1(t))*sin(q0_C2(t)),  cos(q0_C2(t))]])
+
+    The position of the flag's center of mass is found with:
+
+    >>> flag.masscenter.pos_from(floor.masscenter)
+    q1_C1(t)*floor_frame.z + (r + q1_C2(t))*tube_frame.y + w*flag_frame.y - l*flag_frame.z
+
+    The angular velocities of the two tubes can be computed with respect to the
+    floor.
+
+    >>> tube.frame.ang_vel_in(floor.frame)
+    u0_C1(t)*floor_frame.z
+    >>> flag.frame.ang_vel_in(floor.frame)
+    u0_C1(t)*floor_frame.z + u0_C2(t)*tube_frame.y
+
+    Finally, the linear velocities of the two tube centers of mass can be
+    computed with respect to the floor, while expressed in the tube's frame.
+
+    >>> tube.masscenter.vel(floor.frame).to_matrix(tube.frame)
+    Matrix([
+    [       0],
+    [       0],
+    [u1_C1(t)]])
+    >>> flag.masscenter.vel(floor.frame).to_matrix(tube.frame).simplify()
+    Matrix([
+    [-l*u0_C2(t)*cos(q0_C2(t)) - r*u0_C1(t) - w*u0_C1(t) - q1_C2(t)*u0_C1(t)],
+    [                    -l*u0_C1(t)*sin(q0_C2(t)) + Derivative(q1_C2(t), t)],
+    [                                    l*u0_C2(t)*sin(q0_C2(t)) + u1_C1(t)]])
+
+    """
+
+    def __init__(self, name, parent, child, rotation_coordinate=None,
+                 translation_coordinate=None, rotation_speed=None,
+                 translation_speed=None, parent_point=None, child_point=None,
+                 parent_interframe=None, child_interframe=None,
+                 joint_axis=None):
+        self._joint_axis = joint_axis
+        coordinates = (rotation_coordinate, translation_coordinate)
+        speeds = (rotation_speed, translation_speed)
+        super().__init__(name, parent, child, coordinates, speeds,
+                         parent_point, child_point,
+                         parent_interframe=parent_interframe,
+                         child_interframe=child_interframe)
+
+    def __str__(self):
+        return (f'CylindricalJoint: {self.name}  parent: {self.parent}  '
+                f'child: {self.child}')
+
+    @property
+    def joint_axis(self):
+        """Axis about and along which the rotation and translation occurs."""
+        return self._joint_axis
+
+    @property
+    def rotation_coordinate(self):
+        """Generalized coordinate corresponding to the rotation angle."""
+        return self.coordinates[0]
+
+    @property
+    def translation_coordinate(self):
+        """Generalized coordinate corresponding to the translation distance."""
+        return self.coordinates[1]
+
+    @property
+    def rotation_speed(self):
+        """Generalized speed corresponding to the angular velocity."""
+        return self.speeds[0]
+
+    @property
+    def translation_speed(self):
+        """Generalized speed corresponding to the translation velocity."""
+        return self.speeds[1]
+
+    def _generate_coordinates(self, coordinates):
+        return self._fill_coordinate_list(coordinates, 2, 'q')
+
+    def _generate_speeds(self, speeds):
+        return self._fill_coordinate_list(speeds, 2, 'u')
+
+    def _orient_frames(self):
+        self._joint_axis = self._axis(self.joint_axis, self.parent_interframe)
+        self.child_interframe.orient_axis(
+            self.parent_interframe, self.joint_axis, self.rotation_coordinate)
+
+    def _set_angular_velocity(self):
+        self.child_interframe.set_ang_vel(
+            self.parent_interframe,
+            self.rotation_speed * self.joint_axis.normalize())
+
+    def _set_linear_velocity(self):
+        self.child_point.set_pos(
+            self.parent_point,
+            self.translation_coordinate * self.joint_axis.normalize())
+        self.parent_point.set_vel(self._parent_frame, 0)
+        self.child_point.set_vel(self._child_frame, 0)
+        self.child_point.set_vel(
+            self._parent_frame,
+            self.translation_speed * self.joint_axis.normalize())
+        self.child.masscenter.v2pt_theory(self.child_point, self._parent_frame,
+                                          self.child_interframe)
+
+
+class PlanarJoint(Joint):
+    """Planar Joint.
+
+    .. raw:: html
+        :file: ../../../doc/src/modules/physics/mechanics/api/PlanarJoint.svg
+
+    Explanation
+    ===========
+
+    A planar joint is defined such that the child body translates over a fixed
+    plane of the parent body as well as rotate about the rotation axis, which
+    is perpendicular to that plane. The origin of this plane is the
+    ``parent_point`` and the plane is spanned by two nonparallel planar vectors.
+    The location of the ``child_point`` is based on the planar vectors
+    ($\\vec{v}_1$, $\\vec{v}_2$) and generalized coordinates ($q_1$, $q_2$),
+    i.e. $\\vec{r} = q_1 \\hat{v}_1 + q_2 \\hat{v}_2$. The direction cosine
+    matrix between the ``child_interframe`` and ``parent_interframe`` is formed
+    using a simple rotation ($q_0$) about the rotation axis.
+
+    In order to simplify the definition of the ``PlanarJoint``, the
+    ``rotation_axis`` and ``planar_vectors`` are set to be the unit vectors of
+    the ``parent_interframe`` according to the table below. This ensures that
+    you can only define these vectors by creating a separate frame and supplying
+    that as the interframe. If you however would only like to supply the normals
+    of the plane with respect to the parent and child bodies, then you can also
+    supply those to the ``parent_interframe`` and ``child_interframe``
+    arguments. An example of both of these cases is in the examples section
+    below and the page on the joints framework provides a more detailed
+    explanation of the intermediate frames.
+
+    .. list-table::
+
+        * - ``rotation_axis``
+          - ``parent_interframe.x``
+        * - ``planar_vectors[0]``
+          - ``parent_interframe.y``
+        * - ``planar_vectors[1]``
+          - ``parent_interframe.z``
+
+    Parameters
+    ==========
+
+    name : string
+        A unique name for the joint.
+    parent : Particle or RigidBody or Body
+        The parent body of joint.
+    child : Particle or RigidBody or Body
+        The child body of joint.
+    rotation_coordinate : dynamicsymbol, optional
+        Generalized coordinate corresponding to the rotation angle. The default
+        value is ``dynamicsymbols(f'q0_{joint.name}')``.
+    planar_coordinates : iterable of dynamicsymbols, optional
+        Two generalized coordinates used for the planar translation. The default
+        value is ``dynamicsymbols(f'q1_{joint.name} q2_{joint.name}')``.
+    rotation_speed : dynamicsymbol, optional
+        Generalized speed corresponding to the angular velocity. The default
+        value is ``dynamicsymbols(f'u0_{joint.name}')``.
+    planar_speeds : dynamicsymbols, optional
+        Two generalized speeds used for the planar translation velocity. The
+        default value is ``dynamicsymbols(f'u1_{joint.name} u2_{joint.name}')``.
+    parent_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the parent body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the parent's mass
+        center.
+    child_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the child body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the child's mass
+        center.
+    parent_interframe : ReferenceFrame, optional
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the parent's own frame.
+    child_interframe : ReferenceFrame, optional
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the child's own frame.
+
+    Attributes
+    ==========
+
+    name : string
+        The joint's name.
+    parent : Particle or RigidBody or Body
+        The joint's parent body.
+    child : Particle or RigidBody or Body
+        The joint's child body.
+    rotation_coordinate : dynamicsymbol
+        Generalized coordinate corresponding to the rotation angle.
+    planar_coordinates : Matrix
+        Two generalized coordinates used for the planar translation.
+    rotation_speed : dynamicsymbol
+        Generalized speed corresponding to the angular velocity.
+    planar_speeds : Matrix
+        Two generalized speeds used for the planar translation velocity.
+    coordinates : Matrix
+        Matrix of the joint's generalized coordinates.
+    speeds : Matrix
+        Matrix of the joint's generalized speeds.
+    parent_point : Point
+        Attachment point where the joint is fixed to the parent body.
+    child_point : Point
+        Attachment point where the joint is fixed to the child body.
+    parent_interframe : ReferenceFrame
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated.
+    child_interframe : ReferenceFrame
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated.
+    kdes : Matrix
+        Kinematical differential equations of the joint.
+    rotation_axis : Vector
+        The axis about which the rotation occurs.
+    planar_vectors : list
+        The vectors that describe the planar translation directions.
+
+    Examples
+    =========
+
+    A single planar joint is created between two bodies and has the following
+    basic attributes:
+
+    >>> from sympy.physics.mechanics import RigidBody, PlanarJoint
+    >>> parent = RigidBody('P')
+    >>> parent
+    P
+    >>> child = RigidBody('C')
+    >>> child
+    C
+    >>> joint = PlanarJoint('PC', parent, child)
+    >>> joint
+    PlanarJoint: PC  parent: P  child: C
+    >>> joint.name
+    'PC'
+    >>> joint.parent
+    P
+    >>> joint.child
+    C
+    >>> joint.parent_point
+    P_masscenter
+    >>> joint.child_point
+    C_masscenter
+    >>> joint.rotation_axis
+    P_frame.x
+    >>> joint.planar_vectors
+    [P_frame.y, P_frame.z]
+    >>> joint.rotation_coordinate
+    q0_PC(t)
+    >>> joint.planar_coordinates
+    Matrix([
+    [q1_PC(t)],
+    [q2_PC(t)]])
+    >>> joint.coordinates
+    Matrix([
+    [q0_PC(t)],
+    [q1_PC(t)],
+    [q2_PC(t)]])
+    >>> joint.rotation_speed
+    u0_PC(t)
+    >>> joint.planar_speeds
+    Matrix([
+    [u1_PC(t)],
+    [u2_PC(t)]])
+    >>> joint.speeds
+    Matrix([
+    [u0_PC(t)],
+    [u1_PC(t)],
+    [u2_PC(t)]])
+    >>> child.frame.ang_vel_in(parent.frame)
+    u0_PC(t)*P_frame.x
+    >>> child.frame.dcm(parent.frame)
+    Matrix([
+    [1,              0,             0],
+    [0,  cos(q0_PC(t)), sin(q0_PC(t))],
+    [0, -sin(q0_PC(t)), cos(q0_PC(t))]])
+    >>> joint.child_point.pos_from(joint.parent_point)
+    q1_PC(t)*P_frame.y + q2_PC(t)*P_frame.z
+    >>> child.masscenter.vel(parent.frame)
+    u1_PC(t)*P_frame.y + u2_PC(t)*P_frame.z
+
+    To further demonstrate the use of the planar joint, the kinematics of a
+    block sliding on a slope, can be created as follows.
+
+    >>> from sympy import symbols
+    >>> from sympy.physics.mechanics import PlanarJoint, RigidBody, ReferenceFrame
+    >>> a, d, h = symbols('a d h')
+
+    First create bodies to represent the slope and the block.
+
+    >>> ground = RigidBody('G')
+    >>> block = RigidBody('B')
+
+    To define the slope you can either define the plane by specifying the
+    ``planar_vectors`` or/and the ``rotation_axis``. However it is advisable to
+    create a rotated intermediate frame, so that the ``parent_vectors`` and
+    ``rotation_axis`` will be the unit vectors of this intermediate frame.
+
+    >>> slope = ReferenceFrame('A')
+    >>> slope.orient_axis(ground.frame, ground.y, a)
+
+    The planar joint can be created using these bodies and intermediate frame.
+    We can specify the origin of the slope to be ``d`` above the slope's center
+    of mass and the block's center of mass to be a distance ``h`` above the
+    slope's surface. Note that we can specify the normal of the plane using the
+    rotation axis argument.
+
+    >>> joint = PlanarJoint('PC', ground, block, parent_point=d * ground.x,
+    ...                     child_point=-h * block.x, parent_interframe=slope)
+
+    Once the joint is established the kinematics of the bodies can be accessed.
+    First the ``rotation_axis``, which is normal to the plane and the
+    ``plane_vectors``, can be found.
+
+    >>> joint.rotation_axis
+    A.x
+    >>> joint.planar_vectors
+    [A.y, A.z]
+
+    The direction cosine matrix of the block with respect to the ground can be
+    found with:
+
+    >>> block.frame.dcm(ground.frame)
+    Matrix([
+    [              cos(a),              0,              -sin(a)],
+    [sin(a)*sin(q0_PC(t)),  cos(q0_PC(t)), sin(q0_PC(t))*cos(a)],
+    [sin(a)*cos(q0_PC(t)), -sin(q0_PC(t)), cos(a)*cos(q0_PC(t))]])
+
+    The angular velocity of the block can be computed with respect to the
+    ground.
+
+    >>> block.frame.ang_vel_in(ground.frame)
+    u0_PC(t)*A.x
+
+    The position of the block's center of mass can be found with:
+
+    >>> block.masscenter.pos_from(ground.masscenter)
+    d*G_frame.x + h*B_frame.x + q1_PC(t)*A.y + q2_PC(t)*A.z
+
+    Finally, the linear velocity of the block's center of mass can be
+    computed with respect to the ground.
+
+    >>> block.masscenter.vel(ground.frame)
+    u1_PC(t)*A.y + u2_PC(t)*A.z
+
+    In some cases it could be your preference to only define the normals of the
+    plane with respect to both bodies. This can most easily be done by supplying
+    vectors to the ``interframe`` arguments. What will happen in this case is
+    that an interframe will be created with its ``x`` axis aligned with the
+    provided vector. For a further explanation of how this is done see the notes
+    of the ``Joint`` class. In the code below, the above example (with the block
+    on the slope) is recreated by supplying vectors to the interframe arguments.
+    Note that the previously described option is however more computationally
+    efficient, because the algorithm now has to compute the rotation angle
+    between the provided vector and the 'x' axis.
+
+    >>> from sympy import symbols, cos, sin
+    >>> from sympy.physics.mechanics import PlanarJoint, RigidBody
+    >>> a, d, h = symbols('a d h')
+    >>> ground = RigidBody('G')
+    >>> block = RigidBody('B')
+    >>> joint = PlanarJoint(
+    ...     'PC', ground, block, parent_point=d * ground.x,
+    ...     child_point=-h * block.x, child_interframe=block.x,
+    ...     parent_interframe=cos(a) * ground.x + sin(a) * ground.z)
+    >>> block.frame.dcm(ground.frame).simplify()
+    Matrix([
+    [               cos(a),              0,               sin(a)],
+    [-sin(a)*sin(q0_PC(t)),  cos(q0_PC(t)), sin(q0_PC(t))*cos(a)],
+    [-sin(a)*cos(q0_PC(t)), -sin(q0_PC(t)), cos(a)*cos(q0_PC(t))]])
+
+    """
+
+    def __init__(self, name, parent, child, rotation_coordinate=None,
+                 planar_coordinates=None, rotation_speed=None,
+                 planar_speeds=None, parent_point=None, child_point=None,
+                 parent_interframe=None, child_interframe=None):
+        # A ready to merge implementation of setting the planar_vectors and
+        # rotation_axis was added and removed in PR #24046
+        coordinates = (rotation_coordinate, planar_coordinates)
+        speeds = (rotation_speed, planar_speeds)
+        super().__init__(name, parent, child, coordinates, speeds,
+                         parent_point, child_point,
+                         parent_interframe=parent_interframe,
+                         child_interframe=child_interframe)
+
+    def __str__(self):
+        return (f'PlanarJoint: {self.name}  parent: {self.parent}  '
+                f'child: {self.child}')
+
+    @property
+    def rotation_coordinate(self):
+        """Generalized coordinate corresponding to the rotation angle."""
+        return self.coordinates[0]
+
+    @property
+    def planar_coordinates(self):
+        """Two generalized coordinates used for the planar translation."""
+        return self.coordinates[1:, 0]
+
+    @property
+    def rotation_speed(self):
+        """Generalized speed corresponding to the angular velocity."""
+        return self.speeds[0]
+
+    @property
+    def planar_speeds(self):
+        """Two generalized speeds used for the planar translation velocity."""
+        return self.speeds[1:, 0]
+
+    @property
+    def rotation_axis(self):
+        """The axis about which the rotation occurs."""
+        return self.parent_interframe.x
+
+    @property
+    def planar_vectors(self):
+        """The vectors that describe the planar translation directions."""
+        return [self.parent_interframe.y, self.parent_interframe.z]
+
+    def _generate_coordinates(self, coordinates):
+        rotation_speed = self._fill_coordinate_list(coordinates[0], 1, 'q',
+                                                    number_single=True)
+        planar_speeds = self._fill_coordinate_list(coordinates[1], 2, 'q', 1)
+        return rotation_speed.col_join(planar_speeds)
+
+    def _generate_speeds(self, speeds):
+        rotation_speed = self._fill_coordinate_list(speeds[0], 1, 'u',
+                                                    number_single=True)
+        planar_speeds = self._fill_coordinate_list(speeds[1], 2, 'u', 1)
+        return rotation_speed.col_join(planar_speeds)
+
+    def _orient_frames(self):
+        self.child_interframe.orient_axis(
+            self.parent_interframe, self.rotation_axis,
+            self.rotation_coordinate)
+
+    def _set_angular_velocity(self):
+        self.child_interframe.set_ang_vel(
+            self.parent_interframe,
+            self.rotation_speed * self.rotation_axis)
+
+    def _set_linear_velocity(self):
+        self.child_point.set_pos(
+            self.parent_point,
+            self.planar_coordinates[0] * self.planar_vectors[0] +
+            self.planar_coordinates[1] * self.planar_vectors[1])
+        self.parent_point.set_vel(self.parent_interframe, 0)
+        self.child_point.set_vel(self.child_interframe, 0)
+        self.child_point.set_vel(
+            self._parent_frame, self.planar_speeds[0] * self.planar_vectors[0] +
+            self.planar_speeds[1] * self.planar_vectors[1])
+        self.child.masscenter.v2pt_theory(self.child_point, self._parent_frame,
+                                          self._child_frame)
+
+
+class SphericalJoint(Joint):
+    """Spherical (Ball-and-Socket) Joint.
+
+    .. image:: SphericalJoint.svg
+        :align: center
+        :width: 600
+
+    Explanation
+    ===========
+
+    A spherical joint is defined such that the child body is free to rotate in
+    any direction, without allowing a translation of the ``child_point``. As can
+    also be seen in the image, the ``parent_point`` and ``child_point`` are
+    fixed on top of each other, i.e. the ``joint_point``. This rotation is
+    defined using the :func:`parent_interframe.orient(child_interframe,
+    rot_type, amounts, rot_order)
+    <sympy.physics.vector.frame.ReferenceFrame.orient>` method. The default
+    rotation consists of three relative rotations, i.e. body-fixed rotations.
+    Based on the direction cosine matrix following from these rotations, the
+    angular velocity is computed based on the generalized coordinates and
+    generalized speeds.
+
+    Parameters
+    ==========
+
+    name : string
+        A unique name for the joint.
+    parent : Particle or RigidBody or Body
+        The parent body of joint.
+    child : Particle or RigidBody or Body
+        The child body of joint.
+    coordinates: iterable of dynamicsymbols, optional
+        Generalized coordinates of the joint.
+    speeds : iterable of dynamicsymbols, optional
+        Generalized speeds of joint.
+    parent_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the parent body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the parent's mass
+        center.
+    child_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the child body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the child's mass
+        center.
+    parent_interframe : ReferenceFrame, optional
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the parent's own frame.
+    child_interframe : ReferenceFrame, optional
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the child's own frame.
+    rot_type : str, optional
+        The method used to generate the direction cosine matrix. Supported
+        methods are:
+
+        - ``'Body'``: three successive rotations about new intermediate axes,
+          also called "Euler and Tait-Bryan angles"
+        - ``'Space'``: three successive rotations about the parent frames' unit
+          vectors
+
+        The default method is ``'Body'``.
+    amounts :
+        Expressions defining the rotation angles or direction cosine matrix.
+        These must match the ``rot_type``. See examples below for details. The
+        input types are:
+
+        - ``'Body'``: 3-tuple of expressions, symbols, or functions
+        - ``'Space'``: 3-tuple of expressions, symbols, or functions
+
+        The default amounts are the given ``coordinates``.
+    rot_order : str or int, optional
+        If applicable, the order of the successive of rotations. The string
+        ``'123'`` and integer ``123`` are equivalent, for example. Required for
+        ``'Body'`` and ``'Space'``. The default value is ``123``.
+
+    Attributes
+    ==========
+
+    name : string
+        The joint's name.
+    parent : Particle or RigidBody or Body
+        The joint's parent body.
+    child : Particle or RigidBody or Body
+        The joint's child body.
+    coordinates : Matrix
+        Matrix of the joint's generalized coordinates.
+    speeds : Matrix
+        Matrix of the joint's generalized speeds.
+    parent_point : Point
+        Attachment point where the joint is fixed to the parent body.
+    child_point : Point
+        Attachment point where the joint is fixed to the child body.
+    parent_interframe : ReferenceFrame
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated.
+    child_interframe : ReferenceFrame
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated.
+    kdes : Matrix
+        Kinematical differential equations of the joint.
+
+    Examples
+    =========
+
+    A single spherical joint is created from two bodies and has the following
+    basic attributes:
+
+    >>> from sympy.physics.mechanics import RigidBody, SphericalJoint
+    >>> parent = RigidBody('P')
+    >>> parent
+    P
+    >>> child = RigidBody('C')
+    >>> child
+    C
+    >>> joint = SphericalJoint('PC', parent, child)
+    >>> joint
+    SphericalJoint: PC  parent: P  child: C
+    >>> joint.name
+    'PC'
+    >>> joint.parent
+    P
+    >>> joint.child
+    C
+    >>> joint.parent_point
+    P_masscenter
+    >>> joint.child_point
+    C_masscenter
+    >>> joint.parent_interframe
+    P_frame
+    >>> joint.child_interframe
+    C_frame
+    >>> joint.coordinates
+    Matrix([
+    [q0_PC(t)],
+    [q1_PC(t)],
+    [q2_PC(t)]])
+    >>> joint.speeds
+    Matrix([
+    [u0_PC(t)],
+    [u1_PC(t)],
+    [u2_PC(t)]])
+    >>> child.frame.ang_vel_in(parent.frame).to_matrix(child.frame)
+    Matrix([
+    [ u0_PC(t)*cos(q1_PC(t))*cos(q2_PC(t)) + u1_PC(t)*sin(q2_PC(t))],
+    [-u0_PC(t)*sin(q2_PC(t))*cos(q1_PC(t)) + u1_PC(t)*cos(q2_PC(t))],
+    [                             u0_PC(t)*sin(q1_PC(t)) + u2_PC(t)]])
+    >>> child.frame.x.to_matrix(parent.frame)
+    Matrix([
+    [                                            cos(q1_PC(t))*cos(q2_PC(t))],
+    [sin(q0_PC(t))*sin(q1_PC(t))*cos(q2_PC(t)) + sin(q2_PC(t))*cos(q0_PC(t))],
+    [sin(q0_PC(t))*sin(q2_PC(t)) - sin(q1_PC(t))*cos(q0_PC(t))*cos(q2_PC(t))]])
+    >>> joint.child_point.pos_from(joint.parent_point)
+    0
+
+    To further demonstrate the use of the spherical joint, the kinematics of a
+    spherical joint with a ZXZ rotation can be created as follows.
+
+    >>> from sympy import symbols
+    >>> from sympy.physics.mechanics import RigidBody, SphericalJoint
+    >>> l1 = symbols('l1')
+
+    First create bodies to represent the fixed floor and a pendulum bob.
+
+    >>> floor = RigidBody('F')
+    >>> bob = RigidBody('B')
+
+    The joint will connect the bob to the floor, with the joint located at a
+    distance of ``l1`` from the child's center of mass and the rotation set to a
+    body-fixed ZXZ rotation.
+
+    >>> joint = SphericalJoint('S', floor, bob, child_point=l1 * bob.y,
+    ...                        rot_type='body', rot_order='ZXZ')
+
+    Now that the joint is established, the kinematics of the connected body can
+    be accessed.
+
+    The position of the bob's masscenter is found with:
+
+    >>> bob.masscenter.pos_from(floor.masscenter)
+    - l1*B_frame.y
+
+    The angular velocities of the pendulum link can be computed with respect to
+    the floor.
+
+    >>> bob.frame.ang_vel_in(floor.frame).to_matrix(
+    ...     floor.frame).simplify()
+    Matrix([
+    [u1_S(t)*cos(q0_S(t)) + u2_S(t)*sin(q0_S(t))*sin(q1_S(t))],
+    [u1_S(t)*sin(q0_S(t)) - u2_S(t)*sin(q1_S(t))*cos(q0_S(t))],
+    [                          u0_S(t) + u2_S(t)*cos(q1_S(t))]])
+
+    Finally, the linear velocity of the bob's center of mass can be computed.
+
+    >>> bob.masscenter.vel(floor.frame).to_matrix(bob.frame)
+    Matrix([
+    [                           l1*(u0_S(t)*cos(q1_S(t)) + u2_S(t))],
+    [                                                             0],
+    [-l1*(u0_S(t)*sin(q1_S(t))*sin(q2_S(t)) + u1_S(t)*cos(q2_S(t)))]])
+
+    """
+    def __init__(self, name, parent, child, coordinates=None, speeds=None,
+                 parent_point=None, child_point=None, parent_interframe=None,
+                 child_interframe=None, rot_type='BODY', amounts=None,
+                 rot_order=123):
+        self._rot_type = rot_type
+        self._amounts = amounts
+        self._rot_order = rot_order
+        super().__init__(name, parent, child, coordinates, speeds,
+                         parent_point, child_point,
+                         parent_interframe=parent_interframe,
+                         child_interframe=child_interframe)
+
+    def __str__(self):
+        return (f'SphericalJoint: {self.name}  parent: {self.parent}  '
+                f'child: {self.child}')
+
+    def _generate_coordinates(self, coordinates):
+        return self._fill_coordinate_list(coordinates, 3, 'q')
+
+    def _generate_speeds(self, speeds):
+        return self._fill_coordinate_list(speeds, len(self.coordinates), 'u')
+
+    def _orient_frames(self):
+        supported_rot_types = ('BODY', 'SPACE')
+        if self._rot_type.upper() not in supported_rot_types:
+            raise NotImplementedError(
+                f'Rotation type "{self._rot_type}" is not implemented. '
+                f'Implemented rotation types are: {supported_rot_types}')
+        amounts = self.coordinates if self._amounts is None else self._amounts
+        self.child_interframe.orient(self.parent_interframe, self._rot_type,
+                                     amounts, self._rot_order)
+
+    def _set_angular_velocity(self):
+        t = dynamicsymbols._t
+        vel = self.child_interframe.ang_vel_in(self.parent_interframe).xreplace(
+            {q.diff(t): u for q, u in zip(self.coordinates, self.speeds)}
+        )
+        self.child_interframe.set_ang_vel(self.parent_interframe, vel)
+
+    def _set_linear_velocity(self):
+        self.child_point.set_pos(self.parent_point, 0)
+        self.parent_point.set_vel(self._parent_frame, 0)
+        self.child_point.set_vel(self._child_frame, 0)
+        self.child.masscenter.v2pt_theory(self.parent_point, self._parent_frame,
+                                          self._child_frame)
+
+
+class WeldJoint(Joint):
+    """Weld Joint.
+
+    .. raw:: html
+        :file: ../../../doc/src/modules/physics/mechanics/api/WeldJoint.svg
+
+    Explanation
+    ===========
+
+    A weld joint is defined such that there is no relative motion between the
+    child and parent bodies. The direction cosine matrix between the attachment
+    frame (``parent_interframe`` and ``child_interframe``) is the identity
+    matrix and the attachment points (``parent_point`` and ``child_point``) are
+    coincident. The page on the joints framework gives a more detailed
+    explanation of the intermediate frames.
+
+    Parameters
+    ==========
+
+    name : string
+        A unique name for the joint.
+    parent : Particle or RigidBody or Body
+        The parent body of joint.
+    child : Particle or RigidBody or Body
+        The child body of joint.
+    parent_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the parent body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the parent's mass
+        center.
+    child_point : Point or Vector, optional
+        Attachment point where the joint is fixed to the child body. If a
+        vector is provided, then the attachment point is computed by adding the
+        vector to the body's mass center. The default value is the child's mass
+        center.
+    parent_interframe : ReferenceFrame, optional
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the parent's own frame.
+    child_interframe : ReferenceFrame, optional
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated. If a Vector is provided then an interframe
+        is created which aligns its X axis with the given vector. The default
+        value is the child's own frame.
+
+    Attributes
+    ==========
+
+    name : string
+        The joint's name.
+    parent : Particle or RigidBody or Body
+        The joint's parent body.
+    child : Particle or RigidBody or Body
+        The joint's child body.
+    coordinates : Matrix
+        Matrix of the joint's generalized coordinates. The default value is
+        ``dynamicsymbols(f'q_{joint.name}')``.
+    speeds : Matrix
+        Matrix of the joint's generalized speeds. The default value is
+        ``dynamicsymbols(f'u_{joint.name}')``.
+    parent_point : Point
+        Attachment point where the joint is fixed to the parent body.
+    child_point : Point
+        Attachment point where the joint is fixed to the child body.
+    parent_interframe : ReferenceFrame
+        Intermediate frame of the parent body with respect to which the joint
+        transformation is formulated.
+    child_interframe : ReferenceFrame
+        Intermediate frame of the child body with respect to which the joint
+        transformation is formulated.
+    kdes : Matrix
+        Kinematical differential equations of the joint.
+
+    Examples
+    =========
+
+    A single weld joint is created from two bodies and has the following basic
+    attributes:
+
+    >>> from sympy.physics.mechanics import RigidBody, WeldJoint
+    >>> parent = RigidBody('P')
+    >>> parent
+    P
+    >>> child = RigidBody('C')
+    >>> child
+    C
+    >>> joint = WeldJoint('PC', parent, child)
+    >>> joint
+    WeldJoint: PC  parent: P  child: C
+    >>> joint.name
+    'PC'
+    >>> joint.parent
+    P
+    >>> joint.child
+    C
+    >>> joint.parent_point
+    P_masscenter
+    >>> joint.child_point
+    C_masscenter
+    >>> joint.coordinates
+    Matrix(0, 0, [])
+    >>> joint.speeds
+    Matrix(0, 0, [])
+    >>> child.frame.ang_vel_in(parent.frame)
+    0
+    >>> child.frame.dcm(parent.frame)
+    Matrix([
+    [1, 0, 0],
+    [0, 1, 0],
+    [0, 0, 1]])
+    >>> joint.child_point.pos_from(joint.parent_point)
+    0
+
+    To further demonstrate the use of the weld joint, two relatively-fixed
+    bodies rotated by a quarter turn about the Y axis can be created as follows:
+
+    >>> from sympy import symbols, pi
+    >>> from sympy.physics.mechanics import ReferenceFrame, RigidBody, WeldJoint
+    >>> l1, l2 = symbols('l1 l2')
+
+    First create the bodies to represent the parent and rotated child body.
+
+    >>> parent = RigidBody('P')
+    >>> child = RigidBody('C')
+
+    Next the intermediate frame specifying the fixed rotation with respect to
+    the parent can be created.
+
+    >>> rotated_frame = ReferenceFrame('Pr')
+    >>> rotated_frame.orient_axis(parent.frame, parent.y, pi / 2)
+
+    The weld between the parent body and child body is located at a distance
+    ``l1`` from the parent's center of mass in the X direction and ``l2`` from
+    the child's center of mass in the child's negative X direction.
+
+    >>> weld = WeldJoint('weld', parent, child, parent_point=l1 * parent.x,
+    ...                  child_point=-l2 * child.x,
+    ...                  parent_interframe=rotated_frame)
+
+    Now that the joint has been established, the kinematics of the bodies can be
+    accessed. The direction cosine matrix of the child body with respect to the
+    parent can be found:
+
+    >>> child.frame.dcm(parent.frame)
+    Matrix([
+    [0, 0, -1],
+    [0, 1,  0],
+    [1, 0,  0]])
+
+    As can also been seen from the direction cosine matrix, the parent X axis is
+    aligned with the child's Z axis:
+    >>> parent.x == child.z
+    True
+
+    The position of the child's center of mass with respect to the parent's
+    center of mass can be found with:
+
+    >>> child.masscenter.pos_from(parent.masscenter)
+    l1*P_frame.x + l2*C_frame.x
+
+    The angular velocity of the child with respect to the parent is 0 as one
+    would expect.
+
+    >>> child.frame.ang_vel_in(parent.frame)
+    0
+
+    """
+
+    def __init__(self, name, parent, child, parent_point=None, child_point=None,
+                 parent_interframe=None, child_interframe=None):
+        super().__init__(name, parent, child, [], [], parent_point,
+                         child_point, parent_interframe=parent_interframe,
+                         child_interframe=child_interframe)
+        self._kdes = Matrix(1, 0, []).T  # Removes stackability problems #10770
+
+    def __str__(self):
+        return (f'WeldJoint: {self.name}  parent: {self.parent}  '
+                f'child: {self.child}')
+
+    def _generate_coordinates(self, coordinate):
+        return Matrix()
+
+    def _generate_speeds(self, speed):
+        return Matrix()
+
+    def _orient_frames(self):
+        self.child_interframe.orient_axis(self.parent_interframe,
+                                          self.parent_interframe.x, 0)
+
+    def _set_angular_velocity(self):
+        self.child_interframe.set_ang_vel(self.parent_interframe, 0)
+
+    def _set_linear_velocity(self):
+        self.child_point.set_pos(self.parent_point, 0)
+        self.parent_point.set_vel(self._parent_frame, 0)
+        self.child_point.set_vel(self._child_frame, 0)
+        self.child.masscenter.set_vel(self._parent_frame, 0)

mplug_owl2/lib/python3.10/site-packages/sympy/physics/mechanics/jointsmethod.py

@@ -0,0 +1,318 @@
+from sympy.physics.mechanics import (Body, Lagrangian, KanesMethod, LagrangesMethod,
+                                    RigidBody, Particle)
+from sympy.physics.mechanics.body_base import BodyBase
+from sympy.physics.mechanics.method import _Methods
+from sympy import Matrix
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+__all__ = ['JointsMethod']
+
+
+class JointsMethod(_Methods):
+    """Method for formulating the equations of motion using a set of interconnected bodies with joints.
+
+    .. deprecated:: 1.13
+        The JointsMethod class is deprecated. Its functionality has been
+        replaced by the new :class:`~.System` class.
+
+    Parameters
+    ==========
+
+    newtonion : Body or ReferenceFrame
+        The newtonion(inertial) frame.
+    *joints : Joint
+        The joints in the system
+
+    Attributes
+    ==========
+
+    q, u : iterable
+        Iterable of the generalized coordinates and speeds
+    bodies : iterable
+        Iterable of Body objects in the system.
+    loads : iterable
+        Iterable of (Point, vector) or (ReferenceFrame, vector) tuples
+        describing the forces on the system.
+    mass_matrix : Matrix, shape(n, n)
+        The system's mass matrix
+    forcing : Matrix, shape(n, 1)
+        The system's forcing vector
+    mass_matrix_full : Matrix, shape(2*n, 2*n)
+        The "mass matrix" for the u's and q's
+    forcing_full : Matrix, shape(2*n, 1)
+        The "forcing vector" for the u's and q's
+    method : KanesMethod or Lagrange's method
+        Method's object.
+    kdes : iterable
+        Iterable of kde in they system.
+
+    Examples
+    ========
+
+    As Body and JointsMethod have been deprecated, the following examples are
+    for illustrative purposes only. The functionality of Body is fully captured
+    by :class:`~.RigidBody` and :class:`~.Particle` and the functionality of
+    JointsMethod is fully captured by :class:`~.System`. To ignore the
+    deprecation warning we can use the ignore_warnings context manager.
+
+    >>> from sympy.utilities.exceptions import ignore_warnings
+
+    This is a simple example for a one degree of freedom translational
+    spring-mass-damper.
+
+    >>> from sympy import symbols
+    >>> from sympy.physics.mechanics import Body, JointsMethod, PrismaticJoint
+    >>> from sympy.physics.vector import dynamicsymbols
+    >>> c, k = symbols('c k')
+    >>> x, v = dynamicsymbols('x v')
+    >>> with ignore_warnings(DeprecationWarning):
+    ...     wall = Body('W')
+    ...     body = Body('B')
+    >>> J = PrismaticJoint('J', wall, body, coordinates=x, speeds=v)
+    >>> wall.apply_force(c*v*wall.x, reaction_body=body)
+    >>> wall.apply_force(k*x*wall.x, reaction_body=body)
+    >>> with ignore_warnings(DeprecationWarning):
+    ...     method = JointsMethod(wall, J)
+    >>> method.form_eoms()
+    Matrix([[-B_mass*Derivative(v(t), t) - c*v(t) - k*x(t)]])
+    >>> M = method.mass_matrix_full
+    >>> F = method.forcing_full
+    >>> rhs = M.LUsolve(F)
+    >>> rhs
+    Matrix([
+    [                     v(t)],
+    [(-c*v(t) - k*x(t))/B_mass]])
+
+    Notes
+    =====
+
+    ``JointsMethod`` currently only works with systems that do not have any
+    configuration or motion constraints.
+
+    """
+
+    def __init__(self, newtonion, *joints):
+        sympy_deprecation_warning(
+            """
+            The JointsMethod class is deprecated.
+            Its functionality has been replaced by the new System class.
+            """,
+            deprecated_since_version="1.13",
+            active_deprecations_target="deprecated-mechanics-jointsmethod"
+        )
+        if isinstance(newtonion, BodyBase):
+            self.frame = newtonion.frame
+        else:
+            self.frame = newtonion
+
+        self._joints = joints
+        self._bodies = self._generate_bodylist()
+        self._loads = self._generate_loadlist()
+        self._q = self._generate_q()
+        self._u = self._generate_u()
+        self._kdes = self._generate_kdes()
+
+        self._method = None
+
+    @property
+    def bodies(self):
+        """List of bodies in they system."""
+        return self._bodies
+
+    @property
+    def loads(self):
+        """List of loads on the system."""
+        return self._loads
+
+    @property
+    def q(self):
+        """List of the generalized coordinates."""
+        return self._q
+
+    @property
+    def u(self):
+        """List of the generalized speeds."""
+        return self._u
+
+    @property
+    def kdes(self):
+        """List of the generalized coordinates."""
+        return self._kdes
+
+    @property
+    def forcing_full(self):
+        """The "forcing vector" for the u's and q's."""
+        return self.method.forcing_full
+
+    @property
+    def mass_matrix_full(self):
+        """The "mass matrix" for the u's and q's."""
+        return self.method.mass_matrix_full
+
+    @property
+    def mass_matrix(self):
+        """The system's mass matrix."""
+        return self.method.mass_matrix
+
+    @property
+    def forcing(self):
+        """The system's forcing vector."""
+        return self.method.forcing
+
+    @property
+    def method(self):
+        """Object of method used to form equations of systems."""
+        return self._method
+
+    def _generate_bodylist(self):
+        bodies = []
+        for joint in self._joints:
+            if joint.child not in bodies:
+                bodies.append(joint.child)
+            if joint.parent not in bodies:
+                bodies.append(joint.parent)
+        return bodies
+
+    def _generate_loadlist(self):
+        load_list = []
+        for body in self.bodies:
+            if isinstance(body, Body):
+                load_list.extend(body.loads)
+        return load_list
+
+    def _generate_q(self):
+        q_ind = []
+        for joint in self._joints:
+            for coordinate in joint.coordinates:
+                if coordinate in q_ind:
+                    raise ValueError('Coordinates of joints should be unique.')
+                q_ind.append(coordinate)
+        return Matrix(q_ind)
+
+    def _generate_u(self):
+        u_ind = []
+        for joint in self._joints:
+            for speed in joint.speeds:
+                if speed in u_ind:
+                    raise ValueError('Speeds of joints should be unique.')
+                u_ind.append(speed)
+        return Matrix(u_ind)
+
+    def _generate_kdes(self):
+        kd_ind = Matrix(1, 0, []).T
+        for joint in self._joints:
+            kd_ind = kd_ind.col_join(joint.kdes)
+        return kd_ind
+
+    def _convert_bodies(self):
+        # Convert `Body` to `Particle` and `RigidBody`
+        bodylist = []
+        for body in self.bodies:
+            if not isinstance(body, Body):
+                bodylist.append(body)
+                continue
+            if body.is_rigidbody:
+                rb = RigidBody(body.name, body.masscenter, body.frame, body.mass,
+                    (body.central_inertia, body.masscenter))
+                rb.potential_energy = body.potential_energy
+                bodylist.append(rb)
+            else:
+                part = Particle(body.name, body.masscenter, body.mass)
+                part.potential_energy = body.potential_energy
+                bodylist.append(part)
+        return bodylist
+
+    def form_eoms(self, method=KanesMethod):
+        """Method to form system's equation of motions.
+
+        Parameters
+        ==========
+
+        method : Class
+            Class name of method.
+
+        Returns
+        ========
+
+        Matrix
+            Vector of equations of motions.
+
+        Examples
+        ========
+
+        As Body and JointsMethod have been deprecated, the following examples
+        are for illustrative purposes only. The functionality of Body is fully
+        captured by :class:`~.RigidBody` and :class:`~.Particle` and the
+        functionality of JointsMethod is fully captured by :class:`~.System`. To
+        ignore the deprecation warning we can use the ignore_warnings context
+        manager.
+
+        >>> from sympy.utilities.exceptions import ignore_warnings
+
+        This is a simple example for a one degree of freedom translational
+        spring-mass-damper.
+
+        >>> from sympy import S, symbols
+        >>> from sympy.physics.mechanics import LagrangesMethod, dynamicsymbols, Body
+        >>> from sympy.physics.mechanics import PrismaticJoint, JointsMethod
+        >>> q = dynamicsymbols('q')
+        >>> qd = dynamicsymbols('q', 1)
+        >>> m, k, b = symbols('m k b')
+        >>> with ignore_warnings(DeprecationWarning):
+        ...     wall = Body('W')
+        ...     part = Body('P', mass=m)
+        >>> part.potential_energy = k * q**2 / S(2)
+        >>> J = PrismaticJoint('J', wall, part, coordinates=q, speeds=qd)
+        >>> wall.apply_force(b * qd * wall.x, reaction_body=part)
+        >>> with ignore_warnings(DeprecationWarning):
+        ...     method = JointsMethod(wall, J)
+        >>> method.form_eoms(LagrangesMethod)
+        Matrix([[b*Derivative(q(t), t) + k*q(t) + m*Derivative(q(t), (t, 2))]])
+
+        We can also solve for the states using the 'rhs' method.
+
+        >>> method.rhs()
+        Matrix([
+        [                Derivative(q(t), t)],
+        [(-b*Derivative(q(t), t) - k*q(t))/m]])
+
+        """
+
+        bodylist = self._convert_bodies()
+        if issubclass(method, LagrangesMethod): #LagrangesMethod or similar
+            L = Lagrangian(self.frame, *bodylist)
+            self._method = method(L, self.q, self.loads, bodylist, self.frame)
+        else: #KanesMethod or similar
+            self._method = method(self.frame, q_ind=self.q, u_ind=self.u, kd_eqs=self.kdes,
+                                    forcelist=self.loads, bodies=bodylist)
+        soln = self.method._form_eoms()
+        return soln
+
+    def rhs(self, inv_method=None):
+        """Returns equations that can be solved numerically.
+
+        Parameters
+        ==========
+
+        inv_method : str
+            The specific sympy inverse matrix calculation method to use. For a
+            list of valid methods, see
+            :meth:`~sympy.matrices.matrixbase.MatrixBase.inv`
+
+        Returns
+        ========
+
+        Matrix
+            Numerically solvable equations.
+
+        See Also
+        ========
+
+        sympy.physics.mechanics.kane.KanesMethod.rhs:
+            KanesMethod's rhs function.
+        sympy.physics.mechanics.lagrange.LagrangesMethod.rhs:
+            LagrangesMethod's rhs function.
+
+        """
+
+        return self.method.rhs(inv_method=inv_method)

mplug_owl2/lib/python3.10/site-packages/sympy/physics/mechanics/lagrange.py

@@ -0,0 +1,512 @@
+from sympy import diff, zeros, Matrix, eye, sympify
+from sympy.core.sorting import default_sort_key
+from sympy.physics.vector import dynamicsymbols, ReferenceFrame
+from sympy.physics.mechanics.method import _Methods
+from sympy.physics.mechanics.functions import (
+    find_dynamicsymbols, msubs, _f_list_parser, _validate_coordinates)
+from sympy.physics.mechanics.linearize import Linearizer
+from sympy.utilities.iterables import iterable
+
+__all__ = ['LagrangesMethod']
+
+
+class LagrangesMethod(_Methods):
+    """Lagrange's method object.
+
+    Explanation
+    ===========
+
+    This object generates the equations of motion in a two step procedure. The
+    first step involves the initialization of LagrangesMethod by supplying the
+    Lagrangian and the generalized coordinates, at the bare minimum. If there
+    are any constraint equations, they can be supplied as keyword arguments.
+    The Lagrange multipliers are automatically generated and are equal in
+    number to the constraint equations. Similarly any non-conservative forces
+    can be supplied in an iterable (as described below and also shown in the
+    example) along with a ReferenceFrame. This is also discussed further in the
+    __init__ method.
+
+    Attributes
+    ==========
+
+    q, u : Matrix
+        Matrices of the generalized coordinates and speeds
+    loads : iterable
+        Iterable of (Point, vector) or (ReferenceFrame, vector) tuples
+        describing the forces on the system.
+    bodies : iterable
+        Iterable containing the rigid bodies and particles of the system.
+    mass_matrix : Matrix
+        The system's mass matrix
+    forcing : Matrix
+        The system's forcing vector
+    mass_matrix_full : Matrix
+        The "mass matrix" for the qdot's, qdoubledot's, and the
+        lagrange multipliers (lam)
+    forcing_full : Matrix
+        The forcing vector for the qdot's, qdoubledot's and
+        lagrange multipliers (lam)
+
+    Examples
+    ========
+
+    This is a simple example for a one degree of freedom translational
+    spring-mass-damper.
+
+    In this example, we first need to do the kinematics.
+    This involves creating generalized coordinates and their derivatives.
+    Then we create a point and set its velocity in a frame.
+
+        >>> from sympy.physics.mechanics import LagrangesMethod, Lagrangian
+        >>> from sympy.physics.mechanics import ReferenceFrame, Particle, Point
+        >>> from sympy.physics.mechanics import dynamicsymbols
+        >>> from sympy import symbols
+        >>> q = dynamicsymbols('q')
+        >>> qd = dynamicsymbols('q', 1)
+        >>> m, k, b = symbols('m k b')
+        >>> N = ReferenceFrame('N')
+        >>> P = Point('P')
+        >>> P.set_vel(N, qd * N.x)
+
+    We need to then prepare the information as required by LagrangesMethod to
+    generate equations of motion.
+    First we create the Particle, which has a point attached to it.
+    Following this the lagrangian is created from the kinetic and potential
+    energies.
+    Then, an iterable of nonconservative forces/torques must be constructed,
+    where each item is a (Point, Vector) or (ReferenceFrame, Vector) tuple,
+    with the Vectors representing the nonconservative forces or torques.
+
+        >>> Pa = Particle('Pa', P, m)
+        >>> Pa.potential_energy = k * q**2 / 2.0
+        >>> L = Lagrangian(N, Pa)
+        >>> fl = [(P, -b * qd * N.x)]
+
+    Finally we can generate the equations of motion.
+    First we create the LagrangesMethod object. To do this one must supply
+    the Lagrangian, and the generalized coordinates. The constraint equations,
+    the forcelist, and the inertial frame may also be provided, if relevant.
+    Next we generate Lagrange's equations of motion, such that:
+    Lagrange's equations of motion = 0.
+    We have the equations of motion at this point.
+
+        >>> l = LagrangesMethod(L, [q], forcelist = fl, frame = N)
+        >>> print(l.form_lagranges_equations())
+        Matrix([[b*Derivative(q(t), t) + 1.0*k*q(t) + m*Derivative(q(t), (t, 2))]])
+
+    We can also solve for the states using the 'rhs' method.
+
+        >>> print(l.rhs())
+        Matrix([[Derivative(q(t), t)], [(-b*Derivative(q(t), t) - 1.0*k*q(t))/m]])
+
+    Please refer to the docstrings on each method for more details.
+    """
+
+    def __init__(self, Lagrangian, qs, forcelist=None, bodies=None, frame=None,
+                 hol_coneqs=None, nonhol_coneqs=None):
+        """Supply the following for the initialization of LagrangesMethod.
+
+        Lagrangian : Sympifyable
+
+        qs : array_like
+            The generalized coordinates
+
+        hol_coneqs : array_like, optional
+            The holonomic constraint equations
+
+        nonhol_coneqs : array_like, optional
+            The nonholonomic constraint equations
+
+        forcelist : iterable, optional
+            Takes an iterable of (Point, Vector) or (ReferenceFrame, Vector)
+            tuples which represent the force at a point or torque on a frame.
+            This feature is primarily to account for the nonconservative forces
+            and/or moments.
+
+        bodies : iterable, optional
+            Takes an iterable containing the rigid bodies and particles of the
+            system.
+
+        frame : ReferenceFrame, optional
+            Supply the inertial frame. This is used to determine the
+            generalized forces due to non-conservative forces.
+        """
+
+        self._L = Matrix([sympify(Lagrangian)])
+        self.eom = None
+        self._m_cd = Matrix()           # Mass Matrix of differentiated coneqs
+        self._m_d = Matrix()            # Mass Matrix of dynamic equations
+        self._f_cd = Matrix()           # Forcing part of the diff coneqs
+        self._f_d = Matrix()            # Forcing part of the dynamic equations
+        self.lam_coeffs = Matrix()      # The coeffecients of the multipliers
+
+        forcelist = forcelist if forcelist else []
+        if not iterable(forcelist):
+            raise TypeError('Force pairs must be supplied in an iterable.')
+        self._forcelist = forcelist
+        if frame and not isinstance(frame, ReferenceFrame):
+            raise TypeError('frame must be a valid ReferenceFrame')
+        self._bodies = bodies
+        self.inertial = frame
+
+        self.lam_vec = Matrix()
+
+        self._term1 = Matrix()
+        self._term2 = Matrix()
+        self._term3 = Matrix()
+        self._term4 = Matrix()
+
+        # Creating the qs, qdots and qdoubledots
+        if not iterable(qs):
+            raise TypeError('Generalized coordinates must be an iterable')
+        self._q = Matrix(qs)
+        self._qdots = self.q.diff(dynamicsymbols._t)
+        self._qdoubledots = self._qdots.diff(dynamicsymbols._t)
+        _validate_coordinates(self.q)
+
+        mat_build = lambda x: Matrix(x) if x else Matrix()
+        hol_coneqs = mat_build(hol_coneqs)
+        nonhol_coneqs = mat_build(nonhol_coneqs)
+        self.coneqs = Matrix([hol_coneqs.diff(dynamicsymbols._t),
+                nonhol_coneqs])
+        self._hol_coneqs = hol_coneqs
+
+    def form_lagranges_equations(self):
+        """Method to form Lagrange's equations of motion.
+
+        Returns a vector of equations of motion using Lagrange's equations of
+        the second kind.
+        """
+
+        qds = self._qdots
+        qdd_zero = dict.fromkeys(self._qdoubledots, 0)
+        n = len(self.q)
+
+        # Internally we represent the EOM as four terms:
+        # EOM = term1 - term2 - term3 - term4 = 0
+
+        # First term
+        self._term1 = self._L.jacobian(qds)
+        self._term1 = self._term1.diff(dynamicsymbols._t).T
+
+        # Second term
+        self._term2 = self._L.jacobian(self.q).T
+
+        # Third term
+        if self.coneqs:
+            coneqs = self.coneqs
+            m = len(coneqs)
+            # Creating the multipliers
+            self.lam_vec = Matrix(dynamicsymbols('lam1:' + str(m + 1)))
+            self.lam_coeffs = -coneqs.jacobian(qds)
+            self._term3 = self.lam_coeffs.T * self.lam_vec
+            # Extracting the coeffecients of the qdds from the diff coneqs
+            diffconeqs = coneqs.diff(dynamicsymbols._t)
+            self._m_cd = diffconeqs.jacobian(self._qdoubledots)
+            # The remaining terms i.e. the 'forcing' terms in diff coneqs
+            self._f_cd = -diffconeqs.subs(qdd_zero)
+        else:
+            self._term3 = zeros(n, 1)
+
+        # Fourth term
+        if self.forcelist:
+            N = self.inertial
+            self._term4 = zeros(n, 1)
+            for i, qd in enumerate(qds):
+                flist = zip(*_f_list_parser(self.forcelist, N))
+                self._term4[i] = sum(v.diff(qd, N).dot(f) for (v, f) in flist)
+        else:
+            self._term4 = zeros(n, 1)
+
+        # Form the dynamic mass and forcing matrices
+        without_lam = self._term1 - self._term2 - self._term4
+        self._m_d = without_lam.jacobian(self._qdoubledots)
+        self._f_d = -without_lam.subs(qdd_zero)
+
+        # Form the EOM
+        self.eom = without_lam - self._term3
+        return self.eom
+
+    def _form_eoms(self):
+        return self.form_lagranges_equations()
+
+    @property
+    def mass_matrix(self):
+        """Returns the mass matrix, which is augmented by the Lagrange
+        multipliers, if necessary.
+
+        Explanation
+        ===========
+
+        If the system is described by 'n' generalized coordinates and there are
+        no constraint equations then an n X n matrix is returned.
+
+        If there are 'n' generalized coordinates and 'm' constraint equations
+        have been supplied during initialization then an n X (n+m) matrix is
+        returned. The (n + m - 1)th and (n + m)th columns contain the
+        coefficients of the Lagrange multipliers.
+        """
+
+        if self.eom is None:
+            raise ValueError('Need to compute the equations of motion first')
+        if self.coneqs:
+            return (self._m_d).row_join(self.lam_coeffs.T)
+        else:
+            return self._m_d
+
+    @property
+    def mass_matrix_full(self):
+        """Augments the coefficients of qdots to the mass_matrix."""
+
+        if self.eom is None:
+            raise ValueError('Need to compute the equations of motion first')
+        n = len(self.q)
+        m = len(self.coneqs)
+        row1 = eye(n).row_join(zeros(n, n + m))
+        row2 = zeros(n, n).row_join(self.mass_matrix)
+        if self.coneqs:
+            row3 = zeros(m, n).row_join(self._m_cd).row_join(zeros(m, m))
+            return row1.col_join(row2).col_join(row3)
+        else:
+            return row1.col_join(row2)
+
+    @property
+    def forcing(self):
+        """Returns the forcing vector from 'lagranges_equations' method."""
+
+        if self.eom is None:
+            raise ValueError('Need to compute the equations of motion first')
+        return self._f_d
+
+    @property
+    def forcing_full(self):
+        """Augments qdots to the forcing vector above."""
+
+        if self.eom is None:
+            raise ValueError('Need to compute the equations of motion first')
+        if self.coneqs:
+            return self._qdots.col_join(self.forcing).col_join(self._f_cd)
+        else:
+            return self._qdots.col_join(self.forcing)
+
+    def to_linearizer(self, q_ind=None, qd_ind=None, q_dep=None, qd_dep=None,
+                      linear_solver='LU'):
+        """Returns an instance of the Linearizer class, initiated from the data
+        in the LagrangesMethod class. This may be more desirable than using the
+        linearize class method, as the Linearizer object will allow more
+        efficient recalculation (i.e. about varying operating points).
+
+        Parameters
+        ==========
+
+        q_ind, qd_ind : array_like, optional
+            The independent generalized coordinates and speeds.
+        q_dep, qd_dep : array_like, optional
+            The dependent generalized coordinates and speeds.
+        linear_solver : str, callable
+            Method used to solve the several symbolic linear systems of the
+            form ``A*x=b`` in the linearization process. If a string is
+            supplied, it should be a valid method that can be used with the
+            :meth:`sympy.matrices.matrixbase.MatrixBase.solve`. If a callable is
+            supplied, it should have the format ``x = f(A, b)``, where it
+            solves the equations and returns the solution. The default is
+            ``'LU'`` which corresponds to SymPy's ``A.LUsolve(b)``.
+            ``LUsolve()`` is fast to compute but will often result in
+            divide-by-zero and thus ``nan`` results.
+
+        Returns
+        =======
+        Linearizer
+            An instantiated
+            :class:`sympy.physics.mechanics.linearize.Linearizer`.
+
+        """
+
+        # Compose vectors
+        t = dynamicsymbols._t
+        q = self.q
+        u = self._qdots
+        ud = u.diff(t)
+        # Get vector of lagrange multipliers
+        lams = self.lam_vec
+
+        mat_build = lambda x: Matrix(x) if x else Matrix()
+        q_i = mat_build(q_ind)
+        q_d = mat_build(q_dep)
+        u_i = mat_build(qd_ind)
+        u_d = mat_build(qd_dep)
+
+        # Compose general form equations
+        f_c = self._hol_coneqs
+        f_v = self.coneqs
+        f_a = f_v.diff(t)
+        f_0 = u
+        f_1 = -u
+        f_2 = self._term1
+        f_3 = -(self._term2 + self._term4)
+        f_4 = -self._term3
+
+        # Check that there are an appropriate number of independent and
+        # dependent coordinates
+        if len(q_d) != len(f_c) or len(u_d) != len(f_v):
+            raise ValueError(("Must supply {:} dependent coordinates, and " +
+                    "{:} dependent speeds").format(len(f_c), len(f_v)))
+        if set(Matrix([q_i, q_d])) != set(q):
+            raise ValueError("Must partition q into q_ind and q_dep, with " +
+                    "no extra or missing symbols.")
+        if set(Matrix([u_i, u_d])) != set(u):
+            raise ValueError("Must partition qd into qd_ind and qd_dep, " +
+                    "with no extra or missing symbols.")
+
+        # Find all other dynamic symbols, forming the forcing vector r.
+        # Sort r to make it canonical.
+        insyms = set(Matrix([q, u, ud, lams]))
+        r = list(find_dynamicsymbols(f_3, insyms))
+        r.sort(key=default_sort_key)
+        # Check for any derivatives of variables in r that are also found in r.
+        for i in r:
+            if diff(i, dynamicsymbols._t) in r:
+                raise ValueError('Cannot have derivatives of specified \
+                                 quantities when linearizing forcing terms.')
+
+        return Linearizer(f_0, f_1, f_2, f_3, f_4, f_c, f_v, f_a, q, u, q_i,
+                          q_d, u_i, u_d, r, lams, linear_solver=linear_solver)
+
+    def linearize(self, q_ind=None, qd_ind=None, q_dep=None, qd_dep=None,
+                  linear_solver='LU', **kwargs):
+        """Linearize the equations of motion about a symbolic operating point.
+
+        Parameters
+        ==========
+        linear_solver : str, callable
+            Method used to solve the several symbolic linear systems of the
+            form ``A*x=b`` in the linearization process. If a string is
+            supplied, it should be a valid method that can be used with the
+            :meth:`sympy.matrices.matrixbase.MatrixBase.solve`. If a callable is
+            supplied, it should have the format ``x = f(A, b)``, where it
+            solves the equations and returns the solution. The default is
+            ``'LU'`` which corresponds to SymPy's ``A.LUsolve(b)``.
+            ``LUsolve()`` is fast to compute but will often result in
+            divide-by-zero and thus ``nan`` results.
+        **kwargs
+            Extra keyword arguments are passed to
+            :meth:`sympy.physics.mechanics.linearize.Linearizer.linearize`.
+
+        Explanation
+        ===========
+
+        If kwarg A_and_B is False (default), returns M, A, B, r for the
+        linearized form, M*[q', u']^T = A*[q_ind, u_ind]^T + B*r.
+
+        If kwarg A_and_B is True, returns A, B, r for the linearized form
+        dx = A*x + B*r, where x = [q_ind, u_ind]^T. Note that this is
+        computationally intensive if there are many symbolic parameters. For
+        this reason, it may be more desirable to use the default A_and_B=False,
+        returning M, A, and B. Values may then be substituted in to these
+        matrices, and the state space form found as
+        A = P.T*M.inv()*A, B = P.T*M.inv()*B, where P = Linearizer.perm_mat.
+
+        In both cases, r is found as all dynamicsymbols in the equations of
+        motion that are not part of q, u, q', or u'. They are sorted in
+        canonical form.
+
+        The operating points may be also entered using the ``op_point`` kwarg.
+        This takes a dictionary of {symbol: value}, or a an iterable of such
+        dictionaries. The values may be numeric or symbolic. The more values
+        you can specify beforehand, the faster this computation will run.
+
+        For more documentation, please see the ``Linearizer`` class."""
+
+        linearizer = self.to_linearizer(q_ind, qd_ind, q_dep, qd_dep,
+                                        linear_solver=linear_solver)
+        result = linearizer.linearize(**kwargs)
+        return result + (linearizer.r,)
+
+    def solve_multipliers(self, op_point=None, sol_type='dict'):
+        """Solves for the values of the lagrange multipliers symbolically at
+        the specified operating point.
+
+        Parameters
+        ==========
+
+        op_point : dict or iterable of dicts, optional
+            Point at which to solve at. The operating point is specified as
+            a dictionary or iterable of dictionaries of {symbol: value}. The
+            value may be numeric or symbolic itself.
+
+        sol_type : str, optional
+            Solution return type. Valid options are:
+            - 'dict': A dict of {symbol : value} (default)
+            - 'Matrix': An ordered column matrix of the solution
+        """
+
+        # Determine number of multipliers
+        k = len(self.lam_vec)
+        if k == 0:
+            raise ValueError("System has no lagrange multipliers to solve for.")
+        # Compose dict of operating conditions
+        if isinstance(op_point, dict):
+            op_point_dict = op_point
+        elif iterable(op_point):
+            op_point_dict = {}
+            for op in op_point:
+                op_point_dict.update(op)
+        elif op_point is None:
+            op_point_dict = {}
+        else:
+            raise TypeError("op_point must be either a dictionary or an "
+                            "iterable of dictionaries.")
+        # Compose the system to be solved
+        mass_matrix = self.mass_matrix.col_join(-self.lam_coeffs.row_join(
+                zeros(k, k)))
+        force_matrix = self.forcing.col_join(self._f_cd)
+        # Sub in the operating point
+        mass_matrix = msubs(mass_matrix, op_point_dict)
+        force_matrix = msubs(force_matrix, op_point_dict)
+        # Solve for the multipliers
+        sol_list = mass_matrix.LUsolve(-force_matrix)[-k:]
+        if sol_type == 'dict':
+            return dict(zip(self.lam_vec, sol_list))
+        elif sol_type == 'Matrix':
+            return Matrix(sol_list)
+        else:
+            raise ValueError("Unknown sol_type {:}.".format(sol_type))
+
+    def rhs(self, inv_method=None, **kwargs):
+        """Returns equations that can be solved numerically.
+
+        Parameters
+        ==========
+
+        inv_method : str
+            The specific sympy inverse matrix calculation method to use. For a
+            list of valid methods, see
+            :meth:`~sympy.matrices.matrixbase.MatrixBase.inv`
+        """
+
+        if inv_method is None:
+            self._rhs = self.mass_matrix_full.LUsolve(self.forcing_full)
+        else:
+            self._rhs = (self.mass_matrix_full.inv(inv_method,
+                         try_block_diag=True) * self.forcing_full)
+        return self._rhs
+
+    @property
+    def q(self):
+        return self._q
+
+    @property
+    def u(self):
+        return self._qdots
+
+    @property
+    def bodies(self):
+        return self._bodies
+
+    @property
+    def forcelist(self):
+        return self._forcelist
+
+    @property
+    def loads(self):
+        return self._forcelist

mplug_owl2/lib/python3.10/site-packages/sympy/physics/mechanics/loads.py

@@ -0,0 +1,177 @@
+from abc import ABC
+from collections import namedtuple
+from sympy.physics.mechanics.body_base import BodyBase
+from sympy.physics.vector import Vector, ReferenceFrame, Point
+
+__all__ = ['LoadBase', 'Force', 'Torque']
+
+
+class LoadBase(ABC, namedtuple('LoadBase', ['location', 'vector'])):
+    """Abstract base class for the various loading types."""
+
+    def __add__(self, other):
+        raise TypeError(f"unsupported operand type(s) for +: "
+                        f"'{self.__class__.__name__}' and "
+                        f"'{other.__class__.__name__}'")
+
+    def __mul__(self, other):
+        raise TypeError(f"unsupported operand type(s) for *: "
+                        f"'{self.__class__.__name__}' and "
+                        f"'{other.__class__.__name__}'")
+
+    __radd__ = __add__
+    __rmul__ = __mul__
+
+
+class Force(LoadBase):
+    """Force acting upon a point.
+
+    Explanation
+    ===========
+
+    A force is a vector that is bound to a line of action. This class stores
+    both a point, which lies on the line of action, and the vector. A tuple can
+    also be used, with the location as the first entry and the vector as second
+    entry.
+
+    Examples
+    ========
+
+    A force of magnitude 2 along N.x acting on a point Po can be created as
+    follows:
+
+    >>> from sympy.physics.mechanics import Point, ReferenceFrame, Force
+    >>> N = ReferenceFrame('N')
+    >>> Po = Point('Po')
+    >>> Force(Po, 2 * N.x)
+    (Po, 2*N.x)
+
+    If a body is supplied, then the center of mass of that body is used.
+
+    >>> from sympy.physics.mechanics import Particle
+    >>> P = Particle('P', point=Po)
+    >>> Force(P, 2 * N.x)
+    (Po, 2*N.x)
+
+    """
+
+    def __new__(cls, point, force):
+        if isinstance(point, BodyBase):
+            point = point.masscenter
+        if not isinstance(point, Point):
+            raise TypeError('Force location should be a Point.')
+        if not isinstance(force, Vector):
+            raise TypeError('Force vector should be a Vector.')
+        return super().__new__(cls, point, force)
+
+    def __repr__(self):
+        return (f'{self.__class__.__name__}(point={self.point}, '
+                f'force={self.force})')
+
+    @property
+    def point(self):
+        return self.location
+
+    @property
+    def force(self):
+        return self.vector
+
+
+class Torque(LoadBase):
+    """Torque acting upon a frame.
+
+    Explanation
+    ===========
+
+    A torque is a free vector that is acting on a reference frame, which is
+    associated with a rigid body. This class stores both the frame and the
+    vector. A tuple can also be used, with the location as the first item and
+    the vector as second item.
+
+    Examples
+    ========
+
+    A torque of magnitude 2 about N.x acting on a frame N can be created as
+    follows:
+
+    >>> from sympy.physics.mechanics import ReferenceFrame, Torque
+    >>> N = ReferenceFrame('N')
+    >>> Torque(N, 2 * N.x)
+    (N, 2*N.x)
+
+    If a body is supplied, then the frame fixed to that body is used.
+
+    >>> from sympy.physics.mechanics import RigidBody
+    >>> rb = RigidBody('rb', frame=N)
+    >>> Torque(rb, 2 * N.x)
+    (N, 2*N.x)
+
+    """
+
+    def __new__(cls, frame, torque):
+        if isinstance(frame, BodyBase):
+            frame = frame.frame
+        if not isinstance(frame, ReferenceFrame):
+            raise TypeError('Torque location should be a ReferenceFrame.')
+        if not isinstance(torque, Vector):
+            raise TypeError('Torque vector should be a Vector.')
+        return super().__new__(cls, frame, torque)
+
+    def __repr__(self):
+        return (f'{self.__class__.__name__}(frame={self.frame}, '
+                f'torque={self.torque})')
+
+    @property
+    def frame(self):
+        return self.location
+
+    @property
+    def torque(self):
+        return self.vector
+
+
+def gravity(acceleration, *bodies):
+    """
+    Returns a list of gravity forces given the acceleration
+    due to gravity and any number of particles or rigidbodies.
+
+    Example
+    =======
+
+    >>> from sympy.physics.mechanics import ReferenceFrame, Particle, RigidBody
+    >>> from sympy.physics.mechanics.loads import gravity
+    >>> from sympy import symbols
+    >>> N = ReferenceFrame('N')
+    >>> g = symbols('g')
+    >>> P = Particle('P')
+    >>> B = RigidBody('B')
+    >>> gravity(g*N.y, P, B)
+    [(P_masscenter, P_mass*g*N.y),
+     (B_masscenter, B_mass*g*N.y)]
+
+    """
+
+    gravity_force = []
+    for body in bodies:
+        if not isinstance(body, BodyBase):
+            raise TypeError(f'{type(body)} is not a body type')
+        gravity_force.append(Force(body.masscenter, body.mass * acceleration))
+    return gravity_force
+
+
+def _parse_load(load):
+    """Helper function to parse loads and convert tuples to load objects."""
+    if isinstance(load, LoadBase):
+        return load
+    elif isinstance(load, tuple):
+        if len(load) != 2:
+            raise ValueError(f'Load {load} should have a length of 2.')
+        if isinstance(load[0], Point):
+            return Force(load[0], load[1])
+        elif isinstance(load[0], ReferenceFrame):
+            return Torque(load[0], load[1])
+        else:
+            raise ValueError(f'Load not recognized. The load location {load[0]}'
+                             f' should either be a Point or a ReferenceFrame.')
+    raise TypeError(f'Load type {type(load)} not recognized as a load. It '
+                    f'should be a Force, Torque or tuple.')

mplug_owl2/lib/python3.10/site-packages/sympy/physics/mechanics/method.py

@@ -0,0 +1,39 @@
+from abc import ABC, abstractmethod
+
+class _Methods(ABC):
+    """Abstract Base Class for all methods."""
+
+    @abstractmethod
+    def q(self):
+        pass
+
+    @abstractmethod
+    def u(self):
+        pass
+
+    @abstractmethod
+    def bodies(self):
+        pass
+
+    @abstractmethod
+    def loads(self):
+        pass
+
+    @abstractmethod
+    def mass_matrix(self):
+        pass
+
+    @abstractmethod
+    def forcing(self):
+        pass
+
+    @abstractmethod
+    def mass_matrix_full(self):
+        pass
+
+    @abstractmethod
+    def forcing_full(self):
+        pass
+
+    def _form_eoms(self):
+        raise NotImplementedError("Subclasses must implement this.")

mplug_owl2/lib/python3.10/site-packages/sympy/physics/mechanics/models.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python
+"""This module contains some sample symbolic models used for testing and
+examples."""
+
+# Internal imports
+from sympy.core import backend as sm
+import sympy.physics.mechanics as me
+
+
+def multi_mass_spring_damper(n=1, apply_gravity=False,
+                             apply_external_forces=False):
+    r"""Returns a system containing the symbolic equations of motion and
+    associated variables for a simple multi-degree of freedom point mass,
+    spring, damper system with optional gravitational and external
+    specified forces. For example, a two mass system under the influence of
+    gravity and external forces looks like:
+
+    ::
+
+        ----------------
+         |     |     |   | g
+         \    | |    |   V
+      k0 /    --- c0 |
+         |     |     | x0, v0
+        ---------    V
+        |  m0   | -----
+        ---------    |
+         | |   |     |
+         \ v  | |    |
+      k1 / f0 --- c1 |
+         |     |     | x1, v1
+        ---------    V
+        |  m1   | -----
+        ---------
+           | f1
+           V
+
+    Parameters
+    ==========
+
+    n : integer
+        The number of masses in the serial chain.
+    apply_gravity : boolean
+        If true, gravity will be applied to each mass.
+    apply_external_forces : boolean
+        If true, a time varying external force will be applied to each mass.
+
+    Returns
+    =======
+
+    kane : sympy.physics.mechanics.kane.KanesMethod
+        A KanesMethod object.
+
+    """
+
+    mass = sm.symbols('m:{}'.format(n))
+    stiffness = sm.symbols('k:{}'.format(n))
+    damping = sm.symbols('c:{}'.format(n))
+
+    acceleration_due_to_gravity = sm.symbols('g')
+
+    coordinates = me.dynamicsymbols('x:{}'.format(n))
+    speeds = me.dynamicsymbols('v:{}'.format(n))
+    specifieds = me.dynamicsymbols('f:{}'.format(n))
+
+    ceiling = me.ReferenceFrame('N')
+    origin = me.Point('origin')
+    origin.set_vel(ceiling, 0)
+
+    points = [origin]
+    kinematic_equations = []
+    particles = []
+    forces = []
+
+    for i in range(n):
+
+        center = points[-1].locatenew('center{}'.format(i),
+                                      coordinates[i] * ceiling.x)
+        center.set_vel(ceiling, points[-1].vel(ceiling) +
+                       speeds[i] * ceiling.x)
+        points.append(center)
+
+        block = me.Particle('block{}'.format(i), center, mass[i])
+
+        kinematic_equations.append(speeds[i] - coordinates[i].diff())
+
+        total_force = (-stiffness[i] * coordinates[i] -
+                       damping[i] * speeds[i])
+        try:
+            total_force += (stiffness[i + 1] * coordinates[i + 1] +
+                            damping[i + 1] * speeds[i + 1])
+        except IndexError:  # no force from below on last mass
+            pass
+
+        if apply_gravity:
+            total_force += mass[i] * acceleration_due_to_gravity
+
+        if apply_external_forces:
+            total_force += specifieds[i]
+
+        forces.append((center, total_force * ceiling.x))
+
+        particles.append(block)
+
+    kane = me.KanesMethod(ceiling, q_ind=coordinates, u_ind=speeds,
+                          kd_eqs=kinematic_equations)
+    kane.kanes_equations(particles, forces)
+
+    return kane
+
+
+def n_link_pendulum_on_cart(n=1, cart_force=True, joint_torques=False):
+    r"""Returns the system containing the symbolic first order equations of
+    motion for a 2D n-link pendulum on a sliding cart under the influence of
+    gravity.
+
+    ::
+
+                  |
+         o    y   v
+          \ 0 ^   g
+           \  |
+          --\-|----
+          |  \|   |
+      F-> |   o --|---> x
+          |       |
+          ---------
+           o     o
+
+    Parameters
+    ==========
+
+    n : integer
+        The number of links in the pendulum.
+    cart_force : boolean, default=True
+        If true an external specified lateral force is applied to the cart.
+    joint_torques : boolean, default=False
+        If true joint torques will be added as specified inputs at each
+        joint.
+
+    Returns
+    =======
+
+    kane : sympy.physics.mechanics.kane.KanesMethod
+        A KanesMethod object.
+
+    Notes
+    =====
+
+    The degrees of freedom of the system are n + 1, i.e. one for each
+    pendulum link and one for the lateral motion of the cart.
+
+    M x' = F, where x = [u0, ..., un+1, q0, ..., qn+1]
+
+    The joint angles are all defined relative to the ground where the x axis
+    defines the ground line and the y axis points up. The joint torques are
+    applied between each adjacent link and the between the cart and the
+    lower link where a positive torque corresponds to positive angle.
+
+    """
+    if n <= 0:
+        raise ValueError('The number of links must be a positive integer.')
+
+    q = me.dynamicsymbols('q:{}'.format(n + 1))
+    u = me.dynamicsymbols('u:{}'.format(n + 1))
+
+    if joint_torques is True:
+        T = me.dynamicsymbols('T1:{}'.format(n + 1))
+
+    m = sm.symbols('m:{}'.format(n + 1))
+    l = sm.symbols('l:{}'.format(n))
+    g, t = sm.symbols('g t')
+
+    I = me.ReferenceFrame('I')
+    O = me.Point('O')
+    O.set_vel(I, 0)
+
+    P0 = me.Point('P0')
+    P0.set_pos(O, q[0] * I.x)
+    P0.set_vel(I, u[0] * I.x)
+    Pa0 = me.Particle('Pa0', P0, m[0])
+
+    frames = [I]
+    points = [P0]
+    particles = [Pa0]
+    forces = [(P0, -m[0] * g * I.y)]
+    kindiffs = [q[0].diff(t) - u[0]]
+
+    if cart_force is True or joint_torques is True:
+        specified = []
+    else:
+        specified = None
+
+    for i in range(n):
+        Bi = I.orientnew('B{}'.format(i), 'Axis', [q[i + 1], I.z])
+        Bi.set_ang_vel(I, u[i + 1] * I.z)
+        frames.append(Bi)
+
+        Pi = points[-1].locatenew('P{}'.format(i + 1), l[i] * Bi.y)
+        Pi.v2pt_theory(points[-1], I, Bi)
+        points.append(Pi)
+
+        Pai = me.Particle('Pa' + str(i + 1), Pi, m[i + 1])
+        particles.append(Pai)
+
+        forces.append((Pi, -m[i + 1] * g * I.y))
+
+        if joint_torques is True:
+
+            specified.append(T[i])
+
+            if i == 0:
+                forces.append((I, -T[i] * I.z))
+
+            if i == n - 1:
+                forces.append((Bi, T[i] * I.z))
+            else:
+                forces.append((Bi, T[i] * I.z - T[i + 1] * I.z))
+
+        kindiffs.append(q[i + 1].diff(t) - u[i + 1])
+
+    if cart_force is True:
+        F = me.dynamicsymbols('F')
+        forces.append((P0, F * I.x))
+        specified.append(F)
+
+    kane = me.KanesMethod(I, q_ind=q, u_ind=u, kd_eqs=kindiffs)
+    kane.kanes_equations(particles, forces)
+
+    return kane

mplug_owl2/lib/python3.10/site-packages/sympy/physics/mechanics/particle.py

@@ -0,0 +1,209 @@
+from sympy import S
+from sympy.physics.vector import cross, dot
+from sympy.physics.mechanics.body_base import BodyBase
+from sympy.physics.mechanics.inertia import inertia_of_point_mass
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+__all__ = ['Particle']
+
+
+class Particle(BodyBase):
+    """A particle.
+
+    Explanation
+    ===========
+
+    Particles have a non-zero mass and lack spatial extension; they take up no
+    space.
+
+    Values need to be supplied on initialization, but can be changed later.
+
+    Parameters
+    ==========
+
+    name : str
+        Name of particle
+    point : Point
+        A physics/mechanics Point which represents the position, velocity, and
+        acceleration of this Particle
+    mass : Sympifyable
+        A SymPy expression representing the Particle's mass
+    potential_energy : Sympifyable
+        The potential energy of the Particle.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.mechanics import Particle, Point
+    >>> from sympy import Symbol
+    >>> po = Point('po')
+    >>> m = Symbol('m')
+    >>> pa = Particle('pa', po, m)
+    >>> # Or you could change these later
+    >>> pa.mass = m
+    >>> pa.point = po
+
+    """
+    point = BodyBase.masscenter
+
+    def __init__(self, name, point=None, mass=None):
+        super().__init__(name, point, mass)
+
+    def linear_momentum(self, frame):
+        """Linear momentum of the particle.
+
+        Explanation
+        ===========
+
+        The linear momentum L, of a particle P, with respect to frame N is
+        given by:
+
+        L = m * v
+
+        where m is the mass of the particle, and v is the velocity of the
+        particle in the frame N.
+
+        Parameters
+        ==========
+
+        frame : ReferenceFrame
+            The frame in which linear momentum is desired.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.mechanics import Particle, Point, ReferenceFrame
+        >>> from sympy.physics.mechanics import dynamicsymbols
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> m, v = dynamicsymbols('m v')
+        >>> N = ReferenceFrame('N')
+        >>> P = Point('P')
+        >>> A = Particle('A', P, m)
+        >>> P.set_vel(N, v * N.x)
+        >>> A.linear_momentum(N)
+        m*v*N.x
+
+        """
+
+        return self.mass * self.point.vel(frame)
+
+    def angular_momentum(self, point, frame):
+        """Angular momentum of the particle about the point.
+
+        Explanation
+        ===========
+
+        The angular momentum H, about some point O of a particle, P, is given
+        by:
+
+        ``H = cross(r, m * v)``
+
+        where r is the position vector from point O to the particle P, m is
+        the mass of the particle, and v is the velocity of the particle in
+        the inertial frame, N.
+
+        Parameters
+        ==========
+
+        point : Point
+            The point about which angular momentum of the particle is desired.
+
+        frame : ReferenceFrame
+            The frame in which angular momentum is desired.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.mechanics import Particle, Point, ReferenceFrame
+        >>> from sympy.physics.mechanics import dynamicsymbols
+        >>> from sympy.physics.vector import init_vprinting
+        >>> init_vprinting(pretty_print=False)
+        >>> m, v, r = dynamicsymbols('m v r')
+        >>> N = ReferenceFrame('N')
+        >>> O = Point('O')
+        >>> A = O.locatenew('A', r * N.x)
+        >>> P = Particle('P', A, m)
+        >>> P.point.set_vel(N, v * N.y)
+        >>> P.angular_momentum(O, N)
+        m*r*v*N.z
+
+        """
+
+        return cross(self.point.pos_from(point),
+                     self.mass * self.point.vel(frame))
+
+    def kinetic_energy(self, frame):
+        """Kinetic energy of the particle.
+
+        Explanation
+        ===========
+
+        The kinetic energy, T, of a particle, P, is given by:
+
+        ``T = 1/2 (dot(m * v, v))``
+
+        where m is the mass of particle P, and v is the velocity of the
+        particle in the supplied ReferenceFrame.
+
+        Parameters
+        ==========
+
+        frame : ReferenceFrame
+            The Particle's velocity is typically defined with respect to
+            an inertial frame but any relevant frame in which the velocity is
+            known can be supplied.
+
+        Examples
+        ========
+
+        >>> from sympy.physics.mechanics import Particle, Point, ReferenceFrame
+        >>> from sympy import symbols
+        >>> m, v, r = symbols('m v r')
+        >>> N = ReferenceFrame('N')
+        >>> O = Point('O')
+        >>> P = Particle('P', O, m)
+        >>> P.point.set_vel(N, v * N.y)
+        >>> P.kinetic_energy(N)
+        m*v**2/2
+
+        """
+
+        return S.Half * self.mass * dot(self.point.vel(frame),
+                                        self.point.vel(frame))
+
+    def set_potential_energy(self, scalar):
+        sympy_deprecation_warning(
+            """
+The sympy.physics.mechanics.Particle.set_potential_energy()
+method is deprecated. Instead use
+
+    P.potential_energy = scalar
+            """,
+        deprecated_since_version="1.5",
+        active_deprecations_target="deprecated-set-potential-energy",
+        )
+        self.potential_energy = scalar
+
+    def parallel_axis(self, point, frame):
+        """Returns an inertia dyadic of the particle with respect to another
+        point and frame.
+
+        Parameters
+        ==========
+
+        point : sympy.physics.vector.Point
+            The point to express the inertia dyadic about.
+        frame : sympy.physics.vector.ReferenceFrame
+            The reference frame used to construct the dyadic.
+
+        Returns
+        =======
+
+        inertia : sympy.physics.vector.Dyadic
+            The inertia dyadic of the particle expressed about the provided
+            point and frame.
+
+        """
+        return inertia_of_point_mass(self.mass, self.point.pos_from(point),
+                                     frame)

mplug_owl2/lib/python3.10/site-packages/sympy/physics/mechanics/pathway.py

@@ -0,0 +1,688 @@
+"""Implementations of pathways for use by actuators."""
+
+from abc import ABC, abstractmethod
+
+from sympy.core.singleton import S
+from sympy.physics.mechanics.loads import Force
+from sympy.physics.mechanics.wrapping_geometry import WrappingGeometryBase
+from sympy.physics.vector import Point, dynamicsymbols
+
+
+__all__ = ['PathwayBase', 'LinearPathway', 'ObstacleSetPathway',
+           'WrappingPathway']
+
+
+class PathwayBase(ABC):
+    """Abstract base class for all pathway classes to inherit from.
+
+    Notes
+    =====
+
+    Instances of this class cannot be directly instantiated by users. However,
+    it can be used to created custom pathway types through subclassing.
+
+    """
+
+    def __init__(self, *attachments):
+        """Initializer for ``PathwayBase``."""
+        self.attachments = attachments
+
+    @property
+    def attachments(self):
+        """The pair of points defining a pathway's ends."""
+        return self._attachments
+
+    @attachments.setter
+    def attachments(self, attachments):
+        if hasattr(self, '_attachments'):
+            msg = (
+                f'Can\'t set attribute `attachments` to {repr(attachments)} '
+                f'as it is immutable.'
+            )
+            raise AttributeError(msg)
+        if len(attachments) != 2:
+            msg = (
+                f'Value {repr(attachments)} passed to `attachments` was an '
+                f'iterable of length {len(attachments)}, must be an iterable '
+                f'of length 2.'
+            )
+            raise ValueError(msg)
+        for i, point in enumerate(attachments):
+            if not isinstance(point, Point):
+                msg = (
+                    f'Value {repr(point)} passed to `attachments` at index '
+                    f'{i} was of type {type(point)}, must be {Point}.'
+                )
+                raise TypeError(msg)
+        self._attachments = tuple(attachments)
+
+    @property
+    @abstractmethod
+    def length(self):
+        """An expression representing the pathway's length."""
+        pass
+
+    @property
+    @abstractmethod
+    def extension_velocity(self):
+        """An expression representing the pathway's extension velocity."""
+        pass
+
+    @abstractmethod
+    def to_loads(self, force):
+        """Loads required by the equations of motion method classes.
+
+        Explanation
+        ===========
+
+        ``KanesMethod`` requires a list of ``Point``-``Vector`` tuples to be
+        passed to the ``loads`` parameters of its ``kanes_equations`` method
+        when constructing the equations of motion. This method acts as a
+        utility to produce the correctly-structred pairs of points and vectors
+        required so that these can be easily concatenated with other items in
+        the list of loads and passed to ``KanesMethod.kanes_equations``. These
+        loads are also in the correct form to also be passed to the other
+        equations of motion method classes, e.g. ``LagrangesMethod``.
+
+        """
+        pass
+
+    def __repr__(self):
+        """Default representation of a pathway."""
+        attachments = ', '.join(str(a) for a in self.attachments)
+        return f'{self.__class__.__name__}({attachments})'
+
+
+class LinearPathway(PathwayBase):
+    """Linear pathway between a pair of attachment points.
+
+    Explanation
+    ===========
+
+    A linear pathway forms a straight-line segment between two points and is
+    the simplest pathway that can be formed. It will not interact with any
+    other objects in the system, i.e. a ``LinearPathway`` will intersect other
+    objects to ensure that the path between its two ends (its attachments) is
+    the shortest possible.
+
+    A linear pathway is made up of two points that can move relative to each
+    other, and a pair of equal and opposite forces acting on the points. If the
+    positive time-varying Euclidean distance between the two points is defined,
+    then the "extension velocity" is the time derivative of this distance. The
+    extension velocity is positive when the two points are moving away from
+    each other and negative when moving closer to each other. The direction for
+    the force acting on either point is determined by constructing a unit
+    vector directed from the other point to this point. This establishes a sign
+    convention such that a positive force magnitude tends to push the points
+    apart. The following diagram shows the positive force sense and the
+    distance between the points::
+
+       P           Q
+       o<--- F --->o
+       |           |
+       |<--l(t)--->|
+
+    Examples
+    ========
+
+    >>> from sympy.physics.mechanics import LinearPathway
+
+    To construct a pathway, two points are required to be passed to the
+    ``attachments`` parameter as a ``tuple``.
+
+    >>> from sympy.physics.mechanics import Point
+    >>> pA, pB = Point('pA'), Point('pB')
+    >>> linear_pathway = LinearPathway(pA, pB)
+    >>> linear_pathway
+    LinearPathway(pA, pB)
+
+    The pathway created above isn't very interesting without the positions and
+    velocities of its attachment points being described. Without this its not
+    possible to describe how the pathway moves, i.e. its length or its
+    extension velocity.
+
+    >>> from sympy.physics.mechanics import ReferenceFrame
+    >>> from sympy.physics.vector import dynamicsymbols
+    >>> N = ReferenceFrame('N')
+    >>> q = dynamicsymbols('q')
+    >>> pB.set_pos(pA, q*N.x)
+    >>> pB.pos_from(pA)
+    q(t)*N.x
+
+    A pathway's length can be accessed via its ``length`` attribute.
+
+    >>> linear_pathway.length
+    sqrt(q(t)**2)
+
+    Note how what appears to be an overly-complex expression is returned. This
+    is actually required as it ensures that a pathway's length is always
+    positive.
+
+    A pathway's extension velocity can be accessed similarly via its
+    ``extension_velocity`` attribute.
+
+    >>> linear_pathway.extension_velocity
+    sqrt(q(t)**2)*Derivative(q(t), t)/q(t)
+
+    Parameters
+    ==========
+
+    attachments : tuple[Point, Point]
+        Pair of ``Point`` objects between which the linear pathway spans.
+        Constructor expects two points to be passed, e.g.
+        ``LinearPathway(Point('pA'), Point('pB'))``. More or fewer points will
+        cause an error to be thrown.
+
+    """
+
+    def __init__(self, *attachments):
+        """Initializer for ``LinearPathway``.
+
+        Parameters
+        ==========
+
+        attachments : Point
+            Pair of ``Point`` objects between which the linear pathway spans.
+            Constructor expects two points to be passed, e.g.
+            ``LinearPathway(Point('pA'), Point('pB'))``. More or fewer points
+            will cause an error to be thrown.
+
+        """
+        super().__init__(*attachments)
+
+    @property
+    def length(self):
+        """Exact analytical expression for the pathway's length."""
+        return _point_pair_length(*self.attachments)
+
+    @property
+    def extension_velocity(self):
+        """Exact analytical expression for the pathway's extension velocity."""
+        return _point_pair_extension_velocity(*self.attachments)
+
+    def to_loads(self, force):
+        """Loads required by the equations of motion method classes.
+
+        Explanation
+        ===========
+
+        ``KanesMethod`` requires a list of ``Point``-``Vector`` tuples to be
+        passed to the ``loads`` parameters of its ``kanes_equations`` method
+        when constructing the equations of motion. This method acts as a
+        utility to produce the correctly-structred pairs of points and vectors
+        required so that these can be easily concatenated with other items in
+        the list of loads and passed to ``KanesMethod.kanes_equations``. These
+        loads are also in the correct form to also be passed to the other
+        equations of motion method classes, e.g. ``LagrangesMethod``.
+
+        Examples
+        ========
+
+        The below example shows how to generate the loads produced in a linear
+        actuator that produces an expansile force ``F``. First, create a linear
+        actuator between two points separated by the coordinate ``q`` in the
+        ``x`` direction of the global frame ``N``.
+
+        >>> from sympy.physics.mechanics import (LinearPathway, Point,
+        ...     ReferenceFrame)
+        >>> from sympy.physics.vector import dynamicsymbols
+        >>> q = dynamicsymbols('q')
+        >>> N = ReferenceFrame('N')
+        >>> pA, pB = Point('pA'), Point('pB')
+        >>> pB.set_pos(pA, q*N.x)
+        >>> linear_pathway = LinearPathway(pA, pB)
+
+        Now create a symbol ``F`` to describe the magnitude of the (expansile)
+        force that will be produced along the pathway. The list of loads that
+        ``KanesMethod`` requires can be produced by calling the pathway's
+        ``to_loads`` method with ``F`` passed as the only argument.
+
+        >>> from sympy import symbols
+        >>> F = symbols('F')
+        >>> linear_pathway.to_loads(F)
+        [(pA, - F*q(t)/sqrt(q(t)**2)*N.x), (pB, F*q(t)/sqrt(q(t)**2)*N.x)]
+
+        Parameters
+        ==========
+
+        force : Expr
+            Magnitude of the force acting along the length of the pathway. As
+            per the sign conventions for the pathway length, pathway extension
+            velocity, and pair of point forces, if this ``Expr`` is positive
+            then the force will act to push the pair of points away from one
+            another (it is expansile).
+
+        """
+        relative_position = _point_pair_relative_position(*self.attachments)
+        loads = [
+            Force(self.attachments[0], -force*relative_position/self.length),
+            Force(self.attachments[-1], force*relative_position/self.length),
+        ]
+        return loads
+
+
+class ObstacleSetPathway(PathwayBase):
+    """Obstacle-set pathway between a set of attachment points.
+
+    Explanation
+    ===========
+
+    An obstacle-set pathway forms a series of straight-line segment between
+    pairs of consecutive points in a set of points. It is similiar to multiple
+    linear pathways joined end-to-end. It will not interact with any other
+    objects in the system, i.e. an ``ObstacleSetPathway`` will intersect other
+    objects to ensure that the path between its pairs of points (its
+    attachments) is the shortest possible.
+
+    Examples
+    ========
+
+    To construct an obstacle-set pathway, three or more points are required to
+    be passed to the ``attachments`` parameter as a ``tuple``.
+
+    >>> from sympy.physics.mechanics import ObstacleSetPathway, Point
+    >>> pA, pB, pC, pD = Point('pA'), Point('pB'), Point('pC'), Point('pD')
+    >>> obstacle_set_pathway = ObstacleSetPathway(pA, pB, pC, pD)
+    >>> obstacle_set_pathway
+    ObstacleSetPathway(pA, pB, pC, pD)
+
+    The pathway created above isn't very interesting without the positions and
+    velocities of its attachment points being described. Without this its not
+    possible to describe how the pathway moves, i.e. its length or its
+    extension velocity.
+
+    >>> from sympy import cos, sin
+    >>> from sympy.physics.mechanics import ReferenceFrame
+    >>> from sympy.physics.vector import dynamicsymbols
+    >>> N = ReferenceFrame('N')
+    >>> q = dynamicsymbols('q')
+    >>> pO = Point('pO')
+    >>> pA.set_pos(pO, N.y)
+    >>> pB.set_pos(pO, -N.x)
+    >>> pC.set_pos(pA, cos(q) * N.x - (sin(q) + 1) * N.y)
+    >>> pD.set_pos(pA, sin(q) * N.x + (cos(q) - 1) * N.y)
+    >>> pB.pos_from(pA)
+    - N.x - N.y
+    >>> pC.pos_from(pA)
+    cos(q(t))*N.x + (-sin(q(t)) - 1)*N.y
+    >>> pD.pos_from(pA)
+    sin(q(t))*N.x + (cos(q(t)) - 1)*N.y
+
+    A pathway's length can be accessed via its ``length`` attribute.
+
+    >>> obstacle_set_pathway.length.simplify()
+    sqrt(2)*(sqrt(cos(q(t)) + 1) + 2)
+
+    A pathway's extension velocity can be accessed similarly via its
+    ``extension_velocity`` attribute.
+
+    >>> obstacle_set_pathway.extension_velocity.simplify()
+    -sqrt(2)*sin(q(t))*Derivative(q(t), t)/(2*sqrt(cos(q(t)) + 1))
+
+    Parameters
+    ==========
+
+    attachments : tuple[Point, Point]
+        The set of ``Point`` objects that define the segmented obstacle-set
+        pathway.
+
+    """
+
+    def __init__(self, *attachments):
+        """Initializer for ``ObstacleSetPathway``.
+
+        Parameters
+        ==========
+
+        attachments : tuple[Point, ...]
+            The set of ``Point`` objects that define the segmented obstacle-set
+            pathway.
+
+        """
+        super().__init__(*attachments)
+
+    @property
+    def attachments(self):
+        """The set of points defining a pathway's segmented path."""
+        return self._attachments
+
+    @attachments.setter
+    def attachments(self, attachments):
+        if hasattr(self, '_attachments'):
+            msg = (
+                f'Can\'t set attribute `attachments` to {repr(attachments)} '
+                f'as it is immutable.'
+            )
+            raise AttributeError(msg)
+        if len(attachments) <= 2:
+            msg = (
+                f'Value {repr(attachments)} passed to `attachments` was an '
+                f'iterable of length {len(attachments)}, must be an iterable '
+                f'of length 3 or greater.'
+            )
+            raise ValueError(msg)
+        for i, point in enumerate(attachments):
+            if not isinstance(point, Point):
+                msg = (
+                    f'Value {repr(point)} passed to `attachments` at index '
+                    f'{i} was of type {type(point)}, must be {Point}.'
+                )
+                raise TypeError(msg)
+        self._attachments = tuple(attachments)
+
+    @property
+    def length(self):
+        """Exact analytical expression for the pathway's length."""
+        length = S.Zero
+        attachment_pairs = zip(self.attachments[:-1], self.attachments[1:])
+        for attachment_pair in attachment_pairs:
+            length += _point_pair_length(*attachment_pair)
+        return length
+
+    @property
+    def extension_velocity(self):
+        """Exact analytical expression for the pathway's extension velocity."""
+        extension_velocity = S.Zero
+        attachment_pairs = zip(self.attachments[:-1], self.attachments[1:])
+        for attachment_pair in attachment_pairs:
+            extension_velocity += _point_pair_extension_velocity(*attachment_pair)
+        return extension_velocity
+
+    def to_loads(self, force):
+        """Loads required by the equations of motion method classes.
+
+        Explanation
+        ===========
+
+        ``KanesMethod`` requires a list of ``Point``-``Vector`` tuples to be
+        passed to the ``loads`` parameters of its ``kanes_equations`` method
+        when constructing the equations of motion. This method acts as a
+        utility to produce the correctly-structred pairs of points and vectors
+        required so that these can be easily concatenated with other items in
+        the list of loads and passed to ``KanesMethod.kanes_equations``. These
+        loads are also in the correct form to also be passed to the other
+        equations of motion method classes, e.g. ``LagrangesMethod``.
+
+        Examples
+        ========
+
+        The below example shows how to generate the loads produced in an
+        actuator that follows an obstacle-set pathway between four points and
+        produces an expansile force ``F``. First, create a pair of reference
+        frames, ``A`` and ``B``, in which the four points ``pA``, ``pB``,
+        ``pC``, and ``pD`` will be located. The first two points in frame ``A``
+        and the second two in frame ``B``. Frame ``B`` will also be oriented
+        such that it relates to ``A`` via a rotation of ``q`` about an axis
+        ``N.z`` in a global frame (``N.z``, ``A.z``, and ``B.z`` are parallel).
+
+        >>> from sympy.physics.mechanics import (ObstacleSetPathway, Point,
+        ...     ReferenceFrame)
+        >>> from sympy.physics.vector import dynamicsymbols
+        >>> q = dynamicsymbols('q')
+        >>> N = ReferenceFrame('N')
+        >>> N = ReferenceFrame('N')
+        >>> A = N.orientnew('A', 'axis', (0, N.x))
+        >>> B = A.orientnew('B', 'axis', (q, N.z))
+        >>> pO = Point('pO')
+        >>> pA, pB, pC, pD = Point('pA'), Point('pB'), Point('pC'), Point('pD')
+        >>> pA.set_pos(pO, A.x)
+        >>> pB.set_pos(pO, -A.y)
+        >>> pC.set_pos(pO, B.y)
+        >>> pD.set_pos(pO, B.x)
+        >>> obstacle_set_pathway = ObstacleSetPathway(pA, pB, pC, pD)
+
+        Now create a symbol ``F`` to describe the magnitude of the (expansile)
+        force that will be produced along the pathway. The list of loads that
+        ``KanesMethod`` requires can be produced by calling the pathway's
+        ``to_loads`` method with ``F`` passed as the only argument.
+
+        >>> from sympy import Symbol
+        >>> F = Symbol('F')
+        >>> obstacle_set_pathway.to_loads(F)
+        [(pA, sqrt(2)*F/2*A.x + sqrt(2)*F/2*A.y),
+         (pB, - sqrt(2)*F/2*A.x - sqrt(2)*F/2*A.y),
+         (pB, - F/sqrt(2*cos(q(t)) + 2)*A.y - F/sqrt(2*cos(q(t)) + 2)*B.y),
+         (pC, F/sqrt(2*cos(q(t)) + 2)*A.y + F/sqrt(2*cos(q(t)) + 2)*B.y),
+         (pC, - sqrt(2)*F/2*B.x + sqrt(2)*F/2*B.y),
+         (pD, sqrt(2)*F/2*B.x - sqrt(2)*F/2*B.y)]
+
+        Parameters
+        ==========
+
+        force : Expr
+            The force acting along the length of the pathway. It is assumed
+            that this ``Expr`` represents an expansile force.
+
+        """
+        loads = []
+        attachment_pairs = zip(self.attachments[:-1], self.attachments[1:])
+        for attachment_pair in attachment_pairs:
+            relative_position = _point_pair_relative_position(*attachment_pair)
+            length = _point_pair_length(*attachment_pair)
+            loads.extend([
+                Force(attachment_pair[0], -force*relative_position/length),
+                Force(attachment_pair[1], force*relative_position/length),
+            ])
+        return loads
+
+
+class WrappingPathway(PathwayBase):
+    """Pathway that wraps a geometry object.
+
+    Explanation
+    ===========
+
+    A wrapping pathway interacts with a geometry object and forms a path that
+    wraps smoothly along its surface. The wrapping pathway along the geometry
+    object will be the geodesic that the geometry object defines based on the
+    two points. It will not interact with any other objects in the system, i.e.
+    a ``WrappingPathway`` will intersect other objects to ensure that the path
+    between its two ends (its attachments) is the shortest possible.
+
+    To explain the sign conventions used for pathway length, extension
+    velocity, and direction of applied forces, we can ignore the geometry with
+    which the wrapping pathway interacts. A wrapping pathway is made up of two
+    points that can move relative to each other, and a pair of equal and
+    opposite forces acting on the points. If the positive time-varying
+    Euclidean distance between the two points is defined, then the "extension
+    velocity" is the time derivative of this distance. The extension velocity
+    is positive when the two points are moving away from each other and
+    negative when moving closer to each other. The direction for the force
+    acting on either point is determined by constructing a unit vector directed
+    from the other point to this point. This establishes a sign convention such
+    that a positive force magnitude tends to push the points apart. The
+    following diagram shows the positive force sense and the distance between
+    the points::
+
+       P           Q
+       o<--- F --->o
+       |           |
+       |<--l(t)--->|
+
+    Examples
+    ========
+
+    >>> from sympy.physics.mechanics import WrappingPathway
+
+    To construct a wrapping pathway, like other pathways, a pair of points must
+    be passed, followed by an instance of a wrapping geometry class as a
+    keyword argument. We'll use a cylinder with radius ``r`` and its axis
+    parallel to ``N.x`` passing through a point ``pO``.
+
+    >>> from sympy import symbols
+    >>> from sympy.physics.mechanics import Point, ReferenceFrame, WrappingCylinder
+    >>> r = symbols('r')
+    >>> N = ReferenceFrame('N')
+    >>> pA, pB, pO = Point('pA'), Point('pB'), Point('pO')
+    >>> cylinder = WrappingCylinder(r, pO, N.x)
+    >>> wrapping_pathway = WrappingPathway(pA, pB, cylinder)
+    >>> wrapping_pathway
+    WrappingPathway(pA, pB, geometry=WrappingCylinder(radius=r, point=pO,
+        axis=N.x))
+
+    Parameters
+    ==========
+
+    attachment_1 : Point
+        First of the pair of ``Point`` objects between which the wrapping
+        pathway spans.
+    attachment_2 : Point
+        Second of the pair of ``Point`` objects between which the wrapping
+        pathway spans.
+    geometry : WrappingGeometryBase
+        Geometry about which the pathway wraps.
+
+    """
+
+    def __init__(self, attachment_1, attachment_2, geometry):
+        """Initializer for ``WrappingPathway``.
+
+        Parameters
+        ==========
+
+        attachment_1 : Point
+            First of the pair of ``Point`` objects between which the wrapping
+            pathway spans.
+        attachment_2 : Point
+            Second of the pair of ``Point`` objects between which the wrapping
+            pathway spans.
+        geometry : WrappingGeometryBase
+            Geometry about which the pathway wraps.
+            The geometry about which the pathway wraps.
+
+        """
+        super().__init__(attachment_1, attachment_2)
+        self.geometry = geometry
+
+    @property
+    def geometry(self):
+        """Geometry around which the pathway wraps."""
+        return self._geometry
+
+    @geometry.setter
+    def geometry(self, geometry):
+        if hasattr(self, '_geometry'):
+            msg = (
+                f'Can\'t set attribute `geometry` to {repr(geometry)} as it '
+                f'is immutable.'
+            )
+            raise AttributeError(msg)
+        if not isinstance(geometry, WrappingGeometryBase):
+            msg = (
+                f'Value {repr(geometry)} passed to `geometry` was of type '
+                f'{type(geometry)}, must be {WrappingGeometryBase}.'
+            )
+            raise TypeError(msg)
+        self._geometry = geometry
+
+    @property
+    def length(self):
+        """Exact analytical expression for the pathway's length."""
+        return self.geometry.geodesic_length(*self.attachments)
+
+    @property
+    def extension_velocity(self):
+        """Exact analytical expression for the pathway's extension velocity."""
+        return self.length.diff(dynamicsymbols._t)
+
+    def to_loads(self, force):
+        """Loads required by the equations of motion method classes.
+
+        Explanation
+        ===========
+
+        ``KanesMethod`` requires a list of ``Point``-``Vector`` tuples to be
+        passed to the ``loads`` parameters of its ``kanes_equations`` method
+        when constructing the equations of motion. This method acts as a
+        utility to produce the correctly-structred pairs of points and vectors
+        required so that these can be easily concatenated with other items in
+        the list of loads and passed to ``KanesMethod.kanes_equations``. These
+        loads are also in the correct form to also be passed to the other
+        equations of motion method classes, e.g. ``LagrangesMethod``.
+
+        Examples
+        ========
+
+        The below example shows how to generate the loads produced in an
+        actuator that produces an expansile force ``F`` while wrapping around a
+        cylinder. First, create a cylinder with radius ``r`` and an axis
+        parallel to the ``N.z`` direction of the global frame ``N`` that also
+        passes through a point ``pO``.
+
+        >>> from sympy import symbols
+        >>> from sympy.physics.mechanics import (Point, ReferenceFrame,
+        ...     WrappingCylinder)
+        >>> N = ReferenceFrame('N')
+        >>> r = symbols('r', positive=True)
+        >>> pO = Point('pO')
+        >>> cylinder = WrappingCylinder(r, pO, N.z)
+
+        Create the pathway of the actuator using the ``WrappingPathway`` class,
+        defined to span between two points ``pA`` and ``pB``. Both points lie
+        on the surface of the cylinder and the location of ``pB`` is defined
+        relative to ``pA`` by the dynamics symbol ``q``.
+
+        >>> from sympy import cos, sin
+        >>> from sympy.physics.mechanics import WrappingPathway, dynamicsymbols
+        >>> q = dynamicsymbols('q')
+        >>> pA = Point('pA')
+        >>> pB = Point('pB')
+        >>> pA.set_pos(pO, r*N.x)
+        >>> pB.set_pos(pO, r*(cos(q)*N.x + sin(q)*N.y))
+        >>> pB.pos_from(pA)
+        (r*cos(q(t)) - r)*N.x + r*sin(q(t))*N.y
+        >>> pathway = WrappingPathway(pA, pB, cylinder)
+
+        Now create a symbol ``F`` to describe the magnitude of the (expansile)
+        force that will be produced along the pathway. The list of loads that
+        ``KanesMethod`` requires can be produced by calling the pathway's
+        ``to_loads`` method with ``F`` passed as the only argument.
+
+        >>> F = symbols('F')
+        >>> loads = pathway.to_loads(F)
+        >>> [load.__class__(load.location, load.vector.simplify()) for load in loads]
+        [(pA, F*N.y), (pB, F*sin(q(t))*N.x - F*cos(q(t))*N.y),
+         (pO, - F*sin(q(t))*N.x + F*(cos(q(t)) - 1)*N.y)]
+
+        Parameters
+        ==========
+
+        force : Expr
+            Magnitude of the force acting along the length of the pathway. It
+            is assumed that this ``Expr`` represents an expansile force.
+
+        """
+        pA, pB = self.attachments
+        pO = self.geometry.point
+        pA_force, pB_force = self.geometry.geodesic_end_vectors(pA, pB)
+        pO_force = -(pA_force + pB_force)
+
+        loads = [
+            Force(pA, force * pA_force),
+            Force(pB, force * pB_force),
+            Force(pO, force * pO_force),
+        ]
+        return loads
+
+    def __repr__(self):
+        """Representation of a ``WrappingPathway``."""
+        attachments = ', '.join(str(a) for a in self.attachments)
+        return (
+            f'{self.__class__.__name__}({attachments}, '
+            f'geometry={self.geometry})'
+        )
+
+
+def _point_pair_relative_position(point_1, point_2):
+    """The relative position between a pair of points."""
+    return point_2.pos_from(point_1)
+
+
+def _point_pair_length(point_1, point_2):
+    """The length of the direct linear path between two points."""
+    return _point_pair_relative_position(point_1, point_2).magnitude()
+
+
+def _point_pair_extension_velocity(point_1, point_2):
+    """The extension velocity of the direct linear path between two points."""
+    return _point_pair_length(point_1, point_2).diff(dynamicsymbols._t)

mplug_owl2/lib/python3.10/site-packages/sympy/physics/mechanics/system.py

@@ -0,0 +1,1553 @@
+from functools import wraps
+
+from sympy.core.basic import Basic
+from sympy.matrices.immutable import ImmutableMatrix
+from sympy.matrices.dense import Matrix, eye, zeros
+from sympy.core.containers import OrderedSet
+from sympy.physics.mechanics.actuator import ActuatorBase
+from sympy.physics.mechanics.body_base import BodyBase
+from sympy.physics.mechanics.functions import (
+    Lagrangian, _validate_coordinates, find_dynamicsymbols)
+from sympy.physics.mechanics.joint import Joint
+from sympy.physics.mechanics.kane import KanesMethod
+from sympy.physics.mechanics.lagrange import LagrangesMethod
+from sympy.physics.mechanics.loads import _parse_load, gravity
+from sympy.physics.mechanics.method import _Methods
+from sympy.physics.mechanics.particle import Particle
+from sympy.physics.vector import Point, ReferenceFrame, dynamicsymbols
+from sympy.utilities.iterables import iterable
+from sympy.utilities.misc import filldedent
+
+__all__ = ['SymbolicSystem', 'System']
+
+
+def _reset_eom_method(method):
+    """Decorator to reset the eom_method if a property is changed."""
+
+    @wraps(method)
+    def wrapper(self, *args, **kwargs):
+        self._eom_method = None
+        return method(self, *args, **kwargs)
+
+    return wrapper
+
+
+class System(_Methods):
+    """Class to define a multibody system and form its equations of motion.
+
+    Explanation
+    ===========
+
+    A ``System`` instance stores the different objects associated with a model,
+    including bodies, joints, constraints, and other relevant information. With
+    all the relationships between components defined, the ``System`` can be used
+    to form the equations of motion using a backend, such as ``KanesMethod``.
+    The ``System`` has been designed to be compatible with third-party
+    libraries for greater flexibility and integration with other tools.
+
+    Attributes
+    ==========
+
+    frame : ReferenceFrame
+        Inertial reference frame of the system.
+    fixed_point : Point
+        A fixed point in the inertial reference frame.
+    x : Vector
+        Unit vector fixed in the inertial reference frame.
+    y : Vector
+        Unit vector fixed in the inertial reference frame.
+    z : Vector
+        Unit vector fixed in the inertial reference frame.
+    q : ImmutableMatrix
+        Matrix of all the generalized coordinates, i.e. the independent
+        generalized coordinates stacked upon the dependent.
+    u : ImmutableMatrix
+        Matrix of all the generalized speeds, i.e. the independent generealized
+        speeds stacked upon the dependent.
+    q_ind : ImmutableMatrix
+        Matrix of the independent generalized coordinates.
+    q_dep : ImmutableMatrix
+        Matrix of the dependent generalized coordinates.
+    u_ind : ImmutableMatrix
+        Matrix of the independent generalized speeds.
+    u_dep : ImmutableMatrix
+        Matrix of the dependent generalized speeds.
+    u_aux : ImmutableMatrix
+        Matrix of auxiliary generalized speeds.
+    kdes : ImmutableMatrix
+        Matrix of the kinematical differential equations as expressions equated
+        to the zero matrix.
+    bodies : tuple of BodyBase subclasses
+        Tuple of all bodies that make up the system.
+    joints : tuple of Joint
+        Tuple of all joints that connect bodies in the system.
+    loads : tuple of LoadBase subclasses
+        Tuple of all loads that have been applied to the system.
+    actuators : tuple of ActuatorBase subclasses
+        Tuple of all actuators present in the system.
+    holonomic_constraints : ImmutableMatrix
+        Matrix with the holonomic constraints as expressions equated to the zero
+        matrix.
+    nonholonomic_constraints : ImmutableMatrix
+        Matrix with the nonholonomic constraints as expressions equated to the
+        zero matrix.
+    velocity_constraints : ImmutableMatrix
+        Matrix with the velocity constraints as expressions equated to the zero
+        matrix. These are by default derived as the time derivatives of the
+        holonomic constraints extended with the nonholonomic constraints.
+    eom_method : subclass of KanesMethod or LagrangesMethod
+        Backend for forming the equations of motion.
+
+    Examples
+    ========
+
+    In the example below a cart with a pendulum is created. The cart moves along
+    the x axis of the rail and the pendulum rotates about the z axis. The length
+    of the pendulum is ``l`` with the pendulum represented as a particle. To
+    move the cart a time dependent force ``F`` is applied to the cart.
+
+    We first need to import some functions and create some of our variables.
+
+    >>> from sympy import symbols, simplify
+    >>> from sympy.physics.mechanics import (
+    ...     mechanics_printing, dynamicsymbols, RigidBody, Particle,
+    ...     ReferenceFrame, PrismaticJoint, PinJoint, System)
+    >>> mechanics_printing(pretty_print=False)
+    >>> g, l = symbols('g l')
+    >>> F = dynamicsymbols('F')
+
+    The next step is to create bodies. It is also useful to create a frame for
+    locating the particle with respect to the pin joint later on, as a particle
+    does not have a body-fixed frame.
+
+    >>> rail = RigidBody('rail')
+    >>> cart = RigidBody('cart')
+    >>> bob = Particle('bob')
+    >>> bob_frame = ReferenceFrame('bob_frame')
+
+    Initialize the system, with the rail as the Newtonian reference. The body is
+    also automatically added to the system.
+
+    >>> system = System.from_newtonian(rail)
+    >>> print(system.bodies[0])
+    rail
+
+    Create the joints, while immediately also adding them to the system.
+
+    >>> system.add_joints(
+    ...     PrismaticJoint('slider', rail, cart, joint_axis=rail.x),
+    ...     PinJoint('pin', cart, bob, joint_axis=cart.z,
+    ...              child_interframe=bob_frame,
+    ...              child_point=l * bob_frame.y)
+    ... )
+    >>> system.joints
+    (PrismaticJoint: slider  parent: rail  child: cart,
+    PinJoint: pin  parent: cart  child: bob)
+
+    While adding the joints, the associated generalized coordinates, generalized
+    speeds, kinematic differential equations and bodies are also added to the
+    system.
+
+    >>> system.q
+    Matrix([
+    [q_slider],
+    [   q_pin]])
+    >>> system.u
+    Matrix([
+    [u_slider],
+    [   u_pin]])
+    >>> system.kdes
+    Matrix([
+    [u_slider - q_slider'],
+    [      u_pin - q_pin']])
+    >>> [body.name for body in system.bodies]
+    ['rail', 'cart', 'bob']
+
+    With the kinematics established, we can now apply gravity and the cart force
+    ``F``.
+
+    >>> system.apply_uniform_gravity(-g * system.y)
+    >>> system.add_loads((cart.masscenter, F * rail.x))
+    >>> system.loads
+    ((rail_masscenter, - g*rail_mass*rail_frame.y),
+     (cart_masscenter, - cart_mass*g*rail_frame.y),
+     (bob_masscenter, - bob_mass*g*rail_frame.y),
+     (cart_masscenter, F*rail_frame.x))
+
+    With the entire system defined, we can now form the equations of motion.
+    Before forming the equations of motion, one can also run some checks that
+    will try to identify some common errors.
+
+    >>> system.validate_system()
+    >>> system.form_eoms()
+    Matrix([
+    [bob_mass*l*u_pin**2*sin(q_pin) - bob_mass*l*cos(q_pin)*u_pin'
+     - (bob_mass + cart_mass)*u_slider' + F],
+    [                   -bob_mass*g*l*sin(q_pin) - bob_mass*l**2*u_pin'
+     - bob_mass*l*cos(q_pin)*u_slider']])
+    >>> simplify(system.mass_matrix)
+    Matrix([
+    [ bob_mass + cart_mass, bob_mass*l*cos(q_pin)],
+    [bob_mass*l*cos(q_pin),         bob_mass*l**2]])
+    >>> system.forcing
+    Matrix([
+    [bob_mass*l*u_pin**2*sin(q_pin) + F],
+    [          -bob_mass*g*l*sin(q_pin)]])
+
+    The complexity of the above example can be increased if we add a constraint
+    to prevent the particle from moving in the horizontal (x) direction. This
+    can be done by adding a holonomic constraint. After which we should also
+    redefine what our (in)dependent generalized coordinates and speeds are.
+
+    >>> system.add_holonomic_constraints(
+    ...     bob.masscenter.pos_from(rail.masscenter).dot(system.x)
+    ... )
+    >>> system.q_ind = system.get_joint('pin').coordinates
+    >>> system.q_dep = system.get_joint('slider').coordinates
+    >>> system.u_ind = system.get_joint('pin').speeds
+    >>> system.u_dep = system.get_joint('slider').speeds
+
+    With the updated system the equations of motion can be formed again.
+
+    >>> system.validate_system()
+    >>> system.form_eoms()
+    Matrix([[-bob_mass*g*l*sin(q_pin)
+             - bob_mass*l**2*u_pin'
+             - bob_mass*l*cos(q_pin)*u_slider'
+             - l*(bob_mass*l*u_pin**2*sin(q_pin)
+             - bob_mass*l*cos(q_pin)*u_pin'
+             - (bob_mass + cart_mass)*u_slider')*cos(q_pin)
+             - l*F*cos(q_pin)]])
+    >>> simplify(system.mass_matrix)
+    Matrix([
+    [bob_mass*l**2*sin(q_pin)**2, -cart_mass*l*cos(q_pin)],
+    [               l*cos(q_pin),                       1]])
+    >>> simplify(system.forcing)
+    Matrix([
+    [-l*(bob_mass*g*sin(q_pin) + bob_mass*l*u_pin**2*sin(2*q_pin)/2
+     + F*cos(q_pin))],
+    [
+    l*u_pin**2*sin(q_pin)]])
+
+    """
+
+    def __init__(self, frame=None, fixed_point=None):
+        """Initialize the system.
+
+        Parameters
+        ==========
+
+        frame : ReferenceFrame, optional
+            The inertial frame of the system. If none is supplied, a new frame
+            will be created.
+        fixed_point : Point, optional
+            A fixed point in the inertial reference frame. If none is supplied,
+            a new fixed_point will be created.
+
+        """
+        if frame is None:
+            frame = ReferenceFrame('inertial_frame')
+        elif not isinstance(frame, ReferenceFrame):
+            raise TypeError('Frame must be an instance of ReferenceFrame.')
+        self._frame = frame
+        if fixed_point is None:
+            fixed_point = Point('inertial_point')
+        elif not isinstance(fixed_point, Point):
+            raise TypeError('Fixed point must be an instance of Point.')
+        self._fixed_point = fixed_point
+        self._fixed_point.set_vel(self._frame, 0)
+        self._q_ind = ImmutableMatrix(1, 0, []).T
+        self._q_dep = ImmutableMatrix(1, 0, []).T
+        self._u_ind = ImmutableMatrix(1, 0, []).T
+        self._u_dep = ImmutableMatrix(1, 0, []).T
+        self._u_aux = ImmutableMatrix(1, 0, []).T
+        self._kdes = ImmutableMatrix(1, 0, []).T
+        self._hol_coneqs = ImmutableMatrix(1, 0, []).T
+        self._nonhol_coneqs = ImmutableMatrix(1, 0, []).T
+        self._vel_constrs = None
+        self._bodies = []
+        self._joints = []
+        self._loads = []
+        self._actuators = []
+        self._eom_method = None
+
+    @classmethod
+    def from_newtonian(cls, newtonian):
+        """Constructs the system with respect to a Newtonian body."""
+        if isinstance(newtonian, Particle):
+            raise TypeError('A Particle has no frame so cannot act as '
+                            'the Newtonian.')
+        system = cls(frame=newtonian.frame, fixed_point=newtonian.masscenter)
+        system.add_bodies(newtonian)
+        return system
+
+    @property
+    def fixed_point(self):
+        """Fixed point in the inertial reference frame."""
+        return self._fixed_point
+
+    @property
+    def frame(self):
+        """Inertial reference frame of the system."""
+        return self._frame
+
+    @property
+    def x(self):
+        """Unit vector fixed in the inertial reference frame."""
+        return self._frame.x
+
+    @property
+    def y(self):
+        """Unit vector fixed in the inertial reference frame."""
+        return self._frame.y
+
+    @property
+    def z(self):
+        """Unit vector fixed in the inertial reference frame."""
+        return self._frame.z
+
+    @property
+    def bodies(self):
+        """Tuple of all bodies that have been added to the system."""
+        return tuple(self._bodies)
+
+    @bodies.setter
+    @_reset_eom_method
+    def bodies(self, bodies):
+        bodies = self._objects_to_list(bodies)
+        self._check_objects(bodies, [], BodyBase, 'Bodies', 'bodies')
+        self._bodies = bodies
+
+    @property
+    def joints(self):
+        """Tuple of all joints that have been added to the system."""
+        return tuple(self._joints)
+
+    @joints.setter
+    @_reset_eom_method
+    def joints(self, joints):
+        joints = self._objects_to_list(joints)
+        self._check_objects(joints, [], Joint, 'Joints', 'joints')
+        self._joints = []
+        self.add_joints(*joints)
+
+    @property
+    def loads(self):
+        """Tuple of loads that have been applied on the system."""
+        return tuple(self._loads)
+
+    @loads.setter
+    @_reset_eom_method
+    def loads(self, loads):
+        loads = self._objects_to_list(loads)
+        self._loads = [_parse_load(load) for load in loads]
+
+    @property
+    def actuators(self):
+        """Tuple of actuators present in the system."""
+        return tuple(self._actuators)
+
+    @actuators.setter
+    @_reset_eom_method
+    def actuators(self, actuators):
+        actuators = self._objects_to_list(actuators)
+        self._check_objects(actuators, [], ActuatorBase, 'Actuators',
+                            'actuators')
+        self._actuators = actuators
+
+    @property
+    def q(self):
+        """Matrix of all the generalized coordinates with the independent
+        stacked upon the dependent."""
+        return self._q_ind.col_join(self._q_dep)
+
+    @property
+    def u(self):
+        """Matrix of all the generalized speeds with the independent stacked
+        upon the dependent."""
+        return self._u_ind.col_join(self._u_dep)
+
+    @property
+    def q_ind(self):
+        """Matrix of the independent generalized coordinates."""
+        return self._q_ind
+
+    @q_ind.setter
+    @_reset_eom_method
+    def q_ind(self, q_ind):
+        self._q_ind, self._q_dep = self._parse_coordinates(
+            self._objects_to_list(q_ind), True, [], self.q_dep, 'coordinates')
+
+    @property
+    def q_dep(self):
+        """Matrix of the dependent generalized coordinates."""
+        return self._q_dep
+
+    @q_dep.setter
+    @_reset_eom_method
+    def q_dep(self, q_dep):
+        self._q_ind, self._q_dep = self._parse_coordinates(
+            self._objects_to_list(q_dep), False, self.q_ind, [], 'coordinates')
+
+    @property
+    def u_ind(self):
+        """Matrix of the independent generalized speeds."""
+        return self._u_ind
+
+    @u_ind.setter
+    @_reset_eom_method
+    def u_ind(self, u_ind):
+        self._u_ind, self._u_dep = self._parse_coordinates(
+            self._objects_to_list(u_ind), True, [], self.u_dep, 'speeds')
+
+    @property
+    def u_dep(self):
+        """Matrix of the dependent generalized speeds."""
+        return self._u_dep
+
+    @u_dep.setter
+    @_reset_eom_method
+    def u_dep(self, u_dep):
+        self._u_ind, self._u_dep = self._parse_coordinates(
+            self._objects_to_list(u_dep), False, self.u_ind, [], 'speeds')
+
+    @property
+    def u_aux(self):
+        """Matrix of auxiliary generalized speeds."""
+        return self._u_aux
+
+    @u_aux.setter
+    @_reset_eom_method
+    def u_aux(self, u_aux):
+        self._u_aux = self._parse_coordinates(
+            self._objects_to_list(u_aux), True, [], [], 'u_auxiliary')[0]
+
+    @property
+    def kdes(self):
+        """Kinematical differential equations as expressions equated to the zero
+        matrix. These equations describe the coupling between the generalized
+        coordinates and the generalized speeds."""
+        return self._kdes
+
+    @kdes.setter
+    @_reset_eom_method
+    def kdes(self, kdes):
+        kdes = self._objects_to_list(kdes)
+        self._kdes = self._parse_expressions(
+            kdes, [], 'kinematic differential equations')
+
+    @property
+    def holonomic_constraints(self):
+        """Matrix with the holonomic constraints as expressions equated to the
+        zero matrix."""
+        return self._hol_coneqs
+
+    @holonomic_constraints.setter
+    @_reset_eom_method
+    def holonomic_constraints(self, constraints):
+        constraints = self._objects_to_list(constraints)
+        self._hol_coneqs = self._parse_expressions(
+            constraints, [], 'holonomic constraints')
+
+    @property
+    def nonholonomic_constraints(self):
+        """Matrix with the nonholonomic constraints as expressions equated to
+        the zero matrix."""
+        return self._nonhol_coneqs
+
+    @nonholonomic_constraints.setter
+    @_reset_eom_method
+    def nonholonomic_constraints(self, constraints):
+        constraints = self._objects_to_list(constraints)
+        self._nonhol_coneqs = self._parse_expressions(
+            constraints, [], 'nonholonomic constraints')
+
+    @property
+    def velocity_constraints(self):
+        """Matrix with the velocity constraints as expressions equated to the
+        zero matrix. The velocity constraints are by default derived from the
+        holonomic and nonholonomic constraints unless they are explicitly set.
+        """
+        if self._vel_constrs is None:
+            return self.holonomic_constraints.diff(dynamicsymbols._t).col_join(
+                self.nonholonomic_constraints)
+        return self._vel_constrs
+
+    @velocity_constraints.setter
+    @_reset_eom_method
+    def velocity_constraints(self, constraints):
+        if constraints is None:
+            self._vel_constrs = None
+            return
+        constraints = self._objects_to_list(constraints)
+        self._vel_constrs = self._parse_expressions(
+            constraints, [], 'velocity constraints')
+
+    @property
+    def eom_method(self):
+        """Backend for forming the equations of motion."""
+        return self._eom_method
+
+    @staticmethod
+    def _objects_to_list(lst):
+        """Helper to convert passed objects to a list."""
+        if not iterable(lst):  # Only one object
+            return [lst]
+        return list(lst[:])  # converts Matrix and tuple to flattened list
+
+    @staticmethod
+    def _check_objects(objects, obj_lst, expected_type, obj_name, type_name):
+        """Helper to check the objects that are being added to the system.
+
+        Explanation
+        ===========
+        This method checks that the objects that are being added to the system
+        are of the correct type and have not already been added. If any of the
+        objects are not of the correct type or have already been added, then
+        an error is raised.
+
+        Parameters
+        ==========
+        objects : iterable
+            The objects that would be added to the system.
+        obj_lst : list
+            The list of objects that are already in the system.
+        expected_type : type
+            The type that the objects should be.
+        obj_name : str
+            The name of the category of objects. This string is used to
+            formulate the error message for the user.
+        type_name : str
+            The name of the type that the objects should be. This string is used
+            to formulate the error message for the user.
+
+        """
+        seen = set(obj_lst)
+        duplicates = set()
+        wrong_types = set()
+        for obj in objects:
+            if not isinstance(obj, expected_type):
+                wrong_types.add(obj)
+            if obj in seen:
+                duplicates.add(obj)
+            else:
+                seen.add(obj)
+        if wrong_types:
+            raise TypeError(f'{obj_name} {wrong_types} are not {type_name}.')
+        if duplicates:
+            raise ValueError(f'{obj_name} {duplicates} have already been added '
+                             f'to the system.')
+
+    def _parse_coordinates(self, new_coords, independent, old_coords_ind,
+                           old_coords_dep, coord_type='coordinates'):
+        """Helper to parse coordinates and speeds."""
+        # Construct lists of the independent and dependent coordinates
+        coords_ind, coords_dep = old_coords_ind[:], old_coords_dep[:]
+        if not iterable(independent):
+            independent = [independent] * len(new_coords)
+        for coord, indep in zip(new_coords, independent):
+            if indep:
+                coords_ind.append(coord)
+            else:
+                coords_dep.append(coord)
+        # Check types and duplicates
+        current = {'coordinates': self.q_ind[:] + self.q_dep[:],
+                   'speeds': self.u_ind[:] + self.u_dep[:],
+                   'u_auxiliary': self._u_aux[:],
+                   coord_type: coords_ind + coords_dep}
+        _validate_coordinates(**current)
+        return (ImmutableMatrix(1, len(coords_ind), coords_ind).T,
+                ImmutableMatrix(1, len(coords_dep), coords_dep).T)
+
+    @staticmethod
+    def _parse_expressions(new_expressions, old_expressions, name,
+                           check_negatives=False):
+        """Helper to parse expressions like constraints."""
+        old_expressions = old_expressions[:]
+        new_expressions = list(new_expressions)  # Converts a possible tuple
+        if check_negatives:
+            check_exprs = old_expressions + [-expr for expr in old_expressions]
+        else:
+            check_exprs = old_expressions
+        System._check_objects(new_expressions, check_exprs, Basic, name,
+                              'expressions')
+        for expr in new_expressions:
+            if expr == 0:
+                raise ValueError(f'Parsed {name} are zero.')
+        return ImmutableMatrix(1, len(old_expressions) + len(new_expressions),
+                               old_expressions + new_expressions).T
+
+    @_reset_eom_method
+    def add_coordinates(self, *coordinates, independent=True):
+        """Add generalized coordinate(s) to the system.
+
+        Parameters
+        ==========
+
+        *coordinates : dynamicsymbols
+            One or more generalized coordinates to be added to the system.
+        independent : bool or list of bool, optional
+            Boolean whether a coordinate is dependent or independent. The
+            default is True, so the coordinates are added as independent by
+            default.
+
+        """
+        self._q_ind, self._q_dep = self._parse_coordinates(
+            coordinates, independent, self.q_ind, self.q_dep, 'coordinates')
+
+    @_reset_eom_method
+    def add_speeds(self, *speeds, independent=True):
+        """Add generalized speed(s) to the system.
+
+        Parameters
+        ==========
+
+        *speeds : dynamicsymbols
+            One or more generalized speeds to be added to the system.
+        independent : bool or list of bool, optional
+            Boolean whether a speed is dependent or independent. The default is
+            True, so the speeds are added as independent by default.
+
+        """
+        self._u_ind, self._u_dep = self._parse_coordinates(
+            speeds, independent, self.u_ind, self.u_dep, 'speeds')
+
+    @_reset_eom_method
+    def add_auxiliary_speeds(self, *speeds):
+        """Add auxiliary speed(s) to the system.
+
+        Parameters
+        ==========
+
+        *speeds : dynamicsymbols
+            One or more auxiliary speeds to be added to the system.
+
+        """
+        self._u_aux = self._parse_coordinates(
+            speeds, True, self._u_aux, [], 'u_auxiliary')[0]
+
+    @_reset_eom_method
+    def add_kdes(self, *kdes):
+        """Add kinematic differential equation(s) to the system.
+
+        Parameters
+        ==========
+
+        *kdes : Expr
+            One or more kinematic differential equations.
+
+        """
+        self._kdes = self._parse_expressions(
+            kdes, self.kdes, 'kinematic differential equations',
+            check_negatives=True)
+
+    @_reset_eom_method
+    def add_holonomic_constraints(self, *constraints):
+        """Add holonomic constraint(s) to the system.
+
+        Parameters
+        ==========
+
+        *constraints : Expr
+            One or more holonomic constraints, which are expressions that should
+            be zero.
+
+        """
+        self._hol_coneqs = self._parse_expressions(
+            constraints, self._hol_coneqs, 'holonomic constraints',
+            check_negatives=True)
+
+    @_reset_eom_method
+    def add_nonholonomic_constraints(self, *constraints):
+        """Add nonholonomic constraint(s) to the system.
+
+        Parameters
+        ==========
+
+        *constraints : Expr
+            One or more nonholonomic constraints, which are expressions that
+            should be zero.
+
+        """
+        self._nonhol_coneqs = self._parse_expressions(
+            constraints, self._nonhol_coneqs, 'nonholonomic constraints',
+            check_negatives=True)
+
+    @_reset_eom_method
+    def add_bodies(self, *bodies):
+        """Add body(ies) to the system.
+
+        Parameters
+        ==========
+
+        bodies : Particle or RigidBody
+            One or more bodies.
+
+        """
+        self._check_objects(bodies, self.bodies, BodyBase, 'Bodies', 'bodies')
+        self._bodies.extend(bodies)
+
+    @_reset_eom_method
+    def add_loads(self, *loads):
+        """Add load(s) to the system.
+
+        Parameters
+        ==========
+
+        *loads : Force or Torque
+            One or more loads.
+
+        """
+        loads = [_parse_load(load) for load in loads]  # Checks the loads
+        self._loads.extend(loads)
+
+    @_reset_eom_method
+    def apply_uniform_gravity(self, acceleration):
+        """Apply uniform gravity to all bodies in the system by adding loads.
+
+        Parameters
+        ==========
+
+        acceleration : Vector
+            The acceleration due to gravity.
+
+        """
+        self.add_loads(*gravity(acceleration, *self.bodies))
+
+    @_reset_eom_method
+    def add_actuators(self, *actuators):
+        """Add actuator(s) to the system.
+
+        Parameters
+        ==========
+
+        *actuators : subclass of ActuatorBase
+            One or more actuators.
+
+        """
+        self._check_objects(actuators, self.actuators, ActuatorBase,
+                            'Actuators', 'actuators')
+        self._actuators.extend(actuators)
+
+    @_reset_eom_method
+    def add_joints(self, *joints):
+        """Add joint(s) to the system.
+
+        Explanation
+        ===========
+
+        This methods adds one or more joints to the system including its
+        associated objects, i.e. generalized coordinates, generalized speeds,
+        kinematic differential equations and the bodies.
+
+        Parameters
+        ==========
+
+        *joints : subclass of Joint
+            One or more joints.
+
+        Notes
+        =====
+
+        For the generalized coordinates, generalized speeds and bodies it is
+        checked whether they are already known by the system instance. If they
+        are, then they are not added. The kinematic differential equations are
+        however always added to the system, so you should not also manually add
+        those on beforehand.
+
+        """
+        self._check_objects(joints, self.joints, Joint, 'Joints', 'joints')
+        self._joints.extend(joints)
+        coordinates, speeds, kdes, bodies = (OrderedSet() for _ in range(4))
+        for joint in joints:
+            coordinates.update(joint.coordinates)
+            speeds.update(joint.speeds)
+            kdes.update(joint.kdes)
+            bodies.update((joint.parent, joint.child))
+        coordinates = coordinates.difference(self.q)
+        speeds = speeds.difference(self.u)
+        kdes = kdes.difference(self.kdes[:] + (-self.kdes)[:])
+        bodies = bodies.difference(self.bodies)
+        self.add_coordinates(*tuple(coordinates))
+        self.add_speeds(*tuple(speeds))
+        self.add_kdes(*(kde for kde in tuple(kdes) if not kde == 0))
+        self.add_bodies(*tuple(bodies))
+
+    def get_body(self, name):
+        """Retrieve a body from the system by name.
+
+        Parameters
+        ==========
+
+        name : str
+            The name of the body to retrieve.
+
+        Returns
+        =======
+
+        RigidBody or Particle
+            The body with the given name, or None if no such body exists.
+
+        """
+        for body in self._bodies:
+            if body.name == name:
+                return body
+
+    def get_joint(self, name):
+        """Retrieve a joint from the system by name.
+
+        Parameters
+        ==========
+
+        name : str
+            The name of the joint to retrieve.
+
+        Returns
+        =======
+
+        subclass of Joint
+            The joint with the given name, or None if no such joint exists.
+
+        """
+        for joint in self._joints:
+            if joint.name == name:
+                return joint
+
+    def _form_eoms(self):
+        return self.form_eoms()
+
+    def form_eoms(self, eom_method=KanesMethod, **kwargs):
+        """Form the equations of motion of the system.
+
+        Parameters
+        ==========
+
+        eom_method : subclass of KanesMethod or LagrangesMethod
+            Backend class to be used for forming the equations of motion. The
+            default is ``KanesMethod``.
+
+        Returns
+        ========
+
+        ImmutableMatrix
+            Vector of equations of motions.
+
+        Examples
+        ========
+
+        This is a simple example for a one degree of freedom translational
+        spring-mass-damper.
+
+        >>> from sympy import S, symbols
+        >>> from sympy.physics.mechanics import (
+        ...     LagrangesMethod, dynamicsymbols, PrismaticJoint, Particle,
+        ...     RigidBody, System)
+        >>> q = dynamicsymbols('q')
+        >>> qd = dynamicsymbols('q', 1)
+        >>> m, k, b = symbols('m k b')
+        >>> wall = RigidBody('W')
+        >>> system = System.from_newtonian(wall)
+        >>> bob = Particle('P', mass=m)
+        >>> bob.potential_energy = S.Half * k * q**2
+        >>> system.add_joints(PrismaticJoint('J', wall, bob, q, qd))
+        >>> system.add_loads((bob.masscenter, b * qd * system.x))
+        >>> system.form_eoms(LagrangesMethod)
+        Matrix([[-b*Derivative(q(t), t) + k*q(t) + m*Derivative(q(t), (t, 2))]])
+
+        We can also solve for the states using the 'rhs' method.
+
+        >>> system.rhs()
+        Matrix([
+        [               Derivative(q(t), t)],
+        [(b*Derivative(q(t), t) - k*q(t))/m]])
+
+        """
+        # KanesMethod does not accept empty iterables
+        loads = self.loads + tuple(
+            load for act in self.actuators for load in act.to_loads())
+        loads = loads if loads else None
+        if issubclass(eom_method, KanesMethod):
+            disallowed_kwargs = {
+                "frame", "q_ind", "u_ind", "kd_eqs", "q_dependent",
+                "u_dependent", "u_auxiliary", "configuration_constraints",
+                "velocity_constraints", "forcelist", "bodies"}
+            wrong_kwargs = disallowed_kwargs.intersection(kwargs)
+            if wrong_kwargs:
+                raise ValueError(
+                    f"The following keyword arguments are not allowed to be "
+                    f"overwritten in {eom_method.__name__}: {wrong_kwargs}.")
+            kwargs = {"frame": self.frame, "q_ind": self.q_ind,
+                      "u_ind": self.u_ind, "kd_eqs": self.kdes,
+                      "q_dependent": self.q_dep, "u_dependent": self.u_dep,
+                      "configuration_constraints": self.holonomic_constraints,
+                      "velocity_constraints": self.velocity_constraints,
+                      "u_auxiliary": self.u_aux,
+                      "forcelist": loads, "bodies": self.bodies,
+                      "explicit_kinematics": False, **kwargs}
+            self._eom_method = eom_method(**kwargs)
+        elif issubclass(eom_method, LagrangesMethod):
+            disallowed_kwargs = {
+                "frame", "qs", "forcelist", "bodies", "hol_coneqs",
+                "nonhol_coneqs", "Lagrangian"}
+            wrong_kwargs = disallowed_kwargs.intersection(kwargs)
+            if wrong_kwargs:
+                raise ValueError(
+                    f"The following keyword arguments are not allowed to be "
+                    f"overwritten in {eom_method.__name__}: {wrong_kwargs}.")
+            kwargs = {"frame": self.frame, "qs": self.q, "forcelist": loads,
+                      "bodies": self.bodies,
+                      "hol_coneqs": self.holonomic_constraints,
+                      "nonhol_coneqs": self.nonholonomic_constraints, **kwargs}
+            if "Lagrangian" not in kwargs:
+                kwargs["Lagrangian"] = Lagrangian(kwargs["frame"],
+                                                  *kwargs["bodies"])
+            self._eom_method = eom_method(**kwargs)
+        else:
+            raise NotImplementedError(f'{eom_method} has not been implemented.')
+        return self.eom_method._form_eoms()
+
+    def rhs(self, inv_method=None):
+        """Compute the equations of motion in the explicit form.
+
+        Parameters
+        ==========
+
+        inv_method : str
+            The specific sympy inverse matrix calculation method to use. For a
+            list of valid methods, see
+            :meth:`~sympy.matrices.matrixbase.MatrixBase.inv`
+
+        Returns
+        ========
+
+        ImmutableMatrix
+            Equations of motion in the explicit form.
+
+        See Also
+        ========
+
+        sympy.physics.mechanics.kane.KanesMethod.rhs:
+            KanesMethod's ``rhs`` function.
+        sympy.physics.mechanics.lagrange.LagrangesMethod.rhs:
+            LagrangesMethod's ``rhs`` function.
+
+        """
+        return self.eom_method.rhs(inv_method=inv_method)
+
+    @property
+    def mass_matrix(self):
+        r"""The mass matrix of the system.
+
+        Explanation
+        ===========
+
+        The mass matrix $M_d$ and the forcing vector $f_d$ of a system describe
+        the system's dynamics according to the following equations:
+
+        .. math::
+            M_d \dot{u} = f_d
+
+        where $\dot{u}$ is the time derivative of the generalized speeds.
+
+        """
+        return self.eom_method.mass_matrix
+
+    @property
+    def mass_matrix_full(self):
+        r"""The mass matrix of the system, augmented by the kinematic
+        differential equations in explicit or implicit form.
+
+        Explanation
+        ===========
+
+        The full mass matrix $M_m$ and the full forcing vector $f_m$ of a system
+        describe the dynamics and kinematics according to the following
+        equation:
+
+        .. math::
+            M_m \dot{x} = f_m
+
+        where $x$ is the state vector stacking $q$ and $u$.
+
+        """
+        return self.eom_method.mass_matrix_full
+
+    @property
+    def forcing(self):
+        """The forcing vector of the system."""
+        return self.eom_method.forcing
+
+    @property
+    def forcing_full(self):
+        """The forcing vector of the system, augmented by the kinematic
+        differential equations in explicit or implicit form."""
+        return self.eom_method.forcing_full
+
+    def validate_system(self, eom_method=KanesMethod, check_duplicates=False):
+        """Validates the system using some basic checks.
+
+        Explanation
+        ===========
+
+        This method validates the system based on the following checks:
+
+        - The number of dependent generalized coordinates should equal the
+          number of holonomic constraints.
+        - All generalized coordinates defined by the joints should also be known
+          to the system.
+        - If ``KanesMethod`` is used as a ``eom_method``:
+            - All generalized speeds and kinematic differential equations
+              defined by the joints should also be known to the system.
+            - The number of dependent generalized speeds should equal the number
+              of velocity constraints.
+            - The number of generalized coordinates should be less than or equal
+              to the number of generalized speeds.
+            - The number of generalized coordinates should equal the number of
+              kinematic differential equations.
+        - If ``LagrangesMethod`` is used as ``eom_method``:
+            - There should not be any generalized speeds that are not
+              derivatives of the generalized coordinates (this includes the
+              generalized speeds defined by the joints).
+
+        Parameters
+        ==========
+
+        eom_method : subclass of KanesMethod or LagrangesMethod
+            Backend class that will be used for forming the equations of motion.
+            There are different checks for the different backends. The default
+            is ``KanesMethod``.
+        check_duplicates : bool
+            Boolean whether the system should be checked for duplicate
+            definitions. The default is False, because duplicates are already
+            checked when adding objects to the system.
+
+        Notes
+        =====
+
+        This method is not guaranteed to be backwards compatible as it may
+        improve over time. The method can become both more and less strict in
+        certain areas. However a well-defined system should always pass all
+        these tests.
+
+        """
+        msgs = []
+        # Save some data in variables
+        n_hc = self.holonomic_constraints.shape[0]
+        n_vc = self.velocity_constraints.shape[0]
+        n_q_dep, n_u_dep = self.q_dep.shape[0], self.u_dep.shape[0]
+        q_set, u_set = set(self.q), set(self.u)
+        n_q, n_u = len(q_set), len(u_set)
+        # Check number of holonomic constraints
+        if n_q_dep != n_hc:
+            msgs.append(filldedent(f"""
+            The number of dependent generalized coordinates {n_q_dep} should be
+            equal to the number of holonomic constraints {n_hc}."""))
+        # Check if all joint coordinates and speeds are present
+        missing_q = set()
+        for joint in self.joints:
+            missing_q.update(set(joint.coordinates).difference(q_set))
+        if missing_q:
+            msgs.append(filldedent(f"""
+            The generalized coordinates {missing_q} used in joints are not added
+            to the system."""))
+        # Method dependent checks
+        if issubclass(eom_method, KanesMethod):
+            n_kdes = len(self.kdes)
+            missing_kdes, missing_u = set(), set()
+            for joint in self.joints:
+                missing_u.update(set(joint.speeds).difference(u_set))
+                missing_kdes.update(set(joint.kdes).difference(
+                    self.kdes[:] + (-self.kdes)[:]))
+            if missing_u:
+                msgs.append(filldedent(f"""
+                The generalized speeds {missing_u} used in joints are not added
+                to the system."""))
+            if missing_kdes:
+                msgs.append(filldedent(f"""
+                The kinematic differential equations {missing_kdes} used in
+                joints are not added to the system."""))
+            if n_u_dep != n_vc:
+                msgs.append(filldedent(f"""
+                The number of dependent generalized speeds {n_u_dep} should be
+                equal to the number of velocity constraints {n_vc}."""))
+            if n_q > n_u:
+                msgs.append(filldedent(f"""
+                The number of generalized coordinates {n_q} should be less than
+                or equal to the number of generalized speeds {n_u}."""))
+            if n_u != n_kdes:
+                msgs.append(filldedent(f"""
+                The number of generalized speeds {n_u} should be equal to the
+                number of kinematic differential equations {n_kdes}."""))
+        elif issubclass(eom_method, LagrangesMethod):
+            not_qdots = set(self.u).difference(self.q.diff(dynamicsymbols._t))
+            for joint in self.joints:
+                not_qdots.update(set(
+                    joint.speeds).difference(self.q.diff(dynamicsymbols._t)))
+            if not_qdots:
+                msgs.append(filldedent(f"""
+                The generalized speeds {not_qdots} are not supported by this
+                method. Only derivatives of the generalized coordinates are
+                supported. If these symbols are used in your expressions, then
+                this will result in wrong equations of motion."""))
+            if self.u_aux:
+                msgs.append(filldedent(f"""
+                This method does not support auxiliary speeds. If these symbols
+                are used in your expressions, then this will result in wrong
+                equations of motion. The auxiliary speeds are {self.u_aux}."""))
+        else:
+            raise NotImplementedError(f'{eom_method} has not been implemented.')
+        if check_duplicates:  # Should be redundant
+            duplicates_to_check = [('generalized coordinates', self.q),
+                                   ('generalized speeds', self.u),
+                                   ('auxiliary speeds', self.u_aux),
+                                   ('bodies', self.bodies),
+                                   ('joints', self.joints)]
+            for name, lst in duplicates_to_check:
+                seen = set()
+                duplicates = {x for x in lst if x in seen or seen.add(x)}
+                if duplicates:
+                    msgs.append(filldedent(f"""
+                    The {name} {duplicates} exist multiple times within the
+                    system."""))
+        if msgs:
+            raise ValueError('\n'.join(msgs))
+
+
+class SymbolicSystem:
+    """SymbolicSystem is a class that contains all the information about a
+    system in a symbolic format such as the equations of motions and the bodies
+    and loads in the system.
+
+    There are three ways that the equations of motion can be described for
+    Symbolic System:
+
+
+        [1] Explicit form where the kinematics and dynamics are combined
+            x' = F_1(x, t, r, p)
+
+        [2] Implicit form where the kinematics and dynamics are combined
+            M_2(x, p) x' = F_2(x, t, r, p)
+
+        [3] Implicit form where the kinematics and dynamics are separate
+            M_3(q, p) u' = F_3(q, u, t, r, p)
+            q' = G(q, u, t, r, p)
+
+    where
+
+    x : states, e.g. [q, u]
+    t : time
+    r : specified (exogenous) inputs
+    p : constants
+    q : generalized coordinates
+    u : generalized speeds
+    F_1 : right hand side of the combined equations in explicit form
+    F_2 : right hand side of the combined equations in implicit form
+    F_3 : right hand side of the dynamical equations in implicit form
+    M_2 : mass matrix of the combined equations in implicit form
+    M_3 : mass matrix of the dynamical equations in implicit form
+    G : right hand side of the kinematical differential equations
+
+        Parameters
+        ==========
+
+        coord_states : ordered iterable of functions of time
+            This input will either be a collection of the coordinates or states
+            of the system depending on whether or not the speeds are also
+            given. If speeds are specified this input will be assumed to
+            be the coordinates otherwise this input will be assumed to
+            be the states.
+
+        right_hand_side : Matrix
+            This variable is the right hand side of the equations of motion in
+            any of the forms. The specific form will be assumed depending on
+            whether a mass matrix or coordinate derivatives are given.
+
+        speeds : ordered iterable of functions of time, optional
+            This is a collection of the generalized speeds of the system. If
+            given it will be assumed that the first argument (coord_states)
+            will represent the generalized coordinates of the system.
+
+        mass_matrix : Matrix, optional
+            The matrix of the implicit forms of the equations of motion (forms
+            [2] and [3]). The distinction between the forms is determined by
+            whether or not the coordinate derivatives are passed in. If
+            they are given form [3] will be assumed otherwise form [2] is
+            assumed.
+
+        coordinate_derivatives : Matrix, optional
+            The right hand side of the kinematical equations in explicit form.
+            If given it will be assumed that the equations of motion are being
+            entered in form [3].
+
+        alg_con : Iterable, optional
+            The indexes of the rows in the equations of motion that contain
+            algebraic constraints instead of differential equations. If the
+            equations are input in form [3], it will be assumed the indexes are
+            referencing the mass_matrix/right_hand_side combination and not the
+            coordinate_derivatives.
+
+        output_eqns : Dictionary, optional
+            Any output equations that are desired to be tracked are stored in a
+            dictionary where the key corresponds to the name given for the
+            specific equation and the value is the equation itself in symbolic
+            form
+
+        coord_idxs : Iterable, optional
+            If coord_states corresponds to the states rather than the
+            coordinates this variable will tell SymbolicSystem which indexes of
+            the states correspond to generalized coordinates.
+
+        speed_idxs : Iterable, optional
+            If coord_states corresponds to the states rather than the
+            coordinates this variable will tell SymbolicSystem which indexes of
+            the states correspond to generalized speeds.
+
+        bodies : iterable of Body/Rigidbody objects, optional
+            Iterable containing the bodies of the system
+
+        loads : iterable of load instances (described below), optional
+            Iterable containing the loads of the system where forces are given
+            by (point of application, force vector) and torques are given by
+            (reference frame acting upon, torque vector). Ex [(point, force),
+            (ref_frame, torque)]
+
+    Attributes
+    ==========
+
+    coordinates : Matrix, shape(n, 1)
+        This is a matrix containing the generalized coordinates of the system
+
+    speeds : Matrix, shape(m, 1)
+        This is a matrix containing the generalized speeds of the system
+
+    states : Matrix, shape(o, 1)
+        This is a matrix containing the state variables of the system
+
+    alg_con : List
+        This list contains the indices of the algebraic constraints in the
+        combined equations of motion. The presence of these constraints
+        requires that a DAE solver be used instead of an ODE solver.
+        If the system is given in form [3] the alg_con variable will be
+        adjusted such that it is a representation of the combined kinematics
+        and dynamics thus make sure it always matches the mass matrix
+        entered.
+
+    dyn_implicit_mat : Matrix, shape(m, m)
+        This is the M matrix in form [3] of the equations of motion (the mass
+        matrix or generalized inertia matrix of the dynamical equations of
+        motion in implicit form).
+
+    dyn_implicit_rhs : Matrix, shape(m, 1)
+        This is the F vector in form [3] of the equations of motion (the right
+        hand side of the dynamical equations of motion in implicit form).
+
+    comb_implicit_mat : Matrix, shape(o, o)
+        This is the M matrix in form [2] of the equations of motion.
+        This matrix contains a block diagonal structure where the top
+        left block (the first rows) represent the matrix in the
+        implicit form of the kinematical equations and the bottom right
+        block (the last rows) represent the matrix in the implicit form
+        of the dynamical equations.
+
+    comb_implicit_rhs : Matrix, shape(o, 1)
+        This is the F vector in form [2] of the equations of motion. The top
+        part of the vector represents the right hand side of the implicit form
+        of the kinemaical equations and the bottom of the vector represents the
+        right hand side of the implicit form of the dynamical equations of
+        motion.
+
+    comb_explicit_rhs : Matrix, shape(o, 1)
+        This vector represents the right hand side of the combined equations of
+        motion in explicit form (form [1] from above).
+
+    kin_explicit_rhs : Matrix, shape(m, 1)
+        This is the right hand side of the explicit form of the kinematical
+        equations of motion as can be seen in form [3] (the G matrix).
+
+    output_eqns : Dictionary
+        If output equations were given they are stored in a dictionary where
+        the key corresponds to the name given for the specific equation and
+        the value is the equation itself in symbolic form
+
+    bodies : Tuple
+        If the bodies in the system were given they are stored in a tuple for
+        future access
+
+    loads : Tuple
+        If the loads in the system were given they are stored in a tuple for
+        future access. This includes forces and torques where forces are given
+        by (point of application, force vector) and torques are given by
+        (reference frame acted upon, torque vector).
+
+    Example
+    =======
+
+    As a simple example, the dynamics of a simple pendulum will be input into a
+    SymbolicSystem object manually. First some imports will be needed and then
+    symbols will be set up for the length of the pendulum (l), mass at the end
+    of the pendulum (m), and a constant for gravity (g). ::
+
+        >>> from sympy import Matrix, sin, symbols
+        >>> from sympy.physics.mechanics import dynamicsymbols, SymbolicSystem
+        >>> l, m, g = symbols('l m g')
+
+    The system will be defined by an angle of theta from the vertical and a
+    generalized speed of omega will be used where omega = theta_dot. ::
+
+        >>> theta, omega = dynamicsymbols('theta omega')
+
+    Now the equations of motion are ready to be formed and passed to the
+    SymbolicSystem object. ::
+
+        >>> kin_explicit_rhs = Matrix([omega])
+        >>> dyn_implicit_mat = Matrix([l**2 * m])
+        >>> dyn_implicit_rhs = Matrix([-g * l * m * sin(theta)])
+        >>> symsystem = SymbolicSystem([theta], dyn_implicit_rhs, [omega],
+        ...                            dyn_implicit_mat)
+
+    Notes
+    =====
+
+    m : number of generalized speeds
+    n : number of generalized coordinates
+    o : number of states
+
+    """
+
+    def __init__(self, coord_states, right_hand_side, speeds=None,
+                 mass_matrix=None, coordinate_derivatives=None, alg_con=None,
+                 output_eqns={}, coord_idxs=None, speed_idxs=None, bodies=None,
+                 loads=None):
+        """Initializes a SymbolicSystem object"""
+
+        # Extract information on speeds, coordinates and states
+        if speeds is None:
+            self._states = Matrix(coord_states)
+
+            if coord_idxs is None:
+                self._coordinates = None
+            else:
+                coords = [coord_states[i] for i in coord_idxs]
+                self._coordinates = Matrix(coords)
+
+            if speed_idxs is None:
+                self._speeds = None
+            else:
+                speeds_inter = [coord_states[i] for i in speed_idxs]
+                self._speeds = Matrix(speeds_inter)
+        else:
+            self._coordinates = Matrix(coord_states)
+            self._speeds = Matrix(speeds)
+            self._states = self._coordinates.col_join(self._speeds)
+
+        # Extract equations of motion form
+        if coordinate_derivatives is not None:
+            self._kin_explicit_rhs = coordinate_derivatives
+            self._dyn_implicit_rhs = right_hand_side
+            self._dyn_implicit_mat = mass_matrix
+            self._comb_implicit_rhs = None
+            self._comb_implicit_mat = None
+            self._comb_explicit_rhs = None
+        elif mass_matrix is not None:
+            self._kin_explicit_rhs = None
+            self._dyn_implicit_rhs = None
+            self._dyn_implicit_mat = None
+            self._comb_implicit_rhs = right_hand_side
+            self._comb_implicit_mat = mass_matrix
+            self._comb_explicit_rhs = None
+        else:
+            self._kin_explicit_rhs = None
+            self._dyn_implicit_rhs = None
+            self._dyn_implicit_mat = None
+            self._comb_implicit_rhs = None
+            self._comb_implicit_mat = None
+            self._comb_explicit_rhs = right_hand_side
+
+        # Set the remainder of the inputs as instance attributes
+        if alg_con is not None and coordinate_derivatives is not None:
+            alg_con = [i + len(coordinate_derivatives) for i in alg_con]
+        self._alg_con = alg_con
+        self.output_eqns = output_eqns
+
+        # Change the body and loads iterables to tuples if they are not tuples
+        # already
+        if not isinstance(bodies, tuple) and bodies is not None:
+            bodies = tuple(bodies)
+        if not isinstance(loads, tuple) and loads is not None:
+            loads = tuple(loads)
+        self._bodies = bodies
+        self._loads = loads
+
+    @property
+    def coordinates(self):
+        """Returns the column matrix of the generalized coordinates"""
+        if self._coordinates is None:
+            raise AttributeError("The coordinates were not specified.")
+        else:
+            return self._coordinates
+
+    @property
+    def speeds(self):
+        """Returns the column matrix of generalized speeds"""
+        if self._speeds is None:
+            raise AttributeError("The speeds were not specified.")
+        else:
+            return self._speeds
+
+    @property
+    def states(self):
+        """Returns the column matrix of the state variables"""
+        return self._states
+
+    @property
+    def alg_con(self):
+        """Returns a list with the indices of the rows containing algebraic
+        constraints in the combined form of the equations of motion"""
+        return self._alg_con
+
+    @property
+    def dyn_implicit_mat(self):
+        """Returns the matrix, M, corresponding to the dynamic equations in
+        implicit form, M x' = F, where the kinematical equations are not
+        included"""
+        if self._dyn_implicit_mat is None:
+            raise AttributeError("dyn_implicit_mat is not specified for "
+                                 "equations of motion form [1] or [2].")
+        else:
+            return self._dyn_implicit_mat
+
+    @property
+    def dyn_implicit_rhs(self):
+        """Returns the column matrix, F, corresponding to the dynamic equations
+        in implicit form, M x' = F, where the kinematical equations are not
+        included"""
+        if self._dyn_implicit_rhs is None:
+            raise AttributeError("dyn_implicit_rhs is not specified for "
+                                 "equations of motion form [1] or [2].")
+        else:
+            return self._dyn_implicit_rhs
+
+    @property
+    def comb_implicit_mat(self):
+        """Returns the matrix, M, corresponding to the equations of motion in
+        implicit form (form [2]), M x' = F, where the kinematical equations are
+        included"""
+        if self._comb_implicit_mat is None:
+            if self._dyn_implicit_mat is not None:
+                num_kin_eqns = len(self._kin_explicit_rhs)
+                num_dyn_eqns = len(self._dyn_implicit_rhs)
+                zeros1 = zeros(num_kin_eqns, num_dyn_eqns)
+                zeros2 = zeros(num_dyn_eqns, num_kin_eqns)
+                inter1 = eye(num_kin_eqns).row_join(zeros1)
+                inter2 = zeros2.row_join(self._dyn_implicit_mat)
+                self._comb_implicit_mat = inter1.col_join(inter2)
+                return self._comb_implicit_mat
+            else:
+                raise AttributeError("comb_implicit_mat is not specified for "
+                                     "equations of motion form [1].")
+        else:
+            return self._comb_implicit_mat
+
+    @property
+    def comb_implicit_rhs(self):
+        """Returns the column matrix, F, corresponding to the equations of
+        motion in implicit form (form [2]), M x' = F, where the kinematical
+        equations are included"""
+        if self._comb_implicit_rhs is None:
+            if self._dyn_implicit_rhs is not None:
+                kin_inter = self._kin_explicit_rhs
+                dyn_inter = self._dyn_implicit_rhs
+                self._comb_implicit_rhs = kin_inter.col_join(dyn_inter)
+                return self._comb_implicit_rhs
+            else:
+                raise AttributeError("comb_implicit_mat is not specified for "
+                                     "equations of motion in form [1].")
+        else:
+            return self._comb_implicit_rhs
+
+    def compute_explicit_form(self):
+        """If the explicit right hand side of the combined equations of motion
+        is to provided upon initialization, this method will calculate it. This
+        calculation can potentially take awhile to compute."""
+        if self._comb_explicit_rhs is not None:
+            raise AttributeError("comb_explicit_rhs is already formed.")
+
+        inter1 = getattr(self, 'kin_explicit_rhs', None)
+        if inter1 is not None:
+            inter2 = self._dyn_implicit_mat.LUsolve(self._dyn_implicit_rhs)
+            out = inter1.col_join(inter2)
+        else:
+            out = self._comb_implicit_mat.LUsolve(self._comb_implicit_rhs)
+
+        self._comb_explicit_rhs = out
+
+    @property
+    def comb_explicit_rhs(self):
+        """Returns the right hand side of the equations of motion in explicit
+        form, x' = F, where the kinematical equations are included"""
+        if self._comb_explicit_rhs is None:
+            raise AttributeError("Please run .combute_explicit_form before "
+                                 "attempting to access comb_explicit_rhs.")
+        else:
+            return self._comb_explicit_rhs
+
+    @property
+    def kin_explicit_rhs(self):
+        """Returns the right hand side of the kinematical equations in explicit
+        form, q' = G"""
+        if self._kin_explicit_rhs is None:
+            raise AttributeError("kin_explicit_rhs is not specified for "
+                                 "equations of motion form [1] or [2].")
+        else:
+            return self._kin_explicit_rhs
+
+    def dynamic_symbols(self):
+        """Returns a column matrix containing all of the symbols in the system
+        that depend on time"""
+        # Create a list of all of the expressions in the equations of motion
+        if self._comb_explicit_rhs is None:
+            eom_expressions = (self.comb_implicit_mat[:] +
+                               self.comb_implicit_rhs[:])
+        else:
+            eom_expressions = (self._comb_explicit_rhs[:])
+
+        functions_of_time = set()
+        for expr in eom_expressions:
+            functions_of_time = functions_of_time.union(
+                find_dynamicsymbols(expr))
+        functions_of_time = functions_of_time.union(self._states)
+
+        return tuple(functions_of_time)
+
+    def constant_symbols(self):
+        """Returns a column matrix containing all of the symbols in the system
+        that do not depend on time"""
+        # Create a list of all of the expressions in the equations of motion
+        if self._comb_explicit_rhs is None:
+            eom_expressions = (self.comb_implicit_mat[:] +
+                               self.comb_implicit_rhs[:])
+        else:
+            eom_expressions = (self._comb_explicit_rhs[:])
+
+        constants = set()
+        for expr in eom_expressions:
+            constants = constants.union(expr.free_symbols)
+        constants.remove(dynamicsymbols._t)
+
+        return tuple(constants)
+
+    @property
+    def bodies(self):
+        """Returns the bodies in the system"""
+        if self._bodies is None:
+            raise AttributeError("bodies were not specified for the system.")
+        else:
+            return self._bodies
+
+    @property
+    def loads(self):
+        """Returns the loads in the system"""
+        if self._loads is None:
+            raise AttributeError("loads were not specified for the system.")
+        else:
+            return self._loads

mplug_owl2/lib/python3.10/site-packages/sympy/physics/mechanics/tests/test_actuator.py

@@ -0,0 +1,851 @@
+"""Tests for the ``sympy.physics.mechanics.actuator.py`` module."""
+
+import pytest
+
+from sympy import (
+    S,
+    Matrix,
+    Symbol,
+    SympifyError,
+    sqrt,
+    Abs
+)
+from sympy.physics.mechanics import (
+    ActuatorBase,
+    Force,
+    ForceActuator,
+    KanesMethod,
+    LinearDamper,
+    LinearPathway,
+    LinearSpring,
+    Particle,
+    PinJoint,
+    Point,
+    ReferenceFrame,
+    RigidBody,
+    TorqueActuator,
+    Vector,
+    dynamicsymbols,
+    DuffingSpring,
+)
+
+from sympy.core.expr import Expr as ExprType
+
+target = RigidBody('target')
+reaction = RigidBody('reaction')
+
+
+class TestForceActuator:
+
+    @pytest.fixture(autouse=True)
+    def _linear_pathway_fixture(self):
+        self.force = Symbol('F')
+        self.pA = Point('pA')
+        self.pB = Point('pB')
+        self.pathway = LinearPathway(self.pA, self.pB)
+        self.q1 = dynamicsymbols('q1')
+        self.q2 = dynamicsymbols('q2')
+        self.q3 = dynamicsymbols('q3')
+        self.q1d = dynamicsymbols('q1', 1)
+        self.q2d = dynamicsymbols('q2', 1)
+        self.q3d = dynamicsymbols('q3', 1)
+        self.N = ReferenceFrame('N')
+
+    def test_is_actuator_base_subclass(self):
+        assert issubclass(ForceActuator, ActuatorBase)
+
+    @pytest.mark.parametrize(
+        'force, expected_force',
+        [
+            (1, S.One),
+            (S.One, S.One),
+            (Symbol('F'), Symbol('F')),
+            (dynamicsymbols('F'), dynamicsymbols('F')),
+            (Symbol('F')**2 + Symbol('F'), Symbol('F')**2 + Symbol('F')),
+        ]
+    )
+    def test_valid_constructor_force(self, force, expected_force):
+        instance = ForceActuator(force, self.pathway)
+        assert isinstance(instance, ForceActuator)
+        assert hasattr(instance, 'force')
+        assert isinstance(instance.force, ExprType)
+        assert instance.force == expected_force
+
+    @pytest.mark.parametrize('force', [None, 'F'])
+    def test_invalid_constructor_force_not_sympifyable(self, force):
+        with pytest.raises(SympifyError):
+            _ = ForceActuator(force, self.pathway)
+
+    @pytest.mark.parametrize(
+        'pathway',
+        [
+            LinearPathway(Point('pA'), Point('pB')),
+        ]
+    )
+    def test_valid_constructor_pathway(self, pathway):
+        instance = ForceActuator(self.force, pathway)
+        assert isinstance(instance, ForceActuator)
+        assert hasattr(instance, 'pathway')
+        assert isinstance(instance.pathway, LinearPathway)
+        assert instance.pathway == pathway
+
+    def test_invalid_constructor_pathway_not_pathway_base(self):
+        with pytest.raises(TypeError):
+            _ = ForceActuator(self.force, None)
+
+    @pytest.mark.parametrize(
+        'property_name, fixture_attr_name',
+        [
+            ('force', 'force'),
+            ('pathway', 'pathway'),
+        ]
+    )
+    def test_properties_are_immutable(self, property_name, fixture_attr_name):
+        instance = ForceActuator(self.force, self.pathway)
+        value = getattr(self, fixture_attr_name)
+        with pytest.raises(AttributeError):
+            setattr(instance, property_name, value)
+
+    def test_repr(self):
+        actuator = ForceActuator(self.force, self.pathway)
+        expected = "ForceActuator(F, LinearPathway(pA, pB))"
+        assert repr(actuator) == expected
+
+    def test_to_loads_static_pathway(self):
+        self.pB.set_pos(self.pA, 2*self.N.x)
+        actuator = ForceActuator(self.force, self.pathway)
+        expected = [
+            (self.pA, - self.force*self.N.x),
+            (self.pB, self.force*self.N.x),
+        ]
+        assert actuator.to_loads() == expected
+
+    def test_to_loads_2D_pathway(self):
+        self.pB.set_pos(self.pA, 2*self.q1*self.N.x)
+        actuator = ForceActuator(self.force, self.pathway)
+        expected = [
+            (self.pA, - self.force*(self.q1/sqrt(self.q1**2))*self.N.x),
+            (self.pB, self.force*(self.q1/sqrt(self.q1**2))*self.N.x),
+        ]
+        assert actuator.to_loads() == expected
+
+    def test_to_loads_3D_pathway(self):
+        self.pB.set_pos(
+            self.pA,
+            self.q1*self.N.x - self.q2*self.N.y + 2*self.q3*self.N.z,
+        )
+        actuator = ForceActuator(self.force, self.pathway)
+        length = sqrt(self.q1**2 + self.q2**2 + 4*self.q3**2)
+        pO_force = (
+            - self.force*self.q1*self.N.x/length
+            + self.force*self.q2*self.N.y/length
+            - 2*self.force*self.q3*self.N.z/length
+        )
+        pI_force = (
+            self.force*self.q1*self.N.x/length
+            - self.force*self.q2*self.N.y/length
+            + 2*self.force*self.q3*self.N.z/length
+        )
+        expected = [
+            (self.pA, pO_force),
+            (self.pB, pI_force),
+        ]
+        assert actuator.to_loads() == expected
+
+
+class TestLinearSpring:
+
+    @pytest.fixture(autouse=True)
+    def _linear_spring_fixture(self):
+        self.stiffness = Symbol('k')
+        self.l = Symbol('l')
+        self.pA = Point('pA')
+        self.pB = Point('pB')
+        self.pathway = LinearPathway(self.pA, self.pB)
+        self.q = dynamicsymbols('q')
+        self.N = ReferenceFrame('N')
+
+    def test_is_force_actuator_subclass(self):
+        assert issubclass(LinearSpring, ForceActuator)
+
+    def test_is_actuator_base_subclass(self):
+        assert issubclass(LinearSpring, ActuatorBase)
+
+    @pytest.mark.parametrize(
+        (
+            'stiffness, '
+            'expected_stiffness, '
+            'equilibrium_length, '
+            'expected_equilibrium_length, '
+            'force'
+        ),
+        [
+            (
+                1,
+                S.One,
+                0,
+                S.Zero,
+                -sqrt(dynamicsymbols('q')**2),
+            ),
+            (
+                Symbol('k'),
+                Symbol('k'),
+                0,
+                S.Zero,
+                -Symbol('k')*sqrt(dynamicsymbols('q')**2),
+            ),
+            (
+                Symbol('k'),
+                Symbol('k'),
+                S.Zero,
+                S.Zero,
+                -Symbol('k')*sqrt(dynamicsymbols('q')**2),
+            ),
+            (
+                Symbol('k'),
+                Symbol('k'),
+                Symbol('l'),
+                Symbol('l'),
+                -Symbol('k')*(sqrt(dynamicsymbols('q')**2) - Symbol('l')),
+            ),
+        ]
+    )
+    def test_valid_constructor(
+        self,
+        stiffness,
+        expected_stiffness,
+        equilibrium_length,
+        expected_equilibrium_length,
+        force,
+    ):
+        self.pB.set_pos(self.pA, self.q*self.N.x)
+        spring = LinearSpring(stiffness, self.pathway, equilibrium_length)
+
+        assert isinstance(spring, LinearSpring)
+
+        assert hasattr(spring, 'stiffness')
+        assert isinstance(spring.stiffness, ExprType)
+        assert spring.stiffness == expected_stiffness
+
+        assert hasattr(spring, 'pathway')
+        assert isinstance(spring.pathway, LinearPathway)
+        assert spring.pathway == self.pathway
+
+        assert hasattr(spring, 'equilibrium_length')
+        assert isinstance(spring.equilibrium_length, ExprType)
+        assert spring.equilibrium_length == expected_equilibrium_length
+
+        assert hasattr(spring, 'force')
+        assert isinstance(spring.force, ExprType)
+        assert spring.force == force
+
+    @pytest.mark.parametrize('stiffness', [None, 'k'])
+    def test_invalid_constructor_stiffness_not_sympifyable(self, stiffness):
+        with pytest.raises(SympifyError):
+            _ = LinearSpring(stiffness, self.pathway, self.l)
+
+    def test_invalid_constructor_pathway_not_pathway_base(self):
+        with pytest.raises(TypeError):
+            _ = LinearSpring(self.stiffness, None, self.l)
+
+    @pytest.mark.parametrize('equilibrium_length', [None, 'l'])
+    def test_invalid_constructor_equilibrium_length_not_sympifyable(
+        self,
+        equilibrium_length,
+    ):
+        with pytest.raises(SympifyError):
+            _ = LinearSpring(self.stiffness, self.pathway, equilibrium_length)
+
+    @pytest.mark.parametrize(
+        'property_name, fixture_attr_name',
+        [
+            ('stiffness', 'stiffness'),
+            ('pathway', 'pathway'),
+            ('equilibrium_length', 'l'),
+        ]
+    )
+    def test_properties_are_immutable(self, property_name, fixture_attr_name):
+        spring = LinearSpring(self.stiffness, self.pathway, self.l)
+        value = getattr(self, fixture_attr_name)
+        with pytest.raises(AttributeError):
+            setattr(spring, property_name, value)
+
+    @pytest.mark.parametrize(
+        'equilibrium_length, expected',
+        [
+            (S.Zero, 'LinearSpring(k, LinearPathway(pA, pB))'),
+            (
+                Symbol('l'),
+                'LinearSpring(k, LinearPathway(pA, pB), equilibrium_length=l)',
+            ),
+        ]
+    )
+    def test_repr(self, equilibrium_length, expected):
+        self.pB.set_pos(self.pA, self.q*self.N.x)
+        spring = LinearSpring(self.stiffness, self.pathway, equilibrium_length)
+        assert repr(spring) == expected
+
+    def test_to_loads(self):
+        self.pB.set_pos(self.pA, self.q*self.N.x)
+        spring = LinearSpring(self.stiffness, self.pathway, self.l)
+        normal = self.q/sqrt(self.q**2)*self.N.x
+        pA_force = self.stiffness*(sqrt(self.q**2) - self.l)*normal
+        pB_force = -self.stiffness*(sqrt(self.q**2) - self.l)*normal
+        expected = [Force(self.pA, pA_force), Force(self.pB, pB_force)]
+        loads = spring.to_loads()
+
+        for load, (point, vector) in zip(loads, expected):
+            assert isinstance(load, Force)
+            assert load.point == point
+            assert (load.vector - vector).simplify() == 0
+
+
+class TestLinearDamper:
+
+    @pytest.fixture(autouse=True)
+    def _linear_damper_fixture(self):
+        self.damping = Symbol('c')
+        self.l = Symbol('l')
+        self.pA = Point('pA')
+        self.pB = Point('pB')
+        self.pathway = LinearPathway(self.pA, self.pB)
+        self.q = dynamicsymbols('q')
+        self.dq = dynamicsymbols('q', 1)
+        self.u = dynamicsymbols('u')
+        self.N = ReferenceFrame('N')
+
+    def test_is_force_actuator_subclass(self):
+        assert issubclass(LinearDamper, ForceActuator)
+
+    def test_is_actuator_base_subclass(self):
+        assert issubclass(LinearDamper, ActuatorBase)
+
+    def test_valid_constructor(self):
+        self.pB.set_pos(self.pA, self.q*self.N.x)
+        damper = LinearDamper(self.damping, self.pathway)
+
+        assert isinstance(damper, LinearDamper)
+
+        assert hasattr(damper, 'damping')
+        assert isinstance(damper.damping, ExprType)
+        assert damper.damping == self.damping
+
+        assert hasattr(damper, 'pathway')
+        assert isinstance(damper.pathway, LinearPathway)
+        assert damper.pathway == self.pathway
+
+    def test_valid_constructor_force(self):
+        self.pB.set_pos(self.pA, self.q*self.N.x)
+        damper = LinearDamper(self.damping, self.pathway)
+
+        expected_force = -self.damping*sqrt(self.q**2)*self.dq/self.q
+        assert hasattr(damper, 'force')
+        assert isinstance(damper.force, ExprType)
+        assert damper.force == expected_force
+
+    @pytest.mark.parametrize('damping', [None, 'c'])
+    def test_invalid_constructor_damping_not_sympifyable(self, damping):
+        with pytest.raises(SympifyError):
+            _ = LinearDamper(damping, self.pathway)
+
+    def test_invalid_constructor_pathway_not_pathway_base(self):
+        with pytest.raises(TypeError):
+            _ = LinearDamper(self.damping, None)
+
+    @pytest.mark.parametrize(
+        'property_name, fixture_attr_name',
+        [
+            ('damping', 'damping'),
+            ('pathway', 'pathway'),
+        ]
+    )
+    def test_properties_are_immutable(self, property_name, fixture_attr_name):
+        damper = LinearDamper(self.damping, self.pathway)
+        value = getattr(self, fixture_attr_name)
+        with pytest.raises(AttributeError):
+            setattr(damper, property_name, value)
+
+    def test_repr(self):
+        self.pB.set_pos(self.pA, self.q*self.N.x)
+        damper = LinearDamper(self.damping, self.pathway)
+        expected = 'LinearDamper(c, LinearPathway(pA, pB))'
+        assert repr(damper) == expected
+
+    def test_to_loads(self):
+        self.pB.set_pos(self.pA, self.q*self.N.x)
+        damper = LinearDamper(self.damping, self.pathway)
+        direction = self.q**2/self.q**2*self.N.x
+        pA_force = self.damping*self.dq*direction
+        pB_force = -self.damping*self.dq*direction
+        expected = [Force(self.pA, pA_force), Force(self.pB, pB_force)]
+        assert damper.to_loads() == expected
+
+
+class TestForcedMassSpringDamperModel():
+    r"""A single degree of freedom translational forced mass-spring-damper.
+
+    Notes
+    =====
+
+    This system is well known to have the governing equation:
+
+    .. math::
+        m \ddot{x} = F - k x - c \dot{x}
+
+    where $F$ is an externally applied force, $m$ is the mass of the particle
+    to which the spring and damper are attached, $k$ is the spring's stiffness,
+    $c$ is the dampers damping coefficient, and $x$ is the generalized
+    coordinate representing the system's single (translational) degree of
+    freedom.
+
+    """
+
+    @pytest.fixture(autouse=True)
+    def _force_mass_spring_damper_model_fixture(self):
+        self.m = Symbol('m')
+        self.k = Symbol('k')
+        self.c = Symbol('c')
+        self.F = Symbol('F')
+
+        self.q = dynamicsymbols('q')
+        self.dq = dynamicsymbols('q', 1)
+        self.u = dynamicsymbols('u')
+
+        self.frame = ReferenceFrame('N')
+        self.origin = Point('pO')
+        self.origin.set_vel(self.frame, 0)
+
+        self.attachment = Point('pA')
+        self.attachment.set_pos(self.origin, self.q*self.frame.x)
+
+        self.mass = Particle('mass', self.attachment, self.m)
+        self.pathway = LinearPathway(self.origin, self.attachment)
+
+        self.kanes_method = KanesMethod(
+            self.frame,
+            q_ind=[self.q],
+            u_ind=[self.u],
+            kd_eqs=[self.dq - self.u],
+        )
+        self.bodies = [self.mass]
+
+        self.mass_matrix = Matrix([[self.m]])
+        self.forcing = Matrix([[self.F - self.c*self.u - self.k*self.q]])
+
+    def test_force_acuator(self):
+        stiffness = -self.k*self.pathway.length
+        spring = ForceActuator(stiffness, self.pathway)
+        damping = -self.c*self.pathway.extension_velocity
+        damper = ForceActuator(damping, self.pathway)
+
+        loads = [
+            (self.attachment, self.F*self.frame.x),
+            *spring.to_loads(),
+            *damper.to_loads(),
+        ]
+        self.kanes_method.kanes_equations(self.bodies, loads)
+
+        assert self.kanes_method.mass_matrix == self.mass_matrix
+        assert self.kanes_method.forcing == self.forcing
+
+    def test_linear_spring_linear_damper(self):
+        spring = LinearSpring(self.k, self.pathway)
+        damper = LinearDamper(self.c, self.pathway)
+
+        loads = [
+            (self.attachment, self.F*self.frame.x),
+            *spring.to_loads(),
+            *damper.to_loads(),
+        ]
+        self.kanes_method.kanes_equations(self.bodies, loads)
+
+        assert self.kanes_method.mass_matrix == self.mass_matrix
+        assert self.kanes_method.forcing == self.forcing
+
+
+class TestTorqueActuator:
+
+    @pytest.fixture(autouse=True)
+    def _torque_actuator_fixture(self):
+        self.torque = Symbol('T')
+        self.N = ReferenceFrame('N')
+        self.A = ReferenceFrame('A')
+        self.axis = self.N.z
+        self.target = RigidBody('target', frame=self.N)
+        self.reaction = RigidBody('reaction', frame=self.A)
+
+    def test_is_actuator_base_subclass(self):
+        assert issubclass(TorqueActuator, ActuatorBase)
+
+    @pytest.mark.parametrize(
+        'torque',
+        [
+            Symbol('T'),
+            dynamicsymbols('T'),
+            Symbol('T')**2 + Symbol('T'),
+        ]
+    )
+    @pytest.mark.parametrize(
+        'target_frame, reaction_frame',
+        [
+            (target.frame, reaction.frame),
+            (target, reaction.frame),
+            (target.frame, reaction),
+            (target, reaction),
+        ]
+    )
+    def test_valid_constructor_with_reaction(
+        self,
+        torque,
+        target_frame,
+        reaction_frame,
+    ):
+        instance = TorqueActuator(
+            torque,
+            self.axis,
+            target_frame,
+            reaction_frame,
+        )
+        assert isinstance(instance, TorqueActuator)
+
+        assert hasattr(instance, 'torque')
+        assert isinstance(instance.torque, ExprType)
+        assert instance.torque == torque
+
+        assert hasattr(instance, 'axis')
+        assert isinstance(instance.axis, Vector)
+        assert instance.axis == self.axis
+
+        assert hasattr(instance, 'target_frame')
+        assert isinstance(instance.target_frame, ReferenceFrame)
+        assert instance.target_frame == target.frame
+
+        assert hasattr(instance, 'reaction_frame')
+        assert isinstance(instance.reaction_frame, ReferenceFrame)
+        assert instance.reaction_frame == reaction.frame
+
+    @pytest.mark.parametrize(
+        'torque',
+        [
+            Symbol('T'),
+            dynamicsymbols('T'),
+            Symbol('T')**2 + Symbol('T'),
+        ]
+    )
+    @pytest.mark.parametrize('target_frame', [target.frame, target])
+    def test_valid_constructor_without_reaction(self, torque, target_frame):
+        instance = TorqueActuator(torque, self.axis, target_frame)
+        assert isinstance(instance, TorqueActuator)
+
+        assert hasattr(instance, 'torque')
+        assert isinstance(instance.torque, ExprType)
+        assert instance.torque == torque
+
+        assert hasattr(instance, 'axis')
+        assert isinstance(instance.axis, Vector)
+        assert instance.axis == self.axis
+
+        assert hasattr(instance, 'target_frame')
+        assert isinstance(instance.target_frame, ReferenceFrame)
+        assert instance.target_frame == target.frame
+
+        assert hasattr(instance, 'reaction_frame')
+        assert instance.reaction_frame is None
+
+    @pytest.mark.parametrize('torque', [None, 'T'])
+    def test_invalid_constructor_torque_not_sympifyable(self, torque):
+        with pytest.raises(SympifyError):
+            _ = TorqueActuator(torque, self.axis, self.target)
+
+    @pytest.mark.parametrize('axis', [Symbol('a'), dynamicsymbols('a')])
+    def test_invalid_constructor_axis_not_vector(self, axis):
+        with pytest.raises(TypeError):
+            _ = TorqueActuator(self.torque, axis, self.target, self.reaction)
+
+    @pytest.mark.parametrize(
+        'frames',
+        [
+            (None, ReferenceFrame('child')),
+            (ReferenceFrame('parent'), True),
+            (None, RigidBody('child')),
+            (RigidBody('parent'), True),
+        ]
+    )
+    def test_invalid_constructor_frames_not_frame(self, frames):
+        with pytest.raises(TypeError):
+            _ = TorqueActuator(self.torque, self.axis, *frames)
+
+    @pytest.mark.parametrize(
+        'property_name, fixture_attr_name',
+        [
+            ('torque', 'torque'),
+            ('axis', 'axis'),
+            ('target_frame', 'target'),
+            ('reaction_frame', 'reaction'),
+        ]
+    )
+    def test_properties_are_immutable(self, property_name, fixture_attr_name):
+        actuator = TorqueActuator(
+            self.torque,
+            self.axis,
+            self.target,
+            self.reaction,
+        )
+        value = getattr(self, fixture_attr_name)
+        with pytest.raises(AttributeError):
+            setattr(actuator, property_name, value)
+
+    def test_repr_without_reaction(self):
+        actuator = TorqueActuator(self.torque, self.axis, self.target)
+        expected = 'TorqueActuator(T, axis=N.z, target_frame=N)'
+        assert repr(actuator) == expected
+
+    def test_repr_with_reaction(self):
+        actuator = TorqueActuator(
+            self.torque,
+            self.axis,
+            self.target,
+            self.reaction,
+        )
+        expected = 'TorqueActuator(T, axis=N.z, target_frame=N, reaction_frame=A)'
+        assert repr(actuator) == expected
+
+    def test_at_pin_joint_constructor(self):
+        pin_joint = PinJoint(
+            'pin',
+            self.target,
+            self.reaction,
+            coordinates=dynamicsymbols('q'),
+            speeds=dynamicsymbols('u'),
+            parent_interframe=self.N,
+            joint_axis=self.axis,
+        )
+        instance = TorqueActuator.at_pin_joint(self.torque, pin_joint)
+        assert isinstance(instance, TorqueActuator)
+
+        assert hasattr(instance, 'torque')
+        assert isinstance(instance.torque, ExprType)
+        assert instance.torque == self.torque
+
+        assert hasattr(instance, 'axis')
+        assert isinstance(instance.axis, Vector)
+        assert instance.axis == self.axis
+
+        assert hasattr(instance, 'target_frame')
+        assert isinstance(instance.target_frame, ReferenceFrame)
+        assert instance.target_frame == self.A
+
+        assert hasattr(instance, 'reaction_frame')
+        assert isinstance(instance.reaction_frame, ReferenceFrame)
+        assert instance.reaction_frame == self.N
+
+    def test_at_pin_joint_pin_joint_not_pin_joint_invalid(self):
+        with pytest.raises(TypeError):
+            _ = TorqueActuator.at_pin_joint(self.torque, Symbol('pin'))
+
+    def test_to_loads_without_reaction(self):
+        actuator = TorqueActuator(self.torque, self.axis, self.target)
+        expected = [
+            (self.N, self.torque*self.axis),
+        ]
+        assert actuator.to_loads() == expected
+
+    def test_to_loads_with_reaction(self):
+        actuator = TorqueActuator(
+            self.torque,
+            self.axis,
+            self.target,
+            self.reaction,
+        )
+        expected = [
+            (self.N, self.torque*self.axis),
+            (self.A, - self.torque*self.axis),
+        ]
+        assert actuator.to_loads() == expected
+
+
+class NonSympifyable:
+    pass
+
+
+class TestDuffingSpring:
+    @pytest.fixture(autouse=True)
+    # Set up common vairables that will be used in multiple tests
+    def _duffing_spring_fixture(self):
+        self.linear_stiffness = Symbol('beta')
+        self.nonlinear_stiffness = Symbol('alpha')
+        self.equilibrium_length = Symbol('l')
+        self.pA = Point('pA')
+        self.pB = Point('pB')
+        self.pathway = LinearPathway(self.pA, self.pB)
+        self.q = dynamicsymbols('q')
+        self.N = ReferenceFrame('N')
+
+    # Simples tests to check that DuffingSpring is a subclass of ForceActuator and ActuatorBase
+    def test_is_force_actuator_subclass(self):
+        assert issubclass(DuffingSpring, ForceActuator)
+
+    def test_is_actuator_base_subclass(self):
+        assert issubclass(DuffingSpring, ActuatorBase)
+
+    @pytest.mark.parametrize(
+    # Create parametrized tests that allows running the same test function multiple times with different sets of arguments
+    (
+        'linear_stiffness,  '
+        'expected_linear_stiffness,  '
+        'nonlinear_stiffness,   '
+        'expected_nonlinear_stiffness,  '
+        'equilibrium_length,    '
+        'expected_equilibrium_length,   '
+        'force'
+    ),
+    [
+            (
+                1,
+                S.One,
+                1,
+                S.One,
+                0,
+                S.Zero,
+                -sqrt(dynamicsymbols('q')**2)-(sqrt(dynamicsymbols('q')**2))**3,
+            ),
+            (
+                Symbol('beta'),
+                Symbol('beta'),
+                Symbol('alpha'),
+                Symbol('alpha'),
+                0,
+                S.Zero,
+                -Symbol('beta')*sqrt(dynamicsymbols('q')**2)-Symbol('alpha')*(sqrt(dynamicsymbols('q')**2))**3,
+            ),
+            (
+                Symbol('beta'),
+                Symbol('beta'),
+                Symbol('alpha'),
+                Symbol('alpha'),
+                S.Zero,
+                S.Zero,
+                -Symbol('beta')*sqrt(dynamicsymbols('q')**2)-Symbol('alpha')*(sqrt(dynamicsymbols('q')**2))**3,
+            ),
+            (
+                Symbol('beta'),
+                Symbol('beta'),
+                Symbol('alpha'),
+                Symbol('alpha'),
+                Symbol('l'),
+                Symbol('l'),
+                -Symbol('beta') * (sqrt(dynamicsymbols('q')**2) - Symbol('l')) - Symbol('alpha') * (sqrt(dynamicsymbols('q')**2) - Symbol('l'))**3,
+            ),
+        ]
+    )
+
+    # Check if DuffingSpring correctly inializes its attributes
+    # It tests various combinations of linear & nonlinear stiffness, equilibriun length, and the resulting force expression
+    def test_valid_constructor(
+        self,
+        linear_stiffness,
+        expected_linear_stiffness,
+        nonlinear_stiffness,
+        expected_nonlinear_stiffness,
+        equilibrium_length,
+        expected_equilibrium_length,
+        force,
+    ):
+        self.pB.set_pos(self.pA, self.q*self.N.x)
+        spring = DuffingSpring(linear_stiffness, nonlinear_stiffness, self.pathway, equilibrium_length)
+
+        assert isinstance(spring, DuffingSpring)
+
+        assert hasattr(spring, 'linear_stiffness')
+        assert isinstance(spring.linear_stiffness, ExprType)
+        assert spring.linear_stiffness == expected_linear_stiffness
+
+        assert hasattr(spring, 'nonlinear_stiffness')
+        assert isinstance(spring.nonlinear_stiffness, ExprType)
+        assert spring.nonlinear_stiffness == expected_nonlinear_stiffness
+
+        assert hasattr(spring, 'pathway')
+        assert isinstance(spring.pathway, LinearPathway)
+        assert spring.pathway == self.pathway
+
+        assert hasattr(spring, 'equilibrium_length')
+        assert isinstance(spring.equilibrium_length, ExprType)
+        assert spring.equilibrium_length == expected_equilibrium_length
+
+        assert hasattr(spring, 'force')
+        assert isinstance(spring.force, ExprType)
+        assert spring.force == force
+
+    @pytest.mark.parametrize('linear_stiffness', [None, NonSympifyable()])
+    def test_invalid_constructor_linear_stiffness_not_sympifyable(self, linear_stiffness):
+        with pytest.raises(SympifyError):
+            _ = DuffingSpring(linear_stiffness, self.nonlinear_stiffness, self.pathway, self.equilibrium_length)
+
+    @pytest.mark.parametrize('nonlinear_stiffness', [None, NonSympifyable()])
+    def test_invalid_constructor_nonlinear_stiffness_not_sympifyable(self, nonlinear_stiffness):
+        with pytest.raises(SympifyError):
+            _ = DuffingSpring(self.linear_stiffness, nonlinear_stiffness, self.pathway, self.equilibrium_length)
+
+    def test_invalid_constructor_pathway_not_pathway_base(self):
+        with pytest.raises(TypeError):
+            _ = DuffingSpring(self.linear_stiffness, self.nonlinear_stiffness, NonSympifyable(), self.equilibrium_length)
+
+    @pytest.mark.parametrize('equilibrium_length', [None, NonSympifyable()])
+    def test_invalid_constructor_equilibrium_length_not_sympifyable(self, equilibrium_length):
+        with pytest.raises(SympifyError):
+            _ = DuffingSpring(self.linear_stiffness, self.nonlinear_stiffness, self.pathway, equilibrium_length)
+
+    @pytest.mark.parametrize(
+        'property_name, fixture_attr_name',
+        [
+            ('linear_stiffness', 'linear_stiffness'),
+            ('nonlinear_stiffness', 'nonlinear_stiffness'),
+            ('pathway', 'pathway'),
+            ('equilibrium_length', 'equilibrium_length')
+        ]
+    )
+    # Check if certain properties of DuffingSpring object are immutable after initialization
+    # Ensure that once DuffingSpring is created, its key properties cannot be changed
+    def test_properties_are_immutable(self, property_name, fixture_attr_name):
+        spring = DuffingSpring(self.linear_stiffness, self.nonlinear_stiffness, self.pathway, self.equilibrium_length)
+        with pytest.raises(AttributeError):
+            setattr(spring, property_name, getattr(self, fixture_attr_name))
+
+    @pytest.mark.parametrize(
+        'equilibrium_length, expected',
+        [
+            (0, 'DuffingSpring(beta, alpha, LinearPathway(pA, pB), equilibrium_length=0)'),
+            (Symbol('l'), 'DuffingSpring(beta, alpha, LinearPathway(pA, pB), equilibrium_length=l)'),
+        ]
+    )
+    # Check the __repr__ method of DuffingSpring class
+    # Check if the actual string representation of DuffingSpring instance matches the expected string for each provided parameter values
+    def test_repr(self, equilibrium_length, expected):
+        spring = DuffingSpring(self.linear_stiffness, self.nonlinear_stiffness, self.pathway, equilibrium_length)
+        assert repr(spring) == expected
+
+    def test_to_loads(self):
+        self.pB.set_pos(self.pA, self.q*self.N.x)
+        spring = DuffingSpring(self.linear_stiffness, self.nonlinear_stiffness, self.pathway, self.equilibrium_length)
+
+        # Calculate the displacement from the equilibrium length
+        displacement = self.q - self.equilibrium_length
+
+        # Make sure this matches the computation in DuffingSpring class
+        force = -self.linear_stiffness * displacement - self.nonlinear_stiffness * displacement**3
+
+        # The expected loads on pA and pB due to the spring
+        expected_loads = [Force(self.pA, force * self.N.x), Force(self.pB, -force * self.N.x)]
+
+        # Compare expected loads to what is returned from DuffingSpring.to_loads()
+        calculated_loads = spring.to_loads()
+        for calculated, expected in zip(calculated_loads, expected_loads):
+            assert calculated.point == expected.point
+            for dim in self.N:  # Assuming self.N is the reference frame
+                calculated_component = calculated.vector.dot(dim)
+                expected_component = expected.vector.dot(dim)
+                # Substitute all symbols with numeric values
+                substitutions = {self.q: 1, Symbol('l'): 1, Symbol('alpha'): 1, Symbol('beta'): 1}  # Add other necessary symbols as needed
+                diff = (calculated_component - expected_component).subs(substitutions).evalf()
+                # Check if the absolute value of the difference is below a threshold
+                assert Abs(diff) < 1e-9, f"The forces do not match. Difference: {diff}"

mplug_owl2/lib/python3.10/site-packages/sympy/physics/mechanics/tests/test_body.py

@@ -0,0 +1,340 @@
+from sympy import (Symbol, symbols, sin, cos, Matrix, zeros,
+                                simplify)
+from sympy.physics.vector import Point, ReferenceFrame, dynamicsymbols, Dyadic
+from sympy.physics.mechanics import inertia, Body
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+
+
+def test_default():
+    with warns_deprecated_sympy():
+        body = Body('body')
+    assert body.name == 'body'
+    assert body.loads == []
+    point = Point('body_masscenter')
+    point.set_vel(body.frame, 0)
+    com = body.masscenter
+    frame = body.frame
+    assert com.vel(frame) == point.vel(frame)
+    assert body.mass == Symbol('body_mass')
+    ixx, iyy, izz = symbols('body_ixx body_iyy body_izz')
+    ixy, iyz, izx = symbols('body_ixy body_iyz body_izx')
+    assert body.inertia == (inertia(body.frame, ixx, iyy, izz, ixy, iyz, izx),
+                            body.masscenter)
+
+
+def test_custom_rigid_body():
+    # Body with RigidBody.
+    rigidbody_masscenter = Point('rigidbody_masscenter')
+    rigidbody_mass = Symbol('rigidbody_mass')
+    rigidbody_frame = ReferenceFrame('rigidbody_frame')
+    body_inertia = inertia(rigidbody_frame, 1, 0, 0)
+    with warns_deprecated_sympy():
+        rigid_body = Body('rigidbody_body', rigidbody_masscenter,
+                          rigidbody_mass, rigidbody_frame, body_inertia)
+    com = rigid_body.masscenter
+    frame = rigid_body.frame
+    rigidbody_masscenter.set_vel(rigidbody_frame, 0)
+    assert com.vel(frame) == rigidbody_masscenter.vel(frame)
+    assert com.pos_from(com) == rigidbody_masscenter.pos_from(com)
+
+    assert rigid_body.mass == rigidbody_mass
+    assert rigid_body.inertia == (body_inertia, rigidbody_masscenter)
+
+    assert rigid_body.is_rigidbody
+
+    assert hasattr(rigid_body, 'masscenter')
+    assert hasattr(rigid_body, 'mass')
+    assert hasattr(rigid_body, 'frame')
+    assert hasattr(rigid_body, 'inertia')
+
+
+def test_particle_body():
+    #  Body with Particle
+    particle_masscenter = Point('particle_masscenter')
+    particle_mass = Symbol('particle_mass')
+    particle_frame = ReferenceFrame('particle_frame')
+    with warns_deprecated_sympy():
+        particle_body = Body('particle_body', particle_masscenter,
+                             particle_mass, particle_frame)
+    com = particle_body.masscenter
+    frame = particle_body.frame
+    particle_masscenter.set_vel(particle_frame, 0)
+    assert com.vel(frame) == particle_masscenter.vel(frame)
+    assert com.pos_from(com) == particle_masscenter.pos_from(com)
+
+    assert particle_body.mass == particle_mass
+    assert not hasattr(particle_body, "_inertia")
+    assert hasattr(particle_body, 'frame')
+    assert hasattr(particle_body, 'masscenter')
+    assert hasattr(particle_body, 'mass')
+    assert particle_body.inertia == (Dyadic(0), particle_body.masscenter)
+    assert particle_body.central_inertia == Dyadic(0)
+    assert not particle_body.is_rigidbody
+
+    particle_body.central_inertia = inertia(particle_frame, 1, 1, 1)
+    assert particle_body.central_inertia == inertia(particle_frame, 1, 1, 1)
+    assert particle_body.is_rigidbody
+
+    with warns_deprecated_sympy():
+        particle_body = Body('particle_body', mass=particle_mass)
+    assert not particle_body.is_rigidbody
+    point = particle_body.masscenter.locatenew('point', particle_body.x)
+    point_inertia = particle_mass * inertia(particle_body.frame, 0, 1, 1)
+    particle_body.inertia = (point_inertia, point)
+    assert particle_body.inertia == (point_inertia, point)
+    assert particle_body.central_inertia == Dyadic(0)
+    assert particle_body.is_rigidbody
+
+
+def test_particle_body_add_force():
+    #  Body with Particle
+    particle_masscenter = Point('particle_masscenter')
+    particle_mass = Symbol('particle_mass')
+    particle_frame = ReferenceFrame('particle_frame')
+    with warns_deprecated_sympy():
+        particle_body = Body('particle_body', particle_masscenter,
+                             particle_mass, particle_frame)
+
+    a = Symbol('a')
+    force_vector = a * particle_body.frame.x
+    particle_body.apply_force(force_vector, particle_body.masscenter)
+    assert len(particle_body.loads) == 1
+    point = particle_body.masscenter.locatenew(
+        particle_body._name + '_point0', 0)
+    point.set_vel(particle_body.frame, 0)
+    force_point = particle_body.loads[0][0]
+
+    frame = particle_body.frame
+    assert force_point.vel(frame) == point.vel(frame)
+    assert force_point.pos_from(force_point) == point.pos_from(force_point)
+
+    assert particle_body.loads[0][1] == force_vector
+
+
+def test_body_add_force():
+    # Body with RigidBody.
+    rigidbody_masscenter = Point('rigidbody_masscenter')
+    rigidbody_mass = Symbol('rigidbody_mass')
+    rigidbody_frame = ReferenceFrame('rigidbody_frame')
+    body_inertia = inertia(rigidbody_frame, 1, 0, 0)
+    with warns_deprecated_sympy():
+        rigid_body = Body('rigidbody_body', rigidbody_masscenter,
+                          rigidbody_mass, rigidbody_frame, body_inertia)
+
+    l = Symbol('l')
+    Fa = Symbol('Fa')
+    point = rigid_body.masscenter.locatenew(
+        'rigidbody_body_point0',
+        l * rigid_body.frame.x)
+    point.set_vel(rigid_body.frame, 0)
+    force_vector = Fa * rigid_body.frame.z
+    # apply_force with point
+    rigid_body.apply_force(force_vector, point)
+    assert len(rigid_body.loads) == 1
+    force_point = rigid_body.loads[0][0]
+    frame = rigid_body.frame
+    assert force_point.vel(frame) == point.vel(frame)
+    assert force_point.pos_from(force_point) == point.pos_from(force_point)
+    assert rigid_body.loads[0][1] == force_vector
+    # apply_force without point
+    rigid_body.apply_force(force_vector)
+    assert len(rigid_body.loads) == 2
+    assert rigid_body.loads[1][1] == force_vector
+    # passing something else than point
+    raises(TypeError, lambda: rigid_body.apply_force(force_vector,  0))
+    raises(TypeError, lambda: rigid_body.apply_force(0))
+
+def test_body_add_torque():
+    with warns_deprecated_sympy():
+        body = Body('body')
+    torque_vector = body.frame.x
+    body.apply_torque(torque_vector)
+
+    assert len(body.loads) == 1
+    assert body.loads[0] == (body.frame, torque_vector)
+    raises(TypeError, lambda: body.apply_torque(0))
+
+def test_body_masscenter_vel():
+    with warns_deprecated_sympy():
+        A = Body('A')
+    N = ReferenceFrame('N')
+    with warns_deprecated_sympy():
+        B = Body('B', frame=N)
+    A.masscenter.set_vel(N, N.z)
+    assert A.masscenter_vel(B) == N.z
+    assert A.masscenter_vel(N) == N.z
+
+def test_body_ang_vel():
+    with warns_deprecated_sympy():
+        A = Body('A')
+    N = ReferenceFrame('N')
+    with warns_deprecated_sympy():
+        B = Body('B', frame=N)
+    A.frame.set_ang_vel(N, N.y)
+    assert A.ang_vel_in(B) == N.y
+    assert B.ang_vel_in(A) == -N.y
+    assert A.ang_vel_in(N) == N.y
+
+def test_body_dcm():
+    with warns_deprecated_sympy():
+        A = Body('A')
+        B = Body('B')
+    A.frame.orient_axis(B.frame, B.frame.z, 10)
+    assert A.dcm(B) == Matrix([[cos(10), sin(10), 0], [-sin(10), cos(10), 0], [0, 0, 1]])
+    assert A.dcm(B.frame) == Matrix([[cos(10), sin(10), 0], [-sin(10), cos(10), 0], [0, 0, 1]])
+
+def test_body_axis():
+    N = ReferenceFrame('N')
+    with warns_deprecated_sympy():
+        B = Body('B', frame=N)
+    assert B.x == N.x
+    assert B.y == N.y
+    assert B.z == N.z
+
+def test_apply_force_multiple_one_point():
+    a, b = symbols('a b')
+    P = Point('P')
+    with warns_deprecated_sympy():
+        B = Body('B')
+    f1 = a*B.x
+    f2 = b*B.y
+    B.apply_force(f1, P)
+    assert B.loads == [(P, f1)]
+    B.apply_force(f2, P)
+    assert B.loads == [(P, f1+f2)]
+
+def test_apply_force():
+    f, g = symbols('f g')
+    q, x, v1, v2 = dynamicsymbols('q x v1 v2')
+    P1 = Point('P1')
+    P2 = Point('P2')
+    with warns_deprecated_sympy():
+        B1 = Body('B1')
+        B2 = Body('B2')
+    N = ReferenceFrame('N')
+
+    P1.set_vel(B1.frame, v1*B1.x)
+    P2.set_vel(B2.frame, v2*B2.x)
+    force = f*q*N.z # time varying force
+
+    B1.apply_force(force, P1, B2, P2) #applying equal and opposite force on moving points
+    assert B1.loads == [(P1, force)]
+    assert B2.loads == [(P2, -force)]
+
+    g1 = B1.mass*g*N.y
+    g2 = B2.mass*g*N.y
+
+    B1.apply_force(g1) #applying gravity on B1 masscenter
+    B2.apply_force(g2) #applying gravity on B2 masscenter
+
+    assert B1.loads == [(P1,force), (B1.masscenter, g1)]
+    assert B2.loads == [(P2, -force), (B2.masscenter, g2)]
+
+    force2 = x*N.x
+
+    B1.apply_force(force2, reaction_body=B2) #Applying time varying force on masscenter
+
+    assert B1.loads == [(P1, force), (B1.masscenter, force2+g1)]
+    assert B2.loads == [(P2, -force), (B2.masscenter, -force2+g2)]
+
+def test_apply_torque():
+    t = symbols('t')
+    q = dynamicsymbols('q')
+    with warns_deprecated_sympy():
+        B1 = Body('B1')
+        B2 = Body('B2')
+    N = ReferenceFrame('N')
+    torque = t*q*N.x
+
+    B1.apply_torque(torque, B2) #Applying equal and opposite torque
+    assert B1.loads == [(B1.frame, torque)]
+    assert B2.loads == [(B2.frame, -torque)]
+
+    torque2 = t*N.y
+    B1.apply_torque(torque2)
+    assert B1.loads == [(B1.frame, torque+torque2)]
+
+def test_clear_load():
+    a = symbols('a')
+    P = Point('P')
+    with warns_deprecated_sympy():
+        B = Body('B')
+    force = a*B.z
+    B.apply_force(force, P)
+    assert B.loads == [(P, force)]
+    B.clear_loads()
+    assert B.loads == []
+
+def test_remove_load():
+    P1 = Point('P1')
+    P2 = Point('P2')
+    with warns_deprecated_sympy():
+        B = Body('B')
+    f1 = B.x
+    f2 = B.y
+    B.apply_force(f1, P1)
+    B.apply_force(f2, P2)
+    assert B.loads == [(P1, f1), (P2, f2)]
+    B.remove_load(P2)
+    assert B.loads == [(P1, f1)]
+    B.apply_torque(f1.cross(f2))
+    assert B.loads == [(P1, f1), (B.frame, f1.cross(f2))]
+    B.remove_load()
+    assert B.loads == [(P1, f1)]
+
+def test_apply_loads_on_multi_degree_freedom_holonomic_system():
+    """Example based on: https://pydy.readthedocs.io/en/latest/examples/multidof-holonomic.html"""
+    with warns_deprecated_sympy():
+        W = Body('W') #Wall
+        B = Body('B') #Block
+        P = Body('P') #Pendulum
+        b = Body('b') #bob
+    q1, q2 = dynamicsymbols('q1 q2') #generalized coordinates
+    k, c, g, kT = symbols('k c g kT') #constants
+    F, T = dynamicsymbols('F T') #Specified forces
+
+    #Applying forces
+    B.apply_force(F*W.x)
+    W.apply_force(k*q1*W.x, reaction_body=B) #Spring force
+    W.apply_force(c*q1.diff()*W.x, reaction_body=B) #dampner
+    P.apply_force(P.mass*g*W.y)
+    b.apply_force(b.mass*g*W.y)
+
+    #Applying torques
+    P.apply_torque(kT*q2*W.z, reaction_body=b)
+    P.apply_torque(T*W.z)
+
+    assert B.loads == [(B.masscenter, (F - k*q1 - c*q1.diff())*W.x)]
+    assert P.loads == [(P.masscenter, P.mass*g*W.y), (P.frame, (T + kT*q2)*W.z)]
+    assert b.loads == [(b.masscenter, b.mass*g*W.y), (b.frame, -kT*q2*W.z)]
+    assert W.loads == [(W.masscenter, (c*q1.diff() + k*q1)*W.x)]
+
+
+def test_parallel_axis():
+    N = ReferenceFrame('N')
+    m, Ix, Iy, Iz, a, b = symbols('m, I_x, I_y, I_z, a, b')
+    Io = inertia(N, Ix, Iy, Iz)
+    # Test RigidBody
+    o = Point('o')
+    p = o.locatenew('p', a * N.x + b * N.y)
+    with warns_deprecated_sympy():
+        R = Body('R', masscenter=o, frame=N, mass=m, central_inertia=Io)
+    Ip = R.parallel_axis(p)
+    Ip_expected = inertia(N, Ix + m * b**2, Iy + m * a**2,
+                          Iz + m * (a**2 + b**2), ixy=-m * a * b)
+    assert Ip == Ip_expected
+    # Reference frame from which the parallel axis is viewed should not matter
+    A = ReferenceFrame('A')
+    A.orient_axis(N, N.z, 1)
+    assert simplify(
+        (R.parallel_axis(p, A) - Ip_expected).to_matrix(A)) == zeros(3, 3)
+    # Test Particle
+    o = Point('o')
+    p = o.locatenew('p', a * N.x + b * N.y)
+    with warns_deprecated_sympy():
+        P = Body('P', masscenter=o, mass=m, frame=N)
+    Ip = P.parallel_axis(p, N)
+    Ip_expected = inertia(N, m * b ** 2, m * a ** 2, m * (a ** 2 + b ** 2),
+                          ixy=-m * a * b)
+    assert not P.is_rigidbody
+    assert Ip == Ip_expected

mplug_owl2/lib/python3.10/site-packages/sympy/physics/mechanics/tests/test_functions.py

@@ -0,0 +1,262 @@
+from sympy import sin, cos, tan, pi, symbols, Matrix, S, Function
+from sympy.physics.mechanics import (Particle, Point, ReferenceFrame,
+                                     RigidBody)
+from sympy.physics.mechanics import (angular_momentum, dynamicsymbols,
+                                     kinetic_energy, linear_momentum,
+                                     outer, potential_energy, msubs,
+                                     find_dynamicsymbols, Lagrangian)
+
+from sympy.physics.mechanics.functions import (
+    center_of_mass, _validate_coordinates, _parse_linear_solver)
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+
+
+q1, q2, q3, q4, q5 = symbols('q1 q2 q3 q4 q5')
+N = ReferenceFrame('N')
+A = N.orientnew('A', 'Axis', [q1, N.z])
+B = A.orientnew('B', 'Axis', [q2, A.x])
+C = B.orientnew('C', 'Axis', [q3, B.y])
+
+
+def test_linear_momentum():
+    N = ReferenceFrame('N')
+    Ac = Point('Ac')
+    Ac.set_vel(N, 25 * N.y)
+    I = outer(N.x, N.x)
+    A = RigidBody('A', Ac, N, 20, (I, Ac))
+    P = Point('P')
+    Pa = Particle('Pa', P, 1)
+    Pa.point.set_vel(N, 10 * N.x)
+    raises(TypeError, lambda: linear_momentum(A, A, Pa))
+    raises(TypeError, lambda: linear_momentum(N, N, Pa))
+    assert linear_momentum(N, A, Pa) == 10 * N.x + 500 * N.y
+
+
+def test_angular_momentum_and_linear_momentum():
+    """A rod with length 2l, centroidal inertia I, and mass M along with a
+    particle of mass m fixed to the end of the rod rotate with an angular rate
+    of omega about point O which is fixed to the non-particle end of the rod.
+    The rod's reference frame is A and the inertial frame is N."""
+    m, M, l, I = symbols('m, M, l, I')
+    omega = dynamicsymbols('omega')
+    N = ReferenceFrame('N')
+    a = ReferenceFrame('a')
+    O = Point('O')
+    Ac = O.locatenew('Ac', l * N.x)
+    P = Ac.locatenew('P', l * N.x)
+    O.set_vel(N, 0 * N.x)
+    a.set_ang_vel(N, omega * N.z)
+    Ac.v2pt_theory(O, N, a)
+    P.v2pt_theory(O, N, a)
+    Pa = Particle('Pa', P, m)
+    A = RigidBody('A', Ac, a, M, (I * outer(N.z, N.z), Ac))
+    expected = 2 * m * omega * l * N.y + M * l * omega * N.y
+    assert linear_momentum(N, A, Pa) == expected
+    raises(TypeError, lambda: angular_momentum(N, N, A, Pa))
+    raises(TypeError, lambda: angular_momentum(O, O, A, Pa))
+    raises(TypeError, lambda: angular_momentum(O, N, O, Pa))
+    expected = (I + M * l**2 + 4 * m * l**2) * omega * N.z
+    assert angular_momentum(O, N, A, Pa) == expected
+
+
+def test_kinetic_energy():
+    m, M, l1 = symbols('m M l1')
+    omega = dynamicsymbols('omega')
+    N = ReferenceFrame('N')
+    O = Point('O')
+    O.set_vel(N, 0 * N.x)
+    Ac = O.locatenew('Ac', l1 * N.x)
+    P = Ac.locatenew('P', l1 * N.x)
+    a = ReferenceFrame('a')
+    a.set_ang_vel(N, omega * N.z)
+    Ac.v2pt_theory(O, N, a)
+    P.v2pt_theory(O, N, a)
+    Pa = Particle('Pa', P, m)
+    I = outer(N.z, N.z)
+    A = RigidBody('A', Ac, a, M, (I, Ac))
+    raises(TypeError, lambda: kinetic_energy(Pa, Pa, A))
+    raises(TypeError, lambda: kinetic_energy(N, N, A))
+    assert 0 == (kinetic_energy(N, Pa, A) - (M*l1**2*omega**2/2
+            + 2*l1**2*m*omega**2 + omega**2/2)).expand()
+
+
+def test_potential_energy():
+    m, M, l1, g, h, H = symbols('m M l1 g h H')
+    omega = dynamicsymbols('omega')
+    N = ReferenceFrame('N')
+    O = Point('O')
+    O.set_vel(N, 0 * N.x)
+    Ac = O.locatenew('Ac', l1 * N.x)
+    P = Ac.locatenew('P', l1 * N.x)
+    a = ReferenceFrame('a')
+    a.set_ang_vel(N, omega * N.z)
+    Ac.v2pt_theory(O, N, a)
+    P.v2pt_theory(O, N, a)
+    Pa = Particle('Pa', P, m)
+    I = outer(N.z, N.z)
+    A = RigidBody('A', Ac, a, M, (I, Ac))
+    Pa.potential_energy = m * g * h
+    A.potential_energy = M * g * H
+    assert potential_energy(A, Pa) == m * g * h + M * g * H
+
+
+def test_Lagrangian():
+    M, m, g, h = symbols('M m g h')
+    N = ReferenceFrame('N')
+    O = Point('O')
+    O.set_vel(N, 0 * N.x)
+    P = O.locatenew('P', 1 * N.x)
+    P.set_vel(N, 10 * N.x)
+    Pa = Particle('Pa', P, 1)
+    Ac = O.locatenew('Ac', 2 * N.y)
+    Ac.set_vel(N, 5 * N.y)
+    a = ReferenceFrame('a')
+    a.set_ang_vel(N, 10 * N.z)
+    I = outer(N.z, N.z)
+    A = RigidBody('A', Ac, a, 20, (I, Ac))
+    Pa.potential_energy = m * g * h
+    A.potential_energy = M * g * h
+    raises(TypeError, lambda: Lagrangian(A, A, Pa))
+    raises(TypeError, lambda: Lagrangian(N, N, Pa))
+
+
+def test_msubs():
+    a, b = symbols('a, b')
+    x, y, z = dynamicsymbols('x, y, z')
+    # Test simple substitution
+    expr = Matrix([[a*x + b, x*y.diff() + y],
+                   [x.diff().diff(), z + sin(z.diff())]])
+    sol = Matrix([[a + b, y],
+                  [x.diff().diff(), 1]])
+    sd = {x: 1, z: 1, z.diff(): 0, y.diff(): 0}
+    assert msubs(expr, sd) == sol
+    # Test smart substitution
+    expr = cos(x + y)*tan(x + y) + b*x.diff()
+    sd = {x: 0, y: pi/2, x.diff(): 1}
+    assert msubs(expr, sd, smart=True) == b + 1
+    N = ReferenceFrame('N')
+    v = x*N.x + y*N.y
+    d = x*(N.x|N.x) + y*(N.y|N.y)
+    v_sol = 1*N.y
+    d_sol = 1*(N.y|N.y)
+    sd = {x: 0, y: 1}
+    assert msubs(v, sd) == v_sol
+    assert msubs(d, sd) == d_sol
+
+
+def test_find_dynamicsymbols():
+    a, b = symbols('a, b')
+    x, y, z = dynamicsymbols('x, y, z')
+    expr = Matrix([[a*x + b, x*y.diff() + y],
+                   [x.diff().diff(), z + sin(z.diff())]])
+    # Test finding all dynamicsymbols
+    sol = {x, y.diff(), y, x.diff().diff(), z, z.diff()}
+    assert find_dynamicsymbols(expr) == sol
+    # Test finding all but those in sym_list
+    exclude_list = [x, y, z]
+    sol = {y.diff(), x.diff().diff(), z.diff()}
+    assert find_dynamicsymbols(expr, exclude=exclude_list) == sol
+    # Test finding all dynamicsymbols in a vector with a given reference frame
+    d, e, f = dynamicsymbols('d, e, f')
+    A = ReferenceFrame('A')
+    v = d * A.x + e * A.y + f * A.z
+    sol = {d, e, f}
+    assert find_dynamicsymbols(v, reference_frame=A) == sol
+    # Test if a ValueError is raised on supplying only a vector as input
+    raises(ValueError, lambda: find_dynamicsymbols(v))
+
+
+# This function tests the center_of_mass() function
+# that was added in PR #14758 to compute the center of
+# mass of a system of bodies.
+def test_center_of_mass():
+    a = ReferenceFrame('a')
+    m = symbols('m', real=True)
+    p1 = Particle('p1', Point('p1_pt'), S.One)
+    p2 = Particle('p2', Point('p2_pt'), S(2))
+    p3 = Particle('p3', Point('p3_pt'), S(3))
+    p4 = Particle('p4', Point('p4_pt'), m)
+    b_f = ReferenceFrame('b_f')
+    b_cm = Point('b_cm')
+    mb = symbols('mb')
+    b = RigidBody('b', b_cm, b_f, mb, (outer(b_f.x, b_f.x), b_cm))
+    p2.point.set_pos(p1.point, a.x)
+    p3.point.set_pos(p1.point, a.x + a.y)
+    p4.point.set_pos(p1.point, a.y)
+    b.masscenter.set_pos(p1.point, a.y + a.z)
+    point_o=Point('o')
+    point_o.set_pos(p1.point, center_of_mass(p1.point, p1, p2, p3, p4, b))
+    expr = 5/(m + mb + 6)*a.x + (m + mb + 3)/(m + mb + 6)*a.y + mb/(m + mb + 6)*a.z
+    assert point_o.pos_from(p1.point)-expr == 0
+
+
+def test_validate_coordinates():
+    q1, q2, q3, u1, u2, u3, ua1, ua2, ua3 = dynamicsymbols('q1:4 u1:4 ua1:4')
+    s1, s2, s3 = symbols('s1:4')
+    # Test normal
+    _validate_coordinates([q1, q2, q3], [u1, u2, u3],
+                          u_auxiliary=[ua1, ua2, ua3])
+    # Test not equal number of coordinates and speeds
+    _validate_coordinates([q1, q2])
+    _validate_coordinates([q1, q2], [u1])
+    _validate_coordinates(speeds=[u1, u2])
+    # Test duplicate
+    _validate_coordinates([q1, q2, q2], [u1, u2, u3], check_duplicates=False)
+    raises(ValueError, lambda: _validate_coordinates(
+        [q1, q2, q2], [u1, u2, u3]))
+    _validate_coordinates([q1, q2, q3], [u1, u2, u2], check_duplicates=False)
+    raises(ValueError, lambda: _validate_coordinates(
+        [q1, q2, q3], [u1, u2, u2], check_duplicates=True))
+    raises(ValueError, lambda: _validate_coordinates(
+        [q1, q2, q3], [q1, u2, u3], check_duplicates=True))
+    _validate_coordinates([q1, q2, q3], [u1, u2, u3], check_duplicates=False,
+                          u_auxiliary=[u1, ua2, ua2])
+    raises(ValueError, lambda: _validate_coordinates(
+        [q1, q2, q3], [u1, u2, u3], u_auxiliary=[u1, ua2, ua3]))
+    raises(ValueError, lambda: _validate_coordinates(
+        [q1, q2, q3], [u1, u2, u3], u_auxiliary=[q1, ua2, ua3]))
+    raises(ValueError, lambda: _validate_coordinates(
+        [q1, q2, q3], [u1, u2, u3], u_auxiliary=[ua1, ua2, ua2]))
+    # Test is_dynamicsymbols
+    _validate_coordinates([q1 + q2, q3], is_dynamicsymbols=False)
+    raises(ValueError, lambda: _validate_coordinates([q1 + q2, q3]))
+    _validate_coordinates([s1, q1, q2], [0, u1, u2], is_dynamicsymbols=False)
+    raises(ValueError, lambda: _validate_coordinates(
+        [s1, q1, q2], [0, u1, u2], is_dynamicsymbols=True))
+    _validate_coordinates([s1 + s2 + s3, q1], [0, u1], is_dynamicsymbols=False)
+    raises(ValueError, lambda: _validate_coordinates(
+        [s1 + s2 + s3, q1], [0, u1], is_dynamicsymbols=True))
+    _validate_coordinates(u_auxiliary=[s1, ua1], is_dynamicsymbols=False)
+    raises(ValueError, lambda: _validate_coordinates(u_auxiliary=[s1, ua1]))
+    # Test normal function
+    t = dynamicsymbols._t
+    a = symbols('a')
+    f1, f2 = symbols('f1:3', cls=Function)
+    _validate_coordinates([f1(a), f2(a)], is_dynamicsymbols=False)
+    raises(ValueError, lambda: _validate_coordinates([f1(a), f2(a)]))
+    raises(ValueError, lambda: _validate_coordinates(speeds=[f1(a), f2(a)]))
+    dynamicsymbols._t = a
+    _validate_coordinates([f1(a), f2(a)])
+    raises(ValueError, lambda: _validate_coordinates([f1(t), f2(t)]))
+    dynamicsymbols._t = t
+
+
+def test_parse_linear_solver():
+    A, b = Matrix(3, 3, symbols('a:9')), Matrix(3, 2, symbols('b:6'))
+    assert _parse_linear_solver(Matrix.LUsolve) == Matrix.LUsolve  # Test callable
+    assert _parse_linear_solver('LU')(A, b) == Matrix.LUsolve(A, b)
+
+
+def test_deprecated_moved_functions():
+    from sympy.physics.mechanics.functions import (
+        inertia, inertia_of_point_mass, gravity)
+    N = ReferenceFrame('N')
+    with warns_deprecated_sympy():
+        assert inertia(N, 0, 1, 0, 1) == (N.x | N.y) + (N.y | N.x) + (N.y | N.y)
+    with warns_deprecated_sympy():
+        assert inertia_of_point_mass(1, N.x + N.y, N) == (
+            (N.x | N.x) + (N.y | N.y) + 2 * (N.z | N.z) -
+            (N.x | N.y) - (N.y | N.x))
+    p = Particle('P')
+    with warns_deprecated_sympy():
+        assert gravity(-2 * N.z, p) == [(p.masscenter, -2 * p.mass * N.z)]

mplug_owl2/lib/python3.10/site-packages/sympy/physics/mechanics/tests/test_inertia.py

@@ -0,0 +1,71 @@
+from sympy import symbols
+from sympy.testing.pytest import raises
+from sympy.physics.mechanics import (inertia, inertia_of_point_mass,
+                                     Inertia, ReferenceFrame, Point)
+
+
+def test_inertia_dyadic():
+    N = ReferenceFrame('N')
+    ixx, iyy, izz = symbols('ixx iyy izz')
+    ixy, iyz, izx = symbols('ixy iyz izx')
+    assert inertia(N, ixx, iyy, izz) == (ixx * (N.x | N.x) + iyy *
+            (N.y | N.y) + izz * (N.z | N.z))
+    assert inertia(N, 0, 0, 0) == 0 * (N.x | N.x)
+    raises(TypeError, lambda: inertia(0, 0, 0, 0))
+    assert inertia(N, ixx, iyy, izz, ixy, iyz, izx) == (ixx * (N.x | N.x) +
+            ixy * (N.x | N.y) + izx * (N.x | N.z) + ixy * (N.y | N.x) + iyy *
+        (N.y | N.y) + iyz * (N.y | N.z) + izx * (N.z | N.x) + iyz * (N.z |
+            N.y) + izz * (N.z | N.z))
+
+
+def test_inertia_of_point_mass():
+    r, s, t, m = symbols('r s t m')
+    N = ReferenceFrame('N')
+
+    px = r * N.x
+    I = inertia_of_point_mass(m, px, N)
+    assert I == m * r**2 * (N.y | N.y) + m * r**2 * (N.z | N.z)
+
+    py = s * N.y
+    I = inertia_of_point_mass(m, py, N)
+    assert I == m * s**2 * (N.x | N.x) + m * s**2 * (N.z | N.z)
+
+    pz = t * N.z
+    I = inertia_of_point_mass(m, pz, N)
+    assert I == m * t**2 * (N.x | N.x) + m * t**2 * (N.y | N.y)
+
+    p = px + py + pz
+    I = inertia_of_point_mass(m, p, N)
+    assert I == (m * (s**2 + t**2) * (N.x | N.x) -
+                 m * r * s * (N.x | N.y) -
+                 m * r * t * (N.x | N.z) -
+                 m * r * s * (N.y | N.x) +
+                 m * (r**2 + t**2) * (N.y | N.y) -
+                 m * s * t * (N.y | N.z) -
+                 m * r * t * (N.z | N.x) -
+                 m * s * t * (N.z | N.y) +
+                 m * (r**2 + s**2) * (N.z | N.z))
+
+
+def test_inertia_object():
+    N = ReferenceFrame('N')
+    O = Point('O')
+    ixx, iyy, izz = symbols('ixx iyy izz')
+    I_dyadic = ixx * (N.x | N.x) + iyy * (N.y | N.y) + izz * (N.z | N.z)
+    I = Inertia(inertia(N, ixx, iyy, izz), O)
+    assert isinstance(I, tuple)
+    assert I.__repr__() == ('Inertia(dyadic=ixx*(N.x|N.x) + iyy*(N.y|N.y) + '
+                            'izz*(N.z|N.z), point=O)')
+    assert I.dyadic == I_dyadic
+    assert I.point == O
+    assert I[0] == I_dyadic
+    assert I[1] == O
+    assert I == (I_dyadic, O)  # Test tuple equal
+    raises(TypeError, lambda: I != (O, I_dyadic))  # Incorrect tuple order
+    assert I == Inertia(O, I_dyadic)  # Parse changed argument order
+    assert I == Inertia.from_inertia_scalars(O, N, ixx, iyy, izz)
+    # Test invalid tuple operations
+    raises(TypeError, lambda: I + (1, 2))
+    raises(TypeError, lambda: (1, 2) + I)
+    raises(TypeError, lambda: I * 2)
+    raises(TypeError, lambda: 2 * I)