关节框架（文档字符串）

联合 (文档字符串)

class sympy.physics.mechanics.joint.Joint(
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,
)[源代码][源代码]

所有特定关节的抽象基类。

参数:
名称字符串

关节的唯一名称。

父级粒子或刚体或物体

关节的父体。

子粒子或刚体或物体

关节的子体。

坐标dynamicsymbols 的可迭代对象，可选

关节的广义坐标。

速度dynamicsymbols 的可迭代对象，可选

关节的广义速度。

父点点或向量，可选

关节固定在父体上的附着点。如果提供了一个向量，那么附着点是通过将该向量加到物体的质心来计算的。默认值是父体的质心。

子节点点或向量，可选

关节固定在子体上的附着点。如果提供了一个向量，那么附着点是通过将向量加到物体的质心来计算的。默认值是子体的质心。

parent_axisVector, 可选

自 1.12 版本弃用: 在父体中固定的轴，与子体中固定的轴对齐。默认是父体参考系的x轴。关于此弃用的更多信息，请参见 新的关节中间帧。

child_axisVector, 可选

自 1.12 版本弃用: 在子体中固定的轴，该轴与父体中固定的轴对齐。默认是子体参考系的x轴。有关此弃用的更多信息，请参阅 新的关节中间帧。

parent_interframeReferenceFrame, 可选

相对于父体的中级框架，关节变换以此为基准。如果提供了一个向量，则会创建一个中级框架，其X轴与给定向量对齐。默认值为父体自身的框架。

child_interframeReferenceFrame, 可选

相对于子体中间帧的关节变换。如果提供了一个向量，则创建一个中间帧，其X轴与给定向量对齐。默认值是子体自身的帧。

parent_joint_pos点或向量，可选

自 1.12 版本弃用: 此参数将被 parent_point 替换，并将在未来版本中移除。更多信息请参见 关节附着点参数的变化。

child_joint_pos点或向量，可选

自 1.12 版本弃用: 此参数将被 child_point 替换，并在未来版本中移除。更多信息请参见 关节附着点参数的变化。

属性:
name字符串

关节的名称。

parent粒子或刚体或物体

关节的父体。

child粒子或刚体或物体

关节的子体。

coordinates矩阵

关节广义坐标的矩阵。

speeds矩阵

关节广义速度的矩阵。

parent_point点

关节固定在父体上的附着点。

child_point点

关节固定在子体上的附着点。

parent_axis向量

父坐标系的轴。

child_axis向量

子框架的轴。

parent_interframe参考框架

相对于父体的中级框架，关节变换即基于此框架进行定义。

child_interframe参考框架

相对于子体中间帧的关节变换。

kdes矩阵

关节的运动学微分方程。

注释

当提供一个向量作为中间帧时，会创建一个新的中间帧，其X轴与提供的向量对齐。这是通过围绕一个旋转轴进行单一固定旋转来完成的。该旋转轴是通过将``body.x``轴与提供的向量进行叉积来确定的。在提供的向量位于``-body.x``方向的情况下，旋转是围绕``body.y``轴进行的。

property child

关节的子体。

property child_axis

子框架的轴。

property child_point

关节固定在子体上的附着点。

property coordinates

关节广义坐标的矩阵。

property kdes

关节的运动学微分方程。

property name

关节的名称。

property parent

关节的父体。

property parent_axis

父坐标系的轴。

property parent_point

关节固定在父体上的附着点。

property speeds

关节广义速度的矩阵。

class sympy.physics.mechanics.joint.PinJoint(
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,
)[源代码][源代码]

销（旋转）关节。

joint_axis q, u child.masscenter attachment points parent.frame parent_interframe parent.masscenter child.frame child_interframe
参数:
名称字符串

关节的唯一名称。

父级粒子或刚体或物体

关节的父体。

子粒子或刚体或物体

关节的子体。

坐标dynamicsymbol, 可选

关节的广义坐标。

速度dynamicsymbol, 可选

关节的广义速度。

父点点或向量，可选

关节固定在父体上的附着点。如果提供了一个向量，那么附着点是通过将该向量加到物体的质心来计算的。默认值是父体的质心。

子节点点或向量，可选

关节固定在子体上的附着点。如果提供了一个向量，那么附着点是通过将向量加到物体的质心来计算的。默认值是子体的质心。

