diff --git a/docs/amplified_piezoelectric_stack.html b/docs/amplified_piezoelectric_stack.html index 347e894..eedd982 100644 --- a/docs/amplified_piezoelectric_stack.html +++ b/docs/amplified_piezoelectric_stack.html @@ -3,7 +3,7 @@ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
- +-The presented model is based on souleille18_concep_activ_mount_space_applic. +The presented model is based on (Souleille et al. 2018).
@@ -136,8 +170,8 @@ The parameters are shown in the table below.
m = 1; % [kg] @@ -167,8 +201,8 @@ IFF Controller:
Identification in open-loop. @@ -223,8 +257,8 @@ Giff.OutputName = {'Fs', 'x1'};
m = 1;
+k1 = 1e6;
+ka = 1e6;
+ke = 1e6;
+
+Giff.InputName = {'f'};
+Giff.OutputName = {'Fs'};
+
++This analysis gave rise to a paper (Dehaeze and Collette 2020). +
m = 1; % [kg] @@ -336,8 +385,8 @@ h = 0.2; % [m]
Rotating speed in rad/s: @@ -386,8 +435,8 @@ end
K = tf(zeros(6)); Kiff = tf(zeros(6)); @@ -512,9 +565,21 @@ The nano-hexapod has the following leg’s stiffness and damping.
+The loop gain for IFF is shown in Figure 8. +
+ ++The corresponding root locus is shown in Figure 9. +
+ ++Finally, the damping as function of the gain is display in Figure 10. +
+ @@ -530,9 +595,6 @@ The nano-hexapod has the following leg’s stiffness and damping.
@@ -530,9 +595,6 @@ The nano-hexapod has the following leg’s stiffness and damping.
 
Figure 9: Root Locus for the IFF control for three payload masses
-Damping as function of the gain -
 @@ -541,7 +603,7 @@ Damping as function of the gain
@@ -541,7 +603,7 @@ Damping as function of the gain
 
-Finally, we use the following controller for the Decentralized Direct Velocity Feedback: +The following controller for the Decentralized Integral Force Feedback is used:
Kiff = -1e4/s*eye(6); @@ -550,9 +612,9 @@ Finally, we use the following controller for the Decentralized Direct Velocity F
 @@ -584,15 +646,19 @@ Finally, we use the following controller for the Decentralized Direct Velocity F
@@ -584,15 +646,19 @@ Finally, we use the following controller for the Decentralized Direct Velocity F
 
 
 
Figure 15: Norm of the transfer function from vertical disturbances to vertical position error with (dashed) and without (solid) Integral Force Feedback applied
+Based on the analytical analysis, we can determine the parameters of the amplified piezoelectric actuator in order to be able to add a lots of damping using IFF: +
++However, this might not be realizable. +
++The nano-hexapod is initialized with the following parameters: +
+initializeNanoHexapod('actuator', 'amplified', ...
+                      'k1', 1e4, ...
+                      'ke', 1e6, ...
+                      'ka', 1e6);
+
++The obtain plan for the IFF control is shown in Figure 16. +The associated Root Locus is shown in Figure 17. +
+ ++Based on that, the following IFF gain is chosen: +
+Kiff = -1e3/s*eye(6); ++
 +
