Fortuna.CFType
CF <: SORMSubmethod

Type used to perform reliability analysis using Curve-Fitting (CF) method.

  • ϵ::Real: Step size used to compute the Hessian at the design point in $U$-space
Fortuna.CFCacheType
CFCache

Type used to perform reliability analysis using Point-Fitting (PF) method.

  • FORMSolution::Union{HLRFCache, RFCache, iHLRFCache}: Results of reliability analysis performed using First-Order Reliability Method (FORM)

  • β₂::Vector{Union{Missing, Float64}}: Generalized reliability indices $\beta$

  • PoF₂::Vector{Union{Missing, Float64}}: Probabilities of failure $P_{f}$

  • κ::Vector{Float64}: Principal curvatures $\kappa$

Fortuna.FORMType
FORM <: AbstractReliabililyAnalysisMethod

Type used to perform reliability analysis using First-Order Reliability Method (FORM).

  • Submethod::Fortuna.FORMSubmethod
Fortuna.FORMSubmethodType
abstract type FORMSubmethod end

Abstract type for First-Order Reliability Method's (FORM) submethods.

Fortuna.HLRFType
HLRF <: FORMSubmethod

Type used to perform reliability analysis using Hasofer-Lind Rackwitz-Fiessler (HLRF) method.

  • MaxNumIterations::Integer: Maximum number of iterations

  • ϵ₁::Real: Convergance criterion #1 $\epsilon_{1}$

  • ϵ₂::Real: Convergance criterion #1 $\epsilon_{2}$

  • x₀::Union{Nothing, Vector{<:Real}}: Starting point $x_{0}$

Fortuna.HLRFCacheType
HLRFCache

Type used to store results of reliability analysis performed using Hasofer-Lind Rackwitz-Fiessler (HLRF) method.

  • β::Float64: Reliability index $\beta$

  • PoF::Float64: Probability of failure $P_{f}$

  • x::Matrix{Float64}: Design points in X-space at each iteration $\vec{x}_{i}^{*}$

  • u::Matrix{Float64}: Design points in U-space at each iteration $\vec{u}_{i}^{*}$

  • G::Vector{Float64}: Limit state function at each iteration $G(\vec{u}_{i}^{*})$

  • ∇G::Matrix{Float64}: Gradient of the limit state function at each iteration $\nabla G(\vec{u}_{i}^{*})$

  • α::Matrix{Float64}: Normalized negative gradient of the limit state function at each iteration $\vec{\alpha}_{i}$

  • d::Matrix{Float64}: Search direction at each iteration $\vec{d}_{i}$

  • γ::Vector{Float64}: Importance vector $\vec{\gamma}$

  • Convergance::Bool: Convergance status

Fortuna.ISType
IS <: AbstractReliabililyAnalysisMethod

Type used to perform reliability analysis using Importance Sampling (IS) method.

Fortuna.ISCacheType
ISCache

Type used to store results of reliability analysis performed using Importance Sampling (IS) method.

Fortuna.InverseReliabilityProblemType
InverseReliabilityProblem <: AbstractReliabilityProblem

Type used to define inverse reliability problems.

  • X::AbstractVector{<:Distributions.UnivariateDistribution}: Random vector $\vec{X}$

  • ρˣ::AbstractMatrix{<:Real}: Correlation matrix $\rho^{X}$

  • g::Function: Limit state function $g(\vec{X}, \theta)$

  • β::Real: Target reliability index $\beta_t$

Fortuna.InverseReliabilityProblemCacheType
InverseReliabilityProblemCache