parent_axisVector, 可选

自 1.12 版本弃用: 在父体中固定的轴，与子体中固定的轴对齐。默认是父体参考系的x轴。关于此弃用的更多信息，请参见 新的关节中间帧。

child_axisVector, 可选

自 1.12 版本弃用: 在子体中固定的轴，该轴与父体中固定的轴对齐。默认是子体参考系的x轴。有关此弃用的更多信息，请参阅 新的关节中间帧。

parent_interframeReferenceFrame, 可选

相对于父体的中级框架，关节变换以此为基准。如果提供了一个向量，则会创建一个中级框架，其X轴与给定向量对齐。默认值为父体自身的框架。

child_interframeReferenceFrame, 可选

相对于子体中间帧的关节变换。如果提供了一个向量，则创建一个中间帧，其X轴与给定向量对齐。默认值是子体自身的帧。

joint_axis向量

旋转发生的轴。注意，这个轴的分量在 parent_interframe 和 child_interframe 中是相同的。

parent_joint_pos点或向量，可选

自 1.12 版本弃用: 此参数将被 parent_point 替换，并将在未来版本中移除。更多信息请参见 关节附着点参数的变化。

child_joint_pos点或向量，可选

自 1.12 版本弃用: 此参数将被 child_point 替换，并在未来版本中移除。更多信息请参见 关节附着点参数的变化。

属性:
name字符串

关节的名称。

parent粒子或刚体或物体

关节的父体。

child粒子或刚体或物体

关节的子体。

coordinates矩阵

关节广义坐标的矩阵。

speeds矩阵

关节广义速度的矩阵。

parent_point点

关节固定在父体上的附着点。

child_point点

关节固定在子体上的附着点。

parent_axis向量

父坐标系的轴。

child_axis向量

子框架的轴。

parent_interframe参考框架

相对于父体的中级框架，关节变换即基于此框架进行定义。

child_interframe参考框架

相对于子体中间帧的关节变换。

joint_axis向量

子对象相对于父对象旋转的轴。

kdes矩阵

关节的运动学微分方程。

示例

单个销接头由两个物体创建，并具有以下基本属性：

>>> 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

为了进一步演示销接头的使用，可以创建一个简单的双摆的机构学，该双摆围绕每个连接体的Z轴旋转，如下所示。

>>> from sympy import symbols, trigsimp
>>> from sympy.physics.mechanics import RigidBody, PinJoint
>>> l1, l2 = symbols('l1 l2')

首先创建体来表示固定的天花板，并创建一个体来表示每个摆锤。

>>> ceiling = RigidBody('C')
>>> upper_bob = RigidBody('U')
>>> lower_bob = RigidBody('L')

第一个关节将通过距离 l1 将上部摆锤连接到天花板，并且每个体的关节轴将围绕Z轴。

>>> ceiling_joint = PinJoint('P1', ceiling, upper_bob,
... child_point=-l1*upper_bob.frame.x,
... joint_axis=ceiling.frame.z)

第二个关节将通过距离 l2 连接下部摆锤和上部摆锤，并且关节轴也将围绕每个物体的 Z 轴。

>>> pendulum_joint = PinJoint('P2', upper_bob, lower_bob,
... child_point=-l2*lower_bob.frame.x,
... joint_axis=upper_bob.frame.z)

一旦关节建立，连接体的运动学就可以被访问。首先找到相对于天花板的摆动链路的方向余弦矩阵：

>>> 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]])

下摆质心的位置通过以下公式找到：

>>> lower_bob.masscenter.pos_from(ceiling.masscenter)
l1*U_frame.x + l2*L_frame.x

两个摆杆的角速度可以相对于天花板计算。

>>> 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

最后，两个摆锤的线速度可以相对于天花板计算。

>>> 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
property joint_axis

子对象相对于父对象旋转的轴。

class sympy.physics.mechanics.joint.PrismaticJoint(
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,
)[源代码][源代码]

棱柱（滑动）关节。

../../../../_images/PrismaticJoint.svg
参数:
名称字符串

关节的唯一名称。

父级粒子或刚体或物体

关节的父体。

子粒子或刚体或物体

关节的子体。

坐标dynamicsymbol, 可选

关节的广义坐标。默认值为 dynamicsymbols(f'q_{joint.name}')。

速度dynamicsymbol, 可选

