GridapROMs.ParamDataStructures

GridapROMs.ParamDataStructures.AbstractSnapshotsType
abstract type AbstractSnapshots{T,N} <: AbstractParamData{T,N} end

Type representing N-dimensional arrays of snapshots. Subtypes must contain the following information:

  • data: a (parametric) array
  • realization: a subtype of AbstractRealization, representing the points in the parameter space used to compute the array data
  • dof map: a subtype of AbstractDofMap, representing a reindexing strategy for the array data

Subtypes:

source
GridapROMs.ParamDataStructures.BlockSnapshotsType
struct BlockSnapshots{S<:Snapshots,N} <: AbstractSnapshots{S,N}
  array::Array{S,N}
  touched::Array{Bool,N}
end

Block container for Snapshots of type S in a MultiField setting. This type is conceived similarly to ArrayBlock in Gridap

source
GridapROMs.ParamDataStructures.ConsecutiveParamArrayType
struct ConsecutiveParamArray{T,N,M,A<:AbstractArray{T,M}} <: ParamArray{T,N}
  data::A
end

Parametric array with entries stored consecutively in memory. It is characterized by an inner size equal to size(data)[1:N], and parametric length equal to size(data,N+1), where data is an AbstractArray of dimension M = N+1

source
GridapROMs.ParamDataStructures.ConsecutiveParamSparseMatrixCSCType
struct ConsecutiveParamSparseMatrixCSC{Tv,Ti<:Integer,A<:AbstractMatrix{Tv}} <: ParamSparseMatrixCSC{Tv,Ti}
  m::Int64
  n::Int64
  colptr::Vector{Ti}
  rowval::Vector{Ti}
  data::A
end

