Reliability

Reliability of a system refers to the assessment of its probability of failure (i.e the system no longer satisfies some performance measures), given the model uncertainty in the structural, environmental and load parameters. Given a vector of random variables \(\textbf{X}=\{X_1, X_2, \ldots, X_n\} \in \mathcal{D}_\textbf{X}\subset \mathbb{R}^n\), where \(\mathcal{D}\) is the domain of interest and \(f_{\textbf{X}}(\textbf{x})\) is its joint probability density function then, the probability that the system will fail is defined as

\[P_f =\mathbb{P}(g(\textbf{X}) \leq 0) = \int_{D_f} f_{\textbf{X}}(\textbf{x})d\textbf{x} = \int_{\{\textbf{X}:g(\textbf{X})\leq 0 \}} f_{\textbf{X}}(\textbf{x})d\textbf{x}\]

where \(g(\textbf{X})\) is the so-called performance function. The reliability problem is often formulated in the standard normal space \(\textbf{U}\sim \mathcal{N}(\textbf{0}, \textbf{I}_n)\), which means that a nonlinear isoprobabilistic transformation from the generally non-normal parameter space \(\textbf{X}\sim f_{\textbf{X}}(\cdot)\) to the standard normal is required (see the Tansformations module). The performance function in the standard normal space is denoted \(G(\textbf{U})\). UQpy does not require this transformation and can support reliability analysis for problems with arbitrarily distributed parameters.

This module contains functionality for all reliability methods supported in UQpy. The module currently contains the following classes:

  • TaylorSeries: Class to perform reliability analysis using First Order Reliability Method (FORM) and Second Order Reliability Method (SORM).

  • SubsetSimulation: Class to perform reliability analysis using subset simulation.

Subset Simulation

In the subset simulation method 3 the probability of failure \(P_f\) is approximated by a product of probabilities of more frequent events. That is, the failure event \(G = \{\textbf{x} \in \mathbb{R}^n:G(\textbf{x}) \leq 0\}\), is expressed as the of union of M nested intermediate events \(G_1,G_2,\cdots,G_M\) such that \(G_1 \supset G_2 \supset \cdots \supset G_M\), and \(G = \cap_{i=1}^{M} G_i\). The intermediate failure events are defined as \(G_i=\{G(\textbf{x})\le b_i\}\), where \(b_1>b_2>\cdots>b_i=0\) are positive thresholds selected such that each conditional probability \(P(G_i | G_{i-1}), ~i=2,3,\cdots,M-1\) equals a target probability value \(p_0\). The probability of failure \(P_f\) is estimated as:

\[P_f = P\left(\cap_{i=1}^M G_i\right) = P(G_1)\prod_{i=2}^M P(G_i | G_{i-1})\]

where the probability \(P(G_1)\) is computed through Monte Carlo simulations. In order to estimate the conditional probabilities \(P(G_i|G_{i-1}),~j=2,3,\cdots,M\) generation of Markov Chain Monte Carlo (MCMC) samples from the conditional pdf \(p_{\textbf{U}}(\textbf{u}|G_{i-1})\) is required. In the context of subset simulation, the Markov chains are constructed through a two-step acceptance/rejection criterion. Starting from a Markov chain state \(\textbf{x}\) and a proposal distribution \(q(\cdot|\textbf{x})\), a candidate sample \(\textbf{w}\) is generated. In the first stage, the sample \(\textbf{w}\) is accepted/rejected with probability

\[\alpha=\min\bigg\{1, \frac{p(\textbf{w})q(\textbf{x}|\textbf{w})}{p(\textbf{x})q(\textbf{w}|\textbf{x})}\bigg\}\]

and in the second stage is accepted/rejected based on whether the sample belongs to the failure region \(G_j\). SubSetSimulation can be used with any of the available (or custom) MCMC classes in the SampleMethods module.

SubsetSimulation Class Descriptions

