系统 (文档字符串)¶

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时间的函数的有序可迭代对象: 此输入将根据是否给出速度来决定是系统的坐标集合还是状态。如果指定了速度，则此输入将被视为坐标；否则，此输入将被视为状态。
右侧矩阵: 此变量是运动方程右侧的任何形式。具体形式将根据是否给出质量矩阵或坐标导数来假设。
速度时间的函数的有序可迭代对象，可选: 这是系统广义速度的集合。如果给出，将假设第一个参数（coord_states）将表示系统的广义坐标。
质量矩阵矩阵，可选: 运动方程隐式形式的矩阵（形式 [2] 和 [3]）。形式的区分取决于是否传递了坐标导数。如果给出了坐标导数，则假设为形式 [3]，否则假设为形式 [2]。
坐标导数矩阵，可选: 运动学方程的显式形式中的右侧。如果给出，将假定运动方程以形式[3]输入。
alg_con可迭代对象，可选: 运动方程中包含代数约束而非微分方程的行索引。如果方程以形式[3]输入，将假定索引引用的是质量矩阵/右手边组合，而不是坐标导数。
output_eqns字典，可选: 任何希望被跟踪的输出方程都存储在一个字典中，其中键对应于为特定方程指定的名称，而值是方程本身的符号形式。
coord_idxs可迭代对象，可选: 如果 coord_states 对应于状态而不是坐标，此变量将告诉 SymbolicSystem 状态的哪些索引对应于广义坐标。
速度索引可迭代对象，可选: 如果 coord_states 对应于状态而不是坐标，此变量将告诉 SymbolicSystem 状态的哪些索引对应于广义速度。
bodiesBody/Rigidbody 对象的可迭代对象，可选: 包含系统主体的可迭代对象
加载加载实例的可迭代对象（如下所述），可选: 包含系统负载的可迭代对象，其中力由（作用点，力矢量）给出，扭矩由（作用参考系，扭矩矢量）给出。例如 [(点, 力), (参考系, 扭矩)]

属性:

coordinates矩阵，形状(n, 1): 返回广义坐标的列矩阵
speeds矩阵，形状(m, 1): 返回广义速度的列矩阵
states矩阵，形状(o, 1): 返回状态变量的列矩阵
alg_con列表: 返回一个包含代数行索引的列表
dyn_implicit_mat矩阵，形状(m, m): 返回与动态方程对应的矩阵 M。
dyn_implicit_rhs矩阵，形状(m, 1): 返回与动态方程对应的列矩阵 F。
comb_implicit_mat矩阵，形状(o, o): 返回与运动方程对应的矩阵 M。
comb_implicit_rhs矩阵，形状(o, 1): 返回对应于方程的列矩阵 F。
comb_explicit_rhs矩阵，形状(o, 1): 返回运动方程的右侧显式部分
kin_explicit_rhs矩阵，形状(m, 1): 返回运动学方程的右手边，以显式形式。
output_eqns字典: 如果给出了输出方程，它们将存储在一个字典中，其中键对应于为特定方程指定的名称，值是方程本身的符号形式。
bodies元组: 返回系统中的主体
loads元组: 返回系统中的负载

方法

`compute_explicit_form`()	如果在初始化时提供了运动方程的显式右侧，此方法将计算它。
`constant_symbols`()	返回一个包含系统中所有不依赖于时间的符号的列矩阵
`dynamic_symbols`()	返回一个包含系统中所有依赖于时间的符号的列矩阵

注释

m : 广义速度的数量 n : 广义坐标的数量 o : 状态的数量

property alg_con¶: 返回一个包含运动方程组合形式中代数约束行索引的列表

property bodies¶: 返回系统中的主体

property comb_explicit_rhs¶: 返回运动方程的右手边，以显式形式 x’ = F，其中包含运动学方程。

property comb_implicit_mat¶: 返回矩阵 M，对应于隐式形式（形式 [2]）的运动方程，M x’ = F，其中包含运动学方程。

property comb_implicit_rhs¶: 返回隐式形式（形式[2]）的运动方程对应的列矩阵 F，即 M x’ = F，其中包含运动学方程。

compute_explicit_form()[源代码][源代码]¶: 如果在初始化时提供了运动方程的显式右侧，此方法将计算它。这个计算可能需要一段时间来完成。

