lecture-h-infinity/index.org

#+TITLE: Robust Control - $\mathcal{H}_\infty$ Synthesis
:DRAWER:
#+STARTUP: overview

#+LANGUAGE: en
#+EMAIL: dehaeze.thomas@gmail.com
#+AUTHOR: Dehaeze Thomas

#+HTML_LINK_HOME: ../index.html
#+HTML_LINK_UP:   ../index.html

# #+HTML_HEAD: <link rel="stylesheet" type="text/css" href="https://research.tdehaeze.xyz/css/style.css"/>
# #+HTML_HEAD: <script type="text/javascript" src="https://research.tdehaeze.xyz/js/script.js"></script>

#+HTML_HEAD: <link rel="stylesheet" type="text/css" href="/home/thomas/Cloud/thesis/matlab/research-home-page/css/style.css"/>
#+HTML_HEAD: <script type="text/javascript" src="/home/thomas/Cloud/thesis/matlab/research-home-page/js/script.js"></script>

#+HTML_MATHJAX: align: center tagside: right font: TeX

#+PROPERTY: header-args:matlab  :session *MATLAB*
#+PROPERTY: header-args:matlab+ :comments org
#+PROPERTY: header-args:matlab+ :results none
#+PROPERTY: header-args:matlab+ :exports both
#+PROPERTY: header-args:matlab+ :eval no-export
#+PROPERTY: header-args:matlab+ :output-dir figs
#+PROPERTY: header-args:matlab+ :tangle no
#+PROPERTY: header-args:matlab+ :mkdirp yes

#+PROPERTY: header-args:shell  :eval no-export

#+PROPERTY: header-args:latex  :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/tikz/org/}{config.tex}")
#+PROPERTY: header-args:latex+ :imagemagick t :fit yes
#+PROPERTY: header-args:latex+ :iminoptions -scale 100% -density 150
#+PROPERTY: header-args:latex+ :imoutoptions -quality 100
#+PROPERTY: header-args:latex+ :results file raw replace
#+PROPERTY: header-args:latex+ :buffer no
#+PROPERTY: header-args:latex+ :eval no-export
#+PROPERTY: header-args:latex+ :exports results
#+PROPERTY: header-args:latex+ :mkdirp yes
#+PROPERTY: header-args:latex+ :output-dir figs
#+PROPERTY: header-args:latex+ :post pdf2svg(file=*this*, ext="png")
:END:

* Matlab Init                                                :noexport:ignore:
#+begin_src matlab :tangle no :exports none :results silent :noweb yes :var current_dir=(file-name-directory buffer-file-name)
  <<matlab-dir>>
#+end_src

#+begin_src matlab :exports none :results silent :noweb yes
  <<matlab-init>>
#+end_src

* Introduction to the Control Methodology - Model Based Control

The typical methodology when applying Model Based Control to a plant is schematically shown in Figure [[fig:control-procedure]].
It consists of three steps:
1. *Identification or modeling*: $\Longrightarrow$ mathematical model
2. *Translate the specifications into mathematical criteria*:
   - _Specifications_: Response Time, Noise Rejection, Maximum input amplitude, Robustness, ...
   - _Mathematical Criteria_: Cost Function, Shape of TF
   # - Cost Function, Needed Bandwidth, Roll-off, ...
   # - $\Longrightarrow$ We will use the $\hinf$ Norm
3. *Synthesis*: research of $K$ that satisfies the specifications for the model of the system

