593 lines
21 KiB
Org Mode
593 lines
21 KiB
Org Mode
#+TITLE: Identification
|
|
:DRAWER:
|
|
#+STARTUP: overview
|
|
|
|
#+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="../css/htmlize.css"/>
|
|
#+HTML_HEAD: <link rel="stylesheet" type="text/css" href="../css/readtheorg.css"/>
|
|
#+HTML_HEAD: <link rel="stylesheet" type="text/css" href="../css/zenburn.css"/>
|
|
#+HTML_HEAD: <script type="text/javascript" src="../js/jquery.min.js"></script>
|
|
#+HTML_HEAD: <script type="text/javascript" src="../js/bootstrap.min.js"></script>
|
|
#+HTML_HEAD: <script type="text/javascript" src="../js/jquery.stickytableheaders.min.js"></script>
|
|
#+HTML_HEAD: <script type="text/javascript" src="../js/readtheorg.js"></script>
|
|
|
|
#+HTML_MATHJAX: align: center tagside: right font: TeX
|
|
|
|
#+PROPERTY: header-args:matlab :session *MATLAB*
|
|
#+PROPERTY: header-args:matlab+ :comments org
|
|
#+PROPERTY: header-args:matlab+ :results none
|
|
#+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 matlab/modal_frf_coh.m
|
|
#+PROPERTY: header-args:matlab+ :mkdirp yes
|
|
|
|
#+PROPERTY: header-args:shell :eval no-export
|
|
|
|
#+PROPERTY: header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/Cloud/thesis/latex/}{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 raw replace :buffer no
|
|
#+PROPERTY: header-args:latex+ :eval no-export
|
|
#+PROPERTY: header-args:latex+ :exports both
|
|
#+PROPERTY: header-args:latex+ :mkdirp yes
|
|
#+PROPERTY: header-args:latex+ :output-dir figs
|
|
:END:
|
|
|
|
* Introduction :ignore:
|
|
The goal here is to tune the Simscape model of the station in order to have a good dynamical representation of the real system.
|
|
|
|
In order to do so, we reproduce the Modal Analysis done on the station using the Simscape model.
|
|
|
|
We can then compare the measured Frequency Response Functions with the identified dynamics of the model.
|
|
|
|
Finally, this should help to tune the parameters of the model such that the dynamics is closer to the measured FRF.
|
|
|
|
* Identification of the Micro-Station :noexport:
|
|
** 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
|
|
simulinkproject('../');
|
|
#+end_src
|
|
|
|
** Simscape Model
|
|
The simulink file for the identification is =sim_micro_station_id.slx=.
|
|
#+begin_src matlab
|
|
open('identification/matlab/sim_micro_station_id.slx')
|
|
#+end_src
|
|
|
|
We load the configuration and we set a small =StopTime=.
|
|
#+begin_src matlab
|
|
load('mat/conf_simulink.mat');
|
|
set_param(conf_simulink, 'StopTime', '0.5');
|
|
#+end_src
|
|
|
|
We initialize all the stages.
|
|
#+begin_src matlab
|
|
initializeGround();
|
|
initializeGranite();
|
|
initializeTy();
|
|
initializeRy();
|
|
initializeRz();
|
|
initializeMicroHexapod();
|
|
initializeAxisc();
|
|
initializeMirror();
|
|
initializeNanoHexapod('actuator', 'piezo');
|
|
initializeSample('mass', 50);
|
|
#+end_src
|
|
|
|
** Compute the transfer functions
|
|
We first define some parameters for the identification.
|
|
#+begin_src matlab
|
|
%% Options for Linearized
|
|
options = linearizeOptions;
|
|
options.SampleTime = 0;
|
|
|
|
%% Name of the Simulink File
|
|
mdl = 'sim_micro_station_id';
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
%% Micro-Hexapod
|
|
% Input/Output definition
|
|
io(1) = linio([mdl, '/Micro-Station/Fm_ext'],1,'openinput');
|
|
io(2) = linio([mdl, '/Micro-Station/Fg_ext'],1,'openinput');
|
|
io(3) = linio([mdl, '/Micro-Station/Dm_inertial'],1,'output');
|
|
io(4) = linio([mdl, '/Micro-Station/Ty_inertial'],1,'output');
|
|
io(5) = linio([mdl, '/Micro-Station/Ry_inertial'],1,'output');
|
|
io(6) = linio([mdl, '/Micro-Station/Dg_inertial'],1,'output');
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
% Run the linearization
|
|
G_ms = linearize(mdl, io, 0);
|
|
|
|
% Input/Output names
|
|
G_ms.InputName = {'Fmx', 'Fmy', 'Fmz',...
|
|
'Fgx', 'Fgy', 'Fgz'};
|
|
G_ms.OutputName = {'Dmx', 'Dmy', 'Dmz', ...
|
|
'Tyx', 'Tyy', 'Tyz', ...
|
|
'Ryx', 'Ryy', 'Ryz', ...
|
|
'Dgx', 'Dgy', 'Dgz'};
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
%% Save the obtained transfer functions
|
|
save('./mat/id_micro_station.mat', 'G_ms');
|
|
#+end_src
|
|
|
|
** Plots the transfer functions
|
|
|
|
** Compare with the measurements
|
|
|
|
* Modal Analysis of the Micro-Station :noexport:
|
|
** 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
|
|
simulinkproject('../');
|
|
#+end_src
|
|
|
|
** Simscape Model
|
|
The simulink file for the analysis is =sim_micro_station_modal_analysis.slx=.
|
|
#+begin_src matlab
|
|
open('identification/matlab/sim_micro_station_modal_analysis.slx')
|
|
#+end_src
|
|
|
|
We load the configuration and we set a small =StopTime=.
|
|
#+begin_src matlab
|
|
load('mat/conf_simulink.mat');
|
|
set_param(conf_simulink, 'StopTime', '0.5');
|
|
#+end_src
|
|
|
|
We initialize all the stages.
|
|
#+begin_src matlab
|
|
initializeGround();
|
|
initializeGranite();
|
|
initializeTy();
|
|
initializeRy();
|
|
initializeRz();
|
|
initializeMicroHexapod();
|
|
initializeAxisc();
|
|
initializeMirror();
|
|
initializeNanoHexapod('actuator', 'piezo');
|
|
initializeSample('mass', 50);
|
|
#+end_src
|
|
|
|
** Identification
|
|
#+begin_src matlab
|
|
%% Options for Linearized
|
|
options = linearizeOptions;
|
|
options.SampleTime = 0;
|
|
|
|
%% Name of the Simulink File
|
|
mdl = 'sim_micro_station_modal_analysis';
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
%% Micro-Hexapod
|
|
% Input/Output definition
|
|
io(1) = linio([mdl, '/Micro-Station/F_hammer'],1,'openinput');
|
|
io(2) = linio([mdl, '/Micro-Station/acc9'],1,'output');
|
|
io(3) = linio([mdl, '/Micro-Station/acc10'],1,'output');
|
|
io(4) = linio([mdl, '/Micro-Station/acc11'],1,'output');
|
|
io(5) = linio([mdl, '/Micro-Station/acc12'],1,'output');
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
% Run the linearization
|
|
G_ms = linearize(mdl, io, 0);
|
|
|
|
% Input/Output names
|
|
G_ms.InputName = {'Fx', 'Fy', 'Fz'};
|
|
G_ms.OutputName = {'x9', 'y9', 'z9', ...
|
|
'x10', 'y10', 'z10', ...
|
|
'x11', 'y11', 'z11', ...
|
|
'x12', 'y12', 'z12'};
|
|
#+end_src
|
|
|
|
** Plot Results
|
|
#+begin_src matlab
|
|
figure;
|
|
hold on;
|
|
plot(freqs, abs(squeeze(freqresp(G_ms('x9', 'Fx'), freqs, 'Hz'))));
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
ylabel('Amplitude [m/N]');
|
|
hold off;
|
|
#+end_src
|
|
|
|
** Compare with measurements
|
|
#+begin_src matlab
|
|
load('../meas/modal-analysis/mat/frf_coh_matrices.mat', 'FRFs', 'COHs', 'freqs');
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
dirs = {'x', 'y', 'z'};
|
|
|
|
n_acc = 9;
|
|
n_dir = 1; % x, y, z
|
|
n_exc = 1; % x, y, z
|
|
|
|
figure;
|
|
hold on;
|
|
plot(freqs, abs(squeeze(FRFs(3*(n_acc-1) + n_dir, n_exc, :)))./((2*pi*freqs).^2)');
|
|
plot(freqs, abs(squeeze(freqresp(G_ms([dirs{n_dir}, num2str(n_acc)], ['F', dirs{n_dir}]), freqs, 'Hz'))));
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
ylabel('Amplitude [m/N]');
|
|
hold off;
|
|
#+end_src
|
|
|
|
* Some notes about the Simscape Model
|
|
The Simscape Model of the micro-station consists of several solid bodies:
|
|
- Bottom Granite
|
|
- Top Granite
|
|
- Translation Stage
|
|
- Tilt Stage
|
|
- Spindle
|
|
- Hexapod
|
|
|
|
Each solid body has some characteristics: Center of Mass, mass, moment of inertia, etc...
|
|
These parameters are automatically computed from the geometry and from the density of the materials.
|
|
|
|
Then, the solid bodies are connected with springs and dampers.
|
|
Some of the springs and dampers values can be estimated from the joints/stages specifications, however, we here prefer to tune these values based on the measurements.
|
|
|
|
* Compare with measurements at the CoM of each element
|
|
** Introduction :ignore:
|
|
[[file:../../meas/modal-analysis/index.org][here]]
|
|
|
|
** 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
|
|
simulinkproject('../');
|
|
#+end_src
|
|
|
|
** Prepare the Simulation
|
|
#+begin_src matlab
|
|
open('nass_model.slx')
|
|
#+end_src
|
|
|
|
We load the configuration.
|
|
#+begin_src matlab
|
|
load('mat/conf_simulink.mat');
|
|
#+end_src
|
|
|
|
We set a small =StopTime=.
|
|
#+begin_src matlab
|
|
set_param(conf_simulink, 'StopTime', '0.5');
|
|
#+end_src
|
|
|
|
We initialize all the stages.
|
|
#+begin_src matlab
|
|
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');
|
|
|
|
initializeController( 'type', 'open-loop');
|
|
|
|
initializeLoggingConfiguration('log', 'none');
|
|
|
|
initializeReferences();
|
|
initializeDisturbances('enable', false);
|
|
#+end_src
|
|
|
|
** Estimate the position of the CoM of each solid and compare with the one took for the Measurement Analysis
|
|
Thanks to the [[https://fr.mathworks.com/help/physmod/sm/ref/inertiasensor.html][Inertia Sensor]] simscape block, it is possible to estimate the position of the Center of Mass of a solid body with respect to a defined frame.
|
|
|
|
#+begin_src matlab
|
|
sim('nass_model')
|
|
#+end_src
|
|
|
|
The results are shown in the table [[tab:com_simscape]].
|
|
|
|
#+begin_src matlab :exports results :results value table replace :tangle no :post addhdr(*this*)
|
|
stages_com = 1e3*[granite_bot_com.Data(end, :) ;
|
|
granite_top_com.Data(end, :) ;
|
|
ty_com.Data(end, :) ;
|
|
ry_com.Data(end, :) ;
|
|
rz_com.Data(end, :) ;
|
|
hexa_com.Data(end, :) ]';
|
|
|
|
data2orgtable(stages_com, {'X [mm]', 'Y [mm]', 'Z [mm]'}, {'granite bot', 'granite top', 'ty', 'ry', 'rz', 'hexa'}, ' %.1f ');
|
|
#+end_src
|
|
|
|
#+name: tab:com_simscape
|
|
#+caption: Center of Mass of each solid body as defined in Simscape
|
|
#+RESULTS:
|
|
| | granite bot | granite top | ty | ry | rz | hexa |
|
|
|--------+-------------+-------------+--------+--------+--------+--------|
|
|
| X [mm] | 52.4 | 51.7 | 0.9 | -0.1 | 0.0 | -0.0 |
|
|
| Y [mm] | 190.4 | 263.2 | 0.7 | 5.2 | -0.0 | 0.1 |
|
|
| Z [mm] | -1200.0 | -777.1 | -598.9 | -627.7 | -643.2 | -317.1 |
|
|
|
|
We can compare the obtained center of mass (table [[tab:com_simscape]]) with the one used for the Modal Analysis shown in table [[tab:com_solidworks]].
|
|
|
|
#+name: tab:com_solidworks
|
|
#+caption: Estimated Center of Mass of each solid body using Solidworks
|
|
| | granite bot | granite top | ty | ry | rz | hexa |
|
|
|--------+-------------+-------------+------+------+------+------|
|
|
| X [mm] | 45 | 52 | 0 | 0 | 0 | -4 |
|
|
| Y [mm] | 144 | 258 | 14 | -5 | 0 | 6 |
|
|
| Z [mm] | -1251 | -778 | -600 | -628 | -580 | -319 |
|
|
|
|
The results are quite similar.
|
|
The differences can be explained by some differences in the chosen density of the materials or by the fact that not exactly all the same elements have been chosen for each stage.
|
|
|
|
For instance, on simscape, the fixed part of the translation stage counts for the top granite solid body.
|
|
However, in SolidWorks, this has probably not be included with the top granite.
|
|
|
|
** Create a frame at the CoM of each solid body
|
|
Now we use one =inertiasensor= block connected on each solid body that measured the center of mass of this solid with respect to the same connected frame.
|
|
|
|
We do that in order to position an accelerometer on the Simscape model at this particular point.
|
|
|
|
#+begin_src matlab
|
|
open('identification/matlab/sim_micro_station_com_estimation.slx')
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
sim('sim_micro_station_com_estimation')
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports results :results value table replace :tangle no :post addhdr(*this*)
|
|
stages_com = 1e3*[granite_bot_com.Data(end, :) ;
|
|
granite_top_com.Data(end, :) ;
|
|
ty_com.Data(end, :) ;
|
|
ry_com.Data(end, :) ;
|
|
rz_com.Data(end, :) ;
|
|
hexa_com.Data(end, :) ]';
|
|
|
|
data2orgtable(stages_com, {'X [mm]', 'Y [mm]', 'Z [mm]'}, {'granite bot', 'granite top', 'ty', 'ry', 'rz', 'hexa'}, ' %.1f ');
|
|
#+end_src
|
|
|
|
#+RESULTS:
|
|
| | granite bot | granite top | ty | ry | rz | hexa |
|
|
|--------+-------------+-------------+-------+--------+-------+-------|
|
|
| X [mm] | 0.0 | 51.7 | 0.9 | -0.1 | 0.0 | -0.0 |
|
|
| Y [mm] | 0.0 | 753.2 | 0.7 | 5.2 | -0.0 | 0.1 |
|
|
| Z [mm] | -250.0 | 22.9 | -17.1 | -146.5 | -23.2 | -47.1 |
|
|
|
|
We now same this for further use:
|
|
#+begin_src matlab
|
|
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');
|
|
#+end_src
|
|
|
|
Then, we use the obtained results to add a =rigidTransform= block in order to create a new frame at the center of mass of each solid body.
|
|
|
|
** Identification of the dynamics of the Simscape Model
|
|
We now use a new Simscape Model where 6DoF inertial sensors are located at the Center of Mass of each solid body.
|
|
|
|
#+begin_src matlab
|
|
% load('mat/solids_com.mat', 'granite_bot_com', 'granite_top_com', 'ty_com', 'ry_com', 'rz_com', 'hexa_com');
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
open('nass_model.slx')
|
|
#+end_src
|
|
|
|
We use the =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.
|
|
#+begin_src matlab
|
|
%% Options for Linearized
|
|
options = linearizeOptions;
|
|
options.SampleTime = 0;
|
|
|
|
%% Name of the Simulink File
|
|
mdl = 'nass_model';
|
|
|
|
%% 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;
|
|
#+end_src
|
|
|
|
#+begin_src matlab
|
|
% Run the linearization
|
|
G_ms = linearize(mdl, io, 0);
|
|
|
|
%% Input/Output definition
|
|
clear io; io_i = 1;
|
|
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'};
|
|
#+end_src
|
|
|
|
The output of =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}$;
|
|
#+begin_src matlab
|
|
G_ms = G_ms/s^2;
|
|
#+end_src
|
|
|
|
** Compare with measurements
|
|
We now load the Frequency Response Functions measurements during the Modal Analysis (accessible [[file:../../meas/modal-analysis/index.org][here]]).
|
|
|
|
#+begin_src matlab
|
|
load('../meas/modal-analysis/mat/frf_coh_matrices.mat', 'freqs');
|
|
load('../meas/modal-analysis/mat/frf_com.mat', 'FRFs_CoM');
|
|
#+end_src
|
|
|
|
We then compare the measurements with the identified transfer functions using the Simscape Model.
|
|
|
|
#+begin_src matlab :exports none
|
|
dirs = {'x', 'y', 'z', 'rx', 'ry', 'rz'};
|
|
stages = {'gbot', 'gtop', 'ty', 'ry', 'rz', 'hexa'}
|
|
|
|
n_stg = 3;
|
|
n_dir = 6; % x, y, z, Rx, Ry, Rz
|
|
n_exc = 2; % x, y, z
|
|
|
|
f = logspace(0, 3, 1000);
|
|
|
|
figure;
|
|
hold on;
|
|
plot(freqs, abs(squeeze(FRFs_CoM(6*(n_stg-1) + n_dir, n_exc, :)))./((2*pi*freqs).^2)');
|
|
plot(f, abs(squeeze(freqresp(G_ms([stages{n_stg}, '_', dirs{n_dir}], ['F', dirs{n_exc}]), f, 'Hz'))));
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
ylabel('Amplitude [m/N]');
|
|
hold off;
|
|
xlim([1, 200]);
|
|
#+end_src
|
|
|
|
#+begin_src matlab :exports none
|
|
dirs = {'x', 'y', 'z', 'rx', 'ry', 'rz'};
|
|
stages = {'gtop', 'ty', 'ry', 'rz', 'hexa'}
|
|
|
|
f = logspace(1, 3, 1000);
|
|
|
|
figure;
|
|
for n_stg = 1:2
|
|
for n_dir = 1:3
|
|
subplot(3, 2, (n_dir-1)*2 + n_stg);
|
|
title(['F ', dirs{n_dir}, ' to ', stages{n_stg}, ' ', dirs{n_dir}]);
|
|
hold on;
|
|
plot(freqs, abs(squeeze(FRFs_CoM(6*(n_stg) + n_dir, n_dir, :)))./((2*pi*freqs).^2)');
|
|
plot(f, abs(squeeze(freqresp(G_ms([stages{n_stg}, '_', dirs{n_dir}], ['F', dirs{n_dir}]), f, 'Hz'))));
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
ylabel('Amplitude [m/N]');
|
|
if n_dir == 3
|
|
xlabel('Frequency [Hz]');
|
|
end
|
|
hold off;
|
|
xlim([10, 1000]);
|
|
ylim([1e-12, 1e-6]);
|
|
end
|
|
end
|
|
#+end_src
|
|
|
|
#+HEADER: :tangle no :exports results :results none :noweb yes
|
|
#+begin_src matlab :var filepath="figs/identification_comp_bot_stages.pdf" :var figsize="full-tall" :post pdf2svg(file=*this*, ext="png")
|
|
<<plt-matlab>>
|
|
#+end_src
|
|
|
|
#+NAME: fig:identification_comp_bot_stages
|
|
#+CAPTION: caption ([[./figs/identification_comp_bot_stages.png][png]], [[./figs/identification_comp_bot_stages.pdf][pdf]])
|
|
[[file:figs/identification_comp_bot_stages.png]]
|
|
|
|
|
|
#+begin_src matlab :exports none
|
|
dirs = {'x', 'y', 'z', 'rx', 'ry', 'rz'};
|
|
stages = {'ry', 'rz', 'hexa'}
|
|
|
|
f = logspace(1, 3, 1000);
|
|
|
|
figure;
|
|
for n_stg = 1:2
|
|
for n_dir = 1:3
|
|
subplot(3, 2, (n_dir-1)*2 + n_stg);
|
|
title(['F ', dirs{n_dir}, ' to ', stages{n_stg}, ' ', dirs{n_dir}]);
|
|
hold on;
|
|
plot(freqs, abs(squeeze(FRFs_CoM(6*(n_stg+2) + n_dir, n_dir, :)))./((2*pi*freqs).^2)');
|
|
plot(f, abs(squeeze(freqresp(G_ms([stages{n_stg}, '_', dirs{n_dir}], ['F', dirs{n_dir}]), f, 'Hz'))));
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
ylabel('Amplitude [m/N]');
|
|
if n_dir == 3
|
|
xlabel('Frequency [Hz]');
|
|
end
|
|
hold off;
|
|
xlim([10, 1000]);
|
|
ylim([1e-12, 1e-6]);
|
|
end
|
|
end
|
|
#+end_src
|
|
|
|
#+HEADER: :tangle no :exports results :results none :noweb yes
|
|
#+begin_src matlab :var filepath="figs/identification_comp_mid_stages.pdf" :var figsize="full-tall" :post pdf2svg(file=*this*, ext="png")
|
|
<<plt-matlab>>
|
|
#+end_src
|
|
|
|
#+NAME: fig:identification_comp_mid_stages
|
|
#+CAPTION: caption ([[./figs/identification_comp_mid_stages.png][png]], [[./figs/identification_comp_mid_stages.pdf][pdf]])
|
|
[[file:figs/identification_comp_mid_stages.png]]
|
|
|
|
|
|
#+begin_src matlab :exports none
|
|
dirs = {'x', 'y', 'z', 'rx', 'ry', 'rz'};
|
|
stages = {'hexa'}
|
|
|
|
f = logspace(1, 3, 1000);
|
|
|
|
figure;
|
|
for n_stg = 1
|
|
for n_dir = 1:3
|
|
subplot(3, 1, (n_dir-1) + n_stg);
|
|
title(['F ', dirs{n_dir}, ' to ', stages{n_stg}, ' ', dirs{n_dir}]);
|
|
hold on;
|
|
plot(freqs, abs(squeeze(FRFs_CoM(6*(n_stg+4) + n_dir, n_dir, :)))./((2*pi*freqs).^2)');
|
|
plot(f, abs(squeeze(freqresp(G_ms([stages{n_stg}, '_', dirs{n_dir}], ['F', dirs{n_dir}]), f, 'Hz'))));
|
|
set(gca, 'XScale', 'log'); set(gca, 'YScale', 'log');
|
|
ylabel('Amplitude [m/N]');
|
|
if n_dir == 3
|
|
xlabel('Frequency [Hz]');
|
|
end
|
|
hold off;
|
|
xlim([10, 1000]);
|
|
ylim([1e-12, 1e-6]);
|
|
end
|
|
end
|
|
#+end_src
|
|
|
|
#+HEADER: :tangle no :exports results :results none :noweb yes
|
|
#+begin_src matlab :var filepath="figs/identification_comp_top_stages.pdf" :var figsize="full-tall" :post pdf2svg(file=*this*, ext="png")
|
|
<<plt-matlab>>
|
|
#+end_src
|
|
|
|
#+NAME: fig:identification_comp_top_stages
|
|
#+CAPTION: caption ([[./figs/identification_comp_top_stages.png][png]], [[./figs/identification_comp_top_stages.pdf][pdf]])
|
|
[[file:figs/identification_comp_top_stages.png]]
|
|
|
|
|
|
* Conclusion
|
|
#+begin_important
|
|
For such a complex system, we believe that the Simscape Model represents the dynamics of the system with enough fidelity.
|
|
#+end_important
|