# Essential Components (Docstrings)¶

## ReferenceFrame¶

class sympy.physics.mechanics.essential.ReferenceFrame(name, indices=None, latexs=None)[source]

A reference frame in classical mechanics.

ReferenceFrame is a class used to represent a reference frame in classical mechanics. It has a standard basis of three unit vectors in the frame’s x, y, and z directions.

It also can have a rotation relative to a parent frame; this rotation is defined by a direction cosine matrix relating this frame’s basis vectors to the parent frame’s basis vectors. It can also have an angular velocity vector, defined in another frame.

ang_acc_in(otherframe)[source]

Returns the angular acceleration Vector of the ReferenceFrame.

Effectively returns the Vector: ^N alpha ^B which represent the angular acceleration of B in N, where B is self, and N is otherframe.

Parameters : otherframe : ReferenceFrame The ReferenceFrame which the angular acceleration is returned in.

Examples

>>> from sympy.physics.mechanics import ReferenceFrame, Vector
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> V = 10 * N.x
>>> A.set_ang_acc(N, V)
>>> A.ang_acc_in(N)
10*N.x

ang_vel_in(otherframe)[source]

Returns the angular velocity Vector of the ReferenceFrame.

Effectively returns the Vector: ^N omega ^B which represent the angular velocity of B in N, where B is self, and N is otherframe.

Parameters : otherframe : ReferenceFrame The ReferenceFrame which the angular velocity is returned in.

Examples

>>> from sympy.physics.mechanics import ReferenceFrame, Vector
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> V = 10 * N.x
>>> A.set_ang_vel(N, V)
>>> A.ang_vel_in(N)
10*N.x

dcm(otherframe)[source]

The direction cosine matrix between frames.

This gives the DCM between this frame and the otherframe. The format is N.xyz = N.dcm(B) * B.xyz A SymPy Matrix is returned.

Parameters : otherframe : ReferenceFrame The otherframe which the DCM is generated to.

Examples

>>> from sympy.physics.mechanics import ReferenceFrame, Vector
>>> from sympy import symbols
>>> q1 = symbols('q1')
>>> N = ReferenceFrame('N')
>>> A = N.orientnew('A', 'Axis', [q1, N.x])
>>> N.dcm(A)
Matrix([
[1,       0,        0],
[0, cos(q1), -sin(q1)],
[0, sin(q1),  cos(q1)]])

orient(parent, rot_type, amounts, rot_order='')[source]

Defines the orientation of this frame relative to a parent frame.

Parameters : parent : ReferenceFrame The frame that this ReferenceFrame will have its orientation matrix defined in relation to. rot_type : str The type of orientation matrix that is being created. Supported types are ‘Body’, ‘Space’, ‘Quaternion’, and ‘Axis’. See examples for correct usage. amounts : list OR value The quantities that the orientation matrix will be defined by. rot_order : str If applicable, the order of a series of rotations.

Examples

>>> from sympy.physics.mechanics import ReferenceFrame, Vector
>>> from sympy import symbols
>>> q0, q1, q2, q3, q4 = symbols('q0 q1 q2 q3 q4')
>>> N = ReferenceFrame('N')
>>> B = ReferenceFrame('B')


Now we have a choice of how to implement the orientation. First is Body. Body orientation takes this reference frame through three successive simple rotations. Acceptable rotation orders are of length 3, expressed in XYZ or 123, and cannot have a rotation about about an axis twice in a row.

>>> B.orient(N, 'Body', [q1, q2, q3], '123')
>>> B.orient(N, 'Body', [q1, q2, 0], 'ZXZ')
>>> B.orient(N, 'Body', [0, 0, 0], 'XYX')


Next is Space. Space is like Body, but the rotations are applied in the opposite order.

>>> B.orient(N, 'Space', [q1, q2, q3], '312')


Next is Quaternion. This orients the new ReferenceFrame with Quaternions, defined as a finite rotation about lambda, a unit vector, by some amount theta. This orientation is described by four parameters: q0 = cos(theta/2) q1 = lambda_x sin(theta/2) q2 = lambda_y sin(theta/2) q3 = lambda_z sin(theta/2) Quaternion does not take in a rotation order.

