UP | HOME

Simscape Uniaxial Model

Table of Contents

The idea is to use the same model as the full Simscape Model but to restrict the motion only in the vertical direction.

This is done in order to more easily study the system and evaluate control techniques.

1 Simscape Model

A schematic of the uniaxial model used for simulations is represented in figure 1.

The perturbations \(w\) are:

  • \(F_s\): direct forces applied to the sample such as inertia forces and cable forces
  • \(F_{rz}\): parasitic forces due to the rotation of the spindle
  • \(F_{ty}\): parasitic forces due to scans with the translation stage
  • \(D_w\): ground motion

The quantity to \(z\) to control is:

  • \(D\): the position of the sample with respect to the granite

The measured quantities \(v\) are:

  • \(D\): the position of the sample with respect to the granite

We study the use of an additional sensor:

  • \(F_n\): a force sensor located in the nano-hexapod
  • \(v_n\): an absolute velocity sensor located on the top platform of the nano-hexapod
  • \(d_r\): a relative motion sensor located in the nano-hexapod

The control signal \(u\) is:

  • \(F\) the force applied by the nano-hexapod actuator

uniaxial-model-nass-flexible.png

Figure 1: Schematic of the uniaxial model used

Few active damping techniques will be compared in order to decide which sensor is to be included in the system. Schematics of the active damping techniques are displayed in figure 2.

uniaxial-model-nass-flexible-active-damping.png

Figure 2: Comparison of used active damping techniques

2 Undamped System

Let's start by study the undamped system.

2.1 Init

We initialize all the stages with the default parameters. The nano-hexapod is a piezoelectric hexapod and the sample has a mass of 50kg.

All the controllers are set to 0 (Open Loop).

2.2 Identification

We identify the dynamics of the system. 

%% Options for Linearized
options = linearizeOptions;
options.SampleTime = 0;

%% Name of the Simulink File
mdl = 'sim_nano_station_uniaxial';

The inputs and outputs are defined below and corresponds to the name of simulink blocks. 

%% Input/Output definition
io(1)  = linio([mdl, '/Dw'],   1, 'input'); % Ground Motion
io(2)  = linio([mdl, '/Fs'],   1, 'input'); % Force applied on the sample
io(3)  = linio([mdl, '/Fnl'],  1, 'input'); % Force applied by the NASS
io(4)  = linio([mdl, '/Fdty'], 1, 'input'); % Parasitic force Ty
io(5)  = linio([mdl, '/Fdrz'], 1, 'input'); % Parasitic force Rz

io(6)  = linio([mdl, '/Dsm'],  1, 'output'); % Displacement of the sample
io(7)  = linio([mdl, '/Fnlm'], 1, 'output'); % Force sensor in NASS's legs
io(8)  = linio([mdl, '/Dnlm'], 1, 'output'); % Displacement of NASS's legs
io(9)  = linio([mdl, '/Dgm'],  1, 'output'); % Absolute displacement of the granite
io(10) = linio([mdl, '/Vlm'],  1, 'output'); % Measured absolute velocity of the top NASS platform

Finally, we use the linearize Matlab function to extract a state space model from the simscape model. 

%% Run the linearization
G = linearize(mdl, io, options);
G.InputName  = {'Dw',   ... % Ground Motion [m]
                'Fs',   ... % Force Applied on Sample [N]
                'Fn',   ... % Force applied by NASS [N]
                'Fty',  ... % Parasitic Force Ty [N]
                'Frz'};     % Parasitic Force Rz [N]
G.OutputName = {'D',    ... % Measured sample displacement x.r.t. granite [m]
                'Fnm',  ... % Force Sensor in NASS [N]
                'Dnm',  ... % Displacement Sensor in NASS [m]
                'Dgm',  ... % Asbolute displacement of Granite [m]
                'Vlm'}; ... % Absolute Velocity of NASS [m/s]

Finally, we save the identified system dynamics for further analysis. 

save('./uniaxial/mat/plants.mat', 'G');

2.3 Sensitivity to Disturbances

We show several plots representing the sensitivity to disturbances:

  • in figure 3 the transfer functions from ground motion \(D_w\) to the sample position \(D\) and the transfer function from direct force on the sample \(F_s\) to the sample position \(D\) are shown
  • in figure 4, it is the effect of parasitic forces of the positioning stages (\(F_{ty}\) and \(F_{rz}\)) on the position \(D\) of the sample that are shown

