¿Cómo podemos relacionar el comportamiento de un sistema no lineal con el comportamiento de un sistema lineal? Hay varias formas. Una de ellas es la linealización jacobiana.

La linealización Jacobiana es relativamente simple a entender y aplicar al sistema no lineal para obtener el sistema lineal asociado.

En algunos casos, puede ser necesario realizar una comparación entre ambos sistemas. Esta comparación puede ser en lazo abierto o en lazo cerrado.

¿Para qué puede ser útil realizar una comparación?

Esencialmente, para evaluación del desempeño y para responder a las interrogantes: ¿nos servirán las estrategias de control diseñadas en función del sistema linealizado para regular el sistema no lineal? ¿hasta nos servirán tales estrategias?

Los años que llevo enseñando linealización aproximada en cursos introductorios del área de sistemas de control me han mostrado que, aparentemente, no es fácil y directo el uso de esta información para realizar una comparación entre ambos sistemas.

Resumen

Mostraré en esta breve nota cómo se usa la información generada a partir de la linealización Jacobiana y cuáles son los errores más comunes que se cometen al hacer una comparación. Para ello me basaré en las ecuaciones y en el código en GNU Octave (muy parecido al de MATLAB).

Objetivo

Ilustrar mediante algunos ejemplos como comparar el sistema no lineal y su sistema lineal aproximado

Linealización

Basado en la aproximación por serie de Taylor, el procedimiento de linealización se puede resumir a lo siguiente. Dado un sistema no lineal representado por $\dot x = f(x,u)$, se tiene

$$\dot x = f(x,u) = f(\bar x, \bar u) +\left.\frac {\partial f}{\partial x} \right|_{(\bar x, \bar u)}(x-\bar x)+\left.\frac {\partial f}{\partial u} \right|_{(\bar x, \bar u)}(u-\bar u) + \text{T.O.S.}$$
donde $f(\bar x, \bar u)\equiv 0$, el par $(\bar x, \bar u)]$corresponde al punto de equilibrio. Las siglas T.O.S. denotan los Términos de Orden Superior.

Si se eliminan los términos de orden superior, se obtiene
$$\dot x = f(x,u) \approx A(x-\bar x) + B(u-\bar u) = Ax_\delta+Bx_\delta$$

El sistema lineal asociado está dado entonces por $$\dot x_\delta = Ax_\delta + Bu_\delta$$ donde $A =\left.\frac {\partial f}{\partial x} \right|_{(\bar x, \bar u)}$, $B =\left.\frac {\partial f}{\partial u} \right|_{(\bar x, \bar u)}$.

Relación entre las variables linealizadas y las originales

Las variables *lineal* y *no lineal* están **asociadas** a través de la relación obtenida mediante la **aproximación de Taylor**: \begin{aligned}x_\delta &= x-\bar x \\ u_\delta &= u-\bar u\end{aligned}

Esta relación determina la relación en el tiempo de $x(t)$ y $x_\delta(t)$ y su posible comparación: $$x_\delta(t) = x(t)-\bar x$$ Lo que nos indica esta relación es que si se desea comparar ambos sistemas, no debe hacerse $x_\delta(t)$ vs $x(t)$ sino precisamente $x_\delta(t)$ vs $x(t)-\bar x$ o en todo caso su relación equivalente $x_\delta(t)+\bar x$ vs $x(t)$.

En particular, la relación $x_\delta(t) = x(t)-\bar x$ indica las condiciones iniciales del sistema lineal $x_\delta(0)$ dadas las condiciones iniciales del sistema no lineal $x(0)$: $$x_\delta(0) = x(0)-\bar x$$

Ejemplo: control de congestión de datos

Considere el siguiente modelo (monovariable) $$R\frac {d x}{d t} = \left[a-\left(a+\frac{2b}{2-b}x\right)\mu\right]$$ donde $x$ representa el tamaño de la ventana de congestión y $\mu$ la tasa por unidad de tiempo de pérdida de paquetes. El punto de equilibrio de este sistema está dado por: $\bar x = X$ y $\bar \mu = a/(a+2bX/(2-b))$. La linealización Jacobiana del modelo anterior resulta, entonces, en: $$R\dot x_\delta = -\frac{2b}{2-b}\bar \mu x_\delta-\left(a+\frac{2b}{2-b}X\right)\mu_\delta$$

Procedimiento al comparar (lazo abierto): Si el valor de $\mu$ se fija en su valor de equilibio, es decir, $\mu = \bar \mu$, entonces $\mu_\delta = \mu -\bar \mu \equiv 0$. Si el valor inicial de $x(0) = 0$ entonces $x_\delta(0) = -X$. Si el valor inicial de $x(0) = X-1$ entonces $x_\delta(0) = -1$. Al efectuar la comparación, se puede tomar $x$ vs $x_\delta + X$.

En términos de código en GNU Octave:

function dx = f(x,t)
  a = 0.5; b = 1;
  X = 100;
  mu = a/(a+2*b/(2-b)*X);
  dx = a-(a+2*b/(2-b)*x)*mu;
endfunction

function dx = fl(x,t)
  a = 0.5; b = 1;
  X= 100;
  mub = a/(a+2*b/(2-b)*X);
  mu = 0;
  dx = -2*b/(2-b)* mub*x-(a+2*b/(2-b)*X)*mu;
endfunction

X = 100;
x0 = 0; x0l = -X;
t = linspace(0,1000,50);

x = lsode('f',x0,t);
xl = lsode('fl',x0l,t);
plot(t,x,t,xl+X,'o')
xlabel('tiempo t (s)')
ylabel('tamano ventana congestion (paquetes)')

Se puede comprobar que las gráficas resultantes de código mostrado son muy similares, es decir, con errores absolutos menores a `5e-6`. *Observación:* se han omitido algunos detalles en el código.

Este ejemplo se puede ejecutar en línea en GNU Octave.