7.7. Multiple Stripe Analysis Postprocessing

postprocessor.process_msa_results(imls, edps, damage_thresholds, sigma_build2build=0.3, sigma_ds=0.3, intensities=np.round(np.geomspace(0.05, 10.0, 50), 3))[source]

Perform maximum likelihood estimation (MLE) for fragility curve fitting following a multiple stripe analysis. This method calculates the fragility function by fitting to the provided intensity measure levels (IMLs) and engineering demand parameters (EDPs) “stripes”.

The method is useful for deriving fragility functions by determining the probability of exceedance for various damage states based on the provided data.

Parameters:

  • imls (list or array) – A list or array of intensity measure levels (IMLs) representing the seismic intensity levels used for sampling the fragility functions.

  • edps (list or array) – A list or array of engineering demand parameters (EDPs), which describe the structural response to seismic events. Examples include maximum interstorey drifts, maximum peak floor acceleration, or top displacements.

  • damage_thresholds (list) – A list of EDP-based damage thresholds that correspond to different levels of structural damage, such as slight, moderate, extensive, and complete. These thresholds help categorize the severity of damage based on EDP values.

  • sigma_build2build (float, optional, default=0.3) – The building-to-building variability or modeling uncertainty. It accounts for differences in performance between buildings with similar characteristics due to random variations or model uncertainties.

  • sigma_ds (float, optional) – The logarithmic standard deviation representing uncertainty in damage-state thresholds. Default value is 0.30.

  • intensities (array, optional, default=np.geomspace(0.05, 10.0, 50)) – An array of intensity measure levels over which the fragility function will be sampled. By default, this is a logarithmic space ranging from 0.05 to 10.0, with 50 sample points.

Returns:

msa_dict – A nested dictionary with the following top-level keys:

’msa_inputs’dict

Inputs passed to the analysis.

  • 'imls' : array — intensity measure levels used for each stripe.

  • 'edps' : array — engineering demand parameters recorded at each stripe.

  • 'damage_thresholds' : list — EDP values defining each damage state boundary.

  • 'sigma_build2build' : float — building-to- building modelling uncertainty.

  • 'sigma_ds' : float — uncertainty in the damage-state threshold definition.

’fragility’dict

MLE-fitted fragility function results.

  • 'fragility_method' : str — always ‘mle’.

  • 'intensities' : array — IM levels at which PoEs are evaluated.

  • 'poes' : ndarray, shape (n_IM, n_DS) — probabilities of exceedance per damage state.

  • 'medians' : list, length n_DS — median IM (theta) for each damage state.

  • 'sigma_record2record' : list, length n_DS — record-to-record dispersion per damage state.

  • 'betas_total' : list, length n_DS — total logarithmic standard deviation per damage state, combining record-to-record, building-to-building, and damage-state threshold uncertainties.

’metadata’dict

Stripe-level summary information.

  • 'stripe_levels' : array — mean IM value for each stripe.

  • 'observed_fractions' : list of lists, shape (n_DS, n_stripes) — observed fraction of ground-motion records exceeding each damage threshold at each stripe level.

Return type:

dict

Notes

This method fits the fragility curve using MLE, which minimizes the difference between observed and predicted exceedance probabilities.

Theoretical Background

Multiple Stripe Analysis (MSA) conditions structural response on discrete intensity levels (stripes), fitting fragility functions directly from binomial observations at each stripe (Baker, 2015).

Observed data per stripe

At each intensity level \(\text{IM}_j\), \(n_j\) ground-motion records are run and \(z_j\) records result in exceedance of the damage-state threshold. The empirical exceedance rate at stripe \(j\) is \(\hat{p}_j = z_j / n_j\).

Maximum likelihood estimation

Assuming a lognormal fragility model \(F(\text{IM};\,\theta,\beta) = \Phi\!\bigl(\ln(\text{IM}/\theta)/\beta\bigr)\), the parameters \((\theta, \beta)\) are estimated by maximising the binomial log-likelihood across all stripes:

\[\mathcal{L}(\theta, \beta) = \sum_{j=1}^{m} \left[ z_j \ln F(\text{IM}_j;\,\theta,\beta) + (n_j - z_j) \ln\bigl(1 - F(\text{IM}_j;\,\theta,\beta)\bigr) \right]\]

where \(m\) is the total number of stripes, \(\theta\) is the median IM capacity, and \(\beta\) is the logarithmic standard deviation.

Total dispersion

The fitted \(\beta_{\text{r2r}}\) represents record-to-record variability. Additional modelling uncertainties are combined in quadrature:

\[\beta_{\text{total}} = \sqrt{\beta_{\text{r2r}}^2 + \beta_{\text{b2b}}^2 + \beta_{\text{DS}}^2}\]

Example

from openquake.vmtk.postprocessor import postprocessor

pp = postprocessor()
# stripe_imls, stripe_edps: 2-D arrays (n_records × n_stripes) from MSA
msa_dict = pp.process_msa_results(
    stripe_imls=stripe_imls,
    stripe_edps=stripe_edps,
    damage_thresholds=[0.005, 0.015, 0.040],
)
print(msa_dict['fragility']['medians'])