关节的广义速度。默认值是 dynamicsymbols(f'u_{joint.name}')。

父点点或向量，可选

关节固定在父体上的附着点。如果提供了一个向量，那么附着点是通过将该向量加到物体的质心来计算的。默认值是父体的质心。

子节点点或向量，可选

关节固定在子体上的附着点。如果提供了一个向量，那么附着点是通过将向量加到物体的质心来计算的。默认值是子体的质心。

parent_axisVector, 可选

自 1.12 版本弃用: 在父体中固定的轴，与子体中固定的轴对齐。默认是父体参考系的x轴。关于此弃用的更多信息，请参见 新的关节中间帧。

child_axisVector, 可选

自 1.12 版本弃用: 在子体中固定的轴，该轴与父体中固定的轴对齐。默认是子体参考系的x轴。有关此弃用的更多信息，请参阅 新的关节中间帧。

parent_interframeReferenceFrame, 可选

相对于父体的中级框架，关节变换以此为基准。如果提供了一个向量，则会创建一个中级框架，其X轴与给定向量对齐。默认值为父体自身的框架。

child_interframeReferenceFrame, 可选

相对于子体中间帧的关节变换。如果提供了一个向量，则创建一个中间帧，其X轴与给定向量对齐。默认值是子体自身的帧。

joint_axis向量

发生平移的轴。注意，该轴的分量在 parent_interframe 和 child_interframe 中是相同的。

parent_joint_pos点或向量，可选

自 1.12 版本弃用: 此参数将被 parent_point 替换，并将在未来版本中移除。更多信息请参见 关节附着点参数的变化。

child_joint_pos点或向量，可选

自 1.12 版本弃用: 此参数将被 child_point 替换，并在未来版本中移除。更多信息请参见 关节附着点参数的变化。

属性:
name字符串

关节的名称。

parent粒子或刚体或物体

关节的父体。

child粒子或刚体或物体

关节的子体。

coordinates矩阵

关节广义坐标的矩阵。

speeds矩阵

关节广义速度的矩阵。

parent_point点

关节固定在父体上的附着点。

child_point点

关节固定在子体上的附着点。

parent_axis向量

父坐标系的轴。

child_axis向量

子框架的轴。

parent_interframe参考框架

相对于父体的中级框架，关节变换即基于此框架进行定义。

child_interframe参考框架

相对于子体中间帧的关节变换。

kdes矩阵

关节的运动学微分方程。

示例

一个单棱柱关节由两个物体创建，并具有以下基本属性：

>>> 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

为了进一步演示棱柱关节的使用，可以创建两个质量滑动的运动学，一个相对于固定体移动，另一个相对于移动体移动。关于每个连接体的X轴的运动可以如下创建。

>>> from sympy.physics.mechanics import PrismaticJoint, RigidBody

首先创建两个体，一个代表固定天花板，另一个代表粒子。

>>> wall = RigidBody('W')
>>> Part1 = RigidBody('P1')
>>> Part2 = RigidBody('P2')

第一个关节将连接粒子到天花板，并且每个物体的关节轴将围绕X轴。

>>> J1 = PrismaticJoint('J1', wall, Part1)

第二个关节将连接第二个粒子到第一个粒子，并且关节轴也将围绕每个物体的X轴。

>>> J2 = PrismaticJoint('J2', Part1, Part2)

一旦关节建立，连接体的运动学信息就可以被访问。首先找到部件相对于天花板的方向余弦矩阵：

>>> 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]])

粒子的质心位置通过以下方式找到：

>>> 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

两个粒子连杆的角速度可以相对于天花板计算。

>>> Part1.frame.ang_vel_in(wall.frame)
0

>>> Part2.frame.ang_vel_in(wall.frame)
0

最后，两个粒子相对于天花板的线速度可以被计算出来。

>>> 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
property joint_axis

沿着该轴，子对象相对于父对象进行平移。

class sympy.physics.mechanics.joint.CylindricalJoint(
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,
)[源代码][源代码]

圆柱关节。

../../../../_images/CylindricalJoint.svg
参数:
名称字符串

关节的唯一名称。

父级粒子或刚体或物体

关节的父体。

子粒子或刚体或物体

关节的子体。

旋转坐标dynamicsymbol, 可选

对应于旋转角度的广义坐标。默认值为 dynamicsymbols(f'q0_{joint.name}')。

