diff --git a/content/research/2020-h-infinity-lecture/_index.md b/content/research/2020-h-infinity-lecture/_index.md
new file mode 100644
index 0000000..fd3715f
--- /dev/null
+++ b/content/research/2020-h-infinity-lecture/_index.md
@@ -0,0 +1,2040 @@
++++
+title = "A brief and practical introduction to $\\mathcal{H}_\\infty$ Control"
+author = ["Dehaeze Thomas"]
+draft = false
+year = 2020
+pubtype = "lecture"
+pdf = "https://git.tdehaeze.xyz/tdehaeze/lecture-h-infinity/raw/branch/master/index.pdf"
+video = "https://www.youtube.com/watch?v=KdJsm_X8uks"
+code = "https://git.tdehaeze.xyz/tdehaeze/lecture-h-infinity"
++++
+
+{{< youtube KdJsm_X8uks >}}
+
+
+## Introduction {#introduction}
+
+The purpose of this document is to give a _practical introduction_ to the wonderful world of \\(\mathcal{H}\_\infty\\) Control.
+
+No attend is made to provide an exhaustive treatment of the subject.
+\\(\mathcal{H}\_\infty\\) Control is a very broad topic and entire books are written on it.
+Therefore, for more advanced discussion, please have a look at the recommended references at the bottom of this document.
+
+When possible, Matlab scripts used for the example/exercises are provided such that you can easily test them on your computer.
+
+The general structure of this document is as follows:
+
+- A short introduction to _model based control_ is given in Section
+- Classical _open_ loop shaping method is presented in Section .
+ It is also shown that \\(\mathcal{H}\_\infty\\) synthesis can be used for _open_ loop shaping
+- Important concepts indispensable for \\(\mathcal{H}\_\infty\\) control such as the \\(\mathcal{H}\_\infty\\) norm and the generalized plant are introduced in Section
+- A very important step in \\(\mathcal{H}\_\infty\\) control is to express the control specifications (performances, robustness, etc.) as an \\(\mathcal{H}\_\infty\\) optimization problem. Such procedure is described in Section
+- One of the most useful use of the \\(\mathcal{H}\_\infty\\) control is the shaping of closed-loop transfer functions.
+ Such technique is presented in Section
+- Finally, complete examples of the use of \\(\mathcal{H}\_\infty\\) Control for practical problems are provided in Section
+
+
+## Introduction to Model Based Control {#introduction-to-model-based-control}
+
+
+
+
+### Model Based Control - Methodology {#model-based-control-methodology}
+
+
+
+The typical methodology for **Model Based Control** techniques is schematically shown in Figure [Figure 1](#figure--fig:control-procedure).
+
+It consists of three steps:
+
+1. **Identification or modeling**: a mathematical model \\(G(s)\\) representing the plant dynamics is obtained
+2. **Translate the specifications into mathematical criteria**:
+ - Specifications: Response Time, Noise Rejection, Maximum input amplitude, Robustness, ...
+ - Mathematical Criteria: Cost Function, Shape of transfer function, Phase/Gain margin, Roll-Off, ...
+3. **Synthesis**: research of a controller \\(K(s)\\) that satisfies the specifications for the model of the system
+
+
+
+{{< figure src="figs/control-procedure.png" caption="Figure 1: Typical Methodoly for Model Based Control" >}}
+
+In this document, we will suppose a model of the plant is available (step 1 already performed), and we will focus on steps 2 and 3.
+
+In Section , steps 2 and 3 will be described for a control techniques called **classical (open-)loop shaping**.
+
+Then, steps 2 and 3 for the **\\(\mathcal{H}\_\infty\\) Loop Shaping** of closed-loop transfer functions will be discussed in Sections , and .
+
+
+### From Classical Control to Robust Control {#from-classical-control-to-robust-control}
+
+
+
+Many different model based control techniques have been developed since the birth of _classical control theory_ in the '30s.
+
+**Classical control** methods were developed starting from 1930 based on tools such as the Laplace and Fourier transforms.
+It was then natural to study systems in the frequency domain using tools such as the Bode and Nyquist plots.
+Controllers were manually tuned to optimize criteria such as control bandwidth, gain and phase margins.
+
+The '60s saw the development of control techniques based on a state-space.
+Linear algebra and matrices were used instead of the frequency domain tool of the class control theory.
+This allows multi-inputs multi-outputs systems to be easily treated.
+Kalman introduced the well known _Kalman estimator_ as well the notion of optimality by minimizing quadratic cost functions.
+This set of developments is loosely termed **Modern Control** theory.
+
+By the 1980's, modern control theory was shown to have some robustness issues and to lack the intuitive tools that the classical control methods were offering.
+This led to a new control theory called **Robust control** that blends the best features of classical and modern techniques.
+This robust control theory is the subject of this document.
+
+The three presented control methods are compared in Table [Table 1](#table--tab:comparison-control-methods).
+
+Note that in parallel, there have been numerous other developments, including non-linear control, adaptive control, machine-learning control just to name a few.
+
+
+
+
Table 1:
+ Table summurazing the main differences between classical, modern and robust control
+
+
Table 2:
+ Example system variables
+
+
+Derive the following open-loop transfer functions:
+
+\begin{align}
+ G(s) &= \frac{y}{u} \\\\
+ G\_d(s) &= \frac{y}{d}
+\end{align}
+
+Hint
+
+You can follow this generic procedure:
+
+1. List all applied forces ot the mass: Actuator force, Stiffness force (Hooke's law), ...
+2. Apply the Newton's Second Law on the payload
+ \\[ m \ddot{y} = \Sigma F \\]
+3. Transform the differential equations into the Laplace domain:
+ \\[ \frac{d\ \cdot}{dt} \Leftrightarrow \cdot \times s \\]
+4. Write \\(y(s)\\) as a function of \\(u(s)\\) and \\(w(s)\\)
+
+Results
+
+\begin{align}
+ G(s) &= \frac{1}{m s^2 + cs + k} \\\\
+ G\_d(s) &= \frac{cs + k}{m s^2 + cs + k}
+\end{align}
+
+
+
+Having obtained \\(G(s)\\) and \\(G\_d(s)\\), we can transform the system shown in Figure [Figure 2](#figure--fig:mech-sys-1dof-inertial-contr) into a classical feedback architecture as shown in Figure [Figure 6](#figure--fig:open-loop-shaping).
+
+
+
+{{< figure src="figs/classical_feedback_test_system.png" caption="Figure 3: Block diagram corresponding to the example system of Figure [Figure 2](#figure--fig:mech-sys-1dof-inertial-contr)" >}}
+
+Let's define the system parameters on Matlab.
+
+```matlab { linenos=true, linenostart=1 }
+ k = 1e6; % Stiffness [N/m]
+ c = 4e2; % Damping [N/(m/s)]
+ m = 10; % Mass [kg]
+```
+
+And now the system dynamics \\(G(s)\\) and \\(G\_d(s)\\).
+
+```matlab { linenos=true, linenostart=4 }
+ G = 1/(m*s^2 + c*s + k); % Plant
+ Gd = (c*s + k)/(m*s^2 + c*s + k); % Disturbance
+```
+
+The Bode plots of \\(G(s)\\) and \\(G\_d(s)\\) are shown in Figures [Figure 4](#figure--fig:bode-plot-example-afm) and [Figure 5](#figure--fig:bode-plot-example-Gd).
+
+
+
+{{< figure src="figs/bode_plot_example_afm.png" caption="Figure 4: Bode plot of the plant \\(G(s)\\)" >}}
+
+
+
+{{< figure src="figs/bode_plot_example_Gd.png" caption="Figure 5: Magnitude of the disturbance transfer function \\(G\_d(s)\\)" >}}
+
+
+## Classical Open Loop Shaping {#classical-open-loop-shaping}
+
+
+
+After an introduction to classical Loop Shaping in Section , a practical example is given in Section .
+Such Loop Shaping is usually performed manually with tools coming from the classical control theory.
+
+However, the \\(\mathcal{H}\_\infty\\) synthesis can be used to automate the Loop Shaping process.
+This is presented in Section and applied on the same example in Section .
+
+
+### Introduction to Loop Shaping {#introduction-to-loop-shaping}
+
+
+
+
+
+**Loop Shaping** refers to a control design procedure that involves explicitly shaping the magnitude of the **Loop Transfer Function** \\(L(s)\\).
+
+
+
+
+
+The **Loop Gain** (or Loop transfer function) \\(L(s)\\) usually refers to as the product of the controller and the plant (see Figure [Figure 6](#figure--fig:open-loop-shaping)):
+
+\begin{equation}
+ L(s) = G(s) \cdot K(s)
+\end{equation}
+
+Its name comes from the fact that this is actually the "gain around the loop".
+
+
+
+{{< figure src="figs/open_loop_shaping.png" caption="
Figure 6: Classical Feedback Architecture" >}}
+
+
+
+Let's take our example system described in Section and design a controller using the Open-Loop shaping synthesis approach.
+The specifications are:
+
+1. **Disturbance rejection**: Highest possible rejection below 1Hz
+2. **Positioning speed**: Bandwidth of approximately 10Hz
+3. **Noise attenuation**: Roll-off of -40dB/decade past 30Hz
+4. **Robustness**: Gain margin > 3dB and Phase margin > 30 deg
+
+
+
+
+
+Using `SISOTOOL`, design a controller that fulfills the specifications.
+
+```matlab
+ sisotool(G)
+```
+
+Hint
+
+You can follow this procedure:
+
+1. In order to have good disturbance rejection at low frequency, add a simple or double **integrator**
+2. In terms of the loop gain, the **bandwidth** can be defined at the frequency \\(\omega\_c\\) where \\(|l(j\omega\_c)|\\) first crosses 1 from above.
+ Therefore, adjust the **gain** such that \\(L(j\omega)\\) crosses 1 at around 10Hz
+3. The roll-off at high frequency for noise attenuation should already be good enough.
+ If not, add a **low pass filter**
+4. Add a **Lead** centered around the crossover frequency (10 Hz) and tune it such that sufficient phase margin is added.
+ Verify that the gain margin is good enough.
+
+
+
+Let's say we came up with the following controller.
+
+```matlab
+ K = 14e8 * ... % Gain
+ 1/(s^2) * ... % Double Integrator
+ 1/(1 + s/2/pi/40) * ... % Low Pass Filter
+ (1 + s/(2*pi*10/sqrt(8)))/(1 + s/(2*pi*10*sqrt(8))); % Lead
+```
+
+The bode plot of the Loop Gain is shown in Figure [Figure 8](#figure--fig:loop-gain-manual-afm) and we can verify that we have the wanted stability margins using the `margin` command:
+
+```matlab
+ [Gm, Pm, ~, Wc] = margin(G*K)
+```
+
+| Requirements | Manual Method |
+|---------------------------------|---------------|
+| Gain Margin \\(> 3\\) [dB] | 3.1 |
+| Phase Margin \\(> 30\\) [deg] | 35.4 |
+| Crossover \\(\approx 10\\) [Hz] | 10.1 |
+
+
+
+{{< figure src="figs/loop_gain_manual_afm.png" caption="Figure 8: Bode Plot of the obtained Loop Gain \\(L(s) = G(s) K(s)\\)" >}}
+
+
+### \\(\mathcal{H}\_\infty\\) Loop Shaping Synthesis {#mathcal-h-infty-loop-shaping-synthesis}
+
+
+
+The synthesis of controllers based on the Loop Shaping method can be automated using the \\(\mathcal{H}\_\infty\\) Synthesis.
+
+Using Matlab, it can be easily performed using the `loopsyn` command:
+
+```matlab
+ K = loopsyn(G, Lw);
+```
+
+where:
+
+- `G` is the (LTI) plant
+- `Lw` is the wanted loop shape
+- `K` is the synthesize controller
+
+
+
+Matlab documentation of `loopsyn` ([link](https://www.mathworks.com/help/robust/ref/loopsyn.html)).
+
+
+
+Therefore, by just providing the wanted loop shape and the plant model, the \\(\mathcal{H}\_\infty\\) Loop Shaping synthesis generates a _stabilizing_ controller such that the obtained loop gain \\(L(s)\\) matches the specified one with an accuracy \\(\gamma\\).
+
+Even though we will not go into details and explain how such synthesis is working, an example is provided in the next section.
+
+
+### Example of the \\(\mathcal{H}\_\infty\\) Loop Shaping Synthesis {#example-of-the-mathcal-h-infty-loop-shaping-synthesis}
+
+
+
+To apply the \\(\mathcal{H}\_\infty\\) Loop Shaping Synthesis, the wanted shape of the loop gain should be determined from the specifications.
+This is summarized in Table [Table 3](#table--tab:open-loop-shaping-specifications).
+
+Such shape corresponds to the typical wanted Loop gain Shape shown in Figure [Figure 7](#figure--fig:open-loop-shaping-shape).
+
+
+
+
Table 3:
+ Wanted Loop Shape corresponding to each specification
+
+
+When using the \\(\mathcal{H}\_\infty\\) Synthesis, it is usually recommended to analyze the obtained controller.
+
+This is usually done by breaking down the controller into simple elements such as low pass filters, high pass filters, notches, leads, etc.
+
+
+
+Let's briefly analyze the obtained controller which bode plot is shown in Figure [Figure 10](#figure--fig:open-loop-shaping-hinf-K):
+
+- two integrators are used at low frequency to have the wanted low frequency high gain
+- a lead is added centered with the crossover frequency to increase the phase margin
+- a notch is added at the resonance of the plant to increase the gain margin (this is very typical of \\(\mathcal{H}\_\infty\\) controllers, and can be an issue, more info on that latter)
+
+
+
+{{< figure src="figs/open_loop_shaping_hinf_K.png" caption="Figure 10: Obtained controller \\(K\\) using the open-loop \\(\mathcal{H}\_\infty\\) shaping" >}}
+
+Let's finally compare the obtained stability margins of the \\(\mathcal{H}\_\infty\\) controller and of the manually developed controller in Table [Table 4](#table--tab:open-loop-shaping-compare).
+
+
+
+
Table 4:
+ Comparison of the characteristics obtained with the two methods
+
+
+The \\(\mathcal{H}\_\infty\\) norm of a multi-input multi-output system \\(G(s)\\) is defined as the peak of the maximum singular value of its frequency response
+
+\begin{equation}
+ \\|G(s)\\|\_\infty = \max\_\omega \bar{\sigma}\big( G(j\omega) \big)
+\end{equation}
+
+For a single-input single-output 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}
+
+
+
+
+
+Let's compute the \\(\mathcal{H}\_\infty\\) norm of our test plant \\(G(s)\\) using the `hinfnorm` function:
+
+```matlab
+ hinfnorm(G)
+```
+
+```text
+7.9216e-06
+```
+
+We can see in Figure [Figure 11](#figure--fig:hinfinity-norm-siso-bode) that indeed, the \\(\mathcal{H}\_\infty\\) norm of \\(G(s)\\) does corresponds to the peak value of \\(|G(j\omega)|\\).
+
+
+
+{{< figure src="figs/hinfinity_norm_siso_bode.png" caption="
Figure 11: Example of the \\(\mathcal{H}\_\infty\\) norm of a SISO system" >}}
+
+
+
+The \\(\mathcal{H}\_\infty\\) synthesis is a method that uses an **algorithm** (LMI optimization, Riccati equation) to find a controller that stabilizes the system and that **minimizes** the \\(\mathcal{H}\_\infty\\) norms of defined transfer functions.
+
+
+
+Why optimizing the \\(\mathcal{H}\_\infty\\) norm of transfer functions is a pertinent choice will become clear when we will translate the typical control specifications into the \\(\mathcal{H}\_\infty\\) norm of transfer functions in Section .
+
+
+
+Then applying the \\(\mathcal{H}\_\infty\\) synthesis to a plant, the engineer work usually consists of the following steps:
+
+1. Write the problem as standard \\(\mathcal{H}\_\infty\\) problem using the generalized plant (described in the next section)
+2. Translate the specifications as \\(\mathcal{H}\_\infty\\) norms of transfer functions (Section )
+3. Make the synthesis and analyze the obtained controller
+
+As the \\(\mathcal{H}\_\infty\\) synthesis usually gives very high order controllers, an additional step that reduces the controller order is sometimes required for practical implementation.
+
+
+
+Note that there are many ways to use the \\(\mathcal{H}\_\infty\\) Synthesis:
+
+- Traditional \\(\mathcal{H}\_\infty\\) Synthesis (`hinfsyn` [doc](https://www.mathworks.com/help/robust/ref/hinfsyn.html))
+- Open Loop Shaping \\(\mathcal{H}\_\infty\\) Synthesis (`loopsyn` [doc](https://www.mathworks.com/help/robust/ref/loopsyn.html))
+- Mixed Sensitivity Loop Shaping (`mixsyn` [doc](https://www.mathworks.com/help/robust/ref/lti.mixsyn.html))
+- Fixed-Structure \\(\mathcal{H}\_\infty\\) Synthesis (`hinfstruct` [doc](https://www.mathworks.com/help/robust/ref/lti.hinfstruct.html))
+- Signal Based \\(\mathcal{H}\_\infty\\) Synthesis, and many more...
+
+
+### The Generalized Plant {#the-generalized-plant}
+
+
+
+The first step when applying the \\(\mathcal{H}\_\infty\\) synthesis is usually to write the problem as a standard \\(\mathcal{H}\_\infty\\) problem.
+This consist of deriving the **Generalized Plant** for the current problem.
+
+The generalized plant, usually noted \\(P(s)\\), is shown in Figure [Figure 12](#figure--fig:general-plant).
+It has two _sets_ of inputs \\([w,\\,u]\\) and two _sets_ of outputs \\([z\\,v]\\) such that:
+
+\begin{equation}
+ \begin{bmatrix} z \\\ v \end{bmatrix} = P \begin{bmatrix} w \\\ u \end{bmatrix}
+\end{equation}
+
+The meaning of these inputs and outputs are summarized in Table [Table 5](#table--tab:notation-general).
+
+A practical example about how to derive the generalized plant for a classical control problem is given in Section .
+
+
+
+
+
+{{< figure src="figs/general_plant.png" caption="
Figure 12: Inputs and Outputs of the generalized Plant" >}}
+
+
+
+
Table 5:
+ Notations for the general configuration
+
+
+| **Notation** | **Meaning** |
+|--------------|----------------------------------------------------|
+| \\(P\\) | Generalized plant model |
+| \\(w\\) | Exogenous inputs: references, disturbances, noises |
+| \\(z\\) | Exogenous outputs: signals to be minimized |
+| \\(v\\) | Controller inputs: measurements |
+| \\(u\\) | Control signals |
+
+
+
+\\(\mathcal{H}\_\infty\\) Synthesis applied on the generalized plant
+:
+
+Find a stabilizing controller \\(K\\) that, using the sensed outputs \\(v\\), generates control signals \\(u\\) such that the \\(\mathcal{H}\_\infty\\) norm of the closed-loop transfer function from \\(w\\) to \\(z\\) is minimized.
+
+After \\(K\\) is found, the system is _robustified_ by adjusting the response around the unity gain frequency to increase stability margins.
+
+The obtained controller \\(K\\) and the generalized plant are connected as shown in Figure [Figure 13](#figure--fig:general-control-names).
+
+
+
+{{< figure src="figs/general_control_names.png" caption="
Figure 13: General Control Configuration" >}}
+
+
+
+Consider the feedback control architecture shown in Figure [Figure 14](#figure--fig:classical-feedback-tracking).
+Suppose we want to design \\(K\\) using the general \\(\mathcal{H}\_\infty\\) synthesis, and suppose the signals to be minimized are the control input \\(u\\) and the tracking error \\(\epsilon\\).
+
+1. Convert the control architecture to a generalized configuration
+2. Compute the transfer function matrix of the generalized plant \\(P\\) using Matlab as a function or \\(K\\) and \\(G\\)
+
+
+
+{{< figure src="figs/classical_feedback_tracking.png" caption="
Figure 14: Classical Feedback Control Architecture (Tracking)" >}}
+
+
Hint
+
+First, define the signals of the generalized plant:
+
+- Exogenous inputs: \\(w = r\\)
+- Signals to be minimized:
+ Usually, we want to minimize the tracking errors \\(\epsilon\\) and the control signal \\(u\\): \\(z = [\epsilon,\ u]\\)
+- Controller inputs: this is the signal at the input of the controller: \\(v = \epsilon\\)
+- Controller outputs: signal generated by the controller: \\(u\\)
+
+Then, Remove \\(K\\) and rearrange the inputs and outputs as in Figure [Figure 12](#figure--fig:general-plant).
+
+
+
+
Answer
+
+The obtained generalized plant shown in Figure [Figure 15](#figure--fig:mixed-sensitivity-ref-tracking).
+
+
+
+{{< figure src="figs/mixed_sensitivity_ref_tracking.png" caption="Figure 15: Generalized plant of the Classical Feedback Control Architecture (Tracking)" >}}
+
+Using Matlab, the generalized plant can be defined as follows:
+
+```matlab
+ P = [1 -G;
+ 0 1;
+ 1 -G]
+ P.InputName = {'w', 'u'};
+ P.OutputName = {'e', 'u', 'v'};
+```
+
+
+
+
+
Table 6:
+ Typical Specification and associated closed-loop transfer function
+
+
+For the feedback system in Figure [Figure 16](#figure--fig:gang-of-four-feedback), write the output signals \\([\epsilon, u, y]\\) as a function of the systems \\(K(s), G(s)\\) and the input signals \\([r, d, n]\\).
+
+Hint
+
+Take one of the output (e.g. \\(y\\)), and write it as a function of the inputs \\([d, r, n]\\) going step by step around the loop:
+
+\begin{align\*}
+ y &= G u \\\\
+ &= G (d + K \epsilon) \\\\
+ &= G \big(d + K (r - n - y) \big) \\\\
+ &= G d + GK r - GK n - GK y
+\end{align\*}
+
+Isolate \\(y\\) at the right hand side, and finally obtain:
+\\[ y = \frac{GK}{1+ GK} r + \frac{G}{1 + GK} d - \frac{GK}{1 + GK} n \\]
+
+Do the same procedure for \\(u\\) and \\(\epsilon\\)
+
+Answer
+
+The following equations should be obtained:
+
+\begin{align}
+ y &= \frac{GK}{1 + GK} r + \frac{G}{1 + GK} d - \frac{GK}{1 + GK} n \\\\
+ \epsilon &= \frac{1 }{1 + GK} r - \frac{G}{1 + GK} d - \frac{G }{1 + GK} n \\\\
+ u &= \frac{K }{1 + GK} r - \frac{1}{1 + GK} d - \frac{K }{1 + GK} n
+\end{align}
+
+
+
+
+
+We can see that they are 4 different closed-loop transfer functions describing the behavior of the feedback system in Figure [Figure 16](#figure--fig:gang-of-four-feedback).
+These called the **Gang of Four**:
+
+\begin{align}
+ S &= \frac{1 }{1 + GK}, \quad \text{the sensitivity function} \\\\
+ T &= \frac{GK}{1 + GK}, \quad \text{the complementary sensitivity function} \\\\
+ GS &= \frac{G }{1 + GK}, \quad \text{the load disturbance sensitivity function} \\\\
+ KS &= \frac{K }{1 + GK}, \quad \text{the noise sensitivity function}
+\end{align}
+
+
+
+
+
+If a feedforward controller is included, a **Gang of Six** transfer functions can be defined.
+More on that in this [short video](https://www.youtube.com/watch?v=b_8v8scghh8).
+
+
+
+The behavior of the feedback system in Figure [Figure 16](#figure--fig:gang-of-four-feedback) is fully described by the following set of equations:
+
+\begin{align}
+ \epsilon &= S r - GS d - GS n \\\\
+ y &= T r + GS d - T n \\\\
+ u &= KS r - S d - KS n
+\end{align}
+
+Thus, for reference tracking, we have to shape the _closed-loop_ transfer function from \\(r\\) to \\(\epsilon\\), that is the sensitivity function \\(S(s)\\).
+Similarly, to reduce the effect of measurement noise \\(n\\) on the output \\(y\\), we have to act on the complementary sensitivity function \\(T(s)\\).
+
+
+### The Sensitivity Function {#the-sensitivity-function}
+
+
+
+The sensitivity function is indisputably the most important closed-loop transfer function of a feedback system.
+In this section, we will see how the shape of the sensitivity function will impact the performances of the closed-loop system.
+
+Suppose we have developed a "_reference_" controller \\(K\_r(s)\\) and made three small changes to obtained three controllers \\(K\_1(s)\\), \\(K\_2(s)\\) and \\(K\_3(s)\\).
+The obtained sensitivity functions for these four controllers are shown in Figure [Figure 17](#figure--fig:sensitivity-shape-effect) and the corresponding step responses are shown in Figure [Figure 18](#figure--fig:sensitivity-shape-effect-step).
+
+The comparison of the sensitivity functions shapes and their effect on the step response is summarized in Table [Table 7](#table--tab:compare-sensitivity-shapes).
+
+
+
+
Table 7:
+ Comparison of the sensitivity function shape and the corresponding step response for the three controller variations
+
+
+Closed-Loop Bandwidth
+: The closed-loop bandwidth \\(\omega\_b\\) is the frequency where \\(|S(j\omega)|\\) first crosses \\(1/\sqrt{2} = -3dB\\) from below.
+
+ In general, a large bandwidth corresponds to a faster rise time.
+
+
+
+
+
+From the simple analysis above, we can draw a first estimation of the wanted shape for the sensitivity function (Figure [Figure 19](#figure--fig:h-infinity-spec-S)):
+
+- A small magnitude at low frequency to make the static errors small
+- A wanted minimum closed-loop bandwidth in order to have fast rise time and good rejection of perturbations
+- A small peak value (small \\(\mathcal{H}\_\infty\\) norm) in order to limit large overshoot and oscillations.
+ This generally means higher robustness.
+ This will become clear in the next section about the **module margin**.
+
+
+
+{{< figure src="figs/h-infinity-spec-S.png" caption="
Figure 19: Typical wanted shape of the Sensitivity transfer function" >}}
+
+
+
+Consider the following plant \\(G\_t(s)\\):
+
+```matlab
+ w0 = 2*pi*100;
+ xi = 0.1;
+ k = 1e7;
+
+ Gt = 1/k*(s/w0/4 + 1)/(s^2/w0^2 + 2*xi*s/w0 + 1);
+```
+
+Let's say we have designed a controller \\(K\_t(s)\\) that gives the loop gain shown in Figure [Figure 20](#figure--fig:phase-gain-margin-model-plant).
+
+```matlab
+ Kt = 1.2e6*(s + w0)/s;
+```
+
+The following characteristics can be determined from the Loop gain in Figure [Figure 20](#figure--fig:phase-gain-margin-model-plant):
+
+- Control bandwidth of \\(\approx 10\\, \text{Hz}\\)
+- Infinite gain margin (the phase of the loop-gain never reaches \\(-180^o\\))
+- More than \\(90^o\\) of phase margin
+
+This clearly indicate very good robustness of the closed-loop system!
+Or does it? Let's find out.
+
+
+
+{{< figure src="figs/phase_gain_margin_model_plant.png" caption="
Figure 20: Bode plot of the obtained Loop Gain \\(L(s)\\)" >}}
+
+Now let's suppose the controller is implemented in practice, and the "real" plant \\(G\_r(s)\\) as a slightly lower damping factor than the one estimated for the model:
+
+```matlab
+ xi = 0.03;
+```
+
+The obtained "real" loop gain is shown in Figure [Figure 21](#figure--fig:phase-gain-margin-real-plant).
+At a frequency little bit above 100Hz, the phase of the loop gain reaches -180 degrees while its magnitude is more than one which indicates instability.
+
+It is confirmed by checking the stability of the closed loop system:
+
+```matlab
+ isstable(feedback(Gr,K))
+```
+
+```text
+0
+```
+
+
+
+{{< figure src="figs/phase_gain_margin_real_plant.png" caption="
Figure 21: Bode plots of \\(L(s)\\) (loop gain corresponding the nominal plant) and \\(L\_r(s)\\) (loop gain corresponding to the real plant)" >}}
+
+Therefore, even a small change of the plant parameter renders the system unstable even though both the gain margin and the phase margin for the nominal plant are excellent.
+
+This is due to the fact that the gain and phase margin are robustness indicators corresponding a **pure** change or gain or a **pure** change of phase but not a combination of both.
+
+
+
+Nyquist Stability Criteria (for stable systems)
+: If the open-loop transfer function \\(L(s)\\) is stable, then the closed-loop system will be unstable for any encirclement of the point \\(-1\\) on the Nyquist plot.
+
+
+Nyquist Plot
+: The Nyquist plot shows the evolution of \\(L(j\omega)\\) in the complex plane from \\(\omega = 0 \to \infty\\).
+
+
+
+
+
+For more information about the _general_ Nyquist Stability Criteria, you may want to look at [this](https://www.youtube.com/watch?v=sof3meN96MA) video.
+
+
+
+From the Nyquist stability criteria, it is clear that we want \\(L(j\omega)\\) to be as far as possible from the \\(-1\\) point (called the _unstable point_) in the complex plane.
+This minimum distance is called the **module margin**.
+
+
+
+Module Margin
+: The Module Margin \\(\Delta M\\) is defined as the **minimum distance** between the point \\(-1\\) and the loop gain \\(L(j\omega)\\) in the complex plane.
+
+
+
+
+
+A typical Nyquist plot is shown in Figure [Figure 22](#figure--fig:module-margin-example).
+The gain, phase and module margins are graphically shown to have an idea of what they represent.
+
+
+
+{{< figure src="figs/module_margin_example.png" caption="
Figure 22: Nyquist plot with visual indication of the Gain margin \\(\Delta G\\), Phase margin \\(\Delta \phi\\) and Module margin \\(\Delta M\\)" >}}
+
+
+
+The \\(\mathcal{H}\_\infty\\) norm of the sensitivity function \\(\\|S\\|\_\infty\\) is a measure of the Module margin \\(\Delta M\\) and therefore an indicator of the system robustness.
+
+\begin{equation}
+ \Delta M = \frac{1}{\\|S\\|\_\infty} \label{eq:module\_margin\_S}
+\end{equation}
+
+The wanted robustness of the closed-loop system can be specified by setting a maximum value on \\(\\|S\\|\_\infty\\).
+
+
+
+Note that this is why large peak value of \\(|S(j\omega)|\\) usually indicate robustness problems.
+And we now understand why setting an upper bound on the magnitude of \\(S\\) is generally a good idea.
+
+
+
+Typical, we require \\(\\|S\\|\_\infty < 2 (6dB)\\) which implies \\(\Delta G \ge 2\\) and \\(\Delta \phi \ge 29^o\\)
+
+
+
+
+
+To learn more about module/disk margin, you can check out [this](https://www.youtube.com/watch?v=XazdN6eZF80) video.
+
+
+
+
+### Summary of typical specification and associated wanted shaping {#summary-of-typical-specification-and-associated-wanted-shaping}
+
+
+
+
+
+
Table 8:
+ Typical Specifications and corresponding wanted norms of open and closed loop tansfer functions
+
+
+The _trick_ is to include a **weighting function** \\(W\_S(s)\\) in the generalized plant as shown in Figure [Figure 24](#figure--fig:loop-shaping-S-with-W).
+
+Now, the closed-loop transfer function from \\(w\\) to \\(z\\) is equal to \\(W\_s(s)S(s)\\) and applying the \\(\mathcal{H}\_\infty\\) synthesis to the _weighted_ generalized plant \\(\tilde{P}(s)\\) will generate a controller \\(K(s)\\) such that \\(\\|W\_s(s)S(s)\\|\_\infty\\) is minimized.
+
+
+
+Let's now show how this is equivalent as **shaping** the sensitivity function:
+
+\begin{align}
+ & \left\\| W\_s(s) S(s) \right\\|\_\infty < 1\nonumber \\\\
+ \Leftrightarrow & \left| W\_s(j\omega) S(j\omega) \right| < 1 \quad \forall \omega\nonumber \\\\
+ \Leftrightarrow & \left| S(j\omega) \right| < \frac{1}{\left| W\_s(j\omega) \right|} \quad \forall \omega
+\end{align}
+
+
+
+As shown in Equation , the objective of the \\(\mathcal{H}\_\infty\\) synthesis applied on the _weighted_ plant is to make the norm sensitivity function smaller than the inverse of the norm of the weighting function, and that at all frequencies.
+
+Therefore, the choice of the weighting function \\(W\_s(s)\\) is very important: its inverse magnitude will define the wanted **upper bound** of the sensitivity function magnitude over all frequencies.
+
+
+
+
+
+{{< figure src="figs/loop_shaping_S_with_W.png" caption="Figure 24: Weighted Generalized Plant" >}}
+
+
+
+Using matlab, compute the weighted generalized plant shown in Figure [Figure 25](#figure--fig:first-order-weight) as a function of \\(G(s)\\) and \\(W\_S(s)\\).
+
+Hint
+
+The weighted generalized plant can be defined in Matlab using two techniques:
+
+- by writing manually the 4 transfer functions from \\([w, u]\\) to \\([\tilde{\epsilon}, v]\\)
+- by pre-multiplying the (non-weighted) generalized plant by a block-diagonal transfer function matrix containing the weights for the outputs \\(z\\) and `1` for the outputs \\(v\\)
+
+Answer
+
+The two solutions below can be used.
+
+```matlab
+ Pw = [Ws -Ws*G;
+ 1 -G];
+```
+
+The second solution is however more general, and can also be used when weights are added at the inputs by post-multiplying instead of pre-multiplying.
+
+```matlab
+ P = [1 -G;
+ 1 -G];
+ Pw = blkdiag(Ws, 1)*P;
+```
+
+
+
+
+### Design of Weighting Functions {#design-of-weighting-functions}
+
+
+
+Weighting function included in the generalized plant must be **proper**, **stable** and **minimum phase** transfer functions.
+
+
+
+proper
+: more poles than zeros, this implies \\(\lim\_{\omega \to \infty} |W(j\omega)| < \infty\\)
+
+stable
+: no poles in the right half plane
+
+minimum phase
+: no zeros in the right half plane
+
+
+
+Good guidelines for design of weighting function are given in (Bibel and Malyevac 1992).
+
+There is a Matlab function called `makeweight` that allows to design first-order weights by specifying the low frequency gain, high frequency gain, and the gain at a specific frequency:
+
+```matlab
+ W = makeweight(dcgain,[freq,mag],hfgain)
+```
+
+with:
+
+- `dcgain`: low frequency gain
+- `[freq,mag]`: frequency `freq` at which the gain is `mag`
+- `hfgain`: high frequency gain
+
+
+
+The Matlab code below produces a weighting function with the following characteristics (Figure [Figure 25](#figure--fig:first-order-weight)):
+
+- Low frequency gain of 100
+- Gain of 1 at 10Hz
+- High frequency gain of 0.5
+
+
+
+```matlab
+ Ws = makeweight(1e2, [2*pi*10, 1], 1/2);
+```
+
+
+
+{{< figure src="figs/first_order_weight.png" caption="
Figure 25: Obtained Magnitude of the Weighting Function" >}}
+
+
+
+Quite often, higher orders weights are required.
+
+In such case, the following formula can be used:
+
+\begin{equation}
+ W(s) = \left( \frac{
+ \frac{1}{\omega\_0} \sqrt{\frac{1 - \left(\frac{G\_0}{G\_c}\right)^{\frac{2}{n}}}{1 - \left(\frac{G\_c}{G\_\infty}\right)^{\frac{2}{n}}}} s + \left(\frac{G\_0}{G\_c}\right)^{\frac{1}{n}}
+ }{
+ \left(\frac{1}{G\_\infty}\right)^{\frac{1}{n}} \frac{1}{\omega\_0} \sqrt{\frac{1 - \left(\frac{G\_0}{G\_c}\right)^{\frac{2}{n}}}{1 - \left(\frac{G\_c}{G\_\infty}\right)^{\frac{2}{n}}}} s + \left(\frac{1}{G\_c}\right)^{\frac{1}{n}}
+ }\right)^n
+\end{equation}
+
+The parameters permit to specify:
+
+- the low frequency gain: \\(G\_0 = lim\_{\omega \to 0} |W(j\omega)|\\)
+- the high frequency gain: \\(G\_\infty = lim\_{\omega \to \infty} |W(j\omega)|\\)
+- the absolute gain at \\(\omega\_0\\): \\(G\_c = |W(j\omega\_0)|\\)
+- the absolute slope between high and low frequency: \\(n\\)
+
+A Matlab function implementing Equation is shown below:
+
+```matlab
+ function [W] = generateWeight(args)
+ arguments
+ args.G0 (1,1) double {mustBeNumeric, mustBePositive} = 0.1
+ args.G1 (1,1) double {mustBeNumeric, mustBePositive} = 10
+ args.Gc (1,1) double {mustBeNumeric, mustBePositive} = 1
+ args.wc (1,1) double {mustBeNumeric, mustBePositive} = 2*pi
+ args.n (1,1) double {mustBeInteger, mustBePositive} = 1
+ end
+
+ if (args.Gc <= args.G0 && args.Gc <= args.G1) || (args.Gc >= args.G0 && args.Gc >= args.G1)
+ eid = 'value:range';
+ msg = 'Gc must be between G0 and G1';
+ throwAsCaller(MException(eid,msg))
+ end
+
+ s = zpk('s');
+
+ W = (((1/args.wc) * sqrt((1-(args.G0/args.Gc)^(2/args.n))/(1-(args.Gc/args.G1)^(2/args.n)))*s + (args.G0/args.Gc)^(1/args.n)) / ((1/args.G1)^(1/args.n) * (1/args.wc) * sqrt((1-(args.G0/args.Gc)^(2/args.n))/(1-(args.Gc/args.G1)^(2/args.n)))*s + (1/args.Gc)^(1/args.n)))^args.n;
+
+ end
+```
+
+Let's use this function to generate three weights with the same high and low frequency gains, but but different slopes.
+
+```matlab
+ W1 = generateWeight('G0', 1e2, 'G1', 1/2, 'Gc', 1, 'wc', 2*pi*10, 'n', 1);
+ W2 = generateWeight('G0', 1e2, 'G1', 1/2, 'Gc', 1, 'wc', 2*pi*10, 'n', 2);
+ W3 = generateWeight('G0', 1e2, 'G1', 1/2, 'Gc', 1, 'wc', 2*pi*10, 'n', 3);
+```
+
+The obtained shapes are shown in Figure [Figure 26](#figure--fig:high-order-weight).
+
+
+
+{{< figure src="figs/high_order_weight.png" caption="
Figure 26: Higher order weights using Equation " >}}
+
+
+
+Translate the requirements as upper bounds on the Sensitivity function and design the corresponding weighting functions using Matlab.
+
+
Hint
+
+The typical wanted upper bound of the sensitivity function is shown in Figure [Figure 27](#figure--fig:h-infinity-spec-S-bis).
+
+More precisely:
+
+1. Recall that the closed-loop bandwidth is defined as the frequency \\(|S(j\omega)|\\) first crosses \\(1/\sqrt{2} = -3dB\\) from below
+2. For the small static error, -60dB is usually enough as other factors (measurement noise, disturbances) will anyhow limit the performances
+3. Recall that the module margin is equal to the inverse of the \\(\mathcal{H}\_\infty\\) norm of the sensitivity function:
+ \\[ \Delta M = \frac{1}{\\|S\\|\_\infty} \\]
+
+Remember that the wanted upper bound of the sensitivity function is defined by the **inverse** magnitude of the weight.
+
+
+
+{{< figure src="figs/h-infinity-spec-S.png" caption="Figure 27: Typical wanted shape of the Sensitivity transfer function" >}}
+
+
+
+
Answer
+
+We want to design the weighting function \\(W\_s(s)\\) such that:
+
+1. \\(|W\_s(j \cdot 2 \pi 10)| = \sqrt{2}\\)
+2. \\(|W\_s(j \cdot 0)| = 10^3\\)
+3. \\(\\|W\_s\\|\_\infty = 0.5\\)
+
+Using Matlab, such weighting function can be generated using the `makeweight` function as shown below:
+
+```matlab
+ Ws = makeweight(1e3, [2*pi*10, sqrt(2)], 1/2);
+```
+
+Or using the `generateWeight` function:
+
+```matlab
+ Ws = generateWeight('G0', 1e3, ...
+ 'G1', 1/2, ...
+ 'Gc', sqrt(2), 'wc', 2*pi*10, ...
+ 'n', 2);
+```
+
+
+
+
+
+Obtaining \\(\gamma < 1\\) means that the \\(\mathcal{H}\_\infty\\) synthesis found a controller such that the specified closed-loop transfer functions are bellow the specified upper bounds.
+
+Yet, obtaining a \\(\gamma\\) slightly above one does not necessary means the synthesis is unsuccessful.
+It just means that at some frequency, one of the closed-loop transfer functions is above the specified upper bound by a factor \\(\gamma\\).
+
+
+
+
+
+{{< figure src="figs/results_sensitivity_hinf.png" caption="Figure 28: Weighting function and obtained closed-loop sensitivity" >}}
+
+
+### Shaping multiple closed-loop transfer functions - Limitations {#shaping-multiple-closed-loop-transfer-functions-limitations}
+
+
+
+As was shown in Section , each of the four main closed-loop transfer functions (called the _gang of four_) will impact different characteristics of the closed-loop system.
+This is summarized in Table [Table 9](#table--tab:usual-shaping-gang-four).
+
+Therefore, we might want to shape multiple closed-loop transfer functions at the same time.
+For instance \\(S\\) could be shape to have good step responses, \\(KS\\) to limit the input usage and \\(T\\) to filter measurement noise.
+When multiple closed-loop transfer function are shaped at the same time, it is refereed to as **Mixed-Sensitivity \\(\mathcal{H}\_\infty\\) Control** and is the subject of Section .
+
+
+
+
Table 9:
+ Typical specifications and corresponding shaping of the
Gang of four
+
Shaping of S and KS
+
+
+
+{{< figure src="figs/general_conf_shaping_S_KS.png" caption="Figure 29: Generalized Plant to shape \\(S\\) and \\(KS\\)" >}}
+
+Weighting functions:
+
+- \\(W\_1(s)\\) is used to shape \\(S\\)
+- \\(W\_2(s)\\) is used to shape \\(KS\\)
+
+
+
+```matlab
+ P = [1 -G
+ 0 1
+ 1 -G];
+ Pw = blkdiag(W1, W2, 1)*P;
+```
+
+Shaping of S and T
+
+
+
+{{< figure src="figs/general_conf_shaping_S_T.png" caption="Figure 30: Generalized Plant to shape \\(S\\) and \\(T\\)" >}}
+
+Weighting functions:
+
+- \\(W\_1\\) is used to shape \\(S\\)
+- \\(W\_2\\) is used to shape \\(T\\)
+
+
+
+```matlab
+ P = [1 -G
+ 0 G
+ 1 -G];
+ Pw = blkdiag(W1, W2, 1)*P;
+```
+
+Shaping of S and GS
+
+
+
+{{< figure src="figs/general_conf_shaping_S_GS.png" caption="Figure 31: Generalized Plant to shape \\(S\\) and \\(GS\\)" >}}
+
+Weighting functions:
+
+- \\(W\_1\\) is used to shape \\(S\\)
+- \\(W\_2\\) is used to shape \\(GS\\)
+
+
+
+```matlab
+ P = [1 -1
+ G -G
+ G -G];
+ Pw = blkdiag(W1, W2, 1)*P;
+```
+
+Shaping of S, T and KS
+
+
+
+{{< figure src="figs/general_conf_shaping_S_T_KS.png" caption="Figure 32: Generalized Plant to shape \\(S\\), \\(T\\) and \\(KS\\)" >}}
+
+Weighting functions:
+
+- \\(W\_1\\) is used to shape \\(S\\)
+- \\(W\_2\\) is used to shape \\(KS\\)
+- \\(W\_3\\) is used to shape \\(T\\)
+
+
+
+```matlab
+ P = [1 -G
+ 0 1
+ 0 G
+ 1 -G];
+ Pw = blkdiag(W1, W2, W3, 1)*P;
+```
+
+Shaping of S, T and GS
+
+
+
+{{< figure src="figs/general_conf_shaping_S_T_GS.png" caption="Figure 33: Generalized Plant to shape \\(S\\), \\(T\\) and \\(GS\\)" >}}
+
+Weighting functions:
+
+- \\(W\_1\\) is used to shape \\(S\\)
+- \\(W\_2\\) is used to shape \\(GS\\)
+- \\(W\_3\\) is used to shape \\(T\\)
+
+
+
+```matlab
+ P = [1 -1
+ G -G
+ 0 1
+ G -G];
+ Pw = blkdiag(W1, W2, W3, 1)*P;
+```
+
+Shaping of S, T, KS and GS
+
+
+
+{{< figure src="figs/general_conf_shaping_S_T_KS_GS.png" caption="Figure 34: Generalized Plant to shape \\(S\\), \\(T\\), \\(KS\\) and \\(GS\\)" >}}
+
+Weighting functions:
+
+- \\(W\_1\\) is used to shape \\(S\\)
+- \\(W\_2\\) is used to shape \\(KS\\)
+- \\(W\_1W\_3\\) is used to shape \\(GS\\)
+- \\(W\_2W\_3\\) is used to shape \\(T\\)
+
+
+
+```matlab
+ P = [ 1 -G -G
+ 0 0 1
+ 1 -G -G];
+ Pw = blkdiag(W1, W2, 1)*P*blkdiag(1, W3, 1);
+```
+
+
+
+When shaping multiple closed-loop transfer functions, one should be very careful about the three following points that are further discussed:
+
+- The shaped closed-loop transfer functions are linked by mathematical relations and cannot be shaped independently
+- Closed-loop transfer function can only be shaped in certain frequency range
+- The size of the obtained controller may be very large and not implementable in practice
+
+
+
+
+
+Mathematical relations are linking the closed-loop transfer functions.
+For instance, the sensitivity function \\(S(s)\\) and the complementary sensitivity function \\(T(s)\\) are linked by the following well known relation:
+
+\begin{equation}
+ S(s) + T(s) = 1
+\end{equation}
+
+This means that \\(|S(j\omega)|\\) and \\(|T(j\omega)|\\) cannot be made small at the same time!
+
+It is therefore **not** possible to shape the four closed-loop transfer functions independently.
+The weighting function should be carefully design such as these fundamental relations are not violated.
+
+
+
+For practical control systems, above some frequency (the control bandwidth), the loop gain is much smaller than 1.
+On the other size, there is a frequency range where the loop gain is much larger than 1, this frequency range is called the bandwidth.
+Let's see what does that means for the closed-loop transfer function.
+First, take the case of the sensibility function:
+
+\begin{align\*}
+ &|G(j\omega) K(j\omega)| \ll 1 \Longrightarrow |S(j\omega)| = \frac{1}{1 + |G(j\omega)K(j\omega)|} \approx 1 \\\\
+ &|G(j\omega) K(j\omega)| \gg 1 \Longrightarrow |S(j\omega)| = \frac{1}{1 + |G(j\omega)K(j\omega)|} \approx \frac{1}{|G(j\omega)K(j\omega)|}
+\end{align\*}
+
+This means that the Sensitivity function cannot be shaped at frequencies where the loop gain is small.
+
+Similar relationship can be found for \\(T\\), \\(KS\\) and \\(GS\\).
+
+
+
+Determine the approximate norms of \\(T\\), \\(KS\\) and \\(GS\\) for large loop gains (\\(|G(j\omega) K(j\omega)| \gg 1\\)) and small loop gains (\\(|G(j\omega) K(j\omega)| \ll 1\\)).
+
+Hint
+
+You can follows this procedure for \\(T\\), \\(KS\\) and \\(GS\\):
+
+1. Write the closed-loop transfer function as a function of \\(K(s)\\) and \\(G(s)\\)
+2. Take \\(|K(j\omega)G(j\omega)| \gg 1\\) and conclude on the norm of the closed-loop transfer function
+3. Take \\(|K(j\omega)G(j\omega)| \ll 1\\) and conclude
+
+Answer
+
+The obtained constrains are shown in Figure [Figure 35](#figure--fig:h-infinity-4-blocs-constrains).
+
+
+
+Depending on the frequency band, the norms of the closed-loop transfer functions are a function of the controller \\(K\\) and therefore can be shaped.
+However, in some frequency band, the norms do not depend on the controller and therefore **cannot** be shaped.
+
+Therefore the weighting functions should only focus on certainty frequency range depending on the transfer function being shaped.
+These regions are summarized in Figure [Figure 35](#figure--fig:h-infinity-4-blocs-constrains).
+
+
+
+{{< figure src="figs/h-infinity-4-blocs-constrains.png" caption="Figure 35: Shaping the Gang of Four. Blue regions indicate that the transfer function can be shaped using \\(K\\). Red regions indicate this is not the case" >}}
+
+
+
+The order (e.g. number of state) of the controller given by the \\(\mathcal{H}\_\infty\\) synthesis is equal to the order (e.g. number of state) of the weighted generalized plant.
+It is thus equal to the **sum** of the number of state of the non-weighted generalized plant and the number of state of all the weighting functions.
+Then, the \\(\mathcal{H}\_\infty\\) synthesis usually generate a controller with a very high order that is not implementable in practice.
+
+Two approaches can be used to obtain controllers with reasonable order:
+
+1. use simple weights (usually first order)
+2. perform a model reduction on the obtained high order controller
+
+
+
+
+## Mixed-Sensitivity \\(\mathcal{H}\_\infty\\) Control - Example {#mixed-sensitivity-mathcal-h-infty-control-example}
+
+
+
+Let's now apply the \\(\mathcal{H}\_\infty\\) Shaping control procedure on a practical example.
+
+In Section the control problem is presented.
+The design procedure used to apply the \\(\mathcal{H}\_\infty\\) Mixed Sensitivity synthesis is described in Section .
+
+The important step of interpreting the specifications as wanted shape of closed-loop transfer functions is performed in Section .
+
+Finally, the shaping of closed-loop transfer functions is performed in Sections , and .
+
+
+### Control Problem {#control-problem}
+
+
+
+Let's consider our usual _test system_ shown in Figure [Figure 36](#figure--fig:ex-test-system).
+
+
+
+{{< figure src="figs/ex_test_system.png" caption="Figure 36: Test System consisting of a payload with a mass \\(m\\) on top of an active system with a stiffness \\(k\\), damping \\(c\\) and an actuator. A feedback controller \\(K(s)\\) is added to position / isolate the payload." >}}
+
+
+
+The control specifications are:
+
+- The displacement \\(y\\) should follow reference inputs \\(r\\) with negligible static error after 0.1s
+- Reject disturbances \\(d\\) in less than 0.1s
+- Limit the effect of measurement noise \\(n\\) on the output displacement \\(y\\)
+- Obtain a Robust System with good stability margins
+
+
+
+The considered inputs are:
+
+- disturbances \\(d\\) as step inputs with an amplitude of \\(5\\,\mu m\\)
+- reference inputs with are ramp inputs with a slope of \\(100\\,\mu m/s\\) and a time duration of \\(0.2\\,s\\)
+- measurement noise \\(n\\) with a large spectral density at high frequency (increasing starting from 100Hz)
+
+
+### Control Design Procedure {#control-design-procedure}
+
+
+
+Here is the general design procedure that will be followed:
+
+1. Compute the model of the plant
+2. Write the control system as a general control problem
+3. Translate the specifications into the wanted shape of closed-loop transfer functions
+4. Chose the suitable weighted general plant to shape the wanted quantities
+5. Shape sequentially the chosen closed-loop transfer functions
+
+Let's first convert the system of Figure [Figure 36](#figure--fig:ex-test-system) into the classical feedback architecture of Figure [Figure 37](#figure--fig:classical-feedback-test-system-bis).
+
+
+
+{{< figure src="figs/ex_test_system_feedback.png" caption="Figure 37: Block diagram corresponding to the example system" >}}
+
+The two transfer functions present in the system are derived and defined below:
+
+```matlab { linenos=true, linenostart=1 }
+ k = 1e6; % Stiffness [N/m]
+ c = 4e2; % Damping [N/(m/s)]
+ m = 10; % Mass [kg]
+
+ % Control Plant
+ G = 1/(m*s^2 + c*s + k);
+ % Disturbance dynamics
+ Gd = (c*s + k)/(m*s^2 + c*s + k);
+```
+
+We also define the inputs signals that will be used for time domain simulations.
+They are graphically shown in Figure [Figure 38](#figure--fig:ex-inputs-signals).
+
+```matlab { linenos=true, linenostart=9 }
+ % Time Vector
+ t = 0:1e-4:0.5;
+
+ % Reference Input
+ r = zeros(size(t));
+ r(t>0.05 & t<=0.25) = 1e-4*(t(t>0.05 & t<=0.25)-0.05);
+ r(t>0.25) = 2e-5;
+
+ % Measurement Noise
+ Fs = 1e3; % Sampling Frequency [Hz]
+ Ts = 1/Fs; % Sampling Time [s]
+ n = sqrt(Fs/2)*randn(1, length(t)); % Signal with an ASD equal to one
+ n = lsim(1e-6*(s + 2*pi*1e2)^2/(s + 2*pi*1e3)^2/(1+s/2/pi/500), n, t)'; % Shaped noise
+
+ % Disturbance
+ d = zeros(size(t));
+ d(t>0.3) = 5e-6;
+```
+
+
+
+{{< figure src="figs/ex_inputs_signals.png" caption="Figure 38: Time domain inputs signals" >}}
+
+We also define the generalized plant corresponding to the system and that will be used for time domain simulations (Figure [Figure 39](#figure--fig:ex-general-plant-sim)).
+
+
+
+{{< figure src="figs/ex_general_plant_sim.png" caption="Figure 39: Generalized plant that will be used for simulations" >}}
+
+The Generalized plant of Figure [Figure 39](#figure--fig:ex-general-plant-sim) is defined on Matlab as follows:
+
+```matlab { linenos=true, linenostart=26 }
+ Psim = [0 0 Gd G
+ 0 0 0 1
+ 1 -1 -Gd -G];
+
+ Psim.InputName = {'r', 'n', 'd', 'u'};
+ Psim.OutputName = {'y', 'u', 'e'};
+```
+
+Time domain simulations will be performed by first computing the closed-loop system using the `lft` command and then using the `lsim` command on the closed-loop system:
+
+```matlab { linenos=true, linenostart=32 }
+ % Compute the closed-Loop System, K is the controller
+ P_CL = lft(Psim, K);
+
+ % Time simulation of the closed-loop system with specified inputs
+ z = lsim(P_CL, [r; n; d], t);
+ % The two outputs are
+ y = z(:,1); % Output Motion [m]
+ u = z(:,2); % Input usage [N]
+```
+
+
+### Modern Interpretation of control specifications {#modern-interpretation-of-control-specifications}
+
+
+
+
+
+1. Translate the control specifications into wanted shape of closed-loop transfer functions
+2. Conclude and the closed-loop transfer functions to be shaped
+3. Chose a general configuration architecture that allows to shape these transfer function
+4. Using Matlab, define the generalized plant
+
+Hint
+
+1. Make use of Table [Table 9](#table--tab:usual-shaping-gang-four)
+2. Make use of Table [Table 9](#table--tab:usual-shaping-gang-four)
+3. See Section
+4. See Section
+
+
+
+After converting the control specifications into wanted shape of closed-loop transfer functions, we might come up with the Table [Table 10](#table--tab:ex-specification-shapes).
+
+In such case, we want to shape \\(S\\), \\(GS\\) and \\(T\\).
+
+
+
+
Table 10:
+ Control Specifications and associated wanted shape of the closed-loop transfer functions
+
+
Bibel, John E, and D Stephen Malyevac. 1992. “Guidelines for the Selection of Weighting Functions for H-Infinity Control.” NAVAL SURFACE WARFARE CENTER DAHLGREN DIV VA.
+
Duc, G, and S Font. 1999.
Commande H Infinie et Mu-Analyse-Des Outils Pour La Robustesse.
Hermes., Paris: Hermes. Lavoisier.
+
Lurie, Boris J., Ali Ghavimi, Fred Y. Hadaegh, and Edward Mettler. 2002. “System Architecture Trades Using Bode-Step Control Design.”
Journal of Guidance, Control, and Dynamics 25 (2): 309–15. doi:
10.2514/2.4883.
+
Skogestad, Sigurd, and Ian Postlethwaite. 2007.
Multivariable Feedback Control: Analysis and Design. John Wiley.
+
{{ .Content }}
diff --git a/layouts/research/section.html b/layouts/research/section.html
index b69ca3d..2df5f92 100644
--- a/layouts/research/section.html
+++ b/layouts/research/section.html
@@ -13,6 +13,7 @@
(dict "type" "phdthesis" "label" "PhD Theses" "prefix" "T")
(dict "type" "journal" "label" "Journal Articles" "prefix" "J")
(dict "type" "conference" "label" "Conference Publications" "prefix" "C")
+ (dict "type" "lecture" "label" "Lectures" "prefix" "L")
-}}
{{- range $groups -}}