num_lp_butter, den_lp_butter = sig.lp2lp(num_lp, den_lp, eps**(-1 / nn))
# obtengo la transferencia normalizada del pasabanda
num_bp_n, den_bp_n = sig.lp2bp(num_lp_butter, den_lp_butter, wo=1, bw=1 / .253)
# obtengo la transferencia desnormalizada del pasabanda
num_bp, den_bp = sig.lp2bp(num_lp_butter, den_lp_butter, wo=8.367, bw=33)
# Averiguo los polos y ceros
z_bp_n, p_bp_n, k_bp_n = sig.tf2zpk(num_bp_n, den_bp_n)
str_aux = 'Pasabanda normalizado'
print(str_aux)
print('-' * len(str_aux))
this_lti = sig.TransferFunction(num_bp_n, den_bp_n)
pretty_print_lti(this_lti)
print('\n\n')
#%matplotlib qt5
# visualizo el modelo matemático normalizado
#analyze_sys([sig.TransferFunction(num_bp_n,den_bp_n)], ['mp'])
# o el modelo matemático desnormalizado
#analyze_sys([sig.TransferFunction(num_bp,den_bp)], ['mp'])
# visualización de cada sección
##
# Factorización en BP - BP
###########################
def movingAverageOrde2():
#cara berfikir dimatlab berbeda dengan dipython
#MAx/yk matlab = MAx/yk.T python
MAxk = np.transpose(np.matrix(Vin2)) #transpose matrix 1D
MAyk = np.transpose(np.matrix(Vout2))
MAxk1 = Vin2.copy()
MAxk1 = np.insert(MAxk1, 0, 0)
MAxk1 = np.delete(MAxk1, len(MAxk1) - 1)
MAxk1 = np.transpose(np.matrix(MAxk1))
MAxk2 = Vin2.copy()
MAxk2 = np.insert(MAxk2, 0, 0)
MAxk2 = np.insert(MAxk2, 1, 0)
MAxk2 = np.delete(MAxk2, len(MAxk2) - 1)
MAxk2 = np.delete(MAxk2, len(MAxk2) - 1)
MAxk2 = np.transpose(np.matrix(MAxk2))
MApi = (np.vstack((MAxk.T, MAxk1.T, MAxk2.T))).T #tidka bisa langsung
MA = np.linalg.inv(MApi.T.dot(MApi)).dot(MApi.T).dot(MAyk)
a = MA[0].dot(MAxk[0]) + MA[1].dot(0) + MA[2].dot(0)
MAy = ([a])
a = MA[0].dot(MAxk[1]) + MA[1].dot(MAy[0]) + MA[2].dot(0)
MAy = np.insert(MAy, 1, a)
for i in range(2, len(MAxk)):
a = MA[0].dot(MAxk[i]) + MA[1].dot(MAxk[i - 1]) + MA[2].dot(
MAxk[i - 2])
MAy = np.insert(MAy, i, a)
dataMA = np.vstack((MAxk.T, MAy)).T
num = [1]
den = MA.A1 #merubah menjadi rank 1
den = list(den) #list ==> menambah koma diantara elements
sys = signal.TransferFunction(
num, den, dt=1
) # selalu menghasilkan tf dg s pangkat tertinggi berubah menjadi (s^n),
# sehingga hasil tersebut merupakan angka hasil bagi den[0]
# misal 1/4s^2+2s+1 menjadi 0.25/s^2+0.5s+0.25
# aku sudah mensimulasikannya hasilnya sama, secara matematis dan logika pun juga sama
# jika menemukan solusinya silahkan PR ke https://github.com/ahmaddidiks/pis_py
print(" MAxk1 = ")
print(MAxk1)
print("\n MAxk2 = ")
print(MAxk2)
print("\n MApi = ")
print(MApi)
print("\n MA = ")
print(MA)
print("\n MAy = ")
print(MAy)
print("\n dataMA = ")
print(dataMA)
print("\n Transfer Fungsi = ")
print(sys)
plt.plot(MAxk, MAy)
plt.plot(Vin2, Vout2)
plt.title('Hubungan Vin-Vout Metode MA Orde 2', fontdict=font)
plt.xlabel('Vin', fontdict=font)
plt.ylabel('Vout', fontdict=font)
plt.legend(['MA', 'Data'])
plt.show()
def autoRegresiveOrde2():
#cara berfikir dimatlab berbeda dengan dipython
#ARx/yk matlab = ARx/yk.T python
ARxk = np.transpose(np.matrix(Vin2)) #transpose matrix 1D
ARyk = np.transpose(np.matrix(Vout2))
ARyk1 = Vout2.copy()
ARyk1 = np.insert(ARyk1, 0, 0)
ARyk1 = np.delete(ARyk1, len(ARyk1) - 1)
ARyk1 = np.transpose(np.matrix(ARyk1))
ARyk2 = Vout2.copy()
ARyk2 = np.insert(ARyk2, 0, 0)
ARyk2 = np.insert(ARyk2, 1, 0)
ARyk2 = np.delete(ARyk2, len(ARyk2) - 1)
ARyk2 = np.delete(ARyk2, len(ARyk2) - 1)
ARyk2 = np.transpose(np.matrix(ARyk2))
ARpi = (np.vstack((ARxk.T, ARyk1.T, ARyk2.T))).T #tidak bisa langsung
AR = np.linalg.inv(ARpi.T.dot(ARpi)).dot(ARpi.T).dot(ARyk)
a = AR[0].dot(ARxk[0]) + AR[1].dot(0) + AR[2].dot(0)
ARy = ([a]) #ARy[0] di python = ARy(1)
a = AR[0].dot(ARxk[1]) + AR[1].dot(ARy[0]) + AR[2].dot(0)
ARy = np.insert(ARy, 1, a)
for i in range(2, len(ARxk)):
a = AR[0].dot(ARxk[i]) + AR[1].dot(ARy[i - 1]) + AR[2].dot(ARy[i - 2])
ARy = np.insert(ARy, i, a)
dataAR = np.vstack((ARxk.T, ARy)).T
num = [1]
den = AR.A1 #merubah menjadi rank 1
den = list(den) #list ==> menambah koma diantara elements
sys = signal.TransferFunction(
num, den, dt=1
) # selalu menghasilkan tf dg s pangkat tertinggi berubah menjadi (s^n),
# sehingga hasil tersebut merupakan angka hasil bagi den[0]
# misal 0.25/4s^2+2s+1 menjadi 0.4/s^2+0.5s+0.25
# aku sudah mensimulasikannya hasilnya sama, secara matematis dan logika pun juga sama
# jika menemukan solusinya silahkan PR ke https://github.com/ahmaddidiks/pis_py
print(" ARyk1 = ")
print(ARyk1)
print("\n ARyk2 = ")
print(ARyk2)
print("\n ARpi = ")
print(ARpi)
print("\n AR = ")
print(AR)
print("\n ARy = ")
print(ARy)
print("\n dataAR = ")
print(dataAR)
print("\n Transfer Fungsi = ")
print(sys)
plt.plot(ARxk, ARy)
plt.plot(Vin2, Vout2)
plt.title('Hubungan Vin-Vout Metode AR Orde 2', fontdict=font)
plt.xlabel('Vin', fontdict=font)
plt.ylabel('Vout', fontdict=font)
plt.legend(['AR', 'Data'])
plt.show()
def plot_dtlti_analysis(z, p, k, fs=1, Nf=2**10, Nt=2**5):
"""Plot linear, time-invariant, discrete-time system.
Impulse, step, frequency response (level/phase/group delay) and z-plane
of transfer function H(z) given as zeros/poles/gain description
Note that we use fs only for the frequency responses
"""
# still hard coded, TBD:
# figure size
# group_delay discontinuities and automatic ylim, yticks is not
# useful sometimes
plt.figure(figsize=(9, 9), tight_layout=True)
mu = np.arange(Nf)
df = fs / Nf
dW = 2 * np.pi / Nf
f = mu * df # frequency vector [0...fs)
W = mu * dW # digital angular frequency [0...2pi)
sys = signal.dlti(z, p, k, dt=True)
sys_ba = signal.TransferFunction(sys)
b = sys_ba.num # we need coeff b,a for group_delay()
a = sys_ba.den
[W, H] = signal.dlti.freqresp(sys, W)
[W, gd] = signal.group_delay((b, a), w=W) # gd in samples
h = signal.dimpulse(sys, n=Nt)
he = signal.dstep(sys, n=Nt)
# plot frequency response: level
ax1 = plt.subplot(3, 2, 1)
ax1t = ax1.twiny()
ax1.grid(True, color='lavender', which='major')
# plotted below grid :-(
# ax1t.grid(True, color='mistyrose', which='minor')
ax1.plot(W / (2 * np.pi), 20 * np.log10(np.abs(H)), color='C0', lw=2)
ax1.set_xscale('linear')
ax1.set_xlim([0, 1])
ax1.tick_params(axis='x', labelcolor='C0')
ax1.set_xlabel(r'$\frac{\Omega}{2\pi} = \frac{f}{f_s}$', color='C0')
ax1.set_xticks(np.arange(11) / 10)
ax1.set_ylabel('level in dB or 20 lg|H| / dB', color='k')
ax1.set_axisbelow(True)
ax1t.plot(f, 20 * np.log10(np.abs(H)), color='C3', lw=2)
ax1t.set_xscale('log')
ax1t.set_xlim([f[1], f[-1]])
ax1t.tick_params(axis='x', labelcolor='C3')
ax1t.set_xlabel('frequency in Hz or f / Hz for $f_s$ = ' +
'{0:5.2f}'.format(fs) + ' Hz',
color='C3')
ax1t.set_axisbelow(True)
# plot impulse response
ax2 = plt.subplot(3, 2, 2)
ax2.stem(np.squeeze(h[0]),
np.squeeze(h[1]),
use_line_collection=True,
linefmt='C0:',
markerfmt='C0o',
basefmt='C0:')
ax2.xaxis.set_major_locator(MaxNLocator(integer=True))
ax2.grid(True)
ax2.set_xlabel(r'$k$')
ax2.set_ylabel(r'impulse response $h[k]$')
# plot frequency response: phase
ax3 = plt.subplot(3, 2, 3)
ax3.plot(W, np.unwrap(np.angle(H)))
ax3.set_xlabel(
r'digital angular frequency in radian or $\Omega$ / rad')
ax3.set_ylabel(r'phase in radian or $\angle$ H / rad')
ax3.set_xlim([0, 2 * np.pi])
ax3.set_xticks(np.arange(9) * np.pi / 4)
ax3.set_xticklabels([
r'0', r'$\pi/4$', r'$\pi/2$', r'$3/4\pi$', r'$\pi$', r'$5/4\pi$',
r'$3/2\pi$', r'$7/4\pi$', r'$2\pi$'
])
# ax3.set_ylim([-180, +180])
# ax3.set_yticks(np.arange(-180, +180+45, 45))
ax3.grid(True)
# plot step response
ax4 = plt.subplot(3, 2, 4)
ax4.stem(np.squeeze(he[0]),
np.squeeze(he[1]),
use_line_collection=True,
linefmt='C0:',
markerfmt='C0o',
basefmt='C0:')
ax4.xaxis.set_major_locator(MaxNLocator(integer=True))
ax4.grid(True)
ax4.set_xlabel(r'$k$')
ax4.set_ylabel(r'step response $h_\epsilon[k]$')
# plot frequency response: group delay
ax5 = plt.subplot(3, 2, 5)
ax5.plot(W / np.pi, gd / fs)
ax5.set_xscale('linear')
ax5.set_xlim([0, 2])
ax5.set_xlabel(r'$\frac{\Omega}{\pi}$')
ax5.set_ylabel(r'group delay in seconds or $\tau_\mathrm{GD}$ / s')
ax5.grid(True, which='both')
# zplane
ax6 = plt.subplot(3, 2, 6)
plot_zplane(sys.zeros, sys.poles, sys.gain) # see function above
# Plot t segundos de sinal ruidoso
plt.figure()
plt.plot(x, y)
plt.title("Intervalo de " + str(t) + " segundos")
plt.ylabel("Amplitude")
plt.xlabel("Tempo [s]")
plt.grid()
# Filtro Notch
f0 = 60.0 # frequencia a ser removida do sinal
Q = 1.0 # Quality factor
w0 = f0/(fs/2) # frequencia normalizada
b, a = signal.iirnotch(w0, Q)
y_f = signal.filtfilt(b, a, np.ravel(data))
tf = signal.TransferFunction(b, a)
# Plot sinal ruidoso
plt.figure()
plt.plot(T,y_f)
plt.title("Sinal filtrado")
plt.ylabel("Amplitude")
plt.xlabel("Tempo [s]")
plt.grid()
b, a = signal.iirnotch(w0, Q)
y_t = signal.filtfilt(b, a, np.ravel(y))
# Plot t segundos de sinal filtrado
plt.figure()
plt.plot(x, y_t)
def modelPT2(x, t, u):
x1 = x[0]
x2 = x[1]
dx1dt = x2
dx2dt = u - x2 - x1
dxdt = [dx1dt, dx2dt]
return dxdt
if __name__ == "__main__":
import matplotlib.pyplot as plt
nomSys = [1.0]
denSys = [1.0, 2.0, 1.0]
mySys = signal.TransferFunction(nomSys, denSys)
kSys = 1.0
nomSys = []
denSys = [-1.0, -1.0]
mySys2 = signal.ZerosPolesGain(nomSys, denSys, kSys)
t, y = signal.step(mySys2)
figure = plt.figure()
axis = figure.add_subplot(111)
# ax1.set_xlim([0, 6])
# ax2.set_ylim([-2, 2])
axis.plot(t, y)
plt.show()
from scipy import signal import matplotlib.pyplot as plt sys = signal.TransferFunction([1], [1, 1]) w, mag, phase = sys.bode() plt.figure() plt.semilogx(w, mag) # Bode magnitude plot plt.figure() plt.semilogx(w, phase) # Bode phase plot plt.show()
import numpy as np
from scipy import signal
import matplotlib.pyplot as plt
from scipy.integrate import odeint
# Change these values based on graphical fit
Kp = 1.0
taus = 1.0
zeta = 1.0
# Transfer Function
# Kp / (taus * s**2 + 2 * zeta * taus * s + 1)
num = [Kp]
den = [taus**2,2.0*zeta*taus,1]
sys1 = signal.TransferFunction(num,den)
t1,y1 = signal.step(sys1)
plt.figure(1)
plt.plot(t1,y1,'b--',linewidth=3,label='Transfer Fcn')
plt.xlabel('Time')
plt.ylabel('Response (y)')
plt.legend(loc='best')
plt.show()
def main_TanQua():
#### gerar configurações da entrada e do tempo de avaliação
#input_ pode ser - degrau, impulso, senoide, aleatoria, superposi, ponto_dif
#cada entrada refere-se a um experimento apresentado na documentação
input_ = 'superposi'
gain = 3
#referente ao primeiro segundo degrau da superposição
gains = [2,4]
#para senoide
freq = 0.01
ponto_medio = 3
cont_time=100000
#variaveis de tempo de execução
t0 = 0
tf = 4000
h = 0.01
t = np.arange(t0, tf, h)
#setando valores de pontos iniciais são necessários para execução em questão
init_ = [10.1]
#executando simulação
x_f = []
for point_stt in init_:
x0 = np.array([[point_stt], [point_stt], [point_stt], [point_stt]])
dc = np.zeros((len(x0), len(t) - 1))
x = x0.copy()
x = np.append(x, dc, axis=1)
#Seleção de entrada
if input_ == 'degrau':
u = degrau(t,gain)
elif input_ == 'senoide':
u = seno(t, gain, freq, ponto_medio)
elif input_ == 'impulso':
u = impulso(t, 15)
elif input_ == 'aleatoria':
u = aleatorio(t,0,6)
elif input_ == 'superposi':
u = signal_super(t,gains)
else:
u = np.zeros(len(t))
for k in range(1, len(t)):
result = rkTanQua(x[:, k - 1], u[k], u[k], h, t[k])
x[:, k] = result
x_f.append(x)
plot_mode = 'segOrd'
mode_ = 'exc'
#valores encontrados modelando com base no video do prof Aguirre
#https://www.youtube.com/watch?v=J-ZQ29dcmJU&feature=youtu.be
#https://www.youtube.com/watch?v=dm5cdpsuxlM&feature=youtu.be
if plot_mode == 'primOrd':
#criando sistemas de primeira ordem com valores calculados como no video do prof. Aguirre
num = [4]
den = [200, 1]
sist1 = signal.TransferFunction(num, den)
num = [2.7]
den = [200, 1]
sist2 = signal.TransferFunction(num, den)
num = [0.5]
den = [50, 1]
sist3 = signal.TransferFunction(num, den)
num = [0.3]
den = [50, 1]
sist4 = signal.TransferFunction(num, den)
#estabelecendo valores entre 0 e 3000
t_v = t[:-cont_time]
#resposta ao degrau de cada sistema
t1, out1 = signal.step(sist1, X0=None, T=t_v, N=None)
plt.plot(t1,out1, '--')
t2, out2 = signal.step(sist2, X0=None, T=t_v, N=None)
plt.plot(t2,out2, '--')
t3, out3 = signal.step(sist3, X0=None, T=t_v, N=None)
plt.plot(t3,out3, '--')
t4, out4 = signal.step(sist4, X0=None, T=t_v, N=None)
plt.plot(t4,out4, '--')
plotsignals(x_f,u,t,input_,init_)
elif plot_mode == 'segOrd':
#criando sistemas de segunda ordem
num = [4]
den = [0.575, 7.656, 1]
sist1 = signal.TransferFunction(num, den)
num = [2.7]
den = [0.575, 7.656, 1]
sist2 = signal.TransferFunction(num, den)
num = [0.5]
den = [8672, 259, 1]
sist3 = signal.TransferFunction(num, den)
num = [0.3]
den = [8672, 259, 1]
sist4 = signal.TransferFunction(num, den)
#estabelecendo uma quantidade de 3000 valores
t_v = t[:-cont_time]
#plots referentes a cada questão específica.
if mode_ == 'normal':
#plotando as a resposta ao degrau
t1, out1 = signal.step(sist1, X0=None, T=t_v, N=None)
plt.plot(t1,out1, '--')
t2, out2 = signal.step(sist2, X0=None, T=t_v, N=None)
plt.plot(t2,out2, '--')
t3, out3 = signal.step(sist3, X0=None, T=t_v, N=None)
plt.plot(t3,out3, '--')
t4, out4 = signal.step(sist4, X0=None, T=t_v, N=None)
plt.plot(t4,out4, '--')
plotsignals(x_f,u,t,input_,init_)
elif mode_ == 'normaliz':
plotsignals_p(x_f,u,t,input_,init_)
elif mode_ == 'exc':
t1, out1 =sist1.output(u, t, X0=None)
plt.plot(t1,out1[:-cont_time], '--')
t2, out2 =sist2.output(u, t, X0=None)
plt.plot(t1,out1[:-cont_time], '--')
t3, out3 =sist3.output(u, t, X0=None)
plt.plot(t1,out1[:-cont_time], '--')
t4, out4 =sist4.output(u, t, X0=None)
plt.plot(t1,out1[:-cont_time], '--')
plotsignals(x_f,u,t,input_,init_)
else:
w, mag, phase = sist1.bode()
plt.figure()
plt.legend('Saida 1 Magnitude')
plt.semilogx(w, mag) # Bode magnitude plot
plt.figure()
plt.legend('Saida 1 Fase')
plt.semilogx(w, phase) # Bode phase plot
plt.show()
w, mag, phase = sist2.bode()
plt.figure()
plt.legend('Saida 2 Magnitude')
plt.semilogx(w, mag) # Bode magnitude plot
plt.figure()
plt.legend('Saida 2 Fase')
plt.semilogx(w, phase) # Bode phase plot
plt.show()
w, mag, phase = sist3.bode()
plt.figure()
plt.legend('Saida 3 Magnitude')
plt.semilogx(w, mag) # Bode magnitude plot
plt.figure()
plt.legend('Saida 3 Fase')
plt.semilogx(w, phase) # Bode phase plot
plt.show()
w, mag, phase = sist4.bode()
plt.figure()
plt.legend('Saida 4 Magnitude')
plt.semilogx(w, mag) # Bode magnitude plot
plt.figure()
plt.legend('Saida 4 Fase')
plt.semilogx(w, phase) # Bode phase plot
plt.show()
def concatenateSystems(self,H1,H2):
H = signal.TransferFunction(np.polymul(H1.num,H2.num),np.polymul(H1.den,H2.den))
return H
def inverseMultiple(self,H1,H2):
H = signal.TransferFunction(np.polymul(H1.num,H2.den),np.polymul(H1.den,H2.num))
return H
#tf_num = [2*K_T*I_Q]
#tf_den = [J, 2*zeta]
"""
motor with PI feedback
(b*k_p*s + b*k_i)/(s^2 + (a + b*k_p)*s + b*k_i)
#from Notebook #4, pg 130
"""
b = 2 * K_T / J
a = 2 * zeta / J
k_p = 0.02
k_i = 0.01
tf_num = [b * k_p, b * k_i]
tf_den = [1, (a + b * k_p), b * k_i]
motor_tf = signal.TransferFunction(tf_num, tf_den)
t1, y1 = signal.step(motor_tf) #t1 in seconds, y1 in rad/s
y1 = y1 / (2 * pi) #convert y1 to Hz
plt.figure(1)
plt.plot(t1, y1)
plt.xlabel('time (s)')
plt.ylabel('motor freq (Hz)')
f = logspace(-1, 8)
w = 2 * pi * f
w, mag, phase = signal.bode(motor_tf, w)
plt.figure(2)
plt.semilogx(f, mag)
#######################
if aprox_type != 'LP':
print_console_alert('Frequency transformation LP -> ' + aprox_type)
if aprox_type == 'HP':
num, den = sig.lp2hp(lowpass_proto_lti.num, lowpass_proto_lti.den)
if aprox_type == 'BP':
num, den = sig.lp2bp(lowpass_proto_lti.num,
lowpass_proto_lti.den,
wo=1,
bw=BWbp)
xp_tf = sig.TransferFunction(num, den)
print_console_subtitle('Transformed transfer function')
pretty_print_lti(xp_tf)
print_console_subtitle('Cascade of second order systems (SOS' 's)')
xp_sos = tf2sos_analog(num, den)
pretty_print_SOS(xp_sos)
pretty_print_SOS(xp_sos, mode='omegayq')
print_console_subtitle('Respuesta en frecuencia')
analyze_sys(xp_sos, str_designed_filter, same_figs=False)
eps = np.sqrt(10**(this_ripple / 10) - 1)
num, den = sig.zpk2tf(z, p, k)
num, den = sig.lp2lp(num, den, eps**(-1 / this_order))
z, p, k = sig.tf2zpk(num, den)
elif aprox_name == 'Chebyshev1':
z, p, k = sig.cheb1ap(this_order, this_ripple)
elif aprox_name == 'Chebyshev2':
z, p, k = sig.cheb2ap(this_order, this_ripple)
elif aprox_name == 'Bessel':
z, p, k = sig.besselap(this_order, norm='mag')
elif aprox_name == 'Cauer':
z, p, k = sig.ellipap(this_order, this_ripple, this_att)
num, den = sig.zpk2tf(z, p, k)
all_sys.append(sig.TransferFunction(num, den))
filter_names.append(aprox_name + '_ord_' + str(this_order) + '_rip_' +
str(this_ripple) + '_att_' + str(this_att))
analyze_sys(all_sys, filter_names)
axs[1].set_xlabel('Time [ms]')
axs[1].set_ylabel('Step Response')
axs[1].grid()
fig.align_ylabels(axs[:])
plt.show()
""" Second Order Response """
tau = 1e-3
w0 = 1 / tau
s = 1j * w
Q = 1.5
mag_second = (abs(w0**2 / (s**2 + s * w0 / Q + w0**2)))
tin = np.linspace(0, 10e-3, 100)
sys_second = signal.TransferFunction([w0**2], [1, w0 / Q, w0**2])
w, mag_second, phase = sys_second.bode() # rad/s, dB, degrees
f = w / 2 / np.pi
tout, step_second = signal.step(sys_second, X0=None, T=tin)
# Plot the frequency response
fig, axs = plt.subplots(2)
fig.suptitle('$2^{nd}$ Order System Magnitude and Step Responses')
axs[0].semilogx(f, mag_second)
axs[0].grid()
axs[0].set_ylabel('Magnitude Response [dB]')
axs[0].set_xlabel('Frequency [Hz]')
axs[1].plot(1e3 * tin, step_second)
axs[1].grid()
axs[1].set_ylabel('Step Response')
def denormalize(self):
self.den=np.poly1d([1])
self.num=np.poly1d([1])
tempPoles=[]
tempZeros=[]
self.denorm_gain=1
if self.name=='LowPass': #If required filter is LP
#Denormalize poles
for i in range(0,len(self.poles)):#For each pole denormalization is realized
if self.poles[i] != 0:#If pole is not zero
pol=np.poly1d([-1/(self.wpl*self.poles[i]),1])
if np.real(np.roots(pol))<=0:
self.den= self.den*pol #Filter is denormalized by frequency scaling it S=Sn/wc
tempPoles.append(np.roots(pol)[0])
else:
pol=np.poly1d([1/(self.wpl),0])
self.den=self.den*pol
tempPoles.append(np.roots(pol)[0])
#Denormalize zeroes
for i in range(0,len(self.zeroes)):#For each zero denormalization is realized
if self.zeroes[i] != 0:#If zero is not located in origin
pol=np.poly1d([1/(self.wpl*self.zeroes[i]),1])
self.num= self.num*pol #Filter is denormalized by frequency scaling it S=Sn/wc
tempZeros.append(np.roots(pol)[0])
else:
pol=np.poly1d([1/(self.wpl),0])
self.num=self.num*pol
tempZeros.append(np.roots(pol)[0])
elif self.name=='HighPass': #If required filter is HP
#Denormalize poles
self.num=np.poly1d(np.zeros(len(self.poles)),r=True) #Zeroes created after doing HP denormalization to poles
for i in range(0,len(np.roots(self.num))):
tempZeros.append(np.roots(self.num)[i])
for i in range(0,len(self.poles)):
if self.poles[i] != 0:#If pole is not zero
pol=np.poly1d([1,-self.wpl/(self.poles[i])])
self.denorm_gain=(-(self.poles[i])/self.wpl)*self.denorm_gain
if np.real(np.roots(pol))<=0:
self.den= self.den*pol #Filter is denormalized by frequency scaling it S=wc/Sn
tempPoles.append(np.roots(pol)[0])
else:
pol=np.poly1d([-self.wpl])
self.denorm_gain=self.denorm_gain*-self.wpl
self.den= self.den*pol #Filter is denormalized by frequency scaling it S=wc/Sn
#tempPoles.append(np.roots(pol)[0])
#Denormalize zeroes
pol=np.poly1d(np.zeros(len(self.zeroes)),r=True)
self.den=self.den*pol #Poles created after doing HP denormalization to zeroes
for i in range(0,len(np.roots(pol))):
tempPoles.append(np.roots(pol)[i])
for i in range(0,len(self.zeroes)):
if self.zeroes[i] != 0:#If zero is not located in origin
pol=np.poly1d([1,self.wpl/(self.zeroes[i])])
self.num= self.num*pol #Filter is denormalized by frequency scaling it S=wc/Sn
tempZeros.append(np.roots(pol)[0])
self.denorm_gain=self.denorm_gain*(self.zeroes[i])/self.wpl
else:
pol=np.poly1d([self.wpl])
self.num= self.num*pol #Filter is denormalized by frequency scaling it S=wc/Sn
tempZeros.append(np.roots(pol)[0])
self.denorm_gain=self.denorm_gain*1/self.wpl
elif self.name=='BandPass': #If required filter is BP
wo=np.sqrt(self.wpl*self.wph)
B=(self.wph-self.wpl)/wo
#Denormalize poles
self.num=np.poly1d(np.zeros(len(self.poles)),r=True) #Zeroes created after doing HP denormalization to poles
for i in range(0,len(np.roots(self.num))):
tempZeros.append(np.roots(self.num)[i])
for i in range (0,len(self.poles)):
if self.poles[i] != 0:#If pole is not zero
if np.absolute(np.real(self.poles[i]))<0.0000001:
self.poles[i]=1j*np.imag(self.poles[i])
pol=np.poly1d([-1/(wo*B*self.poles[i]), 1, -wo/(B*self.poles[i])])
self.den=self.den*pol
tempPoles.append(np.roots(pol)[0])
tempPoles.append(np.roots(pol)[1])
self.denorm_gain=self.denorm_gain*1*(-B*self.poles[i]/(wo))
else:
pol=np.poly1d([-1/(wo*B), 0, -wo/B])
self.den=self.den*pol
tempPoles.append(np.roots(pol)[0])
tempPoles.append(np.roots(pol)[1])
self.denorm_gain=self.denorm_gain*1*(-B/(wo))
#Denormalize zeroes
pol=np.poly1d(np.zeros(len(self.zeroes)),r=True)
self.den=self.den*pol #Zeroes created after doing HP denormalization to poles
for i in range(0,len(np.roots(pol))):
tempPoles.append(np.roots(pol)[i])
for i in range (0,len(self.zeroes)):
if self.zeroes[i] != 0:#If zero is not located in origin
if np.absolute(np.real(self.zeroes[i]))<0.0000001:
self.zeroes[i]=1j*np.imag(self.zeroes[i])
pol=np.poly1d([1/(wo*B*self.zeroes[i]), 1, wo/(B*self.zeroes[i])])
self.num=self.num*pol
tempZeros.append(np.roots(pol)[0])
tempZeros.append(np.roots(pol)[1])
self.denorm_gain=self.denorm_gain*1/(-B*self.poles[i]/(wo))
else:
pol=np.poly1d([1/(wo*B), 0, wo/B])
self.num=self.num*pol
tempZeros.append(np.roots(pol)[0])
tempZeros.append(np.roots(pol)[1])
self.denorm_gain=self.denorm_gain*1/(B/(wo))
elif self.name=='StopBand': #If required filter is SB
wo=np.sqrt(self.wal*self.wah)
tempwph=self.wal*self.wah/self.wpl
tempwpl=self.wal*self.wah/self.wph
if (tempwph<self.wph) and (tempwpl>self.wpl):
B=(tempwph-tempwpl)/wo
elif (tempwph>self.wph) and (tempwpl>self.wpl):
B=(self.wph-tempwpl)/wo
elif (tempwph<self.wph) and (tempwpl<self.wpl):
B=(tempwph-self.wpl)/wo
else:
B=(self.wph-self.wpl)/wo
bool=True
#Denormalize poles
for i in range (0,len(self.poles)):
if self.poles[i] != 0:#If pole is not zero
if np.absolute(np.real(self.poles[i]))<0.0001:
self.poles[i]=1j*np.imag(self.poles[i])
pol=np.poly1d([1/wo, B/(-self.poles[i]), wo])
self.den=self.den*pol
tempPoles.append(np.roots(pol)[0])
tempPoles.append(np.roots(pol)[1])
else:
pol=np.poly1d([B,0])
self.den=self.den*pol
tempPoles.append(np.roots(pol)[0])
if (len(self.zeroes)!=0) and np.mod(self.n,2)==0:
bool=False
if bool==True:
pol=np.poly1d([1/wo,0,wo])
self.num=self.num*pol
tempZeros.append(np.roots(pol)[0])
tempZeros.append(np.roots(pol)[1])
if len(self.zeroes)!=0:
bool=False
#Denormalize zeroes
for i in range (0,len(self.zeroes)):
if self.zeroes[i] != 0:#If pole is not zero
pol=np.poly1d([1/wo, B/(self.zeroes[i]), wo])
self.num=self.num*pol
tempZeros.append(np.roots(pol)[0])
tempZeros.append(np.roots(pol)[1])
else:
pol=np.poly1d([B,0])
self.num=self.num*pol
tempZeros.append(np.roots(pol)[0])
elif self.name=='Group Delay':
#Denormalize poles
for i in range(0,len(self.poles)):#For each pole denormalization is realized
if self.poles[i] != 0:#If pole is not zero
pol=np.poly1d([-self.tao0/(self.poles[i]),1])
self.den= self.den*pol #Filter is denormalized by frequency scaling it S=Sn/wc
tempPoles.append(np.roots(pol)[0])
else:
pol=np.poly1d([self.tao0,0])
self.den=self.den*pol
tempPoles.append(np.roots(pol)[0])
#Denormalize zeroes
for i in range(0,len(self.zeroes)):#For each zero denormalization is realized
if self.zeroes[i] != 0:#If zero is not located in origin
pol=np.poly1d([self.tao0/self.zeroes[i],1])
self.num= self.num*pol #Filter is denormalized by frequency scaling it S=Sn/wc
tempZeros.append(np.roots(pol)[0])
else:
pol=np.poly1d([self.tao0,0])
self.num=self.num*pol
tempZeros.append(np.roots(pol)[0])
else:
pass
self.zeroes=tempZeros
self.poles=tempPoles
self.den=np.real(self.den)
self.num=np.real(self.num)
for i in range(0,len(self.poles)):
if np.real(self.poles[i])>0:
self.poles[i]=-np.real(self.poles[i])+1j*np.imag(self.poles[i])
for sing_pole in self.poles:
if np.real(sing_pole) !=0:
if (-np.absolute(sing_pole)/(2*np.real(sing_pole)))>self.q:
self.q=(-np.absolute(sing_pole)/(2*np.real(sing_pole)))
else:
self.q=float('inf')
self.K=np.power(10,self.gain/20)*self.aprox_gain
self.num=self.num*self.K
self.denorm_n=len(self.den)-1
self.K=np.power(10,self.gain/20)*self.aprox_gain*self.denorm_gain
#if self.name== 'StopBand':
# self.denorm_sys=signal.ZerosPolesGain.to_tf(signal.ZerosPolesGain(self.zeroes,self.poles,self.K))
#else:
self.denorm_sys = signal.TransferFunction(self.num,self.den) #Denormalized system is obtained