test-bench-nano-hexapod/test-bench-nano-hexapod.org

#+TITLE: Nano-Hexapod - Test Bench
:DRAWER:
#+LANGUAGE: en
#+EMAIL: dehaeze.thomas@gmail.com
#+AUTHOR: Dehaeze Thomas

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

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

#+BIND: org-latex-image-default-option "scale=1"
#+BIND: org-latex-image-default-width ""

#+LaTeX_CLASS: scrreprt
#+LaTeX_CLASS_OPTIONS: [a4paper, 10pt, DIV=12, parskip=full]
#+LaTeX_HEADER_EXTRA: \input{preamble.tex}
#+LATEX_HEADER_EXTRA: \addbibresource{ref.bib}

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

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

#+begin_export html
  <hr>
  <p>This report is also available as a <a href="./test-bench-nano-hexapod.pdf">pdf</a>.</p>
  <hr>
#+end_export

#+latex: \clearpage

* Introduction                                                        :ignore:
This document is dedicated to the experimental study of the nano-hexapod shown in Figure [[fig:picture_bench_granite_nano_hexapod]].

#+name: fig:picture_bench_granite_nano_hexapod
#+caption: Nano-Hexapod
#+attr_latex: :width \linewidth
[[file:figs/IMG_20210608_152917.jpg]]

#+begin_note
Here are the documentation of the equipment used for this test bench (lots of them are shwon in Figure [[fig:picture_bench_granite_overview]]):
- Voltage Amplifier: PiezoDrive [[file:doc/PD200-V7-R1.pdf][PD200]]
- Amplified Piezoelectric Actuator: Cedrat [[file:doc/APA300ML.pdf][APA300ML]]
- DAC/ADC: Speedgoat [[file:doc/IO131-OEM-Datasheet.pdf][IO313]]
- Encoder: Renishaw [[file:doc/L-9517-9678-05-A_Data_sheet_VIONiC_series_en.pdf][Vionic]] and used [[file:doc/L-9517-9862-01-C_Data_sheet_RKLC_EN.pdf][Ruler]]
- Interferometers: Attocube
#+end_note

#+name: fig:picture_bench_granite_overview
#+caption: Nano-Hexapod and the control electronics
#+attr_latex: :width \linewidth
[[file:figs/IMG_20210608_154722.jpg]]

In Figure [[fig:nano_hexapod_signals]] is shown a block diagram of the experimental setup.
When possible, the notations are consistent with this diagram and summarized in Table [[tab:list_signals]].

#+begin_src latex :file nano_hexapod_signals.pdf
\definecolor{instrumentation}{rgb}{0, 0.447, 0.741}
\definecolor{mechanics}{rgb}{0.8500, 0.325, 0.098}

\begin{tikzpicture}
  % Blocs
  \node[block={4.0cm}{3.0cm}, fill=mechanics!20!white] (nano_hexapod) {Mechanics};
  \coordinate[] (inputF)  at (nano_hexapod.west);
  \coordinate[] (outputL) at ($(nano_hexapod.south east)!0.8!(nano_hexapod.north east)$);
  \coordinate[] (outputF) at ($(nano_hexapod.south east)!0.2!(nano_hexapod.north east)$);

  \node[block, left= 0.8 of inputF,  fill=instrumentation!20!white, align=center] (F_stack) {\tiny Actuator \\ \tiny stacks};
  \node[block, left= 0.8 of F_stack, fill=instrumentation!20!white] (PD200)   {PD200};
  \node[DAC,   left= 0.8 of PD200,   fill=instrumentation!20!white] (F_DAC)   {DAC};
  \node[block, right=0.8 of outputF, fill=instrumentation!20!white, align=center] (Fm_stack){\tiny Sensor \\ \tiny stack};
  \node[ADC,   right=0.8 of Fm_stack,fill=instrumentation!20!white] (Fm_ADC)  {ADC};
  \node[block, right=0.8 of outputL, fill=instrumentation!20!white] (encoder) {\tiny Encoder};

  % Connections and labels
  \draw[->] ($(F_DAC.west)+(-0.8,0)$) node[above right]{$\bm{u}$} node[below right]{$[V]$} -- node[sloped]{$/$} (F_DAC.west);
  \draw[->] (F_DAC.east)   -- node[midway, above]{$\tilde{\bm{u}}$}node[midway, below]{$[V]$} (PD200.west);
  \draw[->] (PD200.east)   -- node[midway, above]{$\bm{u}_a$}node[midway, below]{$[V]$} (F_stack.west);
  \draw[->] (F_stack.east) -- (inputF) node[above left]{$\bm{\tau}$}node[below left]{$[N]$};

  \draw[->] (outputF)       -- (Fm_stack.west) node[above left]{$\bm{\epsilon}$} node[below left]{$[m]$};
  \draw[->] (Fm_stack.east) -- node[midway, above]{$\tilde{\bm{\tau}}_m$}node[midway, below]{$[V]$} (Fm_ADC.west);
  \draw[->] (Fm_ADC.east)   -- node[sloped]{$/$} ++(0.8, 0)coordinate(end) node[above left]{$\bm{\tau}_m$}node[below left]{$[V]$};

  \draw[->] (outputL)      -- (encoder.west) node[above left]{$d\bm{\mathcal{L}}$} node[below left]{$[m]$};
  \draw[->] (encoder.east) -- node[sloped]{$/$} (encoder-|end) node[above left]{$d\bm{\mathcal{L}}_m$}node[below left]{$[m]$};

  % Nano-Hexapod
  \begin{scope}[on background layer]
    \node[fit={(F_stack.west|-nano_hexapod.south) (Fm_stack.east|-nano_hexapod.north)}, fill=black!20!white, draw, inner sep=2pt] (system) {};
    \node[above] at (system.north) {Nano-Hexapod};
  \end{scope}
\end{tikzpicture}
#+end_src

#+name: fig:nano_hexapod_signals
#+caption: Block diagram of the system with named signals
#+attr_latex: :scale 1
[[file:figs/nano_hexapod_signals.png]]

#+name: tab:list_signals
#+caption: List of signals
#+attr_latex: :environment tabularx :width \linewidth :align Xllll
#+attr_latex: :center t :booktabs t
|                                    | *Unit*    | *Matlab*  | *Vector*              | *Elements*           |
|------------------------------------+-----------+-----------+-----------------------+----------------------|
| Control Input (wanted DAC voltage) | =[V]=     | =u=       | $\bm{u}$              | $u_i$                |
| DAC Output Voltage                 | =[V]=     | =u=       | $\tilde{\bm{u}}$      | $\tilde{u}_i$        |
| PD200 Output Voltage               | =[V]=     | =ua=      | $\bm{u}_a$            | $u_{a,i}$            |
| Actuator applied force             | =[N]=     | =tau=     | $\bm{\tau}$           | $\tau_i$             |
|------------------------------------+-----------+-----------+-----------------------+----------------------|
| Strut motion                       | =[m]=     | =dL=      | $d\bm{\mathcal{L}}$   | $d\mathcal{L}_i$     |
| Encoder measured displacement      | =[m]=     | =dLm=     | $d\bm{\mathcal{L}}_m$ | $d\mathcal{L}_{m,i}$ |
|------------------------------------+-----------+-----------+-----------------------+----------------------|
| Force Sensor strain                | =[m]=     | =epsilon= | $\bm{\epsilon}$       | $\epsilon_i$         |
| Force Sensor Generated Voltage     | =[V]=     | =taum=    | $\tilde{\bm{\tau}}_m$ | $\tilde{\tau}_{m,i}$ |
| Measured Generated Voltage         | =[V]=     | =taum=    | $\bm{\tau}_m$         | $\tau_{m,i}$         |
|------------------------------------+-----------+-----------+-----------------------+----------------------|
| Motion of the top platform         | =[m,rad]= | =dX=      | $d\bm{\mathcal{X}}$   | $d\mathcal{X}_i$     |
| Metrology measured displacement    | =[m,rad]= | =dXm=     | $d\bm{\mathcal{X}}_m$ | $d\mathcal{X}_{m,i}$ |

This document is divided in the following sections:
- Section [[sec:encoders_struts]]: the dynamics of the nano-hexapod when the encoders are fixed to the struts is studied.
- Section [[sec:encoders_plates]]: the same is done when the encoders are fixed to the plates.
- Section [[sec:decentralized_hac_iff]]: a decentralized HAC-LAC strategy is studied and implemented.

* Encoders fixed to the Struts - Dynamics
<<sec:encoders_struts>>

** Introduction                                                      :ignore:
In this section, the encoders are fixed to the struts.

It is divided in the following sections:
- Section [[sec:enc_struts_plant_id]]: the transfer function matrix from the actuators to the force sensors and to the encoders is experimentally identified.
- Section [[sec:enc_struts_comp_simscape]]: the obtained FRF matrix is compared with the dynamics of the simscape model
- Section [[sec:enc_struts_iff]]: decentralized Integral Force Feedback (IFF) is applied and its performances are evaluated.
- Section [[sec:enc_struts_modal_analysis]]: a modal analysis of the nano-hexapod is performed

** Identification of the dynamics
<<sec:enc_struts_plant_id>>
*** Introduction                                                    :ignore:

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

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

#+begin_src matlab :tangle no
addpath('./matlab/mat/');
addpath('./matlab/src/');
addpath('./matlab/');
#+end_src

#+begin_src matlab :eval no
addpath('./mat/');
addpath('./src/');
#+end_src

*** Load Measurement Data
#+begin_src matlab
%% Load Identification Data
meas_data_lf = {};

for i = 1:6
    meas_data_lf(i) = {load(sprintf('mat/frf_data_exc_strut_%i_noise_lf.mat', i), 't', 'Va', 'Vs', 'de')};
    meas_data_hf(i) = {load(sprintf('mat/frf_data_exc_strut_%i_noise_hf.mat', i), 't', 'Va', 'Vs', 'de')};
end
#+end_src

*** Spectral Analysis - Setup
#+begin_src matlab
%% Setup useful variables
% Sampling Time [s]
Ts = (meas_data_lf{1}.t(end) - (meas_data_lf{1}.t(1)))/(length(meas_data_lf{1}.t)-1);

% Sampling Frequency [Hz]
Fs = 1/Ts;

% Hannning Windows
win = hanning(ceil(1*Fs));

% And we get the frequency vector
[~, f] = tfestimate(meas_data_lf{1}.Va, meas_data_lf{1}.de, win, [], [], 1/Ts);

i_lf = f < 250; % Points for low frequency excitation
i_hf = f > 250; % Points for high frequency excitation
#+end_src

*** Transfer function from Actuator to Encoder
First, let's compute the coherence from the excitation voltage and the displacement as measured by the encoders (Figure [[fig:enc_struts_dvf_coh]]).

#+begin_src matlab
%% Coherence
coh_dvf = zeros(length(f), 6, 6);

for i = 1:6
    coh_dvf_lf = mscohere(meas_data_lf{i}.Va, meas_data_lf{i}.de, win, [], [], 1/Ts);
    coh_dvf_hf = mscohere(meas_data_hf{i}.Va, meas_data_hf{i}.de, win, [], [], 1/Ts);
    coh_dvf(:,:,i) = [coh_dvf_lf(i_lf, :); coh_dvf_hf(i_hf, :)];
end
#+end_src

#+begin_src matlab :exports none
%% Coherence for the transfer function from u to dLm
figure;
hold on;
for i = 1:5
    for j = i+1:6
        plot(f, coh_dvf(:, i, j), 'color', [0, 0, 0, 0.2], ...
             'HandleVisibility', 'off');
    end
end
for i =1:6
    set(gca,'ColorOrderIndex',i)
    plot(f, coh_dvf(:, i, i), ...
         'DisplayName', sprintf('$G_{dvf}(%i,%i)$', i, i));
end
plot(f, coh_dvf(:, 1, 2), 'color', [0, 0, 0, 0.2], ...
     'DisplayName', '$G_{dvf}(i,j)$');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Coherence [-]');
xlim([20, 2e3]); ylim([0, 1]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);
#+end_src

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

#+name: fig:enc_struts_dvf_coh
#+caption: Obtained coherence for the DVF plant
#+RESULTS:
[[file:figs/enc_struts_dvf_coh.png]]

Then the 6x6 transfer function matrix is estimated (Figure [[fig:enc_struts_dvf_frf]]).
#+begin_src matlab
%% DVF Plant (transfer function from u to dLm)
G_dvf = zeros(length(f), 6, 6);

for i = 1:6
    G_dvf_lf = tfestimate(meas_data_lf{i}.Va, meas_data_lf{i}.de, win, [], [], 1/Ts);
    G_dvf_hf = tfestimate(meas_data_hf{i}.Va, meas_data_hf{i}.de, win, [], [], 1/Ts);
    G_dvf(:,:,i) = [G_dvf_lf(i_lf, :); G_dvf_hf(i_hf, :)];
end
#+end_src

#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:5
    for j = i+1:6
        plot(f, abs(G_dvf(:, i, j)), 'color', [0, 0, 0, 0.2], ...
             'HandleVisibility', 'off');
    end
end
for i =1:6
    set(gca,'ColorOrderIndex',i)
    plot(f, abs(G_dvf(:,i, i)), ...
         'DisplayName', sprintf('$G_{dvf}(%i,%i)$', i, i));
    set(gca,'ColorOrderIndex',i)
    plot(f, abs(G_dvf(:,i, i)), ...
         'HandleVisibility', 'off');
end
plot(f, abs(G_dvf(:, 1, 2)), 'color', [0, 0, 0, 0.2], ...
     'DisplayName', '$G_{dvf}(i,j)$');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_e/V_a$ [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-9, 1e-3]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);

ax2 = nexttile;
hold on;
for i =1:6
    set(gca,'ColorOrderIndex',i)
    plot(f, 180/pi*angle(G_dvf(:,i, i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

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

#+name: fig:enc_struts_dvf_frf
#+caption: Measured FRF for the DVF plant
#+RESULTS:
[[file:figs/enc_struts_dvf_frf.png]]

*** Transfer function from Actuator to Force Sensor
First, let's compute the coherence from the excitation voltage and the displacement as measured by the encoders (Figure [[fig:enc_struts_iff_coh]]).

#+begin_src matlab
%% Coherence for the IFF plant
coh_iff = zeros(length(f), 6, 6);

for i = 1:6
    coh_iff_lf = mscohere(meas_data_lf{i}.Va, meas_data_lf{i}.Vs, win, [], [], 1/Ts);
    coh_iff_hf = mscohere(meas_data_hf{i}.Va, meas_data_hf{i}.Vs, win, [], [], 1/Ts);
    coh_iff(:,:,i) = [coh_iff_lf(i_lf, :); coh_iff_hf(i_hf, :)];
end
#+end_src

#+begin_src matlab :exports none
%% Coherence of the IFF Plant (transfer function from u to taum)
figure;
hold on;
for i = 1:5
    for j = i+1:6
        plot(f, coh_iff(:, i, j), 'color', [0, 0, 0, 0.2], ...
             'HandleVisibility', 'off');
    end
end
for i =1:6
    set(gca,'ColorOrderIndex',i)
    plot(f, coh_iff(:,i, i), ...
         'DisplayName', sprintf('$G_{iff}(%i,%i)$', i, i));
end
plot(f, coh_iff(:, 1, 2), 'color', [0, 0, 0, 0.2], ...
     'DisplayName', '$G_{iff}(i,j)$');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Coherence [-]');
xlim([20, 2e3]); ylim([0, 1]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);
#+end_src

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

#+name: fig:enc_struts_iff_coh
#+caption: Obtained coherence for the IFF plant
#+RESULTS:
[[file:figs/enc_struts_iff_coh.png]]

Then the 6x6 transfer function matrix is estimated (Figure [[fig:enc_struts_iff_frf]]).
#+begin_src matlab
%% IFF Plant
G_iff = zeros(length(f), 6, 6);

for i = 1:6
    G_iff_lf = tfestimate(meas_data_lf{i}.Va, meas_data_lf{i}.Vs, win, [], [], 1/Ts);
    G_iff_hf = tfestimate(meas_data_hf{i}.Va, meas_data_hf{i}.Vs, win, [], [], 1/Ts);
    G_iff(:,:,i) = [G_iff_lf(i_lf, :); G_iff_hf(i_hf, :)];
end
#+end_src

#+begin_src matlab :exports none
%% Bode plot of the IFF Plant (transfer function from u to taum)
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:5
    for j = i+1:6
        plot(f, abs(G_iff(:, i, j)), 'color', [0, 0, 0, 0.2], ...
             'HandleVisibility', 'off');
    end
end
for i =1:6
    set(gca,'ColorOrderIndex',i)
    plot(f, abs(G_iff(:,i , i)), ...
         'DisplayName', sprintf('$G_{iff}(%i,%i)$', i, i));
end
plot(f, abs(G_iff(:, 1, 2)), 'color', [0, 0, 0, 0.2], ...
     'DisplayName', '$G_{iff}(i,j)$');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $V_s/V_a$ [V/V]'); set(gca, 'XTickLabel',[]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);
ylim([1e-3, 1e2]);

ax2 = nexttile;
hold on;
for i =1:6
    set(gca,'ColorOrderIndex',i)
    plot(f, 180/pi*angle(G_iff(:,i, i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

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

#+name: fig:enc_struts_iff_frf
#+caption: Measured FRF for the IFF plant
#+RESULTS:
[[file:figs/enc_struts_iff_frf.png]]

*** Save Identified Plants
#+begin_src matlab :tangle no
save('matlab/mat/identified_plants_enc_struts.mat', 'f', 'Ts', 'G_iff', 'G_dvf')
#+end_src

#+begin_src matlab :exports none :eval no
save('mat/identified_plants_enc_struts.mat', 'f', 'Ts', 'G_iff', 'G_dvf')
#+end_src

** Jacobian                                                        :noexport:
*** Introduction                                                    :ignore:
The Jacobian is used to transform the excitation force in the cartesian frame as well as the displacements.

Consider the plant shown in Figure [[fig:schematic_jacobian_in_out]] with:
- $\tau$ the 6 input voltages (going to the PD200 amplifier and then to the APA)
- $d\mathcal{L}$ the relative motion sensor outputs (encoders)
- $\bm{\tau}_m$ the generated voltage of the force sensor stacks
- $J_a$ and $J_s$ the Jacobians for the actuators and sensors

#+begin_src latex :file schematic_jacobian_in_out.pdf
\begin{tikzpicture}
  % Blocs
  \node[block={2.0cm}{2.0cm}] (P) {Plant};
  \coordinate[] (inputF)  at (P.west);
  \coordinate[] (outputL) at ($(P.south east)!0.8!(P.north east)$);
  \coordinate[] (outputF) at ($(P.south east)!0.2!(P.north east)$);

  \node[block, left= of inputF]   (Ja) {$\bm{J}^{-T}_a$};
  \node[block, right= of outputL] (Js) {$\bm{J}^{-1}_s$};
  \node[block, right= of outputF] (Jf) {$\bm{J}^{-1}_s$};

  % Connections and labels
  \draw[->] ($(Ja.west)+(-1,0)$) -- (Ja.west) node[above left]{$\bm{\mathcal{F}}$};
  \draw[->] (Ja.east) -- (inputF)  node[above left]{$\bm{\tau}$};
  \draw[->] (outputL) -- (Js.west) node[above left]{$d\bm{\mathcal{L}}$};
  \draw[->] (Js.east) -- ++(1, 0) node[above left]{$d\bm{\mathcal{X}}$};
  \draw[->] (outputF) -- (Jf.west) node[above left]{$\bm{\tau}_m$};
  \draw[->] (Jf.east) -- ++(1, 0) node[above left]{$\bm{\mathcal{F}}_m$};
\end{tikzpicture}
#+end_src

#+name: fig:schematic_jacobian_in_out
#+caption: Plant in the cartesian Frame
#+RESULTS:
[[file:figs/schematic_jacobian_in_out.png]]

First, we load the Jacobian matrix (same for the actuators and sensors).
#+begin_src matlab
load('jacobian.mat', 'J');
#+end_src

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

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

#+begin_src matlab :tangle no
addpath('./matlab/mat/');
addpath('./matlab/src/');
addpath('./matlab/');
#+end_src

#+begin_src matlab :eval no
addpath('./mat/');
addpath('./src/');
#+end_src

#+begin_src matlab
load('identified_plants_enc_struts.mat', 'f', 'Ts', 'G_iff', 'G_dvf')
load('jacobian.mat', 'J');
#+end_src

*** DVF Plant
The transfer function from $\bm{\mathcal{F}}$ to $d\bm{\mathcal{X}}$ is computed and shown in Figure [[fig:enc_struts_dvf_cart_frf]].

#+begin_src matlab
G_dvf_J = permute(pagemtimes(inv(J), pagemtimes(permute(G_dvf, [2 3 1]), inv(J'))), [3 1 2]);
#+end_src

#+begin_src matlab :exports none
labels = {'$D_x/F_{x}$', '$D_y/F_{y}$', '$D_z/F_{z}$', '$R_{x}/M_{x}$', '$R_{y}/M_{y}$', '$R_{R}/M_{z}$'};

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:5
    for j = i+1:6
        plot(f, abs(G_dvf_J(:, i, j)), 'color', [0, 0, 0, 0.2], ...
             'HandleVisibility', 'off');
    end
end
for i =1:6
    set(gca,'ColorOrderIndex',i)
    plot(f, abs(G_dvf_J(:,i , i)), ...
         'DisplayName', labels{i});
end
plot(f, abs(G_dvf_J(:, 1, 2)), 'color', [0, 0, 0, 0.2], ...
     'DisplayName', '$D_i/F_j$');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_e/V_a$ [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-7, 1e-1]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);

ax2 = nexttile;
hold on;
for i =1:6
    set(gca,'ColorOrderIndex',i)
    plot(f, 180/pi*angle(G_dvf_J(:,i , i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

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

#+name: fig:enc_struts_dvf_cart_frf
#+caption: Measured FRF for the DVF plant in the cartesian frame
#+RESULTS:
[[file:figs/enc_struts_dvf_cart_frf.png]]

*** IFF Plant
The transfer function from $\bm{\mathcal{F}}$ to $\bm{\mathcal{F}}_m$ is computed and shown in Figure [[fig:enc_struts_iff_cart_frf]].

#+begin_src matlab
G_iff_J = permute(pagemtimes(inv(J), pagemtimes(permute(G_iff, [2 3 1]), inv(J'))), [3 1 2]);
#+end_src

#+begin_src matlab :exports none
labels = {'$F_{m,x}/F_{x}$', '$F_{m,y}/F_{y}$', '$F_{m,z}/F_{z}$', '$M_{m,x}/M_{x}$', '$M_{m,y}/M_{y}$', '$M_{m,z}/M_{z}$'};

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:5
    for j = i+1:6
        plot(f, abs(G_iff_J(:, i, j)), 'color', [0, 0, 0, 0.2], ...
             'HandleVisibility', 'off');
    end
end
for i =1:6
    set(gca,'ColorOrderIndex',i)
    plot(f, abs(G_iff_J(:,i, i)), ...
         'DisplayName', labels{i});
end
plot(f, abs(G_iff_J(:, 1, 2)), 'color', [0, 0, 0, 0.2], ...
     'DisplayName', '$D_i/F_j$');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_e/V_a$ [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-3, 1e4]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);

ax2 = nexttile;
hold on;
for i =1:6
    set(gca,'ColorOrderIndex',i)
    plot(f, 180/pi*angle(G_iff_J(:,i, i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

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

#+name: fig:enc_struts_iff_cart_frf
#+caption: Measured FRF for the IFF plant in the cartesian frame
#+RESULTS:
[[file:figs/enc_struts_iff_cart_frf.png]]

** Comparison with the Simscape Model
<<sec:enc_struts_comp_simscape>>
*** Introduction                                                    :ignore:
In this section, the measured dynamics is compared with the dynamics estimated from the Simscape model.

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

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

#+begin_src matlab :tangle no
addpath('./matlab/mat/');
addpath('./matlab/src/');
addpath('./matlab/');
#+end_src

#+begin_src matlab :eval no
addpath('./mat/');
addpath('./src/');
#+end_src

#+begin_src matlab :tangle no
%% Add all useful folders to the path
addpath('matlab/nass-simscape/matlab/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/png/')
addpath('matlab/nass-simscape/src/')
addpath('matlab/nass-simscape/mat/')
#+end_src

#+begin_src matlab :eval no
%% Add all useful folders to the path
addpath('nass-simscape/matlab/nano_hexapod/')
addpath('nass-simscape/STEPS/nano_hexapod/')
addpath('nass-simscape/STEPS/png/')
addpath('nass-simscape/src/')
addpath('nass-simscape/mat/')
#+end_src

#+begin_src matlab
%% Open Simulink Model
mdl = 'nano_hexapod_simscape';

options = linearizeOptions;
options.SampleTime = 0;

Rx = zeros(1, 7);

open(mdl)
#+end_src

*** Load measured FRF

#+begin_src matlab
%% Load data
load('identified_plants_enc_struts.mat', 'f', 'Ts', 'G_iff', 'G_dvf')
#+end_src

*** Dynamics from Actuator to Force Sensors
#+begin_src matlab
%% Initialize Nano-Hexapod
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '4dof', ...
                                       'flex_top_type', '4dof', ...
                                       'motion_sensor_type', 'struts', ...
                                       'actuator_type', '2dof');
#+end_src

#+begin_src matlab
%% Identify the IFF Plant (transfer function from u to taum)
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'],  1, 'openinput');   io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/dum'],  1, 'openoutput'); io_i = io_i + 1; % Force Sensors

Giff = exp(-s*Ts)*linearize(mdl, io, 0.0, options);
#+end_src

#+begin_src matlab :exports none
%% Bode plot of the identified IFF Plant (Simscape) and measured FRF data
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
plot(f, abs(G_iff(:,1, 1)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$\tau_{m,i}/u_i$ - FRF')
for i = 2:6
    set(gca,'ColorOrderIndex',2)
    plot(f, abs(G_iff(:,i, i)), 'color', [0,0,0,0.2], ...
         'HandleVisibility', 'off');
end
set(gca,'ColorOrderIndex',2);
plot(freqs, abs(squeeze(freqresp(Giff(1,1), freqs, 'Hz'))), '-', ...
     'DisplayName', '$\tau_{m,i}/u_i$ - Model')
for i = 2:6
    set(gca,'ColorOrderIndex',2);
    plot(freqs, abs(squeeze(freqresp(Giff(i,i), freqs, 'Hz'))), '-', ...
         'HandleVisibility', 'off');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [V/V]'); set(gca, 'XTickLabel',[]);
legend('location', 'southeast');

ax2 = nexttile;
hold on;
for i = 1:6
    plot(f, 180/pi*angle(G_iff(:,i, i)), 'color', [0,0,0,0.2]);
end
for i = 1:6
    set(gca,'ColorOrderIndex',2);
    plot(freqs, 180/pi*angle(squeeze(freqresp(Giff(i,i), freqs, 'Hz'))), '-');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-180, 180]);
yticks([-180, -90, 0, 90, 180]);

linkaxes([ax1,ax2],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

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

#+name: fig:enc_struts_iff_comp_simscape
#+caption: Diagonal elements of the IFF Plant
#+RESULTS:
[[file:figs/enc_struts_iff_comp_simscape.png]]

#+begin_src matlab :exports none
%% Bode plot of the identified IFF Plant (Simscape) and measured FRF data (off-diagonal elements)
freqs = 2*logspace(1, 3, 1000);

figure;
hold on;
% Off diagonal terms
plot(f, abs(G_iff(:, 1, 2)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$\tau_{m,i}/u_j$ - FRF')
for i = 1:5
    for j = i+1:6
        plot(f, abs(G_iff(:, i, j)), 'color', [0,0,0,0.2], ...
             'HandleVisibility', 'off');
    end
end
set(gca,'ColorOrderIndex',2);
plot(freqs, abs(squeeze(freqresp(Giff(1, 2), freqs, 'Hz'))), ...
     'DisplayName', '$\tau_{m,i}/u_j$ - Model')
for i = 1:5
    for j = i+1:6
        set(gca,'ColorOrderIndex',2);
        plot(freqs, abs(squeeze(freqresp(Giff(i, j), freqs, 'Hz'))), ...
             'HandleVisibility', 'off');
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('Amplitude [V/V]');
xlim([freqs(1), freqs(end)]); ylim([1e-3, 1e2]);
legend('location', 'northeast');
#+end_src

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

#+name: fig:enc_struts_iff_comp_offdiag_simscape
#+caption: Off diagonal elements of the IFF Plant
#+RESULTS:
[[file:figs/enc_struts_iff_comp_offdiag_simscape.png]]

*** Dynamics from Actuator to Encoder
#+begin_src matlab
%% Initialization of the Nano-Hexapod
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '4dof', ...
                                       'flex_top_type', '4dof', ...
                                       'motion_sensor_type', 'struts', ...
                                       'actuator_type', 'flexible');
#+end_src

#+begin_src matlab
%% Identify the DVF Plant (transfer function from u to dLm)
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'],  1, 'openinput');  io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/D'],  1, 'openoutput'); io_i = io_i + 1; % Encoders

Gdvf = exp(-s*Ts)*linearize(mdl, io, 0.0, options);
#+end_src

#+begin_src matlab :exports none
%% Diagonal elements of the DVF plant
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
plot(f, abs(G_dvf(:,1, 1)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_i$ - FRF')
for i = 2:6
    set(gca,'ColorOrderIndex',2)
    plot(f, abs(G_dvf(:,i, i)), 'color', [0,0,0,0.2], ...
         'HandleVisibility', 'off');
end
set(gca,'ColorOrderIndex',2);
plot(freqs, abs(squeeze(freqresp(Gdvf(1,1), freqs, 'Hz'))), '-', ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_i$ - Model')
for i = 2:6
    set(gca,'ColorOrderIndex',2);
    plot(freqs, abs(squeeze(freqresp(Gdvf(i,i), freqs, 'Hz'))), '-', ...
         'HandleVisibility', 'off');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-8, 1e-3]);
legend('location', 'northeast');

ax2 = nexttile;
hold on;
for i = 1:6
    plot(f, 180/pi*angle(G_dvf(:,i, i)), 'color', [0,0,0,0.2]);
end
for i = 1:6
    set(gca,'ColorOrderIndex',2);
    plot(freqs, 180/pi*angle(squeeze(freqresp(Gdvf(i,i), freqs, 'Hz'))), '-');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-180, 180]);
yticks([-180, -90, 0, 90, 180]);

linkaxes([ax1,ax2],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

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

#+name: fig:enc_struts_dvf_comp_simscape
#+caption: Diagonal elements of the DVF Plant
#+RESULTS:
[[file:figs/enc_struts_dvf_comp_simscape.png]]

#+begin_src matlab :exports none
%% Off-diagonal elements of the DVF plant
freqs = 2*logspace(1, 3, 1000);

figure;
hold on;
% Off diagonal terms
plot(f, abs(G_dvf(:, 1, 2)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_j$ - FRF')
for i = 1:5
    for j = i+1:6
        plot(f, abs(G_dvf(:, i, j)), 'color', [0,0,0,0.2], ...
             'HandleVisibility', 'off');
    end
end
set(gca,'ColorOrderIndex',2);
plot(freqs, abs(squeeze(freqresp(Gdvf(1, 2), freqs, 'Hz'))), ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_j$ - Model')
for i = 1:5
    for j = i+1:6
        set(gca,'ColorOrderIndex',2);
        plot(freqs, abs(squeeze(freqresp(Gdvf(i, j), freqs, 'Hz'))), ...
             'HandleVisibility', 'off');
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('Amplitude [m/V]');
xlim([freqs(1), freqs(end)]); ylim([1e-8, 1e-3]);
legend('location', 'northeast');
#+end_src

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

#+name: fig:enc_struts_dvf_comp_offdiag_simscape
#+caption: Off diagonal elements of the DVF Plant
#+RESULTS:
[[file:figs/enc_struts_dvf_comp_offdiag_simscape.png]]

*** Effect of a change in bending damping of the joints
#+begin_src matlab
%% Tested bending dampings [Nm/(rad/s)]
cRs = [1e-3, 5e-3, 1e-2, 5e-2, 1e-1];
#+end_src

#+begin_src matlab
%% Identify the DVF Plant (transfer function from u to dLm)
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'],  1, 'openinput');  io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/D'],  1, 'openoutput'); io_i = io_i + 1; % Encoders
#+end_src

Then the identification is performed for all the values of the bending damping.
#+begin_src matlab
%% Idenfity the transfer function from actuator to encoder for all bending dampins
Gs = {zeros(length(cRs), 1)};

for i = 1:length(cRs)
    n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '4dof', ...
                                           'flex_top_type', '4dof', ...
                                           'motion_sensor_type', 'struts', ...
                                           'actuator_type', 'flexible', ...
                                           'flex_bot_cRx', cRs(i), ...
                                           'flex_bot_cRy', cRs(i), ...
                                           'flex_top_cRx', cRs(i), ...
                                           'flex_top_cRy', cRs(i));

    G = exp(-s*Ts)*linearize(mdl, io, 0.0, options);
    G.InputName  = {'Va1', 'Va2', 'Va3', 'Va4', 'Va5', 'Va6'};
    G.OutputName = {'dL1', 'dL2', 'dL3', 'dL4', 'dL5', 'dL6'};

    Gs(i) = {G};
end
#+end_src

#+begin_src matlab :exports none
%% Plot the obtained direct transfer functions for all the bending stiffnesses
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:length(cRs)
    plot(freqs, abs(squeeze(freqresp(Gs{i}('dL1', 'Va1'), freqs, 'Hz'))), ...
         'DisplayName', sprintf('$c_R = %.3f\\,[\\frac{Nm}{rad/s}]$', cRs(i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_L/V_a$ [m/V]'); set(gca, 'XTickLabel',[]);
hold off;
ylim([1e-8, 1e-3]);
legend('location', 'southwest');

ax2 = nexttile;
hold on;
for i = 1:length(cRs)
    plot(freqs, 180/pi*angle(squeeze(freqresp(Gs{i}('dL1', 'Va1'), freqs, 'Hz'))));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360); ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

#+begin_src matlab :exports none
%% Plot the obtained coupling transfer functions for all the bending stiffnesses
freqs = 2*logspace(1, 3, 1000);

figure;
hold on;
for i = 1:length(cRs)
    plot(freqs, abs(squeeze(freqresp(Gs{i}('dL2', 'Va1'), freqs, 'Hz'))), ...
         'DisplayName', sprintf('$c_R = %.3f\\,[\\frac{Nm}{rad/s}]$', cRs(i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_L/V_a$ [m/V]'); set(gca, 'XTickLabel',[]);
hold off;
ylim([1e-8, 1e-3]);
legend('location', 'southwest');
xlim([20, 2e3]);
#+end_src

- Could be nice
- Actual damping is very small

*** Effect of a change in damping factor of the APA
#+begin_src matlab
%% Tested bending dampings [Nm/(rad/s)]
xis = [1e-3, 5e-3, 1e-2, 5e-2, 1e-1];
#+end_src

#+begin_src matlab
%% Identify the DVF Plant (transfer function from u to dLm)
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'],  1, 'openinput');  io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/D'],  1, 'openoutput'); io_i = io_i + 1; % Encoders
#+end_src

#+begin_src matlab
%% Idenfity the transfer function from actuator to encoder for all bending dampins
Gs = {zeros(length(xis), 1)};

for i = 1:length(xis)
    n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '4dof', ...
                                           'flex_top_type', '4dof', ...
                                           'motion_sensor_type', 'struts', ...
                                           'actuator_type', 'flexible', ...
                                           'actuator_xi', xis(i));

    G = exp(-s*Ts)*linearize(mdl, io, 0.0, options);
    G.InputName  = {'Va1', 'Va2', 'Va3', 'Va4', 'Va5', 'Va6'};
    G.OutputName = {'dL1', 'dL2', 'dL3', 'dL4', 'dL5', 'dL6'};

    Gs(i) = {G};
end
#+end_src

#+begin_src matlab :exports none
%% Plot the obtained direct transfer functions for all the bending stiffnesses
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:length(xis)
    plot(freqs, abs(squeeze(freqresp(Gs{i}('dL1', 'Va1'), freqs, 'Hz'))), ...
         'DisplayName', sprintf('$\\xi = %.3f$', xis(i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_L/V_a$ [m/V]'); set(gca, 'XTickLabel',[]);
hold off;
ylim([1e-8, 1e-3]);
legend('location', 'southwest');

ax2 = nexttile;
hold on;
for i = 1:length(xis)
    plot(freqs, 180/pi*angle(squeeze(freqresp(Gs{i}('dL1', 'Va1'), freqs, 'Hz'))));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360); ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

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

#+name: fig:bode_Va_dL_effect_xi_damp
#+caption: Effect of the APA damping factor $\xi$ on the dynamics from $u$ to $d\mathcal{L}$
#+RESULTS:
[[file:figs/bode_Va_dL_effect_xi_damp.png]]

#+begin_src matlab :exports none
%% Plot the obtained coupling transfer functions for all the bending stiffnesses
freqs = 2*logspace(1, 3, 1000);

figure;
hold on;
for i = 1:length(xis)
    plot(freqs, abs(squeeze(freqresp(Gs{i}('dL2', 'Va1'), freqs, 'Hz'))), ...
         'DisplayName', sprintf('$c_R = %.3f\\,[\\frac{Nm}{rad/s}]$', xis(i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_L/V_a$ [m/V]'); set(gca, 'XTickLabel',[]);
hold off;
ylim([1e-8, 1e-3]);
legend('location', 'southwest');
xlim([20, 2e3]);
#+end_src

#+begin_important
Damping factor $\xi$ has a large impact on the damping of the "spurious resonances" at 200Hz and 300Hz.
#+end_important

#+begin_question
Why is the damping factor does not change the damping of the first peak?
#+end_question

*** Effect of a change in stiffness damping coef of the APA
#+begin_src matlab
m_coef = 1e1;
#+end_src

#+begin_src matlab
%% Tested bending dampings [Nm/(rad/s)]
k_coefs = [1e-6, 5e-6, 1e-5, 5e-5, 1e-4];
#+end_src

#+begin_src matlab
%% Identify the DVF Plant (transfer function from u to dLm)
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'],  1, 'openinput');  io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/D'],  1, 'openoutput'); io_i = io_i + 1; % Encoders
#+end_src

#+begin_src matlab
%% Idenfity the transfer function from actuator to encoder for all bending dampins
Gs = {zeros(length(k_coefs), 1)};
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '4dof', ...
                                       'flex_top_type', '4dof', ...
                                       'motion_sensor_type', 'struts', ...
                                       'actuator_type', 'flexible');

for i = 1:length(k_coefs)
    k_coef = k_coefs(i);

    G = exp(-s*Ts)*linearize(mdl, io, 0.0, options);
    G.InputName  = {'Va1', 'Va2', 'Va3', 'Va4', 'Va5', 'Va6'};
    G.OutputName = {'dL1', 'dL2', 'dL3', 'dL4', 'dL5', 'dL6'};

    Gs(i) = {G};
end
#+end_src

#+begin_src matlab :exports none
%% Plot the obtained direct transfer functions for all the bending stiffnesses
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:length(k_coefs)
    plot(freqs, abs(squeeze(freqresp(Gs{i}('dL1', 'Va1'), freqs, 'Hz'))), ...
         'DisplayName', sprintf('kcoef = %.0e', k_coefs(i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_L/V_a$ [m/V]'); set(gca, 'XTickLabel',[]);
hold off;
ylim([1e-8, 1e-3]);
legend('location', 'southwest');

ax2 = nexttile;
hold on;
for i = 1:length(k_coefs)
    plot(freqs, 180/pi*angle(squeeze(freqresp(Gs{i}('dL1', 'Va1'), freqs, 'Hz'))));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360); ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

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

#+name: fig:bode_Va_dL_effect_k_coef
#+caption: Effect of a change of the damping "stiffness coeficient" on the transfer function from $u$ to $d\mathcal{L}$
#+RESULTS:
[[file:figs/bode_Va_dL_effect_k_coef.png]]

#+begin_src matlab :exports none
%% Plot the obtained coupling transfer functions for all the bending stiffnesses
freqs = 2*logspace(1, 3, 1000);

figure;
hold on;
for i = 1:length(xis)
    plot(freqs, abs(squeeze(freqresp(Gs{i}('dL2', 'Va1'), freqs, 'Hz'))), ...
         'DisplayName', sprintf('$c_R = %.3f\\,[\\frac{Nm}{rad/s}]$', xis(i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_L/V_a$ [m/V]'); set(gca, 'XTickLabel',[]);
hold off;
ylim([1e-8, 1e-3]);
legend('location', 'southwest');
xlim([20, 2e3]);
#+end_src

*** Effect of a change in mass damping coef of the APA
#+begin_src matlab
k_coef = 1e-6;
#+end_src

#+begin_src matlab
%% Tested bending dampings [Nm/(rad/s)]
m_coefs = [1e1, 5e1, 1e2, 5e2, 1e3];
#+end_src

#+begin_src matlab
%% Identify the DVF Plant (transfer function from u to dLm)
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'],  1, 'openinput');  io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/D'],  1, 'openoutput'); io_i = io_i + 1; % Encoders
#+end_src

#+begin_src matlab
%% Idenfity the transfer function from actuator to encoder for all bending dampins
Gs = {zeros(length(m_coefs), 1)};
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '4dof', ...
                                       'flex_top_type', '4dof', ...
                                       'motion_sensor_type', 'struts', ...
                                       'actuator_type', 'flexible');

for i = 1:length(m_coefs)
    m_coef = m_coefs(i);

    G = exp(-s*Ts)*linearize(mdl, io, 0.0, options);
    G.InputName  = {'Va1', 'Va2', 'Va3', 'Va4', 'Va5', 'Va6'};
    G.OutputName = {'dL1', 'dL2', 'dL3', 'dL4', 'dL5', 'dL6'};

    Gs(i) = {G};
end
#+end_src

#+begin_src matlab :exports none
%% Plot the obtained direct transfer functions for all the bending stiffnesses
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:length(m_coefs)
    plot(freqs, abs(squeeze(freqresp(Gs{i}('dL1', 'Va1'), freqs, 'Hz'))), ...
         'DisplayName', sprintf('mcoef = %.0e', m_coefs(i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_L/V_a$ [m/V]'); set(gca, 'XTickLabel',[]);
hold off;
ylim([1e-8, 1e-3]);
legend('location', 'southwest');

ax2 = nexttile;
hold on;
for i = 1:length(m_coefs)
    plot(freqs, 180/pi*angle(squeeze(freqresp(Gs{i}('dL1', 'Va1'), freqs, 'Hz'))));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360); ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

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

#+name: fig:bode_Va_dL_effect_m_coef
#+caption: Effect of a change of the damping "mass coeficient" on the transfer function from $u$ to $d\mathcal{L}$
#+RESULTS:
[[file:figs/bode_Va_dL_effect_m_coef.png]]

#+begin_src matlab :exports none
%% Plot the obtained coupling transfer functions for all the bending stiffnesses
freqs = 2*logspace(1, 3, 1000);

figure;
hold on;
for i = 1:length(xis)
    plot(freqs, abs(squeeze(freqresp(Gs{i}('dL2', 'Va1'), freqs, 'Hz'))), ...
         'DisplayName', sprintf('$c_R = %.3f\\,[\\frac{Nm}{rad/s}]$', xis(i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_L/V_a$ [m/V]'); set(gca, 'XTickLabel',[]);
hold off;
ylim([1e-8, 1e-3]);
legend('location', 'southwest');
xlim([20, 2e3]);
#+end_src

*** TODO Using Flexible model
#+begin_src matlab
d_aligns = [[-0.05,  -0.3,  0];
            [ 0,      0.5,  0];
            [-0.1,   -0.3,  0];
            [ 0,      0.3,  0];
            [-0.05,   0.05, 0];
            [0,       0,    0]]*1e-3;
#+end_src

#+begin_src matlab
d_aligns = zeros(6,3);
% d_aligns(1,:) = [-0.05,  -0.3,  0]*1e-3;
d_aligns(2,:) = [ 0,      0.3,  0]*1e-3;
#+end_src

#+begin_src matlab
%% Initialize Nano-Hexapod
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '4dof', ...
                                       'flex_top_type', '4dof', ...
                                       'motion_sensor_type', 'struts', ...
                                       'actuator_type', 'flexible', ...
                                       'actuator_d_align', d_aligns);
#+end_src

#+begin_question
Why do we have smaller resonances when using flexible APA?
On the test bench we have the same resonance as the 2DoF model.
Could it be due to the compliance in other dof of the flexible model?
#+end_question

#+begin_src matlab
%% Identify the DVF Plant (transfer function from u to dLm)
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'],  1, 'openinput');  io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/D'],  1, 'openoutput'); io_i = io_i + 1; % Encoders

Gdvf = exp(-s*Ts)*linearize(mdl, io, 0.0, options);
#+end_src

#+begin_src matlab :exports none
%% Comparison of the plants (encoder output) when tuning the misalignment
freqs = 2*logspace(0, 3, 1000);

figure;
tiledlayout(2, 3, 'TileSpacing', 'Compact', 'Padding', 'None');
ax1 = nexttile();
hold on;
plot(f, abs(G_dvf(:, 1, 1)));
plot(freqs, abs(squeeze(freqresp(Gdvf(1,1), freqs, 'Hz'))));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
set(gca, 'XTickLabel',[]); ylabel('Amplitude [m/V]');

ax2 = nexttile();
hold on;
plot(f, abs(G_dvf(:, 2, 2)));
plot(freqs, abs(squeeze(freqresp(Gdvf(2,2), freqs, 'Hz'))));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
set(gca, 'XTickLabel',[]); set(gca, 'YTickLabel',[]);

ax3 = nexttile();
hold on;
plot(f, abs(G_dvf(:, 3, 3)), 'DisplayName', 'Meas.');
plot(freqs, abs(squeeze(freqresp(Gdvf(3,3), freqs, 'Hz'))), ...
     'DisplayName', 'Model');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
set(gca, 'XTickLabel',[]); set(gca, 'YTickLabel',[]);
legend('location', 'southwest', 'FontSize', 8);

ax4 = nexttile();
hold on;
plot(f, abs(G_dvf(:, 4, 4)));
plot(freqs, abs(squeeze(freqresp(Gdvf(4,4), freqs, 'Hz'))));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('Amplitude [m/V]');

ax5 = nexttile();
hold on;
plot(f, abs(G_dvf(:, 5, 5)));
plot(freqs, abs(squeeze(freqresp(Gdvf(5,5), freqs, 'Hz'))));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); set(gca, 'YTickLabel',[]);

ax6 = nexttile();
hold on;
plot(f, abs(G_dvf(:, 6, 6)));
plot(freqs, abs(squeeze(freqresp(Gdvf(6,6), freqs, 'Hz'))));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); set(gca, 'YTickLabel',[]);

linkaxes([ax1,ax2,ax3,ax4,ax5,ax6],'xy');
% xlim([20, 2e3]); ylim([1e-8, 1e-3]);
xlim([50, 5e2]); ylim([1e-6, 1e-3]);
#+end_src

#+begin_src matlab :exports none
%% Diagonal elements of the DVF plant
freqs = 6*logspace(1, 2, 2000);

i_strut = 1;

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
plot(f, abs(G_dvf(:,i_strut, 2)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_i$ - FRF')
plot(freqs, abs(squeeze(freqresp(Gdvf(2,2), freqs, 'Hz'))), '-', ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_i$ - Model')
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-8, 1e-3]);
legend('location', 'northeast');

ax2 = nexttile;
hold on;
plot(f, 180/pi*angle(G_dvf(:,2, 2)), 'color', [0,0,0,0.2]);
plot(freqs, 180/pi*angle(squeeze(freqresp(Gdvf(2,2), freqs, 'Hz'))), '-');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-180, 180]);
yticks([-180, -90, 0, 90, 180]);

linkaxes([ax1,ax2],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

#+begin_src matlab :exports none
%% Diagonal elements of the DVF plant
freqs = 6*logspace(1, 2, 2000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
plot(f, abs(G_dvf(:,1, 1)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_i$ - FRF')
for i = 2:6
    set(gca,'ColorOrderIndex',2)
    plot(f, abs(G_dvf(:,i, i)), 'color', [0,0,0,0.2], ...
         'HandleVisibility', 'off');
end
set(gca,'ColorOrderIndex',2);
plot(freqs, abs(squeeze(freqresp(Gdvf(1,1), freqs, 'Hz'))), '-', ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_i$ - Model')
for i = 2:6
    set(gca,'ColorOrderIndex',2);
    plot(freqs, abs(squeeze(freqresp(Gdvf(i,i), freqs, 'Hz'))), '-', ...
         'HandleVisibility', 'off');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-8, 1e-3]);
legend('location', 'northeast');

ax2 = nexttile;
hold on;
for i = 1:6
    plot(f, 180/pi*angle(G_dvf(:,i, i)), 'color', [0,0,0,0.2]);
end
for i = 1:6
    set(gca,'ColorOrderIndex',2);
    plot(freqs, 180/pi*angle(squeeze(freqresp(Gdvf(i,i), freqs, 'Hz'))), '-');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-180, 180]);
yticks([-180, -90, 0, 90, 180]);

linkaxes([ax1,ax2],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

#+begin_src matlab
%% Identify the IFF Plant (transfer function from u to taum)
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'],  1, 'openinput');   io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/dum'],  1, 'openoutput'); io_i = io_i + 1; % Force Sensors

Giff = exp(-s*Ts)*linearize(mdl, io, 0.0, options);
#+end_src

#+begin_src matlab :exports none
%% Bode plot of the identified IFF Plant (Simscape) and measured FRF data
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
plot(f, abs(G_iff(:,1, 1)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$\tau_{m,i}/u_i$ - FRF')
for i = 2:6
    set(gca,'ColorOrderIndex',2)
    plot(f, abs(G_iff(:,i, i)), 'color', [0,0,0,0.2], ...
         'HandleVisibility', 'off');
end
set(gca,'ColorOrderIndex',2);
plot(freqs, abs(squeeze(freqresp(Giff(1,1), freqs, 'Hz'))), '-', ...
     'DisplayName', '$\tau_{m,i}/u_i$ - Model')
for i = 2:6
    set(gca,'ColorOrderIndex',2);
    plot(freqs, abs(squeeze(freqresp(Giff(i,i), freqs, 'Hz'))), '-', ...
         'HandleVisibility', 'off');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [V/V]'); set(gca, 'XTickLabel',[]);
legend('location', 'southeast');

ax2 = nexttile;
hold on;
for i = 1:6
    plot(f, 180/pi*angle(G_iff(:,i, i)), 'color', [0,0,0,0.2]);
end
for i = 1:6
    set(gca,'ColorOrderIndex',2);
    plot(freqs, 180/pi*angle(squeeze(freqresp(Giff(i,i), freqs, 'Hz'))), '-');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-180, 180]);
yticks([-180, -90, 0, 90, 180]);

linkaxes([ax1,ax2],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

*** Flexible model + encoders fixed to the plates
#+begin_src matlab
%% Identify the IFF Plant (transfer function from u to taum)
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'],  1, 'openinput');   io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/D'],  1, 'openoutput'); io_i = io_i + 1; % Force Sensors
#+end_src

#+begin_src matlab
d_aligns = [[-0.05,  -0.3,  0];
            [ 0,      0.5,  0];
            [-0.1,   -0.3,  0];
            [ 0,      0.3,  0];
            [-0.05,   0.05, 0];
            [0,       0,    0]]*1e-3;
#+end_src

#+begin_src matlab
%% Initialize Nano-Hexapod
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '4dof', ...
                                       'flex_top_type', '4dof', ...
                                       'motion_sensor_type', 'struts', ...
                                       'actuator_type', 'flexible', ...
                                       'actuator_d_align', d_aligns);
#+end_src

#+begin_src matlab
Gdvf_struts = exp(-s*Ts)*linearize(mdl, io, 0.0, options);
#+end_src

#+begin_src matlab
%% Initialize Nano-Hexapod
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '4dof', ...
                                       'flex_top_type', '4dof', ...
                                       'motion_sensor_type', 'plates', ...
                                       'actuator_type', 'flexible', ...
                                       'actuator_d_align', d_aligns);
#+end_src

#+begin_src matlab
Gdvf_plates = exp(-s*Ts)*linearize(mdl, io, 0.0, options);
#+end_src

#+begin_src matlab :exports none
%% Plot the obtained direct transfer functions for all the bending stiffnesses
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
plot(freqs, abs(squeeze(freqresp(Gdvf_struts(1, 1), freqs, 'Hz'))), ...
     'DisplayName', 'Struts');
plot(freqs, abs(squeeze(freqresp(Gdvf_plates(1, 1), freqs, 'Hz'))), ...
     'DisplayName', 'Plates');
for i = 2:6
    set(gca,'ColorOrderIndex',1);
    plot(freqs, abs(squeeze(freqresp(Gdvf_struts(i, i), freqs, 'Hz'))), ...
         'HandleVisibility', 'off');
    set(gca,'ColorOrderIndex',2);
    plot(freqs, abs(squeeze(freqresp(Gdvf_plates(i, i), freqs, 'Hz'))), ...
         'HandleVisibility', 'off');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_L/V_a$ [m/V]'); set(gca, 'XTickLabel',[]);
hold off;
ylim([1e-8, 1e-3]);
legend('location', 'southwest');

ax2 = nexttile;
hold on;
for i = 1:6
    set(gca,'ColorOrderIndex',1);
    plot(freqs, 180/pi*angle(squeeze(freqresp(Gdvf_struts(i, i), freqs, 'Hz'))));
    set(gca,'ColorOrderIndex',2);
    plot(freqs, 180/pi*angle(squeeze(freqresp(Gdvf_plates(i, i), freqs, 'Hz'))));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360); ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

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

#+name: fig:dvf_plant_comp_struts_plates
#+caption: Comparison of the dynamics from $V_a$ to $d_L$ when the encoders are fixed to the struts (blue) and to the plates (red). APA are modeled as a flexible element.
#+RESULTS:
[[file:figs/dvf_plant_comp_struts_plates.png]]

** Integral Force Feedback
<<sec:enc_struts_iff>>
*** Introduction                                                    :ignore:

In this section, the Integral Force Feedback (IFF) control strategy is applied to the nano-hexapod.
The main goal of this to add damping to the nano-hexapod's modes.

The control architecture is shown in Figure [[fig:control_architecture_iff_struts]] where $\bm{K}_\text{IFF}$ is a diagonal $6 \times 6$ controller.

The system as then a new input $\bm{u}^\prime$, and the transfer function from $\bm{u}^\prime$ to $d\bm{\mathcal{L}}_m$ should be easier to control than the initial transfer function from $\bm{u}$ to $d\bm{\mathcal{L}}_m$.

#+begin_src latex :file control_architecture_iff_struts.pdf
\begin{tikzpicture}
  % Blocs
  \node[block={3.0cm}{2.0cm}] (P) {Plant};
  \coordinate[] (inputF) at ($(P.south west)!0.5!(P.north west)$);
  \coordinate[] (outputF) at ($(P.south east)!0.7!(P.north east)$);
  \coordinate[] (outputL) at ($(P.south east)!0.3!(P.north east)$);

  \node[block, above=0.4 of P] (Kiff) {$\bm{K}_\text{IFF}$};
  \node[addb, left= of inputF] (addF) {};

  % Connections and labels
  \draw[->] (outputF) -- ++(1, 0) node[below left]{$\bm{\tau}_m$};
  \draw[->] (outputL) -- ++(1, 0) node[below left]{$d\bm{\mathcal{L}}_m$};

  \draw[->] ($(outputF) + (0.6, 0)$)node[branch]{} |- (Kiff.east);
  \draw[->] (Kiff.west) -| (addF.north);
  \draw[->] (addF.east) -- (inputF) node[above left]{$\bm{u}$};
  \draw[<-] (addF.west) -- ++(-1, 0) node[above right]{$\bm{u}^\prime$};
\end{tikzpicture}
#+end_src

#+name: fig:control_architecture_iff_struts
#+caption: Integral Force Feedback Strategy
#+RESULTS:
[[file:figs/control_architecture_iff_struts.png]]

This section is structured as follow:
- Section [[sec:iff_struts_plant_id]]: Using the Simscape model (APA taken as 2DoF model), the transfer function from $\bm{u}$ to $\bm{\tau}_m$ is identified. Based on the obtained dynamics, the control law is developed and the optimal gain is estimated using the Root Locus.
- Section [[sec:iff_struts_effect_plant]]: Still using the Simscape model, the effect of the IFF gain on the the transfer function from $\bm{u}^\prime$ to $d\bm{\mathcal{L}}_m$ is studied.
- Section [[sec:iff_struts_effect_plant_exp]]: The same is performed experimentally: several IFF gains are used and the damped plant is identified each time.
- Section [[sec:iff_struts_opt_gain]]: The damped model and the identified damped system are compared for the optimal IFF gain. It is found that IFF indeed adds a lot of damping into the system. However it is not efficient in damping the spurious struts modes.
- Section [[sec:iff_struts_comp_flex_model]]: Finally, a "flexible" model of the APA is used in the Simscape model and the optimally damped model is compared with the measurements.

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

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

#+begin_src matlab :tangle no
addpath('./matlab/mat/');
addpath('./matlab/src/');
addpath('./matlab/');
#+end_src

#+begin_src matlab :eval no
addpath('./mat/');
addpath('./src/');
#+end_src

#+begin_src matlab
load('identified_plants_enc_struts.mat', 'f', 'Ts', 'G_iff', 'G_dvf')
#+end_src

#+begin_src matlab :tangle no
%% Add all useful folders to the path
addpath('matlab/nass-simscape/matlab/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/png/')
addpath('matlab/nass-simscape/src/')
addpath('matlab/nass-simscape/mat/')
#+end_src

#+begin_src matlab :eval no
%% Add all useful folders to the path
addpath('nass-simscape/matlab/nano_hexapod/')
addpath('nass-simscape/STEPS/nano_hexapod/')
addpath('nass-simscape/STEPS/png/')
addpath('nass-simscape/src/')
addpath('nass-simscape/mat/')
#+end_src

#+begin_src matlab
%% Open Simulink Model
mdl = 'nano_hexapod_simscape';

options = linearizeOptions;
options.SampleTime = 0;

Rx = zeros(1, 7);

open(mdl)
#+end_src

*** IFF Control Law and Optimal Gain
<<sec:iff_struts_plant_id>>

Let's use a model of the Nano-Hexapod with the encoders fixed to the struts and the APA taken as 2DoF model.
#+begin_src matlab
%% Initialize Nano-Hexapod
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '4dof', ...
                                       'flex_top_type', '4dof', ...
                                       'motion_sensor_type', 'struts', ...
                                       'actuator_type', '2dof');
#+end_src

The transfer function from $\bm{u}$ to $\bm{\tau}_m$ is identified.
#+begin_src matlab
%% Identify the IFF Plant (transfer function from u to taum)
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'],  1, 'openinput');   io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/dum'],  1, 'openoutput'); io_i = io_i + 1; % Force Sensors

Giff = exp(-s*Ts)*linearize(mdl, io, 0.0, options);
#+end_src

The IFF controller is defined as shown below:
#+begin_src matlab
%% IFF Controller
Kiff_g1 = -(1/(s + 2*pi*40))*...    % LPF: provides integral action above 40Hz
           (s/(s + 2*pi*30))*...    % HPF: limit low frequency gain
           (1/(1 + s/2/pi/500))*... % LPF: more robust to high frequency resonances
           eye(6);                  % Diagonal 6x6 controller
#+end_src

Then, the poles of the system are shown in the complex plane as a function of the controller gain (i.e. Root Locus plot) in Figure [[fig:enc_struts_iff_root_locus]].
A gain of $400$ is chosen as the "optimal" gain as it visually seems to be the gain that adds the maximum damping to all the suspension modes simultaneously.

#+begin_src matlab :exports none
%% Root Locus for IFF
gains = logspace(1, 4, 100);

figure;

hold on;
% Pure Integrator
set(gca,'ColorOrderIndex',1);
plot(real(pole(Giff)),  imag(pole(Giff)), 'x', 'DisplayName', '$g = 0$');
set(gca,'ColorOrderIndex',1);
plot(real(tzero(Giff)),  imag(tzero(Giff)), 'o', 'HandleVisibility', 'off');

for g = gains
    clpoles = pole(feedback(Giff, g*Kiff_g1*eye(6)));
    set(gca,'ColorOrderIndex',1);
    plot(real(clpoles), imag(clpoles), '.', 'HandleVisibility', 'off');
end

g = 4e2;
clpoles = pole(feedback(Giff, g*Kiff_g1*eye(6)));
set(gca,'ColorOrderIndex',2);
plot(real(clpoles), imag(clpoles), 'x', 'DisplayName', sprintf('$g=%.0f$', g));
hold off;
axis square;
xlim([-1250, 0]); ylim([0, 1250]);
xlabel('Real Part'); ylabel('Imaginary Part');
legend('location', 'northwest');
#+end_src

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

#+name: fig:enc_struts_iff_root_locus
#+caption: Root Locus for the IFF control strategy
#+RESULTS:
[[file:figs/enc_struts_iff_root_locus.png]]

Then the "optimal" IFF controller is:
#+begin_src matlab
%% IFF controller with Optimal gain
Kiff = 400*Kiff_g1;
#+end_src

And it is saved for further use.
#+begin_src matlab :exports none :tangle no
save('matlab/mat/Kiff.mat', 'Kiff')
#+end_src

#+begin_src matlab :eval no
save('mat/Kiff.mat', 'Kiff')
#+end_src

The bode plots of the "diagonal" elements of the loop gain are shown in Figure [[fig:enc_struts_iff_opt_loop_gain]].
It is shown that the phase and gain margins are quite high and the loop gain is large arround the resonances.
#+begin_src matlab :exports none
%% Bode plot of the "decentralized loop gain"
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
plot(f, abs(squeeze(freqresp(Kiff(1,1), f, 'Hz')).*G_iff(:, 1, 1)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$\tau_{m,i}/u_i \cdot K_{iff}$ - FRF')
for i = 2:6
    set(gca,'ColorOrderIndex',2)
    plot(f, abs(squeeze(freqresp(Kiff(1,1), f, 'Hz')).*G_iff(:, i, i)), 'color', [0,0,0,0.2], ...
         'HandleVisibility', 'off');
end
set(gca,'ColorOrderIndex',2);
plot(freqs, abs(squeeze(freqresp(Kiff(1,1)*Giff(1,1), freqs, 'Hz'))), '-', ...
     'DisplayName', '$\tau_{m,i}/u_i \cdot K_{iff}$ - Model')
for i = 2:6
    set(gca,'ColorOrderIndex',2);
    plot(freqs, abs(squeeze(freqresp(Kiff(1,1)*Giff(i,i), freqs, 'Hz'))), '-', ...
         'HandleVisibility', 'off');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [V/V]'); set(gca, 'XTickLabel',[]);
legend('location', 'northeast');

ax2 = nexttile;
hold on;
for i = 1:6
    plot(f, 180/pi*angle(squeeze(freqresp(Kiff(1,1), f, 'Hz')).*G_iff(:, i, i)), 'color', [0,0,0,0.2]);
end
for i = 1:6
    set(gca,'ColorOrderIndex',2);
    plot(freqs, 180/pi*angle(squeeze(freqresp(Kiff(1,1)*Giff(i,i), freqs, 'Hz'))), '-');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-180, 180]);
yticks([-180, -90, 0, 90, 180]);

linkaxes([ax1,ax2],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

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

#+name: fig:enc_struts_iff_opt_loop_gain
#+caption: Bode plot of the "decentralized loop gain" $G_\text{iff}(i,i) \times K_\text{iff}(i,i)$
#+RESULTS:
[[file:figs/enc_struts_iff_opt_loop_gain.png]]

*** Effect of IFF on the plant - Simulations
<<sec:iff_struts_effect_plant>>

Still using the Simscape model with encoders fixed to the struts and 2DoF APA, the IFF strategy is tested.
#+begin_src matlab
%% Initialize the Simscape model in closed loop
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '4dof', ...
                                       'flex_top_type', '4dof', ...
                                       'motion_sensor_type', 'struts', ...
                                       'actuator_type', '2dof', ...
                                       'controller_type', 'iff');
#+end_src

The following IFF gains are tried:
#+begin_src matlab
%% Tested IFF gains
iff_gains = [4, 10, 20, 40, 100, 200, 400];
#+end_src

And the transfer functions from $\bm{u}^\prime$ to $d\bm{\mathcal{L}}_m$ are identified for all the IFF gains.
#+begin_src matlab
%% Identify the (damped) transfer function from u to dLm for different values of the IFF gain
Gd_iff = {zeros(1, length(iff_gains))};

clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'], 1, 'openinput');  io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/dL'], 1, 'openoutput'); io_i = io_i + 1; % Strut Displacement (encoder)

for i = 1:length(iff_gains)
    Kiff = iff_gains(i)*Kiff_g1*eye(6); % IFF Controller
    Gd_iff(i) = {exp(-s*Ts)*linearize(mdl, io, 0.0, options)};

    isstable(Gd_iff{i})
end
#+end_src

The obtained dynamics are shown in Figure [[fig:enc_struts_iff_gains_effect_dvf_plant]].
#+begin_src matlab :exports none
%% Bode plot of the transfer function from u to dLm for tested values of the IFF gain
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:length(iff_gains)
    plot(freqs, abs(squeeze(freqresp(Gd_iff{i}(1,1), freqs, 'Hz'))), '-', ...
         'DisplayName', sprintf('$g = %.0f$', iff_gains(i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/V]'); set(gca, 'XTickLabel',[]);
legend('location', 'northeast', 'FontSize', 8, 'NumColumns', 2);

ax2 = nexttile;
hold on;
for i = 1:length(iff_gains)
    plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_iff{i}(1,1), freqs, 'Hz'))), '-');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-180, 180]);
yticks([-180, -90, 0, 90, 180]);

linkaxes([ax1,ax2],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

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

#+name: fig:enc_struts_iff_gains_effect_dvf_plant
#+caption: Effect of the IFF gain $g$ on the transfer function from $\bm{\tau}$ to $d\bm{\mathcal{L}}_m$
#+RESULTS:
[[file:figs/enc_struts_iff_gains_effect_dvf_plant.png]]

*** Effect of IFF on the plant - Experimental Results
<<sec:iff_struts_effect_plant_exp>>

**** Introduction                                                  :ignore:
The IFF strategy is applied experimentally and the transfer function from $\bm{u}^\prime$ to $d\bm{\mathcal{L}}_m$ is identified for all the defined values of the gain.

**** Load Data
First load the identification data.
#+begin_src matlab
%% Load Identification Data
meas_iff_gains = {};

for i = 1:length(iff_gains)
    meas_iff_gains(i) = {load(sprintf('mat/iff_strut_1_noise_g_%i.mat', iff_gains(i)), 't', 'Vexc', 'Vs', 'de', 'u')};
end
#+end_src

**** Spectral Analysis - Setup
And define the useful variables that will be used for the identification using the =tfestimate= function.
#+begin_src matlab
%% Setup useful variables
% Sampling Time [s]
Ts = (meas_iff_gains{1}.t(end) - (meas_iff_gains{1}.t(1)))/(length(meas_iff_gains{1}.t)-1);

% Sampling Frequency [Hz]
Fs = 1/Ts;

% Hannning Windows
win = hanning(ceil(1*Fs));

% And we get the frequency vector
[~, f] = tfestimate(meas_iff_gains{1}.Vexc, meas_iff_gains{1}.de, win, [], [], 1/Ts);
#+end_src

**** DVF Plant
The transfer functions are estimated for all the values of the gain.
#+begin_src matlab
%% DVF Plant (transfer function from u to dLm)
G_iff_gains = {};

for i = 1:length(iff_gains)
    G_iff_gains{i} = tfestimate(meas_iff_gains{i}.Vexc, meas_iff_gains{i}.de(:,1), win, [], [], 1/Ts);
end
#+end_src

The obtained dynamics as shown in the bode plot in Figure [[fig:comp_iff_gains_dvf_plant]].
The dashed curves are the results obtained using the model, and the solid curves the results from the experimental identification.
#+begin_src matlab :exports none
%% Bode plot of the transfer function from u to dLm for tested values of the IFF gain
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:length(iff_gains)
    plot(f, abs(G_iff_gains{i}), '-', ...
         'DisplayName', sprintf('$g = %.0f$', iff_gains(i)));
end
set(gca,'ColorOrderIndex',1)
for i = 1:length(iff_gains)
    plot(freqs, abs(squeeze(freqresp(Gd_iff{i}(1,1), freqs, 'Hz'))), '--', ...
         'HandleVisibility', 'off');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/V]'); set(gca, 'XTickLabel',[]);
legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 2);

ax2 = nexttile;
hold on;
for i =1:length(iff_gains)
    plot(f, 180/pi*angle(G_iff_gains{i}), '-');
end
set(gca,'ColorOrderIndex',1)
for i = 1:length(iff_gains)
    plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_iff{i}(1,1), freqs, 'Hz'))), '--');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-180, 180]);
yticks([-180, -90, 0, 90, 180]);

linkaxes([ax1,ax2],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

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

#+name: fig:comp_iff_gains_dvf_plant
#+caption: Transfer function from $u$ to $d\mathcal{L}_m$ for multiple values of the IFF gain
#+RESULTS:
[[file:figs/comp_iff_gains_dvf_plant.png]]

The bode plot is then zoomed on the suspension modes of the nano-hexapod in Figure [[fig:comp_iff_gains_dvf_plant_zoom]].
#+begin_src matlab :exports none
xlim([20, 200]);
#+end_src

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

#+name: fig:comp_iff_gains_dvf_plant_zoom
#+caption: Transfer function from $u$ to $d\mathcal{L}_m$ for multiple values of the IFF gain (Zoom)
#+RESULTS:
[[file:figs/comp_iff_gains_dvf_plant_zoom.png]]

#+begin_important
The IFF control strategy is very effective for the damping of the suspension modes.
It however does not damp the modes at 200Hz, 300Hz and 400Hz (flexible modes of the APA).

Also, the experimental results and the models obtained from the Simscape model are in agreement concerning the damped system (up to the flexible modes).
#+end_important

**** Experimental Results - Comparison of the un-damped and fully damped system
The un-damped and damped experimental plants are compared in Figure [[fig:comp_undamped_opt_iff_gain_diagonal]] (diagonal terms).

It is very clear that all the suspension modes are very well damped thanks to IFF.
However, there is little to no effect on the flexible modes of the struts and of the plate.

#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
% Un Damped measurement
set(gca,'ColorOrderIndex',1)
plot(f, abs(G_dvf(:, 1, 1)), ...
     'DisplayName', 'Un-Damped')
for i = 2:6
    set(gca,'ColorOrderIndex',1)
    plot(f, abs(G_dvf(:,i , i)), ...
         'HandleVisibility', 'off');
end

% IFF Damped measurement
set(gca,'ColorOrderIndex',2)
plot(f, abs(G_iff_opt{1}(:,1)), ...
     'DisplayName', 'Optimal gain')
for i = 2:6
    set(gca,'ColorOrderIndex',2)
    plot(f, abs(G_iff_opt{i}(:,i)), ...
         'HandleVisibility', 'off');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_e/V_{exc}$ [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-9, 1e-3]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);

ax2 = nexttile;
hold on;
for i =1:6
    set(gca,'ColorOrderIndex',1)
    plot(f, 180/pi*angle(G_dvf(i,i, i)));
    set(gca,'ColorOrderIndex',2)
    plot(f, 180/pi*angle(G_iff_opt{i}(:,i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

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

#+name: fig:comp_undamped_opt_iff_gain_diagonal
#+caption: Comparison of the diagonal elements of the tranfer function from $\bm{u}$ to $d\bm{\mathcal{L}}_m$ without active damping and with optimal IFF gain
#+RESULTS:
[[file:figs/comp_undamped_opt_iff_gain_diagonal.png]]

*** Experimental Results - Damped Plant with Optimal gain
<<sec:iff_struts_opt_gain>>
**** Introduction                                                  :ignore:
Let's now look at the $6 \times 6$ damped plant with the optimal gain $g = 400$.

**** Load Data
The experimental data are loaded.
#+begin_src matlab
%% Load Identification Data
meas_iff_struts = {};

for i = 1:6
    meas_iff_struts(i) = {load(sprintf('mat/iff_strut_%i_noise_g_400.mat', i), 't', 'Vexc', 'Vs', 'de', 'u')};
end
#+end_src

**** Spectral Analysis - Setup
And the parameters useful for the spectral analysis are defined.
#+begin_src matlab
%% Setup useful variables
% Sampling Time [s]
Ts = (meas_iff_struts{1}.t(end) - (meas_iff_struts{1}.t(1)))/(length(meas_iff_struts{1}.t)-1);

% Sampling Frequency [Hz]
Fs = 1/Ts;

% Hannning Windows
win = hanning(ceil(1*Fs));

% And we get the frequency vector
[~, f] = tfestimate(meas_iff_struts{1}.Vexc, meas_iff_struts{1}.de, win, [], [], 1/Ts);
#+end_src

**** DVF Plant
Finally, the $6 \times 6$ plant is identified using the =tfestimate= function.
#+begin_src matlab
%% DVF Plant (transfer function from u to dLm)
G_iff_opt = {};

for i = 1:6
    G_iff_opt{i} = tfestimate(meas_iff_struts{i}.Vexc, meas_iff_struts{i}.de, win, [], [], 1/Ts);
end
#+end_src

The obtained diagonal elements are compared with the model in Figure [[fig:damped_iff_plant_comp_diagonal]].
#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
% Diagonal Elements FRF
plot(f, abs(G_iff_opt{1}(:,1)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_i$ - FRF')
for i = 2:6
    plot(f, abs(G_iff_opt{i}(:,i)), 'color', [0,0,0,0.2], ...
         'HandleVisibility', 'off');
end

% Diagonal Elements Model
set(gca,'ColorOrderIndex',2)
plot(freqs, abs(squeeze(freqresp(Gd_iff{end}(1,1), freqs, 'Hz'))), '-', ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_i$ - Model')
for i = 2:6
    set(gca,'ColorOrderIndex',2)
    plot(freqs, abs(squeeze(freqresp(Gd_iff{end}(i,i), freqs, 'Hz'))), '-', ...
         'HandleVisibility', 'off');
end

hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_e/V_{exc}$ [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-9, 1e-3]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);

ax2 = nexttile;
hold on;
for i =1:6
    plot(f, 180/pi*angle(G_iff_opt{i}(:,i)), 'color', [0,0,0,0.2]);
    set(gca,'ColorOrderIndex',2)
    plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_iff{end}(i,i), freqs, 'Hz'))));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

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

#+name: fig:damped_iff_plant_comp_diagonal
#+caption: Comparison of the diagonal elements of the transfer functions from $\bm{u}$ to $d\bm{\mathcal{L}}_m$ with active damping (IFF) applied with an optimal gain $g = 400$
#+RESULTS:
[[file:figs/damped_iff_plant_comp_diagonal.png]]

And all the off-diagonal elements are compared with the model in Figure [[fig:damped_iff_plant_comp_off_diagonal]].
#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
% Off diagonal FRF
plot(f, abs(G_iff_opt{1}(:,2)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_j$ - FRF')
for i = 1:5
    for j = i+1:6
        plot(f, abs(G_iff_opt{i}(:,j)), 'color', [0, 0, 0, 0.2], ...
             'HandleVisibility', 'off');
    end
end

% Off diagonal Model
set(gca,'ColorOrderIndex',2)
plot(freqs, abs(squeeze(freqresp(Gd_iff{end}(1,2), freqs, 'Hz'))), '-', ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_j$ - Model')
for i = 1:5
    for j = i+1:6
        set(gca,'ColorOrderIndex',2)
        plot(freqs, abs(squeeze(freqresp(Gd_iff{end}(i,j), freqs, 'Hz'))), ...
             'HandleVisibility', 'off');
    end
end

hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_e/V_{exc}$ [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-9, 1e-3]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);

ax2 = nexttile;
hold on;
% Off diagonal FRF
for i = 1:5
    for j = i+1:6
        plot(f, 180/pi*angle(G_iff_opt{i}(:,j)), 'color', [0, 0, 0, 0.2]);
    end
end

% Off diagonal Model
for i = 1:5
    for j = i+1:6
        set(gca,'ColorOrderIndex',2)
        plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_iff{end}(i,j), freqs, 'Hz'))));
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

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

#+name: fig:damped_iff_plant_comp_off_diagonal
#+caption: Comparison of the off-diagonal elements of the transfer functions from $\bm{u}$ to $d\bm{\mathcal{L}}_m$ with active damping (IFF) applied with an optimal gain $g = 400$
#+RESULTS:
[[file:figs/damped_iff_plant_comp_off_diagonal.png]]

#+begin_important
With the IFF control strategy applied and the optimal gain used, the suspension modes are very well damped.
Remains the un-damped flexible modes of the APA (200Hz, 300Hz, 400Hz), and the modes of the plates (700Hz).

The Simscape model and the experimental results are in very good agreement.
#+end_important

*** Comparison with the Flexible model
<<sec:iff_struts_comp_flex_model>>

When using the 2-DoF model for the APA, the flexible modes of the struts were not modelled, and it was the main limitation of the model.
Now, let's use a flexible model for the APA, and see if the obtained damped plant using the model is similar to the measured dynamics.

First, the nano-hexapod is initialized.
#+begin_src matlab
%% Estimated misalignement of the struts
d_aligns = [[-0.05,  -0.3,  0];
            [ 0,      0.5,  0];
            [-0.1,   -0.3,  0];
            [ 0,      0.3,  0];
            [-0.05,   0.05, 0];
            [0,       0,    0]]*1e-3;


%% Initialize Nano-Hexapod
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '4dof', ...
                                       'flex_top_type', '4dof', ...
                                       'motion_sensor_type', 'struts', ...
                                       'actuator_type', 'flexible', ...
                                       'actuator_d_align', d_aligns, ...
                                       'controller_type', 'iff');
#+end_src

And the "optimal" controller is loaded.
#+begin_src matlab
%% Optimal IFF controller
load('Kiff.mat', 'Kiff');
#+end_src

The transfer function from $\bm{u}^\prime$ to $d\bm{\mathcal{L}}_m$ is identified using the Simscape model.
#+begin_src matlab
%% Linearized inputs/outputs
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'],  1, 'openinput');  io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/dL'],  1, 'openoutput'); io_i = io_i + 1; % Strut Displacement (encoder)

%% Identification of the plant
Gd_iff = exp(-s*Ts)*linearize(mdl, io, 0.0, options);
#+end_src

The obtained diagonal elements are shown in Figure [[fig:enc_struts_iff_opt_damp_comp_flex_model_diag]] while the off-diagonal elements are shown in Figure [[fig:enc_struts_iff_opt_damp_comp_flex_model_off_diag]].
#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
% Diagonal Elements FRF
plot(f, abs(G_iff_opt{1}(:,1)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u^\prime_i$ - FRF')
for i = 2:6
    plot(f, abs(G_iff_opt{i}(:,i)), 'color', [0,0,0,0.2], ...
         'HandleVisibility', 'off');
end

% Diagonal Elements Model
set(gca,'ColorOrderIndex',2)
plot(freqs, abs(squeeze(freqresp(Gd_iff(1,1), freqs, 'Hz'))), '-', ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u^\prime_i$ - Model')
for i = 2:6
    set(gca,'ColorOrderIndex',2)
    plot(freqs, abs(squeeze(freqresp(Gd_iff(i,i), freqs, 'Hz'))), '-', ...
         'HandleVisibility', 'off');
end

hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d\mathcal{L}_m/u^\prime$ [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-9, 1e-3]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);

ax2 = nexttile;
hold on;
for i =1:6
    plot(f, 180/pi*angle(G_iff_opt{i}(:,i)), 'color', [0,0,0,0.2]);
    set(gca,'ColorOrderIndex',2)
    plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_iff(i,i), freqs, 'Hz'))));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

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

#+name: fig:enc_struts_iff_opt_damp_comp_flex_model_diag
#+caption: Diagonal elements of the transfer function from $\bm{u}^\prime$ to $d\bm{\mathcal{L}}_m$ - comparison of the measured FRF and the identified dynamics using the flexible model
#+RESULTS:
[[file:figs/enc_struts_iff_opt_damp_comp_flex_model_diag.png]]


#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
% Off diagonal FRF
plot(f, abs(G_iff_opt{1}(:,2)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u^\prime_j$ - FRF')
for i = 1:5
    for j = i+1:6
        plot(f, abs(G_iff_opt{i}(:,j)), 'color', [0, 0, 0, 0.2], ...
             'HandleVisibility', 'off');
    end
end

% Off diagonal Model
set(gca,'ColorOrderIndex',2)
plot(freqs, abs(squeeze(freqresp(Gd_iff(1,2), freqs, 'Hz'))), '-', ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u^\prime_j$ - Model')
for i = 1:5
    for j = i+1:6
        set(gca,'ColorOrderIndex',2)
        plot(freqs, abs(squeeze(freqresp(Gd_iff(i,j), freqs, 'Hz'))), ...
             'HandleVisibility', 'off');
    end
end

hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d\mathcal{L}_m/u^\prime$ [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-9, 1e-3]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);

ax2 = nexttile;
hold on;
% Off diagonal FRF
for i = 1:5
    for j = i+1:6
        plot(f, 180/pi*angle(G_iff_opt{i}(:,j)), 'color', [0, 0, 0, 0.2]);
    end
end

% Off diagonal Model
for i = 1:5
    for j = i+1:6
        set(gca,'ColorOrderIndex',2)
        plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_iff(i,j), freqs, 'Hz'))));
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

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

#+name: fig:enc_struts_iff_opt_damp_comp_flex_model_off_diag
#+caption: Off-diagonal elements of the transfer function from $\bm{u}^\prime$ to $d\bm{\mathcal{L}}_m$ - comparison of the measured FRF and the identified dynamics using the flexible model
#+RESULTS:
[[file:figs/enc_struts_iff_opt_damp_comp_flex_model_off_diag.png]]

#+begin_important
Using flexible models for the APA, the agreement between the Simscape model of the nano-hexapod and the measured FRF is very good.

Only the flexible mode of the top-plate is not appearing in the model which is very logical as the top plate is taken as a solid body.
#+end_important

*** Conclusion
#+begin_important
The decentralized Integral Force Feedback strategy applied on the nano-hexapod is very effective in damping all the suspension modes.

The Simscape model (especially when using a flexible model for the APA) is shown to be very accurate, even when IFF is applied.
#+end_important

** Modal Analysis
<<sec:enc_struts_modal_analysis>>

*** Introduction                                                    :ignore:
Several 3-axis accelerometers are fixed on the top platform of the nano-hexapod as shown in Figure [[fig:compliance_vertical_comp_iff]].

#+name: fig:accelerometers_nano_hexapod
#+caption: Location of the accelerometers on top of the nano-hexapod
#+attr_latex: :width \linewidth
[[file:figs/accelerometers_nano_hexapod.jpg]]

The top platform is then excited using an instrumented hammer as shown in Figure [[fig:hammer_excitation_compliance_meas]].

#+name: fig:hammer_excitation_compliance_meas
#+caption: Example of an excitation using an instrumented hammer
#+attr_latex: :width \linewidth
[[file:figs/hammer_excitation_compliance_meas.jpg]]

From this experiment, the resonance frequencies and the associated mode shapes can be computed (Section [[sec:modal_analysis_mode_shapes]]).
Then, in Section [[sec:compliance_effect_iff]], the vertical compliance of the nano-hexapod is experimentally estimated.
Finally, in Section [[sec:compliance_effect_iff_comp_model]], the measured compliance is compare with the estimated one from the Simscape model.

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

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

#+begin_src matlab :tangle no
addpath('./matlab/mat/');
addpath('./matlab/src/');
addpath('./matlab/');
#+end_src

#+begin_src matlab :eval no
addpath('./mat/');
addpath('./src/');
#+end_src

#+begin_src matlab :tangle no
%% Add all useful folders to the path
addpath('matlab/nass-simscape/matlab/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/png/')
addpath('matlab/nass-simscape/src/')
addpath('matlab/nass-simscape/mat/')
#+end_src

#+begin_src matlab :eval no
%% Add all useful folders to the path
addpath('nass-simscape/matlab/nano_hexapod/')
addpath('nass-simscape/STEPS/nano_hexapod/')
addpath('nass-simscape/STEPS/png/')
addpath('nass-simscape/src/')
addpath('nass-simscape/mat/')
#+end_src

#+begin_src matlab
%% Open Simulink Model
mdl = 'nano_hexapod_simscape';

options = linearizeOptions;
options.SampleTime = 0;

Rx = zeros(1, 7);

open(mdl)
#+end_src

*** Obtained Mode Shapes
<<sec:modal_analysis_mode_shapes>>

We can observe the mode shapes of the first 6 modes that are the suspension modes (the plate is behaving as a solid body) in Figure [[fig:mode_shapes_annotated]].

#+name: fig:mode_shapes_annotated
#+caption: Measured mode shapes for the first six modes
#+attr_latex: :width \linewidth
[[file:figs/mode_shapes_annotated.gif]]

Then, there is a mode at 692Hz which corresponds to a flexible mode of the top plate (Figure [[fig:mode_shapes_flexible_annotated]]).

#+name: fig:mode_shapes_flexible_annotated
#+caption: First flexible mode at 692Hz
#+attr_latex: :width 0.3\linewidth
[[file:figs/ModeShapeFlex1_crop.gif]]

The obtained modes are summarized in Table [[tab:description_modes]].

#+name: tab:description_modes
#+caption: Description of the identified modes
#+attr_latex: :environment tabularx :width 0.7\linewidth :align ccX
#+attr_latex: :center t :booktabs t
| *Mode* | *Freq. [Hz]* | *Description*                                |
|--------+--------------+----------------------------------------------|
|      1 |          105 | Suspension Mode: Y-translation               |
|      2 |          107 | Suspension Mode: X-translation               |
|      3 |          131 | Suspension Mode: Z-translation               |
|      4 |          161 | Suspension Mode: Y-tilt                      |
|      5 |          162 | Suspension Mode: X-tilt                      |
|      6 |          180 | Suspension Mode: Z-rotation                  |
|      7 |          692 | (flexible) Membrane mode of the top platform |

*** Nano-Hexapod Compliance - Effect of IFF
<<sec:compliance_effect_iff>>

In this section, we wish to estimated the effectiveness of the IFF strategy concerning the compliance.

The top plate is excited vertically using the instrumented hammer two times:
1. no control loop is used
2. decentralized IFF is used

The data is loaded.
#+begin_src matlab
frf_ol  = load('Measurement_Z_axis.mat'); % Open-Loop
frf_iff = load('Measurement_Z_axis_damped.mat'); % IFF
#+end_src

The mean vertical motion of the top platform is computed by averaging all 5 accelerometers.
#+begin_src matlab
%% Multiply by 10 (gain in m/s^2/V) and divide by 5 (number of accelerometers)
d_frf_ol = 10/5*(frf_ol.FFT1_H1_4_1_RMS_Y_Mod + frf_ol.FFT1_H1_7_1_RMS_Y_Mod + frf_ol.FFT1_H1_10_1_RMS_Y_Mod + frf_ol.FFT1_H1_13_1_RMS_Y_Mod + frf_ol.FFT1_H1_16_1_RMS_Y_Mod)./(2*pi*frf_ol.FFT1_H1_16_1_RMS_X_Val).^2;
d_frf_iff = 10/5*(frf_iff.FFT1_H1_4_1_RMS_Y_Mod + frf_iff.FFT1_H1_7_1_RMS_Y_Mod + frf_iff.FFT1_H1_10_1_RMS_Y_Mod + frf_iff.FFT1_H1_13_1_RMS_Y_Mod + frf_iff.FFT1_H1_16_1_RMS_Y_Mod)./(2*pi*frf_iff.FFT1_H1_16_1_RMS_X_Val).^2;
#+end_src

The vertical compliance (magnitude of the transfer function from a vertical force applied on the top plate to the vertical motion of the top plate) is shown in Figure [[fig:compliance_vertical_comp_iff]].
#+begin_src matlab :exports none
figure;
hold on;
plot(frf_ol.FFT1_H1_16_1_RMS_X_Val,  d_frf_ol, 'DisplayName', 'OL');
plot(frf_iff.FFT1_H1_16_1_RMS_X_Val, d_frf_iff, 'DisplayName', 'IFF');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('Vertical Compliance [$m/N$]');
xlim([20, 2e3]); ylim([2e-9, 2e-5]);
legend('location', 'northeast');
#+end_src

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

#+name: fig:compliance_vertical_comp_iff
#+caption: Measured vertical compliance with and without IFF
#+RESULTS:
[[file:figs/compliance_vertical_comp_iff.png]]

#+begin_important
From Figure [[fig:compliance_vertical_comp_iff]], it is clear that the IFF control strategy is very effective in damping the suspensions modes of the nano-hexapod.
It also has the effect of (slightly) degrading the vertical compliance at low frequency.

It also seems some damping can be added to the modes at around 205Hz which are flexible modes of the struts.
#+end_important

*** Comparison with the Simscape Model
<<sec:compliance_effect_iff_comp_model>>

Let's now compare the measured vertical compliance with the vertical compliance as estimated from the Simscape model.

The transfer function from a vertical external force to the absolute motion of the top platform is identified (with and without IFF) using the Simscape model.
#+begin_src matlab :exports none
%% Identify the IFF Plant (transfer function from u to taum)
clear io; io_i = 1;
io(io_i) = linio([mdl, '/duz_ext'],     1, 'openinput');  io_i = io_i + 1; % External - Vertical force
io(io_i) = linio([mdl, '/Z_top_plat'], 1, 'openoutput'); io_i = io_i + 1; % Absolute vertical motion of top platform

%% Initialize Nano-Hexapod in Open Loop
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '4dof', ...
                                       'flex_top_type', '4dof', ...
                                       'motion_sensor_type', 'struts', ...
                                       'actuator_type', '2dof');

G_compl_z_ol = linearize(mdl, io, 0.0, options);

%% Initialize Nano-Hexapod with IFF
Kiff = 400*(1/(s + 2*pi*40))*... % Low pass filter (provides integral action above 40Hz)
           (s/(s + 2*pi*30))*... % High pass filter to limit low frequency gain
           (1/(1 + s/2/pi/500))*... % Low pass filter to be more robust to high frequency resonances
           eye(6); % Diagonal 6x6 controller

n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '4dof', ...
                                       'flex_top_type', '4dof', ...
                                       'motion_sensor_type', 'struts', ...
                                       'actuator_type', '2dof', ...
                                       'controller_type', 'iff');

G_compl_z_iff = linearize(mdl, io, 0.0, options);
#+end_src

The comparison is done in Figure [[fig:compliance_vertical_comp_model_iff]].
Again, the model is quite accurate!
#+begin_src matlab :exports none
%% Comparison of the measured compliance and the one obtained from the model
freqs = 2*logspace(1,3,1000);

figure;
hold on;
plot(frf_ol.FFT1_H1_16_1_RMS_X_Val,  d_frf_ol,  '-', 'DisplayName', 'OL - Meas.');
plot(frf_iff.FFT1_H1_16_1_RMS_X_Val, d_frf_iff, '-', 'DisplayName', 'IFF - Meas.');
set(gca,'ColorOrderIndex',1)
plot(freqs, abs(squeeze(freqresp(G_compl_z_ol,  freqs, 'Hz'))), '--', 'DisplayName', 'OL - Model')
plot(freqs, abs(squeeze(freqresp(G_compl_z_iff, freqs, 'Hz'))), '--', 'DisplayName', 'IFF - Model')
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('Vertical Compliance [$m/N$]');
xlim([20, 2e3]); ylim([2e-9, 2e-5]);
legend('location', 'northeast', 'FontSize', 8);
#+end_src

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

#+name: fig:compliance_vertical_comp_model_iff
#+caption: Measured vertical compliance with and without IFF
#+RESULTS:
[[file:figs/compliance_vertical_comp_model_iff.png]]

** TODO Accelerometers fixed on the top platform                   :noexport:
*** Introduction                                                    :ignore:

#+name: fig:acc_top_plat_top_view
#+caption: Accelerometers fixed on the top platform
#+attr_latex: :width \linewidth
[[file:figs/acc_top_plat_top_view.jpg]]

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

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

#+begin_src matlab :tangle no
addpath('./matlab/mat/');
addpath('./matlab/src/');
addpath('./matlab/');
#+end_src

#+begin_src matlab :eval no
addpath('./mat/');
addpath('./src/');
#+end_src

#+begin_src matlab :tangle no
%% Add all useful folders to the path
addpath('matlab/nass-simscape/matlab/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/png/')
addpath('matlab/nass-simscape/src/')
addpath('matlab/nass-simscape/mat/')
#+end_src

#+begin_src matlab :eval no
%% Add all useful folders to the path
addpath('nass-simscape/matlab/nano_hexapod/')
addpath('nass-simscape/STEPS/nano_hexapod/')
addpath('nass-simscape/STEPS/png/')
addpath('nass-simscape/src/')
addpath('nass-simscape/mat/')
#+end_src

#+begin_src matlab
%% Open Simulink Model
mdl = 'nano_hexapod_simscape';

options = linearizeOptions;
options.SampleTime = 0;

Rx = zeros(1, 7);

open(mdl)
#+end_src

*** Experimental Identification
#+begin_src matlab
%% Load Identification Data
meas_acc = {};

for i = 1:6
    meas_acc(i) = {load(sprintf('mat/meas_acc_top_plat_strut_%i.mat', i), 't', 'Va', 'de', 'Am')};
end
#+end_src

#+begin_src matlab
%% Setup useful variables
% Sampling Time [s]
Ts = (meas_acc{1}.t(end) - (meas_acc{1}.t(1)))/(length(meas_acc{1}.t)-1);

% Sampling Frequency [Hz]
Fs = 1/Ts;

% Hannning Windows
win = hanning(ceil(1*Fs));

% And we get the frequency vector
[~, f] = tfestimate(meas_acc{1}.Va, meas_acc{1}.de, win, [], [], 1/Ts);
#+end_src

The sensibility of the accelerometers are $0.1 V/g \approx 0.01 V/(m/s^2)$.
#+begin_src matlab
%% Compute the 6x6 transfer function matrix
G_acc = zeros(length(f), 6, 6);

for i = 1:6
    G_acc(:,:,i) = tfestimate(meas_acc{i}.Va, 1/0.01*meas_acc{i}.Am, win, [], [], 1/Ts);
end
#+end_src

*** Location and orientation of accelerometers
#+begin_src matlab
Opm = [ 0.047, -0.112, 10e-3;
        0.047, -0.112, 10e-3;
       -0.113,  0.011, 10e-3;
       -0.113,  0.011, 10e-3;
        0.040,  0.113, 10e-3;
        0.040,  0.113, 10e-3]';

Osm = [-1,  0, 0;
        0,  0, 1;
        0, -1, 0;
        0,  0, 1;
       -1,  0, 0;
        0,  0, 1]';

#+end_src

*** COM
#+begin_src matlab
Hbm = -15e-3;

M = getTransformationMatrixAcc(Opm-[0;0;Hbm], Osm);
J = getJacobianNanoHexapod(Hbm);
#+end_src

#+begin_src matlab
G_acc_CoM = zeros(size(G_acc));

for i = 1:length(f)
    G_acc_CoM(i, :, :) = inv(M)*squeeze(G_acc(i, :, :))*inv(J');
end
#+end_src

#+begin_src matlab :exports none
labels = {'$D_x/F_{x}$', '$D_y/F_{y}$', '$D_z/F_{z}$', '$R_{x}/M_{x}$', '$R_{y}/M_{y}$', '$R_{R}/M_{z}$'};

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:2
    for j = i+1:3
        plot(f, abs(G_acc_CoM(:, i, j)./(-(2*pi*f).^2)), 'color', [0, 0, 0, 0.2], ...
             'HandleVisibility', 'off');
    end
end
for i =1:3
    set(gca,'ColorOrderIndex',i)
    plot(f, abs(G_acc_CoM(:,i , i)./(-(2*pi*f).^2)), ...
         'DisplayName', labels{i});
end
plot(f, abs(G_acc_CoM(:, 1, 2)./(-(2*pi*f).^2)), 'color', [0, 0, 0, 0.2], ...
     'DisplayName', '$D_i/F_j$');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $A_m/V_a$ [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-9, 1e-5]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);

ax2 = nexttile;
hold on;
for i =1:3
    set(gca,'ColorOrderIndex',i)
    plot(f, 180/pi*angle(G_acc_CoM(:,i , i)./(-(2*pi*f).^2)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

#+begin_src matlab :exports none
labels = {'$D_x/F_{x}$', '$D_y/F_{y}$', '$D_z/F_{z}$', '$R_{x}/M_{x}$', '$R_{y}/M_{y}$', '$R_{R}/M_{z}$'};

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i =1:6
    set(gca,'ColorOrderIndex',i)
    plot(f, abs(G_acc_CoM(:,i , i)./(-(2*pi*f).^2)), ...
         'DisplayName', labels{i});
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $A_m/V_a$ [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-9, 1e-3]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);

ax2 = nexttile;
hold on;
for i =1:6
    set(gca,'ColorOrderIndex',i)
    plot(f, 180/pi*angle(G_acc_CoM(:,i , i)./(-(2*pi*f).^2)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);

linkaxes([ax1,ax2],'x');
xlim([50, 5e2]);
#+end_src

*** COK
#+begin_src matlab
Hbm = -42.3e-3;

M = getTransformationMatrixAcc(Opm-[0;0;Hbm], Osm);
J = getJacobianNanoHexapod(Hbm);
#+end_src

#+begin_src matlab
G_acc_CoK = zeros(size(G_acc));

for i = 1:length(f)
    G_acc_CoK(i, :, :) = inv(M)*squeeze(G_acc(i, :, :))*inv(J');
end
#+end_src

#+begin_src matlab :exports none
labels = {'$D_x/F_{x}$', '$D_y/F_{y}$', '$D_z/F_{z}$', '$R_{x}/M_{x}$', '$R_{y}/M_{y}$', '$R_{R}/M_{z}$'};

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:2
    for j = i+1:3
        plot(f, abs(G_acc_CoK(:, i, j)./(-(2*pi*f).^2)), 'color', [0, 0, 0, 0.2], ...
             'HandleVisibility', 'off');
    end
end
for i =1:3
    set(gca,'ColorOrderIndex',i)
    plot(f, abs(G_acc_CoK(:,i , i)./(-(2*pi*f).^2)), ...
         'DisplayName', labels{i});
end
plot(f, abs(G_acc_CoK(:, 1, 2)./(-(2*pi*f).^2)), 'color', [0, 0, 0, 0.2], ...
     'DisplayName', '$D_i/F_j$');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $A_m/V_a$ [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-9, 1e-5]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);

ax2 = nexttile;
hold on;
for i =1:3
    set(gca,'ColorOrderIndex',i)
    plot(f, 180/pi*angle(G_acc_CoK(:,i , i)./(-(2*pi*f).^2)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

#+begin_src matlab :exports none
labels = {'$D_x/\mathcal{F}_x$', '$D_y/\mathcal{F}_y$', '$D_z/\mathcal{F}_z$', ...
          '$R_x/\mathcal{M}_x$', '$R_y/\mathcal{M}_y$', '$R_z/\mathcal{M}_z$'};

figure;
hold on;
for i =1:6
    set(gca,'ColorOrderIndex',i)
    plot(f, abs(G_acc_CoK(:,i,i)./(-(2*pi*f).^2)), ...
         'DisplayName', labels{i});
end
plot(f, abs(G_acc_CoK(:,1,2)./(-(2*pi*f).^2)), 'color', [0, 0, 0, 0.2], ...
    'DisplayName', 'Off-Diagonal');
for i = 1:5
    for j = i+1:6
        plot(f, abs(G_acc_CoK(:,i,j)./(-(2*pi*f).^2)), 'color', [0, 0, 0, 0.2], ...
             'HandleVisibility', 'off');
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('Amplitude $X_m/V_a$ [m/V]');
xlim([50, 5e2]); ylim([1e-7, 1e-1]);
legend('location', 'southwest');
#+end_src

*** Comp with the Simscape Model
#+begin_src matlab
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '4dof', ...
                                       'flex_top_type', '4dof', ...
                                       'motion_sensor_type', 'struts', ...
                                       'actuator_type', 'flexible', ...
                                       'MO_B', -42.3e-3);
#+end_src

#+begin_src matlab
%% Input/Output definition
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'],  1, 'openinput');  io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/D'],  1, 'openoutput'); io_i = io_i + 1; % Relative Motion Outputs

G = linearize(mdl, io, 0.0, options);
G.InputName  = {'F1', 'F2', 'F3', 'F4', 'F5', 'F6'};
G.OutputName = {'D1', 'D2', 'D3', 'D4', 'D5', 'D6'};
#+end_src

Then use the Jacobian matrices to obtain the "cartesian" centralized plant.
#+begin_src matlab
Gc = inv(n_hexapod.geometry.J)*...
     G*...
     inv(n_hexapod.geometry.J');
#+end_src

#+begin_src matlab :exports none
freqs = 2*logspace(1, 3, 1000);

labels = {'$D_x/\mathcal{F}_x$', '$D_y/\mathcal{F}_y$', '$D_z/\mathcal{F}_z$', ...
          '$R_x/\mathcal{M}_x$', '$R_y/\mathcal{M}_y$', '$R_z/\mathcal{M}_z$'};

figure;
hold on;
for i = 1:6
    plot(freqs, abs(squeeze(freqresp(Gc(i,i), freqs, 'Hz'))), '-', ...
         'DisplayName', labels{i});
end
plot(freqs, abs(squeeze(freqresp(Gc(1, 2), freqs, 'Hz'))), 'color', [0, 0, 0, 0.2], ...
    'DisplayName', 'Off-Diagonal');
for i = 1:5
    for j = i+1:6
        plot(freqs, abs(squeeze(freqresp(Gc(i, j), freqs, 'Hz'))), 'color', [0, 0, 0, 0.2], ...
             'HandleVisibility', 'off');
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('Amplitude [m/N,rad/N/m]');
xlim([50, 5e2]); ylim([1e-7, 1e-1]);
legend('location', 'southwest');
#+end_src

** Conclusion
#+begin_important
From the previous analysis, several conclusions can be drawn:
- Decentralized IFF is very effective in damping the "suspension" modes of the nano-hexapod (Figure [[fig:comp_undamped_opt_iff_gain_diagonal]])
- Decentralized IFF does not damp the "spurious" modes of the struts nor the flexible modes of the top plate (Figure [[fig:comp_undamped_opt_iff_gain_diagonal]])
- Even though the Simscape model and the experimentally measured FRF are in good agreement (Figures [[fig:enc_struts_iff_opt_damp_comp_flex_model_diag]] and [[fig:enc_struts_iff_opt_damp_comp_flex_model_off_diag]]), the obtain dynamics from the control inputs $\bm{u}$ and the encoders $d\bm{\mathcal{L}}_m$ is very difficult to control

Therefore, in the following sections, the encoders will be fixed to the plates.
The goal is to be less sensitive to the flexible modes of the struts.
#+end_important

* Encoders fixed to the plates - Dynamics
<<sec:encoders_plates>>

** Introduction                                                      :ignore:
In this section, the encoders are fixed to the plates rather than to the struts as shown in Figure [[fig:enc_fixed_to_struts]].

#+name: fig:enc_fixed_to_struts
#+caption: Nano-Hexapod with encoders fixed to the struts
#+attr_latex: :width \linewidth
[[file:figs/IMG_20210625_083801.jpg]]

It is structured as follow:
- Section [[sec:enc_plates_plant_id]]: The dynamics of the nano-hexapod is identified.
- Section [[sec:enc_plates_comp_simscape]]: The identified dynamics is compared with the Simscape model.
- Section [[sec:enc_plates_iff]]: The Integral Force Feedback (IFF) control strategy is applied and the dynamics of the damped nano-hexapod is identified and compare with the Simscape model.

** Identification of the dynamics
<<sec:enc_plates_plant_id>>
*** Introduction                                                    :ignore:
In this section, the dynamics of the nano-hexapod with the encoders fixed to the plates is identified.

First, the measurement data are loaded in Section [[sec:enc_plates_plant_id_setup]], then the transfer function matrix from the actuators to the encoders are estimated in Section [[sec:enc_plates_plant_id_dvf]].
Finally, the transfer function matrix from the actuators to the force sensors is estimated in Section [[sec:enc_plates_plant_id_iff]].

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

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

#+begin_src matlab :tangle no
addpath('./matlab/mat/');
addpath('./matlab/src/');
addpath('./matlab/');
#+end_src

#+begin_src matlab :eval no
addpath('./mat/');
addpath('./src/');
#+end_src

*** Data Loading and Spectral Analysis Setup
<<sec:enc_plates_plant_id_setup>>

The actuators are excited one by one using a low pass filtered white noise.
For each excitation, the 6 force sensors and 6 encoders are measured and saved.
#+begin_src matlab
%% Load Identification Data
meas_data_lf = {};

for i = 1:6
    meas_data_lf(i) = {load(sprintf('mat/frf_exc_strut_%i_enc_plates_noise.mat', i), 't', 'Va', 'Vs', 'de')};
end
#+end_src

#+begin_src matlab :exports none
%% Setup useful variables
% Sampling Time [s]
Ts = (meas_data_lf{1}.t(end) - (meas_data_lf{1}.t(1)))/(length(meas_data_lf{1}.t)-1);

% Sampling Frequency [Hz]
Fs = 1/Ts;

% Hannning Windows
win = hanning(ceil(1*Fs));

% And we get the frequency vector
[~, f] = tfestimate(meas_data_lf{1}.Va, meas_data_lf{1}.de, win, [], [], 1/Ts);
#+end_src

*** Transfer function from Actuator to Encoder
<<sec:enc_plates_plant_id_dvf>>

Let's compute the coherence from the excitation voltage $\bm{u}$ and the displacement $d\bm{\mathcal{L}}_m$ as measured by the encoders.
#+begin_src matlab
%% Coherence
coh_dvf = zeros(length(f), 6, 6);

for i = 1:6
    coh_dvf(:, :, i) = mscohere(meas_data_lf{i}.Va, meas_data_lf{i}.de, win, [], [], 1/Ts);
end
#+end_src

The obtained coherence shown in Figure [[fig:enc_plates_dvf_coh]] is quite good up to 400Hz.

#+begin_src matlab :exports none
%% Coherence for the transfer function from u to dLm
figure;
hold on;
for i = 1:5
    for j = i+1:6
        plot(f, coh_dvf(:, i, j), 'color', [0, 0, 0, 0.2], ...
             'HandleVisibility', 'off');
    end
end
for i =1:6
    set(gca,'ColorOrderIndex',i)
    plot(f, coh_dvf(:, i, i), ...
         'DisplayName', sprintf('$G_{dvf}(%i,%i)$', i, i));
end
plot(f, coh_dvf(:, 1, 2), 'color', [0, 0, 0, 0.2], ...
     'DisplayName', '$G_{dvf}(i,j)$');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Coherence [-]');
xlim([20, 2e3]); ylim([0, 1]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);
#+end_src

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

#+name: fig:enc_plates_dvf_coh
#+caption: Obtained coherence for the DVF plant
#+RESULTS:
[[file:figs/enc_plates_dvf_coh.png]]

Then the 6x6 transfer function matrix is estimated.
#+begin_src matlab
%% DVF Plant (transfer function from u to dLm)
G_dvf = zeros(length(f), 6, 6);

for i = 1:6
    G_dvf(:,:,i) = tfestimate(meas_data_lf{i}.Va, meas_data_lf{i}.de, win, [], [], 1/Ts);
end
#+end_src

The diagonal and off-diagonal terms of this transfer function matrix are shown in Figure [[fig:enc_plates_dvf_frf]].
#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:5
    for j = i+1:6
        plot(f, abs(G_dvf(:, i, j)), 'color', [0, 0, 0, 0.2], ...
             'HandleVisibility', 'off');
    end
end
for i =1:6
    set(gca,'ColorOrderIndex',i)
    plot(f, abs(G_dvf(:,i, i)), ...
         'DisplayName', sprintf('$G_{dvf}(%i,%i)$', i, i));
end
plot(f, abs(G_dvf(:, 1, 2)), 'color', [0, 0, 0, 0.2], ...
     'DisplayName', '$G_{dvf}(i,j)$');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_e/V_a$ [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-9, 1e-3]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);

ax2 = nexttile;
hold on;
for i =1:6
    set(gca,'ColorOrderIndex',i)
    plot(f, 180/pi*angle(G_dvf(:,i, i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

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

#+name: fig:enc_plates_dvf_frf
#+caption: Measured FRF for the DVF plant
#+RESULTS:
[[file:figs/enc_plates_dvf_frf.png]]

#+begin_important
From Figure [[fig:enc_plates_dvf_frf]], we can draw few conclusions on the transfer functions from $\bm{u}$ to $d\bm{\mathcal{L}}_m$ when the encoders are fixed to the plates:
- the decoupling is rather good at low frequency (below the first suspension mode).
  The low frequency gain is constant for the off diagonal terms, whereas when the encoders where fixed to the struts, the low frequency gain of the off-diagonal terms were going to zero (Figure [[fig:enc_struts_dvf_frf]]).
- the flexible modes of the struts at 226Hz and 337Hz are indeed shown in the transfer functions, but their amplitudes are rather low.
- the diagonal terms have alternating poles and zeros up to at least 600Hz: the flexible modes of the struts are not affecting the alternating pole/zero pattern. This what not the case when the encoders were fixed to the struts (Figure [[fig:enc_struts_dvf_frf]]).
#+end_important

*** Transfer function from Actuator to Force Sensor
<<sec:enc_plates_plant_id_iff>>

Let's now compute the coherence from the excitation voltage $\bm{u}$ and the voltage $\bm{\tau}_m$ generated by the Force senors.
#+begin_src matlab
%% Coherence for the IFF plant
coh_iff = zeros(length(f), 6, 6);

for i = 1:6
    coh_iff(:,:,i) = mscohere(meas_data_lf{i}.Va, meas_data_lf{i}.Vs, win, [], [], 1/Ts);
end
#+end_src

The coherence is shown in Figure [[fig:enc_plates_iff_coh]], and is very good for from 10Hz up to 2kHz.
#+begin_src matlab :exports none
%% Coherence of the IFF Plant (transfer function from u to taum)
figure;
hold on;
for i = 1:5
    for j = i+1:6
        plot(f, coh_iff(:, i, j), 'color', [0, 0, 0, 0.2], ...
             'HandleVisibility', 'off');
    end
end
for i =1:6
    set(gca,'ColorOrderIndex',i)
    plot(f, coh_iff(:,i, i), ...
         'DisplayName', sprintf('$G_{iff}(%i,%i)$', i, i));
end
plot(f, coh_iff(:, 1, 2), 'color', [0, 0, 0, 0.2], ...
     'DisplayName', '$G_{iff}(i,j)$');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Coherence [-]');
xlim([20, 2e3]); ylim([0, 1]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);
#+end_src

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

#+name: fig:enc_plates_iff_coh
#+caption: Obtained coherence for the IFF plant
#+RESULTS:
[[file:figs/enc_plates_iff_coh.png]]

Then the 6x6 transfer function matrix is estimated.
#+begin_src matlab
%% IFF Plant
G_iff = zeros(length(f), 6, 6);

for i = 1:6
    G_iff(:,:,i) = tfestimate(meas_data_lf{i}.Va, meas_data_lf{i}.Vs, win, [], [], 1/Ts);
end
#+end_src

The bode plot of the diagonal and off-diagonal terms are shown in Figure [[fig:enc_plates_iff_frf]].
#+begin_src matlab :exports none
%% Bode plot of the IFF Plant (transfer function from u to taum)
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:5
    for j = i+1:6
        plot(f, abs(G_iff(:, i, j)), 'color', [0, 0, 0, 0.2], ...
             'HandleVisibility', 'off');
    end
end
for i =1:6
    set(gca,'ColorOrderIndex',i)
    plot(f, abs(G_iff(:,i , i)), ...
         'DisplayName', sprintf('$G_{iff}(%i,%i)$', i, i));
end
plot(f, abs(G_iff(:, 1, 2)), 'color', [0, 0, 0, 0.2], ...
     'DisplayName', '$G_{iff}(i,j)$');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $V_s/V_a$ [V/V]'); set(gca, 'XTickLabel',[]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);
ylim([1e-3, 1e2]);

ax2 = nexttile;
hold on;
for i =1:6
    set(gca,'ColorOrderIndex',i)
    plot(f, 180/pi*angle(G_iff(:,i, i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

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

#+name: fig:enc_plates_iff_frf
#+caption: Measured FRF for the IFF plant
#+RESULTS:
[[file:figs/enc_plates_iff_frf.png]]

#+begin_important
It is shown in Figure [[fig:enc_plates_iff_comp_simscape_all]] that:
- The IFF plant has alternating poles and zeros
- The first flexible mode of the struts as 235Hz is appearing, and therefore is should be possible to add some damping to this mode using IFF
- The decoupling is quite good at low frequency (below the first model) as well as high frequency (above the last suspension mode, except near the flexible modes of the top plate)
#+end_important

*** Save Identified Plants
The identified dynamics is saved for further use.
#+begin_src matlab :exports none :tangle no
save('matlab/mat/identified_plants_enc_plates.mat', 'f', 'Ts', 'G_iff', 'G_dvf')
#+end_src

#+begin_src matlab :eval no
save('mat/identified_plants_enc_plates.mat', 'f', 'Ts', 'G_iff', 'G_dvf')
#+end_src

** Comparison with the Simscape Model
<<sec:enc_plates_comp_simscape>>
*** Introduction                                                    :ignore:
In this section, the measured dynamics done in Section [[sec:enc_plates_plant_id]] is compared with the dynamics estimated from the Simscape model.

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

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

#+begin_src matlab :tangle no
addpath('./matlab/mat/');
addpath('./matlab/src/');
addpath('./matlab/');
#+end_src

#+begin_src matlab :eval no
addpath('./mat/');
addpath('./src/');
#+end_src

#+begin_src matlab :tangle no
%% Add all useful folders to the path
addpath('matlab/nass-simscape/matlab/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/png/')
addpath('matlab/nass-simscape/src/')
addpath('matlab/nass-simscape/mat/')
#+end_src

#+begin_src matlab :eval no
%% Add all useful folders to the path
addpath('nass-simscape/matlab/nano_hexapod/')
addpath('nass-simscape/STEPS/nano_hexapod/')
addpath('nass-simscape/STEPS/png/')
addpath('nass-simscape/src/')
addpath('nass-simscape/mat/')
#+end_src

#+begin_src matlab
%% Load identification data
load('identified_plants_enc_plates.mat', 'f', 'Ts', 'G_iff', 'G_dvf')
#+end_src

#+begin_src matlab
%% Open Simulink Model
mdl = 'nano_hexapod_simscape';

options = linearizeOptions;
options.SampleTime = 0;

Rx = zeros(1, 7);

open(mdl)
#+end_src

*** Identification Setup
The nano-hexapod is initialized with the APA taken as flexible models.
#+begin_src matlab
%% Initialize Nano-Hexapod
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '4dof', ...
                                       'flex_top_type', '4dof', ...
                                       'motion_sensor_type', 'plates', ...
                                       'actuator_type', 'flexible');
#+end_src

*** TODO Paper MEDSI                                              :noexport:
#+begin_src matlab
%% Initialize Nano-Hexapod
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '4dof', ...
                                       'flex_top_type', '4dof', ...
                                       'motion_sensor_type', 'plates', ...
                                       'actuator_type', 'flexible');
#+end_src

#+begin_src matlab
%% Identify the DVF Plant (transfer function from u to dLm)
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'],  1, 'openinput');  io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/dL'], 1, 'openoutput'); io_i = io_i + 1; % Encoders

Gdvf = exp(-s*Ts)*linearize(mdl, io, 0.0, options);
#+end_src

#+begin_src matlab
%% Identify the IFF Plant (transfer function from u to taum)
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'], 1, 'openinput');   io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/Fm'], 1, 'openoutput'); io_i = io_i + 1; % Force Sensors

Giff = exp(-s*Ts)*linearize(mdl, io, 0.0, options);
#+end_src

#+begin_src matlab :exports none
%% Diagonal elements of the DVF plant
freqs = logspace(log10(20), 3, 1000);

colors = colororder;

figure;
tiledlayout(3, 2, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
plot(f, abs(G_dvf(:,1, 1)), 'color', [colors(1,:),0.2], ...
     'DisplayName', 'FRF')
for i = 2:6
    set(gca,'ColorOrderIndex',2)
    plot(f, abs(G_dvf(:,i, i)), 'color', [colors(1,:),0.2], ...
         'HandleVisibility', 'off');
end
set(gca,'ColorOrderIndex',2);
plot(freqs, abs(squeeze(freqresp(Gdvf(1,1), freqs, 'Hz'))), '-', ...
     'DisplayName', 'Model')
% for i = 2:6
%     set(gca,'ColorOrderIndex',2);
%     plot(freqs, abs(squeeze(freqresp(Gdvf(i,i), freqs, 'Hz'))), '-', ...
%          'HandleVisibility', 'off');
% end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/V]'); set(gca, 'XTickLabel',[]);
ylim([3e-7, 1e-3]);
legend('location', 'southwest', 'FontSize', 8);

ax1b = nexttile([2,1]);
hold on;
plot(f, abs(G_iff(:,1, 1)), 'color', [colors(1,:),0.2])
for i = 2:6
    set(gca,'ColorOrderIndex',2)
    plot(f, abs(G_iff(:,i, i)), 'color', [colors(1,:),0.2]);
end
set(gca,'ColorOrderIndex',2);
plot(freqs, abs(squeeze(freqresp(Giff(1,1), freqs, 'Hz'))), '-')
% for i = 2:6
%     set(gca,'ColorOrderIndex',2);
%     plot(freqs, abs(squeeze(freqresp(Giff(i,i), freqs, 'Hz'))), '-');
% end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [V/V]'); set(gca, 'XTickLabel',[]);
ylim([3e-2, 1e2]);

ax2 = nexttile;
hold on;
for i = 1:6
    plot(f, 180/pi*angle(G_dvf(:,i, i)), 'color', [colors(1,:),0.2]);
end
for i = 1:1
    set(gca,'ColorOrderIndex',2);
    plot(freqs, 180/pi*angle(squeeze(freqresp(Gdvf(i,i), freqs, 'Hz'))), '-');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-90, 180]);
yticks([-180, -90, 0, 90, 180]);

ax2b = nexttile;
hold on;
for i = 1:6
    plot(f, 180/pi*angle(G_iff(:,i, i)), 'color', [colors(1,:),0.2]);
end
for i = 1:1
    set(gca,'ColorOrderIndex',2);
    plot(freqs, 180/pi*angle(squeeze(freqresp(Giff(i,i), freqs, 'Hz'))), '-');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-90, 180]);
yticks([-180, -90, 0, 90, 180]);

linkaxes([ax1,ax2,ax1b,ax2b],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

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

#+name: fig:nano_hexapod_identification_comp_simscape
#+caption:
#+RESULTS:
[[file:figs/nano_hexapod_identification_comp_simscape.png]]

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

[[file:figs/nano_hexapod_identification_comp_simscape_full.png]]

*** MEDSI Talk                                                    :noexport:

#+begin_src matlab :exports none
%% Diagonal elements of the DVF plant
freqs = logspace(log10(20), 3, 1000);

colors = colororder;

figure;
tiledlayout(3, 2, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
plot(f, abs(G_dvf(:,1, 1)), 'color', [colors(1,:),0.2], ...
     'DisplayName', 'FRF - $d_{e,i}/V_{a,i}$')
for i = 2:6
    plot(f, abs(G_dvf(:,i, i)), 'color', [colors(1,:),0.2], ...
         'HandleVisibility', 'off');
end
plot(freqs, abs(squeeze(freqresp(Gdvf(1,1), freqs, 'Hz'))), '--', 'color', colors(1,:), ...
     'DisplayName', 'Model - $d_{e,i}/V_{a,i}$')
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/V]'); set(gca, 'XTickLabel',[]);
ylim([3e-7, 1e-3]);
legend('location', 'northwest', 'FontSize', 8);

ax1b = nexttile([2,1]);
hold on;
for i = [2,5]
    plot(f, abs(G_dvf(:,1, i)), 'color', [colors(i,:),0.5], ...
        'DisplayName', sprintf('FRF - $d_{e,1}/V_{a,%i}$', i));
end
for i = [2,5]
    plot(freqs, abs(squeeze(freqresp(Gdvf(1,i), freqs, 'Hz'))), '--', 'color', colors(i,:), ...
        'DisplayName', sprintf('Model - $d_{e,1}/V_{a,%i}$', i));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
set(gca, 'YTickLabel',[]); set(gca, 'XTickLabel',[]);
ylim([3e-7, 1e-3]);
legend('location', 'northwest', 'FontSize', 8);

ax2 = nexttile;
hold on;
for i = 1:6
    plot(f, 180/pi*angle(G_dvf(:,i, i)), 'color', [colors(1,:),0.2]);
end
plot(freqs, 180/pi*angle(squeeze(freqresp(Gdvf(i,i), freqs, 'Hz'))), '--', 'color', colors(1,:));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-180, 180]);
yticks([-180, -90, 0, 90, 180]);

ax2b = nexttile;
hold on;
for i = [2,5]
    plot(f, 180/pi*angle(G_dvf(:,1,i)), 'color', [colors(i,:),0.5]);
end
for i = [2,5]
    plot(freqs, 180/pi*angle(squeeze(freqresp(Gdvf(1,i), freqs, 'Hz'))), '--', 'color', colors(i,:));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
set(gca, 'YTickLabel',[]); xlabel('Frequency [Hz]');
ylim([-180, 180]);

linkaxes([ax1,ax2,ax1b,ax2b],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

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

#+name: fig:nano_hexapod_enc_bode_plot
#+caption:
#+RESULTS:
[[file:figs/nano_hexapod_enc_bode_plot.png]]

#+begin_src matlab :exports none
%% Diagonal elements of the IFF plant
freqs = logspace(log10(20), 3, 1000);

colors = colororder;

figure;
tiledlayout(3, 2, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
plot(f, abs(G_iff(:,1, 1)), 'color', [colors(1,:),0.2], ...
     'DisplayName', 'FRF - $V_{s,i}/V_{a,i}$')
for i = 2:6
    plot(f, abs(G_iff(:,i, i)), 'color', [colors(1,:),0.2], ...
         'HandleVisibility', 'off');
end
plot(freqs, abs(squeeze(freqresp(Giff(1,1), freqs, 'Hz'))), '--', 'color', colors(1,:), ...
     'DisplayName', 'Model - $V_{s,i}/V_{a,i}$')
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [V/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-2, 1e2]);
legend('location', 'northwest', 'FontSize', 8);

ax1b = nexttile([2,1]);
hold on;
for i = [2,3]
    plot(f, abs(G_iff(:,1, i)), 'color', [colors(i,:),0.5], ...
        'DisplayName', sprintf('FRF - $V_{s,1}/V_{a,%i}$', i));
end
for i = [2,3]
    plot(freqs, abs(squeeze(freqresp(Giff(1,i), freqs, 'Hz'))), '--', 'color', colors(i,:), ...
        'DisplayName', sprintf('Model - $V_{s,1}/V_{a,%i}$', i));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
set(gca, 'YTickLabel',[]); set(gca, 'XTickLabel',[]);
ylim([1e-2, 1e2]);
legend('location', 'northwest', 'FontSize', 8);

ax2 = nexttile;
hold on;
for i = 1:6
    plot(f, 180/pi*angle(G_iff(:,i, i)), 'color', [colors(1,:),0.2]);
end
plot(freqs, 180/pi*angle(squeeze(freqresp(Giff(i,i), freqs, 'Hz'))), '--', 'color', colors(1,:));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-180, 180]);
yticks([-180, -90, 0, 90, 180]);

ax2b = nexttile;
hold on;
for i = [2,3]
    plot(f, 180/pi*angle(G_iff(:,1,i)), 'color', [colors(i,:),0.5]);
end
for i = [2,3]
    plot(freqs, 180/pi*angle(squeeze(freqresp(Giff(1,i), freqs, 'Hz'))), '--', 'color', colors(i,:));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
set(gca, 'YTickLabel',[]); xlabel('Frequency [Hz]');
ylim([-180, 180]);

linkaxes([ax1,ax2,ax1b,ax2b],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

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

#+name: fig:nano_hexapod_iff_bode_plot
#+caption:
#+RESULTS:
[[file:figs/nano_hexapod_iff_bode_plot.png]]

#+begin_src matlab
#+end_src

*** Dynamics from Actuator to Force Sensors
Then the transfer function from $\bm{u}$ to $\bm{\tau}_m$ is identified using the Simscape model.
#+begin_src matlab
%% Identify the IFF Plant (transfer function from u to taum)
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'], 1, 'openinput');   io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/Fm'], 1, 'openoutput'); io_i = io_i + 1; % Force Sensors

Giff = exp(-s*Ts)*linearize(mdl, io, 0.0, options);
#+end_src

The identified dynamics is compared with the measured FRF:
- Figure [[fig:enc_plates_iff_comp_simscape_all]]: the individual transfer function from $u_1$ (the DAC voltage for the first actuator) to the force sensors of all 6 struts are compared
- Figure [[fig:enc_plates_iff_comp_simscape]]: all the diagonal elements are compared
- Figure [[fig:enc_plates_iff_comp_offdiag_simscape]]: all the off-diagonal elements are compared

#+begin_src matlab :exports none
%% Comparison of the plants (encoder output) when tuning the misalignment
freqs = 2*logspace(1, 3, 1000);

i_input = 1;

figure;
tiledlayout(2, 3, 'TileSpacing', 'Compact', 'Padding', 'None');

ax1 = nexttile();
hold on;
plot(f, abs(G_iff(:, 1, i_input)));
plot(freqs, abs(squeeze(freqresp(Giff(1, i_input), freqs, 'Hz'))));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
set(gca, 'XTickLabel',[]); ylabel('Amplitude [m/V]');
title(sprintf('$d\\tau_{m1}/u_{%i}$', i_input));

ax2 = nexttile();
hold on;
plot(f, abs(G_iff(:, 2, i_input)));
plot(freqs, abs(squeeze(freqresp(Giff(2, i_input), freqs, 'Hz'))));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
set(gca, 'XTickLabel',[]); set(gca, 'YTickLabel',[]);
title(sprintf('$d\\tau_{m2}/u_{%i}$', i_input));

ax3 = nexttile();
hold on;
plot(f, abs(G_iff(:, 3, i_input)), ...
     'DisplayName', 'Meas.');
plot(freqs, abs(squeeze(freqresp(Giff(3, i_input), freqs, 'Hz'))), ...
     'DisplayName', 'Model');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
set(gca, 'XTickLabel',[]); set(gca, 'YTickLabel',[]);
legend('location', 'southeast', 'FontSize', 8);
title(sprintf('$d\\tau_{m3}/u_{%i}$', i_input));

ax4 = nexttile();
hold on;
plot(f, abs(G_iff(:, 4, i_input)));
plot(freqs, abs(squeeze(freqresp(Giff(4, i_input), freqs, 'Hz'))));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('Amplitude [m/V]');
title(sprintf('$d\\tau_{m4}/u_{%i}$', i_input));

ax5 = nexttile();
hold on;
plot(f, abs(G_iff(:, 5, i_input)));
plot(freqs, abs(squeeze(freqresp(Giff(5, i_input), freqs, 'Hz'))));
hold off;
xlabel('Frequency [Hz]'); set(gca, 'YTickLabel',[]);
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
title(sprintf('$d\\tau_{m5}/u_{%i}$', i_input));

ax6 = nexttile();
hold on;
plot(f, abs(G_iff(:, 6, i_input)));
plot(freqs, abs(squeeze(freqresp(Giff(6, i_input), freqs, 'Hz'))));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); set(gca, 'YTickLabel',[]);
title(sprintf('$d\\tau_{m6}/u_{%i}$', i_input));

linkaxes([ax1,ax2,ax3,ax4,ax5,ax6],'xy');
xlim([20, 2e3]); ylim([1e-2, 1e2]);
#+end_src

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

#+name: fig:enc_plates_iff_comp_simscape_all
#+caption: IFF Plant for the first actuator input and all the force senosrs
#+RESULTS:
[[file:figs/enc_plates_iff_comp_simscape_all.png]]

#+begin_src matlab :exports none
%% Bode plot of the identified IFF Plant (Simscape) and measured FRF data
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
plot(f, abs(G_iff(:,1, 1)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$\tau_{m,i}/u_i$ - FRF')
for i = 2:6
    set(gca,'ColorOrderIndex',2)
    plot(f, abs(G_iff(:,i, i)), 'color', [0,0,0,0.2], ...
         'HandleVisibility', 'off');
end
set(gca,'ColorOrderIndex',2);
plot(freqs, abs(squeeze(freqresp(Giff(1,1), freqs, 'Hz'))), '-', ...
     'DisplayName', '$\tau_{m,i}/u_i$ - Model')
for i = 2:6
    set(gca,'ColorOrderIndex',2);
    plot(freqs, abs(squeeze(freqresp(Giff(i,i), freqs, 'Hz'))), '-', ...
         'HandleVisibility', 'off');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [V/V]'); set(gca, 'XTickLabel',[]);
legend('location', 'southeast');

ax2 = nexttile;
hold on;
for i = 1:6
    plot(f, 180/pi*angle(G_iff(:,i, i)), 'color', [0,0,0,0.2]);
end
for i = 1:6
    set(gca,'ColorOrderIndex',2);
    plot(freqs, 180/pi*angle(squeeze(freqresp(Giff(i,i), freqs, 'Hz'))), '-');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-180, 180]);
yticks([-180, -90, 0, 90, 180]);

linkaxes([ax1,ax2],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

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

#+name: fig:enc_plates_iff_comp_simscape
#+caption: Diagonal elements of the IFF Plant
#+RESULTS:
[[file:figs/enc_plates_iff_comp_simscape.png]]

#+begin_src matlab :exports none
%% Bode plot of the identified IFF Plant (Simscape) and measured FRF data (off-diagonal elements)
freqs = 2*logspace(1, 3, 1000);

figure;
hold on;
% Off diagonal terms
plot(f, abs(G_iff(:, 1, 2)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$\tau_{m,i}/u_j$ - FRF')
for i = 1:5
    for j = i+1:6
        plot(f, abs(G_iff(:, i, j)), 'color', [0,0,0,0.2], ...
             'HandleVisibility', 'off');
    end
end
set(gca,'ColorOrderIndex',2);
plot(freqs, abs(squeeze(freqresp(Giff(1, 2), freqs, 'Hz'))), ...
     'DisplayName', '$\tau_{m,i}/u_j$ - Model')
for i = 1:5
    for j = i+1:6
        set(gca,'ColorOrderIndex',2);
        plot(freqs, abs(squeeze(freqresp(Giff(i, j), freqs, 'Hz'))), ...
             'HandleVisibility', 'off');
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('Amplitude [V/V]');
xlim([freqs(1), freqs(end)]); ylim([1e-3, 1e2]);
legend('location', 'northeast');
#+end_src

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

#+name: fig:enc_plates_iff_comp_offdiag_simscape
#+caption: Off diagonal elements of the IFF Plant
#+RESULTS:
[[file:figs/enc_plates_iff_comp_offdiag_simscape.png]]

*** Dynamics from Actuator to Encoder
Now, the dynamics from the DAC voltage $\bm{u}$ to the encoders $d\bm{\mathcal{L}}_m$ is estimated using the Simscape model.
#+begin_src matlab
%% Identify the DVF Plant (transfer function from u to dLm)
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'],  1, 'openinput');  io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/dL'], 1, 'openoutput'); io_i = io_i + 1; % Encoders

Gdvf = exp(-s*Ts)*linearize(mdl, io, 0.0, options);
#+end_src

The identified dynamics is compared with the measured FRF:
- Figure [[fig:enc_plates_dvf_comp_simscape_all]]: the individual transfer function from $u_3$ (the DAC voltage for the actuator number 3) to the six encoders
- Figure [[fig:enc_plates_dvf_comp_simscape]]: all the diagonal elements are compared
- Figure [[fig:enc_plates_dvf_comp_offdiag_simscape]]: all the off-diagonal elements are compared

#+begin_src matlab :exports none
%% Comparison of the plants (encoder output) when tuning the misalignment
freqs = 2*logspace(1, 3, 1000);

i_input = 3;

figure;
tiledlayout(2, 3, 'TileSpacing', 'Compact', 'Padding', 'None');

ax1 = nexttile();
hold on;
plot(f, abs(G_dvf(:, 1, i_input)));
plot(freqs, abs(squeeze(freqresp(Gdvf(1, i_input), freqs, 'Hz'))));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
set(gca, 'XTickLabel',[]); ylabel('Amplitude [m/V]');
title(sprintf('$d\\mathcal{L}_{m1}/u_{%i}$', i_input));

ax2 = nexttile();
hold on;
plot(f, abs(G_dvf(:, 2, i_input)));
plot(freqs, abs(squeeze(freqresp(Gdvf(2, i_input), freqs, 'Hz'))));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
set(gca, 'XTickLabel',[]); set(gca, 'YTickLabel',[]);
title(sprintf('$d\\mathcal{L}_{m2}/u_{%i}$', i_input));

ax3 = nexttile();
hold on;
plot(f, abs(G_dvf(:, 3, i_input)), ...
     'DisplayName', 'Meas.');
plot(freqs, abs(squeeze(freqresp(Gdvf(3, i_input), freqs, 'Hz'))), ...
     'DisplayName', 'Model');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
set(gca, 'XTickLabel',[]); set(gca, 'YTickLabel',[]);
legend('location', 'southeast', 'FontSize', 8);
title(sprintf('$d\\mathcal{L}_{m3}/u_{%i}$', i_input));

ax4 = nexttile();
hold on;
plot(f, abs(G_dvf(:, 4, i_input)));
plot(freqs, abs(squeeze(freqresp(Gdvf(4, i_input), freqs, 'Hz'))));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('Amplitude [m/V]');
title(sprintf('$d\\mathcal{L}_{m4}/u_{%i}$', i_input));

ax5 = nexttile();
hold on;
plot(f, abs(G_dvf(:, 5, i_input)));
plot(freqs, abs(squeeze(freqresp(Gdvf(5, i_input), freqs, 'Hz'))));
hold off;
xlabel('Frequency [Hz]'); set(gca, 'YTickLabel',[]);
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
title(sprintf('$d\\mathcal{L}_{m5}/u_{%i}$', i_input));

ax6 = nexttile();
hold on;
plot(f, abs(G_dvf(:, 6, i_input)));
plot(freqs, abs(squeeze(freqresp(Gdvf(6, i_input), freqs, 'Hz'))));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); set(gca, 'YTickLabel',[]);
title(sprintf('$d\\mathcal{L}_{m6}/u_{%i}$', i_input));

linkaxes([ax1,ax2,ax3,ax4,ax5,ax6],'xy');
xlim([40, 4e2]); ylim([1e-8, 1e-2]);
#+end_src

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

#+name: fig:enc_plates_dvf_comp_simscape_all
#+caption: DVF Plant for the first actuator input and all the encoders
#+RESULTS:
[[file:figs/enc_plates_dvf_comp_simscape_all.png]]

#+begin_src matlab :exports none
%% Diagonal elements of the DVF plant
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
plot(f, abs(G_dvf(:,1, 1)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_i$ - FRF')
for i = 2:6
    set(gca,'ColorOrderIndex',2)
    plot(f, abs(G_dvf(:,i, i)), 'color', [0,0,0,0.2], ...
         'HandleVisibility', 'off');
end
set(gca,'ColorOrderIndex',2);
plot(freqs, abs(squeeze(freqresp(Gdvf(1,1), freqs, 'Hz'))), '-', ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_i$ - Model')
for i = 2:6
    set(gca,'ColorOrderIndex',2);
    plot(freqs, abs(squeeze(freqresp(Gdvf(i,i), freqs, 'Hz'))), '-', ...
         'HandleVisibility', 'off');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-8, 1e-3]);
legend('location', 'northeast');

ax2 = nexttile;
hold on;
for i = 1:6
    plot(f, 180/pi*angle(G_dvf(:,i, i)), 'color', [0,0,0,0.2]);
end
for i = 1:6
    set(gca,'ColorOrderIndex',2);
    plot(freqs, 180/pi*angle(squeeze(freqresp(Gdvf(i,i), freqs, 'Hz'))), '-');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-180, 180]);
yticks([-180, -90, 0, 90, 180]);

linkaxes([ax1,ax2],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

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

#+name: fig:enc_plates_dvf_comp_simscape
#+caption: Diagonal elements of the DVF Plant
#+RESULTS:
[[file:figs/enc_plates_dvf_comp_simscape.png]]

#+begin_src matlab :exports none
%% Off-diagonal elements of the DVF plant
freqs = 2*logspace(1, 3, 1000);

figure;
hold on;
% Off diagonal terms
plot(f, abs(G_dvf(:, 1, 2)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_j$ - FRF')
for i = 1:5
    for j = i+1:6
        plot(f, abs(G_dvf(:, i, j)), 'color', [0,0,0,0.2], ...
             'HandleVisibility', 'off');
    end
end
set(gca,'ColorOrderIndex',2);
plot(freqs, abs(squeeze(freqresp(Gdvf(1, 2), freqs, 'Hz'))), ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_j$ - Model')
for i = 1:5
    for j = i+1:6
        set(gca,'ColorOrderIndex',2);
        plot(freqs, abs(squeeze(freqresp(Gdvf(i, j), freqs, 'Hz'))), ...
             'HandleVisibility', 'off');
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('Amplitude [m/V]');
xlim([freqs(1), freqs(end)]); ylim([1e-8, 1e-3]);
legend('location', 'northeast');
#+end_src

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

#+name: fig:enc_plates_dvf_comp_offdiag_simscape
#+caption: Off diagonal elements of the DVF Plant
#+RESULTS:
[[file:figs/enc_plates_dvf_comp_offdiag_simscape.png]]

*** TODO Flexible Top Plate
#+begin_src matlab
%% Initialize Nano-Hexapod
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '2dof', ...
                                       'flex_top_type', '3dof', ...
                                       'motion_sensor_type', 'struts', ...
                                       'actuator_type', '2dof', ...
                                       'top_plate_type', 'rigid');
#+end_src

#+begin_src matlab
%% Identify the DVF Plant (transfer function from u to dLm)
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'],  1, 'openinput');  io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/dL'], 1, 'openoutput'); io_i = io_i + 1; % Encoders

Gdvf = linearize(mdl, io, 0.0, options);
#+end_src

#+begin_src matlab
size(Gdvf)
isstable(Gdvf)
#+end_src

#+begin_src matlab
[sys,g] = balreal(Gdvf);  % Compute balanced realization
elim = (g<1e-4);         % Small entries of g are negligible states
rsys = modred(sys,elim); % Remove negligible states
size(rsys)
#+end_src

#+begin_src matlab :exports none
%% Diagonal elements of the DVF plant
freqs = logspace(-1, 3, 1000);

figure;
hold on;
for i = 1:6
        plot(freqs, abs(squeeze(freqresp(Gdvf(i,i), freqs, 'Hz'))), '-', ...
             'DisplayName', sprintf('%i', i));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/V]');
ylim([1e-8, 1e-3]);
xlim([freqs(1), freqs(end)]);
legend('location', 'northeast');
#+end_src

#+begin_src matlab :exports none
%% Diagonal elements of the DVF plant
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
plot(f, abs(G_dvf(:,1, 1)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_i$ - FRF')
for i = 2:6
    set(gca,'ColorOrderIndex',2)
    plot(f, abs(G_dvf(:,i, i)), 'color', [0,0,0,0.2], ...
         'HandleVisibility', 'off');
end
set(gca,'ColorOrderIndex',2);
plot(freqs, abs(squeeze(freqresp(Gdvf(1,1), freqs, 'Hz'))), '-', ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_i$ - Model')
for i = 2:6
    set(gca,'ColorOrderIndex',2);
    plot(freqs, abs(squeeze(freqresp(Gdvf(i,i), freqs, 'Hz'))), '-', ...
         'HandleVisibility', 'off');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-8, 1e-3]);
legend('location', 'northeast');

ax2 = nexttile;
hold on;
for i = 1:6
    plot(f, 180/pi*angle(G_dvf(:,i, i)), 'color', [0,0,0,0.2]);
end
for i = 1:6
    set(gca,'ColorOrderIndex',2);
    plot(freqs, 180/pi*angle(squeeze(freqresp(Gdvf(i,i), freqs, 'Hz'))), '-');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-180, 180]);
yticks([-180, -90, 0, 90, 180]);

linkaxes([ax1,ax2],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

#+begin_src matlab
%% Identify the IFF Plant (transfer function from u to taum)
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'], 1, 'openinput');   io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/Fm'], 1, 'openoutput'); io_i = io_i + 1; % Force Sensors

Giff = exp(-s*Ts)*linearize(mdl, io, 0.0, options);
#+end_src

#+begin_src matlab :exports none
%% Bode plot of the identified IFF Plant (Simscape) and measured FRF data
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
plot(f, abs(G_iff(:,1, 1)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$\tau_{m,i}/u_i$ - FRF')
for i = 2:6
    set(gca,'ColorOrderIndex',2)
    plot(f, abs(G_iff(:,i, i)), 'color', [0,0,0,0.2], ...
         'HandleVisibility', 'off');
end
set(gca,'ColorOrderIndex',2);
plot(freqs, abs(squeeze(freqresp(Giff(1,1), freqs, 'Hz'))), '-', ...
     'DisplayName', '$\tau_{m,i}/u_i$ - Model')
for i = 2:6
    set(gca,'ColorOrderIndex',2);
    plot(freqs, abs(squeeze(freqresp(Giff(i,i), freqs, 'Hz'))), '-', ...
         'HandleVisibility', 'off');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [V/V]'); set(gca, 'XTickLabel',[]);
legend('location', 'southeast');

ax2 = nexttile;
hold on;
for i = 1:6
    plot(f, 180/pi*angle(G_iff(:,i, i)), 'color', [0,0,0,0.2]);
end
for i = 1:6
    set(gca,'ColorOrderIndex',2);
    plot(freqs, 180/pi*angle(squeeze(freqresp(Giff(i,i), freqs, 'Hz'))), '-');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-180, 180]);
yticks([-180, -90, 0, 90, 180]);

linkaxes([ax1,ax2],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

*** Conclusion
#+begin_important
The Simscape model is quite accurate for the transfer function matrices from $\bm{u}$ to $\bm{\tau}_m$ and from $\bm{u}$ to $d\bm{\mathcal{L}}_m$ except at frequencies of the flexible modes of the top-plate.
The Simscape model can therefore be used to develop the control strategies.
#+end_important

** Integral Force Feedback
<<sec:enc_plates_iff>>
*** Introduction                                                    :ignore:

In this section, the Integral Force Feedback (IFF) control strategy is applied to the nano-hexapod in order to add damping to the suspension modes.

The control architecture is shown in Figure [[fig:control_architecture_iff]]:
- $\bm{\tau}_m$ is the measured voltage of the 6 force sensors
- $\bm{K}_{\text{IFF}}$ is the $6 \times 6$ diagonal controller
- $\bm{u}$ is the plant input (voltage generated by the 6 DACs)
- $\bm{u}^\prime$ is the new plant inputs with added damping

#+begin_src latex :file control_architecture_iff.pdf
\begin{tikzpicture}
  % Blocs
  \node[block={3.0cm}{2.0cm}] (P) {Plant};
  \coordinate[] (inputF) at ($(P.south west)!0.5!(P.north west)$);
  \coordinate[] (outputF) at ($(P.south east)!0.7!(P.north east)$);
  \coordinate[] (outputL) at ($(P.south east)!0.3!(P.north east)$);

  \node[block, above=0.4 of P] (Kiff) {$\bm{K}_\text{IFF}$};
  \node[addb, left= of inputF] (addF) {};

  % Connections and labels
  \draw[->] (outputF) -- ++(1, 0) node[below left]{$\bm{\tau}_m$};
  \draw[->] (outputL) -- ++(1, 0) node[below left]{$d\bm{\mathcal{L}}_m$};

  \draw[->] ($(outputF) + (0.6, 0)$)node[branch]{} |- (Kiff.east);
  \draw[->] (Kiff.west) -| (addF.north);
  \draw[->] (addF.east) -- (inputF) node[above left]{$\bm{u}$};
  \draw[<-] (addF.west) -- ++(-1, 0) node[above right]{$\bm{u}^\prime$};
\end{tikzpicture}
#+end_src

#+name: fig:control_architecture_iff
#+caption: Integral Force Feedback Strategy
#+RESULTS:
[[file:figs/control_architecture_iff.png]]

- Section [[sec:enc_struts_effect_iff_plant]]

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

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

#+begin_src matlab :tangle no
addpath('./matlab/mat/');
addpath('./matlab/src/');
addpath('./matlab/');
#+end_src

#+begin_src matlab :eval no
addpath('./mat/');
addpath('./src/');
#+end_src

#+begin_src matlab
load('identified_plants_enc_plates.mat', 'f', 'Ts', 'G_iff', 'G_dvf')
#+end_src

#+begin_src matlab :tangle no
%% Add all useful folders to the path
addpath('matlab/nass-simscape/matlab/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/png/')
addpath('matlab/nass-simscape/src/')
addpath('matlab/nass-simscape/mat/')
#+end_src

#+begin_src matlab :eval no
%% Add all useful folders to the path
addpath('nass-simscape/matlab/nano_hexapod/')
addpath('nass-simscape/STEPS/nano_hexapod/')
addpath('nass-simscape/STEPS/png/')
addpath('nass-simscape/src/')
addpath('nass-simscape/mat/')
#+end_src

#+begin_src matlab
%% Open Simulink Model
mdl = 'nano_hexapod_simscape';

options = linearizeOptions;
options.SampleTime = 0;

open(mdl)

Rx = zeros(1, 7);

colors = colororder;
#+end_src

*** Effect of IFF on the plant - Simscape Model
<<sec:enc_struts_effect_iff_plant>>

The nano-hexapod is initialized with flexible APA and the encoders fixed to the struts.
#+begin_src matlab
%% Initialize the Simscape model in closed loop
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '4dof', ...
                                       'flex_top_type', '4dof', ...
                                       'motion_sensor_type', 'plates', ...
                                       'actuator_type', 'flexible');
#+end_src

The same controller as the one developed when the encoder were fixed to the struts is used.
#+begin_src matlab
%% Optimal IFF controller
load('Kiff.mat', 'Kiff')
#+end_src

The transfer function from $\bm{u}^\prime$ to $d\bm{\mathcal{L}}_m$ is identified.
#+begin_src matlab
%% Identify the (damped) transfer function from u to dLm for different values of the IFF gain
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'],  1, 'openinput');  io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/dL'], 1, 'openoutput'); io_i = io_i + 1; % Plate Displacement (encoder)
#+end_src

First in Open-Loop:
#+begin_src matlab
%% Transfer function from u to dL (open-loop)
Gd_ol = exp(-s*Ts)*linearize(mdl, io, 0.0, options);
#+end_src

And then with the IFF controller:
#+begin_src matlab
%% Initialize the Simscape model in closed loop
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '4dof', ...
                                       'flex_top_type', '4dof', ...
                                       'motion_sensor_type', 'plates', ...
                                       'actuator_type', 'flexible', ...
                                       'controller_type', 'iff');

%% Transfer function from u to dL (IFF)
Gd_iff = exp(-s*Ts)*linearize(mdl, io, 0.0, options);
#+end_src

It is first verified that the system is stable:
#+begin_src matlab :results value replace :exports both :tangle no
isstable(Gd_iff)
#+end_src

#+RESULTS:
: 1

The diagonal and off-diagonal terms of the $6 \times 6$ transfer function matrices identified are compared in Figure [[fig:enc_plates_iff_gains_effect_dvf_plant]].
It is shown, as was the case when the encoders were fixed to the struts, that the IFF control strategy is very effective in damping the suspension modes of the nano-hexapod.
#+begin_src matlab :exports none
%% Bode plot of the transfer function from u to dLm for tested values of the IFF gain
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
plot(freqs, abs(squeeze(freqresp(Gd_ol(1,1),  freqs, 'Hz'))), '-', ...
     'DisplayName', 'OL - Diag');
plot(freqs, abs(squeeze(freqresp(Gd_iff(1,1), freqs, 'Hz'))), '-', ...
     'DisplayName', 'IFF - Diag');
for i = 2:6
    set(gca,'ColorOrderIndex',1);
    plot(freqs, abs(squeeze(freqresp(Gd_ol(1,1), freqs, 'Hz'))), '-', ...
         'HandleVisibility', 'off');
end
for i = 2:6
    set(gca,'ColorOrderIndex',2);
    plot(freqs, abs(squeeze(freqresp(Gd_iff(i,i), freqs, 'Hz'))), '-', ...
         'HandleVisibility', 'off');
end

plot(freqs, abs(squeeze(freqresp(Gd_ol(1,2), freqs, 'Hz'))), 'color', [colors(1,:), 0.2], ...
     'DisplayName', 'OL - Off-diag')
for i = 1:5
    for j = i+1:6
        plot(freqs, abs(squeeze(freqresp(Gd_ol(i,j), freqs, 'Hz'))), 'color', [colors(1,:), 0.2], ...
             'HandleVisibility', 'off');
    end
end
plot(freqs, abs(squeeze(freqresp(Gd_iff(1,2), freqs, 'Hz'))), 'color', [colors(2,:), 0.2], ...
     'DisplayName', 'IFF - Off-diag')
for i = 1:5
    for j = i+1:6
        plot(freqs, abs(squeeze(freqresp(Gd_iff(i,j), freqs, 'Hz'))), 'color', [colors(2,:), 0.2], ...
             'HandleVisibility', 'off');
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/V]'); set(gca, 'XTickLabel',[]);
legend('location', 'northeast', 'FontSize', 8, 'NumColumns', 2);

ax2 = nexttile;
hold on;
for i = 1:6
    set(gca,'ColorOrderIndex',1);
    plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_ol(1,1), freqs, 'Hz'))), '-', ...
         'HandleVisibility', 'off');
    set(gca,'ColorOrderIndex',2);
    plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_iff(i,i), freqs, 'Hz'))), '-', ...
         'HandleVisibility', 'off');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-180, 180]);
yticks([-180, -90, 0, 90, 180]);

linkaxes([ax1,ax2],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

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

#+name: fig:enc_plates_iff_gains_effect_dvf_plant
#+caption: Effect of the IFF control strategy on the transfer function from $\bm{\tau}$ to $d\bm{\mathcal{L}}_m$
#+RESULTS:
[[file:figs/enc_plates_iff_gains_effect_dvf_plant.png]]

*** Effect of IFF on the plant - FRF
The IFF control strategy is experimentally implemented.
The (damped) transfer function from $\bm{u}^\prime$ to $d\bm{\mathcal{L}}_m$ is experimentally identified.

The identification data are loaded:
#+begin_src matlab
%% Load Identification Data
meas_iff_plates = {};

for i = 1:6
    meas_iff_plates(i) = {load(sprintf('mat/frf_exc_iff_strut_%i_enc_plates_noise.mat', i), 't', 'Va', 'Vs', 'de', 'u')};
end
#+end_src

And the parameters used for the transfer function estimation are defined below.
#+begin_src matlab
% Sampling Time [s]
Ts = (meas_iff_plates{1}.t(end) - (meas_iff_plates{1}.t(1)))/(length(meas_iff_plates{1}.t)-1);

% Hannning Windows
win = hanning(ceil(1/Ts));

% And we get the frequency vector
[~, f] = tfestimate(meas_iff_plates{1}.Va, meas_iff_plates{1}.de, win, [], [], 1/Ts);
#+end_src

The estimation is performed using the =tfestimate= command.
#+begin_src matlab
%% Estimation of the transfer function matrix from u to dL when IFF is applied
G_enc_iff_opt = zeros(length(f), 6, 6);

for i = 1:6
    G_enc_iff_opt(:,:,i) = tfestimate(meas_iff_plates{i}.Va, meas_iff_plates{i}.de, win, [], [], 1/Ts);
end
#+end_src

The obtained diagonal and off-diagonal elements of the transfer function from $\bm{u}^\prime$ to $d\bm{\mathcal{L}}_m$ are shown in Figure [[fig:enc_plant_plates_effect_iff]] both without and with IFF.
#+begin_src matlab :exports none
%% Bode plot of the transfer function from u to dLm for tested values of the IFF gain
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
plot(f, abs(G_dvf(:,1,1)), '-', ...
     'DisplayName', 'OL - Diag');
plot(f, abs(G_enc_iff_opt(:,1,1)), '-', ...
     'DisplayName', 'IFF - Diag');
for i = 2:6
    set(gca,'ColorOrderIndex',1);
    plot(f, abs(G_dvf(:,1,1)), '-', ...
         'HandleVisibility', 'off');
end
for i = 2:6
    set(gca,'ColorOrderIndex',2);
    plot(f, abs(G_enc_iff_opt(:,i,i)), '-', ...
         'HandleVisibility', 'off');
end

plot(f, abs(G_dvf(:,1,2)), 'color', [colors(1,:), 0.2], ...
     'DisplayName', 'OL - Off-diag')
for i = 1:5
    for j = i+1:6
        plot(f, abs(G_dvf(:,i,j)), 'color', [colors(1,:), 0.2], ...
             'HandleVisibility', 'off');
    end
end
plot(f, abs(G_enc_iff_opt(:,1,2)), 'color', [colors(2,:), 0.2], ...
     'DisplayName', 'IFF - Off-diag')
for i = 1:5
    for j = i+1:6
        plot(f, abs(G_enc_iff_opt(:,i,j)), 'color', [colors(2,:), 0.2], ...
             'HandleVisibility', 'off');
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/V]'); set(gca, 'XTickLabel',[]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 2);

ax2 = nexttile;
hold on;
for i = 1:6
    set(gca,'ColorOrderIndex',1);
    plot(f, 180/pi*angle(G_dvf(:,i,i)), '-')
    set(gca,'ColorOrderIndex',2);
    plot(f, 180/pi*angle(G_enc_iff_opt(:,i,i)), '-')
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-180, 180]);
yticks([-180, -90, 0, 90, 180]);

linkaxes([ax1,ax2],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

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

#+name: fig:enc_plant_plates_effect_iff
#+caption: Effect of the IFF control strategy on the transfer function from $\bm{\tau}$ to $d\bm{\mathcal{L}}_m$
#+RESULTS:
[[file:figs/enc_plant_plates_effect_iff.png]]

#+begin_important
As was predicted with the Simscape model, the IFF control strategy is very effective in damping the suspension modes of the nano-hexapod.
Little damping is also applied on the first flexible mode of the strut at 235Hz.
However, no damping is applied on other modes, such as the flexible modes of the top plate.
#+end_important

*** Comparison of the measured FRF and the Simscape model
Let's now compare the obtained damped plants obtained experimentally with the one extracted from Simscape:
- Figure [[fig:enc_plates_opt_iff_comp_simscape_all]]: the individual transfer function from $u_1^\prime$ to the six encoders are comapred
- Figure [[fig:damped_iff_plates_plant_comp_diagonal]]: all the diagonal elements are compared
- Figure [[fig:damped_iff_plates_plant_comp_off_diagonal]]: all the off-diagonal elements are compared

#+begin_src matlab :exports none
%% Comparison of the plants (encoder output) when tuning the misalignment
freqs = 2*logspace(1, 3, 1000);

i_input = 1;

figure;
tiledlayout(2, 3, 'TileSpacing', 'Compact', 'Padding', 'None');

ax1 = nexttile();
hold on;
plot(f, abs(G_enc_iff_opt(:, 1, i_input)));
plot(freqs, abs(squeeze(freqresp(Gd_iff(1, i_input), freqs, 'Hz'))));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
set(gca, 'XTickLabel',[]); ylabel('Amplitude [m/V]');
title(sprintf('$d\\tau_{m1}/u_{%i}$', i_input));

ax2 = nexttile();
hold on;
plot(f, abs(G_enc_iff_opt(:, 2, i_input)));
plot(freqs, abs(squeeze(freqresp(Gd_iff(2, i_input), freqs, 'Hz'))));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
set(gca, 'XTickLabel',[]); set(gca, 'YTickLabel',[]);
title(sprintf('$d\\tau_{m2}/u_{%i}$', i_input));

ax3 = nexttile();
hold on;
plot(f, abs(G_enc_iff_opt(:, 3, i_input)), ...
     'DisplayName', 'Meas.');
plot(freqs, abs(squeeze(freqresp(Gd_iff(3, i_input), freqs, 'Hz'))), ...
     'DisplayName', 'Model');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
set(gca, 'XTickLabel',[]); set(gca, 'YTickLabel',[]);
legend('location', 'southeast', 'FontSize', 8);
title(sprintf('$d\\tau_{m3}/u_{%i}$', i_input));

ax4 = nexttile();
hold on;
plot(f, abs(G_enc_iff_opt(:, 4, i_input)));
plot(freqs, abs(squeeze(freqresp(Gd_iff(4, i_input), freqs, 'Hz'))));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('Amplitude [m/V]');
title(sprintf('$d\\tau_{m4}/u_{%i}$', i_input));

ax5 = nexttile();
hold on;
plot(f, abs(G_enc_iff_opt(:, 5, i_input)));
plot(freqs, abs(squeeze(freqresp(Gd_iff(5, i_input), freqs, 'Hz'))));
hold off;
xlabel('Frequency [Hz]'); set(gca, 'YTickLabel',[]);
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
title(sprintf('$d\\tau_{m5}/u_{%i}$', i_input));

ax6 = nexttile();
hold on;
plot(f, abs(G_enc_iff_opt(:, 6, i_input)));
plot(freqs, abs(squeeze(freqresp(Gd_iff(6, i_input), freqs, 'Hz'))));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); set(gca, 'YTickLabel',[]);
title(sprintf('$d\\tau_{m6}/u_{%i}$', i_input));

linkaxes([ax1,ax2,ax3,ax4,ax5,ax6],'xy');
xlim([20, 2e3]); ylim([1e-8, 1e-4]);
#+end_src

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

#+name: fig:enc_plates_opt_iff_comp_simscape_all
#+caption: FRF from one actuator to all the encoders when the plant is damped using IFF
#+RESULTS:
[[file:figs/enc_plates_opt_iff_comp_simscape_all.png]]

#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
% Diagonal Elements FRF
plot(f, abs(G_enc_iff_opt(:,1,1)), 'color', [colors(1,:), 0.2], ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_i$ - FRF')
for i = 2:6
    plot(f, abs(G_enc_iff_opt(:,i,i)), 'color', [colors(1,:), 0.2], ...
         'HandleVisibility', 'off');
end

% Diagonal Elements Model
set(gca,'ColorOrderIndex',2)
plot(freqs, abs(squeeze(freqresp(Gd_iff(1,1), freqs, 'Hz'))), '-', ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_i$ - Model')
for i = 2:6
    set(gca,'ColorOrderIndex',2)
    plot(freqs, abs(squeeze(freqresp(Gd_iff(i,i), freqs, 'Hz'))), '-', ...
         'HandleVisibility', 'off');
end

hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_e/V_{exc}$ [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-8, 1e-4]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);

ax2 = nexttile;
hold on;
for i =1:6
    plot(f, 180/pi*angle(G_enc_iff_opt(:,i,i)), 'color', [colors(1,:), 0.2]);
    set(gca,'ColorOrderIndex',2)
    plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_iff(i,i), freqs, 'Hz'))));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

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

#+name: fig:damped_iff_plates_plant_comp_diagonal
#+caption: Comparison of the diagonal elements of the transfer functions from $\bm{u}$ to $d\bm{\mathcal{L}}_m$ with active damping (IFF) applied with an optimal gain $g = 400$
#+RESULTS:
[[file:figs/damped_iff_plates_plant_comp_diagonal.png]]

#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
% Off diagonal FRF
plot(f, abs(G_enc_iff_opt(:,1,2)), 'color', [colors(1,:), 0.2], ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_j$ - FRF')
for i = 1:5
    for j = i+1:6
        plot(f, abs(G_enc_iff_opt(:,i,j)), 'color', [colors(1,:), 0.2], ...
             'HandleVisibility', 'off');
    end
end

% Off diagonal Model
set(gca,'ColorOrderIndex',2)
plot(freqs, abs(squeeze(freqresp(Gd_iff(1,2), freqs, 'Hz'))), '-', ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_j$ - Model')
for i = 1:5
    for j = i+1:6
        set(gca,'ColorOrderIndex',2)
        plot(freqs, abs(squeeze(freqresp(Gd_iff(i,j), freqs, 'Hz'))), ...
             'HandleVisibility', 'off');
    end
end

hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_e/V_{exc}$ [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-8, 1e-4]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);

ax2 = nexttile;
hold on;
% Off diagonal FRF
for i = 1:5
    for j = i+1:6
        plot(f, 180/pi*angle(G_enc_iff_opt(:,i,j)), 'color', [colors(1,:), 0.2]);
    end
end

% Off diagonal Model
for i = 1:5
    for j = i+1:6
        set(gca,'ColorOrderIndex',2)
        plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_iff(i,j), freqs, 'Hz'))));
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

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

#+name: fig:damped_iff_plates_plant_comp_off_diagonal
#+caption: Comparison of the off-diagonal elements of the transfer functions from $\bm{u}$ to $d\bm{\mathcal{L}}_m$ with active damping (IFF) applied with an optimal gain $g = 400$
#+RESULTS:
[[file:figs/damped_iff_plates_plant_comp_off_diagonal.png]]

#+begin_important
From Figures [[fig:damped_iff_plates_plant_comp_diagonal]] and [[fig:damped_iff_plates_plant_comp_off_diagonal]], it is clear that the Simscape model very well represents the dynamics of the nano-hexapod.
This is true to around 400Hz, then the dynamics depends on the flexible modes of the top plate which are not modelled.
#+end_important

*** TODO Paper MEDSI                                              :noexport:
#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
freqs = logspace(log10(20), 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
% Undamped FRF
plot(f, abs(G_dvf(:,1, 1)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$d\mathcal{L}/u$')
for i = 2:6
    set(gca,'ColorOrderIndex',2)
    plot(f, abs(G_dvf(:,i, i)), 'color', [0,0,0,0.2], ...
         'HandleVisibility', 'off');
end

% Diagonal Elements FRF
plot(f, abs(G_enc_iff_opt(:,1,1)), 'color', [colors(1,:), 0.2], ...
     'DisplayName', 'FRF - $d\mathcal{L}/u^\prime$')
for i = 2:6
    plot(f, abs(G_enc_iff_opt(:,i,i)), 'color', [colors(1,:), 0.2], ...
         'HandleVisibility', 'off');
end

% Diagonal Elements Model
set(gca,'ColorOrderIndex',2)
plot(freqs, abs(squeeze(freqresp(Gd_iff(1,1), freqs, 'Hz'))), '--', ...
     'DisplayName', 'Model')

hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-7, 1e-3]);
legend('location', 'southwest', 'FontSize', 8);

ax2 = nexttile;
hold on;
for i =1:6
    plot(f, 180/pi*angle(G_dvf(:,i, i)), 'color', [0,0,0,0.2]);
    plot(f, 180/pi*angle(G_enc_iff_opt(:,i,i)), 'color', [colors(1,:), 0.2]);
end
set(gca,'ColorOrderIndex',2)
plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_iff(1,1), freqs, 'Hz'))), '--');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-90, 180]);

linkaxes([ax1,ax2],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

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

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

#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
freqs = logspace(log10(20), 3, 1000);

figure;
tiledlayout(3, 2, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
% Undamped FRF
plot(f, abs(G_dvf(:,1, 1)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$d\mathcal{L}/u$')
for i = 2:6
    set(gca,'ColorOrderIndex',2)
    plot(f, abs(G_dvf(:,i, i)), 'color', [0,0,0,0.2], ...
         'HandleVisibility', 'off');
end

% Diagonal Elements FRF
plot(f, abs(G_enc_iff_opt(:,1,1)), 'color', [colors(1,:), 0.2], ...
     'DisplayName', '$d\mathcal{L}/u^\prime$')
for i = 2:6
    plot(f, abs(G_enc_iff_opt(:,i,i)), 'color', [colors(1,:), 0.2], ...
         'HandleVisibility', 'off');
end

% Diagonal Elements Model
set(gca,'ColorOrderIndex',2)
plot(freqs, abs(squeeze(freqresp(Gd_iff(1,1), freqs, 'Hz'))), '-', 'LineWidth', 1, 'color', colors(2,:), ...
     'DisplayName', 'Model')
for i = 2:6
    plot(freqs, abs(squeeze(freqresp(Gd_iff(i,i), freqs, 'Hz'))), '-', 'LineWidth', 1, 'color', colors(2,:), ...
         'HandleVisibility', 'off');
end

hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-7, 1e-3]);
legend('location', 'southwest', 'FontSize', 8);

ax1b = nexttile([2,1]);
hold on;
% Off diagonal terms
plot(f, abs(G_dvf(:, 1, 2)), 'color', [0,0,0,0.2], ...
     'DisplayName', '$d\mathcal{L}_{m,i}/u_j$ - FRF')
for i = 1:5
    for j = i+1:6
        plot(f, abs(G_dvf(:, i, j)), 'color', [0,0,0,0.2], ...
             'HandleVisibility', 'off');
    end
end

% Off diagonal FRF
plot(f, abs(G_enc_iff_opt(:,1,2)), 'color', [colors(1,:), 0.2])
for i = 1:5
    for j = i+1:6
        plot(f, abs(G_enc_iff_opt(:,i,j)), 'color', [colors(1,:), 0.2]);
    end
end

% Off diagonal Model
set(gca,'ColorOrderIndex',2)
plot(freqs, abs(squeeze(freqresp(Gd_iff(1,2), freqs, 'Hz'))), '-', 'LineWidth', 1)
for i = 1:5
    for j = i+1:6
        set(gca,'ColorOrderIndex',2)
        plot(freqs, abs(squeeze(freqresp(Gd_iff(i,j), freqs, 'Hz'))));
    end
end

hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
set(gca, 'XTickLabel',[]); set(gca, 'YTickLabel',[]);
ylim([1e-7, 1e-3]);


ax2 = nexttile;
hold on;
for i =1:6
    plot(f, 180/pi*angle(G_dvf(:,i, i)), 'color', [0,0,0,0.2]);
    plot(f, 180/pi*angle(G_enc_iff_opt(:,i,i)), 'color', [colors(1,:), 0.2]);
end
set(gca,'ColorOrderIndex',2)
plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_iff(1,1), freqs, 'Hz'))), '-', 'LineWidth', 1);
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

ax2b = nexttile;
hold on;
% for i = 1:5
%     for j = i+1:6
%         plot(f, 180/pi*angle(G_dvf(:, i, j)), 'color', [0,0,0,0.2]);
%     end
% end

% Off diagonal FRF
for i = 1:5
    for j = i+1:6
        plot(f, 180/pi*angle(G_enc_iff_opt(:,i,j)), 'color', [colors(1,:), 0.2]);
    end
end

% Off diagonal Model
for i = 1:5
    for j = i+1:6
        set(gca,'ColorOrderIndex',2)
        plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_iff(i,j), freqs, 'Hz'))), 'LineWidth', 1);
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]');
hold off;
ylim([-180, 180]);
set(gca, 'YTickLabel',[]);

linkaxes([ax1,ax2,ax1b,ax2b],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

#+begin_src matlab :exports none
i_in  = 1;
i_out = 6;
#+end_src

#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
freqs = logspace(log10(20), 3, 1000);

figure;
tiledlayout(3, 2, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
% OL - FRF
plot(f, abs(G_dvf(:,1, 1)), 'color', [colors(1,:), 0.5], ...
     'DisplayName', '$d\mathcal{L}/u$')

% IFF - FRF
plot(f, abs(G_enc_iff_opt(:,1,1)), 'color', [colors(2,:), 0.5], ...
     'DisplayName', '$d\mathcal{L}/u^\prime$')

% OL - Model
plot(freqs, abs(squeeze(freqresp(Gd_ol(1,1), freqs, 'Hz'))), '--', 'LineWidth', 1, 'color', colors(1,:), ...
     'DisplayName', 'Model')

% IFF - Model
plot(freqs, abs(squeeze(freqresp(Gd_iff(1,1), freqs, 'Hz'))), '--', 'LineWidth', 1, 'color', colors(2,:), ...
     'DisplayName', 'Model')

hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-7, 1e-3]);
legend('location', 'southwest', 'FontSize', 8);

ax1b = nexttile([2,1]);
hold on;
plot(f, abs(G_dvf(:,i_out,i_in)),                                    '-',  'color', [colors(1,:), 0.5])
plot(f, abs(G_enc_iff_opt(:,i_out,i_in)),                            '-',  'color', [colors(2,:), 0.5])
plot(freqs, abs(squeeze(freqresp(Gd_ol(i_out,i_in), freqs, 'Hz'))),  '--', 'color', colors(1,:), 'LineWidth', 1)
plot(freqs, abs(squeeze(freqresp(Gd_iff(i_out,i_in), freqs, 'Hz'))), '--', 'color', colors(2,:), 'LineWidth', 1)
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
set(gca, 'XTickLabel',[]); set(gca, 'YTickLabel',[]);
ylim([1e-7, 1e-3]);


ax2 = nexttile;
hold on;
plot(f, 180/pi*angle(G_dvf(:,1, 1)),                                   '-',  'color', [colors(1,:), 0.5]);
plot(f, 180/pi*angle(G_enc_iff_opt(:,1,1)),                            '-',  'color', [colors(2,:), 0.5]);
plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_ol(1,1), freqs, 'Hz'))),  '--', 'color', colors(1,:), 'LineWidth', 1);
plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_iff(1,1), freqs, 'Hz'))), '--', 'color', colors(2,:), 'LineWidth', 1);
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

ax2b = nexttile;
hold on;
plot(f, 180/pi*angle(G_dvf(:,i_out,i_in)),                                    '-',  'color', [colors(1,:), 0.5]);
plot(f, 180/pi*angle(G_enc_iff_opt(:,i_out,i_in)),                            '-',  'color', [colors(2,:), 0.5]);
plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_ol(i_out,i_in), freqs, 'Hz'))),  '--', 'color', colors(1,:), 'LineWidth', 1);
plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_iff(i_out,i_in), freqs, 'Hz'))), '--', 'color', colors(2,:), 'LineWidth', 1);
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]');
hold off;
ylim([-180, 180]);
set(gca, 'YTickLabel',[]);

linkaxes([ax1,ax2,ax1b,ax2b],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

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

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

*** MEDSI Talk                                                    :noexport:
#+begin_src matlab
%% Load identification data
load('identified_plants_enc_plates.mat', 'f', 'Ts', 'G_iff', 'G_dvf')
#+end_src

#+begin_src matlab :exports none
%% Diagonal elements of the DVF plant
freqs = logspace(log10(20), 3, 1000);

colors = colororder;

figure;
tiledlayout(3, 2, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
plot(f, abs(G_dvf(:,1, 1)), 'color', [colors(1,:),0.2], ...
     'DisplayName', 'FRF - $d_{e,i}/V_{a,i}$')
for i = 2:6
    plot(f, abs(G_dvf(:,i, i)), 'color', [colors(1,:),0.2], ...
         'HandleVisibility', 'off');
end
plot(f, abs(G_enc_iff_opt(:,1, 1)), 'color', [colors(2,:),0.2], ...
     'DisplayName', 'FRF - $d_{e,i}/V_{a,i}^\prime$')
for i = 2:6
    plot(f, abs(G_enc_iff_opt(:,i, i)), 'color', [colors(2,:),0.2], ...
         'HandleVisibility', 'off');
end
plot(freqs, abs(squeeze(freqresp(Gd_ol(1,1), freqs, 'Hz'))), '--', 'color', colors(1,:), ...
     'DisplayName', 'Model - $d_{e,i}/V_{a,i}$')
plot(freqs, abs(squeeze(freqresp(Gd_iff(1,1), freqs, 'Hz'))), '--', 'color', colors(2,:), ...
     'DisplayName', 'Model - $d_{e,i}/V_{a,i}^\prime$')
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/V]'); set(gca, 'XTickLabel',[]);
ylim([3e-7, 1e-3]);
legend('location', 'northwest', 'FontSize', 8);

ax1b = nexttile([2,1]);
hold on;
plot(f, abs(G_dvf(:,1, 2)), 'color', [colors(1,:),0.5], ...
     'DisplayName', 'FRF - $d_{e,1}/V_{a,2}$')
plot(f, abs(G_enc_iff_opt(:,1, 2)), 'color', [colors(2,:),0.5], ...
     'DisplayName', 'FRF - $d_{e,1}/V_{a,2}^\prime$')
plot(freqs, abs(squeeze(freqresp(Gd_ol(1,2), freqs, 'Hz'))), '--', 'color', colors(1,:), ...
     'DisplayName', 'Model - $d_{e,1}/V_{a,2}$')
plot(freqs, abs(squeeze(freqresp(Gd_iff(1,2), freqs, 'Hz'))), '--', 'color', colors(2,:), ...
     'DisplayName', 'Model - $d_{e,1}/V_{a,2}^\prime$')
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
set(gca, 'YTickLabel',[]); set(gca, 'XTickLabel',[]);
ylim([3e-7, 1e-3]);
legend('location', 'northwest', 'FontSize', 8);

ax2 = nexttile;
hold on;
for i = 1:6
    plot(f, 180/pi*angle(G_dvf(:,i, i)), 'color', [colors(1,:),0.2]);
end
for i = 1:6
    plot(f, 180/pi*angle(G_enc_iff_opt(:,i, i)), 'color', [colors(2,:),0.2]);
end
plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_ol(1,1), freqs, 'Hz'))), '--', 'color', colors(1,:));
plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_iff(1,1), freqs, 'Hz'))), '--', 'color', colors(2,:));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-180, 180]);
yticks([-180, -90, 0, 90, 180]);

ax2b = nexttile;
hold on;
plot(f,     180/pi*angle(G_dvf(:,1, 2)), 'color', [colors(1,:),0.5]);
plot(f,     180/pi*angle(G_enc_iff_opt(:,1, 2)), 'color', [colors(2,:),0.5]);
plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_ol(1,2), freqs, 'Hz'))), '--', 'color', colors(1,:));
plot(freqs, 180/pi*angle(squeeze(freqresp(Gd_iff(1,2), freqs, 'Hz'))), '--', 'color', colors(2,:));
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
set(gca, 'YTickLabel',[]); xlabel('Frequency [Hz]');
ylim([-180, 180]);

linkaxes([ax1,ax2,ax1b,ax2b],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

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

#+name: fig:nano_hexapod_damped_bode_plot
#+caption:
#+RESULTS:
[[file:figs/nano_hexapod_damped_bode_plot.png]]

*** Save Damped Plant
The experimentally identified plant is saved for further use.
#+begin_src matlab  :exports none:tangle no
save('matlab/mat/damped_plant_enc_plates.mat', 'f', 'Ts', 'G_enc_iff_opt')
#+end_src

#+begin_src matlab :eval no
save('mat/damped_plant_enc_plates.mat', 'f', 'Ts', 'G_enc_iff_opt')
#+end_src

** Effect of Payload mass - Robust IFF
<<sec:added_mass>>
*** Introduction                                                    :ignore:
In this section, the encoders are fixed to the plates, and we identify the dynamics for several payloads.
The added payload are half cylinders, and three layers can be added for a total of around 40kg (Figure [[fig:picture_added_3_masses]]).

#+name: fig:picture_added_3_masses
#+caption: Picture of the nano-hexapod with added mass
#+attr_latex: :width \linewidth
[[file:figs/picture_added_3_masses.jpg]]

First the dynamics from $\bm{u}$ to $d\mathcal{L}_m$ and $\bm{\tau}_m$ is identified.
Then, the Integral Force Feedback controller is developed and applied as shown in Figure [[fig:nano_hexapod_signals_iff]].
Finally, the dynamics from $\bm{u}^\prime$ to $d\mathcal{L}_m$ is identified and the added damping can be estimated.

#+begin_src latex :file nano_hexapod_signals_iff.pdf
\definecolor{instrumentation}{rgb}{0, 0.447, 0.741}
\definecolor{mechanics}{rgb}{0.8500, 0.325, 0.098}
\definecolor{control}{rgb}{0.4660, 0.6740, 0.1880}

\begin{tikzpicture}
  % Blocs
  \node[block={4.0cm}{3.0cm}, fill=mechanics!20!white] (nano_hexapod) {Mechanics};
  \coordinate[] (inputF)  at (nano_hexapod.west);
  \coordinate[] (outputL) at ($(nano_hexapod.south east)!0.8!(nano_hexapod.north east)$);
  \coordinate[] (outputF) at ($(nano_hexapod.south east)!0.2!(nano_hexapod.north east)$);

  \node[block, left= 0.8 of inputF,  fill=instrumentation!20!white, align=center] (F_stack) {\tiny Actuator \\ \tiny stacks};
  \node[block, left= 0.8 of F_stack, fill=instrumentation!20!white] (PD200)   {PD200};
  \node[DAC,   left= 0.8 of PD200,   fill=instrumentation!20!white] (F_DAC)   {DAC};
  \node[block, right=0.8 of outputF, fill=instrumentation!20!white, align=center] (Fm_stack){\tiny Sensor \\ \tiny stack};
  \node[ADC,   right=0.8 of Fm_stack,fill=instrumentation!20!white] (Fm_ADC)  {ADC};
  \node[block, right=0.8 of outputL, fill=instrumentation!20!white] (encoder) {\tiny Encoder};
  \node[addb,  left= 0.8 of F_DAC,   fill=control!20!white]         (add_iff) {};
  \node[block, below=0.8 of add_iff, fill=control!20!white]         (Kiff) {\tiny $K_{\text{IFF}}(s)$};

  % Connections and labels
  \draw[->] (add_iff.east) node[above right]{$\bm{u}$} node[below right]{$[V]$} -- node[sloped]{$/$} (F_DAC.west);
  \draw[->] (F_DAC.east)   -- node[midway, above]{$\tilde{\bm{u}}$}node[midway, below]{$[V]$} (PD200.west);
  \draw[->] (PD200.east)   -- node[midway, above]{$\bm{u}_a$}node[midway, below]{$[V]$} (F_stack.west);
  \draw[->] (F_stack.east) -- (inputF) node[above left]{$\bm{\tau}$}node[below left]{$[N]$};

  \draw[->] (outputF)       -- (Fm_stack.west) node[above left]{$\bm{\epsilon}$} node[below left]{$[m]$};
  \draw[->] (Fm_stack.east) -- node[midway, above]{$\tilde{\bm{\tau}}_m$}node[midway, below]{$[V]$} (Fm_ADC.west);
  \draw[->] (Fm_ADC.east)   -- node[sloped]{$/$} ++(0.8, 0)coordinate(end) node[above left]{$\bm{\tau}_m$}node[below left]{$[V]$};

  \draw[->] (outputL)      -- (encoder.west) node[above left]{$d\bm{\mathcal{L}}$} node[below left]{$[m]$};
  \draw[->] (encoder.east) -- node[sloped]{$/$} (encoder-|end) node[above left]{$d\bm{\mathcal{L}}_m$}node[below left]{$[m]$};

  \draw[->] ($(Fm_ADC.east)+(0.14,0)$) node[branch]{} -- node[sloped]{$/$} ++(0, -1.8) -| (Kiff.south);
  \draw[->] (Kiff.north) -- node[sloped]{$/$} (add_iff.south);
  \draw[->] ($(add_iff.west)+(-0.8,0)$) node[above right]{$\bm{u}^\prime$} node[below right]{$[V]$} -- node[sloped]{$/$} (add_iff.west);

  % Nano-Hexapod
  \begin{scope}[on background layer]
    \node[fit={(F_stack.west|-nano_hexapod.south) (Fm_stack.east|-nano_hexapod.north)}, fill=black!20!white, draw, inner sep=2pt] (system) {};
    \node[above] at (system.north) {Nano-Hexapod};
  \end{scope}
\end{tikzpicture}
#+end_src

#+name: fig:nano_hexapod_signals_iff
#+caption: Block Diagram of the experimental setup and model
#+RESULTS:
[[file:figs/nano_hexapod_signals_iff.png]]

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

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

**** Compute FRF in open-loop
#+begin_src matlab :tangle no :exports none
addpath('./matlab/mat/');
#+end_src

#+begin_src matlab :eval no :exports none
addpath('./mat/');
#+end_src

The identification is performed without added mass, and with one, two and three layers of added cylinders.
#+begin_src matlab
i_masses = 0:3;
#+end_src

The following data are loaded:
- =Va=: the excitation voltage (corresponding to $u_i$)
- =Vs=: the generated voltage by the 6 force sensors (corresponding to $\bm{\tau}_m$)
- =de=: the measured motion by the 6 encoders (corresponding to $d\bm{\mathcal{L}}_m$)
#+begin_src matlab
%% Load Identification Data
meas_added_mass = {};

for i_mass = i_masses
    for i_strut = 1:6
        meas_added_mass(i_strut, i_mass+1) = {load(sprintf('frf_data_exc_strut_%i_realigned_vib_table_%im.mat', i_strut, i_mass), 't', 'Va', 'Vs', 'de')};
    end
end
#+end_src

The window =win= and the frequency vector =f= are defined.
#+begin_src matlab
% Sampling Time [s]
Ts = (meas_added_mass{1,1}.t(end) - (meas_added_mass{1,1}.t(1)))/(length(meas_added_mass{1,1}.t)-1);

% Hannning Windows
win = hanning(ceil(1/Ts));

% And we get the frequency vector
[~, f] = tfestimate(meas_added_mass{1,1}.Va, meas_added_mass{1,1}.de, win, [], [], 1/Ts);
#+end_src

Finally the $6 \times 6$ transfer function matrices from $\bm{u}$ to $d\bm{\mathcal{L}}_m$ and from $\bm{u}$ to $\bm{\tau}_m$ are identified:
#+begin_src matlab
%% DVF Plant (transfer function from u to dLm)
G_dL = {};

for i_mass = i_masses
    G_dL(i_mass+1) = {zeros(length(f), 6, 6)};
    for i_strut = 1:6
        G_dL{i_mass+1}(:,:,i_strut) = tfestimate(meas_added_mass{i_strut, i_mass+1}.Va, meas_added_mass{i_strut, i_mass+1}.de, win, [], [], 1/Ts);
    end
end

%% IFF Plant (transfer function from u to taum)
G_tau = {};

for i_mass = i_masses
    G_tau(i_mass+1) = {zeros(length(f), 6, 6)};
    for i_strut = 1:6
        G_tau{i_mass+1}(:,:,i_strut) = tfestimate(meas_added_mass{i_strut, i_mass+1}.Va, meas_added_mass{i_strut, i_mass+1}.Vs, win, [], [], 1/Ts);
    end
end
#+end_src

The identified dynamics are then saved for further use.
#+begin_src matlab :exports none :tangle no
save('matlab/mat/frf_vib_table_m.mat', 'f', 'Ts', 'G_tau', 'G_dL')
#+end_src

#+begin_src matlab :eval no
save('mat/frf_vib_table_m.mat', 'f', 'Ts', 'G_tau', 'G_dL')
#+end_src

*** Transfer function from $\bm{u}$ to $d\bm{\mathcal{L}}_m$
The transfer functions from $u_i$ to $d\mathcal{L}_{m,i}$ are shown in Figure [[fig:comp_plant_payloads_dvf]].

#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i_mass = i_masses
    plot(frf_ol.f, abs(frf_ol.G_dL{i_mass+1}(:,1, 1)), 'color', colors(i_mass+1,:), ...
         'DisplayName', sprintf('$d\\mathcal{L}_{m,i}/u_i$ - %i', i_mass));
    for i = 2:6
        plot(frf_ol.f, abs(frf_ol.G_dL{i_mass+1}(:,i, i)), 'color', colors(i_mass+1,:), ...
             'HandleVisibility', 'off');
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-8, 1e-3]);
legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 2);

ax2 = nexttile;
hold on;
for i_mass = i_masses
    for i =1:6
        plot(frf_ol.f, 180/pi*angle(frf_ol.G_dL{i_mass+1}(:,i, i)), 'color', colors(i_mass+1,:));
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-90, 180])

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

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

#+name: fig:comp_plant_payloads_dvf
#+caption: Measured Frequency Response Functions from $u_i$ to $d\mathcal{L}_{m,i}$ for all 4 payload conditions
#+RESULTS:
[[file:figs/comp_plant_payloads_dvf.png]]


#+begin_important
From Figure [[fig:comp_plant_payloads_dvf]], we can observe few things:
- The obtained dynamics is changing a lot between the case without mass and when there is at least one added mass.
- Between 1, 2 and 3 added masses, the dynamics is not much different, and it would be easier to design a controller only for these cases.
- The flexible modes of the top plate is first decreased a lot when the first mass is added (from 700Hz to 400Hz).
  This is due to the fact that the added mass is composed of two half cylinders which are not fixed together.
  Therefore is adds a lot of mass to the top plate without adding a lot of rigidity in one direction.
  When more than 1 mass layer is added, the half cylinders are added with some angles such that rigidity are added in all directions (see Figure [[fig:picture_added_3_masses]]).
  In that case, the frequency of these flexible modes are increased.
  In practice, the payload should be one solid body, and we should not see a massive decrease of the frequency of this flexible mode.
- Flexible modes of the top plate are becoming less problematic as masses are added.
- First flexible mode of the strut at 230Hz is not much decreased when mass is added.
  However, its apparent amplitude is much decreased.
#+end_important

*** Transfer function from $\bm{u}$ to $\bm{\tau}_m$
The transfer functions from $u_i$ to $\tau_{m,i}$ are shown in Figure [[fig:comp_plant_payloads_iff]].

#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i_mass = i_masses
    set(gca, 'ColorOrderIndex', i_mass+1)
    plot(frf_ol.f, abs(frf_ol.G_tau{i_mass+1}(:,1, 1)), ...
         'DisplayName', sprintf('$\\tau_{m,i}/u_i$ - %i', i_mass));
    for i = 2:6
        set(gca, 'ColorOrderIndex', i_mass+1)
        plot(frf_ol.f, abs(frf_ol.G_tau{i_mass+1}(:,i, i)), ...
             'HandleVisibility', 'off');
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [V/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-2, 1e2]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 3);

ax2 = nexttile;
hold on;
for i_mass = i_masses
    for i =1:6
        set(gca,'ColorOrderIndex',i_mass+1)
        plot(frf_ol.f, 180/pi*angle(frf_ol.G_tau{i_mass+1}(:,i, i)));
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

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

#+name: fig:comp_plant_payloads_iff
#+caption: Measured Frequency Response Functions from $u_i$ to $\tau_{m,i}$ for all 4 payload conditions
#+RESULTS:
[[file:figs/comp_plant_payloads_iff.png]]

#+begin_important
From Figure [[fig:comp_plant_payloads_iff]], we can see that for all added payloads, the transfer function from $u_i$ to $\tau_{m,i}$ always has alternating poles and zeros.
#+end_important

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

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

#+begin_src matlab :tangle no
addpath('./matlab/mat/');
addpath('./matlab/src/');
addpath('./matlab/');
#+end_src

#+begin_src matlab :eval no
addpath('./mat/');
addpath('./src/');
#+end_src

#+begin_src matlab :tangle no
%% Add all useful folders to the path
addpath('matlab/nass-simscape/matlab/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/png/')
addpath('matlab/nass-simscape/src/')
addpath('matlab/nass-simscape/mat/')
addpath('matlab/vibration-table/matlab/')
addpath('matlab/vibration-table/STEPS/')
#+end_src

#+begin_src matlab :eval no
%% Add all useful folders to the path
addpath('nass-simscape/matlab/nano_hexapod/')
addpath('nass-simscape/STEPS/nano_hexapod/')
addpath('nass-simscape/STEPS/png/')
addpath('nass-simscape/src/')
addpath('nass-simscape/mat/')
addpath('vibration-table/matlab/')
#+end_src

#+begin_src matlab
%% Load the identified FRF
frf_ol = load('frf_vib_table_m.mat', 'f', 'Ts', 'G_tau', 'G_dL');
#+end_src

#+begin_src matlab
i_masses = 0:3;
#+end_src

#+begin_src matlab
%% Open Simulink Model
mdl = 'nano_hexapod_simscape';

options = linearizeOptions;
options.SampleTime = 0;

open(mdl)

Rx = zeros(1, 7);

colors = colororder;
#+end_src

*** System Identification
Let's initialize the simscape model with the nano-hexapod fixed on top of the vibration table.
#+begin_src matlab
support.type = 1; % On top of vibration table
#+end_src

The model of the nano-hexapod is defined as shown bellow:
#+begin_src matlab
%% Initialize Nano-Hexapod
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '2dof', ...
                                       'flex_top_type', '3dof', ...
                                       'motion_sensor_type', 'plates', ...
                                       'actuator_type', '2dof');
#+end_src

And finally, we add the same payloads as during the experiments:
#+begin_src matlab
payload.type = 1; % Payload / 1 "mass layer"
#+end_src

First perform the identification for the transfer functions from $\bm{u}$ to $d\bm{\mathcal{L}}_m$:
#+begin_src matlab
%% Identify the DVF Plant (transfer function from u to dLm)
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'], 1, 'openinput');  io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/dL'], 1, 'openoutput'); io_i = io_i + 1; % Encoders

%% Identification for all the added payloads
G_dL = {};

for i = i_masses
    fprintf('i = %i\n', i)
    payload.type = i;
    G_dL(i+1) = {exp(-s*frf_ol.Ts)*linearize(mdl, io, 0.0, options)};
end
#+end_src

#+begin_src matlab
%% Identify the IFF Plant (transfer function from u to taum)
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'], 1, 'openinput');  io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/Fm'], 1, 'openoutput'); io_i = io_i + 1; % Force Sensors

%% Identification for all the added payloads
G_tau = {};

for i = 0:3
    fprintf('i = %i\n', i)
    payload.type = i;
    G_tau(i+1) = {exp(-s*frf_ol.Ts)*linearize(mdl, io, 0.0, options)};
end
#+end_src

The identified dynamics are then saved for further use.
#+begin_src matlab :exports none :tangle no
save('matlab/mat/sim_vib_table_m.mat', 'G_tau', 'G_dL')
#+end_src

#+begin_src matlab :eval no
save('mat/sim_vib_table_m.mat', 'G_tau', 'G_dL')
#+end_src

*** Transfer function from $\bm{u}$ to $d\bm{\mathcal{L}}_m$
#+begin_src matlab :exports none
sim_m = load('sim_vib_table_m.mat', 'G_tau', 'G_dL');
#+end_src

The measured FRF and the identified dynamics from $u_i$ to $d\mathcal{L}_{m,i}$ are compared in Figure [[fig:comp_masses_model_exp_dvf]].
A zoom near the "suspension" modes is shown in Figure [[fig:comp_masses_model_exp_dvf_zoom]].

#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

freqs = 2*logspace(1,3,1000);

ax1 = nexttile([2,1]);
hold on;
for i_mass = i_masses
    plot(frf_ol.f, abs(frf_ol.G_dL{i_mass+1}(:,1, 1)), 'color', [colors(i_mass+1,:), 0.2], ...
         'DisplayName', sprintf('$d\\mathcal{L}_{m,i}/u_i$ - FRF %i', i_mass));
    for i = 2:6
        plot(frf_ol.f, abs(frf_ol.G_dL{i_mass+1}(:,i, i)), 'color', [colors(i_mass+1,:), 0.2], ...
             'HandleVisibility', 'off');
    end
    set(gca, 'ColorOrderIndex', i_mass+1)
    plot(freqs, abs(squeeze(freqresp(sim_m.G_dL{i_mass+1}(1,1), freqs, 'Hz'))), '--', ...
         'DisplayName', sprintf('$d\\mathcal{L}_{m,i}/u_i$ - Sim %i', i_mass));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-8, 1e-3]);
legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 2);

ax2 = nexttile;
hold on;
for i_mass = i_masses
    for i =1:6
        plot(frf_ol.f, 180/pi*angle(frf_ol.G_dL{i_mass+1}(:,i, i)), 'color', [colors(i_mass+1,:), 0.2]);
    end
    set(gca, 'ColorOrderIndex', i_mass+1)
    plot(freqs, 180/pi*angle(squeeze(freqresp(sim_m.G_dL{i_mass+1}(1,1), freqs, 'Hz'))), '--');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:45:360);
ylim([-45, 180]);

linkaxes([ax1,ax2],'x');
xlim([20, 1e3]);
#+end_src

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

#+name: fig:comp_masses_model_exp_dvf
#+caption: Comparison of the transfer functions from $u_i$ to $d\mathcal{L}_{m,i}$ - measured FRF and identification from the Simscape model
#+RESULTS:
[[file:figs/comp_masses_model_exp_dvf.png]]

#+begin_src matlab :exports none :tangle no
ax1.YLim = [1e-6, 5e-4];
xlim([40, 2e2]);
#+end_src

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

#+name: fig:comp_masses_model_exp_dvf_zoom
#+caption: Comparison of the transfer functions from $u_i$ to $d\mathcal{L}_{m,i}$ - measured FRF and identification from the Simscape model (Zoom)
#+RESULTS:
[[file:figs/comp_masses_model_exp_dvf_zoom.png]]

#+begin_important
The Simscape model is very accurately representing the measured dynamics up.
Only the flexible modes of the struts and of the top plate are not represented here as these elements are modelled as rigid bodies.
#+end_important

*** Transfer function from $\bm{u}$ to $\bm{\tau}_m$
The measured FRF and the identified dynamics from $u_i$ to $\tau_{m,i}$ are compared in Figure [[fig:comp_masses_model_exp_iff]].
A zoom near the "suspension" modes is shown in Figure [[fig:comp_masses_model_exp_iff_zoom]].

#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

freqs = 2*logspace(1,3,1000);

ax1 = nexttile([2,1]);
hold on;
for i_mass = 0:3
    plot(frf_ol.f, abs(frf_ol.G_tau{i_mass+1}(:,1, 1)), 'color', [colors(i_mass+1,:), 0.2], ...
         'DisplayName', sprintf('$d\\tau_{m,i}/u_i$ - FRF %i', i_mass));
    for i = 2:6
        plot(frf_ol.f, abs(frf_ol.G_tau{i_mass+1}(:,i, i)), 'color', [colors(i_mass+1,:), 0.2], ...
             'HandleVisibility', 'off');
    end
    plot(freqs, abs(squeeze(freqresp(sim_m.G_tau{i_mass+1}(1,1), freqs, 'Hz'))), '--', 'color', colors(i_mass+1,:), ...
         'DisplayName', sprintf('$\\tau_{m,i}/u_i$ - Sim %i', i_mass));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [V/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-2, 1e2]);
legend('location', 'southeast', 'FontSize', 8, 'NumColumns', 2);

ax2 = nexttile;
hold on;
for i_mass = 0:3
    for i =1:6
        plot(frf_ol.f, 180/pi*angle(frf_ol.G_tau{i_mass+1}(:,i, i)), 'color', [colors(i_mass+1,:), 0.2]);
    end
    plot(freqs, 180/pi*angle(squeeze(freqresp(sim_m.G_tau{i_mass+1}(i,i), freqs, 'Hz'))), '--', 'color', colors(i_mass+1,:));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);

linkaxes([ax1,ax2],'x');
xlim([20, 2e3]);
#+end_src

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

#+name: fig:comp_masses_model_exp_iff
#+caption: Comparison of the transfer functions from $u_i$ to $\tau_{m,i}$ - measured FRF and identification from the Simscape model
#+RESULTS:
[[file:figs/comp_masses_model_exp_iff.png]]

#+begin_src matlab :exports none :tangle no
xlim([40, 2e2]);
#+end_src

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

#+name: fig:comp_masses_model_exp_iff_zoom
#+caption: Comparison of the transfer functions from $u_i$ to $\tau_{m,i}$ - measured FRF and identification from the Simscape model (Zoom)
#+RESULTS:
[[file:figs/comp_masses_model_exp_iff_zoom.png]]

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

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

#+begin_src matlab :tangle no
addpath('./matlab/mat/');
addpath('./matlab/src/');
addpath('./matlab/');
#+end_src

#+begin_src matlab :eval no
addpath('./mat/');
addpath('./src/');
#+end_src

#+begin_src matlab :tangle no
%% Add all useful folders to the path
addpath('matlab/nass-simscape/matlab/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/png/')
addpath('matlab/nass-simscape/src/')
addpath('matlab/nass-simscape/mat/')
addpath('matlab/vibration-table/matlab/')
addpath('matlab/vibration-table/STEPS/')
#+end_src

#+begin_src matlab :eval no
%% Add all useful folders to the path
addpath('nass-simscape/matlab/nano_hexapod/')
addpath('nass-simscape/STEPS/nano_hexapod/')
addpath('nass-simscape/STEPS/png/')
addpath('nass-simscape/src/')
addpath('nass-simscape/mat/')
addpath('vibration-table/matlab/')
#+end_src

#+begin_src matlab
%% Load the identified FRF and Simscape model
frf_ol = load('frf_vib_table_m.mat', 'f', 'Ts', 'G_tau', 'G_dL');
sim_ol = load('sim_vib_table_m.mat', 'G_tau', 'G_dL');
#+end_src

#+begin_src matlab
i_masses = 0:3;
#+end_src

#+begin_src matlab
%% Open Simulink Model
mdl = 'nano_hexapod_simscape';

options = linearizeOptions;
options.SampleTime = 0;

Rx = zeros(1, 7);

colors = colororder;
#+end_src

*** Robust IFF Controller
Based on the measured FRF from $u_i$ to $\tau_{m,i}$, the following IFF controller is developed:
#+begin_src matlab
%% IFF Controller
Kiff_g1 = (1/(s + 2*pi*20))*... % LPF: provides integral action above 20[Hz]
          (s/(s + 2*pi*20))*... % HPF: limit low frequency gain
          (1/(1 + s/2/pi/400)); % LPF: more robust to high frequency resonances
#+end_src

Then, the Root Locus plot of Figure [[fig:iff_root_locus_masses]] is used to estimate the optimal gain.
This Root Locus plot is computed from the Simscape model.
#+begin_src matlab :exports none
%% Root Locus for IFF
gains = -logspace(1, 3, 100);

figure;

hold on;
% Pure Integrator
for i_mass = 0:3
    plot(real(pole(sim_ol.G_tau{i_mass+1})),   imag(pole(sim_ol.G_tau{i_mass+1})),  'x', 'color', colors(i_mass+1, :), ...
         'DisplayName', sprintf('OL Poles - %i', i_mass));
    plot(real(tzero(sim_ol.G_tau{i_mass+1})),  imag(tzero(sim_ol.G_tau{i_mass+1})), 'o', 'color', colors(i_mass+1, :), ...
         'HandleVisibility', 'off');
end

for i_mass = 0:3
    for g = gains
        clpoles = pole(feedback(sim_ol.G_tau{i_mass+1}, g*Kiff_g1*eye(6), +1));
        plot(real(clpoles), imag(clpoles), '.', 'color', colors(i_mass+1, :), ...
             'HandleVisibility', 'off');
    end
end

g_opt = -2e2;

clpoles = pole(feedback(sim_ol.G_tau{1}, g_opt*Kiff_g1*eye(6), +1));
plot(real(clpoles), imag(clpoles), 'kx', ...
     'DisplayName', sprintf('$g = %.0f$', g_opt));
for i_mass = 1:3
    clpoles = pole(feedback(sim_ol.G_tau{i_mass+1}, g_opt*Kiff_g1*eye(6), +1));
    plot(real(clpoles), imag(clpoles), 'kx', ...
         'HandleVisibility', 'off');
end
hold off;
axis square;
xlim([-600, 0]); ylim([0, 1400]);
xlabel('Real Part'); ylabel('Imaginary Part');
legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 3);
#+end_src

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

#+name: fig:iff_root_locus_masses
#+caption: Root Locus for the IFF control strategy (for all payload conditions).
#+RESULTS:
[[file:figs/iff_root_locus_masses.png]]

#+begin_src matlab :exports none
%% Verify close-loop stability for all payloads
for i_mass = 0:3
    clpoles = pole(feedback(sim_ol.G_tau{i_mass+1}, g_opt*Kiff_g1*eye(6), +1));
    sum(real(clpoles)>0)
end
#+end_src

The found optimal IFF controller is:
#+begin_src matlab
%% Optimal controller
g_opt = -2e2;
Kiff = g_opt*Kiff_g1*eye(6);
#+end_src

It is saved for further use.
#+begin_src matlab :exports none :tangle no
save('matlab/mat/Kiff_opt.mat', 'Kiff')
#+end_src

#+begin_src matlab :eval no
save('mat/Kiff_opt.mat', 'Kiff')
#+end_src

The corresponding experimental loop gains are shown in Figure [[fig:iff_loop_gain_masses]].
#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i_mass = 0:3
    for i = 1:6
        plot(frf_ol.f, abs(squeeze(freqresp(Kiff(i,i), frf_ol.f, 'Hz')).*frf_ol.G_tau{i_mass+1}(:,i,i)), '-', 'color', [colors(i_mass+1,:), 0.2]);
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Loop Gain [-]'); set(gca, 'XTickLabel',[]);
ylim([1e-2, 1e2]);

ax2 = nexttile;
hold on;
for i_mass = 0:3
    for i = 1:6
        plot(frf_ol.f, 180/pi*angle(squeeze(freqresp(-Kiff(i,i), frf_ol.f, 'Hz')).*frf_ol.G_tau{i_mass+1}(:,i,i)), '-', 'color', [colors(i_mass+1,:), 0.2]);
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([10, 1e3]);
#+end_src

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

#+name: fig:iff_loop_gain_masses
#+caption: Loop gain for the Integral Force Feedback controller
#+RESULTS:
[[file:figs/iff_loop_gain_masses.png]]

#+begin_important
Based on the above analysis:
- The same IFF controller can be used to damp the suspension modes for all payload conditions
- The IFF controller should be robust
#+end_important

*** Estimated Damped Plant from the Simscape model
Let's initialize the simscape model with the nano-hexapod fixed on top of the vibration table.
#+begin_src matlab
support.type = 1; % On top of vibration table
#+end_src

The model of the nano-hexapod is defined as shown bellow:
#+begin_src matlab
%% Initialize the Simscape model in closed loop
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '2dof', ...
                                       'flex_top_type', '3dof', ...
                                       'motion_sensor_type', 'plates', ...
                                       'actuator_type', '2dof', ...
                                       'controller_type', 'iff');
#+end_src

And finally, we add the same payloads as during the experiments:
#+begin_src matlab
payload.type = 1; % Payload / 1 "mass layer"
#+end_src

#+begin_src matlab :exports none
%% Open Simscape Model
open(mdl)

%% Make sure IFF controller is loaded
load('mat/Kiff_opt.mat', 'Kiff')
#+end_src

#+begin_src matlab
%% Identify the (damped) transfer function from u to dLm
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'], 1, 'openinput');  io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/dL'], 1, 'openoutput'); io_i = io_i + 1; % Plate Displacement (encoder)

%% Identify for all add masses
G_dL = {};

for i = i_masses
    payload.type = i;
    G_dL(i+1) = {exp(-s*frf_ol.Ts)*linearize(mdl, io, 0.0, options)};
end
#+end_src

The identified dynamics are then saved for further use.
#+begin_src matlab :exports none :tangle no
save('matlab/mat/sim_iff_vib_table_m.mat', 'G_dL');
#+end_src

#+begin_src matlab :eval no
save('mat/sim_iff_vib_table_m.mat', 'G_dL');
#+end_src

#+begin_src matlab
sim_iff = load('sim_iff_vib_table_m.mat', 'G_dL');
#+end_src

#+begin_src matlab :exports none
%% Verify Stability
for i = i_masses
    isstable(sim_iff.G_dL{i+1})
end
#+end_src

#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

freqs = logspace(1,3,1000);

ax1 = nexttile([2,1]);
hold on;
for i_mass = i_masses
    for i = 1
        plot(freqs, abs(squeeze(freqresp(sim_ol.G_dL{i_mass+1}(i,i), freqs, 'Hz'))), '-', 'color', [colors(i_mass+1, :), 0.5], ...
             'DisplayName', sprintf('$d\\mathcal{L}_i/u_i$ - %i', i_mass));
        plot(freqs, abs(squeeze(freqresp(sim_iff.G_dL{i_mass+1}(i,i), freqs, 'Hz'))), '-', 'color', colors(i_mass+1, :), ...
             'DisplayName', sprintf('$d\\mathcal{L}_i/u^\\prime_i$ - %i', i_mass));
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-7, 1e-3]);
legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 4);

ax2 = nexttile;
hold on;
for i_mass = i_masses
    for i = 1
        plot(freqs, 180/pi*angle(squeeze(freqresp(sim_ol.G_dL{i_mass+1}(1,1), freqs, 'Hz'))), '-', 'color', [colors(i_mass+1, :), 0.5]);
        plot(freqs, 180/pi*angle(squeeze(freqresp(sim_iff.G_dL{i_mass+1}(1,1), freqs, 'Hz'))), '-', 'color', colors(i_mass+1, :));
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

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

#+name: fig:damped_plant_model_masses
#+caption: Transfer function from $u_i$ to $d\mathcal{L}_{m,i}$ (without active damping) and from $u^\prime_i$ to $d\mathcal{L}_{m,i}$ (with IFF)
#+RESULTS:
[[file:figs/damped_plant_model_masses.png]]

*** Compute the identified FRF with IFF
The identification is performed without added mass, and with one, two and three layers of added cylinders.
#+begin_src matlab
i_masses = 0:3;
#+end_src

The following data are loaded:
- =Va=: the excitation voltage for the damped plant (corresponding to $u^\prime_i$)
- =de=: the measured motion by the 6 encoders (corresponding to $d\bm{\mathcal{L}}_m$)
#+begin_src matlab
%% Load Identification Data
meas_added_mass = {};

for i_mass = i_masses
    for i_strut = 1:6
        meas_iff_mass(i_strut, i_mass+1) = {load(sprintf('frf_data_exc_strut_%i_iff_vib_table_%im.mat', i_strut, i_mass), 't', 'Va', 'de')};
    end
end
#+end_src

The window =win= and the frequency vector =f= are defined.
#+begin_src matlab
% Sampling Time [s]
Ts = (meas_iff_mass{1,1}.t(end) - (meas_iff_mass{1,1}.t(1)))/(length(meas_iff_mass{1,1}.t)-1);

% Hannning Windows
win = hanning(ceil(1/Ts));

% And we get the frequency vector
[~, f] = tfestimate(meas_iff_mass{1,1}.Va, meas_iff_mass{1,1}.de, win, [], [], 1/Ts);
#+end_src

Finally the $6 \times 6$ transfer function matrix from $\bm{u}^\prime$ to $d\bm{\mathcal{L}}_m$ is estimated:
#+begin_src matlab
%% DVF Plant (transfer function from u to dLm)
G_dL = {};

for i_mass = i_masses
    G_dL(i_mass+1) = {zeros(length(f), 6, 6)};
    for i_strut = 1:6
        G_dL{i_mass+1}(:,:,i_strut) = tfestimate(meas_iff_mass{i_strut, i_mass+1}.Va, meas_iff_mass{i_strut, i_mass+1}.de, win, [], [], 1/Ts);
    end
end
#+end_src

The identified dynamics are then saved for further use.
#+begin_src matlab :exports none :tangle no
save('matlab/mat/frf_iff_vib_table_m.mat', 'f', 'Ts', 'G_dL');
#+end_src

#+begin_src matlab :eval no
save('mat/frf_iff_vib_table_m.mat', 'f', 'Ts', 'G_dL');
#+end_src

*** Comparison of the measured FRF and the Simscape model
#+begin_src matlab :exports none
%% Load the Measured FRF of the damped plant
frf_iff = load('frf_iff_vib_table_m.mat', 'f', 'Ts', 'G_dL');
#+end_src

The following figures are computed:
- Figure [[fig:damped_iff_plant_meas_frf]]: the measured damped FRF are displayed
- Figure [[fig:comp_undamped_damped_plant_meas_frf]]: the open-loop and damped FRF are compared (diagonal elements)
- Figure [[fig:comp_iff_plant_frf_sim]]: the obtained damped FRF is compared with the identified damped from using the Simscape model

#+begin_src matlab :exports none
%% Diagonal and Off Diagonal elements of the damped plants
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i_mass = i_masses
    plot(frf_iff.f, abs(frf_iff.G_dL{i_mass+1}(:,1,1)), 'color', colors(i_mass+1,:), ...
         'DisplayName', sprintf('$d\\mathcal{L}_{m,i}/u^\\prime_i$ - %i', i_mass));
    for i = 2:6
        plot(frf_iff.f, abs(frf_iff.G_dL{i_mass+1}(:,i,i)), 'color', colors(i_mass+1,:), ...
             'HandleVisibility', 'off');
    end
    plot(frf_iff.f, abs(frf_iff.G_dL{i_mass+1}(:,1,2)), 'color', [colors(i_mass+1,:), 0.2], ...
         'DisplayName', sprintf('$d\\mathcal{L}_{m,i}/u^\\prime_j$ - %i', i_mass));
    for i = 1:5
        for j = i+1:6
            plot(frf_iff.f, abs(frf_iff.G_dL{i_mass+1}(:,i,j)), 'color', [colors(i_mass+1,:), 0.2], ...
                 'HandleVisibility', 'off');
        end
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_L/V_a$ [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-9, 1e-4]);
legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 2);

ax2 = nexttile;
hold on;
for i_mass = i_masses
    for i =1:6
        plot(frf_iff.f, 180/pi*angle(frf_iff.G_dL{i_mass+1}(:,i, i)), 'color', colors(i_mass+1,:));
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([10, 1e3]);
#+end_src

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

#+name: fig:damped_iff_plant_meas_frf
#+caption: Diagonal and off-diagonal of the measured FRF matrix for the damped plant
#+RESULTS:
[[file:figs/damped_iff_plant_meas_frf.png]]

#+begin_src matlab :exports none
%% Comparison of the OL and IFF identified FRF
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i_mass = i_masses
    plot(frf_ol.f,  abs(frf_ol.G_dL{i_mass+1}(:,1,1)), '-', 'color', [colors(i_mass+1, :), 0.5], ...
         'DisplayName', sprintf('$d\\mathcal{L}_i/u_i$ - %i', i_mass));
    plot(frf_iff.f, abs(frf_iff.G_dL{i_mass+1}(:,1,1)), '-', 'color', colors(i_mass+1, :), ...
         'DisplayName', sprintf('$d\\mathcal{L}_i/u^\\prime_i$ - %i', i_mass));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_L/V_a$ [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-7, 1e-3]);
legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 2);

ax2 = nexttile;
hold on;
for i_mass = i_masses
    plot(frf_ol.f,  180/pi*angle(frf_ol.G_dL{i_mass+1}(:,1,1)),  '-', 'color', [colors(i_mass+1, :), 0.5]);
    plot(frf_iff.f, 180/pi*angle(frf_iff.G_dL{i_mass+1}(:,1,1)), '-', 'color', colors(i_mass+1, :));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([10, 1e3]);
#+end_src

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

#+name: fig:comp_undamped_damped_plant_meas_frf
#+caption: Damped and Undamped measured FRF (diagonal elements)
#+RESULTS:
[[file:figs/comp_undamped_damped_plant_meas_frf.png]]

#+begin_src matlab :exports none
%% Comparison of the measured FRF and identified TF of the damped plant
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

freqs = logspace(1,3,1000);

ax1 = nexttile([2,1]);
hold on;
for i_mass = i_masses
    plot(frf_iff.f, abs(frf_iff.G_dL{i_mass+1}(:,1, 1)), 'color', [colors(i_mass+1,:), 0.2], ...
         'DisplayName', sprintf('$d\\mathcal{L}_{m,i}/u^\\prime_i$ - FRF %i', i_mass));
    for i = 2:6
        plot(frf_iff.f, abs(frf_iff.G_dL{i_mass+1}(:,i, i)), 'color', [colors(i_mass+1,:), 0.2], ...
             'HandleVisibility', 'off');
    end
    set(gca, 'ColorOrderIndex', i_mass+1)
    plot(freqs, abs(squeeze(freqresp(sim_iff.G_dL{i_mass+1}(1,1), freqs, 'Hz'))), '--', ...
         'DisplayName', sprintf('$d\\mathcal{L}_{m,i}/u^\\prime_i$ - Sim %i', i_mass));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-8, 1e-4]);
legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 2);

ax2 = nexttile;
hold on;
for i_mass = i_masses
    for i =1:6
        plot(frf_iff.f, 180/pi*angle(frf_iff.G_dL{i_mass+1}(:,i, i)), 'color', [colors(i_mass+1,:), 0.2]);
    end
    set(gca, 'ColorOrderIndex', i_mass+1)
    plot(freqs, 180/pi*angle(squeeze(freqresp(sim_iff.G_dL{i_mass+1}(1,1), freqs, 'Hz'))), '--');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([10, 1e3]);
#+end_src

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

#+name: fig:comp_iff_plant_frf_sim
#+caption: Comparison of the measured FRF and the identified dynamics from the Simscape model
#+RESULTS:
[[file:figs/comp_iff_plant_frf_sim.png]]

#+begin_important
The IFF control strategy effectively damps all the suspensions modes of the nano-hexapod whatever the payload is.
The obtained plant is easier to control (provided the flexible modes of the top platform are well damped).
#+end_important

*** Change of coupling with IFF
The added damping using IFF reduces the coupling in the system near the suspensions modes that are damped.
It can be estimated by taking the ratio of the diagonal-term and the off-diagonal term.

This is shown in Figure [[fig:reduced_coupling_iff_masses]].

#+begin_src matlab :exports none
%% Estimation of the coupling and comparison between OL and IFF
figure;
tiledlayout(2, 2, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile;
hold on;
i_mass = 0
plot(frf_iff.f, abs(frf_ol.G_dL{i_mass+1}(:,1,2))./abs(frf_ol.G_dL{i_mass+1}(:,1,1)), 'color', [colors(1,:), 0.5], ...
    'DisplayName', 'OL - 0');
plot(frf_iff.f, abs(frf_iff.G_dL{i_mass+1}(:,1,2))./abs(frf_iff.G_dL{i_mass+1}(:,1,1)), 'color', [colors(2,:), 0.5], ...
    'DisplayName', 'IFF - 0');
for i = 1:5
    for j = i+1:6
        plot(frf_iff.f, abs(frf_ol.G_dL{i_mass+1}(:,i,j))./abs(frf_ol.G_dL{i_mass+1}(:,i,i)), 'color', [colors(1,:), 0.5], ...
            'HandleVisibility', 'off');
        plot(frf_iff.f, abs(frf_iff.G_dL{i_mass+1}(:,i,j))./abs(frf_iff.G_dL{i_mass+1}(:,i,i)), 'color', [colors(2,:), 0.5], ...
            'HandleVisibility', 'off');
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
set(gca, 'XTickLabel',[]); ylabel('Amplitude [-]');
legend('location', 'northwest', 'FontSize', 8);

ax2 = nexttile;
hold on;
i_mass = 1
plot(frf_iff.f, abs(frf_ol.G_dL{i_mass+1}(:,1,2))./abs(frf_ol.G_dL{i_mass+1}(:,1,1)), 'color', [colors(1,:), 0.5], ...
    'DisplayName', 'OL - 0');
plot(frf_iff.f, abs(frf_iff.G_dL{i_mass+1}(:,1,2))./abs(frf_iff.G_dL{i_mass+1}(:,1,1)), 'color', [colors(2,:), 0.5], ...
    'DisplayName', 'IFF - 0');
for i = 1:5
    for j = i+1:6
        plot(frf_iff.f, abs(frf_ol.G_dL{i_mass+1}(:,i,j))./abs(frf_ol.G_dL{i_mass+1}(:,i,i)), 'color', [colors(1,:), 0.5], ...
            'HandleVisibility', 'off');
        plot(frf_iff.f, abs(frf_iff.G_dL{i_mass+1}(:,i,j))./abs(frf_iff.G_dL{i_mass+1}(:,i,i)), 'color', [colors(2,:), 0.5], ...
            'HandleVisibility', 'off');
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
set(gca, 'XTickLabel',[]); set(gca, 'YTickLabel',[]);
legend('location', 'northwest', 'FontSize', 8);

ax3 = nexttile;
hold on;
i_mass = 2
plot(frf_iff.f, abs(frf_ol.G_dL{i_mass+1}(:,1,2))./abs(frf_ol.G_dL{i_mass+1}(:,1,1)), 'color', [colors(1,:), 0.5], ...
    'DisplayName', 'OL - 0');
plot(frf_iff.f, abs(frf_iff.G_dL{i_mass+1}(:,1,2))./abs(frf_iff.G_dL{i_mass+1}(:,1,1)), 'color', [colors(2,:), 0.5], ...
    'DisplayName', 'IFF - 0');
for i = 1:5
    for j = i+1:6
        plot(frf_iff.f, abs(frf_ol.G_dL{i_mass+1}(:,i,j))./abs(frf_ol.G_dL{i_mass+1}(:,i,i)), 'color', [colors(1,:), 0.5], ...
            'HandleVisibility', 'off');
        plot(frf_iff.f, abs(frf_iff.G_dL{i_mass+1}(:,i,j))./abs(frf_iff.G_dL{i_mass+1}(:,i,i)), 'color', [colors(2,:), 0.5], ...
            'HandleVisibility', 'off');
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Amplitude [-]');
legend('location', 'northwest', 'FontSize', 8);

ax4 = nexttile;
hold on;
i_mass = 3
plot(frf_iff.f, abs(frf_ol.G_dL{i_mass+1}(:,1,2))./abs(frf_ol.G_dL{i_mass+1}(:,1,1)), 'color', [colors(1,:), 0.5], ...
    'DisplayName', 'OL - 0');
plot(frf_iff.f, abs(frf_iff.G_dL{i_mass+1}(:,1,2))./abs(frf_iff.G_dL{i_mass+1}(:,1,1)), 'color', [colors(2,:), 0.5], ...
    'DisplayName', 'IFF - 0');
for i = 1:5
    for j = i+1:6
        plot(frf_iff.f, abs(frf_ol.G_dL{i_mass+1}(:,i,j))./abs(frf_ol.G_dL{i_mass+1}(:,i,i)), 'color', [colors(1,:), 0.5], ...
            'HandleVisibility', 'off');
        plot(frf_iff.f, abs(frf_iff.G_dL{i_mass+1}(:,i,j))./abs(frf_iff.G_dL{i_mass+1}(:,i,i)), 'color', [colors(2,:), 0.5], ...
            'HandleVisibility', 'off');
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); set(gca, 'YTickLabel',[]);
legend('location', 'northwest', 'FontSize', 8);

linkaxes([ax1,ax2,ax3,ax4],'xy');
ylim([0, 1]); xlim([10, 5e2]);
#+end_src

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

#+name: fig:reduced_coupling_iff_masses
#+caption: Comparison of the coupling with and without IFF
#+RESULTS:
[[file:figs/reduced_coupling_iff_masses.png]]

** Un-Balanced mass
*** Introduction

#+name: fig:picture_unbalanced_payload
#+caption: Nano-Hexapod with unbalanced payload
#+attr_latex: :width \linewidth
[[file:figs/picture_unbalanced_payload.jpg]]

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

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

#+begin_src matlab :tangle no
addpath('./matlab/mat/');
addpath('./matlab/src/');
addpath('./matlab/');
#+end_src

#+begin_src matlab :eval no
addpath('./mat/');
addpath('./src/');
#+end_src

#+begin_src matlab :tangle no
%% Add all useful folders to the path
addpath('matlab/nass-simscape/matlab/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/png/')
addpath('matlab/nass-simscape/src/')
addpath('matlab/nass-simscape/mat/')
addpath('matlab/vibration-table/matlab/')
addpath('matlab/vibration-table/STEPS/')
#+end_src

#+begin_src matlab :eval no
%% Add all useful folders to the path
addpath('nass-simscape/matlab/nano_hexapod/')
addpath('nass-simscape/STEPS/nano_hexapod/')
addpath('nass-simscape/STEPS/png/')
addpath('nass-simscape/src/')
addpath('nass-simscape/mat/')
addpath('vibration-table/matlab/')
addpath('vibration-table/STEPS/')
#+end_src

#+begin_src matlab
i_masses = 0:3;
#+end_src

#+begin_src matlab
%% Open Simulink Model
mdl = 'nano_hexapod_simscape';

options = linearizeOptions;
options.SampleTime = 0;

Rx = zeros(1, 7);

colors = colororder;
#+end_src



*** Compute the identified FRF with IFF
The following data are loaded:
- =Va=: the excitation voltage for the damped plant (corresponding to $u^\prime_i$)
- =de=: the measured motion by the 6 encoders (corresponding to $d\bm{\mathcal{L}}_m$)
#+begin_src matlab
%% Load Identification Data
meas_added_mass = {zeros(6,1)};

for i_strut = 1:6
    meas_iff_mass(i_strut) = {load(sprintf('frf_data_exc_strut_%i_iff_vib_table_1m_unbalanced.mat', i_strut), 't', 'Va', 'de')};
end
#+end_src

The window =win= and the frequency vector =f= are defined.
#+begin_src matlab
% Sampling Time [s]
Ts = (meas_iff_mass{1}.t(end) - (meas_iff_mass{1}.t(1)))/(length(meas_iff_mass{1}.t)-1);

% Hannning Windows
win = hanning(ceil(1/Ts));

% And we get the frequency vector
[~, f] = tfestimate(meas_iff_mass{1}.Va, meas_iff_mass{1}.de, win, [], [], 1/Ts);
#+end_src

Finally the $6 \times 6$ transfer function matrix from $\bm{u}^\prime$ to $d\bm{\mathcal{L}}_m$ is estimated:
#+begin_src matlab
%% DVF Plant (transfer function from u to dLm)
G_dL = zeros(length(f), 6, 6);
for i_strut = 1:6
    G_dL(:,:,i_strut) = tfestimate(meas_iff_mass{i_strut}.Va, meas_iff_mass{i_strut}.de, win, [], [], 1/Ts);
end
#+end_src

The identified dynamics are then saved for further use.
#+begin_src matlab :exports none :tangle no
save('matlab/mat/frf_iff_unbalanced_vib_table_m.mat', 'f', 'Ts', 'G_dL');
#+end_src

#+begin_src matlab :eval no
save('mat/frf_iff_unbalanced_vib_table_m.mat', 'f', 'Ts', 'G_dL');
#+end_src

*** Effect of an unbalanced payload
#+begin_src matlab :exports none
%% Load the Measured FRF of the damped plant
frf_unb_iff = load('frf_iff_unbalanced_vib_table_m.mat', 'f', 'Ts', 'G_dL');
#+end_src

The transfer functions from $u_i$ to $d\mathcal{L}_i$ are shown in Figure [[fig:frf_damp_unbalanced_mass]].
Due to the unbalanced payload, the system is not symmetrical anymore, and therefore each of the diagonal elements are not equal.
This is due to the fact that each strut is not affected by the same inertia.

#+begin_src matlab :exports none
%% Diagonal and Off Diagonal elements of the damped plants
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:6
    plot(frf_unb_iff.f, abs(frf_unb_iff.G_dL(:,i,i)), 'color', colors(i,:), ...
         'DisplayName', sprintf('$d\\mathcal{L}_{m,%i}/u^\\prime_%i$', i, i));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_L/V_a$ [m/V]'); set(gca, 'XTickLabel',[]);
ylim([5e-8, 3e-5]);
legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 2);

ax2 = nexttile;
hold on;
for i =1:6
    plot(frf_unb_iff.f, 180/pi*angle(frf_unb_iff.G_dL(:,i, i)), 'color', colors(i,:));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([10, 1e3]);
#+end_src

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

#+name: fig:frf_damp_unbalanced_mass
#+caption: Transfer function from $u_i$ to $d\mathcal{L}_i$ for the nano-hexapod with an unbalanced payload
#+RESULTS:
[[file:figs/frf_damp_unbalanced_mass.png]]



** Conclusion
#+begin_important
In this section, the dynamics of the nano-hexapod with the encoders fixed to the plates is studied.

It has been found that:
- The measured dynamics is in agreement with the dynamics of the simscape model, up to the flexible modes of the top plate.
  See figures [[fig:enc_plates_iff_comp_simscape]] and [[fig:enc_plates_iff_comp_offdiag_simscape]] for the transfer function to the force sensors and Figures [[fig:enc_plates_dvf_comp_simscape]] and [[fig:enc_plates_dvf_comp_offdiag_simscape]]for the transfer functions to the encoders
- The Integral Force Feedback strategy is very effective in damping the suspension modes of the nano-hexapod (Figure [[fig:enc_plant_plates_effect_iff]]).
- The transfer function from $\bm{u}^\prime$ to $d\bm{\mathcal{L}}_m$ show nice dynamical properties and is a much better candidate for the high-authority-control than when the encoders were fixed to the struts.
  At least up to the flexible modes of the top plate, the diagonal elements of the transfer function matrix have alternating poles and zeros, and the phase is moving smoothly.
  Only the flexible modes of the top plates seems to be problematic for control.
#+end_important

* Noise Budgeting                                                   :noexport:
** Introduction                                                      :ignore:

Noise sources:
- PD200 => plant
- DAC => plant x 20
- Encoder => direct output
- ADC (Force Sensor) => added when closing the loop (controller + plant)

Disturbances Sources:
- Ground motion

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

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

#+begin_src matlab :tangle no
addpath('./matlab/mat/');
addpath('./matlab/src/');
addpath('./matlab/');
#+end_src

#+begin_src matlab :eval no
addpath('./mat/');
addpath('./src/');
#+end_src

#+begin_src matlab
i_masses = 0:3;
#+end_src

#+begin_src matlab
colors = colororder;
#+end_src

** Measurements
#+begin_src matlab
noise_enc = load('noise_meas_100s_20kHz.mat', 't', 'x');
noise_enc.Ts = (noise_enc.t(end) - (noise_enc.t(1)))/(length(noise_enc.t)-1);
noise_enc.win = hanning(ceil(1/noise_enc.Ts));
noise_enc.x = noise_enc.x - noise_enc.x(1);
[noise_enc.pxx, noise_enc.f] = pwelch(noise_enc.x, noise_enc.win, [], [], 1/noise_enc.Ts);
#+end_src

#+begin_src matlab :exports none
noise_ol  = load('noise_meas_2m_ol.mat', 't', 'Vs', 'de');
noise_ol.Ts = (noise_ol.t(end) - (noise_ol.t(1)))/(length(noise_ol.t)-1);
noise_ol.win = hanning(ceil(1/noise_ol.Ts));
[noise_ol.pxx, noise_ol.f] = pwelch(noise_ol.de(:,1), noise_ol.win, [], [], 1/noise_ol.Ts);
#+end_src

#+begin_src matlab :exports none
noise_iff  = load('noise_meas_2m_iff.mat', 't', 'de');
noise_iff.Ts = (noise_iff.t(end) - (noise_iff.t(1)))/(length(noise_iff.t)-1);
noise_iff.win = hanning(ceil(1/noise_iff.Ts));
[noise_iff.pxx, noise_iff.f] = pwelch(noise_iff.de(:,1), noise_iff.win, [], [], 1/noise_iff.Ts);
#+end_src

#+begin_src matlab :exports none
figure;
hold on;
plot(noise_ol.f, sqrt(noise_ol.pxx), 'DisplayName', 'OL');
plot(noise_iff.f, sqrt(noise_iff.pxx), 'DisplayName', 'IFF');
plot(noise_enc.f, sqrt(noise_enc.pxx), 'DisplayName', 'Encoder');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('ASD [$m/\sqrt{Hz}$]');
legend('location', 'northeast');
xlim([1, Fs/2]); ylim([1e-11, 1e-7]);
#+end_src


* Decentralized High Authority Control with Integral Force Feedback
<<sec:decentralized_hac_iff>>

** Introduction                                                      :ignore:

In this section is studied the HAC-IFF architecture for the Nano-Hexapod.
More precisely:
- The LAC control is a decentralized integral force feedback as studied in Section [[sec:enc_plates_iff]]
- The HAC control is a decentralized controller working in the frame of the struts

The corresponding control architecture is shown in Figure [[fig:control_architecture_hac_iff_struts]] with:
- $\bm{r}_{\mathcal{X}_n}$: the $6 \times 1$ reference signal in the cartesian frame
- $\bm{r}_{d\mathcal{L}}$: the $6 \times 1$ reference signal transformed in the frame of the struts thanks to the inverse kinematic
- $\bm{\epsilon}_{d\mathcal{L}}$: the $6 \times 1$ length error of the 6 struts
- $\bm{u}^\prime$: input of the damped plant
- $\bm{u}$: generated DAC voltages
- $\bm{\tau}_m$: measured force sensors
- $d\bm{\mathcal{L}}_m$: measured displacement of the struts by the encoders

#+begin_src latex :file control_architecture_hac_iff_struts.pdf
\definecolor{instrumentation}{rgb}{0, 0.447, 0.741}
\definecolor{mechanics}{rgb}{0.8500, 0.325, 0.098}
\definecolor{control}{rgb}{0.4660, 0.6740, 0.1880}

\begin{tikzpicture}
  % Blocs
  \node[block={3.0cm}{2.0cm}, fill=black!20!white] (P) {Plant};
  \coordinate[] (inputF) at ($(P.south west)!0.5!(P.north west)$);
  \coordinate[] (outputF) at ($(P.south east)!0.2!(P.north east)$);
  \coordinate[] (outputL) at ($(P.south east)!0.8!(P.north east)$);

  \node[block, below=0.4 of P, fill=control!20!white] (Kiff) {$\bm{K}_\text{IFF}$};
  \node[block, left=0.8 of inputF, fill=instrumentation!20!white] (pd200) {\tiny PD200};
  \node[addb,  left=0.8 of pd200, fill=control!20!white] (addF) {};
  \node[block, left=0.8 of addF, fill=control!20!white] (K) {$\bm{K}_\mathcal{L}$};
  \node[addb={+}{}{-}{}{}, left=0.8 of K, fill=control!20!white] (subr) {};
  \node[block, align=center, left= of subr, fill=control!20!white] (J) {\tiny Inverse\\\tiny Kinematics};

  % Connections and labels
  \draw[->] (outputF) -- ++(1.0, 0) node[above left]{$\bm{\tau}_m$};
  \draw[->] ($(outputF) + (0.6, 0)$)node[branch]{} |- (Kiff.east);
  \draw[->] (Kiff.west) -| (addF.south);
  \draw[->] (addF.east) -- (pd200.west) node[above left]{$\bm{u}$};
  \draw[->] (pd200.east) -- (inputF) node[above left]{$\bm{u}_a$};

  \draw[->] (outputL) -- ++(1.0, 0) node[below left]{$d\bm{\mathcal{L}_m}$};
  \draw[->] ($(outputL) + (0.6, 0)$)node[branch]{} -- ++(0, 1) -| (subr.north);
  \draw[->] (subr.east) -- (K.west) node[above left]{$\bm{\epsilon}_{d\mathcal{L}}$};
  \draw[->] (K.east) -- (addF.west) node[above left]{$\bm{u}^\prime$};

  \draw[->] (J.east) -- (subr.west) node[above left]{$\bm{r}_{d\mathcal{L}}$};
  \draw[<-] (J.west)node[above left]{$\bm{r}_{\mathcal{X}_n}$} -- ++(-1, 0);
\end{tikzpicture}
#+end_src

#+name: fig:control_architecture_hac_iff_struts
#+caption: HAC-LAC: IFF + Control in the frame of the legs
#+RESULTS:
[[file:figs/control_architecture_hac_iff_struts.png]]

This part is structured as follow:
- Section [[sec:hac_iff_struts_ref_track]]: some reference tracking tests are performed
- Section [[sec:hac_iff_struts_controller]]: the decentralized high authority controller is tuned using the Simscape model and is implemented and tested experimentally
- Section [[sec:interaction_analysis]]: an interaction analysis is performed, from which the best decoupling strategy can be determined
- Section [[sec:robust_hac_design]]: Robust High Authority Controller are designed

** Reference Tracking - Trajectories
<<sec:hac_iff_struts_ref_track>>
*** Introduction                                                    :ignore:
In this section, several trajectories representing the wanted pose (position and orientation) of the top platform with respect to the bottom platform are defined.

These trajectories will be used to test the HAC-LAC architecture.

In order to transform the wanted pose to the wanted displacement of the 6 struts, the inverse kinematic is required.
As a first approximation, the Jacobian matrix $\bm{J}$ can be used instead of using the full inverse kinematic equations.

Therefore, the control architecture with the input trajectory $\bm{r}_{\mathcal{X}_n}$ is shown in Figure [[fig:control_architecture_hac_iff_L]].

#+begin_src latex :file control_architecture_hac_iff_struts_L.pdf
\definecolor{instrumentation}{rgb}{0, 0.447, 0.741}
\definecolor{mechanics}{rgb}{0.8500, 0.325, 0.098}
\definecolor{control}{rgb}{0.4660, 0.6740, 0.1880}

\begin{tikzpicture}
  % Blocs
  \node[block={3.0cm}{2.0cm}, fill=black!20!white] (P) {Plant};
  \coordinate[] (inputF) at ($(P.south west)!0.5!(P.north west)$);
  \coordinate[] (outputF) at ($(P.south east)!0.2!(P.north east)$);
  \coordinate[] (outputL) at ($(P.south east)!0.8!(P.north east)$);

  \node[block, below=0.4 of P, fill=control!20!white] (Kiff) {$\bm{K}_\text{IFF}$};
  \node[block, left=0.8 of inputF, fill=instrumentation!20!white] (pd200) {\tiny PD200};
  \node[addb,  left=0.8 of pd200, fill=control!20!white] (addF) {};
  \node[block, left=0.8 of addF, fill=control!20!white] (K) {$\bm{K}_\mathcal{L}$};
  \node[addb={+}{}{-}{}{}, left=0.8 of K, fill=control!20!white] (subr) {};
  \node[block, align=center, left= of subr, fill=control!20!white] (J) {$\bm{J}$};

  % Connections and labels
  \draw[->] (outputF) -- ++(1.0, 0) node[above left]{$\bm{\tau}_m$};
  \draw[->] ($(outputF) + (0.6, 0)$)node[branch]{} |- (Kiff.east);
  \draw[->] (Kiff.west) -| (addF.south);
  \draw[->] (addF.east) -- (pd200.west) node[above left]{$\bm{u}$};
  \draw[->] (pd200.east) -- (inputF) node[above left]{$\bm{u}_a$};

  \draw[->] (outputL) -- ++(1.0, 0) node[below left]{$d\bm{\mathcal{L}_m}$};
  \draw[->] ($(outputL) + (0.6, 0)$)node[branch]{} -- ++(0, 1) -| (subr.north);
  \draw[->] (subr.east) -- (K.west) node[above left]{$\bm{\epsilon}_{d\mathcal{L}}$};
  \draw[->] (K.east) -- (addF.west) node[above left]{$\bm{u}^\prime$};

  \draw[->] (J.east) -- (subr.west) node[above left]{$\bm{r}_{d\mathcal{L}}$};
  \draw[<-] (J.west)node[above left]{$\bm{r}_{\mathcal{X}_n}$} -- ++(-1, 0);
\end{tikzpicture}
#+end_src

#+name: fig:control_architecture_hac_iff_L
#+caption: HAC-LAC: IFF + Control in the frame of the legs
#+RESULTS:
[[file:figs/control_architecture_hac_iff_struts_L.png]]

In the following sections, several reference trajectories are defined:
- Section [[sec:yz_scans]]: simple scans in the Y-Z plane
- Section [[sec:tilt_scans]]: scans in tilt are performed
- Section [[sec:nass_scans]]: scans with X-Y-Z translations in order to draw the word "NASS"

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

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

#+begin_src matlab :tangle no
addpath('./matlab/mat/');
addpath('./matlab/src/');
addpath('./matlab/');
#+end_src

#+begin_src matlab :eval no
addpath('./mat/');
addpath('./src/');
#+end_src

*** Y-Z Scans
<<sec:yz_scans>>
A function =generateYZScanTrajectory= has been developed (accessible [[sec:generateYZScanTrajectory][here]]) in order to easily generate scans in the Y-Z plane.

For instance, the following generated trajectory is represented in Figure [[fig:yz_scan_example_trajectory_yz_plane]].
#+begin_src matlab
%% Generate the Y-Z trajectory scan
Rx_yz = generateYZScanTrajectory(...
    'y_tot', 4e-6, ... % Length of Y scans [m]
    'z_tot', 4e-6, ... % Total Z distance [m]
    'n', 5, ...     % Number of Y scans
    'Ts', 1e-3, ... % Sampling Time [s]
    'ti', 1, ...    % Time to go to initial position [s]
    'tw', 0, ...    % Waiting time between each points [s]
    'ty', 0.6, ...  % Time for a scan in Y [s]
    'tz', 0.2);     % Time for a scan in Z [s]
#+end_src

#+begin_src matlab :exports none
%% Plot the trajectory in the Y-Z plane
figure;
plot(Rx_yz(:,3), Rx_yz(:,4));
xlabel('y [m]'); ylabel('z [m]');
#+end_src

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

#+name: fig:yz_scan_example_trajectory_yz_plane
#+caption: Generated scan in the Y-Z plane
#+RESULTS:
[[file:figs/yz_scan_example_trajectory_yz_plane.png]]

The Y and Z positions as a function of time are shown in Figure [[fig:yz_scan_example_trajectory]].

#+begin_src matlab :exports none
%% Plot the Y-Z trajectory as a function of time
figure;
hold on;
plot(Rx_yz(:,1), Rx_yz(:,3), ...
     'DisplayName', 'Y motion')
plot(Rx_yz(:,1), Rx_yz(:,4), ...
     'DisplayName', 'Z motion')
hold off;
xlabel('Time [s]');
ylabel('Displacement [m]');
legend('location', 'northeast');
#+end_src

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

#+name: fig:yz_scan_example_trajectory
#+caption: Y and Z trajectories as a function of time
#+RESULTS:
[[file:figs/yz_scan_example_trajectory.png]]

Using the Jacobian matrix, it is possible to compute the wanted struts lengths as a function of time:
\begin{equation}
  \bm{r}_{d\mathcal{L}} = \bm{J} \bm{r}_{\mathcal{X}_n}
\end{equation}

#+begin_src matlab :exports none
load('jacobian.mat', 'J');
#+end_src

#+begin_src matlab
%% Compute the reference in the frame of the legs
dL_ref = [J*Rx_yz(:, 2:7)']';
#+end_src

The reference signal for the strut length is shown in Figure [[fig:yz_scan_example_trajectory_struts]].
#+begin_src matlab :exports none
%% Plot the reference in the frame of the legs
figure;
hold on;
for i=1:6
    plot(Rx_yz(:,1), dL_ref(:, i), ...
         'DisplayName', sprintf('$r_{d\\mathcal{L}_%i}$', i))
end
xlabel('Time [s]'); ylabel('Strut Motion [m]');
legend('location', 'northeast', 'FontSize', 8, 'NumColumns', 2);
yticks(1e-6*[-5:5]);
#+end_src

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

#+name: fig:yz_scan_example_trajectory_struts
#+caption: Trajectories for the 6 individual struts
#+RESULTS:
[[file:figs/yz_scan_example_trajectory_struts.png]]

*** Tilt Scans
<<sec:tilt_scans>>

A function =generalSpiralAngleTrajectory= has been developed in order to easily generate $R_x,R_y$ tilt scans.

For instance, the following generated trajectory is represented in Figure [[fig:tilt_scan_example_trajectory]].
#+begin_src matlab
%% Generate the "tilt-spiral" trajectory scan
R_tilt = generateSpiralAngleTrajectory(...
    'R_tot',  20e-6, ... % Total Tilt [ad]
    'n_turn', 5, ...     % Number of scans
    'Ts',     1e-3, ...  % Sampling Time [s]
    't_turn', 1, ...     % Turn time [s]
    't_end',  1);        % End time to go back to zero [s]
#+end_src

#+begin_src matlab :exports none
%% Plot the trajectory
figure;
plot(1e6*R_tilt(:,5), 1e6*R_tilt(:,6));
xlabel('$R_x$ [$\mu$rad]'); ylabel('$R_y$ [$\mu$rad]');
#+end_src

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

#+name: fig:tilt_scan_example_trajectory
#+caption: Generated "spiral" scan
#+RESULTS:
[[file:figs/tilt_scan_example_trajectory.png]]

#+begin_src matlab :exports none
%% Compute the reference in the frame of the legs
load('jacobian.mat', 'J');
dL_ref = [J*R_tilt(:, 2:7)']';
#+end_src

The reference signal for the strut length is shown in Figure [[fig:tilt_scan_example_trajectory_struts]].
#+begin_src matlab :exports none
%% Plot the reference in the frame of the legs
figure;
hold on;
for i=1:6
    plot(R_tilt(:,1), dL_ref(:, i), ...
         'DisplayName', sprintf('$r_{d\\mathcal{L}_%i}$', i))
end
xlabel('Time [s]'); ylabel('Strut Motion [m]');
legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 2);
yticks(1e-6*[-5:5]);
#+end_src

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

#+name: fig:tilt_scan_example_trajectory_struts
#+caption: Trajectories for the 6 individual struts - Tilt scan
#+RESULTS:
[[file:figs/tilt_scan_example_trajectory_struts.png]]

*** "NASS" reference path
<<sec:nass_scans>>
In this section, a reference path that "draws" the work "NASS" is developed.

First, a series of points representing each letter are defined.
Between each letter, a negative Z motion is performed.
#+begin_src matlab
%% List of points that draws "NASS"
ref_path = [ ...
    0, 0,0; % Initial Position
    0,0,1; 0,4,1; 3,0,1; 3,4,1; % N
    3,4,0; 4,0,0; % Transition
    4,0,1; 4,3,1; 5,4,1; 6,4,1; 7,3,1; 7,2,1; 4,2,1; 4,3,1; 5,4,1; 6,4,1; 7,3,1; 7,0,1; % A
    7,0,0; 8,0,0; % Transition
    8,0,1; 11,0,1; 11,2,1; 8,2,1; 8,4,1; 11,4,1; % S
    11,4,0; 12,0,0; % Transition
    12,0,1; 15,0,1; 15,2,1; 12,2,1; 12,4,1; 15,4,1; % S
    15,4,0;
           ];

%% Center the trajectory arround zero
ref_path = ref_path - (max(ref_path) - min(ref_path))/2;

%% Define the X-Y-Z cuboid dimensions containing the trajectory
X_max = 10e-6;
Y_max =  4e-6;
Z_max =  2e-6;

ref_path = ([X_max, Y_max, Z_max]./max(ref_path)).*ref_path; % [m]
#+end_src

Then, using the =generateXYZTrajectory= function, the $6 \times 1$ trajectory signal is computed.
#+begin_src matlab
%% Generating the trajectory
Rx_nass = generateXYZTrajectory('points', ref_path);
#+end_src

The trajectory in the X-Y plane is shown in Figure [[fig:ref_track_test_nass]] (the transitions between the letters are removed).
#+begin_src matlab :exports none
%% "NASS" trajectory in the X-Y plane
figure;
plot(1e6*Rx_nass(Rx_nass(:,4)>0, 2), 1e6*Rx_nass(Rx_nass(:,4)>0, 3), 'k.')
xlabel('X [$\mu m$]');
ylabel('Y [$\mu m$]');
axis equal;
xlim(1e6*[min(Rx_nass(:,2)), max(Rx_nass(:,2))]);
ylim(1e6*[min(Rx_nass(:,3)), max(Rx_nass(:,3))]);
#+end_src

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

#+name: fig:ref_track_test_nass
#+caption: Reference path corresponding to the "NASS" acronym
#+RESULTS:
[[file:figs/ref_track_test_nass.png]]

It can also be better viewed in a 3D representation as in Figure [[fig:ref_track_test_nass_3d]].

#+begin_src matlab :exports none
figure;
plot3(1e6*Rx_nass(:,2), 1e6*Rx_nass(:,3), 1e6*Rx_nass(:,4), 'k-');
xlabel('x [$\mu m$]'); ylabel('y [$\mu m$]'); zlabel('z [$\mu m$]');
view(-13, 41)
#+end_src

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

#+name: fig:ref_track_test_nass_3d
#+caption: Reference path that draws "NASS" - 3D view
#+RESULTS:
[[file:figs/ref_track_test_nass_3d.png]]

** First Basic High Authority Controller
<<sec:hac_iff_struts_controller>>
*** Introduction                                                    :ignore:
In this section, a simple decentralized high authority controller $\bm{K}_{\mathcal{L}}$ is developed to work without any payload.

The diagonal controller is tuned using classical Loop Shaping in Section [[sec:hac_iff_no_payload_tuning]].
The stability is verified in Section [[sec:hac_iff_no_payload_stability]] using the Simscape model.

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

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

#+begin_src matlab :tangle no
addpath('./matlab/mat/');
addpath('./matlab/src/');
addpath('./matlab/');
#+end_src

#+begin_src matlab :eval no
%% Add useful folders to the path
addpath('./mat/');
addpath('./src/');
#+end_src

#+begin_src matlab :tangle no
addpath('matlab/nass-simscape/matlab/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/png/')
addpath('matlab/nass-simscape/src/')
addpath('matlab/nass-simscape/mat/')
addpath('matlab/vibration-table/matlab/')
addpath('matlab/vibration-table/STEPS/')
#+end_src

#+begin_src matlab :eval no
%% Add other useful folders to the path related to the Simscape model
addpath('nass-simscape/matlab/nano_hexapod/')
addpath('nass-simscape/STEPS/nano_hexapod/')
addpath('nass-simscape/STEPS/png/')
addpath('nass-simscape/src/')
addpath('nass-simscape/mat/')
addpath('vibration-table/matlab/')
addpath('vibration-table/STEPS/')
#+end_src

#+begin_src matlab
%% Load the identified FRF and Simscape model
frf_iff = load('frf_iff_vib_table_m.mat', 'f', 'Ts', 'G_dL');
sim_iff = load('sim_iff_vib_table_m.mat', 'G_dL');
#+end_src

#+begin_src matlab
%% Open Simulink Model
mdl = 'nano_hexapod_simscape';

options = linearizeOptions;
options.SampleTime = 0;

open(mdl)

%% Initialize the Rerference path to zero
Rx = zeros(1, 7);

%% Colors for the figures
colors = colororder;
#+end_src

*** HAC Controller
<<sec:hac_iff_no_payload_tuning>>

Let's first try to design a first decentralized controller with:
- a bandwidth of 100Hz
- sufficient phase margin
- simple and understandable components

After some very basic and manual loop shaping, A diagonal controller is developed.
Each diagonal terms are identical and are composed of:
- A lead around 100Hz
- A first order low pass filter starting at 200Hz to add some robustness to high frequency modes
- A notch at 700Hz to cancel the flexible modes of the top plate
- A pure integrator

#+begin_src matlab
%% Lead to increase phase margin
a  = 2;  % Amount of phase lead / width of the phase lead / high frequency gain
wc = 2*pi*100; % Frequency with the maximum phase lead [rad/s]

H_lead = (1 + s/(wc/sqrt(a)))/(1 + s/(wc*sqrt(a)));

%% Low Pass filter to increase robustness
H_lpf = 1/(1 + s/2/pi/200);

%% Notch at the top-plate resonance
gm = 0.02;
xi = 0.3;
wn = 2*pi*700;

H_notch = (s^2 + 2*gm*xi*wn*s + wn^2)/(s^2 + 2*xi*wn*s + wn^2);

%% Decentralized HAC
Khac_iff_struts = -(1/(2.87e-5)) * ... % Gain
                  H_lead * ...       % Lead
                  H_notch * ...      % Notch
                  (2*pi*100/s) * ... % Integrator
                  eye(6);            % 6x6 Diagonal
#+end_src

This controller is saved for further use.
#+begin_src matlab :exports none :tangle no
save('matlab/mat/Khac_iff_struts.mat', 'Khac_iff_struts')
#+end_src

#+begin_src matlab :eval no
save('mat/Khac_iff_struts.mat', 'Khac_iff_struts')
#+end_src

The experimental loop gain is computed  and shown in Figure [[fig:loop_gain_hac_iff_struts]].
#+begin_src matlab
L_hac_iff_struts = pagemtimes(permute(frf_iff.G_dL{1}, [2 3 1]), squeeze(freqresp(Khac_iff_struts, frf_iff.f, 'Hz')));
#+end_src

#+begin_src matlab :exports none
%% Bode plot of the Loop Gain
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');


ax1 = nexttile([2,1]);
hold on;
% Diagonal Elements Model
plot(frf_iff.f, abs(squeeze(L_hac_iff_struts(1,1,:))), 'color', colors(1,:), ...
     'DisplayName', 'Diagonal');
for i = 2:6
    plot(frf_iff.f, abs(squeeze(L_hac_iff_struts(i,i,:))), 'color', colors(1,:), ...
         'HandleVisibility', 'off');
end
plot(frf_iff.f, abs(squeeze(L_hac_iff_struts(1,2,:))), 'color', [colors(2,:), 0.2], ...
     'DisplayName', 'Off-Diag');
for i = 1:5
    for j = i+1:6
        plot(frf_iff.f, abs(squeeze(L_hac_iff_struts(i,j,:))), 'color', [colors(2,:), 0.2], ...
             'HandleVisibility', 'off');
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Loop Gain [-]'); set(gca, 'XTickLabel',[]);
ylim([1e-3, 1e2]);
legend('location', 'northeast');

ax2 = nexttile;
hold on;
for i =1:6
    plot(frf_iff.f, 180/pi*angle(squeeze(L_hac_iff_struts(i,i,:))), 'color', colors(1,:));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([2, 2e3]);
#+end_src

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

#+name: fig:loop_gain_hac_iff_struts
#+caption: Diagonal and off-diagonal elements of the Loop gain for "HAC-IFF-Struts"
#+RESULTS:
[[file:figs/loop_gain_hac_iff_struts.png]]

*** Verification of the Stability using the Simscape model
<<sec:hac_iff_no_payload_stability>>

The HAC-IFF control strategy is implemented using Simscape.
#+begin_src matlab
%% Initialize the Simscape model in closed loop
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '4dof', ...
                                       'flex_top_type', '4dof', ...
                                       'motion_sensor_type', 'plates', ...
                                       'actuator_type', 'flexible', ...
                                       'controller_type', 'hac-iff-struts');
#+end_src

#+begin_src matlab :exports none
support.type = 1; % On top of vibration table
payload.type = 3; % Payload / 1 "mass layer"

load('Kiff_opt.mat', 'Kiff');
#+end_src

#+begin_src matlab
%% Identify the (damped) transfer function from u to dLm
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'], 1, 'openinput');  io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/dL'], 1, 'openoutput'); io_i = io_i + 1; % Plate Displacement (encoder)
#+end_src

We identify the closed-loop system.
#+begin_src matlab
%% Identification
Gd_iff_hac_opt = linearize(mdl, io, 0.0, options);
#+end_src

And verify that it is indeed stable.
#+begin_src matlab :results value replace :exports both
%% Verify the stability
isstable(Gd_iff_hac_opt)
#+end_src

#+RESULTS:
: 1

*** Experimental Validation
Both the Integral Force Feedback controller (developed in Section [[sec:enc_plates_iff]]) and the high authority controller working in the frame of the struts (developed in Section [[sec:hac_iff_struts_controller]]) are implemented experimentally.

Two reference tracking experiments are performed to evaluate the stability and performances of the implemented control.

#+begin_src matlab
%% Load the experimental data
load('hac_iff_struts_yz_scans.mat', 't', 'de')
#+end_src

#+begin_src matlab :exports none
%% Reset initial time
t = t - t(1);
#+end_src

The position of the top-platform is estimated using the Jacobian matrix:
#+begin_src matlab
%% Pose of the top platform from the encoder values
load('jacobian.mat', 'J');
Xe = [inv(J)*de']';
#+end_src

#+begin_src matlab
%% Generate the Y-Z trajectory scan
Rx_yz = generateYZScanTrajectory(...
    'y_tot', 4e-6, ... % Length of Y scans [m]
    'z_tot', 8e-6, ... % Total Z distance [m]
    'n', 5, ...     % Number of Y scans
    'Ts', 1e-3, ... % Sampling Time [s]
    'ti', 1, ...    % Time to go to initial position [s]
    'tw', 0, ...    % Waiting time between each points [s]
    'ty', 0.6, ...  % Time for a scan in Y [s]
    'tz', 0.2);     % Time for a scan in Z [s]
#+end_src

The reference path as well as the measured position are partially shown in the Y-Z plane in Figure [[fig:yz_scans_exp_results_first_K]].
#+begin_src matlab :exports none
%% Position and reference signal in the Y-Z plane
figure;
tiledlayout(1, 3, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile;
hold on;
plot(1e6*Xe(t>2,2),    1e6*Xe(t>2,3));
plot(1e6*Rx_yz(:,3), 1e6*Rx_yz(:,4), '--');
hold off;
xlabel('Y [$\mu m$]'); ylabel('Z [$\mu m$]');
xlim([-2.05, 2.05]); ylim([-4.1, 4.1]);
axis equal;

ax2 = nexttile([1,2]);
hold on;
plot(1e6*Xe(:,2),    1e6*Xe(:,3), ...
     'DisplayName', '$\mathcal{X}_n$');
plot(1e6*Rx_yz(:,3), 1e6*Rx_yz(:,4), '--', ...
     'DisplayName', '$r_{\mathcal{X}_n}$');
hold off;
legend('location', 'northwest');
xlabel('Y [$\mu m$]'); ylabel('Z [$\mu m$]');
axis equal;
xlim([1.6, 2.1]); ylim([-4.1, -3.6]);
#+end_src

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

#+name: fig:yz_scans_exp_results_first_K
#+caption: Measured position $\bm{\mathcal{X}}_n$ and reference signal $\bm{r}_{\mathcal{X}_n}$ in the Y-Z plane - Zoom on a change of direction
#+RESULTS:
[[file:figs/yz_scans_exp_results_first_K.png]]

#+begin_important
It is clear from Figure [[fig:yz_scans_exp_results_first_K]] that the position of the nano-hexapod effectively tracks to reference signal.
However, oscillations with amplitudes as large as 50nm can be observe.

It turns out that the frequency of these oscillations is 100Hz which is corresponding to the crossover frequency of the High Authority Control loop.
This clearly indicates poor stability margins.
In the next section, the controller is re-designed to improve the stability margins.
#+end_important

*** Controller with increased stability margins
The High Authority Controller is re-designed in order to improve the stability margins.
#+begin_src matlab
%% Lead
a  = 5;  % Amount of phase lead / width of the phase lead / high frequency gain
wc = 2*pi*110; % Frequency with the maximum phase lead [rad/s]

H_lead = (1 + s/(wc/sqrt(a)))/(1 + s/(wc*sqrt(a)));

%% Low Pass Filter
H_lpf = 1/(1 + s/2/pi/300);

%% Notch
gm = 0.02;
xi = 0.5;
wn = 2*pi*700;

H_notch = (s^2 + 2*gm*xi*wn*s + wn^2)/(s^2 + 2*xi*wn*s + wn^2);

%% HAC Controller
Khac_iff_struts = -2.2e4 * ... % Gain
            H_lead * ...       % Lead
            H_lpf * ...        % Lead
            H_notch * ...      % Notch
            (2*pi*100/s) * ... % Integrator
            eye(6);            % 6x6 Diagonal
#+end_src

#+begin_src matlab :exports none
%% Load the FRF of the transfer function from u to dL with IFF
frf_iff = load('frf_iff_vib_table_m.mat', 'f', 'Ts', 'G_dL');
#+end_src

#+begin_src matlab :exports none
%% Compute the Loop Gain
L_frf = pagemtimes(permute(frf_iff.G_dL{1}, [2 3 1]), squeeze(freqresp(Khac_iff_struts, frf_iff.f, 'Hz')));
#+end_src

The bode plot of the new loop gain is shown in Figure [[fig:hac_iff_plates_exp_loop_gain_redesigned_K]].
#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
freqs = 2*logspace(1, 3, 1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
% Diagonal Elements FRF
plot(frf_iff.f, abs(squeeze(L_frf(1,1,:))), 'color', colors(1,:), ...
     'DisplayName', 'Diagonal');
for i = 2:6
    plot(frf_iff.f, abs(squeeze(L_frf(i,i,:))), 'color', colors(1,:), ...
         'HandleVisibility', 'off');
end
plot(frf_iff.f, abs(squeeze(L_frf(1,2,:))), 'color', [colors(2,:), 0.2], ...
     'DisplayName', 'Off-Diag');
for i = 1:5
    for j = i+1:6
        plot(frf_iff.f, abs(squeeze(L_frf(i,j,:))), 'color', [colors(2,:), 0.2], ...
             'HandleVisibility', 'off');
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Loop Gain [-]'); set(gca, 'XTickLabel',[]);
ylim([1e-3, 1e2]);
legend('location', 'northeast');

ax2 = nexttile;
hold on;
for i =1:6
    plot(frf_iff.f, 180/pi*angle(squeeze(L_frf(i,i,:))), 'color', colors(1,:));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([1, 2e3]);
#+end_src

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

#+name: fig:hac_iff_plates_exp_loop_gain_redesigned_K
#+caption: Loop Gain for the updated decentralized HAC controller
#+RESULTS:
[[file:figs/hac_iff_plates_exp_loop_gain_redesigned_K.png]]

This new controller is implemented experimentally and several tracking tests are performed.
#+begin_src matlab
%% Load Measurements
load('hac_iff_more_lead_nass_scan.mat', 't', 'de')
#+end_src

#+begin_src matlab :exports none
%% Reset Time
t = t - t(1);
#+end_src

The pose of the top platform is estimated from the encoder position using the Jacobian matrix.
#+begin_src matlab
%% Compute the pose of the top platform
load('jacobian.mat', 'J');
Xe = [inv(J)*de']';
#+end_src

#+begin_src matlab :exports none
%% Load the reference path
load('reference_path.mat', 'Rx_nass')
#+end_src

The measured motion as well as the trajectory are shown in Figure [[fig:nass_scans_first_test_exp]].
#+begin_src matlab :exports none
%% Plot the X-Y-Z "NASS" trajectory
figure;
hold on;
plot3(Xe(1:100:end,1), Xe(1:100:end,2), Xe(1:100:end,3))
plot3(Rx_nass(1:100:end,2), Rx_nass(1:100:end,3), Rx_nass(1:100:end,4))
hold off;
xlabel('x [$\mu m$]'); ylabel('y [$\mu m$]'); zlabel('z [$\mu m$]');
view(-13, 41)
#+end_src

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

#+name: fig:nass_scans_first_test_exp
#+caption: Measured position $\bm{\mathcal{X}}_n$ and reference signal $\bm{r}_{\mathcal{X}_n}$ for the "NASS" trajectory
#+RESULTS:
[[file:figs/nass_scans_first_test_exp.png]]

The trajectory and measured motion are also shown in the X-Y plane in Figure [[fig:ref_track_nass_exp_hac_iff_struts]].
#+begin_src matlab :exports none
%% Estimate when the hexpod is on top position and drawing the letters
i_top = Xe(:,3) > 1.9e-6;
i_rx = Rx_nass(:,4) > 0;
#+end_src

#+begin_src matlab :exports none
%% Plot the reference as well as the measurement in the X-Y plane
figure;
tiledlayout(1, 3, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([1,2]);
hold on;
scatter(1e6*Xe(i_top,1),  1e6*Xe(i_top,2),'.');
plot(1e6*Rx_nass(i_rx,2), 1e6*Rx_nass(i_rx,3), '--');
hold off;
xlabel('X [$\mu m$]'); ylabel('Y [$\mu m$]');
axis equal;
xlim([-10.5, 10.5]); ylim([-4.5, 4.5]);

ax2 = nexttile;
hold on;
scatter(1e6*Xe(i_top,1),  1e6*Xe(i_top,2),'.');
plot(1e6*Rx_nass(i_rx,2), 1e6*Rx_nass(i_rx,3), '--');
hold off;
xlabel('X [$\mu m$]'); ylabel('Y [$\mu m$]');
axis equal;
xlim([4.5, 4.7]); ylim([-0.15, 0.05]);
#+end_src

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

#+name: fig:ref_track_nass_exp_hac_iff_struts
#+caption: Reference path and measured motion in the X-Y plane
#+RESULTS:
[[file:figs/ref_track_nass_exp_hac_iff_struts.png]]

The orientation errors during all the scans are shown in Figure [[fig:nass_ref_rx_ry]].
#+begin_src matlab :exports none
%% Orientation Errors
figure;
hold on;
plot(t(t>20&t<20.1), 1e6*Xe(t>20&t<20.1,4), '-', 'DisplayName', '$\epsilon_{\theta_x}$');
plot(t(t>20&t<20.1), 1e6*Xe(t>20&t<20.1,5), '-', 'DisplayName', '$\epsilon_{\theta_y}$');
plot(t(t>20&t<20.1), 1e6*Xe(t>20&t<20.1,6), '-', 'DisplayName', '$\epsilon_{\theta_z}$');
hold off;
xlabel('Time [s]'); ylabel('Orientation Error [$\mu$ rad]');
legend('location', 'northeast');
#+end_src

#+begin_src matlab :exports none
%% Orientation Errors
figure;
hold on;
plot(1e9*Xe(100000:100:end,4), 1e9*Xe(100000:100:end,5), '.');
th = 0:pi/50:2*pi;
xunit = 90 * cos(th);
yunit = 90 * sin(th);
plot(xunit, yunit, '--');
hold off;
xlabel('$R_x$ [nrad]'); ylabel('$R_y$ [nrad]');
xlim([-100, 100]);
ylim([-100, 100]);
#+end_src

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

#+name: fig:nass_ref_rx_ry
#+caption: Orientation errors during the scan
#+RESULTS:
[[file:figs/nass_ref_rx_ry.png]]

#+begin_important
Using the updated High Authority Controller, the nano-hexapod can follow trajectories with high accuracy (the position errors are in the order of 50nm peak to peak, and the orientation errors 300nrad peak to peak).
#+end_important

** Interaction Analysis and Decoupling
<<sec:interaction_analysis>>
*** Introduction                                                    :ignore:

In this section, the interaction in the identified plant is estimated using the Relative Gain Array (RGA) [[cite:skogestad07_multiv_feedb_contr][Chap. 3.4]].

Then, several decoupling strategies are compared for the nano-hexapod.

The RGA Matrix is defined as follow:
\begin{equation}
  \text{RGA}(G(f)) = G(f) \times (G(f)^{-1})^T
\end{equation}

Then, the RGA number is defined:
\begin{equation}
\text{RGA-num}(f) = \| \text{I - RGA(G(f))} \|_{\text{sum}}
\end{equation}


In this section, the plant with 2 added mass is studied.

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

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

#+begin_src matlab :tangle no
addpath('./matlab/mat/');
addpath('./matlab/src/');
addpath('./matlab/');
#+end_src

#+begin_src matlab :eval no
%% Add useful folders to the path
addpath('./mat/');
addpath('./src/');
#+end_src

#+begin_src matlab :tangle no
addpath('matlab/nass-simscape/matlab/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/png/')
addpath('matlab/nass-simscape/src/')
addpath('matlab/nass-simscape/mat/')
addpath('matlab/vibration-table/matlab/')
addpath('matlab/vibration-table/STEPS/')
#+end_src

#+begin_src matlab :eval no
%% Add other useful folders to the path related to the Simscape model
addpath('nass-simscape/matlab/nano_hexapod/')
addpath('nass-simscape/STEPS/nano_hexapod/')
addpath('nass-simscape/STEPS/png/')
addpath('nass-simscape/src/')
addpath('nass-simscape/mat/')
addpath('vibration-table/matlab/')
addpath('vibration-table/STEPS/')
#+end_src

#+begin_src matlab
%% Load the identified FRF and Simscape model
frf_iff = load('frf_iff_vib_table_m.mat', 'f', 'Ts', 'G_dL');
sim_iff = load('sim_iff_vib_table_m.mat', 'G_dL');
#+end_src

#+begin_src matlab
i_masses = 0:3;
#+end_src

#+begin_src matlab
%% Colors for the figures
colors = colororder;
#+end_src

*** Parameters
#+begin_src matlab
wc = 100; % Wanted crossover frequency [Hz]
[~, i_wc] = min(abs(frf_iff.f - wc)); % Indice corresponding to wc
#+end_src

#+begin_src matlab
%% Plant to be decoupled
frf_coupled = frf_iff.G_dL{2};
G_coupled = sim_iff.G_dL{2};
#+end_src

*** No Decoupling (Decentralized)
<<sec:interaction_decentralized>>

#+begin_src latex :file decoupling_arch_decentralized.pdf :tangle no :exports results
\begin{tikzpicture}
  \node[block] (G) {$\bm{G}$};

  % Connections and labels
  \draw[<-] (G.west) -- ++(-1.8, 0) node[above right]{$\bm{\tau}$};
  \draw[->] (G.east) -- ++( 1.8, 0) node[above left]{$d\bm{\mathcal{L}}$};
\end{tikzpicture}
#+end_src

#+name: fig:decoupling_arch_decentralized
#+caption: Block diagram representing the plant.
#+RESULTS:
[[file:figs/decoupling_arch_decentralized.png]]

#+begin_src matlab :exports none
%% Decentralized Plant
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:5
    for j = i+1:6
        plot(frf_iff.f, abs(frf_coupled(:,i,j)), 'color', [0,0,0,0.2], ...
             'HandleVisibility', 'off');
    end
end
set(gca,'ColorOrderIndex',1)
for i = 1:6
    plot(frf_iff.f, abs(frf_coupled(:,i,i)), ...
         'DisplayName', sprintf('$y_%i/u_%i$', i, i));
end
plot(frf_iff.f, abs(frf_coupled(:,1,2)), 'color', [0,0,0,0.2], ...
     'DisplayName', 'Coupling');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude'); set(gca, 'XTickLabel',[]);
ylim([1e-9, 1e-4]);
legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 3);

ax2 = nexttile;
hold on;
for i =1:6
    plot(frf_iff.f, 180/pi*angle(frf_coupled(:,i,i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([10, 1e3]);
#+end_src

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

#+name: fig:interaction_decentralized_plant
#+caption: Bode Plot of the decentralized plant (diagonal and off-diagonal terms)
#+RESULTS:
[[file:figs/interaction_decentralized_plant.png]]

#+begin_src matlab :exports none
%% Decentralized RGA
RGA_dec = zeros(size(frf_coupled));
for i = 1:length(frf_iff.f)
    RGA_dec(i,:,:) = squeeze(frf_coupled(i,:,:)).*inv(squeeze(frf_coupled(i,:,:))).';
end

RGA_dec_sum = zeros(length(frf_iff), 1);
for i = 1:length(frf_iff.f)
    RGA_dec_sum(i) = sum(sum(abs(eye(6) - squeeze(RGA_dec(i,:,:)))));
end
#+end_src

#+begin_src matlab :exports none
%% RGA for Decentralized plant
figure;
plot(frf_iff.f, RGA_dec_sum, 'k-');
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('RGA Number');
xlim([10, 1e3]); ylim([1e-2, 1e2]);
#+end_src

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

#+name: fig:interaction_rga_decentralized
#+caption: RGA number for the decentralized plant
#+RESULTS:
[[file:figs/interaction_rga_decentralized.png]]

*** Static Decoupling
<<sec:interaction_static>>

#+begin_src latex :file decoupling_arch_static.pdf :tangle no :exports results
\begin{tikzpicture}
  \node[block] (G) {$\bm{G}$};
  \node[block, left=0.8 of G] (Ginv) {$\bm{\hat{G}}(j0)^{-1}$};

  % Connections and labels
  \draw[<-] (Ginv.west) -- ++(-1.8, 0) node[above right]{$\bm{u}$};
  \draw[->] (Ginv.east) -- (G.west)    node[above left]{$\bm{\tau}$};
  \draw[->] (G.east) -- ++( 1.8, 0)    node[above left]{$d\bm{\mathcal{L}}$};

  \begin{scope}[on background layer]
    \node[fit={(Ginv.south west) (G.north east)}, fill=black!10!white, draw, dashed, inner sep=16pt] (Gx) {};
    \node[below right] at (Gx.north west) {$\bm{G}_{\text{static}}$};
  \end{scope}
\end{tikzpicture}
#+end_src

#+name: fig:decoupling_arch_static
#+caption: Decoupling using the inverse of the DC gain of the plant
#+RESULTS:
[[file:figs/decoupling_arch_static.png]]

The DC gain is evaluated from the model as be have bad low frequency identification.

#+begin_src matlab :exports none
%% Compute the inverse of the DC gain
G_model = G_coupled;
G_model.outputdelay = 0; % necessary for further inversion
dc_inv = inv(dcgain(G_model));

%% Compute the inversed plant
G_dL_sta = zeros(size(frf_coupled));
for i = 1:length(frf_iff.f)
    G_dL_sta(i,:,:) = squeeze(frf_coupled(i,:,:))*dc_inv;
end
#+end_src

#+begin_src matlab :exports results :results value table replace :tangle no
data2orgtable(dc_inv, {}, {}, ' %.1f ');
#+end_src

#+RESULTS:
| -62011.5 |   3910.6 |   4299.3 |    660.7 |  -4016.5 |  -4373.6 |
|   3914.4 | -61991.2 |  -4356.8 |  -4019.2 |    640.2 |   4281.6 |
|  -4020.0 |  -4370.5 | -62004.5 |   3914.6 |   4295.8 |    653.8 |
|    660.9 |   4292.4 |   3903.3 | -62012.2 |  -4366.5 |  -4008.9 |
|   4302.8 |    655.6 |  -4025.8 |  -4377.8 | -62006.0 |   3919.7 |
|  -4377.9 |  -4013.2 |    668.6 |   4303.7 |   3906.8 | -62019.3 |

#+begin_src matlab :exports none
%% Bode plot of the static decoupled plant
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:5
    for j = i+1:6
        plot(frf_iff.f, abs(G_dL_sta(:,i,j)), 'color', [0,0,0,0.2], ...
             'HandleVisibility', 'off');
    end
end
set(gca,'ColorOrderIndex',1)
for i = 1:6
    plot(frf_iff.f, abs(G_dL_sta(:,i,i)), ...
         'DisplayName', sprintf('$y_%i/u_%i$', i, i));
end
plot(frf_iff.f, abs(G_dL_sta(:,1,2)), 'color', [0,0,0,0.2], ...
     'DisplayName', 'Coupling');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude'); set(gca, 'XTickLabel',[]);
ylim([1e-3, 1e1]);
legend('location', 'northeast', 'FontSize', 8, 'NumColumns', 2);

ax2 = nexttile;
hold on;
for i =1:6
    plot(frf_iff.f, 180/pi*angle(G_dL_sta(:,i,i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([10, 1e3]);
#+end_src

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

#+name: fig:interaction_static_dec_plant
#+caption: Bode Plot of the static decoupled plant
#+RESULTS:
[[file:figs/interaction_static_dec_plant.png]]

#+begin_src matlab :exports none
%% Compute RGA Matrix
RGA_sta = zeros(size(frf_coupled));
for i = 1:length(frf_iff.f)
    RGA_sta(i,:,:) = squeeze(G_dL_sta(i,:,:)).*inv(squeeze(G_dL_sta(i,:,:))).';
end

%% Compute RGA-number
RGA_sta_sum = zeros(length(frf_iff), 1);
for i = 1:size(RGA_sta, 1)
    RGA_sta_sum(i) = sum(sum(abs(eye(6) - squeeze(RGA_sta(i,:,:)))));
end
#+end_src

#+begin_src matlab :exports none
%% Plot the RGA-number for statically decoupled plant
figure;
plot(frf_iff.f, RGA_sta_sum, 'k-');
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('RGA Number');
xlim([10, 1e3]); ylim([1e-2, 1e2]);
#+end_src

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

#+name: fig:interaction_rga_static_dec
#+caption: RGA number for the statically decoupled plant
#+RESULTS:
[[file:figs/interaction_rga_static_dec.png]]

*** Decoupling at the Crossover
<<sec:interaction_crossover>>

#+begin_src latex :file decoupling_arch_crossover.pdf :tangle no :exports results
\begin{tikzpicture}
  \node[block] (G) {$\bm{G}$};
  \node[block, left=0.8 of G] (Ginv) {$\bm{\hat{G}}(j\omega_c)^{-1}$};

  % Connections and labels
  \draw[<-] (Ginv.west) -- ++(-1.8, 0) node[above right]{$\bm{u}$};
  \draw[->] (Ginv.east) -- (G.west)    node[above left]{$\bm{\tau}$};
  \draw[->] (G.east) -- ++( 1.8, 0)    node[above left]{$d\bm{\mathcal{L}}$};

  \begin{scope}[on background layer]
    \node[fit={(Ginv.south west) (G.north east)}, fill=black!10!white, draw, dashed, inner sep=16pt] (Gx) {};
    \node[below right] at (Gx.north west) {$\bm{G}_{\omega_c}$};
  \end{scope}
\end{tikzpicture}
#+end_src

#+name: fig:decoupling_arch_crossover
#+caption: Decoupling using the inverse of a dynamical model $\bm{\hat{G}}$ of the plant dynamics $\bm{G}$
#+RESULTS:
[[file:figs/decoupling_arch_crossover.png]]

#+begin_src matlab :exports none
%% Take complex matrix corresponding to the plant at 100Hz
V = squeeze(frf_coupled(i_wc,:,:));

%% Real approximation of inv(G(100Hz))
D = pinv(real(V'*V));
H1 = D*real(V'*diag(exp(1j*angle(diag(V*D*V.'))/2)));

%% Compute the decoupled plant
G_dL_wc = zeros(size(frf_coupled));
for i = 1:length(frf_iff.f)
    G_dL_wc(i,:,:) = squeeze(frf_coupled(i,:,:))*H1;
end
#+end_src

#+begin_src matlab :exports results :results value table replace :tangle no
data2orgtable(H1, {}, {}, ' %.1f ');
#+end_src

#+RESULTS:
|  67229.8 |   3769.3 | -13704.6 | -23084.8 |  -6318.2 |  23378.7 |
|   3486.2 |  67708.9 |  23220.0 |  -6314.5 | -22699.8 | -14060.6 |
|  -5731.7 |  22471.7 |  66701.4 |   3070.2 | -13205.6 | -21944.6 |
| -23305.5 | -14542.6 |   2743.2 |  70097.6 |  24846.8 |  -5295.0 |
| -14882.9 | -22957.8 |  -5344.4 |  25786.2 |  70484.6 |   2979.9 |
|  24353.3 |  -5195.2 | -22449.0 | -14459.2 |   2203.6 |  69484.2 |

#+begin_src matlab :exports none
%% Bode plot of the plant decoupled at the crossover
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:5
    for j = i+1:6
        plot(frf_iff.f, abs(G_dL_wc(:,i,j)), 'color', [0,0,0,0.2], ...
             'HandleVisibility', 'off');
    end
end
for i = 1:6
    plot(frf_iff.f, abs(G_dL_wc(:,i,i)), ...
         'DisplayName', sprintf('$y_%i/u_%i$', i, i));
end
plot(frf_iff.f, abs(G_dL_wc(:,1,2)), 'color', [0,0,0,0.2], ...
     'DisplayName', 'Coupling');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude $d_L/V_a$ [m/V]'); set(gca, 'XTickLabel',[]);
ylim([1e-3, 1e1]);
legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 2);

ax2 = nexttile;
hold on;
for i =1:6
    plot(frf_iff.f, 180/pi*angle(G_dL_wc(:,i,i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([10, 1e3]);
#+end_src

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

#+name: fig:interaction_wc_plant
#+caption: Bode Plot of the plant decoupled at the crossover
#+RESULTS:
[[file:figs/interaction_wc_plant.png]]

#+begin_src matlab
%% Compute RGA Matrix
RGA_wc = zeros(size(frf_coupled));
for i = 1:length(frf_iff.f)
    RGA_wc(i,:,:) = squeeze(G_dL_wc(i,:,:)).*inv(squeeze(G_dL_wc(i,:,:))).';
end

%% Compute RGA-number
RGA_wc_sum = zeros(size(RGA_wc, 1), 1);
for i = 1:size(RGA_wc, 1)
    RGA_wc_sum(i) = sum(sum(abs(eye(6) - squeeze(RGA_wc(i,:,:)))));
end
#+end_src

#+begin_src matlab :exports none
%% Plot the RGA-Number for the plant decoupled at crossover
figure;
plot(frf_iff.f, RGA_wc_sum, 'k-');
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('RGA Number');
xlim([10, 1e3]); ylim([1e-2, 1e2]);
#+end_src

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

#+name: fig:interaction_rga_wc
#+caption: RGA number for the plant decoupled at the crossover
#+RESULTS:
[[file:figs/interaction_rga_wc.png]]

*** SVD Decoupling
<<sec:interaction_svd>>

#+begin_src latex :file decoupling_arch_svd.pdf :tangle no :exports results
\begin{tikzpicture}
  \node[block] (G) {$\bm{G}$};

  \node[block, left=0.8 of G.west] (V) {$V^{-T}$};
  \node[block, right=0.8 of G.east] (U) {$U^{-1}$};

  % Connections and labels
  \draw[<-] (V.west) -- ++(-1.0, 0) node[above right]{$u$};
  \draw[->] (V.east) -- (G.west) node[above left]{$\bm{\tau}$};
  \draw[->] (G.east) -- (U.west) node[above left]{$d\bm{\mathcal{L}}$};
  \draw[->] (U.east) -- ++( 1.0, 0) node[above left]{$y$};

  \begin{scope}[on background layer]
    \node[fit={(V.south west) (G.north-|U.east)}, fill=black!10!white, draw, dashed, inner sep=14pt] (Gsvd) {};
    \node[below right] at (Gsvd.north west) {$\bm{G}_{SVD}$};
  \end{scope}
\end{tikzpicture}
#+end_src

#+name: fig:decoupling_arch_svd
#+caption: Decoupling using the Singular Value Decomposition
#+RESULTS:
[[file:figs/decoupling_arch_svd.png]]

#+begin_src matlab :exports none
%% Take complex matrix corresponding to the plant at 100Hz
V = squeeze(frf_coupled(i_wc,:,:));

%% Real approximation of G(100Hz)
D = pinv(real(V'*V));
H1 = pinv(D*real(V'*diag(exp(1j*angle(diag(V*D*V.'))/2))));

%% Singular Value Decomposition
[U,S,V] = svd(H1);

%% Compute the decoupled plant using SVD
G_dL_svd = zeros(size(frf_coupled));
for i = 1:length(frf_iff.f)
    G_dL_svd(i,:,:) = inv(U)*squeeze(frf_coupled(i,:,:))*inv(V');
end
#+end_src

#+begin_src matlab :exports none
%% Bode Plot of the SVD decoupled plant
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:5
    for j = i+1:6
        plot(frf_iff.f, abs(G_dL_svd(:,i,j)), 'color', [0,0,0,0.2], ...
             'HandleVisibility', 'off');
    end
end
set(gca,'ColorOrderIndex',1)
for i = 1:6
    plot(frf_iff.f, abs(G_dL_svd(:,i,i)), ...
         'DisplayName', sprintf('$y_%i/u_%i$', i, i));
end
plot(frf_iff.f, abs(G_dL_svd(:,1,2)), 'color', [0,0,0,0.2], ...
     'DisplayName', 'Coupling');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude'); set(gca, 'XTickLabel',[]);
ylim([1e-9, 1e-4]);
legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 3);

ax2 = nexttile;
hold on;
for i =1:6
    plot(frf_iff.f, 180/pi*angle(G_dL_svd(:,i,i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([10, 1e3]);
#+end_src

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

#+name: fig:interaction_svd_plant
#+caption: Bode Plot of the plant decoupled using the Singular Value Decomposition
#+RESULTS:
[[file:figs/interaction_svd_plant.png]]

#+begin_src matlab
%% Compute the RGA matrix for the SVD decoupled plant
RGA_svd = zeros(size(frf_coupled));
for i = 1:length(frf_iff.f)
    RGA_svd(i,:,:) = squeeze(G_dL_svd(i,:,:)).*inv(squeeze(G_dL_svd(i,:,:))).';
end

%% Compute the RGA-number
RGA_svd_sum = zeros(size(RGA_svd, 1), 1);
for i = 1:length(frf_iff.f)
    RGA_svd_sum(i) = sum(sum(abs(eye(6) - squeeze(RGA_svd(i,:,:)))));
end
#+end_src

#+begin_src matlab
%% RGA Number for the SVD decoupled plant
figure;
plot(frf_iff.f, RGA_svd_sum, 'k-');
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('RGA Number');
xlim([10, 1e3]); ylim([1e-2, 1e2]);
#+end_src

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

#+name: fig:interaction_rga_svd
#+caption: RGA number for the plant decoupled using the SVD
#+RESULTS:
[[file:figs/interaction_rga_svd.png]]

*** Dynamic decoupling
<<sec:interaction_dynamic>>

#+begin_src latex :file decoupling_arch_dynamic.pdf :tangle no :exports results
\begin{tikzpicture}
  \node[block] (G) {$\bm{G}$};
  \node[block, left=0.8 of G] (Ginv) {$\bm{\hat{G}}^{-1}$};

  % Connections and labels
  \draw[<-] (Ginv.west) -- ++(-1.8, 0) node[above right]{$\bm{u}$};
  \draw[->] (Ginv.east) -- (G.west)    node[above left]{$\bm{\tau}$};
  \draw[->] (G.east) -- ++( 1.8, 0)    node[above left]{$d\bm{\mathcal{L}}$};

  \begin{scope}[on background layer]
    \node[fit={(Ginv.south west) (G.north east)}, fill=black!10!white, draw, dashed, inner sep=16pt] (Gx) {};
    \node[below right] at (Gx.north west) {$\bm{G}_{\text{inv}}$};
  \end{scope}
\end{tikzpicture}
#+end_src

#+name: fig:decoupling_arch_dynamic
#+caption: Decoupling using the inverse of a dynamical model $\bm{\hat{G}}$ of the plant dynamics $\bm{G}$
#+RESULTS:
[[file:figs/decoupling_arch_dynamic.png]]

#+begin_src matlab :exports none
%% Compute the plant inverse from the model
G_model = G_coupled;
G_model.outputdelay = 0; % necessary for further inversion
G_inv = inv(G_model);

%% Compute the decoupled plant
G_dL_inv = zeros(size(frf_coupled));
for i = 1:length(frf_iff.f)
    G_dL_inv(i,:,:) = squeeze(frf_coupled(i,:,:))*squeeze(evalfr(G_inv, 1j*2*pi*frf_iff.f(i)));
end
#+end_src

#+begin_src matlab :exports none
%% Bode plot of the decoupled plant by full inversion
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:5
    for j = i+1:6
        plot(frf_iff.f, abs(G_dL_inv(:,i,j)), 'color', [0,0,0,0.2], ...
             'HandleVisibility', 'off');
    end
end
set(gca,'ColorOrderIndex',1)
for i = 1:6
    plot(frf_iff.f, abs(G_dL_inv(:,i,i)), ...
         'DisplayName', sprintf('$y_%i/u_%i$', i, i));
end
plot(frf_iff.f, abs(G_dL_inv(:,1,2)), 'color', [0,0,0,0.2], ...
     'DisplayName', 'Coupling');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude'); set(gca, 'XTickLabel',[]);
ylim([1e-4, 1e1]);
legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 2);

ax2 = nexttile;
hold on;
for i =1:6
    plot(frf_iff.f, 180/pi*angle(G_dL_inv(:,i,i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([10, 1e3]);
#+end_src

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

#+name: fig:interaction_dynamic_dec_plant
#+caption: Bode Plot of the dynamically decoupled plant
#+RESULTS:
[[file:figs/interaction_dynamic_dec_plant.png]]

#+begin_src matlab :exports none
%% Compute the RGA matrix for the inverse based decoupled plant
RGA_inv = zeros(size(frf_coupled));
for i = 1:length(frf_iff.f)
    RGA_inv(i,:,:) = squeeze(G_dL_inv(i,:,:)).*inv(squeeze(G_dL_inv(i,:,:))).';
end

%% Compute the RGA-number
RGA_inv_sum = zeros(size(RGA_inv, 1), 1);
for i = 1:size(RGA_inv, 1)
    RGA_inv_sum(i) = sum(sum(abs(eye(6) - squeeze(RGA_inv(i,:,:)))));
end
#+end_src

#+begin_src matlab :exports none
%% RGA Number for the decoupled plant using full inversion
figure;
plot(frf_iff.f, RGA_inv_sum, 'k-');
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('RGA Number');
xlim([10, 1e3]); ylim([1e-2, 1e2]);
#+end_src

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

#+name: fig:interaction_rga_dynamic_dec
#+caption: RGA number for the dynamically decoupled plant
#+RESULTS:
[[file:figs/interaction_rga_dynamic_dec.png]]

*** Jacobian Decoupling - Center of Stiffness
<<sec:interaction_jacobian_cok>>

#+begin_src latex :file decoupling_arch_jacobian_cok.pdf :tangle no :exports results
\begin{tikzpicture}
  \node[block] (G) {$\bm{G}$};
  \node[block, left=0.8 of G] (Jt) {$J_{s,\{K\}}^{-T}$};
  \node[block, right=0.8 of G] (Ja) {$J_{a,\{K\}}^{-1}$};

  % Connections and labels
  \draw[<-] (Jt.west) -- ++(-1.8, 0) node[above right]{$\bm{\mathcal{F}}_{\{K\}}$};
  \draw[->] (Jt.east) -- (G.west)  node[above left]{$\bm{\tau}$};
  \draw[->] (G.east) -- (Ja.west)  node[above left]{$d\bm{\mathcal{L}}$};
  \draw[->] (Ja.east) -- ++( 1.8, 0)  node[above left]{$\bm{\mathcal{X}}_{\{K\}}$};

  \begin{scope}[on background layer]
    \node[fit={(Jt.south west) (Ja.north east)}, fill=black!10!white, draw, dashed, inner sep=16pt] (Gx) {};
    \node[below right] at (Gx.north west) {$\bm{G}_{\{K\}}$};
  \end{scope}
\end{tikzpicture}
#+end_src

#+name: fig:decoupling_arch_jacobian_cok
#+caption: Decoupling using Jacobian matrices evaluated at the Center of Stiffness
#+RESULTS:
[[file:figs/decoupling_arch_jacobian_cok.png]]

#+begin_src matlab :exports none
%% Initialize the Nano-Hexapod
n_hexapod = initializeNanoHexapodFinal('MO_B', -42e-3, ...
                                       'motion_sensor_type', 'plates');

%% Get the Jacobians
J_cok  = n_hexapod.geometry.J;
Js_cok = n_hexapod.geometry.Js;

%% Decouple plant using Jacobian (CoM)
G_dL_J_cok = zeros(size(frf_coupled));
for i = 1:length(frf_iff.f)
    G_dL_J_cok(i,:,:) = inv(Js_cok)*squeeze(frf_coupled(i,:,:))*inv(J_cok');
end

%% Normalize the plant input
[~, i_100] = min(abs(frf_iff.f - 100));
input_normalize = diag(1./diag(abs(squeeze(G_dL_J_cok(i_100,:,:)))));

for i = 1:length(frf_iff.f)
    G_dL_J_cok(i,:,:) = squeeze(G_dL_J_cok(i,:,:))*input_normalize;
end
#+end_src

#+begin_src matlab :exports none
%% Bode Plot of the SVD decoupled plant
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:5
    for j = i+1:6
        plot(frf_iff.f, abs(G_dL_J_cok(:,i,j)), 'color', [0,0,0,0.2], ...
             'HandleVisibility', 'off');
    end
end
set(gca,'ColorOrderIndex',1)
plot(frf_iff.f, abs(G_dL_J_cok(:,1,1)), ...
     'DisplayName', '$D_x/\tilde{\mathcal{F}}_x$');
plot(frf_iff.f, abs(G_dL_J_cok(:,2,2)), ...
     'DisplayName', '$D_y/\tilde{\mathcal{F}}_y$');
plot(frf_iff.f, abs(G_dL_J_cok(:,3,3)), ...
     'DisplayName', '$D_z/\tilde{\mathcal{F}}_z$');
plot(frf_iff.f, abs(G_dL_J_cok(:,4,4)), ...
     'DisplayName', '$R_x/\tilde{\mathcal{M}}_x$');
plot(frf_iff.f, abs(G_dL_J_cok(:,5,5)), ...
     'DisplayName', '$R_y/\tilde{\mathcal{M}}_y$');
plot(frf_iff.f, abs(G_dL_J_cok(:,6,6)), ...
     'DisplayName', '$R_z/\tilde{\mathcal{M}}_z$');
plot(frf_iff.f, abs(G_dL_J_cok(:,1,2)), 'color', [0,0,0,0.2], ...
     'DisplayName', 'Coupling');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude'); set(gca, 'XTickLabel',[]);
ylim([1e-3, 1e1]);
legend('location', 'northeast', 'FontSize', 8, 'NumColumns', 2);

ax2 = nexttile;
hold on;
for i =1:6
    plot(frf_iff.f, 180/pi*angle(G_dL_J_cok(:,i,i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([10, 1e3]);
#+end_src

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

#+name: fig:interaction_J_cok_plant
#+caption: Bode Plot of the plant decoupled using the Jacobian evaluated at the "center of stiffness"
#+RESULTS:
[[file:figs/interaction_J_cok_plant.png]]

#+begin_src matlab :exports none
%% Compute RGA Matrix
RGA_cok = zeros(size(frf_coupled));
for i = 1:length(frf_iff.f)
    RGA_cok(i,:,:) = squeeze(G_dL_J_cok(i,:,:)).*inv(squeeze(G_dL_J_cok(i,:,:))).';
end

%% Compute RGA-number
RGA_cok_sum = zeros(length(frf_iff.f), 1);
for i = 1:length(frf_iff.f)
    RGA_cok_sum(i) = sum(sum(abs(eye(6) - squeeze(RGA_cok(i,:,:)))));
end
#+end_src

#+begin_src matlab :exports none
%% Plot the RGA-Number for the Jacobian (CoK) decoupled plant
figure;
plot(frf_iff.f, RGA_cok_sum, 'k-');
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('RGA Number');
xlim([10, 1e3]); ylim([1e-2, 1e2]);
#+end_src

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

#+name: fig:interaction_rga_J_cok
#+caption: RGA number for the plant decoupled using the Jacobian evaluted at the Center of Stiffness
#+RESULTS:
[[file:figs/interaction_rga_J_cok.png]]

*** Jacobian Decoupling - Center of Mass
<<sec:interaction_jacobian_com>>

#+begin_src latex :file decoupling_arch_jacobian_com.pdf :tangle no :exports results
\begin{tikzpicture}
  \node[block] (G) {$\bm{G}$};
  \node[block, left=0.8 of G] (Jt) {$J_{s,\{M\}}^{-T}$};
  \node[block, right=0.8 of G] (Ja) {$J_{a,\{M\}}^{-1}$};

  % Connections and labels
  \draw[<-] (Jt.west) -- ++(-1.8, 0) node[above right]{$\bm{\mathcal{F}}_{\{M\}}$};
  \draw[->] (Jt.east) -- (G.west)  node[above left]{$\bm{\tau}$};
  \draw[->] (G.east) -- (Ja.west)  node[above left]{$d\bm{\mathcal{L}}$};
  \draw[->] (Ja.east) -- ++( 1.8, 0)  node[above left]{$\bm{\mathcal{X}}_{\{M\}}$};

  \begin{scope}[on background layer]
    \node[fit={(Jt.south west) (Ja.north east)}, fill=black!10!white, draw, dashed, inner sep=16pt] (Gx) {};
    \node[below right] at (Gx.north west) {$\bm{G}_{\{M\}}$};
  \end{scope}
\end{tikzpicture}
#+end_src

#+name: fig:decoupling_arch_jacobian_com
#+caption: Decoupling using Jacobian matrices evaluated at the Center of Mass
#+RESULTS:
[[file:figs/decoupling_arch_jacobian_com.png]]

#+begin_src matlab :exports none
%% Initialize the Nano-Hexapod
n_hexapod = initializeNanoHexapodFinal('MO_B', 25e-3, ...
                                       'motion_sensor_type', 'plates');

%% Get the Jacobians
J_com  = n_hexapod.geometry.J;
Js_com = n_hexapod.geometry.Js;

%% Decouple plant using Jacobian (CoM)
G_dL_J_com = zeros(size(frf_coupled));
for i = 1:length(frf_iff.f)
    G_dL_J_com(i,:,:) = inv(Js_com)*squeeze(frf_coupled(i,:,:))*inv(J_com');
end

%% Normalize the plant input
[~, i_100] = min(abs(frf_iff.f - 100));
input_normalize = diag(1./diag(abs(squeeze(G_dL_J_com(i_100,:,:)))));

for i = 1:length(frf_iff.f)
    G_dL_J_com(i,:,:) = squeeze(G_dL_J_com(i,:,:))*input_normalize;
end
#+end_src

#+begin_src matlab :exports none
%% Bode Plot of the SVD decoupled plant
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:5
    for j = i+1:6
        plot(frf_iff.f, abs(G_dL_J_com(:,i,j)), 'color', [0,0,0,0.2], ...
             'HandleVisibility', 'off');
    end
end
set(gca,'ColorOrderIndex',1)
plot(frf_iff.f, abs(G_dL_J_com(:,1,1)), ...
     'DisplayName', '$D_x/\tilde{\mathcal{F}}_x$');
plot(frf_iff.f, abs(G_dL_J_com(:,2,2)), ...
     'DisplayName', '$D_y/\tilde{\mathcal{F}}_y$');
plot(frf_iff.f, abs(G_dL_J_com(:,3,3)), ...
     'DisplayName', '$D_z/\tilde{\mathcal{F}}_z$');
plot(frf_iff.f, abs(G_dL_J_com(:,4,4)), ...
     'DisplayName', '$R_x/\tilde{\mathcal{M}}_x$');
plot(frf_iff.f, abs(G_dL_J_com(:,5,5)), ...
     'DisplayName', '$R_y/\tilde{\mathcal{M}}_y$');
plot(frf_iff.f, abs(G_dL_J_com(:,6,6)), ...
     'DisplayName', '$R_z/\tilde{\mathcal{M}}_z$');
plot(frf_iff.f, abs(G_dL_J_com(:,1,2)), 'color', [0,0,0,0.2], ...
     'DisplayName', 'Coupling');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude'); set(gca, 'XTickLabel',[]);
ylim([1e-3, 1e1]);
legend('location', 'northeast', 'FontSize', 8, 'NumColumns', 2);

ax2 = nexttile;
hold on;
for i =1:6
    plot(frf_iff.f, 180/pi*angle(G_dL_J_com(:,i,i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([10, 1e3]);
#+end_src

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

#+name: fig:interaction_J_com_plant
#+caption: Bode Plot of the plant decoupled using the Jacobian evaluated at the Center of Mass
#+RESULTS:
[[file:figs/interaction_J_com_plant.png]]

#+begin_src matlab :exports none
%% Compute RGA Matrix
RGA_com = zeros(size(frf_coupled));
for i = 1:length(frf_iff.f)
    RGA_com(i,:,:) = squeeze(G_dL_J_com(i,:,:)).*inv(squeeze(G_dL_J_com(i,:,:))).';
end

%% Compute RGA-number
RGA_com_sum = zeros(size(RGA_com, 1), 1);
for i = 1:size(RGA_com, 1)
    RGA_com_sum(i) = sum(sum(abs(eye(6) - squeeze(RGA_com(i,:,:)))));
end
#+end_src

#+begin_src matlab :exports none
%% Plot the RGA-Number for the Jacobian (CoM) decoupled plant
figure;
plot(frf_iff.f, RGA_com_sum, 'k-');
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('RGA Number');
xlim([10, 1e3]); ylim([1e-2, 1e2]);
#+end_src

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

#+name: fig:interaction_rga_J_com
#+caption: RGA number for the plant decoupled using the Jacobian evaluted at the Center of Mass
#+RESULTS:
[[file:figs/interaction_rga_J_com.png]]

*** Decoupling Comparison
<<sec:interaction_comparison>>

Let's now compare all of the decoupling methods (Figure [[fig:interaction_compare_rga_numbers]]).

#+begin_important
From Figure [[fig:interaction_compare_rga_numbers]], the following remarks are made:
- *Decentralized plant*: well decoupled below suspension modes
- *Static inversion*: similar to the decentralized plant as the decentralized plant has already a good decoupling at low frequency
- *Crossover inversion*: the decoupling is improved around the crossover frequency as compared to the decentralized plant. However, the decoupling is increased at lower frequency.
- *SVD decoupling*: Very good decoupling up to 235Hz. Especially between 100Hz and 200Hz.
- *Dynamic Inversion*: the plant is very well decoupled at frequencies where the model is accurate (below 235Hz where flexible modes are not modelled).
- *Jacobian - Stiffness*: good decoupling at low frequency. The decoupling increases at the frequency of the suspension modes, but is acceptable up to the strut flexible modes (235Hz).
- *Jacobian - Mass*: bad decoupling at low frequency. Better decoupling above the frequency of the suspension modes, and acceptable decoupling up to the strut flexible modes (235Hz).
#+end_important

#+begin_src matlab :exports none
%% Comparison of the RGA-Numbers
figure;
hold on;
plot(frf_iff.f, RGA_dec_sum, 'DisplayName', 'Decentralized');
plot(frf_iff.f, RGA_sta_sum, 'DisplayName', 'Static inv.');
plot(frf_iff.f, RGA_wc_sum,  'DisplayName', 'Crossover inv.');
plot(frf_iff.f, RGA_svd_sum, 'DisplayName', 'SVD');
plot(frf_iff.f, RGA_inv_sum, 'DisplayName', 'Dynamic inv.');
plot(frf_iff.f, RGA_cok_sum, 'DisplayName', 'Jacobian - CoK');
plot(frf_iff.f, RGA_com_sum, 'DisplayName', 'Jacobian - CoM');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('RGA Number');
xlim([10, 1e3]); ylim([1e-2, 1e2]);
legend('location', 'northwest', 'FontSize', 8, 'NumColumns', 2);
#+end_src

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

#+name: fig:interaction_compare_rga_numbers
#+caption: Comparison of the obtained RGA-numbers for all the decoupling methods
#+RESULTS:
[[file:figs/interaction_compare_rga_numbers.png]]

*** Decoupling Robustness
<<sec:interaction_robustness>>

Let's now see how the decoupling is changing when changing the payload's mass.
#+begin_src matlab
frf_new = frf_iff.G_dL{3};
#+end_src

#+begin_src matlab :exports none
%% Decentralized RGA
RGA_dec_b = zeros(size(frf_new));
for i = 1:length(frf_iff.f)
    RGA_dec_b(i,:,:) = squeeze(frf_new(i,:,:)).*inv(squeeze(frf_new(i,:,:))).';
end

RGA_dec_sum_b = zeros(length(frf_iff), 1);
for i = 1:length(frf_iff.f)
    RGA_dec_sum_b(i) = sum(sum(abs(eye(6) - squeeze(RGA_dec_b(i,:,:)))));
end
#+end_src

#+begin_src matlab :exports none
%% Static Decoupling
G_dL_sta_b = zeros(size(frf_new));
for i = 1:length(frf_iff.f)
    G_dL_sta_b(i,:,:) = squeeze(frf_new(i,:,:))*dc_inv;
end

RGA_sta_b = zeros(size(frf_new));
for i = 1:length(frf_iff.f)
    RGA_sta_b(i,:,:) = squeeze(G_dL_sta_b(i,:,:)).*inv(squeeze(G_dL_sta_b(i,:,:))).';
end

RGA_sta_sum_b = zeros(size(RGA_sta_b, 1), 1);
for i = 1:size(RGA_sta_b, 1)
    RGA_sta_sum_b(i) = sum(sum(abs(eye(6) - squeeze(RGA_sta_b(i,:,:)))));
end
#+end_src

#+begin_src matlab :exports none
%% Crossover Decoupling
V = squeeze(frf_coupled(i_wc,:,:));
D = pinv(real(V'*V));
H1 = D*real(V'*diag(exp(1j*angle(diag(V*D*V.'))/2)));

G_dL_wc_b = zeros(size(frf_new));
for i = 1:length(frf_iff.f)
    G_dL_wc_b(i,:,:) = squeeze(frf_new(i,:,:))*H1;
end

RGA_wc_b = zeros(size(frf_new));
for i = 1:length(frf_iff.f)
    RGA_wc_b(i,:,:) = squeeze(G_dL_wc_b(i,:,:)).*inv(squeeze(G_dL_wc_b(i,:,:))).';
end

RGA_wc_sum_b = zeros(size(RGA_wc_b, 1), 1);
for i = 1:size(RGA_wc_b, 1)
    RGA_wc_sum_b(i) = sum(sum(abs(eye(6) - squeeze(RGA_wc_b(i,:,:)))));
end
#+end_src

#+begin_src matlab :exports none
%% SVD
V = squeeze(frf_coupled(i_wc,:,:));
D = pinv(real(V'*V));
H1 = pinv(D*real(V'*diag(exp(1j*angle(diag(V*D*V.'))/2))));
[U,S,V] = svd(H1);

G_dL_svd_b = zeros(size(frf_new));
for i = 1:length(frf_iff.f)
    G_dL_svd_b(i,:,:) = inv(U)*squeeze(frf_new(i,:,:))*inv(V');
end

RGA_svd_b = zeros(size(frf_new));
for i = 1:length(frf_iff.f)
    RGA_svd_b(i,:,:) = squeeze(G_dL_svd_b(i,:,:)).*inv(squeeze(G_dL_svd_b(i,:,:))).';
end

RGA_svd_sum_b = zeros(size(RGA_svd_b, 1), 1);
for i = 1:size(RGA_svd, 1)
    RGA_svd_sum_b(i) = sum(sum(abs(eye(6) - squeeze(RGA_svd_b(i,:,:)))));
end
#+end_src

#+begin_src matlab :exports none
%% Dynamic Decoupling
G_model = G_coupled;
G_model.outputdelay = 0; % necessary for further inversion
G_inv = inv(G_model);

G_dL_inv_b = zeros(size(frf_new));
for i = 1:length(frf_iff.f)
    G_dL_inv_b(i,:,:) = squeeze(frf_new(i,:,:))*squeeze(evalfr(G_inv, 1j*2*pi*frf_iff.f(i)));
end

RGA_inv_b = zeros(size(frf_new));
for i = 1:length(frf_iff.f)
    RGA_inv_b(i,:,:) = squeeze(G_dL_inv_b(i,:,:)).*inv(squeeze(G_dL_inv_b(i,:,:))).';
end

RGA_inv_sum_b = zeros(size(RGA_inv_b, 1), 1);
for i = 1:size(RGA_inv_b, 1)
    RGA_inv_sum_b(i) = sum(sum(abs(eye(6) - squeeze(RGA_inv_b(i,:,:)))));
end
#+end_src

#+begin_src matlab :exports none
%% Jacobian (CoK)
G_dL_J_cok_b = zeros(size(frf_new));
for i = 1:length(frf_iff.f)
    G_dL_J_cok_b(i,:,:) = inv(Js_cok)*squeeze(frf_new(i,:,:))*inv(J_cok');
end

RGA_cok_b = zeros(size(frf_new));
for i = 1:length(frf_iff.f)
    RGA_cok_b(i,:,:) = squeeze(G_dL_J_cok_b(i,:,:)).*inv(squeeze(G_dL_J_cok_b(i,:,:))).';
end

RGA_cok_sum_b = zeros(size(RGA_cok_b, 1), 1);
for i = 1:size(RGA_cok_b, 1)
    RGA_cok_sum_b(i) = sum(sum(abs(eye(6) - squeeze(RGA_cok_b(i,:,:)))));
end
#+end_src

#+begin_src matlab :exports none
%% Jacobian (CoM)
G_dL_J_com_b = zeros(size(frf_new));
for i = 1:length(frf_iff.f)
    G_dL_J_com_b(i,:,:) = inv(Js_com)*squeeze(frf_new(i,:,:))*inv(J_com');
end

RGA_com_b = zeros(size(frf_new));
for i = 1:length(frf_iff.f)
    RGA_com_b(i,:,:) = squeeze(G_dL_J_com_b(i,:,:)).*inv(squeeze(G_dL_J_com_b(i,:,:))).';
end

RGA_com_sum_b = zeros(size(RGA_com_b, 1), 1);
for i = 1:size(RGA_com_b, 1)
    RGA_com_sum_b(i) = sum(sum(abs(eye(6) - squeeze(RGA_com_b(i,:,:)))));
end
#+end_src

The obtained RGA-numbers are shown in Figure [[fig:interaction_compare_rga_numbers_rob]].

#+begin_important
From Figure [[fig:interaction_compare_rga_numbers_rob]]:
- The decoupling using the Jacobian evaluated at the "center of stiffness" seems to give the most robust results.
#+end_important

#+begin_src matlab :exports none
%% Robustness of the Decoupling method
figure;
hold on;
plot(frf_iff.f, RGA_dec_sum, '-', 'DisplayName', 'Decentralized');
plot(frf_iff.f, RGA_sta_sum, '-', 'DisplayName', 'Static inv.');
plot(frf_iff.f, RGA_wc_sum,  '-', 'DisplayName', 'Crossover inv.');
plot(frf_iff.f, RGA_svd_sum, '-', 'DisplayName', 'SVD');
plot(frf_iff.f, RGA_inv_sum, '-', 'DisplayName', 'Dynamic inv.');
plot(frf_iff.f, RGA_cok_sum, '-', 'DisplayName', 'Jacobian - CoK');
plot(frf_iff.f, RGA_com_sum, '-', 'DisplayName', 'Jacobian - CoM');
set(gca,'ColorOrderIndex',1)
plot(frf_iff.f, RGA_dec_sum_b, '--', 'HandleVisibility', 'off');
plot(frf_iff.f, RGA_sta_sum_b, '--', 'HandleVisibility', 'off');
plot(frf_iff.f, RGA_wc_sum_b,  '--', 'HandleVisibility', 'off');
plot(frf_iff.f, RGA_svd_sum_b, '--', 'HandleVisibility', 'off');
plot(frf_iff.f, RGA_inv_sum_b, '--', 'HandleVisibility', 'off');
plot(frf_iff.f, RGA_cok_sum_b, '--', 'HandleVisibility', 'off');
plot(frf_iff.f, RGA_com_sum_b, '--', 'HandleVisibility', 'off');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
xlabel('Frequency [Hz]'); ylabel('RGA Number');
xlim([10, 1e3]); ylim([1e-2, 1e2]);
legend('location', 'northwest', 'FontSize', 8, 'NumColumns', 2);
#+end_src

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

#+name: fig:interaction_compare_rga_numbers_rob
#+caption: Change of the RGA-number with a change of the payload. Indication of the robustness of the inversion method.
#+RESULTS:
[[file:figs/interaction_compare_rga_numbers_rob.png]]

*** Conclusion

#+begin_important
Several decoupling methods can be used:
- SVD
- Inverse
- Jacobian (CoK)
#+end_important

#+name: tab:interaction_analysis_conclusion
#+caption: Summary of the interaction analysis and different decoupling strategies
#+attr_latex: :environment tabularx :width \linewidth :align lccc
#+attr_latex: :center t :booktabs t
| *Method*       | *RGA* | *Diag Plant* | *Robustness* |
|----------------+-------+--------------+--------------|
| Decentralized  | --    | Equal        | ++           |
| Static dec.    | --    | Equal        | ++           |
| Crossover dec. | -     | Equal        | 0            |
| SVD            | ++    | Diff         | +            |
| Dynamic dec.   | ++    | Unity, equal | -            |
| Jacobian - CoK | +     | Diff         | ++           |
| Jacobian - CoM | 0     | Diff         | +            |

** Robust High Authority Controller
<<sec:robust_hac_design>>
*** Introduction                                                    :ignore:
In this section we wish to develop a robust High Authority Controller (HAC) that is working for all payloads.

cite:indri20_mechat_robot

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

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

#+begin_src matlab :tangle no
addpath('./matlab/mat/');
addpath('./matlab/src/');
addpath('./matlab/');
#+end_src

#+begin_src matlab :eval no
%% Add useful folders to the path
addpath('./mat/');
addpath('./src/');
#+end_src

#+begin_src matlab :tangle no
addpath('matlab/nass-simscape/matlab/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/png/')
addpath('matlab/nass-simscape/src/')
addpath('matlab/nass-simscape/mat/')
addpath('matlab/vibration-table/matlab/')
addpath('matlab/vibration-table/STEPS/')
#+end_src

#+begin_src matlab :eval no
%% Add other useful folders to the path related to the Simscape model
addpath('nass-simscape/matlab/nano_hexapod/')
addpath('nass-simscape/STEPS/nano_hexapod/')
addpath('nass-simscape/STEPS/png/')
addpath('nass-simscape/src/')
addpath('nass-simscape/mat/')
addpath('vibration-table/matlab/')
addpath('vibration-table/STEPS/')
#+end_src

#+begin_src matlab
%% Load the identified FRF and Simscape model
frf_iff = load('frf_iff_vib_table_m.mat', 'f', 'Ts', 'G_dL');
sim_iff = load('sim_iff_vib_table_m.mat', 'G_dL');
#+end_src

#+begin_src matlab
i_masses = 0:3;
#+end_src

#+begin_src matlab
%% Colors for the figures
colors = colororder;
#+end_src

*** Using Jacobian evaluated at the center of stiffness
**** Decoupled Plant
#+begin_src matlab
G_nom = frf_iff.G_dL{2}; % Nominal Plant
#+end_src

#+begin_src matlab :exports none
%% Initialize the Nano-Hexapod
n_hexapod = initializeNanoHexapodFinal('MO_B', -42e-3, ...
                                       'motion_sensor_type', 'plates');

%% Get the Jacobians
J_cok  = n_hexapod.geometry.J;
Js_cok = n_hexapod.geometry.Js;

%% Decouple plant using Jacobian (CoM)
G_dL_J_cok = zeros(size(G_nom));
for i = 1:length(frf_iff.f)
    G_dL_J_cok(i,:,:) = inv(Js_cok)*squeeze(G_nom(i,:,:))*inv(J_cok');
end

%% Normalize the plant input
[~, i_100] = min(abs(frf_iff.f - 10));
input_normalize = diag(1./diag(abs(squeeze(G_dL_J_cok(i_100,:,:)))));

for i = 1:length(frf_iff.f)
    G_dL_J_cok(i,:,:) = squeeze(G_dL_J_cok(i,:,:))*input_normalize;
end
#+end_src

#+begin_src matlab :exports none
%% Bode Plot of the decoupled plant
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:5
    for j = i+1:6
        plot(frf_iff.f, abs(G_dL_J_cok(:,i,j)), 'color', [0,0,0,0.2], ...
             'HandleVisibility', 'off');
    end
end
set(gca,'ColorOrderIndex',1)
plot(frf_iff.f, abs(G_dL_J_cok(:,1,1)), ...
     'DisplayName', '$D_x/\tilde{\mathcal{F}}_x$');
plot(frf_iff.f, abs(G_dL_J_cok(:,2,2)), ...
     'DisplayName', '$D_y/\tilde{\mathcal{F}}_y$');
plot(frf_iff.f, abs(G_dL_J_cok(:,3,3)), ...
     'DisplayName', '$D_z/\tilde{\mathcal{F}}_z$');
plot(frf_iff.f, abs(G_dL_J_cok(:,4,4)), ...
     'DisplayName', '$R_x/\tilde{\mathcal{M}}_x$');
plot(frf_iff.f, abs(G_dL_J_cok(:,5,5)), ...
     'DisplayName', '$R_y/\tilde{\mathcal{M}}_y$');
plot(frf_iff.f, abs(G_dL_J_cok(:,6,6)), ...
     'DisplayName', '$R_z/\tilde{\mathcal{M}}_z$');
plot(frf_iff.f, abs(G_dL_J_cok(:,1,2)), 'color', [0,0,0,0.2], ...
     'DisplayName', 'Coupling');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude'); set(gca, 'XTickLabel',[]);
ylim([1e-3, 1e1]);
legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 2);

ax2 = nexttile;
hold on;
for i =1:6
    plot(frf_iff.f, 180/pi*angle(G_dL_J_cok(:,i,i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([10, 1e3]);
#+end_src

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

#+name: fig:bode_plot_hac_iff_plant_jacobian_cok
#+caption: Bode plot of the decoupled plant using the Jacobian evaluated at the Center of Stiffness
#+RESULTS:
[[file:figs/bode_plot_hac_iff_plant_jacobian_cok.png]]

**** SISO Controller Design
As the diagonal elements of the plant are not equal, several SISO controllers are designed and then combined to form a diagonal controller.
All the diagonal terms of the controller consists of:
- A double integrator to have high gain at low frequency
- A lead around the crossover frequency to increase stability margins
- Two second order low pass filters above the crossover frequency to increase the robustness to high frequency modes

#+begin_src matlab :exports none
%% Controller Ry,Rz

% Wanted crossover frequency
wc_Rxy = 2*pi*80;

% Lead
a  = 8.0;  % Amount of phase lead / width of the phase lead / high frequency gain
wc = wc_Rxy; % Frequency with the maximum phase lead [rad/s]
Kd_lead = (1 + s/(wc/sqrt(a)))/(1 + s/(wc*sqrt(a)))/sqrt(a);

% Integrator
w0_int = wc_Rxy/2; % [rad/s]
xi_int = 0.3;

Kd_int = (1 + 2*xi_int/w0_int*s + s^2/w0_int^2)/(s^2/w0_int^2);

% Low Pass Filter (High frequency robustness)
w0_lpf = wc_Rxy*2; % Cut-off frequency [rad/s]
xi_lpf = 0.6; % Damping Ratio

Kd_lpf = 1/(1 + 2*xi_lpf/w0_lpf*s + s^2/w0_lpf^2);

w0_lpf_b = wc_Rxy*4; % Cut-off frequency [rad/s]
xi_lpf_b = 0.7; % Damping Ratio

Kd_lpf_b = 1/(1 + 2*xi_lpf_b/w0_lpf_b*s + s^2/w0_lpf_b^2);

% Unity Gain frequency
[~, i_80] = min(abs(frf_iff.f - wc_Rxy/2/pi));

% Combination of all the elements
Kd_Rxy = ...
     -1/abs(G_dL_J_cok(i_80,4,4)) * ...
     Kd_lead/abs(evalfr(Kd_lead, 1j*wc_Rxy)) * ... % Lead (gain of 1 at wc)
     Kd_int /abs(evalfr(Kd_int,  1j*wc_Rxy)) * ...
     Kd_lpf_b/abs(evalfr(Kd_lpf_b, 1j*wc_Rxy)) * ...
     Kd_lpf /abs(evalfr(Kd_lpf,  1j*wc_Rxy));      % Low Pass Filter
#+end_src

#+begin_src matlab :exports none
%% Controller Dx,Dy,Rz

% Wanted crossover frequency
wc_Dxy = 2*pi*100;

% Lead
a  = 8.0;  % Amount of phase lead / width of the phase lead / high frequency gain
wc = wc_Dxy; % Frequency with the maximum phase lead [rad/s]
Kd_lead = (1 + s/(wc/sqrt(a)))/(1 + s/(wc*sqrt(a)))/sqrt(a);

% Integrator
w0_int = wc_Dxy/2; % [rad/s]
xi_int = 0.3;

Kd_int = (1 + 2*xi_int/w0_int*s + s^2/w0_int^2)/(s^2/w0_int^2);

% Low Pass Filter (High frequency robustness)
w0_lpf = wc_Dxy*2; % Cut-off frequency [rad/s]
xi_lpf = 0.6; % Damping Ratio

Kd_lpf = 1/(1 + 2*xi_lpf/w0_lpf*s + s^2/w0_lpf^2);

w0_lpf_b = wc_Dxy*4; % Cut-off frequency [rad/s]
xi_lpf_b = 0.7; % Damping Ratio

Kd_lpf_b = 1/(1 + 2*xi_lpf_b/w0_lpf_b*s + s^2/w0_lpf_b^2);

% Unity Gain frequency
[~, i_100] = min(abs(frf_iff.f - wc_Dxy/2/pi));

% Combination of all the elements
Kd_Dyx_Rz = ...
     -1/abs(G_dL_J_cok(i_100,1,1)) * ...
     Kd_int /abs(evalfr(Kd_int,  1j*wc_Dxy)) * ... % Integrator
     Kd_lead/abs(evalfr(Kd_lead, 1j*wc_Dxy)) * ... % Lead (gain of 1 at wc)
     Kd_lpf_b/abs(evalfr(Kd_lpf_b, 1j*wc_Dxy)) * ... % Lead (gain of 1 at wc)
     Kd_lpf /abs(evalfr(Kd_lpf,  1j*wc_Dxy));      % Low Pass Filter
#+end_src

#+begin_src matlab :exports none
%% Controller Dz

% Wanted crossover frequency
wc_Dz = 2*pi*100;

% Lead
a  = 8.0;  % Amount of phase lead / width of the phase lead / high frequency gain
wc = wc_Dz; % Frequency with the maximum phase lead [rad/s]
Kd_lead = (1 + s/(wc/sqrt(a)))/(1 + s/(wc*sqrt(a)))/sqrt(a);

% Integrator
w0_int = wc_Dz/2; % [rad/s]
xi_int = 0.3;

Kd_int = (1 + 2*xi_int/w0_int*s + s^2/w0_int^2)/(s^2/w0_int^2);

% Low Pass Filter (High frequency robustness)
w0_lpf = wc_Dz*2; % Cut-off frequency [rad/s]
xi_lpf = 0.6; % Damping Ratio

Kd_lpf = 1/(1 + 2*xi_lpf/w0_lpf*s + s^2/w0_lpf^2);

w0_lpf_b = wc_Dz*4; % Cut-off frequency [rad/s]
xi_lpf_b = 0.7; % Damping Ratio

Kd_lpf_b = 1/(1 + 2*xi_lpf_b/w0_lpf_b*s + s^2/w0_lpf_b^2);

% Unity Gain frequency
[~, i_100] = min(abs(frf_iff.f - wc_Dz/2/pi));

% Combination of all the elements
Kd_Dz = ...
     -1/abs(G_dL_J_cok(i_100,3,3)) * ...
     Kd_int /abs(evalfr(Kd_int,  1j*wc_Dz)) * ... % Integrator
     Kd_lead/abs(evalfr(Kd_lead, 1j*wc_Dz)) * ... % Lead (gain of 1 at wc)
     Kd_lpf_b/abs(evalfr(Kd_lpf_b, 1j*wc_Dz)) * ... % Lead (gain of 1 at wc)
     Kd_lpf /abs(evalfr(Kd_lpf,  1j*wc_Dz));      % Low Pass Filter
#+end_src

#+begin_src matlab :exports none
%% Diagonal Controller
Kd_diag = blkdiag(Kd_Dyx_Rz, Kd_Dyx_Rz, Kd_Dz, Kd_Rxy, Kd_Rxy, Kd_Dyx_Rz);
#+end_src

**** Obtained Loop Gain
#+begin_src matlab :exports none
%% Experimental Loop Gain
Lmimo = permute(pagemtimes(permute(G_dL_J_cok, [2,3,1]), squeeze(freqresp(Kd_diag, frf_iff.f, 'Hz'))), [3,1,2]);
#+end_src

#+begin_src matlab :exports none
%% Bode plot of the experimental Loop Gain
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:6
    plot(frf_iff.f, abs(Lmimo(:,i,i)), '-');
end
for i = 1:5
    for j = i+1:6
        plot(frf_iff.f, abs(squeeze(Lmimo(:,i,j))), 'color', [0,0,0,0.2]);
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Loop Gain'); set(gca, 'XTickLabel',[]);
ylim([1e-3, 1e+3]);

ax2 = nexttile;
hold on;
for i = 1:6
    plot(frf_iff.f, 180/pi*angle(Lmimo(:,i,i)), '-');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:45:360);
ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([1, 2e3]);
#+end_src

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

#+name: fig:bode_plot_hac_iff_loop_gain_jacobian_cok
#+caption: Bode plot of the Loop Gain when using the Jacobian evaluated at the Center of Stiffness to decouple the system
#+RESULTS:
[[file:figs/bode_plot_hac_iff_loop_gain_jacobian_cok.png]]

#+begin_src matlab
%% Controller to be implemented
Kd = inv(J_cok')*input_normalize*ss(Kd_diag)*inv(Js_cok);
#+end_src

**** Verification of the Stability
Now the stability of the feedback loop is verified using the generalized Nyquist criteria.

#+begin_src matlab :exports none
%% Compute the Eigenvalues of the loop gain
Ldet = zeros(3, 6, length(frf_iff.f));

for i_mass = 1:3
    % Loop gain
    Lmimo = pagemtimes(permute(frf_iff.G_dL{i_mass}, [2,3,1]),squeeze(freqresp(Kd, frf_iff.f, 'Hz')));
    for i_f = 2:length(frf_iff.f)
        Ldet(i,:, i_f) = eig(squeeze(Lmimo(:,:,i_f)));
    end
end
#+end_src

#+begin_src matlab :exports none
%% Plot of the eigenvalues of L in the complex plane
figure;
hold on;
for i_mass = 2:3
    plot(real(squeeze(Ldet(i_mass, 1,:))), imag(squeeze(Ldet(i_mass, 1,:))), ...
         '.', 'color', colors(i_mass+1, :), ...
         'DisplayName', sprintf('%i masses', i_mass));
    plot(real(squeeze(Ldet(i_mass, 1,:))), -imag(squeeze(Ldet(i_mass, 1,:))), ...
         '.', 'color', colors(i_mass+1, :), ...
         'HandleVisibility', 'off');
    for i = 1:6
        plot(real(squeeze(Ldet(i_mass, i,:))), imag(squeeze(Ldet(i_mass, i,:))), ...
             '.', 'color', colors(i_mass+1, :), ...
             'HandleVisibility', 'off');
        plot(real(squeeze(Ldet(i_mass, i,:))), -imag(squeeze(Ldet(i_mass, i,:))), ...
             '.', 'color', colors(i_mass+1, :), ...
             'HandleVisibility', 'off');
    end
end
plot(-1, 0, 'kx', 'HandleVisibility', 'off');
hold off;
set(gca, 'XScale', 'lin'); set(gca, 'YScale', 'lin');
xlabel('Real'); ylabel('Imag');
legend('location', 'southeast');
xlim([-3, 1]); ylim([-2, 2]);
#+end_src

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

#+name: fig:loci_hac_iff_loop_gain_jacobian_cok
#+caption: Loci of $L(j\omega)$ in the complex plane.
#+RESULTS:
[[file:figs/loci_hac_iff_loop_gain_jacobian_cok.png]]

**** Save for further analysis
#+begin_src matlab :exports none :tangle no
save('matlab/mat/Khac_iff_struts_jacobian_cok.mat', 'Kd')
#+end_src

#+begin_src matlab :eval no
save('mat/Khac_iff_struts_jacobian_cok.mat', 'Kd')
#+end_src

*** Using Singular Value Decomposition
**** Decoupled Plant
#+begin_src matlab
G_nom = frf_iff.G_dL{2}; % Nominal Plant
#+end_src

#+begin_src matlab :exports none
%% Take complex matrix corresponding to the plant at 100Hz
wc = 100; % Wanted crossover frequency [Hz]
[~, i_wc] = min(abs(frf_iff.f - wc)); % Indice corresponding to wc

V = squeeze(G_nom(i_wc,:,:));

%% Real approximation of G(100Hz)
D = pinv(real(V'*V));
H1 = pinv(D*real(V'*diag(exp(1j*angle(diag(V*D*V.'))/2))));

%% Singular Value Decomposition
[U,S,V] = svd(H1);

%% Compute the decoupled plant using SVD
G_dL_svd = zeros(size(G_nom));
for i = 1:length(frf_iff.f)
    G_dL_svd(i,:,:) = inv(U)*squeeze(G_nom(i,:,:))*inv(V');
end
#+end_src

#+begin_src matlab :exports none
%% Bode plot of the decoupled plant using SVD
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:5
    for j = i+1:6
        plot(frf_iff.f, abs(G_dL_svd(:,i,j)), 'color', [0,0,0,0.2], ...
             'HandleVisibility', 'off');
    end
end
set(gca,'ColorOrderIndex',1);
for i = 1:6
    plot(frf_iff.f, abs(G_dL_svd(:,i,i)), ...
         'DisplayName', sprintf('$y_%i/u_%i$', i, i));
end
plot(frf_iff.f, abs(G_dL_svd(:,1,2)), 'color', [0,0,0,0.2], ...
     'DisplayName', 'Coupling');
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude'); set(gca, 'XTickLabel',[]);
ylim([1e-9, 1e-4]);
legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 2);

ax2 = nexttile;
hold on;
for i =1:6
    plot(frf_iff.f, 180/pi*angle(G_dL_svd(:,i,i)));
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:90:360);
ylim([-180, 180]);

linkaxes([ax1,ax2],'x');
xlim([10, 1e3]);
#+end_src

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

#+name: fig:bode_plot_hac_iff_plant_svd
#+caption: Bode plot of the decoupled plant using the SVD
#+RESULTS:
[[file:figs/bode_plot_hac_iff_plant_svd.png]]

**** Controller Design
#+begin_src matlab :exports none
%% Lead
a  = 6.0;  % Amount of phase lead / width of the phase lead / high frequency gain
wc = 2*pi*100; % Frequency with the maximum phase lead [rad/s]
Kd_lead = (1 + s/(wc/sqrt(a)))/(1 + s/(wc*sqrt(a)))/sqrt(a);

%% Integrator
Kd_int = ((2*pi*50 + s)/(2*pi*0.1 + s))^2;

%% Low Pass Filter (High frequency robustness)
w0_lpf = 2*pi*200; % Cut-off frequency [rad/s]
xi_lpf = 0.3; % Damping Ratio

Kd_lpf = 1/(1 + 2*xi_lpf/w0_lpf*s + s^2/w0_lpf^2);

%% Normalize Gain
Kd_norm = diag(1./abs(diag(squeeze(G_dL_svd(i_100,:,:)))));

%% Diagonal Control
Kd_diag = ...
     Kd_norm  * ... % Normalize gain at 100Hz
     Kd_int /abs(evalfr(Kd_int,  1j*2*pi*100)) * ... % Integrator
     Kd_lead/abs(evalfr(Kd_lead, 1j*2*pi*100)) * ... % Lead (gain of 1 at wc)
     Kd_lpf /abs(evalfr(Kd_lpf,  1j*2*pi*100));      % Low Pass Filter
#+end_src

#+begin_src matlab :exports none
%% MIMO Controller
Kd = -inv(V') * ... % Output decoupling
      ss(Kd_diag) * ...
      inv(U); % Input decoupling
#+end_src

**** Loop Gain
#+begin_src matlab :exports none
%% Experimental Loop Gain
Lmimo = permute(pagemtimes(permute(G_nom, [2,3,1]),squeeze(freqresp(Kd, frf_iff.f, 'Hz'))), [3,1,2]);
#+end_src

#+begin_src matlab :exports none
%% Loop gain when using SVD
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:6
    plot(frf_iff.f, abs(Lmimo(:,i,i)), '-');
end
for i = 1:5
    for j = i+1:6
        plot(frf_iff.f, abs(squeeze(Lmimo(:,i,j))), 'color', [0,0,0,0.2]);
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Loop Gain'); set(gca, 'XTickLabel',[]);
ylim([1e-3, 1e+3]);

ax2 = nexttile;
hold on;
for i = 1:6
    plot(frf_iff.f, 180/pi*angle(Lmimo(:,i,i)), '-');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:30:360);
ylim([-180, 0]);

linkaxes([ax1,ax2],'x');
xlim([1, 2e3]);
#+end_src

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

#+name: fig:bode_plot_hac_iff_loop_gain_svd
#+caption: Bode plot of Loop Gain when using the SVD
#+RESULTS:
[[file:figs/bode_plot_hac_iff_loop_gain_svd.png]]

**** Stability Verification
#+begin_src matlab
%% Compute the Eigenvalues of the loop gain
Ldet = zeros(3, 6, length(frf_iff.f));

for i = 1:3
    Lmimo = pagemtimes(permute(frf_iff.G_dL{i}, [2,3,1]),squeeze(freqresp(Kd, frf_iff.f, 'Hz')));
    for i_f = 2:length(frf_iff.f)
        Ldet(i,:, i_f) = eig(squeeze(Lmimo(:,:,i_f)));
    end
end
#+end_src

#+begin_src matlab :exports none
%% Plot of the eigenvalues of L in the complex plane
figure;
hold on;
for i_mass = 2:3
    plot(real(squeeze(Ldet(i_mass, 1,:))), imag(squeeze(Ldet(i_mass, 1,:))), ...
         '.', 'color', colors(i_mass+1, :), ...
         'DisplayName', sprintf('%i masses', i_mass));
    plot(real(squeeze(Ldet(i_mass, 1,:))), -imag(squeeze(Ldet(i_mass, 1,:))), ...
         '.', 'color', colors(i_mass+1, :), ...
         'HandleVisibility', 'off');
    for i = 1:6
        plot(real(squeeze(Ldet(i_mass, i,:))), imag(squeeze(Ldet(i_mass, i,:))), ...
             '.', 'color', colors(i_mass+1, :), ...
             'HandleVisibility', 'off');
        plot(real(squeeze(Ldet(i_mass, i,:))), -imag(squeeze(Ldet(i_mass, i,:))), ...
             '.', 'color', colors(i_mass+1, :), ...
             'HandleVisibility', 'off');
    end
end
plot(-1, 0, 'kx', 'HandleVisibility', 'off');
hold off;
set(gca, 'XScale', 'lin'); set(gca, 'YScale', 'lin');
xlabel('Real'); ylabel('Imag');
legend('location', 'southeast');
xlim([-3, 1]); ylim([-2, 2]);
#+end_src

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

#+name: fig:loci_hac_iff_loop_gain_svd
#+caption: Locis of $L(j\omega)$ in the complex plane.
#+RESULTS:
[[file:figs/loci_hac_iff_loop_gain_svd.png]]

**** Save for further analysis
#+begin_src matlab :exports none :tangle no
save('matlab/mat/Khac_iff_struts_svd.mat', 'Kd')
#+end_src

#+begin_src matlab :eval no
save('mat/Khac_iff_struts_svd.mat', 'Kd')
#+end_src

*** Using (diagonal) Dynamical Inverse                            :noexport:
**** Decoupled Plant
#+begin_src matlab
G_nom = frf_iff.G_dL{2}; % Nominal Plant
G_model = sim_iff.G_dL{2}; % Model of the Plant
#+end_src

#+begin_src matlab :exports none
%% Simplified model of the diagonal term
balred_opts = balredOptions('FreqIntervals', 2*pi*[0, 1000], 'StateElimMethod', 'Truncate');

G_red = balred(G_model(1,1), 8, balred_opts);
G_red.outputdelay = 0; % necessary for further inversion
#+end_src

#+begin_src matlab
%% Inverse
G_inv = inv(G_red);
[G_z, G_p, G_g] = zpkdata(G_inv);
p_uns = real(G_p{1}) > 0;
G_p{1}(p_uns) = -G_p{1}(p_uns);
G_inv_stable = zpk(G_z, G_p, G_g);
#+end_src

#+begin_src matlab :exports none
%% "Uncertainty" of inversed plant
freqs = logspace(0,3,1000);

figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i_mass = i_masses
    for i = 1
        plot(freqs, abs(squeeze(freqresp(G_inv_stable*sim_iff.G_dL{i_mass+1}(i,i), freqs, 'Hz'))), '-', 'color', colors(i_mass+1, :), ...
             'DisplayName', sprintf('$d\\mathcal{L}_i/u^\\prime_i$ - %i', i_mass));
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude'); set(gca, 'XTickLabel',[]);
ylim([1e-1, 1e1]);
legend('location', 'southwest', 'FontSize', 8, 'NumColumns', 4);

ax2 = nexttile;
hold on;
for i_mass = i_masses
    for i = 1
        plot(freqs, 180/pi*angle(squeeze(freqresp(G_inv_stable*sim_iff.G_dL{i_mass+1}(1,1), freqs, 'Hz'))), '-', 'color', colors(i_mass+1, :));
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:15:360);
ylim([-45, 45]);

linkaxes([ax1,ax2],'x');
xlim([freqs(1), freqs(end)]);
#+end_src

**** Controller Design
#+begin_src matlab :exports none
% Wanted crossover frequency
wc = 2*pi*80;
[~, i_wc] = min(abs(frf_iff.f - wc/2/pi));

%% Lead
a  = 20.0;  % Amount of phase lead / width of the phase lead / high frequency gain
Kd_lead = (1 + s/(wc/sqrt(a)))/(1 + s/(wc*sqrt(a)))/sqrt(a);

%% Integrator
Kd_int = ((wc)/(2*pi*0.2 + s))^2;

%% Low Pass Filter (High frequency robustness)
w0_lpf = 2*wc; % Cut-off frequency [rad/s]
xi_lpf = 0.3; % Damping Ratio

Kd_lpf = 1/(1 + 2*xi_lpf/w0_lpf*s + s^2/w0_lpf^2);

w0_lpf_b = wc*4; % Cut-off frequency [rad/s]
xi_lpf_b = 0.7; % Damping Ratio

Kd_lpf_b = 1/(1 + 2*xi_lpf_b/w0_lpf_b*s + s^2/w0_lpf_b^2);

%% Normalize Gain
Kd_norm = diag(1./abs(diag(squeeze(G_dL_svd(i_wc,:,:)))));

%% Diagonal Control
Kd_diag = ...
     G_inv_stable  * ... % Normalize gain at 100Hz
     Kd_int /abs(evalfr(Kd_int,    1j*wc)) * ... % Integrator
     Kd_lead/abs(evalfr(Kd_lead,   1j*wc)) * ... % Lead (gain of 1 at wc)
     Kd_lpf /abs(evalfr(Kd_lpf,    1j*wc));      % Low Pass Filter
#+end_src

#+begin_src matlab :exports none
Kd = ss(Kd_diag)*eye(6);
#+end_src

**** Loop Gain
#+begin_src matlab :exports none
%% Experimental Loop Gain
Lmimo = permute(pagemtimes(permute(G_nom, [2,3,1]),squeeze(freqresp(Kd, frf_iff.f, 'Hz'))), [3,1,2]);
#+end_src

#+begin_src matlab :exports none
%% Loop gain when using SVD
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:6
    plot(frf_iff.f, abs(Lmimo(:,i,i)), '-');
end
for i = 1:5
    for j = i+1:6
        plot(frf_iff.f, abs(squeeze(Lmimo(:,i,j))), 'color', [0,0,0,0.2]);
    end
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Loop Gain'); set(gca, 'XTickLabel',[]);
ylim([1e-3, 1e+3]);

ax2 = nexttile;
hold on;
for i = 1:6
    plot(frf_iff.f, 180/pi*angle(Lmimo(:,i,i)), '-');
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
xlabel('Frequency [Hz]'); ylabel('Phase [deg]');
hold off;
yticks(-360:30:360);
ylim([-180, 0]);

linkaxes([ax1,ax2],'x');
xlim([1, 2e3]);
#+end_src

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

#+name: fig:bode_plot_hac_iff_loop_gain_diag_inverse
#+caption: Bode plot of Loop Gain when using the Diagonal inversion
#+RESULTS:
[[file:figs/bode_plot_hac_iff_loop_gain_diag_inverse.png]]

**** Stability Verification
MIMO Nyquist with eigenvalues
#+begin_src matlab
%% Compute the Eigenvalues of the loop gain
Ldet = zeros(3, 6, length(frf_iff.f));

for i = 1:3
    Lmimo = pagemtimes(permute(frf_iff.G_dL{i}, [2,3,1]),squeeze(freqresp(Kd, frf_iff.f, 'Hz')));
    for i_f = 2:length(frf_iff.f)
        Ldet(i,:, i_f) = eig(squeeze(Lmimo(:,:,i_f)));
    end
end
#+end_src

#+begin_src matlab :exports none
%% Plot of the eigenvalues of L in the complex plane
figure;
hold on;
for i_mass = 2:3
    plot(real(squeeze(Ldet(i_mass, 1,:))), imag(squeeze(Ldet(i_mass, 1,:))), ...
         '.', 'color', colors(i_mass+1, :), ...
         'DisplayName', sprintf('%i masses', i_mass));
    plot(real(squeeze(Ldet(i_mass, 1,:))), -imag(squeeze(Ldet(i_mass, 1,:))), ...
         '.', 'color', colors(i_mass+1, :), ...
         'HandleVisibility', 'off');
    for i = 1:6
        plot(real(squeeze(Ldet(i_mass, i,:))), imag(squeeze(Ldet(i_mass, i,:))), ...
             '.', 'color', colors(i_mass+1, :), ...
             'HandleVisibility', 'off');
        plot(real(squeeze(Ldet(i_mass, i,:))), -imag(squeeze(Ldet(i_mass, i,:))), ...
             '.', 'color', colors(i_mass+1, :), ...
             'HandleVisibility', 'off');
    end
end
plot(-1, 0, 'kx', 'HandleVisibility', 'off');
hold off;
set(gca, 'XScale', 'lin'); set(gca, 'YScale', 'lin');
xlabel('Real'); ylabel('Imag');
legend('location', 'southeast');
xlim([-3, 1]); ylim([-2, 2]);
#+end_src

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

#+name: fig:loci_hac_iff_loop_gain_diag_inverse
#+caption: Locis of $L(j\omega)$ in the complex plane.
#+RESULTS:
[[file:figs/loci_hac_iff_loop_gain_diag_inverse.png]]

#+begin_important
Even though the loop gain seems to be fine, the closed-loop system is unstable.
This might be due to the fact that there is large interaction in the plant.
We could look at the RGA-number to verify that.
#+end_important

**** Save for further use
#+begin_src matlab :exports none :tangle no
save('matlab/mat/Khac_iff_struts_diag_inverse.mat', 'Kd')
#+end_src

#+begin_src matlab :eval no
save('mat/Khac_iff_struts_diag_inverse.mat', 'Kd')
#+end_src

*** Closed Loop Stability (Model)                                 :noexport:
Verify stability using Simscape model
#+begin_src matlab
%% Initialize the Simscape model in closed loop
n_hexapod = initializeNanoHexapodFinal('flex_bot_type', '2dof', ...
                                       'flex_top_type', '3dof', ...
                                       'motion_sensor_type', 'plates', ...
                                       'actuator_type', '2dof', ...
                                       'controller_type', 'hac-iff-struts');
#+end_src

#+begin_src matlab
%% IFF Controller
Kiff = -g_opt*Kiff_g1*eye(6);
Khac_iff_struts = Kd*eye(6);
#+end_src

#+begin_src matlab
%% Identify the (damped) transfer function from u to dLm for different values of the IFF gain
clear io; io_i = 1;
io(io_i) = linio([mdl, '/du'],  1, 'openinput');  io_i = io_i + 1; % Actuator Inputs
io(io_i) = linio([mdl, '/dL'], 1, 'openoutput'); io_i = io_i + 1; % Plate Displacement (encoder)
#+end_src

#+begin_src matlab
GG_cl = {};

for i = i_masses
    payload.type = i;
    GG_cl(i+1) = {exp(-s*Ts)*linearize(mdl, io, 0.0, options)};
end
#+end_src

#+begin_src matlab
for i = i_masses
    isstable(GG_cl{i+1})
end
#+end_src

MIMO Nyquist
#+begin_src matlab
Kdm = Kd*eye(6);

Ldet = zeros(3, length(fb(i_lim)));

for i = 1:3
    Lmimo = pagemtimes(permute(G_damp_m{i}(i_lim,:,:), [2,3,1]),squeeze(freqresp(Kdm, fb(i_lim), 'Hz')));
    Ldet(i,:) = arrayfun(@(t) det(eye(6) + squeeze(Lmimo(:,:,t))), 1:size(Lmimo,3));
end
#+end_src

#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
figure;
hold on;
for i_mass = 3
    for i = 1
        plot(real(Ldet(i_mass,:)), imag(Ldet(i_mass,:)), ...
             '-', 'color', colors(i_mass+1, :));
    end
end
hold off;
set(gca, 'XScale', 'lin'); set(gca, 'YScale', 'lin');
xlabel('Real'); ylabel('Imag');
xlim([-10, 1]); ylim([-4, 4]);
#+end_src

MIMO Nyquist with eigenvalues
#+begin_src matlab
Kdm = Kd*eye(6);

Ldet = zeros(3, 6, length(fb(i_lim)));

for i = 1:3
    Lmimo = pagemtimes(permute(G_damp_m{i}(i_lim,:,:), [2,3,1]),squeeze(freqresp(Kdm, fb(i_lim), 'Hz')));
    for i_f = 1:length(fb(i_lim))
        Ldet(i,:, i_f) = eig(squeeze(Lmimo(:,:,i_f)));
    end
end
#+end_src

#+begin_src matlab :exports none
%% Bode plot for the transfer function from u to dLm
figure;
hold on;
for i_mass = 1
    for i = 1:6
        plot(real(squeeze(Ldet(i_mass, i,:))), imag(squeeze(Ldet(i_mass, i,:))), ...
             '-', 'color', colors(i_mass+1, :));
    end
end
hold off;
set(gca, 'XScale', 'lin'); set(gca, 'YScale', 'lin');
xlabel('Real'); ylabel('Imag');
xlim([-10, 1]); ylim([-4, 2]);
#+end_src


* Feedforward Control                                               :noexport:
<<sec:feedforward>>

** Introduction                                                      :ignore:

#+begin_src latex :file control_architecture_iff_feedforward.pdf
\begin{tikzpicture}
  % Blocs
  \node[block={3.0cm}{3.0cm}] (P) {Plant};
  \coordinate[] (inputF) at ($(P.south west)!0.5!(P.north west)$);
  \coordinate[] (outputF) at ($(P.south east)!0.8!(P.north east)$);
  \coordinate[] (outputX) at ($(P.south east)!0.5!(P.north east)$);
  \coordinate[] (outputL) at ($(P.south east)!0.2!(P.north east)$);

  \node[block, above=0.4 of P] (Kiff) {$\bm{K}_\text{IFF}$};
  \node[addb, left= of inputF] (addF) {};
  \node[block, left= of addF] (Kff) {$\bm{K}_{\mathcal{L},\text{ff}}$};
  \node[block, align=center, left= of Kff] (J) {Inverse\\Kinematics};

  % Connections and labels
  \draw[->] (outputF) -- ++(1, 0) node[below left]{$\bm{\tau}_m$};
  \draw[->] ($(outputF) + (0.6, 0)$)node[branch]{} |- (Kiff.east);
  \draw[->] (Kiff.west) -| (addF.north);
  \draw[->] (addF.east) -- (inputF) node[above left]{$\bm{u}$};

  \draw[->] (outputL) -- ++(1, 0) node[above left]{$d\bm{\mathcal{L}}$};
  \draw[->] (outputX) -- ++(1, 0) node[above left]{$\bm{\mathcal{X}}$};

  \draw[->] (Kff.east) -- (addF.west) node[above left]{$\bm{u}_{\text{ff}}$};
  \draw[->] (J.east) --   (Kff.west)  node[above left]{$\bm{r}_{d\mathcal{L}}$};
  \draw[<-] (J.west)node[above left]{$\bm{r}_{\mathcal{X}}$} -- ++(-1, 0);
\end{tikzpicture}
#+end_src

#+name: fig:control_architecture_iff_feedforward
#+caption: Feedforward control in the frame of the legs
#+RESULTS:
[[file:figs/control_architecture_iff_feedforward.png]]

Main problems:
- Non-linearity: Creep, Hysteresis
- Variability of the plant

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

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

#+begin_src matlab :tangle no
addpath('./matlab/mat/');
addpath('./matlab/src/');
addpath('./matlab/');
#+end_src

#+begin_src matlab :eval no
addpath('./mat/');
addpath('./src/');
#+end_src

#+begin_src matlab
load('damped_plant_enc_plates.mat', 'f', 'Ts', 'G_enc_iff_opt')
#+end_src

#+begin_src matlab :tangle no
%% Add all useful folders to the path
addpath('matlab/nass-simscape/matlab/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/nano_hexapod/')
addpath('matlab/nass-simscape/STEPS/png/')
addpath('matlab/nass-simscape/src/')
addpath('matlab/nass-simscape/mat/')
#+end_src

#+begin_src matlab :eval no
%% Add all useful folders to the path
addpath('nass-simscape/matlab/nano_hexapod/')
addpath('nass-simscape/STEPS/nano_hexapod/')
addpath('nass-simscape/STEPS/png/')
addpath('nass-simscape/src/')
addpath('nass-simscape/mat/')
#+end_src

#+begin_src matlab
%% Open Simulink Model
mdl = 'nano_hexapod_simscape';

options = linearizeOptions;
options.SampleTime = 0;

open(mdl)

Rx = zeros(1, 7);

colors = colororder;
#+end_src

** Simple Feedforward Controller
Let's estimate the mean DC gain for the damped plant (diagonal elements:)
#+begin_src matlab :results value replace :exports results :tangle no
mean(diag(abs(squeeze(mean(G_enc_iff_opt(f>2 & f<4,:,:))))))
#+end_src

#+RESULTS:
: 1.773e-05

The feedforward controller is then taken as the inverse of this gain (the minus sign is there manually added as it is "removed" by the =abs= function):
#+begin_src matlab
Kff_iff_L = -1/mean(diag(abs(squeeze(mean(G_enc_iff_opt(f>2 & f<4,:,:))))));
#+end_src

The open-loop gain (feedforward controller times the damped plant) is shown in Figure [[fig:open_loop_gain_feedforward_iff_struts]].

#+begin_src matlab :exports none
%% Bode plot of the transfer function from u to dLm for tested values of the IFF gain
figure;
tiledlayout(3, 1, 'TileSpacing', 'None', 'Padding', 'None');

ax1 = nexttile([2,1]);
hold on;
for i = 1:6
    set(gca,'ColorOrderIndex',1);
    plot(f, abs(Kff_iff_L*G_enc_iff_opt(:,i,i)), 'k-');
end

hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
ylabel('Amplitude [-]'); set(gca, 'XTickLabel',[]);
ylim([1e-2, 1e1]);

ax2 = nexttile;
hold on;
for i = 1:6
    set(gca,'ColorOrderIndex',1);
    plot(f, 180/pi*angle(Kff_iff_L*G_enc_iff_opt(:,i,i)), 'k-')
end
hold off;
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'lin');
ylabel('Phase [deg]'); xlabel('Frequency [Hz]');
ylim([-180, 180]);
yticks([-180, -90, 0, 90, 180]);

linkaxes([ax1,ax2],'x');
xlim([1, 2e3]);
#+end_src

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

#+name: fig:open_loop_gain_feedforward_iff_struts
#+caption: Diagonal elements of the "open loop gain"
#+RESULTS:
[[file:figs/open_loop_gain_feedforward_iff_struts.png]]

And save the feedforward controller for further use:
#+begin_src matlab
Kff_iff_L = zpk(Kff_iff_L)*eye(6);
#+end_src

#+begin_src matlab :tangle no
save('matlab/mat/feedforward_iff.mat', 'Kff_iff_L')
#+end_src

#+begin_src matlab :exports none :eval no
save('mat/feedforward_iff.mat', 'Kff_iff_L')
#+end_src

** Test with Simscape Model
#+begin_src matlab
load('reference_path.mat', 'Rx_yz');
#+end_src

** Feedback/Feedforward control in the frame of the struts
*** Introduction                                                    :ignore:

#+begin_src latex :file control_architecture_hac_iff_L_feedforward.pdf
\begin{tikzpicture}
  % Blocs
  \node[block={3.0cm}{3.0cm}] (P) {Plant};
  \coordinate[] (inputF) at ($(P.south west)!0.5!(P.north west)$);
  \coordinate[] (outputF) at ($(P.south east)!0.8!(P.north east)$);
  \coordinate[] (outputX) at ($(P.south east)!0.5!(P.north east)$);
  \coordinate[] (outputL) at ($(P.south east)!0.2!(P.north east)$);

  \node[block, above=0.4 of P] (Kiff) {$\bm{K}_\text{IFF}$};
  \node[addb, left= of inputF] (addF) {};
  \node[block, left= of addF] (K) {$\bm{K}_\mathcal{L}$};
  \node[block, above= of K] (Kff) {$\bm{K}_{\mathcal{L},\text{ff}}$};
  \node[addb, left= of K] (subr) {};
  \node[block, align=center, left= of subr] (J) {Inverse\\Kinematics};

  % Connections and labels
  \draw[->] (outputF) -- ++(1, 0) node[below left]{$\bm{\tau}_m$};
  \draw[->] ($(outputF) + (0.6, 0)$)node[branch]{} |- (Kiff.east);
  \draw[->] (Kiff.west) -| (addF.north);
  \draw[->] (addF.east) -- (inputF) node[above left]{$\bm{u}$};

  \draw[->] (outputL) -- ++(1, 0) node[above left]{$d\bm{\mathcal{L}}$};
  \draw[->] ($(outputL) + (0.6, 0)$)node[branch]{} -- ++(0, -1) -| (subr.south);
  \draw[->] (subr.east) -- (K.west) node[above left]{$\bm{\epsilon}_{d\mathcal{L}}$};
  \draw[->] (K.east) -- (addF.west) node[above left]{$\bm{u}^\prime$};

  \draw[->] (outputX) -- ++(1, 0) node[above left]{$\bm{\mathcal{X}}_n$};

  \draw[->] (J.east) -- (subr.west);
  \draw[->] ($(J.east) + (0.4, 0)$)node[branch]{} node[below]{$\bm{r}_{d\mathcal{L}}$} |- (Kff.west);
  \draw[->] (Kff.east) -- ++(0.5, 0) -- (addF.north west);

  \draw[<-] (J.west)node[above left]{$\bm{r}_{\mathcal{X}_n}$} -- ++(-1, 0);
\end{tikzpicture}
#+end_src

#+name: fig:control_architecture_hac_iff_L_feedforward
#+caption: Feedback/Feedforward control in the frame of the legs
#+RESULTS:
[[file:figs/control_architecture_hac_iff_L_feedforward.png]]



* Functions
** =generateXYZTrajectory=
:PROPERTIES:
:header-args:matlab+: :tangle matlab/src/generateXYZTrajectory.m
:header-args:matlab+: :comments none :mkdirp yes :eval no
:END:
<<sec:generateXYZTrajectory>>

*** Function description
:PROPERTIES:
:UNNUMBERED: t
:END:
#+begin_src matlab
function [ref] = generateXYZTrajectory(args)
% generateXYZTrajectory -
%
% Syntax: [ref] = generateXYZTrajectory(args)
%
% Inputs:
%    - args
%
% Outputs:
%    - ref - Reference Signal
#+end_src

*** Optional Parameters
:PROPERTIES:
:UNNUMBERED: t
:END:

#+begin_src matlab
arguments
    args.points double {mustBeNumeric} = zeros(2, 3) % [m]

    args.ti    (1,1) double {mustBeNumeric, mustBeNonnegative} = 1 % Time to go to first point and after last point [s]
    args.tw    (1,1) double {mustBeNumeric, mustBeNonnegative} = 0.5 % Time wait between each point [s]
    args.tm    (1,1) double {mustBeNumeric, mustBeNonnegative} = 1 % Motion time between points [s]

    args.Ts    (1,1) double {mustBeNumeric, mustBePositive} = 1e-3 % Sampling Time [s]
end
#+end_src

*** Initialize Time Vectors
:PROPERTIES:
:UNNUMBERED: t
:END:

#+begin_src matlab
time_i = 0:args.Ts:args.ti;
time_w = 0:args.Ts:args.tw;
time_m = 0:args.Ts:args.tm;
#+end_src

*** XYZ Trajectory
:PROPERTIES:
:UNNUMBERED: t
:END:

#+begin_src matlab
% Go to initial position
xyz = (args.points(1,:))'*(time_i/args.ti);

% Wait
xyz = [xyz, xyz(:,end).*ones(size(time_w))];

% Scans
for i = 2:size(args.points, 1)
    % Go to next point
    xyz = [xyz, xyz(:,end) + (args.points(i,:)' - xyz(:,end))*(time_m/args.tm)];
    % Wait a litle bit
    xyz = [xyz, xyz(:,end).*ones(size(time_w))];
end

% End motion
xyz = [xyz, xyz(:,end) - xyz(:,end)*(time_i/args.ti)];
#+end_src

*** Reference Signal
:PROPERTIES:
:UNNUMBERED: t
:END:

#+begin_src matlab
t = 0:args.Ts:args.Ts*(length(xyz) - 1);
#+end_src

#+begin_src matlab
ref = zeros(length(xyz), 7);

ref(:, 1) = t;
ref(:, 2:4) = xyz';
#+end_src

** =generateYZScanTrajectory=
:PROPERTIES:
:header-args:matlab+: :tangle matlab/src/generateYZScanTrajectory.m
:header-args:matlab+: :comments none :mkdirp yes :eval no
:END:
<<sec:generateYZScanTrajectory>>

*** Function description
:PROPERTIES:
:UNNUMBERED: t
:END:
#+begin_src matlab
function [ref] = generateYZScanTrajectory(args)
% generateYZScanTrajectory -
%
% Syntax: [ref] = generateYZScanTrajectory(args)
%
% Inputs:
%    - args
%
% Outputs:
%    - ref - Reference Signal
#+end_src

*** Optional Parameters
:PROPERTIES:
:UNNUMBERED: t
:END:

#+begin_src matlab
arguments
    args.y_tot (1,1) double {mustBeNumeric, mustBePositive} = 10e-6 % [m]
    args.z_tot (1,1) double {mustBeNumeric, mustBePositive} = 10e-6 % [m]

    args.n     (1,1) double {mustBeInteger, mustBePositive} = 10 % [-]

    args.Ts    (1,1) double {mustBeNumeric, mustBePositive} = 1e-4 % [s]

    args.ti    (1,1) double {mustBeNumeric, mustBeNonnegative} = 1 % [s]
    args.tw    (1,1) double {mustBeNumeric, mustBeNonnegative} = 1 % [s]
    args.ty    (1,1) double {mustBeNumeric, mustBeNonnegative} = 1 % [s]
    args.tz    (1,1) double {mustBeNumeric, mustBeNonnegative} = 1 % [s]
end
#+end_src

*** Initialize Time Vectors
:PROPERTIES:
:UNNUMBERED: t
:END:

#+begin_src matlab
time_i = 0:args.Ts:args.ti;
time_w = 0:args.Ts:args.tw;
time_y = 0:args.Ts:args.ty;
time_z = 0:args.Ts:args.tz;
#+end_src

*** Y and Z vectors
:PROPERTIES:
:UNNUMBERED: t
:END:

#+begin_src matlab
% Go to initial position
y = (time_i/args.ti)*(args.y_tot/2);

% Wait
y = [y, y(end)*ones(size(time_w))];

% Scans
for i = 1:args.n
    if mod(i,2) == 0
        y = [y, -(args.y_tot/2) + (time_y/args.ty)*args.y_tot];
    else
        y = [y,  (args.y_tot/2) - (time_y/args.ty)*args.y_tot];
    end

    if i < args.n
        y = [y, y(end)*ones(size(time_z))];
    end
end

% Wait a litle bit
y = [y, y(end)*ones(size(time_w))];

% End motion
y = [y, y(end) - y(end)*time_i/args.ti];
#+end_src

#+begin_src matlab
% Go to initial position
z = (time_i/args.ti)*(args.z_tot/2);

% Wait
z = [z, z(end)*ones(size(time_w))];

% Scans
for i = 1:args.n
    z = [z, z(end)*ones(size(time_y))];

    if i < args.n
        z = [z, z(end) - (time_z/args.tz)*args.z_tot/(args.n-1)];
    end
end

% Wait a litle bit
z = [z, z(end)*ones(size(time_w))];

% End motion
z = [z, z(end) - z(end)*time_i/args.ti];
#+end_src

*** Reference Signal
:PROPERTIES:
:UNNUMBERED: t
:END:

#+begin_src matlab
t = 0:args.Ts:args.Ts*(length(y) - 1);
#+end_src

#+begin_src matlab
ref = zeros(length(y), 7);

ref(:, 1) = t;
ref(:, 3) = y;
ref(:, 4) = z;
#+end_src

** =generateSpiralAngleTrajectory=
:PROPERTIES:
:header-args:matlab+: :tangle matlab/src/generateSpiralAngleTrajectory.m
:header-args:matlab+: :comments none :mkdirp yes :eval no
:END:
<<sec:generateSpiralAngleTrajectory>>

*** Function description
:PROPERTIES:
:UNNUMBERED: t
:END:
#+begin_src matlab
function [ref] = generateSpiralAngleTrajectory(args)
% generateSpiralAngleTrajectory -
%
% Syntax: [ref] = generateSpiralAngleTrajectory(args)
%
% Inputs:
%    - args
%
% Outputs:
%    - ref - Reference Signal
#+end_src

*** Optional Parameters
:PROPERTIES:
:UNNUMBERED: t
:END:

#+begin_src matlab
arguments
    args.R_tot  (1,1) double {mustBeNumeric, mustBePositive} = 10e-6 % [rad]
    args.n_turn (1,1) double {mustBeInteger, mustBePositive} = 5 % [-]
    args.Ts     (1,1) double {mustBeNumeric, mustBePositive} = 1e-3 % [s]
    args.t_turn (1,1) double {mustBeNumeric, mustBePositive} = 1 % [s]
    args.t_end  (1,1) double {mustBeNumeric, mustBePositive} = 1 % [s]
end
#+end_src

*** Initialize Time Vectors
:PROPERTIES:
:UNNUMBERED: t
:END:

#+begin_src matlab
time_s = 0:args.Ts:args.n_turn*args.t_turn;
time_e = 0:args.Ts:args.t_end;
#+end_src

*** Rx and Ry vectors
:PROPERTIES:
:UNNUMBERED: t
:END:

#+begin_src matlab
Rx = sin(2*pi*time_s/args.t_turn).*(args.R_tot*time_s/(args.n_turn*args.t_turn));
Ry = cos(2*pi*time_s/args.t_turn).*(args.R_tot*time_s/(args.n_turn*args.t_turn));
#+end_src

#+begin_src matlab
Rx = [Rx, 0*time_e];
Ry = [Ry, Ry(end) - Ry(end)*time_e/args.t_end];
#+end_src

*** Reference Signal
:PROPERTIES:
:UNNUMBERED: t
:END:

#+begin_src matlab
t = 0:args.Ts:args.Ts*(length(Rx) - 1);
#+end_src

#+begin_src matlab
ref = zeros(length(Rx), 7);

ref(:, 1) = t;
ref(:, 5) = Rx;
ref(:, 6) = Ry;
#+end_src

** =getTransformationMatrixAcc=
:PROPERTIES:
:header-args:matlab+: :tangle matlab/src/getTransformationMatrixAcc.m
:header-args:matlab+: :comments none :mkdirp yes :eval no
:END:
<<sec:getTransformationMatrixAcc>>

*** Function description
:PROPERTIES:
:UNNUMBERED: t
:END:
#+begin_src matlab
function [M] = getTransformationMatrixAcc(Opm, Osm)
% getTransformationMatrixAcc -
%
% Syntax: [M] = getTransformationMatrixAcc(Opm, Osm)
%
% Inputs:
%    - Opm - Nx3 (N = number of accelerometer measurements) X,Y,Z position of accelerometers
%    - Opm - Nx3 (N = number of accelerometer measurements) Unit vectors representing the accelerometer orientation
%
% Outputs:
%    - M - Transformation Matrix
#+end_src

*** Transformation matrix from motion of the solid body to accelerometer measurements
:PROPERTIES:
:UNNUMBERED: t
:END:

Let's try to estimate the x-y-z acceleration of any point of the solid body from the acceleration/angular acceleration of the solid body expressed in $\{O\}$.
For any point $p_i$ of the solid body (corresponding to an accelerometer), we can write:
\begin{equation}
\begin{bmatrix}
a_{i,x} \\ a_{i,y} \\ a_{i,z}
\end{bmatrix} = \begin{bmatrix}
\dot{v}_x \\ \dot{v}_y \\ \dot{v}_z
\end{bmatrix} + p_i \times \begin{bmatrix}
\dot{\omega}_x \\ \dot{\omega}_y \\ \dot{\omega}_z
\end{bmatrix}
\end{equation}

We can write the cross product as a matrix product using the skew-symmetric transformation:
\begin{equation}
\begin{bmatrix}
a_{i,x} \\ a_{i,y} \\ a_{i,z}
\end{bmatrix} = \begin{bmatrix}
\dot{v}_x \\ \dot{v}_y \\ \dot{v}_z
\end{bmatrix} + \underbrace{\begin{bmatrix}
  0       &  p_{i,z} & -p_{i,y} \\
 -p_{i,z} &  0       &  p_{i,x} \\
  p_{i,y} & -p_{i,x} &  0
\end{bmatrix}}_{P_{i,[\times]}} \cdot \begin{bmatrix}
\dot{\omega}_x \\ \dot{\omega}_y \\ \dot{\omega}_z
\end{bmatrix}
\end{equation}

If we now want to know the (scalar) acceleration $a_i$ of the point $p_i$ in the direction of the accelerometer direction $\hat{s}_i$, we can just project the 3d acceleration on $\hat{s}_i$:
\begin{equation}
a_i = \hat{s}_i^T \cdot \begin{bmatrix}
a_{i,x} \\ a_{i,y} \\ a_{i,z}
\end{bmatrix} = \hat{s}_i^T \cdot \begin{bmatrix}
\dot{v}_x \\ \dot{v}_y \\ \dot{v}_z
\end{bmatrix} + \left( \hat{s}_i^T \cdot P_{i,[\times]} \right) \cdot \begin{bmatrix}
\dot{\omega}_x \\ \dot{\omega}_y \\ \dot{\omega}_z
\end{bmatrix}
\end{equation}

Which is equivalent as a simple vector multiplication:
\begin{equation}
a_i = \begin{bmatrix}
\hat{s}_i^T & \hat{s}_i^T \cdot P_{i,[\times]}
\end{bmatrix}
\begin{bmatrix}
\dot{v}_x \\ \dot{v}_y \\ \dot{v}_z \\ \dot{\omega}_x \\ \dot{\omega}_y \\ \dot{\omega}_z
\end{bmatrix} = \begin{bmatrix}
\hat{s}_i^T & \hat{s}_i^T \cdot P_{i,[\times]}
\end{bmatrix} {}^O\vec{x}
\end{equation}

And finally we can combine the 6 (line) vectors for the 6 accelerometers to write that in a matrix form.
We obtain Eq. eqref:eq:M_matrix.
#+begin_important
The transformation from solid body acceleration ${}^O\vec{x}$ from sensor measured acceleration $\vec{a}$ is:
\begin{equation} \label{eq:M_matrix}
\vec{a} = \underbrace{\begin{bmatrix}
\hat{s}_1^T & \hat{s}_1^T \cdot P_{1,[\times]} \\
\vdots & \vdots \\
\hat{s}_6^T & \hat{s}_6^T \cdot P_{6,[\times]}
\end{bmatrix}}_{M} {}^O\vec{x}
\end{equation}

with $\hat{s}_i$ the unit vector representing the measured direction of the i'th accelerometer expressed in frame $\{O\}$ and $P_{i,[\times]}$ the skew-symmetric matrix representing the cross product of the position of the i'th accelerometer expressed in frame $\{O\}$.
#+end_important

Let's define such matrix using matlab:
#+begin_src matlab
M = zeros(length(Opm), 6);

for i = 1:length(Opm)
    Ri = [0,         Opm(3,i), -Opm(2,i);
         -Opm(3,i),  0,         Opm(1,i);
          Opm(2,i), -Opm(1,i),  0];
    M(i, 1:3) = Osm(:,i)';
    M(i, 4:6) = Osm(:,i)'*Ri;
end
#+end_src

#+begin_src matlab
end
#+end_src


** =getJacobianNanoHexapod=
:PROPERTIES:
:header-args:matlab+: :tangle matlab/src/getJacobianNanoHexapod.m
:header-args:matlab+: :comments none :mkdirp yes :eval no
:END:
<<sec:getJacobianNanoHexapod>>

*** Function description
:PROPERTIES:
:UNNUMBERED: t
:END:
#+begin_src matlab
function [J] = getJacobianNanoHexapod(Hbm)
% getJacobianNanoHexapod -
%
% Syntax: [J] = getJacobianNanoHexapod(Hbm)
%
% Inputs:
%    - Hbm - Height of {B} w.r.t. {M} [m]
%
% Outputs:
%    - J - Jacobian Matrix
#+end_src

*** Transformation matrix from motion of the solid body to accelerometer measurements
:PROPERTIES:
:UNNUMBERED: t
:END:

#+begin_src matlab
Fa = [[-86.05,  -74.78, 22.49],
      [ 86.05,  -74.78, 22.49],
      [ 107.79, -37.13, 22.49],
      [ 21.74,  111.91, 22.49],
      [-21.74,  111.91, 22.49],
      [-107.79, -37.13, 22.49]]'*1e-3; % Ai w.r.t. {F} [m]

Mb = [[-28.47, -106.25, -22.50],
      [ 28.47, -106.25, -22.50],
      [ 106.25, 28.47,  -22.50],
      [ 77.78,  77.78,  -22.50],
      [-77.78,  77.78,  -22.50],
      [-106.25, 28.47,  -22.50]]'*1e-3; % Bi w.r.t. {M} [m]

H = 95e-3; % Stewart platform height [m]
Fb = Mb + [0; 0; H]; % Bi w.r.t. {F} [m]

si = Fb - Fa;
si = si./vecnorm(si); % Normalize

Bb = Mb - [0; 0; Hbm];

J = [si', cross(Bb, si)'];
#+end_src

* Bibliography                                                        :ignore:
#+latex: \printbibliography