#+begin_src latex :file control-procedure.pdf
  \begin{tikzpicture}
    \node[addb={+}{}{}{}{-}] (addsub) at (0, 0){};

    \node[block, right=1.5 of addsub] (controller) {Controller};
    \node[block, right=1.5 of controller] (plant) {Plant};

    \node[block, above=1 of controller] (controller_design) {Synthesis};
    \node[block, above=1 of plant] (model_plant) {Model};

    \draw[<-] (addsub.west) -- ++(-1, 0) node[above right]{$r$};

    \draw[->] (addsub) -- (controller.west) node[above left]{$\epsilon$};
    \draw[->] (controller) -- (plant.west) node[above left]{$u$};
    \draw[->] (plant.east) -- ++(1, 0) node[above left]{$y$};
    \draw[] ($(plant.east) + (0.5, 0)$) -- ++(0, -1);
    \draw[->] ($(plant.east) + (0.5, -1)$) -| (addsub.south);

    \draw[->, dashed] (plant) -- node[midway, right, labelc, solid]{1} (model_plant);
    \draw[->, dashed] (controller_design) --node[midway, right, labelc, solid]{3} (controller);
    \draw[->, dashed] (model_plant) -- (controller_design);
    \draw[<-, dashed] (controller_design.west) -- node[midway, above, labelc, solid]{2} ++(-1, 0) node[left, style={align=center}]{Specifications};
  \end{tikzpicture}
#+end_src

#+name: fig:control-procedure
#+caption: Typical Methodoly for Model Based Control
#+RESULTS:
[[file:figs/control-procedure.png]]

In this document, we will mainly focus on steps 2 and 3.

* Some Background: From Classical Control to Robust Control

Classical Control (1930)
- Tools:
  - TF (input-output)
  - Nyquist, Bode, Black, \ldots
  - P-PI-PID, Phase lead-lag, \ldots
- Advantages:
  - Stability
  - Performances
  - Robustness
- Disadvantages:
  - Manual Method
  - Only SISO

Modern Control (1960)
- Tools:
  - State Space
  - Optimal Command
  - LQR, LQG
- Advantages:
  - Automatic Synthesis
  - MIMO
  - Optimisation problem
- Disadvantages:
  - Robustness
  - Rejection of Perturbations

Robust Control (1980)
- Tools:
  - Disk Margin
  - Systems and Signals norms ($\mathcal{H}_\infty$ and $\mathcal{H}_2$ norms)
  - Closed Loop Transfer Functions
  - Loop Shaping
- Advantages:
  - Stability
  - Performances
  - Robustness
  - Automatic Synthesis
  - MIMO
  - Optimization Problem
- Disadvantages:
  - Requires the knowledge of specific tools
  - Need a reasonably good model of the system

* The $\mathcal{H}_\infty$ Norm

#+begin_definition
 The $\mathcal{H}_\infty$ norm is defined as the peak of the maximum singular value of the frequency response
 \begin{equation}
   \|G(s)\|_\infty = \max_\omega \bar{\sigma}\big( G(j\omega) \big)
 \end{equation}

 For a SISO system $G(s)$, it is simply the peak value of $|G(j\omega)|$ as a function of frequency:
 \begin{equation}
   \|G(s)\|_\infty = \max_{\omega} |G(j\omega)| \label{eq:hinf_norm_siso}
 \end{equation}
#+end_definition

#+begin_exampl
Let's define a plant dynamics:
#+begin_src matlab
   w0 = 2*pi; k = 1e6; xi = 0.04;

   G = 1/k/(s^2/w0^2 + 2*xi*s/w0 + 1);
#+end_src

And compute its $\mathcal{H}_\infty$ norm using the =hinfnorm= function:
#+begin_src matlab :results value replace
  hinfnorm(G)
#+end_src

#+RESULTS:
: 1.0013e-05

The magnitude $|G(j\omega)|$ of the plant $G(s)$ as a function of frequency is shown in Figure [[fig:hinfinity_norm_siso_bode]].
The maximum value of the magnitude over all frequencies does correspond to the $\mathcal{H}_\infty$ norm of $G(s)$ as Equation eqref:eq:hinf_norm_siso implies.

