SymPy-1-13-中文文档-十九-
SymPy 1.13 中文文档(十九)
State
状态的 Dirac 符号表示法。
class sympy.physics.quantum.state.Bra(*args, **kwargs)
量子力学中的一般时间无关的 Bra。
继承自 State 和 BraBase。Bra 是 Ket 的对偶[R769]。这个类及其子类将是用户表达 Dirac 符号表示法中 Bras 的主要类。
参数:
args:元组
一组唯一指定 Ket 的数字或参数列表。这通常是其符号或量子数。对于时间相关状态,这将包括时间。
例子
创建一个简单的 Bra 并查看其属性:
>>> from sympy.physics.quantum import Bra
>>> from sympy import symbols, I
>>> b = Bra('psi')
>>> b
<psi|
>>> b.hilbert_space
H
>>> b.is_commutative
False
Bra 的知道它们对偶 Ket 的:
>>> b.dual
|psi>
>>> b.dual_class()
<class 'sympy.physics.quantum.state.Ket'>
和 Kets 一样,Bras 可以有复合标签,并且可以以类似的方式进行操作:
>>> n, m = symbols('n,m')
>>> b = Bra(n,m) - I*Bra(m,n)
>>> b
-I*<mn| + <nm|
可以使用.subs
替换 Bra 中的符号。
>>> b.subs(n,m)
<mm| - I*<mm|
参考资料
[R769] (1,2)
en.wikipedia.org/wiki/Bra-ket_notation
class sympy.physics.quantum.state.BraBase(*args, **kwargs)
Bras 的基类。
该类定义了对偶属性和打印时的括号。这是一个抽象基类,不应直接实例化,而是使用 Bra。
class sympy.physics.quantum.state.Ket(*args, **kwargs)
量子力学中的一般时间无关的 Ket。
继承自 State 和 KetBase。这个类应该作为系统中所有物理、时间无关的 Ket 的基类使用。这个类及其子类将是用户表达 Dirac 符号表示法中 Kets 的主要类。
参数:
args:元组
一组唯一指定 Ket 的数字或参数列表。这通常是其符号或量子数。对于时间相关状态,这将包括时间。
例子
创建一个简单的 Ket 并查看其属性:
>>> from sympy.physics.quantum import Ket
>>> from sympy import symbols, I
>>> k = Ket('psi')
>>> k
|psi>
>>> k.hilbert_space
H
>>> k.is_commutative
False
>>> k.label
(psi,)
Ket 知道其关联的 Bra:
>>> k.dual
<psi|
>>> k.dual_class()
<class 'sympy.physics.quantum.state.Bra'>
取两个 Ket 的线性组合:
>>> k0 = Ket(0)
>>> k1 = Ket(1)
>>> 2*I*k0 - 4*k1
2*I*|0> - 4*|1>
复合标签作为元组传递:
>>> n, m = symbols('n,m')
>>> k = Ket(n,m)
>>> k
|nm>
参考资料
[R770] (1,2)
en.wikipedia.org/wiki/Bra-ket_notation
class sympy.physics.quantum.state.KetBase(*args, **kwargs)
Kets 的基类。
该类定义了对偶属性和打印时的括号。这是一个抽象基类,不应直接实例化,而是使用 Ket。
class sympy.physics.quantum.state.OrthogonalBra(*args, **kwargs)
量子力学中的正交 Bra。
class sympy.physics.quantum.state.OrthogonalKet(*args, **kwargs)
量子力学中的正交 Ket。
两个具有不同标签的态的内积为零,具有相同标签的态的内积为一。
>>> from sympy.physics.quantum import OrthogonalBra, OrthogonalKet
>>> from sympy.abc import m, n
>>> (OrthogonalBra(n)*OrthogonalKet(n)).doit()
1
>>> (OrthogonalBra(n)*OrthogonalKet(n+1)).doit()
0
>>> (OrthogonalBra(n)*OrthogonalKet(m)).doit()
<n|m>
class sympy.physics.quantum.state.OrthogonalState(*args, **kwargs)
用作 Ket 和 Bra 的基类的一般抽象量子态。
class sympy.physics.quantum.state.State(*args, **kwargs)
用作 Ket 和 Bra 的基类的一般抽象量子态。
class sympy.physics.quantum.state.StateBase(*args, **kwargs)
量子力学中一般抽象态的抽象基类。
所有其他定义的状态类都需要从此类继承。它承载了所有其他状态的基本结构,如对偶、_eval_adjoint 和标签。
这是一个抽象基类,不应直接实例化,而是使用 State。
property dual
返回此态的对偶态。
classmethod dual_class()
返回用于构造对偶的类。
property operators
返回这个态是本征态的算符(们)。
class sympy.physics.quantum.state.TimeDepBra(*args, **kwargs)
量子力学中的通用时间依赖Bra
。
这继承自TimeDepState
和BraBase
,是应该用于随时间变化的Bra
的主要类。其对偶体是一个TimeDepBra
。
参数:
args:元组
列出唯一指定
ket
的数字或参数的列表。通常将是其符号或量子数。对于时间依赖状态,这将包括时间作为最后一个参数。
例子
>>> from sympy.physics.quantum import TimeDepBra
>>> b = TimeDepBra('psi', 't')
>>> b
<psi;t|
>>> b.time
t
>>> b.label
(psi,)
>>> b.hilbert_space
H
>>> b.dual
|psi;t>
class sympy.physics.quantum.state.TimeDepKet(*args, **kwargs)
量子力学中的通用时间依赖Ket
。
这继承自TimeDepState
和KetBase
,是应该用于随时间变化的Ket
的主要类。其对偶体是一个TimeDepBra
。
参数:
args:元组
列出唯一指定
ket
的数字或参数的列表。通常将是其符号或量子数。对于时间依赖状态,这将包括时间作为最后一个参数。
例子
创建一个TimeDepKet
并查看其属性:
>>> from sympy.physics.quantum import TimeDepKet
>>> k = TimeDepKet('psi', 't')
>>> k
|psi;t>
>>> k.time
t
>>> k.label
(psi,)
>>> k.hilbert_space
H
TimeDepKets
知道它们的对偶bra
:
>>> k.dual
<psi;t|
>>> k.dual_class()
<class 'sympy.physics.quantum.state.TimeDepBra'>
class sympy.physics.quantum.state.TimeDepState(*args, **kwargs)
通用时间依赖量子态的基类。
此类用作任何时间依赖状态的基类。此类与时间独立状态的主要区别在于,此类除了通常的标签参数外,还接受第二个参数作为时间。
参数:
args:元组
列出唯一指定
ket
的数字或参数的列表。通常将是其符号或量子数。对于时间依赖状态,这将包括时间作为最后一个参数。
property label
状态的标签。
property time
状态的时间。
class sympy.physics.quantum.state.Wavefunction(*args)
连续基底表示的类
此类在其构造函数中接受表达式和坐标。可用于轻松计算标准化和概率。
参数:
expr:表达式
表示波函数功能形式的表达式。
coords:符号或元组
要进行积分的坐标及其边界
例子
在盒子中的粒子,以更原始的方式使用Piecewise
来指定边界:
>>> from sympy import Symbol, Piecewise, pi, N
>>> from sympy.functions import sqrt, sin
>>> from sympy.physics.quantum.state import Wavefunction
>>> x = Symbol('x', real=True)
>>> n = 1
>>> L = 1
>>> g = Piecewise((0, x < 0), (0, x > L), (sqrt(2//L)*sin(n*pi*x/L), True))
>>> f = Wavefunction(g, x)
>>> f.norm
1
>>> f.is_normalized
True
>>> p = f.prob()
>>> p(0)
0
>>> p(L)
0
>>> p(0.5)
2
>>> p(0.85*L)
2*sin(0.85*pi)**2
>>> N(p(0.85*L))
0.412214747707527
此外,您可以以更紧凑的方式指定函数的边界和指数:
>>> from sympy import symbols, pi, diff
>>> from sympy.functions import sqrt, sin
>>> from sympy.physics.quantum.state import Wavefunction
>>> x, L = symbols('x,L', positive=True)
>>> n = symbols('n', integer=True, positive=True)
>>> g = sqrt(2/L)*sin(n*pi*x/L)
>>> f = Wavefunction(g, (x, 0, L))
>>> f.norm
1
>>> f(L+1)
0
>>> f(L-1)
sqrt(2)*sin(pi*n*(L - 1)/L)/sqrt(L)
>>> f(-1)
0
>>> f(0.85)
sqrt(2)*sin(0.85*pi*n/L)/sqrt(L)
>>> f(0.85, n=1, L=1)
sqrt(2)*sin(0.85*pi)
>>> f.is_commutative
False
所有参数都会自动转换为sympy
对象,因此您可以将变量定义为字符串,而不是符号:
>>> expr = x**2
>>> f = Wavefunction(expr, 'x')
>>> type(f.variables[0])
<class 'sympy.core.symbol.Symbol'>
波函数的导数将返回波函数:
>>> diff(f, x)
Wavefunction(2*x, x)
property expr
返回表示波函数功能形式的表达式
例子
>>> from sympy.physics.quantum.state import Wavefunction
>>> from sympy import symbols
>>> x, y = symbols('x, y')
>>> f = Wavefunction(x**2, x)
>>> f.expr
x**2
property is_commutative
覆盖函数的is_commutative
,以保持表达式中的顺序
property is_normalized
如果波函数正确归一化则返回真
例子
>>> from sympy import symbols, pi
>>> from sympy.functions import sqrt, sin
>>> from sympy.physics.quantum.state import Wavefunction
>>> x, L = symbols('x,L', positive=True)
>>> n = symbols('n', integer=True, positive=True)
>>> g = sqrt(2/L)*sin(n*pi*x/L)
>>> f = Wavefunction(g, (x, 0, L))
>>> f.is_normalized
True
property limits
返回波函数依赖的坐标的限制。如果未指定限制,则默认为(-oo, oo)
。
例子
>>> from sympy.physics.quantum.state import Wavefunction
>>> from sympy import symbols
>>> x, y = symbols('x, y')
>>> f = Wavefunction(x**2, (x, 0, 1))
>>> f.limits
{x: (0, 1)}
>>> f = Wavefunction(x**2, x)
>>> f.limits
{x: (-oo, oo)}
>>> f = Wavefunction(x**2 + y**2, x, (y, -1, 2))
>>> f.limits
{x: (-oo, oo), y: (-1, 2)}
property norm
返回指定函数形式的归一化。
此函数对Wavefunction
的坐标进行积分,指定了边界。
例子
>>> from sympy import symbols, pi
>>> from sympy.functions import sqrt, sin
>>> from sympy.physics.quantum.state import Wavefunction
>>> x, L = symbols('x,L', positive=True)
>>> n = symbols('n', integer=True, positive=True)
>>> g = sqrt(2/L)*sin(n*pi*x/L)
>>> f = Wavefunction(g, (x, 0, L))
>>> f.norm
1
>>> g = sin(n*pi*x/L)
>>> f = Wavefunction(g, (x, 0, L))
>>> f.norm
sqrt(2)*sqrt(L)/2
normalize()
返回波函数的归一化版本
例子
>>> from sympy import symbols, pi
>>> from sympy.functions import sin
>>> from sympy.physics.quantum.state import Wavefunction
>>> x = symbols('x', real=True)
>>> L = symbols('L', positive=True)
>>> n = symbols('n', integer=True, positive=True)
>>> g = sin(n*pi*x/L)
>>> f = Wavefunction(g, (x, 0, L))
>>> f.normalize()
Wavefunction(sqrt(2)*sin(pi*n*x/L)/sqrt(L), (x, 0, L))
prob()
返回波函数的绝对幅度,(|\psi(x)|²)
例子
>>> from sympy import symbols, pi
>>> from sympy.functions import sin
>>> from sympy.physics.quantum.state import Wavefunction
>>> x, L = symbols('x,L', real=True)
>>> n = symbols('n', integer=True)
>>> g = sin(n*pi*x/L)
>>> f = Wavefunction(g, (x, 0, L))
>>> f.prob()
Wavefunction(sin(pi*n*x/L)**2, x)
property variables
返回波函数依赖的坐标
例子
>>> from sympy.physics.quantum.state import Wavefunction
>>> from sympy import symbols
>>> x,y = symbols('x,y')
>>> f = Wavefunction(x*y, x, y)
>>> f.variables
(x, y)
>>> g = Wavefunction(x*y, x)
>>> g.variables
(x,)
电路绘图
原文:
docs.sympy.org/latest/modules/physics/quantum/circuitplot.html
基于 Matplotlib 的量子电路绘图。
待办事项:
-
优化大电路的打印。
-
使其与单门一起工作。
-
更好地检查电路形式,以确保它是 Gates 的乘积。
-
获取多目标门绘图。
-
获取初始状态和最终状态以绘制。
-
获取用于绘制的测量值。可能需要重新考虑测量作为一个门的问题。
-
更好地处理比例和 figsize。
-
编写一些测试/示例!
class sympy.physics.quantum.circuitplot.CircuitPlot(c, nqubits, **kwargs)
一个管理电路图的类。
control_line(gate_idx, min_wire, max_wire)
绘制垂直控制线。
control_point(gate_idx, wire_idx)
绘制一个控制点。
not_point(gate_idx, wire_idx)
绘制 NOT 门,作为中间带加号的圆圈。
one_qubit_box(t, gate_idx, wire_idx)
为单量子比特门绘制一个框。
swap_point(gate_idx, wire_idx)
将交换点绘制为十字架。
two_qubit_box(t, gate_idx, wire_idx)
为两量子比特门绘制一个框。目前还不能正常工作。
update(kwargs)
将 kwargs 加载到实例字典中。
sympy.physics.quantum.circuitplot.CreateCGate(name, latexname=None)
使用词法闭包制作一个受控门。
class sympy.physics.quantum.circuitplot.Mx(*args, **kwargs)
一个 x 测量门的草图。
这是在 circuitplot 中而不是 gate.py 中,因为它不是一个真正的门,它只是画了一个门。
class sympy.physics.quantum.circuitplot.Mz(*args, **kwargs)
一个 z 测量门的草图。
这是在 circuitplot 中而不是 gate.py 中,因为它不是一个真正的门,它只是画了一个门。
sympy.physics.quantum.circuitplot.circuit_plot(c, nqubits, **kwargs)
绘制具有 n 量子比特电路的电路图。
参数:
c:电路
要绘制的电路。应该是 Gate 实例的乘积。
nqubits:整数
要包括在电路中的量子比特数。必须至少与门的最大
min_qubits
一样大。
sympy.physics.quantum.circuitplot.labeller(n, symbol='q')
为量子电路的线自动生成标签。
参数:
n:整数
电路中的量子比特数。
符号:字符串
一个字符字符串,用于所有门标签之前。例如‘q_0’,‘q_1’等。
>>> from sympy.physics.quantum.circuitplot import labeller
>>> labeller(2)
['q_1', 'q_0']
>>> labeller(3,'j')
['j_2', 'j_1', 'j_0']
门
作用于量子比特的门的实现。
门是作用于量子比特空间的幺正算符。
中期待办事项:
-
优化 Gate._apply_operators_Qubit 以消除许多中间 Qubit 对象的创建。
-
为所有操作符添加交换关系,并在 gate_sort 中使用。
-
修复 gate_sort 和 gate_simp。
-
正确地绘制多目标 UGates。
-
使用 sympy/numpy 矩阵中的 UGate,并输出任意格式。这也应该使用矩阵槽。
class sympy.physics.quantum.gate.CGate(*args, **kwargs)
带有控制量子比特的通用幺正门。
通用控制门在所有控制量子比特具有特定值时(由CGate.control_value
设置)对一组目标执行目标门。
参数:
标签:tuple
在此情况下,标签的形式为(control, gate),其中 control 是控制量子比特的元组/列表(作为整数),gate 是目标操作符的
Gate
实例。
property controls
一个控制量子比特的元组。
decompose(**options)
将受控门分解为 CNOT 门和单量子比特门。
eval_controls(qubit)
返回 True/False 以指示是否满足控制条件。
property gate
将应用于目标的非受控门。
property min_qubits
该门需要作用的最小量子比特数。
property nqubits
该门作用的总量子比特数。
对于受控门子类,包括目标和控制量子比特,例如 CNOT 门作用于 2 个量子比特。
plot_gate(circ_plot, gate_idx)
绘制受控门。如果simplify_cgate为 true,则将 C-X 和 C-Z 门简化为它们更熟悉的形式。
property targets
一个目标量子比特的元组。
class sympy.physics.quantum.gate.CGateS(*args, **kwargs)
允许门简化的 CGate 版本。例如,cnot 看起来像 oplus,cphase 有点等等。
sympy.physics.quantum.gate.CNOT
CNotGate
的别名
class sympy.physics.quantum.gate.CNotGate(*args, **kwargs)
两量子比特控制 NOT 门。
如果所有控制量子比特的值都为 1,则该门在目标量子比特上执行 NOT 或 X 门。
参数:
标签:tuple
一个形如(control, target)的元组。
示例
>>> from sympy.physics.quantum.gate import CNOT
>>> from sympy.physics.quantum.qapply import qapply
>>> from sympy.physics.quantum.qubit import Qubit
>>> c = CNOT(1,0)
>>> qapply(c*Qubit('10')) # note that qubits are indexed from right to left
|11>
property controls
一个控制量子比特的元组。
property gate
将应用于目标的非受控门。
property min_qubits
该门需要作用的最小量子比特数。
property targets
一个目标量子比特的元组。
class sympy.physics.quantum.gate.Gate(*args, **kwargs)
非控制幺正门操作符,作用于量子比特。
这是一个一般的抽象门,需要子类化才能有用。
参数:
标签:tuple, int
将门应用于的目标量子比特的列表(作为整数)。
get_target_matrix(format='sympy')
门的目标部分的矩阵表示。
参数:
格式:str
格式字符串('sympy','numpy'等)。
property min_qubits
该门需要作用的最小量子比特数。
property nqubits
该门作用的总量子比特数。
对于受控门子类,包括目标和控制量子比特,例如 CNOT 门作用于 2 个量子比特。
property targets
一个目标量子比特的元组。
sympy.physics.quantum.gate.H
HadamardGate
的别名
class sympy.physics.quantum.gate.HadamardGate(*args, **kwargs)
单量子比特 Hadamard 门。
参数:
目标:int
此门将应用于的目标量子比特。
示例
>>> from sympy import sqrt
>>> from sympy.physics.quantum.qubit import Qubit
>>> from sympy.physics.quantum.gate import HadamardGate
>>> from sympy.physics.quantum.qapply import qapply
>>> qapply(HadamardGate(0)*Qubit('1'))
sqrt(2)*|0>/2 - sqrt(2)*|1>/2
>>> # Hadamard on bell state, applied on 2 qubits.
>>> psi = 1/sqrt(2)*(Qubit('00')+Qubit('11'))
>>> qapply(HadamardGate(0)*HadamardGate(1)*psi)
sqrt(2)*|00>/2 + sqrt(2)*|11>/2
class sympy.physics.quantum.gate.IdentityGate(*args, **kwargs)
单量子比特恒等门。
参数:
目标 : 整数
此门将应用于的目标量子比特。
class sympy.physics.quantum.gate.OneQubitGate(*args, **kwargs)
单量子比特酉门基类。
sympy.physics.quantum.gate.Phase
PhaseGate
的别名。
class sympy.physics.quantum.gate.PhaseGate(*args, **kwargs)
单量子比特相位或 S 门。
此门在状态为 |1>
时将状态相位旋转 π/2,如果状态为 |0>
则不做任何操作。
参数:
目标 : 整数
此门将应用于的目标量子比特。
sympy.physics.quantum.gate.S
PhaseGate
的别名。
sympy.physics.quantum.gate.SWAP
SwapGate
的别名。
class sympy.physics.quantum.gate.SwapGate(*args, **kwargs)
两量子比特 SWAP 门。
此门交换两个量子比特的值。
参数:
标签 : 元组
一个形如 (目标 1, 目标 2) 的元组。
decompose(**options)
将 SWAP 门分解为 CNOT 门。
sympy.physics.quantum.gate.T
TGate
的别名。
class sympy.physics.quantum.gate.TGate(*args, **kwargs)
单量子比特 π/8 门。
此门在状态为 |1>
时将状态相位旋转 π/4,如果状态为 |0>
则不做任何操作。
参数:
目标 : 整数
此门将应用于的目标量子比特。
class sympy.physics.quantum.gate.TwoQubitGate(*args, **kwargs)
两量子比特酉门基类。
class sympy.physics.quantum.gate.UGate(*args, **kwargs)
由一组目标和目标矩阵指定的通用门。
参数:
标签 : 元组
一个形如 (目标, U) 的元组,其中目标是目标量子比特的一个元组,U 是一个维度为 len(targets) 的酉矩阵。
get_target_matrix(format='sympy')
目标部分门的矩阵表示。
参数:
格式 : 字符串
格式化字符串(‘sympy’,‘numpy’等)。
property targets
目标量子比特的一个元组。
sympy.physics.quantum.gate.X
XGate
的别名。
class sympy.physics.quantum.gate.XGate(*args, **kwargs)
单量子比特 X 或 NOT 门。
参数:
目标 : 整数
此门将应用于的目标量子比特。
sympy.physics.quantum.gate.Y
YGate
的别名。
class sympy.physics.quantum.gate.YGate(*args, **kwargs)
单量子比特 Y 门。
参数:
目标 : 整数
此门将应用于的目标量子比特。
sympy.physics.quantum.gate.Z
ZGate
的别名。
class sympy.physics.quantum.gate.ZGate(*args, **kwargs)
单量子比特 Z 门。
参数:
目标 : 整数
此门将应用于的目标量子比特。
sympy.physics.quantum.gate.gate_simp(circuit)
符号化简门。
首先使用 gate_sort 对门进行排序。然后应用基本简化规则到电路,例如 XGate**2 = Identity。
sympy.physics.quantum.gate.gate_sort(circuit)
在保持对易关系的同时对门进行排序。
此函数使用冒泡排序重新排列门的应用顺序。跟踪量子计算的特殊对易关系(例如,应用于同一量子比特的事物不会相互对易)。
电路是要排序的门的乘积。
sympy.physics.quantum.gate.normalized(normalize)
设置标志,控制 Hadamard 门通过 (1/\sqrt{2}) 进行归一化。
这是一个全局设置,可以通过省略 Hadamard 门的前导 (1/\sqrt{2}) 来简化各种表达式的外观。
参数:
归一化 : 布尔值
哈达玛门是否应包括 (1/\sqrt{2}) 的归一化因子?当为 True 时,哈达玛门将包括 (1/\sqrt{2})。当为 False 时,则不包括此因子。
sympy.physics.quantum.gate.random_circuit(ngates, nqubits, gate_space=(<class 'sympy.physics.quantum.gate.XGate'>, <class 'sympy.physics.quantum.gate.YGate'>, <class 'sympy.physics.quantum.gate.ZGate'>, <class 'sympy.physics.quantum.gate.PhaseGate'>, <class 'sympy.physics.quantum.gate.TGate'>, <class 'sympy.physics.quantum.gate.HadamardGate'>, <class 'sympy.physics.quantum.gate.CNotGate'>, <class 'sympy.physics.quantum.gate.SwapGate'>))
返回一个 ngates 和 nqubits 的随机电路。
这使用了等权重的样本(X, Y, Z, S, T, H, CNOT, SWAP)门。
参数:
ngates : 整数
电路中的门数量。
nqubits : 整数
电路中的量子比特数量。
gate_space : 元组
一个元组,包含将在电路中使用的门类。在此元组中多次重复门类将增加它们在随机电路中出现的频率。
Grover 算法
原文链接:
docs.sympy.org/latest/modules/physics/quantum/grover.html
Grover 算法和辅助函数。
待办事项:
-
W 门的构造(或者根据 Mermin 的书可能是 -W 门)
-
为返回多量子比特状态为 1 的未知函数泛化算法。
-
在 OracleGate 中实现 _represent_ZGate
class sympy.physics.quantum.grover.OracleGate(*args, **kwargs)
一个黑盒门。
该门通过翻转量子位的符号来标记未知函数的所需量子比特。当未知函数找到所需量子比特时返回 true,否则返回 false。
参数:
qubits : 整数
量子比特的数量。
oracle : 可调用对象
返回一个在计算基上返回布尔值的可调用函数。
示例
在不同量子比特上应用翻转 |2>
的 Oracle 门:
>>> from sympy.physics.quantum.qubit import IntQubit
>>> from sympy.physics.quantum.qapply import qapply
>>> from sympy.physics.quantum.grover import OracleGate
>>> f = lambda qubits: qubits == IntQubit(2)
>>> v = OracleGate(2, f)
>>> qapply(v*IntQubit(2))
-|2>
>>> qapply(v*IntQubit(3))
|3>
property search_function
帮助找到所需量子比特的未知函数。
property targets
目标量子比特的元组。
class sympy.physics.quantum.grover.WGate(*args, **kwargs)
Grover 算法中的一般 n 量子位 W 门。
该门在某些量子比特上执行操作 2|phi><phi| - 1
。|phi> = (n 个 Hadamard 的张量积)*(n 量子比特的 |0>)
参数:
nqubits : 整数
操作的量子比特数
sympy.physics.quantum.grover.apply_grover(oracle, nqubits, iterations=None)
应用 Grover 算法。
参数:
oracle : 可调用对象
未知的可调用函数,在应用于所需的量子比特时返回 true,否则返回 false。
返回:
state : 表达式
Grover 算法迭代后的结果状态。
示例
将 Grover 算法应用于两个量子比特的均匀叠加:
>>> from sympy.physics.quantum.qapply import qapply
>>> from sympy.physics.quantum.qubit import IntQubit
>>> from sympy.physics.quantum.grover import apply_grover
>>> f = lambda qubits: qubits == IntQubit(2)
>>> qapply(apply_grover(f, 2))
|2>
sympy.physics.quantum.grover.grover_iteration(qstate, oracle)
应用一次 Oracle 和 W 门,WV。
参数:
qstate : 量子位
量子比特的叠加态。
oracle : OracleGate
黑盒运算符,翻转所需基础量子位的符号。
返回:
Qubit : 在应用 Oracle 和 W 门后的量子比特。
示例
执行一次 Grover 算法迭代以查看相位变化:
>>> from sympy.physics.quantum.qapply import qapply
>>> from sympy.physics.quantum.qubit import IntQubit
>>> from sympy.physics.quantum.grover import OracleGate
>>> from sympy.physics.quantum.grover import superposition_basis
>>> from sympy.physics.quantum.grover import grover_iteration
>>> numqubits = 2
>>> basis_states = superposition_basis(numqubits)
>>> f = lambda qubits: qubits == IntQubit(2)
>>> v = OracleGate(numqubits, f)
>>> qapply(grover_iteration(basis_states, v))
|2>
sympy.physics.quantum.grover.superposition_basis(nqubits)
创建计算基的等幺角叠加。
参数:
nqubits : 整数
量子比特的数量。
返回:
state : 量子位
用 nqubits 创建计算基的等幺角叠加。
示例
创建两个量子比特的等幺角叠加:
>>> from sympy.physics.quantum.grover import superposition_basis
>>> superposition_basis(2)
|0>/2 + |1>/2 + |2>/2 + |3>/2
QFT
一个作用于量子比特及其门的实现。
待办事项:
-
更新文档字符串。
-
更新测试。
-
使用分解实现应用。
-
使用分解或更智能的方法来实现 represent。为此,我们首先必须为 SWAP 实现 represent。
-
决定是否要在构造函数中包含上限索引。
-
修复绘图中 Rk 门的打印。
class sympy.physics.quantum.qft.IQFT(*args, **kwargs)
量子傅里叶逆变换。
decompose()
将 IQFT 分解为基本门。
class sympy.physics.quantum.qft.QFT(*args, **kwargs)
正向量子傅里叶变换。
decompose()
将 QFT 分解为基本门。
sympy.physics.quantum.qft.Rk
RkGate
的别名。
class sympy.physics.quantum.qft.RkGate(*args)
这是 QTF 的 R_k 门。
Qubit
原始文档:
docs.sympy.org/latest/modules/physics/quantum/qubit.html
量子计算的 Qubit。
Todo: * 完成实现测量逻辑。这应包括 POVM。 * 更新文档字符串。 * 更新测试。
class sympy.physics.quantum.qubit.IntQubit(*args, **kwargs)
存储整数作为 qubit 值的 qubit ket。
此类与 Qubit
之间的区别是:
-
构造函数的形式。
-
qubit 值以其相应的整数形式打印,而不是原始 qubit 值。qubit 值的内部存储格式与
Qubit
相同。
参数:
values : 整数,元组
如果是单个参数,是我们想要表示在 qubit 值中的整数。这个整数将使用尽可能少的 qubit 数来表示。如果是一对整数,第二个值超过一个,那么第一个整数以二进制形式表示我们要表示的整数,第二个整数给出要使用的 qubit 数量。也接受零和一的列表以按位模式生成 qubit。
nqubits : 整数
表示 qubit 数量的整数。应使用关键字
nqubits=N
传递此数字。您可以使用此功能来避免 Qubit 样式的位元组的歧义。有关更多详细信息,请参见下面的示例。
示例
创建整数 5 的 qubit:
>>> from sympy.physics.quantum.qubit import IntQubit
>>> from sympy.physics.quantum.qubit import Qubit
>>> q = IntQubit(5)
>>> q
|5>
我们还可以通过传递 Qubit
实例来创建 IntQubit
。
>>> q = IntQubit(Qubit('101'))
>>> q
|5>
>>> q.as_int()
5
>>> q.nqubits
3
>>> q.qubit_values
(1, 0, 1)
我们可以回到常规的 qubit 形式。
>>> Qubit(q)
|101>
请注意,IntQubit
还接受 Qubit
风格的位列表。因此,下面的代码产生的是 3 个 qubits,而不是单个位 1
。
>>> IntQubit(1, 1)
|3>
为避免歧义,请使用 nqubits
参数。特别是在通过变量提供值时,建议使用此关键字。
>>> IntQubit(1, nqubits=1)
|1>
>>> a = 1
>>> IntQubit(a, nqubits=1)
|1>
class sympy.physics.quantum.qubit.IntQubitBra(*args, **kwargs)
存储整数作为 qubit 值的 qubit bra。
class sympy.physics.quantum.qubit.Qubit(*args, **kwargs)
在计算(z)基础上的多 qubit ket。
我们使用正常约定,即最低有效 qubit 在右侧,因此 |00001>
在最低有效 qubit 中有 1。
参数:
values : 列表,字符串
qubit 值作为整数列表([0,0,0,1,1,])或字符串(‘011’)。
示例
以几种不同的方式创建 qubit 并查看它们的属性:
>>> from sympy.physics.quantum.qubit import Qubit
>>> Qubit(0,0,0)
|000>
>>> q = Qubit('0101')
>>> q
|0101>
>>> q.nqubits
4
>>> len(q)
4
>>> q.dimension
4
>>> q.qubit_values
(0, 1, 0, 1)
我们可以翻转单个 qubit 的值:
>>> q.flip(1)
|0111>
我们可以取 Qubit 的 dagger 来得到一个 bra:
>>> from sympy.physics.quantum.dagger import Dagger
>>> Dagger(q)
<0101|
>>> type(Dagger(q))
<class 'sympy.physics.quantum.qubit.QubitBra'>
内积按预期工作:
>>> ip = Dagger(q)*q
>>> ip
<0101|0101>
>>> ip.doit()
1
class sympy.physics.quantum.qubit.QubitBra(*args, **kwargs)
在计算(z)基础上的多 qubit bra。
我们使用正常约定,即最低有效 qubit 在右侧,因此 |00001>
在最低有效 qubit 中有 1。
参数:
values : 列表,字符串
qubit 值作为整数列表([0,0,0,1,1,])或字符串(‘011’)。
参见
Qubit
使用 qubits 的示例
sympy.physics.quantum.qubit.matrix_to_density(mat)
通过找到矩阵的特征向量和特征值来工作。我们知道可以通过以下方式分解 rho:sum(EigenVal*|Eigenvect><Eigenvect|)
sympy.physics.quantum.qubit.matrix_to_qubit(matrix)
从矩阵表示转换为一组 Qubit 对象的总和。
参数:
matrix : 矩阵,numpy.matrix,scipy.sparse
构建 Qubit 表示的矩阵。适用于 SymPy 矩阵、numpy 矩阵和 scipy.sparse 稀疏矩阵。
示例
表示一个状态,然后返回其 Qubit 形式:
>>> from sympy.physics.quantum.qubit import matrix_to_qubit, Qubit
>>> from sympy.physics.quantum.represent import represent
>>> q = Qubit('01')
>>> matrix_to_qubit(represent(q))
|01>
sympy.physics.quantum.qubit.measure_all(qubit, format='sympy', normalize=True)
对所有量子位执行集合测量。
参数:
qubit : Qubit, Add
要测量的量子位(qubit)。可以是任何量子位或它们的线性组合。
format : 字符串
要使用的中间矩阵的格式。可能的值为(‘sympy’,‘numpy’,‘scipy.sparse’)。目前只实现了‘sympy’。
返回:
result : 列表
由原始状态及其概率组成的列表。
示例
>>> from sympy.physics.quantum.qubit import Qubit, measure_all
>>> from sympy.physics.quantum.gate import H
>>> from sympy.physics.quantum.qapply import qapply
>>> c = H(0)*H(1)*Qubit('00')
>>> c
H(0)*H(1)*|00>
>>> q = qapply(c)
>>> measure_all(q)
[(|00>, 1/4), (|01>, 1/4), (|10>, 1/4), (|11>, 1/4)]
sympy.physics.quantum.qubit.measure_all_oneshot(qubit, format='sympy')
对所有量子位执行一次性集合测量。
一次性测量等同于对量子系统进行测量。这种类型的测量不像集合测量那样返回概率,而是返回可能结果中的一个。返回的确切状态是根据集合概率随机选择的。
参数:
qubits : Qubit
要测量的量子位。可以是任何量子位或它们的线性组合。
format : 字符串
要使用的中间矩阵的格式。可能的值为(‘sympy’,‘numpy’,‘scipy.sparse’)。目前只实现了‘sympy’。
返回:
result : Qubit
系统在测量时崩溃到的量子位。
sympy.physics.quantum.qubit.measure_partial(qubit, bits, format='sympy', normalize=True)
对指定量子位执行部分集合测量。
参数:
qubits : Qubit
要测量的量子位。可以是任何量子位或它们的线性组合。
bits : 元组
要测量的量子位。
format : 字符串
要使用的中间矩阵的格式。可能的值为(‘sympy’,‘numpy’,‘scipy.sparse’)。目前只实现了‘sympy’。
返回:
result : 列表
由原始状态及其概率组成的列表。
示例
>>> from sympy.physics.quantum.qubit import Qubit, measure_partial
>>> from sympy.physics.quantum.gate import H
>>> from sympy.physics.quantum.qapply import qapply
>>> c = H(0)*H(1)*Qubit('00')
>>> c
H(0)*H(1)*|00>
>>> q = qapply(c)
>>> measure_partial(q, (0,))
[(sqrt(2)*|00>/2 + sqrt(2)*|10>/2, 1/2), (sqrt(2)*|01>/2 + sqrt(2)*|11>/2, 1/2)]
sympy.physics.quantum.qubit.measure_partial_oneshot(qubit, bits, format='sympy')
对指定量子位执行部分一次性测量。
一次性测量等同于对量子系统进行测量。这种类型的测量不像集合测量那样返回概率,而是返回可能结果中的一个。返回的确切状态是根据集合概率随机选择的。
参数:
qubits : Qubit
要测量的量子位。可以是任何量子位或它们的线性组合。
bits : 元组
要测量的量子位。
format : 字符串
要使用的中间矩阵的格式。可能的值为(‘sympy’,‘numpy’,‘scipy.sparse’)。目前只实现了‘sympy’。
返回:
result : Qubit
系统在测量时崩溃到的量子位。
sympy.physics.quantum.qubit.qubit_to_matrix(qubit, format='sympy')
将 Qubit 对象的 Add/Mul 转换为其矩阵表示
此函数是matrix_to_qubit
的反函数,是represent(qubit)
的简写。
Shor 算法
原文链接:
docs.sympy.org/latest/modules/physics/quantum/shor.html
Shor 算法及其辅助函数。
待办事项:
-
使用新的 Gate API 重新使 CMod 门工作。
-
修复一切。
-
更新文档字符串并重新格式化。
class sympy.physics.quantum.shor.CMod(*args, **kwargs)
一个控制的模门。
这是用于 Shor 算法的黑盒子控制模函数。TODO:实现一个 decompose 属性,以元素门的术语返回如何执行此操作。
property N
N 是我们进行的模算术的类型。
property a
控制模函数的基础。
property t
1/2 输入寄存器的大小。前半部分保存输出。
sympy.physics.quantum.shor.period_find(a, N)
在模 N 算术中找到 a 的周期
这是 Shor 算法的量子部分。它接受两个寄存器,将第一个置于哈达玛德变换的状态叠加中:|k>|0>
,其中 k 是所有可能的选择。然后进行一个控制模门和一个量子傅立叶变换以确定 a 的阶。
sympy.physics.quantum.shor.shor(N)
这个函数在整数 N 上实现了 Shor 的因数分解算法。
算法首先随机选择一个数(a),并检查它是否与 N 互质。如果不是,则两个数的最大公约数是一个因子,我们完成了。否则,它开始执行 period_finding 子例程,用于找到在模 N 算术中 a 的周期。如果这个周期是偶数,可以通过取 a(r/2)-1 和 a(r/2)+1 来计算因子。这些值被返回。
盒中的粒子
1D 量子盒子中的粒子。
class sympy.physics.quantum.piab.PIABBra(*args, **kwargs)
粒子在盒子中的本征矢。
class sympy.physics.quantum.piab.PIABHamiltonian(*args, **kwargs)
粒子在盒子中的哈密顿算符。
class sympy.physics.quantum.piab.PIABKet(*args, **kwargs)
粒子在盒子中的本征态。
光学模块
-
高斯光学
-
介质
-
极化
-
实用工具
-
波
高斯光学
原文链接:
docs.sympy.org/latest/modules/physics/optics/gaussopt.html
高斯光学。
模块实现:
-
几何光学和高斯光学的射线传输矩阵。
参见 RayTransferMatrix,GeometricRay 和 BeamParameter
-
几何光学和高斯光学的共轭关系。
查看 geometric_conj*, gauss_conj 和 conjugate_gauss_beams
距离的惯例如下:
焦距
对于会聚透镜为正
物体距离
对于真实物体为正
图像距离
对于真实图像为正
class sympy.physics.optics.gaussopt.BeamParameter(wavelen, z, z_r=None, w=None, n=1)
高斯光线在射线传输矩阵形式主义中的表示。
参数:
wavelen : 波长,
z : 腰部距离,以及
w : 腰部,或
z_r : 雷利范围。
n : 介质的折射率。
示例
>>> from sympy.physics.optics import BeamParameter
>>> p = BeamParameter(530e-9, 1, w=1e-3)
>>> p.q
1 + 1.88679245283019*I*pi
>>> p.q.n()
1.0 + 5.92753330865999*I
>>> p.w_0.n()
0.00100000000000000
>>> p.z_r.n()
5.92753330865999
>>> from sympy.physics.optics import FreeSpace
>>> fs = FreeSpace(10)
>>> p1 = fs*p
>>> p.w.n()
0.00101413072159615
>>> p1.w.n()
0.00210803120913829
另见
RayTransferMatrix
参考文献
[R740]
en.wikipedia.org/wiki/Complex_beam_parameter
[R741]
en.wikipedia.org/wiki/Gaussian_beam
property divergence
总角度扩展的一半。
示例
>>> from sympy.physics.optics import BeamParameter
>>> p = BeamParameter(530e-9, 1, w=1e-3)
>>> p.divergence
0.00053/pi
property gouy
Gouy 相位。
示例
>>> from sympy.physics.optics import BeamParameter
>>> p = BeamParameter(530e-9, 1, w=1e-3)
>>> p.gouy
atan(0.53/pi)
property q
表示光束的复参数。
示例
>>> from sympy.physics.optics import BeamParameter
>>> p = BeamParameter(530e-9, 1, w=1e-3)
>>> p.q
1 + 1.88679245283019*I*pi
property radius
相位前沿的曲率半径。
示例
>>> from sympy.physics.optics import BeamParameter
>>> p = BeamParameter(530e-9, 1, w=1e-3)
>>> p.radius
1 + 3.55998576005696*pi**2
property w
在光束沿着光束的任何位置 z 处的光束半径 w(z)。光束半径在(1/e²)强度(轴向值)处。
示例
>>> from sympy.physics.optics import BeamParameter
>>> p = BeamParameter(530e-9, 1, w=1e-3)
>>> p.w
0.001*sqrt(0.2809/pi**2 + 1)
另见
w_0
光束的最小半径。
property w_0
光束在(1/e²)强度(峰值)处的最小半径。
示例
>>> from sympy.physics.optics import BeamParameter
>>> p = BeamParameter(530e-9, 1, w=1e-3)
>>> p.w_0
0.00100000000000000
另见
w
光束在(1/e²)强度(轴向值)处的光束半径。
property waist_approximation_limit
适用于高斯光束近似有效的最小腰部。
解释
高斯光束是抛物近轴方程的解。对于曲率太大的情况,这不是一个有效的近似。
示例
>>> from sympy.physics.optics import BeamParameter
>>> p = BeamParameter(530e-9, 1, w=1e-3)
>>> p.waist_approximation_limit
1.06e-6/pi
class sympy.physics.optics.gaussopt.CurvedMirror(R)
曲面反射的射线传输矩阵。
参数:
R : 曲率半径(凹面为正)
示例
>>> from sympy.physics.optics import CurvedMirror
>>> from sympy import symbols
>>> R = symbols('R')
>>> CurvedMirror(R)
Matrix([
[ 1, 0],
[-2/R, 1]])
另见
RayTransferMatrix
class sympy.physics.optics.gaussopt.CurvedRefraction(R, n1, n2)
曲面间折射的射线传输矩阵。
参数:
R :
曲率半径(凹面为正)。
n1 :
单个介质的折射率。
n2 :
其他介质的折射率。
示例
>>> from sympy.physics.optics import CurvedRefraction
>>> from sympy import symbols
>>> R, n1, n2 = symbols('R n1 n2')
>>> CurvedRefraction(R, n1, n2)
Matrix([
[ 1, 0],
[(n1 - n2)/(R*n2), n1/n2]])
另见
RayTransferMatrix
class sympy.physics.optics.gaussopt.FlatMirror
反射的射线传输矩阵。
示例
>>> from sympy.physics.optics import FlatMirror
>>> FlatMirror()
Matrix([
[1, 0],
[0, 1]])
另见
RayTransferMatrix
class sympy.physics.optics.gaussopt.FlatRefraction(n1, n2)
折射的射线传输矩阵。
参数:
n1 :
单个介质的折射率。
n2 :
其他介质的折射率。
示例
>>> from sympy.physics.optics import FlatRefraction
>>> from sympy import symbols
>>> n1, n2 = symbols('n1 n2')
>>> FlatRefraction(n1, n2)
Matrix([
[1, 0],
[0, n1/n2]])
另见
RayTransferMatrix
class sympy.physics.optics.gaussopt.FreeSpace(d)
自由空间的光线传输矩阵。
参数:
distance
示例
>>> from sympy.physics.optics import FreeSpace
>>> from sympy import symbols
>>> d = symbols('d')
>>> FreeSpace(d)
Matrix([
[1, d],
[0, 1]])
另见
RayTransferMatrix
class sympy.physics.optics.gaussopt.GeometricRay(*args)
几何光线在射线传输矩阵形式化中的表示。
参数:
h : 高度,和
angle : 角度,或
matrix : a 2x1 matrix (Matrix(2, 1, [height, angle]))
示例
>>> from sympy.physics.optics import GeometricRay, FreeSpace
>>> from sympy import symbols, Matrix
>>> d, h, angle = symbols('d, h, angle')
>>> GeometricRay(h, angle)
Matrix([
[ h],
[angle]])
>>> FreeSpace(d)*GeometricRay(h, angle)
Matrix([
[angle*d + h],
[ angle]])
>>> GeometricRay( Matrix( ((h,), (angle,)) ) )
Matrix([
[ h],
[angle]])
另见
RayTransferMatrix
property angle
光轴角度。
示例
>>> from sympy.physics.optics import GeometricRay
>>> from sympy import symbols
>>> h, angle = symbols('h, angle')
>>> gRay = GeometricRay(h, angle)
>>> gRay.angle
angle
property height
光轴距离。
示例
>>> from sympy.physics.optics import GeometricRay
>>> from sympy import symbols
>>> h, angle = symbols('h, angle')
>>> gRay = GeometricRay(h, angle)
>>> gRay.height
h
class sympy.physics.optics.gaussopt.RayTransferMatrix(*args)
射线传输矩阵的基类。
如果“参见”中没有更具体的子类,则应使用此选项。
参数:
parameters :
A, B, C and D or 2x2 matrix (Matrix(2, 2, [A, B, C, D]))
示例
>>> from sympy.physics.optics import RayTransferMatrix, ThinLens
>>> from sympy import Symbol, Matrix
>>> mat = RayTransferMatrix(1, 2, 3, 4)
>>> mat
Matrix([
[1, 2],
[3, 4]])
>>> RayTransferMatrix(Matrix([[1, 2], [3, 4]]))
Matrix([
[1, 2],
[3, 4]])
>>> mat.A
1
>>> f = Symbol('f')
>>> lens = ThinLens(f)
>>> lens
Matrix([
[ 1, 0],
[-1/f, 1]])
>>> lens.C
-1/f
另见
GeometricRay
, BeamParameter
, FreeSpace
, FlatRefraction
, CurvedRefraction
, FlatMirror
, CurvedMirror
, ThinLens
参考文献
[R742]
en.wikipedia.org/wiki/Ray_transfer_matrix_analysis
property A
矩阵的参数 A。
示例
>>> from sympy.physics.optics import RayTransferMatrix
>>> mat = RayTransferMatrix(1, 2, 3, 4)
>>> mat.A
1
property B
矩阵的参数 B。
示例
>>> from sympy.physics.optics import RayTransferMatrix
>>> mat = RayTransferMatrix(1, 2, 3, 4)
>>> mat.B
2
property C
矩阵的参数 C。
示例
>>> from sympy.physics.optics import RayTransferMatrix
>>> mat = RayTransferMatrix(1, 2, 3, 4)
>>> mat.C
3
property D
矩阵的参数 D。
示例
>>> from sympy.physics.optics import RayTransferMatrix
>>> mat = RayTransferMatrix(1, 2, 3, 4)
>>> mat.D
4
class sympy.physics.optics.gaussopt.ThinLens(f)
薄透镜的光线传输矩阵。
参数:
f :
焦距。
示例
>>> from sympy.physics.optics import ThinLens
>>> from sympy import symbols
>>> f = symbols('f')
>>> ThinLens(f)
Matrix([
[ 1, 0],
[-1/f, 1]])
另见
RayTransferMatrix
sympy.physics.optics.gaussopt.conjugate_gauss_beams(wavelen, waist_in, waist_out, **kwargs)
找到将物体/像腰部共轭的光学设置。
参数:
wavelen :
光束的波长。
waist_in and waist_out :
要共轭的腰部。
f :
用于共轭中使用的元件的焦距。
返回:
一个包含(s_in, s_out, f)的元组。
s_in :
光学元件前的距离。
s_out :
光学元件后的距离。
f :
光学元件的焦距。
示例
>>> from sympy.physics.optics import conjugate_gauss_beams
>>> from sympy import symbols, factor
>>> l, w_i, w_o, f = symbols('l w_i w_o f')
>>> conjugate_gauss_beams(l, w_i, w_o, f=f)[0]
f*(1 - sqrt(w_i**2/w_o**2 - pi**2*w_i**4/(f**2*l**2)))
>>> factor(conjugate_gauss_beams(l, w_i, w_o, f=f)[1])
f*w_o**2*(w_i**2/w_o**2 - sqrt(w_i**2/w_o**2 -
pi**2*w_i**4/(f**2*l**2)))/w_i**2
>>> conjugate_gauss_beams(l, w_i, w_o, f=f)[2]
f
sympy.physics.optics.gaussopt.gaussian_conj(s_in, z_r_in, f)
高斯光束的共轭关系。
参数:
s_in :
光学元件距离腰部的距离。
z_r_in :
入射光束的瑞利范围。
f :
光学元件的焦距。
返回:
包含 (s_out, z_r_out, m) 的元组
s_out :
新腰部与光学元件之间的距离。
z_r_out :
出射光束的瑞利范围。
m :
新旧腰部之间的比率。
示例
>>> from sympy.physics.optics import gaussian_conj
>>> from sympy import symbols
>>> s_in, z_r_in, f = symbols('s_in z_r_in f')
>>> gaussian_conj(s_in, z_r_in, f)[0]
1/(-1/(s_in + z_r_in**2/(-f + s_in)) + 1/f)
>>> gaussian_conj(s_in, z_r_in, f)[1]
z_r_in/(1 - s_in**2/f**2 + z_r_in**2/f**2)
>>> gaussian_conj(s_in, z_r_in, f)[2]
1/sqrt(1 - s_in**2/f**2 + z_r_in**2/f**2)
sympy.physics.optics.gaussopt.geometric_conj_ab(a, b)
偏轴条件下几何光束的共轭关系。
解释
获取到光学元件的距离,并返回所需的焦距。
示例
>>> from sympy.physics.optics import geometric_conj_ab
>>> from sympy import symbols
>>> a, b = symbols('a b')
>>> geometric_conj_ab(a, b)
a*b/(a + b)
参见
geometric_conj_af
, geometric_conj_bf
sympy.physics.optics.gaussopt.geometric_conj_af(a, f)
偏轴条件下几何光束的共轭关系。
解释
获取光学元件的物距(用于 geometric_conj_af)或像距(用于 geometric_conj_bf)和焦距。然后返回共轭所需的另一个距离。
示例
>>> from sympy.physics.optics.gaussopt import geometric_conj_af, geometric_conj_bf
>>> from sympy import symbols
>>> a, b, f = symbols('a b f')
>>> geometric_conj_af(a, f)
a*f/(a - f)
>>> geometric_conj_bf(b, f)
b*f/(b - f)
参见
geometric_conj_ab
sympy.physics.optics.gaussopt.geometric_conj_bf(a, f)
偏轴条件下几何光束的共轭关系。
解释
获取光学元件的物距(用于 geometric_conj_af)或像距(用于 geometric_conj_bf)和焦距。然后返回共轭所需的另一个距离。
示例
>>> from sympy.physics.optics.gaussopt import geometric_conj_af, geometric_conj_bf
>>> from sympy import symbols
>>> a, b, f = symbols('a b f')
>>> geometric_conj_af(a, f)
a*f/(a - f)
>>> geometric_conj_bf(b, f)
b*f/(b - f)
参见
geometric_conj_ab
sympy.physics.optics.gaussopt.rayleigh2waist(z_r, wavelen)
计算高斯光束的腰部从瑞利范围。
示例
>>> from sympy.physics.optics import rayleigh2waist
>>> from sympy import symbols
>>> z_r, wavelen = symbols('z_r wavelen')
>>> rayleigh2waist(z_r, wavelen)
sqrt(wavelen*z_r)/sqrt(pi)
参见
waist2rayleigh
, BeamParameter
sympy.physics.optics.gaussopt.waist2rayleigh(w, wavelen, n=1)
计算高斯光束从腰部到瑞利范围的光线范围。
示例
>>> from sympy.physics.optics import waist2rayleigh
>>> from sympy import symbols
>>> w, wavelen = symbols('w wavelen')
>>> waist2rayleigh(w, wavelen)
pi*w**2/wavelen
参见
rayleigh2waist
, BeamParameter
介质
包含
- 介质
class sympy.physics.optics.medium.Medium(name, permittivity=None, permeability=None, n=None)
这个类表示一个光学介质。实施这一点的主要原因是为了促进折射、费马原理等。
参数:
名称:字符串
介质的显示名称。
电容率:可以符号化
空间的电介质常数。
磁导率:可以符号化
空间的磁导率。
n:可以符号化
介质的折射率。
解释
光学介质是电磁波传播的材料。介质的电容率和磁导率决定了电磁波在其中的传播方式。
例子
>>> from sympy.abc import epsilon, mu
>>> from sympy.physics.optics import Medium
>>> m1 = Medium('m1')
>>> m2 = Medium('m2', epsilon, mu)
>>> m1.intrinsic_impedance
149896229*pi*kilogram*meter**2/(1250000*ampere**2*second**3)
>>> m2.refractive_index
299792458*meter*sqrt(epsilon*mu)/second
参考文献
[R743]
en.wikipedia.org/wiki/Optical_medium
property refractive_index
返回介质的折射率。
例子
>>> from sympy.physics.optics import Medium
>>> m = Medium('m')
>>> m.refractive_index
1
property speed
返回介质中电磁波的传播速度。
例子
>>> from sympy.physics.optics import Medium
>>> m = Medium('m')
>>> m.speed
299792458*meter/second
>>> m2 = Medium('m2', n=1)
>>> m.speed == m2.speed
True
极化
原文:
docs.sympy.org/latest/modules/physics/optics/polarization.html
该模块实现了光场极化建模的例程,并可用于计算极化光元件对场的影响。
-
Jones 矢量。
-
Stokes 矢量。
-
Jones 矩阵。
-
Mueller 矩阵。
示例
我们计算一个通用的 Jones 矢量:
>>> from sympy import symbols, pprint, zeros, simplify
>>> from sympy.physics.optics.polarization import (jones_vector, stokes_vector,
... half_wave_retarder, polarizing_beam_splitter, jones_2_stokes)
>>> psi, chi, p, I0 = symbols("psi, chi, p, I0", real=True)
>>> x0 = jones_vector(psi, chi)
>>> pprint(x0, use_unicode=True)
⎡-ⅈ⋅sin(χ)⋅sin(ψ) + cos(χ)⋅cos(ψ)⎤
⎢ ⎥
⎣ⅈ⋅sin(χ)⋅cos(ψ) + sin(ψ)⋅cos(χ) ⎦
以及更一般的 Stokes 矢量:
>>> s0 = stokes_vector(psi, chi, p, I0)
>>> pprint(s0, use_unicode=True)
⎡ I₀ ⎤
⎢ ⎥
⎢I₀⋅p⋅cos(2⋅χ)⋅cos(2⋅ψ)⎥
⎢ ⎥
⎢I₀⋅p⋅sin(2⋅ψ)⋅cos(2⋅χ)⎥
⎢ ⎥
⎣ I₀⋅p⋅sin(2⋅χ) ⎦
我们计算 Jones 矢量如何被半波片修改:
>>> alpha = symbols("alpha", real=True)
>>> HWP = half_wave_retarder(alpha)
>>> x1 = simplify(HWP*x0)
我们计算将光束通过半波片,然后通过偏振分束器的常见操作。我们通过将这个 Jones 矢量作为第一个条目放入一个模拟偏振分束器的 4x4 Jones 矩阵的两个 Jones 矢量状态来实现这一点,以获得传输和反射的 Jones 矢量:
>>> PBS = polarizing_beam_splitter()
>>> X1 = zeros(4, 1)
>>> X1[:2, :] = x1
>>> X2 = PBS*X1
>>> transmitted_port = X2[:2, :]
>>> reflected_port = X2[2:, :]
这使我们能够计算两个端口中的功率如何依赖于初始极化:
>>> transmitted_power = jones_2_stokes(transmitted_port)[0]
>>> reflected_power = jones_2_stokes(reflected_port)[0]
>>> print(transmitted_power)
cos(-2*alpha + chi + psi)**2/2 + cos(2*alpha + chi - psi)**2/2
>>> print(reflected_power)
sin(-2*alpha + chi + psi)**2/2 + sin(2*alpha + chi - psi)**2/2
请查看单个函数的描述以获取更多详细信息和示例。
References
[R744]
en.wikipedia.org/wiki/Jones_calculus
[R745]
en.wikipedia.org/wiki/Mueller_calculus
[R746]
en.wikipedia.org/wiki/Stokes_parameters
sympy.physics.optics.polarization.half_wave_retarder(theta)
角度为theta
的半波片 Jones 矩阵。
Parameters:
theta : 数值类型或 SymPy 符号
快轴相对于水平面的角度。
Returns:
SymPy 矩阵
表示减速器的 Jones 矩阵。
示例
一个通用的半波片。
>>> from sympy import pprint, symbols
>>> from sympy.physics.optics.polarization import half_wave_retarder
>>> theta= symbols("theta", real=True)
>>> HWP = half_wave_retarder(theta)
>>> pprint(HWP, use_unicode=True)
⎡ ⎛ 2 2 ⎞ ⎤
⎢-ⅈ⋅⎝- sin (θ) + cos (θ)⎠ -2⋅ⅈ⋅sin(θ)⋅cos(θ) ⎥
⎢ ⎥
⎢ ⎛ 2 2 ⎞⎥
⎣ -2⋅ⅈ⋅sin(θ)⋅cos(θ) -ⅈ⋅⎝sin (θ) - cos (θ)⎠⎦
sympy.physics.optics.polarization.jones_2_stokes(e)
返回 Jones 矢量e
的 Stokes 矢量。
Parameters:
e : SymPy 矩阵
一个 Jones 矢量。
Returns:
SymPy 矩阵
一个 Jones 矢量。
示例
Poincaré球上的轴。
>>> from sympy import pprint, pi
>>> from sympy.physics.optics.polarization import jones_vector
>>> from sympy.physics.optics.polarization import jones_2_stokes
>>> H = jones_vector(0, 0)
>>> V = jones_vector(pi/2, 0)
>>> D = jones_vector(pi/4, 0)
>>> A = jones_vector(-pi/4, 0)
>>> R = jones_vector(0, pi/4)
>>> L = jones_vector(0, -pi/4)
>>> pprint([jones_2_stokes(e) for e in [H, V, D, A, R, L]],
... use_unicode=True)
⎡⎡1⎤ ⎡1 ⎤ ⎡1⎤ ⎡1 ⎤ ⎡1⎤ ⎡1 ⎤⎤
⎢⎢ ⎥ ⎢ ⎥ ⎢ ⎥ ⎢ ⎥ ⎢ ⎥ ⎢ ⎥⎥
⎢⎢1⎥ ⎢-1⎥ ⎢0⎥ ⎢0 ⎥ ⎢0⎥ ⎢0 ⎥⎥
⎢⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥, ⎢ ⎥⎥
⎢⎢0⎥ ⎢0 ⎥ ⎢1⎥ ⎢-1⎥ ⎢0⎥ ⎢0 ⎥⎥
⎢⎢ ⎥ ⎢ ⎥ ⎢ ⎥ ⎢ ⎥ ⎢ ⎥ ⎢ ⎥⎥
⎣⎣0⎦ ⎣0 ⎦ ⎣0⎦ ⎣0 ⎦ ⎣1⎦ ⎣-1⎦⎦
sympy.physics.optics.polarization.jones_vector(psi, chi)
一个与极化椭圆(具有(psi)倾斜和(chi)圆度)对应的 Jones 矢量。
Parameters:
psi : 数值类型或 SymPy 符号
相对于(x)轴的极化倾斜。
chi : 数值类型或 SymPy 符号
极化椭圆主轴相邻的角度。
Returns:
矩阵 :
一个 Jones 矢量。
示例
Poincaré球上的轴。
>>> from sympy import pprint, symbols, pi
>>> from sympy.physics.optics.polarization import jones_vector
>>> psi, chi = symbols("psi, chi", real=True)
一个通用的 Jones 矢量。
>>> pprint(jones_vector(psi, chi), use_unicode=True)
⎡-ⅈ⋅sin(χ)⋅sin(ψ) + cos(χ)⋅cos(ψ)⎤
⎢ ⎥
⎣ⅈ⋅sin(χ)⋅cos(ψ) + sin(ψ)⋅cos(χ) ⎦
水平极化。
>>> pprint(jones_vector(0, 0), use_unicode=True)
⎡1⎤
⎢ ⎥
⎣0⎦
垂直极化。
>>> pprint(jones_vector(pi/2, 0), use_unicode=True)
⎡0⎤
⎢ ⎥
⎣1⎦
对角极化。
>>> pprint(jones_vector(pi/4, 0), use_unicode=True)
⎡√2⎤
⎢──⎥
⎢2 ⎥
⎢ ⎥
⎢√2⎥
⎢──⎥
⎣2 ⎦
反对角极化。
>>> pprint(jones_vector(-pi/4, 0), use_unicode=True)
⎡ √2 ⎤
⎢ ── ⎥
⎢ 2 ⎥
⎢ ⎥
⎢-√2 ⎥
⎢────⎥
⎣ 2 ⎦
右旋圆极化。
>>> pprint(jones_vector(0, pi/4), use_unicode=True)
⎡ √2 ⎤
⎢ ── ⎥
⎢ 2 ⎥
⎢ ⎥
⎢√2⋅ⅈ⎥
⎢────⎥
⎣ 2 ⎦
左旋圆极化。
>>> pprint(jones_vector(0, -pi/4), use_unicode=True)
⎡ √2 ⎤
⎢ ── ⎥
⎢ 2 ⎥
⎢ ⎥
⎢-√2⋅ⅈ ⎥
⎢──────⎥
⎣ 2 ⎦
sympy.physics.optics.polarization.linear_polarizer(theta=0)
一个带有传输轴角度为theta
的线性偏振器 Jones 矩阵。
Parameters:
theta : 数值类型或 SymPy 符号
传输轴相对于水平面的角度。
Returns:
SymPy 矩阵
表示偏振器的 Jones 矩阵。
示例
一个通用的偏振器。
>>> from sympy import pprint, symbols
>>> from sympy.physics.optics.polarization import linear_polarizer
>>> theta = symbols("theta", real=True)
>>> J = linear_polarizer(theta)
>>> pprint(J, use_unicode=True)
⎡ 2 ⎤
⎢ cos (θ) sin(θ)⋅cos(θ)⎥
⎢ ⎥
⎢ 2 ⎥
⎣sin(θ)⋅cos(θ) sin (θ) ⎦
sympy.physics.optics.polarization.mueller_matrix(J)
与 Jones 矩阵(J)对应的 Mueller 矩阵。
Parameters:
J : SymPy 矩阵
一个 Jones 矩阵。
Returns:
SymPy 矩阵
相应的 Mueller 矩阵。
示例
通用光学元件。
>>> from sympy import pprint, symbols
>>> from sympy.physics.optics.polarization import (mueller_matrix,
... linear_polarizer, half_wave_retarder, quarter_wave_retarder)
>>> theta = symbols("theta", real=True)
一个线性偏振器
>>> pprint(mueller_matrix(linear_polarizer(theta)), use_unicode=True)
⎡ cos(2⋅θ) sin(2⋅θ) ⎤
⎢ 1/2 ──────── ──────── 0⎥
⎢ 2 2 ⎥
⎢ ⎥
⎢cos(2⋅θ) cos(4⋅θ) 1 sin(4⋅θ) ⎥
⎢──────── ──────── + ─ ──────── 0⎥
⎢ 2 4 4 4 ⎥
⎢ ⎥
⎢sin(2⋅θ) sin(4⋅θ) 1 cos(4⋅θ) ⎥
⎢──────── ──────── ─ - ──────── 0⎥
⎢ 2 4 4 4 ⎥
⎢ ⎥
⎣ 0 0 0 0⎦
一个半波片
>>> pprint(mueller_matrix(half_wave_retarder(theta)), use_unicode=True)
⎡1 0 0 0 ⎤
⎢ ⎥
⎢ 4 2 ⎥
⎢0 8⋅sin (θ) - 8⋅sin (θ) + 1 sin(4⋅θ) 0 ⎥
⎢ ⎥
⎢ 4 2 ⎥
⎢0 sin(4⋅θ) - 8⋅sin (θ) + 8⋅sin (θ) - 1 0 ⎥
⎢ ⎥
⎣0 0 0 -1⎦
一个四分之一波片
>>> pprint(mueller_matrix(quarter_wave_retarder(theta)), use_unicode=True)
⎡1 0 0 0 ⎤
⎢ ⎥
⎢ cos(4⋅θ) 1 sin(4⋅θ) ⎥
⎢0 ──────── + ─ ──────── -sin(2⋅θ)⎥
⎢ 2 2 2 ⎥
⎢ ⎥
⎢ sin(4⋅θ) 1 cos(4⋅θ) ⎥
⎢0 ──────── ─ - ──────── cos(2⋅θ) ⎥
⎢ 2 2 2 ⎥
⎢ ⎥
⎣0 sin(2⋅θ) -cos(2⋅θ) 0 ⎦
sympy.physics.optics.polarization.phase_retarder(theta=0, delta=0)
在角度 theta
处具有 delta
减速度的相位减速器 Jones 矩阵。
参数:
theta:数值类型或 SymPy 符号
快轴相对于水平面的角度。
delta:数值类型或 SymPy 符号
传输光的快轴和慢轴之间的相位差。
返回:
SymPy 矩阵:
代表减速器的 Jones 矩阵。
示例
通用减速器。
>>> from sympy import pprint, symbols
>>> from sympy.physics.optics.polarization import phase_retarder
>>> theta, delta = symbols("theta, delta", real=True)
>>> R = phase_retarder(theta, delta)
>>> pprint(R, use_unicode=True)
⎡ -ⅈ⋅δ -ⅈ⋅δ ⎤
⎢ ───── ───── ⎥
⎢⎛ ⅈ⋅δ 2 2 ⎞ 2 ⎛ ⅈ⋅δ⎞ 2 ⎥
⎢⎝ℯ ⋅sin (θ) + cos (θ)⎠⋅ℯ ⎝1 - ℯ ⎠⋅ℯ ⋅sin(θ)⋅cos(θ)⎥
⎢ ⎥
⎢ -ⅈ⋅δ -ⅈ⋅δ ⎥
⎢ ───── ─────⎥
⎢⎛ ⅈ⋅δ⎞ 2 ⎛ ⅈ⋅δ 2 2 ⎞ 2 ⎥
⎣⎝1 - ℯ ⎠⋅ℯ ⋅sin(θ)⋅cos(θ) ⎝ℯ ⋅cos (θ) + sin (θ)⎠⋅ℯ ⎦
sympy.physics.optics.polarization.polarizing_beam_splitter(Tp=1, Rs=1, Ts=0, Rp=0, phia=0, phib=0)
在角度 (theta) 处的偏振分光镜 Jones 矩阵。
参数:
J:SymPy 矩阵
一个 Jones 矩阵。
Tp:数值类型或 SymPy 符号
P 极化组分的透射率。
Rs:数值类型或 SymPy 符号
S 极化组分的反射率。
Ts:数值类型或 SymPy 符号
S 极化组分的透射率。
Rp:数值类型或 SymPy 符号
P 极化组分的反射率。
phia:数值类型或 SymPy 符号
输出模式 a 的传输和反射组分之间的相位差。
phib:数值类型或 SymPy 符号
输出模式 b 的传输和反射组分之间的相位差。
返回:
SymPy 矩阵
代表 PBS 的 4x4 矩阵。此矩阵作用于 4x1 向量,其前两个条目是 PBS 一个端口上的 Jones 矢量,后两个条目是另一个端口上的 Jones 矢量。
示例
通用偏振分光镜。
>>> from sympy import pprint, symbols
>>> from sympy.physics.optics.polarization import polarizing_beam_splitter
>>> Ts, Rs, Tp, Rp = symbols(r"Ts, Rs, Tp, Rp", positive=True)
>>> phia, phib = symbols("phi_a, phi_b", real=True)
>>> PBS = polarizing_beam_splitter(Tp, Rs, Ts, Rp, phia, phib)
>>> pprint(PBS, use_unicode=False)
[ ____ ____ ]
[ \/ Tp 0 I*\/ Rp 0 ]
[ ]
[ ____ ____ I*phi_a]
[ 0 \/ Ts 0 -I*\/ Rs *e ]
[ ]
[ ____ ____ ]
[I*\/ Rp 0 \/ Tp 0 ]
[ ]
[ ____ I*phi_b ____ ]
[ 0 -I*\/ Rs *e 0 \/ Ts ]
sympy.physics.optics.polarization.quarter_wave_retarder(theta)
在角度 theta
处的四分之一波减速器 Jones 矩阵。
参数:
theta:数值类型或 SymPy 符号
快轴相对于水平面的角度。
返回:
SymPy 矩阵
代表减速器的 Jones 矩阵。
示例
通用四分之一波片。
>>> from sympy import pprint, symbols
>>> from sympy.physics.optics.polarization import quarter_wave_retarder
>>> theta= symbols("theta", real=True)
>>> QWP = quarter_wave_retarder(theta)
>>> pprint(QWP, use_unicode=True)
⎡ -ⅈ⋅π -ⅈ⋅π ⎤
⎢ ───── ───── ⎥
⎢⎛ 2 2 ⎞ 4 4 ⎥
⎢⎝ⅈ⋅sin (θ) + cos (θ)⎠⋅ℯ (1 - ⅈ)⋅ℯ ⋅sin(θ)⋅cos(θ)⎥
⎢ ⎥
⎢ -ⅈ⋅π -ⅈ⋅π ⎥
⎢ ───── ─────⎥
⎢ 4 ⎛ 2 2 ⎞ 4 ⎥
⎣(1 - ⅈ)⋅ℯ ⋅sin(θ)⋅cos(θ) ⎝sin (θ) + ⅈ⋅cos (θ)⎠⋅ℯ ⎦
sympy.physics.optics.polarization.reflective_filter(R)
具有反射率 R
的反射型滤波器 Jones 矩阵。
参数:
R:数值类型或 SymPy 符号
滤波器的反射率。
返回:
SymPy 矩阵
代表滤波器的 Jones 矩阵。
示例
通用滤波器。
>>> from sympy import pprint, symbols
>>> from sympy.physics.optics.polarization import reflective_filter
>>> R = symbols("R", real=True)
>>> pprint(reflective_filter(R), use_unicode=True)
⎡√R 0 ⎤
⎢ ⎥
⎣0 -√R⎦
sympy.physics.optics.polarization.stokes_vector(psi, chi, p=1, I=1)
与极化椭圆的 Stokes 矢量相对应,其倾斜为 psi
,圆性为 chi
。
参数:
psi:数值类型或 SymPy 符号
相对于
x
轴的极化倾斜。
chi:数值类型或 SymPy 符号
极化椭圆主轴相邻的角度。
p:数值类型或 SymPy 符号
偏振度。
I:数值类型或 SymPy 符号
场的强度。
返回:
矩阵:
一个 Stokes 矢量。
示例
波尔卡雷球上的轴。
>>> from sympy import pprint, symbols, pi
>>> from sympy.physics.optics.polarization import stokes_vector
>>> psi, chi, p, I = symbols("psi, chi, p, I", real=True)
>>> pprint(stokes_vector(psi, chi, p, I), use_unicode=True)
⎡ I ⎤
⎢ ⎥
⎢I⋅p⋅cos(2⋅χ)⋅cos(2⋅ψ)⎥
⎢ ⎥
⎢I⋅p⋅sin(2⋅ψ)⋅cos(2⋅χ)⎥
⎢ ⎥
⎣ I⋅p⋅sin(2⋅χ) ⎦
水平极化
>>> pprint(stokes_vector(0, 0), use_unicode=True)
⎡1⎤
⎢ ⎥
⎢1⎥
⎢ ⎥
⎢0⎥
⎢ ⎥
⎣0⎦
垂直极化
>>> pprint(stokes_vector(pi/2, 0), use_unicode=True)
⎡1 ⎤
⎢ ⎥
⎢-1⎥
⎢ ⎥
⎢0 ⎥
⎢ ⎥
⎣0 ⎦
对角极化
>>> pprint(stokes_vector(pi/4, 0), use_unicode=True)
⎡1⎤
⎢ ⎥
⎢0⎥
⎢ ⎥
⎢1⎥
⎢ ⎥
⎣0⎦
反对角极化
>>> pprint(stokes_vector(-pi/4, 0), use_unicode=True)
⎡1 ⎤
⎢ ⎥
⎢0 ⎥
⎢ ⎥
⎢-1⎥
⎢ ⎥
⎣0 ⎦
右旋圆偏振
>>> pprint(stokes_vector(0, pi/4), use_unicode=True)
⎡1⎤
⎢ ⎥
⎢0⎥
⎢ ⎥
⎢0⎥
⎢ ⎥
⎣1⎦
左旋圆偏振
>>> pprint(stokes_vector(0, -pi/4), use_unicode=True)
⎡1 ⎤
⎢ ⎥
⎢0 ⎥
⎢ ⎥
⎢0 ⎥
⎢ ⎥
⎣-1⎦
非偏振光
>>> pprint(stokes_vector(0, 0, 0), use_unicode=True)
⎡1⎤
⎢ ⎥
⎢0⎥
⎢ ⎥
⎢0⎥
⎢ ⎥
⎣0⎦
sympy.physics.optics.polarization.transmissive_filter(T)
具有透射率 T
的衰减器 Jones 矩阵。
参数:
T:数值类型或 SymPy 符号
衰减器的透射率。
返回:
SymPy 矩阵
代表滤波器的 Jones 矩阵。
示例
通用滤波器。
>>> from sympy import pprint, symbols
>>> from sympy.physics.optics.polarization import transmissive_filter
>>> T = symbols("T", real=True)
>>> NDF = transmissive_filter(T)
>>> pprint(NDF, use_unicode=True)
⎡√T 0 ⎤
⎢ ⎥
⎣0 √T⎦
实用工具
包含
-
折射角
-
菲涅尔系数
-
偏差
-
布鲁斯特角
-
临界角
-
镜片制造公式
-
镜公式
-
镜头公式
-
超焦距
-
横向放大率
sympy.physics.optics.utils.brewster_angle(medium1, medium2)
此函数计算入射到 Medium 1 到 Medium 2 的布鲁斯特角(弧度)。
参数:
medium 1:Medium 或可合成对象
Medium 1 的折射率
medium 2:Medium 或可合成对象
Medium 1 的折射率
示例
>>> from sympy.physics.optics import brewster_angle
>>> brewster_angle(1, 1.33)
0.926093295503462
sympy.physics.optics.utils.critical_angle(medium1, medium2)
此函数计算入射到 Medium 1 到 Medium 2 的临界入射角(标记总内反射开始)的角度(弧度)。
参数:
medium 1:Medium 或可合成对象
Medium 1 的折射率。
medium 2:Medium 或可合成对象
Medium 1 的折射率。
示例
>>> from sympy.physics.optics import critical_angle
>>> critical_angle(1.33, 1)
0.850908514477849
sympy.physics.optics.utils.deviation(incident, medium1, medium2, normal=None, plane=None)
此函数计算光线由于在平面表面的折射而产生的偏离角度。
参数:
incident:Matrix、Ray3D、序列或浮点数
入射向量或入射角
medium1:sympy.physics.optics.medium.Medium 或可合成对象
Medium 1 或其折射率
medium2:sympy.physics.optics.medium.Medium 或可合成对象
Medium 2 或其折射率
normal:Matrix、Ray3D 或序列
法线向量
平面:平面
两个介质的分离面。
返回入射和折射光线之间的角度偏差
示例
>>> from sympy.physics.optics import deviation
>>> from sympy.geometry import Point3D, Ray3D, Plane
>>> from sympy.matrices import Matrix
>>> from sympy import symbols
>>> n1, n2 = symbols('n1, n2')
>>> n = Matrix([0, 0, 1])
>>> P = Plane(Point3D(0, 0, 0), normal_vector=[0, 0, 1])
>>> r1 = Ray3D(Point3D(-1, -1, 1), Point3D(0, 0, 0))
>>> deviation(r1, 1, 1, n)
0
>>> deviation(r1, n1, n2, plane=P)
-acos(-sqrt(-2*n1**2/(3*n2**2) + 1)) + acos(-sqrt(3)/3)
>>> round(deviation(0.1, 1.2, 1.5), 5)
-0.02005
sympy.physics.optics.utils.fresnel_coefficients(angle_of_incidence, medium1, medium2)
此函数使用菲涅尔方程计算反射和透射系数。当电场矢量在入射平面内(标记为‘p’)时和当电场矢量垂直于入射平面(标记为‘s’)时,分别获得两种极化的系数。除非入射光线完全内反射,否则有四个实系数和两个复系数。入射角是入射光线与表面法线之间的角度。medium1
和 medium2
可以是 Medium
或任何可合成的对象。
参数:
入射角:sympifiable
medium1:Medium 或可合成对象
Medium 1 或其折射率
medium2:Medium 或可合成对象
Medium 2 或其折射率
返回:
返回一个包含四个实菲涅尔系数的列表:
[反射 p(TM),反射 s(TE),
透射 p(TM),透射 s(TE)]
如果光线经历全内反射,则返回
两个复菲涅尔系数的列表:
[反射 p(TM),反射 s(TE)]
示例
>>> from sympy.physics.optics import fresnel_coefficients
>>> fresnel_coefficients(0.3, 1, 2)
[0.317843553417859, -0.348645229818821,
0.658921776708929, 0.651354770181179]
>>> fresnel_coefficients(0.6, 2, 1)
[-0.235625382192159 - 0.971843958291041*I,
0.816477005968898 - 0.577377951366403*I]
参考文献
[R747]
en.wikipedia.org/wiki/Fresnel_equations
sympy.physics.optics.utils.hyperfocal_distance(f, N, c)
参数:
f: sympifiable
给定镜头的焦距。
N: sympifiable
给定镜头的 F 数。
c: sympifiable
给定图像格式的焦点混淆圈(CoC)。
示例
>>> from sympy.physics.optics import hyperfocal_distance
>>> round(hyperfocal_distance(f = 0.5, N = 8, c = 0.0033), 2)
9.47
sympy.physics.optics.utils.lens_formula(focal_length=None, u=None, v=None)
此函数在提供两个参数时,提供其中三个参数之一。仅适用于副轴光线。
参数:
focal_length:sympifiable
镜的焦距。
u:可简化
物体到主轴上光学中心的距离。
v:可简化
图像到主轴上光学中心的距离。
示例
>>> from sympy.physics.optics import lens_formula
>>> from sympy.abc import f, u, v
>>> lens_formula(focal_length=f, u=u)
f*u/(f + u)
>>> lens_formula(focal_length=f, v=v)
f*v/(f - v)
>>> lens_formula(u=u, v=v)
u*v/(u - v)
sympy.physics.optics.utils.lens_makers_formula(n_lens, n_surr, r1, r2, d=0)
此函数计算透镜的焦距。遵循笛卡尔符号约定。
参数:
n_lens:介质或可简化
透镜的折射率。
n_surr:介质或可简化
周围的反射率指数。
r1:可简化
第一表面的曲率半径。
r2:可简化
第二表面的曲率半径。
d:可简化,可选
透镜厚度,默认值为 0。
示例
>>> from sympy.physics.optics import lens_makers_formula
>>> from sympy import S
>>> lens_makers_formula(1.33, 1, 10, -10)
15.1515151515151
>>> lens_makers_formula(1.2, 1, 10, S.Infinity)
50.0000000000000
>>> lens_makers_formula(1.33, 1, 10, -10, d=1)
15.3418463277618
sympy.physics.optics.utils.mirror_formula(focal_length=None, u=None, v=None)
此函数在提供两个参数时提供其中一个的参数。这仅对于平行光线有效。
参数:
focal_length:可简化
镜的焦距。
u:可简化
物体到主轴极点的距离。
v:可简化
图像到主轴极点的距离。
示例
>>> from sympy.physics.optics import mirror_formula
>>> from sympy.abc import f, u, v
>>> mirror_formula(focal_length=f, u=u)
f*u/(-f + u)
>>> mirror_formula(focal_length=f, v=v)
f*v/(-f + v)
>>> mirror_formula(u=u, v=v)
u*v/(u + v)
sympy.physics.optics.utils.refraction_angle(incident, medium1, medium2, normal=None, plane=None)
此函数计算平面表面折射后的传输向量。medium1
和medium2
可以是Medium
或任何可简化的对象。如果incident
是一个数字,则视为入射角(弧度),在这种情况下返回折射角。
如果incident
是(Ray3D)的对象,则为了得到(Ray3D)作为输出,normal
也必须是(Ray3D)的实例。请注意,如果未提供分离面而normal
是(Ray3D)的实例,则假定normal
与分离面处的入射光线相交。当normal
是(Matrix)或其他序列时,情况并非如此。如果incident
是(Ray3D)的实例且未提供plane
且normal
不是(Ray3D),则输出将为(Matrix)。
参数:
incident:矩阵、Ray3D、序列或数字
入射向量或入射角
medium1:sympy.physics.optics.medium.Medium 或可简化
第一介质或其折射率
medium2:sympy.physics.optics.medium.Medium 或可简化
第二介质或其折射率
normal:矩阵、Ray3D 或序列
法向量
plane:平面
两种介质的分界面。
返回:
返回折射角或依据输入返回折射光线。
示例
>>> from sympy.physics.optics import refraction_angle
>>> from sympy.geometry import Point3D, Ray3D, Plane
>>> from sympy.matrices import Matrix
>>> from sympy import symbols, pi
>>> n = Matrix([0, 0, 1])
>>> P = Plane(Point3D(0, 0, 0), normal_vector=[0, 0, 1])
>>> r1 = Ray3D(Point3D(-1, -1, 1), Point3D(0, 0, 0))
>>> refraction_angle(r1, 1, 1, n)
Matrix([
[ 1],
[ 1],
[-1]])
>>> refraction_angle(r1, 1, 1, plane=P)
Ray3D(Point3D(0, 0, 0), Point3D(1, 1, -1))
具有不同折射率的两种介质
>>> n1, n2 = symbols('n1, n2')
>>> refraction_angle(r1, n1, n2, n)
Matrix([
[ n1/n2],
[ n1/n2],
[-sqrt(3)*sqrt(-2*n1**2/(3*n2**2) + 1)]])
>>> refraction_angle(r1, n1, n2, plane=P)
Ray3D(Point3D(0, 0, 0), Point3D(n1/n2, n1/n2, -sqrt(3)*sqrt(-2*n1**2/(3*n2**2) + 1)))
>>> round(refraction_angle(pi/6, 1.2, 1.5), 5)
0.41152
sympy.physics.optics.utils.transverse_magnification(si, so)
计算镜面反射时的横向放大倍数,即图像大小与物体大小的比率。
参数:
so: sympifiable
透镜物距。
si: sympifiable
透镜图像距离。
示例
>>> from sympy.physics.optics import transverse_magnification
>>> transverse_magnification(30, 15)
-2
波
该模块包含所有与光学波相关的类和函数.
Contains
- TWave
class sympy.physics.optics.waves.TWave(amplitude, frequency=None, phase=0, time_period=None, n=n)
这是一个简单的横向正弦波,在一维空间中传播. 在对象创建时需要基本属性,但可以使用提供的相应方法随后更改.
引发:
ValueError : 当未提供频率或时间周期时
或者它们不一致.
TypeError : 当添加的对象不是 TWave 对象时.
解释
它表示为 (A \times cos(k*x - \omega \times t + \phi )), 其中 (A) 是振幅, (\omega) 是角频率, (k) 是波数(空间频率), (x) 是表示波传播的维度上的位置的空间变量, (\phi) 是波的相位角.
参数
amplitudeSympifyable
波的振幅.
frequencySympifyable
波的频率.
phaseSympifyable
波的相位角.
time_periodSympifyable
波的时间周期.
nSympifyable
介质的折射率.
示例
>>> from sympy import symbols
>>> from sympy.physics.optics import TWave
>>> A1, phi1, A2, phi2, f = symbols('A1, phi1, A2, phi2, f')
>>> w1 = TWave(A1, f, phi1)
>>> w2 = TWave(A2, f, phi2)
>>> w3 = w1 + w2 # Superposition of two waves
>>> w3
TWave(sqrt(A1**2 + 2*A1*A2*cos(phi1 - phi2) + A2**2), f,
atan2(A1*sin(phi1) + A2*sin(phi2), A1*cos(phi1) + A2*cos(phi2)), 1/f, n)
>>> w3.amplitude
sqrt(A1**2 + 2*A1*A2*cos(phi1 - phi2) + A2**2)
>>> w3.phase
atan2(A1*sin(phi1) + A2*sin(phi2), A1*cos(phi1) + A2*cos(phi2))
>>> w3.speed
299792458*meter/(second*n)
>>> w3.angular_velocity
2*pi*f
property amplitude
返回波的振幅.
示例
>>> from sympy import symbols
>>> from sympy.physics.optics import TWave
>>> A, phi, f = symbols('A, phi, f')
>>> w = TWave(A, f, phi)
>>> w.amplitude
A
property angular_velocity
返回波的角速度,单位为每秒弧度.
示例
>>> from sympy import symbols
>>> from sympy.physics.optics import TWave
>>> A, phi, f = symbols('A, phi, f')
>>> w = TWave(A, f, phi)
>>> w.angular_velocity
2*pi*f
property frequency
返回波的频率,单位为每秒周期数.
示例
>>> from sympy import symbols
>>> from sympy.physics.optics import TWave
>>> A, phi, f = symbols('A, phi, f')
>>> w = TWave(A, f, phi)
>>> w.frequency
f
property n
返回介质的折射率
property phase
返回波的相位角,单位为弧度.
示例
>>> from sympy import symbols
>>> from sympy.physics.optics import TWave
>>> A, phi, f = symbols('A, phi, f')
>>> w = TWave(A, f, phi)
>>> w.phase
phi
property speed
返回波的传播速度,单位为每秒米. 它依赖于传播介质.
示例
>>> from sympy import symbols
>>> from sympy.physics.optics import TWave
>>> A, phi, f = symbols('A, phi, f')
>>> w = TWave(A, f, phi)
>>> w.speed
299792458*meter/(second*n)
property time_period
返回波的时间周期,单位为每周期秒.
示例
>>> from sympy import symbols
>>> from sympy.physics.optics import TWave
>>> A, phi, f = symbols('A, phi, f')
>>> w = TWave(A, f, phi)
>>> w.time_period
1/f
property wavelength
返回波的波长(空间周期),单位为每周期米. 它取决于波的介质.
示例
>>> from sympy import symbols
>>> from sympy.physics.optics import TWave
>>> A, phi, f = symbols('A, phi, f')
>>> w = TWave(A, f, phi)
>>> w.wavelength
299792458*meter/(second*f*n)
property wavenumber
返回波的波数,单位为每米的弧度.
示例
>>> from sympy import symbols
>>> from sympy.physics.optics import TWave
>>> A, phi, f = symbols('A, phi, f')
>>> w = TWave(A, f, phi)
>>> w.wavenumber
pi*second*f*n/(149896229*meter)
控制模块
- 控制
-
控制 API
-
控制系统图表
控制
原文:
docs.sympy.org/latest/modules/physics/control/control.html
目前,sympy.physics.control
能够处理 LTI(线性、时不变)系统。TransferFunction
类用于表示拉普拉斯域中的连续时间传递函数;其中传递函数是动态系统的输入到输出表示。Parallel
类中用于传递函数的加法属性,Series
类中用于传递函数的乘法属性。此外,还有一个 Feedback
类,用于表示两个输入/输出系统之间的负反馈互连。MIMO 系统也支持,使用 TransferFunctionMatrix
作为表示的基类。MIMOSeries
、MIMOParallel
和 MIMOFeedback
是 Series
、Parallel
和 Feedback
类的 MIMO 版本。
这个符号控制系统包的优势在于,从中获得的解决方案非常准确,并且不依赖于数值方法来近似解决方案。获得的符号解决方案还以紧凑的形式存在,可用于进一步的分析。
控制 API
lti
class sympy.physics.control.lti.TransferFunction(num, den, var)
用于表示可以由拉普拉斯变换复数变量中的多项式比严格描述的 LTI(线性、时不变)系统的类。参数包括 num
、den
和 var
,其中 num
和 den
分别是传递函数的分子和分母多项式,第三个参数是这些传递函数中使用的拉普拉斯变换的复数变量。num
和 den
可以是多项式或数字,而 var
必须是一个Symbol
。
参数:
num:表达式,数值
传递函数的分子多项式。
den:表达式,数值
传递函数的分母多项式。
var:符号
传递函数的拉普拉斯变换中使用的复数变量。
引发:
TypeError
当
var
不是符号或num
或den
不是数字或多项式时。
ValueError
当
den
为零时。
解释
一般来说,表示物理模型的动态系统可以用线性常微分方程描述,如 -
(\small{b_{m}y{\left(m\right)}+b_{m-1}y+\dots+b_{1}y^{\left(1\right)}+b_{0}y= a_{n}x{\left(n\right)}+a_{n-1}x+\dots+a_{1}x^{\left(1\right)}+a_{0}x})
这里,(x) 是输入信号,(y) 是输出信号,两者上的上标表示导数的阶数(不是指数)。导数是相对于自变量 (t) 求取的。一般情况下,(m) 大于 (n)。
在其原生形式下分析这类系统的属性是不可行的,因此我们使用拉普拉斯变换等数学工具来获得更好的视角。在方程两边(在零初值条件下)进行拉普拉斯变换,我们得到 -
(\small{\mathcal{L}[b_{m}y{\left(m\right)}+b_{m-1}y+\dots+b_{1}y^{\left(1\right)}+b_{0}y]= \mathcal{L}[a_{n}x{\left(n\right)}+a_{n-1}x+\dots+a_{1}x^{\left(1\right)}+a_{0}x]})
利用拉普拉斯变换的线性性质,并考虑零初值条件(即 (\small{y(0^{-}) = 0}),(\small{y'(0^{-}) = 0}) 等),上述方程可以转化为 -
(\small{b_{m}\mathcal{L}[y{\left(m\right)}]+\dots+b_{1}\mathcal{L}[y]+b_{0}\mathcal{L}[y]= a_{n}\mathcal{L}[x{\left(n\right)}]+\dots+a_{1}\mathcal{L}[x]+a_{0}\mathcal{L}[x]})
现在,应用拉普拉斯变换的导数性质,
(\small{b_{m}s^{m}\mathcal{L}[y]+\dots+b_{1}s\mathcal{L}[y]+b_{0}\mathcal{L}[y]= a_{n}s^{n}\mathcal{L}[x]+\dots+a_{1}s\mathcal{L}[x]+a_{0}\mathcal{L}[x]})
在这里,(s)上的上标是指数。请注意,上面提到的零初始条件假设非常重要,不能忽略,否则动态系统不能被视为时间独立,并且无法达到上述简化的方程。
从两边收集(\mathcal{L}[y])和(\mathcal{L}[x])项,并取比率(\frac{ \mathcal{L}\left{y\right} }{ \mathcal{L}\left{x\right} }),我们得到传递函数的典型有理形式。
传递函数的分子因此是输出信号(信号表示为时间函数)的拉普拉斯变换,类似地,传递函数的分母是输入信号的拉普拉斯变换。如下所示,将输入和输出信号的拉普拉斯变换用大写字母表示也是一种约定。
(H(s) = \frac{Y(s)}{X(s)} = \frac{ \mathcal{L}\left{y(t)\right} }{ \mathcal{L}\left{x(t)\right} })
(s),也称为复频率,在拉普拉斯域中是一个复变量。它对应于时间域中的等效变量(t)。传递函数有时也称为系统冲激响应的拉普拉斯变换。传递函数(H)在(s)中表示为一个有理函数,如下所示,
(H(s) =\ \frac{a_{n}s{n}+a_{n-1}s+\dots+a_{1}s+a_{0}}{b_{m}s{m}+b_{m-1}s+\dots+b_{1}s+b_{0}})
示例
>>> from sympy.abc import s, p, a
>>> from sympy.physics.control.lti import TransferFunction
>>> tf1 = TransferFunction(s + a, s**2 + s + 1, s)
>>> tf1
TransferFunction(a + s, s**2 + s + 1, s)
>>> tf1.num
a + s
>>> tf1.den
s**2 + s + 1
>>> tf1.var
s
>>> tf1.args
(a + s, s**2 + s + 1, s)
任何复变量都可以用于var
。
>>> tf2 = TransferFunction(a*p**3 - a*p**2 + s*p, p + a**2, p)
>>> tf2
TransferFunction(a*p**3 - a*p**2 + p*s, a**2 + p, p)
>>> tf3 = TransferFunction((p + 3)*(p - 1), (p - 1)*(p + 5), p)
>>> tf3
TransferFunction((p - 1)*(p + 3), (p - 1)*(p + 5), p)
要对传递函数取反,可以在其前面加上-
运算符:
>>> tf4 = TransferFunction(-a + s, p**2 + s, p)
>>> -tf4
TransferFunction(a - s, p**2 + s, p)
>>> tf5 = TransferFunction(s**4 - 2*s**3 + 5*s + 4, s + 4, s)
>>> -tf5
TransferFunction(-s**4 + 2*s**3 - 5*s - 4, s + 4, s)
您可以使用浮点数或整数(或其他常数)作为分子和分母:
>>> tf6 = TransferFunction(1/2, 4, s)
>>> tf6.num
0.500000000000000
>>> tf6.den
4
>>> tf6.var
s
>>> tf6.args
(0.5, 4, s)
您可以使用**
运算符对传递函数进行整数幂运算:
>>> tf7 = TransferFunction(s + a, s - a, s)
>>> tf7**3
TransferFunction((a + s)**3, (-a + s)**3, s)
>>> tf7**0
TransferFunction(1, 1, s)
>>> tf8 = TransferFunction(p + 4, p - 3, p)
>>> tf8**-1
TransferFunction(p - 3, p + 4, p)
传递函数的加法、减法和乘法可以形成未计算的Series
或Parallel
对象。
>>> tf9 = TransferFunction(s + 1, s**2 + s + 1, s)
>>> tf10 = TransferFunction(s - p, s + 3, s)
>>> tf11 = TransferFunction(4*s**2 + 2*s - 4, s - 1, s)
>>> tf12 = TransferFunction(1 - s, s**2 + 4, s)
>>> tf9 + tf10
Parallel(TransferFunction(s + 1, s**2 + s + 1, s), TransferFunction(-p + s, s + 3, s))
>>> tf10 - tf11
Parallel(TransferFunction(-p + s, s + 3, s), TransferFunction(-4*s**2 - 2*s + 4, s - 1, s))
>>> tf9 * tf10
Series(TransferFunction(s + 1, s**2 + s + 1, s), TransferFunction(-p + s, s + 3, s))
>>> tf10 - (tf9 + tf12)
Parallel(TransferFunction(-p + s, s + 3, s), TransferFunction(-s - 1, s**2 + s + 1, s), TransferFunction(s - 1, s**2 + 4, s))
>>> tf10 - (tf9 * tf12)
Parallel(TransferFunction(-p + s, s + 3, s), Series(TransferFunction(-1, 1, s), TransferFunction(s + 1, s**2 + s + 1, s), TransferFunction(1 - s, s**2 + 4, s)))
>>> tf11 * tf10 * tf9
Series(TransferFunction(4*s**2 + 2*s - 4, s - 1, s), TransferFunction(-p + s, s + 3, s), TransferFunction(s + 1, s**2 + s + 1, s))
>>> tf9 * tf11 + tf10 * tf12
Parallel(Series(TransferFunction(s + 1, s**2 + s + 1, s), TransferFunction(4*s**2 + 2*s - 4, s - 1, s)), Series(TransferFunction(-p + s, s + 3, s), TransferFunction(1 - s, s**2 + 4, s)))
>>> (tf9 + tf12) * (tf10 + tf11)
Series(Parallel(TransferFunction(s + 1, s**2 + s + 1, s), TransferFunction(1 - s, s**2 + 4, s)), Parallel(TransferFunction(-p + s, s + 3, s), TransferFunction(4*s**2 + 2*s - 4, s - 1, s)))
这些未计算的Series
或Parallel
对象可以通过.doit()
方法或.rewrite(TransferFunction)
转换为最终的传递函数。
>>> ((tf9 + tf10) * tf12).doit()
TransferFunction((1 - s)*((-p + s)*(s**2 + s + 1) + (s + 1)*(s + 3)), (s + 3)*(s**2 + 4)*(s**2 + s + 1), s)
>>> (tf9 * tf10 - tf11 * tf12).rewrite(TransferFunction)
TransferFunction(-(1 - s)*(s + 3)*(s**2 + s + 1)*(4*s**2 + 2*s - 4) + (-p + s)*(s - 1)*(s + 1)*(s**2 + 4), (s - 1)*(s + 3)*(s**2 + 4)*(s**2 + s + 1), s)
另请参见
反馈
, 串联
, 并联
参考文献
[R734]
[R735]
dc_gain()
计算频率接近零时响应的增益。
对于纯积分器系统,直流增益是无穷大。
示例
>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction
>>> tf1 = TransferFunction(s + 3, s**2 - 9, s)
>>> tf1.dc_gain()
-1/3
>>> tf2 = TransferFunction(p**2, p - 3 + p**3, p)
>>> tf2.dc_gain()
0
>>> tf3 = TransferFunction(a*p**2 - b, s + b, s)
>>> tf3.dc_gain()
(a*p**2 - b)/b
>>> tf4 = TransferFunction(1, s, s)
>>> tf4.dc_gain()
oo
property den
返回传递函数的分母多项式。
示例
>>> from sympy.abc import s, p
>>> from sympy.physics.control.lti import TransferFunction
>>> G1 = TransferFunction(s + 4, p**3 - 2*p + 4, s)
>>> G1.den
p**3 - 2*p + 4
>>> G2 = TransferFunction(3, 4, s)
>>> G2.den
4
eval_frequency(other)
返回在实数或复数平面上任意点的系统响应。
示例
>>> from sympy.abc import s, p, a
>>> from sympy.physics.control.lti import TransferFunction
>>> from sympy import I
>>> tf1 = TransferFunction(1, s**2 + 2*s + 1, s)
>>> omega = 0.1
>>> tf1.eval_frequency(I*omega)
1/(0.99 + 0.2*I)
>>> tf2 = TransferFunction(s**2, a*s + p, s)
>>> tf2.eval_frequency(2)
4/(2*a + p)
>>> tf2.eval_frequency(I*2)
-4/(2*I*a + p)
expand()
返回展开形式中分子和分母的传递函数。
示例
>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction
>>> G1 = TransferFunction((a - s)**2, (s**2 + a)**2, s)
>>> G1.expand()
TransferFunction(a**2 - 2*a*s + s**2, a**2 + 2*a*s**2 + s**4, s)
>>> G2 = TransferFunction((p + 3*b)*(p - b), (p - b)*(p + 2*b), p)
>>> G2.expand()
TransferFunction(-3*b**2 + 2*b*p + p**2, -2*b**2 + b*p + p**2, p)
classmethod from_coeff_lists(num_list, den_list, var)
从系数列表高效地创建新的TransferFunction
。
参数:
num_list : 序列
组成分子系数的序列。
den_list : 序列
组成分母系数的序列。
var : 符号
传递函数多项式使用的复变量拉普拉斯变换。
抛出:
ZeroDivisionError
当构造的分母为零时。
示例
>>> from sympy.abc import s, p
>>> from sympy.physics.control.lti import TransferFunction
>>> num = [1, 0, 2]
>>> den = [3, 2, 2, 1]
>>> tf = TransferFunction.from_coeff_lists(num, den, s)
>>> tf
TransferFunction(s**2 + 2, 3*s**3 + 2*s**2 + 2*s + 1, s)
使用多个变量创建传递函数 >>> tf1 = TransferFunction.from_coeff_lists([p, 1], [2p, 0, 4], s) >>> tf1 TransferFunction(ps + 1, 2ps**2 + 4, s)
classmethod from_rational_expression(expr, var=None)
从有理表达式有效地创建新的 TransferFunction
。
参数:
expr : 表达式,数值
表示
TransferFunction
的有理表达式。
var : 符号,可选
传递函数多项式使用的复变量拉普拉斯变换。
抛出:
ValueError
当
expr
是Number
类型且可选参数var
未传递时。当
expr
包含多个变量且可选参数var
未传递时。
ZeroDivisionError
当
expr
的分母为零或其分子中包含ComplexInfinity
时。
示例
>>> from sympy.abc import s, p, a
>>> from sympy.physics.control.lti import TransferFunction
>>> expr1 = (s + 5)/(3*s**2 + 2*s + 1)
>>> tf1 = TransferFunction.from_rational_expression(expr1)
>>> tf1
TransferFunction(s + 5, 3*s**2 + 2*s + 1, s)
>>> expr2 = (a*p**3 - a*p**2 + s*p)/(p + a**2) # Expr with more than one variables
>>> tf2 = TransferFunction.from_rational_expression(expr2, p)
>>> tf2
TransferFunction(a*p**3 - a*p**2 + p*s, a**2 + p, p)
如果在表达式中存在两个或多个变量的冲突,SymPy 将会抛出 ValueError
,如果用户未传递 var
。
>>> tf = TransferFunction.from_rational_expression((a + a*s)/(s**2 + s + 1))
Traceback (most recent call last):
...
ValueError: Conflicting values found for positional argument `var` ({a, s}). Specify it manually.
这可以通过手动指定 var
参数来纠正。
>>> tf = TransferFunction.from_rational_expression((a + a*s)/(s**2 + s + 1), s)
>>> tf
TransferFunction(a*s + a, s**2 + s + 1, s)
当 expr
是 Number
时,也需要指定 var
。
>>> tf3 = TransferFunction.from_rational_expression(10, s)
>>> tf3
TransferFunction(10, 1, s)
classmethod from_zpk(zeros, poles, gain, var)
从给定的零点、极点和增益创建新的 TransferFunction
。
参数:
zeros : 序列
组成传递函数的零点序列。
poles : 序列
传递函数的极点序列。
gain : 数值,符号,表达式
指定模型增益的标量值。
var : 符号
传递函数多项式使用的复变量拉普拉斯变换。
示例
>>> from sympy.abc import s, p, k
>>> from sympy.physics.control.lti import TransferFunction
>>> zeros = [1, 2, 3]
>>> poles = [6, 5, 4]
>>> gain = 7
>>> tf = TransferFunction.from_zpk(zeros, poles, gain, s)
>>> tf
TransferFunction(7*(s - 3)*(s - 2)*(s - 1), (s - 6)*(s - 5)*(s - 4), s)
使用变量极点和零点创建传递函数 >>> tf1 = TransferFunction.from_zpk([p, k], [p + k, p - k], 2, s) >>> tf1 TransferFunction(2(-k + s)(-p + s), (-k - p + s)*(k - p + s), s)
复极点或零点都是可以接受的 >>> tf2 = TransferFunction.from_zpk([0], [1-1j, 1+1j, 2], -2, s) >>> tf2 TransferFunction(-2s, (s - 2)(s - 1.0 - 1.0I)(s - 1.0 + 1.0*I), s)
property is_biproper
返回如果分子多项式的次数等于分母多项式的次数则为 True,否则为 False。
示例
>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf1.is_biproper
True
>>> tf2 = TransferFunction(p**2, p + a, p)
>>> tf2.is_biproper
False
property is_proper
返回如果分子多项式的次数小于或等于分母多项式的次数则为 True,否则为 False。
示例
>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction
>>> tf1 = TransferFunction(b*s**2 + p**2 - a*p + s, b - p**2, s)
>>> tf1.is_proper
False
>>> tf2 = TransferFunction(p**2 - 4*p, p**3 + 3*p + 2, p)
>>> tf2.is_proper
True
is_stable()
返回如果传递函数是渐近稳定的则为 True,否则为 False。
这不会检查系统的边际或条件稳定性。
示例
>>> from sympy.abc import s, p, a
>>> from sympy import symbols
>>> from sympy.physics.control.lti import TransferFunction
>>> q, r = symbols('q, r', negative=True)
>>> tf1 = TransferFunction((1 - s)**2, (s + 1)**2, s)
>>> tf1.is_stable()
True
>>> tf2 = TransferFunction((1 - p)**2, (s**2 + 1)**2, s)
>>> tf2.is_stable()
False
>>> tf3 = TransferFunction(4, q*s - r, s)
>>> tf3.is_stable()
False
>>> tf4 = TransferFunction(p + 1, a*p - s**2, p)
>>> tf4.is_stable() is None # Not enough info about the symbols to determine stability
True
property is_strictly_proper
返回如果分子多项式的次数严格小于分母多项式的次数则为 True,否则为 False。
示例
>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf1.is_strictly_proper
False
>>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)
>>> tf2.is_strictly_proper
True
property num
返回传递函数的分子多项式。
示例
>>> from sympy.abc import s, p
>>> from sympy.physics.control.lti import TransferFunction
>>> G1 = TransferFunction(s**2 + p*s + 3, s - 4, s)
>>> G1.num
p*s + s**2 + 3
>>> G2 = TransferFunction((p + 5)*(p - 3), (p - 3)*(p + 1), p)
>>> G2.num
(p - 3)*(p + 5)
poles()
返回传递函数的极点。
示例
>>> from sympy.abc import s, p, a
>>> from sympy.physics.control.lti import TransferFunction
>>> tf1 = TransferFunction((p + 3)*(p - 1), (p - 1)*(p + 5), p)
>>> tf1.poles()
[-5, 1]
>>> tf2 = TransferFunction((1 - s)**2, (s**2 + 1)**2, s)
>>> tf2.poles()
[I, I, -I, -I]
>>> tf3 = TransferFunction(s**2, a*s + p, s)
>>> tf3.poles()
[-p/a]
to_expr()
将 TransferFunction
对象转换为 SymPy 表达式。
示例
>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction
>>> from sympy import Expr
>>> tf1 = TransferFunction(s, a*s**2 + 1, s)
>>> tf1.to_expr()
s/(a*s**2 + 1)
>>> isinstance(_, Expr)
True
>>> tf2 = TransferFunction(1, (p + 3*b)*(b - p), p)
>>> tf2.to_expr()
1/((b - p)*(3*b + p))
>>> tf3 = TransferFunction((s - 2)*(s - 3), (s - 1)*(s - 2)*(s - 3), s)
>>> tf3.to_expr()
((s - 3)*(s - 2))/(((s - 3)*(s - 2)*(s - 1)))
property var
返回传递函数多项式使用的复变量拉普拉斯变换。
示例
>>> from sympy.abc import s, p
>>> from sympy.physics.control.lti import TransferFunction
>>> G1 = TransferFunction(p**2 + 2*p + 4, p - 6, p)
>>> G1.var
p
>>> G2 = TransferFunction(0, s - 5, s)
>>> G2.var
s
zeros()
返回传递函数的零点。
示例
>>> from sympy.abc import s, p, a
>>> from sympy.physics.control.lti import TransferFunction
>>> tf1 = TransferFunction((p + 3)*(p - 1), (p - 1)*(p + 5), p)
>>> tf1.zeros()
[-3, 1]
>>> tf2 = TransferFunction((1 - s)**2, (s**2 + 1)**2, s)
>>> tf2.zeros()
[1, 1]
>>> tf3 = TransferFunction(s**2, a*s + p, s)
>>> tf3.zeros()
[0, 0]
class sympy.physics.control.lti.Series(*args, evaluate=False)
用于表示串联配置的 SISO 系统的类。
参数:
args : SISO 线性时不变
串联配置的 SISO 系统。
评估 : 布尔值,关键字
当传递
True
时,返回等效于Series(*args).doit()
。 默认设置为False
。
引发:
数值错误
当没有传递参数时。
var
属性对每个系统不相同。
类型错误
任何传递的
*args
具有不支持的类型传递了 SISO 和 MIMO 系统的组合。 传递的系统类型应保持同质性,此处为 SISO。
示例
>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Series, Parallel
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)
>>> tf3 = TransferFunction(p**2, p + s, s)
>>> S1 = Series(tf1, tf2)
>>> S1
Series(TransferFunction(a*p**2 + b*s, -p + s, s), TransferFunction(s**3 - 2, s**4 + 5*s + 6, s))
>>> S1.var
s
>>> S2 = Series(tf2, Parallel(tf3, -tf1))
>>> S2
Series(TransferFunction(s**3 - 2, s**4 + 5*s + 6, s), Parallel(TransferFunction(p**2, p + s, s), TransferFunction(-a*p**2 - b*s, -p + s, s)))
>>> S2.var
s
>>> S3 = Series(Parallel(tf1, tf2), Parallel(tf2, tf3))
>>> S3
Series(Parallel(TransferFunction(a*p**2 + b*s, -p + s, s), TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)), Parallel(TransferFunction(s**3 - 2, s**4 + 5*s + 6, s), TransferFunction(p**2, p + s, s)))
>>> S3.var
s
您可以通过使用 .doit()
方法获得结果传递函数:
>>> S3 = Series(tf1, tf2, -tf3)
>>> S3.doit()
TransferFunction(-p**2*(s**3 - 2)*(a*p**2 + b*s), (-p + s)*(p + s)*(s**4 + 5*s + 6), s)
>>> S4 = Series(tf2, Parallel(tf1, -tf3))
>>> S4.doit()
TransferFunction((s**3 - 2)*(-p**2*(-p + s) + (p + s)*(a*p**2 + b*s)), (-p + s)*(p + s)*(s**4 + 5*s + 6), s)
注意
所有传递函数应使用拉普拉斯变换的同一复变量 var
。
参见
MIMO 串联
, 并联
, 传递函数
, 反馈
doit(**hints)
返回在串联配置中评估传递函数后获得的结果传递函数。
示例
>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Series
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)
>>> Series(tf2, tf1).doit()
TransferFunction((s**3 - 2)*(a*p**2 + b*s), (-p + s)*(s**4 + 5*s + 6), s)
>>> Series(-tf1, -tf2).doit()
TransferFunction((2 - s**3)*(-a*p**2 - b*s), (-p + s)*(s**4 + 5*s + 6), s)
property is_biproper
如果结果传递函数的分子多项式的度数等于相同分母多项式的度数,则返回 True,否则返回 False。
示例
>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Series
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf2 = TransferFunction(p, s**2, s)
>>> tf3 = TransferFunction(s**2, 1, s)
>>> S1 = Series(tf1, -tf2)
>>> S1.is_biproper
False
>>> S2 = Series(tf2, tf3)
>>> S2.is_biproper
True
property is_proper
如果结果传递函数的分子多项式的度数小于或等于相同分母多项式的度数,则返回 True,否则返回 False。
示例
>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Series
>>> tf1 = TransferFunction(b*s**2 + p**2 - a*p + s, b - p**2, s)
>>> tf2 = TransferFunction(p**2 - 4*p, p**3 + 3*s + 2, s)
>>> tf3 = TransferFunction(s, s**2 + s + 1, s)
>>> S1 = Series(-tf2, tf1)
>>> S1.is_proper
False
>>> S2 = Series(tf1, tf2, tf3)
>>> S2.is_proper
True
property is_strictly_proper
如果结果传递函数的分子多项式的度数严格小于相同分母多项式的度数,则返回 True,否则返回 False。
示例
>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Series
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf2 = TransferFunction(s**3 - 2, s**2 + 5*s + 6, s)
>>> tf3 = TransferFunction(1, s**2 + s + 1, s)
>>> S1 = Series(tf1, tf2)
>>> S1.is_strictly_proper
False
>>> S2 = Series(tf1, tf2, tf3)
>>> S2.is_strictly_proper
True
to_expr()
返回等效于 Expr
对象。
property var
返回所有传递函数使用的复变量。
示例
>>> from sympy.abc import p
>>> from sympy.physics.control.lti import TransferFunction, Series, Parallel
>>> G1 = TransferFunction(p**2 + 2*p + 4, p - 6, p)
>>> G2 = TransferFunction(p, 4 - p, p)
>>> G3 = TransferFunction(0, p**4 - 1, p)
>>> Series(G1, G2).var
p
>>> Series(-G3, Parallel(G1, G2)).var
p
class sympy.physics.control.lti.Parallel(*args, evaluate=False)
用于表示串联配置的 SISO 系统的类。
参数:
args : SISO 线性时不变
并联排列的 SISO 系统。
评估 : 布尔值,关键字
当传递
True
时,返回等效于Parallel(*args).doit()
。 默认设置为False
。
引发:
数值错误
当没有传递参数时。
var
属性对每个系统不相同。
类型错误
任何传递的
*args
具有不支持的类型传递了 SISO 和 MIMO 系统的组合。 传递的系统类型应保持同质性。
示例
>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Parallel, Series
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)
>>> tf3 = TransferFunction(p**2, p + s, s)
>>> P1 = Parallel(tf1, tf2)
>>> P1
Parallel(TransferFunction(a*p**2 + b*s, -p + s, s), TransferFunction(s**3 - 2, s**4 + 5*s + 6, s))
>>> P1.var
s
>>> P2 = Parallel(tf2, Series(tf3, -tf1))
>>> P2
Parallel(TransferFunction(s**3 - 2, s**4 + 5*s + 6, s), Series(TransferFunction(p**2, p + s, s), TransferFunction(-a*p**2 - b*s, -p + s, s)))
>>> P2.var
s
>>> P3 = Parallel(Series(tf1, tf2), Series(tf2, tf3))
>>> P3
Parallel(Series(TransferFunction(a*p**2 + b*s, -p + s, s), TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)), Series(TransferFunction(s**3 - 2, s**4 + 5*s + 6, s), TransferFunction(p**2, p + s, s)))
>>> P3.var
s
您可以通过使用 .doit()
方法获得结果传递函数:
>>> Parallel(tf1, tf2, -tf3).doit()
TransferFunction(-p**2*(-p + s)*(s**4 + 5*s + 6) + (-p + s)*(p + s)*(s**3 - 2) + (p + s)*(a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)*(p + s)*(s**4 + 5*s + 6), s)
>>> Parallel(tf2, Series(tf1, -tf3)).doit()
TransferFunction(-p**2*(a*p**2 + b*s)*(s**4 + 5*s + 6) + (-p + s)*(p + s)*(s**3 - 2), (-p + s)*(p + s)*(s**4 + 5*s + 6), s)
注意
所有传递函数应使用拉普拉斯变换的同一复变量 var
。
参见
串联
, 传递函数
, 反馈
doit(**hints)
返回在并联配置中评估传递函数后获得的结果传递函数。
示例
>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Parallel
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)
>>> Parallel(tf2, tf1).doit()
TransferFunction((-p + s)*(s**3 - 2) + (a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)*(s**4 + 5*s + 6), s)
>>> Parallel(-tf1, -tf2).doit()
TransferFunction((2 - s**3)*(-p + s) + (-a*p**2 - b*s)*(s**4 + 5*s + 6), (-p + s)*(s**4 + 5*s + 6), s)
property is_biproper
如果结果传递函数的分子多项式的次数等于相同的分母多项式的次数,则返回 True,否则返回 False。
示例
>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Parallel
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf2 = TransferFunction(p**2, p + s, s)
>>> tf3 = TransferFunction(s, s**2 + s + 1, s)
>>> P1 = Parallel(tf1, -tf2)
>>> P1.is_biproper
True
>>> P2 = Parallel(tf2, tf3)
>>> P2.is_biproper
False
property is_proper
如果结果传递函数的分子多项式的次数小于或等于相同的分母多项式的次数,则返回 True,否则返回 False。
示例
>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Parallel
>>> tf1 = TransferFunction(b*s**2 + p**2 - a*p + s, b - p**2, s)
>>> tf2 = TransferFunction(p**2 - 4*p, p**3 + 3*s + 2, s)
>>> tf3 = TransferFunction(s, s**2 + s + 1, s)
>>> P1 = Parallel(-tf2, tf1)
>>> P1.is_proper
False
>>> P2 = Parallel(tf2, tf3)
>>> P2.is_proper
True
property is_strictly_proper
如果结果传递函数的分子多项式的次数严格小于分母多项式的次数,则返回 True,否则返回 False。
示例
>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, Parallel
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)
>>> tf3 = TransferFunction(s, s**2 + s + 1, s)
>>> P1 = Parallel(tf1, tf2)
>>> P1.is_strictly_proper
False
>>> P2 = Parallel(tf2, tf3)
>>> P2.is_strictly_proper
True
to_expr()
返回等效的Expr
对象。
property var
返回所有传递函数使用的复数变量。
示例
>>> from sympy.abc import p
>>> from sympy.physics.control.lti import TransferFunction, Parallel, Series
>>> G1 = TransferFunction(p**2 + 2*p + 4, p - 6, p)
>>> G2 = TransferFunction(p, 4 - p, p)
>>> G3 = TransferFunction(0, p**4 - 1, p)
>>> Parallel(G1, G2).var
p
>>> Parallel(-G3, Series(G1, G2)).var
p
class sympy.physics.control.lti.Feedback(sys1, sys2=None, sign=-1)
一个用于表示两个 SISO 输入/输出系统之间闭环反馈互连的类。
第一个参数sys1
是闭环系统的前馈部分,或者简单来说,是代表要控制的过程的动态模型。第二个参数sys2
是反馈系统,并控制反馈信号到sys1
。sys1
和sys2
都可以是Series
或TransferFunction
对象。
参数:
sys1 : Series, TransferFunction
前馈路径系统。
sys2 : Series, TransferFunction, optional
反馈路径系统(通常是反馈控制器)。它是位于反馈路径上的模型。
如果未明确指定,假设
sys2
为单位(1.0)传递函数。
sign : int, optional
反馈的符号。可以是
1
(正反馈)或-1
(负反馈)。默认值为(-1)。
抛出:
ValueError
当
sys1
和sys2
没有使用相同的拉普拉斯变换复数变量时。当
sys1
和sys2
的组合产生零分母时。
TypeError
当
sys1
或sys2
不是Series
或TransferFunction
对象时。
示例
>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction, Feedback
>>> plant = TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s)
>>> controller = TransferFunction(5*s - 10, s + 7, s)
>>> F1 = Feedback(plant, controller)
>>> F1
Feedback(TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s), TransferFunction(5*s - 10, s + 7, s), -1)
>>> F1.var
s
>>> F1.args
(TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s), TransferFunction(5*s - 10, s + 7, s), -1)
你可以分别使用.sys1
和.sys2
获取前馈和反馈路径系统。
>>> F1.sys1
TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s)
>>> F1.sys2
TransferFunction(5*s - 10, s + 7, s)
通过使用.doit()
方法,你可以获得通过负反馈互连得到的结果闭环传递函数。
>>> F1.doit()
TransferFunction((s + 7)*(s**2 - 4*s + 2)*(3*s**2 + 7*s - 3), ((s + 7)*(s**2 - 4*s + 2) + (5*s - 10)*(3*s**2 + 7*s - 3))*(s**2 - 4*s + 2), s)
>>> G = TransferFunction(2*s**2 + 5*s + 1, s**2 + 2*s + 3, s)
>>> C = TransferFunction(5*s + 10, s + 10, s)
>>> F2 = Feedback(G*C, TransferFunction(1, 1, s))
>>> F2.doit()
TransferFunction((s + 10)*(5*s + 10)*(s**2 + 2*s + 3)*(2*s**2 + 5*s + 1), (s + 10)*((s + 10)*(s**2 + 2*s + 3) + (5*s + 10)*(2*s**2 + 5*s + 1))*(s**2 + 2*s + 3), s)
要否定Feedback
对象,可以添加-
运算符:
>>> -F1
Feedback(TransferFunction(-3*s**2 - 7*s + 3, s**2 - 4*s + 2, s), TransferFunction(10 - 5*s, s + 7, s), -1)
>>> -F2
Feedback(Series(TransferFunction(-1, 1, s), TransferFunction(2*s**2 + 5*s + 1, s**2 + 2*s + 3, s), TransferFunction(5*s + 10, s + 10, s)), TransferFunction(-1, 1, s), -1)
另见
MIMOFeedback
, Series
, Parallel
property den
返回闭环反馈模型的分母。
doit(cancel=False, expand=False, **hints)
返回通过反馈互连得到的结果传递函数。
示例
>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction, Feedback
>>> plant = TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s)
>>> controller = TransferFunction(5*s - 10, s + 7, s)
>>> F1 = Feedback(plant, controller)
>>> F1.doit()
TransferFunction((s + 7)*(s**2 - 4*s + 2)*(3*s**2 + 7*s - 3), ((s + 7)*(s**2 - 4*s + 2) + (5*s - 10)*(3*s**2 + 7*s - 3))*(s**2 - 4*s + 2), s)
>>> G = TransferFunction(2*s**2 + 5*s + 1, s**2 + 2*s + 3, s)
>>> F2 = Feedback(G, TransferFunction(1, 1, s))
>>> F2.doit()
TransferFunction((s**2 + 2*s + 3)*(2*s**2 + 5*s + 1), (s**2 + 2*s + 3)*(3*s**2 + 7*s + 4), s)
使用关键字参数expand=True
来展开结果传递函数。使用cancel=True
来取消分子和分母中的公共项。
>>> F2.doit(cancel=True, expand=True)
TransferFunction(2*s**2 + 5*s + 1, 3*s**2 + 7*s + 4, s)
>>> F2.doit(expand=True)
TransferFunction(2*s**4 + 9*s**3 + 17*s**2 + 17*s + 3, 3*s**4 + 13*s**3 + 27*s**2 + 29*s + 12, s)
property num
返回闭环反馈系统的分子。
property sensitivity
返回反馈环路的灵敏度函数。
反馈系统的敏感性是开环增益变化与闭环增益变化的比率。
注意
此方法不会返回互补的敏感性函数。
例子
>>> from sympy.abc import p
>>> from sympy.physics.control.lti import TransferFunction, Feedback
>>> C = TransferFunction(5*p + 10, p + 10, p)
>>> P = TransferFunction(1 - p, p + 2, p)
>>> F_1 = Feedback(P, C)
>>> F_1.sensitivity
1/((1 - p)*(5*p + 10)/((p + 2)*(p + 10)) + 1)
property sign
返回 MIMO 反馈模型的类型。 1
表示正反馈,-1
表示负反馈。
property sys1
返回反馈互联的前馈系统。
例子
>>> from sympy.abc import s, p
>>> from sympy.physics.control.lti import TransferFunction, Feedback
>>> plant = TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s)
>>> controller = TransferFunction(5*s - 10, s + 7, s)
>>> F1 = Feedback(plant, controller)
>>> F1.sys1
TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s)
>>> G = TransferFunction(2*s**2 + 5*s + 1, p**2 + 2*p + 3, p)
>>> C = TransferFunction(5*p + 10, p + 10, p)
>>> P = TransferFunction(1 - s, p + 2, p)
>>> F2 = Feedback(TransferFunction(1, 1, p), G*C*P)
>>> F2.sys1
TransferFunction(1, 1, p)
property sys2
返回反馈互联的反馈控制器。
例子
>>> from sympy.abc import s, p
>>> from sympy.physics.control.lti import TransferFunction, Feedback
>>> plant = TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s)
>>> controller = TransferFunction(5*s - 10, s + 7, s)
>>> F1 = Feedback(plant, controller)
>>> F1.sys2
TransferFunction(5*s - 10, s + 7, s)
>>> G = TransferFunction(2*s**2 + 5*s + 1, p**2 + 2*p + 3, p)
>>> C = TransferFunction(5*p + 10, p + 10, p)
>>> P = TransferFunction(1 - s, p + 2, p)
>>> F2 = Feedback(TransferFunction(1, 1, p), G*C*P)
>>> F2.sys2
Series(TransferFunction(2*s**2 + 5*s + 1, p**2 + 2*p + 3, p), TransferFunction(5*p + 10, p + 10, p), TransferFunction(1 - s, p + 2, p))
to_expr()
将Feedback
对象转换为 SymPy 表达式。
例子
>>> from sympy.abc import s, a, b
>>> from sympy.physics.control.lti import TransferFunction, Feedback
>>> from sympy import Expr
>>> tf1 = TransferFunction(a+s, 1, s)
>>> tf2 = TransferFunction(b+s, 1, s)
>>> fd1 = Feedback(tf1, tf2)
>>> fd1.to_expr()
(a + s)/((a + s)*(b + s) + 1)
>>> isinstance(_, Expr)
True
property var
返回在反馈互联中涉及的所有传递函数使用的拉普拉斯变换的复变量。
例子
>>> from sympy.abc import s, p
>>> from sympy.physics.control.lti import TransferFunction, Feedback
>>> plant = TransferFunction(3*s**2 + 7*s - 3, s**2 - 4*s + 2, s)
>>> controller = TransferFunction(5*s - 10, s + 7, s)
>>> F1 = Feedback(plant, controller)
>>> F1.var
s
>>> G = TransferFunction(2*s**2 + 5*s + 1, p**2 + 2*p + 3, p)
>>> C = TransferFunction(5*p + 10, p + 10, p)
>>> P = TransferFunction(1 - s, p + 2, p)
>>> F2 = Feedback(TransferFunction(1, 1, p), G*C*P)
>>> F2.var
p
class sympy.physics.control.lti.TransferFunctionMatrix(arg)
用于表示 SISO(单输入单输出)传递函数的 MIMO(多输入多输出)概括的类。
它是传递函数矩阵(TransferFunction
,SISO-Series
或 SISO-Parallel
)的矩阵。 只有一个参数,arg
也是强制性参数。 期望arg
严格为列表列表类型,其中包含传递函数或可化简为传递函数。
参数:
arg:嵌套的List
(严格)。
用户预期输入
TransferFunction
,Series
和/或Parallel
对象的嵌套列表。
例子
注意
pprint()
可用于更好地可视化TransferFunctionMatrix
对象。
>>> from sympy.abc import s, p, a
>>> from sympy import pprint
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, Series, Parallel
>>> tf_1 = TransferFunction(s + a, s**2 + s + 1, s)
>>> tf_2 = TransferFunction(p**4 - 3*p + 2, s + p, s)
>>> tf_3 = TransferFunction(3, s + 2, s)
>>> tf_4 = TransferFunction(-a + p, 9*s - 9, s)
>>> tfm_1 = TransferFunctionMatrix([[tf_1], [tf_2], [tf_3]])
>>> tfm_1
TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(3, s + 2, s),)))
>>> tfm_1.var
s
>>> tfm_1.num_inputs
1
>>> tfm_1.num_outputs
3
>>> tfm_1.shape
(3, 1)
>>> tfm_1.args
(((TransferFunction(a + s, s**2 + s + 1, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(3, s + 2, s),)),)
>>> tfm_2 = TransferFunctionMatrix([[tf_1, -tf_3], [tf_2, -tf_1], [tf_3, -tf_2]])
>>> tfm_2
TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s), TransferFunction(-3, s + 2, s)), (TransferFunction(p**4 - 3*p + 2, p + s, s), TransferFunction(-a - s, s**2 + s + 1, s)), (TransferFunction(3, s + 2, s), TransferFunction(-p**4 + 3*p - 2, p + s, s))))
>>> pprint(tfm_2, use_unicode=False) # pretty-printing for better visualization
[ a + s -3 ]
[ ---------- ----- ]
[ 2 s + 2 ]
[ s + s + 1 ]
[ ]
[ 4 ]
[p - 3*p + 2 -a - s ]
[------------ ---------- ]
[ p + s 2 ]
[ s + s + 1 ]
[ ]
[ 4 ]
[ 3 - p + 3*p - 2]
[ ----- --------------]
[ s + 2 p + s ]{t}
如果用户希望切换输入和输出传递函数,可以对TransferFunctionMatrix
进行转置。
>>> tfm_2.transpose()
TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s), TransferFunction(p**4 - 3*p + 2, p + s, s), TransferFunction(3, s + 2, s)), (TransferFunction(-3, s + 2, s), TransferFunction(-a - s, s**2 + s + 1, s), TransferFunction(-p**4 + 3*p - 2, p + s, s))))
>>> pprint(_, use_unicode=False)
[ 4 ]
[ a + s p - 3*p + 2 3 ]
[---------- ------------ ----- ]
[ 2 p + s s + 2 ]
[s + s + 1 ]
[ ]
[ 4 ]
[ -3 -a - s - p + 3*p - 2]
[ ----- ---------- --------------]
[ s + 2 2 p + s ]
[ s + s + 1 ]{t}
>>> tf_5 = TransferFunction(5, s, s)
>>> tf_6 = TransferFunction(5*s, (2 + s**2), s)
>>> tf_7 = TransferFunction(5, (s*(2 + s**2)), s)
>>> tf_8 = TransferFunction(5, 1, s)
>>> tfm_3 = TransferFunctionMatrix([[tf_5, tf_6], [tf_7, tf_8]])
>>> tfm_3
TransferFunctionMatrix(((TransferFunction(5, s, s), TransferFunction(5*s, s**2 + 2, s)), (TransferFunction(5, s*(s**2 + 2), s), TransferFunction(5, 1, s))))
>>> pprint(tfm_3, use_unicode=False)
[ 5 5*s ]
[ - ------]
[ s 2 ]
[ s + 2]
[ ]
[ 5 5 ]
[---------- - ]
[ / 2 \ 1 ]
[s*\s + 2/ ]{t}
>>> tfm_3.var
s
>>> tfm_3.shape
(2, 2)
>>> tfm_3.num_outputs
2
>>> tfm_3.num_inputs
2
>>> tfm_3.args
(((TransferFunction(5, s, s), TransferFunction(5*s, s**2 + 2, s)), (TransferFunction(5, s*(s**2 + 2), s), TransferFunction(5, 1, s))),)
要访问TransferFunctionMatrix
中任何索引处的TransferFunction
,请使用索引表示法。
>>> tfm_3[1, 0] # gives the TransferFunction present at 2nd Row and 1st Col. Similar to that in Matrix classes
TransferFunction(5, s*(s**2 + 2), s)
>>> tfm_3[0, 0] # gives the TransferFunction present at 1st Row and 1st Col.
TransferFunction(5, s, s)
>>> tfm_3[:, 0] # gives the first column
TransferFunctionMatrix(((TransferFunction(5, s, s),), (TransferFunction(5, s*(s**2 + 2), s),)))
>>> pprint(_, use_unicode=False)
[ 5 ]
[ - ]
[ s ]
[ ]
[ 5 ]
[----------]
[ / 2 \]
[s*\s + 2/]{t}
>>> tfm_3[0, :] # gives the first row
TransferFunctionMatrix(((TransferFunction(5, s, s), TransferFunction(5*s, s**2 + 2, s)),))
>>> pprint(_, use_unicode=False)
[5 5*s ]
[- ------]
[s 2 ]
[ s + 2]{t}
要对传递函数矩阵取反,可以在其前面加上-
运算符:
>>> tfm_4 = TransferFunctionMatrix([[tf_2], [-tf_1], [tf_3]])
>>> -tfm_4
TransferFunctionMatrix(((TransferFunction(-p**4 + 3*p - 2, p + s, s),), (TransferFunction(a + s, s**2 + s + 1, s),), (TransferFunction(-3, s + 2, s),)))
>>> tfm_5 = TransferFunctionMatrix([[tf_1, tf_2], [tf_3, -tf_1]])
>>> -tfm_5
TransferFunctionMatrix(((TransferFunction(-a - s, s**2 + s + 1, s), TransferFunction(-p**4 + 3*p - 2, p + s, s)), (TransferFunction(-3, s + 2, s), TransferFunction(a + s, s**2 + s + 1, s))))
subs()
返回替换为表达式中的值的TransferFunctionMatrix
对象。 这不会改变您的原始TransferFunctionMatrix
。
>>> tfm_2.subs(p, 2) # substituting p everywhere in tfm_2 with 2.
TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s), TransferFunction(-3, s + 2, s)), (TransferFunction(12, s + 2, s), TransferFunction(-a - s, s**2 + s + 1, s)), (TransferFunction(3, s + 2, s), TransferFunction(-12, s + 2, s))))
>>> pprint(_, use_unicode=False)
[ a + s -3 ]
[---------- ----- ]
[ 2 s + 2 ]
[s + s + 1 ]
[ ]
[ 12 -a - s ]
[ ----- ----------]
[ s + 2 2 ]
[ s + s + 1]
[ ]
[ 3 -12 ]
[ ----- ----- ]
[ s + 2 s + 2 ]{t}
>>> pprint(tfm_2, use_unicode=False) # State of tfm_2 is unchanged after substitution
[ a + s -3 ]
[ ---------- ----- ]
[ 2 s + 2 ]
[ s + s + 1 ]
[ ]
[ 4 ]
[p - 3*p + 2 -a - s ]
[------------ ---------- ]
[ p + s 2 ]
[ s + s + 1 ]
[ ]
[ 4 ]
[ 3 - p + 3*p - 2]
[ ----- --------------]
[ s + 2 p + s ]{t}
subs()
还支持多个替换。
>>> tfm_2.subs({p: 2, a: 1}) # substituting p with 2 and a with 1
TransferFunctionMatrix(((TransferFunction(s + 1, s**2 + s + 1, s), TransferFunction(-3, s + 2, s)), (TransferFunction(12, s + 2, s), TransferFunction(-s - 1, s**2 + s + 1, s)), (TransferFunction(3, s + 2, s), TransferFunction(-12, s + 2, s))))
>>> pprint(_, use_unicode=False)
[ s + 1 -3 ]
[---------- ----- ]
[ 2 s + 2 ]
[s + s + 1 ]
[ ]
[ 12 -s - 1 ]
[ ----- ----------]
[ s + 2 2 ]
[ s + s + 1]
[ ]
[ 3 -12 ]
[ ----- ----- ]
[ s + 2 s + 2 ]{t}
用户可以通过使用doit()
将矩阵的Series
和Parallel
元素减少为TransferFunction
。
>>> tfm_6 = TransferFunctionMatrix([[Series(tf_3, tf_4), Parallel(tf_3, tf_4)]])
>>> tfm_6
TransferFunctionMatrix(((Series(TransferFunction(3, s + 2, s), TransferFunction(-a + p, 9*s - 9, s)), Parallel(TransferFunction(3, s + 2, s), TransferFunction(-a + p, 9*s - 9, s))),))
>>> pprint(tfm_6, use_unicode=False)
[-a + p 3 -a + p 3 ]
[-------*----- ------- + -----]
[9*s - 9 s + 2 9*s - 9 s + 2]{t}
>>> tfm_6.doit()
TransferFunctionMatrix(((TransferFunction(-3*a + 3*p, (s + 2)*(9*s - 9), s), TransferFunction(27*s + (-a + p)*(s + 2) - 27, (s + 2)*(9*s - 9), s)),))
>>> pprint(_, use_unicode=False)
[ -3*a + 3*p 27*s + (-a + p)*(s + 2) - 27]
[----------------- ----------------------------]
[(s + 2)*(9*s - 9) (s + 2)*(9*s - 9) ]{t}
>>> tf_9 = TransferFunction(1, s, s)
>>> tf_10 = TransferFunction(1, s**2, s)
>>> tfm_7 = TransferFunctionMatrix([[Series(tf_9, tf_10), tf_9], [tf_10, Parallel(tf_9, tf_10)]])
>>> tfm_7
TransferFunctionMatrix(((Series(TransferFunction(1, s, s), TransferFunction(1, s**2, s)), TransferFunction(1, s, s)), (TransferFunction(1, s**2, s), Parallel(TransferFunction(1, s, s), TransferFunction(1, s**2, s)))))
>>> pprint(tfm_7, use_unicode=False)
[ 1 1 ]
[---- - ]
[ 2 s ]
[s*s ]
[ ]
[ 1 1 1]
[ -- -- + -]
[ 2 2 s]
[ s s ]{t}
>>> tfm_7.doit()
TransferFunctionMatrix(((TransferFunction(1, s**3, s), TransferFunction(1, s, s)), (TransferFunction(1, s**2, s), TransferFunction(s**2 + s, s**3, s))))
>>> pprint(_, use_unicode=False)
[1 1 ]
[-- - ]
[ 3 s ]
[s ]
[ ]
[ 2 ]
[1 s + s]
[-- ------]
[ 2 3 ]
[s s ]{t}
传递函数矩阵的加法、减法和乘法可以形成未评估的Series
或Parallel
对象。
-
对于加法和减法:所有传递函数矩阵必须具有相同的形状。
-
对于乘法(C = A * B):第一个传递函数矩阵(A)的输入数量必须等于第二个传递函数矩阵(B)的输出数量。
还有,使用漂亮打印(pprint
)来进行更好的分析。
>>> tfm_8 = TransferFunctionMatrix([[tf_3], [tf_2], [-tf_1]])
>>> tfm_9 = TransferFunctionMatrix([[-tf_3]])
>>> tfm_10 = TransferFunctionMatrix([[tf_1], [tf_2], [tf_4]])
>>> tfm_11 = TransferFunctionMatrix([[tf_4], [-tf_1]])
>>> tfm_12 = TransferFunctionMatrix([[tf_4, -tf_1, tf_3], [-tf_2, -tf_4, -tf_3]])
>>> tfm_8 + tfm_10
MIMOParallel(TransferFunctionMatrix(((TransferFunction(3, s + 2, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(-a - s, s**2 + s + 1, s),))), TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(-a + p, 9*s - 9, s),))))
>>> pprint(_, use_unicode=False)
[ 3 ] [ a + s ]
[ ----- ] [ ---------- ]
[ s + 2 ] [ 2 ]
[ ] [ s + s + 1 ]
[ 4 ] [ ]
[p - 3*p + 2] [ 4 ]
[------------] + [p - 3*p + 2]
[ p + s ] [------------]
[ ] [ p + s ]
[ -a - s ] [ ]
[ ---------- ] [ -a + p ]
[ 2 ] [ ------- ]
[ s + s + 1 ]{t} [ 9*s - 9 ]{t}
>>> -tfm_10 - tfm_8
MIMOParallel(TransferFunctionMatrix(((TransferFunction(-a - s, s**2 + s + 1, s),), (TransferFunction(-p**4 + 3*p - 2, p + s, s),), (TransferFunction(a - p, 9*s - 9, s),))), TransferFunctionMatrix(((TransferFunction(-3, s + 2, s),), (TransferFunction(-p**4 + 3*p - 2, p + s, s),), (TransferFunction(a + s, s**2 + s + 1, s),))))
>>> pprint(_, use_unicode=False)
[ -a - s ] [ -3 ]
[ ---------- ] [ ----- ]
[ 2 ] [ s + 2 ]
[ s + s + 1 ] [ ]
[ ] [ 4 ]
[ 4 ] [- p + 3*p - 2]
[- p + 3*p - 2] + [--------------]
[--------------] [ p + s ]
[ p + s ] [ ]
[ ] [ a + s ]
[ a - p ] [ ---------- ]
[ ------- ] [ 2 ]
[ 9*s - 9 ]{t} [ s + s + 1 ]{t}
>>> tfm_12 * tfm_8
MIMOSeries(TransferFunctionMatrix(((TransferFunction(3, s + 2, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(-a - s, s**2 + s + 1, s),))), TransferFunctionMatrix(((TransferFunction(-a + p, 9*s - 9, s), TransferFunction(-a - s, s**2 + s + 1, s), TransferFunction(3, s + 2, s)), (TransferFunction(-p**4 + 3*p - 2, p + s, s), TransferFunction(a - p, 9*s - 9, s), TransferFunction(-3, s + 2, s)))))
>>> pprint(_, use_unicode=False)
[ 3 ]
[ ----- ]
[ -a + p -a - s 3 ] [ s + 2 ]
[ ------- ---------- -----] [ ]
[ 9*s - 9 2 s + 2] [ 4 ]
[ s + s + 1 ] [p - 3*p + 2]
[ ] *[------------]
[ 4 ] [ p + s ]
[- p + 3*p - 2 a - p -3 ] [ ]
[-------------- ------- -----] [ -a - s ]
[ p + s 9*s - 9 s + 2]{t} [ ---------- ]
[ 2 ]
[ s + s + 1 ]{t}
>>> tfm_12 * tfm_8 * tfm_9
MIMOSeries(TransferFunctionMatrix(((TransferFunction(-3, s + 2, s),),)), TransferFunctionMatrix(((TransferFunction(3, s + 2, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(-a - s, s**2 + s + 1, s),))), TransferFunctionMatrix(((TransferFunction(-a + p, 9*s - 9, s), TransferFunction(-a - s, s**2 + s + 1, s), TransferFunction(3, s + 2, s)), (TransferFunction(-p**4 + 3*p - 2, p + s, s), TransferFunction(a - p, 9*s - 9, s), TransferFunction(-3, s + 2, s)))))
>>> pprint(_, use_unicode=False)
[ 3 ]
[ ----- ]
[ -a + p -a - s 3 ] [ s + 2 ]
[ ------- ---------- -----] [ ]
[ 9*s - 9 2 s + 2] [ 4 ]
[ s + s + 1 ] [p - 3*p + 2] [ -3 ]
[ ] *[------------] *[-----]
[ 4 ] [ p + s ] [s + 2]{t}
[- p + 3*p - 2 a - p -3 ] [ ]
[-------------- ------- -----] [ -a - s ]
[ p + s 9*s - 9 s + 2]{t} [ ---------- ]
[ 2 ]
[ s + s + 1 ]{t}
>>> tfm_10 + tfm_8*tfm_9
MIMOParallel(TransferFunctionMatrix(((TransferFunction(a + s, s**2 + s + 1, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(-a + p, 9*s - 9, s),))), MIMOSeries(TransferFunctionMatrix(((TransferFunction(-3, s + 2, s),),)), TransferFunctionMatrix(((TransferFunction(3, s + 2, s),), (TransferFunction(p**4 - 3*p + 2, p + s, s),), (TransferFunction(-a - s, s**2 + s + 1, s),)))))
>>> pprint(_, use_unicode=False)
[ a + s ] [ 3 ]
[ ---------- ] [ ----- ]
[ 2 ] [ s + 2 ]
[ s + s + 1 ] [ ]
[ ] [ 4 ]
[ 4 ] [p - 3*p + 2] [ -3 ]
[p - 3*p + 2] + [------------] *[-----]
[------------] [ p + s ] [s + 2]{t}
[ p + s ] [ ]
[ ] [ -a - s ]
[ -a + p ] [ ---------- ]
[ ------- ] [ 2 ]
[ 9*s - 9 ]{t} [ s + s + 1 ]{t}
这些未评估的Series
或Parallel
对象可以通过.doit()
方法或.rewrite(TransferFunctionMatrix)
转换为结果传递函数矩阵。
>>> (-tfm_8 + tfm_10 + tfm_8*tfm_9).doit()
TransferFunctionMatrix(((TransferFunction((a + s)*(s + 2)**3 - 3*(s + 2)**2*(s**2 + s + 1) - 9*(s + 2)*(s**2 + s + 1), (s + 2)**3*(s**2 + s + 1), s),), (TransferFunction((p + s)*(-3*p**4 + 9*p - 6), (p + s)**2*(s + 2), s),), (TransferFunction((-a + p)*(s + 2)*(s**2 + s + 1)**2 + (a + s)*(s + 2)*(9*s - 9)*(s**2 + s + 1) + (3*a + 3*s)*(9*s - 9)*(s**2 + s + 1), (s + 2)*(9*s - 9)*(s**2 + s + 1)**2, s),)))
>>> (-tfm_12 * -tfm_8 * -tfm_9).rewrite(TransferFunctionMatrix)
TransferFunctionMatrix(((TransferFunction(3*(-3*a + 3*p)*(p + s)*(s + 2)*(s**2 + s + 1)**2 + 3*(-3*a - 3*s)*(p + s)*(s + 2)*(9*s - 9)*(s**2 + s + 1) + 3*(a + s)*(s + 2)**2*(9*s - 9)*(-p**4 + 3*p - 2)*(s**2 + s + 1), (p + s)*(s + 2)**3*(9*s - 9)*(s**2 + s + 1)**2, s),), (TransferFunction(3*(-a + p)*(p + s)*(s + 2)**2*(-p**4 + 3*p - 2)*(s**2 + s + 1) + 3*(3*a + 3*s)*(p + s)**2*(s + 2)*(9*s - 9) + 3*(p + s)*(s + 2)*(9*s - 9)*(-3*p**4 + 9*p - 6)*(s**2 + s + 1), (p + s)**2*(s + 2)**3*(9*s - 9)*(s**2 + s + 1), s),)))
另请参见
TransferFunction
,MIMOSeries
,MIMOParallel
,Feedback
elem_poles()
返回每个TransferFunctionMatrix
元素的极点。
注意
MIMO 系统的实际极点不是各个元素的极点。
示例
>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix
>>> tf_1 = TransferFunction(3, (s + 1), s)
>>> tf_2 = TransferFunction(s + 6, (s + 1)*(s + 2), s)
>>> tf_3 = TransferFunction(s + 3, s**2 + 3*s + 2, s)
>>> tf_4 = TransferFunction(s + 2, s**2 + 5*s - 10, s)
>>> tfm_1 = TransferFunctionMatrix([[tf_1, tf_2], [tf_3, tf_4]])
>>> tfm_1
TransferFunctionMatrix(((TransferFunction(3, s + 1, s), TransferFunction(s + 6, (s + 1)*(s + 2), s)), (TransferFunction(s + 3, s**2 + 3*s + 2, s), TransferFunction(s + 2, s**2 + 5*s - 10, s))))
>>> tfm_1.elem_poles()
[[[-1], [-2, -1]], [[-2, -1], [-5/2 + sqrt(65)/2, -sqrt(65)/2 - 5/2]]]
参见
elem_zeros
elem_zeros()
返回TransferFunctionMatrix
的每个元素的零点。
注意
MIMO 系统的实际零点不是各个元素的零点。
示例
>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix
>>> tf_1 = TransferFunction(3, (s + 1), s)
>>> tf_2 = TransferFunction(s + 6, (s + 1)*(s + 2), s)
>>> tf_3 = TransferFunction(s + 3, s**2 + 3*s + 2, s)
>>> tf_4 = TransferFunction(s**2 - 9*s + 20, s**2 + 5*s - 10, s)
>>> tfm_1 = TransferFunctionMatrix([[tf_1, tf_2], [tf_3, tf_4]])
>>> tfm_1
TransferFunctionMatrix(((TransferFunction(3, s + 1, s), TransferFunction(s + 6, (s + 1)*(s + 2), s)), (TransferFunction(s + 3, s**2 + 3*s + 2, s), TransferFunction(s**2 - 9*s + 20, s**2 + 5*s - 10, s))))
>>> tfm_1.elem_zeros()
[[[], [-6]], [[-3], [4, 5]]]
参见
elem_poles
eval_frequency(other)
在实数或复数平面的任意点评估TransferFunctionMatrix
中每个传输函数的系统响应。
示例
>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix
>>> from sympy import I
>>> tf_1 = TransferFunction(3, (s + 1), s)
>>> tf_2 = TransferFunction(s + 6, (s + 1)*(s + 2), s)
>>> tf_3 = TransferFunction(s + 3, s**2 + 3*s + 2, s)
>>> tf_4 = TransferFunction(s**2 - 9*s + 20, s**2 + 5*s - 10, s)
>>> tfm_1 = TransferFunctionMatrix([[tf_1, tf_2], [tf_3, tf_4]])
>>> tfm_1
TransferFunctionMatrix(((TransferFunction(3, s + 1, s), TransferFunction(s + 6, (s + 1)*(s + 2), s)), (TransferFunction(s + 3, s**2 + 3*s + 2, s), TransferFunction(s**2 - 9*s + 20, s**2 + 5*s - 10, s))))
>>> tfm_1.eval_frequency(2)
Matrix([
[ 1, 2/3],
[5/12, 3/2]])
>>> tfm_1.eval_frequency(I*2)
Matrix([
[ 3/5 - 6*I/5, -I],
[3/20 - 11*I/20, -101/74 + 23*I/74]])
expand(**hints)
扩展传输函数矩阵
classmethod from_Matrix(matrix, var)
有效地从 SymPy 矩阵的Expr
对象创建新的TransferFunctionMatrix
。
参数:
matrix:具有Expr
/Number
元素的ImmutableMatrix
。
var:符号
拉普拉斯变换的复变量,将被
TransferFunctionMatrix
中所有TransferFunction
对象使用。
示例
>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunctionMatrix
>>> from sympy import Matrix, pprint
>>> M = Matrix([[s, 1/s], [1/(s+1), s]])
>>> M_tf = TransferFunctionMatrix.from_Matrix(M, s)
>>> pprint(M_tf, use_unicode=False)
[ s 1]
[ - -]
[ 1 s]
[ ]
[ 1 s]
[----- -]
[s + 1 1]{t}
>>> M_tf.elem_poles()
[[[], [0]], [[-1], []]]
>>> M_tf.elem_zeros()
[[[0], []], [[], [0]]]
property num_inputs
返回系统的输入数量。
示例
>>> from sympy.abc import s, p
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix
>>> G1 = TransferFunction(s + 3, s**2 - 3, s)
>>> G2 = TransferFunction(4, s**2, s)
>>> G3 = TransferFunction(p**2 + s**2, p - 3, s)
>>> tfm_1 = TransferFunctionMatrix([[G2, -G1, G3], [-G2, -G1, -G3]])
>>> tfm_1.num_inputs
3
参见
num_outputs
property num_outputs
返回系统输出的数量。
示例
>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunctionMatrix
>>> from sympy import Matrix
>>> M_1 = Matrix([[s], [1/s]])
>>> TFM = TransferFunctionMatrix.from_Matrix(M_1, s)
>>> print(TFM)
TransferFunctionMatrix(((TransferFunction(s, 1, s),), (TransferFunction(1, s, s),)))
>>> TFM.num_outputs
2
参见
num_inputs
property shape
返回传输函数矩阵的形状,即(# of outputs, # of inputs)
。
示例
>>> from sympy.abc import s, p
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix
>>> tf1 = TransferFunction(p**2 - 1, s**4 + s**3 - p, p)
>>> tf2 = TransferFunction(1 - p, p**2 - 3*p + 7, p)
>>> tf3 = TransferFunction(3, 4, p)
>>> tfm1 = TransferFunctionMatrix([[tf1, -tf2]])
>>> tfm1.shape
(1, 2)
>>> tfm2 = TransferFunctionMatrix([[-tf2, tf3], [tf1, -tf1]])
>>> tfm2.shape
(2, 2)
transpose()
返回TransferFunctionMatrix
的转置(交换输入和输出层)。
property var
返回所有传输函数或Series
/Parallel
对象中使用的复变量。
示例
>>> from sympy.abc import p, s
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, Series, Parallel
>>> G1 = TransferFunction(p**2 + 2*p + 4, p - 6, p)
>>> G2 = TransferFunction(p, 4 - p, p)
>>> G3 = TransferFunction(0, p**4 - 1, p)
>>> G4 = TransferFunction(s + 1, s**2 + s + 1, s)
>>> S1 = Series(G1, G2)
>>> S2 = Series(-G3, Parallel(G2, -G1))
>>> tfm1 = TransferFunctionMatrix([[G1], [G2], [G3]])
>>> tfm1.var
p
>>> tfm2 = TransferFunctionMatrix([[-S1, -S2], [S1, S2]])
>>> tfm2.var
p
>>> tfm3 = TransferFunctionMatrix([[G4]])
>>> tfm3.var
s
class sympy.physics.control.lti.MIMOSeries(*args, evaluate=False)
用于表示 MIMO 系统串联配置的类。
参数:
args:MIMOLinearTimeInvariant
MIMO 系统处于串联配置。
evaluate:布尔值,关键字
当传递
True
时,返回等效的MIMOSeries(*args).doit()
。默认设置为False
。
引发:
ValueError
当不传递任何参数时。
对于每个系统,
var
属性并不相同。MIMO 系统的
num_outputs
不等于其相邻 MIMO 系统的num_inputs
。(基本上是矩阵乘法约束)
TypeError
任何传递的
*args
具有不支持的类型将 SISO 和 MIMO 系统的组合传递。在传递的系统类型中应保持同质性,本例中是 MIMO 系统。
示例
>>> from sympy.abc import s
>>> from sympy.physics.control.lti import MIMOSeries, TransferFunctionMatrix
>>> from sympy import Matrix, pprint
>>> mat_a = Matrix([[5*s], [5]]) # 2 Outputs 1 Input
>>> mat_b = Matrix([[5, 1/(6*s**2)]]) # 1 Output 2 Inputs
>>> mat_c = Matrix([[1, s], [5/s, 1]]) # 2 Outputs 2 Inputs
>>> tfm_a = TransferFunctionMatrix.from_Matrix(mat_a, s)
>>> tfm_b = TransferFunctionMatrix.from_Matrix(mat_b, s)
>>> tfm_c = TransferFunctionMatrix.from_Matrix(mat_c, s)
>>> MIMOSeries(tfm_c, tfm_b, tfm_a)
MIMOSeries(TransferFunctionMatrix(((TransferFunction(1, 1, s), TransferFunction(s, 1, s)), (TransferFunction(5, s, s), TransferFunction(1, 1, s)))), TransferFunctionMatrix(((TransferFunction(5, 1, s), TransferFunction(1, 6*s**2, s)),)), TransferFunctionMatrix(((TransferFunction(5*s, 1, s),), (TransferFunction(5, 1, s),))))
>>> pprint(_, use_unicode=False) # For Better Visualization
[5*s] [1 s]
[---] [5 1 ] [- -]
[ 1 ] [- ----] [1 1]
[ ] *[1 2] *[ ]
[ 5 ] [ 6*s ]{t} [5 1]
[ - ] [- -]
[ 1 ]{t} [s 1]{t}
>>> MIMOSeries(tfm_c, tfm_b, tfm_a).doit()
TransferFunctionMatrix(((TransferFunction(150*s**4 + 25*s, 6*s**3, s), TransferFunction(150*s**4 + 5*s, 6*s**2, s)), (TransferFunction(150*s**3 + 25, 6*s**3, s), TransferFunction(150*s**3 + 5, 6*s**2, s))))
>>> pprint(_, use_unicode=False) # (2 Inputs -A-> 2 Outputs) -> (2 Inputs -B-> 1 Output) -> (1 Input -C-> 2 Outputs) is equivalent to (2 Inputs -Series Equivalent-> 2 Outputs).
[ 4 4 ]
[150*s + 25*s 150*s + 5*s]
[------------- ------------]
[ 3 2 ]
[ 6*s 6*s ]
[ ]
[ 3 3 ]
[ 150*s + 25 150*s + 5 ]
[ ----------- ---------- ]
[ 3 2 ]
[ 6*s 6*s ]{t}
注意
所有传输函数矩阵应使用拉普拉斯变换的相同复变量var
。
MIMOSeries(A, B)
与A*B
不等同。它总是以相反的顺序,即B*A
。
参见
Series
, MIMOParallel
doit(cancel=False, **kwargs)
返回在串联配置的 MIMO 系统评估后获得的结果传递函数矩阵。
示例
>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, MIMOSeries, TransferFunctionMatrix
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)
>>> tfm1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf2]])
>>> tfm2 = TransferFunctionMatrix([[tf2, tf1], [tf1, tf1]])
>>> MIMOSeries(tfm2, tfm1).doit()
TransferFunctionMatrix(((TransferFunction(2*(-p + s)*(s**3 - 2)*(a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)**2*(s**4 + 5*s + 6)**2, s), TransferFunction((-p + s)**2*(s**3 - 2)*(a*p**2 + b*s) + (-p + s)*(a*p**2 + b*s)**2*(s**4 + 5*s + 6), (-p + s)**3*(s**4 + 5*s + 6), s)), (TransferFunction((-p + s)*(s**3 - 2)**2*(s**4 + 5*s + 6) + (s**3 - 2)*(a*p**2 + b*s)*(s**4 + 5*s + 6)**2, (-p + s)*(s**4 + 5*s + 6)**3, s), TransferFunction(2*(s**3 - 2)*(a*p**2 + b*s), (-p + s)*(s**4 + 5*s + 6), s))))
property num_inputs
返回串联系统的输入信号数量。
property num_outputs
返回串联系统的输出信号数量。
property shape
返回等效 MIMO 系统的形状。
property var
返回所有传递函数使用的复变量。
示例
>>> from sympy.abc import p
>>> from sympy.physics.control.lti import TransferFunction, MIMOSeries, TransferFunctionMatrix
>>> G1 = TransferFunction(p**2 + 2*p + 4, p - 6, p)
>>> G2 = TransferFunction(p, 4 - p, p)
>>> G3 = TransferFunction(0, p**4 - 1, p)
>>> tfm_1 = TransferFunctionMatrix([[G1, G2, G3]])
>>> tfm_2 = TransferFunctionMatrix([[G1], [G2], [G3]])
>>> MIMOSeries(tfm_2, tfm_1).var
p
class sympy.physics.control.lti.MIMOParallel(*args, evaluate=False)
表示并联配置的 MIMO 系统的类。
参数:
args:MIMOLinearTimeInvariant
并联配置的 MIMO 系统。
evaluate:布尔值,关键字
当传递
True
时,返回等效的MIMOParallel(*args).doit()
。默认为False
。
Raises:
数值错误
当未传递参数时。
var
属性在每个系统中不相同。所有传递的 MIMO 系统形状不同。
类型错误
传递的任何
*args
类型都不受支持。传递了一组 SISO 和 MIMO 系统。在这种情况下,传递的系统类型应该是同质的,即 MIMO。
示例
>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunctionMatrix, MIMOParallel
>>> from sympy import Matrix, pprint
>>> expr_1 = 1/s
>>> expr_2 = s/(s**2-1)
>>> expr_3 = (2 + s)/(s**2 - 1)
>>> expr_4 = 5
>>> tfm_a = TransferFunctionMatrix.from_Matrix(Matrix([[expr_1, expr_2], [expr_3, expr_4]]), s)
>>> tfm_b = TransferFunctionMatrix.from_Matrix(Matrix([[expr_2, expr_1], [expr_4, expr_3]]), s)
>>> tfm_c = TransferFunctionMatrix.from_Matrix(Matrix([[expr_3, expr_4], [expr_1, expr_2]]), s)
>>> MIMOParallel(tfm_a, tfm_b, tfm_c)
MIMOParallel(TransferFunctionMatrix(((TransferFunction(1, s, s), TransferFunction(s, s**2 - 1, s)), (TransferFunction(s + 2, s**2 - 1, s), TransferFunction(5, 1, s)))), TransferFunctionMatrix(((TransferFunction(s, s**2 - 1, s), TransferFunction(1, s, s)), (TransferFunction(5, 1, s), TransferFunction(s + 2, s**2 - 1, s)))), TransferFunctionMatrix(((TransferFunction(s + 2, s**2 - 1, s), TransferFunction(5, 1, s)), (TransferFunction(1, s, s), TransferFunction(s, s**2 - 1, s)))))
>>> pprint(_, use_unicode=False) # For Better Visualization
[ 1 s ] [ s 1 ] [s + 2 5 ]
[ - ------] [------ - ] [------ - ]
[ s 2 ] [ 2 s ] [ 2 1 ]
[ s - 1] [s - 1 ] [s - 1 ]
[ ] + [ ] + [ ]
[s + 2 5 ] [ 5 s + 2 ] [ 1 s ]
[------ - ] [ - ------] [ - ------]
[ 2 1 ] [ 1 2 ] [ s 2 ]
[s - 1 ]{t} [ s - 1]{t} [ s - 1]{t}
>>> MIMOParallel(tfm_a, tfm_b, tfm_c).doit()
TransferFunctionMatrix(((TransferFunction(s**2 + s*(2*s + 2) - 1, s*(s**2 - 1), s), TransferFunction(2*s**2 + 5*s*(s**2 - 1) - 1, s*(s**2 - 1), s)), (TransferFunction(s**2 + s*(s + 2) + 5*s*(s**2 - 1) - 1, s*(s**2 - 1), s), TransferFunction(5*s**2 + 2*s - 3, s**2 - 1, s))))
>>> pprint(_, use_unicode=False)
[ 2 2 / 2 \ ]
[ s + s*(2*s + 2) - 1 2*s + 5*s*\s - 1/ - 1]
[ -------------------- -----------------------]
[ / 2 \ / 2 \ ]
[ s*\s - 1/ s*\s - 1/ ]
[ ]
[ 2 / 2 \ 2 ]
[s + s*(s + 2) + 5*s*\s - 1/ - 1 5*s + 2*s - 3 ]
[--------------------------------- -------------- ]
[ / 2 \ 2 ]
[ s*\s - 1/ s - 1 ]{t}
注释
所有传递函数矩阵应使用拉普拉斯变换的相同复变量var
。
另请参阅
Parallel
, MIMOSeries
doit(**hints)
返回在并联配置的 MIMO 系统评估后获得的结果传递函数矩阵。
示例
>>> from sympy.abc import s, p, a, b
>>> from sympy.physics.control.lti import TransferFunction, MIMOParallel, TransferFunctionMatrix
>>> tf1 = TransferFunction(a*p**2 + b*s, s - p, s)
>>> tf2 = TransferFunction(s**3 - 2, s**4 + 5*s + 6, s)
>>> tfm_1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]])
>>> tfm_2 = TransferFunctionMatrix([[tf2, tf1], [tf1, tf2]])
>>> MIMOParallel(tfm_1, tfm_2).doit()
TransferFunctionMatrix(((TransferFunction((-p + s)*(s**3 - 2) + (a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)*(s**4 + 5*s + 6), s), TransferFunction((-p + s)*(s**3 - 2) + (a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)*(s**4 + 5*s + 6), s)), (TransferFunction((-p + s)*(s**3 - 2) + (a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)*(s**4 + 5*s + 6), s), TransferFunction((-p + s)*(s**3 - 2) + (a*p**2 + b*s)*(s**4 + 5*s + 6), (-p + s)*(s**4 + 5*s + 6), s))))
property num_inputs
返回并联系统的输入信号数量。
property num_outputs
返回并行系统的输出信号数量。
property shape
返回等效 MIMO 系统的形状。
property var
返回所有系统使用的复变量。
示例
>>> from sympy.abc import p
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, MIMOParallel
>>> G1 = TransferFunction(p**2 + 2*p + 4, p - 6, p)
>>> G2 = TransferFunction(p, 4 - p, p)
>>> G3 = TransferFunction(0, p**4 - 1, p)
>>> G4 = TransferFunction(p**2, p**2 - 1, p)
>>> tfm_a = TransferFunctionMatrix([[G1, G2], [G3, G4]])
>>> tfm_b = TransferFunctionMatrix([[G2, G1], [G4, G3]])
>>> MIMOParallel(tfm_a, tfm_b).var
p
class sympy.physics.control.lti.MIMOFeedback(sys1, sys2, sign=-1)
表示两个 MIMO 输入/输出系统之间闭环反馈连接的类。
参数:
sys1:MIMOSeries,TransferFunctionMatrix
将 MIMO 系统放置在前馈路径上。
sys2:MIMOSeries,TransferFunctionMatrix
放置在反馈路径上的系统(通常是反馈控制器)。
符号:整数,可选
反馈的符号。可以是
1
(正反馈)或-1
(负反馈)。默认值为(-1)。
Raises:
数值错误
当
sys1
和sys2
没有使用拉普拉斯变换的相同复变量时。前向路径模型应具有与反馈路径输出/输入相等数量的输入/输出。
当
sys1
和sys2
的乘积不是方阵时。当等效 MIMO 系统不可逆时。
类型错误
当
sys1
或sys2
不是MIMOSeries
或TransferFunctionMatrix
对象时。
示例
>>> from sympy import Matrix, pprint
>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunctionMatrix, MIMOFeedback
>>> plant_mat = Matrix([[1, 1/s], [0, 1]])
>>> controller_mat = Matrix([[10, 0], [0, 10]]) # Constant Gain
>>> plant = TransferFunctionMatrix.from_Matrix(plant_mat, s)
>>> controller = TransferFunctionMatrix.from_Matrix(controller_mat, s)
>>> feedback = MIMOFeedback(plant, controller) # Negative Feedback (default)
>>> pprint(feedback, use_unicode=False)
/ [1 1] [10 0 ] \-1 [1 1]
| [- -] [-- - ] | [- -]
| [1 s] [1 1 ] | [1 s]
|I + [ ] *[ ] | * [ ]
| [0 1] [0 10] | [0 1]
| [- -] [- --] | [- -]
\ [1 1]{t} [1 1 ]{t}/ [1 1]{t}
要获取等效系统矩阵,请使用doit
或rewrite
方法。
>>> pprint(feedback.doit(), use_unicode=False)
[1 1 ]
[-- -----]
[11 121*s]
[ ]
[0 1 ]
[- -- ]
[1 11 ]{t}
要否定MIMOFeedback
对象,请使用-
运算符。
>>> neg_feedback = -feedback
>>> pprint(neg_feedback.doit(), use_unicode=False)
[-1 -1 ]
[--- -----]
[11 121*s]
[ ]
[ 0 -1 ]
[ - --- ]
[ 1 11 ]{t}
另请参阅
Feedback
, MIMOSeries
, MIMOParallel
doit(cancel=True, expand=False, **hints)
返回通过反馈互连获得的结果传递函数矩阵。
示例
>>> from sympy import pprint
>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, MIMOFeedback
>>> tf1 = TransferFunction(s, 1 - s, s)
>>> tf2 = TransferFunction(1, s, s)
>>> tf3 = TransferFunction(5, 1, s)
>>> tf4 = TransferFunction(s - 1, s, s)
>>> tf5 = TransferFunction(0, 1, s)
>>> sys1 = TransferFunctionMatrix([[tf1, tf2], [tf3, tf4]])
>>> sys2 = TransferFunctionMatrix([[tf3, tf5], [tf5, tf5]])
>>> F_1 = MIMOFeedback(sys1, sys2, 1)
>>> pprint(F_1, use_unicode=False)
/ [ s 1 ] [5 0] \-1 [ s 1 ]
| [----- - ] [- -] | [----- - ]
| [1 - s s ] [1 1] | [1 - s s ]
|I - [ ] *[ ] | * [ ]
| [ 5 s - 1] [0 0] | [ 5 s - 1]
| [ - -----] [- -] | [ - -----]
\ [ 1 s ]{t} [1 1]{t}/ [ 1 s ]{t}
>>> pprint(F_1.doit(), use_unicode=False)
[ -s s - 1 ]
[------- ----------- ]
[6*s - 1 s*(6*s - 1) ]
[ ]
[5*s - 5 (s - 1)*(6*s + 24)]
[------- ------------------]
[6*s - 1 s*(6*s - 1) ]{t}
如果用户希望获得结果的TransferFunctionMatrix
对象而不取消公共因子,则应将cancel
参数传递为False
。
>>> pprint(F_1.doit(cancel=False), use_unicode=False)
[ s*(s - 1) s - 1 ]
[ ----------------- ----------- ]
[ (1 - s)*(6*s - 1) s*(6*s - 1) ]
[ ]
[s*(25*s - 25) + 5*(1 - s)*(6*s - 1) s*(s - 1)*(6*s - 1) + s*(25*s - 25)]
[----------------------------------- -----------------------------------]
[ (1 - s)*(6*s - 1) 2 ]
[ s *(6*s - 1) ]{t}
如果用户希望获得结果传递函数矩阵的展开形式,则应将expand
参数传递为True
。
>>> pprint(F_1.doit(expand=True), use_unicode=False)
[ -s s - 1 ]
[------- -------- ]
[6*s - 1 2 ]
[ 6*s - s ]
[ ]
[ 2 ]
[5*s - 5 6*s + 18*s - 24]
[------- ----------------]
[6*s - 1 2 ]
[ 6*s - s ]{t}
property sensitivity
返回反馈环路的灵敏度函数矩阵。
闭环系统的灵敏度是指开环增益变化与闭环增益变化的比率。
注意
此方法不会返回互补灵敏度函数。
示例
>>> from sympy import pprint
>>> from sympy.abc import p
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, MIMOFeedback
>>> tf1 = TransferFunction(p, 1 - p, p)
>>> tf2 = TransferFunction(1, p, p)
>>> tf3 = TransferFunction(1, 1, p)
>>> sys1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]])
>>> sys2 = TransferFunctionMatrix([[tf1, tf3], [tf3, tf2]])
>>> F_1 = MIMOFeedback(sys1, sys2, 1) # Positive feedback
>>> F_2 = MIMOFeedback(sys1, sys2) # Negative feedback
>>> pprint(F_1.sensitivity, use_unicode=False)
[ 4 3 2 5 4 2 ]
[- p + 3*p - 4*p + 3*p - 1 p - 2*p + 3*p - 3*p + 1 ]
[---------------------------- -----------------------------]
[ 4 3 2 5 4 3 2 ]
[ p + 3*p - 8*p + 8*p - 3 p + 3*p - 8*p + 8*p - 3*p]
[ ]
[ 4 3 2 3 2 ]
[ p - p - p + p 3*p - 6*p + 4*p - 1 ]
[ -------------------------- -------------------------- ]
[ 4 3 2 4 3 2 ]
[ p + 3*p - 8*p + 8*p - 3 p + 3*p - 8*p + 8*p - 3 ]
>>> pprint(F_2.sensitivity, use_unicode=False)
[ 4 3 2 5 4 2 ]
[p - 3*p + 2*p + p - 1 p - 2*p + 3*p - 3*p + 1]
[------------------------ --------------------------]
[ 4 3 5 4 2 ]
[ p - 3*p + 2*p - 1 p - 3*p + 2*p - p ]
[ ]
[ 4 3 2 4 3 ]
[ p - p - p + p 2*p - 3*p + 2*p - 1 ]
[ ------------------- --------------------- ]
[ 4 3 4 3 ]
[ p - 3*p + 2*p - 1 p - 3*p + 2*p - 1 ]
property sign
返回两个模型的反馈互连类型。正反馈返回1
,负反馈返回-1
。
property sys1
返回放置在 MIMO 反馈互连的前馈路径上的系统。
示例
>>> from sympy import pprint
>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, MIMOFeedback
>>> tf1 = TransferFunction(s**2 + s + 1, s**2 - s + 1, s)
>>> tf2 = TransferFunction(1, s, s)
>>> tf3 = TransferFunction(1, 1, s)
>>> sys1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]])
>>> sys2 = TransferFunctionMatrix([[tf3, tf3], [tf3, tf2]])
>>> F_1 = MIMOFeedback(sys1, sys2, 1)
>>> F_1.sys1
TransferFunctionMatrix(((TransferFunction(s**2 + s + 1, s**2 - s + 1, s), TransferFunction(1, s, s)), (TransferFunction(1, s, s), TransferFunction(s**2 + s + 1, s**2 - s + 1, s))))
>>> pprint(_, use_unicode=False)
[ 2 ]
[s + s + 1 1 ]
[---------- - ]
[ 2 s ]
[s - s + 1 ]
[ ]
[ 2 ]
[ 1 s + s + 1]
[ - ----------]
[ s 2 ]
[ s - s + 1]{t}
property sys2
返回 MIMO 反馈互连的反馈控制器。
示例
>>> from sympy import pprint
>>> from sympy.abc import s
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, MIMOFeedback
>>> tf1 = TransferFunction(s**2, s**3 - s + 1, s)
>>> tf2 = TransferFunction(1, s, s)
>>> tf3 = TransferFunction(1, 1, s)
>>> sys1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]])
>>> sys2 = TransferFunctionMatrix([[tf1, tf3], [tf3, tf2]])
>>> F_1 = MIMOFeedback(sys1, sys2)
>>> F_1.sys2
TransferFunctionMatrix(((TransferFunction(s**2, s**3 - s + 1, s), TransferFunction(1, 1, s)), (TransferFunction(1, 1, s), TransferFunction(1, s, s))))
>>> pprint(_, use_unicode=False)
[ 2 ]
[ s 1]
[---------- -]
[ 3 1]
[s - s + 1 ]
[ ]
[ 1 1]
[ - -]
[ 1 s]{t}
property var
返回所有 MIMO 反馈环路中涉及的传递函数使用的拉普拉斯变换的复变量。
示例
>>> from sympy.abc import p
>>> from sympy.physics.control.lti import TransferFunction, TransferFunctionMatrix, MIMOFeedback
>>> tf1 = TransferFunction(p, 1 - p, p)
>>> tf2 = TransferFunction(1, p, p)
>>> tf3 = TransferFunction(1, 1, p)
>>> sys1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]])
>>> sys2 = TransferFunctionMatrix([[tf1, tf3], [tf3, tf2]])
>>> F_1 = MIMOFeedback(sys1, sys2, 1) # Positive feedback
>>> F_1.var
p
sympy.physics.control.lti.gbt(tf, sample_per, alpha)
返回 H(z) 的分子和分母的降序系数。
解释
其中 H(z) 是相应的离散化传递函数,使用广义双线性变换方法进行离散化。H(z) 是通过将 (s(z) = \frac{z-1}{T(\alpha z + (1-\alpha))}) 替换到 H(s) 中获得的,其中 T 是采样周期。系数是降序排列的,即 (H(z) = \frac{az+b}{cz+d}) 返回为 [a, b], [c, d]。
示例
>>> from sympy.physics.control.lti import TransferFunction, gbt
>>> from sympy.abc import s, L, R, T
>>> tf = TransferFunction(1, s*L + R, s)
>>> numZ, denZ = gbt(tf, T, 0.5)
>>> numZ
[T/(2*(L + R*T/2)), T/(2*(L + R*T/2))]
>>> denZ
[1, (-L + R*T/2)/(L + R*T/2)]
>>> numZ, denZ = gbt(tf, T, 0)
>>> numZ
[T/L]
>>> denZ
[1, (-L + R*T)/L]
>>> numZ, denZ = gbt(tf, T, 1)
>>> numZ
[T/(L + R*T), 0]
>>> denZ
[1, -L/(L + R*T)]
>>> numZ, denZ = gbt(tf, T, 0.3)
>>> numZ
[3*T/(10*(L + 3*R*T/10)), 7*T/(10*(L + 3*R*T/10))]
>>> denZ
[1, (-L + 7*R*T/10)/(L + 3*R*T/10)]
参考文献
[R736]
www.polyu.edu.hk/ama/profile/gfzhang/Research/ZCC09_IJC.pdf
sympy.physics.control.lti.bilinear(tf, sample_per)
返回 H(z) 的分子和分母的降序系数。
解释
其中 H(z) 是相应的离散化传递函数,使用双线性变换方法进行离散化。H(z) 是通过将 (s(z) = \frac{2}{T}\frac{z-1}{z+1}) 替换到 H(s) 中获得的,其中 T 是采样周期。系数是降序排列的,即 (H(z) = \frac{az+b}{cz+d}) 返回为 [a, b], [c, d]。
示例
>>> from sympy.physics.control.lti import TransferFunction, bilinear
>>> from sympy.abc import s, L, R, T
>>> tf = TransferFunction(1, s*L + R, s)
>>> numZ, denZ = bilinear(tf, T)
>>> numZ
[T/(2*(L + R*T/2)), T/(2*(L + R*T/2))]
>>> denZ
[1, (-L + R*T/2)/(L + R*T/2)]
sympy.physics.control.lti.forward_diff(tf, sample_per)
返回 H(z) 的分子和分母的降序系数。
解释
其中 H(z) 是相应的离散化传递函数,使用前向差分变换方法进行离散化。H(z) 是通过将 (s(z) = \frac{z-1}{T}) 替换到 H(s) 中获得的,其中 T 是采样周期。系数是降序排列的,即 (H(z) = \frac{az+b}{cz+d}) 返回为 [a, b], [c, d]。
示例
>>> from sympy.physics.control.lti import TransferFunction, forward_diff
>>> from sympy.abc import s, L, R, T
>>> tf = TransferFunction(1, s*L + R, s)
>>> numZ, denZ = forward_diff(tf, T)
>>> numZ
[T/L]
>>> denZ
[1, (-L + R*T)/L]
sympy.physics.control.lti.backward_diff(tf, sample_per)
返回 H(z) 的分子和分母的降序系数。
解释
其中,H(z) 是相应的离散化传递函数,使用后向差分变换方法离散化。H(z) 是从连续传递函数 H(s) 通过将 (s(z) = \frac{z-1}{Tz}) 代入 H(s) 而获得的,其中 T 是采样周期。系数在变小,即 (H(z) = \frac{az+b}{cz+d}) 被返回为 [a, b], [c, d]。
举例
>>> from sympy.physics.control.lti import TransferFunction, backward_diff
>>> from sympy.abc import s, L, R, T
>>> tf = TransferFunction(1, s*L + R, s)
>>> numZ, denZ = backward_diff(tf, T)
>>> numZ
[T/(L + R*T), 0]
>>> denZ
[1, -L/(L + R*T)]