pyOMA.core.SSICovRef.PogerSSICovRef#

class pyOMA.core.SSICovRef.PogerSSICovRef[source]#

Bases: BRSSICovRef

“In the PoGER approach, first a nonparametric system model is identified for each setup separately. In the time domain, this nonparametric model consists of the correlations between all measured outputs. In a second step, the output correlations obtained from the different setups are stacked on top of each other. Extracting the modal parameters from the resulting correlation function yields global values for the eigenfrequencies and damping ratios. The identified partial mode shapes are stacked on top of each other in a global mode shape. However, due to the non-stationary ambient excitation level and the non-stationary ambient excitation color, it is necessary to re-scale the partial mode shapes in a least-squares sense, for instance to the reference DOFs of the first partial mode shape, just as in the PoSER approach”

from: Döhler, M.; Reynders, E.; Magalhaes, F.; Mevel, L.; Roeck, G. D. & Cunha, A. Pre-and post-identification merging for multi-setup OMA with covariance-driven SSI 28th International Modal Analysis Conference, 2010 , 57-70

Analysis steps:

  • Create your geometry definitions

  • Create configuration files and channel-dof-assignments for each setup

  • Pre-process each setup using PreProcessData

  • Pre-compute correlations functions using PreProcessData.compute_correlation_functions (note: m_lags >= num_block_columns + num_block_rows >= 2 * num_block_columns + 1)

  • add the PreProcessData objects of each setup using add_setup

  • call pair_channels(), build_merged_subspace_matrix(), estimate_state(), compute_modal_params()

Notes on the reference channels: There are two different uses of reference channels:

  1. Reference channels for reducing the computational effort / improving results if noisy channels are present

  2. Reference channels for mode shape rescaling when multiple setups should be merged

In PoGER merging the first group of reference channels are required for joint identification. In this case, reference-based correlation functions are “stacked on top of each other” and then assembled into a joint Hankel matrix. Here, only the reference channels, that are present in all setups can be used.

Based on each setups’ channel-dof-assignments and selected reference channels, the PogerSSICovRef class automatically determines the reference channels for:

  • joint identification and

  • mode shape rescaling / merging.

Thus, by changing the reference channel definition in each setup, the used reference channels in joint identification can be influenced. The reference channels for modeshape rescaling are automatically generated, regardless of the the definition in the setup. Rescaling is always done with respect to the first setup, so a “good” setup should always be added first.

Todo

  • Add modal contributions

  • Implement PreGER merging with variance computation in a new class

__init__()[source]#

Initializes class and all class variables channel definition: channels start at 0

Methods

__init__()

Initializes class and all class variables channel definition: channels start at 0

add_setup(prep_signals)

todo: check that ref_channels are equal in each setup (by number and by DOF)

build_merged_subspace_matrix(num_block_columns)

Builds a Block-Hankel Matrix of Covariances with varying time lags

build_toeplitz_cov([num_block_columns, ...])

Builds a Block-Toeplitz Matrix of Covariances with varying time lags and decomposes it by a Singular Value decomposition.

compute_modal_params([max_model_order, ...])

Perform a multi-order computation of modal parameters.

estimate_state(order[, max_modes, algo])

Compute the state matrix A, output matrix C and next-state-output covariance matrix G from the singular values and vectors of the block Toeplitz matrix, truncated at the requested order.

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)

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)

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

pair_channels()

pairs channels from all given setups for the poger merging methods

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

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

rescale_by_references(mode_shape)

This is PoGer Rescaling

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_correlation(A, C, G)

Correlation function synthetization in a modal decoupled form follows Reynders-2012-SystemIdentificationMethodsFor(Operational)ModalAnalysisReviewAndComparison Eq.

synthesize_spectrum(A, C, G)

L = N*dt (duration = number_of_samples*sampling_period) P = N*df (maximal frequency = number of samples * frequency inverval)

Attributes

accel_channels

velo_channels

add_setup(prep_signals)[source]#

todo: check that ref_channels are equal in each setup (by number and by DOF)

build_merged_subspace_matrix(num_block_columns, num_block_rows=None)[source]#

Builds a Block-Hankel Matrix of Covariances with varying time lags

  <- num_block_columns*num_ref_channels-> _
[     R_1      R_2      ...      R_i     ]^
[     R_2      R_3      ...      R_2     ]num_block_rows*(num_num_ref_channels*num_setups)
[     ...      ...      ...      ...     ]v
[     R_i      ...      ...      R_2i-1  ]_

R_1 =   [ R_1^1          ]
        [ R_1^2          ]
        [ ...            ]
        [ R_1^num_setups ]
compute_modal_params(max_model_order=None, max_modes=None, algo='svd')[source]#

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

  • estimate_state(order, max_modes, algo)

  • modal_analysis(A,C)

  • synthesize_correlation(A,C, G), if modal_contrib == True

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 min(num_channels * (num_block_rows + 1), num_reference_channels * num_block_columns)

classmethod load_state(fname)[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)[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 ((order,) numpy.ndarray) – Array holding the modal frequencies for each mode

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

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

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

pair_channels()[source]#

pairs channels from all given setups for the poger merging methods

ssi_reference channels are common to all setups rescale reference channels are common to at least two setups

finds common dofs from all setups and their respective channels generates new channel_dof_assignments with ascending channel numbers rescale reference channels are assumed to be equal to ssi_reference channels

rescale_by_references(mode_shape)[source]#

This is PoGer Rescaling

  • extracts each setup’s reference and roving parts of the modeshape

  • compute rescaling factor from all setup’s reference channels using a least-squares approach

  • rescales each setup’s roving channels and assembles final modeshape vector

reference channel_pairs and final channel-dof-assignments have been determined by function pair_channels note: reference channels for SSI need not necessarily be reference channels for rescaling and vice versa

\(S_\phi \times \alpha = [n \times 1, 0 .. 0]\)

\(\phi^{ref}_i\) : Reference-sensor part of modeshape estimated from setup \(i = 0 .. n\) \(j_{max} = \operatorname{argmax}(\Pi_i |\phi^{ref}_i|)\) : maximal modal component in all setups → will be approximately scaled to 1, must belong to the same sensor in each setup

\[\begin{split}S_\phi = \begin{bmatrix} \phi^{ref}_{0,j_{max}}& \phi^{ref}_{1,j_{max}}& ..& ..& \phi^{ref}_{n,j_{max}} \\ \phi^{ref}_0& -\phi^{ref}_1& 0& ..& 0 \\ \phi^{ref}_0& 0& -\phi^{ref}_2& ..& 0 \\ . &. &. & . & . \\ . &. &. & . & . \\ \phi^{ref}_0& 0& 0& ..& -\phi^{ref}_n \\ 0& \phi^{ref}_1& -\phi^{ref}_2& ..& 0 \\ . &. & . & . & . \\ . &. & . & . & . \\ 0& \phi^{ref}_1& 0& ..& -\phi^{ref}_n \\ . &. & . & . & . \\ . &. & . & . & . \\ 0& 0& \phi^{ref}_2& ..& -\phi^{ref}_n \\ . &. & . & . & . \\ . &. & . & . & . \\ 0& 0& 0& \phi^{ref}_{n-1}& -\phi^{ref}_n \end{bmatrix}\end{split}\]

if references are the same in all setups

dimensions \(= 1 + (n_{setups} ! )* n_{ref_{channels}} \times n_{setups}\)

not quite exact, since different setups may share different references

→ list based assembly of the \(S_\phi\) matrix

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