Lie-Klammer für die Exakte Eingangs-Zustandslinearisierung

Bei der Eingangs-Zustandslinearisierung ist der Ausgang $y$ des nichtlinearen Systems nicht relevant. Es gibt eine gut ausgebaute Theorie, welche die Überprüfung der Eingangs-Zustands-Linearisierbarkeit erlaubt.

Für die Überprüfung der Existenz eines Ausganges mit relativem Grad $r = n$ erweist sich die Lie-Klammer als hilfreich. Das gilt sowohl für Ein- als auch Mehrgrößensysteme (SISO und MIMO Systeme).

Die Theorie der differential-geometrischen Regelungstechnik ist sehr gut ausgebaut, jedoch alles andere als trivial. Für das Erlernen dieser Techniken sollte viel Zeit eingeplant werden. An den Universitäten werden dafür meist mehrere Vorlesungen benötigt, um diese Theorie vollständig einzuführen.

Es soll hier nur gezeigt werden, dass Python / Sympy auf für nichtlineare Methoden gut geeignet ist.

Lie-Klammer

Die Lie-Klammer ist folgendermaßen definiert

$[f, g] (x) = L_{f} g (x) = \frac{\partial g}{\partial x} f (x) - \frac{\partial f}{\partial x} g (x)$

wobei hier sowohl $f (x)$ als auch $g (x)$ Vektorfelder sind.

Auch die Lie-Klammer (Lie-Ableitung der Vektorfelder) kann wie die Lie-Ableitung der skalaren Funktionen rekursive angewendet werden. Die k-fache Lie-Klammer lässt sich in der Form

$a d_{f}^{k} g (x) = [\begin{matrix} f & a d_{f}^{k - 1} g \end{matrix}] (x) a d_{f}^{0} g (x) = g (x)$

mit dem Operator $a d$ definieren.

Hinweis

Existenz eines Ausganges mit relativem Grad r = n)

Für SISO Systeme ist es notwendig aber nicht hinreichend, dass die Matrix

$M = [\begin{matrix} g & a d_{f} g & \dots & a d_{f}^{n - 1} g \end{matrix}]$

den Rang $n$ besitzt.

Beispiel

Dieses Beispiel ist aus dem Vorlesungskript von Andreas Kugi, TU Wien entnommen.

Gegeben sei das AI-System

$\dot{x} = \underset{f (x)}{\underset{⏟}{[\begin{matrix} x_{3} \\ x_{4} \\ - \frac{c}{I_{1}} x_{1} + \frac{c}{I_{1}} x_{2} - \frac{d_{1}}{I_{1}} x_{3} \\ \frac{c}{I_{2}} x_{1} - \frac{c}{I_{2}} x_{2} - \frac{m g l}{I_{2}} c o s (x_{2}) - \frac{d_{2}}{I_{2}} x_{4} \end{matrix}]}} + \underset{g (x)}{\underset{⏟}{[\begin{matrix} 0 \\ 0 \\ \frac{1}{I_{1}} \\ 0 \end{matrix}]}} u .$

Das Durchführen der Rechnung führt auf das Ergebnis

$r a n g ([\begin{matrix} a d_{f}^{0} g & a d_{f}^{1} g & a d_{f}^{2} g & a d_{f}^{3} g \end{matrix}]) = r a n g ([\begin{matrix} 0 & \frac{- 1}{I_{1}} & \frac{- d_{1}}{I_{1}^{2}} & \frac{I_{1} c - d_{1}^{2}}{I_{1}^{3}} \\ 0 & 0 & 0 & - \frac{c}{I_{2} I_{1}} \\ \frac{1}{I_{1}} & \frac{d_{1}}{I_{1}^{2}} & \frac{d_{1}^{2} - c I_{1}}{I_{1}^{3}} & \frac{d_{1}^{3} - 2 c d_{1} I_{1}}{I_{4}^{4}} \\ 0 & 0 & \frac{c}{I_{2} I_{1}} & \frac{c}{I_{2} I_{1}} (\frac{d_{1}}{I_{1}} + \frac{d_{2}}{I_{2}}) \end{matrix}]) = 4.$

Wir wollen diese Berechnung nun in Python / Sympy durchführen.

from sympy import init_printing
init_printing()

from sympy import *