+
Figure 16: Plant dynamics for IFF with the amplified piezoelectric stack actuator
+ +
+
Figure 17: Root Locus for IFF with the amplified piezoelectric stack actuator
+ +
+
Figure 18: Damping of the modes as a function of the IFF gain
+ +
+
Figure 19: Effect of disturbance with and without IFF
++ +
+ +h = 2.5; +Kl = 5e6 * eye(6) * ... + 1/h*(s/(2*pi*40/h) + 1)/(s/(2*pi*40*h) + 1) * ... + 1/h*(s/(2*pi*100/h) + 1)/(s/(2*pi*100*h) + 1) * ... + (s/2/pi/50 + 1)/(s/2/pi/50) * ... + (s/2/pi/10 + 1)/(s/2/pi/10) * ... + 1/(1 + s/2/pi/200); ++
Kl = 3e10 * eye(6) * ... + 1/s * ... + (s+0.8)/s * ... + (s+50)/(s+0.01) * ... + (s+120)/(s+1000) * ... + (s+150)/(s+1000); ++
+Finally, we include the Jacobian in the control and we ignore the measurement of the vertical rotation as for the real system. +
+load('mat/stages.mat', 'nano_hexapod');
+K = Kl*nano_hexapod.kinematics.J*diag([1, 1, 1, 1, 1, 0]);
+
++We identify the transfer function from disturbances to the position error of the sample when the HAC-LAC control is applied. +
++Let’s now simulate a tomography experiment. +To do so, we include all disturbances except vibrations of the translation stage. +
+initializeDisturbances();
+initializeSimscapeConfiguration('gravity', false);
+initializeLoggingConfiguration('log', 'all');
+
++And we run the simulation for all three payload Masses. +
++Lack of collocation. +
+ +initializeController('type', 'hac-dvf');
+K = tf(zeros(6));
+Kdvf = tf(zeros(6));
+
++We identify the system for the following payload masses: +
+Ms = [1, 10, 50]; ++
initializeNanoHexapod('actuator', 'amplified', ...
+                      'k1', 1e4, ...
+                      'ke', 1e6, ...
+                      'ka', 1e6);
+
+initializeGround();
+initializeGranite();
+initializeTy();
+initializeRy();
+initializeRz();
+initializeMicroHexapod();
+initializeAxisc();
+initializeMirror();
+
+initializeSimscapeConfiguration();
+initializeDisturbances('enable', false);
+initializeLoggingConfiguration('log', 'none');
+
+initializeController('type', 'hac-dvf');
+
++We set the stiffness of the payload fixation: +
+Kp = 1e8; % [N/m] ++
K = tf(zeros(6)); +Kdvf = tf(zeros(6)); ++
+We identify the system for the following payload masses: +
+Ms = [1, 10, 50]; ++
+The nano-hexapod has the following leg’s stiffness and damping. +
+initializeNanoHexapod('actuator', 'amplified', 'k1', 0.4e6, 'ka', 43e6, 'ke', 1.5e6);
+
++Damping as function of the gain +Finally, we use the following controller for the Decentralized Direct Velocity Feedback: +
+Kdvf = 5e5*s/(1+s/2/pi/1e3)*eye(6); ++
+We design a diagonal controller with all the same diagonal elements. +
+ ++The requirements for the controller are: +
++The design controller is as follows: +
+h = 2.0; +Kl = 1e9 * eye(6) * ... + 1/h*(s/(2*pi*100/h) + 1)/(s/(2*pi*100*h) + 1) * ... + 1/h*(s/(2*pi*200/h) + 1)/(s/(2*pi*200*h) + 1) * ... + (s/2/pi/10 + 1)/(s/2/pi/10) * ... + 1/(1 + s/2/pi/300); ++
load('mat/stages.mat', 'nano_hexapod');
+K = Kl*nano_hexapod.kinematics.J*diag([1, 1, 1, 1, 1, 0]);
+
++We identify the transfer function from disturbances to the position error of the sample when the HAC-LAC control is applied. +
+ + +
+
Figure 20: Amplitude Spectral Density of the vertical position error of the sample when the HAC-DVF control is applied due to both the ground motion and spindle vibrations
+ +
+
Figure 21: Amplitude Spectral Density of the vertical position error of the sample in Open-Loop and when the HAC-DVF control is applied
+ +
+
Figure 22: Cumulative Amplitude Spectrum of the vertical position error of the sample in Open-Loop and when the HAC-DVF control is applied
++Let’s now simulate a tomography experiment. +To do so, we include all disturbances except vibrations of the translation stage. +
+initializeDisturbances();
+initializeSimscapeConfiguration('gravity', false);
+initializeLoggingConfiguration('log', 'all');
+
++And we run the simulation for all three payload Masses. +
+Created: 2020-05-25 lun. 11:13
+Created: 2020-09-01 mar. 13:48
StopTime.
 
 load('mat/conf_simulink.mat');
