[PYTHON] Die Konvertierung von Sympy Laplace ist nicht praktikabel

Laplace-Konvertierung

Die Laplace-Umwandlung erfolgt durch Bringen des Signals in der Zeitebene (t-Ebene) in die s-Ebene. Es ist ein sehr effektives Mittel zur algebraischen Lösung von Differentialgleichungen. Beispielsweise wird bei der Signalverarbeitung ein zeitvariables periodisches Signal Laplace-konvertiert, verschiedene Operationen (wie Feinintegration usw.) werden ausgeführt, und dann wird eine inverse Laplace-Konvertierung durchgeführt, um zur Zeitachse zurückzukehren.

Sympy Ich wollte Laplace-Konvertierung mit Python durchführen und fand heraus, dass dies mit Sympy möglich ist. Deshalb habe ich es versucht, aber ich konnte es nicht zu Tode verwenden, also werde ich es hier aufnehmen.

Grundkenntnisse der Laplace-Konvertierung

Definition

\mathcal{L}[f(t)] = \int_0^{\infty}f(t)e^{-st}dt

Einfaches Beispiel

test.py

import sympy as sp

s, t = sp.symbols("s, t")
w = sp.symbols("w", real=True)
sp.laplace_transform(sp.cos(w*t), t, s)

>> (s/(s**2 + w**2), 0, Eq(Abs(periodic_argument(polar_lift(w)**2, oo)), 0))

Das ist ein gutes Ergebnis. das ist richtig. Die Laplace-Transformation der cos-Welle wird wie definiert berechnet, und ich denke, einige Leute erinnern sich daran.

Dreieckwelle

Gehen Sie einen Schritt vor dem, was Sie tatsächlich tun möchten, mit einer einfachen Dreieckswelle um.

TriangularPulse.py

T = 0.2 #Zeitraum
ft = 2/T*t*sp.Heaviside(t) + 2/T*(t-T)*sp.Heaviside(t-T) - 4/T*(t-T/2)*sp.Heaviside(t-T/2)

p = plot(ft, (t, -0.2, 1), xlabel="t", ylabel="y")

"Heaviside" ist eine Schwerheitsfunktion, die wie eine Schrittfunktion ist. Das Signal ft wurde auf der Zeitachse aufgetragen und eine Dreieckswelle wurde erfolgreich erzeugt. Das Gute an der Laplace-Konvertierung ist, dass Sie sie regelmäßig auf der s-Ebene kontinuierlich ausführen möchten

\frac{1}{1-e^{-Ts}}　...(1)

Es ist ein guter Ort, um sich zu bewerben. Mit anderen Worten

1. 1. Erzeugen Sie ein Einheitssignal (in diesem Fall eine Dreieckswelle).
2. Laplace-Konvertierung
3. 3. Multipliziere Gleichung (1)
4. Führen Sie eine inverse Laplace-Konvertierung durch

Dieser Schritt hätte sehr einfach sein sollen. Ich werde tatsächlich gehen.

LaplaceTransform.py

ft = 2/T*t*sp.Heaviside(t) + 2/T*(t-T)*sp.Heaviside(t-T) - 4/T*(t-T/2)*sp.Heaviside(t-T/2)

Fs = laplace_transform(ft, t, s)
Fs_period = (1-sp.exp(-T*s))**(-1)*Fs[0]
Fs_period_integral = Fs_period / s
Fs_integral = Fs[0] / s
print(Fs)
print(Fs[0])
print(Fs_period)
print(Fs_period_integral)
print(Fs_integral)

(10.0/s**2 + 10.0*exp(-0.2*s)/s**2 - 20.0*exp(-0.1*s)/s**2, 0, True)
10.0/s**2 + 10.0*exp(-0.2*s)/s**2 - 20.0*exp(-0.1*s)/s**2
(10.0/s**2 + 10.0*exp(-0.2*s)/s**2 - 20.0*exp(-0.1*s)/s**2)/(1 - exp(-0.2*s))
(10.0/s**2 + 10.0*exp(-0.2*s)/s**2 - 20.0*exp(-0.1*s)/s**2)/(s*(1 - exp(-0.2*s)))
(10.0/s**2 + 10.0*exp(-0.2*s)/s**2 - 20.0*exp(-0.1*s)/s**2)/s

