SymPy 1.13 中文文档（三十六）

原文：docs.sympy.org/latest/index.html

包装几何体（文档字符串）

原文链接：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

广义速度的列表。

生物力学

原文：docs.sympy.org/latest/modules/physics/biomechanics/index.html

Introduction

生物力学模型通常涉及同时建模多个解剖学方面。这些可以是骨骼、肌肉和神经系统。骨骼系统通常使用多体动力学进行建模。这可以通过sympy.physics.mechanics来实现。sympy.physics.biomechanics 提供了用于建模肌腱（肌肉系统）和激活动力学（神经系统）的功能。

力学

本模块作为sympy.physics.mechanics的扩展模块。不建议单独使用本模块。相反，用户应该同时导入sympy.physics.mechanics和sympy.physics.biomechanics，并可互换地使用两者的对象。sympy.physics.biomechanics 的类层次结构与sympy.physics.mechanics相关联，其接口（例如属性名称、调用签名和返回类型）模仿了后者。因此，sympy.physics.mechanics将正确为包含生物力学组件的多体系统生成运动方程。

生物力学指南

• 生物力学 API 参考

  • 肌腱（文档字符串）

  • 激活（文档字符串）

  • 曲线（文档字符串）

生物力学 API 参考

原文：docs.sympy.org/latest/modules/physics/biomechanics/api/index.html

• 肌腱（文档字符串）

• 激活函数（文档字符串）

• 曲线（文档字符串）

肌腱（文档字符串）

原文链接：docs.sympy.org/latest/modules/physics/biomechanics/api/musculotendon.html

肌腱模型的实现。

肌腱模型是生物力学模型的关键组成部分，它使其与纯多体系统有所区别。肌腱模型产生的力量取决于它们的激活水平、长度和伸展速度。长度和伸展速度相关的力量产生由力长特性和力速特性控制。这些是归一化函数，取决于肌腱的状态，并且特定于给定的肌腱模型。

class sympy.physics.biomechanics.musculotendon.MusculotendonBase(name, pathway, activation_dynamics, *, musculotendon_dynamics=MusculotendonFormulation.RIGID_TENDON, tendon_slack_length=None, peak_isometric_force=None, optimal_fiber_length=None, maximal_fiber_velocity=None, optimal_pennation_angle=None, fiber_damping_coefficient=None, with_defaults=False)

所有肌腱类继承的抽象基类。

参数：

name : str

与肌腱相关的名称标识符。这个名称在自动生成符号时用作后缀。它必须是非零长度的字符串。

pathway : PathwayBase

执行器所遵循的路径。这必须是PathwayBase的具体子类的实例，例如LinearPathway。

activation_dynamics : ActivationBase

将在肌腱内模拟的激活动力学。这必须是ActivationBase的具体子类的实例，例如FirstOrderActivationDeGroote2016。

musculotendon_dynamics : MusculotendonFormulation | int

应在内部使用的肌腱动力学制式，即刚性或弹性肌腱模型的选择，肌腱状态的选择等。这必须是整数枚举MusculotendonFormulation的成员或可以转换为成员的整数。要使用刚性肌腱制式，请将其设置为MusculotendonFormulation.RIGID_TENDON（或整数值0，将被转换为枚举成员）。有四种弹性肌腱模型制式。要使用以纤维长度为状态的显式制式，请将其设置为MusculotendonFormulation.FIBER_LENGTH_EXPLICIT（或整数值1）。要使用以肌腱力为状态的显式制式，请将其设置为MusculotendonFormulation.TENDON_FORCE_EXPLICIT（或整数值2）。要使用以纤维长度为状态的隐式制式，请将其设置为MusculotendonFormulation.FIBER_LENGTH_IMPLICIT（或整数值3）。要使用以肌腱力为状态的隐式制式，请将其设置为MusculotendonFormulation.TENDON_FORCE_IMPLICIT（或整数值4）。默认值为MusculotendonFormulation.RIGID_TENDON，对应于刚性肌腱制式。

tendon_slack_length : Expr | None

当肌腱处于无负荷状态时的肌腱长度。在刚性肌腱模型中，肌腱长度即为肌腱松弛长度。在所有肌腱模型中，肌腱松弛长度用于归一化肌腱长度以得到 (\tilde{l}^T = \frac{l^T}{l^T_{slack}})。

