Re-worked section 5

index.org

@@ -1103,30 +1103,36 @@ The procedure to convert a typical control architecture as the one shown in Figu
 
 ** Introduction                                                      :ignore:
 
-- Section [[sec:closed_loop_tf]]
-- Section [[sec:sensitivity_transfer_functions]]
-- Section [[sec:module_margin]]
-- Section [[sec:other_requirements]]
-
 As shown in Section [[sec:open_loop_shaping]], the loop gain $L(s) = G(s) K(s)$ is a useful and easy tool when manually designing controllers.
 This is mainly due to the fact that $L(s)$ is very easy to shape as it depends /linearly/ on $K(s)$.
 Moreover, important quantities such as the stability margins and the control bandwidth can be estimated from the shape/phase of $L(s)$.
 
-However, the loop gain $L(s)$ does *not* directly give the performances of the closed-loop system, which are determined by the *closed-loop* transfer functions.
+However, the loop gain $L(s)$ does *not* directly give the performances of the closed-loop system.
+As a matter of fact, the behavior of the closed-loop system by the *closed-loop* transfer functions.
+These are derived of a typical feedback architecture functions in Section [[sec:closed_loop_tf]].
 
-If we consider the feedback system shown in Figure [[fig:gang_of_four_feedback]], we can link to the following specifications to closed-loop transfer functions.
-This is summarized in Table [[tab:spec_closed_loop_tf]].
 
-#+name: tab:spec_closed_loop_tf
+The modern interpretation of control specifications then consists of determining the *required shape of the closed-loop transfer functions* such that the system behavior corresponds to the requirements.
-#+caption: Typical Specification and associated closed-loop transfer function
+Once this is done, the $\mathcal{H}_\infty$ synthesis can be used to generate a controller that will *shape* the closed-loop transfer function as specified..
-| Specification                  | Closed-Loop Transfer Function                 |
+This method is presented in Section [[sec:closed-loop-shaping]].
-|--------------------------------+-----------------------------------------------|
+
-| Reference Tracking             | From $r$ to $\epsilon$                        |
+
-| Disturbance Rejection          | From $d$ to $y$                               |
+One of the most important closed-loop transfer function is called the *sensitivity function*.
-| Measurement Noise Filtering    | From $n$ to $y$                               |
+Its link with the closed-loop behavior of the feedback system is studied in Section [[sec:sensitivity_transfer_functions]].
-| Small Command Amplitude        | From $n,r,d$ to $u$                           |
+
-| Stability                      | All closed-loop transfer function             |
+The robustness (stability margins) of the system can also be linked to the shape of the sensitivity function with the use of the *module margin* (Section [[sec:module_margin]]).
-| Robustness (stability margins) | Module margin (see Section [[sec:module_margin]]) |
+
+Links between typical control specifications and shapes of the closed-loop transfer functions are summarized in Section [[sec:other_requirements]].
+
+** Closed Loop Transfer Functions and the Gang of Four
+<<sec:closed_loop_tf>>
+
+Consider the typical feedback system shown in Figure [[fig:gang_of_four_feedback]].
+
+The behavior (performances) of this feedback system is determined by the closed-loop transfer functions from the inputs ($r$, $d$ and $n$) to the important signals such as $\epsilon$, $u$ and $y$.
+
+Depending on the specification, different closed-loop transfer functions do matter.
+These are summarized in Table [[tab:spec_closed_loop_tf]].
 
 #+begin_src latex :file gang_of_four_feedback.pdf
   \begin{tikzpicture}
@@ -1149,17 +1155,23 @@ This is summarized in Table [[tab:spec_closed_loop_tf]].
 #+end_src
 
 #+name: fig:gang_of_four_feedback
-#+caption: Simple Feedback Architecture
+#+caption: Simple Feedback Architecture with $r$ the reference signal, $\epsilon$ the tracking error, $d$ a disturbance acting at the plant input $u$, $y$ is the output signal and $n$ the measurement noise
 #+RESULTS:
 [[file:figs/gang_of_four_feedback.png]]
 
