Random Vibration Theory Parameters

Definition of the custom type RandomVibrationParameters to represent the model components/approaches used for the random vibration theory calculations. In particular, the type stores symbols to define the:

pf_method the peak factor model/method to use.
dur_ex specifies the excitation duration model to use,
dur_rms specifies the model to use for converting excitation to RMS duration, and
dur_region: the region or tectonic setting for excitation duration predictions, i.e. :ACR or :SCR for active and stable crustal regions

StochasticGroundMotionSimulation.RandomVibrationParameters — Type

RandomVibrationParameters

Struct holding parameters/methods for Random Vibration Theory.

pf_method is the method used for peak factor computation

- `:DK80` (default) is Der Kiureghian (1980), building on Vanmarcke (1975)
- `:CL56` is Cartwright Longuet-Higgins (1956)

dur_ex is the model for excitation duration

- `:BT14` (default) is the Boore & Thompson (2014) model for ACRs - note that this is adpated to work with `r_ps`
- `:BT15` is the Boore & Thompson (2015) model for SCRs
- `:BE23` is an excitation duration model from Ben Edwards (2023), suggested for a South African NPP project

dur_rms is the model for rms duration

- `:BT12` is the Boore & Thompson (2012) model
- `:BT15` (default) is the Boore & Thompson (2015) model
- `:LP99` is the Liu & Pezeshk (1999) model linking rms, excitation and oscillator durations

dur_region is the region specified for the duration model

- `:ACR` (default) is active crustal regions (like western North America)
- `:SCR` is stable crustal regions (like eastern North America)

Note that only certain combinations are meaningful:

:CL56 peak factor method should be paired with :BT12 or :LP99 rms duration
:DK80 peak factor method should be paired with :BT15 rms duration

Constructors that take only the peak factor as input, or the peak factor and duration region automatically assign the appropriate rms duration method.

source

Note that the default specification is:

RandomVibrationParameters() = RandomVibrationParameters(:DK80, :BT14, :BT15, :ACR)

RandomVibrationParameters (generic function with 1 method)

However, an alternative constructor exists that takes a pf_method as a single argument, or that take a pf_method and dur_region specification. For these constructors, the dur_rms model is linked to the pf_method peak factor method:

DK80 is paired with :BT15, and is the default
CL56 is paired with :BT12

As these are currently the only two dur_rms models implemented, the constructor is specified as:

RandomVibrationParameters(pf) = RandomVibrationParameters(pf, :BT14, ((pf == :DK80) ? :BT15 : :BT12), :ACR)

RandomVibrationParameters (generic function with 1 method)

In all cases, the Boore & Thompson (2014, 2015) excitation duration model is employed as that is the only model currently implemented. This model uses a standard source duration definition, related to the source corner frequencies, and then applies a path duration model that is purely a function of the equivalent point-source distance. The path duration model depends upon the region, as in active crustal regions or stable crustal regions.

## Functionality

The overall goal of these random vibration methods is to compute:

\[S_a = \psi \sqrt{ \frac{m_0}{D_{rms}}}\]

where $\psi$ is the peak factor computed from peak_factor, $m_0$ is the zeroth order spectral moment computed from spectral_moment, and $D_{rms}$ is the root-mean-square duration computed from dur_rms.

The main methods used to interact with RandomVibrationParameters are:

StochasticGroundMotionSimulation.SpectralMoments — Type

@kwdef struct SpectralMoments{T<:Real}

Struct holding spectral moments m0 to m4

source

StochasticGroundMotionSimulation.create_spectral_moments — Function

create_spectral_moments(order::Vector{Int}, value::Vector{T}) where {T<:Real}

Create a SpectralMoments instance from vectors of order integers and moment values. Allows for encapsulation of named moments within the returned instance.

source

StochasticGroundMotionSimulation.spectral_moment — Function

spectral_moment(order::Int, m::S, r_ps::T, fas::FourierParameters, sdof::Oscillator; nodes::Int=31, control_freqs::Vector{Float64}=[1e-3, 1e-1, 1.0, 10.0, 100.0, 300.0] ) where {S<:Real,T<:Real}

Compute spectral moment of a specified order.

Evaluates the expression:

\[ m_k = 2\int_{0}^{\infty} \left(2\pi f\right)^k |H(f;f_n,\zeta_n)|^2 |A(f)|^2 df\]

where $k$ is the order of the moment.

Integration is performed using Gauss-Legendre integration using nodes nodes and weights. The integration domain is partitioned over the control_freqs as well as two inserted frequencies at f_n/1.5 and f_n*1.5 in order to ensure good approximation of the integral around the sdof resonant frequency.

See also: spectral_moments

source

StochasticGroundMotionSimulation.spectral_moments — Function

spectral_moments(order::Vector{Int}, m::S, r_ps::T, fas::FourierParameters, sdof::Oscillator; glxi::Vector{Float64}=xn31i, glwi::Vector{Float64}=wn31i, nodes::Int=length(glxi), control_freqs::Vector{Float64}=[1e-3, 1e-1, 1.0, 10.0, 100.0, 300.0] ) where {S<:Real,T<:Real}

Compute a vector of spectral moments for the specified order.

Evaluates the expression:

\[ m_k = 2\int_{0}^{\infty} \left(2\pi f\right)^k |H(f;f_n,\zeta_n)|^2 |A(f)|^2 df\]

for each order, where $k$ is the order of the moment.

source

StochasticGroundMotionSimulation.spectral_moments_gk — Function

spectral_moments_gk(order::Vector{Int}, m::S, r_ps::T, fas::FourierParameters, sdof::Oscillator) where {S<:Real,T<:Real}

Compute a vector of spectral moments for the specified order using Gauss-Kronrod integration from the QuadGK.jl package.