class UQpy.Reliability.SubsetSimulation(runmodel_object, mcmc_class=<class 'UQpy.SampleMethods.MMH'>, samples_init=None, p_cond=0.1, nsamples_per_ss=1000, max_level=10, verbose=False, **mcmc_kwargs)[source]

Perform Subset Simulation to estimate probability of failure.

This class estimates probability of failure for a user-defined model using Subset Simulation. The class can use one of several MCMC algorithms to draw conditional samples.

Input:

  • runmodel_object (RunModel object):

    The computational model. It should be of type RunModel (see RunModel class).

  • mcmc_class (Class of type SampleMethods.MCMC)

    Specifies the MCMC algorithm.

    Must be a child class of the SampleMethods.MCMC parent class. Note: This is not and object of the class. This input specifies the class itself.

  • samples_init (ndarray)

    A set of samples from the specified probability distribution. These are the samples from the original distribution. They are not conditional samples. The samples must be an array of size nsamples_per_ss x dimension.

    If samples_init is not specified, the Subset_Simulation class will use the mcmc_class to draw the initial samples.

  • p_cond (float):

    Conditional probability for each conditional level.

  • nsamples_per_ss (int)

    Number of samples to draw in each conditional level.

  • max_level (int)

    Maximum number of allowable conditional levels.

  • verbose (Boolean):

    A boolean declaring whether to write text to the terminal.

  • mcmc_kwargs (dict)

    Any additional keyword arguments needed for the specific MCMC class.

Attributes:

  • samples (list of ndarrays)

    A list of arrays containing the samples in each conditional level.

  • g (list of ndarrays)

    A list of arrays containing the evaluation of the performance function at each sample in each conditional level.

  • g_level (list)

    Threshold value of the performance function for each conditional level

  • pf (float)

    Probability of failure estimate

  • cov1 (float)

    Coefficient of variation of the probability of failure estimate assuming independent chains

  • cov2 (float)

    Coefficient of variation of the probability of failure estimate with dependent chains. From 4

Methods:

run()[source]

Execute subset simulation

This is an instance method that runs subset simulation. It is automatically called when the SubsetSimulation class is instantiated.

Output/Returns:

  • pf (float)

    Probability of failure estimate

  • cov1 (float)

    Coefficient of variation of the probability of failure estimate assuming independent chains

  • cov2 (float)

    Coefficient of variation of the probability of failure estimate with dependent chains. From 4

Taylor Series

TaylorSeries is a class that calculates the reliability of a model using the First Order Reliability Method (FORM) or the Second Order Reliability Method (SORM) based on the first-order and second-order Taylor series expansion approximation of the performance function, respectively (1, 2).

In FORM, the performance function is linearized according to

\[G(\textbf{U}) \approx G(\textbf{U}^\star) + \nabla G(\textbf{U}^\star)(\textbf{U}-\textbf{U}^\star)^\intercal\]

where \(\textbf{U}^\star\) is the expansion point, \(G(\textbf{U})\) is the performance function evaluated in the standard normal space and \(\nabla G(\textbf{U}^\star)\) is the gradient of \(G(\textbf{U})\) evaluated at \(\textbf{U}^\star\). The probability failure can be calculated by

\[P_{f, \text{form}} = \Phi(-\beta_{HL})\]

where \(\Phi(\cdot)\) is the standard normal cumulative distribution function and \(\beta_{HL}=||\textbf{U}^*||\) is the norm of the design point known as the Hasofer-Lind reliability index calculated with the iterative Hasofer-Lind-Rackwitz-Fiessler (HLRF) algorithm. The convergence criteria used for HLRF algorithm are:

\[e1: ||\textbf{U}^{k} - \textbf{U}^{k-1}||_2 \leq 10^{-3}\]
\[e2: ||\beta_{HL}^{k} - \beta_{HL}^{k-1}||_2 \leq 10^{-3}\]
\[e3: ||\nabla G(\textbf{U}^{k})- \nabla G(\textbf{U}^{k-1})||_2 \leq 10^{-3}\]
Graphical representation of the FORM.

In SORM the performance function is approximated by a second-order Taylor series around the design point according to