#+begin_src matlab :exports none
  freqs = logspace(-1, 1, 1000);
  figure;
  hold on;
  plot(freqs, abs(squeeze(freqresp(G, freqs, 'Hz'))), 'k-');
  plot([0.5, 2], [hinfnorm(G) hinfnorm(G)], 'k--');
  text(2, hinfnorm(G), '$\quad \|G\|_\infty$')
  hold off;
  set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
  xlabel('Frequency [Hz]'); ylabel('Magnitude $|G(j\omega)|$');
  ylim([1e-8, 2e-5]);
#+end_src

#+begin_src matlab :tangle no :exports results :results file replace
  exportFig('figs/hinfinity_norm_siso_bode.pdf', 'width', 'wide', 'height', 'normal');
#+end_src

#+name: fig:hinfinity_norm_siso_bode
#+caption: Example of the $\mathcal{H}_\infty$ norm of a SISO system
#+RESULTS:
[[file:figs/hinfinity_norm_siso_bode.png]]
#+end_exampl

* $\mathcal{H}_\infty$ Synthesis

*Optimization problem*:
$\hinf$ synthesis is a method that uses an *algorithm* (LMI optimization, Riccati equation) to find a controller of the same order as the system so that the $\hinf$ norms of defined transfer functions are minimized.

*Engineer work*:
1. Write the problem as standard $\hinf$ problem
2. Translate the specifications as $\hinf$ norms
3. Make the synthesis and analyze the obtain controller
4. Reduce the order of the controller for implementation

*Many ways to use the $\hinf$ Synthesis*:
- Traditional $\hinf$ Synthesis
- Mixed Sensitivity Loop Shaping
- Fixed-Structure $\hinf$ Synthesis
- Signal Based $\hinf$ Synthesis

* The Generalized Plant
#+begin_src latex :file general_plant.pdf
  \begin{tikzpicture}
    \node[block={2.0cm}{2.0cm}] (P) {$P$};
    \node[above] at (P.north) {Generalized Plant};

    % Input and outputs coordinates
    \coordinate[] (inputw)  at ($(P.south west)!0.75!(P.north west)$);
    \coordinate[] (inputu)  at ($(P.south west)!0.25!(P.north west)$);
    \coordinate[] (outputz) at ($(P.south east)!0.75!(P.north east)$);
    \coordinate[] (outputv) at ($(P.south east)!0.25!(P.north east)$);

    % Connections and labels
    \draw[<-] (inputw) -- ++(-0.8, 0) node[above right]{$w$};
    \draw[<-] (inputu) -- ++(-0.8, 0) node[above right]{$u$};

    \draw[->] (outputz) -- ++(0.8, 0) node[above left]{$z$};
    \draw[->] (outputv) -- ++(0.8, 0) node[above left]{$v$};
  \end{tikzpicture}
#+end_src

#+RESULTS:
[[file:figs/general_plant.png]]

#+name: tab:notation_general
#+caption: Notations for the general configuration
| Notation | Meaning                                         |
|----------+-------------------------------------------------|
| $P$      | Generalized plant model                         |
| $w$      | Exogenous inputs: commands, disturbances, noise |
| $z$      | Exogenous outputs: signals to be minimized      |
| $v$      | Controller inputs: measurements                 |
| $u$      | Control signals                                 |

\begin{equation}
  \begin{bmatrix} z \\ v \end{bmatrix} = P \begin{bmatrix} w \\ u \end{bmatrix} = \begin{bmatrix} P_{11} & P_{12} \\ P_{21} & P_{22} \end{bmatrix} \begin{bmatrix} w \\ u \end{bmatrix}
\end{equation}

* Problem Formulation

#+begin_important
  The $\mathcal{H}_\infty$ Synthesis objective is to find all stabilizing controllers $K$ which minimize
  \begin{equation}
    \| F_l(P, K) \|_\infty = \max_{\omega} \overline{\sigma} \big( F_l(P, K)(j\omega) \big)
  \end{equation}

#+end_important

