Edit on GitHub

Main Functions

PlateKinematics.jl includes functions to aid in the step between Finite Rotations to Euler Vectors to Surface Velocity. These steps usually involve interpolation and concatenation of Finite Rotations. All functions allow the user to work with (i) sampled ensembles of a Finite Rotations, (ii) an average Finite Rotation from which an ensemble is drawn, or (iii) a single Finite Rotation to which no Covariance has been given. The same principle applies to functions involving Euler Vectors. In many functions you will notice the optional parameter Nsize, which aims at providing control to the user on the size of the sampled ensemble of Finite Rotations/Euler Vector, shall a Covariance be provided.

Contents

Index

Main Functions

Build Sampled Ensembles

Missing docstring.

Missing docstring for BuildEnsemble3D. Check Documenter's build log for details.

Un-build Sampled Ensembles (Average)

PlateKinematics.AverageEnsemble — Function
AverageEnsemble(FRsArray::Array{T}, time=nothing::Union{Nothing, Float64}) where {T<:FiniteRotSph}
AverageEnsemble(FRcArray::Array{T}, time=nothing::Union{Nothing, Float64}) where {T<:FiniteRotCart}

Return the average Finite Rotation from a given ensemble. A specific output :Time field may be passed through the argument time. The output type (FiniteRotSph or FiniteRotCart) will mirror the input array type.

source
AverageEnsemble(EVsArray::Array{T}, timeRange=nothing::Union{Nothing, Matrix}) where {T<:EulerVectorSph}
AverageEnsemble(EVcArray::Array{T}, timeRange=nothing::Union{Nothing, Matrix}) where {T<:EulerVectorCart}

Return the average Euler Vector from a given ensemble. A specific output :TimeRange field may be passed through the argument timeRange. The output type (EulerVectorSph or EulerVectorCart) will mirror the input array type.

source

Interpolate Finite Rotations

PlateKinematics.Interpolate_FiniteRotation — Function
Interpolate_FiniteRotation(FRs1::FiniteRotSph, time::Float64, Nsize=100000::Int64)
Interpolate_FiniteRotation(FRs1::Array{T}, time::Float64) where {T<:FiniteRotSph}

Interpolate a Finite Fotation for a given time between a Finite Rotation FRs and present-day.

source
Interpolate_FiniteRotation(
    FRs1::FiniteRotSph, FRs2::FiniteRotSph, time::Float64, Nsize=100000::Int64)

Interpolate_FiniteRotation(
    FRs1::Array{T}, FRs2::Array{T}, time::Float64) where {T<:FiniteRotSph}

Interpolate a Finite Rotation for a given time between two total Finite Rotations, a younger FRs1 and an older one FRs2.

source
Interpolate_FiniteRotation(
    FRsList::Array{T}, times::Array{N}, Nsize=100000::Int64) where {T<:FiniteRotSph, N<:Float64}

Interpolate a list times from a list of total Finite Rotations FRsList.

source
Interpolate_FiniteRotation(MTX::Array{N, 3}, t1::N, time::N) where {N<:Float64}

Interpolate a Finite Fotation for a given time between a Rotation Matrix MTX and present-day. t1 is the age of the Rotation Matrix. MTX may be a sampled ensemble from BuildEnsemble.

source

Interpolate_FiniteRotation( MTX1::Array{N, 3}, MTX2::Array{N, 3}, t1::N, t2::N, time::N) where {N<:Float64}

Interpolate a Finite Rotation for a given time between two total Rotation Matrices, a younger MTX1 and an older one MTX2. Rotation Matrices ages are t1 and t2, respectively. MTX1 and MTX2 may be sampled ensembles from BuildEnsemble.

source

Add Finite Rotations

PlateKinematics.Add_FiniteRotations — Function
Add_FiniteRotations(
    FRs1::FiniteRotSph, FRs2::FiniteRotSph, 
    Nsize=100000::Int64, time=nothing::Union{Nothing, Float64})

Add_FiniteRotations(
    FRs1::Array{T}, FRs2::Array{T},
    time=nothing::Union{Nothing, Float64}) where {T<:FiniteRotSph}

Return the sumation of two Finite Rotations in Spherical coordinates. A specific output :Time field may be passed through the argument time.

