面向Autolev用户的SymPy Mechanism#

介绍#

Autolev（现在被MotionGenesis取代）是一种特定于领域的编程语言，用于符号多体动力学。SymPy mechanics模块现在有足够的能力和功能，可以成为一个功能齐全的符号动力学模块。PyDy软件包将SymPy的输出扩展到数值领域，用于模拟、分析和可视化。Autolev和SymPy Mechanism有许多共同之处，但它们之间也有许多不同之处。这一页将详述他们的分歧。这是一个前往参考的Autolev用户谁想过渡到交响力学。

在翻阅这一页之前，最好对共线和共线力学有一个基本的了解。如果您对Python完全陌生，可以查看 Python Tutorial . 查看 SymPy Documentation ，尤其是让你感受到sypy的教程。对于Python中多体动力学的介绍， this 讲座很有帮助。

你也可以找到 Autolev Parser 这是同情的一部分。

一些关键区别#

Autolev

共线力学
Autolev是一种特定于领域的编程语言，用于执行多体动力学。由于它是一种自己的语言，它有一个非常严格的语言规范。它根据输入代码预定义、假设和计算许多事情。因此，它的代码更加简洁明了。
SymPy是一个用通用语言Python编写的库。尽管Autolev的代码更紧凑，但SymPy（作为Python的附加组件）更灵活。用户对他们能做的事情有更多的控制权。例如，我们可以在他们的代码中创建一个类，比如一类具有公共属性的rigibody。大量的科学Python库也是一大优势。
Autolev从一小部分符号数学中生成Matlab、C或Fortran代码。
SymPy从用sypy创建的大量符号数学集合生成Python、C或Octave/Matlab代码。它还建立在流行的科学Python堆栈之上，如NumPy、SciPy、IPython、matplotlib、Cython和Theano。
Autolev使用基于1（一）的索引。序列的初始元素使用 [1] .
python使用基于0（零）的索引。序列的初始元素使用 [0] .
Autolev不区分大小写。
SymPy代码是Python代码，区分大小写。
人们可以在Autolev中定义自己的命令，方法是生成可以在程序中使用的.R和.A文件。
SymPy代码是Python代码，因此可以在代码中定义函数。这样方便多了。
Autolev是专有的。
SymPy是开源的。

粗略的Autolev SymPy等价物#

下表给出了一些常见的Autolev表达式的粗略等价物。 这些不是确切的等价物 ，但应该被视为提示，让你朝着正确的方向前进。有关更多详细信息，请阅读 SymPy vectors ， SymPy mechanics 和 PyDy .

在下表中，假设您已经在Python中执行了以下命令：：：

import sympy.physics.mechanics as me
import sympy as sm

数学等价物#

Autolev

SymPy

Notes
Constants A, B
a, b = sm.symbols(‘a b’, real=True)
请注意，符号的名称可以不同于它们被指定给的变量的名称。我们可以定义 a, b = symbols(‘b a’) 但遵循惯例是很好的做法。
Constants C+
c = sm.symbols(‘c’, real=True, nonnegative=True)
参考SymPy assumptions 更多信息。
Constants D-
d = sm.symbols(‘d’, real=True, nonpositive=True)

Constants K{4}
k1, k2, k3, k4 = sm.symbols('k1 k2 k3 k4', real=True)

Constants a{2:4}
a2, a3, a4 = sm.symbols('a2 a3 a4', real=True)

Constants b{1:2, 1:2}
b11, b12, b21, b22 = sm.symbols('b11 b12 b21 b22', real=True)