translation_coordinatedynamicsymbol, 可选

对应于平移距离的广义坐标。默认值为 dynamicsymbols(f'q1_{joint.name}')。

rotation_speeddynamicsymbol, 可选

对应于角速度的广义速度。默认值为 dynamicsymbols(f'u0_{joint.name}')。

translation_speeddynamicsymbol, 可选

对应于平移速度的广义速度。默认值为 dynamicsymbols(f'u1_{joint.name}')。

父点点或向量，可选

关节固定在父体上的附着点。如果提供了一个向量，那么附着点是通过将该向量加到物体的质心来计算的。默认值是父体的质心。

子节点点或向量，可选

关节固定在子体上的附着点。如果提供了一个向量，那么附着点是通过将向量加到物体的质心来计算的。默认值是子体的质心。

parent_interframeReferenceFrame, 可选

相对于父体的中级框架，关节变换以此为基准。如果提供了一个向量，则会创建一个中级框架，其X轴与给定向量对齐。默认值为父体自身的框架。

child_interframeReferenceFrame, 可选

相对于子体中间帧的关节变换。如果提供了一个向量，则创建一个中间帧，其X轴与给定向量对齐。默认值是子体自身的帧。

joint_axisVector, 可选

旋转以及平移轴。注意，这个轴的分量在 parent_interframe 和 child_interframe 中是相同的。

属性:
name字符串

关节的名称。

parent粒子或刚体或物体

关节的父体。

child粒子或刚体或物体

关节的子体。

rotation_coordinatedynamicsymbol

对应于旋转角度的广义坐标。

translation_coordinatedynamicsymbol

对应于平移距离的广义坐标。

rotation_speeddynamicsymbol

广义速度对应于角速度。

translation_speeddynamicsymbol

对应于平移速度的广义速度。

coordinates矩阵

关节广义坐标的矩阵。

speeds矩阵

关节广义速度的矩阵。

parent_point点

关节固定在父体上的附着点。

child_point点

关节固定在子体上的附着点。

parent_interframe参考框架

相对于父体的中级框架，关节变换即基于此框架进行定义。

child_interframe参考框架

相对于子体中间帧的关节变换。

kdes矩阵

关节的运动学微分方程。

joint_axis向量

旋转和平移发生的轴线。

示例

在两个物体之间创建一个单缸关节，并具有以下基本属性：

>>> 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

为了进一步演示圆柱关节的使用，可以创建两个相互垂直的圆柱关节的运动学，如下所示。

>>> from sympy import symbols
>>> from sympy.physics.mechanics import RigidBody, CylindricalJoint
>>> r, l, w = symbols('r l w')

首先创建表示固定地板和固定在其上的杆的刚体。第二个刚体表示围绕该杆自由移动的管子。第三个刚体表示一个沿着管子的Y轴自由平移和旋转的实心旗帜。

>>> floor = RigidBody('floor')
>>> tube = RigidBody('tube')
>>> flag = RigidBody('flag')

第一个关节将第一个管子与地板连接起来，使其沿两个物体的Z轴平移并绕其旋转。

>>> floor_joint = CylindricalJoint('C1', floor, tube, joint_axis=floor.z)

第二个关节将沿着管和旗的Y轴，将管与旗垂直连接，关节位于距管质心``r``的距离处，并且距旗质心的距离为``l``和``w``的组合。

>>> flag_joint = CylindricalJoint('C2', tube, flag,
...                               parent_point=r * tube.y,
...                               child_point=-w * flag.y + l * flag.z,
...                               joint_axis=tube.y)

一旦关节建立，连接体的运动学就可以被访问。首先找到相对于地面的主体和旗帜的方向余弦矩阵：

>>> 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))]])

旗子的质心位置是通过以下方法找到的：

>>> 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

两个管道的角速度可以相对于地面计算。

>>> 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

最后，两个管状物体质心的线速度可以相对于地面计算，同时在管状物体的坐标系中表示。

>>> 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)]])
property joint_axis

旋转和平移发生的轴线。

property rotation_coordinate

对应于旋转角度的广义坐标。

property rotation_speed

广义速度对应于角速度。

property translation_coordinate

对应于平移距离的广义坐标。

property translation_speed

对应于平移速度的广义速度。

class sympy.physics.mechanics.joint.PlanarJoint(
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,
)[源代码][源代码]