peak_isometric_force : Expr | None

当肌肉纤维进行等长收缩（无长度变化速度）时，肌肉纤维能够产生的最大力量。在所有肌腱模型中，峰值等长力用于将肌腱和肌肉纤维力归一化，得到 (\tilde{F}^T = \frac{F^T}{F^M_{max}})。

optimal_fiber_length : Expr | None

在所有肌腱模型中，最佳纤维长度用于将肌肉纤维长度归一化，得到 (\tilde{l}^M = \frac{l^M}{l^M_{opt}})。

maximal_fiber_velocity : Expr | None

在肌肉纤维缩短过程中，当肌肉纤维无法产生任何主动力时的纤维速度。在所有肌腱模型中，最大纤维速度用于将肌肉纤维伸展速度归一化，得到 (\tilde{v}^M = \frac{v^M}{v^M_{max}})。

optimal_pennation_angle : Expr | None

当肌肉纤维长度等于最佳纤维长度时的夹角。

fiber_damping_coefficient : Expr | None

在肌肉纤维模型中使用的阻尼元件中要使用的阻尼系数。

with_defaults : bool

是否在自动构造子类时使用with_defaults替代构造函数。默认值为False。

说明

肌腱根据其激活、长度和缩短速度生成收缩力。这个抽象基类应该被所有肌腱子类继承，这些子类实现不同的特征肌腱曲线。特征肌腱曲线需要关于肌腱力长、被动纤维力长、主动纤维力长和纤维力速度关系的实现。

property F

M x' = F右手边的有序列方程组。

说明

形成控制激活动力学线性系统右手边的列矩阵：

M(x, r, t, p) x' = F(x, r, t, p)。

零阶激活动力学没有状态变量，因此这个线性系统的维度为 0，因此F是一个空的列Matrix，形状为(0, 1)。

property F_M_max

符号或对应于峰值等长力常数的值。

说明

当肌肉纤维进行等长收缩（无长度变化速度）时，肌肉纤维能够产生的最大力量。在所有肌腱模型中，峰值等长力用于将肌腱和肌肉纤维力归一化，得到 (\tilde{F}^T = \frac{F^T}{F^M_{max}})。

别名peak_isometric_force也可以用于访问相同的属性。

property M

M x' = F左手边的有序方阵系数。

说明

形成控制激活动力学线性系统左手边的方阵的一部分：

M(x, r, t, p) x' = F(x, r, t, p).

零阶激活动力学没有状态变量，因此这个线性系统的维度为 0，因此M是一个空的方阵Matrix，形状为(0, 0)。

property a

表示激活的动态符号。

解释

别名activation也可以用来访问相同的属性。

property activation

表示激活的动态符号。

解释

别名a也可以用来访问相同的属性。

property activation_dynamics

控制肌腱激活的激活动力学模型。

解释

返回一个子类实例，该子类继承自ActivationBase，用于描述肌腱激活动力学的激活与激发关系。

property alpha_opt

对应于最佳肌肉腱角度常数的符号或值。

解释

当肌纤维长度等于最佳纤维长度时的肌肉腱角度。

别名optimal_pennation_angle也可以用来访问相同的属性。

property beta

对应于纤维阻尼系数常数的符号或值。

解释

在肌纤维模型的阻尼元件中使用的阻尼系数。

别名fiber_damping_coefficient也可以用来访问相同的属性。

property constants

在M和F中存在的非时变符号的有序列矩阵。

解释

仅返回符号常量。如果在代码生成过程中使用了数值类型（例如Float）而不是Symbol作为常数，则该属性不会包含在此属性的矩阵中。这是因为此属性的主要用途是提供一个有序序列，其中包含在代码生成期间需要数值值的仍然自由的符号。

别名p也可以用来访问相同的属性。

abstract curves()

返回一个与特定模型相关的CharacteristicCurveCollection曲线集合。

property e

表示兴奋的动态符号。

解释

别名excitation也可以用来访问相同的属性。

property excitation

表示兴奋的动态符号。

解释

别名e也可以用来访问相同的属性。

property fiber_damping_coefficient