-** Closed Loop Transfer Functions
+#+name: tab:spec_closed_loop_tf
-<<sec:closed_loop_tf>>
+#+caption: Typical Specification and associated closed-loop transfer function
-
+| Specification                  | Closed-Loop Transfer Function                 |
-As the performances of a controlled system depend on the *closed* loop transfer functions, it is very important to derive these closed-loop transfer functions as a function of the plant $G(s)$ and controller $K(s)$.
+|--------------------------------+-----------------------------------------------|
+| Reference Tracking             | From $r$ to $\epsilon$                        |
+| Disturbance Rejection          | From $d$ to $y$                               |
+| Measurement Noise Filtering    | From $n$ to $y$                               |
+| Small Command Amplitude        | From $n,r,d$ to $u$                           |
+| Stability                      | All                                           |
+| Robustness (stability margins) | Module margin (see Section [[sec:module_margin]]) |
 
 #+begin_exercice
-Write the output signals $[\epsilon, u, y]$ as a function of the systems $K(s), G(s)$ and of the input signals $[r, d, n]$ as shown in Figure [[fig:gang_of_four_feedback]].
+For the feedback system in 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]$.
 
 #+HTML: <details><summary>Hint</summary>
 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:
@@ -1187,7 +1199,7 @@ The following equations should be obtained:
 #+end_exercice
 
 #+begin_important
-We can see that they are 4 different transfer functions describing the behavior of the system in Figure [[fig:gang_of_four_feedback]].
+We can see that they are 4 different closed-loop transfer functions describing the behavior of the feedback system in Figure [[fig:gang_of_four_feedback]].
 These called the *Gang of Four*:
 \begin{align}
   S  &= \frac{1 }{1 + GK}, \quad \text{the sensitivity function} \\
