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