#+begin_src latex :file general_control_names.pdf
  \begin{tikzpicture}

    % Blocs
    \node[block={2.0cm}{2.0cm}] (P) {$P$};
    \node[block={1.5cm}{1.5cm}, below=0.7 of P] (K) {$K$};

    % Input and outputs coordinates
    \coordinate[] (inputw)  at ($(P.south west)!0.75!(P.north west)$);
    \coordinate[] (inputu)  at ($(P.south west)!0.25!(P.north west)$);
    \coordinate[] (outputz) at ($(P.south east)!0.75!(P.north east)$);
    \coordinate[] (outputv) at ($(P.south east)!0.25!(P.north east)$);

    % Connections and labels
    \draw[<-] (inputw) node[above left, align=right]{(weighted)\\exogenous inputs\\$w$} -- ++(-1.5, 0);
    \draw[<-] (inputu) -- ++(-0.8, 0) |- node[left, near start, align=right]{control signals\\$u$} (K.west);

    \draw[->] (outputz) node[above right, align=left]{(weighted)\\exogenous outputs\\$z$} -- ++(1.5, 0);
    \draw[->] (outputv) -- ++(0.8, 0) |- node[right, near start, align=left]{sensed output\\$v$} (K.east);
  \end{tikzpicture}
#+end_src

#+name: fig:general_control_names
#+caption: General Control Configuration
#+RESULTS:
[[file:figs/general_control_names.png]]


* Classical feedback control and closed loop transfer functions

#+begin_src latex :file classical_feedback.pdf
  \begin{tikzpicture}
    \node[addb={+}{}{}{}{-}] (addfb) at (0, 0){};
    \node[block, right=0.8 of addfb] (K){$K(s)$};
    \node[addb={+}{}{}{}{}, right=0.8 of K] (addu){};
    \node[block, right=0.8 of addu] (G){$G(s)$};

    \draw[<-] (addfb.west) -- ++(-0.8, 0) node[above right]{$r$};
    \draw[->] (addfb.east) -- (K.west) node[above left]{$\epsilon$};
    \draw[->] (K.east) -- (addu.west) node[above left]{$u$};
    \draw[->] (addu.east) -- (G.west);
    \draw[<-] (addu.north) -- ++(0, 0.8) node[below right]{$d$};
    \draw[->] (G.east) -- ++(1.2, 0);
    \draw[->] ($(G.east) + (0.6, 0)$) node[branch]{} node[above]{$y$} -- ++(0, -0.8) -| (addfb.south);
  \end{tikzpicture}
#+end_src

#+name: fig:classical_feedback
#+caption: Classical Feedback Architecture
#+RESULTS:
[[file:figs/classical_feedback.png]]

#+name:       table:notation_conventional
#+caption:    Notations for the Classical Feedback Architecture
| Notation   | Meaning           |
|------------+-------------------|
| $G$        | Plant model       |
| $K$        | Controller        |
| $r$        | Reference inputs  |
| $y$        | Plant outputs     |
| $u$        | Control signals   |
| $d$        | Input Disturbance |
| $\epsilon$ | Tracking Error    |

* From a Classical Feedback Architecture to a Generalized Plant
The procedure is:
1. define signals of the generalized plant
2. Remove $K$ and rearrange the inputs and outputs

#+begin_src latex :file classical_feedback_tracking.pdf
  \begin{tikzpicture}
    \node[addb={+}{}{}{}{-}] (addfb) at (0, 0){};
    \node[block, right=0.8 of addfb] (K){$K(s)$};
    \node[block, right=0.8 of K] (G){$G(s)$};

    \draw[<-] (addfb.west) -- ++(-0.8, 0) node[above right]{$r$};
    \draw[->] (addfb.east) -- (K.west) node[above left]{$\epsilon$};
    \draw[->] (K.east) -- (G.west) node[above left]{$u$};
    \draw[->] (G.east) -- ++(1.2, 0);
    \draw[->] ($(G.east) + (0.6, 0)$) node[branch]{} node[above]{$y$} -- ++(0, -0.8) -| (addfb.south);
  \end{tikzpicture}