uniaxial-sensitivity-disturbances.png

Figure 3: Sensitivity to disturbances (png, pdf)

uniaxial-sensitivity-force-dist.png

Figure 4: Sensitivity to disturbances (png, pdf)

2.4 Noise Budget

We first load the measured PSD of the disturbance. 

load('./disturbances/mat/dist_psd.mat', 'dist_f');

The effect of these disturbances on the distance \(D\) is computed below. The PSD of the obtain distance \(D\) due to each of the perturbation is shown in figure 5 and the Cumulative Amplitude Spectrum is shown in figure 6.

The Root Mean Square value of the obtained displacement \(D\) is computed below and can be determined from the figure 6. 

3.3793e-06

uniaxial-psd-dist.png

Figure 5: caption (png, pdf)

uniaxial-cas-dist.png

Figure 6: caption (png, pdf)

2.5 Plant

The transfer function from the force \(F\) applied by the nano-hexapod to the position of the sample \(D\) is shown in figure 7. It corresponds to the plant to control.

uniaxial-plant.png

Figure 7: Bode plot of the Plant (png, pdf)

3 Integral Force Feedback

uniaxial-model-nass-flexible-iff.png

Figure 8: Uniaxial IFF Control Schematic

3.1 Control Design

load('./uniaxial/mat/plants.mat', 'G');

Let's look at the transfer function from actuator forces in the nano-hexapod to the force sensor in the nano-hexapod legs for all 6 pairs of actuator/sensor.

uniaxial_iff_plant.png

Figure 9: Transfer function from forces applied in the legs to force sensor (png, pdf)

The controller for each pair of actuator/sensor is: 

K_iff = -1000/s;

uniaxial_iff_open_loop.png

Figure 10: Loop Gain for the Integral Force Feedback (png, pdf)

3.2 Identification

Let's initialize the system prior to identification. 

initializeGround();
initializeGranite();
initializeTy();
initializeRy();
initializeRz();
initializeMicroHexapod();
initializeAxisc();
initializeMirror();
initializeNanoHexapod(struct('actuator', 'piezo'));
initializeSample(struct('mass', 50));

All the controllers are set to 0. 

K = tf(0);
save('./mat/controllers.mat', 'K', '-append');
K_iff = -K_iff;
save('./mat/controllers.mat', 'K_iff', '-append');
K_rmc = tf(0);
save('./mat/controllers.mat', 'K_rmc', '-append');
K_dvf = tf(0);
save('./mat/controllers.mat', 'K_dvf', '-append');

%% Options for Linearized
options = linearizeOptions;
options.SampleTime = 0;

%% Name of the Simulink File
mdl = 'sim_nano_station_uniaxial';

%% Input/Output definition
io(1)  = linio([mdl, '/Dw'],    1, 'input');  % Ground Motion
io(2)  = linio([mdl, '/Fs'],    1, 'input');  % Force applied on the sample
io(3)  = linio([mdl, '/Fnl'],   1, 'input');  % Force applied by the NASS
io(4)  = linio([mdl, '/Fdty'],  1, 'input');  % Parasitic force Ty
io(5)  = linio([mdl, '/Fdrz'],  1, 'input');  % Parasitic force Rz

io(6)  = linio([mdl, '/Dsm'],  1, 'output'); % Displacement of the sample
io(7)  = linio([mdl, '/Fnlm'], 1, 'output'); % Force sensor in NASS's legs
io(8)  = linio([mdl, '/Dnlm'], 1, 'output'); % Displacement of NASS's legs
io(9)  = linio([mdl, '/Dgm'],  1, 'output'); % Absolute displacement of the granite
io(10) = linio([mdl, '/Vlm'],  1, 'output'); % Measured absolute velocity of the top NASS platform

%% Run the linearization
G_iff = linearize(mdl, io, options);
G_iff.InputName  = {'Dw',   ... % Ground Motion [m]
                    'Fs',   ... % Force Applied on Sample [N]
                    'Fn',   ... % Force applied by NASS [N]
                    'Fty',  ... % Parasitic Force Ty [N]
                    'Frz'};     % Parasitic Force Rz [N]