-set_param(conf_simulink, 'StopTime', '0.5');
+load('mat/conf_simulink.mat');
+set_param(conf_simulink, 'StopTime', '0.5');
 
 initializeGround(); -initializeGranite('type', 'modal-analysis'); +initializeGranite('type', 'modal-analysis'); initializeTy(); initializeRy(); initializeRz(); -initializeMicroHexapod('type', 'modal-analysis'); -initializeAxisc('type', 'none'); -initializeMirror('type', 'none'); -initializeNanoHexapod('type', 'none'); -initializeSample('type', 'none'); +initializeMicroHexapod('type', 'modal-analysis'); +initializeAxisc('type', 'none'); +initializeMirror('type', 'none'); +initializeNanoHexapod('type', 'none'); +initializeSample('type', 'none');
initializeController('type', 'open-loop');
+initializeController('type', 'open-loop');
 
 initializeSimscapeConfiguration('gravity', false);
+initializeSimscapeConfiguration('gravity', false);
 
 initializeLoggingConfiguration('log', 'all');
+initializeLoggingConfiguration('log', 'all');
 
 %% Name of the Simulink File -mdl = 'nass_model'; +%% Name of the Simulink File +mdl = 'nass_model'; -%% Micro-Hexapod +%% Micro-Hexapod clear io; io_i = 1; -io(io_i) = linio([mdl, '/Disturbances'], 1, 'openinput', [], 'Dwz'); io_i = io_i + 1; % Vertical Ground Motion -io(io_i) = linio([mdl, '/Disturbances'], 1, 'openinput', [], 'Fty_z'); io_i = io_i + 1; % Parasitic force Ty -io(io_i) = linio([mdl, '/Disturbances'], 1, 'openinput', [], 'Frz_z'); io_i = io_i + 1; % Parasitic force Rz +io(io_i) = linio([mdl, '/Disturbances'], 1, 'openinput', [], 'Dwz'); io_i = io_i + 1; % Vertical Ground Motion +io(io_i) = linio([mdl, '/Disturbances'], 1, 'openinput', [], 'Fty_z'); io_i = io_i + 1; % Parasitic force Ty +io(io_i) = linio([mdl, '/Disturbances'], 1, 'openinput', [], 'Frz_z'); io_i = io_i + 1; % Parasitic force Rz -io(io_i) = linio([mdl, '/Micro-Station/Granite/Modal Analysis/accelerometer'], 1, 'openoutput'); io_i = io_i + 1; % Absolute motion - Granite -io(io_i) = linio([mdl, '/Micro-Station/Micro Hexapod/Modal Analysis/accelerometer'], 1, 'openoutput'); io_i = io_i + 1; % Absolute Motion - Hexapod +io(io_i) = linio([mdl, '/Micro-Station/Granite/Modal Analysis/accelerometer'], 1, 'openoutput'); io_i = io_i + 1; % Absolute motion - Granite +io(io_i) = linio([mdl, '/Micro-Station/Micro Hexapod/Modal Analysis/accelerometer'], 1, 'openoutput'); io_i = io_i + 1; % Absolute Motion - Hexapod -% Run the linearization +% Run the linearization G = linearize(mdl, io, 0);