Represents a vector of sparse matrices in CSC format, with entries stored consecutively in memory. For sake of coherence, an instance of ConsecutiveParamSparseMatrixCSC inherits from AbstractMatrix{<:SparseMatrixCSC{Tv,Ti} rather than AbstractVector{<:SparseMatrixCSC{Tv,Ti}, but should conceptually be thought as an AbstractVector{<:SparseMatrixCSC{Tv,Ti}.

source
GridapROMs.ParamDataStructures.ConsecutiveParamSparseMatrixCSRType
struct ConsecutiveParamSparseMatrixCSR{Bi,Tv,Ti<:Integer,A<:AbstractMatrix{Tv}} <: ParamSparseMatrixCSR{Bi,Tv,Ti}
  m::Int64
  n::Int64
  rowptr::Vector{Ti}
  colval::Vector{Ti}
  data::A
end

Represents a vector of sparse matrices in CSR format, with entries stored consecutively in memory. For sake of coherence, an instance of ConsecutiveParamSparseMatrixCSR inherits from AbstractMatrix{<:SparseMatrixCSR{Bi,Tv,Ti} rather than AbstractVector{<:SparseMatrixCSR{Bi,Tv,Ti}, but should conceptually be thought as an AbstractVector{<:SparseMatrixCSR{Bi,Tv,Ti}.

source
GridapROMs.ParamDataStructures.GenericParamSparseMatrixCSCType
struct GenericParamSparseMatrixCSC{Tv,Ti<:Integer} <: ParamSparseMatrixCSC{Tv,Ti}
  m::Int64
  n::Int64
  colptr::Vector{Ti}
  rowval::Vector{Ti}
  data::Vector{Tv}
  ptrs::Vector{Ti}
end

Represents a vector of sparse matrices in CSC format, with entries stored non-consecutively in memory. For sake of coherence, an instance of GenericParamSparseMatrixCSC inherits from AbstractMatrix{<:SparseMatrixCSC{Tv,Ti} rather than AbstractVector{<:SparseMatrixCSC{Tv,Ti}, but should conceptually be thought as an AbstractVector{<:SparseMatrixCSC{Tv,Ti}.

source
GridapROMs.ParamDataStructures.GenericParamSparseMatrixCSRType
struct GenericParamSparseMatrixCSR{Bi,Tv,Ti<:Integer} <: ParamSparseMatrixCSR{Bi,Tv,Ti}
  m::Int64
  n::Int64
  rowptr::Vector{Ti}
  colval::Vector{Ti}
  data::Vector{Tv}
  ptrs::Vector{Ti}
end

Represents a vector of sparse matrices in CSR format, with entries stored non-consecutively in memory. For sake of coherence, an instance of GenericParamSparseMatrixCSR inherits from AbstractMatrix{<:SparseMatrixCSR{Bi,Tv,Ti} rather than AbstractVector{<:SparseMatrixCSR{Bi,Tv,Ti}, but should conceptually be thought as an AbstractVector{<:SparseMatrixCSR{Bi,Tv,Ti}.

source
GridapROMs.ParamDataStructures.HaltonSamplingType
struct HaltonSampling <: SamplingStyle
  start::Int
end

Sampling according to a Halton sequence

Note

Halton is a sequence, not a distribution, hence this sampling strategy repeats realizations since the draws are not randomized; to draw different parameters, one needs to provide a starting point in the sequence (start = 1 by default)

source
GridapROMs.ParamDataStructures.ParamArrayType
abstract type ParamArray{T,N} <: AbstractParamArray{T,N,Array{T,N}} end

Type representing parametric arrays of type A. Subtypes:

Also acts as a constructor according to the following rules:

  • ParamArray(A::AbstractArray{<:Number}) -> ParamNumber
  • ParamArray(A::AbstractArray{<:Number},plength::Int) -> TrivialParamArray
  • ParamArray(A::AbstractVector{<:AbstractArray}) -> ParamArray
  • ParamArray(A::AbstractVector{<:AbstractSparseMatrix}) -> ParamSparseMatrix
  • ParamArray(A::AbstractArray{<:ParamArray}) -> BlockParamArray
source
GridapROMs.ParamDataStructures.ParamFunctionType
struct ParamFunction{F,P} <: AbstractParamFunction{P}
  fun::F
  params::P
end

Representation of parametric functions with domain a parametric space. Given a function f : Ω₁ × ... × Ωₙ × D, where D is a ParamSpace, the evaluation of f in μ ∈ D returns the restriction of f to Ω₁ × ... × Ωₙ

source
GridapROMs.ParamDataStructures.ParamSpaceType
struct ParamSpace{P<:AbstractVector{<:AbstractVector},S<:SamplingStyle} <: AbstractSet{Realization}
  param_domain::P
  sampling_style::S
end

Fields:

  • param_domain: domain of definition of the parameters
  • sampling_style: distribution on param_domain according to which we can sample the parameters (by default it is set to HaltonSampling)
source
GridapROMs.ParamDataStructures.RealizationType
struct Realization{P<:AbstractVector} <: AbstractRealization
  params::P
end

Represents standard parametric realizations, i.e. samples extracted from a given parameter space. The field params is most commonly a vector of vectors. When the parameters are scalars, they still need to be defined as vectors of vectors of unit length. In other words, we treat the case in which params is a vector of numbers as the case in which params is a vector of one vector.

source
GridapROMs.ParamDataStructures.TransientParamFunctionType
struct TransientParamFunction{F,P,T} <: AbstractParamFunction{P}
  fun::F
  params::P
  times::T
end

Representation of parametric functions with domain a transient parametric space. Given a function f : Ω₁ × ... × Ωₙ × D × [t₁,t₂], where [t₁,t₂] is a temporal domain and D is a ParamSpace, or equivalently f : Ω₁ × ... × Ωₙ × D × [t₁,t₂], where D is a TransientParamSpace, the evaluation of f in (μ,t) ∈ D × [t₁,t₂] returns the restriction of f to Ω₁ × ... × Ωₙ

source
GridapROMs.ParamDataStructures.TransientParamSpaceType
struct TransientParamSpace{P<:ParamSpace,T} <: AbstractSet{TransientRealization}
  parametric_space::P
  temporal_domain::T
end

Fields:

  • parametric_space: underlying parameter space
  • temporal_domain: underlying temporal space

It represents, in essence, the set of tuples (p,t) in parametric_space × temporal_domain

source
GridapROMs.ParamDataStructures.TransientRealizationType
abstract type TransientRealization{P<:Realization,T<:Real} <: AbstractRealization end

Represents temporal parametric realizations, i.e. samples extracted from a given parameter space for every time step in a temporal range. The most obvious application of this type are transient PDEs, where an initial condition is given. Following this convention, the initial time instant is kept separate from the other time steps.

source
GridapROMs.ParamDataStructures.TransientRealizationAtType
struct TransientRealizationAt{P,T} <: TransientRealization{P,T}
  params::P
  t::Base.RefValue{T}
end

Represents a GenericTransientRealization{P,T} at a certain time instant t. To avoid making it a mutable struct, the time instant t is stored as a Base.RefValue{T}.

source
GridapROMs.ParamDataStructures.find_param_lengthMethod
find_param_length(a...) -> Int

Returns the parametric length of all parametric quantities. An error is thrown if there are no parametric quantities or if at least two quantities have different parametric length

source
GridapROMs.ParamDataStructures.get_param_entryMethod
get_param_entry(A::AbstractParamArray{T},i...) where T -> Vector{eltype(T)}

Returns a vector of the entries of A at index i, for every parameter. The length of the output is equals to param_length(A)

source
GridapROMs.ParamDataStructures.parameterizeMethod
parameterize(a,plength::Integer) -> Any

Returns a quantity with parametric length plength from a. When a already possesses a parametric length, i.e. it is a parametrized quantity, it returns a

source
GridapROMs.ParamDataStructures.parameterizeMethod
parameterize(f::Function,r::Realization) -> ParamFunction
parameterize(f::Function,r::TransientRealization) -> TransientParamFunction

Method that parameterizes an input quantity by a realization r

source
GridapROMs.ParamDataStructures.realizationMethod
realization(p::ParamSpace;nparams=1,sampling=get_sampling_style(p),kwargs...) -> Realization
realization(p::TransientParamSpace;nparams=1,sampling=get_sampling_style(p),kwargs...) -> TransientRealization

Extraction of a set of nparams parameters from a given parametric space, by default according to the sampling strategy specified in p.

source
GridapROMs.ParamDataStructures.space_dofsMethod
space_dofs(s::SteadySnapshots{T,N}) where {T,N} -> NTuple{N-1,Integer}
space_dofs(s::TransientSnapshots{T,N}) where {T,N} -> NTuple{N-2,Integer}

Returns the spatial size of the snapshots

source