平面关节。

child_point child_interframe planar_vectors parent_point parent_interframe q1, u1 q0, u0child.masscenter child.frame parent. masscenter parent.frame q2, u2 rotation_axis
参数:
名称字符串

关节的唯一名称。

父级粒子或刚体或物体

关节的父体。

子粒子或刚体或物体

关节的子体。

旋转坐标dynamicsymbol, 可选

对应于旋转角度的广义坐标。默认值为 dynamicsymbols(f'q0_{joint.name}')。

平面坐标dynamicsymbols 的可迭代对象，可选

用于平面平移的两个广义坐标。默认值为 dynamicsymbols(f'q1_{joint.name} q2_{joint.name}')。

rotation_speeddynamicsymbol, 可选

对应于角速度的广义速度。默认值为 dynamicsymbols(f'u0_{joint.name}')。

平面速度dynamicsymbols, 可选

用于平面平移速度的两个广义速度。默认值为 dynamicsymbols(f'u1_{joint.name} u2_{joint.name}')。

父点点或向量，可选

关节固定在父体上的附着点。如果提供了一个向量，那么附着点是通过将该向量加到物体的质心来计算的。默认值是父体的质心。

子节点点或向量，可选

关节固定在子体上的附着点。如果提供了一个向量，那么附着点是通过将向量加到物体的质心来计算的。默认值是子体的质心。

parent_interframeReferenceFrame, 可选

相对于父体的中级框架，关节变换以此为基准。如果提供了一个向量，则会创建一个中级框架，其X轴与给定向量对齐。默认值为父体自身的框架。

child_interframeReferenceFrame, 可选

相对于子体中间帧的关节变换。如果提供了一个向量，则创建一个中间帧，其X轴与给定向量对齐。默认值是子体自身的帧。

属性:
name字符串

关节的名称。

parent粒子或刚体或物体

关节的父体。

child粒子或刚体或物体

关节的子体。

rotation_coordinatedynamicsymbol

对应于旋转角度的广义坐标。

planar_coordinates矩阵

用于平面平移的两个广义坐标。

rotation_speeddynamicsymbol

广义速度对应于角速度。

planar_speeds矩阵

用于平面平移速度的两个广义速度。

coordinates矩阵

关节广义坐标的矩阵。

speeds矩阵

关节广义速度的矩阵。

parent_point点

关节固定在父体上的附着点。

child_point点

关节固定在子体上的附着点。

parent_interframe参考框架

相对于父体的中级框架，关节变换即基于此框架进行定义。

child_interframe参考框架

相对于子体中间帧的关节变换。

kdes矩阵

关节的运动学微分方程。

rotation_axis向量

旋转发生的轴。

planar_vectors列表

描述平面平移方向的向量。

示例

在两个物体之间创建一个单一的平面关节，并具有以下基本属性：

>>> 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

为了进一步演示平面关节的使用，可以按照以下方式创建一个在斜面上滑动的块的运动学。

>>> from sympy import symbols
>>> from sympy.physics.mechanics import PlanarJoint, RigidBody, ReferenceFrame
>>> a, d, h = symbols('a d h')

首先创建表示斜坡和方块的主体。

>>> ground = RigidBody('G')
>>> block = RigidBody('B')

要定义斜率，你可以通过指定 planar_vectors 或/和 rotation_axis 来定义平面。然而，建议创建一个旋转的中间坐标系，这样 parent_vectors 和 rotation_axis 将是该中间坐标系的单位向量。

>>> slope = ReferenceFrame('A')
>>> slope.orient_axis(ground.frame, ground.y, a)

可以使用这些物体和中间框架创建平面关节。我们可以指定斜坡的原点在斜坡质心上方 d 处，并且块的质心在斜坡表面上方距离 h 处。请注意，我们可以使用旋转轴参数指定平面的法线。

>>> joint = PlanarJoint('PC', ground, block, parent_point=d * ground.x,
...                     child_point=-h * block.x, parent_interframe=slope)

一旦关节建立，可以访问物体的运动学。首先可以找到 rotation_axis，它是垂直于平面的轴，以及 plane_vectors。

>>> joint.rotation_axis
A.x
>>> joint.planar_vectors
[A.y, A.z]

相对于地面的块的方向余弦矩阵可以通过以下方式找到：

