Joints Framework in Physics/Mechanics#
sympy.physics.mechanics
provides a joints framework. This system consists
of two parts. The first are the joints
themselves, which are used to create connections between
bodies
. The second part is the
JointsMethod
, which is used to form the equations of motion. Both of
these parts are doing what we can call “book-keeping”: keeping track of the
relationships between bodies
.
Joints in Physics/Mechanics#
The general task of the joints
is creating
kinematic relationships between
bodies
. Each joint has a setup as
shown in the image below (this is the example of the PrismaticJoint
).

As can be seen in this image, each joint needs several objects in order to
define the relationships. First off it needs two bodies: the parent body (shown
in green) and the child body (shown in blue). Both of these bodies have a mass
center from which the position of the joint is defined. In the parent body the
vector from the mass center to the parent_point
is called the
parent_joint_pos
. For the child body these are called the child_point
and child_joint_pos
. The orientation of the joint in each body is defined by
the parent_axis
and child_axis
. These two vectors are aligned as
explained in the Joint
notes and are in the image parallel to the
red vector. As last the joint also needs dynamicsymbols()
as generalized
coordinates and speeds. In the case of the PrismaticJoint
shown
above, the generalized coordinate q_1
distance along the joint axis.
And the generalized speed u_1
is its velocity.
With the information listed above, the joint defines the following relationships. It first defines the kinematic differential equations, which relate the generalized coordinates to the generalized speeds. Next, it orients the parent and child body with respect to each other. After which it also defines their velocity relationships.
The following code shows the creation of a PrismaticJoint
as shown
above with arbitrary linked position vectors:
>>> from sympy.physics.mechanics import *
>>> mechanics_printing(pretty_print=False)
>>> q1, u1 = dynamicsymbols('q1, u1')
>>> parent = Body('parent')
>>> child = Body('child')
>>> joint = PrismaticJoint(
... 'slider', parent, child, q1, u1,
... parent_joint_pos=parent.frame.x / 2 + parent.frame.y / 10,
... child_joint_pos=-(child.frame.x + child.frame.y) / 10,
... parent_axis=parent.frame.x, child_axis=child.frame.x)
>>> joint.kdes
[u1 - q1']
>>> child.masscenter.pos_from(parent.masscenter)
(q1 + 1/2)*parent_frame.x + 1/10*parent_frame.y + 1/10*child_frame.x + 1/10*child_frame.y
>>> child.masscenter.vel(parent.frame)
u1*parent_frame.x
JointsMethod in Physics/Mechanics#
After defining the entire system you can use the JointsMethod
to
parse the system and form the equations of motion. In this process the
JointsMethod
only does the “book-keeping” of the joints. It uses
another method, like the KanesMethod
, as its backend for forming the
equations of motion.
In the code below we form the equations of motion of the single
PrismaticJoint
above.
>>> method = JointsMethod(parent, joint)
>>> method.form_eoms()
Matrix([[-child_mass*u1']])
>>> type(method.method) # The method working in the backend
<class 'sympy.physics.mechanics.kane.KanesMethod'>