def jac(f,x):
    return f.jacobian(x)

def lie_deriv(f, h, x, n=1):
    """ Lie-derivative of a scalar function h with respect to a vector-field f
    """
    if n==0:
        Lfh = h
    else:
        Lfh = h.jacobian(x)@f
        for i in range(1,n):
            Lfh = Lfh.jacobian(x)@f
    return Lfh

def lie_braket(f, g, x, n=1):
    """ Lie-bracket, Lie-derivative of a vector-field g with respect to another vector-field f
    """
    if n==0:
        adfg = g
    else:
        adfg = g.jacobian(x)@f - f.jacobian(x)@g
        for i in range(1,n):
            adfg = adfg.jacobian(x)@f - f.jacobian(x)@adfg
    return adfg

x1, x2, x3, x4 = symbols('x1 x2 x3 x4', real=True)
x_vec =  Matrix([[x1],[x2],[x3],[x4]])

c, g, l, m = symbols('c g l m', positive=True)
I1, d1 = symbols('I1 d1', positive=True)
I2, d2 = symbols('I2 d2', positive=True)

f = Matrix([
    [x3],
    [x4],
    [-c/I1*x1+c/I1*x2-d1/I1*x3],
    [c/I2*x1-c/I2*x2-m*g*l/I2*cos(x2)-d2/I2*x4]
           ])

f

$[\begin{matrix} x_{3} \\ x_{4} \\ - \frac{c x_{1}}{I_{1}} + \frac{c x_{2}}{I_{1}} - \frac{d_{1} x_{3}}{I_{1}} \\ \frac{c x_{1}}{I_{2}} - \frac{c x_{2}}{I_{2}} - \frac{d_{2} x_{4}}{I_{2}} - \frac{g l m \cos (x_{2})}{I_{2}} \end{matrix}]$

g = Matrix([
    [0],
    [0],
    [1/I1],
    [0]
])
g

$[\begin{matrix} 0 \\ 0 \\ \frac{1}{I_{1}} \\ 0 \end{matrix}]$

adf0g = lie_braket(f, g, x_vec,n=0)
adf1g = lie_braket(f, g, x_vec,n=1)
adf2g = lie_braket(f, g, x_vec,n=2)
adf3g = lie_braket(f, g, x_vec,n=3)
M = adf0g
M = M.col_insert(1,adf1g)
M = M.col_insert(2,adf2g)
M = M.col_insert(3,adf3g)
simplify(M)

$[\begin{matrix} 0 & - \frac{1}{I_{1}} & - \frac{d_{1}}{I_{1}^{2}} & \frac{I_{1} c - d_{1}^{2}}{I_{1}^{3}} \\ 0 & 0 & 0 & - \frac{c}{I_{1} I_{2}} \\ \frac{1}{I_{1}} & \frac{d_{1}}{I_{1}^{2}} & \frac{- I_{1} c + d_{1}^{2}}{I_{1}^{3}} & \frac{d_{1} (- 2 I_{1} c + d_{1}^{2})}{I_{1}^{4}} \\ 0 & 0 & \frac{c}{I_{1} I_{2}} & \frac{c (I_{1} d_{2} + I_{2} d_{1})}{I_{1}^{2} I_{2}^{2}} \end{matrix}]$

M.rank()

$4$

Die Matrix

$M = [\begin{matrix} a d_{f}^{0} g & a d_{f}^{1} g & a d_{f}^{2} g & a d_{f}^{3} g \end{matrix}]$

hat also den vollen Rang $n = 4$ und der relative Grad ist also $r = 4$ .

Fazit

Python / Sympy bietet viele Möglichkeiten für die nichtlineare Regelungtechnik. Dieser Blogeintrag bezieht sich auf differentialgeometrischen Methoden, genauer auf die Exakte Eingangs-Zustandslinearisierung im Eingrößenfall.

Sind die nichtlinearen Regler einmal hergeleitet, so können diese mithilfe der Python-Control Submodule wie control.flatsys oder control.NonlinearIOSystem implementiert werden.

Referenzen

Nichtlineare Systeme und Regelungen, 3. Auflage (Jürgen Adamy, 2018)
The Geometry of Physics, Third Edition (Theodore Frankel, 2012)
Regelsysteme 2 (Andreas Kugi, Vorlesung SS 2021)