对应于纤维阻尼系数常数的符号或值。

解释

在肌纤维模型的阻尼元件中使用的阻尼系数。

别名beta也可以用来访问相同的属性。

property input_vars

表示输入变量的时间函数的有序列矩阵。

解释

别名r也可以用来访问相同的属性。

property l_M_opt

对应于最佳纤维长度常数的符号或值。

解释

当肌纤维长度等于最佳纤维长度时，肌纤维不产生被动力，并产生其最大主动力的肌纤维长度。在所有肌腱模型中，最佳纤维长度用于将肌纤维长度归一化，以得到 (\tilde{l}^M = \frac{l^M}{l^M_{opt}})。

别名optimal_fiber_length也可以用来访问相同的属性。

property l_T_slack

对应于肌腱松弛长度常数的符号或值。

解释

当肌腱肌腱处于无载荷状态时的肌腱长度。在刚性肌腱模型中，肌腱长度为肌腱松弛长度。在所有肌腱模型中，肌腱松弛长度用于归一化肌腱长度，得到(\tilde{l}^T = \frac{l^T}{l^T_{slack}})。

别名tendon_slack_length也可以用于访问相同的属性。

property maximal_fiber_velocity

对应于最大肌纤维速度常数的符号或值。

说明

在肌肉纤维缩短期间，肌纤维无法产生任何主动力时的纤维速度。在所有肌腱模型中，最大纤维速度用于将肌纤维伸展速度归一化，得到(\tilde{v}^M = \frac{v^M}{v^M_{max}})。

别名v_M_max也可以用于访问相同的属性。

property musculotendon_dynamics

选择刚性或弹性肌腱肌腱动力学类型。

说明

应在内部使用的肌腱肌腱动力学公式，即刚性或弹性肌腱模型的选择，肌腱肌腱状态等。这必须是整数枚举MusculotendonFormulation的成员或可以转换为成员的整数。要使用刚性肌腱公式，请将其设置为MusculotendonFormulation.RIGID_TENDON（或整数值0，将被转换为枚举成员）。弹性肌腱模型有四种可能的公式。要使用以肌纤维长度为状态的显式公式，请将其设置为MusculotendonFormulation.FIBER_LENGTH_EXPLICIT（或整数值1）。要使用以肌腱力为状态的显式公式，请将其设置为MusculotendonFormulation.TENDON_FORCE_EXPLICIT（或整数值2）。要使用以肌纤维长度为状态的隐式公式，请将其设置为MusculotendonFormulation.FIBER_LENGTH_IMPLICIT（或整数值3）。要使用以肌腱力为状态的隐式公式，请将其设置为MusculotendonFormulation.TENDON_FORCE_IMPLICIT（或整数值4）。默认为MusculotendonFormulation.RIGID_TENDON，对应刚性肌腱公式。

property optimal_fiber_length

对应于最优肌纤维长度常数的符号或值。

说明

当肌纤维不产生被动力和其最大主动力时的肌纤维长度。在所有肌腱模型中，最优肌纤维长度用于归一化肌纤维长度，得到(\tilde{l}^M = \frac{l^M}{l^M_{opt}})。

别名l_M_opt也可以用于访问相同的属性。

property optimal_pennation_angle

对应于最优羽毛角常数的符号或值。

说明

当肌纤维长度等于最优肌纤维长度时的羽毛角度。

别名alpha_opt也可以用于访问相同的属性。

property p

M和F中存在的非时变符号的有序列矩阵。

说明

仅返回符号常量。如果数字类型（例如 Float）用于常量而不是 Symbol，则该属性不会包含在此属性返回的矩阵中。这是因为此属性的主要用途是在代码生成期间提供仍需数值值的有序符号序列。

别名 constants 也可用于访问同一属性。

property peak_isometric_force

对应于峰值等长收缩力常数的符号或值。

解释

当肌纤维进行等长收缩（无长度变化速度）时，肌纤维可以产生的最大力量。在所有肌腱模型中，峰值等长收缩力用于将肌腱和肌纤维力量归一化，以给出 (\tilde{F}^T = \frac{F^T}{F^M_{max}})。

别名 F_M_max 也可用于访问同一属性。

property r

表示输入变量的时间函数的有序列方程列矩阵。