>>> B.orient(N, 'Quaternion', [q0, q1, q2, q3])


Last is Axis. This is a rotation about an arbitrary, non-time-varying axis by some angle. The axis is supplied as a Vector. This is how simple rotations are defined.

>>> B.orient(N, 'Axis', [q1, N.x + 2 * N.y])

orientnew(newname, rot_type, amounts, rot_order='', indices=None, latexs=None)[source]

Creates a new ReferenceFrame oriented with respect to this Frame.

See ReferenceFrame.orient() for acceptable rotation types, amounts, and orders. Parent is going to be self.

Parameters : parent : ReferenceFrame The frame that this ReferenceFrame will have its orientation matrix defined in relation to. rot_type : str The type of orientation matrix that is being created. Supported types are ‘Body’, ‘Space’, ‘Quaternion’, and ‘Axis’. See examples for correct usage. amounts : list OR value The quantities that the orientation matrix will be defined by. rot_order : str If applicable, the order of a series of rotations.

Examples

>>> from sympy.physics.mechanics import ReferenceFrame, Vector
>>> from sympy import symbols
>>> q0, q1, q2, q3, q4 = symbols('q0 q1 q2 q3 q4')
>>> N = ReferenceFrame('N')
>>> B = ReferenceFrame('B')


Now we have a choice of how to implement the orientation. First is Body. Body orientation takes this reference frame through three successive simple rotations. Acceptable rotation orders are of length 3, expressed in XYZ or 123, and cannot have a rotation about about an axis twice in a row.

>>> B.orient(N, 'Body', [q1, q2, q3], '123')
>>> B.orient(N, 'Body', [q1, q2, 0], 'ZXZ')
>>> B.orient(N, 'Body', [0, 0, 0], 'XYX')


Next is Space. Space is like Body, but the rotations are applied in the opposite order.

>>> B.orient(N, 'Space', [q1, q2, q3], '312')


Next is Quaternion. This orients the new ReferenceFrame with Quaternions, defined as a finite rotation about lambda, a unit vector, by some amount theta. This orientation is described by four parameters: q0 = cos(theta/2) q1 = lambda_x sin(theta/2) q2 = lambda_y sin(theta/2) q3 = lambda_z sin(theta/2) Quaternion does not take in a rotation order.

>>> B.orient(N, 'Quaternion', [q0, q1, q2, q3])


Last is Axis. This is a rotation about an arbitrary, non-time-varying axis by some angle. The axis is supplied as a Vector. This is how simple rotations are defined.

>>> B.orient(N, 'Axis', [q1, N.x + 2 * N.y])

set_ang_acc(otherframe, value)[source]

Define the angular acceleration Vector in a ReferenceFrame.

Defines the angular acceleration of this ReferenceFrame, in another. Angular acceleration can be defined with respect to multiple different ReferenceFrames. Care must be taken to not create loops which are inconsistent.

Parameters : otherframe : ReferenceFrame A ReferenceFrame to define the angular acceleration in value : Vector The Vector representing angular acceleration

Examples

>>> from sympy.physics.mechanics import ReferenceFrame, Vector
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> V = 10 * N.x
>>> A.set_ang_acc(N, V)
>>> A.ang_acc_in(N)
10*N.x

set_ang_vel(otherframe, value)[source]

Define the angular velocity vector in a ReferenceFrame.

Defines the angular velocity of this ReferenceFrame, in another. Angular velocity can be defined with respect to multiple different ReferenceFrames. Care must be taken to not create loops which are inconsistent.

Parameters : otherframe : ReferenceFrame A ReferenceFrame to define the angular velocity in value : Vector The Vector representing angular velocity

Examples

>>> from sympy.physics.mechanics import ReferenceFrame, Vector
>>> N = ReferenceFrame('N')
>>> A = ReferenceFrame('A')
>>> V = 10 * N.x
>>> A.set_ang_vel(N, V)
>>> A.ang_vel_in(N)
10*N.x

