Continue analysis of optimal_stiffness

org/optimal_stiffness.org

@@ -22,7 +22,7 @@
 #+PROPERTY: header-args:matlab+ :exports both
 #+PROPERTY: header-args:matlab+ :eval no-export
 #+PROPERTY: header-args:matlab+ :output-dir figs
-#+PROPERTY: header-args:matlab+ :tangle no
+#+PROPERTY: header-args:matlab+ :tangle ../matlab/optimal_stiffness.m
 #+PROPERTY: header-args:matlab+ :mkdirp yes
 
 #+PROPERTY: header-args:shell  :eval no-export
@@ -73,6 +73,7 @@ The overall goal is to design a nano-hexapod that will allow the highest possibl
 #+end_src
 
 #+begin_src matlab
+  load('mat/conf_simulink.mat');
   open('nass_model.slx')
 #+end_src
 
@@ -89,20 +90,15 @@ We initialize all the stages with the default parameters.
   initializeMirror();
 #+end_src
 
-The worst case scenario is a rotation speed of 60rpm with a payload mass of 1Kg.
+The worst case scenario is a rotation speed of 60rpm with a payload mass of 10Kg.
 #+begin_src matlab
   initializeSample('mass', 10);
 #+end_src
 
 We don't include gravity nor disturbances in this model as it adds complexity to the simulations and does not alter the obtained dynamics.
 #+begin_src matlab
-  initializeSimscapeConfiguration('gravity', false);
+  initializeSimscapeConfiguration('gravity', true);
   initializeDisturbances('enable', false);
-#+end_src
-
-We set the controller type to Open-Loop, and we do not need to log any signal.
-#+begin_src matlab
-  initializeController('type', 'stabilizing');
   initializeLoggingConfiguration('log', 'none');
 #+end_src
 
@@ -121,20 +117,22 @@ We set the controller type to Open-Loop, and we do not need to log any signal.
 ** Identification when not rotating
 We set the range of stiffness that we want to use.
 #+begin_src matlab
-  Ks = logspace(3,9,7)
+  Ks = logspace(3,9,7); % [N/m]
 #+end_src
 
+We don't move any stage and no controller is used.
 #+begin_src matlab
   initializeReferences();
+  initializeController();
 #+end_src
 
-#+begin_src matlab
+#+begin_src matlab :exports none
   Gk_iff = {zeros(length(Ks))};
   Gk_dvf = {zeros(length(Ks))};
   Gk_err = {zeros(length(Ks))};
 #+end_src
 
-#+begin_src matlab
+#+begin_src matlab :exports none
   for i = 1:length(Ks)
     initializeNanoHexapod('k', Ks(i));
 
@@ -156,6 +154,7 @@ We set the range of stiffness that we want to use.
 #+end_src
 
 ** Identification when rotating at maximum speed
+We now set the reference path such that the Spindle is rotating at 60rpm and such that it is at the zero position at the time of the identification.
 #+begin_src matlab
   Rz_rpm = 60;
 
@@ -168,17 +167,20 @@ We set the range of stiffness that we want to use.
   t_sim = Rz.time(i_end); % Simulation time before identification [s]
 #+end_src
 
+We here use a decentralized controller that is used to stabilize the nano-hexapod until the identification is made.
+This controller virtually adds stiffness in each of the nano-hexapod leg.
 #+begin_src matlab
   k_sta = -1e8;
+  initializeController('type', 'stabilizing');
 #+end_src
 
-#+begin_src matlab
+#+begin_src matlab :exports none
   Gk_wz_iff = {zeros(length(Ks))};
   Gk_wz_dvf = {zeros(length(Ks))};
   Gk_wz_err = {zeros(length(Ks))};
 #+end_src
 
-#+begin_src matlab
+#+begin_src matlab :exports none
   for i = 1:length(Ks)
     initializeNanoHexapod('k', Ks(i));
 
@@ -199,13 +201,17 @@ We set the range of stiffness that we want to use.
   end
 #+end_src
 