Type used to store results of inverse reliability analysis.

  • x::Matrix{Float64}: Design points in X-space at each iteration $\vec{x}_{i}^{*}$

  • u::Matrix{Float64}: Design points in U-space at each iteration $\vec{u}_{i}^{*}$

  • θ::Vector{Float64}: Parameter of interest at each iteration $\theta_{i}$

  • G::Vector{Float64}: Limit state function at each iteration $G(\vec{u}_{i}^{*}, \theta_{i})$

  • ∇Gu::Matrix{Float64}: Gradient of the limit state function at each iteration $\nabla_{\vec{u}} G(\vec{u}_{i}^{*}, \theta_{i})$

  • ∇Gθ::Vector{Float64}: Gradient of the limit state function at each iteration $\nabla_{\theta} G(\vec{u}_{i}^{*}, \theta_{i})$

  • α::Matrix{Float64}: Normalized negative gradient of the limit state function at each iteration $\vec{\alpha}_{i}$

  • du::Matrix{Float64}: Search direction for the design point in U-space at each iteration $\vec{d}_{u_{i}}$

  • dθ::Vector{Float64}: Search direction for the parameter of interest at each iteration $\vec{d}_{u_{i}}$

  • c₁::Vector{Float64}: $c_{1}$-coefficients at each iteration $c_{1_{i}}$

  • c₂::Vector{Float64}: $c_{2}$-coefficients at each iteration $c_{2_{i}}$

  • m₁::Vector{Float64}: First merit function at each iteration $m_{1_{i}}$

  • m₂::Vector{Float64}: Second merit function at each iteration $m_{2_{i}}$

  • m::Vector{Float64}: Merit function at each iteration $m_{i}$

  • λ::Vector{Float64}: Step size at each iteration $\lambda_{i}$

Fortuna.MCType
MC <: AbstractReliabililyAnalysisMethod

Type used to perform reliability analysis using Monte Carlo (MC) simulations.

  • NumSimulations::Integer: Number of simulations $N$

  • SamplingTechnique::Symbol: Sampling technique

Fortuna.MCCacheType
MCCache

Type used to store results of reliability analysis performed using Monte Carlo (MC) simulations.

  • Samples::Matrix{Float64}: Generated samples $\vec{x}_{i}$

  • gValues::Vector{Float64}: Limit state function evalued at each sample $g(\vec{x}_{i})$

  • PoF::Float64: Probability of failure $P_{f}$

Fortuna.MCFOSMType
MCFOSM <: FORMSubmethod

Type used to perform reliability analysis using Mean-Centered First-Order Second-Moment (MCFOSM) method.

Fortuna.MCFOSMCacheType
MCFOSMCache

Type used to store results of reliability analysis performed using Mean-Centered First-Order Second-Moment (MCFOSM) method.

  • β::Float64: Reliability index $\beta$
Fortuna.NatafTransformationType
NatafTransformation <: AbstractTransformation

Type used to perform Nataf Transformation.

  • X::AbstractVector{<:Distributions.Distribution{Distributions.Univariate, Distributions.Continuous}}: Random vector $\vec{X}$

  • ρˣ::AbstractMatrix{<:Real}: Correlation matrix $\rho^{X}$

  • ρᶻ::AbstractMatrix{<:Real}: Distorted correlation matrix $\rho^{Z}$

  • L::AbstractMatrix{<:Real}: Lower triangular matrix of the Cholesky decomposition of the distorted correlation matrix $L$

  • L⁻¹::AbstractMatrix{<:Real}: Inverse of the lower triangular matrix of the Cholesky decomposition of the distorted correlation matrix $L^{-1}$

Fortuna.PFType
PF <: SORMSubmethod

Type used to perform reliability analysis using Point-Fitting (PF) method.

Fortuna.PFCacheType
PFCache

Type used to perform reliability analysis using Point-Fitting (PF) method.

  • FORMSolution::iHLRFCache: Results of reliability analysis performed using First-Order Reliability Method (FORM)

  • β₂::Vector{Union{Missing, Float64}}: Generalized reliability index $\beta$

  • PoF₂::Vector{Union{Missing, Float64}}: Probabilities of failure $P_{f}$

  • FittingPoints⁻::Matrix{Float64}: Fitting points on the negative side of the hyper-cylinder

  • FittingPoints⁺::Matrix{Float64}: Fitting points on the positive side of the hyper-cylinder

  • κ₁::Matrix{Float64}: Principal curvatures on the negative and positive sides

  • κ₂::Matrix{Float64}: Principal curvatures of each hyper-semiparabola

Fortuna.RFType
RF <: FORMSubmethod