x[source]

The basis Vector for the ReferenceFrame, in the x direction.

y[source]

The basis Vector for the ReferenceFrame, in the y direction.

z[source]

The basis Vector for the ReferenceFrame, in the z direction.

## Vector¶

class sympy.physics.mechanics.essential.Vector(inlist)[source]

The class used to define vectors.

It along with ReferenceFrame are the building blocks of describing a classical mechanics system in PyDy.

Attributes

 simp Boolean Let certain methods use trigsimp on their outputs
cross(other)[source]

The cross product operator for two Vectors.

Returns a Vector, expressed in the same ReferenceFrames as self.

Parameters : other : Vector The Vector which we are crossing with

Examples

>>> from sympy.physics.mechanics import ReferenceFrame, Vector
>>> from sympy import symbols
>>> q1 = symbols('q1')
>>> N = ReferenceFrame('N')
>>> N.x ^ N.y
N.z
>>> A = N.orientnew('A', 'Axis', [q1, N.x])
>>> A.x ^ N.y
N.z
>>> N.y ^ A.x
- sin(q1)*A.y - cos(q1)*A.z

diff(wrt, otherframe)[source]

Takes the partial derivative, with respect to a value, in a frame.

Returns a Vector.

Parameters : wrt : Symbol What the partial derivative is taken with respect to. otherframe : ReferenceFrame The ReferenceFrame that the partial derivative is taken in.

Examples

>>> from sympy.physics.mechanics import ReferenceFrame, Vector, dynamicsymbols
>>> from sympy import Symbol
>>> Vector.simp = True
>>> t = Symbol('t')
>>> q1 = dynamicsymbols('q1')
>>> N = ReferenceFrame('N')
>>> A = N.orientnew('A', 'Axis', [q1, N.y])
>>> A.x.diff(t, N)
- q1'*A.z

doit(**hints)[source]

Calls .doit() on each term in the Vector

dot(other)[source]

Dot product of two vectors.

Returns a scalar, the dot product of the two Vectors

Parameters : other : Vector The Vector which we are dotting with

Examples

>>> from sympy.physics.mechanics import ReferenceFrame, Vector, dot
>>> from sympy import symbols
>>> q1 = symbols('q1')
>>> N = ReferenceFrame('N')
>>> dot(N.x, N.x)
1
>>> dot(N.x, N.y)
0
>>> A = N.orientnew('A', 'Axis', [q1, N.x])
>>> dot(N.y, A.y)
cos(q1)

dt(otherframe)[source]

Returns the time derivative of the Vector in a ReferenceFrame.

Returns a Vector which is the time derivative of the self Vector, taken in frame otherframe.

Parameters : otherframe : ReferenceFrame The ReferenceFrame that the partial derivative is taken in.

Examples

>>> from sympy.physics.mechanics import ReferenceFrame, Vector, dynamicsymbols
>>> from sympy import Symbol
>>> q1 = Symbol('q1')
>>> u1 = dynamicsymbols('u1')
>>> N = ReferenceFrame('N')
>>> A = N.orientnew('A', 'Axis', [q1, N.x])
>>> v = u1 * N.x
>>> A.set_ang_vel(N, 10*A.x)
>>> A.x.dt(N) == 0
True
>>> v.dt(N)
u1'*N.x

express(otherframe)[source]

Returns a vector, expressed in the other frame.

A new Vector is returned, equalivalent to this Vector, but its components are all defined in only the otherframe.

Parameters : otherframe : ReferenceFrame The frame for this Vector to be described in

Examples

>>> from sympy.physics.mechanics import ReferenceFrame, Vector, dynamicsymbols
>>> q1 = dynamicsymbols('q1')
>>> N = ReferenceFrame('N')
>>> A = N.orientnew('A', 'Axis', [q1, N.y])
>>> A.x.express(N)
cos(q1)*N.x - sin(q1)*N.z