G = G([3,9], :); +G = G([3,9], :); -% Input/Output names -G.InputName = {'Dw', 'Fty', 'Frz'}; -G.OutputName = {'Agm', 'Ahm'}; +% Input/Output names +G.InputName = {'Dw', 'Fty', 'Frz'}; +G.OutputName = {'Agm', 'Ahm'};
G = (1/s)*tf([-1, 1])*G; +G = (1/s)*tf([-1, 1])*G; -% Input/Output names -G.InputName = {'Dw', 'Fty', 'Frz'}; -G.OutputName = {'Vm'}; +% Input/Output names +G.InputName = {'Dw', 'Fty', 'Frz'}; +G.OutputName = {'Vm'};
gm  = load('./mat/psd_gm.mat', 'f', 'psd_gm');
-rz  = load('./mat/pxsp_r.mat', 'f', 'pxsp_r');
-tyz = load('./mat/pxz_ty_r.mat', 'f', 'pxz_ty_r');
-tyx = load('./mat/pxe_ty_r.mat', 'f', 'pxe_ty_r');
+gm  = load('./mat/psd_gm.mat', 'f', 'psd_gm');
+rz  = load('./mat/pxsp_r.mat', 'f', 'pxsp_r');
+tyz = load('./mat/pxz_ty_r.mat', 'f', 'pxz_ty_r');
+tyx = load('./mat/pxe_ty_r.mat', 'f', 'pxe_ty_r');
 
 f0s = [50, 100, 150, 200, 250, 350, 450]; -for f0 = f0s - i = find(gm.f > f0-0.5 & gm.f < f0+0.5); - gm.psd_gm(i) = linspace(gm.psd_gm(i(1)), gm.psd_gm(i(end)), length(i)); -end +for f0 = f0s + i = find(gm.f > f0-0.5 & gm.f < f0+0.5); + gm.psd_gm(i) = linspace(gm.psd_gm(i(1)), gm.psd_gm(i(end)), length(i)); +end
gm.psd_rv = gm.psd_gm.*abs(squeeze(freqresp(G('Vm', 'Dw'), gm.f, 'Hz'))).^2;
+gm.psd_rv = gm.psd_gm.*abs(squeeze(freqresp(G('Vm', 'Dw'), gm.f, 'Hz'))).^2;
 
 rz.psd_f  = rz.pxsp_r./abs(squeeze(freqresp(G('Vm', 'Frz'), rz.f, 'Hz'))).^2;
-tyz.psd_f = tyz.pxz_ty_r./abs(squeeze(freqresp(G('Vm', 'Fty'), tyz.f, 'Hz'))).^2;
+rz.psd_f  = rz.pxsp_r./abs(squeeze(freqresp(G('Vm', 'Frz'), rz.f, 'Hz'))).^2;
+tyz.psd_f = tyz.pxz_ty_r./abs(squeeze(freqresp(G('Vm', 'Fty'), tyz.f, 'Hz'))).^2;
 
 psd_gm_d = gm.psd_gm.*abs(squeeze(freqresp(G('Vm', 'Dw')/s, gm.f, 'Hz'))).^2;
-psd_ty_d = tyz.psd_f.*abs(squeeze(freqresp(G('Vm', 'Fty')/s, tyz.f, 'Hz'))).^2;
-psd_rz_d = rz.psd_f.*abs(squeeze(freqresp(G('Vm', 'Frz')/s, rz.f, 'Hz'))).^2;
+psd_gm_d = gm.psd_gm.*abs(squeeze(freqresp(G('Vm', 'Dw')/s, gm.f, 'Hz'))).^2;
+psd_ty_d = tyz.psd_f.*abs(squeeze(freqresp(G('Vm', 'Fty')/s, tyz.f, 'Hz'))).^2;
+psd_rz_d = rz.psd_f.*abs(squeeze(freqresp(G('Vm', 'Frz')/s, rz.f, 'Hz'))).^2;
 
 dist_f = struct(); -dist_f.f = gm.f; % Frequency Vector [Hz] +dist_f.f = gm.f; % Frequency Vector [Hz] -dist_f.psd_gm = gm.psd_gm; % Power Spectral Density of the Ground Motion [m^2/Hz] -dist_f.psd_ty = tyz.psd_f; % Power Spectral Density of the force induced by the Ty stage in the Z direction [N^2/Hz] -dist_f.psd_rz = rz.psd_f; % Power Spectral Density of the force induced by the Rz stage in the Z direction [N^2/Hz] +dist_f.psd_gm = gm.psd_gm; % Power Spectral Density of the Ground Motion [m^2/Hz] +dist_f.psd_ty = tyz.psd_f; % Power Spectral Density of the force induced by the Ty stage in the Z direction [N^2/Hz] +dist_f.psd_rz = rz.psd_f; % Power Spectral Density of the force induced by the Rz stage in the Z direction [N^2/Hz] -save('./mat/dist_psd.mat', 'dist_f'); +save('./mat/dist_psd.mat', 'dist_f');
