SymPy-1-13-中文文档-十七-
SymPy 1.13 中文文档(十七)
Kane 方法与 Lagrange 方法(文档字符串)
原文链接:
docs.sympy.org/latest/modules/physics/mechanics/api/kane_lagrange.html
class sympy.physics.mechanics.kane.KanesMethod(frame, q_ind, u_ind, kd_eqs=None, q_dependent=None, configuration_constraints=None, u_dependent=None, velocity_constraints=None, acceleration_constraints=None, u_auxiliary=None, bodies=None, forcelist=None, explicit_kinematics=True, kd_eqs_solver='LU', constraint_solver='LU')
Kane 方法对象。
参数:
frame:参考系
系统的惯性参考系。
q_ind:动力学符号的可迭代对象。
独立广义坐标。
u_ind:动力学符号的可迭代对象。
独立广义速度。
kd_eqs:表达式的可迭代对象,可选。
运动学微分方程,将广义速度线性相关到广义坐标的时间导数。
q_dependent:动力学符号的可迭代对象,可选。
依赖广义坐标。
configuration_constraints:表达式的可迭代对象,可选。
系统配置的约束,即全息约束。
u_dependent:动力学符号的可迭代对象,可选。
依赖广义速度。
velocity_constraints:表达式的可迭代对象,可选。
系统速度的约束,即非全息约束与全息约束时间导数的组合。
acceleration_constraints:表达式的可迭代对象,可选。
系统加速度的约束,默认为速度约束的时间导数。
u_auxiliary:动力学符号的可迭代对象,可选。
辅助广义速度。
bodies:粒子和/或刚体的可迭代对象,可选。
系统中的粒子和刚体。
forcelist:元组的可迭代对象,格式为[Point | ReferenceFrame, Vector],可选。
施加在系统上的力和力矩。
explicit_kinematics:布尔值
布尔值,指示质量矩阵和迫使向量应使用显式形式(默认)还是隐式形式的运动学。详细信息请参阅备注。
kd_eqs_solver:字符串,可调用对象
用于解决运动学微分方程的方法。如果提供了字符串,则应为可用于
sympy.matrices.matrixbase.MatrixBase.solve()
的有效方法。如果提供了可调用对象,则应具有格式f(A, rhs)
,其中解决方程并返回解决方案。默认情况下使用 LU 解法。更多信息请参阅备注。
constraint_solver:字符串,可调用对象
用于解决速度约束的方法。如果提供了字符串,则应为可用于
sympy.matrices.matrixbase.MatrixBase.solve()
的有效方法。如果提供了可调用对象,则应具有格式f(A, rhs)
,其中解决方程并返回解决方案。默认情况下使用 LU 解法。更多信息请参阅备注。
解释
此对象用于在进行动力学方程的形成时进行“账务处理”,方式如 Kane 在《Kane, T., Levinson, D. Dynamics Theory and Applications. 1985 McGraw-Hill》中所述。
方程的属性是形如[M] udot = forcing。
注释
与运动学方程相关的质量矩阵和作用力矢量默认以显式形式给出。换句话说,运动学质量矩阵为(\mathbf{k_{k\dot{q}}} = \mathbf{I})。为了得到这些矩阵/矢量的隐式形式,您可以将explicit_kinematics
属性设置为False
。因此,(\mathbf{k_{k\dot{q}}})不一定是单位矩阵。这可以为非简单运动学提供更紧凑的方程。
可以为KanesMethod
提供两个线性求解器:一个用于解决运动微分方程,另一个用于解决速度约束。这两组方程均可表示为线性系统Ax = rhs
,必须按顺序解决以获取动力学方程。
默认求解器'LU'
,即 LU 求解,操作数相对较低。该方法的弱点在于可能导致零除错误。
如果遇到零除错误,可能的求解器是"CRAMER"
。该方法使用克拉默法则来解决系统。该方法比默认求解器慢,操作数更多。然而,默认情况下每个解条目仅使用单个除法。
虽然可以在sympy.matrices.matrixbase.MatrixBase.solve()
找到有效的求解器列表,但也可以提供一个(callable)。这样可以使用不同的求解器程序。如果运动微分方程不太复杂,可以通过使用simplify(Matrix.LUsolve(A, b))
来简化解决方案。另一个可用的求解器选项是sympy.solvers.solveset.linsolve()
。这可以通过(lambda A, b: tuple(linsolve((A, b)))[0])来实现,其中我们选择第一个解作为我们的系统应该有唯一解。
示例
这是一个简单的一自由度平移弹簧-质量-阻尼器的示例。
在此示例中,我们首先需要进行运动学。这涉及创建广义速度和坐标及其导数。然后我们创建一个点并在一个参考系中设置其速度。
>>> from sympy import symbols
>>> from sympy.physics.mechanics import dynamicsymbols, ReferenceFrame
>>> from sympy.physics.mechanics import Point, Particle, KanesMethod
>>> q, u = dynamicsymbols('q u')
>>> qd, ud = dynamicsymbols('q u', 1)
>>> m, c, k = symbols('m c k')
>>> N = ReferenceFrame('N')
>>> P = Point('P')
>>> P.set_vel(N, u * N.x)
接下来我们需要按照 KanesMethod 所需的方式安排/存储信息。运动微分方程应该是表达式的可迭代对象。必须构建一个力/力矩的列表,其中列表中的每个条目都是(Point, Vector)或(ReferenceFrame, Vector)元组,其中向量表示力或力矩。接下来需要创建一个质点,并为其分配点和质量。最后,需要创建所有物体和粒子的列表。
>>> kd = [qd - u]
>>> FL = [(P, (-k * q - c * u) * N.x)]
>>> pa = Particle('pa', P, m)
>>> BL = [pa]
最后,我们可以生成运动方程。首先创建 KanesMethod 对象,提供一个惯性参考系、坐标、广义速度和运动微分方程。此处还提供了其他量,如配置和运动约束、依赖坐标和速度、辅助速度(请参阅在线文档)。接下来形成 FR和 FR 来完成:Fr + Fr = 0。此时我们得到了运动方程。不过,重新排列它们是有意义的,因此我们计算质量矩阵和强迫项,以 E.o.M.的形式表示:[MM] udot = forcing,其中 MM 是质量矩阵,udot 是广义速度的时间导数向量,forcing 是表示“强迫”项的向量。
>>> KM = KanesMethod(N, q_ind=[q], u_ind=[u], kd_eqs=kd)
>>> (fr, frstar) = KM.kanes_equations(BL, FL)
>>> MM = KM.mass_matrix
>>> forcing = KM.forcing
>>> rhs = MM.inv() * forcing
>>> rhs
Matrix([[(-c*u(t) - k*q(t))/m]])
>>> KM.linearize(A_and_B=True)[0]
Matrix([
[ 0, 1],
[-k/m, -c/m]])
请查看文档页面,了解如何进行线性化、处理依赖坐标和速度,以及如何处理非贡献力。
属性
q, u | (Matrix) 广义坐标和速度的矩阵 |
---|---|
bodies | (iterable) 系统中的粒子和刚体对象的可迭代对象。 |
loads | (iterable) 描述系统上的力的(Point, vector)或(ReferenceFrame, vector)元组的可迭代对象。 |
auxiliary_eqs | (Matrix) 如果适用,用于解算非贡献力的辅助 Kane 方程集合。 |
mass_matrix | (Matrix) 系统动力学质量矩阵:[k_d; k_dnh] |
forcing | (Matrix) 系统动力学强迫向量:-[f_d; f_dnh] |
mass_matrix_kin | (Matrix) 运动微分方程的“质量矩阵”:k_kqdot |
forcing_kin | (Matrix) 运动微分方程的“强迫向量”:-(k_ku*u + f_k) |
mass_matrix_full | (Matrix) 带有动力学和运动学 u 和 q 的“质量矩阵” |
forcing_full | (Matrix) 带有动力学和运动学 u 和 q 的“强迫向量” |
property auxiliary_eqs
包含辅助方程的矩阵。
property forcing
系统的强迫向量。
property forcing_full
系统的强迫向量,由显式或隐式形式的运动微分方程增广。
property forcing_kin
系统的运动“强迫向量”。
kanes_equations(bodies=None, loads=None)
形成 Kane 方程 Fr + Fr* = 0 的方法。
参数:
bodies : iterable
系统中所有刚体和质点的可迭代对象。系统至少必须有一个物体。
loads : iterable
接受一个 (Particle, Vector) 或 (ReferenceFrame, Vector) 元组的可迭代对象,表示点上的力或框架上的扭矩。必须是一个非空元组的可迭代对象或 None,对应于没有约束的系统。
解释
返回 (Fr, Fr*)。在存在辅助广义速度的情况下(例如 s 个辅助速度,o 个广义速度和 m 个运动约束),返回向量的长度将是 o - m + s。前 o - m 个方程将是约束的 Kane 方程,然后是 s 个辅助 Kane 方程。可以使用 auxiliary_eqs 属性访问这些辅助方程。
kindiffdict()
返回一个将 q’ 映射到 u 的字典。
linearize(*, new_method=None, linear_solver='LU', **kwargs)
在符号操作点周围线性化运动方程。
参数:
new_method
弃用,无作用并将被移除。
linear_solver : str, callable
在线性化过程中用于解决形如
A*x=b
的几个符号线性系统的方法。如果提供了一个字符串,它应该是一个可以与sympy.matrices.matrixbase.MatrixBase.solve()
一起使用的有效方法。如果提供了一个可调用对象,它应具有格式x = f(A, b)
,其中它解决方程并返回解。默认值为'LU'
,对应于 SymPy 的A.LUsolve(b)
。LUsolve()
计算速度快,但通常会导致除以零并因此得到nan
结果。
**kwargs
额外的关键字参数传递给
sympy.physics.mechanics.linearize.Linearizer.linearize()
。
解释
如果 kwarg A_and_B 为 False(默认),则返回 M、A、B、r,用于线性化形式 M[q’, u’]^T = A[q_ind, u_ind]^T + B*r。
如果 kwarg A_and_B 为 True,则返回线性化形式 dx = Ax + Br 的 A、B、r,其中 x = [q_ind, u_ind]^T。如果有许多符号参数,则计算量大。因此,如果使用默认值 A_and_B=False,则更希望返回 M、A 和 B。然后可以将值替换到这些矩阵中,并找到状态空间形式 A = P.TM.inv()A、B = P.TM.inv()B,其中 P = Linearizer.perm_mat。
在这两种情况下,r 是在运动方程中找到的所有不属于 q、u、q’ 或 u’ 的动态符号,它们以规范形式排序。
也可以使用 op_point
kwarg 输入操作点。这需要一个 {symbol: value} 字典或这样的可迭代对象。值可以是数值或符号。您能事先指定的值越多,计算速度就越快。
更多文档,请参阅Linearizer
类。
property mass_matrix
系统的质量矩阵。
property mass_matrix_full
系统的质量矩阵,通过显式或隐式形式的运动微分方程进行扩展。
property mass_matrix_kin
系统的运动“质量矩阵” (\mathbf{k_{k\dot{q}}})。
rhs(inv_method=None)
返回第一阶形式的系统运动方程。输出是:
x' = |q'| =: f(q, u, r, p, t)
|u'|
大多数数值 ODE 积分器所需的右手边。
参数:
inv_method:str
要使用的具体 sympy 逆矩阵计算方法。有关有效方法的列表,请参见
inv()
to_linearizer(linear_solver='LU')
返回由 KanesMethod 类中的数据初始化的 Linearizer 类的实例。这可能比使用 linearize 类方法更可取,因为 Linearizer 对象将允许更高效的重新计算(即在不同操作点周围)。
参数:
linear_solver:str,可调用
在线性化过程中用来解决形式为
A*x=b
的几个符号线性系统的方法。如果提供了字符串,它应该是可以与sympy.matrices.matrixbase.MatrixBase.solve()
一起使用的有效方法。如果提供了一个可调用对象,则它应该具有格式x = f(A, b)
,其中它解决方程并返回解。默认值为'LU'
,对应于 SymPy 的A.LUsolve(b)
。LUsolve()
计算快速但通常会导致除以零,因此结果为nan
。
返回:
Linearizer
一个实例化的
sympy.physics.mechanics.linearize.Linearizer
。
class sympy.physics.mechanics.lagrange.LagrangesMethod(Lagrangian, qs, forcelist=None, bodies=None, frame=None, hol_coneqs=None, nonhol_coneqs=None)
拉格朗日方法对象。
解释
该对象通过两步过程生成运动方程。第一步涉及通过提供最小限度的拉格朗日和广义坐标来初始化 LagrangesMethod。如果有任何约束方程,它们可以作为关键字参数提供。拉格朗日乘数会自动生成,并且与约束方程的数量相等。同样,任何非保守力可以与参考框架一起作为可迭代对象(如下所述并在示例中显示)。这也在 init 方法中进一步讨论。
示例
这是一个一自由度传动弹簧-质量-阻尼器的简单示例。
在这个例子中,我们首先需要进行运动学分析。这涉及创建广义坐标及其导数。然后我们创建一个点并在一个参考框架中设置其速度。
>>> 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)
随后需要准备 LagrangesMethod 所需的信息来生成运动方程。首先创建粒子,其附有一个点。然后,从动能和势能创建拉格朗日量。接下来必须构建非保守力/力矩的可迭代对象,其中每个项是 (Point, Vector) 或 (ReferenceFrame, Vector) 元组,其中向量表示非保守力或力矩。
>>> Pa = Particle('Pa', P, m)
>>> Pa.potential_energy = k * q**2 / 2.0
>>> L = Lagrangian(N, Pa)
>>> fl = [(P, -b * qd * N.x)]
最后我们可以生成运动方程。首先创建 LagrangesMethod 对象。为此,必须提供拉格朗日量和广义坐标。如果适用,还可以提供约束方程、力列表和惯性参考系。接下来生成拉格朗日运动方程,即:拉格朗日运动方程 = 0。此时我们得到了运动方程。
>>> 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))]])
我们还可以使用 'rhs' 方法求解状态。
>>> print(l.rhs())
Matrix([[Derivative(q(t), t)], [(-b*Derivative(q(t), t) - 1.0*k*q(t))/m]])
请参考每个方法的文档字符串获取更多细节。
属性
q, u | (矩阵) 广义坐标和速度的矩阵 |
---|---|
负载 | (可迭代的) 描述系统受力的 (Point, vector) 或 (ReferenceFrame, vector) 元组。 |
bodies | (可迭代的) 包含系统的刚体和粒子。 |
mass_matrix | (矩阵) 系统的质量矩阵 |
forcing | (矩阵) 系统的迫使向量 |
mass_matrix_full | (矩阵) qdot、qdoubledot 和拉格朗日乘子(lam)的“质量矩阵” |
forcing_full | (矩阵) qdot、qdoubledot 和拉格朗日乘子(lam)的完整迫使向量 |
property forcing
从 'lagranges_equations' 方法返回迫使向量。
property forcing_full
将 qdots 添加到上述迫使向量。
form_lagranges_equations()
形成拉格朗日运动方程的方法。
使用拉格朗日第二类方程返回运动方程的向量。
linearize(q_ind=None, qd_ind=None, q_dep=None, qd_dep=None, linear_solver='LU', **kwargs)
在符号操作点附近线性化运动方程。
参数:
线性求解器 : 字符串, 可调用对象
用于解决线性化过程中形如
A*x=b
的多个符号线性系统的方法。如果提供了字符串,则应该是可用于sympy.matrices.matrixbase.MatrixBase.solve()
的有效方法之一。如果提供了可调用对象,则其格式应为x = f(A, b)
,其中它解决方程并返回解。默认为'LU'
,对应于 SymPy 的A.LUsolve(b)
。LUsolve()
计算速度快,但通常会导致除以零,从而得到nan
结果。
**kwargs
额外的关键字参数传递给
sympy.physics.mechanics.linearize.Linearizer.linearize()
。
解释
如果 kwarg A_and_B 为 False(默认值),则返回线性化形式的 M、A、B 和 r,即 M[q’, u’]^T = A[q_ind, u_ind]^T + B*r。
如果 kwarg A_and_B 为 True,则返回线性化形式 dx = Ax + Br 的 A、B、r,其中 x = [q_ind, u_ind]^T。请注意,如果有许多符号参数,这在计算上是很密集的。因此,如果 A_and_B=False,则更希望返回 M、A 和 B。然后可以将这些矩阵的值代入,并找到状态空间形式,如 A = P.TM.inv()A,B = P.TM.inv()B,其中 P = Linearizer.perm_mat。
在这两种情况下,r 被发现为运动方程中的所有动力符号,这些符号不是 q、u、q’或 u’的一部分。它们以规范形式排序。
操作点也可以使用op_point
关键字输入。这需要一个{symbol: value}的字典,或这样的字典的可迭代对象。值可以是数值或符号。您能够预先指定的值越多,这个计算就会越快。
更多文档,请参阅Linearizer
类。
property mass_matrix
返回 mass matrix,如果必要,会增加 Lagrange 乘子。
说明
如果系统由'n'个广义坐标描述,并且没有约束方程,则返回一个 n x n 矩阵。
如果有'n'个广义坐标和'm'个约束方程在初始化期间提供,则返回一个 n x (n+m)矩阵。第(n + m - 1)列和第(n + m)列包含 Lagrange 乘子的系数。
property mass_matrix_full
将 qdots 的系数增加到 mass_matrix 中。
rhs(inv_method=None, **kwargs)
返回可以数值解的方程。
参数:
inv_method:str
用于计算具体的 sympy 逆矩阵的方法。有关有效方法的列表,请参见
inv()
solve_multipliers(op_point=None, sol_type='dict')
在指定的操作点符号地解决 Lagrange 乘子的值。
参数:
op_point:dict 或字典的可迭代对象,可选
要解决的点。操作点被指定为{symbol: value}的字典或字典的可迭代对象。该值本身可以是数值或符号。
sol_type:str,可选
解决方案返回类型。有效选项为:- ‘dict’:{symbol : value}的字典(默认)- ‘Matrix’:解的有序列矩阵
to_linearizer(q_ind=None, qd_ind=None, q_dep=None, qd_dep=None, linear_solver='LU')
返回一个 Linearizer 类的实例,从 LagrangesMethod 类中的数据初始化。这可能比使用 linearize 类方法更可取,因为 Linearizer 对象将允许更有效的重新计算(即关于不同操作点的变化)。
参数:
q_ind, qd_ind:array_like,可选
独立的广义坐标和速度。
q_dep, qd_dep:array_like,可选
依赖的广义坐标和速度。
linear_solver:str,可调用的
用于在线性化过程中解决形如
A*x=b
的多个符号线性系统的方法。如果提供了一个字符串,则应该是可以与sympy.matrices.matrixbase.MatrixBase.solve()
一起使用的有效方法。如果提供了一个可调用对象,则应该具有x = f(A, b)
的格式,其中它解决方程并返回解。默认值是'LU'
,对应于 SymPy 的A.LUsolve(b)
。LUsolve()
计算速度快,但通常会导致除零错误,从而得到nan
结果。
返回:
Linearizer
已实例化的
sympy.physics.mechanics.linearize.Linearizer
。
关节框架(文档字符串)
原文:
docs.sympy.org/latest 原文:[https://docs.sympy.org/latest/modules/physics/mechanics/api/joint.html
关节(文档字符串)
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)
所有具体关节的抽象基类。
参数:
name : string
关节的唯一名称。
parent : Particle or RigidBody or Body
关节的父体。
child : Particle or RigidBody or Body
关节的子体。
coordinates : iterable of dynamicsymbols, optional
关节的广义坐标。
speeds : iterable of dynamicsymbols, optional
关节的广义速度。
parent_point : Point or Vector, optional
关节固定到父体的附着点。如果提供了向量,则通过将向量添加到体的质心来计算附着点。默认值为父体的质心。
child_point : Point or Vector, optional
关节固定到子体的附着点。如果提供了向量,则通过将向量添加到体的质心来计算附着点。默认值为子体的质心。
parent_axis : Vector, optional
自版本 1.12 起已废弃:与子体中与父体中对齐的轴固定的轴。默认为父体参考系的 x 轴。有关此废弃的更多信息,请参见新关节中间框架。
child_axis : Vector, optional
自版本 1.12 起已废弃:与父体中与子体中对齐的轴固定的轴。默认为子体参考系的 x 轴。有关此废弃的更多信息,请参见新关节中间框架。
parent_interframe : ReferenceFrame, optional
父体的中间框架,关节变换相对于此框架进行。如果提供了 Vector,则创建一个与给定向量的 X 轴对齐的中间框架。默认值为父体自身框架。
child_interframe : ReferenceFrame, optional
子体的中间框架,关节变换相对于此框架进行。如果提供了 Vector,则创建一个与给定向量的 X 轴对齐的中间框架。默认值为子体自身框架。
parent_joint_pos : Point or Vector, optional
自版本 1.12 起已废弃:此参数由 parent_point 替换,并将在未来版本中删除。有关更多信息,请参见关节附着点参数更改。
child_joint_pos : Point or Vector, optional
自版本 1.12 起已弃用:此参数已由 child_point 取代,并将在将来的版本中删除。有关更多信息,请参见关节附着点参数变更。
解释
关节从物体中减少自由度。这是所有特定关节的基类,并包含作为所有关节接口的所有常用方法。可以通过继承 Joint 类并定义所有抽象函数来创建自定义关节。
抽象方法包括:
-
_generate_coordinates
-
_generate_speeds
-
_orient_frames
-
_set_angular_velocity
-
_set_linear_velocity
注释
当将向量作为中间坐标系提供时,将创建一个新的中间坐标系,使其 X 轴与提供的向量对齐。这是通过围绕旋转轴的单次固定旋转来完成的。此旋转轴是通过将body.x
轴与提供的向量进行叉乘来确定的。在提供的向量为-body.x
方向的情况下,将围绕body.y
轴进行旋转。
属性
name | (string) 关节的名称。 |
---|---|
parent | (Particle or RigidBody or Body) 关节的父体。 |
child | (Particle or RigidBody or Body) 关节的子体。 |
coordinates | (Matrix) 关节的广义坐标矩阵。 |
speeds | (Matrix) 关节的广义速度矩阵。 |
parent_point | (Point) 关节固定在父体上的附着点。 |
child_point | (Point) 关节固定在子体上的附着点。 |
parent_axis | (Vector) 固定在父坐标系中的表示关节的轴。 |
child_axis | (Vector) 固定在子坐标系中的表示关节的轴。 |
parent_interframe | (ReferenceFrame) 父体的中间坐标系,关节变换相对于此坐标系进行。 |
child_interframe | (ReferenceFrame) 子体的中间坐标系,关节变换相对于此坐标系进行。 |
kdes | (Matrix) 关节的运动微分方程。 |
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)
销轴(旋转)关节。
参数:
name:字符串。
joint 的唯一名称。
parent:粒子或刚体或物体。
joint 的父体。
child:粒子或刚体或物体。
joint 的子体。
coordinates:动力符号,可选。
joint 的广义坐标。
speeds:动力符号,可选。
joint 的广义速度。
parent_point:点或向量,可选。
关节固定在父体的附着点。如果提供了一个向量,则通过将该向量添加到体的质心来计算附着点。默认值是父体的质心。
child_point:点或向量,可选。
关节固定在子体的附着点。如果提供了一个向量,则通过将该向量添加到体的质心来计算附着点。默认值是子体的质心。
parent_axis:向量,可选。
自版本 1.12 起弃用:在父体中固定的轴,与子体中固定的轴对齐。默认为父体参考框架的 x 轴。有关此弃用的更多信息,请参见新联合中间框架。
child_axis:向量,可选
自版本 1.12 起弃用:在子体中固定的轴,与父体中固定的轴对齐。默认为子体参考框架的 x 轴。有关此弃用的更多信息,请参见新联合中间框架。
parent_interframe:参考框架,可选
父体的中间框架,用于制定联合变换。如果提供了一个向量,则创建一个内部框架,将其 X 轴与给定向量对齐。默认值为父体自身的框架。
child_interframe:参考框架,可选
子体的中间框架,用于制定联合变换。如果提供了一个向量,则创建一个内部框架,将其 X 轴与给定向量对齐。默认值为子体自身的框架。
joint_axis:向量
旋转发生的轴。请注意,此轴的分量在父体中间框架和子体中间框架中是相同的。
parent_joint_pos:点或向量,可选
自版本 1.12 起弃用:此参数已被 parent_point 替换,并将在将来的版本中删除。有关更多信息,请参见关于联合附件点参数更改。
child_joint_pos:点或向量,可选
自版本 1.12 起弃用:此参数已被 child_point 替换,并将在将来的版本中删除。有关更多信息,请参见关于联合附件点参数更改。
解释
小销关节定义为联合旋转轴在子体和父体中固定,联合的位置相对于每个体的质心。子体相对于父体围绕旋转轴旋转角度θ,并具有相对于父体的简单角速度ω。子体中间框架与父体中间框架之间的方向余弦矩阵是通过简单围绕联合轴的旋转形成的。有关联合框架的更详细解释,请参阅联合框架页面。
示例
从两个物体创建一个单销关节,并具有以下基本属性:
>>> 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
属性
name | (字符串) 关节的名称。 |
---|---|
parent | (粒子或刚体或体) 关节的父体。 |
child | (粒子或刚体或体) 关节的子体。 |
coordinates | (矩阵) 关节的广义坐标。默认值为 dynamicsymbols(f'q_{joint.name}') 。 |
速度 | (矩阵) 关节的广义速度。默认值为 dynamicsymbols(f'u_{joint.name}') 。 |
parent_point | (点) 关节固定在父体的附着点。 |
child_point | (点) 关节固定在子体的附着点。 |
parent_axis | (向量) 固定在父体坐标系中的表示关节的轴。 |
child_axis | (向量) 固定在子体坐标系中的表示关节的轴。 |
parent_interframe | (参考系) 父体相对于其制定关节变换的中间参考系。 |
child_interframe | (参考系) 子体相对于其制定关节变换的中间参考系。 |
joint_axis | (向量) 发生旋转的轴。请注意,此轴的各个分量在父参考系和子参考系中是相同的。 |
kdes | (矩阵) 关节的运动微分方程。 |
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)
棱柱(滑动)关节。
参数:
name : 字符串
关节的唯一名称。
parent : 粒子或刚体或体
关节的父体。
child : 粒子或刚体或体
关节的子体。
coordinates : 动力学符号,可选
关节的广义坐标。默认值为
dynamicsymbols(f'q_{joint.name}')
。
speeds : 动力学符号,可选
关节的广义速度。默认值为
dynamicsymbols(f'u_{joint.name}')
。
parent_point : 点或向量,可选
关节固定在父体的附着点。如果提供了一个向量,则附着点通过将向量添加到体的质心来计算。默认值为父体的质心。
child_point : 点或向量,可选
关节固定在子体上的附着点。如果提供了一个向量,则通过将该向量添加到体的质心来计算附着点。默认值为子体的质心。
parent_axis:Vector,可选
自版本 1.12 起弃用:父体中固定的轴与子体中固定的轴对齐。默认情况下为父体参考系的 x 轴。有关此弃用的更多信息,请参见新关节中间框架。
child_axis:Vector,可选
自版本 1.12 起弃用:子体中固定的轴与父体中固定的轴对齐。默认情况下为子体参考系的 x 轴。有关此弃用的更多信息,请参见新关节中间框架。
父 _interframe:ReferenceFrame,可选
父体的中间框架,关节变换是相对于它进行的。如果提供了一个向量,则创建一个中间框架,其 X 轴与给定向量对齐。默认值为父体自身框架。
child_interframe:ReferenceFrame,可选
子体的中间框架,关节变换是相对于它进行的。如果提供了一个向量,则创建一个中间框架,其 X 轴与给定向量对齐。默认值为子体自身框架。
joint_axis:Vector
平移发生的轴。请注意,该轴的分量在父 _interframe 和子 _interframe 中相同。
parent_joint_pos:Point 或 Vector,可选
自版本 1.12 起弃用:此参数已被 parent_point 替代,并将在将来的版本中移除。有关更多信息,请参见关节附着点参数的更改。
child_joint_pos:Point 或 Vector,可选
自版本 1.12 起弃用:此参数已被 child_point 替代,并将在将来的版本中移除。有关更多信息,请参见关节附着点参数的更改。
解释
定义如下:子体沿着固定于父体的关节轴进行平移。关节的位置由两点定义,分别位于每个体内,当广义坐标为零时它们重合。父 _interframe 和子 _interframe 之间的方向余弦矩阵是单位矩阵。因此,父体和子体框架之间的方向余弦矩阵由中间框架的定义完全确定。有关关节框架的页面提供了更详细的解释。
示例
创建一个单一的平移关节,由两个物体组成,并具有以下基本属性:
>>> 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)
一旦建立关节,可以访问连接体的运动学。首先找到 Part 相对于天花板的方向余弦矩阵:
>>> 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
属性
name | (字符串) 关节的名称。 |
---|---|
parent | (粒子或刚体或物体) 关节的父体。 |
child | (粒子或刚体或物体) 关节的子体。 |
coordinates | (矩阵) 关节的广义坐标矩阵。 |
speeds | (矩阵) 关节的广义速度矩阵。 |
parent_point | (点) 关节固定到父体的附着点。 |
child_point | (点) 关节固定到子体的附着点。 |
parent_axis | (向量) 固定在父体框架中代表关节的轴。 |
child_axis | (向量) 固定在子体框架中代表关节的轴。 |
parent_interframe | (参考系) 父体的中间框架,关于该框架制定关节变换。 |
child_interframe | (参考系) 子体相对于其制定关节变换的中间框架。 |
kdes | (矩阵) 关节的运动微分方程。 |
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)
圆柱关节。
参数:
name : string
关节的唯一名称。
parent : 粒子或刚体或物体
关节的父体。
child : 粒子或刚体或物体
关节的子体。
rotation_coordinate : dynamicsymbol, optional
对应于旋转角度的广义坐标。默认值为
dynamicsymbols(f'q0_{joint.name}')
。
translation_coordinate : dynamicsymbol, optional
对应于平移距离的广义坐标。默认值为
dynamicsymbols(f'q1_{joint.name}')
。
rotation_speed : dynamicsymbol, optional
对应于角速度的广义速度。默认值为
dynamicsymbols(f'u0_{joint.name}')
。
translation_speed:dynamicsymbol,可选
对应于平移速度的广义速度。默认值为
dynamicsymbols(f'u1_{joint.name}')
。
parent_point:Point 或 Vector,可选
关节固定到父体的附着点。如果提供了一个向量,则通过将该向量添加到物体的质心来计算附着点。默认值为父体的质心。
child_point:Point 或 Vector,可选
连接点,即连接到子体的关节固定点。如果提供了一个向量,则通过将该向量添加到物体的质心来计算连接点。默认值为子体的质心。
parent_interframe:ReferenceFrame,可选
父体的中间框架,相对于该框架,关节变换被规定。如果提供了一个向量,则创建一个中间框架,使其 X 轴与给定向量对齐。默认值为父体自己的框架。
child_interframe:ReferenceFrame,可选
子体的中间框架,相对于该框架,关节变换被规定。如果提供了一个向量,则创建一个中间框架,使其 X 轴与给定向量对齐。默认值为子体自己的框架。
joint_axis:Vector,可选
旋转和平移轴。注意,此轴的分量在父框架和子框架中是相同的。
说明
定义一个圆柱关节,使得子体围绕固定关节轴旋转并沿着父体进行平移。关节轴既是旋转轴也是平移轴。关节位置由两个点定义,每个点在两个体中都相同,当对应于平移的广义坐标为零时重合。子体中间框架和父体中间框架之间的方向余弦矩阵是通过关节轴的简单旋转形成的。关于关节框架的页面提供了更详细的解释。
例子
在两个物体之间创建单个圆柱连接,并具有以下基本属性:
>>> 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)]])
属性
name | (字符串) 关节的名称。 |
---|---|
parent | (粒子或刚体或物体) 关节的父体。 |
child | (粒子或刚体或物体) 关节的子体。 |
rotation_coordinate | (动力学符号) 对应于旋转角度的广义坐标。 |
translation_coordinate | (动力学符号) 对应于平移距离的广义坐标。 |
rotation_speed | (动力学符号) 对应于角速度的广义速度。 |
translation_speed | (动力学符号) 对应于平移速度的广义速度。 |
coordinates | (矩阵) 关节的广义坐标矩阵。 |
speeds | (矩阵) 关节的广义速度矩阵。 |
parent_point | (点) 关节固定在父体上的附着点。 |
child_point | (点) 关节固定在子体上的附着点。 |
parent_interframe | (参考系) 父体的中间参考系,相对于它进行关节变换。 |
child_interframe | (参考系) 子体的中间参考系,相对于它进行关节变换。 |
kdes | (矩阵) 关节的运动微分方程。 |
joint_axis | (向量) 旋转和平移的轴线。 |
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)
平面关节。
参数:
name:字符串
关节的唯一名称。
parent:Particle 或 RigidBody 或 Body
关节的母体。
child:Particle 或 RigidBody 或 Body
关节的父体。
rotation_coordinate:dynamicsymbol,可选
对应于旋转角度的广义坐标。默认值为
dynamicsymbols(f'q0_{joint.name}')
。
planar_coordinates:动态符号的可迭代对象,可选
用于平面平移的两个广义坐标。默认值为
dynamicsymbols(f'q1_{joint.name} q2_{joint.name}')
。
rotation_speed:dynamicsymbol,可选
对应于角速度的广义速度。默认值为
dynamicsymbols(f'u0_{joint.name}')
。
planar_speeds:dynamicsymbols,可选
用于平面平移速度的两个广义速度。默认值为
dynamicsymbols(f'u1_{joint.name} u2_{joint.name}')
。
parent_point:点或向量,可选
关节固定在父体的附着点。如果提供了一个向量,则通过将该向量添加到体的质心来计算附着点。默认值为父体的质心。
child_point:点或向量,可选
关节固定在子体的附着点。如果提供了一个向量,则通过将该向量添加到体的质心来计算附着点。默认值为子体的质心。
parent_interframe:ReferenceFrame,可选
父体的中间框架,关于该框架制定了关节变换。如果提供了一个向量,则创建一个使其 X 轴与给定向量对齐的中间框架。默认值为父体自己的框架。
child_interframe:ReferenceFrame,可选
中间框架是子体的一种,用于该框架制定关节变换。如果提供了一个向量,则创建一个使其 X 轴与给定向量对齐的中间框架。默认值为子体自己的框架。
说明
定义了一个平面关节,使得子体在父体的固定平面上平移,并绕着与该平面垂直的旋转轴旋转。该平面的原点是parent_point
,由两个非平行平面向量张成。child_point
的位置基于平面向量((\vec{v}_1), (\vec{v}_2))和广义坐标((q_1), (q_2)),即 (\vec{r} = q_1 \hat{v}_1 + q_2 \hat{v}_2)。child_interframe
与parent_interframe
之间的方向余弦矩阵通过围绕旋转轴的简单旋转((q_0))形成。
为了简化PlanarJoint
的定义,rotation_axis
和planar_vectors
设置为根据下表的parent_interframe
的单位向量。这样确保只能通过创建一个单独的框架并提供作为中间框架来定义这些向量。但是,如果您只想相对于父体和子体定义平面的法线,那么您也可以将这些法线提供给parent_interframe
和child_interframe
参数。这两种情况的示例在下面的示例部分中,关节框架页面提供了对中间框架更详细的解释。
rotation_axis |
parent_interframe.x |
---|---|
planar_vectors[0] |
parent_interframe.y |
planar_vectors[1] |
parent_interframe.z |
示例
创建了两个体之间的单一平面关节,并具有以下基本属性:
>>> 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
参数提供向量来实现。在这种情况下,将创建一个 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))]])
属性
name | (string) 关节的名称。 |
---|---|
parent | (Particle or RigidBody or Body) 关节的父体。 |
child | (Particle or RigidBody or Body) 关节的子体。 |
rotation_coordinate | (dynamicsymbol) 对应于旋转角度的广义坐标。 |
planar_coordinates | (Matrix) 用于平面平移的两个广义坐标。 |
rotation_speed | (dynamicsymbol) 对应于角速度的广义速度。 |
planar_speeds | (Matrix) 用于平面平移速度的两个广义速度。 |
coordinates | (Matrix) 关节的广义坐标矩阵。 |
speeds | (Matrix) 关节的广义速度矩阵。 |
parent_point | (Point) 关节固定到父体的附着点。 |
child_point | (Point) 关节固定到子体的附着点。 |
parent_interframe | (参考框架) 父体的中间框架,关节变换相对于该框架进行。 |
child_interframe | (参考框架) 子体的中间框架,关节变换相对于该框架进行。 |
kdes | (矩阵) 关节的运动微分方程。 |
rotation_axis | (矢量) 旋转发生的轴线。 |
planar_vectors | (列表) 描述平面平移方向的向量。 |
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)
球形(球-插座)关节。
参数:
name : 字符串
关节的唯一名称。
parent : 粒子或刚体或主体
关节的父体。
child : 粒子或刚体或主体
关节的子体。
coordinates: 可迭代的动力符号,可选
关节的广义坐标。
speeds : 可迭代的动力符号,可选
关节的广义速度。
parent_point : 点或矢量,可选
关节固定在父体上的连接点。如果提供了矢量,则通过将矢量添加到体的质心来计算连接点。默认值为父体的质心。
child_point : 点或矢量,可选
连接点,关节固定在子体上。如果提供了矢量,则通过将矢量添加到体的质心来计算连接点。默认值为子体的质心。
parent_interframe : 参考框架,可选
父体的中间框架,关节变换相对于该框架进行。如果提供了矢量,则创建一个与给定矢量的 X 轴对齐的中间框架。默认值为父体自己的框架。
child_interframe : 参考框架,可选
子体的中间框架,关节变换相对于该框架进行。如果提供了矢量,则创建一个与给定矢量的 X 轴对齐的中间框架。默认值为子体自己的框架。
rot_type : 字符串,可选
用于生成方向余弦矩阵的方法。支持的方法包括:
'Body'
:关于新的中间轴的三次连续旋转,也称为“欧拉和泰特-布莱恩角度”'Space'
:关于父框架的单位向量的三次连续旋转默认方法为
'Body'
。
amounts :
定义旋转角度或方向余弦矩阵的表达式。这些必须与
rot_type
匹配。有关详细信息,请参见下面的示例。输入类型为:
'Body'
: 三个表达式、符号或函数的元组'Space'
: 三个表达式、符号或函数的元组默认的数量是给定的
coordinates
。
rot_order : 字符串或整数,可选
如果适用,连续旋转的顺序。例如,字符串
'123'
和整数123
是等效的。对于'Body'
和'Space'
是必需的。默认值为123
。
解释
定义球形关节,使得子体可以在任意方向上自由旋转,但不允许child_point
的平移。正如图中所示,parent_point
和child_point
固定在一起,即joint_point
。使用parent_interframe.orient(child_interframe, rot_type, amounts, rot_order)
方法定义此旋转。默认旋转由三个相对旋转组成,即体固定旋转。基于这些旋转导出的方向余弦矩阵,基于广义坐标和广义速度计算角速度。
示例
从两个体创建一个单一的球形关节,并具有以下基本属性:
>>> 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')
关节将把小球连接到地面,关节位于距离子体质心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)))]])
Attributes
name | (字符串) 关节的名称。 |
---|---|
parent | (粒子或刚体或物体) 关节的父体。 |
child | (粒子或刚体或物体) 关节的子体。 |
coordinates | (矩阵) 关节的广义坐标矩阵。 |
speeds | (矩阵) 关节的广义速度矩阵。 |
parent_point | (点) 关节固定在父体上的连接点。 |
child_point | (点) 关节固定在子体上的连接点。 |
parent_interframe | (参考系) 父体的中间框架,关节变换相对于该框架制定。 |
child_interframe | (参考系) 子体的中间框架,关节变换相对于该框架制定。 |
kdes | (矩阵) 关节的运动学微分方程。 |
class sympy.physics.mechanics.joint.WeldJoint(name, parent, child, parent_point=None, child_point=None, parent_interframe=None, child_interframe=None)
焊接关节。
参数:
名称 : 字符串
联接的唯一名称。
父级 : 粒子或刚体或体
联接的父体。
子级 : 粒子或刚体或体
联接的子体。
父级点 : 点或向量, 可选
附件点,固定在父体上的联接点。如果提供向量,则通过将向量添加到体的质心来计算附件点。默认值为父体的质心。
子级点 : 点或向量, 可选
联接点,固定在子体上的联接点。如果提供向量,则通过将向量添加到体的质心来计算附件点。默认值为子体的质心。
父级中间框架 : 参考框架, 可选
父体的中间框架,关于该框架制定联接变换。如果提供向量,则创建一个使其 X 轴与给定向量对齐的中间框架。默认值为父体自身的框架。
子级中间框架 : 参考框架, 可选
子体的中间框架,关于该框架制定联接变换。如果提供向量,则创建一个使其 X 轴与给定向量对齐的中间框架。默认值为子体自身的框架。
解释
焊接联接定义为子体和父体之间没有相对运动。附件框架(parent_interframe
和 child_interframe
)之间的方向余弦矩阵为单位矩阵,附件点(parent_point
和 child_point
)重合。有关联接框架的详细说明,请参见联接框架页面。
示例
由两个体创建单个焊接关节,并具有以下基本属性:
>>> 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
属性
name | (string) 关节的名称。 |
---|---|
parent | (Particle or RigidBody or Body) 关节的父体。 |
child | (Particle or RigidBody or Body) 关节的子体。 |
coordinates | (Matrix) 关节的广义坐标的矩阵。默认值为 dynamicsymbols(f'q_{joint.name}') 。 |
speeds | (Matrix) 关节广义速度的矩阵。默认值为 dynamicsymbols(f'u_{joint.name}') 。 |
parent_point | (Point) 关节固定到父体的附着点。 |
child_point | (Point) 关节固定到子体的附着点。 |
parent_interframe | (ReferenceFrame) 父体的中间框架,关于它制定了关节变换。 |
child_interframe | (ReferenceFrame) 子体的中间框架,关于它制定了关节变换。 |
kdes | (Matrix) 关节的运动微分方程。 |
系统(文档字符串)
原文:
docs.sympy.org/latest/modules/physics/mechanics/api/system.html
class sympy.physics.mechanics.system.SymbolicSystem(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)
SymbolicSystem 是一个类,其中包含系统的所有信息,以符号格式表示,如运动方程和系统中的主体和载荷。
对于符号系统,可以描述运动方程的三种方式:
[1] 显式形式,其中运动学和动力学结合在一起
x’ = F_1(x, t, r, p)
[2] 隐式形式,其中运动学和动力学结合在一起
M_2(x, p) x’ = F_2(x, t, r, p)
[3] 隐式形式,其中运动学和动力学分开
M_3(q, p) u’ = F_3(q, u, t, r, p) q’ = G(q, u, t, r, p)
其中
x:状态,例如[q, u] t:时间 r:指定的(外生的)输入 p:常数 q:广义坐标 u:广义速度 F_1:显式形式中联合方程的右手边 F_2:隐式形式中联合方程的右手边 F_3:隐式形式中动力学方程的右手边 M_2:隐式形式中联合方程的质量矩阵 M_3:隐式形式中动力学方程的质量矩阵 G:运动学微分方程的右手边
参数:
coord_states:时间函数的有序可迭代集合
此输入将根据是否提供速度而确定是系统的坐标还是状态集合。如果指定了速度,则假定此输入是坐标,否则假定此输入是状态。
right_hand_sideMatrix
此变量是任何形式的运动方程的右手边。具体形式将根据是否提供质量矩阵或坐标导数而假定。
speedsordered:时间函数的有序可迭代集合,可选
这是系统的广义速度集合。如果给定,则假定第一个参数(coord_states)将表示系统的广义坐标。
mass_matrixMatrix,可选
运动方程的隐式形式矩阵(形式[2]和[3])。形式的区别取决于是否传入坐标导数。如果给出坐标导数,则假定为形式[3],否则假定为形式[2]。
coordinate_derivativesMatrix,可选
显式形式的运动学方程的右手边。如果提供,则假定正在以[3]形式输入运动方程。
alg_conIterable,可选
运动方程中包含代数约束而不是微分方程的行的索引。如果方程以[3]形式输入,则假定这些索引引用质量矩阵/右手边组合而不是坐标导数。
output_eqnsDictionary,可选
任何希望跟踪的输出方程都存储在字典中,其中键对应于特定方程的名称,而值则是其在符号形式中的方程。
coord_idxs
可迭代,可选如果
coord_states
对应于状态而不是坐标,则此变量将告诉SymbolicSystem
哪些状态的索引对应于广义坐标。
speed_idxs
可迭代,可选如果
coord_states
对应于状态而不是坐标,则此变量将告诉SymbolicSystem
哪些状态的索引对应于广义速度。
bodies
是 Body/Rigidbody 对象的可迭代集合,可选可迭代对象,包含系统的物体
loads
是负载实例的可迭代集合,可选可迭代对象,包含系统的负载,其中力由(作用点,力矢量)给出,力矩由(作用参考框架,力矩矢量)给出。例如[(point, force), (ref_frame, torque)]
示例
作为简单示例,将简单摆的动态输入到SymbolicSystem
对象中。首先需要一些导入,然后将为摆长(l)、摆尾部质量(m)和重力常数(g)设置符号。
>>> from sympy import Matrix, sin, symbols
>>> from sympy.physics.mechanics import dynamicsymbols, SymbolicSystem
>>> l, m, g = symbols('l m g')
系统将由从垂直方向的角度θ和使用广义速度ω定义,其中ω = θ点。
>>> theta, omega = dynamicsymbols('theta omega')
现在动力学方程已准备好形成,并传递给SymbolicSystem
对象。
>>> 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)
笔记
m:广义速度的数量 n:广义坐标的数量 o:状态的数量
属性
coordinates | (Matrix, shape(n, 1)) 这是系统广义坐标的矩阵。 |
---|---|
speeds | (Matrix, shape(m, 1)) 这是系统广义速度的矩阵。 |
states | (Matrix, shape(o, 1)) 这是系统状态变量的矩阵。 |
alg_con | (List) 此列表包含组合运动方程中代数约束的索引。这些约束的存在要求使用 DAE 求解器而不是 ODE 求解器。如果系统以[3]形式给出,则alg_con 变量将被调整,以便它表示组合运动方程的运动学和动力学,因此始终确保它与输入的质量矩阵匹配。 |
dyn_implicit_mat | (Matrix, shape(m, m)) 这是运动方程[3]中隐式形式的 M 矩阵(质量矩阵或广义惯性矩阵)。 |
dyn_implicit_rhs | (Matrix, shape(m, 1)) 这是运动方程[3]中隐式形式的右手边 F 向量。 |
comb_implicit_mat | (矩阵,形状(o, o)) 这是运动方程[2]中的 M 矩阵。 该矩阵具有块对角结构,其中左上角块(第一行)表示运动方程运动学形式的矩阵,右下角块(最后几行)表示运动方程动力学形式的矩阵。 |
comb_implicit_rhs | (矩阵,形状(o, 1)) 这是运动方程[2]中的 F 向量。 该向量的顶部部分表示运动方程运动学形式的右手边,向量的底部部分表示运动方程动力学形式的右手边。 |
comb_explicit_rhs | (矩阵,形状(o, 1)) 此向量表示联合运动方程以显式形式表示的右手边(上述的形式[1])。 |
kin_explicit_rhs | (矩阵,形状(m, 1)) 这是运动方程运动学形式的显式右手边,如形式[3](G 矩阵)中所示。 |
output_eqns | (字典) 如果给定输出方程,则它们将存储在字典中,其中键对应于特定方程的名称,而值则是其符号形式的方程本身 |
bodies | (元组) 如果系统中给出了主体,则它们将存储在一个元组中,以便将来访问 |
loads | (元组) 如果系统中给出了载荷,则它们将存储在一个元组中,以便将来访问。 这包括力和扭矩,其中力由(施加点,力矢量)给出,扭矩由(作用参考框架,扭矩矢量)给出。 |
property alg_con
返回包含联合运动方程中代数约束行索引的列表
property bodies
返回系统中的主体
property comb_explicit_rhs
返回包含以显式形式表示的运动方程右手边 x’ = F 的列矩阵,其中包括运动方程的运动学方程
property comb_implicit_mat
返回与以隐式形式表示的运动方程(形式[2])M x’ = F 对应的矩阵 M,其中包括运动方程的运动学方程
property comb_implicit_rhs
返回与以隐式形式表示的运动方程(形式[2])M x’ = F 对应的列矩阵 F,其中包括运动方程的运动学方程
compute_explicit_form()
如果在初始化时提供了联合运动方程的显式右手边,则此方法将计算它。 这个计算可能需要一段时间来完成。
constant_symbols()
返回包含系统中所有不依赖于时间的符号的列矩阵
property coordinates
返回广义坐标的列矩阵
property dyn_implicit_mat
返回与动态方程对应的以隐式形式表示的矩阵 M,其中运动方程的运动学方程未包含
property dyn_implicit_rhs
返回与动态方程对应的以隐式形式表示的矩阵 M,其中不包括运动方程的运动学方程
dynamic_symbols()
返回包含系统中所有依赖于时间的符号的列矩阵
property kin_explicit_rhs
返回显式形式的运动学方程右手边,即 q’ = G
property loads
返回系统中的负载
property speeds
返回广义速度的列矩阵
property states
返回状态变量的列矩阵
class sympy.physics.mechanics.system.System(frame=None, fixed_point=None)
定义一个多体系统并形成其运动方程的类。
解释
System
实例存储与模型相关的不同对象,包括刚体、关节、约束和其他相关信息。通过定义各组件之间的关系,System
可以使用诸如 KanesMethod
等后端来形成运动方程。System
已经设计成与第三方库兼容,以增强灵活性和与其他工具的集成。
示例
在下面的示例中,创建了带有摆的小车。小车沿轨道的 x 轴移动,摆绕 z 轴旋转。摆的长度为 l
,将摆表示为一个粒子。为了移动小车,对小车施加了时间相关的力 F
。
首先需要导入一些函数并创建一些变量。
>>> 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')
下一步是创建刚体。还有必要为后来定位粒子与销关节相关的框架创建一个框架,因为粒子没有固定于刚体的框架。
>>> rail = RigidBody('rail')
>>> cart = RigidBody('cart')
>>> bob = Particle('bob')
>>> bob_frame = ReferenceFrame('bob_frame')
初始化系统,以轨道作为牛顿参考。该体系也会自动添加到系统中。
>>> system = System.from_newtonian(rail)
>>> print(system.bodies[0])
rail
创建关节,同时立即将它们添加到系统中。
>>> 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)
添加关节时,还会将相关的广义坐标、广义速度、运动学微分方程和刚体一同加入系统。
>>> 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']
确定了运动学后,我们现在可以应用重力和小车的力 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))
定义完整系统后,我们现在可以形成运动方程。在形成运动方程之前,可以运行一些检查,试图识别一些常见错误。
>>> 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)]])
如果我们添加一个约束以防止粒子在水平(x)方向上移动,则上述示例的复杂性可以增加。可以通过添加一个完全约束来实现。之后,我们还应重新定义我们的(非)独立广义坐标和速度。
>>> 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
利用更新后的系统可以再次形成运动方程。
>>> 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)]])
属性
frame | (ReferenceFrame)系统的惯性参考系。 |
---|---|
fixed_point | (Point)惯性参考系中的固定点。 |
x | (矢量)惯性参考系中固定的单位矢量。 |
y | (矢量)惯性参考系中固定的单位矢量。 |
z | (矢量)惯性参考系中固定的单位矢量。 |
q | (ImmutableMatrix)所有广义坐标的矩阵,即独立广义坐标与依赖广义坐标叠加。 |
u | (ImmutableMatrix)所有广义速度的矩阵,即独立广义速度与依赖广义速度叠加。 |
q_ind | (ImmutableMatrix)独立广义坐标的矩阵。 |
q_dep | (ImmutableMatrix) 依赖广义坐标的矩阵。 |
u_ind | (ImmutableMatrix) 独立广义速度的矩阵。 |
u_dep | (ImmutableMatrix) 依赖广义速度的矩阵。 |
u_aux | (ImmutableMatrix) 辅助广义速度的矩阵。 |
kdes | (ImmutableMatrix) 以表达式形式等于零矩阵的运动微分方程矩阵。 |
bodies | (BodyBase 子类的元组) 构成系统的所有物体的元组。 |
joints | (Joint 的元组) 连接系统中物体的所有关节的元组。 |
loads | (LoadBase 子类的元组) 应用于系统的所有载荷的元组。 |
actuators | (ActuatorBase 子类的元组) 系统中存在的所有执行器的元组。 |
holonomic_constraints | (ImmutableMatrix) 以表达式形式等于零矩阵的完整约束矩阵。 |
nonholonomic_constraints | (ImmutableMatrix) 以表达式形式等于零矩阵的非完整约束矩阵。 |
velocity_constraints | (ImmutableMatrix) 以表达式形式等于零矩阵的速度约束矩阵。这些默认为由扩展非完整约束的时间导数导出的。 |
eom_method | (KanesMethod 或 LagrangesMethod 的子类) 用于形成运动方程的后端。 |
property actuators
系统中存在的执行器的元组。
add_actuators(*actuators)
向系统添加执行器。
参数:
*执行器 :ActuatorBase 的子类
一个或多个执行器。
add_auxiliary_speeds(*speeds)
向系统添加辅助速度。
参数:
*速度 :dynamicsymbols
一个或多个要添加到系统中的辅助速度。
add_bodies(*bodies)
向系统添加物体。
参数:
物体 :Particle 或 RigidBody
一个或多个物体。
add_coordinates(*coordinates, independent=True)
向系统添加广义坐标。
参数:
*坐标 :dynamicsymbols
一个或多个要添加到系统中的广义坐标。
独立 :bool 或 bool 列表,可选
布尔值,表示坐标是依赖还是独立。默认值为 True,因此坐标默认情况下被添加为独立。
add_holonomic_constraints(*constraints)
向系统添加完整约束。
参数:
*约束 :Expr
一个或多个应该为零的完整约束表达式。
add_joints(*joints)
向系统添加关节。
参数:
*连接 :Joint 的子类
一个或多个关节。
Explanation
此方法向系统添加一个或多个关节,包括其相关的对象,即广义坐标、广义速度、运动微分方程和物体。
Notes
对于广义坐标、广义速度和物体,检查它们是否已被系统实例知晓。如果是,则不添加。然而,运动微分方程总是会被添加到系统中,所以你不需要手动提前添加它们。
add_kdes(*kdes)
向系统添加运动微分方程。
参数:
*kdes :Expr
一个或多个运动微分方程。
add_loads(*loads)
向系统添加载荷。
参数:
*loads : Force 或 Torque
一个或多个载荷。
add_nonholonomic_constraints(*constraints)
向系统添加非完整约束。
参数:
*constraints : Expr
一个或多个非完整约束,这些约束是应该为零的表达式。
add_speeds(*speeds, independent=True)
向系统添加广义速度。
参数:
*speeds : dynamicsymbols
要添加到系统中的一个或多个广义速度。
independent : bool 或者 bool 列表,可选
布尔值,指示速度是否是依赖的或独立的。默认为 True,因此速度默认情况下被添加为独立的。
apply_uniform_gravity(acceleration)
通过添加载荷向系统中的所有物体施加均匀重力。
参数:
acceleration : Vector
由于重力引起的加速度。
property bodies
添加到系统中的所有物体的元组。
property eom_method
用于形成运动方程的后端。
property fixed_point
惯性参考框架中的固定点。
property forcing
系统的强制向量。
property forcing_full
系统的强制向量,通过显式或隐式形式的运动微分方程进行扩展。
form_eoms(eom_method=<class 'sympy.physics.mechanics.kane.KanesMethod'>, **kwargs)
形成系统的运动方程。
参数:
eom_method : KanesMethod 或 LagrangesMethod 的子类
用于形成运动方程的后端类。默认为
KanesMethod
。
返回:
ImmutableMatrix
运动方程的向量。
示例
这是一个简单的示例,用于单自由度的弹簧-质量-阻尼器系统。
>>> 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))]])
我们还可以使用 'rhs' 方法来求解状态。
>>> system.rhs()
Matrix([
[ Derivative(q(t), t)],
[(b*Derivative(q(t), t) - k*q(t))/m]])
property frame
系统的惯性参考框架。
classmethod from_newtonian(newtonian)
通过添加载荷将系统构造为牛顿体系。
get_body(name)
通过名称从系统中检索物体。
参数:
name : str
要检索的物体的名称。
返回:
刚体或粒子
具有给定名称的物体,如果没有这样的物体则为 None。
get_joint(name)
通过名称从系统中检索关节。
参数:
name : str
要检索的关节的名称。
返回:
Joint 的子类
具有给定名称的关节,如果没有这样的关节则为 None。
property holonomic_constraints
具有等于零矩阵的完整性约束的矩阵表达式。
property joints
添加到系统中的所有关节的元组。
property kdes
作为表达式等于零矩阵的运动微分方程。这些方程描述了广义坐标和广义速度之间的耦合。
property loads
应用于系统的载荷的元组。
property mass_matrix
系统的质量矩阵。
解释
系统的质量矩阵 (M_d) 和强制向量 (f_d) 描述系统的动力学,如下方程所示:
[M_d \dot{u} = f_d]
其中 (\dot{u}) 是广义速度的时间导数。
property mass_matrix_full
系统的质量矩阵,通过显式或隐式形式的运动微分方程进行扩展。
解释
系统的完整质量矩阵 (M_m) 和完整强制向量 (f_m) 描述系统的动力学和运动学,如下方程所示:
[M_m \dot{x} = f_m]
其中 (x) 是状态向量,堆叠 (q) 和 (u)。
property nonholonomic_constraints
非完整约束作为表达式等于零矩阵的矩阵。
property q
所有广义坐标的矩阵,独立的堆叠在依赖上。
property q_dep
依赖广义坐标的矩阵。
property q_ind
独立广义坐标的矩阵。
rhs(inv_method=None)
计算显式形式的运动方程。
参数:
inv_method : 字符串
用于进行 sympy 逆矩阵计算的特定方法。有关有效方法的列表,请参阅
inv()
返回:
ImmutableMatrix
显式形式的运动方程。
另请参阅
sympy.physics.mechanics.kane.KanesMethod.rhs
KanesMethod 的 rhs
函数。
sympy.physics.mechanics.lagrange.LagrangesMethod.rhs
LagrangesMethod 的 rhs
函数。
property u
所有广义速度的矩阵,独立的堆叠在依赖上。
property u_aux
辅助广义速度的矩阵。
property u_dep
依赖广义速度的矩阵。
property u_ind
独立广义速度的矩阵。
validate_system(eom_method=<class 'sympy.physics.mechanics.kane.KanesMethod'>, check_duplicates=False)
使用一些基本检查验证系统。
参数:
eom_method : KanesMethod 或 LagrangesMethod 的子类
将用于形成运动方程的后端类。不同的后端有不同的检查。默认为
KanesMethod
。
check_duplicates : 布尔值
布尔值,指示是否应检查系统中是否存在重复定义。默认值为 False,因为在向系统添加对象时已经检查了重复性。
解释
此方法根据以下检查验证系统:
-
依赖广义坐标数应等于完整约束数。
-
系统还应知晓由关节定义的所有广义坐标。
-
如果
KanesMethod
作为eom_method
使用:-
系统还应知晓由关节定义的所有广义速度和运动微分方程。
-
依赖广义速度数应等于速度约束数。
-
广义坐标数应小于或等于广义速度数。
-
广义坐标数应等于运动微分方程数。
-
-
如果
LagrangesMethod
作为eom_method
使用:- 不应有任何不是广义坐标的导数的广义速度(包括由关节定义的广义速度)。
注意事项
此方法不能保证向后兼容,因为它可能随时间改进。在某些领域,该方法可能会变得更加严格或更少严格。然而,一个定义良好的系统应该始终通过所有这些测试。
property velocity_constraints
以速度约束为表达式并等于零矩阵的矩阵。速度约束通常由完整约束和非完整约束衍生,除非显式设置。
property x
惯性参考系中固定的单位向量。
property y
惯性参考系中固定的单位向量。
property z
惯性参考系中固定的单位向量。
线性化(文档字符串)
原文链接:
docs.sympy.org/latest/modules/physics/mechanics/api/linearize.html
class sympy.physics.mechanics.linearize.Linearizer(f_0, f_1, f_2, f_3, f_4, f_c, f_v, f_a, q, u, q_i=None, q_d=None, u_i=None, u_d=None, r=None, lams=None, linear_solver='LU')
此对象保存动态系统的一般模型形式。该模型用于计算系统的线性化形式,同时正确处理导致依赖坐标和速度的约束。符号和方法描述在[R739]中。
参考文献
[R739] (1,2)
D. L. Peterson, G. Gede, and M. Hubbard,“Symbolic linearization of equations of motion of constrained multibody systems”,Multibody Syst Dyn,vol. 33,no. 2,pp. 143-161,Feb. 2015,doi: 10.1007/s11044-014-9436-5。
属性
f_0, f_1, f_2, f_3, f_4, f_c, f_v, f_a | (矩阵)包含一般系统形式的矩阵。 |
---|---|
q, u, r | (矩阵)包含广义坐标、速度和输入向量的矩阵。 |
q_i, u_i | (矩阵)独立的广义坐标和速度的矩阵。 |
q_d, u_d | (矩阵)依赖广义坐标和速度的矩阵。 |
perm_mat | (矩阵)排列矩阵,使得[q_ind, u_ind]^T = perm_mat*[q, u]^T |
__init__(f_0, f_1, f_2, f_3, f_4, f_c, f_v, f_a, q, u, q_i=None, q_d=None, u_i=None, u_d=None, r=None, lams=None, linear_solver='LU')
参数:
f_0, f_1, f_2, f_3, f_4, f_c, f_v, f_a:array_like
拥有一般系统形式的方程组。如果参数不存在,则提供空数组或矩阵。
q:array_like
广义坐标。
u:array_like
广义速度
q_i, u_i:array_like,可选
独立的广义坐标和速度。
q_d, u_d:array_like,可选
独立的广义坐标和速度。
r:array_like,可选
输入变量。
lams:array_like,可选
拉格朗日乘数
linear_solver:str,callable
用于解决线性化过程中形式为
A*x=b
的几个符号线性系统的方法。如果提供的是字符串,它应该是一个可以与sympy.matrices.matrixbase.MatrixBase.solve()
一起使用的有效方法。如果提供的是可调用对象,它应具有格式x = f(A, b)
,其中它解决方程并返回解决方案。默认值是'LU'
,对应于 SymPy 的A.LUsolve(b)
。LUsolve()
计算快速,但通常会导致除以零,从而导致nan
结果。
linearize(op_point=None, A_and_B=False, simplify=False)
在操作点附近对系统进行线性化。注意 q_op、u_op、qd_op、ud_op 必须满足运动方程。这些可以是符号的或数值的。
参数:
op_point:字典或字典的可迭代对象,可选
字典或包含所有或部分广义坐标、广义速度及其时间导数的字典的可迭代对象。这些将在线性化完成之前替换到线性化系统中。如果希望操作点是任意符号的集合,则设置为
None
。请注意,任何符号的减少(无论是替换为数字还是具有公共参数的表达式)都将导致更快的运行时。
A_and_B : bool, optional
如果 A_and_B=False(默认),则返回(M, A, B),如果 A_and_B=True,则返回(A, B)。请参阅下文。
simplify : bool, optional
确定返回值在返回前是否被简化。对于大型表达式,这可能需要一些时间。默认为 False。
返回:
M, A, B : 矩阵, A_and_B=False
隐式形式的矩阵:
[M]*[q', u']^T = [A]*[q_ind, u_ind]^T + [B]*r
A, B : 矩阵, A_and_B=True
显式形式的矩阵:
[q_ind', u_ind']^T = [A]*[q_ind, u_ind]^T + [B]*r
注意
请注意,使用 A_and_B=True 进行求解在存在许多符号参数时计算密集。因此,可能更倾向于使用默认的 A_and_B=False,返回 M、A 和 B。稍后可以对这些矩阵进行更多值的替换。然后可以找到状态空间形式为 A = P.TM.LUsolve(A),B = P.TM.LUsolve(B),其中 P = Linearizer.perm_mat。
表达式操作(文档字符串)
原文:
docs.sympy.org/latest/modules/physics/mechanics/api/expr_manip.html
sympy.physics.mechanics.msubs(expr, *sub_dicts, smart=False, **kwargs)
用于物理学衍生表达式的自定义 subs。
遍历一次表达式树,执行在 sub_dicts 中找到的 subs。忽略 Derivative
表达式内的项:
示例
>>> from sympy.physics.mechanics import dynamicsymbols, msubs
>>> x = dynamicsymbols('x')
>>> msubs(x.diff() + x, {x: 1})
Derivative(x(t), t) + 1
注意 sub_dicts 可以是单个字典,也可以是多个字典:
>>> 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
如果 smart=True(默认为 False),还会检查可能导致 nan
的条件,但如果简化后会得到有效表达式。例如:
>>> from sympy import sin, tan
>>> (sin(x)/tan(x)).subs(x, 0)
nan
>>> msubs(sin(x)/tan(x), {x: 0}, smart=True)
1
首先用 sin/cos
替换所有 tan
。然后遍历每个节点。如果节点是分数,则首先对分母进行 subs。如果结果为 0,则尝试简化整个分数。使用这种选择性简化,只针对结果为 1/0 的子表达式,从而实现更快的性能。
sympy.physics.mechanics.find_dynamicsymbols(expression, exclude=None, reference_frame=None)
找到表达式中的所有动态符号。
参数:
expression:SymPy 表达式
exclude:动态符号的可迭代对象,可选
reference_frame:ReferenceFrame,可选
确定给定向量的动态符号的框架。
解释
如果使用了可选的 exclude
关键字参数,则只返回不在可迭代对象 exclude
中的动态符号。如果我们打算将此函数应用于向量,则还需使用可选的 reference_frame
来指示与给定向量的动态符号相关联的相应参考框架。
示例
>>> 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)}
打印(文档字符串)
原文链接:
docs.sympy.org/latest/modules/physics/mechanics/api/printing.html
mechanics_printing
此函数与sympy.physics.vector.printing.init_vprinting
相同。
mprint
此函数与sympy.physics.vector.printing.vprint
相同。
mpprint
此函数与sympy.physics.vector.printing.vpprint
相同。
mlatex
此函数与sympy.physics.vector.printing.vlatex
相同。
路径(文档字符串)
原文:
docs.sympy.org/latest/modules/physics/mechanics/api/pathway.html
实现执行器使用的路径。
class sympy.physics.mechanics.pathway.LinearPathway(*attachments)
一对附件点之间的线性路径。
参数:
attachments:tuple[Point, Point]
两个
Point
对象,线性路径跨越的两个点。构造函数期望传递两个点,例如LinearPathway(Point('pA'), Point('pB'))
。传递更多或更少的点将导致错误抛出。
解释
线性路径形成两点之间的直线段,是可以形成的最简单的路径。它不会与系统中的任何其他对象交互,即LinearPathway
将与其他对象相交,以确保其两端(其附件)之间的路径是最短可能的。
线性路径由可以相对移动的两个点和作用于这些点的一对相等且反向的力组成。如果定义了两点之间的正时间变化欧几里得距离,则“伸展速度”是该距离的时间导数。当两点相互远离时,伸展速度为正;当相互靠近时,为负。对于作用于任一点的力的方向,由构造从另一点指向该点的单位向量来确定。这建立了一个符号约定,使得正力大小倾向于推动点分离。以下图示显示了正力方向和点之间的距离:
P Q
o<--- F --->o
| |
|<--l(t)--->|
示例
>>> from sympy.physics.mechanics import LinearPathway
要构建路径,需要将两个点作为attachments
参数传递为一个tuple
。
>>> from sympy.physics.mechanics import Point
>>> pA, pB = Point('pA'), Point('pB')
>>> linear_pathway = LinearPathway(pA, pB)
>>> linear_pathway
LinearPathway(pA, pB)
在未描述其附件点的位置和速度的情况下,上述创建的路径并不特别有趣。没有这些信息,无法描述路径的运动,即其长度或其伸展速度。
>>> 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
可通过其length
属性访问路径的长度。
>>> linear_pathway.length
sqrt(q(t)**2)
注意返回的看似过于复杂的表达式实际上是必需的,因为它确保了路径的长度始终为正。
类似地,可以通过其extension_velocity
属性访问路径的伸展速度。
>>> linear_pathway.extension_velocity
sqrt(q(t)**2)*Derivative(q(t), t)/q(t)
property extension_velocity
路径伸展速度的精确分析表达式。
property length
路径长度的精确分析表达式。
to_loads(force)
方程运动方法类所需的负载。
参数:
force:Expr
沿路径长度作用的力的大小。根据路径长度、路径伸展速度和点对力的符号约定,如果此
Expr
为正,则力将作用于将一对点推开(它是伸展的)。
解释
当构建运动方程时,KanesMethod
需要将Point
-Vector
元组列表传递给其kanes_equations
方法的loads
参数。此方法充当实用程序,用于生成所需的正确结构的点和向量对,以便这些可以轻松地与负载列表中的其他项目连接,并传递给KanesMethod.kanes_equations
。这些负载也以正确的形式传递给其他运动方程方法类,例如LagrangesMethod
。
示例
下面的示例显示了如何生成线性执行器中产生的扩展力F
的负载。首先,在全局框架N
的x
方向上的坐标q
之间创建两点之间的线性执行器。
>>> 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)
现在创建一个符号F
来描述将沿路径产生的(可扩展的)力的大小。调用路径的to_loads
方法,并将F
作为唯一参数传递,即可生成KanesMethod
所需的负载列表。
>>> 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)]
class sympy.physics.mechanics.pathway.ObstacleSetPathway(*attachments)
一组附着点之间的障碍集路径。
参数:
attachments:tuple[Point, Point]
定义分段障碍集路径的
Point
对象集合。
说明
障碍集路径形成一系列直线段,连接一组点中的相邻点。它类似于多条线性路径端到端连接。它不会与系统中的任何其他对象交互,即ObstacleSetPathway
将保证其附着点(其连接点)之间的路径是可能的最短路径。
示例
要构建障碍集路径,需要将三个或更多点作为tuple
传递给attachments
参数。
>>> 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)
上述创建的路径如果未描述其附着点的位置和速度,则并不十分有趣。没有这些信息,无法描述路径的运动方式,即其长度或伸展速度。
>>> 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
可通过其length
属性访问路径的长度。
>>> obstacle_set_pathway.length.simplify()
sqrt(2)*(sqrt(cos(q(t)) + 1) + 2)
类似地,可通过其extension_velocity
属性访问路径的伸展速度。
>>> obstacle_set_pathway.extension_velocity.simplify()
-sqrt(2)*sin(q(t))*Derivative(q(t), t)/(2*sqrt(cos(q(t)) + 1))
property attachments
定义路径分段路径的点集合。
property extension_velocity
路径伸展速度的精确解析表达式。
property length
路径长度的精确解析表达式。
to_loads(force)
运动方程方法类所需的负载。
参数:
力:Expr
沿路径长度作用的力。假设这个
Expr
代表一个扩展力。
说明
KanesMethod
在构建运动方程时,需要将Point
-Vector
元组列表传递给其kanes_equations
方法的loads
参数。此方法充当实用程序,用于生成所需的正确结构的点和矢量对,以便这些可以轻松地与负载列表中的其他项目连接,并传递给KanesMethod.kanes_equations
。这些负载也以正确的形式传递给其他运动方程方法类,例如LagrangesMethod
。
示例
下面的示例展示了如何在遵循四点之间障碍物设置路径的执行器中生成产生膨胀力F
的负载。首先,在参考框架A
和B
中创建一对参考框架,在这些框架中,四个点pA
、pB
、pC
和pD
将被定位。前两个点在框架A
中,后两个点在框架B
中。框架B
也将被定向,以使其通过全局框架中N.z
轴的旋转q
与A
相关联(N.z
、A.z
和B.z
是平行的)。
>>> 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)
现在创建一个符号F
来描述沿路径产生的(膨胀的)力的大小。通过调用路径的to_loads
方法,并将F
作为唯一参数传递,可以生成KanesMethod
所需的负载列表。
>>> 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)]
class sympy.physics.mechanics.pathway.PathwayBase(*attachments)
所有路径类继承的抽象基类。
注意事项
此类的实例不能直接由用户实例化。然而,可以通过子类化来创建自定义路径类型。
property attachments
定义路径末端的一对点。
abstract property extension_velocity
表示路径扩展速度的表达式。
abstract property length
表示路径长度的表达式。
abstract to_loads(force)
运动方程方法类所需的负载。
解释
KanesMethod
在构建运动方程时,需要将Point
-Vector
元组列表传递给其kanes_equations
方法的loads
参数。此方法充当实用程序,用于生成所需的正确结构的点和矢量对,以便这些可以轻松地与负载列表中的其他项目连接,并传递给KanesMethod.kanes_equations
。这些负载也以正确的形式传递给其他运动方程方法类,例如LagrangesMethod
。
class sympy.physics.mechanics.pathway.WrappingPathway(attachment_1, attachment_2, geometry)
包裹几何对象的路径。
参数:
附件 _1:Point
两个
Point
对象中的第一个,路径跨度的表达式。
附件 _2:Point
两个
Point
对象中的第二个,路径跨度的对象对。
几何:WrappingGeometryBase
包裹路径的几何形状。
解释
一个包裹路径与几何对象相互作用并形成沿其表面平滑包裹的路径。沿着几何对象的包裹路径将是几何对象根据两点定义的测地线。它不会与系统中的任何其他对象相互作用,即WrappingPathway
会与其他对象相交,以确保其两端(其附件)之间的路径是可能的最短路径。
为了解释用于路径长度、扩展速度和应用力方向的符号约定,我们可以忽略包裹路径所与之互动的几何体。包裹路径由可以相对移动的两点组成,并且作用于这些点的一对大小相等且方向相反的力。如果定义了两点之间的正时间变化的欧几里得距离,则“扩展速度”是该距离的时间导数。当两点彼此远离时,扩展速度为正,当彼此靠近时为负。作用于任一点的力的方向由构造的单位向量确定,该单位向量指向另一点到此点。这建立了一种符号约定,使得正力大小倾向于推动点之间的距离。下图显示了正力的方向和点之间的距离:
P Q
o<--- F --->o
| |
|<--l(t)--->|
示例
>>> from sympy.physics.mechanics import WrappingPathway
要构建一个包裹路径,与其他路径一样,必须传递一对点,后跟一个包裹几何类的实例作为关键字参数。我们将使用一个半径为r
且轴平行于N.x
且通过点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))
property extension_velocity
路径扩展速度的精确解析表达式。
property geometry
包裹路径所包裹的几何形状。
property length
路径长度的精确解析表达式。
to_loads(force)
动力学方法类所需的负载。
参数:
力:Expr
沿着路径长度作用的力的大小。假定这个
Expr
代表一个扩展力。
解释
当构建运动方程时,KanesMethod
要求在其kanes_equations
方法的loads
参数中传递一个Point
-Vector
元组列表。这种方法充当一个实用程序,以生成所需的正确结构化的点和向量对,以便这些可以轻松地与列表中的其他项目连接,并传递给KanesMethod.kanes_equations
。这些负载也以正确的形式传递给其他动力学方法类,例如LagrangesMethod
。
示例
下面的示例显示了如何在包裹在圆柱体周围的执行器中生成产生的负载F
。首先,创建一个半径为r
且轴平行于全局框架N
的N.z
方向,并且也通过点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)
使用 WrappingPathway
类创建执行器的路径,该类定义为跨越两点 pA
和 pB
。这两个点位于圆柱体表面,点 pB
的位置相对于点 pA
是由动力学符号 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)
现在创建一个符号 F
来描述(膨胀)力的大小,该力将沿着路径产生。KanesMethod
需要的负载列表可以通过调用路径的 to_loads
方法,并传递 F
作为唯一参数来生成。
>>> 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)]
执行器(文档字符串)
原文链接:
docs.sympy.org/latest/modules/physics/mechanics/api/actuator.html
实现用于链接力和扭矩应用的执行器。
class sympy.physics.mechanics.actuator.ActuatorBase
所有执行器类继承的抽象基类。
注释
该类的实例不能直接由用户实例化。但是,可以通过子类化来创建自定义的执行器类型。
abstract to_loads()
方程运动方法类所需的负载。
说明
KanesMethod
在构建运动方程时需要将Point
-Vector
元组列表传递给其kanes_equations
方法的loads
参数。此方法充当实用程序,以生成所需的正确结构化的点和矢量对,以便这些可以轻松地与负载列表中的其他项目连接,并传递给KanesMethod.kanes_equations
。这些负载也以正确的形式传递给其他运动方程方法类,例如LagrangesMethod
。
class sympy.physics.mechanics.actuator.DuffingSpring(linear_stiffness, nonlinear_stiffness, pathway, equilibrium_length=0)
基于 Duffing 方程的非线性弹簧。
参数:
linear_stiffness:Expr
线性刚度系数(beta)。
nonlinear_stiffness:Expr
非线性刚度系数(alpha)。
pathway:PathwayBase
执行器所遵循的路径。
equilibrium_length:Expr,可选
弹簧处于平衡状态的长度(x)。
说明
在这里,DuffingSpring
表示基于 Duffing 方程的非线性弹簧施加的力:F = -betax-alphax**3,其中 x 是从平衡位置偏移,beta 是线性弹簧常数,alpha 是非线性立方项的系数。
property force
Duffing 弹簧产生的力。
class sympy.physics.mechanics.actuator.ForceActuator(force, pathway)
产生力的执行器。
参数:
force:Expr
定义执行器产生的(扩张性)力的标量表达式。
pathway:PathwayBase
执行器所遵循的路径。这必须是
PathwayBase
的具体子类的实例,例如LinearPathway
。
说明
ForceActuator
是一种沿其长度产生(扩张性)力的执行器。
力致动器使用路径实例来确定其施加在系统上的力的方向和数量。考虑最简单的情况,即使用LinearPathway
实例。该路径由两个可以相对移动的点组成,并导致作用在端点上的一对相等且相反的力。如果定义了两点之间的正时变欧氏距离,则“伸展速度”是该距离的时间导数。当两点彼此远离时,伸展速度为正,当彼此靠近时为负。决定作用于任一点的力的方向是通过构建从另一点指向该点的单位向量来确定的。这建立了一个符号约定,使得正力大小倾向于推动点分开,这是这种情况下“扩展性”的含义。以下图表显示了正力方向和点之间的距离:
P Q
o<--- F --->o
| |
|<--l(t)--->|
示例
要构建一个致动器,必须提供一个表达式(或符号)来表示它可以产生的力,以及指定其作用线的路径。让我们还创建一个全局参考框架,并在其中固定一个点,同时设置另一个点的位置,以便它可以在该框架的x
方向上自由移动,由坐标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))
property force
致动器产生的力的大小。
property pathway
Pathway
定义致动器作用线路。
to_loads()
运动方程方法类所需的加载。
解释
KanesMethod
在构建运动方程时,需要将Point
-Vector
元组列表传递给其loads
参数的kanes_equations
方法。该方法作为一个实用工具,用于生成所需的正确结构的点和向量对,这样可以轻松地与加载列表中的其他项目连接,并传递给KanesMethod.kanes_equations
。这些加载也符合其他运动方程方法类的正确形式,例如LagrangesMethod
。
示例
下面的示例展示了如何生成由线性路径跟随的力致动器产生的加载。在本例中,假设力致动器用于模拟简单的线性弹簧。首先,在全局参考框架N
的x
方向上由坐标q
分隔的两点之间创建一个线性路径。
>>> 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)
现在创建一个符号k
来描述弹簧的刚度,并实例化一个力致动器,该致动器产生与弹簧的刚度和路径长度成比例的(收缩性)力。请注意,致动器类使用的符号约定是扩展力为正,因此为了使弹簧产生收缩力,需要将弹簧力计算为其刚度乘以长度的负值。
>>> from sympy import symbols
>>> from sympy.physics.mechanics import ForceActuator
>>> stiffness = symbols('k')
>>> spring_force = -stiffness*pathway.length
>>> spring = ForceActuator(spring_force, pathway)
弹簧产生的力可以通过调用to_loads
方法在KanesMethod
(和其他运动方程方法)需要的负载列表形式中生成。
>>> spring.to_loads()
[(pA, k*q(t)*N.x), (pB, - k*q(t)*N.x)]
一个简单的线性阻尼器可以以类似的方式建模。创建另一个符号c
来描述阻尼器的阻尼系数。这次实例化一个力作用器,该力与阻尼器的阻尼系数和路径的延伸速度成比例。请注意,阻尼力是负的,因为它作用于阻尼器长度变化的相反方向。
>>> damping_coefficient = symbols('c')
>>> damping_force = -damping_coefficient*pathway.extension_velocity
>>> damper = ForceActuator(damping_force, pathway)
再次,阻尼器产生的力可以通过调用to_loads
方法生成。
>>> damper.to_loads()
[(pA, c*Derivative(q(t), t)*N.x), (pB, - c*Derivative(q(t), t)*N.x)]
class sympy.physics.mechanics.actuator.LinearDamper(damping, pathway)
阻尼器的力是其延伸速度的线性函数。
参数:
阻尼:Expr
阻尼常数。
路径:PathwayBase
执行器遵循的路径。这必须是
PathwayBase
的具体子类的实例,例如LinearPathway
。
解释
请注意,LinearDamper
名称中的“线性”指的是阻尼力是阻尼器长度变化率的线性函数。即对于阻尼系数为c
和延伸速度为v
的线性阻尼器,阻尼力将为-c*v
,这是v
的线性函数。要创建一个沿线性或直线路径在两端之间的阻尼器,需要将一个LinearPathway
实例传递给pathway
参数。
LinearDamper
是ForceActuator
的子类,因此遵循相同的长度、延伸速度和施加在物体附着点上的力的符号约定。力方向的约定是,当一个线性阻尼器以LinearPathway
实例作为其路径实例化时,它们作用于推动阻尼器两端分开的方向。因为阻尼器产生的力与长度变化方向相反,所以当延伸速度为正时,在两端施加的力的标量部分为负,以便在转换为矢量数量时翻转端点力的符号。当延伸速度为负时(即阻尼器缩短时),施加的力的标量部分也为负,以使符号取消,在路径端点的力方向与端点的力的正符号约定相同(即它们作用于推动路径端点分离)。以下图显示了正力感知和点之间的距离:
P Q
o<--- F --->o
| |
|<--l(t)--->|
示例
要构建线性阻尼器,必须提供一个表达式(或符号),用来表示阻尼器的阻尼系数(我们将使用符号c
),并指定其作用路径。让我们还创建一个全局参考框架,并在其中固定一个点的空间位置,同时设置另一个点的位置,使其可以在框架的 x 方向上自由移动,由坐标q
指定。两点彼此移动的速度可以由坐标u
来指定,其中u
是q(t)
的第一阶时间导数(即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))
此阻尼器将产生一个力,其与其阻尼系数和路径的延伸长度成比例。请注意,这个力是负的,因为 SymPy 对执行器的符号约定是负力是收缩性的,而阻尼器的阻尼力将与长度变化的方向相反。
>>> damper.force
-c*sqrt(q(t)**2)*Derivative(q(t), t)/q(t)
另请参见
力执行器
产生力的执行器(LinearDamper
的超类)。
线性路径
一对点之间的直线路径。
property damping
线性阻尼器的阻尼常数。
property force
线性阻尼器产生的阻尼力。
class sympy.physics.mechanics.actuator.LinearSpring(stiffness, pathway, equilibrium_length=0)
其长度的弹簧力为其长度的线性函数。
参数:
刚度 : Expr
弹簧常数。
路径 : PathwayBase
执行器遵循的路径。这必须是
PathwayBase
的一个具体子类的实例,例如LinearPathway
。
平衡长度 : Expr,可选
弹簧处于平衡状态时的长度,即它不产生任何力。默认值为 0,即弹簧力是路径长度的线性函数,没有常量偏移量。
解释
请注意LinearSpring
名称中的“线性”指的是弹簧力是弹簧长度的线性函数的事实。即对于具有刚度k
、其两端距离为x
,且平衡长度为0
的线性弹簧,弹簧力将为-k*x
,这是x
的线性函数。要创建一个遵循线性或直线路径的弹簧,需要将LinearPathway
实例传递给pathway
参数。
LinearSpring
是 ForceActuator
的子类,因此遵循相同的长度、延伸速度和作用于其连接到身体上的点的力的方向的符号约定。力的方向约定是,当线性弹簧实例化为具有 LinearPathway
实例作为其路径时,它们作用于弹簧两端,使它们彼此远离。因为弹簧产生收缩力并在拉伸时拉动两端朝向平衡长度,所以力端点的标量部分为负,以便在转换为矢量量时翻转端点上的力的符号。以下图示显示了正力感知和点之间的距离:
P Q
o<--- F --->o
| |
|<--l(t)--->|
示例
要构造线性弹簧,必须提供一个表达弹簧刚度(弹簧常数)的表达式(或符号),以及指定其作用线的路径。让我们还创建一个全局参考框架,并在其中空间固定其中一个点,同时设置另一个点位于可以自由在框架的 x 方向上移动的坐标 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))
此弹簧将产生与其刚度和路径长度成比例的力。请注意,由于 SymPy 对执行器的符号约定是负力是收缩的,因此此力为负。
>>> spring.force
-k*sqrt(q(t)**2)
要创建具有非零平衡长度的线性弹簧,可以在 LinearSpring
实例的 equilibrium_length
参数上传递一个表达式(或符号)。让我们创建一个符号 l
以表示非零平衡长度,并创建另一个线性弹簧。
>>> l = symbols('l')
>>> spring = LinearSpring(stiffness, linear_pathway, equilibrium_length=l)
>>> spring
LinearSpring(k, LinearPathway(pA, pB), equilibrium_length=l)
这个新弹簧的弹簧力再次与其刚度和路径长度成正比。然而,当 q(t)
等于 l
时,弹簧不会产生任何力。请注意,当 q(t)
小于 l
时,力会变得扩张,正如预期的那样。
>>> spring.force
-k*(-l + sqrt(q(t)**2))
另请参阅
ForceActuator
产生力的执行器(LinearSpring
的超类)。
LinearPathway
一对点之间的直线路径。
property equilibrium_length
弹簧在其不产生力的长度。
property force
线性弹簧产生的弹簧力。
property stiffness
线性弹簧的弹簧常数。
class sympy.physics.mechanics.actuator.TorqueActuator(torque, axis, target_frame, reaction_frame=None)
产生扭矩的执行器。
参数:
扭矩:表达式
定义执行器产生的扭矩的标量表达式。
轴:向量
执行器施加扭矩的轴。
目标框架:参考框架 | 刚体
执行器将施加扭矩的主要框架。
反作用框架:参考框架 | 刚体 | 无
执行器将施加扭矩的次要框架。请注意,(相等和相反的)反作用扭矩应用于该框架。
说明
TorqueActuator
是在一对身体上产生相等且相反扭矩的执行器。
示例
要构建扭矩执行器,必须提供一个表示其可以产生的扭矩的表达式(或符号),以及指定扭矩作用轴线的向量,并且指定扭矩将作用的一对框架。
>>> 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)
注意,因为扭矩实际上作用于框架而不是物体,当传递RigidBody
而不是ReferenceFrame
时,TorqueActuator
将提取与之关联的框架。
classmethod at_pin_joint(torque, pin_joint)
从PinJoint
实例化的替代构造方法。
参数:
torque:Expr
定义执行器产生的扭矩的标量表达式。
pin_joint:PinJoint
销钉关节及其关联的父体和子体,扭矩执行器将作用于其上。扭矩执行器作用于销钉关节的父体和子体,子体作为反作用体。销钉关节的轴线被用作扭矩执行器施加扭矩的轴线。
示例
要创建销钉关节,需要向PinJoint
类的构造函数传递名称、父体和子体。还可以使用joint_axis
关键字参数来控制关节轴线。在这个例子中,让我们使用父体参考框架的 z 轴作为关节轴线。
>>> 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,
... )
让我们还创建一个符号T
,用来表示扭矩执行器施加的扭矩。
>>> from sympy import symbols
>>> torque = symbols('T')
要从先前实例化的torque
和pin_joint
变量创建扭矩执行器,可以将它们传递给TorqueActuator
类的替代构造类方法at_pin_joint
。应注意,正扭矩将导致关节坐标的正位移或者扭矩施加在子体上,产生在父体上的反作用力。
>>> actuator = TorqueActuator.at_pin_joint(torque, pin_joint)
>>> actuator
TorqueActuator(T, axis=N.z, target_frame=A, reaction_frame=N)
property axis
扭矩作用的轴线。
property reaction_frame
扭矩将作用的主要参考框架。
property target_frame
扭矩将作用的主要参考框架。
to_loads()
运动方程方法类所需的负载。
解释
在构造运动方程时,KanesMethod
需要传递到其kanes_equations
方法的loads
参数的Point
-Vector
元组列表。此方法作为一个实用程序,用于生成所需的正确结构化的点和向量对,以便可以轻松地将它们与负载列表中的其他项目连接,并传递给KanesMethod.kanes_equations
。这些负载也以正确的形式传递给其他运动方程方法类,例如LagrangesMethod
。
示例
下面的示例展示了如何生成作用于由销钉关节连接的一对身体上的扭矩执行器产生的负载。
>>> 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)
通过调用to_loads
方法可以生成阻尼器产生的力。
>>> actuator.to_loads()
[(A, T*N.z), (N, - T*N.z)]
或者,如果扭矩执行器创建时没有反作用框架,则to_loads
方法返回的负载将仅包含作用在目标框架上的单个负载。
>>> actuator = TorqueActuator(torque, N.z, N)
>>> actuator.to_loads()
[(N, T*N.z)]
property torque
执行器产生的扭矩大小。
包装几何体(文档字符串)
原文链接:
docs.sympy.org/latest/modules/physics/mechanics/api/wrapping_geometry.html
用于包装路径的几何对象。
class sympy.physics.mechanics.wrapping_geometry.WrappingCylinder(radius, point, axis)
一个实心(无限)圆柱体对象。
参数:
半径:符号
圆柱体的半径。
点:点
圆柱体轴通过的点。
轴:向量
圆柱体对齐的轴线。
解释
允许在两点之间定义圆弧的包装几何体。这些路径始终是测地线(可能的最短路径),即它们在展开后的圆柱体表面上是一条直线。然而,也可以指定一个方向,即路径可以被影响以沿圆柱体的最短侧或最长侧包装。为了定义这些方向,根据右手规则顺时针旋转。
示例
要创建WrappingCylinder
实例,需要一个表示其半径的Symbol
,定义其轴的Vector
,以及通过其轴的Point
:
>>> from sympy import symbols
>>> from sympy.physics.mechanics import (Point, ReferenceFrame,
... WrappingCylinder)
>>> N = ReferenceFrame('N')
>>> r = symbols('r')
>>> pO = Point('pO')
>>> ax = N.x
可以使用半径r
、轴平行于N.x
并通过pO
的圆柱体实例化:
>>> WrappingCylinder(r, pO, ax)
WrappingCylinder(radius=r, point=pO, axis=N.x)
参见
WrappingSphere
包装方向始终为测地线的球面几何体。
property axis
圆柱体对齐的轴线。
geodesic_end_vectors(point_1, point_2)
平行于测地线的两端点处的向量。
参数:
point_1:点
测地线起始点。
point_2:点
测地线终止点。
geodesic_length(point_1, point_2)
几何体表面上两点之间的最短距离。
参数:
point_1:点
测地线长度应计算的起始点。
point_2:点
应计算测地线长度的点。
解释
测地线长度,即连接两点的圆柱体表面上的最短弧长。可以使用毕达哥拉斯定理进行计算。第一个短边是平行于圆柱体轴的两点之间在圆柱体表面上的距离。第二个短边是圆柱体轴垂直方向上连接两点的圆弧。得到的斜边即为测地线长度。
示例
测地线长度只能计算在圆柱体表面上的两点之间。首先,必须创建一个WrappingCylinder
实例以及将位于其表面上的两个点:
>>> from sympy import symbols, cos, sin
>>> from sympy.physics.mechanics import (Point, ReferenceFrame,
... WrappingCylinder, dynamicsymbols)
>>> N = ReferenceFrame('N')
>>> r = symbols('r')
>>> pO = Point('pO')
>>> pO.set_vel(N, 0)
>>> cylinder = WrappingCylinder(r, pO, N.x)
>>> p1 = Point('p1')
>>> p2 = Point('p2')
假设p1
相对于pO
位于N.x + r*N.y
,p2
位于r*(cos(q)*N.y + sin(q)*N.z)
,其中q(t)
是绕N.x
轴按右手规则旋转的广义坐标,其中N.y
为零。可以用以下方式设置这些位置:
>>> q = dynamicsymbols('q')
>>> p1.set_pos(pO, N.x + r*N.y)
>>> p1.pos_from(pO)
N.x + r*N.y
>>> p2.set_pos(pO, r*(cos(q)*N.y + sin(q)*N.z).normalize())
>>> p2.pos_from(pO).simplify()
r*cos(q(t))*N.y + r*sin(q(t))*N.z
圆柱体的半径,这里的测地线长度a
是一个直角三角形的斜边,其它两条边长分别是1
(平行于圆柱体轴)和r*q(t)
(平行于圆柱体横截面),可以使用geodesic_length
方法计算:
>>> cylinder.geodesic_length(p1, p2).simplify()
sqrt(r**2*q(t)**2 + 1)
如果geodesic_length
方法传递一个不在球体表面上的Point
参数,则会引发ValueError
,因为在这种情况下无法计算值。
property point
圆柱体轴经过的点。
point_on_surface(point)
如果一个点位于圆柱体表面上,则返回True
。
参数:
point:点
确定它是否位于圆柱体表面上的点。该点相对于圆柱体轴的位置必须是涉及球体半径的简单表达式,否则此检查可能无法正常工作。
property radius
圆柱体的半径。
class sympy.physics.mechanics.wrapping_geometry.WrappingGeometryBase
所有几何类都要继承的抽象基类。
注意
该类的实例不能由用户直接实例化。但是,可以通过子类化创建自定义几何类型。
abstract geodesic_end_vectors(point_1, point_2)
与圆形测地线在两个端点平行的向量。
参数:
point_1:点
圆形测地线的起点。
point_2:点
圆形测地线的终点。
abstract geodesic_length(point_1, point_2)
返回几何体表面两点之间的最短距离。
参数:
point_1:点
应计算圆形测地线长度的起点。
point_2:点
应计算圆形测地线长度的终点。
abstract property point
几何体关联的点。
abstract point_on_surface(point)
如果一个点位于几何体表面上,则返回True
。
参数:
point:点
确定它是否位于几何体表面上的点。
class sympy.physics.mechanics.wrapping_geometry.WrappingSphere(radius, point)
实心球体。
参数:
radius:符号
球体的半径。该符号必须表示一个正的常数值,即不能是动态符号,也不能是表达式。
point:点
球体的中心点。
解释
允许在两个点之间定义圆弧的包裹几何体。这些路径始终是测地线(最短路径)。
示例
要创建WrappingSphere
实例,需要一个表示其半径的Symbol
和将其中心放置的Point
:
>>> from sympy import symbols
>>> from sympy.physics.mechanics import Point, WrappingSphere
>>> r = symbols('r')
>>> pO = Point('pO')
一个以pO
为中心,半径为r
的球体可以通过以下方式实例化:
>>> WrappingSphere(r, pO)
WrappingSphere(radius=r, point=pO)
另请参阅
WrappingCylinder
允许定义包裹方向的圆柱形几何体。
geodesic_end_vectors(point_1, point_2)
与圆形测地线在两个端点平行的向量。
参数:
point_1:点
圆形测地线的起点。
point_2:点
圆形测地线的终点。
geodesic_length(point_1, point_2)
返回球体表面两点之间的最短距离。
参数:
point_1:点
应计算圆形测地线长度的起点。
point_2:点
应计算测地长度的点。
解释
测地长度,即连接两点的球面上的最短弧长,可以使用以下公式计算:
[l = \arccos\left(\mathbf{v}_1 \cdot \mathbf{v}_2\right)]
其中(\mathbf{v}_1)和(\mathbf{v}_2)是从球心到球面上第一个和第二个点的单位向量。注意,当两个点彼此正好相对时,测地路径的实际路径是未定义的。
示例
地球表面上只能计算两点之间的测地长度。首先,必须创建一个WrappingSphere
实例,以及两个位于其表面上的点:
>>> from sympy import symbols
>>> from sympy.physics.mechanics import (Point, ReferenceFrame,
... WrappingSphere)
>>> N = ReferenceFrame('N')
>>> r = symbols('r')
>>> pO = Point('pO')
>>> pO.set_vel(N, 0)
>>> sphere = WrappingSphere(r, pO)
>>> p1 = Point('p1')
>>> p2 = Point('p2')
假设p1
位于N.x
方向上距离pO
有r
的距离,而p2
位于N.y + N.z
方向上与pO
的球面上。可以通过以下方式设置这些位置:
>>> p1.set_pos(pO, r*N.x)
>>> p1.pos_from(pO)
r*N.x
>>> p2.set_pos(pO, r*(N.y + N.z).normalize())
>>> p2.pos_from(pO)
sqrt(2)*r/2*N.y + sqrt(2)*r/2*N.z
在这种情况下,可以使用geodesic_length
方法计算测地长度,它等于球周长的四分之一:
>>> sphere.geodesic_length(p1, p2)
pi*r/2
如果geodesic_length
方法传递了一个不在球面上的Point
参数,则会引发ValueError
,因为在这种情况下无法计算值。
property point
球的中心点。
point_on_surface(point)
如果点在球面上,则返回True
。
参数:
point:点
应确认是否在球面上的点。这个点相对于球心的位置必须是一个简单的表达式,涉及到球的半径,否则这个检查可能不起作用。
property radius
球的半径。
弃用的类(文档字符串)
原文:
docs.sympy.org/latest/modules/physics/mechanics/api/deprecated_classes.html
自版本 1.13 起已弃用:Body
和 JointsMethod
已被弃用。Body
的功能完全由RigidBody
和 Particle
捕获,并且JointsMethod
的功能完全由System
捕获。
class sympy.physics.mechanics.body.Body(name, masscenter=None, mass=None, frame=None, central_inertia=None)
Body 是一个常见的表示,可以是 SymPy 中的 RigidBody 或 Particle 对象,具体取决于初始化时传入的内容。如果传入了质量并且 central_inertia 为空,则创建 Particle 对象。否则将创建一个 RigidBody 对象。
自版本 1.13 起已弃用:Body 类已被弃用。其功能由RigidBody
和 Particle
捕获。
参数:
name : String
定义物体的名称。用作定义特定物体属性的基础。
masscenter : Point, optional
代表物体或粒子质心的点。如果未指定点,则生成一个点。
mass : Sympifyable, optional
一个可 Sympify 的对象,代表物体的质量。如果未传入质量,则生成一个。
frame : ReferenceFrame, optional
表示物体参考系的参考系。如果未给出参考系,则生成一个参考系。
central_inertia : Dyadic, optional
物体的中心惯性二阶张量。如果在创建刚体时没有传入该参数,则生成默认的惯性。
说明
Body 具有的属性与粒子实例或刚体实例相同,具体取决于创建了哪一个。以下是额外的属性。
示例
由于 Body 已被弃用,以下示例仅用于说明目的。Body 的功能完全由RigidBody
和Particle
捕获。要忽略弃用警告,我们可以使用 ignore_warnings 上下文管理器。
>>> from sympy.utilities.exceptions import ignore_warnings
默认行为。这将创建一个 RigidBody 对象,其中质量、质心、框架和惯性属性具有默认值。
>>> from sympy.physics.mechanics import Body
>>> with ignore_warnings(DeprecationWarning):
... body = Body('name_of_body')
下面的示例演示了指定 Body 对象所有值所需的代码。请注意,这也将创建 Body 对象的 RigidBody 版本。
>>> 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)
创建 Body 对象的 Particle 版本所需的最小代码仅涉及传递名称和质量。
>>> from sympy import Symbol
>>> from sympy.physics.mechanics import Body
>>> mass = Symbol('mass')
>>> with ignore_warnings(DeprecationWarning):
... body = Body('name_of_body', mass=mass)
Body 对象的 Particle 版本也可以接收质心点和参考框架,只是没有惯性。
属性
名称 | (字符串) Body 的名称 |
---|---|
质心 | (Point) 代表刚体质心的点 |
框架 | (ReferenceFrame) Body 固定在其中的参考框架 |
质量 | (可简化) Body 的质量 |
惯性 | ((Dyadic, Point)) Body 围绕其质心的惯性。此属性仅适用于 Body 的刚体形式,对于 Particle 形式则未定义。 |
负载 | (可迭代) 此列表包含作用在 Body 上的不同负载的信息。力以(点,向量)元组列出,扭矩以(参考框架,向量)元组列出。 |
ang_vel_in(body)
返回该身体相对于提供的刚体或参考框架的角速度。
参数:
body: Body 或 ReferenceFrame
计算角速度的刚体或参考框架。
示例
由于 Body 已被弃用,以下示例仅用于说明目的。Body 的功能完全由RigidBody
和Particle
捕获。要忽略弃用警告,我们可以使用 ignore_warnings 上下文管理器。
>>> 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
angular_momentum(point, frame)
返回在给定框架中关于某点的刚体的角动量。
参数:
点 : Point
欲求角动量的点。
框架 : ReferenceFrame
欲求角动量的框架。
解释
刚体 B 关于框架 N 中某点 O 的角动量 H 为:
H = dot(I, w) + cross(r, m * v)
其中 I 和 m 是刚体 B 的中心惯性二阶张量和质量,w 是刚体 B 在框架 N 中的角速度,r 是从点 O 到 B 质心的位置向量,v 是质心在框架 N 中的速度。
示例
>>> from sympy.physics.mechanics import Point, ReferenceFrame, outer
>>> from sympy.physics.mechanics import RigidBody, dynamicsymbols
>>> from sympy.physics.vector import init_vprinting
>>> init_vprinting(pretty_print=False)
>>> m, v, r, omega = dynamicsymbols('m v r omega')
>>> N = ReferenceFrame('N')
>>> b = ReferenceFrame('b')
>>> b.set_ang_vel(N, omega * b.x)
>>> P = Point('P')
>>> P.set_vel(N, 1 * N.x)
>>> I = outer(b.x, b.x)
>>> B = RigidBody('B', P, b, m, (I, P))
>>> B.angular_momentum(P, N)
omega*b.x
apply_force(force, point=None, reaction_body=None, reaction_point=None)
给身体(们)增加力。
参数:
力:向量
要应用的力。
点:Point,可选
施加力的自身点。默认为自身的质心。
反作用体:Body,可选
在第二个物体上应用相等且相反的力。
反应点:点,可选
在其他物体上应用相等且相反的力的点。默认为其他物体的质心。
解释
将力应用于自身或在所需点上的自身和另一物体上施加相等且相反的力。施加在另一物体上的力被取为自身的相反,即,-force。
示例
由于 Body 已被弃用,以下示例仅供说明目的。Body 的功能完全由RigidBody
和Particle
捕捉。要忽略弃用警告,我们可以使用 ignore_warnings 上下文管理器。
>>> 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)]
我们还可以通过在物体上的任意点上添加相反的力来移除物体的某部分力。
>>> 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)]
让我们从物体 B 上的点 P 上移除 f1。
>>> B.apply_force(-f1*B.x, P)
>>> B.loads
[(B_masscenter, g*m*B_frame.z), (P, f2(t)*B_frame.y)]
要进一步展示 apply_force
属性的使用,请考虑通过弹簧连接的两个物体。
>>> 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
现在让我们向物体施加等量且相反的弹簧力。
>>> P1 = Point('P1')
>>> P2 = Point('P2')
>>> B1.apply_force(spring_force, point=P1, reaction_body=B2, reaction_point=P2)
现在我们可以检查施加到物体上的载荷(力)。
>>> B1.loads
[(P1, x(t)*N_frame.x)]
>>> B2.loads
[(P2, - x(t)*N_frame.x)]
注释
如果在已经施加了一些力的点上向物体施加新力,则新力将添加到该点上已施加的力上。
apply_torque(torque, reaction_body=None)
向物体(们)添加扭矩。
参数:
扭矩:向量
要应用的扭矩。
反作用体:Body,可选
在第二个物体上应用相等且相反的扭矩。
解释
将扭矩应用于自身或在所需点上的自身和另一物体上施加相等且相反的扭矩。施加在另一物体上的扭矩被取为自身的相反,即,-torque。
示例
由于 Body 已被弃用,以下示例仅供说明目的。Body 的功能完全由RigidBody
和Particle
捕捉。要忽略弃用警告,我们可以使用 ignore_warnings 上下文管理器。
>>> 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)]
我们还可以通过向物体添加相反的扭矩来移除物体的某部分扭矩。
>>> 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)]
现在让我们从物体 B 上移除 t1。
>>> B.apply_torque(-t1*B.x)
>>> B.loads
[(B_frame, t2(t)*B_frame.y + t*B_frame.z)]
为了进一步展示使用,让我们考虑两个物体,其中一个物体施加了一个扭矩 (T),另一个物体施加了 (-T)。
>>> 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
现在让我们向物体施加等量且相反的扭矩。
>>> B1.apply_torque(T, B2)
现在我们可以检查施加到物体上的载荷(扭矩)。
>>> B1.loads
[(B1_frame, v(t)*N_frame.y)]
>>> B2.loads
[(B2_frame, - v(t)*N_frame.y)]
注释
如果在物体上已施加了一些扭矩,则新的扭矩将添加到围绕物体框架的先前扭矩中。
property central_inertia
体的中心惯性 dyadic。
clear_loads()
清除 Body 的负载列表。
示例
由于 Body 已经过时,以下示例仅用于说明目的。Body 的功能已完全由 RigidBody
和 Particle
完全涵盖。要忽略弃用警告,我们可以使用 ignore_warnings 上下文管理器。
>>> 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
[]
dcm(body)
返回相对于提供的刚体或参考系的该体的方向余弦矩阵。
参数:
body: Body 或 ReferenceFrame
要计算 dcm 的刚体或参考系。
示例
由于 Body 已经过时,以下示例仅用于说明目的。Body 的功能已完全由 RigidBody
和 Particle
完全涵盖。要忽略弃用警告,我们可以使用 ignore_warnings 上下文管理器。
>>> 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)]])
property frame
固定在该体上的参考系。
property inertia
关于点的体惯性;存储为 (Dyadic, Point)。
kinetic_energy(frame)
体的动能。
参数:
frame : ReferenceFrame 或 Body
Body 的角速度和其质心速度通常相对于惯性参考系定义,但可以提供任何相关的速度已知的参考系。
示例
由于 Body 已经过时,以下示例仅用于说明目的。Body 的功能已完全由 RigidBody
和 Particle
完全涵盖。要忽略弃用警告,我们可以使用 ignore_warnings 上下文管理器。
>>> 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
请参阅
sympy.physics.mechanics
粒子,刚体
linear_momentum(frame)
刚体的线动量。
参数:
frame : ReferenceFrame
期望线动量的参考系。
解释
刚体 B 相对于参考系 N 的线动量 L 由以下给出:
L = m * v
其中 m 是刚体的质量,v 是刚体 B 质心在参考系 N 中的速度。
示例
>>> from sympy.physics.mechanics import Point, ReferenceFrame, outer
>>> from sympy.physics.mechanics import RigidBody, dynamicsymbols
>>> from sympy.physics.vector import init_vprinting
>>> init_vprinting(pretty_print=False)
>>> m, v = dynamicsymbols('m v')
>>> N = ReferenceFrame('N')
>>> P = Point('P')
>>> P.set_vel(N, v * N.x)
>>> I = outer (N.x, N.x)
>>> Inertia_tuple = (I, P)
>>> B = RigidBody('B', P, N, m, Inertia_tuple)
>>> B.linear_momentum(N)
m*v*N.x
property mass
体的质量。
property masscenter
体的质心。
masscenter_vel(body)
返回相对于提供的刚体或参考系的质心速度。
参数:
body: Body 或 ReferenceFrame
要计算速度的刚体或参考系。
示例
由于 Body 已经被弃用,以下示例仅供说明目的。Body 的功能完全由 RigidBody
和 Particle
完全捕捉。要忽略弃用警告,我们可以使用 ignore_warnings 上下文管理器。
>>> 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
property name
身体的名称。
parallel_axis(point, frame=None)
返回身体相对于另一点的惯性二元张量。
参数:
点:sympy.physics.vector.Point
表达惯性二元张量的点。
框架:sympy.physics.vector.ReferenceFrame
用于构建二元张量的参考框架。
返回:
惯性:sympy.physics.vector.Dyadic
刚体关于给定点的惯性二元张量。
示例
由于 Body 已经被弃用,以下示例仅供说明目的。Body 的功能完全由 RigidBody
和 Particle
完全捕捉。要忽略弃用警告,我们可以使用 ignore_warnings 上下文管理器。
>>> 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]])
property point
身体的质心。
property potential_energy
身体的势能。
示例
>>> 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
remove_load(about=None)
移除关于点或框架的负载。
参数:
关于:点或参考框架,可选
施加力的点,将要移除。如果 about 为 None,则移除关于自身框架的力矩。
示例
由于 Body 已经被弃用,以下示例仅供说明目的。Body 的功能完全由 RigidBody
和 Particle
完全捕捉。要忽略弃用警告,我们可以使用 ignore_warnings 上下文管理器。
>>> 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)]
property x
身体的基础向量,沿着 x 方向。
property y
身体的基础向量,沿着 y 方向。
property z
身体的基础向量,沿着 z 方向。
class sympy.physics.mechanics.jointsmethod.JointsMethod(newtonion, *joints)
使用一组连接的身体进行运动方程的制定方法。
自版本 1.13 弃用:JointsMethod 类已弃用。其功能已由新的 System
类替代。
参数:
牛顿式:身体或参考框架
牛顿式(惯性)框架。
*连接:Joint
系统中的连接点
示例
鉴于 Body 和 JointsMethod 已被弃用,以下示例仅供说明目的。Body 的功能完全由RigidBody
和 Particle
完全捕获,而 JointsMethod 的功能则完全捕获于System
。要忽略弃用警告,我们可以使用 ignore_warnings 上下文管理器。
>>> from sympy.utilities.exceptions import ignore_warnings
这是一个简单的一自由度弹簧-质量-阻尼系统的例子。
>>> 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]])
注意事项
JointsMethod
目前仅适用于没有任何配置或运动约束的系统。
属性
q, u | (可迭代) 广义坐标和速度的可迭代对象。 |
---|---|
bodies | (可迭代) 系统中的 Body 对象的可迭代对象。 |
loads | (可迭代) 描述系统上力的 (Point, vector) 或 (ReferenceFrame, vector) 元组的可迭代对象。 |
mass_matrix | (矩阵, shape(n, n)) 系统的质量矩阵。 |
forcing | (矩阵, shape(n, 1)) 系统的强迫矢量。 |
mass_matrix_full | (矩阵, shape(2n, 2n)) u 和 q 的“质量矩阵”。 |
forcing_full | (矩阵, shape(2*n, 1)) u 和 q 的“强迫矢量”。 |
method | (KanesMethod or Lagrange’s method) 方法的对象。 |
kdes | (可迭代) 系统中 kde 的可迭代对象。 |
property bodies
系统中的物体列表。
property forcing
系统的强迫矢量。
property forcing_full
u 和 q 的“强迫矢量”。
form_eoms(method=<class 'sympy.physics.mechanics.kane.KanesMethod'>)
形成系统运动方程的方法。
参数:
method : 类
方法的类名。
返回:
矩阵
运动方程的矢量。
示例
鉴于 Body 和 JointsMethod 已被弃用,以下示例仅供说明目的。Body 的功能完全由RigidBody
和 Particle
完全捕获,而 JointsMethod 的功能则完全捕获于System
。要忽略弃用警告,我们可以使用 ignore_warnings 上下文管理器。
>>> from sympy.utilities.exceptions import ignore_warnings
这是一个简单的一自由度弹簧-质量-阻尼系统的例子。
>>> 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))]])
我们还可以使用‘rhs’方法来求解状态。
>>> method.rhs()
Matrix([
[ Derivative(q(t), t)],
[(-b*Derivative(q(t), t) - k*q(t))/m]])
property kdes
广义坐标列表。
property loads
系统上的负载列表。
property mass_matrix
系统的质量矩阵。
property mass_matrix_full
u 和 q 的“质量矩阵”。
property method
用于形成系统方程的方法对象。
property q
广义坐标列表。
rhs(inv_method=None)
返回可以数值求解的方程组。
参数:
inv_method : 字符串
使用特定的 sympy 逆矩阵计算方法。有关有效方法的列表,请参阅
inv()
返回:
矩阵
可数值求解的方程。
参见
sympy.physics.mechanics.kane.KanesMethod.rhs
KanesMethod 的 rhs 函数。
sympy.physics.mechanics.lagrange.LagrangesMethod.rhs
LagrangesMethod 的 rhs 函数。
property u
广义速度的列表。