GitHub

Inverse Reliability Problems

Defining Inverse Reliability Problems

In general, 4 main "items" are always need to fully define an inverse reliability problem and successfully solve it to find the parameter of interest $\theta$:

ItemDescription
$\vec{X}$Random vector with correlated non-normal marginals
$\rho^{X}$Correlation matrix
$g(\vec{X}, \theta)$Limit state function
$\beta$Target reliability index

Fortuna.jl package uses these 4 "items" to fully define inverse reliability problems of type I using SensitivityProblem() type as shown in the example below.

Solving Inverse Reliability Problems

# Define the random vector:
X₁ = randomvariable("Normal", "M", [0, 1])
X₂ = randomvariable("Normal", "M", [0, 1])
X₃ = randomvariable("Normal", "M", [0, 1])
X₄ = randomvariable("Normal", "M", [0, 1])
X  = [X₁, X₂, X₃, X₄]

# Define the correlation matrix:
ρˣ = Matrix{Float64}(1.0 * I, 4, 4)

# Define the limit state function:
g(x::Vector, θ::Real) = exp(-θ * (x[1] + 2 * x[2] + 3 * x[3])) - x[4] + 1.5

# Define the target reliability index:
β = 2

# Define an inverse reliability problem:
Problem = InverseReliabilityProblem(X, ρˣ, g, β)

Solving Inverse Reliability Problems

After defining an inverse reliability problem, Fortuna.jl allows to easily solve it using a single solve() function as shown in the example below.

# Perform the inverse reliability analysis:
Solution = solve(Problem, 0.1, x₀ = [0.2, 0.2, 0.2, 0.2])
println("x = $(Solution.x[:, end])  ")
println("θ = $(Solution.θ[end])")
x = [0.21827438460314785, 0.4365487692062958, 0.6548231538094436, 1.8256473105081492]
θ = 0.3671461348014133

API

Fortuna.solve — Method
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.
source
Fortuna.InverseReliabilityProblem — Type
InverseReliabilityProblem <: AbstractReliabilityProblem

Type used to define inverse reliability problems.

  • X::AbstractVector{<: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$

source
Fortuna.InverseReliabilityProblemCache — Type
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}$

source