>>> 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))]])

块的角速度可以相对于地面计算。

>>> block.frame.ang_vel_in(ground.frame)
u0_PC(t)*A.x

可以通过以下方法找到块的质心位置：

>>> block.masscenter.pos_from(ground.masscenter)
d*G_frame.x + h*B_frame.x + q1_PC(t)*A.y + q2_PC(t)*A.z

最后，可以相对于地面计算块质心的线速度。

>>> block.masscenter.vel(ground.frame)
u1_PC(t)*A.y + u2_PC(t)*A.z

在某些情况下，您可能更倾向于仅定义平面相对于两个物体的法线。这可以通过向 interframe 参数提供向量来最简单地完成。在这种情况下，将创建一个中间框架，其 x 轴与提供的向量对齐。有关如何完成此操作的进一步解释，请参阅 Joint 类的注释。在下面的代码中，通过向 interframe 参数提供向量，重新创建了上述示例（斜面上的块）。请注意，之前描述的选项在计算上更为高效，因为算法现在必须计算提供的向量与 ‘x’ 轴之间的旋转角度。

>>> 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))]])
property planar_coordinates

用于平面平移的两个广义坐标。

property planar_speeds

用于平面平移速度的两个广义速度。

property planar_vectors

描述平面平移方向的向量。

property rotation_axis

旋转发生的轴。

property rotation_coordinate

对应于旋转角度的广义坐标。

property rotation_speed

广义速度对应于角速度。

class sympy.physics.mechanics.joint.SphericalJoint(
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,
)[源代码][源代码]

球窝关节。

../../../../_images/SphericalJoint.svg
参数:
名称字符串

关节的唯一名称。

父级粒子或刚体或物体

关节的父体。

子粒子或刚体或物体

关节的子体。

坐标：dynamicsymbols 的可迭代对象，可选

关节的广义坐标。

速度dynamicsymbols 的可迭代对象，可选

关节的广义速度。

父点点或向量，可选

关节固定在父体上的附着点。如果提供了一个向量，那么附着点是通过将该向量加到物体的质心来计算的。默认值是父体的质心。

子节点点或向量，可选

关节固定在子体上的附着点。如果提供了一个向量，那么附着点是通过将向量加到物体的质心来计算的。默认值是子体的质心。

parent_interframeReferenceFrame, 可选

相对于父体的中级框架，关节变换以此为基准。如果提供了一个向量，则会创建一个中级框架，其X轴与给定向量对齐。默认值为父体自身的框架。

child_interframeReferenceFrame, 可选

相对于子体中间帧的关节变换。如果提供了一个向量，则创建一个中间帧，其X轴与给定向量对齐。默认值是子体自身的帧。

rot_typestr, 可选

生成方向余弦矩阵所使用的方法。支持的方法有：

  • 'Body': 关于新中间轴的三个连续旋转，也称为“欧拉和泰特-布莱恩角”

  • 'Space': 关于父坐标系的单位矢量的三次连续旋转

默认方法是 'Body'。

金额

定义旋转角度或方向余弦矩阵的表达式。这些必须与 rot_type 匹配。详情请参见下面的示例。输入类型如下：

  • 'Body': 表达式、符号或函数的 3-tuple

  • 'Space': 表达式、符号或函数的 3-tuple

默认值是给定的 坐标。

rot_orderstr 或 int，可选

如果适用，旋转的连续顺序。例如，字符串 '123' 和整数 123 是等价的。对于 'Body' 和 'Space' 是必需的。默认值是 123。

属性:
name字符串

关节的名称。

parent粒子或刚体或物体

关节的父体。

child粒子或刚体或物体

关节的子体。

coordinates矩阵

关节广义坐标的矩阵。

speeds矩阵

关节广义速度的矩阵。

parent_point点

关节固定在父体上的附着点。

child_point点

关节固定在子体上的附着点。

parent_interframe参考框架

相对于父体的中级框架，关节变换即基于此框架进行定义。

child_interframe参考框架

相对于子体中间帧的关节变换。

kdes矩阵

关节的运动学微分方程。

示例

一个单球形关节由两个物体创建，并具有以下基本属性：

>>> 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

为了进一步演示球形关节的使用，可以如下创建一个带有ZXZ旋转的球形关节的运动学。

