3.4.1 Respuesta a estado cero – Python

Se continúa con el ejercicio propuesto en la sección Sistema-Modelo:

Referencia:  Lathi ejemplo 2.6 pdf129

x(t) = 10 e^{-3t} \mu (t)

el sistema tiene respuesta a impulso:

h(t) = \big( 2e^{-2t} -e^{-t}\big)\mu (t)

El ejemplo es continuación del presentado para respuesta a entrada cero, que tiene la ecuación:

(D^2 + 3D +2)y(t) = Dx(t)

Se desarrollan el ejercicio de varias formas para obtener la gráfica de salida usando:

  1. Un sistema con Scipy.signal.lti() y simulado con Scipy.signal.lsim()
  2. La integral de convolución con Numpy.convolve()
  3. La integral de convolución con algoritmo

1. Un sistema con Scipy.signal.lti() y simulado con Scipy.signal.lsim()

Esta forma de describir el problema simplifica el desarrollar a partir de la descripción de la ecuación del sistema.

La libreria Scipy.signal permite definir un sistema LTI, usando los coeficientes de la ecuación y condiciones de inicio en cero. La salida y(t) se calcula con una versión muestreada xi de la función de entrada x(t) a partir del tiempo muestreado en el intervalo [a,b].

En el algoritmo se incorpora la gráfica de la función de transferencia h(t) como referencia.

# Sistema lineal usando scipy.signal
#   Q(D)y(t)=P(D)x(t)
# ejemplo: (D^2+3D+2)y(t)=(D+0)x(t)
import numpy as np
import scipy.signal as senal

# INGRESO
# tiempo [a,b]
a = 0 ; b = 5 ; muestras=101

# Señal de entrada
u = lambda t: np.piecewise(t,t>=0,[1,0])
x = lambda t: 10*np.exp(-3*t)*u(t)

# Sistema
# coeficients Q  P de la ecuación diferencial
Q = [1., 3, 2]
P = [1., 0]
# condiciones de inicio [y'0,y0]
inicio = [0,0]

# PROCEDIMIENTO
ti = np.linspace(a, b, muestras)
xi = x(ti)

sistema = senal.lti(P,Q)
[t_y, yi, yc] = senal.lsim(sistema, xi, ti, inicio)
[t_h, hi] = sistema.impulse(T = ti)

# SALIDA - GRAFICA
import matplotlib.pyplot as plt

plt.subplot(211)
plt.suptitle('Respuesta a estado cero')
plt.plot(ti, xi, color='blue', label='x(t)')
plt.plot(t_h, hi, color='red', label='h(t)')

plt.legend()
plt.grid()

plt.subplot(212)
plt.plot(t_y, yi, color='magenta', label='y(t)')
# plt.plot(t_y, yc[:,0], 'g-.', label='y(t)')
# plt.plot(t_y, yc[:,1], color='orange', label='y0(t)')

plt.xlabel('t')
plt.legend()
plt.grid()
plt.show()

2. La integral de convolución con Numpy.convolve()

El algoritmo requiere la expresión de las funciones x(t) y h(t) para determinar y(t). Realiza el cálculo de la convolución que para aproximar a la integral requiere multiplicar por dt.

Note que debe mantener el valor dt pequeño,  en el ejercicio se ha definido como 0.01 que corresponden a casi 1000 muestras.

Para usar la función convolve se requiere muestras en tiempos, simétricos alrededor de cero debido a la naturaleza del algoritmo. Sección que puede ser eliminada antes de mostrar la gráfica.  Para recordarlo se ha dejado la parte negativa del rango de tiempo.

# Lathi ejemplo 2.6 pdf129
# Señales contínuas en convolución
# Compare con el algoritmo en discretas
import numpy as np

# INGRESO
# tiempo [a,b] simétrico a 0
b = 5 ; a = -b; dt =0.01

u = lambda t: np.piecewise(t,t>=0,[1,0])

x = lambda t: 10*np.exp(-3*t)*u(t)
h = lambda t: (2*np.exp(-2*t)-np.exp(-t))*u(t)


# PROCEDIMIENTO
ti = np.arange(a,b+dt,dt)
xi = x(ti)
hi = h(ti)

# Integral de Convolucion x[t]*h[t]
# corrección de magnitud por dt para en integral
yi = np.convolve(xi,hi,'same')*dt

# SALIDA - GRAFICA
import matplotlib.pyplot as plt

plt.figure(1)
plt.suptitle('Integral de Convolución x(t)*h(t)')

plt.subplot(211)
plt.plot(ti,xi,'b', label='x(t)')
plt.plot(ti,hi,'r', label='h(t)')
plt.legend()
plt.grid()

plt.subplot(212)
plt.plot(ti,yi,'m', label='x(t)*h(t)')
plt.xlabel('t')
plt.legend()
plt.grid()

plt.show()

3. La integral de convolución con algoritmo

Esta sección desarrolla el algoritmo para la integral de convolución, tomando paso a paso las operaciones para obtener la gráfica del resultado. El algoritmo se presenta con propósitos didácticos.

Parece ser un poco más lento debido a que se realizan las operaciones de forma básica (interpretada) de Python, la función usa elementos compilados más eficientes.

Note que la única sección que cambia es la de convolución, por lo que la gráfica de salida es la misma que la sección anterior.:

# Lathi ejemplo 2.6 pdf129
# Señales contínuas en convolución
# Compare con el algoritmo en discretas
import numpy as np

# INGRESO
# Rango [a,b], simétrico a 0
b = 5 ; a = -b; dt =0.01

u = lambda t: np.piecewise(t,t>=0,[1,0])

x = lambda t: 10*np.exp(-3*t)*u(t)
h = lambda t: (2*np.exp(-2*t)-np.exp(-t))*u(t)


# PROCEDIMIENTO
ti = np.arange(a,b+dt,dt)
xi = x(ti)
hi = h(ti)

# Integral de Convolución x[t]*h[t]
muestras = len(xi)
yi = np.zeros(muestras, dtype=float)
for i in range(0,muestras):
    suma=0
    for k in range(0,muestras):
        suma = suma + x(ti[k])*h(ti[i]-ti[k])
    yi[i]= suma*dt

# SALIDA - GRAFICA
import matplotlib.pyplot as plt

plt.figure(1)
plt.suptitle('Integral de Convolución x(t)*h(t)')

plt.subplot(211)
plt.plot(ti,xi,'b', label='x(t)')
plt.plot(ti,hi,'r', label='h(t)')
plt.legend()
plt.grid()

plt.subplot(212)
plt.plot(ti,yi,'m', label='x(t)*h(t)')
plt.xlabel('t')
plt.legend()
plt.grid()

plt.show()

Publicado por

Edison Del Rosario

edelros@espol.edu.ec / Profesor del FIEC/FCNM-ESPOL