解释

别名 input_vars 也可用于访问同一属性。

rhs()

用于解决 M x' = F 的有序列方程列矩阵。

解释

解决支配激活动态的常微分方程线性系统的解决方案：

M(x, r, t, p) x' = F(x, r, t, p)。

由于零阶激活动态没有状态变量，因此该线性具有维度 0，因此该方法返回形状为 (0, 1) 的空列 Matrix。

property state_vars

表示状态变量的时间函数的有序列方程列矩阵。

解释

别名 x 也可用于访问同一属性。

property tendon_slack_length

对应于肌腱松弛长度常数的符号或值。

解释

当肌腱处于无载荷状态时的长度。在刚性肌腱模型中，肌腱长度是肌腱松弛长度。在所有肌腱模型中，肌腱松弛长度用于将肌腱长度归一化，以给出 (\tilde{l}^T = \frac{l^T}{l^T_{slack}})。

别名 l_T_slack 也可用于访问同一属性。

property v_M_max

对应于最大肌纤维速度常数的符号或值。

解释

在肌纤维缩短期间，肌纤维无法产生任何主动力的纤维速度。在所有肌腱模型中，最大肌纤维速度用于将肌纤维伸长速度归一化，以给出 (\tilde{v}^M = \frac{v^M}{v^M_{max}})。

别名 maximal_fiber_velocity 也可用于访问同一属性。

classmethod with_defaults(name, pathway, activation_dynamics, *, musculotendon_dynamics=MusculotendonFormulation.RIGID_TENDON, tendon_slack_length=None, peak_isometric_force=None, optimal_fiber_length=None, maximal_fiber_velocity=10.0000000000000, optimal_pennation_angle=0.0, fiber_damping_coefficient=0.100000000000000)

推荐的构造函数将使用已发布的常数。

参数：

name：str

与肌腱相关联的名称标识符。在自动生成符号实例化时，此名称用作后缀。必须是非零长度的字符串。

pathway：PathwayBase

执行器遵循的路径。这必须是 PathwayBase 的具体子类实例，例如 LinearPathway。

activation_dynamics：ActivationBase

将在肌肉肌腱内模拟的激活动力学。这必须是 ActivationBase 的具体子类实例，例如 FirstOrderActivationDeGroote2016。

musculotendon_dynamics : 肌肉肌腱建模 | 整数

应在内部使用的肌肉肌腱动力学配方，即刚性或弹性肌腱模型，肌肉肌腱状态的选择等。这必须是整数枚举 MusculotendonFormulation 的成员或可转换为成员的整数。要使用刚性肌腱配方，请设置为 MusculotendonFormulation.RIGID_TENDON（或整数值 0，将被转换为枚举成员）。弹性肌腱模型有四种可能的配方。要使用纤维长度作为状态的显式配方，请设置为 MusculotendonFormulation.FIBER_LENGTH_EXPLICIT（或整数值 1）。要使用肌腱力作为状态的显式配方，请设置为 MusculotendonFormulation.TENDON_FORCE_EXPLICIT（或整数值 2）。要使用纤维长度作为状态的隐式配方，请设置为 MusculotendonFormulation.FIBER_LENGTH_IMPLICIT（或整数值 3）。要使用肌腱力作为状态的隐式配方，请设置为 MusculotendonFormulation.TENDON_FORCE_IMPLICIT（或整数值 4）。默认为 MusculotendonFormulation.RIGID_TENDON，对应于刚性肌腱配方。

tendon_slack_length : 表达式 | 无

肌肉肌腱在无载荷状态时的肌腱长度。在刚性肌腱模型中，肌腱长度为松弛肌腱长度。在所有肌肉肌腱模型中，松弛肌腱长度用于归一化肌腱长度，得到 (\tilde{l}^T = \frac{l^T}{l^T_{slack}})。

peak_isometric_force : 表达式 | 无

当肌肉纤维正在进行等长收缩时可以产生的最大力量。在所有肌肉肌腱模型中，峰值等长收缩力用于归一化肌腱和肌肉纤维力，得到 (\tilde{F}^T = \frac{F^T}{F^M_{max}})。

optimal_fiber_length : 表达式 | 无