@@ -1202,7 +1214,7 @@ If a feedforward controller is included, a *Gang of Six* transfer functions can
 More on that in this [[https://www.youtube.com/watch?v=b_8v8scghh8][short video]].
 #+end_seealso
 
-And we have:
+The behavior of the feedback system in 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 \\
@@ -1212,7 +1224,7 @@ And we have:
 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)$.
 
-** Sensitivity Function
+** The Sensitivity Function
 <<sec:sensitivity_transfer_functions>>
 
 The sensitivity function is indisputably the most important closed-loop transfer function of a feedback system.
@@ -1220,7 +1232,7 @@ In this section, we will see how the shape of the sensitivity function will impa
 
 
 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 are shown in Figure [[fig:sensitivity_shape_effect]] and the corresponding step responses are shown in Figure [[fig:sensitivity_shape_effect_step]].
+The obtained sensitivity functions for these four controllers are shown in Figure [[fig:sensitivity_shape_effect]] and the corresponding step responses are shown in Figure [[fig:sensitivity_shape_effect_step]].
 
 The comparison of the sensitivity functions shapes and their effect on the step response is summarized in Table [[tab:compare_sensitivity_shapes]].
 
@@ -1358,12 +1370,10 @@ The comparison of the sensitivity functions shapes and their effect on the step
 #+end_definition
 
 #+begin_important
-From the simple analysis above, we can draw a first estimation of the wanted shape for the sensitivity function in Figure [[fig:h-infinity-spec-S]].
+From the simple analysis above, we can draw a first estimation of the wanted shape for the sensitivity function (Figure [[fig:h-infinity-spec-S]]):
-
-The wanted characteristics on the magnitude of the sensitivity function are then:
 - 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 in order to limit large overshoot and oscillations.
+- 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*.
 
@@ -1375,10 +1385,11 @@ The wanted characteristics on the magnitude of the sensitivity function are then
 ** Robustness: Module Margin
 <<sec:module_margin>>
 
-Let's start by an example demonstrating why the phase and gain margins might not be good indicators of robustness.
+Let's start this section by an example demonstrating why the phase and gain margins might not be good indicators of robustness.
+Will follow a discussion about the module margin, a robustness indicator that can be linked to the $\mathcal{H}_\infty$ norm of $S$ and that will prove to be very useful.
 
 #+begin_exampl
-Let's consider the following plant $G_t(s)$:
+Consider the following plant $G_t(s)$:
 #+begin_src matlab
   w0 = 2*pi*100;
   xi = 0.1;
@@ -1393,12 +1404,13 @@ Let's say we have designed a controller $K_t(s)$ that gives the loop gain shown
   Kt = 1.2e6*(s + w0)/s;
 #+end_src
 
-The following characteristics can be determined from Figure [[fig:phase_gain_margin_model_plant]]:
+The following characteristics can be determined from the Loop gain in Figure [[fig:phase_gain_margin_model_plant]]:
-- bandwidth of $\approx 10\, \text{Hz}$
+- Control bandwidth of $\approx 10\, \text{Hz}$
-- infinite gain margin (the phase of the loop-gain never reaches -180 degrees
+- Infinite gain margin (the phase of the loop-gain never reaches $-180^o$)
-- more than 90 degrees of phase margin
+- More than $90^o$ of phase margin
 
-This might indicate very good robustness properties of the closed-loop system.
+This clearly indicate very good robustness of the closed-loop system!
+Or does it? Let's find out.
 
 #+begin_src matlab :exports none
   freqs = logspace(0, 3, 1000);
@@ -1437,7 +1449,7 @@ This might indicate very good robustness properties of the closed-loop system.
 [[file:figs/phase_gain_margin_model_plant.png]]
 
 
-Now let's suppose the "real" plant $G_r(s)$ as a slightly lower damping factor:
+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:
 #+begin_src matlab
   xi = 0.03;
 #+end_src
@@ -1447,7 +1459,7 @@ Now let's suppose the "real" plant $G_r(s)$ as a slightly lower damping factor:
 #+end_src
 
 The obtained "real" loop gain is shown in 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 indicated instability.
+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:
 #+begin_src matlab :results value replace
@@ -1495,16 +1507,16 @@ It is confirmed by checking the stability of the closed loop system:
 #+RESULTS:
 [[file:figs/phase_gain_margin_real_plant.png]]
 
-Therefore, even a small change of the plant parameter makes the system unstable even though both the gain margin and the phase margin for the nominal plant are excellent.
+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 for a *pure* change or gain or a *pure* change of phase but not a combination of both.
+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.
 #+end_exampl
 
 Let's now determine a new robustness indicator based on the Nyquist Stability Criteria.
 
 #+begin_definition
 - Nyquist Stability Criteria (for stable systems) ::
-  If the open-loop transfer function $L(s)$ is stable, then the closed-loop system is unstable for any encirclement of the point $−1$ on the Nyquist plot.
+  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$.
@@ -1586,19 +1598,24 @@ The gain, phase and module margins are graphically shown to have an idea of what
 As expected from Figure [[fig:module_margin_example]], there is a close relationship between the module margin and the gain and phase margins.
 We can indeed show that for a given value of the module margin $\Delta M$, we have:
 \begin{equation}
-  \Delta G \ge \frac{\Delta M}{\Delta M - 1}; \quad \Delta \phi \ge \frac{1}{\Delta M}
+  \Delta G \ge \frac{1}{1 - \Delta M}; \quad \Delta \phi \ge \Delta M
 \end{equation}
 
-
 Let's now try to express the Module margin $\Delta M$ as an $\mathcal{H}_\infty$ norm of a closed-loop transfer function:
 \begin{align*}
 \Delta M &= \text{minimum distance between } L(j\omega) \text{ and point } (-1) \\
          &= \min_\omega |L(j\omega) - (-1)| \\
          &= \min_\omega |1 + L(j\omega)| \\
          &= \frac{1}{\max_\omega \frac{1}{|1 + L(j\omega)|}} \\
+         &= \frac{1}{\max_\omega \left| \frac{1}{1 + G(j\omega)K(j\omega)}\right|} \\
          &= \frac{1}{\|S\|_\infty}
 \end{align*}
 
+Therefore, for a given $\mathcal{H}_\infty$ norm of $S$ ($\|S\|_\infty = M_S$), we have:
+\begin{equation}
+  \Delta G \ge \frac{M_S}{M_S - 1}; \quad \Delta \phi \ge \frac{1}{M_S}
+\end{equation}
+
 #+begin_important
 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.
 
@@ -1610,7 +1627,7 @@ The wanted robustness of the closed-loop system can be specified by setting a ma
 #+end_important
 
 Note that this is why large peak value of $|S(j\omega)|$ usually indicate robustness problems.
-And we know understand why setting an upper bound on the magnitude of $S$ is generally a good idea.
+And we now understand why setting an upper bound on the magnitude of $S$ is generally a good idea.
 
 #+begin_exampl
   Typical, we require $\|S\|_\infty < 2 (6dB)$ which implies $\Delta G \ge 2$ and $\Delta \phi \ge 29^o$
@@ -1620,23 +1637,29 @@ And we know understand why setting an upper bound on the magnitude of $S$ is gen
   To learn more about module/disk margin, you can check out [[https://www.youtube.com/watch?v=XazdN6eZF80][this]] video.
 #+end_seealso
 
-** TODO Other Requirements
+** TODO Summary of
 <<sec:other_requirements>>
 
-Interpretation of the $\mathcal{H}_\infty$ norm of systems:
+# Interpretation of the $\mathcal{H}_\infty$ norm of systems:
-- frequency by frequency attenuation / amplification
+# - frequency by frequency attenuation / amplification
 
-Let's note $G_t(s)$ the closed-loop transfer function from $w$ to $z$.
+# Let's note $G_t(s)$ the closed-loop transfer function from $w$ to $z$.
 
-Consider an input sinusoidal signal $w(t) = \sin\left( \omega_0 t \right)$, then the output signal $z(t)$ will be equal to:
+# Consider an input sinusoidal signal $w(t) = \sin\left( \omega_0 t \right)$, then the output signal $z(t)$ will be equal to:
-\[ z(t) = A \sin\left( \omega_0 t + \phi \right) \]
+# \[ z(t) = A \sin\left( \omega_0 t + \phi \right) \]
-with:
+# with:
-- $A = |G_t(j\omega_0)|$ is the magnitude of $G_t(s)$ at $\omega_0$
+# - $A = |G_t(j\omega_0)|$ is the magnitude of $G_t(s)$ at $\omega_0$
-- $\phi = \angle G_t(j\omega_0)$ is the phase of $G_t(s)$ at $\omega_0$
+# - $\phi = \angle G_t(j\omega_0)$ is the phase of $G_t(s)$ at $\omega_0$
 
 
 Noise Attenuation: typical wanted shape for $T$
 
+$S$ can be used to set a lower bound on the bandwidth
+$T$ can be used to set a higher bound on the bandwidth
+$T$ is used to make the system more robust to high frequency model uncertainties
+
+
+
 #+name: tab:specification_modern
 #+caption: Typical Specifications and corresponding wanted norms of open and closed loop tansfer functions
 |                             | Open-Loop Shaping  | Closed-Loop Shaping                        |
@@ -1653,26 +1676,30 @@ Noise Attenuation: typical wanted shape for $T$
 ** Introduction                                                      :ignore:
 
 In the previous sections, we have seen that the performances of the system depends on the *shape* of the closed-loop transfer function.
-
+Therefore, the synthesis problem is to design $K(s)$ such that closed-loop system is stable and such that the closed-loop transfer functions such as $S$, $KS$ and $T$ are shaped as wanted.
-Therefore, the synthesis problem is to design $K(s)$ such that closed-loop system is stable and such that various closed-loop transfer functions such as $S$, $KS$ and $T$ are shaped as wanted.
 This is clearly not simple as these closed-loop transfer functions does not depend linearly on $K$.
-
 But don't worry, the $\mathcal{H}_\infty$ synthesis will do this job for us!
 
-This
+To do so, *weighting functions* are included in the generalized plant and the $\mathcal{H}_\infty$ synthesis applied on the *weighted* generalized plant.
-Section [[sec:weighting_functions]]
+Such procedure is presented in Section [[sec:weighting_functions]].
-Section [[sec:weighting_functions_design]]
+
-Section [[sec:sensitivity_shaping_example]]
+Some advice on the design of weighting functions are given in Section [[sec:weighting_functions_design]].
-Section [[sec:shaping_multiple_tf]]
+
+An example of the $\mathcal{H}_\infty$ shaping of the sensitivity function is studied in Section [[sec:sensitivity_shaping_example]].
+
+Multiple closed-loop transfer functions can be shaped at the same time.
+Such synthesis is usually called *Mixed-sensitivity Loop Shaping* and is one of the most powerful tool of the robust control theory.
+Some insight on the use and limitations of such techniques are given in Section [[sec:shaping_multiple_tf]].
 
 ** How to Shape closed-loop transfer function? Using Weighting Functions!
 <<sec:weighting_functions>>
 
-If the $\mathcal{H}_\infty$ synthesis is applied on the generalized plant $P(s)$ shown in Figure [[fig:loop_shaping_S_without_W]], it will generate a controller $K(s)$ such that the $\mathcal{H}_\infty$ norm of closed-loop transfer function from $r$ to $\epsilon$ is minimized.
+Suppose we apply the $\mathcal{H}_\infty$ synthesis on the generalized plant $P(s)$ shown in Figure [[fig:loop_shaping_S_without_W]].
-This closed-loop transfer function actually correspond to the sensitivity function.
+It will generate a controller $K(s)$ such that the $\mathcal{H}_\infty$ norm of closed-loop transfer function from $r$ to $\epsilon$ is minimized which is equal to the sensitivity function $S$.
-Therefore, it will minimize the the $\mathcal{H}_\infty$ norm of the sensitivity function: $\|S\|_\infty$.
+Therefore, the synthesis objective is to minimize the $\mathcal{H}_\infty$ norm of the sensitivity function: $\|S\|_\infty$.
 
-However, as the $\mathcal{H}_\infty$ norm is the maximum peak value of the transfer function's magnitude, this synthesis is quite useless and clearly does not allow to *shape* the norm of $S(j\omega)$ over all frequencies.
+However, as the $\mathcal{H}_\infty$ norm is the maximum peak value of the transfer function's magnitude, this synthesis is quite useless as it will just try to decrease of peak value of $S$.
+Clearly this does not allow to *shape* the norm of $S(j\omega)$ over all frequencies nor specify the wanted low frequency gain of $S$ or bandwidth requirements.
 
 #+begin_src latex :file loop_shaping_S_without_W.pdf
   \begin{tikzpicture}
@@ -1720,9 +1747,9 @@ Let's now show how this is equivalent as *shaping* the sensitivity function:
 \end{align}
 
 #+begin_important
-  As shown in Equation eqref:eq:sensitivity_shaping, the $\mathcal{H}_\infty$ synthesis applying on the /weighted/ generalized plant allows to *shape* the magnitude of the sensitivity transfer function.
+  As shown in Equation eqref:eq:sensitivity_shaping, 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.
+  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.
 #+end_important
 
 #+begin_src latex :file loop_shaping_S_with_W.pdf
@@ -1775,11 +1802,13 @@ The two solutions below can be used.
         1  -G];
 #+end_src
 
+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.
+
 #+begin_src matlab :tangle no :eval no
+  P = [1 -G;
+       1 -G];
   Pw = blkdiag(Ws, 1)*P;
 #+end_src
-
-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.
 #+HTML: </details>
 #+end_exercice
 
@@ -1797,7 +1826,7 @@ Weighting function included in the generalized plant must be *proper*, *stable*
   no zeros in the right half plane
 #+end_definition
 
-Matlab is providing the =makeweight= function that allows to design first-order weights by specifying the low frequency gain, high frequency gain, and the gain at a specific frequency:
+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:
 #+begin_src matlab :tangle no :eval no
   W = makeweight(dcgain,[freq,mag],hfgain)
 #+end_src
@@ -1924,7 +1953,7 @@ The obtained shapes are shown in Figure [[fig:high_order_weight]].
 ** Shaping the Sensitivity Function
 <<sec:sensitivity_shaping_example>>
 
-Let's design a controller using the $\mathcal{H}_\infty$ synthesis that fulfils the following requirements:
+Let's design a controller using the $\mathcal{H}_\infty$ shaping of the sensitivity function that fulfils the following requirements:
 1. Bandwidth of at least 10Hz
 2. Small static errors for step responses
 3. Robustness: Large module margin $\Delta M > 0.5$ ($\Rightarrow \Delta G > 2$ and $\Delta \phi > 29^o$)
@@ -1932,7 +1961,7 @@ Let's design a controller using the $\mathcal{H}_\infty$ synthesis that fulfils
 As usual, the plant used is the one presented in Section [[sec:example_system]].
 
 #+begin_exercice
-Translate the requirements as upper bounds on the Sensitivity function and design the corresponding Weight using Matlab.
+Translate the requirements as upper bounds on the Sensitivity function and design the corresponding weighting functions using Matlab.
 
 #+HTML: <details><summary>Hint</summary>
 The typical wanted upper bound of the sensitivity function is shown in Figure [[fig:h-infinity-spec-S-bis]].
@@ -1951,6 +1980,7 @@ Remember that the wanted upper bound of the sensitivity function is defined by t
 #+HTML: </details>
 
 #+HTML: <details><summary>Answer</summary>
+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$
@@ -2003,7 +2033,7 @@ And the $\mathcal{H}_\infty$ synthesis is performed on the /weighted/ generalize
   Best performance (actual): 0.503
 #+end_example
 
-$\gamma \approx 0.5$ means that the $\mathcal{H}_\infty$ synthesis generated a controller $K(s)$ that stabilizes the closed-loop system, and such that:
+$\gamma \approx 0.5$ means that the $\mathcal{H}_\infty$ synthesis generated a controller $K(s)$ that stabilizes the closed-loop system, and such that the $\mathcal{H}_\infty$ norm of the closed-loop transfer function from $w$ to $z$ is less than $\gamma$:
 \begin{aligned}
   & \| W_s(s) S(s) \|_\infty \approx 0.5 \\
   & \Leftrightarrow |S(j\omega)| < \frac{0.5}{|W_s(j\omega)|} \quad \forall \omega
@@ -2012,9 +2042,9 @@ $\gamma \approx 0.5$ means that the $\mathcal{H}_\infty$ synthesis generated a c
 This is indeed what we can see by comparing $|S|$ and $|W_S|$ in Figure [[fig:results_sensitivity_hinf]].
 
 #+begin_important
-Having $\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.
+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.
 
-Having $\gamma$ slightly above one does not necessary means the obtained controller is not "good".
+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$.
 #+end_important
 
@@ -2037,17 +2067,19 @@ It just means that at some frequency, one of the closed-loop transfer functions
 #+RESULTS:
 [[file:figs/results_sensitivity_hinf.png]]
 
-** Shaping multiple closed-loop transfer functions
+** Shaping multiple closed-loop transfer functions - Limitations
 <<sec:shaping_multiple_tf>>
 
-As was shown in Section [[sec:modern_interpretation_specification]], depending on the specifications, up to four closed-loop transfer function may be shaped (the Gang of four).
+*** Introduction                                                    :ignore:
-This was summarized in Table [[tab:specification_modern]].
 
-For instance to limit the control input $u$, $KS$ should be shaped while to filter measurement noise, $T$ should be shaped.
+As was shown in Section [[sec:modern_interpretation_specification]], each of the four main closed-loop transfer functions (called the /gang of four/) will impact different characteristics of the closed-loop system.
 
-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 [[sec:h_infinity_mixed_sensitivity]].
+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 measurment 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 [[sec:h_infinity_mixed_sensitivity]].
 
-Depending on the closed-loop transfer function being shaped, different general control configuration are used and are described below.
+Depending on which closed-loop transfer function are to be shaped, different weighted generalized plant can be used.
+Some of them are described below for reference, it is a good exercise to try to re-design such weighted generalized plants.
 
 *** S KS                                                            :ignore:
 #+HTML: <details><summary>Shaping of S and KS</summary>
@@ -2092,6 +2124,10 @@ Depending on the closed-loop transfer function being shaped, different general c
 #+RESULTS:
 [[file:figs/general_conf_shaping_S_KS.png]]
 
+Weighting functions:
+- $W_1(s)$ is used to shape $S$
+- $W_2(s)$ is used to shape $KS$
+
 #+name: lst:general_plant_S_KS
 #+caption: General Plant definition corresponding to Figure [[fig:general_conf_shaping_S_KS]]
 #+begin_src matlab :eval no :tangle no
@@ -2099,9 +2135,6 @@ Depending on the closed-loop transfer function being shaped, different general c
        0   W2
        1  -G];
 #+end_src
-
-- $W_1(s)$ is used to shape $S$
-- $W_2(s)$ is used to shape $KS$
 #+HTML: </details>
 
 *** S T                                                             :ignore:
@@ -2145,6 +2178,10 @@ Depending on the closed-loop transfer function being shaped, different general c
 #+RESULTS:
 [[file:figs/general_conf_shaping_S_T.png]]
 
+Weighting functions:
+- $W_1$ is used to shape $S$
+- $W_2$ is used to shape $T$
+
 #+name: lst:general_plant_S_T
 #+caption: General Plant definition corresponding to Figure [[fig:general_conf_shaping_S_T]]
 #+begin_src matlab :eval no :tangle no
@@ -2152,9 +2189,6 @@ Depending on the closed-loop transfer function being shaped, different general c
        0   G*W2
        1   -G];
 #+end_src
-
-- $W_1$ is used to shape $S$
-- $W_2$ is used to shape $T$
 #+HTML: </details>
 
 *** S GS                                                            :ignore:
@@ -2198,6 +2232,10 @@ Depending on the closed-loop transfer function being shaped, different general c
 #+RESULTS:
 [[file:figs/general_conf_shaping_S_GS.png]]
 
+Weighting functions:
+- $W_1$ is used to shape $S$
+- $W_2$ is used to shape $GS$
+
 #+name: lst:general_plant_S_GS
 #+caption: General Plant definition corresponding to Figure [[fig:general_conf_shaping_S_GS]]
 #+begin_src matlab :eval no :tangle no
@@ -2205,8 +2243,6 @@ Depending on the closed-loop transfer function being shaped, different general c
        G*W2 -G*W2
        G    -G];
 #+end_src
