2019-07-03 13:54:33 +02:00
#+TITLE : Modal Analysis - Modal Parameter Extraction
2019-07-02 17:48:34 +02:00
:DRAWER:
#+STARTUP : overview
#+LANGUAGE : en
#+EMAIL : dehaeze.thomas@gmail.com
#+AUTHOR : Dehaeze Thomas
#+HTML_LINK_HOME : ../index.html
2019-07-03 17:25:44 +02:00
#+HTML_LINK_UP : ./index.html
2019-07-02 17:48:34 +02:00
#+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
2019-07-05 11:20:02 +02:00
#+PROPERTY : header-args:matlab+ :tangle matlab/modal_extraction.m
#+PROPERTY : header-args:matlab+ :mkdirp yes
2019-07-02 17:48:34 +02:00
#+PROPERTY : header-args:shell :eval no-export
#+PROPERTY : header-args:latex :headers '("\\usepackage{tikz}" "\\usepackage{import}" "\\import{$HOME/MEGA/These/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:
2019-07-05 16:58:15 +02:00
* Introduction :ignore:
The goal here is to extract the modal parameters describing the modes of station being studied, namely:
- the eigen frequencies
- the modal damping
- the mode shapes (eigen vectors)
This is done from the FRF matrix previously extracted from the measurements.
In order to do the modal parameter extraction, we first have to estimate the order of the modal model we want to obtain.
This corresponds to how many modes are present in the frequency band of interest.
In section [[sec:number_of_modes ]], we will use the Singular Value Decomposition and the Modal Indication Function to estimate the number of modes.
The modal parameter extraction methods generally consists of *curve-fitting a theoretical expression for an individual FRF to the actual measured data* .
However, there are multiple level of complexity:
- works on a part of a single FRF curve
- works on a complete curve encompassing several resonances
- works on a set of many FRF plots all obtained from the same structure
The third method is the most complex but gives better results. This is the one we will use in section [[sec:modal_extraction ]].
From the modal model, it is possible to obtain a graphic display of the mode shapes (section [[sec:mode_shape_display ]]).
The modes of the structure are expected to be complex, however real modes are easier to work with when it comes to obtain a spatial model from the modal parameters.
We will thus study the complexity of those modes, in section [[sec:modal_complexity ]], and see if we can estimate real modes from the complex modes.
The mode obtained from the modal software describe the motion of the structure at the position of each accelerometer for all the modes.
However, we would like to describe the motion of each stage (solid body) of the structure in its 6 DOFs.
This in done in section [[sec:global_mode_shapes ]].
2019-07-05 11:20:02 +02:00
* ZIP file containing the data and matlab files :ignore:
#+begin_src bash :exports none :results none
if [ matlab/modal_extraction.m -nt data/modal_extraction.zip ]; then
cp matlab/modal_extraction.m modal_extraction.m;
zip data/modal_extraction \
2019-07-05 16:58:15 +02:00
mat/frf_coh_matrices.mat \
mat/frf_o.mat \
mat/mode_shapes.txt \
mat/mode_freqs.txt \
mat/mode_damps.txt \
mat/mode_modal_a.txt \
mat/mode_modal_b.txt \
2019-07-05 11:20:02 +02:00
modal_extraction.m
rm modal_extraction.m;
fi
#+end_src
#+begin_note
All the files (data and Matlab scripts) are accessible [[file:data/modal_extraction.zip ][here ]].
#+end_note
2019-07-02 17:48:34 +02:00
* 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
2019-07-05 16:58:15 +02:00
* Load Data
#+begin_src matlab
load('mat/frf_coh_matrices.mat', 'FRFs', 'COHs', 'freqs');
load('mat/frf_o.mat', 'FRFs_O');
#+end_src
* Determine the number of modes
<<sec:number_of_modes >>
** Singular Value Decomposition - Modal Indication Function
The Mode Indicator Functions are usually used on $n\times p$ FRF matrix where $n$ is a relatively large number of measurement DOFs and $p$ is the number of excitation DOFs, typically 3 or 4.
In these methods, the frequency dependent FRF matrix is subjected to a singular value decomposition analysis which thus yields a small number (3 or 4) of singular values, these also being frequency dependent.
These methods are used to *determine the number of modes* present in a given frequency range, to *identify repeated natural frequencies* and to pre process the FRF data prior to modal analysis.
From the documentation of the modal software:
#+begin_quote
The MIF consist of the singular values of the Frequency response function matrix. The number of MIFs equals the number of excitations.
By the powerful singular value decomposition, the real signal space is separated from the noise space. Therefore, the MIFs exhibit the modes effectively.
A peak in the MIFs plot usually indicate the existence of a structural mode, and two peaks at the same frequency point means the existence of two repeated modes.
Moreover, the magnitude of the MIFs implies the strength of the a mode.
#+end_quote
#+begin_important
The *Complex Mode Indicator Function* is defined simply by the SVD of the FRF (sub) matrix:
\begin{align*}
[H(\omega)]_{n\times p} &= [U(\omega)]_ {n\times n} [\Sigma(\omega)]_{n\times p} [V(\omega)]_ {p\times p}^H\\
[CMIF(\omega)]_{p\times p} &= [\Sigma(\omega)]_ {p\times n}^T [\Sigma(\omega)]_{n\times p}
\end{align*}
#+end_important
We compute the Complex Mode Indicator Function. The result is shown on figure [[fig:cmif ]].
The exact same curve is obtained when computed using the OROS software.
#+begin_src matlab
MIF = zeros(size(FRFs, 2), size(FRFs, 2), size(FRFs, 3));
for i = 1:length(freqs)
[~,S,~ ] = svd(FRFs(:, :, i));
MIF(:, :, i) = S'*S;
end
#+end_src
#+begin_src matlab :exports none
figure;
hold on;
for i = 1:size(MIF, 1)
plot(freqs, squeeze(MIF(i, i, :)), 'DisplayName', sprintf('MDIF - %i', i));
end
hold off;
set(gca, 'Yscale', 'log');
xlabel('Frequency [Hz]'); ylabel('CMIF Amplitude');
xlim([1, 200]);
legend('location', 'southeast');
#+end_src
#+HEADER : :tangle no :exports results :results none :noweb yes
#+begin_src matlab :var filepath="figs/cmif.pdf" :var figsize= "full-tall" :post pdf2svg(file=*this*, ext= "png")
<<plt-matlab >>
#+end_src
#+NAME : fig:cmif
#+CAPTION : Complex Mode Indicator Function
[[file:figs/cmif.png ]]
We can also compute the CMIF using the FRF matrix expressed in the same global frame.
We compare the two CMIF on figure [[fig:cmif_compare ]].
They do not indicate the same resonance frequencies, especially around 110Hz.
#+begin_src matlab
MIF_O = zeros(size(FRFs_O, 2), size(FRFs_O, 2), size(FRFs_O, 3));
for i = 1:length(freqs)
[~,S,~ ] = svd(FRFs_O(:, :, i));
MIF_O(:, :, i) = S'*S;
end
#+end_src
#+begin_src matlab :exports none
figure;
hold on;
for i = 1:size(MIF, 1)
set(gca,'ColorOrderIndex',i)
plot(freqs, squeeze(MIF(i, i, :)), '-');
set(gca,'ColorOrderIndex',i)
plot(freqs, squeeze(MIF_O(i, i, :)), '--');
end
hold off;
set(gca, 'Yscale', 'log');
xlabel('Frequency [Hz]'); ylabel('CMIF Amplitude');
xlim([1, 200]);
#+end_src
#+HEADER : :tangle no :exports results :results none :noweb yes
#+begin_src matlab :var filepath="figs/cmif_compare.pdf" :var figsize= "full-tall" :post pdf2svg(file=*this*, ext= "png")
<<plt-matlab >>
#+end_src
#+NAME : fig:cmif_compare
#+CAPTION : Complex Mode Indicator Function - Original FRF: solid curves - Processed FRF: dashed curve
[[file:figs/cmif_compare.png ]]
** Composite Response Function
An alternative is the Composite Response Function $HH(\omega)$ defined as the sum of all the measured FRF:
\begin{equation}
HH(\omega) = \sum_j\sum_kH_ {jk}(\omega)
\end{equation}
Instead, we choose here to use the sum of the norms of the measured FRFs:
\begin{equation}
HH(\omega) = \sum_j\sum_k \left|H_ {jk}(\omega) \right|
\end{equation}
The result is shown on figure [[fig:composite_response_function ]].
#+begin_src matlab
figure;
hold on;
plot(freqs, squeeze(sum(sum(abs(FRFs)))), '-k');
plot(freqs, squeeze(sum(sum(abs(FRFs_O)))), '--k');
hold off;
xlabel('Frequency [Hz]'); ylabel('Amplitude');
xlim([1, 200]);
#+end_src
#+HEADER : :tangle no :exports results :results none :noweb yes
#+begin_src matlab :var filepath="figs/composite_response_function.pdf" :var figsize= "full-tall" :post pdf2svg(file=*this*, ext= "png")
<<plt-matlab >>
#+end_src
#+NAME : fig:composite_response_function
#+CAPTION : Composite Response Function. Solid curve: computed from the original FRFs. Dashed curve: computed from the FRFs expressed in the global frame.
[[file:figs/composite_response_function.png ]]
* Modal parameter extraction
<<sec:modal_extraction >>
** OROS - Modal software
Modal identification can be done within the [[https://www.oros.com/solutions/structural-dynamics/modal-analysis/ ][Modal software of OROS ]]. The manual for the software is available [[file:data/oros_modal_manual.pdf ][here ]].
Several modal parameter extraction methods are available.
We choose to use the "broad band method" as it permits to identify the modal parameters using all the FRF curves at the same times.
It takes into account the fact the the properties of all the individual curves are related by being from the same structure: all FRF plots on a given structure should indicate the same values for the natural frequencies and damping factor of each mode.
Such method also have the advantage of producing a unique and consistent model as direct output.
In order to apply this method, we select the frequency range of interest and we give an estimate of how many modes are present.
2019-07-03 17:25:44 +02:00
2019-07-05 16:58:15 +02:00
Then, it shows a stabilization charts, such as the one shown on figure [[fig:stabilization_chart ]], where we have to manually select which modes to take into account in the modal model.
#+name : fig:stabilization_chart
#+caption : Stabilization Chart
[[file:figs/stabilisation_chart.jpg ]]
We can then run the modal analysis, and the software will identify the modal damping and mode shapes at the selected frequency modes.
** Exported modal parameters
The obtained modal parameters are:
2019-07-03 17:25:44 +02:00
- the resonance frequencies
- the modes shapes
- the modal damping
- the residues
2019-07-05 16:58:15 +02:00
They are all exported in a text file named =modes.asc= .
Its first 20 lines as shown below.
2019-07-03 17:25:44 +02:00
#+begin_src bash :results output :exports results :eval no-export
sed 20q mat/modes.asc | sed $'s/ \r//'
#+end_src
#+RESULTS :
#+begin_example
Created by N-Modal
Estimator: bbfd
01-Jul-19 16:44:11
Mode 1
freq = 11.41275Hz
damp = 8.72664%
modal A = -4.50556e+003-9.41744e+003i
modal B = -7.00928e+005+2.62922e+005i
Mode matrix of local coordinate [DOF: Re IM]
1X-: -1.04114e-001 3.50664e-002
1Y-: 2.34008e-001 5.04273e-004
1Z+: -1.93303e-002 5.08614e-003
2X-: -8.38439e-002 3.45978e-002
2Y-: 2.42440e-001 0.00000e+000
2Z+: -7.40734e-003 5.17734e-003
3Y-: 2.17655e-001 6.10802e-003
3X+: 1.18685e-001 -3.54602e-002
3Z+: -2.37725e-002 -1.61649e-003
#+end_example
We split this big =modes.asc= file into sub text files using =bash= . The obtained files are described one table [[tab:modes_files ]].
#+begin_src bash :results none
sed '/^\s*[0-9]*[XYZ][+-]:/ !d' mat/modes.asc > mat/mode_shapes.txt
sed '/freq/ !d' mat/modes.asc | sed 's/ .* = \(.*\)Hz/\1/ ' > mat/mode_freqs.txt
sed '/damp/ !d' mat/modes.asc | sed 's/ .* = \(.*\)\%/\1/ ' > mat/mode_damps.txt
sed '/modal A/ !d' mat/modes.asc | sed 's/ .* =\s\+\([-0-9.e]\+ +[0-9]\+ \)\([-+0-9.e]\+ \)i/\1 \2/ ' > mat/mode_modal_a.txt
sed '/modal B/ !d' mat/modes.asc | sed 's/ .* =\s\+\([-0-9.e]\+ +[0-9]\+ \)\([-+0-9.e]\+ \)i/\1 \2/ ' > mat/mode_modal_b.txt
#+end_src
#+name : tab:modes_files
#+caption : Split =modes.asc= file
| Filename | Content |
|------------------------+--------------------------------------------------|
| =mat/mode_shapes.txt= | mode shapes |
| =mat/mode_freqs.txt= | resonance frequencies |
| =mat/mode_damps.txt= | modal damping |
| =mat/mode_modal_a.txt= | modal residues at low frequency (to be checked) |
| =mat/mode_modal_b.txt= | modal residues at high frequency (to be checked) |
2019-07-05 16:58:15 +02:00
** Importation of the modal parameters on Matlab
2019-07-03 17:25:44 +02:00
Then we import the obtained =.txt= files on Matlab using =readtable= function.
#+begin_src matlab
shapes = readtable('mat/mode_shapes.txt', 'ReadVariableNames', false); % [Sign / Real / Imag]
freqs = table2array(readtable('mat/mode_freqs.txt', 'ReadVariableNames', false)); % in [Hz]
damps = table2array(readtable('mat/mode_damps.txt', 'ReadVariableNames', false)); % in [%]
modal_a = table2array(readtable('mat/mode_modal_a.txt', 'ReadVariableNames', false)); % [Real / Imag]
modal_b = table2array(readtable('mat/mode_modal_b.txt', 'ReadVariableNames', false)); % [Real / Imag]
modal_a = complex(modal_a(:, 1), modal_a(:, 2));
modal_b = complex(modal_b(:, 1), modal_b(:, 2));
#+end_src
We guess the number of modes identified from the length of the imported data.
#+begin_src matlab
acc_n = 23; % Number of accelerometers
dir_n = 3; % Number of directions
dirs = 'XYZ';
mod_n = size(shapes,1)/acc_n/dir_n; % Number of modes
#+end_src
As the mode shapes are split into 3 parts (direction plus sign, real part and imaginary part), we aggregate them into one array of complex numbers.
#+begin_src matlab
T_sign = table2array(shapes(:, 1));
T_real = table2array(shapes(:, 2));
T_imag = table2array(shapes(:, 3));
modes = zeros(mod_n, acc_n, dir_n);
for mod_i = 1:mod_n
for acc_i = 1:acc_n
% Get the correct section of the signs
T = T_sign(acc_n*dir_n* (mod_i-1)+1:acc_n*dir_n*mod_i);
for dir_i = 1:dir_n
% Get the line corresponding to the sensor
i = find(contains(T, sprintf('%i%s',acc_i, dirs(dir_i))), 1, 'first')+acc_n*dir_n* (mod_i-1);
modes(mod_i, acc_i, dir_i) = str2num([T_sign{i}(end-1), '1'])*complex(T_real(i),T_imag(i));
end
end
end
#+end_src
The obtained mode frequencies and damping are shown below.
2019-07-05 16:58:15 +02:00
#+begin_src matlab :exports results :results value table replace :tangle no :post addhdr(*this* )
data2orgtable([(1:length(freqs))', freqs, damps], {}, {'Mode number', 'Frequency [Hz]', 'Damping [%]'}, ' %.1f ');
2019-07-03 17:25:44 +02:00
#+end_src
2019-07-05 16:58:15 +02:00
#+name : tab:obtained_modes_freqs_damps
#+caption : Obtained eigen frequencies and modal damping
2019-07-03 17:25:44 +02:00
#+RESULTS :
2019-07-05 16:58:15 +02:00
| Mode number | Frequency [Hz] | Damping [%] |
|-------------+----------------+-------------|
| 1.0 | 11.4 | 8.7 |
| 2.0 | 18.5 | 11.8 |
| 3.0 | 37.6 | 6.4 |
| 4.0 | 39.4 | 3.6 |
| 5.0 | 54.0 | 0.2 |
| 6.0 | 56.1 | 2.8 |
| 7.0 | 69.7 | 4.6 |
| 8.0 | 71.6 | 0.6 |
| 9.0 | 72.4 | 1.6 |
| 10.0 | 84.9 | 3.6 |
| 11.0 | 90.6 | 0.3 |
| 12.0 | 91.0 | 2.9 |
| 13.0 | 95.8 | 3.3 |
| 14.0 | 105.4 | 3.3 |
| 15.0 | 106.8 | 1.9 |
| 16.0 | 112.6 | 3.0 |
| 17.0 | 116.8 | 2.7 |
| 18.0 | 124.1 | 0.6 |
| 19.0 | 145.4 | 1.6 |
| 20.0 | 150.1 | 2.2 |
| 21.0 | 164.7 | 1.4 |
** Modal Matrices
We arrange the obtained modal parameters into matrices:
\[ \Omega = \begin{bmatrix}
\omega_1^2 & & 0 \\
& \ddots & \\
0 & & \omega_n^2
\end{bmatrix}; \quad \Psi = \begin{bmatrix}
& & \\
\{\psi_1\} & \dots & \{\psi_n\} \\
& &
\end{bmatrix} \]
with $n$ the number of identified modes and:
\[ \{\psi_1\} = \begin{Bmatrix} \psi_ {1_x} & \psi_ {2_x} & \dots & \psi_ {23_x} & \psi_ {1_y} & \dots & \psi_ {1_z} & \dots & \psi_ {23_z} \end{Bmatrix}^T \]
2019-07-03 17:25:44 +02:00
2019-07-05 16:58:15 +02:00
#+begin_src matlab
eigen_value_M = diag(freqs*2*pi);
eigen_vector_M = reshape(modes, [mod_n, acc_n*dir_n])';
#+end_src
2019-07-05 10:16:33 +02:00
2019-07-05 16:58:15 +02:00
Each eigen vector is normalized: $\| \{\psi_i\}\} \|_2 = 1$
2019-07-05 10:16:33 +02:00
2019-07-05 16:58:15 +02:00
* Obtained Mode Shapes animations
<<sec:mode_shape_display >>
From the modal parameters, it is possible to show the modal shapes with an animation.
2019-07-05 10:16:33 +02:00
Examples are shown on figures [[fig:mode1 ]] and [[fig:mode6 ]].
Animations of all the other modes are accessible using the following links: [[file:img/modes/mode1.gif ][mode 1 ]], [[file:img/modes/mode2.gif ][mode 2 ]], [[file:img/modes/mode3.gif ][mode 3 ]], [[file:img/modes/mode4.gif ][mode 4 ]], [[file:img/modes/mode5.gif ][mode 5 ]], [[file:img/modes/mode6.gif ][mode 6 ]], [[file:img/modes/mode7.gif ][mode 7 ]], [[file:img/modes/mode8.gif ][mode 8 ]], [[file:img/modes/mode9.gif ][mode 9 ]], [[file:img/modes/mode10.gif ][mode 10 ]], [[file:img/modes/mode11.gif ][mode 11 ]], [[file:img/modes/mode12.gif ][mode 12 ]], [[file:img/modes/mode13.gif ][mode 13 ]], [[file:img/modes/mode14.gif ][mode 14 ]], [[file:img/modes/mode15.gif ][mode 15 ]], [[file:img/modes/mode16.gif ][mode 16 ]], [[file:img/modes/mode17.gif ][mode 17 ]], [[file:img/modes/mode18.gif ][mode 18 ]], [[file:img/modes/mode19.gif ][mode 19 ]], [[file:img/modes/mode20.gif ][mode 20 ]], [[file:img/modes/mode21.gif ][mode 21 ]].
#+name : fig:mode1
#+caption : Mode 1
[[file:img/modes/mode1.gif ]]
#+name : fig:mode6
#+caption : Mode 6
[[file:img/modes/mode6.gif ]]
2019-07-05 16:58:15 +02:00
We can learn quite a lot from these mode shape animations.
2019-07-03 17:25:44 +02:00
2019-07-05 16:58:15 +02:00
For instance, the mode shape of the first mode at 11Hz (figure [[fig:mode1 ]]) seems to indicate that this corresponds to a suspension mode.
2019-07-03 17:25:44 +02:00
2019-07-05 16:58:15 +02:00
This could be due to the 4 Airloc Levelers that are used for the granite (figure [[fig:airloc ]]).
2019-07-03 17:25:44 +02:00
2019-07-05 16:58:15 +02:00
#+name : fig:airloc
#+caption : AirLoc used for the granite (2120-KSKC)
#+attr_html : :width 500px
[[file:img/airloc/IMG_20190618_155522.jpg ]]
2019-07-03 17:25:44 +02:00
2019-07-05 16:58:15 +02:00
They are probably *not well leveled* , so the granite is supported only by two Airloc.
2019-07-03 17:25:44 +02:00
2019-07-05 16:58:15 +02:00
* Modal Complexity
<<sec:modal_complexity >>
A method of displaying *modal complexity* is by plotting the elements of the eigenvector on an *Argand diagram* (complex plane), such as the ones shown in figure [[fig:modal_complexity_small ]].
2019-07-03 17:25:44 +02:00
2019-07-05 16:58:15 +02:00
To evaluate the complexity of the modes, we plot a polygon around the extremities of the individual vectors.
The obtained area of this polygon is then compared with the area of the circle which is based on the length of the largest vector element. The resulting ratio is used as an *indication of the complexity of the mode* .
2019-07-03 17:25:44 +02:00
2019-07-05 16:58:15 +02:00
A mode with small complexity is shown on figure [[fig:modal_complexity_small ]] whereas an highly complex mode is shown on figure [[fig:modal_complexity_high ]].
The complexity of all the modes are compared on figure [[fig:modal_complexities ]].
2019-07-03 17:25:44 +02:00
2019-07-05 16:58:15 +02:00
#+begin_src matlab :exports none
2019-07-03 17:25:44 +02:00
figure;
2019-07-05 16:58:15 +02:00
mod_i = 1;
i_max = convhull(real(eigen_vector_M(:, mod_i)), imag(eigen_vector_M(:, mod_i)));
radius = max(abs(eigen_vector_M(:, mod_i)));
theta = linspace(0, 2*pi, 100);
2019-07-03 17:25:44 +02:00
hold on;
2019-07-05 16:58:15 +02:00
plot(radius*cos(theta), radius*sin(theta), '-');
plot(real(eigen_vector_M(i_max, mod_i)), imag(eigen_vector_M(i_max, mod_i)), '-');
plot(real(eigen_vector_M(:, mod_i)), imag(eigen_vector_M(:, mod_i)), 'ko');
2019-07-03 17:25:44 +02:00
hold off;
2019-07-05 16:58:15 +02:00
xlabel('Real Part'); ylabel('Imaginary Part');
title(sprintf('Mode %i', mod_i));
axis manual equal
2019-07-03 17:25:44 +02:00
#+end_src
2019-07-05 16:58:15 +02:00
#+HEADER : :tangle no :exports results :results none :noweb yes
#+begin_src matlab :var filepath="figs/modal_complexity_small.pdf" :var figsize= "normal-normal" :post pdf2svg(file=*this*, ext= "png")
<<plt-matlab >>
2019-07-03 17:25:44 +02:00
#+end_src
2019-07-05 16:58:15 +02:00
#+NAME : fig:modal_complexity_small
#+CAPTION : Modal Complexity of one mode with small complexity
[[file:figs/modal_complexity_small.png ]]
2019-07-03 17:25:44 +02:00
2019-07-05 16:58:15 +02:00
#+begin_src matlab :exports none
mod_i = 8;
i_max = convhull(real(eigen_vector_M(:, mod_i)), imag(eigen_vector_M(:, mod_i)));
radius = max(abs(eigen_vector_M(:, mod_i)));
theta = linspace(0, 2*pi, 100);
2019-07-03 17:25:44 +02:00
figure;
hold on;
2019-07-05 16:58:15 +02:00
plot(radius*cos(theta), radius*sin(theta), '-');
plot(real(eigen_vector_M(i_max, mod_i)), imag(eigen_vector_M(i_max, mod_i)), '-');
plot(real(eigen_vector_M(:, mod_i)), imag(eigen_vector_M(:, mod_i)), 'ko');
2019-07-03 17:25:44 +02:00
hold off;
2019-07-05 16:58:15 +02:00
xlabel('Real Part'); ylabel('Imaginary Part');
title(sprintf('Mode %i', mod_i));
2019-07-03 17:25:44 +02:00
axis manual equal
#+end_src
2019-07-05 16:58:15 +02:00
#+HEADER : :tangle no :exports results :results none :noweb yes
#+begin_src matlab :var filepath="figs/modal_complexity_high.pdf" :var figsize= "normal-normal" :post pdf2svg(file=*this*, ext= "png")
<<plt-matlab >>
2019-07-02 17:48:34 +02:00
#+end_src
2019-07-05 16:58:15 +02:00
#+NAME : fig:modal_complexity_high
#+CAPTION : Modal Complexity of one higly complex mode
[[file:figs/modal_complexity_high.png ]]
2019-07-02 17:48:34 +02:00
2019-07-05 16:58:15 +02:00
#+begin_src matlab :exports none
modes_complexity = zeros(mod_n, 1);
2019-07-02 17:48:34 +02:00
for mod_i = 1:mod_n
2019-07-05 16:58:15 +02:00
i = convhull(real(eigen_vector_M(:, mod_i)), imag(eigen_vector_M(:, mod_i)));
area_complex = polyarea(real(eigen_vector_M(i, mod_i)), imag(eigen_vector_M(i, mod_i)));
area_circle = pi*max(abs(eigen_vector_M(:, mod_i)))^2;
modes_complexity(mod_i) = area_complex/area_circle;
2019-07-02 17:48:34 +02:00
end
2019-07-05 16:58:15 +02:00
figure;
plot(1:mod_n, modes_complexity, 'ok');
ylim([0, 1]);
xlabel('Mode Number'); ylabel('Modal Complexity');
2019-07-02 17:48:34 +02:00
#+end_src
2019-07-05 16:58:15 +02:00
#+HEADER : :tangle no :exports results :results none :noweb yes
#+begin_src matlab :var filepath="figs/modal_complexities.pdf" :var figsize= "wide-normal" :post pdf2svg(file=*this*, ext= "png")
<<plt-matlab >>
2019-07-02 17:48:34 +02:00
#+end_src
2019-07-05 16:58:15 +02:00
#+NAME : fig:modal_complexities
#+CAPTION : Modal complexity for each mode
[[file:figs/modal_complexities.png ]]
2019-07-02 17:48:34 +02:00
2019-07-05 16:58:15 +02:00
* BKMK From local coordinates to global coordinates for the mode shapes
<<sec:global_mode_shapes >>
** Mathematical description
2019-07-02 17:48:34 +02:00
#+begin_src latex :file local_to_global_coordinates.pdf :post pdf2svg(file=*this*, ext= "png") :exports results
\newcommand\irregularcircle[2]{% radius, irregularity
\pgfextra {\pgfmathsetmacro\len{(#1)+rand*(#2)}}
+(0:\len pt)
\foreach \a in {10,20,...,350}{
\pgfextra {\pgfmathsetmacro\len{(#1)+rand*(#2)}}
-- +(\a:\len pt)
} -- cycle
}
\begin{tikzpicture}
\draw[rounded corners=1mm] (0, 0) \irregularcircle{3cm}{1mm};
\node[] (origin) at (4, -1) {$\bullet$};
\begin{scope}[shift={(origin)}]
\def\axissize{0.8cm}
\draw[->] (0, 0) -- ++(\axissize, 0) node[above left]{$x$};
\draw[->] (0, 0) -- ++(0, \axissize) node[below right]{$y$};
\draw[fill, color=black] (0, 0) circle (0.05*\axissize);
\node[draw, circle, inner sep=0pt, minimum size=0.4*\axissize, label=left:$z$] (yaxis) at (0, 0){};
\node[below right] at (0, 0){$\{O\}$};
\end{scope}
\coordinate[] (p1) at (-1.5, -1.5);
\coordinate[] (p2) at (-1.5, 1.5);
\coordinate[] (p3) at ( 1.5, 1.5);
\coordinate[] (p4) at ( 1.5, -1.5);
\draw[->] (p1)node[]{$\bullet$}node[above]{$p_1$} -- ++(1, 0.5)node[right]{$v_1$};
\draw[->] (p2)node[]{$\bullet$}node[above]{$p_2$} -- ++(-0.5, 1)node[right]{$v_2$};
\draw[->] (p3)node[]{$\bullet$}node[above]{$p_3$} -- ++(1, 0.5)node[right]{$v_3$};
\draw[->] (p4)node[]{$\bullet$}node[above]{$p_4$} -- ++(0.5, 1)node[right]{$v_4$};
\end{tikzpicture}
#+end_src
#+RESULTS :
[[file:figs/local_to_global_coordinates.png ]]
From the figure above, we can write:
\begin{align*}
\vec{v}_1 &= \vec{v} + \Omega \vec{p}_1\\
\vec{v}_2 &= \vec{v} + \Omega \vec{p}_2\\
\vec{v}_3 &= \vec{v} + \Omega \vec{p}_3\\
\vec{v}_4 &= \vec{v} + \Omega \vec{p}_4
\end{align*}
With
\begin{equation}
\Omega = \begin{bmatrix}
0 & -\Omega_z & \Omega_y \\
\Omega_z & 0 & -\Omega_x \\
-\Omega_y & \Omega_x & 0
\end{bmatrix}
\end{equation}
$\vec{v}$ and $\Omega$ represent to velocity and rotation of the solid expressed in the frame $\{O\}$.
We can rearrange the equations in a matrix form:
\begin{equation}
\left[\begin{array}{ccc|ccc}
1 & 0 & 0 & 0 & p_{1z} & -p_ {1y} \\
0 & 1 & 0 & -p_{1z} & 0 & p_ {1x} \\
0 & 0 & 1 & p_{1y} & -p_ {1x} & 0 \\ \hline
& \vdots & & & \vdots & \\ \hline
1 & 0 & 0 & 0 & p_{4z} & -p_ {4y} \\
0 & 1 & 0 & -p_{4z} & 0 & p_ {4x} \\
0 & 0 & 1 & p_{4y} & -p_ {4x} & 0
\end{array}\right] \begin{bmatrix}
v_x \\ v_y \\ v_z \\ \hline \Omega_x \\ \Omega_y \\ \Omega_z
\end{bmatrix} = \begin{bmatrix}
v_{1x} \\ v_ {1y} \\ v_{1z} \\\hline \vdots \\\hline v_ {4x} \\ v_{4y} \\ v_ {4z}
\end{bmatrix}
\end{equation}
and then we obtain the velocity and rotation of the solid in the wanted frame $\{O\}$:
\begin{equation}
\begin{bmatrix}
v_x \\ v_y \\ v_z \\ \hline \Omega_x \\ \Omega_y \\ \Omega_z
\end{bmatrix} =
\left[\begin{array}{ccc|ccc}
1 & 0 & 0 & 0 & p_{1z} & -p_ {1y} \\
0 & 1 & 0 & -p_{1z} & 0 & p_ {1x} \\
0 & 0 & 1 & p_{1y} & -p_ {1x} & 0 \\ \hline
& \vdots & & & \vdots & \\ \hline
1 & 0 & 0 & 0 & p_{4z} & -p_ {4y} \\
0 & 1 & 0 & -p_{4z} & 0 & p_ {4x} \\
0 & 0 & 1 & p_{4y} & -p_ {4x} & 0
\end{array}\right]^{-1} \begin{bmatrix}
v_{1x} \\ v_ {1y} \\ v_{1z} \\\hline \vdots \\\hline v_ {4x} \\ v_{4y} \\ v_ {4z}
\end{bmatrix}
\end{equation}
This inversion is equivalent to a mean square problem.
2019-07-05 16:58:15 +02:00
** Matlab Implementation
2019-07-02 17:48:34 +02:00
#+begin_src matlab
mode_shapes_O = zeros(mod_n, length(solid_names), 6);
for mod_i = 1:mod_n
for solid_i = 1:length(solid_names)
solids_i = solids.(solid_names{solid_i});
Y = reshape(squeeze(modes(mod_i, solids_i, :))', [], 1);
A = zeros(3*length(solids_i), 6);
for i = 1:length(solids_i)
A(3*(i-1)+1:3*i, 1:3) = eye(3);
A(3*(i-1)+1:3*i, 4:6) = [0 acc_pos(i, 3) -acc_pos(i, 2) ; -acc_pos(i, 3) 0 acc_pos(i, 1) ; acc_pos(i, 2) -acc_pos(i, 1) 0];
end
mode_shapes_O(mod_i, solid_i, :) = A\Y;
end
end
#+end_src
2019-07-05 16:58:15 +02:00
** Modal Matrices
We arrange the obtained modal parameters into matrices:
2019-07-02 17:48:34 +02:00
\[ \Omega = \begin{bmatrix}
\omega_1^2 & & 0 \\
& \ddots & \\
0 & & \omega_n^2
\end{bmatrix}; \quad \Psi = \begin{bmatrix}
& & \\
\{\psi_1\} & \dots & \{\psi_n\} \\
& &
\end{bmatrix} \]
2019-07-05 16:58:15 +02:00
with
\[ \{\psi_1\} = \begin{Bmatrix} \psi_ {1_x} & \psi_ {2_x} & \dots & \psi_ {6_x} & \psi_ {1_y} & \dots & \psi_ {1\Omega_x} & \dots & \psi_ {6\Omega_z} \end{Bmatrix}^T \]
2019-07-02 17:48:34 +02:00
2019-07-05 16:58:15 +02:00
#+begin_warning
How to add damping to the eigen matrices?
#+end_warning
2019-07-02 17:48:34 +02:00
#+begin_src matlab
eigen_value_M = diag(freqs*2*pi);
eigen_vector_M = reshape(mode_shapes_O, [mod_n, 6*length(solid_names)])';
#+end_src
2019-07-05 16:58:15 +02:00
** TODO Normalization of mode shapes?
We normalize each column of the eigen vector matrix.
2019-07-02 17:48:34 +02:00
2019-07-05 16:58:15 +02:00
Then, each eigenvector as a norm of 1.
2019-07-02 17:48:34 +02:00
2019-07-05 16:58:15 +02:00
#+begin_src matlab
eigen_vector_M = eigen_vector_M./vecnorm(eigen_vector_M);
2019-07-02 17:48:34 +02:00
#+end_src
2019-07-05 16:58:15 +02:00
#+begin_important
Should we do such normalization?
#+end_important
2019-07-02 17:48:34 +02:00
* Some notes about constraining the number of degrees of freedom
We want to have the two eigen matrices.
They should have the same size $n \times n$ where $n$ is the number of modes as well as the number of degrees of freedom.
Thus, if we consider 21 modes, we should restrict our system to have only 21 DOFs.
Actually, we are measured 6 DOFs of 6 solids, thus we have 36 DOFs.
From the mode shapes animations, it seems that in the frequency range of interest, the two marbles can be considered as one solid.
We thus have 5 solids and 30 DOFs.
In order to determine which DOF can be neglected, two solutions seems possible:
- compare the mode shapes
- compare the FRFs
The question is: in which base (frame) should be express the modes shapes and FRFs?
Is it meaningful to compare mode shapes as they give no information about the amplitudes of vibration?
| Stage | Motion DOFs | Parasitic DOF | Total DOF | Description of DOF |
|---------+-------------+---------------+-----------+--------------------|
| Granite | 0 | 3 | 3 | |
| Ty | 1 | 2 | 3 | Ty, Rz |
| Ry | 1 | 2 | 3 | Ry, |
| Rz | 1 | 2 | 3 | Rz, Rx, Ry |
| Hexapod | 6 | 0 | 6 | Txyz, Rxyz |
|---------+-------------+---------------+-----------+--------------------|
| | 9 | 9 | 18 | |
#+TBLFM : $4=vsum($2..$3)
#+TBLFM : @>$2..$>=vsum(@I..@II)
* Compare Mode Shapes
Let's say we want to see for the first mode which DOFs can be neglected.
In order to do so, we should estimate the motion of each stage in particular directions.
If we look at the z motion for instance, we will find that we cannot neglect that motion (because of the tilt causing z motion).
#+begin_src matlab
mode_i = 3;
dof_i = 6;
mode = eigen_vector_M(dof_i:6:end, mode_i);
figure;
hold on;
for i=1:length(mode)
plot([0, real(mode(i))], [0, imag(mode(i))], '-', 'DisplayName', solid_names{i});
end
hold off;
legend();
#+end_src
#+begin_src matlab
figure;
subplot(2, 1, 1);
hold on;
for i=1:length(mode)
plot(1, norm(mode(i)), 'o');
end
hold off;
ylabel('Amplitude');
subplot(2, 1, 2);
hold on;
for i=1:length(mode)
plot(1, 180/pi*angle(mode(i)), 'o', 'DisplayName', solid_names{i});
end
hold off;
ylim([-180, 180]); yticks([-180:90:180]);
ylabel('Phase [deg]');
legend();
#+end_src
#+begin_src matlab
test = mode_shapes_O(10, 1, :)/norm(squeeze(mode_shapes_O(10, 1, :)));
test = mode_shapes_O(10, 2, :)/norm(squeeze(mode_shapes_O(10, 2, :)));
#+end_src
2019-07-05 16:58:15 +02:00
* TODO Synthesis of FRF curves from the modal parameters