Specified Phi
phi = me.dynamicsymbols(‘phi ')

Variables q, s
q, s = me.dynamicsymbols(q, s)

Variables x’’

x = me.dynamicsymbols(‘x’ )

xd = me.dynamicsymbols(‘x’ , 1)

xd2 = me.dynamicsymbols(‘x’ , 2)

Variables y{2}’

y1 = me.dynamicsymbols(‘y1’ )

y2 = me.dynamicsymbols(‘y2’ )

y1d = me.dynamicsymbols(‘y1’ , 1)

y2d = me.dynamicsymbols(‘y2' , 1)

MotionVariables u{2}

u1 = me.dynamicsymbols(‘u1’ )

u2 = me.dynamicsymbols('u2' )

在声明过程中，SymPy不区分变量、运动变量和指定项。相反，它将这些元素的不同列表作为KanesMethod等对象的参数。

Imaginary j

j = sm.I

我是一个共形物体，代表想象单位。我们可以用它来定义复数。

z = x + I*y

其中x、y和z是符号。

Tina = 2*pi

s = u*t + a*t^2/2

tina = 2*sm.pi

tina = tina.evalf()

t = me.dynamicsymbols._t

s = u*t + a*t**2/2

使用 .evalf() 将生成数值。
abs(x)^3 + sin(x)^2 + acos(x)
sm.abs(x)**3 + sm.sin(x)**2 + sm.acos(x)

E = (x+2*y)^2 + 3*(7+x)*(x+y)

Expand(E)

Factor(E, x)

Coef(y, x)

Replace(y, sin(x)=3)

Exclude(E,x)

Include(E,x)

Arrange(E,2,y)

E = (x+2*y)**2 + 3*(7+x)*(x+y)

sm.expand(E)

sm.horner(E, wrt=x)

y.coeff(x)

y.subs({sm.sin(x): 3})

e.collect(x).coeff( x, 0)

e.collect(x).coeff( x, 1)

e.collect(y)

有关更多信息，请参阅 simplification.

这些sypy函数不能正常工作。它们只是返回表达式。如果要覆盖原始表达式，则必须执行以下操作：

y = y.subs({sm.sin(x): 3})

Dy = D(E, y)

Dt = Dt(E)

Dt2 = Dt(V, A) 其中V是向量，a是帧

Dy2 = D(V, y, A)

E.diff(y)

E.diff( me.dynamicsymbols._t )

如果表达式由dynamicsymbols组成，则有效。

dt2 = v.dt(A)

dy2 = v.diff(y, A)

有关更多信息，请参阅 calculus.

E = COS(X*Y)

TY = Taylor(E, 0:2, x=0, y=0)

e = sm.cos(x*y)

b = e.series(x, 0, 2).removeO().series(y, 0, 2).removeO()

有关更多信息，请参阅 series.

F = Evaluate(E, x=a, y=2)

E.subs([(x, a), (y, 2)])

要从数值表达式中获取浮点数，请使用 .evalf()

E.evalf((a + sm.pi).subs({a: 3}))

P = Polynomial([a, b, c], x)

p = sm.Poly(sm.Matrix([a, b, c]).reshape(1, 3), x)

有关更多信息，请参阅 polys.

Roots(Polynomial( a*x^2 + b*x + c, x, 2)

Roots([1;2;3])

sm.solve( sm.Poly(a*x**2 + b*x + c))

sm.solve(sm.Poly( sm.Matrix([1,2,3]). reshape(3, 1), x), x)

For more information refer to 解算器.

For numerical computation related to polynomials and roots refer to mpmath/calculus.

Solve(A, x1, x2)

其中A是表示线性方程组的增广矩阵，x1、x2是要求解的变量。

sm.linsolve(A, (x1, x2))

其中A是增广矩阵

有关更多信息，请参阅 :ref:` solvers/solveset. <solveset>`

For non linear solvers refer to nonlinsolve and nsolve in solvers.

RowMatrix = [1, 2, 3, 4]

ColMatrix = [1; 2; 3; 4]

MO = [a, b; c, 0]

MO[2, 2] := d

A + B*C

Cols(A)

Cols(A, 1)

Rows(A)

Rows(A, 1)

Det(A)

Element(A, 2, 3)

Inv(A)

Trace(A)

Transpose(A)

Diagmat(4, 1)

Eig(A)

Eig(A, EigVal, EigVec)

row_matrix = sm.Matrix([[1],[2], [3],[4]])

col_matrix = sm.Matrix([1, 2, 3, 4])

MO = sm.Matrix([[a, b], [c, 0]])

MO[1, 1] = d

A + B*C

A.cols

A.col(0)

A.rows

A.row(0)

M.det()

M[2, 3]

M**-1

sm.trace(A)

A.T

sm.diag(1,1,1,1)

A.eigenvals()

eigval = A.eigenvals()

eigvec = A.eigenvects()

有关更多信息，请参阅 matrices.

物理等效物#

Autolev

SymPy

Notes

Bodies A

它的法向量A3>A，和它的法向量A1>A3>A。

m =sm.symbols(‘m’)

Ao = sm.symbols(‘Ao’)

Af = me.ReferenceFrame(‘Af’ )

I = me.outer(Af.x,Af.x)

P = me.Point(‘P’)

A =me.RigidBody(‘A’, Ao, Af, m, (I, P))

Af.x、Af.y和Af.z相当于A1>、A2>和A3>。

第四和第五个论点是关于质量和惯性的。它们在Autolev中的声明之后指定。

可以为参数传递一个伪参数并使用setter A.mass = \_ 和 A.inertia = \_ 以后再设置。

有关更多信息，请参阅 mechanics/masses .

Frames A

V1> = X1*A1> + X2*A2>

A = me.ReferenceFrame(‘A’ )

v1 = x1*A.x + x2*A.y

有关更多信息，请参阅 physics/vectors.

Newtonian N

N = me.ReferenceFrame(‘N’ )

SymPy并没有指定一个帧在声明过程中是惯性的。许多功能，如 set_ang_vel() 以惯性参考系为参数。

Particles C

m = sm.symbols(‘m’)

Po = me.Point(‘Po’)

C = me.Particle(‘C’, Po, m)

第二个和第三个参数是点和质量。在Autolev中，这些是在声明之后指定的。

一个人可以通过一个假人和使用二传手 (A.point = \_ 和 A.mass = \_ )以后再设置。

Points P, Q

P = me.Point(‘P’)

Q = me.Point(‘Q’)

Mass B=mB

mB = symbols(‘mB’)

B.mass = mB

Inertia B, I1, I2, I3, I12, I23, I31

I = me.inertia(Bf, i1, i2, i3, i12, i23, i31)

B.inertia = (I, P) 其中B是刚体，Bf是相关的框架，P是B的质心。

利用向量外积也可以形成惯性并矢。

I = me.outer(N.x, N.x)

有关更多信息，请参阅 mechanics api.

vec> = P_O_Q>/L

vec> = u1*N1> + u2*N2>

Cross(a>, b>)

Dot(a>, b>)

Mag(v>)

Unitvec(v>)

DYAD>> = 3*A1>*A1> + A2>*A2> + 2*A3>*A3>

vec  = (Qo.pos_from(O))/L

vec = u1*N.x + u2*N.y

cross(a, b)

dot(a, b)

v.magnitude()

v.normalize()

dyad = 3*me.outer(a.x ,a.x) + me.outer(a.y, a.y) + 2*me.outer(a.z ,a.z)

有关更多信息，请参阅 physics/vectors.

P_O_Q> = LA*A1>

P_P_Q> = LA*A1>

Q.point = O.locatenew(‘Qo’, LA*A.x)

其中A是参考坐标系。

Q.point = P.point.locatenew(‘Qo ’, LA*A.x)

有关更多信息，请参阅 kinematics api.

所有这些矢量和运动学函数都将用于 Point 对象与否 Particle 反对如此 .point 必须用于粒子。

V_O_N> = u3*N.1> + u4*N.2>

Partials(V_O_N>, u3)

O.set_vel(N, u1*N.x + u2*N.y)

O.partial_velocity(N , u3)

吸气剂应该是 O.vel(N) .

A_O_N> = 0>

参考坐标系N中O点的加速度。

O.set_acc(N, 0)

吸气剂应该是 O.acc(N) .

W_B_N> = qB’*B3>

参考系F中物体B的角速度。

B.set_ang_vel(N, qBd*Bf.z)

其中Bf是与主体B相关联的框架。

吸气剂应该是 B.ang_vel_in(N) .

ALF_B_N> =Dt(W_B_N>, N)

参考系N中物体B的角加速度。

B.set_ang_acc(N, diff(B.ang_vel_in(N) )

吸气剂应该是 B.ang_acc_in(N) .

Force_O> = F1*N1> + F2*N2>

Torque_A> = -c*qA’*A3>

在SymPy中，应该有一个包含所有力和力矩的列表。

fL.append((O, f1*N.x + f2*N.y))

其中fL是力。

fl.append((A, -c*qAd*A.z))

A_B = M 其中M是矩阵，a，B是帧。

D = A_B*2 + 1

B.orient(A, 'DCM', M) 其中M是一个sypy矩阵。

D = A.dcm(B)*2 + 1

CM(B)

B.masscenter

Mass(A,B,C)

A.mass + B.mass + C.mass

V1pt(A,B,P,Q)

Q.v1pt_theory(P, A, B)

假设P和Q为 Point 这里的对象。记住使用 .point 对于粒子。

V2pts(A,B,P,Q)

Q.v2pt_theory(P, A, B)

A1pt(A,B,P,Q)

Q.a1pt_theory(P, A, B)

A2pts(A,B,P,Q)

Q.a2pt_theory(P, A, B)

Angvel(A,B)

B.ang_vel_in(A)

Simprot(A, B, 1, qA)

B.orient(A, ‘Axis’, qA, A.x)

Gravity(G*N1>)

fL.extend(gravity( g*N.x, P1, P2, ...))

在SymPy中，我们必须使用一个包含元组形式的forceList（这里是fL） (point, force_vector) . 这是传递给 kanes_equations() KanesMethod对象的方法。

CM(O,P1,R)

me.functions. center_of_mass(o, p1, r)

Force(P/Q, v>)

fL.append((P, -1*v), (Q, v))

Torque(A/B, v>)

fL.append((A, -1*v), (B, v))

Kindiffs(A, B ...)

KM.kindiffdict()

Momentum(option)

linear_momentum(N, B1, B2 ...)

后接一个或多个实体的参考框架

angular_momentum(O, N, B1, B2 ...)

点，后接一个或多个实体的参考坐标系

KE()

kinetic_energy(N, B1, B2 ...)

后接一个或多个实体的参考框架

Constrain(...)

velocity_constraints = [...]

u_dependent = [...]

u_auxiliary = [...]

这些列表被传递给KanesMethod对象。

有关详细信息，请参阅 mechanics/kane 以及 kane api.

Fr() FrStar()

KM = KanesMethod(f, q_ind, u_ind, kd_eqs, q_dependent, configura tion_constraints, u_de pendent, velocity_cons traints, acceleration_ constraints, u_auxilia ry)

KanesMethod对象接受后跟多个列表的参考帧作为参数。

(fr, frstar) = KM.kanes_equations(fL, bL) 其中fL和bL分别是力和物体的列表。

有关详细信息，请参阅 mechanics/kane 以及 kane api.

数值计算与可视化#

Autolev的CODE Option（）命令允许生成Matlab、C或Fortran代码，以便进行数值计算和可视化。选项可以是动力学、ODE、非线性或代数。

动力学数值计算可以用PyDy实现。可以将KanesMethod对象与常量、指定值、初始条件和时间点的值一起传递给System类。然后就可以积分运动方程了。绘图是使用matlplotlib实现的。下面是来自 PyDy Documentation 关于如何做到这一点：

from numpy import array, linspace, sin
from pydy.system import System

sys = System(kane,
             constants = {mass: 1.0, stiffness: 1.0,
                          damping: 0.2, gravity: 9.8},
             specifieds = {force: lambda x, t: sin(t)},
             initial_conditions = {position: 0.1, speed:-1.0},
             times = linspace(0.0, 10.0, 1000))

y = sys.integrate()

import matplotlib.pyplot as plt
plt.plot(sys.times, y)
plt.legend((str(position), str(speed)))
plt.show()

有关PyDy可以完成的所有事情的信息，请参阅 PyDy Documentation .

PyDy工作流中的工具包括：

  • SymPy: SymPy是一个Python库，用于

    符号计算。它提供计算机代数功能，可以作为独立应用程序，也可以作为其他应用程序的库，或者以SymPy live或SymPy Gamma的形式在线运行。

  • NumPy: NumPy is a library for the

    Python编程语言，增加了对大型多维数组和矩阵的支持，以及对这些数组进行操作的大量高级数学函数集合。

  • SciPy: SciPy is an open source

    用于科学计算和技术计算的Python库。SciPy包含优化、线性代数、积分、插值、特殊函数、FFT、信号和图像处理、ODE解算器以及其他科学和工程中常见任务的模块。

  • IPython: IPython是一个命令shell

    对于多编程语言的交互式计算，最初是为Python编程语言开发的，它提供了自省、富媒体、shell语法、制表符补全和历史记录。

  • Aesara: Aesara is

    a numerical computation library for Python. In Aesara, computations are expressed using a NumPy-esque syntax and compiled to run efficiently on either CPU or GPU architectures.

  • Cython: Cython is a superset of the

    Python编程语言，用于在代码中提供类C性能，这些代码主要是用Python编写的。Cython是一种编译语言，它生成CPython扩展模块。

  • matplotlib: matplotlib是一个

    Python编程语言的绘图库及其数值数学扩展NumPy。

人们将能够使用这些科学计算工具编写相当于Autolev生成的Matlab、C或Fortran代码的代码。我们建议您先了解一下Python的计算模块。