\[G(\textbf{U}) = G(\textbf{U}^\star) + \nabla G(\textbf{U}^\star)(\textbf{U}-\textbf{U}^\star)^\intercal + \frac{1}{2}(\textbf{U}-\textbf{U}^\star)\textbf{H}(\textbf{U}-\textbf{U}^\star)\]

where \(\textbf{H}\) is the Hessian matrix of the second derivatives of \(G(\textbf{U})\) evaluated at \(\textbf{U}^*\). After the design point \(\textbf{U}^*\) is identified and the probability of failure \(P_{f, \text{form}}\) is calculated with FORM a correction is made according to

\[P_{f, \text{sorm}} = \Phi(-\beta_{HL}) \prod_{i=1}^{n-1} (1+\beta_{HL}\kappa_i)^{-\frac{1}{2}}\]

where \(\kappa_i\) is the i-th curvature.

The TaylorSeries class is the parent class of the FORM and SORM classes that perform the FORM and SORM, respectively. These classes can be imported in a python script using the following command:

>>> from UQpy.Reliability import FORM, SORM

TaylorSeries Class Descriptions

class UQpy.Reliability.TaylorSeries(dist_object, runmodel_object, form_object, corr_x, corr_z, seed_x, seed_u, n_iter, tol1, tol2, tol3, df_step, verbose)[source]

Perform First and Second Order Reliability (FORM/SORM) methods.

This is the parent class to all Taylor series expansion algorithms.

Input:

  • dist_object ((list of ) Distribution object(s)):

    Marginal probability distributions of each random variable. Must be an object of type DistributionContinuous1D or JointInd.

  • runmodel_object (RunModel object):

    The computational model. It should be of type RunModel (see RunModel class).

  • form_object (FORM object):

    It should be of type FORM (see FORM class). Used to calculate SORM correction.

  • corr_z or corr_x (ndarray):

    Covariance matrix

    If corr_x is provided, it is the correlation matrix (\(\mathbf{C_X}\)) of the random vector X .

    If corr_z is provided, it is the correlation matrix (\(\mathbf{C_Z}\)) of the standard normal random vector Z .

    Default: corr_z is specified as the identity matrix.

  • seed_u or seed_x (ndarray):

    The initial starting point for the Hasofer-Lind algorithm.

    Either seed_u or seed_x must be provided.

    If seed_u is provided, it should be a point in the uncorrelated standard normal space of U.

    If seed_x is provided, it should be a point in the parameter space of X.

    Default: seed_u = (0, 0, …, 0)

  • tol1 (float):

    Convergence threshold for criterion e1 of the HLRF algorithm.

    Default: 1.0e-3

  • tol2 (float):

    Convergence threshold for criterion e2 of the HLRF algorithm.

    Default: 1.0e-3

  • tol3 (float):

    Convergence threshold for criterion e3 of the HLRF algorithm.

    Default: 1.0e-3

  • n_iter (int):

    Maximum number of iterations for the HLRF algorithm.

    Default: 100

  • df_step (‘float’):

    Finite difference step in standard normal space.

    Default: 0.01 (see derivatives class)

  • verbose (Boolean):

    A boolean declaring whether to write text to the terminal.

Methods:

static derivatives(point_u, point_x, runmodel_object, nataf_object, order='first', point_qoi=None, df_step=0.01, verbose=False)[source]

A method to estimate the derivatives (1st-order, 2nd-order, mixed) of a function using a central difference scheme after transformation to the standard normal space.

This is a static method of the FORM class.