initializeDisturbances();
-dist = load('nass_disturbances.mat');
+dist = load('nass_disturbances.mat');
 
 initializeNanoHexapod('type', 'rigid');
-initializeSample('mass', 1);
+initializeNanoHexapod('type', 'rigid');
+initializeSample('mass', 1);
 
 initializeReferences(); -initializeController('type', 'open-loop'); -initializeSimscapeConfiguration('gravity', false); -initializeLoggingConfiguration('log', 'all'); +initializeController('type', 'open-loop'); +initializeSimscapeConfiguration('gravity', false); +initializeLoggingConfiguration('log', 'all');
load('mat/conf_simulink.mat');
-set_param(conf_simulink, 'StopTime', '2');
+load('mat/conf_simulink.mat');
+set_param(conf_simulink, 'StopTime', '2');
 
 initializeDisturbances('enable', false);
-sim('nass_model');
+initializeDisturbances('enable', false);
+sim('nass_model');
 sim_no = simout;
 
 initializeDisturbances('Fty_x', false, 'Fty_z', false, 'Frz_z', false);
-sim('nass_model');
+initializeDisturbances('Fty_x', false, 'Fty_z', false, 'Frz_z', false);
+sim('nass_model');
 sim_gm = simout;
 
 initializeDisturbances('Dwx', false, 'Dwy', false, 'Dwz', false, 'Frz_z', false);
-sim('nass_model');
+initializeDisturbances('Dwx', false, 'Dwy', false, 'Dwz', false, 'Frz_z', false);
+sim('nass_model');
 sim_ty = simout;
 
 initializeDisturbances('Dwx', false, 'Dwy', false, 'Dwz', false, 'Fty_x', false, 'Fty_z', false);
-sim('nass_model');
+initializeDisturbances('Dwx', false, 'Dwy', false, 'Dwz', false, 'Fty_x', false, 'Fty_z', false);
+sim('nass_model');
 sim_rz = simout;
 
 Created: 2020-04-17 ven. 09:35
+Created: 2020-09-01 mar. 13:48
load('mat/conf_simulink.mat');
+load('mat/conf_simulink.mat');
 
 StopTime.
 
 set_param(conf_simulink, 'StopTime', '0.5'); +set_param(conf_simulink, 'StopTime', '0.5');
StopTime.
 We initialize all the stages.
 
 initializeGround(      'type', 'rigid');
-initializeGranite(     'type', 'modal-analysis');
-initializeTy(          'type', 'modal-analysis');
-initializeRy(          'type', 'modal-analysis');
-initializeRz(          'type', 'modal-analysis');
-initializeMicroHexapod('type', 'modal-analysis');
-initializeAxisc(       'type', 'flexible');
+initializeGround(      'type', 'rigid');
+initializeGranite(     'type', 'modal-analysis');
+initializeTy(          'type', 'modal-analysis');
+initializeRy(          'type', 'modal-analysis');
+initializeRz(          'type', 'modal-analysis');
+initializeMicroHexapod('type', 'modal-analysis');
+initializeAxisc(       'type', 'flexible');
 
-initializeMirror(      'type', 'none');
-initializeNanoHexapod( 'type', 'none');
-initializeSample(      'type', 'none');
+initializeMirror(      'type', 'none');
+initializeNanoHexapod( 'type', 'none');
+initializeSample(      'type', 'none');
 
-initializeController(  'type', 'open-loop');
+initializeController(  'type', 'open-loop');
 
-initializeLoggingConfiguration('log', 'none');
+initializeLoggingConfiguration('log', 'none');
 
 initializeReferences();