当肌肉纤维不产生 passice 力并达到其最大主动力时的肌肉纤维长度。在所有肌肉肌腱模型中，最佳纤维长度用于归一化肌肉纤维长度，得到 (\tilde{l}^M = \frac{l^M}{l^M_{opt}})。

maximal_fiber_velocity : 表达式 | 无

在肌肉纤维缩短过程中，肌肉纤维无法产生任何主动力的纤维速度。在所有肌腱模型中，最大纤维速度用于归一化肌肉纤维伸展速度，得到 (\tilde{v}^M = \frac{v^M}{v^M_{max}})。

optimal_pennation_angle : 表达式 | 无

当肌肉纤维长度等于最佳纤维长度时的肌肉纤维的羽毛角度。

fiber_damping_coefficient : 表达式 | 无

在肌肉纤维模型中用于阻尼元件的阻尼系数。

说明

返回肌肉肌腱类的新实例，使用推荐的v_M_max、alpha_opt和beta值。这些值为：

(v^M_{max} = 10) (\alpha_{opt} = 0) (\beta = \frac{1}{10})

肌肉肌腱曲线也是使用原始出版物中的常数实例化的。

property x

时间函数的有序列矩阵，表示状态变量。

解释

别名state_vars也可用于访问相同的属性。

class sympy.physics.biomechanics.musculotendon.MusculotendonDeGroote2016(name, pathway, activation_dynamics, *, musculotendon_dynamics=MusculotendonFormulation.RIGID_TENDON, tendon_slack_length=None, peak_isometric_force=None, optimal_fiber_length=None, maximal_fiber_velocity=None, optimal_pennation_angle=None, fiber_damping_coefficient=None, with_defaults=False)

使用 De Groote 等人 2016 年的曲线实例化的肌肉肌腱模型[R728]。

参数：

name：str

与肌肉肌腱相关联的名称标识符。此名称在自动生成符号实例化时用作后缀。它必须是长度非零的字符串。

pathway：PathwayBase

执行器遵循的路径。这必须是PathwayBase的具体子类的实例，例如LinearPathway。

activation_dynamics：ActivationBase

肌肉肌腱内将被建模的激活动力学。这必须是ActivationBase的一个具体子类的实例，例如FirstOrderActivationDeGroote2016。

musculotendon_dynamics：肌肉肌腱形态学 | int

应在内部使用的肌肉肌腱动力学形式，即刚性或弹性肌腱模型，肌肉肌腱状态的选择等。这必须是整数枚举MusculotendonFormulation的成员或可转换为成员的整数。要使用刚性肌腱形式，请将其设置为MusculotendonFormulation.RIGID_TENDON（或整数值0，将被转换为枚举成员）。弹性肌腱模型有四种可能的形式。要使用显式以纤维长度为状态的形式，请将其设置为MusculotendonFormulation.FIBER_LENGTH_EXPLICIT（或整数值1）。要使用显式以肌腱力为状态的形式，请将其设置为MusculotendonFormulation.TENDON_FORCE_EXPLICIT（或整数值2）。要使用隐式以纤维长度为状态的形式，请将其设置为MusculotendonFormulation.FIBER_LENGTH_IMPLICIT（或整数值3）。要使用隐式以肌腱力为状态的形式，请将其设置为MusculotendonFormulation.TENDON_FORCE_IMPLICIT（或整数值4）。默认为MusculotendonFormulation.RIGID_TENDON，对应于刚性肌腱形式。

tendon_slack_length：Expr | None

当肌肉肌腱处于无负荷状态时的肌腱长度。在刚性肌腱模型中，肌腱长度即为肌腱松弛长度。在所有肌肉肌腱模型中，肌腱松弛长度用于标准化肌腱长度，以给出 (\tilde{l}^T = \frac{l^T}{l^T_{slack}})。

peak_isometric_force：Expr | None

当肌纤维进行等长收缩（无延长速度）时，肌纤维可以产生的最大力量。在所有肌腱模型中，峰值等长力用于将腱和肌纤维力归一化，以给出(\tilde{F}^T = \frac{F^T}{F^M_{max}})。

optimal_fiber_length : Expr | None

