2019-07-02 17:48:34 +02:00
<?xml version="1.0" encoding="utf-8"?>
< !DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
< html xmlns = "http://www.w3.org/1999/xhtml" lang = "en" xml:lang = "en" >
< head >
2020-11-12 10:30:56 +01:00
<!-- 2020 - 11 - 12 jeu. 10:29 -->
2019-07-02 17:48:34 +02:00
< meta http-equiv = "Content-Type" content = "text/html;charset=utf-8" / >
2019-07-03 13:54:33 +02:00
< title > Modal Analysis - Modal Parameter Extraction< / title >
2019-07-02 17:48:34 +02:00
< meta name = "generator" content = "Org mode" / >
< meta name = "author" content = "Dehaeze Thomas" / >
2020-11-12 10:30:56 +01:00
< link rel = "stylesheet" type = "text/css" href = "https://research.tdehaeze.xyz/css/style.css" / >
< script type = "text/javascript" src = "https://research.tdehaeze.xyz/js/script.js" > < / script >
< script > M a t h J a x = {
tex: {
tags: 'ams',
macros: {bm: ["\\boldsymbol{#1}",1],}
}
};
< / script >
< script type = "text/javascript" src = "https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js" > < / script >
2019-07-02 17:48:34 +02:00
< / head >
< body >
< div id = "org-div-home-and-up" >
2020-11-12 10:30:56 +01:00
< a accesskey = "h" href = "../index.html" > UP < / a >
2019-07-02 17:48:34 +02:00
|
< a accesskey = "H" href = "../index.html" > HOME < / a >
< / div > < div id = "content" >
2019-07-03 13:54:33 +02:00
< h1 class = "title" > Modal Analysis - Modal Parameter Extraction< / h1 >
2019-07-02 17:48:34 +02:00
< div id = "table-of-contents" >
< h2 > Table of Contents< / h2 >
< div id = "text-table-of-contents" >
< ul >
2020-11-12 10:30:56 +01:00
< li > < a href = "#orgbd4652a" > 1. Load Data< / a > < / li >
< li > < a href = "#org9fc9286" > 2. Determine the number of modes< / a >
2019-07-05 16:58:15 +02:00
< ul >
2020-11-12 10:30:56 +01:00
< li > < a href = "#org4a6ccb8" > 2.1. Singular Value Decomposition - Modal Indication Function< / a > < / li >
< li > < a href = "#org92f0542" > 2.2. Composite Response Function< / a > < / li >
2019-07-05 16:58:15 +02:00
< / ul >
< / li >
2020-11-12 10:30:56 +01:00
< li > < a href = "#orgc062611" > 3. Modal parameter extraction< / a >
2019-07-05 16:58:15 +02:00
< ul >
2020-11-12 10:30:56 +01:00
< li > < a href = "#orgc791c1c" > 3.1. OROS - Modal software< / a > < / li >
< li > < a href = "#orgd4c6149" > 3.2. Exported modal parameters< / a > < / li >
< li > < a href = "#orgc0a3c1d" > 3.3. Importation of the modal parameters on Matlab< / a > < / li >
< li > < a href = "#org8cf19f5" > 3.4. Theory< / a > < / li >
< li > < a href = "#org4b00fcc" > 3.5. Modal Matrices< / a > < / li >
2019-07-05 16:58:15 +02:00
< / ul >
< / li >
2020-11-12 10:30:56 +01:00
< li > < a href = "#org20a0d95" > 4. Obtained Mode Shapes animations< / a > < / li >
< li > < a href = "#org3344df1" > 5. Verify the validity of the Modal Model< / a >
2019-07-05 16:58:15 +02:00
< ul >
2020-11-12 10:30:56 +01:00
< li > < a href = "#orgbc73745" > 5.1. Theory< / a > < / li >
< li > < a href = "#org779f8a2" > 5.2. Matlab Implementation< / a > < / li >
< li > < a href = "#orgc860b37" > 5.3. Original and Synthesize FRF matrix comparison< / a > < / li >
< li > < a href = "#orgb9f2500" > 5.4. Synthesize FRF that has not yet been measured< / a > < / li >
2019-07-05 16:58:15 +02:00
< / ul >
< / li >
2020-11-12 10:30:56 +01:00
< li > < a href = "#orgc656623" > 6. Modal Complexity< / a > < / li >
< li > < a href = "#org0d3f729" > 7. Modal Assurance Criterion (MAC)< / a > < / li >
< li > < a href = "#org10fd77e" > 8. From accelerometer coordinates to global coordinates for the mode shapes< / a >
2019-07-11 16:44:30 +02:00
< ul >
2020-11-12 10:30:56 +01:00
< li > < a href = "#org4e8304a" > 8.1. Mathematical description< / a > < / li >
< li > < a href = "#orgdd38853" > 8.2. Matlab Implementation< / a > < / li >
< li > < a href = "#orgd2ddc47" > 8.3. FRF matrix synthesis< / a >
2019-07-11 16:44:30 +02:00
< ul >
2020-11-12 10:30:56 +01:00
< li > < a href = "#orge66cb85" > 8.3.1. Mathematical description< / a > < / li >
< li > < a href = "#org33d44db" > 8.3.2. Matlab Implementation< / a > < / li >
< li > < a href = "#orge4645f0" > 8.3.3. Test to have the original inputs< / a > < / li >
2019-07-11 16:44:30 +02:00
< / ul >
< / li >
2020-11-12 10:30:56 +01:00
< li > < a href = "#orgb7364d7" > 8.4. Verification< / a > < / li >
< li > < a href = "#orgd383c3c" > 8.5. New FRFs< / a > < / li >
2019-07-11 16:44:30 +02:00
< / ul >
< / li >
2020-11-12 10:30:56 +01:00
< li > < a href = "#org8272b24" > 9. Some notes about constraining the number of degrees of freedom< / a > < / li >
< li > < a href = "#org5e78b29" > 10. Compare Mode Shapes< / a > < / li >
< li > < a href = "#org3174ebf" > 11. Mode shapes expressed in a frame at the CoM of the solid bodies< / a >
2019-07-11 16:44:30 +02:00
< ul >
2020-11-12 10:30:56 +01:00
< li > < a href = "#org2e64795" > 11.1. Modes shapes transformation< / a > < / li >
< li > < a href = "#org85f8012" > 11.2. Mass matrix from solidworks model< / a > < / li >
< li > < a href = "#org6bee07f" > 11.3. Mass-normalized Eigen Vectors< / a > < / li >
< li > < a href = "#org68b7508" > 11.4. Full Response Model from modal model (synthesis)< / a > < / li >
2019-07-11 16:44:30 +02:00
< / ul >
< / li >
2020-11-12 10:30:56 +01:00
< li > < a href = "#org5858b03" > 12. Residues< / a > < / li >
2019-07-02 17:48:34 +02:00
< / ul >
< / div >
< / div >
2019-07-05 16:58:15 +02:00
< p >
The goal here is to extract the modal parameters describing the modes of station being studied, namely:
< / p >
< ul class = "org-ul" >
2019-07-11 16:44:30 +02:00
< li > the eigen frequencies and the modal damping (eigen values)< / li >
2019-07-05 16:58:15 +02:00
< li > the mode shapes (eigen vectors)< / li >
< / ul >
< p >
This is done from the FRF matrix previously extracted from the measurements.
< / p >
< p >
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.
2020-11-12 10:30:56 +01:00
In section < a href = "#org5231c16" > 2< / a > , we will use the Singular Value Decomposition and the Modal Indication Function to estimate the number of modes.
2019-07-05 16:58:15 +02:00
< / p >
2019-07-02 17:48:34 +02:00
2019-07-05 16:58:15 +02:00
< p >
The modal parameter extraction methods generally consists of < b > curve-fitting a theoretical expression for an individual FRF to the actual measured data< / b > .
However, there are multiple level of complexity:
2019-07-02 17:48:34 +02:00
< / p >
2019-07-05 16:58:15 +02:00
< ul class = "org-ul" >
< li > works on a part of a single FRF curve< / li >
< li > works on a complete curve encompassing several resonances< / li >
< li > works on a set of many FRF plots all obtained from the same structure< / li >
< / ul >
< p >
2020-11-12 10:30:56 +01:00
The third method is the most complex but gives better results. This is the one we will use in section < a href = "#orgd105532" > 3< / a > .
2019-07-11 16:44:30 +02:00
< / p >
< p >
2020-11-12 10:30:56 +01:00
From the modal model, it is possible to obtain a graphic display of the mode shapes (section < a href = "#org96bf0aa" > 4< / a > ).
2019-07-05 16:58:15 +02:00
< / p >
< p >
2020-11-12 10:30:56 +01:00
In order to validate the quality of the modal model, we will synthesize the FRF matrix from the modal model and compare it with the FRF measured (section < a href = "#org4f2c071" > 5< / a > ).
2019-07-05 16:58:15 +02:00
< / p >
< p >
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.
2020-11-12 10:30:56 +01:00
We will thus study the complexity of those modes, in section < a href = "#org52018e7" > 6< / a > , and see if we can estimate real modes from the complex modes.
2019-07-05 16:58:15 +02:00
< / p >
< p >
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.
2020-11-12 10:30:56 +01:00
This in done in section < a href = "#orga23db30" > 8< / a > .
2019-07-11 16:44:30 +02:00
< / p >
< p >
Residues will have to be included.
2019-07-05 16:58:15 +02:00
< / p >
2020-11-12 10:30:56 +01:00
< div class = "note" id = "org48f88f5" >
2019-07-05 16:58:15 +02:00
< p >
All the files (data and Matlab scripts) are accessible < a href = "data/modal_extraction.zip" > here< / a > .
< / p >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-orgbd4652a" class = "outline-2" >
< h2 id = "orgbd4652a" > < span class = "section-number-2" > 1< / span > Load Data< / h2 >
2019-07-05 16:58:15 +02:00
< div class = "outline-text-2" id = "text-1" >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > load(< span class = "org-string" > 'mat/frf_coh_matrices.mat'< / span > , < span class = "org-string" > 'FRFs'< / span > , < span class = "org-string" > 'COHs'< / span > , < span class = "org-string" > 'freqs'< / span > );
load(< span class = "org-string" > 'mat/geometry.mat'< / span > , < span class = "org-string" > 'solids'< / span > , < span class = "org-string" > 'solid_names'< / span > , < span class = "org-string" > 'acc_pos'< / span > );
load(< span class = "org-string" > 'mat/frf_o.mat'< / span > , < span class = "org-string" > 'FRFs_O'< / span > );
2019-07-05 16:58:15 +02:00
< / pre >
2019-07-02 17:48:34 +02:00
< / div >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-org9fc9286" class = "outline-2" >
< h2 id = "org9fc9286" > < span class = "section-number-2" > 2< / span > Determine the number of modes< / h2 >
2019-07-02 17:48:34 +02:00
< div class = "outline-text-2" id = "text-2" >
< p >
2020-11-12 10:30:56 +01:00
< a id = "org5231c16" > < / a >
2019-07-05 16:58:15 +02:00
< / p >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-org4a6ccb8" class = "outline-3" >
< h3 id = "org4a6ccb8" > < span class = "section-number-3" > 2.1< / span > Singular Value Decomposition - Modal Indication Function< / h3 >
2019-07-05 16:58:15 +02:00
< div class = "outline-text-3" id = "text-2-1" >
< p >
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.
< / p >
< p >
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.
< / p >
< p >
These methods are used to < b > determine the number of modes< / b > present in a given frequency range, to < b > identify repeated natural frequencies< / b > and to pre process the FRF data prior to modal analysis.
< / p >
< p >
From the documentation of the modal software:
< / p >
< blockquote >
< p >
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.
< / p >
< / blockquote >
2020-11-12 10:30:56 +01:00
< div class = "important" id = "orgb18e0a6" >
2019-07-05 16:58:15 +02:00
< p >
The < b > Complex Mode Indicator Function< / b > is defined simply by the SVD of the FRF (sub) matrix:
< / p >
\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*}
< / div >
< p >
2020-11-12 10:30:56 +01:00
We compute the Complex Mode Indicator Function. The result is shown on figure < a href = "#orga48e169" > 1< / a > .
2019-07-05 16:58:15 +02:00
The exact same curve is obtained when computed using the OROS software.
< / p >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > MIF = zeros(size(FRFs, 2), size(FRFs, 2), size(FRFs, 3));
2019-07-05 16:58:15 +02:00
2020-11-12 10:30:56 +01:00
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:length(freqs)< / span >
[< span class = "org-type" > ~< / span > ,S,< span class = "org-type" > ~< / span > ] = svd(FRFs(< span class = "org-type" > :< / span > , < span class = "org-type" > :< / span > , < span class = "org-constant" > i< / span > ));
MIF(< span class = "org-type" > :< / span > , < span class = "org-type" > :< / span > , < span class = "org-constant" > i< / span > ) = S< span class = "org-type" > '*< / span > S;
2019-07-05 16:58:15 +02:00
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "orga48e169" class = "figure" >
2019-07-05 16:58:15 +02:00
< p > < img src = "figs/cmif.png" alt = "cmif.png" / >
< / p >
< p > < span class = "figure-number" > Figure 1: < / span > Complex Mode Indicator Function< / p >
< / div >
< p >
We can also compute the CMIF using the FRF matrix expressed in the same global frame.
2020-11-12 10:30:56 +01:00
We compare the two CMIF on figure < a href = "#orgf948c4a" > 2< / a > .
2019-07-05 16:58:15 +02:00
< / p >
< p >
They do not indicate the same resonance frequencies, especially around 110Hz.
< / p >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > MIF_O = zeros(size(FRFs_O, 2), size(FRFs_O, 2), size(FRFs_O, 3));
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:length(freqs)< / span >
[< span class = "org-type" > ~< / span > ,S,< span class = "org-type" > ~< / span > ] = svd(FRFs_O(< span class = "org-type" > :< / span > , < span class = "org-type" > :< / span > , < span class = "org-constant" > i< / span > ));
MIF_O(< span class = "org-type" > :< / span > , < span class = "org-type" > :< / span > , < span class = "org-constant" > i< / span > ) = S< span class = "org-type" > '*< / span > S;
2019-07-05 16:58:15 +02:00
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "orgf948c4a" class = "figure" >
2019-07-05 16:58:15 +02:00
< p > < img src = "figs/cmif_compare.png" alt = "cmif_compare.png" / >
< / p >
< p > < span class = "figure-number" > Figure 2: < / span > Complex Mode Indicator Function - Original FRF: solid curves - Processed FRF: dashed curve< / p >
< / div >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-org92f0542" class = "outline-3" >
< h3 id = "org92f0542" > < span class = "section-number-3" > 2.2< / span > Composite Response Function< / h3 >
2019-07-05 16:58:15 +02:00
< div class = "outline-text-3" id = "text-2-2" >
< p >
An alternative is the Composite Response Function \(HH(\omega)\) defined as the sum of all the measured FRF:
< / p >
\begin{equation}
HH(\omega) = \sum_j\sum_kH_{jk}(\omega)
\end{equation}
< p >
Instead, we choose here to use the sum of the norms of the measured FRFs:
< / p >
\begin{equation}
HH(\omega) = \sum_j\sum_k \left|H_{jk}(\omega) \right|
\end{equation}
< p >
2020-11-12 10:30:56 +01:00
The result is shown on figure < a href = "#orgd6aaa14" > 3< / a > .
2019-07-05 16:58:15 +02:00
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "org-type" > figure< / span > ;
hold on;
2020-11-12 10:30:56 +01:00
plot(freqs, squeeze(sum(sum(abs(FRFs)))), < span class = "org-string" > '-k'< / span > );
plot(freqs, squeeze(sum(sum(abs(FRFs_O)))), < span class = "org-string" > '--k'< / span > );
2019-07-05 16:58:15 +02:00
hold off;
2020-11-12 10:30:56 +01:00
xlabel(< span class = "org-string" > 'Frequency [Hz]'< / span > ); ylabel(< span class = "org-string" > 'Amplitude'< / span > );
xlim([1, 200]);
2019-07-05 16:58:15 +02:00
< / pre >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "orgd6aaa14" class = "figure" >
2019-07-05 16:58:15 +02:00
< p > < img src = "figs/composite_response_function.png" alt = "composite_response_function.png" / >
< / p >
< p > < span class = "figure-number" > Figure 3: < / span > Composite Response Function. Solid curve: computed from the original FRFs. Dashed curve: computed from the FRFs expressed in the global frame.< / p >
< / div >
< / div >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-orgc062611" class = "outline-2" >
< h2 id = "orgc062611" > < span class = "section-number-2" > 3< / span > Modal parameter extraction< / h2 >
2019-07-05 16:58:15 +02:00
< div class = "outline-text-2" id = "text-3" >
< p >
2020-11-12 10:30:56 +01:00
< a id = "orgd105532" > < / a >
2019-07-05 16:58:15 +02:00
< / p >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-orgc791c1c" class = "outline-3" >
< h3 id = "orgc791c1c" > < span class = "section-number-3" > 3.1< / span > OROS - Modal software< / h3 >
2019-07-05 16:58:15 +02:00
< div class = "outline-text-3" id = "text-3-1" >
< p >
2019-07-11 16:44:30 +02:00
Modal identification are done within the < a href = "https://www.oros.com/solutions/structural-dynamics/modal-analysis/" > Modal software of OROS< / a > . The manual for the software is available < a href = "data/oros_modal_manual.pdf" > here< / a > .
2019-07-05 16:58:15 +02:00
< / p >
< p >
Several modal parameter extraction methods are available.
2020-11-12 10:30:56 +01:00
We choose to use the “ < b > broad band< / b > ” method as it permits to identify the modal parameters using all the FRF curves at the same time.
2019-07-05 16:58:15 +02:00
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.
< / p >
< p >
2019-07-11 16:44:30 +02:00
Such method also have the advantage of producing a < b > unique and consistent model< / b > as direct output.
2019-07-05 16:58:15 +02:00
< / p >
< p >
In order to apply this method, we select the frequency range of interest and we give an estimate of how many modes are present.
< / p >
< p >
2020-11-12 10:30:56 +01:00
Then, it shows a stabilization charts, such as the one shown on figure < a href = "#org48e5930" > 4< / a > , where we have to manually select which modes to take into account in the modal model.
2019-07-05 16:58:15 +02:00
< / p >
2020-11-12 10:30:56 +01:00
< div id = "org48e5930" class = "figure" >
2019-07-11 16:44:30 +02:00
< p > < img src = "img/modal_software/stabilisation_chart.jpg" alt = "stabilisation_chart.jpg" / >
2019-07-05 16:58:15 +02:00
< / p >
< p > < span class = "figure-number" > Figure 4: < / span > Stabilization Chart< / p >
< / div >
< p >
We can then run the modal analysis, and the software will identify the modal damping and mode shapes at the selected frequency modes.
< / p >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-orgd4c6149" class = "outline-3" >
< h3 id = "orgd4c6149" > < span class = "section-number-3" > 3.2< / span > Exported modal parameters< / h3 >
2019-07-05 16:58:15 +02:00
< div class = "outline-text-3" id = "text-3-2" >
< p >
The obtained modal parameters are:
< / p >
< ul class = "org-ul" >
2019-07-11 16:44:30 +02:00
< li > resonance frequencies in Hertz< / li >
< li > modal damping ratio in percentage< / li >
< li > (complex) modes shapes for each measured DoF< / li >
< li > modal A and modal B which are parameters important for further normalization< / li >
2019-07-05 16:58:15 +02:00
< / ul >
< p >
They are all exported in a text file named < code > modes.asc< / code > .
Its first 20 lines as shown below.
< / p >
2020-11-12 10:30:56 +01:00
< pre class = "example" id = "orgb8be5fa" >
2019-07-05 16:58:15 +02:00
Created by N-Modal
Estimator: bbfd
2019-07-16 11:09:14 +02:00
16-Jul-19 09:35:42
2019-07-05 16:58:15 +02:00
Mode 1
2019-07-16 11:09:14 +02:00
freq = 11.86509Hz
damp = 12.20318%
modal A = 4.13559e+003+6.22828e+003i
modal B = 4.98475e+005-2.49344e+005i
2019-07-05 16:58:15 +02:00
Mode matrix of local coordinate [DOF: Re IM]
2019-07-16 11:09:14 +02:00
1X+: -1.08546e-001 3.17769e-002
1Y+: 2.32355e-001 1.71539e-003
1Z+: -1.98455e-002 5.79676e-003
2X+: -8.59861e-002 2.84442e-002
2Y+: 2.40594e-001 0.00000e+000
2Z+: -7.65144e-003 4.22952e-003
3Y+: 2.14274e-001 7.53040e-003
3X-: 1.22352e-001 -2.90328e-002
3Z+: -2.12103e-002 -3.81368e-003
2019-07-05 16:58:15 +02:00
< / pre >
< p >
2020-11-12 10:30:56 +01:00
We split this big < code > modes.asc< / code > file into sub text files using < code > bash< / code > . The obtained files are described one table < a href = "#orge51e4c2" > 1< / a > .
2019-07-02 17:48:34 +02:00
< / p >
2019-07-05 16:58:15 +02:00
2019-07-02 17:48:34 +02:00
< div class = "org-src-container" >
2019-07-16 11:09:14 +02:00
< pre class = "src src-bash" > sed < span class = "org-string" > '/^\s*[0-9]*[XYZ][+-]:/!d'< / span > mat/modes_2019_07_16.asc > mat/mode_shapes.txt
sed < span class = "org-string" > '/freq/!d'< / span > mat/modes_2019_07_16.asc | sed < span class = "org-string" > 's/.* = \(.*\)Hz/\1/'< / span > > mat/mode_freqs.txt
sed < span class = "org-string" > '/damp/!d'< / span > mat/modes_2019_07_16.asc | sed < span class = "org-string" > 's/.* = \(.*\)\%/\1/'< / span > > mat/mode_damps.txt
sed < span class = "org-string" > '/modal A/!d'< / span > mat/modes_2019_07_16.asc | sed < span class = "org-string" > 's/.* =\s\+\([-0-9.e]\++[0-9]\+\)\([-+0-9.e]\+\)i/\1 \2/'< / span > > mat/mode_modal_a.txt
sed < span class = "org-string" > '/modal B/!d'< / span > mat/modes_2019_07_16.asc | sed < span class = "org-string" > 's/.* =\s\+\([-0-9.e]\++[0-9]\+\)\([-+0-9.e]\+\)i/\1 \2/'< / span > > mat/mode_modal_b.txt
2019-07-02 17:48:34 +02:00
< / pre >
< / div >
2020-11-12 10:30:56 +01:00
< table id = "orge51e4c2" border = "2" cellspacing = "0" cellpadding = "6" rules = "groups" frame = "hsides" >
2019-07-05 16:58:15 +02:00
< caption class = "t-above" > < span class = "table-number" > Table 1:< / span > Split < code > modes.asc< / code > file< / caption >
< colgroup >
< col class = "org-left" / >
< col class = "org-left" / >
< / colgroup >
< thead >
< tr >
< th scope = "col" class = "org-left" > Filename< / th >
< th scope = "col" class = "org-left" > Content< / th >
< / tr >
< / thead >
< tbody >
< tr >
< td class = "org-left" > < code > mat/mode_shapes.txt< / code > < / td >
< td class = "org-left" > mode shapes< / td >
< / tr >
< tr >
< td class = "org-left" > < code > mat/mode_freqs.txt< / code > < / td >
2019-07-11 16:44:30 +02:00
< td class = "org-left" > resonance frequencies [Hz]< / td >
2019-07-05 16:58:15 +02:00
< / tr >
< tr >
< td class = "org-left" > < code > mat/mode_damps.txt< / code > < / td >
2019-07-11 16:44:30 +02:00
< td class = "org-left" > modal damping [per]< / td >
2019-07-05 16:58:15 +02:00
< / tr >
< tr >
< td class = "org-left" > < code > mat/mode_modal_a.txt< / code > < / td >
2019-07-11 16:44:30 +02:00
< td class = "org-left" > Modal A< / td >
2019-07-05 16:58:15 +02:00
< / tr >
< tr >
< td class = "org-left" > < code > mat/mode_modal_b.txt< / code > < / td >
2019-07-11 16:44:30 +02:00
< td class = "org-left" > Modal B< / td >
2019-07-05 16:58:15 +02:00
< / tr >
< / tbody >
< / table >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-orgc0a3c1d" class = "outline-3" >
< h3 id = "orgc0a3c1d" > < span class = "section-number-3" > 3.3< / span > Importation of the modal parameters on Matlab< / h3 >
2019-07-05 16:58:15 +02:00
< div class = "outline-text-3" id = "text-3-3" >
2019-07-02 17:48:34 +02:00
< p >
2019-07-05 16:58:15 +02:00
Then we import the obtained < code > .txt< / code > files on Matlab using < code > readtable< / code > function.
2019-07-02 17:48:34 +02:00
< / p >
2019-07-11 16:44:30 +02:00
2019-07-02 17:48:34 +02:00
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > shapes_m = readtable(< span class = "org-string" > 'mat/mode_shapes.txt'< / span > , < span class = "org-string" > 'ReadVariableNames'< / span > , < span class = "org-constant" > false< / span > ); < span class = "org-comment" > % [Sign / Real / Imag]< / span >
freqs_m = table2array(readtable(< span class = "org-string" > 'mat/mode_freqs.txt'< / span > , < span class = "org-string" > 'ReadVariableNames'< / span > , < span class = "org-constant" > false< / span > )); < span class = "org-comment" > % in [Hz]< / span >
damps_m = table2array(readtable(< span class = "org-string" > 'mat/mode_damps.txt'< / span > , < span class = "org-string" > 'ReadVariableNames'< / span > , < span class = "org-constant" > false< / span > )); < span class = "org-comment" > % in [%]< / span >
modal_a = table2array(readtable(< span class = "org-string" > 'mat/mode_modal_a.txt'< / span > , < span class = "org-string" > 'ReadVariableNames'< / span > , < span class = "org-constant" > false< / span > )); < span class = "org-comment" > % [Real / Imag]< / span >
modal_b = table2array(readtable(< span class = "org-string" > 'mat/mode_modal_b.txt'< / span > , < span class = "org-string" > 'ReadVariableNames'< / span > , < span class = "org-constant" > false< / span > )); < span class = "org-comment" > % [Real / Imag]< / span >
2019-07-02 17:48:34 +02:00
< / pre >
< / div >
< p >
We guess the number of modes identified from the length of the imported data.
< / p >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > acc_n = 23; < span class = "org-comment" > % Number of accelerometers< / span >
dir_n = 3; < span class = "org-comment" > % Number of directions< / span >
2019-07-02 17:48:34 +02:00
dirs = < span class = "org-string" > 'XYZ'< / span > ;
2020-11-12 10:30:56 +01:00
mod_n = size(shapes_m,1)< span class = "org-type" > /< / span > acc_n< span class = "org-type" > /< / span > dir_n; < span class = "org-comment" > % Number of modes< / span >
2019-07-02 17:48:34 +02:00
< / pre >
< / div >
< p >
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.
< / p >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > T_sign = table2array(shapes_m(< span class = "org-type" > :< / span > , 1));
T_real = table2array(shapes_m(< span class = "org-type" > :< / span > , 2));
T_imag = table2array(shapes_m(< span class = "org-type" > :< / span > , 3));
2019-07-02 17:48:34 +02:00
2020-11-12 10:30:56 +01:00
mode_shapes = zeros(mod_n, dir_n, acc_n);
2019-07-02 17:48:34 +02:00
2020-11-12 10:30:56 +01:00
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > mod_i< / span > = < span class = "org-constant" > 1:mod_n< / span >
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > acc_i< / span > = < span class = "org-constant" > 1:acc_n< / span >
2019-07-02 17:48:34 +02:00
< span class = "org-comment" > % Get the correct section of the signs< / span >
2020-11-12 10:30:56 +01:00
T = T_sign(acc_n< span class = "org-type" > *< / span > dir_n< span class = "org-type" > *< / span > (mod_i< span class = "org-type" > -< / span > 1)< span class = "org-type" > +< / span > 1< span class = "org-type" > :< / span > acc_n< span class = "org-type" > *< / span > dir_n< span class = "org-type" > *< / span > mod_i);
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > dir_i< / span > = < span class = "org-constant" > 1:dir_n< / span >
2019-07-02 17:48:34 +02:00
< span class = "org-comment" > % Get the line corresponding to the sensor< / span >
2020-11-12 10:30:56 +01:00
< span class = "org-constant" > i< / span > = find(contains(T, sprintf(< span class = "org-string" > '%i%s'< / span > ,acc_i, dirs(dir_i))), 1, < span class = "org-string" > 'first'< / span > )< span class = "org-type" > +< / span > acc_n< span class = "org-type" > *< / span > dir_n< span class = "org-type" > *< / span > (mod_i< span class = "org-type" > -< / span > 1);
mode_shapes(mod_i, dir_i, acc_i) = str2num([T_sign{< span class = "org-constant" > i< / span > }(end< span class = "org-type" > -< / span > 1), < span class = "org-string" > '1'< / span > ])< span class = "org-type" > *< / span > complex(T_real(< span class = "org-constant" > i< / span > ),T_imag(< span class = "org-constant" > i< / span > ));
2019-07-02 17:48:34 +02:00
< span class = "org-keyword" > end< / span >
< span class = "org-keyword" > end< / span >
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< p >
The obtained mode frequencies and damping are shown below.
< / p >
2019-07-16 11:09:14 +02:00
< table border = "2" cellspacing = "0" cellpadding = "6" rules = "groups" frame = "hsides" >
2019-07-02 17:48:34 +02:00
< colgroup >
< col class = "org-right" / >
2019-07-05 16:58:15 +02:00
< col class = "org-right" / >
2019-07-02 17:48:34 +02:00
< col class = "org-right" / >
< / colgroup >
< thead >
< tr >
2019-07-05 16:58:15 +02:00
< th scope = "col" class = "org-right" > Mode number< / th >
2019-07-02 17:48:34 +02:00
< th scope = "col" class = "org-right" > Frequency [Hz]< / th >
< th scope = "col" class = "org-right" > Damping [%]< / th >
< / tr >
< / thead >
< tbody >
< tr >
2019-07-05 16:58:15 +02:00
< td class = "org-right" > 1.0< / td >
2019-07-16 11:09:14 +02:00
< td class = "org-right" > 11.9< / td >
< td class = "org-right" > 12.2< / td >
2019-07-02 17:48:34 +02:00
< / tr >
< tr >
2019-07-05 16:58:15 +02:00
< td class = "org-right" > 2.0< / td >
2019-07-16 11:09:14 +02:00
< td class = "org-right" > 18.6< / td >
< td class = "org-right" > 11.7< / td >
2019-07-02 17:48:34 +02:00
< / tr >
< tr >
2019-07-05 16:58:15 +02:00
< td class = "org-right" > 3.0< / td >
2019-07-16 11:09:14 +02:00
< td class = "org-right" > 37.8< / td >
< td class = "org-right" > 6.2< / td >
2019-07-02 17:48:34 +02:00
< / tr >
< tr >
2019-07-05 16:58:15 +02:00
< td class = "org-right" > 4.0< / td >
2019-07-16 11:09:14 +02:00
< td class = "org-right" > 39.1< / td >
< td class = "org-right" > 2.8< / td >
2019-07-02 17:48:34 +02:00
< / tr >
< tr >
2019-07-05 16:58:15 +02:00
< td class = "org-right" > 5.0< / td >
2019-07-16 11:09:14 +02:00
< td class = "org-right" > 56.3< / td >
< td class = "org-right" > 2.8< / td >
2019-07-02 17:48:34 +02:00
< / tr >
< tr >
2019-07-05 16:58:15 +02:00
< td class = "org-right" > 6.0< / td >
2019-07-16 11:09:14 +02:00
< td class = "org-right" > 69.8< / td >
< td class = "org-right" > 4.3< / td >
2019-07-02 17:48:34 +02:00
< / tr >
< tr >
2019-07-05 16:58:15 +02:00
< td class = "org-right" > 7.0< / td >
2019-07-16 11:09:14 +02:00
< td class = "org-right" > 72.5< / td >
< td class = "org-right" > 1.3< / td >
2019-07-02 17:48:34 +02:00
< / tr >
< tr >
2019-07-05 16:58:15 +02:00
< td class = "org-right" > 8.0< / td >
2019-07-16 11:09:14 +02:00
< td class = "org-right" > 84.8< / td >
< td class = "org-right" > 3.7< / td >
2019-07-02 17:48:34 +02:00
< / tr >
< tr >
2019-07-05 16:58:15 +02:00
< td class = "org-right" > 9.0< / td >
2019-07-16 11:09:14 +02:00
< td class = "org-right" > 91.3< / td >
< td class = "org-right" > 2.9< / td >
2019-07-02 17:48:34 +02:00
< / tr >
< tr >
2019-07-05 16:58:15 +02:00
< td class = "org-right" > 10.0< / td >
2019-07-16 11:09:14 +02:00
< td class = "org-right" > 105.5< / td >
< td class = "org-right" > 3.2< / td >
2019-07-02 17:48:34 +02:00
< / tr >
< tr >
2019-07-05 16:58:15 +02:00
< td class = "org-right" > 11.0< / td >
2019-07-16 11:09:14 +02:00
< td class = "org-right" > 106.6< / td >
< td class = "org-right" > 1.6< / td >
2019-07-02 17:48:34 +02:00
< / tr >
< tr >
2019-07-05 16:58:15 +02:00
< td class = "org-right" > 12.0< / td >
2019-07-16 11:09:14 +02:00
< td class = "org-right" > 112.7< / td >
< td class = "org-right" > 3.1< / td >
2019-07-02 17:48:34 +02:00
< / tr >
< tr >
2019-07-05 16:58:15 +02:00
< td class = "org-right" > 13.0< / td >
2019-07-16 11:09:14 +02:00
< td class = "org-right" > 124.2< / td >
< td class = "org-right" > 2.8< / td >
2019-07-02 17:48:34 +02:00
< / tr >
< tr >
2019-07-05 16:58:15 +02:00
< td class = "org-right" > 14.0< / td >
2019-07-16 11:09:14 +02:00
< td class = "org-right" > 145.3< / td >
< td class = "org-right" > 1.3< / td >
2019-07-02 17:48:34 +02:00
< / tr >
< tr >
2019-07-05 16:58:15 +02:00
< td class = "org-right" > 15.0< / td >
2019-07-16 11:09:14 +02:00
< td class = "org-right" > 150.5< / td >
< td class = "org-right" > 2.4< / td >
2019-07-02 17:48:34 +02:00
< / tr >
< tr >
2019-07-05 16:58:15 +02:00
< td class = "org-right" > 16.0< / td >
2019-07-16 11:09:14 +02:00
< td class = "org-right" > 165.4< / td >
2019-07-02 17:48:34 +02:00
< td class = "org-right" > 1.4< / td >
< / tr >
< / tbody >
< / table >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-org8cf19f5" class = "outline-3" >
< h3 id = "org8cf19f5" > < span class = "section-number-3" > 3.4< / span > Theory< / h3 >
2019-07-05 16:58:15 +02:00
< div class = "outline-text-3" id = "text-3-4" >
2019-07-02 17:48:34 +02:00
< p >
2019-07-11 16:44:30 +02:00
It seems that the modal analysis software makes the < b > assumption< / b > of viscous damping for the model with which it tries to fit the FRF measurements.
< / p >
< p >
If we note \(N\) the number of modes identified, then there are \(2N\) eigenvalues and eigenvectors given by the software:
< / p >
\begin{align}
s_r & = \omega_r (-\xi_r + i \sqrt{1 - \xi_r^2}),\quad s_r^* \\
\{\psi_r\} & = \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, \quad \{\psi_r\}^*
\end{align}
< p >
for \(r = 1, \dots, N\) where \(\omega_r\) is the natural frequency and \(\xi_r\) is the critical damping ratio for that mode.
< / p >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-org4b00fcc" class = "outline-3" >
< h3 id = "org4b00fcc" > < span class = "section-number-3" > 3.5< / span > Modal Matrices< / h3 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-3" id = "text-3-5" >
< p >
We would like to arrange the obtained modal parameters into two modal matrices:
\[ \Lambda = \begin{bmatrix}
s_1 & & 0 \\
& \ddots & \\
0 & & s_N
\end{bmatrix}_{N \times N}; \quad \Psi = \begin{bmatrix}
2019-07-05 16:58:15 +02:00
& & \\
2019-07-11 16:44:30 +02:00
\{\psi_1\} & \dots & \{\psi_N\} \\
2019-07-05 16:58:15 +02:00
& &
2019-07-11 16:44:30 +02:00
\end{bmatrix}_{M \times N} \]
\[ \{\psi_i\} = \begin{Bmatrix} \psi_{i, 1_x} & \psi_{i, 1_y} & \psi_{i, 1_z} & \psi_{i, 2_x} & \dots & \psi_{i, 23_z} \end{Bmatrix}^T \]
< / p >
< p >
\(M\) is the number of DoF: here it is \(23 \times 3 = 69\).
\(N\) is the number of mode
2019-07-02 17:48:34 +02:00
< / p >
2019-07-05 16:58:15 +02:00
2019-07-02 17:48:34 +02:00
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > eigen_val_M = diag(2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > freqs_m< span class = "org-type" > .*< / span > (< span class = "org-type" > -< / span > damps_m< span class = "org-type" > /< / span > 100 < span class = "org-type" > +< / span > < span class = "org-constant" > j< / span > < span class = "org-type" > *< / span > sqrt(1 < span class = "org-type" > -< / span > (damps_m< span class = "org-type" > /< / span > 100)< span class = "org-type" > .^< / span > 2)));
eigen_vec_M = reshape(mode_shapes, [mod_n, acc_n< span class = "org-type" > *< / span > dir_n])< span class = "org-type" > .'< / span > ;
2019-07-02 17:48:34 +02:00
< / pre >
< / div >
< p >
2019-07-11 16:44:30 +02:00
Each eigen vector is normalized: \(\| \{\psi_i\} \|_2 = 1\)
< / p >
< p >
However, the eigen values and eigen vectors appears as complex conjugates:
\[ s_r, s_r^*, \{\psi\}_r, \{\psi\}_r^*, \quad r = 1, N \]
2019-07-02 17:48:34 +02:00
< / p >
< p >
2019-07-11 16:44:30 +02:00
In the end, they are \(2N\) eigen values.
We then build two extended eigen matrices as follow:
\[ \mathcal{S} = \begin{bmatrix}
s_1 & & & & & \\
& \ddots & & & 0 & \\
& & s_N & & & \\
& & & s_1^* & & \\
& 0 & & & \ddots & \\
& & & & & s_N^*
\end{bmatrix}_{2N \times 2N}; \quad \Phi = \begin{bmatrix}
& & & & & \\
\{\psi_1\} & \dots & \{\psi_N\} & \{\psi_1^*\} & \dots & \{\psi_N^*\} \\
& & & & &
\end{bmatrix}_{M \times 2N} \]
2019-07-02 17:48:34 +02:00
< / p >
2019-07-05 16:58:15 +02:00
2019-07-02 17:48:34 +02:00
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > eigen_val_ext_M = blkdiag(eigen_val_M, conj(eigen_val_M));
eigen_vec_ext_M = [eigen_vec_M, conj(eigen_vec_M)];
2019-07-02 17:48:34 +02:00
< / pre >
< / div >
2019-07-05 16:58:15 +02:00
< p >
2019-07-11 16:44:30 +02:00
We also build the Modal A and Modal B matrices:
< / p >
\begin{equation}
A = \begin{bmatrix}
a_1 & & 0 \\
& \ddots & \\
0 & & a_N
\end{bmatrix}_{N \times N}; \quad B = \begin{bmatrix}
b_1 & & 0 \\
& \ddots & \\
0 & & b_N
\end{bmatrix}_{N \times N}
\end{equation}
< p >
2020-11-12 10:30:56 +01:00
With \(a_i\) is the “ Modal A” parameter linked to mode i.
2019-07-05 16:58:15 +02:00
< / p >
2019-07-02 17:48:34 +02:00
2019-07-11 16:44:30 +02:00
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > modal_a_M = diag(complex(modal_a(< span class = "org-type" > :< / span > , 1), modal_a(< span class = "org-type" > :< / span > , 2)));
modal_b_M = diag(complex(modal_b(< span class = "org-type" > :< / span > , 1), modal_b(< span class = "org-type" > :< / span > , 2)));
2019-07-11 16:44:30 +02:00
2020-11-12 10:30:56 +01:00
modal_a_ext_M = blkdiag(modal_a_M, conj(modal_a_M));
modal_b_ext_M = blkdiag(modal_b_M, conj(modal_b_M));
2019-07-11 16:44:30 +02:00
< / pre >
2019-07-05 16:58:15 +02:00
< / div >
2019-07-16 11:09:14 +02:00
< p >
2020-11-12 10:30:56 +01:00
“ Modal A” and “ modal B” are linked through the following formula:
2019-07-16 11:09:14 +02:00
\[ B = - A \Lambda \]
< / p >
2019-07-05 16:58:15 +02:00
< / div >
< / div >
< / div >
2019-07-02 17:48:34 +02:00
2020-11-12 10:30:56 +01:00
< div id = "outline-container-org20a0d95" class = "outline-2" >
< h2 id = "org20a0d95" > < span class = "section-number-2" > 4< / span > Obtained Mode Shapes animations< / h2 >
2019-07-05 16:58:15 +02:00
< div class = "outline-text-2" id = "text-4" >
< p >
2020-11-12 10:30:56 +01:00
< a id = "org96bf0aa" > < / a >
2019-07-05 16:58:15 +02:00
From the modal parameters, it is possible to show the modal shapes with an animation.
< / p >
2019-07-02 17:48:34 +02:00
2019-07-05 16:58:15 +02:00
< p >
2020-11-12 10:30:56 +01:00
Examples are shown on figures < a href = "#org091f91f" > 5< / a > and < a href = "#org7d63d5e" > 6< / a > .
2019-07-05 16:58:15 +02:00
< / p >
2019-07-02 17:48:34 +02:00
2019-07-05 16:58:15 +02:00
< p >
Animations of all the other modes are accessible using the following links: < a href = "img/modes/mode1.gif" > mode 1< / a > , < a href = "img/modes/mode2.gif" > mode 2< / a > , < a href = "img/modes/mode3.gif" > mode 3< / a > , < a href = "img/modes/mode4.gif" > mode 4< / a > , < a href = "img/modes/mode5.gif" > mode 5< / a > , < a href = "img/modes/mode6.gif" > mode 6< / a > , < a href = "img/modes/mode7.gif" > mode 7< / a > , < a href = "img/modes/mode8.gif" > mode 8< / a > , < a href = "img/modes/mode9.gif" > mode 9< / a > , < a href = "img/modes/mode10.gif" > mode 10< / a > , < a href = "img/modes/mode11.gif" > mode 11< / a > , < a href = "img/modes/mode12.gif" > mode 12< / a > , < a href = "img/modes/mode13.gif" > mode 13< / a > , < a href = "img/modes/mode14.gif" > mode 14< / a > , < a href = "img/modes/mode15.gif" > mode 15< / a > , < a href = "img/modes/mode16.gif" > mode 16< / a > , < a href = "img/modes/mode17.gif" > mode 17< / a > , < a href = "img/modes/mode18.gif" > mode 18< / a > , < a href = "img/modes/mode19.gif" > mode 19< / a > , < a href = "img/modes/mode20.gif" > mode 20< / a > , < a href = "img/modes/mode21.gif" > mode 21< / a > .
< / p >
2019-07-02 17:48:34 +02:00
2020-11-12 10:30:56 +01:00
< div id = "org091f91f" class = "figure" >
2019-07-05 16:58:15 +02:00
< p > < img src = "img/modes/mode1.gif" alt = "mode1.gif" / >
< / p >
< p > < span class = "figure-number" > Figure 5: < / span > Mode 1< / p >
< / div >
2019-07-02 17:48:34 +02:00
2020-11-12 10:30:56 +01:00
< div id = "org7d63d5e" class = "figure" >
2019-07-05 16:58:15 +02:00
< p > < img src = "img/modes/mode6.gif" alt = "mode6.gif" / >
< / p >
< p > < span class = "figure-number" > Figure 6: < / span > Mode 6< / p >
< / div >
2019-07-02 17:48:34 +02:00
2019-07-05 16:58:15 +02:00
< p >
We can learn quite a lot from these mode shape animations.
< / p >
2019-07-02 17:48:34 +02:00
2019-07-05 16:58:15 +02:00
< p >
2020-11-12 10:30:56 +01:00
For instance, the mode shape of the first mode at 11Hz (figure < a href = "#org091f91f" > 5< / a > ) seems to indicate that this corresponds to a suspension mode.
2019-07-05 16:58:15 +02:00
< / p >
2019-07-02 17:48:34 +02:00
2019-07-05 16:58:15 +02:00
< p >
2020-11-12 10:30:56 +01:00
This could be due to the 4 Airloc Levelers that are used for the granite (figure < a href = "#org97ed14b" > 7< / a > ).
2019-07-05 16:58:15 +02:00
< / p >
2019-07-02 17:48:34 +02:00
2020-11-12 10:30:56 +01:00
< div id = "org97ed14b" class = "figure" >
2019-07-05 16:58:15 +02:00
< p > < img src = "img/airloc/IMG_20190618_155522.jpg" alt = "IMG_20190618_155522.jpg" width = "500px" / >
< / p >
< p > < span class = "figure-number" > Figure 7: < / span > AirLoc used for the granite (2120-KSKC)< / p >
< / div >
2019-07-02 17:48:34 +02:00
2019-07-05 16:58:15 +02:00
< p >
They are probably < b > not well leveled< / b > , so the granite is supported only by two Airloc.
< / p >
< / div >
< / div >
2019-07-02 17:48:34 +02:00
2020-11-12 10:30:56 +01:00
< div id = "outline-container-org3344df1" class = "outline-2" >
< h2 id = "org3344df1" > < span class = "section-number-2" > 5< / span > Verify the validity of the Modal Model< / h2 >
2019-07-05 16:58:15 +02:00
< div class = "outline-text-2" id = "text-5" >
< p >
2020-11-12 10:30:56 +01:00
< a id = "org4f2c071" > < / a >
2019-07-11 16:44:30 +02:00
There are two main ways to verify the validity of the modal model
< / p >
< ul class = "org-ul" >
< li > Synthesize FRF measurements that has been used to generate the modal model and compare< / li >
< li > Synthesize FRF that has not yet been measured. Then measure that FRF and compare< / li >
< / ul >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-orgbc73745" class = "outline-3" >
< h3 id = "orgbc73745" > < span class = "section-number-3" > 5.1< / span > Theory< / h3 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-3" id = "text-5-1" >
< p >
From the modal model, we want to synthesize the Frequency Response Functions that has been used to build the modal model.
< / p >
< p >
2020-11-12 10:30:56 +01:00
Let’ s recall that:
2019-07-11 16:44:30 +02:00
< / p >
< ul class = "org-ul" >
2019-07-16 11:09:14 +02:00
< li > \(M\) is the number of measured DOFs (\(3 \times n_\text{acc}\))< / li >
< li > \(N\) is the number of modes identified< / li >
2019-07-11 16:44:30 +02:00
< / ul >
< p >
We then have that the FRF matrix \([H_{\text{syn}}]\) can be synthesize using the following formula:
< / p >
2020-11-12 10:30:56 +01:00
< div class = "important" id = "orgcd483b9" >
2019-07-11 16:44:30 +02:00
\begin{equation}
[H_{\text{syn}}(\omega)]_{M\times M} = [\Phi]_{M\times2N} \left[\frac{Q_r}{j\omega - s_r}\right]_{2N\times2N} [\Phi]_{2N\times M}^T
\end{equation}
< p >
with \(Q_r = 1/M_{A_r}\)
< / p >
< / div >
< p >
An alternative formulation is:
\[ H_{pq}(s_i) = \sum_{r=1}^N \frac{A_{pqr}}{s_i - \lambda_r} + \frac{A_{pqr}^*}{s_i - \lambda_r^*} \]
with:
< / p >
< ul class = "org-ul" >
2020-11-12 10:30:56 +01:00
< li > \(A_{pqr} = \frac{\psi_{pr}\psi_{qr}}{M_{A_r}}\), \(M_{A_r}\) is called “ Modal A” < / li >
2019-07-11 16:44:30 +02:00
< li > \(\psi_{pr}\): scaled modal coefficient for output DOF \(p\), mode \(r\)< / li >
< li > \(\lambda_r\): complex modal frequency< / li >
< / ul >
2019-07-16 11:09:14 +02:00
< p >
From the modal software documentation:
< / p >
< blockquote >
< p >
< b > Modal A< / b >
Scaling constant for a complex mode. It has the same properties as modal mass for normal modes (undamped or proportionally damped cases). Assuming
< / p >
< ul class = "org-ul" >
< li > \(\psi_{pr}\) = Modal coefficient for measured degree of freedom p and mode r< / li >
< li > \(\psi_{qr}\) = Modal coefficient for measured degree of freedom q and mode r< / li >
< li > \(A_{pqr}\) = Residue for measured degree of freedom p, measured degree of q and mode r< / li >
< li > \(M_{Ar}\) = Modal A of mode r< / li >
< / ul >
< p >
Then
\[ A_{pqr} = \frac{\psi_{pr}\psi_{qr}}{M_{Ar}} \]
< / p >
< p >
< b > Modal B< / b >
Scaling constant for a complex mode. It has the same properties as modal stiffness for normal modes (undamped or proportionally damped cases). Assuming
< / p >
< ul class = "org-ul" >
< li > \(M_{Ar}\) = Modal A of mode r< / li >
< li > \(\lambda_r\) = System pole of mode r< / li >
< / ul >
< p >
Then
\[ M_{Br} = - \lambda_r M_{Ar} \]
< / p >
< / blockquote >
2019-07-11 16:44:30 +02:00
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-org779f8a2" class = "outline-3" >
< h3 id = "org779f8a2" > < span class = "section-number-3" > 5.2< / span > Matlab Implementation< / h3 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-3" id = "text-5-2" >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > Hsyn = zeros(acc_n< span class = "org-type" > *< / span > dir_n, acc_n< span class = "org-type" > *< / span > dir_n, length(freqs));
2019-07-11 16:44:30 +02:00
2020-11-12 10:30:56 +01:00
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:length(freqs)< / span >
Hsyn(< span class = "org-type" > :< / span > , < span class = "org-type" > :< / span > , < span class = "org-constant" > i< / span > ) = eigen_vec_ext_M< span class = "org-type" > *< / span > ((< span class = "org-constant" > j< / span > < span class = "org-type" > *< / span > 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > freqs(< span class = "org-constant" > i< / span > ))< span class = "org-type" > .^< / span > 2< span class = "org-type" > *< / span > inv(modal_a_ext_M)< span class = "org-type" > /< / span > (diag(< span class = "org-constant" > j< / span > < span class = "org-type" > *< / span > 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > freqs(< span class = "org-constant" > i< / span > ) < span class = "org-type" > -< / span > diag(eigen_val_ext_M))))< span class = "org-type" > *< / span > eigen_vec_ext_M< span class = "org-type" > .'< / span > ;
2019-07-11 16:44:30 +02:00
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< p >
Because the synthesize frequency response functions are representing the displacement response in \([m/N]\), we multiply each element of the FRF matrix by \((j \omega)^2\) in order to obtain the acceleration response in \([m/s^2/N]\).
< / p >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > < span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:size(Hsyn, 1)< / span >
Hsyn(< span class = "org-constant" > i< / span > , < span class = "org-type" > :< / span > , < span class = "org-type" > :< / span > ) = squeeze(Hsyn(< span class = "org-constant" > i< / span > , < span class = "org-type" > :< / span > , < span class = "org-type" > :< / span > ))< span class = "org-type" > .*< / span > (< span class = "org-constant" > j< / span > < span class = "org-type" > *< / span > 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > freqs)< span class = "org-type" > .^< / span > 2;
2019-07-11 16:44:30 +02:00
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-orgc860b37" class = "outline-3" >
< h3 id = "orgc860b37" > < span class = "section-number-3" > 5.3< / span > Original and Synthesize FRF matrix comparison< / h3 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-3" id = "text-5-3" >
2020-11-12 10:30:56 +01:00
< div id = "org90194af" class = "figure" >
2019-07-11 16:44:30 +02:00
< p > < img src = "figs/compare_synthesize_original_frf.png" alt = "compare_synthesize_original_frf.png" / >
< / p >
< p > < span class = "figure-number" > Figure 8: < / span > Comparison of the Original and Synthesize FRF matrix element< / p >
< / div >
2019-07-16 11:09:14 +02:00
2020-11-12 10:30:56 +01:00
< div id = "org75f341c" class = "figure" >
2019-07-16 11:09:14 +02:00
< p > < img src = "img/modal_software/from11xto1x.jpg" alt = "from11xto1x.jpg" / >
< / p >
< p > < span class = "figure-number" > Figure 9: < / span > Original FRF and synthesize FRF using the modal software. From force applied in the X direction to the acceleration of accelerometer 11 in the X direction< / p >
< / div >
2020-11-12 10:30:56 +01:00
< div class = "warning" id = "org617b3c7" >
2019-07-16 11:09:14 +02:00
< p >
The synthesize FRFs from the modal software do not match the synthesize FRFs computed here.
It is possible that it uses residues that are not exported? Nothing is said about that in the documentation.
< / p >
< / div >
2019-07-11 16:44:30 +02:00
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-orgb9f2500" class = "outline-3" >
< h3 id = "orgb9f2500" > < span class = "section-number-3" > 5.4< / span > Synthesize FRF that has not yet been measured< / h3 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-3" id = "text-5-4" >
2020-11-12 10:30:56 +01:00
< div id = "orge1bbcfb" class = "figure" >
2019-07-11 16:44:30 +02:00
< p > < img src = "figs/synthesize_frf_new_meas.png" alt = "synthesize_frf_new_meas.png" / >
< / p >
2019-07-16 11:09:14 +02:00
< p > < span class = "figure-number" > Figure 10: < / span > Synthesize FRF that has not been measured< / p >
2019-07-11 16:44:30 +02:00
< / div >
< / div >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-orgc656623" class = "outline-2" >
< h2 id = "orgc656623" > < span class = "section-number-2" > 6< / span > Modal Complexity< / h2 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-2" id = "text-6" >
< p >
2020-11-12 10:30:56 +01:00
< a id = "org52018e7" > < / a >
A method of displaying < b > modal complexity< / b > is by plotting the elements of the eigenvector on an < b > Argand diagram< / b > (complex plane), such as the ones shown in figure < a href = "#orgbd119c1" > 11< / a > .
2019-07-05 16:58:15 +02:00
< / p >
2019-07-02 17:48:34 +02:00
2019-07-05 16:58:15 +02:00
< p >
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 < b > indication of the complexity of the mode< / b > .
< / p >
2019-07-02 17:48:34 +02:00
2019-07-05 16:58:15 +02:00
< p >
2020-11-12 10:30:56 +01:00
A mode with small complexity is shown on figure < a href = "#orgbd119c1" > 11< / a > whereas an highly complex mode is shown on figure < a href = "#org2425a3a" > 12< / a > .
The complexity of all the modes are compared on figure < a href = "#org558ffaa" > 13< / a > .
2019-07-05 16:58:15 +02:00
< / p >
2019-07-02 17:48:34 +02:00
2020-11-12 10:30:56 +01:00
< div id = "orgbd119c1" class = "figure" >
2019-07-05 16:58:15 +02:00
< p > < img src = "figs/modal_complexity_small.png" alt = "modal_complexity_small.png" / >
< / p >
2019-07-16 11:09:14 +02:00
< p > < span class = "figure-number" > Figure 11: < / span > Modal Complexity of one mode with small complexity< / p >
2019-07-02 17:48:34 +02:00
< / div >
2019-07-05 16:58:15 +02:00
2020-11-12 10:30:56 +01:00
< div id = "org2425a3a" class = "figure" >
2019-07-05 16:58:15 +02:00
< p > < img src = "figs/modal_complexity_high.png" alt = "modal_complexity_high.png" / >
2019-07-02 17:48:34 +02:00
< / p >
2019-07-16 11:09:14 +02:00
< p > < span class = "figure-number" > Figure 12: < / span > Modal Complexity of one higly complex mode< / p >
2019-07-05 16:58:15 +02:00
< / div >
2019-07-02 17:48:34 +02:00
2019-07-05 16:58:15 +02:00
2020-11-12 10:30:56 +01:00
< div id = "org558ffaa" class = "figure" >
2019-07-05 16:58:15 +02:00
< p > < img src = "figs/modal_complexities.png" alt = "modal_complexities.png" / >
2019-07-02 17:48:34 +02:00
< / p >
2019-07-16 11:09:14 +02:00
< p > < span class = "figure-number" > Figure 13: < / span > Modal complexity for each mode< / p >
2019-07-02 17:48:34 +02:00
< / div >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-org0d3f729" class = "outline-2" >
< h2 id = "org0d3f729" > < span class = "section-number-2" > 7< / span > Modal Assurance Criterion (MAC)< / h2 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-2" id = "text-7" >
< p >
The MAC is calculated as the normalized scalar product of the two sets of vectors \(\{\psi_A\}\) and \(\{\psi_X\}\).
2020-11-12 10:30:56 +01:00
The resulting scalars are arranged into the MAC matrix (< a href = "#citeproc_bib_item_1" > Pastor, Binda, and Harvcarik 2012< / a > ):
2019-07-11 16:44:30 +02:00
< / p >
\begin{equation}
\text{MAC}(r, q) = \frac{\left| \{\psi_A\}_r^T \{\psi_X\}_q^* \right|^2}{\left( \{\psi_A\}_r^T \{\psi_A\}_r^* \right) \left( \{\psi_X\}_q^T \{\psi_X\}_q^* \right)}
\end{equation}
< p >
An equivalent formulation is:
< / p >
\begin{equation}
\text{MAC}(r, q) = \frac{\left| \sum_{j=1}^n \{\psi_A\}_j \{\psi_X\}_j^* \right|^2}{\left( \sum_{j=1}^n |\{\psi_A\}_j|^2 \right) \left( \sum_{j=1}^n |\{\psi_X\}_j|^2 \right)}
\end{equation}
< p >
The MAC takes value between 0 (representing no consistent correspondence) and 1 (representing a consistent correspondence).
< / p >
2019-07-05 16:58:15 +02:00
< p >
2020-11-12 10:30:56 +01:00
We compute the autoMAC matrix that compares all the possible combinations of mode shape pairs for only one set of mode shapes. The result is shown on figure < a href = "#org417c43f" > 14< / a > .
2019-07-05 16:58:15 +02:00
< / p >
2019-07-11 16:44:30 +02:00
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > autoMAC = eye(size(eigen_vec_M, 2));
2019-07-11 16:44:30 +02:00
2020-11-12 10:30:56 +01:00
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > r< / span > = < span class = "org-constant" > 1:size(eigen_vec_M, 2)< / span >
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > q< / span > = < span class = "org-constant" > r+1:size(eigen_vec_M, 2)< / span >
autoMAC(r, q) = abs(eigen_vec_M(r, < span class = "org-type" > :< / span > )< span class = "org-type" > *< / span > eigen_vec_M(q, < span class = "org-type" > :< / span > )< span class = "org-type" > '< / span > )< span class = "org-type" > ^< / span > 2< span class = "org-type" > /< / span > ((eigen_vec_M(r, < span class = "org-type" > :< / span > )< span class = "org-type" > *< / span > eigen_vec_M(r, < span class = "org-type" > :< / span > )< span class = "org-type" > '< / span > )< span class = "org-type" > *< / span > (eigen_vec_M(q, < span class = "org-type" > :< / span > )< span class = "org-type" > *< / span > eigen_vec_M(q, < span class = "org-type" > :< / span > )< span class = "org-type" > '< / span > ));
autoMAC(q, r) = autoMAC(r, q);
2019-07-11 16:44:30 +02:00
< span class = "org-keyword" > end< / span >
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "org417c43f" class = "figure" >
2019-07-11 16:44:30 +02:00
< p > < img src = "figs/automac.png" alt = "automac.png" / >
< / p >
2019-07-16 11:09:14 +02:00
< p > < span class = "figure-number" > Figure 14: < / span > AutoMAC< / p >
2019-07-11 16:44:30 +02:00
< / div >
< / div >
2019-07-05 16:58:15 +02:00
< / div >
2019-07-11 16:44:30 +02:00
2020-11-12 10:30:56 +01:00
< div id = "outline-container-org10fd77e" class = "outline-2" >
< h2 id = "org10fd77e" > < span class = "section-number-2" > 8< / span > From accelerometer coordinates to global coordinates for the mode shapes< / h2 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-2" id = "text-8" >
< p >
2020-11-12 10:30:56 +01:00
< a id = "orga23db30" > < / a >
2019-07-11 16:44:30 +02:00
< / p >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-org4e8304a" class = "outline-3" >
< h3 id = "org4e8304a" > < span class = "section-number-3" > 8.1< / span > Mathematical description< / h3 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-3" id = "text-8-1" >
2019-07-02 17:48:34 +02:00
2020-11-12 10:30:56 +01:00
< div id = "org8d24244" class = "figure" >
2019-07-11 16:44:30 +02:00
< p > < img src = "figs/local_to_global_coordinates_modes.png" alt = "local_to_global_coordinates_modes.png" / >
2019-07-02 17:48:34 +02:00
< / p >
< / div >
2019-07-11 16:44:30 +02:00
< p >
If we note \(\xi_i = \{ \xi_{i,x}\ \xi_{i,y}\ \xi_{i,z} \}^T\) the mode shape corresponding to the accelerometer \(i\).
< / p >
2019-07-02 17:48:34 +02:00
< p >
From the figure above, we can write:
< / p >
\begin{align*}
2019-07-11 16:44:30 +02:00
\xi_1 & = \xi + \Omega p_1\\
\xi_2 & = \xi + \Omega p_2\\
\xi_3 & = \xi + \Omega p_3\\
\xi_4 & = \xi + \Omega p_4
2019-07-02 17:48:34 +02:00
\end{align*}
< p >
With
< / p >
\begin{equation}
\Omega = \begin{bmatrix}
0 & -\Omega_z & \Omega_y \\
\Omega_z & 0 & -\Omega_x \\
-\Omega_y & \Omega_x & 0
\end{bmatrix}
\end{equation}
< p >
2019-07-11 16:44:30 +02:00
\(\xi\) and \(\Omega\) represent to mode shapes in translation and rotation of the solid expressed in the frame \(\{O\}\).
2019-07-02 17:48:34 +02:00
< / p >
< p >
2019-07-11 16:44:30 +02:00
We can rearrange the equations in a matrix form, and then we obtain the mode shape of the solid in the wanted frame \(\{O\}\):
2019-07-02 17:48:34 +02:00
< / p >
\begin{equation}
\begin{bmatrix}
2019-07-11 16:44:30 +02:00
\xi_x \\ \xi_y \\ \xi_z \\ \hline \Omega_x \\ \Omega_y \\ \Omega_z
2019-07-02 17:48:34 +02:00
\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}
2019-07-11 16:44:30 +02:00
\xi_{1,x} \\ \xi_{1,y} \\ \xi_{1,z} \\\hline \vdots \\\hline \xi_{4,x} \\ \xi_{4,y} \\ \xi_{4,z}
2019-07-02 17:48:34 +02:00
\end{bmatrix}
\end{equation}
< p >
This inversion is equivalent to a mean square problem.
< / p >
2019-07-05 16:58:15 +02:00
< / div >
< / div >
2019-07-02 17:48:34 +02:00
2020-11-12 10:30:56 +01:00
< div id = "outline-container-orgdd38853" class = "outline-3" >
< h3 id = "orgdd38853" > < span class = "section-number-3" > 8.2< / span > Matlab Implementation< / h3 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-3" id = "text-8-2" >
< p >
The obtained mode shapes matrix that gives the mode shapes of each solid bodies with respect to the fixed frame \(\{O\}\), < code > mode_shapes_O< / code > , is an \(n \times p \times q\) with:
< / p >
< ul class = "org-ul" >
2019-07-16 11:09:14 +02:00
< li > \(n\) is the number of identified modes< / li >
< li > \(p\) is the number of DOFs for each solid body (6)< / li >
< li > \(q\) is the number of solid bodies< / li >
2019-07-11 16:44:30 +02:00
< / ul >
2019-07-02 17:48:34 +02:00
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > mode_shapes_O = zeros(mod_n, 6, length(solid_names));
2019-07-02 17:48:34 +02:00
2020-11-12 10:30:56 +01:00
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > mod_i< / span > = < span class = "org-constant" > 1:mod_n< / span >
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > solid_i< / span > = < span class = "org-constant" > 1:length(solid_names)< / span >
acc_i = solids.(solid_names{solid_i});
2019-07-02 17:48:34 +02:00
2020-11-12 10:30:56 +01:00
Y = mode_shapes(mod_i, < span class = "org-type" > :< / span > , acc_i);
Y = Y(< span class = "org-type" > :< / span > );
2019-07-02 17:48:34 +02:00
2020-11-12 10:30:56 +01:00
A = zeros(3< span class = "org-type" > *< / span > length(acc_i), 6);
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:length(acc_i)< / span >
A(3< span class = "org-type" > *< / span > (< span class = "org-constant" > i< / span > < span class = "org-type" > -< / span > 1)< span class = "org-type" > +< / span > 1< span class = "org-type" > :< / span > 3< span class = "org-type" > *< / span > < span class = "org-constant" > i< / span > , 1< span class = "org-type" > :< / span > 3) = eye(3);
2019-07-02 17:48:34 +02:00
2020-11-12 10:30:56 +01:00
A(3< span class = "org-type" > *< / span > (< span class = "org-constant" > i< / span > < span class = "org-type" > -< / span > 1)< span class = "org-type" > +< / span > 1< span class = "org-type" > :< / span > 3< span class = "org-type" > *< / span > < span class = "org-constant" > i< / span > , 4< span class = "org-type" > :< / span > 6) = [ 0 acc_pos(< span class = "org-constant" > i< / span > , 3) < span class = "org-type" > -< / span > acc_pos(< span class = "org-constant" > i< / span > , 2) ;
< span class = "org-type" > -< / span > acc_pos(< span class = "org-constant" > i< / span > , 3) 0 acc_pos(< span class = "org-constant" > i< / span > , 1) ;
acc_pos(< span class = "org-constant" > i< / span > , 2) < span class = "org-type" > -< / span > acc_pos(< span class = "org-constant" > i< / span > , 1) 0];
2019-07-02 17:48:34 +02:00
< span class = "org-keyword" > end< / span >
2020-11-12 10:30:56 +01:00
mode_shapes_O(mod_i, < span class = "org-type" > :< / span > , solid_i) = A< span class = "org-type" > \< / span > Y;
2019-07-02 17:48:34 +02:00
< span class = "org-keyword" > end< / span >
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< p >
2019-07-11 16:44:30 +02:00
We then rearrange the eigen vectors in another way:
\[ \Psi_O = \begin{bmatrix}
2019-07-02 17:48:34 +02:00
& & \\
2019-07-11 16:44:30 +02:00
\{\psi_1\} & \dots & \{\psi_N\} \\
2019-07-02 17:48:34 +02:00
& &
2019-07-11 16:44:30 +02:00
\end{bmatrix}_{M \times N} \]
2019-07-05 16:58:15 +02:00
with
2019-07-11 16:44:30 +02:00
\[ \{\psi\}_r = \begin{Bmatrix}
\psi_{1, x} & \psi_{1, y} & \psi_{1, z} & \psi_{1, \theta_x} & \psi_{1, \theta_y} & \psi_{1, \theta_z} & \psi_{2, x} & \dots & \psi_{6, \theta_z}
\end{Bmatrix}^T \]
2019-07-02 17:48:34 +02:00
< / p >
2019-07-05 16:58:15 +02:00
< p >
2019-07-16 11:09:14 +02:00
With \(M = 6 \times n_\text{solid}\) is the new number of DOFs and \(N\) is the number of modes.
2019-07-05 16:58:15 +02:00
< / p >
2019-07-02 17:48:34 +02:00
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > eigen_vec_O = reshape(mode_shapes_O, [mod_n, 6< span class = "org-type" > *< / span > length(solid_names)])< span class = "org-type" > .'< / span > ;
2019-07-11 16:44:30 +02:00
2020-11-12 10:30:56 +01:00
eigen_vec_ext_O = [eigen_vec_O, conj(eigen_vec_O)];
2019-07-02 17:48:34 +02:00
< / pre >
< / div >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-orgd2ddc47" class = "outline-3" >
< h3 id = "orgd2ddc47" > < span class = "section-number-3" > 8.3< / span > FRF matrix synthesis< / h3 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-3" id = "text-8-3" >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-orge66cb85" class = "outline-4" >
< h4 id = "orge66cb85" > < span class = "section-number-4" > 8.3.1< / span > Mathematical description< / h4 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-4" id = "text-8-3-1" >
2019-07-03 11:57:59 +02:00
< p >
2019-07-11 16:44:30 +02:00
The synthesize FRF matrix < code > Hsyn_O< / code > is an \(n \times n \times q\) with:
< / p >
< ul class = "org-ul" >
< li > \(n\) is the number of DOFs of the considered 6 solid-bodies: \(6 \times 6 = 36\)< / li >
< li > \(q\) is the number of frequency points \(\omega_i\)< / li >
< / ul >
< p >
For each frequency point \(\omega_i\), the FRF matrix < code > Hsyn_O< / code > is a \(n\times n\) matrix:
< / p >
\begin{equation}
\text{H}_{\text{syn, O}}(\omega_i) = \begin{bmatrix}
\frac{D_{1,T_x}}{F_{1, T_x}}(\omega_i) & \frac{D_{1,T_x}}{F_{1, T_y}}(\omega_i) & \dots & \frac{D_{1,T_x}}{F_{6, R_z}}(\omega_i) \\
\frac{D_{1,T_y}}{F_{1, T_x}}(\omega_i) & \frac{D_{1,T_y}}{F_{1, T_y}}(\omega_i) & & \frac{D_{1,T_y}}{F_{6, R_z}}(\omega_i) \\
\frac{D_{1,T_z}}{F_{1, T_x}}(\omega_i) & \frac{D_{1,T_z}}{F_{1, T_y}}(\omega_i) & & \frac{D_{1,T_z}}{F_{6, R_z}}(\omega_i) \\
\frac{D_{1,R_x}}{F_{1, T_x}}(\omega_i) & \frac{D_{1,R_x}}{F_{1, T_y}}(\omega_i) & & \frac{D_{1,R_x}}{F_{6, R_z}}(\omega_i) \\
\frac{D_{1,R_y}}{F_{1, T_x}}(\omega_i) & \frac{D_{1,R_y}}{F_{1, T_y}}(\omega_i) & & \frac{D_{1,R_y}}{F_{6, R_z}}(\omega_i) \\
\frac{D_{1,R_z}}{F_{1, T_x}}(\omega_i) & \frac{D_{1,R_z}}{F_{1, T_y}}(\omega_i) & & \frac{D_{1,R_z}}{F_{6, R_z}}(\omega_i) \\
\frac{D_{2,T_x}}{F_{1, T_x}}(\omega_i) & \frac{D_{2,T_x}}{F_{1, T_y}}(\omega_i) & & \frac{D_{2,T_x}}{F_{6, R_z}}(\omega_i) \\
\vdots & \vdots & & \vdots \\
\frac{D_{6,R_z}}{F_{1, T_x}}(\omega_i) & \frac{D_{6,R_z}}{F_{1, T_y}}(\omega_i) & & \frac{D_{6,R_z}}{F_{6, R_z}}(\omega_i)
\end{bmatrix}
\end{equation}
< p >
where \(D_i\) corresponds to the solid body number i, \(F_i\) is a force/torque applied on the solid body number i at the center of the frame \(\{O\}\).
2019-07-03 11:57:59 +02:00
< / p >
2020-11-12 10:30:56 +01:00
< div class = "warning" id = "org6a7871d" >
2019-07-03 11:57:59 +02:00
< p >
2019-07-11 16:44:30 +02:00
As the mode shapes are expressed with respect to the frame \(\{O\}\), the obtain FRF matrix are the responses of the system from forces and torques applied to the solid bodies at the origin of \(\{O\}\) to the displacement of the solid bodies with respect to the frame \(\{O\}\).
2019-07-03 11:57:59 +02:00
< / p >
2019-07-02 17:48:34 +02:00
2019-07-11 16:44:30 +02:00
< / div >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-org33d44db" class = "outline-4" >
< h4 id = "org33d44db" > < span class = "section-number-4" > 8.3.2< / span > Matlab Implementation< / h4 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-4" id = "text-8-3-2" >
2019-07-05 16:58:15 +02:00
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > Hsyn_O = zeros(36, 36, 801);
2019-07-11 16:44:30 +02:00
2020-11-12 10:30:56 +01:00
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:length(freqs)< / span >
Hsyn_O(< span class = "org-type" > :< / span > , < span class = "org-type" > :< / span > , < span class = "org-constant" > i< / span > ) = eigen_vec_ext_O< span class = "org-type" > *< / span > (inv(modal_a_ext_M)< span class = "org-type" > /< / span > (diag(< span class = "org-constant" > j< / span > < span class = "org-type" > *< / span > 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > freqs(< span class = "org-constant" > i< / span > ) < span class = "org-type" > -< / span > diag(eigen_val_ext_M))))< span class = "org-type" > *< / span > eigen_vec_ext_O< span class = "org-type" > .'< / span > ;
2019-07-11 16:44:30 +02:00
< span class = "org-keyword" > end< / span >
2019-07-05 16:58:15 +02:00
< / pre >
2019-07-02 17:48:34 +02:00
< / div >
2019-07-05 16:58:15 +02:00
< p >
2019-07-11 16:44:30 +02:00
Because the synthesize frequency response functions are representing the displacement response in \([m/N]\), we multiply each element of the FRF matrix by \((j \omega)^2\) in order to obtain the acceleration response in \([m/s^2/N]\).
2019-07-03 11:57:59 +02:00
< / p >
2019-07-02 17:48:34 +02:00
2019-07-11 16:44:30 +02:00
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > < span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:size(Hsyn_O, 1)< / span >
Hsyn_O(< span class = "org-constant" > i< / span > , < span class = "org-type" > :< / span > , < span class = "org-type" > :< / span > ) = < span class = "org-type" > -< / span > squeeze(Hsyn_O(< span class = "org-constant" > i< / span > , < span class = "org-type" > :< / span > , < span class = "org-type" > :< / span > ))< span class = "org-type" > .*< / span > (< span class = "org-constant" > j< / span > < span class = "org-type" > *< / span > 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > freqs)< span class = "org-type" > .^< / span > 2;
2019-07-11 16:44:30 +02:00
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-orge4645f0" class = "outline-4" >
< h4 id = "orge4645f0" > < span class = "section-number-4" > 8.3.3< / span > Test to have the original inputs< / h4 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-4" id = "text-8-3-3" >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > Hsyn_O = zeros(36, 3, 801);
2019-07-11 16:44:30 +02:00
2020-11-12 10:30:56 +01:00
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:length(freqs)< / span >
Hsyn_O(< span class = "org-type" > :< / span > , < span class = "org-type" > :< / span > , < span class = "org-constant" > i< / span > ) = eigen_vec_ext_O< span class = "org-type" > *< / span > (inv(modal_a_ext_M)< span class = "org-type" > /< / span > (diag(< span class = "org-constant" > j< / span > < span class = "org-type" > *< / span > 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > freqs(< span class = "org-constant" > i< / span > ) < span class = "org-type" > -< / span > diag(eigen_val_ext_M))))< span class = "org-type" > *< / span > eigen_vec_ext_M(10< span class = "org-type" > *< / span > 3< span class = "org-type" > +< / span > 1< span class = "org-type" > :< / span > 11< span class = "org-type" > *< / span > 3, < span class = "org-type" > :< / span > )< span class = "org-type" > .'< / span > ;
2019-07-11 16:44:30 +02:00
< span class = "org-keyword" > end< / span >
2020-11-12 10:30:56 +01:00
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:size(Hsyn_O, 1)< / span >
Hsyn_O(< span class = "org-constant" > i< / span > , < span class = "org-type" > :< / span > , < span class = "org-type" > :< / span > ) = < span class = "org-type" > -< / span > squeeze(Hsyn_O(< span class = "org-constant" > i< / span > , < span class = "org-type" > :< / span > , < span class = "org-type" > :< / span > ))< span class = "org-type" > .*< / span > (< span class = "org-constant" > j< / span > < span class = "org-type" > *< / span > 2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > freqs)< span class = "org-type" > .^< / span > 2;
2019-07-11 16:44:30 +02:00
< span class = "org-keyword" > end< / span >
< / pre >
2019-07-05 16:58:15 +02:00
< / div >
2019-07-02 17:48:34 +02:00
< / div >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-orgb7364d7" class = "outline-3" >
< h3 id = "orgb7364d7" > < span class = "section-number-3" > 8.4< / span > Verification< / h3 >
2019-07-11 16:44:30 +02:00
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-orgd383c3c" class = "outline-3" >
< h3 id = "orgd383c3c" > < span class = "section-number-3" > 8.5< / span > New FRFs< / h3 >
2019-07-11 16:44:30 +02:00
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-org8272b24" class = "outline-2" >
< h2 id = "org8272b24" > < span class = "section-number-2" > 9< / span > Some notes about constraining the number of degrees of freedom< / h2 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-2" id = "text-9" >
2019-07-02 17:48:34 +02:00
< p >
We want to have the two eigen matrices.
< / p >
< p >
2020-11-12 10:30:56 +01:00
They should have the same size \(n \times n\) where \(n\) is the number of mode_shapes as well as the number of degrees of freedom.
2019-07-16 11:09:14 +02:00
Thus, if we consider \(N\) modes, we should restrict our system to have only \(N\) DOFs.
2019-07-02 17:48:34 +02:00
< / p >
< p >
Actually, we are measured 6 DOFs of 6 solids, thus we have 36 DOFs.
< / p >
< p >
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.
< / p >
< p >
In order to determine which DOF can be neglected, two solutions seems possible:
< / p >
< ul class = "org-ul" >
< li > compare the mode shapes< / li >
< li > compare the FRFs< / li >
< / ul >
< p >
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?
< / p >
< table border = "2" cellspacing = "0" cellpadding = "6" rules = "groups" frame = "hsides" >
< colgroup >
< col class = "org-left" / >
< col class = "org-right" / >
< col class = "org-right" / >
< col class = "org-right" / >
< col class = "org-left" / >
< / colgroup >
< thead >
< tr >
< th scope = "col" class = "org-left" > Stage< / th >
< th scope = "col" class = "org-right" > Motion DOFs< / th >
< th scope = "col" class = "org-right" > Parasitic DOF< / th >
< th scope = "col" class = "org-right" > Total DOF< / th >
< th scope = "col" class = "org-left" > Description of DOF< / th >
< / tr >
< / thead >
< tbody >
< tr >
< td class = "org-left" > Granite< / td >
< td class = "org-right" > 0< / td >
< td class = "org-right" > 3< / td >
< td class = "org-right" > 3< / td >
< td class = "org-left" >   < / td >
< / tr >
< tr >
< td class = "org-left" > Ty< / td >
< td class = "org-right" > 1< / td >
< td class = "org-right" > 2< / td >
< td class = "org-right" > 3< / td >
< td class = "org-left" > Ty, Rz< / td >
< / tr >
< tr >
< td class = "org-left" > Ry< / td >
< td class = "org-right" > 1< / td >
< td class = "org-right" > 2< / td >
< td class = "org-right" > 3< / td >
< td class = "org-left" > Ry,< / td >
< / tr >
< tr >
< td class = "org-left" > Rz< / td >
< td class = "org-right" > 1< / td >
< td class = "org-right" > 2< / td >
< td class = "org-right" > 3< / td >
< td class = "org-left" > Rz, Rx, Ry< / td >
< / tr >
< tr >
< td class = "org-left" > Hexapod< / td >
< td class = "org-right" > 6< / td >
< td class = "org-right" > 0< / td >
< td class = "org-right" > 6< / td >
< td class = "org-left" > Txyz, Rxyz< / td >
< / tr >
< / tbody >
< tbody >
< tr >
< td class = "org-left" >   < / td >
< td class = "org-right" > 9< / td >
< td class = "org-right" > 9< / td >
< td class = "org-right" > 18< / td >
< td class = "org-left" >   < / td >
< / tr >
< / tbody >
< / table >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-org5e78b29" class = "outline-2" >
< h2 id = "org5e78b29" > < span class = "section-number-2" > 10< / span > Compare Mode Shapes< / h2 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-2" id = "text-10" >
2019-07-02 17:48:34 +02:00
< p >
2020-11-12 10:30:56 +01:00
Let’ s say we want to see for the first mode which DOFs can be neglected.
2019-07-02 17:48:34 +02:00
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).
< / p >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > mode_i = 3;
dof_i = 6;
2019-07-02 17:48:34 +02:00
2020-11-12 10:30:56 +01:00
mode = eigen_vector_M(dof_i< span class = "org-type" > :< / span > 6< span class = "org-type" > :< / span > end, mode_i);
2019-07-02 17:48:34 +02:00
< span class = "org-type" > figure< / span > ;
hold on;
2020-11-12 10:30:56 +01:00
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > =< span class = "org-constant" > 1:length(mode)< / span >
plot([0, real(mode(< span class = "org-constant" > i< / span > ))], [0, imag(mode(< span class = "org-constant" > i< / span > ))], < span class = "org-string" > '-'< / span > , < span class = "org-string" > 'DisplayName'< / span > , solid_names{< span class = "org-constant" > i< / span > });
2019-07-02 17:48:34 +02:00
< span class = "org-keyword" > end< / span >
hold off;
2020-11-12 10:30:56 +01:00
legend();
2019-07-02 17:48:34 +02:00
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "org-type" > figure< / span > ;
2020-11-12 10:30:56 +01:00
subplot(2, 1, 1);
2019-07-02 17:48:34 +02:00
hold on;
2020-11-12 10:30:56 +01:00
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > =< span class = "org-constant" > 1:length(mode)< / span >
plot(1, norm(mode(< span class = "org-constant" > i< / span > )), < span class = "org-string" > 'o'< / span > );
2019-07-02 17:48:34 +02:00
< span class = "org-keyword" > end< / span >
hold off;
2020-11-12 10:30:56 +01:00
ylabel(< span class = "org-string" > 'Amplitude'< / span > );
2019-07-02 17:48:34 +02:00
2020-11-12 10:30:56 +01:00
subplot(2, 1, 2);
2019-07-02 17:48:34 +02:00
hold on;
2020-11-12 10:30:56 +01:00
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > =< span class = "org-constant" > 1:length(mode)< / span >
plot(1, 180< span class = "org-type" > /< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > angle(mode(< span class = "org-constant" > i< / span > )), < span class = "org-string" > 'o'< / span > , < span class = "org-string" > 'DisplayName'< / span > , solid_names{< span class = "org-constant" > i< / span > });
2019-07-02 17:48:34 +02:00
< span class = "org-keyword" > end< / span >
hold off;
2020-11-12 10:30:56 +01:00
ylim([< span class = "org-type" > -< / span > 180, 180]); yticks([< span class = "org-type" > -< / span > 180< span class = "org-type" > :< / span > 90< span class = "org-type" > :< / span > 180]);
ylabel(< span class = "org-string" > 'Phase [deg]'< / span > );
legend();
2019-07-02 17:48:34 +02:00
< / pre >
< / div >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > test = mode_shapes_O(10, 1, < span class = "org-type" > :< / span > )< span class = "org-type" > /< / span > norm(squeeze(mode_shapes_O(10, 1, < span class = "org-type" > :< / span > )));
test = mode_shapes_O(10, 2, < span class = "org-type" > :< / span > )< span class = "org-type" > /< / span > norm(squeeze(mode_shapes_O(10, 2, < span class = "org-type" > :< / span > )));
2019-07-02 17:48:34 +02:00
< / pre >
< / div >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-org3174ebf" class = "outline-2" >
< h2 id = "org3174ebf" > < span class = "section-number-2" > 11< / span > Mode shapes expressed in a frame at the CoM of the solid bodies< / h2 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-2" id = "text-11" >
2020-11-12 10:30:56 +01:00
< div class = "warning" id = "org05f56df" >
2019-07-11 16:44:30 +02:00
< p >
Maybe the mass-normalized eigen vectors can only be obtained for undamped systems (real eigen values and vectors).
< / p >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-org2e64795" class = "outline-3" >
< h3 id = "org2e64795" > < span class = "section-number-3" > 11.1< / span > Modes shapes transformation< / h3 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-3" id = "text-11-1" >
< p >
First, we load the position of the Center of Mass of each solid body with respect to the point of interest.
< / p >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > model_com = table2array(readtable(< span class = "org-string" > 'mat/model_solidworks_com.txt'< / span > , < span class = "org-string" > 'ReadVariableNames'< / span > , < span class = "org-constant" > false< / span > ));
2019-07-11 16:44:30 +02:00
< / pre >
< / div >
< p >
Then, we reshape the data.
< / p >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > model_com = reshape(model_com , [3, 6]);
2019-07-11 16:44:30 +02:00
< / pre >
< / div >
< p >
Now we convert the mode shapes expressed in the DOF of the accelerometers to the DoF of each solid body (translations and rotations) with respect to their own CoM.
< / p >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > mode_shapes_CoM = zeros(mod_n, 6, length(solid_names));
2019-07-11 16:44:30 +02:00
2020-11-12 10:30:56 +01:00
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > mod_i< / span > = < span class = "org-constant" > 1:mod_n< / span >
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > solid_i< / span > = < span class = "org-constant" > 1:length(solid_names)< / span >
acc_i = solids.(solid_names{solid_i});
2019-07-11 16:44:30 +02:00
2020-11-12 10:30:56 +01:00
Y = mode_shapes(mod_i, < span class = "org-type" > :< / span > , acc_i);
Y = Y(< span class = "org-type" > :< / span > );
2019-07-11 16:44:30 +02:00
2020-11-12 10:30:56 +01:00
A = zeros(3< span class = "org-type" > *< / span > length(acc_i), 6);
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:length(acc_i)< / span >
acc_pos_com = acc_pos(< span class = "org-constant" > i< / span > , < span class = "org-type" > :< / span > )< span class = "org-type" > .'< / span > < span class = "org-type" > -< / span > model_com(< span class = "org-type" > :< / span > , < span class = "org-constant" > i< / span > );
2019-07-11 16:44:30 +02:00
2020-11-12 10:30:56 +01:00
A(3< span class = "org-type" > *< / span > (< span class = "org-constant" > i< / span > < span class = "org-type" > -< / span > 1)< span class = "org-type" > +< / span > 1< span class = "org-type" > :< / span > 3< span class = "org-type" > *< / span > < span class = "org-constant" > i< / span > , 1< span class = "org-type" > :< / span > 3) = eye(3);
A(3< span class = "org-type" > *< / span > (< span class = "org-constant" > i< / span > < span class = "org-type" > -< / span > 1)< span class = "org-type" > +< / span > 1< span class = "org-type" > :< / span > 3< span class = "org-type" > *< / span > < span class = "org-constant" > i< / span > , 4< span class = "org-type" > :< / span > 6) = [ 0 acc_pos_com(3) < span class = "org-type" > -< / span > acc_pos_com(2) ;
< span class = "org-type" > -< / span > acc_pos_com(3) 0 acc_pos_com(1) ;
acc_pos_com< span class = "org-type" > (2) -acc_pos_com(1) 0];< / span >
2019-07-11 16:44:30 +02:00
< span class = "org-keyword" > end< / span >
2020-11-12 10:30:56 +01:00
mode_shapes_CoM(mod_i, < span class = "org-type" > :< / span > , solid_i) = A< span class = "org-type" > \< / span > Y;
2019-07-11 16:44:30 +02:00
< span class = "org-keyword" > end< / span >
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< p >
We then rearrange the eigen vectors in another way:
\[ \Psi_{\text{CoM}} = \begin{bmatrix}
& & \\
\{\psi_1\} & \dots & \{\psi_N\} \\
& &
\end{bmatrix}_{M \times N} \]
with
\[ \{\psi\}_r = \begin{Bmatrix}
\psi_{1, x} & \psi_{1, y} & \psi_{1, z} & \psi_{1, \theta_x} & \psi_{1, \theta_y} & \psi_{1, \theta_z} & \psi_{2, x} & \dots & \psi_{6, \theta_z}
\end{Bmatrix}^T \]
< / p >
< p >
2019-07-16 11:09:14 +02:00
With \(M = 6 \times n_\text{solids}\) is the new number of DOFs and \(N\) is the number of modes.
2019-07-11 16:44:30 +02:00
< / p >
< p >
Each eigen vector is normalized.
< / p >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > eigen_vec_CoM = reshape(mode_shapes_CoM, [mod_n, 6< span class = "org-type" > *< / span > length(solid_names)])< span class = "org-type" > .'< / span > ;
2019-07-11 16:44:30 +02:00
< span class = "org-comment" > % eigen_vec_CoM = eigen_vec_CoM./vecnorm(eigen_vec_CoM);< / span >
2020-11-12 10:30:56 +01:00
eigen_vec_ext_CoM = [eigen_vec_CoM, conj(eigen_vec_CoM)];
2019-07-11 16:44:30 +02:00
< / pre >
< / div >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-org85f8012" class = "outline-3" >
< h3 id = "org85f8012" > < span class = "section-number-3" > 11.2< / span > Mass matrix from solidworks model< / h3 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-3" id = "text-11-2" >
< div class = "org-src-container" >
< pre class = "src src-bash" > sed < span class = "org-string" > '/Mass = /!d'< / span > mat/1_granite_bot.txt | sed < span class = "org-string" > 's/^\s*\t*Mass = //'< / span > | sed < span class = "org-string" > 's/\([0-9.]*\) kilograms\r/\1/'< / span > > mat/model_solidworks_mass.txt
sed < span class = "org-string" > '/Mass = /!d'< / span > mat/2_granite_top.txt | sed < span class = "org-string" > 's/^\s*\t*Mass = //'< / span > | sed < span class = "org-string" > 's/\([0-9.]*\) kilograms\r/\1/'< / span > > > mat/model_solidworks_mass.txt
sed < span class = "org-string" > '/Mass = /!d'< / span > mat/3_ty.txt | sed < span class = "org-string" > 's/^\s*\t*Mass = //'< / span > | sed < span class = "org-string" > 's/\([0-9.]*\) kilograms\r/\1/'< / span > > > mat/model_solidworks_mass.txt
sed < span class = "org-string" > '/Mass = /!d'< / span > mat/4_ry.txt | sed < span class = "org-string" > 's/^\s*\t*Mass = //'< / span > | sed < span class = "org-string" > 's/\([0-9.]*\) kilograms\r/\1/'< / span > > > mat/model_solidworks_mass.txt
sed < span class = "org-string" > '/Mass = /!d'< / span > mat/5_rz.txt | sed < span class = "org-string" > 's/^\s*\t*Mass = //'< / span > | sed < span class = "org-string" > 's/\([0-9.]*\) kilograms\r/\1/'< / span > > > mat/model_solidworks_mass.txt
sed < span class = "org-string" > '/Mass = /!d'< / span > mat/6_hexa.txt | sed < span class = "org-string" > 's/^\s*\t*Mass = //'< / span > | sed < span class = "org-string" > 's/\([0-9.]*\) kilograms\r/\1/'< / span > > > mat/model_solidworks_mass.txt
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-bash" > sed < span class = "org-string" > '/I[xyz][xyz]/!d'< / span > mat/1_granite_bot.txt | sed < span class = "org-string" > 's/^\s*\t*//'< / span > | sed < span class = "org-string" > 's/I[xyz][xyz] = //g'< / span > | sed $< span class = "org-string" > 's/\r//'< / span > > mat/model_solidworks_inertia.txt
sed < span class = "org-string" > '/I[xyz][xyz]/!d'< / span > mat/2_granite_top.txt | sed < span class = "org-string" > 's/^\s*\t*//'< / span > | sed < span class = "org-string" > 's/I[xyz][xyz] = //g'< / span > | sed $< span class = "org-string" > 's/\r//'< / span > > > mat/model_solidworks_inertia.txt
sed < span class = "org-string" > '/I[xyz][xyz]/!d'< / span > mat/3_ty.txt | sed < span class = "org-string" > 's/^\s*\t*//'< / span > | sed < span class = "org-string" > 's/I[xyz][xyz] = //g'< / span > | sed $< span class = "org-string" > 's/\r//'< / span > > > mat/model_solidworks_inertia.txt
sed < span class = "org-string" > '/I[xyz][xyz]/!d'< / span > mat/4_ry.txt | sed < span class = "org-string" > 's/^\s*\t*//'< / span > | sed < span class = "org-string" > 's/I[xyz][xyz] = //g'< / span > | sed $< span class = "org-string" > 's/\r//'< / span > > > mat/model_solidworks_inertia.txt
sed < span class = "org-string" > '/I[xyz][xyz]/!d'< / span > mat/5_rz.txt | sed < span class = "org-string" > 's/^\s*\t*//'< / span > | sed < span class = "org-string" > 's/I[xyz][xyz] = //g'< / span > | sed $< span class = "org-string" > 's/\r//'< / span > > > mat/model_solidworks_inertia.txt
sed < span class = "org-string" > '/I[xyz][xyz]/!d'< / span > mat/6_hexa.txt | sed < span class = "org-string" > 's/^\s*\t*//'< / span > | sed < span class = "org-string" > 's/I[xyz][xyz] = //g'< / span > | sed $< span class = "org-string" > 's/\r//'< / span > > > mat/model_solidworks_inertia.txt
< / pre >
< / div >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > model_mass = table2array(readtable(< span class = "org-string" > 'mat/model_solidworks_mass.txt'< / span > , < span class = "org-string" > 'ReadVariableNames'< / span > , < span class = "org-constant" > false< / span > ));
model_inertia = table2array(readtable(< span class = "org-string" > 'mat/model_solidworks_inertia.txt'< / span > , < span class = "org-string" > 'ReadVariableNames'< / span > , < span class = "org-constant" > false< / span > ));
2019-07-11 16:44:30 +02:00
< / pre >
< / div >
< p >
\[ M = \begin{bmatrix}
M_1 & & & & & \\
& M_2 & & & & \\
& & M_3 & & & \\
& & & M_4 & & \\
& & & & M_5 & \\
& & & & & M_6 \\
\end{bmatrix}, \text{ with } M_i = \begin{bmatrix}
m_i & & & & & \\
& m_i & & & & \\
& & m_i & & & \\
& & & I_{i,xx} & I_{i,yx} & I_{i,zx} \\
& & & I_{i,xy} & I_{i,yy} & I_{i,zy} \\
& & & I_{i,xz} & I_{i,yz} & I_{i,zz} \\
\end{bmatrix} \]
< / p >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > M = zeros(6< span class = "org-type" > *< / span > 6, 6< span class = "org-type" > *< / span > 6);
2019-07-11 16:44:30 +02:00
2020-11-12 10:30:56 +01:00
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:6< / span >
M((< span class = "org-constant" > i< / span > < span class = "org-type" > -< / span > 1)< span class = "org-type" > *< / span > 6< span class = "org-type" > +< / span > 1< span class = "org-type" > :< / span > < span class = "org-constant" > i< / span > < span class = "org-type" > *< / span > 6, (< span class = "org-constant" > i< / span > < span class = "org-type" > -< / span > 1)< span class = "org-type" > *< / span > 6< span class = "org-type" > +< / span > 1< span class = "org-type" > :< / span > < span class = "org-constant" > i< / span > < span class = "org-type" > *< / span > 6) = blkdiag(model_mass(< span class = "org-constant" > i< / span > )< span class = "org-type" > *< / span > eye(3), model_inertia((< span class = "org-constant" > i< / span > < span class = "org-type" > -< / span > 1)< span class = "org-type" > *< / span > 3< span class = "org-type" > +< / span > 1< span class = "org-type" > :< / span > < span class = "org-constant" > i< / span > < span class = "org-type" > *< / span > 3, 1< span class = "org-type" > :< / span > 3));
2019-07-11 16:44:30 +02:00
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-org6bee07f" class = "outline-3" >
< h3 id = "org6bee07f" > < span class = "section-number-3" > 11.3< / span > Mass-normalized Eigen Vectors< / h3 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-3" id = "text-11-3" >
< p >
To do so, it seems that we need to know the mass matrix \([M]\). Then:
\[ \{\phi\}_r = \frac{1}{\sqrt{m_r}} \{\psi\}_r \text{ where } m_r = \{\psi\}_r^T [M] \{\psi\}_r \]
< / p >
< p >
Mass-normalized eigen vectors are very important for the synthesis and spatial model extraction.
< / p >
< p >
Mass Matrix could be estimated from the SolidWorks model.
< / p >
< p >
We compute the modal masses that will be used for normalization.
< / p >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > mr = zeros(size(eigen_vector_matrix_CoM, 2), 1);
2019-07-11 16:44:30 +02:00
2020-11-12 10:30:56 +01:00
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:length(mr)< / span >
mr(< span class = "org-constant" > i< / span > ) = real(eigen_vector_matrix_CoM(< span class = "org-type" > :< / span > , < span class = "org-constant" > i< / span > )< span class = "org-type" > .'< / span > < span class = "org-type" > *< / span > M < span class = "org-type" > *< / span > eigen_vector_matrix_CoM(< span class = "org-type" > :< / span > , < span class = "org-constant" > i< / span > ));
2019-07-11 16:44:30 +02:00
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "org-type" > figure< / span > ;
2020-11-12 10:30:56 +01:00
plot(freqs_m, mr, < span class = "org-string" > 'ko'< / span > );
xlabel(< span class = "org-string" > 'Mode Frequency [Hz]'< / span > ); ylabel(< span class = "org-string" > 'Modal mass [kg]'< / span > );
2019-07-11 16:44:30 +02:00
< / pre >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "orgf9951b6" class = "figure" >
2019-07-11 16:44:30 +02:00
< p > < img src = "figs/modal_mass.png" alt = "modal_mass.png" / >
< / p >
2019-07-16 11:09:14 +02:00
< p > < span class = "figure-number" > Figure 16: < / span > Modal masses< / p >
2019-07-11 16:44:30 +02:00
< / div >
< p >
And finally, we compute the mass-normalized eigen vectors.
< / p >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > eigen_vector_mass_CoM = zeros(size(eigen_vector_matrix_CoM));
2019-07-11 16:44:30 +02:00
2020-11-12 10:30:56 +01:00
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:size(eigen_vector_matrix_CoM, 2)< / span >
eigen_vector_mass_CoM(< span class = "org-type" > :< / span > , < span class = "org-constant" > i< / span > ) = 1< span class = "org-type" > /< / span > sqrt(mr(< span class = "org-constant" > i< / span > )) < span class = "org-type" > *< / span > eigen_vector_matrix_CoM(< span class = "org-type" > :< / span > , < span class = "org-constant" > i< / span > );
2019-07-11 16:44:30 +02:00
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< p >
Verification that
\[ [\Phi]^T [M] [\Phi] = [I] \]
< / p >
< div class = "org-src-container" >
< pre class = "src src-matlab" > eigen_vector_matrix_CoM< span class = "org-type" > .'*< / span > M< span class = "org-type" > *< / span > eigen_vector_matrix_CoM
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > eigen_vector_mass_CoM< span class = "org-type" > *< / span > M< span class = "org-type" > *< / span > eigen_vector_mass_CoM< span class = "org-type" > .'< / span >
< / pre >
< / div >
< p >
Other test for normalized eigen vectors
< / p >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > eigen_vector_mass_CoM = (eigen_vector_matrix_CoM< span class = "org-type" > .'*< / span > diag(diag(M))< span class = "org-type" > *< / span > eigen_vector_matrix_CoM)< span class = "org-type" > ^< / span > (< span class = "org-type" > -< / span > 0.5) < span class = "org-type" > *< / span > eigen_vector_matrix_CoM< span class = "org-type" > '< / span > ;
2019-07-11 16:44:30 +02:00
eigen_vector_mass_CoM = eigen_vector_mass_CoM< span class = "org-type" > .'< / span > ;
< / pre >
< / div >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-org68b7508" class = "outline-3" >
< h3 id = "org68b7508" > < span class = "section-number-3" > 11.4< / span > Full Response Model from modal model (synthesis)< / h3 >
2019-07-11 16:44:30 +02:00
< div class = "outline-text-3" id = "text-11-4" >
< p >
In general, the form of response model with which we are concerned is an < b > FRF matrix< / b > whose order is dictated by the number of coordinates \(n\) included in the test.
Also, as explained, it is normal in practice to measured and to analyze just a < b > subset of the FRF matrix< / b > but rather to measure the full FRF matrix.
Usually < b > one column< / b > or < b > one row< / b > with a few additional elements are measured.
< / p >
< p >
Thus, if we are to construct an acceptable response model, it will be necessary to synthesize those elements which have not been directly measured.
However, in principle, this need present no major problem as it is possible to compute the full FRF matrix from a modal model using:
< / p >
\begin{equation}
[H]_{n\times n} = [\Phi]_{n\times m} [\lambda_r^2 - \omega^2]_{m\times m}^{-1} [\Phi]_{m\times n}^T
\end{equation}
< p >
\(\{\Phi\}\) is a < b > mass-normalized< / b > eigen vector.
< / p >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > FRF_matrix_CoM = zeros(size(eigen_vector_mass_CoM, 1), size(eigen_vector_mass_CoM, 1), length(freqs));
2019-07-11 16:44:30 +02:00
2020-11-12 10:30:56 +01:00
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:length(freqs)< / span >
FRF_matrix_CoM(< span class = "org-type" > :< / span > , < span class = "org-type" > :< / span > , < span class = "org-constant" > i< / span > ) = eigen_vector_mass_CoM< span class = "org-type" > *< / span > inv(eigen_value_M< span class = "org-type" > ^< / span > 2 < span class = "org-type" > -< / span > (2< span class = "org-type" > *< / span > < span class = "org-constant" > pi< / span > < span class = "org-type" > *< / span > freqs(< span class = "org-constant" > i< / span > )< span class = "org-type" > *< / span > eye(size(eigen_value_M, 1)))< span class = "org-type" > ^< / span > 2)< span class = "org-type" > *< / span > eigen_vector_mass_CoM< span class = "org-type" > .'< / span > ;
2019-07-11 16:44:30 +02:00
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > exc_dir = 3;
meas_mass = 6;
meas_dir = 3;
2019-07-11 16:44:30 +02:00
< span class = "org-type" > figure< / span > ;
hold on;
2020-11-12 10:30:56 +01:00
plot(freqs, abs(squeeze(FRF_matrix_CoM((meas_mass< span class = "org-type" > -< / span > 1)< span class = "org-type" > *< / span > 6 < span class = "org-type" > +< / span > meas_dir, 6< span class = "org-type" > *< / span > 2< span class = "org-type" > +< / span > exc_dir, < span class = "org-type" > :< / span > ))));
plot(freqs, abs(squeeze(FRFs_CoM((meas_mass< span class = "org-type" > -< / span > 1)< span class = "org-type" > *< / span > 6 < span class = "org-type" > +< / span > meas_dir, exc_dir, < span class = "org-type" > :< / span > ))));
2019-07-11 16:44:30 +02:00
hold off;
2020-11-12 10:30:56 +01:00
< span class = "org-type" > set< / span > (< span class = "org-variable-name" > gca< / span > , < span class = "org-string" > 'XScale'< / span > , < span class = "org-string" > 'log'< / span > ); < span class = "org-type" > set< / span > (< span class = "org-variable-name" > gca< / span > , < span class = "org-string" > 'YScale'< / span > , < span class = "org-string" > 'log'< / span > );
xlabel(< span class = "org-string" > 'Frequency [Hz]'< / span > ); ylabel(< span class = "org-string" > 'Amplitude'< / span > );
xlim([1, 200]);
2019-07-11 16:44:30 +02:00
< / pre >
< / div >
< div class = "org-src-container" >
2020-11-12 10:30:56 +01:00
< pre class = "src src-matlab" > FRF_matrix = zeros(size(eigen_vector_mass, 1), size(eigen_vector_mass, 1), length(freqs));
2019-07-11 16:44:30 +02:00
2020-11-12 10:30:56 +01:00
< span class = "org-keyword" > for< / span > < span class = "org-variable-name" > < span class = "org-constant" > i< / span > < / span > = < span class = "org-constant" > 1:length(freqs)< / span >
FRF_matrix(< span class = "org-type" > :< / span > , < span class = "org-type" > :< / span > , < span class = "org-constant" > i< / span > ) = eigen_vector_mass< span class = "org-type" > *< / span > inv(eigen_value_M < span class = "org-type" > -< / span > (freqs(< span class = "org-constant" > i< / span > )< span class = "org-type" > *< / span > eye(size(eigen_value_M, 1)))< span class = "org-type" > ^< / span > 2)< span class = "org-type" > *< / span > eigen_vector_mass< span class = "org-type" > .'< / span > ;
2019-07-11 16:44:30 +02:00
< span class = "org-keyword" > end< / span >
< / pre >
< / div >
< div class = "org-src-container" >
< pre class = "src src-matlab" > < span class = "org-type" > figure< / span > ;
hold on;
2020-11-12 10:30:56 +01:00
plot(freqs, abs(squeeze(FRFs_O(1, 1, < span class = "org-type" > :< / span > ))));
plot(freqs, abs(squeeze(FRF_matrix(1, 1, < span class = "org-type" > :< / span > ))));
2019-07-11 16:44:30 +02:00
hold off;
2020-11-12 10:30:56 +01:00
< span class = "org-type" > set< / span > (< span class = "org-variable-name" > gca< / span > , < span class = "org-string" > 'XScale'< / span > , < span class = "org-string" > 'log'< / span > ); < span class = "org-type" > set< / span > (< span class = "org-variable-name" > gca< / span > , < span class = "org-string" > 'YScale'< / span > , < span class = "org-string" > 'log'< / span > );
xlabel(< span class = "org-string" > 'Frequency [Hz]'< / span > ); ylabel(< span class = "org-string" > 'Amplitude'< / span > );
xlim([1, 200]);
2019-07-11 16:44:30 +02:00
< / pre >
< / div >
< / div >
< / div >
< / div >
2020-11-12 10:30:56 +01:00
< div id = "outline-container-org5858b03" class = "outline-2" >
< h2 id = "org5858b03" > < span class = "section-number-2" > 12< / span > Residues< / h2 >
2019-07-02 17:48:34 +02:00
< / div >
2019-07-11 16:44:30 +02:00
< p >
< / p >
2020-11-12 10:30:56 +01:00
< style > . csl-entry { text-indent : -1.5 em ; margin-left : 1.5 em ; } < / style > < h2 class = 'citeproc-org-bib-h2' > Bibliography< / h2 >
< div class = "csl-bib-body" >
< div class = "csl-entry" > < a name = "citeproc_bib_item_1" > < / a > Pastor, Miroslav, Michal Binda, and Tomávs Harvcarik. 2012. “Modal Assurance Criterion.” < i > Procedia Engineering< / i > 48 (nil):543– < a href = "https://doi.org/10.1016/j.proeng.2012.09.551" > https://doi.org/10.1016/j.proeng.2012.09.551< / a > .< / div >
< / div >
2019-07-02 17:48:34 +02:00
< / div >
< div id = "postamble" class = "status" >
< p class = "author" > Author: Dehaeze Thomas< / p >
2020-11-12 10:30:56 +01:00
< p class = "date" > Created: 2020-11-12 jeu. 10:29< / p >
2019-07-02 17:48:34 +02:00
< / div >
< / body >
< / html >
