2020-10-26 21:35:47 +01:00
<?xml version="1.0" encoding="utf-8"?>
< !DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
< html xmlns = "http://www.w3.org/1999/xhtml" lang = "en" xml:lang = "en" >
< head >
2021-04-28 15:59:35 +02:00
<!-- 2020 - 12 - 11 ven. 14:05 -->
2020-10-26 21:35:47 +01:00
< meta http-equiv = "Content-Type" content = "text/html;charset=utf-8" / >
< title > Complementary Filters Shaping Using \(\mathcal{H}_\infty\) Synthesis - Matlab Computation< / title >
< meta name = "generator" content = "Org mode" / >
< meta name = "author" content = "Thomas Dehaeze" / >
2020-11-12 10:44:59 +01:00
< link rel = "stylesheet" type = "text/css" href = "https://research.tdehaeze.xyz/css/style.css" / >
< script type = "text/javascript" src = "https://research.tdehaeze.xyz/js/script.js" > < / script >
2020-10-26 21:35:47 +01:00
< script > M a t h J a x = {
tex: {
tags: 'ams',
macros: {bm: ["\\boldsymbol{#1}",1],}
}
};
< / script >
< script type = "text/javascript" src = "https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js" > < / script >
< / head >
< body >
< div id = "org-div-home-and-up" >
< a accesskey = "h" href = "../index.html" > UP < / a >
|
< a accesskey = "H" href = "../index.html" > HOME < / a >
< / div > < div id = "content" >
< h1 class = "title" > Complementary Filters Shaping Using \(\mathcal{H}_\infty\) Synthesis - Matlab Computation< / h1 >
< div id = "table-of-contents" >
< h2 > Table of Contents< / h2 >
< div id = "text-table-of-contents" >
< ul >
2021-04-28 15:59:35 +02:00
< li > < a href = "#orga86008b" > 1. H-Infinity synthesis of complementary filters< / a >
2020-10-26 21:35:47 +01:00
< ul >
2021-04-28 15:59:35 +02:00
< li > < a href = "#orga8d0882" > 1.1. Synthesis Architecture< / a > < / li >
< li > < a href = "#orgf309349" > 1.2. Design of Weighting Function< / a > < / li >
< li > < a href = "#org3d519e3" > 1.3. H-Infinity Synthesis< / a > < / li >
< li > < a href = "#org42911cd" > 1.4. Obtained Complementary Filters< / a > < / li >
2020-10-26 21:35:47 +01:00
< / ul >
< / li >
2021-04-28 15:59:35 +02:00
< li > < a href = "#org1cd882b" > 2. Generating 3 complementary filters< / a >
2020-10-26 21:35:47 +01:00
< ul >
2021-04-28 15:59:35 +02:00
< li > < a href = "#org201b962" > 2.1. Theory< / a > < / li >
< li > < a href = "#orgbb81a3a" > 2.2. Weights< / a > < / li >
< li > < a href = "#orgc782a41" > 2.3. H-Infinity Synthesis< / a > < / li >
< li > < a href = "#orgbe6c26a" > 2.4. Obtained Complementary Filters< / a > < / li >
2020-10-26 21:35:47 +01:00
< / ul >
< / li >
2021-04-28 15:59:35 +02:00
< li > < a href = "#orgfb4a473" > 3. Implement complementary filters for LIGO< / a >
2020-10-26 21:35:47 +01:00
< ul >
2021-04-28 15:59:35 +02:00
< li > < a href = "#org0a64590" > 3.1. Specifications< / a > < / li >
< li > < a href = "#org5187f2d" > 3.2. FIR Filter< / a > < / li >
< li > < a href = "#org6e83a71" > 3.3. Weights< / a > < / li >
< li > < a href = "#org56349cf" > 3.4. H-Infinity Synthesis< / a > < / li >
< li > < a href = "#org3ef818f" > 3.5. Compare FIR and H-Infinity Filters< / a > < / li >
< / ul >
< / li >
< li > < a href = "#org6fa1123" > 4. Alternative Synthesis< / a >
< ul >
< li > < a href = "#org1bb8ee7" > 4.1. Two generalized plants< / a > < / li >
< li > < a href = "#orga117463" > 4.2. Shaping the Low pass filter or the high pass filter?< / a > < / li >
< / ul >
< / li >
< li > < a href = "#orgf082879" > 5. Impose a positive slope at DC or a negative slope at infinite frequency< / a >
< ul >
< li > < a href = "#org96df1d1" > 5.1. Manually shift zeros to the origin after synthesis< / a > < / li >
< li > < a href = "#org6b92ce0" > 5.2. Imposing a positive slope at DC during the synthesis phase< / a > < / li >
< li > < a href = "#org71e3235" > 5.3. Imposing a negative slope at infinity frequency during the synthesis phase< / a > < / li >
2020-10-26 21:35:47 +01:00
< / ul >
< / li >
< / ul >
< / div >
< / div >
< p >
In this document, the design of complementary filters is studied.
< / p >
< p >
One use of complementary filter is described below:
< / p >
< blockquote >
< p >
The basic idea of a complementary filter involves taking two or more sensors, filtering out unreliable frequencies for each sensor, and combining the filtered outputs to get a better estimate throughout the entire bandwidth of the system.
To achieve this, the sensors included in the filter should complement one another by performing better over specific parts of the system bandwidth.
< / p >
< / blockquote >
< p >
This document is divided into several sections:
< / p >
< ul class = "org-ul" >
2021-04-28 15:59:35 +02:00
< li > in section < a href = "#orge265c61" > 1< / a > , the \(\mathcal{H}_\infty\) synthesis is used for generating two complementary filters< / li >
< li > in section < a href = "#org0f5d922" > 2< / a > , a method using the \(\mathcal{H}_\infty\) synthesis is proposed to shape three of more complementary filters< / li >
< li > in section < a href = "#org2c84916" > 3< / a > , the \(\mathcal{H}_\infty\) synthesis is used and compared with FIR complementary filters used for LIGO< / li >
2020-10-26 21:35:47 +01:00
< / ul >
2021-04-28 15:59:35 +02:00
< div class = "note" id = "org9abbfdc" >
2020-10-26 21:35:47 +01:00
< p >
Add the Matlab code use to obtain the results presented in the paper are accessible < a href = "matlab.zip" > here< / a > and presented below.
< / p >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "outline-container-orga86008b" class = "outline-2" >
< h2 id = "orga86008b" > < span class = "section-number-2" > 1< / span > H-Infinity synthesis of complementary filters< / h2 >
2020-10-26 21:35:47 +01:00
< div class = "outline-text-2" id = "text-1" >
< p >
2021-04-28 15:59:35 +02:00
< a id = "orge265c61" > < / a >
2020-10-26 21:35:47 +01:00
< / p >
2021-04-28 15:59:35 +02:00
< div class = "note" id = "org7b6c965" >
2020-10-26 21:35:47 +01:00
< p >
The Matlab file corresponding to this section is accessible < a href = "matlab/h_inf_synthesis_complementary_filters.m" > here< / a > .
< / p >
< / div >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "outline-container-orga8d0882" class = "outline-3" >
< h3 id = "orga8d0882" > < span class = "section-number-3" > 1.1< / span > Synthesis Architecture< / h3 >
2020-10-26 21:35:47 +01:00
< div class = "outline-text-3" id = "text-1-1" >
< p >
We here synthesize two complementary filters using the \(\mathcal{H}_\infty\) synthesis.
The goal is to specify upper bounds on the norms of the two complementary filters \(H_1(s)\) and \(H_2(s)\) while ensuring their complementary property (\(H_1(s) + H_2(s) = 1\)).
< / p >
< p >
2021-04-28 15:59:35 +02:00
In order to do so, we use the generalized plant shown on figure < a href = "#orge741156" > 1< / a > where \(W_1(s)\) and \(W_2(s)\) are weighting transfer functions that will be used to shape \(H_1(s)\) and \(H_2(s)\) respectively.
2020-10-26 21:35:47 +01:00
< / p >
2021-04-28 15:59:35 +02:00
< div id = "orge741156" class = "figure" >
2020-10-26 21:35:47 +01:00
< p > < img src = "figs-tikz/h_infinity_robust_fusion.png" alt = "h_infinity_robust_fusion.png" / >
< / p >
< p > < span class = "figure-number" > Figure 1: < / span > \(\mathcal{H}_\infty\) synthesis of the complementary filters< / p >
< / div >
< p >
2021-04-28 15:59:35 +02:00
The \(\mathcal{H}_\infty\) synthesis applied on this generalized plant will give a transfer function \(H_2\) (figure < a href = "#orge741156" > 1< / a > ) such that the \(\mathcal{H}_\infty\) norm of the transfer function from \(w\) to \([z_1,\ z_2]\) is less than one:
2020-10-26 21:35:47 +01:00
\[ \left\| \begin{array}{c} (1 - H_2(s)) W_1(s) \\ H_2(s) W_2(s) \end{array} \right\|_\infty < 1 \ ]
< / p >
< p >
Thus, if the above condition is verified, we can define \(H_1(s) = 1 - H_2(s)\) and we have that:
\[ \left\| \begin{array}{c} H_1(s) W_1(s) \\ H_2(s) W_2(s) \end{array} \right\|_\infty < 1 \ ]
Which is almost (with an maximum error of \(\sqrt{2}\)) equivalent to:
< / p >
\begin{align*}
|H_1(j\omega)| & < \frac{1}{|W_1(j\omega)|}, \quad \forall \omega \\
|H_2(j\omega)| & < \frac{1}{|W_2(j\omega)|}, \quad \forall \omega
\end{align*}
< p >
We then see that \(W_1(s)\) and \(W_2(s)\) can be used to shape both \(H_1(s)\) and \(H_2(s)\) while ensuring their complementary property by the definition of \(H_1(s) = 1 - H_2(s)\).
< / p >
< / div >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "outline-container-orgf309349" class = "outline-3" >
< h3 id = "orgf309349" > < span class = "section-number-3" > 1.2< / span > Design of Weighting Function< / h3 >
2020-10-26 21:35:47 +01:00
< div class = "outline-text-3" id = "text-1-2" >
< p >
A formula is proposed to help the design of the weighting functions:
< / p >
\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}
< p >
The parameters permits to specify:
< / p >
< ul class = "org-ul" >
< li > the low frequency gain: \(G_0 = lim_{\omega \to 0} |W(j\omega)|\)< / li >
< li > the high frequency gain: \(G_\infty = lim_{\omega \to \infty} |W(j\omega)|\)< / li >
< li > the absolute gain at \(\omega_0\): \(G_c = |W(j\omega_0)|\)< / li >
< li > the absolute slope between high and low frequency: \(n\)< / li >
< / ul >
< p >
2021-04-28 15:59:35 +02:00
The general shape of a weighting function generated using the formula is shown in figure < a href = "#org18f93a4" > 2< / a > .
2020-10-26 21:35:47 +01:00
< / p >
2021-04-28 15:59:35 +02:00
< div id = "org18f93a4" class = "figure" >
< p > < img src = "figs/weight_formula.png" alt = "weight_formula.png" / >
2020-10-26 21:35:47 +01:00
< / p >
2021-04-28 15:59:35 +02:00
< p > < span class = "figure-number" > Figure 2: < / span > Gain of the Weighting Function formula< / p >
2020-10-26 21:35:47 +01:00
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > n = 2; w0 = 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 11; G0 = 1< span class = "org-type" > /< / span > 10; G1 = 1000; Gc = 1< span class = "org-type" > /< / span > 2;
W1 = (((1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > ((1< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)< span class = "org-type" > *< / span > (1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (1< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)))< span class = "org-type" > ^< / span > n;
n = 3; w0 = 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 10; G0 = 1000; G1 = 0.1; Gc = 1< span class = "org-type" > /< / span > 2;
W2 = (((1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > ((1< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)< span class = "org-type" > *< / span > (1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (1< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)))< span class = "org-type" > ^< / span > n;
< / pre >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "org54a46b0" class = "figure" >
2020-10-26 21:35:47 +01:00
< p > < img src = "figs/weights_W1_W2.png" alt = "weights_W1_W2.png" / >
< / p >
< p > < span class = "figure-number" > Figure 3: < / span > Weights on the complementary filters \(W_1\) and \(W_2\) and the associated performance weights< / p >
< / div >
< / div >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "outline-container-org3d519e3" class = "outline-3" >
< h3 id = "org3d519e3" > < span class = "section-number-3" > 1.3< / span > H-Infinity Synthesis< / h3 >
2020-10-26 21:35:47 +01:00
< div class = "outline-text-3" id = "text-1-3" >
< p >
We define the generalized plant \(P\) on matlab.
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > P = [W1 < span class = "org-type" > -< / span > W1;
0 W2;
1 0];
< / pre >
< / div >
< p >
And we do the \(\mathcal{H}_\infty\) synthesis using the < code > hinfsyn< / code > command.
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > [H2, < span class = "org-type" > ~< / span > , gamma, < span class = "org-type" > ~< / span > ] = hinfsyn(P, 1, 1,< span class = "org-string" > 'TOLGAM'< / span > , 0.001, < span class = "org-string" > 'METHOD'< / span > , < span class = "org-string" > 'ric'< / span > , < span class = "org-string" > 'DISPLAY'< / span > , < span class = "org-string" > 'on'< / span > );
< / pre >
< / div >
2021-04-28 15:59:35 +02:00
< pre class = "example" id = "orgb213b31" >
2020-10-26 21:35:47 +01:00
[H2, ~, gamma, ~] = hinfsyn(P, 1, 1,'TOLGAM', 0.001, 'METHOD', 'ric', 'DISPLAY', 'on');
Resetting value of Gamma min based on D_11, D_12, D_21 terms
Test bounds: 0.1000 < gamma < = 1050.0000
gamma hamx_eig xinf_eig hamy_eig yinf_eig nrho_xy p/f
1.050e+03 2.8e+01 2.4e-07 4.1e+00 0.0e+00 0.0000 p
525.050 2.8e+01 2.4e-07 4.1e+00 0.0e+00 0.0000 p
262.575 2.8e+01 2.4e-07 4.1e+00 0.0e+00 0.0000 p
131.337 2.8e+01 2.4e-07 4.1e+00 -1.0e-13 0.0000 p
65.719 2.8e+01 2.4e-07 4.1e+00 -9.5e-14 0.0000 p
32.909 2.8e+01 2.4e-07 4.1e+00 0.0e+00 0.0000 p
16.505 2.8e+01 2.4e-07 4.1e+00 -1.0e-13 0.0000 p
8.302 2.8e+01 2.4e-07 4.1e+00 -7.2e-14 0.0000 p
4.201 2.8e+01 2.4e-07 4.1e+00 -2.5e-25 0.0000 p
2.151 2.7e+01 2.4e-07 4.1e+00 -3.8e-14 0.0000 p
1.125 2.6e+01 2.4e-07 4.1e+00 -5.4e-24 0.0000 p
0.613 2.3e+01 -3.7e+01# 4.1e+00 0.0e+00 0.0000 f
0.869 2.6e+01 -3.7e+02# 4.1e+00 0.0e+00 0.0000 f
0.997 2.6e+01 -1.1e+04# 4.1e+00 0.0e+00 0.0000 f
1.061 2.6e+01 2.4e-07 4.1e+00 0.0e+00 0.0000 p
1.029 2.6e+01 2.4e-07 4.1e+00 0.0e+00 0.0000 p
1.013 2.6e+01 2.4e-07 4.1e+00 0.0e+00 0.0000 p
1.005 2.6e+01 2.4e-07 4.1e+00 0.0e+00 0.0000 p
1.001 2.6e+01 -3.1e+04# 4.1e+00 -3.8e-14 0.0000 f
1.003 2.6e+01 -2.8e+05# 4.1e+00 0.0e+00 0.0000 f
1.004 2.6e+01 2.4e-07 4.1e+00 -5.8e-24 0.0000 p
1.004 2.6e+01 2.4e-07 4.1e+00 0.0e+00 0.0000 p
Gamma value achieved: 1.0036
< / pre >
< p >
2021-04-28 15:59:35 +02:00
We then define the high pass filter \(H_1 = 1 - H_2\). The bode plot of both \(H_1\) and \(H_2\) is shown on figure < a href = "#orgc79ce80" > 4< / a > .
2020-10-26 21:35:47 +01:00
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > H1 = 1 < span class = "org-type" > -< / span > H2;
< / pre >
< / div >
< / div >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "outline-container-org42911cd" class = "outline-3" >
< h3 id = "org42911cd" > < span class = "section-number-3" > 1.4< / span > Obtained Complementary Filters< / h3 >
2020-10-26 21:35:47 +01:00
< div class = "outline-text-3" id = "text-1-4" >
< p >
2021-04-28 15:59:35 +02:00
The obtained complementary filters are shown on figure < a href = "#orgc79ce80" > 4< / a > .
2020-10-26 21:35:47 +01:00
< / p >
2021-04-28 15:59:35 +02:00
< div id = "orgc79ce80" class = "figure" >
2020-10-26 21:35:47 +01:00
< p > < img src = "figs/hinf_filters_results.png" alt = "hinf_filters_results.png" / >
< / p >
< p > < span class = "figure-number" > Figure 4: < / span > Obtained complementary filters using \(\mathcal{H}_\infty\) synthesis< / p >
< / div >
< / div >
< / div >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "outline-container-org1cd882b" class = "outline-2" >
< h2 id = "org1cd882b" > < span class = "section-number-2" > 2< / span > Generating 3 complementary filters< / h2 >
2020-10-26 21:35:47 +01:00
< div class = "outline-text-2" id = "text-2" >
< p >
2021-04-28 15:59:35 +02:00
< a id = "org0f5d922" > < / a >
2020-10-26 21:35:47 +01:00
< / p >
2021-04-28 15:59:35 +02:00
< div class = "note" id = "org7c35287" >
2020-10-26 21:35:47 +01:00
< p >
The Matlab file corresponding to this section is accessible < a href = "matlab/three_comp_filters.m" > here< / a > .
< / p >
< / div >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "outline-container-org201b962" class = "outline-3" >
< h3 id = "org201b962" > < span class = "section-number-3" > 2.1< / span > Theory< / h3 >
2020-10-26 21:35:47 +01:00
< div class = "outline-text-3" id = "text-2-1" >
< p >
We want:
< / p >
\begin{align*}
& |H_1(j\omega)| < 1 / | W_1 ( j \ omega ) | , \ quad \ forall \ omega \ \
& |H_2(j\omega)| < 1 / | W_2 ( j \ omega ) | , \ quad \ forall \ omega \ \
& |H_3(j\omega)| < 1 / | W_3 ( j \ omega ) | , \ quad \ forall \ omega \ \
& H_1(s) + H_2(s) + H_3(s) = 1
\end{align*}
< p >
2021-04-28 15:59:35 +02:00
For that, we use the \(\mathcal{H}_\infty\) synthesis with the architecture shown on figure < a href = "#org86ebebf" > 5< / a > .
2020-10-26 21:35:47 +01:00
< / p >
2021-04-28 15:59:35 +02:00
< div id = "org86ebebf" class = "figure" >
2020-10-26 21:35:47 +01:00
< p > < img src = "figs-tikz/comp_filter_three_hinf.png" alt = "comp_filter_three_hinf.png" / >
< / p >
< p > < span class = "figure-number" > Figure 5: < / span > Generalized architecture for generating 3 complementary filters< / p >
< / div >
< p >
The \(\mathcal{H}_\infty\) objective is:
< / p >
\begin{align*}
& |(1 - H_2(j\omega) - H_3(j\omega)) W_1(j\omega)| < 1 , \ quad \ forall \ omega \ \
& |H_2(j\omega) W_2(j\omega)| < 1 , \ quad \ forall \ omega \ \
& |H_3(j\omega) W_3(j\omega)| < 1 , \ quad \ forall \ omega \ \
\end{align*}
< p >
And thus if we choose \(H_1 = 1 - H_2 - H_3\) we have solved the problem.
< / p >
< / div >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "outline-container-orgbb81a3a" class = "outline-3" >
< h3 id = "orgbb81a3a" > < span class = "section-number-3" > 2.2< / span > Weights< / h3 >
2020-10-26 21:35:47 +01:00
< div class = "outline-text-3" id = "text-2-2" >
< p >
First we define the weights.
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > n = 2; w0 = 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 1; G0 = 1< span class = "org-type" > /< / span > 10; G1 = 1000; Gc = 1< span class = "org-type" > /< / span > 2;
W1 = (((1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > ((1< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)< span class = "org-type" > *< / span > (1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (1< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)))< span class = "org-type" > ^< / span > n;
W2 = 0.22< span class = "org-type" > *< / span > (1 < span class = "org-type" > +< / span > s< span class = "org-type" > /< / span > 2< span class = "org-type" > /< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > /< / span > 1)< span class = "org-type" > ^< / span > 2< span class = "org-type" > /< / span > (sqrt(1e< span class = "org-type" > -< / span > 4) < span class = "org-type" > +< / span > s< span class = "org-type" > /< / span > 2< span class = "org-type" > /< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > /< / span > 1)< span class = "org-type" > ^< / span > 2< span class = "org-type" > *< / span > (1 < span class = "org-type" > +< / span > s< span class = "org-type" > /< / span > 2< span class = "org-type" > /< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > /< / span > 10)< span class = "org-type" > ^< / span > 2< span class = "org-type" > /< / span > (1 < span class = "org-type" > +< / span > s< span class = "org-type" > /< / span > 2< span class = "org-type" > /< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > /< / span > 1000)< span class = "org-type" > ^< / span > 2;
n = 3; w0 = 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 10; G0 = 1000; G1 = 0.1; Gc = 1< span class = "org-type" > /< / span > 2;
W3 = (((1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > ((1< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)< span class = "org-type" > *< / span > (1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (1< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)))< span class = "org-type" > ^< / span > n;
< / pre >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "org6ef9224" class = "figure" >
2020-10-26 21:35:47 +01:00
< p > < img src = "figs/three_weighting_functions.png" alt = "three_weighting_functions.png" / >
< / p >
< p > < span class = "figure-number" > Figure 6: < / span > Three weighting functions used for the \(\mathcal{H}_\infty\) synthesis of the complementary filters< / p >
< / div >
< / div >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "outline-container-orgc782a41" class = "outline-3" >
< h3 id = "orgc782a41" > < span class = "section-number-3" > 2.3< / span > H-Infinity Synthesis< / h3 >
2020-10-26 21:35:47 +01:00
< div class = "outline-text-3" id = "text-2-3" >
< p >
Then we create the generalized plant < code > P< / code > .
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > P = [W1 < span class = "org-type" > -< / span > W1 < span class = "org-type" > -< / span > W1;
0 W2 0 ;
0 0 W3;
1 0 0];
< / pre >
< / div >
< p >
And we do the \(\mathcal{H}_\infty\) synthesis.
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > [H, < span class = "org-type" > ~< / span > , gamma, < span class = "org-type" > ~< / span > ] = hinfsyn(P, 1, 2,< span class = "org-string" > 'TOLGAM'< / span > , 0.001, < span class = "org-string" > 'METHOD'< / span > , < span class = "org-string" > 'ric'< / span > , < span class = "org-string" > 'DISPLAY'< / span > , < span class = "org-string" > 'on'< / span > );
< / pre >
< / div >
2021-04-28 15:59:35 +02:00
< pre class = "example" id = "orga35c0a2" >
2020-10-26 21:35:47 +01:00
[H, ~, gamma, ~] = hinfsyn(P, 1, 2,'TOLGAM', 0.001, 'METHOD', 'ric', 'DISPLAY', 'on');
Resetting value of Gamma min based on D_11, D_12, D_21 terms
Test bounds: 0.1000 < gamma < = 1050.0000
gamma hamx_eig xinf_eig hamy_eig yinf_eig nrho_xy p/f
1.050e+03 3.2e+00 4.5e-13 6.3e-02 -1.2e-11 0.0000 p
525.050 3.2e+00 1.3e-13 6.3e-02 0.0e+00 0.0000 p
262.575 3.2e+00 2.1e-12 6.3e-02 -1.5e-13 0.0000 p
131.337 3.2e+00 1.1e-12 6.3e-02 -7.2e-29 0.0000 p
65.719 3.2e+00 2.0e-12 6.3e-02 0.0e+00 0.0000 p
32.909 3.2e+00 7.4e-13 6.3e-02 -5.9e-13 0.0000 p
16.505 3.2e+00 1.4e-12 6.3e-02 0.0e+00 0.0000 p
8.302 3.2e+00 1.6e-12 6.3e-02 0.0e+00 0.0000 p
4.201 3.2e+00 1.6e-12 6.3e-02 0.0e+00 0.0000 p
2.151 3.2e+00 1.6e-12 6.3e-02 0.0e+00 0.0000 p
1.125 3.2e+00 2.8e-12 6.3e-02 0.0e+00 0.0000 p
0.613 3.0e+00 -2.5e+03# 6.3e-02 0.0e+00 0.0000 f
0.869 3.1e+00 -2.9e+01# 6.3e-02 0.0e+00 0.0000 f
0.997 3.2e+00 1.9e-12 6.3e-02 0.0e+00 0.0000 p
0.933 3.1e+00 -6.9e+02# 6.3e-02 0.0e+00 0.0000 f
0.965 3.1e+00 -3.0e+03# 6.3e-02 0.0e+00 0.0000 f
0.981 3.1e+00 -8.6e+03# 6.3e-02 0.0e+00 0.0000 f
0.989 3.2e+00 -2.7e+04# 6.3e-02 0.0e+00 0.0000 f
0.993 3.2e+00 -5.7e+05# 6.3e-02 0.0e+00 0.0000 f
0.995 3.2e+00 2.2e-12 6.3e-02 0.0e+00 0.0000 p
0.994 3.2e+00 1.6e-12 6.3e-02 0.0e+00 0.0000 p
0.994 3.2e+00 1.0e-12 6.3e-02 0.0e+00 0.0000 p
Gamma value achieved: 0.9936
< / pre >
< / div >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "outline-container-orgbe6c26a" class = "outline-3" >
< h3 id = "orgbe6c26a" > < span class = "section-number-3" > 2.4< / span > Obtained Complementary Filters< / h3 >
2020-10-26 21:35:47 +01:00
< div class = "outline-text-3" id = "text-2-4" >
< p >
The obtained filters are:
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > H2 = tf(H(1));
H3 = tf(H(2));
H1 = 1 < span class = "org-type" > -< / span > H2 < span class = "org-type" > -< / span > H3;
< / pre >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "orga85736d" class = "figure" >
2020-10-26 21:35:47 +01:00
< p > < img src = "figs/three_complementary_filters_results.png" alt = "three_complementary_filters_results.png" / >
< / p >
< p > < span class = "figure-number" > Figure 7: < / span > The three complementary filters obtained after \(\mathcal{H}_\infty\) synthesis< / p >
< / div >
< / div >
< / div >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "outline-container-orgfb4a473" class = "outline-2" >
< h2 id = "orgfb4a473" > < span class = "section-number-2" > 3< / span > Implement complementary filters for LIGO< / h2 >
2020-10-26 21:35:47 +01:00
< div class = "outline-text-2" id = "text-3" >
< p >
2021-04-28 15:59:35 +02:00
< a id = "org2c84916" > < / a >
2020-10-26 21:35:47 +01:00
< / p >
2021-04-28 15:59:35 +02:00
< div class = "note" id = "org4890f37" >
2020-10-26 21:35:47 +01:00
< p >
The Matlab file corresponding to this section is accessible < a href = "matlab/comp_filters_ligo.m" > here< / a > .
< / p >
< / div >
< p >
Let’ s try to design complementary filters that are corresponding to the complementary filters design for the LIGO and described in (< a href = "#citeproc_bib_item_1" > Hua 2005< / a > ).
< / p >
< p >
The FIR complementary filters designed in (< a href = "#citeproc_bib_item_1" > Hua 2005< / a > ) are of order 512.
< / p >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "outline-container-org0a64590" class = "outline-3" >
< h3 id = "org0a64590" > < span class = "section-number-3" > 3.1< / span > Specifications< / h3 >
2020-10-26 21:35:47 +01:00
< div class = "outline-text-3" id = "text-3-1" >
< p >
The specifications for the filters are:
< / p >
< ol class = "org-ol" >
< li > From \(0\) to \(0.008\text{ Hz}\),the magnitude of the filter’ < / li >
< li > From \(0.008\text{ Hz}\) to \(0.04\text{ Hz}\), it attenuates the input signal proportional to frequency cubed< / li >
< li > Between \(0.04\text{ Hz}\) and \(0.1\text{ Hz}\), the magnitude of the transfer function should be less than 3< / li >
< li > Above \(0.1\text{ Hz}\), the maximum of the magnitude of the complement filter should be as close to zero as possible. In our system, we would like to have the magnitude of the complementary filter to be less than \(0.1\). As the filters obtained in (< a href = "#citeproc_bib_item_1" > Hua 2005< / a > ) have a magnitude of \(0.045\), we will set that as our requirement< / li >
< / ol >
< p >
2021-04-28 15:59:35 +02:00
The specifications are translated in upper bounds of the complementary filters are shown on figure < a href = "#org40b6368" > 8< / a > .
2020-10-26 21:35:47 +01:00
< / p >
2021-04-28 15:59:35 +02:00
< div id = "org40b6368" class = "figure" >
2020-10-26 21:35:47 +01:00
< p > < img src = "figs/ligo_specifications.png" alt = "ligo_specifications.png" / >
< / p >
< p > < span class = "figure-number" > Figure 8: < / span > Specification for the LIGO complementary filters< / p >
< / div >
< / div >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "outline-container-org5187f2d" class = "outline-3" >
< h3 id = "org5187f2d" > < span class = "section-number-3" > 3.2< / span > FIR Filter< / h3 >
2020-10-26 21:35:47 +01:00
< div class = "outline-text-3" id = "text-3-2" >
< p >
We here try to implement the FIR complementary filter synthesis as explained in (< a href = "#citeproc_bib_item_1" > Hua 2005< / a > ).
For that, we use the < a href = "http://cvxr.com/cvx/" > CVX matlab Toolbox< / a > .
< / p >
< p >
We setup the CVX toolbox and use the < code > SeDuMi< / code > solver.
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > cvx_startup;
cvx_solver sedumi;
< / pre >
< / div >
< p >
We define the frequency vectors on which we will constrain the norm of the FIR filter.
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > w1 = 0< span class = "org-type" > :< / span > 4.06e< span class = "org-type" > -< / span > 4< span class = "org-type" > :< / span > 0.008;
w2 = 0.008< span class = "org-type" > :< / span > 4.06e< span class = "org-type" > -< / span > 4< span class = "org-type" > :< / span > 0.04;
w3 = 0.04< span class = "org-type" > :< / span > 8.12e< span class = "org-type" > -< / span > 4< span class = "org-type" > :< / span > 0.1;
w4 = 0.1< span class = "org-type" > :< / span > 8.12e< span class = "org-type" > -< / span > 4< span class = "org-type" > :< / span > 0.83;
< / pre >
< / div >
< p >
We then define the order of the FIR filter.
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > n = 512;
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > A1 = [ones(length(w1),1), cos(kron(w1< span class = "org-type" > '.*< / span > (2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > ),[1< span class = "org-type" > :< / span > n< span class = "org-type" > -< / span > 1]))];
A2 = [ones(length(w2),1), cos(kron(w2< span class = "org-type" > '.*< / span > (2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > ),[1< span class = "org-type" > :< / span > n< span class = "org-type" > -< / span > 1]))];
A3 = [ones(length(w3),1), cos(kron(w3< span class = "org-type" > '.*< / span > (2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > ),[1< span class = "org-type" > :< / span > n< span class = "org-type" > -< / span > 1]))];
A4 = [ones(length(w4),1), cos(kron(w4< span class = "org-type" > '.*< / span > (2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > ),[1< span class = "org-type" > :< / span > n< span class = "org-type" > -< / span > 1]))];
B1 = [zeros(length(w1),1), sin(kron(w1< span class = "org-type" > '.*< / span > (2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > ),[1< span class = "org-type" > :< / span > n< span class = "org-type" > -< / span > 1]))];
B2 = [zeros(length(w2),1), sin(kron(w2< span class = "org-type" > '.*< / span > (2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > ),[1< span class = "org-type" > :< / span > n< span class = "org-type" > -< / span > 1]))];
B3 = [zeros(length(w3),1), sin(kron(w3< span class = "org-type" > '.*< / span > (2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > ),[1< span class = "org-type" > :< / span > n< span class = "org-type" > -< / span > 1]))];
B4 = [zeros(length(w4),1), sin(kron(w4< span class = "org-type" > '.*< / span > (2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > ),[1< span class = "org-type" > :< / span > n< span class = "org-type" > -< / span > 1]))];
< / pre >
< / div >
< p >
We run the convex optimization.
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > cvx_begin
variable y(n< span class = "org-type" > +< / span > 1,1)
< span class = "org-comment" > % t< / span >
maximize(< span class = "org-type" > -< / span > y(1))
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:length(w1)< / span >
norm([0 A1(< span class = "org-constant" > i< / span > ,< span class = "org-type" > :< / span > ); 0 B1(< span class = "org-constant" > i< / span > ,< span class = "org-type" > :< / span > )]< span class = "org-type" > *< / span > y) < span class = "org-type" > < =< / span > 8e< span class = "org-type" > -< / span > 3;
< span class = "org-keyword" > end< / span >
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:length(w2)< / span >
norm([0 A2(< span class = "org-constant" > i< / span > ,< span class = "org-type" > :< / span > ); 0 B2(< span class = "org-constant" > i< / span > ,< span class = "org-type" > :< / span > )]< span class = "org-type" > *< / span > y) < span class = "org-type" > < =< / span > 8e< span class = "org-type" > -< / span > 3< span class = "org-type" > *< / span > (2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > w2(< span class = "org-constant" > i< / span > )< span class = "org-type" > /< / span > (0.008< span class = "org-type" > *< / span > 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > ))< span class = "org-type" > ^< / span > 3;
< span class = "org-keyword" > end< / span >
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:length(w3)< / span >
norm([0 A3(< span class = "org-constant" > i< / span > ,< span class = "org-type" > :< / span > ); 0 B3(< span class = "org-constant" > i< / span > ,< span class = "org-type" > :< / span > )]< span class = "org-type" > *< / span > y) < span class = "org-type" > < =< / span > 3;
< span class = "org-keyword" > end< / span >
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:length(w4)< / span >
norm([[1 0]< span class = "org-type" > '-< / span > [0 A4(< span class = "org-constant" > i< / span > ,< span class = "org-type" > :< / span > ); 0 B4(< span class = "org-constant" > i< / span > ,< span class = "org-type" > :< / span > )]< span class = "org-type" > *< / span > y]) < span class = "org-type" > < =< / span > y(1);
< span class = "org-keyword" > end< / span >
cvx_end
h = y(2< span class = "org-type" > :< / span > end);
< / pre >
< / div >
2021-04-28 15:59:35 +02:00
< pre class = "example" id = "org199d33a" >
2020-10-26 21:35:47 +01:00
cvx_begin
variable y(n+1,1)
% t
maximize(-y(1))
for i = 1:length(w1)
norm([0 A1(i,:); 0 B1(i,:)]*y) < = 8e-3;
end
for i = 1:length(w2)
norm([0 A2(i,:); 0 B2(i,:)]*y) < = 8e-3*(2*pi*w2(i)/(0.008*2*pi))^3;
end
for i = 1:length(w3)
norm([0 A3(i,:); 0 B3(i,:)]*y) < = 3;
end
for i = 1:length(w4)
norm([[1 0]'- [0 A4(i,:); 0 B4(i,:)]*y]) < = y(1);
end
cvx_end
Calling SeDuMi 1.34: 4291 variables, 1586 equality constraints
For improved efficiency, SeDuMi is solving the dual problem.
------------------------------------------------------------
SeDuMi 1.34 (beta) by AdvOL, 2005-2008 and Jos F. Sturm, 1998-2003.
Alg = 2: xz-corrector, Adaptive Step-Differentiation, theta = 0.250, beta = 0.500
eqs m = 1586, order n = 3220, dim = 4292, blocks = 1073
nnz(A) = 1100727 + 0, nnz(ADA) = 1364794, nnz(L) = 683190
it : b*y gap delta rate t/tP* t/tD* feas cg cg prec
0 : 4.11E+02 0.000
1 : -2.58E+00 1.25E+02 0.000 0.3049 0.9000 0.9000 4.87 1 1 3.0E+02
2 : -2.36E+00 3.90E+01 0.000 0.3118 0.9000 0.9000 1.83 1 1 6.6E+01
3 : -1.69E+00 1.31E+01 0.000 0.3354 0.9000 0.9000 1.76 1 1 1.5E+01
4 : -8.60E-01 7.10E+00 0.000 0.5424 0.9000 0.9000 2.48 1 1 4.8E+00
5 : -4.91E-01 5.44E+00 0.000 0.7661 0.9000 0.9000 3.12 1 1 2.5E+00
6 : -2.96E-01 3.88E+00 0.000 0.7140 0.9000 0.9000 2.62 1 1 1.4E+00
7 : -1.98E-01 2.82E+00 0.000 0.7271 0.9000 0.9000 2.14 1 1 8.5E-01
8 : -1.39E-01 2.00E+00 0.000 0.7092 0.9000 0.9000 1.78 1 1 5.4E-01
9 : -9.99E-02 1.30E+00 0.000 0.6494 0.9000 0.9000 1.51 1 1 3.3E-01
10 : -7.57E-02 8.03E-01 0.000 0.6175 0.9000 0.9000 1.31 1 1 2.0E-01
11 : -5.99E-02 4.22E-01 0.000 0.5257 0.9000 0.9000 1.17 1 1 1.0E-01
12 : -5.28E-02 2.45E-01 0.000 0.5808 0.9000 0.9000 1.08 1 1 5.9E-02
13 : -4.82E-02 1.28E-01 0.000 0.5218 0.9000 0.9000 1.05 1 1 3.1E-02
14 : -4.56E-02 5.65E-02 0.000 0.4417 0.9045 0.9000 1.02 1 1 1.4E-02
15 : -4.43E-02 2.41E-02 0.000 0.4265 0.9004 0.9000 1.01 1 1 6.0E-03
16 : -4.37E-02 8.90E-03 0.000 0.3690 0.9070 0.9000 1.00 1 1 2.3E-03
17 : -4.35E-02 3.24E-03 0.000 0.3641 0.9164 0.9000 1.00 1 1 9.5E-04
18 : -4.34E-02 1.55E-03 0.000 0.4788 0.9086 0.9000 1.00 1 1 4.7E-04
19 : -4.34E-02 8.77E-04 0.000 0.5653 0.9169 0.9000 1.00 1 1 2.8E-04
20 : -4.34E-02 5.05E-04 0.000 0.5754 0.9034 0.9000 1.00 1 1 1.6E-04
21 : -4.34E-02 2.94E-04 0.000 0.5829 0.9136 0.9000 1.00 1 1 9.9E-05
22 : -4.34E-02 1.63E-04 0.015 0.5548 0.9000 0.0000 1.00 1 1 6.6E-05
23 : -4.33E-02 9.42E-05 0.000 0.5774 0.9053 0.9000 1.00 1 1 3.9E-05
24 : -4.33E-02 6.27E-05 0.000 0.6658 0.9148 0.9000 1.00 1 1 2.6E-05
25 : -4.33E-02 3.75E-05 0.000 0.5972 0.9187 0.9000 1.00 1 1 1.6E-05
26 : -4.33E-02 1.89E-05 0.000 0.5041 0.9117 0.9000 1.00 1 1 8.6E-06
27 : -4.33E-02 9.72E-06 0.000 0.5149 0.9050 0.9000 1.00 1 1 4.5E-06
28 : -4.33E-02 2.94E-06 0.000 0.3021 0.9194 0.9000 1.00 1 1 1.5E-06
29 : -4.33E-02 9.73E-07 0.000 0.3312 0.9189 0.9000 1.00 2 2 5.3E-07
30 : -4.33E-02 2.82E-07 0.000 0.2895 0.9063 0.9000 1.00 2 2 1.6E-07
31 : -4.33E-02 8.05E-08 0.000 0.2859 0.9049 0.9000 1.00 2 2 4.7E-08
32 : -4.33E-02 1.43E-08 0.000 0.1772 0.9059 0.9000 1.00 2 2 8.8E-09
iter seconds digits c*x b*y
32 49.4 6.8 -4.3334083581e-02 -4.3334090214e-02
|Ax-b| = 3.7e-09, [Ay-c]_+ = 1.1E-10, |x|= 1.0e+00, |y|= 2.6e+00
Detailed timing (sec)
Pre IPM Post
3.902E+00 4.576E+01 1.035E-02
Max-norms: ||b||=1, ||c|| = 3,
Cholesky |add|=0, |skip| = 0, ||L.L|| = 4.26267.
------------------------------------------------------------
Status: Solved
Optimal value (cvx_optval): -0.0433341
h = y(2:end);
< / pre >
< p >
2021-04-28 15:59:35 +02:00
Finally, we compute the filter response over the frequency vector defined and the result is shown on figure < a href = "#org1807c4b" > 9< / a > which is very close to the filters obtain in (< a href = "#citeproc_bib_item_1" > Hua 2005< / a > ).
2020-10-26 21:35:47 +01:00
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > w = [w1 w2 w3 w4];
H = [exp(< span class = "org-type" > -< / span > < span class = "org-constant" > j< / span > < span class = "org-type" > *< / span > kron(w< span class = "org-type" > '.*< / span > 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > ,[0< span class = "org-type" > :< / span > n< span class = "org-type" > -< / span > 1]))]< span class = "org-type" > *< / span > h;
< / pre >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "org1807c4b" class = "figure" >
2020-10-26 21:35:47 +01:00
< p > < img src = "figs/fir_filter_ligo.png" alt = "fir_filter_ligo.png" / >
< / p >
2020-11-12 10:44:59 +01:00
< p > < span class = "figure-number" > Figure 9: < / span > FIR Complementary filters obtain after convex optimization< / p >
2020-10-26 21:35:47 +01:00
< / div >
< / div >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "outline-container-org6e83a71" class = "outline-3" >
< h3 id = "org6e83a71" > < span class = "section-number-3" > 3.3< / span > Weights< / h3 >
2020-10-26 21:35:47 +01:00
< div class = "outline-text-3" id = "text-3-3" >
< p >
We design weights that will be used for the \(\mathcal{H}_\infty\) synthesis of the complementary filters.
These weights will determine the order of the obtained filters.
Here are the requirements on the filters:
< / p >
< ul class = "org-ul" >
< li > reasonable order< / li >
< li > to be as close as possible to the specified upper bounds< / li >
< li > stable minimum phase< / li >
< / ul >
< p >
2021-04-28 15:59:35 +02:00
The bode plot of the weights is shown on figure < a href = "#org8999a4f" > 10< / a > .
2020-10-26 21:35:47 +01:00
< / p >
2021-04-28 15:59:35 +02:00
< div id = "org8999a4f" class = "figure" >
2020-10-26 21:35:47 +01:00
< p > < img src = "figs/ligo_weights.png" alt = "ligo_weights.png" / >
< / p >
< p > < span class = "figure-number" > Figure 10: < / span > Weights for the \(\mathcal{H}_\infty\) synthesis< / p >
< / div >
< / div >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "outline-container-org56349cf" class = "outline-3" >
< h3 id = "org56349cf" > < span class = "section-number-3" > 3.4< / span > H-Infinity Synthesis< / h3 >
2020-10-26 21:35:47 +01:00
< div class = "outline-text-3" id = "text-3-4" >
< p >
2021-04-28 15:59:35 +02:00
We define the generalized plant as shown on figure < a href = "#orge741156" > 1< / a > .
2020-10-26 21:35:47 +01:00
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > P = [0 wL;
wH < span class = "org-type" > -< / span > wH;
1 0];
< / pre >
< / div >
< p >
And we do the \(\mathcal{H}_\infty\) synthesis using the < code > hinfsyn< / code > command.
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > [Hl, < span class = "org-type" > ~< / span > , gamma, < span class = "org-type" > ~< / span > ] = hinfsyn(P, 1, 1,< span class = "org-string" > 'TOLGAM'< / span > , 0.001, < span class = "org-string" > 'METHOD'< / span > , < span class = "org-string" > 'ric'< / span > , < span class = "org-string" > 'DISPLAY'< / span > , < span class = "org-string" > 'on'< / span > );
< / pre >
< / div >
2021-04-28 15:59:35 +02:00
< pre class = "example" id = "orgd8777e8" >
2020-10-26 21:35:47 +01:00
[Hl, ~, gamma, ~] = hinfsyn(P, 1, 1,'TOLGAM', 0.001, 'METHOD', 'ric', 'DISPLAY', 'on');
Resetting value of Gamma min based on D_11, D_12, D_21 terms
Test bounds: 0.3276 < gamma < = 1.8063
gamma hamx_eig xinf_eig hamy_eig yinf_eig nrho_xy p/f
1.806 1.4e-02 -1.7e-16 3.6e-03 -4.8e-12 0.0000 p
1.067 1.3e-02 -4.2e-14 3.6e-03 -1.9e-12 0.0000 p
0.697 1.3e-02 -3.0e-01# 3.6e-03 -3.5e-11 0.0000 f
0.882 1.3e-02 -9.5e-01# 3.6e-03 -1.2e-34 0.0000 f
0.975 1.3e-02 -2.7e+00# 3.6e-03 -1.6e-12 0.0000 f
1.021 1.3e-02 -8.7e+00# 3.6e-03 -4.5e-16 0.0000 f
1.044 1.3e-02 -6.5e-14 3.6e-03 -3.0e-15 0.0000 p
1.032 1.3e-02 -1.8e+01# 3.6e-03 0.0e+00 0.0000 f
1.038 1.3e-02 -3.8e+01# 3.6e-03 0.0e+00 0.0000 f
1.041 1.3e-02 -8.3e+01# 3.6e-03 -2.9e-33 0.0000 f
1.042 1.3e-02 -1.9e+02# 3.6e-03 -3.4e-11 0.0000 f
1.043 1.3e-02 -5.3e+02# 3.6e-03 -7.5e-13 0.0000 f
Gamma value achieved: 1.0439
< / pre >
< p >
The high pass filter is defined as \(H_H = 1 - H_L\).
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > Hh = 1 < span class = "org-type" > -< / span > Hl;
< / pre >
< / div >
< p >
The size of the filters is shown below.
< / p >
2021-04-28 15:59:35 +02:00
< pre class = "example" id = "orgc30176a" >
2020-10-26 21:35:47 +01:00
size(Hh), size(Hl)
State-space model with 1 outputs, 1 inputs, and 27 states.
State-space model with 1 outputs, 1 inputs, and 27 states.
< / pre >
< p >
2021-04-28 15:59:35 +02:00
The bode plot of the obtained filters as shown on figure < a href = "#orgf3626bd" > 11< / a > .
2020-10-26 21:35:47 +01:00
< / p >
2021-04-28 15:59:35 +02:00
< div id = "orgf3626bd" class = "figure" >
2020-10-26 21:35:47 +01:00
< p > < img src = "figs/hinf_synthesis_ligo_results.png" alt = "hinf_synthesis_ligo_results.png" / >
< / p >
< p > < span class = "figure-number" > Figure 11: < / span > Obtained complementary filters using the \(\mathcal{H}_\infty\) synthesis< / p >
< / div >
< / div >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "outline-container-org3ef818f" class = "outline-3" >
< h3 id = "org3ef818f" > < span class = "section-number-3" > 3.5< / span > Compare FIR and H-Infinity Filters< / h3 >
2020-10-26 21:35:47 +01:00
< div class = "outline-text-3" id = "text-3-5" >
< p >
2021-04-28 15:59:35 +02:00
Let’ s now compare the FIR filters designed in (< a href = "#citeproc_bib_item_1" > Hua 2005< / a > ) and the one obtained with the \(\mathcal{H}_\infty\) synthesis on figure < a href = "#orga60b7f8" > 12< / a > .
2020-10-26 21:35:47 +01:00
< / p >
2021-04-28 15:59:35 +02:00
< div id = "orga60b7f8" class = "figure" >
2020-10-26 21:35:47 +01:00
< p > < img src = "figs/comp_fir_ligo_hinf.png" alt = "comp_fir_ligo_hinf.png" / >
< / p >
< p > < span class = "figure-number" > Figure 12: < / span > Comparison between the FIR filters developped for LIGO and the \(\mathcal{H}_\infty\) complementary filters< / p >
< / div >
< / div >
< / div >
< / div >
2021-04-28 15:59:35 +02:00
< div id = "outline-container-org6fa1123" class = "outline-2" >
< h2 id = "org6fa1123" > < span class = "section-number-2" > 4< / span > Alternative Synthesis< / h2 >
< div class = "outline-text-2" id = "text-4" >
< / div >
< div id = "outline-container-org1bb8ee7" class = "outline-3" >
< h3 id = "org1bb8ee7" > < span class = "section-number-3" > 4.1< / span > Two generalized plants< / h3 >
< div class = "outline-text-3" id = "text-4-1" >
< p >
In order to synthesize the complementary filter using the proposed method, we can use two alternative generalized plant as shown in Figures < a href = "#orgdfb88a5" > 13< / a > and < a href = "#orgb41d84e" > 14< / a > .
< / p >
\begin{equation}
P_1 = \begin{bmatrix} W_1 & -W_1 \\ 0 & W_2 \\ 1 & 0 \end{bmatrix}
\end{equation}
< div id = "orgdfb88a5" class = "figure" >
< p > < img src = "figs/h_infinity_arch_1.png" alt = "h_infinity_arch_1.png" / >
< / p >
< p > < span class = "figure-number" > Figure 13: < / span > Complementary Filter Synthesis - Conf 1< / p >
< / div >
\begin{equation}
P_2 = \begin{bmatrix} 0 & W_1 & 1 \\ W_2 & -W_1 & 0 \end{bmatrix}
\end{equation}
< div id = "orgb41d84e" class = "figure" >
< p > < img src = "figs/h_infinity_arch_2.png" alt = "h_infinity_arch_2.png" / >
< / p >
< p > < span class = "figure-number" > Figure 14: < / span > Complementary Filter Synthesis - Conf 2< / p >
< / div >
< p >
Let’ s run the \(\mathcal{H}_\infty\) synthesis for both generalized plant using the same weights and see if the obtained filters are the same:
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > n = 2; w0 = 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 11; G0 = 1< span class = "org-type" > /< / span > 10; G1 = 1000; Gc = 1< span class = "org-type" > /< / span > 2;
W1 = (((1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > ((1< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)< span class = "org-type" > *< / span > (1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (1< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)))< span class = "org-type" > ^< / span > n;
n = 3; w0 = 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 10; G0 = 1000; G1 = 0.1; Gc = 1< span class = "org-type" > /< / span > 2;
W2 = (((1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > ((1< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)< span class = "org-type" > *< / span > (1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (1< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)))< span class = "org-type" > ^< / span > n;
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > P1 = [W1 < span class = "org-type" > -< / span > W1;
0 W2;
1 0];
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > [H2, < span class = "org-type" > ~< / span > , gamma, < span class = "org-type" > ~< / span > ] = hinfsyn(P1, 1, 1,< span class = "org-string" > 'TOLGAM'< / span > , 0.001, < span class = "org-string" > 'METHOD'< / span > , < span class = "org-string" > 'ric'< / span > , < span class = "org-string" > 'DISPLAY'< / span > , < span class = "org-string" > 'on'< / span > );
< / pre >
< / div >
< pre class = "example" id = "org80f6d17" >
[H2, ~, gamma, ~] = hinfsyn(P1, 1, 1,'TOLGAM', 0.001, 'METHOD', 'ric', 'DISPLAY', 'on');
Test bounds: 0.3263 < = gamma < = 1000
gamma X> =0 Y> =0 rho(XY)< 1 p/f
1.807e+01 1.4e-07 0.0e+00 1.185e-18 p
2.428e+00 1.5e-07 0.0e+00 1.285e-18 p
8.902e-01 -2.9e+02 # -7.1e-17 5.168e-19 f
1.470e+00 1.5e-07 0.0e+00 1.462e-14 p
1.144e+00 1.5e-07 0.0e+00 1.260e-14 p
1.009e+00 1.5e-07 0.0e+00 4.120e-13 p
9.478e-01 -6.8e+02 # -2.4e-17 1.449e-14 f
9.780e-01 -1.6e+03 # -7.3e-17 6.791e-14 f
9.934e-01 -4.2e+03 # -1.2e-16 3.524e-14 f
1.001e+00 -2.0e+04 # -2.3e-17 5.717e-20 f
1.005e+00 1.5e-07 0.0e+00 8.953e-18 p
1.003e+00 -2.2e+05 # -1.8e-17 3.225e-12 f
1.004e+00 1.5e-07 0.0e+00 2.445e-12 p
Limiting gains...
1.004e+00 1.6e-07 0.0e+00 5.811e-18 p
Best performance (actual): 1.004
< / pre >
< div class = "org-src-container" >
< pre class = "src src-matlab" > P2 = [0 W1 1;
W2 < span class = "org-type" > -< / span > W1 0];
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > [H2b, < span class = "org-type" > ~< / span > , gamma, < span class = "org-type" > ~< / span > ] = hinfsyn(P2, 1, 1,< span class = "org-string" > 'TOLGAM'< / span > , 0.001, < span class = "org-string" > 'METHOD'< / span > , < span class = "org-string" > 'ric'< / span > , < span class = "org-string" > 'DISPLAY'< / span > , < span class = "org-string" > 'on'< / span > );
< / pre >
< / div >
< pre class = "example" id = "org7155dd4" >
[H2b, ~, gamma, ~] = hinfsyn(P2, 1, 1,'TOLGAM', 0.001, 'METHOD', 'ric', 'DISPLAY', 'on');
Test bounds: 0.3263 < = gamma < = 1000
gamma X> =0 Y> =0 rho(XY)< 1 p/f
1.807e+01 0.0e+00 1.4e-07 2.055e-16 p
2.428e+00 0.0e+00 1.4e-07 1.894e-18 p
8.902e-01 -2.1e-16 -2.7e+02 # 1.466e-16 f
1.470e+00 0.0e+00 1.4e-07 4.118e-16 p
1.144e+00 0.0e+00 1.5e-07 2.105e-18 p
1.009e+00 0.0e+00 1.5e-07 2.590e-13 p
9.478e-01 -9.5e-17 -6.3e+02 # 1.663e-19 f
9.780e-01 -1.1e-16 -1.5e+03 # 1.546e-14 f
9.934e-01 -2.8e-17 -4.0e+03 # 3.934e-14 f
1.001e+00 -3.1e-17 -1.9e+04 # 1.191e-19 f
1.005e+00 0.0e+00 1.5e-07 1.443e-12 p
1.003e+00 -8.3e-17 -2.1e+05 # 8.807e-13 f
1.004e+00 0.0e+00 1.5e-07 1.459e-15 p
Limiting gains...
1.004e+00 0.0e+00 1.5e-07 9.086e-19 p
Best performance (actual): 1.004
< / pre >
< p >
And indeed, we can see that the exact same filters are obtained (Figure < a href = "#org4ff7339" > 15< / a > ).
< / p >
< div id = "org4ff7339" class = "figure" >
< p > < img src = "figs/hinf_comp_P1_P2_syn.png" alt = "hinf_comp_P1_P2_syn.png" / >
< / p >
< p > < span class = "figure-number" > Figure 15: < / span > Comparison of \(H_2(s)\) when using \(P_1(s)\) or \(P_2(s)\)< / p >
< / div >
< / div >
< / div >
< div id = "outline-container-orga117463" class = "outline-3" >
< h3 id = "orga117463" > < span class = "section-number-3" > 4.2< / span > Shaping the Low pass filter or the high pass filter?< / h3 >
< div class = "outline-text-3" id = "text-4-2" >
< p >
Let’ s see if there is a difference by explicitly shaping \(H_1(s)\) or \(H_2(s)\).
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > n = 2; w0 = 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 11; G0 = 1< span class = "org-type" > /< / span > 10; G1 = 1000; Gc = 1< span class = "org-type" > /< / span > 2;
W1 = (((1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > ((1< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)< span class = "org-type" > *< / span > (1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (1< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)))< span class = "org-type" > ^< / span > n;
n = 3; w0 = 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 10; G0 = 1000; G1 = 0.1; Gc = 1< span class = "org-type" > /< / span > 2;
W2 = (((1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > ((1< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)< span class = "org-type" > *< / span > (1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (1< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)))< span class = "org-type" > ^< / span > n;
< / pre >
< / div >
< p >
Let’ s first synthesize \(H_1(s)\):
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > P1 = [W2 < span class = "org-type" > -< / span > W2;
0 W1;
1 0];
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > [H1, < span class = "org-type" > ~< / span > , gamma, < span class = "org-type" > ~< / span > ] = hinfsyn(P1, 1, 1,< span class = "org-string" > 'TOLGAM'< / span > , 0.001, < span class = "org-string" > 'METHOD'< / span > , < span class = "org-string" > 'ric'< / span > , < span class = "org-string" > 'DISPLAY'< / span > , < span class = "org-string" > 'on'< / span > );
< / pre >
< / div >
< pre class = "example" id = "org45692a7" >
[H1, ~, gamma, ~] = hinfsyn(P1, 1, 1,'TOLGAM', 0.001, 'METHOD', 'ric', 'DISPLAY', 'on');
Test bounds: 0.3263 < = gamma < = 1.712
gamma X> =0 Y> =0 rho(XY)< 1 p/f
7.476e-01 -2.5e+01 # -8.3e-18 4.938e-20 f
1.131e+00 1.9e-07 0.0e+00 1.566e-16 p
9.197e-01 -1.4e+02 # -7.9e-17 4.241e-17 f
1.020e+00 1.9e-07 0.0e+00 2.095e-16 p
9.686e-01 -3.8e+02 # -7.0e-17 1.463e-23 f
9.940e-01 -1.5e+03 # -1.3e-17 3.168e-19 f
1.007e+00 1.9e-07 0.0e+00 1.696e-15 p
1.000e+00 -4.8e+03 # -7.1e-18 7.203e-20 f
1.004e+00 1.9e-07 0.0e+00 1.491e-14 p
1.002e+00 -1.1e+04 # -2.6e-16 2.579e-14 f
1.003e+00 -2.8e+04 # -6.0e-18 8.558e-20 f
Limiting gains...
1.004e+00 2.0e-07 0.0e+00 5.647e-18 p
1.004e+00 1.0e-06 0.0e+00 5.648e-18 p
Best performance (actual): 1.004
< / pre >
< p >
And now \(H_2(s)\):
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > P2 = [W1 < span class = "org-type" > -< / span > W1;
0 W2;
1 0];
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > [H2, < span class = "org-type" > ~< / span > , gamma, < span class = "org-type" > ~< / span > ] = hinfsyn(P2, 1, 1,< span class = "org-string" > 'TOLGAM'< / span > , 0.001, < span class = "org-string" > 'METHOD'< / span > , < span class = "org-string" > 'ric'< / span > , < span class = "org-string" > 'DISPLAY'< / span > , < span class = "org-string" > 'on'< / span > );
< / pre >
< / div >
< pre class = "example" id = "org6543cab" >
[H2b, ~, gamma, ~] = hinfsyn(P2, 1, 1,'TOLGAM', 0.001, 'METHOD', 'ric', 'DISPLAY', 'on');
Test bounds: 0.3263 < = gamma < = 1000
gamma X> =0 Y> =0 rho(XY)< 1 p/f
1.807e+01 1.4e-07 0.0e+00 1.185e-18 p
2.428e+00 1.5e-07 0.0e+00 1.285e-18 p
8.902e-01 -2.9e+02 # -7.1e-17 5.168e-19 f
1.470e+00 1.5e-07 0.0e+00 1.462e-14 p
1.144e+00 1.5e-07 0.0e+00 1.260e-14 p
1.009e+00 1.5e-07 0.0e+00 4.120e-13 p
9.478e-01 -6.8e+02 # -2.4e-17 1.449e-14 f
9.780e-01 -1.6e+03 # -7.3e-17 6.791e-14 f
9.934e-01 -4.2e+03 # -1.2e-16 3.524e-14 f
1.001e+00 -2.0e+04 # -2.3e-17 5.717e-20 f
1.005e+00 1.5e-07 0.0e+00 8.953e-18 p
1.003e+00 -2.2e+05 # -1.8e-17 3.225e-12 f
1.004e+00 1.5e-07 0.0e+00 2.445e-12 p
Limiting gains...
1.004e+00 1.6e-07 0.0e+00 5.811e-18 p
Best performance (actual): 1.004
< / pre >
< p >
And compare \(H_1(s)\) with \(1 - H_2(s)\) and \(H_2(s)\) with \(1 - H_1(s)\) in Figure < a href = "#org4a9724c" > 16< / a > .
< / p >
< div id = "org4a9724c" class = "figure" >
< p > < img src = "figs/hinf_comp_H1_H2_syn.png" alt = "hinf_comp_H1_H2_syn.png" / >
< / p >
< p > < span class = "figure-number" > Figure 16: < / span > Comparison of \(H_1(s)\) with \(1-H_2(s)\), and \(H_2(s)\) with \(1-H_1(s)\)< / p >
< / div >
< / div >
< / div >
< / div >
< div id = "outline-container-orgf082879" class = "outline-2" >
< h2 id = "orgf082879" > < span class = "section-number-2" > 5< / span > Impose a positive slope at DC or a negative slope at infinite frequency< / h2 >
< div class = "outline-text-2" id = "text-5" >
< / div >
< div id = "outline-container-org96df1d1" class = "outline-3" >
< h3 id = "org96df1d1" > < span class = "section-number-3" > 5.1< / span > Manually shift zeros to the origin after synthesis< / h3 >
< div class = "outline-text-3" id = "text-5-1" >
< p >
Suppose we want \(H_2(s)\) to be an high pass filter with a slope of +2 at low frequency (from 0Hz).
< / p >
< p >
We cannot impose that using the weight \(W_2(s)\) as it would be improper.
< / p >
< p >
However, we may manually shift 2 of the low frequency zeros to the origin.
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > n = 2; w0 = 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 11; G0 = 1< span class = "org-type" > /< / span > 10; G1 = 1000; Gc = 1< span class = "org-type" > /< / span > 2;
W1 = (((1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > ((1< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)< span class = "org-type" > *< / span > (1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (1< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)))< span class = "org-type" > ^< / span > n;
n = 3; w0 = 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 10; G0 = 1e4; G1 = 0.1; Gc = 1< span class = "org-type" > /< / span > 2;
W2 = (((1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > ((1< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)< span class = "org-type" > *< / span > (1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (1< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)))< span class = "org-type" > ^< / span > n;
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > P = [W1 < span class = "org-type" > -< / span > W1;
0 W2;
1 0];
< / pre >
< / div >
< p >
And we do the \(\mathcal{H}_\infty\) synthesis using the < code > hinfsyn< / code > command:
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > [H2, < span class = "org-type" > ~< / span > , gamma, < span class = "org-type" > ~< / span > ] = hinfsyn(P, 1, 1,< span class = "org-string" > 'TOLGAM'< / span > , 0.001, < span class = "org-string" > 'METHOD'< / span > , < span class = "org-string" > 'lmi'< / span > , < span class = "org-string" > 'DISPLAY'< / span > , < span class = "org-string" > 'on'< / span > );
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > [z,p,k] = zpkdata(H2)
< / pre >
< / div >
< p >
Looking at the zeros, we see two low frequency complex conjugate zeros.
< / p >
< pre class = "example" id = "orge6a4f22" >
z{1}
ans =
-4690930.24283199 + 0i
-163.420524657426 + 0i
-0.853192261081498 + 0.713416012479897i
-0.853192261081498 - 0.713416012479897i
-3.15812268762265 + 0i
< / pre >
< p >
We manually put these zeros at the origin:
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > z{1}([3,4]) = 0;
< / pre >
< / div >
< p >
And we create a modified filter \(H_{2z}(s)\):
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > H2z = zpk(z,p,k);
< / pre >
< / div >
< p >
And as usual, \(H_{1z}(s)\) is defined as the complementary of \(H_{2z}(s)\):
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > H1z = 1 < span class = "org-type" > -< / span > H2z;
< / pre >
< / div >
< p >
The bode plots of \(H_1(s)\), \(H_2(s)\), \(H_{1z}(s)\) and \(H_{2z}(s)\) are shown in Figure < a href = "#org4631977" > 17< / a > .
And we see that \(H_{1z}(s)\) is slightly modified when setting the zeros at the origin for \(H_{2z}(s)\).
< / p >
< div id = "org4631977" class = "figure" >
< p > < img src = "figs/comp_filters_shift_zero.png" alt = "comp_filters_shift_zero.png" / >
< / p >
< p > < span class = "figure-number" > Figure 17: < / span > Bode plots of \(H_1(s)\), \(H_2(s)\), \(H_{1z}(s)\) and \(H_{2z}(s)\)< / p >
< / div >
< / div >
< / div >
< div id = "outline-container-org6b92ce0" class = "outline-3" >
< h3 id = "org6b92ce0" > < span class = "section-number-3" > 5.2< / span > Imposing a positive slope at DC during the synthesis phase< / h3 >
< div class = "outline-text-3" id = "text-5-2" >
< p >
Suppose we want to synthesize \(H_2(s)\) such that it has a slope of +2 from DC.
We can include this “ feature” in the generalized plant as shown in Figure < a href = "#org00fe83c" > 18< / a > .
< / p >
< div id = "org00fe83c" class = "figure" >
< p > < img src = "figs/h_infinity_arch_H2_feature.png" alt = "h_infinity_arch_H2_feature.png" / >
< / p >
< p > < span class = "figure-number" > Figure 18: < / span > Generalized plant with included wanted feature represented by \(H_{2w}(s)\)< / p >
< / div >
< p >
After synthesis, the obtained filter will be:
< / p >
\begin{equation}
H_2(s) = H_2^\prime(s) H_{2w}(s)
\end{equation}
< p >
and therefore the “ feature” will be included in the filter.
< / p >
< p >
For \(H_1(s)\) nothing is changed: \(H_1(s) = 1 - H_2(s)\).
< / p >
< p >
The weighting functions are defined as usual:
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > n = 2; w0 = 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 11; G0 = 1< span class = "org-type" > /< / span > 10; G1 = 1000; Gc = 1< span class = "org-type" > /< / span > 2;
W1 = (((1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > ((1< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)< span class = "org-type" > *< / span > (1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (1< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)))< span class = "org-type" > ^< / span > n;
n = 3; w0 = 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 10; G0 = 1e4; G1 = 0.1; Gc = 1< span class = "org-type" > /< / span > 2;
W2 = (((1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > ((1< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)< span class = "org-type" > *< / span > (1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (1< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)))< span class = "org-type" > ^< / span > n;
< / pre >
< / div >
< p >
The wanted feature here is a +2 slope at low frequency.
For that, we use an high pass filter with a slope of +2 at low frequency.
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > w0 = 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 50;
H2w = (s< span class = "org-type" > /< / span > w0< span class = "org-type" > /< / span > (s< span class = "org-type" > /< / span > w0< span class = "org-type" > +< / span > 1))< span class = "org-type" > ^< / span > 2;
< / pre >
< / div >
< p >
We define the generalized plant as shown in Figure < a href = "#org00fe83c" > 18< / a > .
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > P = [W1 < span class = "org-type" > -< / span > W1;
0 W2;
H2w 0];
< / pre >
< / div >
< p >
And we do the \(\mathcal{H}_\infty\) synthesis using the < code > hinfsyn< / code > command.
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > [H2p, < span class = "org-type" > ~< / span > , gamma, < span class = "org-type" > ~< / span > ] = hinfsyn(P, 1, 1,< span class = "org-string" > 'TOLGAM'< / span > , 0.001, < span class = "org-string" > 'METHOD'< / span > , < span class = "org-string" > 'lmi'< / span > , < span class = "org-string" > 'DISPLAY'< / span > , < span class = "org-string" > 'on'< / span > );
< / pre >
< / div >
< p >
Finally, we define \(H_2(s)\) as the product of the synthesized filter and the wanted “ feature” :
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > H2 = H2p< span class = "org-type" > *< / span > H2w;
< / pre >
< / div >
< p >
And we define \(H_1(s)\) to be the complementary of \(H_2(s)\):
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > H1 = 1 < span class = "org-type" > -< / span > H2;
< / pre >
< / div >
< p >
The obtained complementary filters are shown in Figure < a href = "#org551ae15" > 19< / a > .
< / p >
< div id = "org551ae15" class = "figure" >
< p > < img src = "figs/comp_filters_H2_feature.png" alt = "comp_filters_H2_feature.png" / >
< / p >
< p > < span class = "figure-number" > Figure 19: < / span > Obtained complementary fitlers< / p >
< / div >
< / div >
< / div >
< div id = "outline-container-org71e3235" class = "outline-3" >
< h3 id = "org71e3235" > < span class = "section-number-3" > 5.3< / span > Imposing a negative slope at infinity frequency during the synthesis phase< / h3 >
< div class = "outline-text-3" id = "text-5-3" >
< p >
Let’ s suppose we now want to shape a low pass filter that as a negative slope until infinite frequency.
< / p >
< p >
The used technique is the same as in the previous section, and the generalized plant is shown in Figure < a href = "#org00fe83c" > 18< / a > .
< / p >
< p >
The weights are defined as usual.
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > n = 3; w0 = 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 10; G0 = 1000; G1 = 0.1; Gc = 1< span class = "org-type" > /< / span > 2;
W1 = (((1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > ((1< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)< span class = "org-type" > *< / span > (1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (1< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)))< span class = "org-type" > ^< / span > n;
n = 2; w0 = 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 11; G0 = 1< span class = "org-type" > /< / span > 10; G1 = 1000; Gc = 1< span class = "org-type" > /< / span > 2;
W2 = (((1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > ((1< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)< span class = "org-type" > *< / span > (1< span class = "org-type" > /< / span > w0)< span class = "org-type" > *< / span > sqrt((1< span class = "org-type" > -< / span > (G0< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n))< span class = "org-type" > /< / span > (1< span class = "org-type" > -< / span > (Gc< span class = "org-type" > /< / span > G1)< span class = "org-type" > ^< / span > (2< span class = "org-type" > /< / span > n)))< span class = "org-type" > *< / span > s < span class = "org-type" > +< / span > (1< span class = "org-type" > /< / span > Gc)< span class = "org-type" > ^< / span > (1< span class = "org-type" > /< / span > n)))< span class = "org-type" > ^< / span > n;
< / pre >
< / div >
< p >
This time, the feature is a low pass filter with a slope of -2 at high frequency.
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > H2w = 1< span class = "org-type" > /< / span > (s< span class = "org-type" > /< / span > (2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > 10) < span class = "org-type" > +< / span > 1)< span class = "org-type" > ^< / span > 2;
< / pre >
< / div >
< p >
The generalized plant is defined:
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > P = [W1 < span class = "org-type" > -< / span > W1;
0 W2;
H2w 0];
< / pre >
< / div >
< p >
And we do the \(\mathcal{H}_\infty\) synthesis using the < code > hinfsyn< / code > command.
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > [H2p, < span class = "org-type" > ~< / span > , gamma, < span class = "org-type" > ~< / span > ] = hinfsyn(P, 1, 1,< span class = "org-string" > 'TOLGAM'< / span > , 0.001, < span class = "org-string" > 'METHOD'< / span > , < span class = "org-string" > 'lmi'< / span > , < span class = "org-string" > 'DISPLAY'< / span > , < span class = "org-string" > 'on'< / span > );
< / pre >
< / div >
< p >
The feature is added to the synthesized filter:
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > H2 = H2p< span class = "org-type" > *< / span > H2w;
< / pre >
< / div >
< p >
And \(H_1(s)\) is defined as follows:
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > H1 = 1 < span class = "org-type" > -< / span > H2;
< / pre >
< / div >
< p >
The obtained complementary filters are shown in Figure < a href = "#org7f33e5d" > 20< / a > .
< / p >
< div id = "org7f33e5d" class = "figure" >
< p > < img src = "figs/comp_filters_H2_feature_neg_slope.png" alt = "comp_filters_H2_feature_neg_slope.png" / >
< / p >
< p > < span class = "figure-number" > Figure 20: < / span > Obtained complementary fitlers< / p >
< / div >
< / div >
< / div >
< / div >
2020-10-26 21:35:47 +01:00
< p >
< / p >
< style > . csl-entry { text-indent : -1.5 em ; margin-left : 1.5 em ; } < / style > < h2 class = 'citeproc-org-bib-h2' > Bibliography< / h2 >
< div class = "csl-bib-body" >
< div class = "csl-entry" > < a name = "citeproc_bib_item_1" > < / a > Hua, Wensheng. 2005. “Low Frequency Vibration Isolation and Alignment System for Advanced LIGO.” stanford university.< / div >
< / div >
< / div >
< div id = "postamble" class = "status" >
< p class = "author" > Author: Thomas Dehaeze< / p >
2021-04-28 15:59:35 +02:00
< p class = "date" > Created: 2020-12-11 ven. 14:05< / p >
2020-10-26 21:35:47 +01:00
< / div >
< / body >
< / html >