-initializeDisturbances('enable', false);
+initializeDisturbances('enable', false);
 
 sim('nass_model')
+sim('nass_model')
 
 open('identification/matlab/sim_micro_station_com_estimation.slx')
+open('identification/matlab/sim_micro_station_com_estimation.slx')
 
 sim('sim_micro_station_com_estimation')
+sim('sim_micro_station_com_estimation')
 
 granite_bot_com = granite_bot_com.Data(end, :)'; -granite_top_com = granite_top_com.Data(end, :)'; -ty_com = ty_com.Data(end, :)'; -ry_com = ry_com.Data(end, :)'; -rz_com = rz_com.Data(end, :)'; -hexa_com = hexa_com.Data(end, :)'; +granite_bot_com = granite_bot_com.Data(end, :)'; +granite_top_com = granite_top_com.Data(end, :)'; +ty_com = ty_com.Data(end, :)'; +ry_com = ry_com.Data(end, :)'; +rz_com = rz_com.Data(end, :)'; +hexa_com = hexa_com.Data(end, :)'; -save('./mat/solids_com.mat', 'granite_bot_com', 'granite_top_com', 'ty_com', 'ry_com', 'rz_com', 'hexa_com'); +save('./mat/solids_com.mat', 'granite_bot_com', 'granite_top_com', 'ty_com', 'ry_com', 'rz_com', 'hexa_com');
% load('mat/solids_com.mat', 'granite_bot_com', 'granite_top_com', 'ty_com', 'ry_com', 'rz_com', 'hexa_com');
+% load('mat/solids_com.mat', 'granite_bot_com', 'granite_top_com', 'ty_com', 'ry_com', 'rz_com', 'hexa_com');
 
 open('nass_model.slx')
+open('nass_model.slx')
 
 linearize function in order to estimate the dynamics from forces applied on the Translation stage at the same position used for the real modal analysis to the inertial sensors.
 
 %% Options for Linearized +%% Options for Linearized options = linearizeOptions; options.SampleTime = 0; -%% Name of the Simulink File -mdl = 'nass_model'; +%% Name of the Simulink File +mdl = 'nass_model'; -%% Input/Output definition +%% Input/Output definition clear io; io_i = 1; -io(io_i) = linio([mdl, '/Micro-Station/Translation Stage/Modal Analysis/F_hammer'], 1, 'openinput'); io_i = io_i + 1; -io(io_i) = linio([mdl, '/Micro-Station/Granite/Modal Analysis/accelerometer'], 1, 'openoutput'); io_i = io_i + 1; -io(io_i) = linio([mdl, '/Micro-Station/Translation Stage/Modal Analysis/accelerometer'], 1, 'openoutput'); io_i = io_i + 1; -io(io_i) = linio([mdl, '/Micro-Station/Tilt Stage/Modal Analysis/accelerometer'], 1, 'openoutput'); io_i = io_i + 1; -io(io_i) = linio([mdl, '/Micro-Station/Spindle/Modal Analysis/accelerometer'], 1, 'openoutput'); io_i = io_i + 1; -io(io_i) = linio([mdl, '/Micro-Station/Micro Hexapod/Modal Analysis/accelerometer'], 1, 'openoutput'); io_i = io_i + 1; +io(io_i) = linio([mdl, '/Micro-Station/Translation Stage/Modal Analysis/F_hammer'], 1, 'openinput'); io_i = io_i + 1; +io(io_i) = linio([mdl, '/Micro-Station/Granite/Modal Analysis/accelerometer'], 1, 'openoutput'); io_i = io_i + 1; +io(io_i) = linio([mdl, '/Micro-Station/Translation Stage/Modal Analysis/accelerometer'], 1, 'openoutput'); io_i = io_i + 1; +io(io_i) = linio([mdl, '/Micro-Station/Tilt Stage/Modal Analysis/accelerometer'], 1, 'openoutput'); io_i = io_i + 1; +io(io_i) = linio([mdl, '/Micro-Station/Spindle/Modal Analysis/accelerometer'], 1, 'openoutput'); io_i = io_i + 1; +io(io_i) = linio([mdl, '/Micro-Station/Micro Hexapod/Modal Analysis/accelerometer'], 1, 'openoutput'); io_i = io_i + 1;