-- $W_1$ is used to shape $S$
-- $W_2$ is used to shape $GS$
 #+HTML: </details>
 
 *** S T KS                                                          :ignore:
@@ -2255,6 +2291,11 @@ Depending on the closed-loop transfer function being shaped, different general c
 #+RESULTS:
 [[file:figs/general_conf_shaping_S_T_KS.png]]
 
+Weighting functions:
+- $W_1$ is used to shape $S$
+- $W_2$ is used to shape $KS$
+- $W_3$ is used to shape $T$
+
 #+name: lst:general_plant_S_T_KS
 #+caption: General Plant definition corresponding to Figure [[fig:general_conf_shaping_S_T_KS]]
 #+begin_src matlab :eval no :tangle no
@@ -2263,10 +2304,6 @@ Depending on the closed-loop transfer function being shaped, different general c
        0   G*W3
        1   -G];
 #+end_src
-
-- $W_1$ is used to shape $S$
-- $W_2$ is used to shape $KS$
-- $W_3$ is used to shape $T$
 #+HTML: </details>
 
 *** S T GS                                                          :ignore:
@@ -2315,6 +2352,11 @@ Depending on the closed-loop transfer function being shaped, different general c
 #+RESULTS:
 [[file:figs/general_conf_shaping_S_T_GS.png]]
 