G_iff.OutputName = {'D',    ... % Measured sample displacement x.r.t. granite [m]
                    'Fnm',  ... % Force Sensor in NASS [N]
                    'Dnm',  ... % Displacement Sensor in NASS [m]
                    'Dgm',  ... % Asbolute displacement of Granite [m]
                    'Vlm'}; ... % Absolute Velocity of NASS [m/s]

save('./uniaxial/mat/plants.mat', 'G_iff', '-append');

3.3 Sensitivity to Disturbance

uniaxial_sensitivity_dist_iff.png

Figure 11: Sensitivity to disturbance once the IFF controller is applied to the system (png, pdf)

uniaxial_sensitivity_dist_stages_iff.png

Figure 12: Sensitivity to force disturbances in various stages when IFF is applied (png, pdf)

3.4 Damped Plant

uniaxial_plant_iff_damped.png

Figure 13: Damped Plant after IFF is applied (png, pdf)

3.5 Conclusion

Integral Force Feedback:

4 Relative Motion Control

In the Relative Motion Control (RMC), a derivative feedback is applied between the measured actuator displacement to the actuator force input.

uniaxial-model-nass-flexible-rmc.png

Figure 14: Uniaxial RMC Control Schematic

4.1 Control Design

load('./uniaxial/mat/plants.mat', 'G');

Let's look at the transfer function from actuator forces in the nano-hexapod to the measured displacement of the actuator for all 6 pairs of actuator/sensor.

uniaxial_rmc_plant.png

Figure 15: Transfer function from forces applied in the legs to leg displacement sensor (png, pdf)

The Relative Motion Controller is defined below. A Low pass Filter is added to make the controller transfer function proper. 

K_rmc = s*50000/(1 + s/2/pi/10000);

uniaxial_rmc_open_loop.png

Figure 16: Loop Gain for the Integral Force Feedback (png, pdf)

4.2 Identification

Let's initialize the system prior to identification. 

initializeGround();
initializeGranite();
initializeTy();
initializeRy();
initializeRz();
initializeMicroHexapod();
initializeAxisc();
initializeMirror();
initializeNanoHexapod(struct('actuator', 'piezo'));
initializeSample(struct('mass', 50));

And initialize the controllers. 

K = tf(0);
save('./mat/controllers.mat', 'K', '-append');
K_iff = tf(0);
save('./mat/controllers.mat', 'K_iff', '-append');
K_rmc = -K_rmc;
save('./mat/controllers.mat', 'K_rmc', '-append');
K_dvf = tf(0);
save('./mat/controllers.mat', 'K_dvf', '-append');

%% Options for Linearized
options = linearizeOptions;
options.SampleTime = 0;

%% Name of the Simulink File
mdl = 'sim_nano_station_uniaxial';

%% Input/Output definition
io(1)  = linio([mdl, '/Dw'],    1, 'input');  % Ground Motion
io(2)  = linio([mdl, '/Fs'],    1, 'input');  % Force applied on the sample
io(3)  = linio([mdl, '/Fnl'],   1, 'input');  % Force applied by the NASS
io(4)  = linio([mdl, '/Fdty'],  1, 'input');  % Parasitic force Ty
io(5)  = linio([mdl, '/Fdrz'],  1, 'input');  % Parasitic force Rz

io(6)  = linio([mdl, '/Dsm'],  1, 'output'); % Displacement of the sample
io(7)  = linio([mdl, '/Fnlm'], 1, 'output'); % Force sensor in NASS's legs
io(8)  = linio([mdl, '/Dnlm'], 1, 'output'); % Displacement of NASS's legs
io(9)  = linio([mdl, '/Dgm'],  1, 'output'); % Absolute displacement of the granite
io(10) = linio([mdl, '/Vlm'],  1, 'output'); % Measured absolute velocity of the top NASS platform

%% Run the linearization
G_rmc = linearize(mdl, io, options);
G_rmc.InputName  = {'Dw',   ... % Ground Motion [m]
                    'Fs',   ... % Force Applied on Sample [N]
                    'Fn',   ... % Force applied by NASS [N]
                    'Fty',  ... % Parasitic Force Ty [N]
                    'Frz'};     % Parasitic Force Rz [N]
G_rmc.OutputName = {'D',    ... % Measured sample displacement x.r.t. granite [m]
                    'Fnm',  ... % Force Sensor in NASS [N]
                    'Dnm',  ... % Displacement Sensor in NASS [m]
                    'Dgm',  ... % Asbolute displacement of Granite [m]
                    'Vlm'}; ... % Absolute Velocity of NASS [m/s]

