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$:
Item | Description |
---|---|
$\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.21827438460314813, 0.4365487692062959, 0.6548231538094436, 1.8256473105081492]
θ = 0.3671461348014138
API
Fortuna.solve
— Methodsolve(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.InverseReliabilityProblem
— TypeInverseReliabilityProblem <: 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$
Fortuna.InverseReliabilityProblemCache
— TypeInverseReliabilityProblemCache
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}$