当肌纤维产生无被动力并且其最大主动力时的肌纤维长度。在所有肌腱模型中，最佳纤维长度用于将肌纤维长度标准化，以给出(\tilde{l}^M = \frac{l^M}{l^M_{opt}})。

maximal_fiber_velocity : Expr | None

在肌纤维缩短过程中，肌纤维无法产生任何主动力的纤维速度。在所有肌腱模型中，最大纤维速度用于将肌纤维伸展速度归一化，以给出(\tilde{v}^M = \frac{v^M}{v^M_{max}})。

optimal_pennation_angle : Expr | None

当肌纤维长度等于最佳纤维长度时的腱角度。

fiber_damping_coefficient : Expr | None

在肌纤维模型中使用的阻尼系数。

with_defaults : bool

当自动构造子类时，是否应使用with_defaults备用构造函数。默认为False。

示例

此类模型通过 De Groote 等人（2016 年）描述的特征曲线对肌腱作用器进行参数化[R728]。像 SymPy 生物力学模块中的所有肌腱模型一样，它需要定义其作用线的路径。我们将首先创建一个简单的LinearPathway，连接两个我们的肌腱将要遵循的点。我们将创建一个点O来表示肌腱的起点，另一个I来表示其插入点。

>>> from sympy import symbols
>>> from sympy.physics.mechanics import (LinearPathway, Point,
...     ReferenceFrame, dynamicsymbols) 

>>> N = ReferenceFrame('N')
>>> O, I = O, P = symbols('O, I', cls=Point)
>>> q, u = dynamicsymbols('q, u', real=True)
>>> I.set_pos(O, q*N.x)
>>> O.set_vel(N, 0)
>>> I.set_vel(N, u*N.x)
>>> pathway = LinearPathway(O, I)
>>> pathway.attachments
(O, I)
>>> pathway.length
Abs(q(t))
>>> pathway.extension_velocity
sign(q(t))*Derivative(q(t), t) 

由于这将用于在肌腱动力学的公式中提供激活的符号，肌腱还需要激活动力学模型的实例。我们将使用FirstOrderActivationDeGroote2016的实例来表示一阶激活动力学。请注意，需要提供单个名称参数，因为 SymPy 将使用此参数作为后缀。

>>> from sympy.physics.biomechanics import FirstOrderActivationDeGroote2016 