Type used to perform reliability analysis using Rackwitz-Fiessler (RF) method.

  • MaxNumIterations::Integer: Maximum number of iterations

  • ϵ::Real: Convergance criterion $\epsilon$

Fortuna.RFCacheType
RFCache

Type used to store results of reliability analysis performed using Rackwitz-Fiessler (RF) method.

  • β::Float64: Reliability index $\beta$

  • x::Matrix{Float64}: Design points in X-space at each iteration $\vec{x}_{i}^{*}$

  • u::Matrix{Float64}: Design points in U-space at each iteration $\vec{u}_{i}^{*}$

  • μ::Matrix{Float64}: Means of equivalent normal marginals at each iteration $\vec{\mu}_{i}$

  • σ::Matrix{Float64}: Standard deviations of equivalent normal marginals at each iteration $\vec{\sigma}_{i}$

  • ∇G::Matrix{Float64}: Gradient of the limit state function at each iteration $\nabla G(\vec{u}_{i}^{*})$

  • α::Matrix{Float64}: Normalized negative gradient of the limit state function at each iteration $\vec{\alpha}_{i}$

  • Convergance::Bool: Convergance status

Fortuna.ReliabilityProblemType
ReliabilityProblem <: AbstractReliabilityProblem

Type used to define reliability problems.

  • X::AbstractVector{<:Distributions.UnivariateDistribution}: Random vector $\vec{X}$

  • ρˣ::AbstractMatrix{<:Real}: Correlation matrix $\rho^{X}$

  • g::Function: Limit state function $g(\vec{X})$

Fortuna.SORMType
SORM <: AbstractReliabililyAnalysisMethod

Type used to perform reliability analysis using Second-Order Reliability Method (SORM).

  • Submethod::Fortuna.SORMSubmethod
Fortuna.SORMSubmethodType
abstract type SORMSubmethod end

Abstract type for Second-Order Reliability Method's (FORM) submethods.

Fortuna.SSMType
SSM <: AbstractReliabililyAnalysisMethod

Type used to perform reliability analysis using Subset Simulation Method (SSM).

  • P₀::Real: Probability of failure for each subset $P_{0}$

  • NumSamples::Integer: Number of samples generated within each subset $N$

  • MaxNumSubsets::Integer: Maximum number of subsets $M$

Fortuna.SSMCacheType
SSMCache

Type used to perform reliability analysis using Subset Simulation Method (SSM).

  • XSamplesSubset::Vector{Matrix{Float64}}: Samples generated within each subset in $X$-space

  • USamplesSubset::Vector{Matrix{Float64}}: Samples generated within each subset in $U$-space

  • CSubset::Vector{Float64}: Threshold for each subset $C_{i}$

  • PoFSubset::Vector{Float64}: Probability of failure for each subset $P_{f_{i}}$

  • PoF::Float64: Probability of failure $P_{f}$

  • Convergance::Bool: Convergance status

Fortuna.SensitivityProblemCacheType
SensitivityProblemCache

Type used to store results of sensitivity analysis for problems of type I (sensitivities w.r.t. the parameters of the limit state function).

  • FORMSolution::iHLRFCache: Results of reliability analysis performed using First-Order Reliability Method (FORM)

  • ∇β::Vector{Float64}: Sensivity vector of reliability index $\vec{\nabla}_{\vec{\Theta}} \beta$

  • ∇PoF::Vector{Float64}: Sensivity vector of probability of failure $\vec{\nabla}_{\vec{\Theta}} P_{f}$

Fortuna.SensitivityProblemTypeIType
SensitivityProblemTypeI <: AbstractReliabilityProblem

Type used to define sensitivity problems of type I (sensitivities w.r.t. the parameters of the limit state function).

  • X::AbstractVector{<:Distributions.UnivariateDistribution}: Random vector $\vec{X}$

  • ρˣ::AbstractMatrix{<:Real}: Correlation matrix $\rho^{X}$

  • g::Function: Limit state function $g(\vec{X}, \vec{\Theta})$

  • Θ::AbstractVector{<:Real}: Parameters of limit state function $\vec{\Theta}$