save('./uniaxial/mat/plants.mat', 'G_rmc', '-append');

4.3 Sensitivity to Disturbance

uniaxial_sensitivity_dist_rmc.png

Figure 17: Sensitivity to disturbance once the RMC controller is applied to the system (png, pdf)

uniaxial_sensitivity_dist_stages_rmc.png

Figure 18: Sensitivity to force disturbances in various stages when RMC is applied (png, pdf)

4.4 Damped Plant

uniaxial_plant_rmc_damped.png

Figure 19: Damped Plant after RMC is applied (png, pdf)

4.5 Conclusion

Relative Motion Control:

5 Direct Velocity Feedback

In the Relative Motion Control (RMC), a feedback is applied between the measured velocity of the platform to the actuator force input.

uniaxial-model-nass-flexible-dvf.png

Figure 20: Uniaxial DVF Control Schematic

5.1 Control Design

load('./uniaxial/mat/plants.mat', 'G');

uniaxial_dvf_plant.png

Figure 21: Transfer function from forces applied in the legs to leg velocity sensor (png, pdf)

K_dvf = tf(5e4);

uniaxial_dvf_loop_gain.png

Figure 22: Transfer function from forces applied in the legs to leg velocity sensor (png, pdf)

5.2 Identification

Let's initialize the system prior to identification. 

initializeGround();
initializeGranite();
initializeTy();
initializeRy();
initializeRz();
initializeMicroHexapod();
initializeAxisc();
initializeMirror();
initializeNanoHexapod(struct('actuator', 'piezo'));
initializeSample(struct('mass', 50));

And initialize the controllers. 

K = tf(0);
save('./mat/controllers.mat', 'K', '-append');
K_iff = tf(0);
save('./mat/controllers.mat', 'K_iff', '-append');
K_rmc = tf(0);
save('./mat/controllers.mat', 'K_rmc', '-append');
K_dvf = -K_dvf;
save('./mat/controllers.mat', 'K_dvf', '-append');

%% Options for Linearized
options = linearizeOptions;
options.SampleTime = 0;

%% Name of the Simulink File
mdl = 'sim_nano_station_uniaxial';

%% Input/Output definition
io(1)  = linio([mdl, '/Dw'],    1, 'input');  % Ground Motion
io(2)  = linio([mdl, '/Fs'],    1, 'input');  % Force applied on the sample
io(3)  = linio([mdl, '/Fnl'],   1, 'input');  % Force applied by the NASS
io(4)  = linio([mdl, '/Fdty'],  1, 'input');  % Parasitic force Ty
io(5)  = linio([mdl, '/Fdrz'],  1, 'input');  % Parasitic force Rz

io(6)  = linio([mdl, '/Dsm'],  1, 'output'); % Displacement of the sample
io(7)  = linio([mdl, '/Fnlm'], 1, 'output'); % Force sensor in NASS's legs
io(8)  = linio([mdl, '/Dnlm'], 1, 'output'); % Displacement of NASS's legs
io(9)  = linio([mdl, '/Dgm'],  1, 'output'); % Absolute displacement of the granite
io(10) = linio([mdl, '/Vlm'],  1, 'output'); % Measured absolute velocity of the top NASS platform

%% Run the linearization
G_dvf = linearize(mdl, io, options);
G_dvf.InputName  = {'Dw',   ... % Ground Motion [m]
                    'Fs',   ... % Force Applied on Sample [N]
                    'Fn',   ... % Force applied by NASS [N]
                    'Fty',  ... % Parasitic Force Ty [N]
                    'Frz'};     % Parasitic Force Rz [N]
G_dvf.OutputName = {'D',    ... % Measured sample displacement x.r.t. granite [m]
                    'Fnm',  ... % Force Sensor in NASS [N]
                    'Dnm',  ... % Displacement Sensor in NASS [m]
                    'Dgm',  ... % Asbolute displacement of Granite [m]
                    'Vlm'}; ... % Absolute Velocity of NASS [m/s]

save('./uniaxial/mat/plants.mat', 'G_dvf', '-append');

5.3 Sensitivity to Disturbance

uniaxial_sensitivity_dist_dvf.png

Figure 23: Sensitivity to disturbance once the DVF controller is applied to the system (png, pdf)

