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
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:
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
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).
- runmodel_object (
- 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.
- mcmc_class (Class of type
- 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
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
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:

In SORM the performance function is approximated by a second-order Taylor series around the design point according to
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
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
orJointInd
.
- dist_object ((list of )
- runmodel_object (
RunModel
object): The computational model. It should be of type
RunModel
(seeRunModel
class).
- runmodel_object (
- form_object (
FORM
object): It should be of type
FORM
(seeFORM
class). Used to calculate SORM correction.
- form_object (
- 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
(seeRunModel
class).
- runmodel_object (
- nataf_object (
Nataf
object): An object of the
Nataf
class (seeNataf
class).
- nataf_object (
- 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 theFORM
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:
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 theTaylorSeries
class.Input:
The
SORM
class requires an object of typeFORM
as input.Output/Returns:
The
SORM
class has the same outputs as theFORM
class plus- Pf_sorm (float):
Second-order probability of failure estimate.
- beta_sorm (float):
Second-order reliability index.
Methods:
References:
- 1
Rackwitz and R. Fiessler, “Structural reliability under combined random load sequences”, Structural Safety, Vol. 22, no. 1, pp: 27–60, 1978.
- 2
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)