constant_symbols()[源代码][源代码]¶: 返回一个包含系统中所有不依赖于时间的符号的列矩阵

property coordinates¶: 返回广义坐标的列矩阵

property dyn_implicit_mat¶: 返回矩阵 M，对应于隐式形式的动态方程 M x’ = F，其中不包括运动学方程。

property dyn_implicit_rhs¶: 返回对应于隐式动态方程的列矩阵 F，即 M x’ = F，其中不包括运动学方程。

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)[源代码][源代码]¶

用于定义多体系统并形成其运动方程的类。

属性:

frame参考框架: 系统的惯性参考系。
fixed_point点: 惯性参考系中的固定点。
x向量: 固定在惯性参考系中的单位向量。
y向量: 固定在惯性参考系中的单位向量。
z向量: 固定在惯性参考系中的单位向量。
qImmutableMatrix: 所有广义坐标的矩阵，其中独立坐标堆叠在从属坐标之上。
uImmutableMatrix: 所有广义速度的矩阵，其中独立的速度叠加在依赖的速度之上。
q_indImmutableMatrix: 独立广义坐标的矩阵。
q_depImmutableMatrix: 依赖广义坐标的矩阵。
u_indImmutableMatrix: 独立广义速度的矩阵。
u_depImmutableMatrix: 依赖广义速度的矩阵。
u_auxImmutableMatrix: 辅助广义速度矩阵。
kdesImmutableMatrix: 运动学微分方程作为等于零矩阵的表达式。
bodiesBodyBase 子类的元组: 已添加到系统中的所有主体的元组。
jointsJoint 的元组: 系统中所有已添加的关节的元组。
loadsLoadBase 子类的元组: 已施加在系统上的载荷元组。
actuatorsActuatorBase 子类的元组: 系统中存在的执行器元组。
holonomic_constraintsImmutableMatrix: 带有将完整约束表示为等于零矩阵的表达式的矩阵。
nonholonomic_constraintsImmutableMatrix: 带有非完整约束的矩阵，这些约束作为表达式等于零矩阵。
velocity_constraintsImmutableMatrix: 以速度约束为表达式等于零矩阵的矩阵。
eom_methodKanesMethod 或 LagrangesMethod 的子类: 形成运动方程的后端。

方法

`add_actuators`(*actuators)	向系统中添加执行器。
`add_auxiliary_speeds`(*speeds)	向系统添加辅助速度。
`add_bodies`(*bodies)	向系统中添加主体。
`add_coordinates`(*coordinates[, independent])	向系统添加广义坐标。
`add_holonomic_constraints`(*constraints)	向系统添加完整约束。
`add_joints`(*joints)	向系统中添加关节。
`add_kdes`(*kdes)	向系统添加运动学微分方程。
`add_loads`(*loads)	向系统添加负载。
`add_nonholonomic_constraints`(*constraints)	向系统添加非完整约束。
`add_speeds`(*speeds[, independent])	向系统添加广义速度。
`apply_uniform_gravity`(acceleration)	通过添加载荷，对系统中的所有物体施加均匀的重力。
`form_eoms`([eom_method])	推导系统的运动方程。
`from_newtonian`(newtonian)	根据牛顿物体构建系统。
`get_body`(name)	通过名称从系统中检索一个主体。
`get_joint`(name)	通过名称从系统中检索关节。
`rhs`([inv_method])	以显式形式计算运动方程。
`validate_system`([eom_method, check_duplicates])	使用一些基本检查验证系统。

示例

在下面的例子中，创建了一个带有摆的推车。推车沿着轨道的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)]])

property actuators¶: 系统中存在的执行器元组。

add_actuators(*actuators)[源代码][源代码]¶

向系统中添加执行器。

参数:

*执行器ActuatorBase 的子类: 一个或多个执行器。

add_auxiliary_speeds(*speeds)[源代码][源代码]¶

向系统添加辅助速度。

参数:

*速度dynamicsymbols: 一个或多个辅助速度将被添加到系统中。

add_bodies(*bodies)[源代码][源代码]¶

向系统中添加主体。

参数:

bodies粒子或刚体: 一个或多个主体。

add_coordinates( *coordinates, independent=True, )[源代码][源代码]¶

