def calc():
X0, X1 = 1, 1 / s
W = parse_expr(e1.get())
Y0 = X0 * W
Y1 = X1 * W
y0 = inverse_laplace_transform(Y0, s, t)
y1 = inverse_laplace_transform(Y1, s, t)
l2['text'] = y0
l3['text'] = y1
p = sp.plot(y0, (t, T_min, T_max), line_color='r', show=False)
p.extend(sp.plot(y1, (t, T_min, T_max), line_color='g', show=False))
p.show()
e. Polynomial roots
"""
import sympy as sym
from sympy.abc import s,t,x,y,z
from sympy.integrals import laplace_transform
from sympy.integrals import inverse_laplace_transform
# Laplace transform (t->s)
U = laplace_transform(5*t, t, s)
print('U')
print(U[0])
# Result: 5/s**2
# Inverse Laplace transform (s->t)
X = inverse_laplace_transform(U[0],s,t)
print('X')
print(X)
# Result: 5*t*Heaviside(t)
# Function
F = 5*(s+1)/(s+3)**2
print('F')
print(F)
# Result: (5*s + 5)/(s + 3)**2
# Partial fraction decomposition
G = sym.apart(F)
print('G')
print(G)
# Result: 5/(s + 3) - 10/(s + 3)**2
y2 = diff(y1, t)
eq = a * y2 + b * y1 + c * y - f
print('equation:', eq)
print(' ')
eqn = laplace_transform(eq, t, s)
print('after laplace equation:', eqn)
print(' ')
eqn = sympify(eqn)
#eqn=eqn.subs(t,0)
#eqn=eqn.subs(y(0),d)
print('after replacing:', eqn)
print(' ')
eqn = eqn.subs(sympify('LaplaceTransform(y(t), t, s)'), Y)
print('after replacing:', eqn)
print(' ')
eqn = eqn.subs(sympify(y1), e)
print('after replacing:', eqn)
eqn = eqn.subs(sympify(y), d)
print(' ')
print('after replacing:', eqn)
print(' ')
collected_expr = collect(eqn, Y)
Y1 = simplify(solve(eqn, Y))
ans = inverse_laplace_transform(Y1, s, t)
ANURADHA.J
def y(t): # function to find output y(t) i.e. in time domain
y = inverse_laplace_transform(Y_S[0], s, t)
return y
from sympy.integrals import inverse_laplace_transform
import matplotlib.pyplot as plt
# Step input
U = 1 / s
# Transfer function
K, J, b, R, L = sym.symbols('K J b R L')
G = K / (s * ((J * s + b) * (L * s + R) + K**2))
G = G.subs([(K, 0.0274), (J, 3.2284E-6), (b, 3.5077E-6), (R, 4), (L, 2.75E-6)])
# Calculate response
Y = G * U
# Inverse Laplace Transform
u = inverse_laplace_transform(U, s, t)
y = inverse_laplace_transform(Y, s, t)
# generate data for plot
tm = np.linspace(0, 8, 100)
us = np.zeros(len(tm))
ys = np.zeros(len(tm))
# substitute numeric values for u and y
for i in range(len(tm)):
us[i] += u.subs(t, tm[i])
ys[i] += y.subs(t, tm[i])
# Plot the results
plt.figure()
plt.plot(tm, us, label='u(t)')
from sympy.abc import s,t
from sympy.integrals import inverse_laplace_transform
import sympy as sy
import math
#if using termux
import subprocess
import shlex
#end if
G, k = sy.symbols('G ,k', real=True)
Ts = (G*((k)**2)*(s**2) + G*(3*k)*s + G)/(((k**2)*(s**2))+ ((3-G)*k*s) + 1) #transfer function
Ds = 1
Ys = Ts*(Ds)
y = inverse_laplace_transform(Ys,s,t) #inverse laplace transform
R = 10000
C = (16)*(10**(-9))
y_t = y.subs({G: 3, k: R*C})
#print("step response is :",y_t)
i = np.linspace(0,0.2,10000)
y =[]
for j in i:
y.append(3*(12*np.sin(6250.0*j) + 4)*(np.heaviside(j,0.5)/4))
#print(y)
plt.xlim(0,0.02)
plt.plot(i,y)
plt.plot(0.0133468,11.9143,'o')
# Transfer functions
Kc = 2.0
tauI = 180.0
Gc = Kc * (tauI*s+1)/(tauI*s)
delay = 1/(15*s+1) # Taylor series approx
Gp = delay * 0.9/(180*s+1)
# Closed loop response
Gc = Gc*Gp/(1+Gc*Gp)
# Calculate response
T1 = Gc * TSP
# Inverse Laplace Transform
tsp = inverse_laplace_transform(TSP,s,t)
t1 = inverse_laplace_transform(T1,s,t)
print('Temperature Solution')
print(t1)
# generate data for plot
tm = np.linspace(0,600,100)
TSPplot = np.zeros(len(tm))
T1plot = np.zeros(len(tm))
# substitute numeric values
for i in range(len(tm)):
TSPplot[i] = tsp.subs(t,tm[i]) + 23.0
T1plot[i] = t1.subs(t,tm[i]) + 23.0
# plot results
def StepResponse(system,
time,
delay=1,
variable_laplace='s',
variable_time='t',
substitute=True,
plot=True,
normalize_plot=True,
evaluation="subs",
Heaviside_Value=0,
Name_StepFct=r'Step Function, normalized',
Name_System=r'Step Response, normalized',
Xlabel_time=['', 's'],
Ylabel_Amplitude=["", 'V']):
#############################################################################
"""
Generate Step Response from System
paramters description
===================== =============================================:
system system symbolic transfer function
time time array for evaluation
delay (optional) delay of heaviside function
variable_laplace (optional) variable in laplace domain
variable_time (optional) variable in time domain
substitute (optional) substitute floats during inverse laplace
plot (optional) plot step response output
normalize_plot (optional) normalize end value to maximum
evaluation (optional) define the used evalutaion function (lambdify|subs)
Heaviside_Value (optional) Value for Heaviside Function at H(0)
Name_StepFct (optional) Name of StepFunction Label
Name_System (optional) Name of System response label
Xlabel_time (optional) Label and Unit of Time X-Axis
Ylabel_Amplitude (optional) Label and Unit of Amplitude Y-Axis
return type
symbolic time domain functions
"""
#############################################################################
# ===================================
# Generate symbolic variables (time only positive)
variable_laplace = sympy.Symbol(variable_laplace)
variable_time = sympy.Symbol(variable_time, positive=True)
# Generate Heaviside function with delay
heaviside_laplace = 1 / variable_laplace * sympy.exp(
-delay * variable_laplace)
heaviside_time = inverse_laplace_transform(heaviside_laplace,
variable_laplace,
variable_time).doit()
# ===================================
# Step Response in Laplace Domain
StepReponse_laplace = system * heaviside_laplace
# Substitute all float numbers
if substitute:
[StepReponse_laplace,
Mapping] = Substitute_Datatype(StepReponse_laplace, datatype="Float")
# Convert StepResponse into Time Domain
StepReponse_time = inverse_laplace_transform(StepReponse_laplace,
variable_laplace,
variable_time).doit()
# Re-Substitute all float numbers
if substitute:
StepReponse_time = ReSubstitute_Datatype(StepReponse_time, Mapping)
# ===================================
if plot:
# evaluation of that data
heaviside = Extract_Sympy_1Var(heaviside_time,
time,
variable=variable_time,
evaluation=evaluation,
Heaviside_Value=Heaviside_Value)
stepresponse = Extract_Sympy_1Var(StepReponse_time,
time,
variable=variable_time,
evaluation=evaluation,
Heaviside_Value=Heaviside_Value)
# As Array
heaviside = np.asarray(heaviside)
stepresponse = np.asarray(stepresponse)
# normalize
if normalize_plot:
heaviside = heaviside / heaviside[-1]
stepresponse = stepresponse / stepresponse[-1]
# ===================================
# Plot Settings
plot_amp = [[
time, heaviside, Name_StepFct,
'linewidth=0.5, marker=x, markersize=10'
], [time, stepresponse, Name_System, 'linewidth=1']]
# ===================================
# Generate Plot
plt.figure(figsize=(10, 10))
ax1 = plt.subplot(111)
basic.Linear_Plot(ax1, plot_amp, Xlabel_time, Ylabel_Amplitude)
plt.show()
# ===================================
# return time domain systems
return [heaviside_time, StepReponse_time]
U1 = 2 / s * sym.exp(-s)
# Ramp (down) starts at 3 sec
U2 = -1 / s**2 * sym.exp(-3 * s)
# Ramp completes at 5 sec
U3 = 1 / s**2 * sym.exp(-5 * s)
# Transfer function
G = 5 * (s + 1) / (s + 3)**2
# Calculate responses
Y1 = G * U1
Y2 = G * U2
Y3 = G * U3
# Inverse Laplace Transform
u1 = inverse_laplace_transform(U1, s, t)
u2 = inverse_laplace_transform(U2, s, t)
u3 = inverse_laplace_transform(U3, s, t)
y1 = inverse_laplace_transform(Y1, s, t)
y2 = inverse_laplace_transform(Y2, s, t)
y3 = inverse_laplace_transform(Y3, s, t)
print('y1')
print(y1)
# generate data for plot
tm = np.linspace(0, 8, 100)
us = np.zeros(len(tm))
ys = np.zeros(len(tm))
# substitute numeric values for u and y
for u in [u1, u2, u3]:
import numpy as np
import sympy as sp
from sympy.integrals import inverse_laplace_transform
s = sp.symbols('s')
t = sp.symbols('t', positive=True)
tf = (-266) / (93 * (s + 8))
from sympy.integrals.transforms import inverse_laplace_transform
from sympy import exp, Symbol
from sympy.abc import s, t
from sympy import pprint
a = Symbol('a', positive=True)
x1 = inverse_laplace_transform(tf, s, t)
#
s = sp.symbols('s')
t = sp.symbols('t', positive=True)
tf = (1199 * s + 534) / (417 * (s**2 + 8 * s + 3))
from sympy.integrals.transforms import inverse_laplace_transform
from sympy import exp, Symbol
from sympy.abc import s, t
from sympy import pprint
a = Symbol('a', positive=True)
x2 = inverse_laplace_transform(tf, s, t)
#############
s = sp.symbols('s')
t = sp.symbols('t', positive=True)
tf = (-65 * s - 1014) / (4309 * (s**2 + 5 * s + 7))
def answersInv():
global AnswInv1, AnswInv2, AnswInv3, AnswInv4, AnswInv5
a, s, t, x, y, z = symbols('a s t x y z')
A2.delete(0, END)
if E1.get() == '' or E1.get() == 0:
AnswInv1 = ''
else:
if E1.index(0) == '-':
AnswInv1 = sympify(inverse_laplace_transform(E1.get(), s, t, simplify=TRUE))
sig = '-'
AnswInv1s = sig + AnswInv1
A2.insert(0, AnswInv1s)
else:
AnswInv1 = sympify(inverse_laplace_transform(E1.get(), s, t, simplify=TRUE))
A2.insert(0, AnswInv1)
if E2.get() == '' or E2.get() == 0:
AnswInv2 = ''
else:
if E2.index(0) == '-':
AnswInv2 = sympify(inverse_laplace_transform(E2.get(), s, t, simplify=TRUE))
sig = ' - '
AnswInv2s = sig + AnswInv2
A2.insert(END, AnswInv2s)
else:
AnswInv2 = sympify(inverse_laplace_transform(E2.get(), s, t, simplify=TRUE))
A2.insert(END, ' + ')
A2.insert(END, AnswInv2)
if E3.get() == '' or E3.get() == 0:
AnswInv3 = ''
else:
if E3.index(0) == '-':
AnswInv3 = sympify(inverse_laplace_transform(E3.get(), s, t, simplify=TRUE))
sig = ' - '
AnswInv3s = sig + AnswInv3
A2.insert(END, AnswInv3s)
else:
AnswInv3 = sympify(inverse_laplace_transform(E3.get(), s, t, simplify=TRUE))
A2.insert(END, ' + ')
A2.insert(END, AnswInv3)
if E4.get() == '' or E4.get() == 0:
AnswInv4 = ''
else:
if E4.index(0) == '-':
AnswInv4 = sympify(inverse_laplace_transform(E4.get(), s, t, simplify=TRUE))
sig = ' - '
AnswInv4s = sig + AnswInv4
A2.insert(END, AnswInv4s)
else:
AnswInv4 = sympify(inverse_laplace_transform(E4.get(), s, t, simplify=TRUE))
A2.insert(END, ' + ')
A2.insert(END, AnswInv4)
if E5.get() == '' or E5.get() == 0:
AnswInv5 = ''
else:
if E5.index(0) == '-':
AnswInv5 = sympify(inverse_laplace_transform(E5.get(), s, t, simplify=TRUE))
sig = ' - '
AnswInv5s = sig + AnswInv5
A2.insert(END, AnswInv5s)
else:
AnswInv5 = sympify(inverse_laplace_transform(E5.get(), s, t, simplify=TRUE))
A2.insert(END, ' + ')
A2.insert(END, AnswInv5)
A2.config(font=("Helvetica", 15))
A2.config(state=DISABLED)
def inverse_laplace_carson(f, t, s):
f = sy.simplify(f / s)
f = sy.apart(f)
f_c = inverse_laplace_transform(f, t, s)
return f_c
# Transfer functions
Kc = 2.0
tauI = 180.0
Gc = Kc * (tauI * s + 1) / (tauI * s)
delay = 1 / (15 * s + 1) # Taylor series approx
Gd = delay * 0.3 / (180 * s + 1)
Gp = delay * 0.9 / (180 * s + 1)
# Closed loop response
Gc = Gd / (1 + Gc * Gp)
# Calculate response
T1 = Gc * T2
# Inverse Laplace Transform
t2 = inverse_laplace_transform(T2, s, t)
t1 = inverse_laplace_transform(T1, s, t)
print('Temperature Solution')
print(t1)
# generate data for plot
tm = np.linspace(0, 600, 100)
T2plot = np.zeros(len(tm))
T1plot = np.zeros(len(tm))
# substitute numeric values
for i in range(len(tm)):
T2plot[i] = t2.subs(t, tm[i])
T1plot[i] = t1.subs(t, tm[i])
# plot results