Evaluates the expression:

\[ m_k = 2\int_{0}^{\infty} \left(2\pi f\right)^k |H(f;f_n,\zeta_n)|^2 |A(f)|^2 df\]

for each order, where $k$ is the order of the moment.

Integration is performed using adaptive Gauss-Kronrod integration with the domain split over two intervals from $[0,f_n]$ and $[f_n,\infty]$ to ensure that the resonant peak is not missed.

Note that due to the default tolerances, the moments computed by this method are more accurate than those from spectral_moments using the Gauss-Legendre approximation. However, this method is also significantly slower, and cannot be used within an automatic differentiation environment.

source

StochasticGroundMotionSimulation.excitation_duration — Function

excitationduration(m, rps::U, src::SourceParameters{S,T}, rvt::RandomVibrationParameters) where {S<:Float64,T<:Real,U<:Real}

Generic function implementing excitation duration models.

Currently, only the general Boore & Thompson (2014, 2015) models are implemented along with some project-specific models from Edwards (2023) (for South Africa), and two UK duration models. The first two are both represented within the Boore & Thompson (2015) paper, so just switch path duration based upon rvt.dur_region To activate the Edwards model, use rvt.dur_ex == :BE23 For the UK models use rvt.dur_ex == :UKfree or rvt.dur_ex == :UKfixed

source

StochasticGroundMotionSimulation.rms_duration — Function

rms_duration(m::S, r_ps::T, src::SourceParameters, sdof::Oscillator, rvt::RandomVibrationParameters) where {T<:Real}

Returns a 3-tuple of (Drms, Dex, Dratio), using a switch on rvt.dur_rms. Default rvt makes use of the :BT14 model for excitation duration, Dex.

m is magnitude
r_ps is an equivalent point source distance

source

StochasticGroundMotionSimulation.peak_factor — Function

peak_factor(m::S, r_ps::T, fas::FourierParameters, sdof::Oscillator, rvt::RandomVibrationParameters; glxi::Vector{Float64}=xn31i, glwi::Vector{Float64}=wn31i, nodes::Int=length(glxi)) where {S<:Real,T<:Real}

Peak factor $u_{max} / u_{rms}$ with a switch of pf_method to determine the approach adopted. rvt.pf_method can currently be one of: - :CL56 for Cartright Longuet-Higgins (1956) - :DK80 for Der Kiureghian (1980), building on Vanmarcke (1975)

Defaults to :DK80.

source

peak_factor(Dex::U, m0::V, rvt::RandomVibrationParameters; glxi::Vector{Float64}=xn31i, glwi::Vector{Float64}=wn31i, nodes::Int=length(glxi)) where {U<:Real}

Peak factor umax / urms with a switch of pf_method to determine the approach adopted. pf_method can currently be one of: - :CL56 for Cartright Longuet-Higgins (1956) - :DK80 for Der Kiureghian (1980), building on Vanmarcke (1975)

Defaults to :DK80.

source

StochasticGroundMotionSimulation.rvt_response_spectral_ordinate — Function

rvt_response_spectral_ordinate(m::S, r_ps::T, fas::FourierParameters, sdof::Oscillator, rvt::RandomVibrationParameters; glxi::Vector{Float64}=xn31i, glwi::Vector{Float64}=wn31i) where {S<:Real,T<:Real}

Response spectral ordinate (units of $g$) for the specified scenario.

The spectral ordinate is computed using the expression:

\[S_a = \psi \sqrt{\frac{m_0}{D_{rms}}}\]

where $\psi$ is the peak factor computed from peak_factor, $m_0$ is the zeroth order spectral moment from spectral_moment, and $D_{rms}$ is the RMS duration computed from rms_duration.

source

rvt_response_spectral_ordinate(period::U, m::S, r_ps::T, fas::FourierParameters, rvt::RandomVibrationParameters; glxi::Vector{Float64}=xn31i, glwi::Vector{Float64}=wn31i) where {S<:Real,T<:Real,U<:Float64}

Response spectral ordinate (units of $g$) for the specified scenario.

The spectral ordinate is computed using the expression:

\[S_a = \psi \sqrt{\frac{m_0}{D_{rms}}}\]

where $\psi$ is the peak factor computed from peak_factor, $m_0$ is the zeroth order spectral moment from spectral_moment, and $D_{rms}$ is the RMS duration computed from rms_duration.

source

StochasticGroundMotionSimulation.rvt_response_spectrum — Function

rvt_response_spectrum(period::Vector{U}, m::S, r_ps::T, fas::FourierParameters, rvt::RandomVibrationParameters; glxi::Vector{Float64}=xn31i, glwi::Vector{Float64}=wn31i) where {S<:Real,T<:Real,U<:Float64}

Response spectrum (units of $g$) for the vector of periods period and the specified scenario.

Each spectral ordinate is computed using the expression:

\[S_a = \psi \sqrt{\frac{m_0}{D_{rms}}}\]

where $\psi$ is the peak factor computed from peak_factor, $m_0$ is the zeroth order spectral moment from spectral_moment, and $D_{rms}$ is the RMS duration computed from rms_duration. The various terms are all functions of the oscillator period.

source

StochasticGroundMotionSimulation.rvt_response_spectrum! — Function

rvt_response_spectrum!(Sa::Vector{U}, period::Vector{V}, m::S, r_ps::T, fas::FourierParameters, rvt::RandomVibrationParameters) where {S<:Real,T<:Real,U<:Real,V<:Float64}

In-place response spectrum (units of $g$) for the vector of periods period and the specified scenario.

Each spectral ordinate is computed using the expression:

\[S_a = \psi \sqrt{\frac{m_0}{D_{rms}}}\]

source