-#+begin_src matlab
+#+begin_src matlab :exports none
   save('mat/optimal_stiffness_Gk_wz.mat', 'Ks', ...
        'Gk_iff',    'Gk_dvf',    'Gk_err', ...
        'Gk_wz_iff', 'Gk_wz_dvf', 'Gk_wz_err');
 #+end_src
 
-** Change of dynamics
+** TODO Change of dynamics
+- [ ] problem of dynamics at low frequency
+  Check if gravity is a problem
+  Think of a before way to identify the dynamics
+
 #+begin_src matlab :exports none
   load('mat/optimal_stiffness_Gk_wz.mat');
 #+end_src
@@ -397,11 +403,11 @@ Comparison of the coupling from $F_x$ to $D_y$ when rotating at 60rpm to the dir
 
 ** 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>>
+  <<matlab-dir>>
 #+end_src
 
 #+begin_src matlab :exports none :results silent :noweb yes
-<<matlab-init>>
+  <<matlab-init>>
 #+end_src
 
 #+begin_src matlab :tangle no
@@ -409,9 +415,337 @@ Comparison of the coupling from $F_x$ to $D_y$ when rotating at 60rpm to the dir
 #+end_src
 
 #+begin_src matlab
+  load('mat/conf_simulink.mat');
   open('nass_model.slx')
 #+end_src
 