% Run the linearization +% Run the linearization G_ms = linearize(mdl, io, 0); -%% Input/Output definition -G_ms.InputName = {'Fx', 'Fy', 'Fz'}; -G_ms.OutputName = {'gtop_x', 'gtop_y', 'gtop_z', 'gtop_rx', 'gtop_ry', 'gtop_rz', ... - 'ty_x', 'ty_y', 'ty_z', 'ty_rx', 'ty_ry', 'ty_rz', ... - 'ry_x', 'ry_y', 'ry_z', 'ry_rx', 'ry_ry', 'ry_rz', ... - 'rz_x', 'rz_y', 'rz_z', 'rz_rx', 'rz_ry', 'rz_rz', ... - 'hexa_x', 'hexa_y', 'hexa_z', 'hexa_rx', 'hexa_ry', 'hexa_rz'}; +%% Input/Output definition +G_ms.InputName = {'Fx', 'Fy', 'Fz'}; +G_ms.OutputName = {'gtop_x', 'gtop_y', 'gtop_z', 'gtop_rx', 'gtop_ry', 'gtop_rz', ... + 'ty_x', 'ty_y', 'ty_z', 'ty_rx', 'ty_ry', 'ty_rz', ... + 'ry_x', 'ry_y', 'ry_z', 'ry_rx', 'ry_ry', 'ry_rz', ... + 'rz_x', 'rz_y', 'rz_z', 'rz_rx', 'rz_ry', 'rz_rz', ... + 'hexa_x', 'hexa_y', 'hexa_z', 'hexa_rx', 'hexa_ry', 'hexa_rz'};
G_ms is the acceleration of each solid body.
 In order to obtain a displacement, we divide the obtained transfer function by \(1/s^{2}\);
 
 G_ms = G_ms/s^2; +G_ms = G_ms/s^2;
load('../meas/modal-analysis/mat/frf_coh_matrices.mat', 'freqs');
-load('../meas/modal-analysis/mat/frf_com.mat', 'FRFs_CoM');
+load('../meas/modal-analysis/mat/frf_coh_matrices.mat', 'freqs');
+load('../meas/modal-analysis/mat/frf_com.mat', 'FRFs_CoM');
 
 initializeAxisc('type', 'none');
-initializeMirror('type', 'none');
-initializeNanoHexapod('type', 'none');
-initializeSample('type', 'none');
+initializeAxisc('type', 'none');
+initializeMirror('type', 'none');
+initializeNanoHexapod('type', 'none');
+initializeSample('type', 'none');
 
 %% Name of the Simulink File -mdl = 'nass_model'; +%% Name of the Simulink File +mdl = 'nass_model'; -%% Input/Output definition +%% 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 +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 +%% Run the linearization Gm = linearize(mdl, io, 0); -Gm.InputName = {'Fmx', 'Fmy', 'Fmz', 'Mmx', 'Mmy', 'Mmz'}; -Gm.OutputName = {'Dx', 'Dy', 'Dz', 'Drx', 'Dry', 'Drz'}; +Gm.InputName = {'Fmx', 'Fmy', 'Fmz', 'Mmx', 'Mmy', 'Mmz'}; +Gm.OutputName = {'Dx', 'Dy', 'Dz', 'Drx', 'Dry', 'Drz'}; ++
save('../meas/micro-station-compliance/mat/model.mat', 'Gm');
 
 Created: 2020-04-17 ven. 09:35
+Created: 2020-09-01 mar. 13:47
Corresponding RMS value in [nm rms, nrad rms]
-1e9*sqrt(trapz(freqs, (abs(squeeze(freqresp(Gamma_x, freqs, 'Hz')))').^2)) --