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

绝不原创的飞龙發表於2024-06-27

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中的有序列矩陣。

解釋

別名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中的非時變符號的有序列矩陣。

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)

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 都可以）

需要考慮多個用例：

傳遞類或類集：首先，我們嘗試為這些算符例項化預設例項。如果失敗，則簡單返回類。如果成功例項化預設例項，則嘗試在算符例項上呼叫 state._operators_to_state。如果失敗，則返回類。否則，返回 _operators_to_state 返回的例項。
傳遞例項或例項集：在這種情況下，對傳遞的例項呼叫 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 都可以）。

需要考慮多個用例：

傳遞狀態類：在這種情況下，首先嚐試例項化類的預設例項。如果成功，則嘗試在該例項上呼叫 state._state_to_operators。如果建立預設例項或呼叫 _state_to_operators 失敗，則返回算符類或算符類集。否則，返回適當的算符例項。
返回狀態例項：在這裡，對例項呼叫 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)

返回附加了虛指數的給定狀態的例項

在兩種不同的模式下執行：

傳遞了兩個引數。第一個是要索引的基態，第二個引數是要附加的索引列表。
傳遞了三個引數。第一個再次是要索引的基態。第二個是計數的起始索引。最後一個引數是您希望接收的 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 中指定的基礎相對應的基態例項。如果未指定基礎，則函式嘗試形成給定表示式的預設基態。

有三種行為：

在選項中指定的基礎已經是 StateBase 的例項。如果是這種情況，則簡單地返回。如果指定了類但不是例項，則返回預設例項。
指定的基礎是運算子或一組運算子。如果是這種情況，則使用 operator_to_state 對映方法。
沒有指定基底。如果 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)

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

SymPy 1.13 中文文件（十八）

生物力學

Introduction

力學

生物力學指南

生物力學 API 參考

肌腱（文件字串）

啟用（文件字串）

曲線（文件字串）

量子力學

量子函式

態和運算元

量子計算

解析解

反對易子

Clebsch-Gordan 係數

交換子

常數

Dagger

內積

張量積。

笛卡爾算符和態

希爾伯特空間

算符

算符/狀態輔助函式

Qapply

表示

自旋

相關文章