The tutorial
A case of typical usage is presented here.
To use real code, take a look at the showcase notebook.
Import EMA
module:
from sdypy import EMA
Instance of the Model
class
a = EMA.Model(
frf_matrix,
frequency_array,
lower=10,
upper=10000,
pol_order_high=60,
driving_point=3,
frf_type='accelerance'
)
frf_matrix
and frequency vector
arguments
The main inputs in the Model
class are the Frequency Response Function (frf_matrix
) with shape (n_locations, n_frequencies)
and
the frequency vector (frequency_vector
) with shape (n_frequencies,)
.
lower
and upper
arguments
To set the frequency limits on the frf_matrix
, the lower
and upper
arguments are used. The poles will be combuted based on the
frf_matric
within these limits, however, the reconstruction will be compted between the limits (0, upper)
.
pol_order_high
argument
This argument determines the highest polynomial order used to approximate the frf_matrix
.
driving_point
argument
If given, the driving_point
is the index of the frf_matrix
of the driving location. This location is used to scale the modal constants to
the modal shapes.
where j
is the driving point index.
frf_type
argument
This argument gives information about what type of FRF you are using. If the accelerations are measured and then the FRF is computed using the excitation data,
the frf_type
is acceleration
. If the speed is measured, the frf_type
is mobility
and if the displacement is measured, the frf_type
is receptance
.
It is possible to transition between accelerance, mobility and receptance:
omega = 2 * np.pi * frequency_array
mobility = receptance * (1j*omega)
accelerance = receptance * (-omega**2)
For further description of the arguments, see code documentation.
Import FRFs
from UFF
It is possible to import the FRFs from a UFF
file.
The UFF
file must contain the FRFs and the frequency vector.
If the frf_matrix
and frequency_vector
are not given, the read_uff()
method can be called:
a = EMA.Model(
lower=10,
upper=10000,
pol_order_high=60,
driving_point=3,
frf_type='accelerance'
)
a.read_uff('file.uff')
The FRFs
and frequency_vector
are automatically imported into the instance of the Model
class.
Compute the poles
This step must always be carried out. The increasing polynomial order (up to pol_order_high
) is used to approximate the FRFs.
a.get_poles()
Select stable poles
After the poles are computed, the stable ones must be selected. To select stable poles, two ways are possible.
Option 1: Display the stability chart
a.select_poles()
Option 2: Use automatic selection
If the approximate values of natural frequencies are already known, it is not necessary to display the stability chart:
approx_nat_freq = [314, 864]
a.select_closest_poles(approx_nat_freq)
Reconstruction
To identify the modal constants, the get_constants()
method must be called. The method currently supports two methods,
lsfd
and lsfd_proportional
. Both methods are based on the Least-Squares Frequency Domain method, however, the lsfd_proportional
assumes the proportional damping and thus return real-values modal constants.
H, A = a.get_constants(method='lsfd')
The method returns the reconstructed FRFs, H
, and the modal constants, A
. The lower and upper residuals can also bi accessed through LR
and UR
attributes, respectively.
lower_residual = a.LR
upper_residual = a.UR
If the driving_point
argument was passed to the Model
class, the modal shapes are available through phi
attribute:
modal_shapes = a.phi
Reconstruction on c
usign poles from a
sdypy-EMA
enables the use of the poles identified using one set of measurments, to identify the modal constants using a different set of measurments.
Create a new object using different set of FRFs:
c = EMA.Model(
frf_matrix,
frequency_array,
lower=10,
upper=10000,
pol_order_high=60
)
Compute reconstruction based on poles determined on object a
:
H, A = c.get_constants(whose_poles=a)