Inputs:

  • point_u (ndarray):

    Point in the uncorrelated standard normal space at which to evaluate the gradient with shape samples.shape=(1, dimension).

    Either point_u or point_x must be specified. If point_u is specified, the derivatives are computed directly.

  • point_x (ndarray):

    Point in the parameter space at which to evaluate the model with shape samples.shape=(1, dimension).

    Either point_u or point_x must be specified. If point_x is specified, the variable is transformed to standard normal using the Nataf transformation and derivatives are computed.

  • runmodel_object (RunModel object):

    The computational model. It should be of type RunModel (see RunModel class).

  • nataf_object (Nataf object):

    An object of the Nataf class (see Nataf class).

  • order (str):

    Order of the derivative. Available options: ‘first’, ‘second’, ‘mixed’.

    Default: ‘first’.

  • point_qoi (float):

    Value of the model evaluated at point_u. Used only for second derivatives.

  • df_step (float):

    Finite difference step in standard normal space.

    Default: 0.01

  • verbose (Boolean):

    A boolean declaring whether to write text to the terminal.

Output/Returns:

  • du_dj (ndarray):

    Vector of first-order derivatives (if order = ‘first’).

  • d2u_dj (ndarray):

    Vector of second-order derivatives (if order = ‘second’).

  • d2u_dij (ndarray):

    Vector of mixed derivatives (if order = ‘mixed’).

FORM

class UQpy.Reliability.FORM(dist_object, runmodel_object, form_object=None, seed_x=None, seed_u=None, df_step=None, corr_x=None, corr_z=None, n_iter=100, tol1=None, tol2=None, tol3=None, verbose=False)[source]

A class perform the First Order Reliability Method. The run method of the FORM class can be invoked many times and each time the results are appended to the existing ones.

This is a child class of the TaylorSeries class.

Input:

See TaylorSeries class.

Attributes:

  • Pf_form (float):

    First-order probability of failure estimate.

  • beta_form (float):

    Hasofer-Lind reliability index.

  • DesignPoint_U (ndarray):

    Design point in the uncorrelated standard normal space U.

  • DesignPoint_X (ndarray):

    Design point in the parameter space X.

  • alpha (ndarray):

    Direction cosine.

  • form_iterations (int):

    Number of model evaluations.

  • u_record (list):

    Record of all iteration points in the standard normal space U.

  • x_record (list):

    Record of all iteration points in the parameter space X.

  • beta_record (list):

    Record of all Hasofer-Lind reliability index values.

  • dg_u_record (list):

    Record of the model’s gradient in the standard normal space.

  • alpha_record (list):

    Record of the alpha (directional cosine).

  • g_record (list):

    Record of the performance function.

  • error_record (list):

    Record of the error defined by criteria e1, e2, e3.

Methods:

run(seed_x=None, seed_u=None)[source]

Run FORM

This is an instance method that runs FORM.

Input:

  • seed_u or seed_x (ndarray):

    See TaylorSeries parent class.

SORM

class UQpy.Reliability.SORM(form_object, dist_object=None, seed_u=None, seed_x=None, runmodel_object=None, def_step=None, corr_x=None, corr_z=None, n_iter=None, tol1=None, tol2=None, tol3=None, verbose=False)[source]
A class to perform the Second Order Reliability Method. This class is used to correct the estimated FORM probability

using second-order information.

SORM is a child class of the TaylorSeries class.

Input:

The SORM class requires an object of type FORM as input.

Output/Returns:

The SORM class has the same outputs as the FORM class plus

  • Pf_sorm (float):

    Second-order probability of failure estimate.

  • beta_sorm (float):

    Second-order reliability index.

Methods:

References:

1
  1. Rackwitz and R. Fiessler, “Structural reliability under combined random load sequences”, Structural Safety, Vol. 22, no. 1, pp: 27–60, 1978.

2
  1. Breitung, “Asymptotic approximations for multinormal integrals”, J. Eng. Mech., ASCE, Vol. 110, no. 3, pp: 357–367, 1984.

3

S.K. Au and J.L. Beck. “Estimation of small failure probabilities in high dimensions by subset simulation”, Probabilistic Engineering Mechanics, 16(4):263–277, 2001.

4(1,2)

Shields, M.D., Giovanis, D.G., and Sundar, V.S. “Subset simulation for problems with strongly non-Gaussian, highly anisotropics, and degenerate distributions,” Computers & Structures (Accepted with Revisions)