>>> from sympy import symbols
>>> from sympy.physics.mechanics import RigidBody, SphericalJoint
>>> l1 = symbols('l1')

首先创建代表固定地板和摆锤的物体。

>>> floor = RigidBody('F')
>>> bob = RigidBody('B')

该关节将连接 bob 到地板，关节位于距离孩子质心 l1 处，旋转设置为固定在身体上的 ZXZ 旋转。

>>> joint = SphericalJoint('S', floor, bob, child_point=l1 * bob.y,
...                        rot_type='body', rot_order='ZXZ')

现在关节已经建立，可以访问连接体的运动学。

摆锤质心的位置通过以下方式找到：

>>> bob.masscenter.pos_from(floor.masscenter)
- l1*B_frame.y

摆杆的角速度可以相对于地面计算。

>>> 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))]])

最后，可以计算出摆锤质心的线速度。

>>> 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)))]])
class sympy.physics.mechanics.joint.WeldJoint(
name,
parent,
child,
parent_point=None,
child_point=None,
parent_interframe=None,
child_interframe=None,
)[源代码][源代码]

焊接接头。

attachment points parent.masscenter child.masscenter parent.frame child.frame attachment frames
参数:
名称字符串

关节的唯一名称。

父级粒子或刚体或物体

关节的父体。

子粒子或刚体或物体

关节的子体。

父点点或向量，可选

关节固定在父体上的附着点。如果提供了一个向量，那么附着点是通过将该向量加到物体的质心来计算的。默认值是父体的质心。

子节点点或向量，可选

关节固定在子体上的附着点。如果提供了一个向量，那么附着点是通过将向量加到物体的质心来计算的。默认值是子体的质心。

parent_interframeReferenceFrame, 可选

相对于父体的中级框架，关节变换以此为基准。如果提供了一个向量，则会创建一个中级框架，其X轴与给定向量对齐。默认值为父体自身的框架。

child_interframeReferenceFrame, 可选

相对于子体中间帧的关节变换。如果提供了一个向量，则创建一个中间帧，其X轴与给定向量对齐。默认值是子体自身的帧。

属性:
name字符串

关节的名称。

parent粒子或刚体或物体

关节的父体。

child粒子或刚体或物体

关节的子体。

coordinates矩阵

关节广义坐标的矩阵。

speeds矩阵

关节广义速度的矩阵。

parent_point点

关节固定在父体上的附着点。

child_point点

关节固定在子体上的附着点。

parent_interframe参考框架

相对于父体的中级框架，关节变换即基于此框架进行定义。

child_interframe参考框架

相对于子体中间帧的关节变换。

kdes矩阵

关节的运动学微分方程。

示例

一个焊接接头由两个物体创建，并具有以下基本属性：

>>> 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

为了进一步演示焊接接头的使用，可以创建两个围绕Y轴旋转四分之一圈的相对固定体，如下所示：

>>> from sympy import symbols, pi
>>> from sympy.physics.mechanics import ReferenceFrame, RigidBody, WeldJoint
>>> l1, l2 = symbols('l1 l2')

首先创建代表父体和旋转子体的实体。

>>> parent = RigidBody('P')
>>> child = RigidBody('C')

接下来，可以创建指定相对于父对象的固定旋转的中间框架。

>>> rotated_frame = ReferenceFrame('Pr')
>>> rotated_frame.orient_axis(parent.frame, parent.y, pi / 2)

父体和子体之间的焊缝位于X方向上距离父体质心 l1 处，以及子体负X方向上距离子体质心 l2 处。

>>> weld = WeldJoint('weld', parent, child, parent_point=l1 * parent.x,
...                  child_point=-l2 * child.x,
...                  parent_interframe=rotated_frame)

现在关节已经建立，可以访问物体的运动学。可以找到相对于父体的子体的方向余弦矩阵：

>>> child.frame.dcm(parent.frame)
Matrix([
[0, 0, -1],
[0, 1,  0],
[1, 0,  0]])

从方向余弦矩阵中也可以看出，父X轴与子Z轴对齐：>>> parent.x == child.z True

子体的质心相对于父体质心的位置可以通过以下方式找到：

>>> child.masscenter.pos_from(parent.masscenter)
l1*P_frame.x + l2*C_frame.x

相对于父对象，子对象的角速度为0，这符合预期。

>>> child.frame.ang_vel_in(parent.frame)
0