Fortuna.SensitivityProblemTypeIIType
SensitivityProblemTypeII <: AbstractReliabilityProblem

Type used to define sensitivity problems of type II (sensitivities w.r.t. the parameters of the random vector).

  • X::Function: Random vector $\vec{X}(\vec{\Theta})$

  • ρˣ::AbstractMatrix{<:Real}: Correlation matrix $\rho^{X}$

  • g::Function: Limit state function $g(\vec{X})$

  • Θ::AbstractVector{<:Real}: Parameters of limit state function $\vec{\Theta}$

Fortuna.iHLRFType
iHLRF <: FORMSubmethod

Type used to perform reliability analysis using improved Hasofer-Lind Rackwitz-Fiessler (iHLRF) method.

  • MaxNumIterations::Integer: Maximum number of iterations

  • ϵ₁::Real: Convergance criterion #1 $\epsilon_{1}$

  • ϵ₂::Real: Convergance criterion #1 $\epsilon_{2}$

  • x₀::Union{Nothing, Vector{<:Real}}: Starting point $x_{0}$

  • c₀::Union{Nothing, Real}: c-coefficient applied at each iteration $c_{0}$

Fortuna.iHLRFCacheType
iHLRFCache

Type used to store results of reliability analysis performed using improved Hasofer-Lind Rackwitz-Fiessler (iHLRF) method.

  • β::Float64: Reliability index $\beta$

  • PoF::Float64: Probability of failure $P_{f}$

  • x::Matrix{Float64}: Design points in X-space at each iteration $\vec{x}_{i}^{*}$

  • u::Matrix{Float64}: Design points in U-space at each iteration $\vec{u}_{i}^{*}$

  • G::Vector{Float64}: Limit state function at each iteration $G(\vec{u}_{i}^{*})$

  • ∇G::Matrix{Float64}: Gradient of the limit state function at each iteration $\nabla G(\vec{u}_{i}^{*})$

  • α::Matrix{Float64}: Normalized negative gradient of the limit state function at each iteration $\vec{\alpha}_{i}$

  • d::Matrix{Float64}: Search direction at each iteration $\vec{d}_{i}$

  • c::Vector{Float64}: c-coefficient at each iteration $c_{i}$

  • m::Vector{Float64}: Merit function at each iteration $m_{i}$

  • λ::Vector{Float64}: Step size at each iteration $\lambda_{i}$

  • γ::Vector{Float64}: Importance vector $\vec{\gamma}$

  • Convergance::Bool: Convergance status

Base.randMethod
rand(RNG::Distributions.AbstractRNG, RandomVariable::Distributions.UnivariateDistribution, NumSamples::Int, SamplingTechnique::Symbol)

Function used to generate samples from an random variable. If SamplingTechnique is:

  • :ITS samples are generated using Inverse Transform Sampling technique.
  • :LHS samples are generated using Latin Hypercube Sampling technique.
Base.randMethod
rand(RNG::Distributions.AbstractRNG, TransformationObject::NatafTransformation, NumSamples::Int, SamplingTechnique::Symbol)

Function used to generate samples from a random vector with correlated marginals using Nataf Transformation object. If SamplingTechnique is:

  • :ITS samples are generated using Inverse Transform Sampling technique.
  • :LHS samples are generated using Latin Hypercube Sampling technique.
Base.randMethod
rand(RNG::Distributions.AbstractRNG, RandomVector::Vector{<:Distributions.UnivariateDistribution}, NumSamples::Int, SamplingTechnique::Symbol)

Function used to generate samples from a random vector with uncorrelated marginals. If SamplingTechnique is:

  • :ITS samples are generated using Inverse Transform Sampling technique.
  • :LHS samples are generated using Latin Hypercube Sampling technique.
Distributions.pdfMethod
pdf(TransformationObject::NatafTransformation, x::AbstractVector{<:Real})

Function used to compute the joint PDF in $X$-space.

Fortuna.getdistortedcorrelationMethod
getdistortedcorrelation(X::AbstractVector{<:Distributions.UnivariateDistribution}, ρˣ::AbstractMatrix{<:Real})

Function used to compute the distorted correlation matrix $\rho^{Z}$.

