pyOMA.core.SSIData.SSIDataMC#

class pyOMA.core.SSIData.SSIDataMC(*args, **kwargs)[source]#

Bases: ModalBase

__init__(*args, **kwargs)[source]#

channel definition: channels start at 0

Methods

__init__(*args, **kwargs)

channel definition: channels start at 0

build_block_hankel([num_block_rows, ...])

Builds a Block-Hankel Matrix of the measured time series with varying time lags and estimates the subspace matrix from its LQ decomposition.

compute_modal_params([max_model_order, j, ...])

Perform a multi-order computation of modal parameters.

estimate_state(order)

Estimate the state matrices A, C and noise covariances Q, R and S from the subspace / projection matrix.

init_from_config(conf_file, prep_signals)

A method for initializing a modal object from configuration data bypassing common operations in explicit code for semi-automated analyses

integrate_quantities(vector, accel_channels, ...)

Rescales mode shapes from modal accelerations / velocities to modal displacements, by multiplication of the relevant modal coordinates (where accelerometers, or velocimeters were used, with $-1 omega^2$ or $i omega$, respectively,

load_state(fname, prep_signals)

Loads the state of the object from a compressed numpy archive file and returns the object This is only a stub for reimplementing the method in a derived class

modal_analysis(A, C[, rescale_fun])

Computes the modal parameters from a given state space model as described by Peeters 1999 and Döhler 2012.

remove_conjugates(eigval[, eigvec_r, ...])

This method finds complex conjugate modes, and removes unstable and overdamped poles.

rescale_mode_shape(modeshape[, rotate_only])

Rescales and rotates modeshapes in the complex plane.

save_state(fname)

Saves the state of the object to a compressed numpy archive file This is only a stub for reimplementing the method in a derived class

synthesize_signals(A, C, Q, R, S[, j])

Computes the modal response signals and the contribution of each mode.
build_block_hankel(num_block_rows=None, reduced_projection=True)[source]#

Builds a Block-Hankel Matrix of the measured time series with varying time lags and estimates the subspace matrix from its LQ decomposition.

  <- num_time samples - num_block_rows->      _
[     y_0      y_1      ...      y_(j-1)     ]^
[     y_1      y_2      ...      y_j         ]num_block_rows (=i)*n_l
[     ...      ...      ...      ...         ]v
[     y_(2i-1)   y_(2i)  ...     y_(2i+j-2)  ]_

The notation mostly follows Peeters 1999.

Parameters:

num_block_rows (integer, required) – The number of block rows of the Subspace matrix

compute_modal_params(max_model_order=None, j=None, validation_blocks=None, synth_sig=True)[source]#

Perform a multi-order computation of modal parameters. Successively calls

  • estimate_state(order,)

  • modal_analysis(A,C)

  • synthesize_signals(A, C, Q, R, S, j)

at ascending model orders, up to max_model_order. See the explanations in the the respective methods, for a detailed explanation of parameters.

Parameters:

max_model_order (integer, optional) – Maximum model order, where to interrupt the algorithm. If not given, it is determined from the previously computed subspace matrix.

estimate_state(order)[source]#

Estimate the state matrices A, C and noise covariances Q, R and S from the subspace / projection matrix. Several methods exist, e.g.

  • Peeters 1999 Reference Based Stochastic Subspace Identification for OMA

  • DeCock 2007 Subspace Identification Methods

  • the algorithm used in BRSSICovRef.

Here, the first algorithm, a residual-based computation of Q, R and S, is implemented.

Parameters:

order (integer, required) – The model order, at which to truncate the singular values of the projection Matrix P_i_ref

Returns:

  • A (numpy.ndarray) – State matrix: Array of shape (order, order)

  • C (numpy.ndarray) – Output matrix: Array of shape (num_analised_channels, order)

  • Q (numpy.ndarray) – state noise covariance matrix: Symmetric array of shape (order, order)

  • R (numpy.ndarray) – signal noise covariance matrix: Array of shape (num_analised_channels, num_analised_channels)

  • S (numpy.ndarray) – system noise - signal noise covariance matrix: Array of shape (order, num_analised_channels)

classmethod init_from_config(conf_file, prep_signals)[source]#

A method for initializing a modal object from configuration data bypassing common operations in explicit code for semi-automated analyses

This is a stub of the method that must be reimplemented by every derived class

classmethod load_state(fname, prep_signals)[source]#

Loads the state of the object from a compressed numpy archive file and returns the object This is only a stub for reimplementing the method in a derived class

modal_analysis(A, C, rescale_fun=None)[source]#

Computes the modal parameters from a given state space model as described by Peeters 1999 and Döhler 2012. Mode shapes are scaled to unit modal displacements. Complex conjugate and real modes are removed prior to further processing. Typically, order // 2 modes are in the returned arrays.

Parameters:

  • A (numpy.ndarray) – State matrix: Array of shape (order, order)

  • C (numpy.ndarray) – Output matrix: Array of shape (num_analised_channels, order)

Returns:

  • modal_frequencies (numpy.ndarray, shape (order,)) – Array holding the modal frequencies for each mode

  • modal_damping (numpy.ndarray, shape (order,)) – Array holding the modal damping ratios (0,100) for each mode

  • mode_shapes (numpy.ndarray, shape (n_l, order,)) – Complex array holding the mode shapes

  • eigenvalues (numpy.ndarray, shape (order,)) – Complex array holding the eigenvalues for each mode

save_state(fname)[source]#

Saves the state of the object to a compressed numpy archive file This is only a stub for reimplementing the method in a derived class

synthesize_signals(A, C, Q, R, S, j=None, **kwargs)[source]#

Computes the modal response signals and the contribution of each mode. The algorithm follows Peeters 1999 and the Lyapunov equation is solved as a discrete-time algebraic Riccati equation (DARE). For long signals, the computation may become time-consuming, thus only time steps up to j may be used to synthesize the signal.

Parameters:

  • A (numpy.ndarray) – State matrix: Array of shape (order, order)

  • C (numpy.ndarray) – Output matrix: Array of shape (num_analised_channels, order)

  • Q (numpy.ndarray) – state noise covariance matrix: Symmetric array of shape (order, order)

  • R (numpy.ndarray) – signal noise covariance matrix: Array of shape (num_analised_channels, num_analised_channels)

  • S (numpy.ndarray) – system noise - signal noise covariance matrix: Array of shape (order, num_analised_channels)

  • j (integer, optional) – length of signal to synthesize (number of timesteps)

Returns:

  • sig_synth (numpy.ndarray, shape (num_analised_channels, j, order // 2)) – Array holding the modally decomposed input signals for each channel n_l and all modes

  • modal_contributions (numpy.ndarray, shape (order, )) – Array holding the contributions of each mode to the input signals.