uniaxial_sensitivity_dist_stages_dvf.png

Figure 24: Sensitivity to force disturbances in various stages when DVF is applied (png, pdf)

5.4 Damped Plant

uniaxial_plant_dvf_damped.png

Figure 25: Damped Plant after DVF is applied (png, pdf)

5.5 Conclusion

Direct Velocity Feedback:

6 With Cedrat Piezo-electric Actuators

6.1 Identification

We identify the dynamics of the system. 

%% Options for Linearized
options = linearizeOptions;
options.SampleTime = 0;

%% Name of the Simulink File
mdl = 'sim_nano_station_uniaxial_cedrat';

The inputs and outputs are defined below and corresponds to the name of simulink blocks. 

%% Input/Output definition
io(1)  = linio([mdl, '/Dw'],   1, 'input'); % Ground Motion
io(2)  = linio([mdl, '/Fs'],   1, 'input'); % Force applied on the sample
io(3)  = linio([mdl, '/Fnl'],  1, 'input'); % Force applied by the NASS
io(4)  = linio([mdl, '/Fdty'], 1, 'input'); % Parasitic force Ty
io(5)  = linio([mdl, '/Fdrz'], 1, 'input'); % Parasitic force Rz

io(6)  = linio([mdl, '/Dsm'],  1, 'output'); % Displacement of the sample
io(7)  = linio([mdl, '/Fnlm'], 1, 'output'); % Force sensor in NASS's legs
io(8)  = linio([mdl, '/Dnlm'], 1, 'output'); % Displacement of NASS's legs
io(9)  = linio([mdl, '/Dgm'],  1, 'output'); % Absolute displacement of the granite
io(10) = linio([mdl, '/Vlm'],  1, 'output'); % Measured absolute velocity of the top NASS platform

Finally, we use the linearize Matlab function to extract a state space model from the simscape model. 

%% Run the linearization
G = linearize(mdl, io, options);
G.InputName  = {'Dw',   ... % Ground Motion [m]
                'Fs',   ... % Force Applied on Sample [N]
                'Fn',   ... % Force applied by NASS [N]
                'Fty',  ... % Parasitic Force Ty [N]
                'Frz'};     % Parasitic Force Rz [N]
G.OutputName = {'D',    ... % Measured sample displacement x.r.t. granite [m]
                'Fnm',  ... % Force Sensor in NASS [N]
                'Dnm',  ... % Displacement Sensor in NASS [m]
                'Dgm',  ... % Asbolute displacement of Granite [m]
                'Vlm'}; ... % Absolute Velocity of NASS [m/s]

6.2 Control Design

Let's look at the transfer function from actuator forces in the nano-hexapod to the force sensor in the nano-hexapod legs for all 6 pairs of actuator/sensor.

uniaxial_cedrat_plant.png

Figure 26: Transfer function from forces applied in the legs to force sensor (png, pdf)

The controller for each pair of actuator/sensor is: 

K_cedrat = 1000/s;

uniaxial_cedrat_open_loop.png

Figure 27: Loop Gain for the Integral Force Feedback (png, pdf)

6.3 Identification

Let's initialize the system prior to identification. 

initializeGround();
initializeGranite();
initializeTy();
initializeRy();
initializeRz();
initializeMicroHexapod();
initializeAxisc();
initializeMirror();
initializeNanoHexapod(struct('actuator', 'piezo'));
initializeSample(struct('mass', 50));

All the controllers are set to 0. 

K = tf(0);
save('./mat/controllers.mat', 'K', '-append');
K_iff = -K_cedrat;
save('./mat/controllers.mat', 'K_iff', '-append');
K_rmc = tf(0);
save('./mat/controllers.mat', 'K_rmc', '-append');
K_dvf = tf(0);
save('./mat/controllers.mat', 'K_dvf', '-append');

%% Options for Linearized
options = linearizeOptions;
options.SampleTime = 0;

%% Name of the Simulink File
mdl = 'sim_nano_station_uniaxial_cedrat';

%% Input/Output definition
io(1)  = linio([mdl, '/Dw'],    1, 'input');  % Ground Motion
io(2)  = linio([mdl, '/Fs'],    1, 'input');  % Force applied on the sample
io(3)  = linio([mdl, '/Fnl'],   1, 'input');  % Force applied by the NASS
io(4)  = linio([mdl, '/Fdty'],  1, 'input');  % Parasitic force Ty
io(5)  = linio([mdl, '/Fdrz'],  1, 'input');  % Parasitic force Rz