+Weighting functions:
+- $W_1$ is used to shape $S$
+- $W_2$ is used to shape $GS$
+- $W_3$ is used to shape $T$
+
 #+name: lst:general_plant_S_T_GS
 #+caption: General Plant definition corresponding to Figure [[fig:general_conf_shaping_S_T_GS]]
 #+begin_src matlab :eval no :tangle no
@@ -2323,10 +2365,6 @@ Depending on the closed-loop transfer function being shaped, different general c
        0     W3
        G    -G];
 #+end_src
-
-- $W_1$ is used to shape $S$
-- $W_2$ is used to shape $GS$
-- $W_3$ is used to shape $T$
 #+HTML: </details>
 
 *** S T KS GS                                                       :ignore:
@@ -2379,6 +2417,12 @@ Depending on the closed-loop transfer function being shaped, different general c
 #+RESULTS:
 [[file:figs/general_conf_shaping_S_T_KS_GS.png]]
 
+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$
+
 #+name: lst:general_plant_S_T_KS_GS
 #+caption: General Plant definition corresponding to Figure [[fig:general_conf_shaping_S_T_KS_GS]]
 #+begin_src matlab :eval no :tangle no
@@ -2386,27 +2430,18 @@ Depending on the closed-loop transfer function being shaped, different general c
         0    0        W2
         1   -G*W3    -G];
 #+end_src