source

Concatenate Finite Rotations

Concatenate two or more finite rotations into a plate circuit that links two plates.

PlateKinematics.Concatenate_FiniteRotations — Function
Concatenate_FiniteRotations(
    FRsList::Array{T}, Nsize=100000::Int64, 
    time=nothing::Union{Nothing, Float64}) where {T<:FiniteRotSph}

Concatenate_FiniteRotations(
    FRsList::Array{T}, time=nothing::Union{Nothing, Float64}) where {T<:Array{FiniteRotSph}}

Concatenate all the Finite Rotations in the given array FRsList. A specific output :Time field may be passed through the argument time. Ensure the list is given in order towards the fixed reference frame (see Examples - Concatenate Finite Rotations).

source
Concatenate_FiniteRotations(
    FRs1List::Array{T}, FRs2List::Array{T}, 
    Nsize=100000::Int64, times=[]]::Array{N}) where {T<:FiniteRotSph, N<:Float64}

Given two lists of Finite Rotations (FRs1List and FRs2List), concatenate the poles for available common ages. Specific ages may be passed through the argument times.

source

Note that concatenation is nothing more than a summation of every two Finite Rotations in a particular order. Knowing this, one may also use the Add_FiniteRotations function.

Finite Rotations to Euler Vector

PlateKinematics.ToEulerVector — Function
ToEulerVector(FRs::FiniteRotSph, reverseRot=false::Bool, Nsize=100000::Int64)
ToEulerVector(FRsArray::Array{FiniteRotSph}, reverseRot=false::Bool)

Return a stage Euler Vector describing the Forward Rotation between a total Finite Rotation FRs and present-day. FRs must represent a Reconstruction Rotation. The output time-orientation may the inverted by setting the reverseRot parameter to true.

source
ToEulerVector(
    FRs1::FiniteRotSph, FRs2::FiniteRotSph, 
    reverseRot=false::Bool, Nsize=100000::Int64)
ToEulerVector(
    FRs1Array::Array{T}, FRs2Array::Array{T}, 
    reverseRot=false::Bool) where {T<:FiniteRotSph}

Return a stage Euler Vector describing the motion between two total Finite Rotations (FRs1 and FRs2). FRs1 and FRs2 must each represent a Reconstruction Rotation. If FRs1.Time > FRs2.Time, the resulting Euler Vector will represent a Forward Rotation. The output time-orientation may the inverted by setting the reverseRot parameter to true.

source
PlateKinematics.ToEulerVectorList — Function
ToEulerVectorList(
    FRsArray::Array{T}, reverseRot=false::Bool, Nsize=100000::Int64) where {T<:FiniteRotSph}

Return a list of Euler Vectors describing the motion for a list of total Finite Rotations FRsArray. The output time-orientation may the inverted by setting the reverseRot parameter to true.

source

Euler Vector de Finite Rotation

PlateKinematics.ToFiniteRotation — Function
ToFiniteRotation(EVs::EulerVectorSph, reverseRot=false::Bool, Nsize=100000::Int64)
ToFiniteRotation(EVsArray::Array{T}, reverseRot=false::Bool) where {T<:EulerVectorSph}

Return a total Finite Rotation from a total Euler Vector EVs. The output time-orientation may the inverted by setting the reverseRot parameter to true.

source

Calculate Surface Velocity

PlateKinematics.Calculate_SurfaceVelocity — Function
Calculate_SurfaceVelocity(
    EVs::EulerVectorSph, pntLon::Float64, pntLat::Float64, Nsize=100000::Int64)

Calculate_SurfaceVelocity(
    EVsArray::Array{T}, pntLon::Float64, pntLat::Float64) where {T<:EulerVectorSph}

Calculate_SurfaceVelocity(
    EVs::EulerVectorSph, arrayLon::Array{N}, arrayLat::Array{N}, 
    Nsize=100000::Int64) where {N<:Float64}

Calculate the Surface Velocity components for a given point on Earth, subject to the motion described by an Euler Vector EVs. Location(s) are given through parameters pntLon and pntLat, which represent spherical coordinates in degrees-East and degrees-North, respectively. Outputs are given in cm/yr and degrees.

source