+** Identification of the micro-station compliance
+We initialize all the stages with the default parameters.
+#+begin_src matlab
+  initializeGround();
+  initializeGranite();
+  initializeTy();
+  initializeRy();
+  initializeRz();
+  initializeMicroHexapod('type', 'compliance');
+#+end_src
+
+We put nothing on top of the micro-hexapod.
+#+begin_src matlab
+  initializeAxisc('type', 'none');
+  initializeMirror('type', 'none');
+  initializeNanoHexapod('type', 'none');
+  initializeSample('type', 'none');
+#+end_src
+
+#+begin_src matlab :exports none
+  initializeReferences();
+  initializeDisturbances();
+  initializeController();
+  initializeSimscapeConfiguration();
+  initializeLoggingConfiguration();
+#+end_src
+
+And we identify the dynamics from forces/torques applied on the micro-hexapod top platform to the motion of the micro-hexapod top platform at the same point.
+#+begin_src matlab :exports noone
+  %% Name of the Simulink File
+  mdl = 'nass_model';
+
+  %% Input/Output definition
+  clear io; io_i = 1;
+  io(io_i) = linio([mdl, '/Micro-Station/Micro Hexapod/Compliance/Fm'], 1, 'openinput');       io_i = io_i + 1; % Direct Forces/Torques applied on the micro-hexapod top platform
+  io(io_i) = linio([mdl, '/Micro-Station/Micro Hexapod/Compliance/Dm'], 1, 'output'); io_i = io_i + 1; % Absolute displacement of the top platform
+
+  %% Run the linearization
+  Gm = linearize(mdl, io, 0);
+  Gm.InputName  = {'Fmx', 'Fmy', 'Fmz', 'Mmx', 'Mmy', 'Mmz'};
+  Gm.OutputName = {'Dx', 'Dy', 'Dz', 'Drx', 'Dry', 'Drz'};
+#+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}$'};
+
+  freqs = logspace(1, 3, 1000);
+
+  figure;
+
+  hold on;
+  plot(freqs, abs(squeeze(freqresp(Gm(1, 1), freqs, 'Hz'))), 'k-', 'DisplayName', labels{1});
+  for i = 2:6
+    plot(freqs, abs(squeeze(freqresp(Gm(1, i), freqs, 'Hz'))), 'DisplayName', labels{i});
+  end
+  hold off;
+  set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
+  xlabel('Frequency [Hz]');
+  ylabel('Compliance');
+  legend('location', 'northwest');
+#+end_src
+
+** Identification of the dynamics with a rigid micro-station
+*** Initialization
+#+begin_src matlab :exports none
+  initializeReferences();
+  initializeDisturbances();
+  initializeController();
+  initializeSimscapeConfiguration();
+  initializeLoggingConfiguration();
+  initializeSimscapeConfiguration('gravity', false);
+#+end_src
+
+#+begin_src matlab :exports none
+  %% Name of the Simulink File
+  mdl = 'nass_model';
+
+  %% Input/Output definition
+  clear io; io_i = 1;
+  io(io_i) = linio([mdl, '/Controller'],     1, 'openinput');              io_i = io_i + 1;
+  io(io_i) = linio([mdl, '/Micro-Station'],  3, 'openoutput', [], 'Dnlm'); io_i = io_i + 1;
+  io(io_i) = linio([mdl, '/Micro-Station'],  3, 'openoutput', [], 'Fnlm'); io_i = io_i + 1;
+  io(io_i) = linio([mdl, '/Tracking Error'], 1, 'openoutput', [], 'En');   io_i = io_i + 1;
+#+end_src
+
+#+begin_src matlab
+  Ks = logspace(3,9,7); % [N/m]
+#+end_src
+
+#+begin_src matlab
+  initializeSample('type', 'rigid', 'mass', 20);
+#+end_src
+
+*** Rigid micro-station
+#+begin_src matlab
+  initializeGround('type', 'rigid');
+  initializeGranite('type', 'rigid');
+  initializeTy('type', 'rigid');
+  initializeRy('type', 'rigid');
+  initializeRz('type', 'rigid');
+  initializeMicroHexapod('type', 'rigid');
+
+  initializeAxisc('type', 'rigid');
+  initializeMirror('type', 'rigid');
+#+end_src
+
+#+begin_src matlab :exports none
+  Gmr_iff = {zeros(length(Ks))};
+  Gmr_dvf = {zeros(length(Ks))};
+  Gmr_err = {zeros(length(Ks))};
+#+end_src
+
+#+begin_src matlab :exports none
+  for i = 1:length(Ks)
+    initializeNanoHexapod('k', Ks(i));
+
+    G = linearize(mdl, io);
+    G.InputName  = {'Fnl1', 'Fnl2', 'Fnl3', 'Fnl4', 'Fnl5', 'Fnl6'};
+    G.OutputName = {'Dnlm1', 'Dnlm2', 'Dnlm3', 'Dnlm4', 'Dnlm5', 'Dnlm6', ...
+                    'Fnlm1', 'Fnlm2', 'Fnlm3', 'Fnlm4', 'Fnlm5', 'Fnlm6', ...
+                    'Ex', 'Ey', 'Ez', 'Erx', 'Ery', 'Erz'};
+
+    Gmr_iff(i) = {minreal(G({'Fnlm1', 'Fnlm2', 'Fnlm3', 'Fnlm4', 'Fnlm5', 'Fnlm6'}, {'Fnl1', 'Fnl2', 'Fnl3', 'Fnl4', 'Fnl5', 'Fnl6'}))};
+    Gmr_dvf(i) = {minreal(G({'Dnlm1', 'Dnlm2', 'Dnlm3', 'Dnlm4', 'Dnlm5', 'Dnlm6'}, {'Fnl1', 'Fnl2', 'Fnl3', 'Fnl4', 'Fnl5', 'Fnl6'}))};
+
+    Jinvt = tf(inv(nano_hexapod.J)');
+    Jinvt.InputName = {'Fx', 'Fy', 'Fz', 'Mx', 'My', 'Mz'};
+    Jinvt.OutputName = {'Fnl1', 'Fnl2', 'Fnl3', 'Fnl4', 'Fnl5', 'Fnl6'};
+    Gmr_err(i) = {-minreal(G({'Ex', 'Ey', 'Ez', 'Erx', 'Ery', 'Erz'},                {'Fnl1', 'Fnl2', 'Fnl3', 'Fnl4', 'Fnl5', 'Fnl6'}))*Jinvt};
+  end
+#+end_src
+
+** Identification of the dynamics with a flexible micro-station
+*** Flexible micro-station
+#+begin_src matlab
+  initializeGround();
+  initializeGranite();
+  initializeTy();
+  initializeRy();
+  initializeRz();
+  initializeMicroHexapod();
+
+  initializeAxisc();
+  initializeMirror();
+#+end_src
+
+#+begin_src matlab :exports none
+  Gmf_iff = {zeros(length(Ks))};
+  Gmf_dvf = {zeros(length(Ks))};
+  Gmf_err = {zeros(length(Ks))};
+#+end_src
+
+#+begin_src matlab :exports none
+  for i = 1:length(Ks)
+    initializeNanoHexapod('k', Ks(i));
+
+    G = linearize(mdl, io);
+    G.InputName  = {'Fnl1', 'Fnl2', 'Fnl3', 'Fnl4', 'Fnl5', 'Fnl6'};
+    G.OutputName = {'Dnlm1', 'Dnlm2', 'Dnlm3', 'Dnlm4', 'Dnlm5', 'Dnlm6', ...
+                    'Fnlm1', 'Fnlm2', 'Fnlm3', 'Fnlm4', 'Fnlm5', 'Fnlm6', ...
+                    'Ex', 'Ey', 'Ez', 'Erx', 'Ery', 'Erz'};
+
+    Gmf_iff(i) = {minreal(G({'Fnlm1', 'Fnlm2', 'Fnlm3', 'Fnlm4', 'Fnlm5', 'Fnlm6'}, {'Fnl1', 'Fnl2', 'Fnl3', 'Fnl4', 'Fnl5', 'Fnl6'}))};
+    Gmf_dvf(i) = {minreal(G({'Dnlm1', 'Dnlm2', 'Dnlm3', 'Dnlm4', 'Dnlm5', 'Dnlm6'}, {'Fnl1', 'Fnl2', 'Fnl3', 'Fnl4', 'Fnl5', 'Fnl6'}))};
+
+    Jinvt = tf(inv(nano_hexapod.J)');
+    Jinvt.InputName = {'Fx', 'Fy', 'Fz', 'Mx', 'My', 'Mz'};
+    Jinvt.OutputName = {'Fnl1', 'Fnl2', 'Fnl3', 'Fnl4', 'Fnl5', 'Fnl6'};
+    Gmf_err(i) = {-minreal(G({'Ex', 'Ey', 'Ez', 'Erx', 'Ery', 'Erz'},                {'Fnl1', 'Fnl2', 'Fnl3', 'Fnl4', 'Fnl5', 'Fnl6'}))*Jinvt};
+  end
+#+end_src
+
+#+begin_src matlab :exports none
+  save('mat/optimal_stiffness_micro_station_compliance.mat', 'Ks', ...
+       'Gmr_iff',    'Gmr_dvf',    'Gmr_err', ...
+       'Gmf_iff',    'Gmf_dvf',    'Gmf_err');
+#+end_src
+
+** Obtained Dynamics
+#+begin_src matlab :exports none
+  load('mat/optimal_stiffness_micro_station_compliance.mat');
+#+end_src
+
+IFF plant
+#+begin_src matlab :exports none
+  freqs = logspace(-1, 3, 1000);
+
+  figure;
+
+  ax1 = subplot(2, 1, 1);
+  hold on;
+  for i = 1:length(Ks)
+    set(gca,'ColorOrderIndex',i);
+    plot(freqs, abs(squeeze(freqresp(Gmr_iff{i}('Fnlm1', 'Fnl1'), freqs, 'Hz'))), '-');
+    set(gca,'ColorOrderIndex',i);
+    plot(freqs, abs(squeeze(freqresp(Gmf_iff{i}('Fnlm1', 'Fnl1'), freqs, 'Hz'))), '--');
+  end
+  hold off;
+  set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
+  ylabel('Amplitude [N/N]'); set(gca, 'XTickLabel',[]);
+
+  ax2 = subplot(2, 1, 2);
+  hold on;
+  for i = 1:length(Ks)
+    set(gca,'ColorOrderIndex',i);
+    plot(freqs, 180/pi*angle(squeeze(freqresp(Gmr_iff{i}('Fnlm1', 'Fnl1'), freqs, 'Hz'))), '-');
+    set(gca,'ColorOrderIndex',i);
+    plot(freqs, 180/pi*angle(squeeze(freqresp(Gmf_iff{i}('Fnlm1', 'Fnl1'), 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
+
+DVF plant
+#+begin_src matlab :exports none
+  freqs = logspace(-1, 3, 1000);
+
+  figure;
+
+  ax1 = subplot(2, 1, 1);
+  hold on;
+  for i = 1:length(Ks)
+    set(gca,'ColorOrderIndex',i);
+    plot(freqs, abs(squeeze(freqresp(Gmr_dvf{i}('Dnlm1', 'Fnl1'), freqs, 'Hz'))), '-');
+    set(gca,'ColorOrderIndex',i);
+    plot(freqs, abs(squeeze(freqresp(Gmf_dvf{i}('Dnlm1', 'Fnl1'), freqs, 'Hz'))), '--');
+  end
+  hold off;
+  set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
+  ylabel('Amplitude [N/N]'); set(gca, 'XTickLabel',[]);
+
+  ax2 = subplot(2, 1, 2);
+  hold on;
+  for i = 1:length(Ks)
+    set(gca,'ColorOrderIndex',i);
+    plot(freqs, 180/pi*angle(squeeze(freqresp(Gmr_dvf{i}('Dnlm1', 'Fnl1'), freqs, 'Hz'))), '-');
+    set(gca,'ColorOrderIndex',i);
+    plot(freqs, 180/pi*angle(squeeze(freqresp(Gmf_dvf{i}('Dnlm1', 'Fnl1'), 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
+
+X direction
+#+begin_src matlab :exports none
+  freqs = logspace(-1, 3, 1000);
+
+  figure;
+
+  ax1 = subplot(2, 1, 1);
+  hold on;
+  for i = 1:length(Ks)
+    set(gca,'ColorOrderIndex',i);
+    plot(freqs, abs(squeeze(freqresp(Gmr_err{i}('Ex', 'Fx'), freqs, 'Hz'))), '-');
+    set(gca,'ColorOrderIndex',i);
+    plot(freqs, abs(squeeze(freqresp(Gmf_err{i}('Ex', 'Fx'), freqs, 'Hz'))), '--');
+  end
+  hold off;
+  set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
+  ylabel('Amplitude [m/N]'); set(gca, 'XTickLabel',[]);
+
+  ax2 = subplot(2, 1, 2);
+  hold on;
+  for i = 1:length(Ks)
+    set(gca,'ColorOrderIndex',i);
+    plot(freqs, 180/pi*angle(squeeze(freqresp(Gmr_err{i}('Ex', 'Fx'), freqs, 'Hz'))), '-');
+    set(gca,'ColorOrderIndex',i);
+    plot(freqs, 180/pi*angle(squeeze(freqresp(Gmf_err{i}('Ex', 'Fx'), 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
+
+Z direction
+#+begin_src matlab :exports none
+  freqs = logspace(-1, 3, 1000);
+
+  figure;
+
+  ax1 = subplot(2, 1, 1);
+  hold on;
+  for i = 1:length(Ks)
+    set(gca,'ColorOrderIndex',i);
+    plot(freqs, abs(squeeze(freqresp(Gmr_err{i}('Ez', 'Fz'), freqs, 'Hz'))), '-');
+    set(gca,'ColorOrderIndex',i);
+    plot(freqs, abs(squeeze(freqresp(Gmf_err{i}('Ez', 'Fz'), freqs, 'Hz'))), '--');
+  end
+  hold off;
+  set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
+  ylabel('Amplitude [m/N]'); set(gca, 'XTickLabel',[]);
+
+  ax2 = subplot(2, 1, 2);
+  hold on;
+  for i = 1:length(Ks)
+    set(gca,'ColorOrderIndex',i);
+    plot(freqs, 180/pi*angle(squeeze(freqresp(Gmr_err{i}('Ez', 'Fz'), freqs, 'Hz'))), '-');
+    set(gca,'ColorOrderIndex',i);
+    plot(freqs, 180/pi*angle(squeeze(freqresp(Gmf_err{i}('Ez', 'Fz'), 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                                                        :ignore:
 * Payload "Impedance" Effect
 <<sec:payload_impedance>>
@@ -432,6 +766,7 @@ Comparison of the coupling from $F_x$ to $D_y$ when rotating at 60rpm to the dir
 #+end_src
 
 #+begin_src matlab
+  load('mat/conf_simulink.mat');
   open('nass_model.slx')
 #+end_src
 
@@ -448,16 +783,17 @@ We initialize all the stages with the default parameters.
   initializeMirror();
 #+end_src
 
-We don't include gravity nor disturbances in this model as it adds complexity to the simulations and does not alter the obtained dynamics.
+We don't include disturbances in this model as it adds complexity to the simulations and does not alter the obtained dynamics.
 #+begin_src matlab
-  initializeSimscapeConfiguration('gravity', false);
+  initializeSimscapeConfiguration('gravity', true);
   initializeDisturbances('enable', false);
 #+end_src
 
 We set the controller type to Open-Loop, and we do not need to log any signal.
 #+begin_src matlab
-  initializeController('type', 'stabilizing');
+  initializeController();
   initializeLoggingConfiguration('log', 'none');
+  initializeReferences();
 #+end_src
 
 #+begin_src matlab :exports none
@@ -472,27 +808,24 @@ We set the controller type to Open-Loop, and we do not need to log any signal.
   io(io_i) = linio([mdl, '/Tracking Error'], 1, 'openoutput', [], 'En');   io_i = io_i + 1;
 #+end_src
 
-** Change of payload dynamics
+** Identification of the dynamics while change the payload dynamics
 - Change of mass: from 1kg to 50kg
 - Change of resonance frequency: from 50Hz to 500Hz
 - The damping ratio of the payload is fixed to $\xi = 0.2$
 
-#+begin_src matlab
+We identify the dynamics for the following payload masses =Ms= and nano-hexapod leg's stiffnesses =Ks=:
-  initializeReferences();
-  Ks = logspace(3,9,7) % [N/m]
-#+end_src
-
 #+begin_src matlab
   Ms = [1, 20, 50]; % [Kg]
+  Ks = logspace(3,9,7); % [N/m]
 #+end_src
 
-#+begin_src matlab
+#+begin_src matlab :exports none
   Gm_iff = {zeros(length(Ks), length(Ms))};
   Gm_dvf = {zeros(length(Ks), length(Ms))};
   Gm_err = {zeros(length(Ks), length(Ms))};
 #+end_src
 
-#+begin_src matlab
+#+begin_src matlab :exports none
   for i = 1:length(Ks)
     for j = 1:length(Ms)
       initializeNanoHexapod('k', Ks(i));
@@ -515,17 +848,18 @@ We set the controller type to Open-Loop, and we do not need to log any signal.
   end
 #+end_src
 
+We then identify the dynamics for the following payload resonance frequencies =Fs=:
 #+begin_src matlab
   Fs = [50, 200, 500]; % [Hz]
 #+end_src
 
-#+begin_src matlab
+#+begin_src matlab :exports none
   Gf_iff = {zeros(length(Ks), length(Fs))};
   Gf_dvf = {zeros(length(Ks), length(Fs))};
   Gf_err = {zeros(length(Ks), length(Fs))};
 #+end_src
 
-#+begin_src matlab
+#+begin_src matlab :exports none
   for i = 1:length(Ks)
     for j = 1:length(Fs)
       initializeNanoHexapod('k', Ks(i));
@@ -548,13 +882,12 @@ We set the controller type to Open-Loop, and we do not need to log any signal.
   end
 #+end_src
 
-#+begin_src matlab
+#+begin_src matlab :exports none
   save('mat/optimal_stiffness_Gm_Gf.mat', 'Ks', 'Ms', 'Fs', ...
        'Gm_iff',    'Gm_dvf',    'Gm_err', ...
        'Gf_iff',    'Gf_dvf',    'Gf_err');
 #+end_src
 
-** Plots
 ** Change of optimal gain for decentralized control
 For each payload, compute the optimal gain for the IFF control.
 The optimal value corresponds to critical damping to *all* the 6 modes of the nano-hexapod.
@@ -1061,6 +1394,5 @@ For a stiff nano-hexapod
   xlim([freqs(1), freqs(end)]);
 #+end_src
 
-
 ** Conclusion                                                        :ignore:
-
+* Total Change of dynamics