-
-- $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$
 #+HTML: </details>
 
-
-
 *** Limitation                                                      :ignore:
 
-When shaping multiple closed-loop transfer functions, one should be verify careful about the three following points that are further discussed:
+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
+- 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.
+- 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
 
-
-
 #+begin_warning
   Mathematical relations are linking the closed-loop transfer functions.
-  For instance, the sensitivity function $S(s)$ and the complementary sensitivity function $T(s)$ as link by the following well known relation:
+  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}
@@ -2417,13 +2452,17 @@ When shaping multiple closed-loop transfer functions, one should be verify caref
   The weighting function should be carefully design such as these fundamental relations are not violated.
 #+end_warning
 
-The control bandwidth is clearly limited by physical constrains such as sampling frequency, electronics bandwidth,
+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$.
 
 #+begin_exercice
@@ -2431,9 +2470,9 @@ Determine the approximate norms of $T$, $KS$ and $GS$ for large loop gains ($|G(
 
 #+HTML: <details><summary>Hint</summary>
 You can follows this procedure for $T$, $KS$ and $GS$:
-1. Write the closed-loop transfer function $T(s)$ as a function of $K(s)$ and $G(s)$
+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 $|T(j\omega)|$
+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 on $|T(j\omega)|$
+3. Take $|K(j\omega)G(j\omega)| \ll 1$ and conclude
 #+HTML: </details>
 
 #+HTML: <details><summary>Answer</summary>
@@ -2441,8 +2480,8 @@ The obtained constrains are shown in Figure [[fig:h-infinity-4-blocs-constrains]
 #+HTML: </details>
 #+end_exercice
 
-Depending on the frequency band, the norms of the closed-loop transfer functions depend on the controller $K$ and therefore can be shaped.
+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 bands, the norms do not depend on the controller and therefore *cannot* 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 [[fig:h-infinity-4-blocs-constrains]].
@@ -2507,13 +2546,14 @@ These regions are summarized in Figure [[fig:h-infinity-4-blocs-constrains]].
 #+end_src
 
 #+name: fig:h-infinity-4-blocs-constrains
-#+caption: Shaping the Gang of Four: Limitations
+#+caption: 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
 #+RESULTS:
 [[file:figs/h-infinity-4-blocs-constrains.png]]
 
 #+begin_warning
-  The order (resp. number of state) of the controller given by the $\mathcal{H}_\infty$ synthesis is equal to the order (resp. number of state) of the weighted generalized plant.
+  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)