>>> activation = FirstOrderActivationDeGroote2016('muscle')
>>> activation.x
Matrix([[a_muscle(t)]])
>>> activation.r
Matrix([[e_muscle(t)]])
>>> activation.p
Matrix([
[tau_a_muscle],
[tau_d_muscle],
[    b_muscle]])
>>> activation.rhs()
Matrix([[((1/2 - tanh(b_muscle*(-a_muscle(t) + e_muscle(t)))/2)*(3*...]]) 

肌腱类需要传递符号或值来表示肌腱动力学中的常数。我们将使用 SymPy 的symbols函数创建符号，用于最大等长力F_M_max，最佳纤维长度l_M_opt，腱松弛长度l_T_slack，最大纤维速度v_M_max，最佳肌肉角度pyalpha_opt, and fiber damping coefficient ``beta。

>>> F_M_max = symbols('F_M_max', real=True)
>>> l_M_opt = symbols('l_M_opt', real=True)
>>> l_T_slack = symbols('l_T_slack', real=True)
>>> v_M_max = symbols('v_M_max', real=True)
>>> alpha_opt = symbols('alpha_opt', real=True)
>>> beta = symbols('beta', real=True) 

然后，我们可以从生物力学模块中导入MusculotendonDeGroote2016类，并通过传入我们之前实例化的各种对象来创建一个实例。默认情况下，将创建一个具有刚性腱肌腱动力学的肌腱模型。

>>> from sympy.physics.biomechanics import MusculotendonDeGroote2016 

>>> rigid_tendon_muscle = MusculotendonDeGroote2016(
...     'muscle',
...     pathway,
...     activation,
...     tendon_slack_length=l_T_slack,
...     peak_isometric_force=F_M_max,
...     optimal_fiber_length=l_M_opt,
...     maximal_fiber_velocity=v_M_max,
...     optimal_pennation_angle=alpha_opt,
...     fiber_damping_coefficient=beta,
... ) 

我们可以检查肌腱的各种属性，包括使用其force属性描述其产生的力的符号表达式。

>>> rigid_tendon_muscle.force
-F_M_max*(beta*(-l_T_slack + Abs(q(t)))*sign(q(t))*Derivative(q(t), t)... 

当创建肌腱对象时，我们传递了一个激活动力学对象的实例，该对象控制肌腱内的激活。SymPy 在这里做出了设计选择，即激活动力学实例将被视为肌腱动力学的子对象。因此，如果我们想检查与肌腱模型相关联的状态和输入变量，我们也将返回与子对象相关联的状态和输入变量，或者在本例中是激活动力学。由于我们创建的肌腱模型使用了刚性肌腱动力学，因此没有引入与肌腱相关的附加状态或输入。因此，该模型仅与一个状态相关联，即激活，以及一个与之相关联的输入，即兴奋。可以使用x和r属性检查状态和输入。请注意，x和r都具有state_vars和input_vars的别名属性。

>>> rigid_tendon_muscle.x
Matrix([[a_muscle(t)]])
>>> rigid_tendon_muscle.r
Matrix([[e_muscle(t)]]) 

要查看肌腱模型中哪些常数是符号常数，我们可以使用p或constants属性。这将返回一个由符号常数填充的Matrix，而不是数值。

>>> rigid_tendon_muscle.p
Matrix([
[           l_T_slack],
[             F_M_max],
[             l_M_opt],
[             v_M_max],
[           alpha_opt],
[                beta],
[        tau_a_muscle],
[        tau_d_muscle],
[            b_muscle],
[     c_0_fl_T_muscle],
[     c_1_fl_T_muscle],
[     c_2_fl_T_muscle],
[     c_3_fl_T_muscle],
[ c_0_fl_M_pas_muscle],
[ c_1_fl_M_pas_muscle],
[ c_0_fl_M_act_muscle],
[ c_1_fl_M_act_muscle],
[ c_2_fl_M_act_muscle],
[ c_3_fl_M_act_muscle],
[ c_4_fl_M_act_muscle],
[ c_5_fl_M_act_muscle],
[ c_6_fl_M_act_muscle],
[ c_7_fl_M_act_muscle],
[ c_8_fl_M_act_muscle],
[ c_9_fl_M_act_muscle],
[c_10_fl_M_act_muscle],
[c_11_fl_M_act_muscle],
[     c_0_fv_M_muscle],
[     c_1_fv_M_muscle],
[     c_2_fv_M_muscle],
[     c_3_fv_M_muscle]]) 

最后，我们可以调用rhs方法返回一个Matrix，其中包含每个肌腱状态对应的普通微分方程的右侧。与 SymPy 力学模块中同名方法类似，该方法返回一个列向量，其行数对应于状态的数量。在这里的示例中，我们只有一个状态，即动态符号a_muscle(t)，因此返回值是一个 1x1 的Matrix。

>>> rigid_tendon_muscle.rhs()
Matrix([[((1/2 - tanh(b_muscle*(-a_muscle(t) + e_muscle(t)))/2)*(3*...]]) 

肌腱类支持弹性肌腱模型和刚性肌腱模型。您可以选择将纤维长度或肌腱力作为附加状态之一。您还可以指定是否使用显式或隐式公式。在调用构造函数时，可以将MusculotendonFormulation枚举的成员传递给musculotendon_dynamics参数以选择一个公式。此枚举是一个IntEnum，因此也可以传递一个整数，但建议使用枚举，因为这样更清楚地显示您实际选择的公式。在下面的示例中，我们将使用FIBER_LENGTH_EXPLICIT成员创建一个具有弹性肌腱的肌腱，它将使用（标准化的）肌肉纤维长度作为附加状态，并以显式形式产生主导的普通微分方程。

>>> from sympy.physics.biomechanics import MusculotendonFormulation 

>>> elastic_tendon_muscle = MusculotendonDeGroote2016(
...     'muscle',
...     pathway,
...     activation,
...     musculotendon_dynamics=MusculotendonFormulation.FIBER_LENGTH_EXPLICIT,
...     tendon_slack_length=l_T_slack,
...     peak_isometric_force=F_M_max,
...     optimal_fiber_length=l_M_opt,
...     maximal_fiber_velocity=v_M_max,
...     optimal_pennation_angle=alpha_opt,
...     fiber_damping_coefficient=beta,
... ) 

>>> elastic_tendon_muscle.force
-F_M_max*TendonForceLengthDeGroote2016((-sqrt(l_M_opt**2*...
>>> elastic_tendon_muscle.x
Matrix([
[l_M_tilde_muscle(t)],
[        a_muscle(t)]])
>>> elastic_tendon_muscle.r
Matrix([[e_muscle(t)]])
>>> elastic_tendon_muscle.p
Matrix([
[           l_T_slack],
[             F_M_max],
[             l_M_opt],
[             v_M_max],
[           alpha_opt],
[                beta],
[        tau_a_muscle],
[        tau_d_muscle],
[            b_muscle],
[     c_0_fl_T_muscle],
[     c_1_fl_T_muscle],
[     c_2_fl_T_muscle],
[     c_3_fl_T_muscle],
[ c_0_fl_M_pas_muscle],
[ c_1_fl_M_pas_muscle],
[ c_0_fl_M_act_muscle],
[ c_1_fl_M_act_muscle],
[ c_2_fl_M_act_muscle],
[ c_3_fl_M_act_muscle],
[ c_4_fl_M_act_muscle],
[ c_5_fl_M_act_muscle],
[ c_6_fl_M_act_muscle],
[ c_7_fl_M_act_muscle],
[ c_8_fl_M_act_muscle],
[ c_9_fl_M_act_muscle],
[c_10_fl_M_act_muscle],
[c_11_fl_M_act_muscle],
[     c_0_fv_M_muscle],
[     c_1_fv_M_muscle],
[     c_2_fv_M_muscle],
[     c_3_fv_M_muscle]])
>>> elastic_tendon_muscle.rhs()
Matrix([
[v_M_max*FiberForceVelocityInverseDeGroote2016((l_M_opt*...],
[ ((1/2 - tanh(b_muscle*(-a_muscle(t) + e_muscle(t)))/2)*(3*...]]) 

强烈建议在创建实例时使用替代的with_defaults构造函数，因为这将确保在肌腱特性曲线中使用已发布的常数。

>>> elastic_tendon_muscle = MusculotendonDeGroote2016.with_defaults(
...     'muscle',
...     pathway,
...     activation,
...     musculotendon_dynamics=MusculotendonFormulation.FIBER_LENGTH_EXPLICIT,
...     tendon_slack_length=l_T_slack,
...     peak_isometric_force=F_M_max,
...     optimal_fiber_length=l_M_opt,
... ) 

>>> elastic_tendon_muscle.x
Matrix([
[l_M_tilde_muscle(t)],
[        a_muscle(t)]])
>>> elastic_tendon_muscle.r
Matrix([[e_muscle(t)]])
>>> elastic_tendon_muscle.p
Matrix([
[   l_T_slack],
[     F_M_max],
[     l_M_opt],
[tau_a_muscle],
[tau_d_muscle],
[    b_muscle]]) 

参考文献

[R728] (1,2,3)

De Groote, F., Kinney, A. L., Rao, A. V., & Fregly, B. J.，《评估用于解决肌肉冗余问题的直接共轭最优控制问题表述方法》，《生物医学工程年鉴》，44(10)，（2016 年）第 2922-2936 页

class sympy.physics.biomechanics.musculotendon.MusculotendonFormulation(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)

肌腱动力学配方类型的枚举。

解释

枚举（整数）用于更清晰地选择肌腱动力学的不同配方。

成员

RIGID_TENDON0

一个刚性肌腱模型。

FIBER_LENGTH_EXPLICIT1

一个明确的弹性肌腱模型，其肌纤维长度（l_M）作为状态变量。

TENDON_FORCE_EXPLICIT2

一个明确的弹性肌腱模型，其肌腱力（F_T）作为状态变量。

FIBER_LENGTH_IMPLICIT3

一个隐式弹性肌腱模型，其肌纤维长度（l_M）作为状态变量，肌纤维速度作为额外的输入变量。

TENDON_FORCE_IMPLICIT4

一个隐式弹性肌腱模型，其肌腱力（F_T）作为状态变量，肌纤维速度作为额外的输入变量。