#+end_src

#+begin_src latex :file mixed_sensitivity_ref_tracking.pdf
  \begin{tikzpicture}
    \node[block] (G) {$G(s)$};
    \node[addb={+}{-}{}{}{}, right=0.6 of G] (addw) {};
    \coordinate[above right=0.6 and 1.4 of addw] (u);
    \coordinate[above=0.6 of u] (epsilon);

    \coordinate[] (w) at ($(epsilon-|G.west)+(-1.4, 0)$);

    \node[block, below left=0.8 and 0 of addw] (K) {$K(s)$};

    % Connections
    \draw[->] (G.east) -- (addw.west);
    \draw[->] ($(addw.east)+(0.4, 0)$)node[branch]{} |- (epsilon) node[above left](z1){$\epsilon$};
    \draw[->] ($(G.west)+(-0.4, 0)$)node[branch](start){} |- (u) node[above left](z2){$u$};

    \draw[->] (addw.east) -- (addw-|z1) |- node[near start, right]{$v$} (K.east);
    \draw[->] (K.west) -| node[near end, left]{$u$} ($(G-|w)+(0.4, 0)$) -- (G.west);

    \draw[->] (w) node[above]{$w = r$} -| (addw.north);

    \draw [decoration={brace, raise=5pt}, decorate] (z1.north east) -- node[right=6pt]{$z$} (z2.south east);

    \begin{scope}[on background layer]
      \node[fit={(G.south-|start.west) ($(z1.north west)+(-0.4, 0)$)}, inner sep=6pt, draw, dashed, fill=black!20!white] (P) {};
      \node[below right] at (P.north west) {Generalized Plant $P(s)$};
    \end{scope}
  \end{tikzpicture}
#+end_src

#+begin_exampl
  Let's find the Generalized plant of corresponding to the tracking control architecture shown in Figure [[fig:classical_feedback_tracking]]

  #+name: fig:classical_feedback_tracking
  #+caption: Classical Feedback Control Architecture (Tracking)
  [[file:figs/classical_feedback_tracking.png]]

  First, define the signals of the generalized plant:
  - Exogenous inputs: $w = r$
  - Signals to be minimized: $z_1 = \epsilon$, $z_2 = u$
  - Control signals: $v = y$
  - Control inputs: $u$

  Then, Remove $K$ and rearrange the inputs and outputs.
  We obtain the generalized plant shown in Figure [[fig:mixed_sensitivity_ref_tracking]].

  #+name: fig:mixed_sensitivity_ref_tracking
  #+caption: Generalized plant of the Classical Feedback Control Architecture (Tracking)
  [[file:figs/mixed_sensitivity_ref_tracking.png]]

  Using Matlab, the generalized plant can be defined as follows:
  #+begin_src matlab :tangle no :eval no
    P = [1 -G;
         0  1;
         1 -G]
  #+end_src
#+end_exampl

* Modern Interpretation of the Control Specifications
** Introduction

- *Reference tracking* Overshoot, Static error, Setling time
  - $S(s) = T_{r \rightarrow \epsilon}$
- *Disturbances rejection*
  - $G(s) S(s) = T_{d \rightarrow \epsilon}$
- *Measurement noise filtering*
  - $T(s) = T_{n \rightarrow \epsilon}$
- *Small command amplitude*
  - $K(s) S(s) = T_{r \rightarrow u}$
- *Stability*
  - $S(s)$, $T(s)$, $K(s)S(s)$, $G(s)S(s)$
- *Robustness to plant uncertainty* (stability margins)
- *Controller implementation*

**

* Resources

yt:?listType=playlist&list=PLn8PRpmsu08qFLMfgTEzR8DxOPE7fBiin

yt:?listType=playlist&list=PLsjPUqcL7ZIFHCObUU_9xPUImZ203gB4o