Fortuna.getjacobianMethod
getjacobian(TransformationObject::NatafTransformation, Samples::AbstractVector{<:Real}, TransformationDirection::Symbol)

Function used to compute the Jacobians of the transformations of samples from $X$- to $U$-space and vice versa.
If TransformationDirection is:

  • :X2U, then the function returns the Jacobians of the transformations of samples $\vec{x}$ from $X$- to $U$-space.
  • :U2X, then the function returns the Jacobians of the transformations of samples $\vec{u}$ from $U$- to $X$-space.
Fortuna.randomvariableMethod
randomvariable(Distribution::AbstractString, DefineBy::AbstractString, Values::Union{Real, AbstractVector{<:Real}})

Function used to define random variables.

Fortuna.solveMethod
solve(Problem::InverseReliabilityProblem, θ₀::Real; 
    x₀::Union{Nothing, Vector{<:Real}} = nothing, 
    MaxNumIterations = 250, ϵ₁ = 10E-6, ϵ₂ = 10E-6, ϵ₃ = 10E-3,
    diff::Symbol = :automatic)

Function used to solve inverse reliability problems.
If diff is:

  • :automatic, then the function will use automatic differentiation to compute gradients, jacobians, etc.
  • :numeric, then the function will use numeric differentiation to compute gradients, jacobians, etc.
Fortuna.solveMethod
solve(Problem::ReliabilityProblem, AnalysisMethod::FORM; diff::Symbol = :automatic)

Function used to solve reliability problems using First-Order Reliability Method (FORM).
If diff is:

  • :automatic, then the function will use automatic differentiation to compute gradients, jacobians, etc.
  • :numeric, then the function will use numeric differentiation to compute gradients, jacobians, etc.
Fortuna.solveMethod
solve(Problem::ReliabilityProblem, AnalysisMethod::IS; showprogressbar = false)

Function used to solve reliability problems using Importance Sampling (IS) method.

Fortuna.solveMethod
solve(Problem::ReliabilityProblem, AnalysisMethod::MC; showprogressbar = false)

Function used to solve reliability problems using Monte Carlo (MC) simulations.

Fortuna.solveMethod

solve(Problem::ReliabilityProblem, AnalysisMethod::SORM; FORMSolution::Union{Nothing, HLRFCache, iHLRFCache} = nothing, FORMConfig::FORM = FORM(), diff::Symbol = :automatic)

Function used to solve reliability problems using Second-Order Reliability Method (SORM).
If diff is:

  • :automatic, then the function will use automatic differentiation to compute gradients, jacobians, etc.
  • :numeric, then the function will use numeric differentiation to compute gradients, jacobians, etc.
Fortuna.solveMethod
solve(Problem::ReliabilityProblem, AnalysisMethod::SSM)

Function used to solve reliability problems using Subset Simulation Method (SSM).

Fortuna.solveMethod
solve(Problem::SensitivityProblemTypeII; diff::Symbol = :automatic)

Function used to solve sensitivity problems of type II (sensitivities w.r.t. the parameters of the random vector).
If diff is:

  • :automatic, then the function will use automatic differentiation to compute gradients, jacobians, etc.
  • :numeric, then the function will use numeric differentiation to compute gradients, jacobians, etc.
Fortuna.solveMethod
solve(Problem::SensitivityProblemTypeI; diff::Symbol = :automatic)

Function used to solve sensitivity problems of type I (sensitivities w.r.t. the parameters of the limit state function).
If diff is:

  • :automatic, then the function will use automatic differentiation to compute gradients, jacobians, etc.
  • :numeric, then the function will use numeric differentiation to compute gradients, jacobians, etc.
Fortuna.transformsamplesMethod
transformsamples(TransformationObject::NatafTransformation, Samples::AbstractVector{<:Real}, TransformationDirection::Symbol)

Function used to transform samples from $X$- to $U$-space and vice versa.
If `TransformationDirection is:

  • :X2U, then the function transforms samples $\vec{x}$ from $X$- to $U$-space.
  • :U2X, then the function transforms samples $\vec{u}$ from $U$- to $X$-space.