io(6)  = linio([mdl, '/Dsm'],  1, 'output'); % Displacement of the sample
io(7)  = linio([mdl, '/Fnlm'], 1, 'output'); % Force sensor in NASS's legs
io(8)  = linio([mdl, '/Dnlm'], 1, 'output'); % Displacement of NASS's legs
io(9)  = linio([mdl, '/Dgm'],  1, 'output'); % Absolute displacement of the granite
io(10) = linio([mdl, '/Vlm'],  1, 'output'); % Measured absolute velocity of the top NASS platform

%% Run the linearization
G_cedrat = linearize(mdl, io, options);
G_cedrat.InputName  = {'Dw',   ... % Ground Motion [m]
                    'Fs',   ... % Force Applied on Sample [N]
                    'Fn',   ... % Force applied by NASS [N]
                    'Fty',  ... % Parasitic Force Ty [N]
                    'Frz'};     % Parasitic Force Rz [N]
G_cedrat.OutputName = {'D',    ... % Measured sample displacement x.r.t. granite [m]
                    'Fnm',  ... % Force Sensor in NASS [N]
                    'Dnm',  ... % Displacement Sensor in NASS [m]
                    'Dgm',  ... % Asbolute displacement of Granite [m]
                    'Vlm'}; ... % Absolute Velocity of NASS [m/s]

save('./uniaxial/mat/plants.mat', 'G_cedrat', '-append');

6.4 Sensitivity to Disturbance

uniaxial_sensitivity_dist_cedrat.png

Figure 28: Sensitivity to disturbance once the CEDRAT controller is applied to the system (png, pdf)

uniaxial_sensitivity_dist_stages_cedrat.png

Figure 29: Sensitivity to force disturbances in various stages when CEDRAT is applied (png, pdf)

6.5 Damped Plant

uniaxial_plant_cedrat_damped.png

Figure 30: Damped Plant after CEDRAT is applied (png, pdf)

6.6 Conclusion

This gives similar results than with a classical force sensor.

7 Comparison of Active Damping Techniques

7.1 Load the plants

load('./uniaxial/mat/plants.mat', 'G', 'G_iff', 'G_rmc', 'G_dvf');

7.2 Sensitivity to Disturbance

uniaxial_sensitivity_ground_motion.png

Figure 31: Sensitivity to Ground Motion - Comparison (png, pdf)

uniaxial_sensitivity_direct_force.png

Figure 32: Sensitivity to disturbance - Comparison (png, pdf)

uniaxial_sensitivity_fty.png

Figure 33: Sensitivity to force disturbances - Comparison (png, pdf)

uniaxial_sensitivity_frz.png

Figure 34: Sensitivity to force disturbances - Comparison (png, pdf)

7.3 Noise Budget

We first load the measured PSD of the disturbance. 

load('./disturbances/mat/dist_psd.mat', 'dist_f');

The effect of these disturbances on the distance \(D\) is computed for all active damping techniques. We then compute the Cumulative Amplitude Spectrum (figure 35).

uniaxial-comp-cas-dist.png

Figure 35: Comparison of the Cumulative Amplitude Spectrum of \(D\) for different active damping techniques (png, pdf)

The obtained Root Mean Square Value for each active damping technique is shown below.

Table 1: Obtain Root Mean Square value of \(D\) for each Active Damping Technique applied
  D [m rms]
OL 3.38e-06
IFF 3.40e-06
RMC 3.37e-06
DVF 3.38e-06

It is important to note that the effect of direct forces applied to the sample are not taken into account here.

7.4 Damped Plant

uniaxial_plant_damped_comp.png

Figure 36: Damped Plant - Comparison (png, pdf)

7.5 Conclusion

Table 2: Comparison of proposed active damping techniques
  IFF RMC DVF
Sensor Type Force sensor Relative Motion Inertial
Guaranteed Stability + + -
Sensitivity (\(D_w\)) - + -
Sensitivity (\(F_s\)) - (at low freq) + +
Sensitivity (\(F_{ty,rz}\)) + - +
Overall RMS of \(D\) = = =

Author: Dehaeze Thomas

Created: 2019-11-04 lun. 17:33

Validate