magnitude()[source]

Returns the magnitude (Euclidean norm) of self.

normalize()[source]

Returns a Vector of magnitude 1, codirectional with self.

outer(other)[source]

Outer product between two Vectors.

A rank increasing operation, which returns a Dyadic from two Vectors

Parameters : other : Vector The Vector to take the outer product with

Examples

>>> from sympy.physics.mechanics import ReferenceFrame, outer
>>> N = ReferenceFrame('N')
>>> outer(N.x, N.x)
(N.x|N.x)

simplify()[source]

Simplify the elements in the Vector in place.

subs(*args, **kwargs)[source]

Substituion on the Vector.

Examples

>>> from sympy.physics.mechanics import ReferenceFrame
>>> from sympy import Symbol
>>> N = ReferenceFrame('N')
>>> s = Symbol('s')
>>> a = N.x * s
>>> a.subs({s: 2})
2*N.x


See: http://en.wikipedia.org/wiki/Dyadic_tensor Kane, T., Levinson, D. Dynamics Theory and Applications. 1985 McGraw-Hill

A more powerful way to represent a rigid body’s inertia. While it is more complex, by choosing Dyadic components to be in body fixed basis vectors, the resulting matrix is equivalent to the inertia tensor.

cross(other)

For a cross product in the form: Dyadic x Vector.

Parameters : other : Vector The Vector that we are crossing this Dyadic with

Examples

>>> from sympy.physics.mechanics import ReferenceFrame, outer, cross
>>> N = ReferenceFrame('N')
>>> d = outer(N.x, N.x)
>>> cross(d, N.y)
(N.x|N.z)

doit(**hints)[source]

Calls .doit() on each term in the Dyadic

dot(other)

The inner product operator for a Dyadic and a Dyadic or Vector.

Parameters : other : Dyadic or Vector The other Dyadic or Vector to take the inner product with

Examples

>>> from sympy.physics.mechanics import ReferenceFrame, outer
>>> N = ReferenceFrame('N')
>>> D1 = outer(N.x, N.y)
>>> D2 = outer(N.y, N.y)
>>> D1.dot(D2)
(N.x|N.y)
>>> D1.dot(N.y)
N.x

dt(frame)[source]

Take the time derivative of this Dyadic in a frame.

Parameters : frame : ReferenceFrame The frame to take the time derivative in

Examples

>>> from sympy.physics.mechanics import ReferenceFrame, outer, dynamicsymbols
>>> N = ReferenceFrame('N')
>>> q = dynamicsymbols('q')
>>> B = N.orientnew('B', 'Axis', [q, N.z])
>>> d = outer(N.x, N.x)
>>> d.dt(B)
- q'*(N.y|N.x) - q'*(N.x|N.y)

express(frame1, frame2=None)[source]

Expresses this Dyadic in alternate frame(s)

The first frame is the list side expression, the second frame is the right side; if Dyadic is in form A.x|B.y, you can express it in two different frames. If no second frame is given, the Dyadic is expressed in only one frame.

Parameters : frame1 : ReferenceFrame The frame to express the left side of the Dyadic in frame2 : ReferenceFrame If provided, the frame to express the right side of the Dyadic in

Examples

>>> from sympy.physics.mechanics import ReferenceFrame, outer, dynamicsymbols
>>> N = ReferenceFrame('N')
>>> q = dynamicsymbols('q')
>>> B = N.orientnew('B', 'Axis', [q, N.z])
>>> d = outer(N.x, N.x)
>>> d.express(B, N)
cos(q)*(B.x|N.x) - sin(q)*(B.y|N.x)

simplify()[source]

Simplify the elements in the Dyadic in-place.

subs(*args, **kwargs)[source]

Examples

>>> from sympy.physics.mechanics import ReferenceFrame
>>> from sympy import Symbol
>>> N = ReferenceFrame('N')
>>> s = Symbol('s')
>>> a = s * (N.x|N.x)
>>> a.subs({s: 2})
2*(N.x|N.x)