Jetzt habe ich hier vier Funktionen in der Reihenfolge von oben erstellt. Die erste ist die Laplace-Umwandlung des Einheitensignals. (Da es als Element Fs [0] zurückgegeben wird, wird die Formel von nun an extrahiert und verwendet.) Die zweite ist diejenige, die dann mit Gleichung (1) multipliziert wird. Der dritte ist ein Versuch, den zweiten zu integrieren (auf der s-Ebene kann die Integration durch Multiplizieren mit 1 / s erfolgen). Der vierte ist ein Versuch, den ersten zu integrieren

Von besonderer Bedeutung sind die zweite und dritte.

Übrigens, wenn ich die umgekehrte Konvertierung versuche, ...

InverseLaplaceTransform.py

ft = sp.inverse_laplace_transform(Fs[0],s,t,noconds=True)
ft_period = sp.inverse_laplace_transform(Fs_period,s,t)
ft_period_integral = sp.inverse_laplace_transform(Fs_period_integral,s,t)
ft_integral = sp.inverse_laplace_transform(Fs_integral,s,t)
print(ft)
print("******************")
print(ft_period)
print("******************")
print(ft_period_integral)
print("******************")
print(ft_integral)

10.0*t*Heaviside(t) + (10.0*t - 2.0)*Heaviside(t - 0.2) - (20.0*t - 2.0)*Heaviside(t - 0.0999999999999999)
******************
10.0*InverseLaplaceTransform(1/(s**2 - s**2*exp(-0.2*s)), s, t, _None) - 20.0*InverseLaplaceTransform(1/(s**2*exp(0.1*s) - s**2*exp(-0.1*s)), s, t, _None) + 10.0*InverseLaplaceTransform(1/(s**2*exp(0.2*s) - s**2*exp(-5.55111512312578e-17*s)), s, t, _None)
******************
10.0*InverseLaplaceTransform(1/(s**3 - s**3*exp(-0.2*s)), s, t, _None) - 20.0*InverseLaplaceTransform(1/(s**3*exp(0.1*s) - s**3*exp(-0.1*s)), s, t, _None) + 10.0*InverseLaplaceTransform(1/(s**3*exp(0.2*s) - s**3*exp(-5.55111512312578e-17*s)), s, t, _None)
******************
5.0*t**2*Heaviside(t) + (5.0*t**2 - 2.0*t + 0.2)*Heaviside(t - 0.2) - (10.0*t**2 - 2.0*t + 0.0999999999999998)*Heaviside(t - 0.0999999999999999)

Es ist so geworden. Wenn in der Reihenfolge geplottet, wurden der erste und der vierte zu diesem Zeitpunkt erstellt.

Plot1.py

p1 = plot(ft, (t, -0.2, 1), xlabel="t", ylabel="y")
p4 = plot(ft_integral, (t, -0.2, 1), xlabel="t", ylabel="y")

ist geworden. Das erste ist natürlich, zum ursprünglichen Signal zurückzukehren. Der zweite scheint gut zu sein, weil das Signal, das dies integriert hat, herauskam.

Fehlerteil

Das zweite Signal ist, wenn die inverse Umwandlung durchgeführt wird.

10.0*InverseLaplaceTransform(1/(s**2 - s**2*exp(-0.2*s)), s, t, _None) - 20.0*InverseLaplaceTransform(1/(s**2*exp(0.1*s) - s**2*exp(-0.1*s)), s, t, _None) + 10.0*InverseLaplaceTransform(1/(s**2*exp(0.2*s) - s**2*exp(-5.55111512312578e-17*s)), s, t, _None)

Und der Teil "InverseLaplaceTransform (1 / (s ** 2- s ** 2 * exp (-0,2 * s)), s, t, _None)" stört die Ausgabe des Ergebnisses. Ich würde es gerne irgendwie lösen, aber wenn jemand Erfahrung hat und versteht, lass es mich wissen.