向系统添加广义坐标。

参数:

*坐标dynamicsymbols: 要添加到系统中的一个或多个广义坐标。
独立布尔值或布尔值列表，可选: 布尔值，表示一个坐标是依赖的还是独立的。默认值为 True，因此默认情况下坐标被添加为独立的。

add_holonomic_constraints(*constraints)[源代码][源代码]¶

向系统添加完整约束。

参数:

*约束条件表达式: 一个或多个完整约束，这些是应该为零的表达式。

add_joints(*joints)[源代码][源代码]¶

向系统中添加关节。

参数:

*关节Joint 的子类: 一个或多个关节。

注释

对于广义坐标、广义速度和刚体，系统实例会检查它们是否已经存在。如果存在，则不会添加它们。然而，运动学微分方程总是会被添加到系统中，因此您不应该在之前手动添加这些方程。

add_kdes(*kdes)[源代码][源代码]¶

向系统添加运动学微分方程。

参数:

*kdes表达式: 一个或多个运动学微分方程。

add_loads(*loads)[源代码][源代码]¶

向系统添加负载。

参数:

*加载力或扭矩: 一个或多个负载。

add_nonholonomic_constraints(*constraints)[源代码][源代码]¶

向系统添加非完整约束。

参数:

*约束条件表达式: 一个或多个非完整约束，这些是应该为零的表达式。

add_speeds(*speeds, independent=True)[源代码][源代码]¶

向系统添加广义速度。

参数:

*速度dynamicsymbols: 要添加到系统中的一个或多个广义速度。
独立布尔值或布尔值列表，可选: 布尔值，表示速度是依赖的还是独立的。默认值为 True，因此默认情况下速度被添加为独立的。

apply_uniform_gravity(acceleration)[源代码][源代码]¶

通过添加载荷，对系统中的所有物体施加均匀的重力。

参数:

加速度向量: 由于重力引起的加速度。

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_methodKanesMethod 或 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)[源代码][源代码]¶

通过名称从系统中检索一个主体。

参数:

名称str: 要检索的主体名称。

返回:

刚体或粒子: 具有给定名称的主体，如果不存在这样的主体，则为 None。

get_joint(name)[源代码][源代码]¶

通过名称从系统中检索关节。

参数:

名称str: 要检索的关节名称。

返回:

Joint 的子类: 具有给定名称的关节，如果不存在这样的关节，则为 None。

property holonomic_constraints¶: 带有将完整约束表示为等于零矩阵的表达式的矩阵。

property joints¶: 系统中所有已添加的关节的元组。

property kdes¶: 运动学微分方程作为等于零矩阵的表达式。这些方程描述了广义坐标和广义速度之间的耦合关系。

property loads¶: 已施加在系统上的载荷元组。

property mass_matrix¶: 系统的质量矩阵。

property mass_matrix_full¶: 系统的质量矩阵，通过显式或隐式形式的运动学微分方程进行增广。

property nonholonomic_constraints¶: 带有非完整约束的矩阵，这些约束作为表达式等于零矩阵。

property q¶: 所有广义坐标的矩阵，其中独立坐标堆叠在从属坐标之上。

property q_dep¶: 依赖广义坐标的矩阵。

property q_ind¶: 独立广义坐标的矩阵。

rhs(inv_method=None)[源代码][源代码]¶

以显式形式计算运动方程。

参数:

inv_methodstr: 要使用的特定 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_methodKanesMethod 或 LagrangesMethod 的子类: 用于形成运动方程的 \(Backend\) 类。不同的后端有不同的检查。默认是 KanesMethod。
检查重复项布尔: 布尔值，指示是否应检查系统中是否存在重复定义。默认值为 False，因为在将对象添加到系统时已经检查了重复项。

注释

此方法不保证向后兼容，因为它可能会随着时间的推移而改进。该方法在某些方面可能会变得更加严格或宽松。然而，一个定义良好的系统应该始终通过所有这些测试。

property velocity_constraints¶: 以速度约束为表达式等于零矩阵的矩阵。速度约束默认从完整约束和非完整约束中推导，除非它们被显式设置。

property x¶: 固定在惯性参考系中的单位向量。

property y¶: 固定在惯性参考系中的单位向量。

property z¶: 固定在惯性参考系中的单位向量。