SymPy-1-13-中文文档-十八-

SymPy 1.13 中文文档（十八）

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

生物力学

原文：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}{lT_{slack}})。

peak_isometric_force : Expr | None

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

optimal_fiber_length : Expr | None

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

maximal_fiber_velocity : Expr | None

在肌肉纤维缩短过程中，当肌肉纤维无法产生任何主动力时的纤维速度。在所有肌腱模型中，最大纤维速度用于将肌肉纤维伸展速度归一化，得到 (\tilde{v}^M = \frac{v^M}{vM_{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}{FM_{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}{lM_{opt}})。

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

property l_T_slack

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

解释

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

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

property maximal_fiber_velocity

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

说明

在肌肉纤维缩短期间，肌纤维无法产生任何主动力时的纤维速度。在所有肌腱模型中，最大纤维速度用于将肌纤维伸展速度归一化，得到(\tilde{v}^M = \frac{v^M}{vM_{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}{lM_{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}{FM_{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}{lT_{slack}})。

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

property v_M_max

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

解释

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

peak_isometric_force : 表达式 | 无

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

optimal_fiber_length : 表达式 | 无

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

maximal_fiber_velocity : 表达式 | 无

在肌肉纤维缩短过程中，肌肉纤维无法产生任何主动力的纤维速度。在所有肌腱模型中，最大纤维速度用于归一化肌肉纤维伸展速度，得到 (\tilde{v}^M = \frac{v^M}{vM_{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}{lT_{slack}})。

peak_isometric_force：Expr | None

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

optimal_fiber_length : Expr | None

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

maximal_fiber_velocity : Expr | None

在肌纤维缩短过程中，肌纤维无法产生任何主动力的纤维速度。在所有肌腱模型中，最大纤维速度用于将肌纤维伸展速度归一化，以给出(\tilde{v}^M = \frac{v^M}{vM_{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）作为状态变量，肌纤维速度作为额外的输入变量。

激活（文档字符串）

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

肌腱模型的激活动力学。

当肌腱模型被激活时，它们能够产生主动力，这是由于肌纤维内的化学过程导致其自愿收缩。从生物学角度来看，这种化学过程（(\textrm{Ca}^{2+})离子的扩散）不是系统的输入，而是来自神经系统的电信号。这些被称为兴奋。激活动力学将标准化的兴奋水平与标准化的激活水平相关联，可以通过该模块中的模型进行建模。

class sympy.physics.biomechanics.activation.ActivationBase(name)

所有激活动力学类继承的抽象基类。

注意事项

该类的实例不能直接由用户实例化。但是，可以通过子类化来创建自定义激活动力学类型。

abstract property F

在M x' = F的右手边的方程的有序列矩阵。

解释

形成线性常微分方程组的右手边列矩阵，用以描述激活动力学的常微分方程。

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

abstract property M

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

解释

形成线性常微分方程组左手边的方阵。

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

property a

表示激活的动态符号。

解释

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

property activation

表示激活的动态符号。

解释

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

abstract property constants

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

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

解释

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

property e

表示兴奋的动态符号。

解释

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

property excitation

表示兴奋的动态符号。

解释

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

abstract property input_vars

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

解释

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

abstract property order

管理激活方程的（微分）方程的顺序。

abstract property p

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

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

解释

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

abstract property r

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

解释

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

abstract rhs()

解释

解决了控制激活动力学的线性常微分方程组：

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

abstract property state_vars

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

解释

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

abstract classmethod with_defaults(name)

提供常数的推荐默认值的替代构造函数。

abstract property x

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

解释

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

class sympy.physics.biomechanics.activation.FirstOrderActivationDeGroote2016(name, activation_time_constant=None, deactivation_time_constant=None, smoothing_rate=None)

基于 De Groote 等人的 2016 年的一阶激活动力学 [R720]。

解释

给出了关于激活速率随时间变化的一阶激活动力学方程，作为激励和激活的函数。

该函数由以下方程定义：

[\frac{da}{dt} = \left(\frac{\frac{1}{2} + a0}{\tau_a \left(\frac{1}{2} + \frac{3a}{2}\right)} + \frac{\left(\frac{1}{2} + \frac{3a}{2}\right) \left(\frac{1}{2} - a0\right)}{\tau_d}\right) \left(e - a\right)]

其中

[a0 = \frac{\tanh{\left(b \left(e - a\right) \right)}}{2}]

其中常数值为 (tau_a = 0.015)，(tau_d = 0.060)，(b = 10)。

参考文献

[R720] (1,2)

De Groote, F., Kinney, A. L., Rao, A. V., & Fregly, B. J.，评估直接配点最优控制问题表述以解决肌肉冗余问题，生物医学工程年报，44(10)，(2016) pp. 2922-2936

property F

有序列出的M x' = F右手边方程列矩阵。

解释

线性常微分方程组的右手边矩阵的列矩阵：

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

property M

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

解释

线性常微分方程组的左手边矩阵的一部分的方阵：

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

property activation_time_constant

激活延迟常数。

解释

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

property b

用于双曲正切项的平滑常数。

解释

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

property constants

有序列出的M和F中的非时间变化符号列矩阵。

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

解释

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

property deactivation_time_constant

反应消退的延迟常数。

解释

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

property input_vars

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

解释

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

property order

控制激活动力学的（微分）方程的阶数。

property p

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

解释

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

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

property r

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

解释

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

rhs()

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

解释

控制激活动力学的线性常微分方程组的解：

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

property smoothing_rate

双曲正切项的平滑常数。

解释

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

property state_vars

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

解释

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

property tau_a

激活的延迟常数。

解释

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

property tau_d

反应消退的延迟常数。

解释

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

classmethod with_defaults(name)

将使用已发布的常数的备用构造器。

解释

使用原始出版物中指定的三个常数值返回FirstOrderActivationDeGroote2016的实例。

这些值为：

(\tau_a = 0.015) (\tau_d = 0.060) (b = 10)

property x

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

解释

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

class sympy.physics.biomechanics.activation.ZerothOrderActivation(name)

简单的零阶激活动力学，将激发映射到激活。

解释

在你想要减少肌腱动力学复杂性的情况下，零阶激活动力学非常有用，因为它们简单地将兴奋映射到激活。因此，您的系统中不会引入额外的状态方程。它们还消除了在输入和系统动力学之间可能存在的延迟源，因为不涉及（普通）微分方程。

property F

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

Explanation

形成控制激活动力学的普通微分方程组右手边的列矩阵：

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

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

property M

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

Explanation

形成控制激活动力学的普通微分方程组的左手边的方阵：

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

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

property constants

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

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

Explanation

零阶激活动力学简单地将兴奋映射到激活，因此该类别没有相关的常数，因此此属性返回形状为(0, 1)的空列矩阵。

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

property input_vars

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

Explanation

在零阶激活动力学中，只有兴奋是输入，因此该属性返回一个包含一个条目e和形状为(1, 1)的列矩阵。

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

property order

控制激活的（微分）方程的顺序。

property p

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

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

Explanation

零阶激活动力学简单地将兴奋映射到激活，因此该类别没有相关的常数，因此此属性返回形状为(0, 1)的空列矩阵。

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

property r

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

解释

激发是零阶激活动力学中唯一的输入，因此此属性返回一个形状为(1, 1)的列Matrix，其中包含一个条目e。

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

rhs()

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

解释

解线性系统的解决方案，控制激活动力学的常微分方程组：

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

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

property state_vars

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

解释

零阶激活动力学仅仅将激发映射到激活，因此该类别没有相关联的状态变量，因此此属性返回一个形状为(0, 1)的空列Matrix。

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

classmethod with_defaults(name)

提供了常量的推荐默认值的备用构造函数。

解释

由于此具体类别没有实现与其动态相关的任何常量，此classmethod简单地创建ZerothOrderActivation的标准实例。提供了一个实现，以确保所有ActivationBase具体类之间的一致接口。

property x

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

解释

零阶激活动力学仅仅将激发映射到激活，因此该类别没有相关联的状态变量，因此此属性返回一个形状为(0, 1)的空列Matrix。

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

曲线（文档字符串）

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

肌腱模型特征曲线的实现。

class sympy.physics.biomechanics.curve.CharacteristicCurveCollection(tendon_force_length: CharacteristicCurveFunction, tendon_force_length_inverse: CharacteristicCurveFunction, fiber_force_length_passive: CharacteristicCurveFunction, fiber_force_length_passive_inverse: CharacteristicCurveFunction, fiber_force_length_active: CharacteristicCurveFunction, fiber_force_velocity: CharacteristicCurveFunction, fiber_force_velocity_inverse: CharacteristicCurveFunction)

简单的数据容器，用于组合相关的特征曲线。

class sympy.physics.biomechanics.curve.CharacteristicCurveFunction

所有肌腱特征曲线函数的基类。

class sympy.physics.biomechanics.curve.FiberForceLengthActiveDeGroote2016(l_M_tilde, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11)

基于 De Groote 等人的 2016 年的活跃肌纤维力长度曲线[R721]。

解释

该函数由以下方程定义：

(fl_{\text{act}}^M = c_0 \exp\left(-\frac{1}{2}\left(\frac{\tilde{l}^M - c_1}{c_2 + c_3 \tilde{l}^M}\right)²\right) + c_4 \exp\left(-\frac{1}{2}\left(\frac{\tilde{l}^M - c_5}{c_6 + c_7 \tilde{l}^M}\right)²\right) + c_8 \exp\left(-\frac{1}{2}\left(\frac{\tilde{l}^M - c_9}{c_{10} + c_{11} \tilde{l}^M}\right)²\right))

使用常量值 (c0 = 0.814)，(c1 = 1.06)，(c2 = 0.162)，(c3 = 0.0633)，(c4 = 0.433)，(c5 = 0.717)，(c6 = -0.0299)，(c7 = 0.2)，(c8 = 0.1)，(c9 = 1.0)，(c10 = 0.354)，(c11 = 0.0)。

虽然可以更改常数值，但这些值是在原始出版物中精心选择的，以赋予特征曲线特定和所需的性质。例如，该函数在标准化肌纤维长度为 1 时产生活跃纤维力为 1，在标准化肌纤维长度为 0 和 2 时产生活跃纤维力为 0。

示例

实例化FiberForceLengthActiveDeGroote2016的首选方式是使用with_defaults()构造函数，因为这将自动使用原始出版物中的浮点值填充特征曲线方程中的常数。此构造函数接受一个与标准化肌纤维长度对应的单个参数。我们将创建一个称为l_M_tilde的Symbol来表示这一点。

>>> from sympy import Symbol
>>> from sympy.physics.biomechanics import FiberForceLengthActiveDeGroote2016
>>> l_M_tilde = Symbol('l_M_tilde')
>>> fl_M = FiberForceLengthActiveDeGroote2016.with_defaults(l_M_tilde)
>>> fl_M
FiberForceLengthActiveDeGroote2016(l_M_tilde, 0.814, 1.06, 0.162, 0.0633,
0.433, 0.717, -0.0299, 0.2, 0.1, 1.0, 0.354, 0.0) 

也可以用您自己的值填充这两个常数。

>>> from sympy import symbols
>>> c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11 = symbols('c0:12')
>>> fl_M = FiberForceLengthActiveDeGroote2016(l_M_tilde, c0, c1, c2, c3,
...     c4, c5, c6, c7, c8, c9, c10, c11)
>>> fl_M
FiberForceLengthActiveDeGroote2016(l_M_tilde, c0, c1, c2, c3, c4, c5, c6,
c7, c8, c9, c10, c11) 

您不仅可以使用符号作为参数，还可以使用表达式。让我们创建一个新的符号对，l_M和l_M_opt，分别表示肌纤维长度和最佳肌纤维长度。然后，我们可以表示l_M_tilde作为这些的比率。

>>> l_M, l_M_opt = symbols('l_M l_M_opt')
>>> l_M_tilde = l_M/l_M_opt
>>> fl_M = FiberForceLengthActiveDeGroote2016.with_defaults(l_M_tilde)
>>> fl_M
FiberForceLengthActiveDeGroote2016(l_M/l_M_opt, 0.814, 1.06, 0.162, 0.0633,
0.433, 0.717, -0.0299, 0.2, 0.1, 1.0, 0.354, 0.0) 

要检查此函数表示的实际符号表达式，我们可以对实例调用 doit() 方法。 我们将使用关键字参数 evaluate=False，因为这将保持表达式的规范形式，并且不会简化任何常数。

>>> fl_M.doit(evaluate=False)
0.814*exp(-19.0519737844841*(l_M/l_M_opt
- 1.06)**2/(0.390740740740741*l_M/l_M_opt + 1)**2)
+ 0.433*exp(-12.5*(l_M/l_M_opt - 0.717)**2/(l_M/l_M_opt - 0.1495)**2)
+ 0.1*exp(-3.98991349867535*(l_M/l_M_opt - 1.0)**2) 

该函数也可以进行微分。 我们将使用单个位置参数 l_M 在实例上使用 diff 方法进行微分。

>>> fl_M.diff(l_M)
((-0.79798269973507*l_M/l_M_opt
+ 0.79798269973507)*exp(-3.98991349867535*(l_M/l_M_opt - 1.0)**2)
+ (10.825*(-l_M/l_M_opt + 0.717)/(l_M/l_M_opt - 0.1495)**2
+ 10.825*(l_M/l_M_opt - 0.717)**2/(l_M/l_M_opt
- 0.1495)**3)*exp(-12.5*(l_M/l_M_opt - 0.717)**2/(l_M/l_M_opt - 0.1495)**2)
+ (31.0166133211401*(-l_M/l_M_opt + 1.06)/(0.390740740740741*l_M/l_M_opt
+ 1)**2 + 13.6174190361677*(0.943396226415094*l_M/l_M_opt
- 1)**2/(0.390740740740741*l_M/l_M_opt
+ 1)**3)*exp(-21.4067977442463*(0.943396226415094*l_M/l_M_opt
- 1)**2/(0.390740740740741*l_M/l_M_opt + 1)**2))/l_M_opt 

参考文献

[R721]（1，2）

De Groote, F., Kinney, A. L., Rao, A. V., & Fregly, B. J., 评估用于解决肌肉冗余问题的直接多段优化控制问题的公式，生物医学工程年鉴，44(10)，（2016）第 2922-2936 页

doit(deep=True, evaluate=True, **hints)

评估定义函数的表达式。

参数：

deep : 布尔值

是否应递归调用 doit。 默认为 True。

evaluate : 布尔值。

是否应在构建时评估 SymPy 表达式。 如果为 False，则不会进行常数折叠，这将使表达式在肌腱的合理操作范围内对应于 l_M_tilde 的值更加稳定。 默认为 True。

**kwargs : 字典[str, 任何]

要递归传递给 doit 的额外关键字参数对。

classmethod eval(l_M_tilde, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11)

基本输入的评估。

参数：

l_M_tilde : 任何（可简化）

标准化肌肉纤维长度。

c0 : 任何（可简化）

特征方程中的第一个常数。 发表的值是 0.814。

c1 : 任何（可简化）

特征方程中的第二个常数。 发表的值是 1.06。

c2 : 任何（可简化）

特征方程中的第三个常数。 发表的值是 0.162。

c3 : 任何（可简化）

特征方程中的第四个常数。 发表的值是 0.0633。

c4 : 任何（可简化）

特征方程中的第五个常数。 发表的值是 0.433。

c5 : 任何（可简化）

特征方程中的第六个常数。 发表的值是 0.717。

c6 : 任何（可简化）

特征方程中的第七个常数。 发表的值是 -0.0299。

c7 : 任何（可简化）

特征方程中的第八个常数。 发表的值是 0.2。

c8 : 任何（可简化）

特征方程中的第九个常数。 发表的值是 0.1。

c9 : 任何（可简化）

特征方程中的第十个常数。 发表的值是 1.0。

c10 : 任何（可简化）

特征方程中的第十一个常数。 发表的值是 0.354。

c11 : 任何（可简化）

特征方程中的第十二个常数。 发表的值是 0.0。

fdiff(argindex=1)

对单个参数的函数的导数。

参数：

argindex : 整数

The index of the function’s arguments with respect to which the derivative should be taken. Argument indexes start at 1. Default is 1.

classmethod with_defaults(l_M_tilde)

Recommended constructor that will use the published constants.

Parameters:

• fl_M_act : Any (sympifiable)

Normalized passive muscle fiber force as a function of muscle fiber length.

Explanation

Returns a new instance of the inverse muscle fiber act force-length function using the four constant values specified in the original publication.

These have the values:

(c0 = 0.814) (c1 = 1.06) (c2 = 0.162) (c3 = 0.0633) (c4 = 0.433) (c5 = 0.717) (c6 = -0.0299) (c7 = 0.2) (c8 = 0.1) (c9 = 1.0) (c10 = 0.354) (c11 = 0.0)

class sympy.physics.biomechanics.curve.FiberForceLengthPassiveDeGroote2016(l_M_tilde, c0, c1)

Passive muscle fiber force-length curve based on De Groote et al., 2016 [R722].

Explanation

The function is defined by the equation:

(fl^M_{pas} = \frac{\frac{\exp{c_1 \left(\tilde{l^M} - 1\right)}}{c_0} - 1}{\exp{c_1} - 1})

with constant values of (c_0 = 0.6) and (c_1 = 4.0).

While it is possible to change the constant values, these were carefully selected in the original publication to give the characteristic curve specific and required properties. For example, the function produces a passive fiber force very close to 0 for all normalized fiber lengths between 0 and 1.

Examples

The preferred way to instantiate FiberForceLengthPassiveDeGroote2016 is using the with_defaults() constructor because this will automatically populate the constants within the characteristic curve equation with the floating point values from the original publication. This constructor takes a single argument corresponding to normalized muscle fiber length. We’ll create a Symbol called l_M_tilde to represent this.

>>> from sympy import Symbol
>>> from sympy.physics.biomechanics import FiberForceLengthPassiveDeGroote2016
>>> l_M_tilde = Symbol('l_M_tilde')
>>> fl_M = FiberForceLengthPassiveDeGroote2016.with_defaults(l_M_tilde)
>>> fl_M
FiberForceLengthPassiveDeGroote2016(l_M_tilde, 0.6, 4.0) 

It’s also possible to populate the two constants with your own values too.

>>> from sympy import symbols
>>> c0, c1 = symbols('c0 c1')
>>> fl_M = FiberForceLengthPassiveDeGroote2016(l_M_tilde, c0, c1)
>>> fl_M
FiberForceLengthPassiveDeGroote2016(l_M_tilde, c0, c1) 

You don’t just have to use symbols as the arguments, it’s also possible to use expressions. Let’s create a new pair of symbols, l_M and l_M_opt, representing muscle fiber length and optimal muscle fiber length respectively. We can then represent l_M_tilde as an expression, the ratio of these.

>>> l_M, l_M_opt = symbols('l_M l_M_opt')
>>> l_M_tilde = l_M/l_M_opt
>>> fl_M = FiberForceLengthPassiveDeGroote2016.with_defaults(l_M_tilde)
>>> fl_M
FiberForceLengthPassiveDeGroote2016(l_M/l_M_opt, 0.6, 4.0) 

To inspect the actual symbolic expression that this function represents, we can call the doit() method on an instance. We’ll use the keyword argument evaluate=False as this will keep the expression in its canonical form and won’t simplify any constants.

>>> fl_M.doit(evaluate=False)
0.0186573603637741*(-1 + exp(6.66666666666667*(l_M/l_M_opt - 1))) 

该函数也可以进行微分。我们将使用单个位置参数l_M对实例进行diff方法微分。

>>> fl_M.diff(l_M)
0.12438240242516*exp(6.66666666666667*(l_M/l_M_opt - 1))/l_M_opt 

参考文献

[R722]（1，2）

De Groote, F., Kinney, A. L., Rao, A. V., & Fregly, B. J., 评估用于解决肌肉冗余问题的直接配位最优控制问题公式，生物医学工程年刊，44（10），（2016）页 2922-2936

doit(deep=True, evaluate=True, **hints)

评估定义函数的表达式。

参数：

deep：bool

是否应递归调用doit。默认值为True。

evaluate：bool。

是否应在构造时评估 SymPy 表达式。如果为False，则不会进行任何常数折叠，这将使得在对应于肌腱的合理操作范围内的l_T_tilde值更加稳定。默认值为True。

****kwargs**：dict[str, Any]

要递归传递给doit的附加关键字参数对。

classmethod eval(l_M_tilde, c0, c1)

评估基本输入。

参数：

l_M_tilde：Any（可符号化）

标准化肌肉纤维长度。

c0：Any（可符号化）

特征方程中的第一个常数。发布值为0.6。

c1：Any（可符号化）

特征方程中的第二个常数。发布值为4.0。

fdiff(argindex=1)

相对于单个参数的函数导数。

参数：

argindex：int

函数参数的索引，相对于其应该进行导数计算的参数。参数索引从1开始。默认值为1。

inverse(argindex=1)

反函数。

参数：

argindex：int

开始索引参数的值。默认值为1。

classmethod with_defaults(l_M_tilde)

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

参数：

l_M_tilde：Any（可符号化）

标准化肌肉纤维长度。

说明

返回使用原始出版物指定的四个常量值的肌肉纤维被动力长度函数的新实例。

这些值为：

(c_0 = 0.6) (c_1 = 4.0)

class sympy.physics.biomechanics.curve.FiberForceLengthPassiveInverseDeGroote2016(fl_M_pas, c0, c1)

基于 De Groote 等人的逆被动肌肉纤维力长度曲线，2016 年[R723]。

说明

给出产生特定标准化被动肌肉纤维力的标准化肌肉纤维长度。

该函数由以下方程定义：

({fl^M_{pas}} = \frac{c_0 \log{\left(\exp{c_1} - 1\right)fl^M_pas + 1}}{c_1} + 1)

具有常量值(c_0 = 0.6)和(c_1 = 4.0)。该函数是相关腱力长度曲线FiberForceLengthPassiveDeGroote2016的精确解析反函数。

虽然可以更改常量值，但在原始出版物中仔细选择这些值，以赋予特征曲线特定和必需的属性。例如，该函数在标准化纤维长度在 0 和 1 之间时产生非常接近 0 的被动纤维力。

示例

实例化FiberForceLengthPassiveInverseDeGroote2016 的首选方法是使用with_defaults() 构造函数，因为这会自动使用原始出版物中的浮点值填充特征曲线方程中的常量。该构造函数接受一个参数，对应于肌肉纤维长度-力量组件的归一化被动肌肉纤维力。我们将创建一个称为fl_M_pas的Symbol 来表示这一点。

>>> from sympy import Symbol
>>> from sympy.physics.biomechanics import FiberForceLengthPassiveInverseDeGroote2016
>>> fl_M_pas = Symbol('fl_M_pas')
>>> l_M_tilde = FiberForceLengthPassiveInverseDeGroote2016.with_defaults(fl_M_pas)
>>> l_M_tilde
FiberForceLengthPassiveInverseDeGroote2016(fl_M_pas, 0.6, 4.0) 

也可以使用您自己的值填充这两个常数。

>>> from sympy import symbols
>>> c0, c1 = symbols('c0 c1')
>>> l_M_tilde = FiberForceLengthPassiveInverseDeGroote2016(fl_M_pas, c0, c1)
>>> l_M_tilde
FiberForceLengthPassiveInverseDeGroote2016(fl_M_pas, c0, c1) 

要检查此函数表示的实际符号表达式，我们可以在实例上调用doit() 方法。我们将使用关键字参数evaluate=False，因为这将保持表达式在其规范形式中，并且不会简化任何常数。

>>> l_M_tilde.doit(evaluate=False)
c0*log(1 + fl_M_pas*(exp(c1) - 1))/c1 + 1 

函数也可以进行微分。我们将使用diff方法对具有单个位置参数fl_M_pas的实例进行微分。

>>> l_M_tilde.diff(fl_M_pas)
c0*(exp(c1) - 1)/(c1*(fl_M_pas*(exp(c1) - 1) + 1)) 

参考文献

[R723] (1,2)

De Groote, F., Kinney, A. L., Rao, A. V., & Fregly, B. J., Evaluation of direct collocation optimal control problem formulations for solving the muscle redundancy problem, Annals of biomedical engineering, 44(10), (2016) pp. 2922-2936

doit(deep=True, evaluate=True, **hints)

评估定义函数的表达式。

参数：

deep : bool

是否应递归调用doit。默认为True。

evaluate : bool.

是否应该在构造时评估 SymPy 表达式。如果为False，则不会进行任何常数折叠，这将使表达式保持在对肌腱肌肉的合理操作范围对应的l_T_tilde值更为数值稳定。默认为True。

kwargs : dict[str, Any]

传递给doit的递归关键字参数对。

classmethod eval(fl_M_pas, c0, c1)

基本输入的评估。

参数：

fl_M_pas : Any (sympifiable)

归一化被动肌肉纤维力。

c0 : Any (sympifiable)

特征方程中的第一个常数。发布值为0.6。

c1 : Any (sympifiable)

特征方程中的第二个常数。发布值为4.0。

fdiff(argindex=1)

函数对单个参数的导数。

参数：

argindex : int

应该进行导数的函数参数的索引。参数索引从1开始。默认为1。

inverse(argindex=1)

反函数。

参数：

argindex : 整数

开始索引参数的值。默认为1。

classmethod with_defaults(fl_M_pas)

建议使用已发布的常数来构造。

参数：

fl_M_pas : 任意（可以符号化）

作为肌肉纤维长度函数的归一化被动肌肉纤维力。

解释

返回使用原始出版物中指定的四个常数值的逆肌肉纤维被动力长函数的新实例。

这些值为：

(c_0 = 0.6) (c_1 = 4.0)

class sympy.physics.biomechanics.curve.FiberForceVelocityDeGroote2016(v_M_tilde, c0, c1, c2, c3)

基于 De Groote 等人的 2016 年研究的肌肉纤维力-速度曲线[R724]。

解释

给出作为归一化肌腱速度函数的函数产生的归一化肌肉纤维力。

函数由以下方程定义：

(fv^M = c_0 \log{\left(c_1 \tilde{v}_m + c_2\right) + \sqrt{\left(c_1 \tilde{v}_m + c_2\right)² + 1}} + c_3)

其中常数值为 (c_0 = -0.318), (c_1 = -8.149), (c_2 = -0.374), 和 (c_3 = 0.886)。

虽然可以更改常数值，但这些值在原始出版物中经过精心选择，以使特征曲线具有特定和所需的属性。例如，当肌肉纤维等长收缩时（伸展速率为 0），该函数产生归一化的肌肉纤维力为 1。

示例

实例化FiberForceVelocityDeGroote2016的首选方式是使用with_defaults()构造函数，因为这将自动使用原始出版物中的浮点值填充特征曲线方程中的常数。此构造函数接受一个参数，对应归一化肌肉纤维伸展速度。我们将创建一个称为v_M_tilde的Symbol来表示这一点。

>>> from sympy import Symbol
>>> from sympy.physics.biomechanics import FiberForceVelocityDeGroote2016
>>> v_M_tilde = Symbol('v_M_tilde')
>>> fv_M = FiberForceVelocityDeGroote2016.with_defaults(v_M_tilde)
>>> fv_M
FiberForceVelocityDeGroote2016(v_M_tilde, -0.318, -8.149, -0.374, 0.886) 

也可以用自己的值填充这四个常数。

>>> from sympy import symbols
>>> c0, c1, c2, c3 = symbols('c0 c1 c2 c3')
>>> fv_M = FiberForceVelocityDeGroote2016(v_M_tilde, c0, c1, c2, c3)
>>> fv_M
FiberForceVelocityDeGroote2016(v_M_tilde, c0, c1, c2, c3) 

不仅可以使用符号作为参数，还可以使用表达式。让我们创建一个新的符号对，v_M和v_M_max，分别表示肌肉纤维伸展速度和最大肌肉纤维伸展速度。然后，我们可以表示v_M_tilde作为一个表达式，即这些的比率。

>>> v_M, v_M_max = symbols('v_M v_M_max')
>>> v_M_tilde = v_M/v_M_max
>>> fv_M = FiberForceVelocityDeGroote2016.with_defaults(v_M_tilde)
>>> fv_M
FiberForceVelocityDeGroote2016(v_M/v_M_max, -0.318, -8.149, -0.374, 0.886) 

要检查该函数代表的实际符号表达式，我们可以在一个实例上调用doit()方法。我们将使用关键字参数evaluate=False，因为这将保持表达式在其规范形式中，并不会简化任何常数。

>>> fv_M.doit(evaluate=False)
0.886 - 0.318*log(-8.149*v_M/v_M_max - 0.374 + sqrt(1 + (-8.149*v_M/v_M_max
- 0.374)**2)) 

函数也可以被微分。我们将使用单个位置参数v_M上的diff方法进行微分。

>>> fv_M.diff(v_M)
2.591382*(1 + (-8.149*v_M/v_M_max - 0.374)**2)**(-1/2)/v_M_max 

参考文献

[R724] (1,2)

De Groote, F., Kinney, A. L., Rao, A. V., & Fregly, B. J., 对解决肌肉冗余问题的直接配点最优控制问题公式的评估，生物医学工程学年鉴，44(10)，（2016）页 2922-2936

doit(deep=True, evaluate=True, **hints)

评估定义函数的表达式。

参数：

deep : 布尔值

doit是否应递归调用。默认为True。

evaluate : 布尔值。

SymPy 表达式是否应在构造时进行评估。如果为False，则不进行任何常数折叠，这将使表达式在v_M_tilde的值对应于肌腱合理操作范围时更加数值稳定。默认为True。

**kwargs : 字典[str, 任意类型]

递归传递给doit的额外关键字参数对。

classmethod eval(v_M_tilde, c0, c1, c2, c3)

评估基本输入。

参数：

v_M_tilde : 任意类型（可 SymPy 化）

标准化肌肉纤维伸展速度。

c0 : 任意类型（可 SymPy 化）

特征方程中的第一个常数。发布值为-0.318。

c1 : 任意类型（可 SymPy 化）

特征方程中的第二个常数。发布值为-8.149。

c2 : 任意类型（可 SymPy 化）

特征方程中的第三个常数。发布值为-0.374。

c3 : 任意类型（可 SymPy 化）

特征方程中的第四个常数。发布值为0.886。

fdiff(argindex=1)

函数关于单个参数的导数。

参数：

argindex : 整数

应对哪个参数的导数应该被取的函数的索引。参数索引从1开始。默认为1。

inverse(argindex=1)

反函数。

参数：

argindex : 整数

开始索引参数的值。默认为1。

classmethod with_defaults(v_M_tilde)

推荐使用原始出版物中指定的四个常数值的构造函数。

参数：

v_M_tilde : 任意类型（可 SymPy 化）

标准化肌肉纤维伸展速度。

说明

返回使用原始出版物中指定的四个常数值的新肌肉纤维力-速度函数的新实例。

这些具有以下数值：

(c_0 = -0.318) (c_1 = -8.149) (c_2 = -0.374) (c_3 = 0.886)

class sympy.physics.biomechanics.curve.FiberForceVelocityInverseDeGroote2016(fv_M, c0, c1, c2, c3)

基于 De Groote 等人，2016 年[R725]的逆肌肉纤维力-速度曲线。

说明

给出产生特定标准化肌肉纤维力的标准化肌肉纤维速度。

函数由以下方程定义：

({fv^M} = \frac{\sinh{\frac{fv^M - c_3}{c_0}} - c_2}{c_1})

具有常数值(c_0 = -0.318)，(c_1 = -8.149)，(c_2 = -0.374)和(c_3 = 0.886)。这个函数是相关肌肉纤维力-速度曲线FiberForceVelocityDeGroote2016的精确解析逆函数。

尽管可以更改常数值，但这些值在原始出版物中被精心选择，以赋予特征曲线特定和必需的属性。例如，当肌肉纤维等长收缩时（其扩展速率为 0），函数产生归一化肌肉纤维力为 1。

示例

实例化 FiberForceVelocityInverseDeGroote2016 的首选方式是使用 with_defaults() 构造函数，因为这将自动将特征曲线方程中的常量使用原始出版物中的浮点值填充。这个构造函数接受一个参数，对应于肌肉纤维力-速度组分的归一化肌肉纤维力。我们将创建一个叫做 fv_M 的 Symbol 来表示这个值。

>>> from sympy import Symbol
>>> from sympy.physics.biomechanics import FiberForceVelocityInverseDeGroote2016
>>> fv_M = Symbol('fv_M')
>>> v_M_tilde = FiberForceVelocityInverseDeGroote2016.with_defaults(fv_M)
>>> v_M_tilde
FiberForceVelocityInverseDeGroote2016(fv_M, -0.318, -8.149, -0.374, 0.886) 

也可以使用自己的值填充这四个常数。

>>> from sympy import symbols
>>> c0, c1, c2, c3 = symbols('c0 c1 c2 c3')
>>> v_M_tilde = FiberForceVelocityInverseDeGroote2016(fv_M, c0, c1, c2, c3)
>>> v_M_tilde
FiberForceVelocityInverseDeGroote2016(fv_M, c0, c1, c2, c3) 

要检查此函数表示的实际符号表达式，我们可以在实例上调用 doit() 方法。我们将使用关键字参数 evaluate=False，因为这将保持表达式在其规范形式中，并且不会简化任何常数。

>>> v_M_tilde.doit(evaluate=False)
(-c2 + sinh((-c3 + fv_M)/c0))/c1 

函数也可以进行微分。我们将使用实例的 diff 方法相对于 fv_M 进行微分，使用单个位置参数 fv_M。

>>> v_M_tilde.diff(fv_M)
cosh((-c3 + fv_M)/c0)/(c0*c1) 

参考文献

[R725] (1,2)

De Groote, F., Kinney, A. L., Rao, A. V., & Fregly, B. J., Evaluation of direct collocation optimal control problem formulations for solving the muscle redundancy problem, Annals of biomedical engineering, 44(10), (2016) pp. 2922-2936

doit(deep=True, evaluate=True, **hints)

评估定义函数的表达式。

参数:

deep : 布尔值

是否应该递归调用 doit。默认为 True。

evaluate : 布尔值。

是否应该按照构造时的 SymPy 表达式进行评估。如果为 False，则不会进行任何常数折叠，这将使表达式在肌腱肌肉的合理操作范围内的 fv_M 值更加数值稳定。默认为 True。

**kwargs : 字典[str, 任意]

递归传递给 doit 的额外关键字参数对。

classmethod eval(fv_M, c0, c1, c2, c3)

基本输入的评估。

参数:

fv_M : 任意（可用 sympify 转换）

归一化肌肉纤维力作为肌肉纤维伸展速度的函数。

c0 : 任意（可用 sympify 转换）

特征方程中的第一个常数。出版值为 -0.318。

c1 : 任意（可用 sympify 转换）

特征方程中的第二个常数。已发布值为-8.149。

c2 : 任何（可简化的）

特征方程中的第三个常数。已发布值为-0.374。

c3 : 任何（可简化的）

特征方程中的第四个常数。已发布值为0.886。

fdiff(argindex=1)

函数对单个参数的导数。

参数：

argindex : 整数

函数参数的索引，应对这些导数进行处理。参数索引从1开始。默认为1。

inverse(argindex=1)

反函数。

参数：

argindex : 整数

起始索引的值。默认为1。

classmethod with_defaults(fv_M)

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

参数：

fv_M : 任何（可简化的）

规范化肌肉纤维伸长速度。

解释

返回一个新的反肌肉纤维力-速度函数实例，使用原始发布中指定的四个常数值。

这些值为：

(c_0 = -0.318), (c_1 = -8.149), (c_2 = -0.374), (c_3 = 0.886)

class sympy.physics.biomechanics.curve.TendonForceLengthDeGroote2016(l_T_tilde, c0, c1, c2, c3)

基于 De Groote 等人 2016 年的肌腱力长度曲线 [R726]。

解释

以规范化的肌腱长度为函数，产生的规范化肌腱力。

函数由以下方程定义：

(fl^T = c_0 \exp{c_3 \left( \tilde{l}^T - c_1 \right)} - c_2)

其常数值为 (c_0 = 0.2), (c_1 = 0.995), (c_2 = 0.25), 和 (c_3 = 33.93669377311689)。

虽然可以更改常数值，但这些值是在原始发布中精心选择的，以赋予特征曲线特定和所需的属性。例如，当肌腱处于无应变状态时，函数不产生力。当肌腱处于 5%应变状态时，它还会产生 1 单位的规范化力量。

示例

首选实例化TendonForceLengthDeGroote2016的方式是使用with_defaults()构造函数，因为这将自动填充特征曲线方程中的常数，使用原始发布中的浮点值。此构造函数接受一个参数，对应规范化肌腱长度。我们将创建一个称为l_T_tilde的Symbol来表示这一点。

>>> from sympy import Symbol
>>> from sympy.physics.biomechanics import TendonForceLengthDeGroote2016
>>> l_T_tilde = Symbol('l_T_tilde')
>>> fl_T = TendonForceLengthDeGroote2016.with_defaults(l_T_tilde)
>>> fl_T
TendonForceLengthDeGroote2016(l_T_tilde, 0.2, 0.995, 0.25,
33.93669377311689) 

你也可以使用自己的值填充这四个常数。

>>> from sympy import symbols
>>> c0, c1, c2, c3 = symbols('c0 c1 c2 c3')
>>> fl_T = TendonForceLengthDeGroote2016(l_T_tilde, c0, c1, c2, c3)
>>> fl_T
TendonForceLengthDeGroote2016(l_T_tilde, c0, c1, c2, c3) 

您不仅可以将符号用作参数，还可以使用表达式。让我们创建一个新的符号对，l_T和l_T_slack，分别表示肌腱长度和肌腱松弛长度。然后我们可以表示l_T_tilde为这些的比率。

>>> l_T, l_T_slack = symbols('l_T l_T_slack')
>>> l_T_tilde = l_T/l_T_slack
>>> fl_T = TendonForceLengthDeGroote2016.with_defaults(l_T_tilde)
>>> fl_T
TendonForceLengthDeGroote2016(l_T/l_T_slack, 0.2, 0.995, 0.25,
33.93669377311689) 

要检查此函数表示的实际符号表达式，我们可以在实例上调用doit()方法。我们将使用关键字参数evaluate=False，因为这将保持表达式在其规范形式中，并且不会简化任何常数。

>>> fl_T.doit(evaluate=False)
-0.25 + 0.2*exp(33.93669377311689*(l_T/l_T_slack - 0.995)) 

函数还可以进行微分。我们将使用单个位置参数l_T在实例上使用diff方法来对l_T进行微分。

>>> fl_T.diff(l_T)
6.787338754623378*exp(33.93669377311689*(l_T/l_T_slack - 0.995))/l_T_slack 

参考文献

[R726] (1,2)

De Groote, F., Kinney, A. L., Rao, A. V., & Fregly, B. J., 评估直接对位最优控制问题公式以解决肌肉冗余问题，生物医学工程学年鉴，44(10)，(2016) pp. 2922-2936

doit(deep=True, evaluate=True, **hints)

评估定义函数的表达式。

参数：

deep：bool

是否应递归调用doit。默认为True。

evaluate：bool。

是否应该在构造时评估 SymPy 表达式。如果为False，则不会进行任何常数折叠，这将使表达式在对应于肌腱合理操作范围的l_T_tilde值更加稳定。默认为True。

****kwargs**：dict[str, Any]

递归传递给doit的额外关键字参数对。

classmethod eval(l_T_tilde, c0, c1, c2, c3)

基本输入的评估。

参数：

l_T_tilde：Any（可符号化）

标准化腱长度。

c0：Any（可符号化）

特征方程中的第一个常数。发布值为0.2。

c1：Any（可符号化）

特征方程中的第二个常数。发布值为0.995。

c2：Any（可符号化）

特征方程中的第三个常数。发布值为0.25。

c3：Any（可符号化）

特征方程中的第四个常数。发布值为33.93669377311689。

fdiff(argindex=1)

函数关于单个参数的导数。

参数：

argindex：int

函数参数的索引，其导数应该被取得。参数索引从1开始。默认为1。

inverse(argindex=1)

逆函数。

参数：

argindex：int

开始索引参数的值。默认为1。

classmethod with_defaults(l_T_tilde)

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

参数：

l_T_tilde：Any（可符号化）

标准化腱长度。

解释

返回使用原始出版物中指定的四个常数值的腱力长度函数的新实例。

这些具有以下值：

(c_0 = 0.2) (c_1 = 0.995) (c_2 = 0.25) (c_3 = 33.93669377311689)

class sympy.physics.biomechanics.curve.TendonForceLengthInverseDeGroote2016(fl_T, c0, c1, c2, c3)

基于 De Groote 等人的逆腱力长度曲线，2016 年[R727]。

解释

给出产生特定标准化腱力的标准化腱长度。

函数由以下方程定义：

({fl^T} = frac{\log{\frac{fl^T + c_2}{c_0}}}{c_3} + c_1)

带有常量值 (c_0 = 0.2), (c_1 = 0.995), (c_2 = 0.25), 和 (c_3 = 33.93669377311689) 的函数是相关肌腱力长度曲线 TendonForceLengthDeGroote2016 的精确解析反函数。

虽然可以更改常量值，但原始出版物中精心选择这些值，以赋予特征曲线具体和所需的属性。例如，当肌腱处于无应变状态时，该函数不会产生力。当肌腱处于 5%应变状态下时，它还会产生 1 个标准单位的力。

示例

首选实例化 TendonForceLengthInverseDeGroote2016 的方法是使用 with_defaults() 构造函数，因为这会自动使用原始出版物中的浮点值填充特征曲线方程中的常数。该构造函数接受一个参数，对应于标准化的肌腱力长度，等于肌腱力。我们将创建一个称为 Symbol 的 fl_T 来表示这个值。

>>> from sympy import Symbol
>>> from sympy.physics.biomechanics import TendonForceLengthInverseDeGroote2016
>>> fl_T = Symbol('fl_T')
>>> l_T_tilde = TendonForceLengthInverseDeGroote2016.with_defaults(fl_T)
>>> l_T_tilde
TendonForceLengthInverseDeGroote2016(fl_T, 0.2, 0.995, 0.25,
33.93669377311689) 

您也可以使用自己的值填充这四个常数。

>>> from sympy import symbols
>>> c0, c1, c2, c3 = symbols('c0 c1 c2 c3')
>>> l_T_tilde = TendonForceLengthInverseDeGroote2016(fl_T, c0, c1, c2, c3)
>>> l_T_tilde
TendonForceLengthInverseDeGroote2016(fl_T, c0, c1, c2, c3) 

要检查该函数所代表的实际符号表达式，我们可以在实例上调用 doit() 方法。我们将使用关键字参数 evaluate=False，因为这将保持表达式在其规范形式中，并且不会简化任何常数。

>>> l_T_tilde.doit(evaluate=False)
c1 + log((c2 + fl_T)/c0)/c3 

该函数也可以进行微分。我们将使用单个位置参数 l_T 上的 diff 方法来进行微分。

>>> l_T_tilde.diff(fl_T)
1/(c3*(c2 + fl_T)) 

参考文献

[R727] (1,2)

De Groote, F., Kinney, A. L., Rao, A. V., & Fregly, B. J., 解决肌肉冗余问题的直接配位最优控制问题表述的评估, 生物医学工程年鉴, 44(10), (2016) pp. 2922-2936

doit(deep=True, evaluate=True, **hints)

评估定义函数的表达式。

参数：

deep : 布尔值

是否应递归调用 doit。默认为 True。

evaluate : 布尔值。

是否应在构建 SymPy 表达式时对其进行评估。如果为 False，则不会进行任何常数折叠，这将使表达式在肌腱的合理操作范围内的 l_T_tilde 值更加稳定。默认为 True。

**kwargs : dict[str, Any]

要递归传递给 doit 的附加关键字参数对。

classmethod eval(fl_T, c0, c1, c2, c3)

基本输入的评估。

参数：

fl_T : 任意值 (可以符号化)

标准化的肌腱力作为肌腱长度的函数。

c0：任意（可简化）

特征方程中的第一个常数。已发布的值为0.2。

c1：任意（可简化）

特征方程中的第二个常数。已发布的值为0.995。

c2：任意（可简化）

特征方程中的第三个常数。已发布的值为0.25。

c3：任意（可简化）

特征方程中的第四个常数。已发布的值为33.93669377311689。

fdiff(argindex=1)

函数关于单个参数的导数。

参数：

argindex：整数

函数参数的索引，对其进行导数计算。参数索引从1开始。默认为1。

inverse(argindex=1)

反函数。

参数：

argindex：整数

起始索引值，默认为1。

classmethod with_defaults(fl_T)

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

参数：

fl_T：任意（可简化）

标准化的肌腱力作为肌腱长度的函数。

解释

返回使用原始出版物中指定的四个常量值的反肌腱力长度函数的新实例。

这些值为：

(c_0 = 0.2) (c_1 = 0.995) (c_2 = 0.25) (c_3 = 33.93669377311689)

量子力学

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

量子函数

• 反对易子

• 克莱布斯-戈登系数

• 对易子

• 常数

• †

• 内积

• 张量积

态和算子

• 笛卡尔算子和态

• 希尔伯特空间

• 算子

• 算子/态辅助函数

• Qapply

• 代表

• 自旋

• 态

量子计算

• 电路图

• 门

• 格罗弗算法

• QFT

• 量子比特

• Shor 算法

解析解

• 盒中的粒子

反对易子

原文：docs.sympy.org/latest/modules/physics/quantum/anticommutator.html

反对易子：{A,B} = A*B + B*A。

class sympy.physics.quantum.anticommutator.AntiCommutator(A, B)

标准的反对易子，以未评估状态。

参数:

A : 表达式

反对易子的第一个参数 {A, B}。

B : 表达式

反对易子的第二个参数 {A, B}。

解释

评估反对易子定义为 [R749]：{A, B} = A*B + B*A。此类以未评估形式返回反对易子。要评估反对易子，请使用 .doit() 方法。

反对易子的规范顺序是 {A, B}，其中 A < B。使用 __cmp__ 将反对易子的参数放入规范顺序。如果 B < A，则返回 {A, B} 作为 {B, A}。

示例

>>> from sympy import symbols
>>> from sympy.physics.quantum import AntiCommutator
>>> from sympy.physics.quantum import Operator, Dagger
>>> x, y = symbols('x,y')
>>> A = Operator('A')
>>> B = Operator('B') 

创建一个反对易子并使用 doit() 将它们相乘。

>>> ac = AntiCommutator(A,B); ac
{A,B}
>>> ac.doit()
A*B + B*A 

交换子按照规范顺序排列其参数：

>>> ac = AntiCommutator(B,A); ac
{A,B} 

可交换的常数被因式分解出来：

>>> AntiCommutator(3*x*A,x*y*B)
3*x**2*y*{A,B} 

共轭操作应用于反对易子时应正确应用到参数上：

>>> Dagger(AntiCommutator(A,B))
{Dagger(A),Dagger(B)} 

参考文献

[R749] (1,2)

en.wikipedia.org/wiki/Commutator

doit(**hints)

评估反对易子

Clebsch-Gordan 系数

原文：docs.sympy.org/latest/modules/physics/quantum/cg.html

Clebsch-Gordan 系数。

class sympy.physics.quantum.cg.CG(j1, m1, j2, m2, j3, m3)

Clebsch-Gordan 系数类。

参数：

j1, m1, j2, m2 : 数字，符号

状态 1 和 2 的角动量。

j3, m3: 数字，符号

耦合系统的总角动量。

解释

Clebsch-Gordan 系数描述了两个系统之间的角动量耦合。这些系数给出了耦合总角动量态和未耦合张量积态的展开。Clebsch-Gordan 系数的定义如下 [R750]：

[C^{j_3,m_3}_{j_1,m_1,j_2,m_2} = \left\langle j_1,m_1;j_2,m_2 | j_3,m_3\right\rangle]

示例

定义 Clebsch-Gordan 系数并计算其值

>>> from sympy.physics.quantum.cg import CG
>>> from sympy import S
>>> cg = CG(S(3)/2, S(3)/2, S(1)/2, -S(1)/2, 1, 1)
>>> cg
CG(3/2, 3/2, 1/2, -1/2, 1, 1)
>>> cg.doit()
sqrt(3)/2
>>> CG(j1=S(1)/2, m1=-S(1)/2, j2=S(1)/2, m2=+S(1)/2, j3=1, m3=0).doit()
sqrt(2)/2 

比较 [R751]。

另请参阅

Wigner3j

Wigner-3j 符号

参考文献

[R750] (1,2)

Varshalovich, D A, 量子角动量理论。1988。

[R751] (1,2)

Clebsch-Gordan 系数，球谐函数和 d 函数，P.A. Zyla 等人（粒子数据组），Prog. Theor. Exp. Phys. 2020, 083C01 (2020)。

class sympy.physics.quantum.cg.Wigner3j(j1, m1, j2, m2, j3, m3)

Wigner-3j 符号类。

参数：

j1, m1, j2, m2, j3, m3 : 数字，符号

决定耦合角动量系统角动量的术语。

解释

Wigner 3j 符号是由两个角动量耦合确定的系数。当创建时，它们被表示为符号量，对于数值参数，可以使用.doit()方法进行评估 [R752]。

示例

声明 Wigner-3j 系数并计算其值

>>> from sympy.physics.quantum.cg import Wigner3j
>>> w3j = Wigner3j(6,0,4,0,2,0)
>>> w3j
Wigner3j(6, 0, 4, 0, 2, 0)
>>> w3j.doit()
sqrt(715)/143 

另请参阅

CG

Clebsch-Gordan 系数

参考文献

[R752] (1,2)

Varshalovich, D A, 量子角动量理论。1988。

class sympy.physics.quantum.cg.Wigner6j(j1, j2, j12, j3, j, j23)

Wigner-6j 符号类

另请参阅

Wigner3j

Wigner-3j 符号

class sympy.physics.quantum.cg.Wigner9j(j1, j2, j12, j3, j4, j34, j13, j24, j)

Wigner-9j 符号类

另请参阅

Wigner3j

Wigner-3j 符号

sympy.physics.quantum.cg.cg_simp(e)

简化和组合 CG 系数。

解释

此函数利用 Clebsch-Gordan 系数的对称性和性质来简化涉及这些术语的语句 [R753]。

示例

简化对所有 alpha 的 CG(a,alpha,0,0,a,alpha)求和

>>> from sympy.physics.quantum.cg import CG, cg_simp
>>> a = CG(1,1,0,0,1,1)
>>> b = CG(1,0,0,0,1,0)
>>> c = CG(1,-1,0,0,1,-1)
>>> cg_simp(a+b+c)
3 

另请参阅

CG

Clebsh-Gordan 系数

参考文献

[R753] (1,2)

Varshalovich, D A, 量子角动量理论。1988。

交换子

原文链接：docs.sympy.org/latest/modules/physics/quantum/commutator.html

交换子：[A,B] = AB - BA。

class sympy.physics.quantum.commutator.Commutator(A, B)

标准的交换子，处于未评估状态。

参数：

A : 表达式

交换子 [A,B] 的第一个参数。

B : 表达式

交换子 [A,B] 的第二个参数。

解释

评估一个交换子被定义为：[A, B] = A*B - B*A [R754]。这个类以未评估的形式返回交换子。要评估交换子，使用 .doit() 方法。

交换子的规范排序为 [A, B]，其中 A < B。交换子的参数使用 __cmp__ 放入规范顺序。如果 B < A，则返回 [B, A] 作为 - [A, B]。

示例

>>> from sympy.physics.quantum import Commutator, Dagger, Operator
>>> from sympy.abc import x, y
>>> A = Operator('A')
>>> B = Operator('B')
>>> C = Operator('C') 

创建一个交换子并使用 .doit() 方法来评估它：

>>> comm = Commutator(A, B)
>>> comm
[A,B]
>>> comm.doit()
A*B - B*A 

交换子按照规范顺序排序其参数：

>>> comm = Commutator(B, A); comm
-[A,B] 

交换常数被分解出来：

>>> Commutator(3*x*A, x*y*B)
3*x**2*y*[A,B] 

使用 .expand(commutator=True)，可以应用标准的交换子展开规则：

>>> Commutator(A+B, C).expand(commutator=True)
[A,C] + [B,C]
>>> Commutator(A, B+C).expand(commutator=True)
[A,B] + [A,C]
>>> Commutator(A*B, C).expand(commutator=True)
[A,C]*B + A*[B,C]
>>> Commutator(A, B*C).expand(commutator=True)
[A,B]*C + B*[A,C] 

对交换子应用伴随操作时，将正确应用于参数：

>>> Dagger(Commutator(A, B))
-[Dagger(A),Dagger(B)] 

参考

[R754] (1,2)

en.wikipedia.org/wiki/Commutator

doit(**hints)

评估交换子

常数

原文：docs.sympy.org/latest/modules/physics/quantum/constants.html

量子力学相关的常数（如 hbar）。

class sympy.physics.quantum.constants.HBar

数值和符号形式下的约化普朗克常数[R755]。

示例

>>> from sympy.physics.quantum.constants import hbar
>>> hbar.evalf()
1.05457162000000e-34 

参考文献

[R755]（1,2）

zh.wikipedia.org/wiki/普朗克常数

Dagger

原文链接：docs.sympy.org/latest/modules/physics/quantum/dagger.html

Hermite 共轭。

class sympy.physics.quantum.dagger.Dagger(arg)

一般的 Hermitian 共轭操作。

参数：

arg：Expr

我们要对其取 Dagger 的 SymPy 表达式。

evaluate：bool

是否应直接评估结果表达式。

解释

取参数的 Hermetian 共轭[R756]。对于矩阵，此操作相当于转置和复共轭[R757]。

示例

各种量子对象的 Dagger 操作：

>>> from sympy.physics.quantum.dagger import Dagger
>>> from sympy.physics.quantum.state import Ket, Bra
>>> from sympy.physics.quantum.operator import Operator
>>> Dagger(Ket('psi'))
<psi|
>>> Dagger(Bra('phi'))
|phi>
>>> Dagger(Operator('A'))
Dagger(A) 

内积和外积：

>>> from sympy.physics.quantum import InnerProduct, OuterProduct
>>> Dagger(InnerProduct(Bra('a'), Ket('b')))
<b|a>
>>> Dagger(OuterProduct(Ket('a'), Bra('b')))
|b><a| 

幂、和及积：

>>> A = Operator('A')
>>> B = Operator('B')
>>> Dagger(A*B)
Dagger(B)*Dagger(A)
>>> Dagger(A+B)
Dagger(A) + Dagger(B)
>>> Dagger(A**2)
Dagger(A)**2 

Dagger 也能无缝处理复数和矩阵：

>>> from sympy import Matrix, I
>>> m = Matrix([[1,I],[2,I]])
>>> m
Matrix([
[1, I],
[2, I]])
>>> Dagger(m)
Matrix([
[ 1,  2],
[-I, -I]]) 

参考文献

[R756] (1,2)

en.wikipedia.org/wiki/Hermitian_adjoint

[R757] (1,2)

en.wikipedia.org/wiki/Hermitian_transpose

内积

原文：docs.sympy.org/latest/modules/physics/quantum/innerproduct.html

符号内积。

class sympy.physics.quantum.innerproduct.InnerProduct(bra, ket)

Bra 和 Ket 之间的未评估内积 [1]。

参数：

bra：BraBase 或其子类

内积在内积的左侧。

ket：KetBase 或其子类

内积右侧的 Ket。

例子

创建一个 InnerProduct 并检查其属性：

>>> from sympy.physics.quantum import Bra, Ket
>>> b = Bra('b')
>>> k = Ket('k')
>>> ip = b*k
>>> ip
<b|k>
>>> ip.bra
<b|
>>> ip.ket
|k> 

在 kets 和 bras 的简单乘积中，内积将自动识别并创建：

>>> b*k
<b|k> 

但在更复杂的表达式中，内积或外积的创建存在歧义：

>>> k*b*k*b
|k><b|*|k>*<b| 

用户可以通过使用括号来分组 Bra 和 Ket 强制在复杂表达式中创建内积：

>>> k*(b*k)*b
<b|k>*|k>*<b| 

注意内积 <b|k> 移到表达式的左侧，因为内积是可交换的复数。

参考文献

[R763]

en.wikipedia.org/wiki/Inner_product

张量积。

原文链接：docs.sympy.org/latest/modules/physics/quantum/tensorproduct.html

抽象张量积。

class sympy.physics.quantum.tensorproduct.TensorProduct(*args)

两个或更多参数的张量积。

对于矩阵，这使用matrix_tensor_product来计算 Kronecker 或张量积矩阵。对于其他对象，返回一个符号的TensorProduct实例。张量积是一种非交换乘法，主要用于量子力学中的算符和态。

目前，张量积区分可交换和非可交换参数。可交换参数假定为标量，并且被拉出到TensorProduct的前面。非可交换参数保留在生成的TensorProduct中。

参数：

args：元组

一个需要进行张量积的对象序列。

示例。

从 SymPy 矩阵的简单张量积开始：

>>> from sympy import Matrix
>>> from sympy.physics.quantum import TensorProduct

>>> m1 = Matrix([[1,2],[3,4]])
>>> m2 = Matrix([[1,0],[0,1]])
>>> TensorProduct(m1, m2)
Matrix([
[1, 0, 2, 0],
[0, 1, 0, 2],
[3, 0, 4, 0],
[0, 3, 0, 4]])
>>> TensorProduct(m2, m1)
Matrix([
[1, 2, 0, 0],
[3, 4, 0, 0],
[0, 0, 1, 2],
[0, 0, 3, 4]]) 

我们还可以构建非交换符号的张量积：

>>> from sympy import Symbol
>>> A = Symbol('A',commutative=False)
>>> B = Symbol('B',commutative=False)
>>> tp = TensorProduct(A, B)
>>> tp
AxB 

我们可以对张量积进行伴随（请注意顺序不像普通乘积的伴随那样反转）：

>>> from sympy.physics.quantum import Dagger
>>> Dagger(tp)
Dagger(A)xDagger(B) 

可以使用Expand将张量积分布到加法之间：

>>> C = Symbol('C',commutative=False)
>>> tp = TensorProduct(A+B,C)
>>> tp
(A + B)xC
>>> tp.expand(tensorproduct=True)
AxC + BxC 

sympy.physics.quantum.tensorproduct.tensor_product_simp(e, **hints)

尝试简化和组合 TensorProducts。

一般来说，这将尝试将表达式拉到TensorProducts内部。目前仅适用于相对简单的情况，其中乘积仅包含标量、原始的TensorProducts，而不是Add、Pow、Commutators的TensorProducts。最好通过示例看看它的表现。

示例。

>>> from sympy.physics.quantum import tensor_product_simp
>>> from sympy.physics.quantum import TensorProduct
>>> from sympy import Symbol
>>> A = Symbol('A',commutative=False)
>>> B = Symbol('B',commutative=False)
>>> C = Symbol('C',commutative=False)
>>> D = Symbol('D',commutative=False) 

首先看看张量积乘积的情况：

>>> e = TensorProduct(A,B)*TensorProduct(C,D)
>>> e
AxB*CxD
>>> tensor_product_simp(e)
(A*C)x(B*D) 

这是该函数的核心逻辑，它适用于内部、幂、求和、对易子和反对易子：

>>> tensor_product_simp(e**2)
(A*C)x(B*D)**2 

笛卡尔算符和态

原文：docs.sympy.org/latest/modules/physics/quantum/cartesian.html

一维笛卡尔位置和动量的算符和态。

待办事项：

• 在 operatorset.py 中将 3D 类添加到映射中

class sympy.physics.quantum.cartesian.PositionBra3D(*args, **kwargs)

三维笛卡尔位置本征矢

class sympy.physics.quantum.cartesian.PositionKet3D(*args, **kwargs)

三维笛卡尔位置本征矢

class sympy.physics.quantum.cartesian.PositionState3D(*args, **kwargs)

三维笛卡尔位置本征态的基类

property position_x

状态的 x 坐标

property position_y

状态的 y 坐标

property position_z

状态的 z 坐标

class sympy.physics.quantum.cartesian.PxBra(*args, **kwargs)

一维笛卡尔动量本征矢。

property momentum

状态的动量。

class sympy.physics.quantum.cartesian.PxKet(*args, **kwargs)

一维笛卡尔动量本征矢。

property momentum

状态的动量。

class sympy.physics.quantum.cartesian.PxOp(*args, **kwargs)

一维笛卡尔动量算符。

class sympy.physics.quantum.cartesian.XBra(*args, **kwargs)

一维笛卡尔位置本征矢。

property position

状态的位置。

class sympy.physics.quantum.cartesian.XKet(*args, **kwargs)

一维笛卡尔位置本征矢。

property position

状态的位置。

class sympy.physics.quantum.cartesian.XOp(*args, **kwargs)

一维笛卡尔位置算符。

class sympy.physics.quantum.cartesian.YOp(*args, **kwargs)

Y 笛卡尔坐标算符（适用于二维或三维系统）

class sympy.physics.quantum.cartesian.ZOp(*args, **kwargs)

Z 笛卡尔坐标算符（适用于三维系统）

希尔伯特空间

原文：docs.sympy.org/latest/modules/physics/quantum/hilbert.html

量子力学的希尔伯特空间。

作者：* Brian Granger * Matt Curry

class sympy.physics.quantum.hilbert.ComplexSpace(dimension)

复数向量的有限维希尔伯特空间。

这个希尔伯特空间的元素是 n 维复值向量，具有常规内积，该内积会将右侧向量的复共轭。

这种类型希尔伯特空间的一个经典示例是自旋-1/2，即 ComplexSpace(2)。推广到自旋-s，该空间是 ComplexSpace(2*s+1)。用 N 个量子位做直积空间 ComplexSpace(2)**N。

示例

>>> from sympy import symbols
>>> from sympy.physics.quantum.hilbert import ComplexSpace
>>> c1 = ComplexSpace(2)
>>> c1
C(2)
>>> c1.dimension
2 

>>> n = symbols('n')
>>> c2 = ComplexSpace(n)
>>> c2
C(n)
>>> c2.dimension
n 

class sympy.physics.quantum.hilbert.DirectSumHilbertSpace(*args)

希尔伯特空间的直和[R758]。

这个类使用运算符 + 表示不同希尔伯特空间之间的直和。

DirectSumHilbertSpace 对象以任意数量的 HilbertSpace 对象作为其参数。此外，HilbertSpace 对象的加法将自动返回一个直和对象。

示例

>>> from sympy.physics.quantum.hilbert import ComplexSpace, FockSpace 

>>> c = ComplexSpace(2)
>>> f = FockSpace()
>>> hs = c+f
>>> hs
C(2)+F
>>> hs.dimension
oo
>>> list(hs.spaces)
[C(2), F] 

参考文献

[R758] (1,2)

zh.wikipedia.org/wiki/%E5%B8%8C%E5%B0%94%E4%BC%AF%E7%89%B9%E7%A9%BA%E9%97%B4#%E7%9B%B4%E5%92%8C

classmethod eval(args)

评估直积。

property spaces

这个直和的希尔伯特空间的元组。

class sympy.physics.quantum.hilbert.FockSpace

用于第二量子化的希尔伯特空间。

从技术上讲，这个希尔伯特空间是单粒子希尔伯特空间的无限直和直积[R759]。这是一个混乱的过程，所以我们有一个类来直接表示它。

示例

>>> from sympy.physics.quantum.hilbert import FockSpace
>>> hs = FockSpace()
>>> hs
F
>>> hs.dimension
oo 

参考文献

[R759] (1,2)

zh.wikipedia.org/wiki/%E7%A6%8F%E5%85%8B%E7%A9%BA%E9%97%B4

class sympy.physics.quantum.hilbert.HilbertSpace

量子力学的抽象希尔伯特空间。

简而言之，希尔伯特空间是一个完备的抽象向量空间，其内积由定义[R760]。

示例

>>> from sympy.physics.quantum.hilbert import HilbertSpace
>>> hs = HilbertSpace()
>>> hs
H 

参考文献

[R760] (1,2)

zh.wikipedia.org/wiki/%E5%B8%8C%E5%B0%94%E4%BC%AF%E7%89%B9%E7%A9%BA%E9%97%B4

property dimension

返回空间的希尔伯特维度。

class sympy.physics.quantum.hilbert.L2(interval)

一个在区间上具有平方可积函数的希尔伯特空间。

L2 对象接受一个 SymPy 区间参数，该参数表示其定义在上的函数（向量）的区间。

示例

>>> from sympy import Interval, oo
>>> from sympy.physics.quantum.hilbert import L2
>>> hs = L2(Interval(0,oo))
>>> hs
L2(Interval(0, oo))
>>> hs.dimension
oo
>>> hs.interval
Interval(0, oo) 

class sympy.physics.quantum.hilbert.TensorPowerHilbertSpace(*args)

指数化的希尔伯特空间[R761]。

张量幂（重复张量积）由运算符 ** 表示。相同的希尔伯特空间相乘后将自动组合为单一的张量幂对象。

任何希尔伯特空间、乘积或和都可以被提升到张量幂。TensorPowerHilbertSpace 接受两个参数：希尔伯特空间和张量幂（数字）。

示例

>>> from sympy.physics.quantum.hilbert import ComplexSpace, FockSpace
>>> from sympy import symbols 

>>> n = symbols('n')
>>> c = ComplexSpace(2)
>>> hs = c**n
>>> hs
C(2)**n
>>> hs.dimension
2**n 

>>> c = ComplexSpace(2)
>>> c*c
C(2)**2
>>> f = FockSpace()
>>> c*f*f
C(2)*F**2 

参考文献

[R761] (1,2)

zh.wikipedia.org/wiki/%E5%B8%8C%E5%B0%94%E4%BC%AF%E7%89%B9%E7%A9%BA%E9%97%B4#%E5%BC%A0%E9%87%8F%E7%A7%AF

class sympy.physics.quantum.hilbert.TensorProductHilbertSpace(*args)

希尔伯特空间的张量积[R762]。

希尔伯特空间之间的张量积由运算符 * 表示，同一希尔伯特空间的乘积将被合并为张量幂。

TensorProductHilbertSpace 对象将任意数量的 HilbertSpace 对象作为其参数。此外，HilbertSpace 对象的乘法将自动返回此张量积对象。

示例

>>> from sympy.physics.quantum.hilbert import ComplexSpace, FockSpace
>>> from sympy import symbols 

>>> c = ComplexSpace(2)
>>> f = FockSpace()
>>> hs = c*f
>>> hs
C(2)*F
>>> hs.dimension
oo
>>> hs.spaces
(C(2), F) 

>>> c1 = ComplexSpace(2)
>>> n = symbols('n')
>>> c2 = ComplexSpace(n)
>>> hs = c1*c2
>>> hs
C(2)*C(n)
>>> hs.dimension
2*n 

参考文献

[R762] (1,2)

en.wikipedia.org/wiki/Hilbert_space#Tensor_products

classmethod eval(args)

评估直积。

property spaces

这个张量积中的 Hilbert 空间的元组。

算符

原文：docs.sympy.org/latest/modules/physics/quantum/operator.html

量子力学算符。

待办事项：

• 修复早期在 apply_operators 中的 0。

• 调试和测试 apply_operators。

• 使此文件中的类与 CSE 协同工作。

• InnerProduct、Commutator、AntiCommutator、represent、apply_operators 的 doctest 和特殊方法的文档。

class sympy.physics.quantum.operator.DifferentialOperator(*args, **kwargs)

用于表示微分算符的算符，即 d/dx

通过传递两个参数来初始化它。第一个是涉及函数的任意表达式，例如 Derivative(f(x), x)。第二个是我们将其替换为该 DifferentialOperator 应用的 Wavefunction 的函数（例如 f(x)）。

参数：

expr：表达式

适合将适当的波函数替换为的任意表达式

func：表达式

一个函数（例如 f(x)），在应用此微分算符时应替换为适当的波函数

示例

您可以定义完全任意的表达式，并指定在哪里应替换波函数。

>>> from sympy import Derivative, Function, Symbol
>>> from sympy.physics.quantum.operator import DifferentialOperator
>>> from sympy.physics.quantum.state import Wavefunction
>>> from sympy.physics.quantum.qapply import qapply
>>> f = Function('f')
>>> x = Symbol('x')
>>> d = DifferentialOperator(1/x*Derivative(f(x), x), f(x))
>>> w = Wavefunction(x**2, x)
>>> d.function
f(x)
>>> d.variables
(x,)
>>> qapply(d*w)
Wavefunction(2, x) 

property expr

返回要将波函数替换为其中的任意表达式

示例

>>> from sympy.physics.quantum.operator import DifferentialOperator
>>> from sympy import Function, Symbol, Derivative
>>> x = Symbol('x')
>>> f = Function('f')
>>> d = DifferentialOperator(Derivative(f(x), x), f(x))
>>> d.expr
Derivative(f(x), x)
>>> y = Symbol('y')
>>> d = DifferentialOperator(Derivative(f(x, y), x) +
...                          Derivative(f(x, y), y), f(x, y))
>>> d.expr
Derivative(f(x, y), x) + Derivative(f(x, y), y) 

property free_symbols

返回表达式的自由符号。

property function

返回要替换为波函数的函数

示例

>>> from sympy.physics.quantum.operator import DifferentialOperator
>>> from sympy import Function, Symbol, Derivative
>>> x = Symbol('x')
>>> f = Function('f')
>>> d = DifferentialOperator(Derivative(f(x), x), f(x))
>>> d.function
f(x)
>>> y = Symbol('y')
>>> d = DifferentialOperator(Derivative(f(x, y), x) +
...                          Derivative(f(x, y), y), f(x, y))
>>> d.function
f(x, y) 

property variables

返回评估指定任意表达式中函数的变量

示例

>>> from sympy.physics.quantum.operator import DifferentialOperator
>>> from sympy import Symbol, Function, Derivative
>>> x = Symbol('x')
>>> f = Function('f')
>>> d = DifferentialOperator(1/x*Derivative(f(x), x), f(x))
>>> d.variables
(x,)
>>> y = Symbol('y')
>>> d = DifferentialOperator(Derivative(f(x, y), x) +
...                          Derivative(f(x, y), y), f(x, y))
>>> d.variables
(x, y) 

class sympy.physics.quantum.operator.HermitianOperator(*args, **kwargs)

一个满足 H == Dagger(H) 的厄米算符。

参数：

args：元组

列出唯一指定算符的数字或参数。对于时间相关算符，这将包括时间。

示例

>>> from sympy.physics.quantum import Dagger, HermitianOperator
>>> H = HermitianOperator('H')
>>> Dagger(H)
H 

class sympy.physics.quantum.operator.IdentityOperator(*args, **kwargs)

一个满足任何算符 op 的单位算符 I，使得 op * I == I * op == op。

参数：

N：整数

操作符的希尔伯特空间的维度的可选参数。在生成矩阵表示时使用。

示例

>>> from sympy.physics.quantum import IdentityOperator
>>> IdentityOperator()
I 

class sympy.physics.quantum.operator.Operator(*args, **kwargs)

用于非对易量子算符的基类。

一个算符，用于映射量子态[R764]。在量子力学中，可观察量（包括但不限于测量的物理值）表示为厄米算符[R765]。

参数：

args：元组

列出唯一指定算符的数字或参数。对于时间相关算符，这将包括时间。

示例

创建一个算符并检查其属性：

>>> from sympy.physics.quantum import Operator
>>> from sympy import I
>>> A = Operator('A')
>>> A
A
>>> A.hilbert_space
H
>>> A.label
(A,)
>>> A.is_commutative
False 

创建另一个算符并进行一些算术操作：

>>> B = Operator('B')
>>> C = 2*A*A + I*B
>>> C
2*A**2 + I*B 

算符不对易：

>>> A.is_commutative
False
>>> B.is_commutative
False
>>> A*B == B*A
False 

算符的多项式尊重交换性质：

>>> e = (A+B)**3
>>> e.expand()
A*B*A + A*B**2 + A**2*B + A**3 + B*A*B + B*A**2 + B**2*A + B**3 

算符逆被符号化处理：

>>> A.inv()
A**(-1)
>>> A*A.inv()
1 

参考文献

[R764] (1,2)

zh.wikipedia.org/wiki/算子 _(物理学)

[R765] (1,2)

zh.wikipedia.org/wiki/可观察算子

class sympy.physics.quantum.operator.OuterProduct(*args, **old_assumptions)

一个未评估的外积，介于 ket 和 bra 之间。

这构造了任何KetBase子类和BraBase之间的外积，如 |a><b|。OuterProduct从 Operator 继承，因为它们在量子表达式中充当操作符。有关详细信息，请参见[R766]。

参数：

ket : KetBase

左侧的外积的 ket。

bar : BraBase

右侧的外积的 bra。

示例

手动创建一个简单的外积并取其伴随：

>>> from sympy.physics.quantum import Ket, Bra, OuterProduct, Dagger
>>> from sympy.physics.quantum import Operator

>>> k = Ket('k')
>>> b = Bra('b')
>>> op = OuterProduct(k, b)
>>> op
|k><b|
>>> op.hilbert_space
H
>>> op.ket
|k>
>>> op.bra
<b|
>>> Dagger(op)
|b><k| 

在 ket 和 bra 的简单乘积中，外积将被自动识别和创建：

>>> k*b
|k><b| 

但在更复杂的表达式中，外积不会自动创建：

>>> A = Operator('A')
>>> A*k*b
A*|k>*<b| 

用户可以通过使用括号来组合 ket 和 bra，在复杂表达式中强制创建外积：

>>> A*(k*b)
A*|k><b| 

参考文献

[R766] (1,2)

en.wikipedia.org/wiki/Outer_product

property bra

返回外积右侧的 bra。

property ket

返回外积的左侧的 ket。

class sympy.physics.quantum.operator.UnitaryOperator(*args, **kwargs)

满足 U*Dagger(U) == 1 的酉算子。

参数：

args : tuple

一组唯一指定运算符的数字或参数列表。对于时变算符，这将包括时间。

示例

>>> from sympy.physics.quantum import Dagger, UnitaryOperator
>>> U = UnitaryOperator('U')
>>> U*Dagger(U)
1 

算符/状态辅助函数

原文：docs.sympy.org/latest/modules/physics/quantum/operatorset.html

一个模块，用于将算符映射到其相应的本征态，反之亦然

它包含一个全局字典，其中包含本征态-算符的配对关系。如果创建了新的状态-算符对，则还应更新此字典。

它还包含函数 operators_to_state 和 state_to_operators，用于在算符和状态之间进行映射。这些函数可以处理算符和状态的类和实例。有关详细信息，请参见各个函数描述。

TODO 列表：- 更新包含状态-算符对完整列表的字典

sympy.physics.quantum.operatorset.operators_to_state(operators, **options)

返回给定算符或算符集的本征态。

一个全局函数，用于将算符类映射到其关联的状态。它接受算符或算符集，并返回与这些算符关联的状态。

此函数可以处理给定算符的实例或仅类本身（即 XOp()和 XOp 都可以）

需要考虑多个用例：

1. 传递类或类集：首先，我们尝试为这些算符实例化默认实例。如果失败，则简单返回类。如果成功实例化默认实例，则尝试在算符实例上调用 state._operators_to_state。如果失败，则返回类。否则，返回 _operators_to_state 返回的实例。

2. 传递实例或实例集：在这种情况下，对传递的实例调用 state._operators_to_state。如果失败，则返回状态类。如果方法返回实例，则返回该实例。

在这两种情况下，如果状态映射字典中不存在算符类或集合，则返回 None。

参数：

arg: 算符或集合

算符或算符集的类或实例要映射到状态

示例

>>> from sympy.physics.quantum.cartesian import XOp, PxOp
>>> from sympy.physics.quantum.operatorset import operators_to_state
>>> from sympy.physics.quantum.operator import Operator
>>> operators_to_state(XOp)
|x>
>>> operators_to_state(XOp())
|x>
>>> operators_to_state(PxOp)
|px>
>>> operators_to_state(PxOp())
|px>
>>> operators_to_state(Operator)
|psi>
>>> operators_to_state(Operator())
|psi> 

sympy.physics.quantum.operatorset.state_to_operators(state, **options)

返回给定本征态对应的算符或算符集

一个全局函数，用于将状态类映射到其关联的算符或算符集。它接受状态类或实例。

此函数可以处理给定状态的实例或仅类本身（即 XKet()和 XKet 都可以）。

需要考虑多个用例：

1. 传递状态类：在这种情况下，首先尝试实例化类的默认实例。如果成功，则尝试在该实例上调用 state._state_to_operators。如果创建默认实例或调用 _state_to_operators 失败，则返回算符类或算符类集。否则，返回适当的算符实例。

2. 返回状态实例：在这里，对实例调用 state._state_to_operators。如果失败，则返回类或算符类集。否则，返回实例。

无论哪种情况，如果状态的类在 state_mapping 中不存在，则返回 None。

参数：

arg: StateBase 类或实例（或其子类）

要映射到操作符或一组操作符的状态的类或实例

示例

>>> from sympy.physics.quantum.cartesian import XKet, PxKet, XBra, PxBra
>>> from sympy.physics.quantum.operatorset import state_to_operators
>>> from sympy.physics.quantum.state import Ket, Bra
>>> state_to_operators(XKet)
X
>>> state_to_operators(XKet())
X
>>> state_to_operators(PxKet)
Px
>>> state_to_operators(PxKet())
Px
>>> state_to_operators(PxBra)
Px
>>> state_to_operators(XBra)
X
>>> state_to_operators(Ket)
O
>>> state_to_operators(Bra)
O 

Qapply

原文：docs.sympy.org/latest/modules/physics/quantum/qapply.html

逻辑应用于状态操作符。

待办事项：*有时最终结果需要展开，我们应该手动执行此操作。

sympy.physics.quantum.qapply.qapply(e, **options)

在量子表达式中应用状态操作符。

参数：

e：表达式

包含操作符和状态的表达式。该表达式树将以符号方式查找操作符作用于状态。

options：字典

一组键值对，确定如何执行操作符的操作。

以下选项有效：

• dagger：尝试将 Dagger 操作符应用于左侧（默认为 False）。
• ip_doit：遇到内积时调用.doit()（默认为 True）。

返回：

e：表达式

将操作符应用于状态的原始表达式。

例子

>>> from sympy.physics.quantum import qapply, Ket, Bra
>>> b = Bra('b')
>>> k = Ket('k')
>>> A = k * b
>>> A
|k><b|
>>> qapply(A * b.dual / (b * b.dual))
|k>
>>> qapply(k.dual * A / (k.dual * k), dagger=True)
<b|
>>> qapply(k.dual * A / (k.dual * k))
<k|*|k><b|/<k|k> 

表示

原文链接：docs.sympy.org/latest/modules/physics/quantum/represent.html

用于在各种基底中表示状态操作符的逻辑。

TODO:

• 获得与连续希尔伯特空间一起工作的表示工作。

• 文档默认基础功能。

sympy.physics.quantum.represent.enumerate_states(*args, **options)

返回附加了虚指数的给定状态的实例

在两种不同的模式下运行：

1. 传递了两个参数。第一个是要索引的基态，第二个参数是要附加的索引列表。

2. 传递了三个参数。第一个再次是要索引的基态。第二个是计数的起始索引。最后一个参数是您希望接收的 ket 的数量。

尝试调用 state._enumerate_state。如果失败，则返回一个空列表

参数：

args : 列表

查看上面的操作模式列表以获取解释

示例

>>> from sympy.physics.quantum.cartesian import XBra, XKet
>>> from sympy.physics.quantum.represent import enumerate_states
>>> test = XKet('foo')
>>> enumerate_states(test, 1, 3)
[|foo_1>, |foo_2>, |foo_3>]
>>> test2 = XBra('bar')
>>> enumerate_states(test2, [4, 5, 10])
[<bar_4|, <bar_5|, <bar_10|] 

sympy.physics.quantum.represent.get_basis(expr, *, basis=None, replace_none=True, **options)

返回与 options=s 中指定的基础相对应的基态实例。如果未指定基础，则函数尝试形成给定表达式的默认基态。

有三种行为：

1. 在选项中指定的基础已经是 StateBase 的实例。如果是这种情况，则简单地返回。如果指定了类但不是实例，则返回默认实例。

2. 指定的基础是操作符或一组操作符。如果是这种情况，则使用 operator_to_state 映射方法。

3. 没有指定基底。如果 expr 是一个状态，则返回其类的默认实例。如果 expr 是一个操作符，则将其映射到相应的状态。如果它既不是，则无法获得基态。

如果无法映射基础，则不会更改。

这将从 represent 内部调用，并且 represent 将只传递 QExpr。

TODO (?): 支持 Muls 和其他类型的表达式？

参数：

expr : 操作符或 StateBase

寻求其基底的表达式

示例

>>> from sympy.physics.quantum.represent import get_basis
>>> from sympy.physics.quantum.cartesian import XOp, XKet, PxOp, PxKet
>>> x = XKet()
>>> X = XOp()
>>> get_basis(x)
|x>
>>> get_basis(X)
|x>
>>> get_basis(x, basis=PxOp())
|px>
>>> get_basis(x, basis=PxKet)
|px> 

sympy.physics.quantum.represent.integrate_result(orig_expr, result, **options)

返回在给定表达式中积分任何 unities (|x><x|) 的结果。用于在连续基底中积分表示的结果。

此函数在量子表达式中插入任何 unities 后进行积分并返回结果。它使用传递给它的基态的希尔伯特空间的区间来确定积分的限制。必须为此指定 unities 选项才能工作。

注意：这主要是由 represent()在内部使用。示例仅用于展示用例。

参数：

orig_expr : 量子表达式

最初要表示的表达式

result: Expr

我们希望对其进行积分的结果表示

示例

>>> from sympy import symbols, DiracDelta
>>> from sympy.physics.quantum.represent import integrate_result
>>> from sympy.physics.quantum.cartesian import XOp, XKet
>>> x_ket = XKet()
>>> X_op = XOp()
>>> x, x_1, x_2 = symbols('x, x_1, x_2')
>>> integrate_result(X_op*x_ket, x*DiracDelta(x-x_1)*DiracDelta(x_1-x_2))
x*DiracDelta(x - x_1)*DiracDelta(x_1 - x_2)
>>> integrate_result(X_op*x_ket, x*DiracDelta(x-x_1)*DiracDelta(x_1-x_2),
...     unities=[1])
x*DiracDelta(x - x_2) 

sympy.physics.quantum.represent.rep_expectation(expr, **options)

返回给定操作符的 <x'|A|x> 类型表示。

参数：

expr : 操作符

要在指定基础上表示的操作符

示例

>>> from sympy.physics.quantum.cartesian import XOp, PxOp, PxKet
>>> from sympy.physics.quantum.represent import rep_expectation
>>> rep_expectation(XOp())
x_1*DiracDelta(x_1 - x_2)
>>> rep_expectation(XOp(), basis=PxOp())
<px_2|*X*|px_1>
>>> rep_expectation(XOp(), basis=PxKet())
<px_2|*X*|px_1> 

sympy.physics.quantum.represent.rep_innerproduct(expr, **options)

返回给定状态的内积表示（例如 <x'|x>）。

尝试计算与来自指定基组的 bra 的内积。只应传递 KetBase 或 BraBase 的实例。

参数：

expr：KetBase 或 BraBase

要表示的表达式

示例

>>> from sympy.physics.quantum.represent import rep_innerproduct
>>> from sympy.physics.quantum.cartesian import XOp, XKet, PxOp, PxKet
>>> rep_innerproduct(XKet())
DiracDelta(x - x_1)
>>> rep_innerproduct(XKet(), basis=PxOp())
sqrt(2)*exp(-I*px_1*x/hbar)/(2*sqrt(hbar)*sqrt(pi))
>>> rep_innerproduct(PxKet(), basis=XOp())
sqrt(2)*exp(I*px*x_1/hbar)/(2*sqrt(hbar)*sqrt(pi)) 

sympy.physics.quantum.represent.represent(expr, **options)

在给定基组中表示量子表达式。

在量子力学中，抽象状态和算符可以在各种基组中表示。在此操作下，发生以下转换：

• Ket -> 列向量或函数

• Bra -> 行向量或函数

• Operator -> 矩阵或微分算符

此函数是此操作的顶级接口。

此函数遍历 SymPy 表达式树，查找具有 _represent 方法的 QExpr 实例。然后调用此方法，并用此方法返回的表示形式替换对象。默认情况下，_represent 方法将分派到处理特定基组表示逻辑的其他方法。这些方法的命名约定如下：

def _represent_FooBasis(self, e, basis, **options) 

此函数将具有在名为 FooBasis 的类中具有基组集的类的实例的表示逻辑。

参数：

expr：Expr

要表示的表达式。

basis：Operator，基组集

包含有关基组的信息的对象。如果使用操作符，则假定基组是该操作符的标准正交特征向量。尽管如此，基组参数通常可以是包含基组信息的任何对象。

options：dict

传递给找到表示形式的基础方法的选项的键/值对。可以使用这些选项来控制如何进行表示。例如，这里可以设置基组大小。

返回：

e：Expr

表示的量子表达式的 SymPy 表达式。

示例

在这里，我们子类化 Operator 和 Ket 来创建 z 自旋算符及其自旋 1/2 上的本征态。通过定义 _represent_SzOp 方法，可以在 z 自旋基组中表示这个 ket。

>>> from sympy.physics.quantum import Operator, represent, Ket
>>> from sympy import Matrix 

>>> class SzUpKet(Ket):
...     def _represent_SzOp(self, basis, **options):
...         return Matrix([1,0])
...
>>> class SzOp(Operator):
...     pass
...
>>> sz = SzOp('Sz')
>>> up = SzUpKet('up')
>>> represent(up, basis=sz)
Matrix([
[1],
[0]]) 

在这里，我们看到在连续基组中的表示示例。我们看到代表笛卡尔位置算符和 ket 的各种组合的结果，给出了涉及 DiracDelta 函数的连续表达式。

>>> from sympy.physics.quantum.cartesian import XOp, XKet, XBra
>>> X = XOp()
>>> x = XKet()
>>> y = XBra('y')
>>> represent(X*x)
x*DiracDelta(x - x_2)
>>> represent(X*x*y)
x*DiracDelta(x - x_3)*DiracDelta(x_1 - y) 

自旋

原文链接：docs.sympy.org/latest/modules/physics/quantum/spin.html

量子力学角动量。

class sympy.physics.quantum.spin.J2Op(*args, **kwargs)

J² 操作符。

class sympy.physics.quantum.spin.JxBra(j, m)

Jx 的本征 bra。

查看 JzKet 以了解自旋特征态的使用。

另请参见

JzKet

自旋态的使用

class sympy.physics.quantum.spin.JxBraCoupled(j, m, jn, *jcoupling)

Jx 的耦合本征 bra。

查看 JzKetCoupled 以了解耦合自旋特征态的使用。

另请参见

JzKetCoupled

耦合自旋态的使用

class sympy.physics.quantum.spin.JxKet(j, m)

Jx 的本征 ket。

查看 JzKet 以了解自旋特征态的使用。

另请参见

JzKet

自旋态的使用

class sympy.physics.quantum.spin.JxKetCoupled(j, m, jn, *jcoupling)

Jx 的耦合本征 ket。

查看 JzKetCoupled 以了解耦合自旋特征态的使用。

另请参见

JzKetCoupled

耦合自旋态的使用

class sympy.physics.quantum.spin.JyBra(j, m)

Jy 的本征 bra。

查看 JzKet 以了解自旋特征态的使用。

另请参见

JzKet

自旋态的使用

class sympy.physics.quantum.spin.JyBraCoupled(j, m, jn, *jcoupling)

Jy 的耦合本征 bra。

查看 JzKetCoupled 以了解耦合自旋特征态的使用。

另请参见

JzKetCoupled

耦合自旋态的使用

class sympy.physics.quantum.spin.JyKet(j, m)

Jy 的本征 ket。

查看 JzKet 以了解自旋特征态的使用。

另请参见

JzKet

自旋态的使用

class sympy.physics.quantum.spin.JyKetCoupled(j, m, jn, *jcoupling)

Jy 的耦合特征态。

查看 JzKetCoupled 以了解耦合自旋特征态的使用。

另请参见

JzKetCoupled

耦合自旋态的使用

class sympy.physics.quantum.spin.JzBra(j, m)

Jz 的本征 bra。

查看 JzKet 以了解自旋特征态的使用。

另请参见

JzKet

自旋态的使用

class sympy.physics.quantum.spin.JzBraCoupled(j, m, jn, *jcoupling)

Jz 的耦合本征 bra。

查看 JzKetCoupled 以了解耦合自旋特征态的使用。

另请参见

JzKetCoupled

耦合自旋态的使用

class sympy.physics.quantum.spin.JzKet(j, m)

Jz 的本征 ket。

是 Jz 算符的本征态的自旋态。未耦合态，即表示多个独立自旋态相互作用的状态，被定义为状态的张量积。

参数：

j：数字，符号

总自旋角动量

m：数字，符号

Jz 自旋算符的本征值

示例

正常状态：

定义简单自旋态，包括数值和符号：

>>> from sympy.physics.quantum.spin import JzKet, JxKet
>>> from sympy import symbols
>>> JzKet(1, 0)
|1,0>
>>> j, m = symbols('j m')
>>> JzKet(j, m)
|j,m> 

将 JzKet 重新写成 Jx 算符的本征 ket：注意：结果的本征态是 JxKet's

>>> JzKet(1,1).rewrite("Jx")
|1,-1>/2 - sqrt(2)*|1,0>/2 + |1,1>/2 

获取状态的矢量表示，用 Jx 算符的基元素表示：

>>> from sympy.physics.quantum.represent import represent
>>> from sympy.physics.quantum.spin import Jx, Jz
>>> represent(JzKet(1,-1), basis=Jx)
Matrix([
[      1/2],
[sqrt(2)/2],
[      1/2]]) 

在状态之间应用内积：

>>> from sympy.physics.quantum.innerproduct import InnerProduct
>>> from sympy.physics.quantum.spin import JxBra
>>> i = InnerProduct(JxBra(1,1), JzKet(1,1))
>>> i
<1,1|1,1>
>>> i.doit()
1/2 

未耦合态：

将未耦合态定义为两个 Jz 特征态之间的张量积：

>>> from sympy.physics.quantum.tensorproduct import TensorProduct
>>> j1,m1,j2,m2 = symbols('j1 m1 j2 m2')
>>> TensorProduct(JzKet(1,0), JzKet(1,1))
|1,0>x|1,1>
>>> TensorProduct(JzKet(j1,m1), JzKet(j2,m2))
|j1,m1>x|j2,m2> 

TensorProduct 可以被重写，此时组成张量积的本征态将被重写为新的基础：

>>> TensorProduct(JzKet(1,1),JxKet(1,1)).rewrite('Jz')
|1,1>x|1,-1>/2 + sqrt(2)*|1,1>x|1,0>/2 + |1,1>x|1,1>/2 

TensorProduct 的 represent 方法给出状态的向量表示。请注意，产品基础中的状态相当于组分本征态的张量积：

>>> represent(TensorProduct(JzKet(1,0),JzKet(1,1)))
Matrix([
[0],
[0],
[0],
[1],
[0],
[0],
[0],
[0],
[0]])
>>> represent(TensorProduct(JzKet(1,1),JxKet(1,1)), basis=Jz)
Matrix([
[      1/2],
[sqrt(2)/2],
[      1/2],
[        0],
[        0],
[        0],
[        0],
[        0],
[        0]]) 

另请参阅

JzKetCoupled

耦合的本征态

sympy.physics.quantum.tensorproduct.TensorProduct

用于指定未耦合的状态

uncouple

给定耦合参数，取消耦合状态

couple

耦合未耦合的状态

class sympy.physics.quantum.spin.JzKetCoupled(j, m, jn, *jcoupling)

Jz 的耦合本征态

表示 Jz 的本征态，表示单独旋转空间的耦合。

创建JzKetCoupled实例的参数是j、m、jn以及可选的jcoupling参数。j和m选项是总角动量量子数，如用于普通状态（例如 JzKet）。

jn中的另一个必需参数是一个元组，定义了乘积空间的(j_n)角动量量子数。例如，如果一个状态表示耦合产品基态(\left|j_1,m_1\right\rangle\times\left|j_2,m_2\right\rangle)，那么这个状态的jn将是(j1,j2)。

最后一个选项是jcoupling，用于定义由jn指定的空间如何耦合，包括耦合这些空间的顺序和由此耦合产生的量子数。jcoupling参数本身是一个列表，其中每个子列表定义了旋转空间之间的单个耦合。如果有 N 个耦合的角动量空间，即jn有 N 个元素，则必须有 N-1 个子列表。组成jcoupling参数的每个子列表长度为 3。前两个元素是被认为耦合在一起的乘积空间的索引。例如，如果我们想要耦合(j_1)和(j_4)，那么索引将是 1 和 4。如果一个状态已经被耦合，则通过耦合其最小的索引来引用它，因此如果(j_2)和(j_4)已经被耦合到某个(j_{24})，则可以通过索引 2 耦合这个值。子列表的最后一个元素是耦合态的量子数。因此，将所有内容放入jcoupling的有效子列表中，如果(j_1)和(j_2)与量子数(j_{12})的角动量空间耦合，则子列表将是(1,2,j12)，在jcoupling的列表中使用 N-1 个这些子列表。

注意 jcoupling 参数是可选的，如果未指定，则采用默认耦合。默认值是按顺序耦合空间，并将耦合的量子数取为最大值。例如，如果自旋空间是 (j_1)，(j_2)，(j_3)，(j_4)，则默认耦合会将 (j_1) 和 (j_2) 耦合到 (j_{12}=j_1+j_2)，然后将 (j_{12}) 和 (j_3) 耦合到 (j_{123}=j_{12}+j_3)，最后将 (j_{123}) 和 (j_4) 耦合到 (j=j_{123}+j_4)。对应的 jcoupling 值如下：

((1,2,j1+j2),(1,3,j1+j2+j3))

参数：

args：tuple

必须传递的参数包括 j，m，jn 和 jcoupling。j 值是总角动量。m 值是 Jz 自旋算符的特征值。jn 列表是耦合在一起的角动量空间的 j 值。jcoupling 参数是一个可选参数，定义空间如何耦合在一起。查看上述描述以了解这些耦合参数的定义。

示例

定义简单的自旋态，包括数值和符号：

>>> from sympy.physics.quantum.spin import JzKetCoupled
>>> from sympy import symbols
>>> JzKetCoupled(1, 0, (1, 1))
|1,0,j1=1,j2=1>
>>> j, m, j1, j2 = symbols('j m j1 j2')
>>> JzKetCoupled(j, m, (j1, j2))
|j,m,j1=j1,j2=j2> 

定义超过 2 个耦合空间的耦合自旋态，具有各种耦合参数：

>>> JzKetCoupled(2, 1, (1, 1, 1))
|2,1,j1=1,j2=1,j3=1,j(1,2)=2>
>>> JzKetCoupled(2, 1, (1, 1, 1), ((1,2,2),(1,3,2)) )
|2,1,j1=1,j2=1,j3=1,j(1,2)=2>
>>> JzKetCoupled(2, 1, (1, 1, 1), ((2,3,1),(1,2,2)) )
|2,1,j1=1,j2=1,j3=1,j(2,3)=1> 

将 JzKetCoupled 重写为 Jx 算符的本征态：注意：结果的本征态是 JxKetCoupled

>>> JzKetCoupled(1,1,(1,1)).rewrite("Jx")
|1,-1,j1=1,j2=1>/2 - sqrt(2)*|1,0,j1=1,j2=1>/2 + |1,1,j1=1,j2=1>/2 

重写方法可以用于将耦合态转换为非耦合态。通过向 rewrite 函数传递 coupled=False 来实现：

>>> JzKetCoupled(1, 0, (1, 1)).rewrite('Jz', coupled=False)
-sqrt(2)*|1,-1>x|1,1>/2 + sqrt(2)*|1,1>x|1,-1>/2 

用 Jx 算符的基本元素的基础上获取一个状态的向量表示：

>>> from sympy.physics.quantum.represent import represent
>>> from sympy.physics.quantum.spin import Jx
>>> from sympy import S
>>> represent(JzKetCoupled(1,-1,(S(1)/2,S(1)/2)), basis=Jx)
Matrix([
[        0],
[      1/2],
[sqrt(2)/2],
[      1/2]]) 

另见

JzKet

正常的自旋本征态

uncouple

耦合耦合自旋态

couple

耦合未耦合的自旋态

class sympy.physics.quantum.spin.JzOp(*args, **kwargs)

Jz 算符。

class sympy.physics.quantum.spin.Rotation(*args, **kwargs)

用欧拉角表示的 Wigner D 算符。

用 z-y-z 惯例定义的欧拉角旋转算符，用于被动变换。即首先围绕 z 轴旋转坐标轴，得到新的 x’-y’-z’ 坐标系。然后围绕新的 y’ 轴旋转这个新的坐标系，得到新的 x’’-y’’-z’’ 坐标系。最后围绕 z’’ 轴旋转这个新的坐标系。符号遵循 [R767] 中列出的惯例。

参数：

alpha：Number, Symbol

第一个欧拉角

beta：Number, Symbol

第二个欧拉角

gamma：Number, Symbol

第三个欧拉角

示例

一个简单的示例旋转算符：

>>> from sympy import pi
>>> from sympy.physics.quantum.spin import Rotation
>>> Rotation(pi, 0, pi/2)
R(pi,0,pi/2) 

使用符号欧拉角计算逆旋转算符：

>>> from sympy import symbols
>>> a, b, c = symbols('a b c')
>>> Rotation(a, b, c)
R(a,b,c)
>>> Rotation(a, b, c).inverse()
R(-c,-b,-a) 

另见

WignerD

符号 Wigner-D 函数

D

Wigner-D 函数

d

Wigner 小 d 函数

References

[R767] (1,2)

Varshalovich, D A, Quantum Theory of Angular Momentum. 1988.

classmethod D(j, m, mp, alpha, beta, gamma)

Wigner D-function.

Returns an instance of the WignerD class corresponding to the Wigner-D function specified by the parameters.

Parameters:

j : Number

Total angular momentum

m : Number

Eigenvalue of angular momentum along axis after rotation

mp : Number

Eigenvalue of angular momentum along rotated axis

alpha : Number, Symbol

First Euler angle of rotation

beta : Number, Symbol

Second Euler angle of rotation

gamma : Number, Symbol

Third Euler angle of rotation

Examples

Return the Wigner-D matrix element for a defined rotation, both numerical and symbolic:

>>> from sympy.physics.quantum.spin import Rotation
>>> from sympy import pi, symbols
>>> alpha, beta, gamma = symbols('alpha beta gamma')
>>> Rotation.D(1, 1, 0,pi, pi/2,-pi)
WignerD(1, 1, 0, pi, pi/2, -pi) 

See also

WignerD

Symbolic Wigner-D function

classmethod d(j, m, mp, beta)

Wigner small-d function.

Returns an instance of the WignerD class corresponding to the Wigner-D function specified by the parameters with the alpha and gamma angles given as 0.

Parameters:

j : Number

Total angular momentum

m : Number

Eigenvalue of angular momentum along axis after rotation

mp : Number

Eigenvalue of angular momentum along rotated axis

beta : Number, Symbol

Second Euler angle of rotation

Examples

Return the Wigner-D matrix element for a defined rotation, both numerical and symbolic:

>>> from sympy.physics.quantum.spin import Rotation
>>> from sympy import pi, symbols
>>> beta = symbols('beta')
>>> Rotation.d(1, 1, 0, pi/2)
WignerD(1, 1, 0, 0, pi/2, 0) 

See also

WignerD

Symbolic Wigner-D function

class sympy.physics.quantum.spin.WignerD(*args, **hints)

Wigner-D function

The Wigner D-function gives the matrix elements of the rotation operator in the jm-representation. For the Euler angles (\alpha), (\beta), (\gamma), the D-function is defined such that:

[<j,m| \mathcal{R}(\alpha, \beta, \gamma ) |j',m'> = \delta_{jj'} D(j, m, m', \alpha, \beta, \gamma)]

Where the rotation operator is as defined by the Rotation class [R768].

The Wigner D-function defined in this way gives:

[D(j, m, m', \alpha, \beta, \gamma) = e^{-i m \alpha} d(j, m, m', \beta) e^{-i m' \gamma}]

Where d is the Wigner small-d function, which is given by Rotation.d.

The Wigner small-d function gives the component of the Wigner D-function that is determined by the second Euler angle. That is the Wigner D-function is:

[D(j, m, m', \alpha, \beta, \gamma) = e^{-i m \alpha} d(j, m, m', \beta) e^{-i m' \gamma}]

Where d is the small-d function. The Wigner D-function is given by Rotation.D.

Note that to evaluate the D-function, the j, m and mp parameters must be integer or half integer numbers.

Parameters:

j : Number

Total angular momentum

m : Number

Eigenvalue of angular momentum along axis after rotation

mp : Number

Eigenvalue of angular momentum along rotated axis

alpha : Number, Symbol

First Euler angle of rotation

beta : Number, Symbol

Second Euler angle of rotation

gamma : Number, Symbol

Third Euler angle of rotation

Examples

Evaluate the Wigner-D matrix elements of a simple rotation:

>>> from sympy.physics.quantum.spin import Rotation
>>> from sympy import pi
>>> rot = Rotation.D(1, 1, 0, pi, pi/2, 0)
>>> rot
WignerD(1, 1, 0, pi, pi/2, 0)
>>> rot.doit()
sqrt(2)/2 

Evaluate the Wigner-d matrix elements of a simple rotation

>>> rot = Rotation.d(1, 1, 0, pi/2)
>>> rot
WignerD(1, 1, 0, 0, pi/2, 0)
>>> rot.doit()
-sqrt(2)/2 

See also

旋转

旋转算子

参考文献

[R768] (1,2)

Varshalovich, D A, Angular Momentum 的量子理论。 1988 年。

sympy.physics.quantum.spin.couple(expr, jcoupling_list=None)

耦合自旋态的张量积

此函数可用于耦合自旋态的非耦合张量积。要耦合的所有特征态必须属于相同类。它将返回由克莱布斯-戈登角动量耦合系数确定的耦合自旋态子类的线性组合。

参数：

expr : 表达式

涉及要耦合的自旋态张量积的表达式。每个状态必须是 SpinState 的子类，并且它们都必须是相同的类。

jcoupling_list : 列表或元组

此列表的元素是长度为 2 的子列表，指定自旋空间耦合的顺序。此列表的长度必须是 N-1，其中 N 是要耦合的张量积中状态的数量。这个子列表的元素与为 JzKetCoupled 定义的jcoupling参数中每个子列表的前两个元素相同。如果未指定此参数，则采用默认值，该默认值耦合第一个和第二个产品基础空间，然后将这个新耦合空间耦合到第三个产品空间等等

示例

为两个空间的数值状态耦合张量积

>>> from sympy.physics.quantum.spin import JzKet, couple
>>> from sympy.physics.quantum.tensorproduct import TensorProduct
>>> couple(TensorProduct(JzKet(1,0), JzKet(1,1)))
-sqrt(2)*|1,1,j1=1,j2=1>/2 + sqrt(2)*|2,1,j1=1,j2=1>/2 

使用默认耦合方法耦合三个空间的数值耦合，即首先耦合第一和第二空间，然后耦合到第三空间：

>>> couple(TensorProduct(JzKet(1,1), JzKet(1,1), JzKet(1,0)))
sqrt(6)*|2,2,j1=1,j2=1,j3=1,j(1,2)=2>/3 + sqrt(3)*|3,2,j1=1,j2=1,j3=1,j(1,2)=2>/3 

进行相同的耦合，但我们定义耦合首先耦合第一个和第三个空间：

>>> couple(TensorProduct(JzKet(1,1), JzKet(1,1), JzKet(1,0)), ((1,3),(1,2)) )
sqrt(2)*|2,2,j1=1,j2=1,j3=1,j(1,3)=1>/2 - sqrt(6)*|2,2,j1=1,j2=1,j3=1,j(1,3)=2>/6 + sqrt(3)*|3,2,j1=1,j2=1,j3=1,j(1,3)=2>/3 

耦合符号态的张量积：

>>> from sympy import symbols
>>> j1,m1,j2,m2 = symbols('j1 m1 j2 m2')
>>> couple(TensorProduct(JzKet(j1,m1), JzKet(j2,m2)))
Sum(CG(j1, m1, j2, m2, j, m1 + m2)*|j,m1 + m2,j1=j1,j2=j2>, (j, m1 + m2, j1 + j2)) 

sympy.physics.quantum.spin.uncouple(expr, jn=None, jcoupling_list=None)

解耦耦合自旋态

给出了耦合自旋态的非耦合表示。参数必须是耦合自旋态子类或自旋态子类以及给出要耦合的空间的 j 值的数组

参数：

expr : 表达式

包含要耦合的状态的表达式。如果状态是 SpinState 的子类，则必须定义jn和jcoupling参数。如果状态是 CoupledSpinState 的子类，则将从状态中取出jn和jcoupling。

jn : 列表或元组

被耦合的 j 值列表。如果状态是 CoupledSpinState，则忽略此参数。如果状态不是 CoupledSpinState 的子类，则必须定义此参数。此参数的语法与 JzKetCoupled 的jn参数相同。

jcoupling_list : 列表或元组

定义了如何耦合 j 值的列表。如果状态是 CoupledSpinState，则忽略此参数。如果状态不是 CoupledSpinState 的子类，则必须定义此参数。此参数的语法与 JzKetCoupled 的jcoupling参数相同。

示例

使用 CoupledSpinState 状态解耦数值状态：

>>> from sympy.physics.quantum.spin import JzKetCoupled, uncouple
>>> from sympy import S
>>> uncouple(JzKetCoupled(1, 0, (S(1)/2, S(1)/2)))
sqrt(2)*|1/2,-1/2>x|1/2,1/2>/2 + sqrt(2)*|1/2,1/2>x|1/2,-1/2>/2 

使用 SpinState 状态执行相同的计算：

>>> from sympy.physics.quantum.spin import JzKet
>>> uncouple(JzKet(1, 0), (S(1)/2, S(1)/2))
sqrt(2)*|1/2,-1/2>x|1/2,1/2>/2 + sqrt(2)*|1/2,1/2>x|1/2,-1/2>/2 

使用 CoupledSpinState 状态解耦三个耦合空间的数值状态：

>>> uncouple(JzKetCoupled(1, 1, (1, 1, 1), ((1,3,1),(1,2,1)) ))
|1,-1>x|1,1>x|1,1>/2 - |1,0>x|1,0>x|1,1>/2 + |1,1>x|1,0>x|1,0>/2 - |1,1>x|1,1>x|1,-1>/2 

使用 SpinState 状态执行相同的计算：

>>> uncouple(JzKet(1, 1), (1, 1, 1), ((1,3,1),(1,2,1)) )
|1,-1>x|1,1>x|1,1>/2 - |1,0>x|1,0>x|1,1>/2 + |1,1>x|1,0>x|1,0>/2 - |1,1>x|1,1>x|1,-1>/2 

使用 CoupledSpinState 状态解耦符号状态：

>>> from sympy import symbols
>>> j,m,j1,j2 = symbols('j m j1 j2')
>>> uncouple(JzKetCoupled(j, m, (j1, j2)))
Sum(CG(j1, m1, j2, m2, j, m)*|j1,m1>x|j2,m2>, (m1, -j1, j1), (m2, -j2, j2)) 

使用 SpinState 状态执行相同的计算

>>> uncouple(JzKet(j, m), (j1, j2))
Sum(CG(j1, m1, j2, m2, j, m)*|j1,m1>x|j2,m2>, (m1, -j1, j1), (m2, -j2, j2))