GridapROMs.RBTransient
Reduced-basis infrastructure for transient parametric PDEs, extending RBSteady to the space–time setting.
Reduction methods
High-dimensional (transient) reduction methods extend the steady Reduction to handle the time dimension. The abstract supertype TransientReduction dispatches to one of three strategies depending on the arguments: TimeMarchingReduction, KroneckerReduction, and SequentialReduction.
Hyper-reduction methods
Transient hyper-reduction wraps a TransientReduction together with a TimeCombination that encodes the ODE time-marching coefficients. See TransientHyperReduction for details on how the θ-method (and higher-order schemes) lead to per-operator combination orders. Concrete subtypes include TransientDEIMHyperReduction, TransientSOPTHyperReduction, TransientRBFHyperReduction, and TimeAffineHyperReduction, for forms independent of time.
Bases construction
The tucker function computes a Tucker decomposition of multi-dimensional snapshot arrays.
Transient projections
TransientProjection stores a spatial projection and a temporal array for space–time reduced-basis problems: a basis for a KroneckerProjection, the last TT core for a SequentialProjection. TransientInterpolation TransientInterpolation provides the corresponding space–time interpolation.
Full API
GridapROMs.RBTransient — Module
module RBTransientExtension of RBSteady to transient parametric PDEs. Snapshots span space and time, and so do reduced bases and hyper-reductions. Main building blocks:
- Reduction methods (
ReductionMethods.jl) —TransientReduction, which builds aKroneckerReduction(space-time POD, a Kronecker product of spatial and temporal bases), aSequentialReduction(TT-SVD) or aTimeMarchingReduction(spatial reduction only, with time marching online); the correspondingTransientHyperReductions. - Projections (
Projections.jl,BasesConstruction.jl) —TransientProjection,KroneckerProjection,SequentialProjection. - Hyper-reduction (
HyperReductions.jl,Interpolations.jl) — space-time interpolation (TransientInterpolation), with time combinations of the time-marching scheme. - Reduced operators and solvers (
RBOperators.jl,RBSolvers.jl,SpaceTime.jl,ParamTimeMarching.jl) —TransientRBOperator, solved as a single space-time system (SpaceTimeSolver), or by time marching for steady reductions. - Post-processing and I/O (
PostProcess.jl,Diagnostics.jl).
GridapROMs.RBTransient.AffineContributionTuple — Type
const AffineContributionTuple = ContributionTuple{<:AffineContribution,T} where TConcrete (see ContributionTuple) replacement for what used to be a raw Tuple{Vararg{AffineContribution}} – one entry per time derivative order in unsteady settings.
GridapROMs.RBTransient.InterpolationStyle — Type
abstract type InterpolationStyle endStructure of a space-time interpolation. Subtypes:
GridapROMs.RBTransient.KroneckerProjection — Type
const KroneckerProjection{A<:Projection} = TransientProjection{A,<:AbstractMatrix}TransientProjection with a temporal basis. The space-time projection operator is equal to
basis_time ⊗ projection_space
which, for efficiency reasons, is never explicitly computed
GridapROMs.RBTransient.KroneckerReduction — Type
struct KroneckerReduction{A,B} <: TransientReduction{A,B}
reductions::AbstractVector{<:Reduction}
endWrapper for reduction methods in high order problems, such as transient ones. The reduced subspaces are constructed as Kronecker product spaces
GridapROMs.RBTransient.KroneckerStyle — Type
struct KroneckerStyle <: InterpolationStyle endSpace-time interpolation with independent spatial and temporal indices, as for a KroneckerProjection
GridapROMs.RBTransient.ODERBParamVector — Type
struct ODERBParamVector{T,A<:RBParamVector{T},B<:Tuple{Vararg{RBParamVector{T}}}} <: ParamArray{T,1}
data::A
data0::B
endSolution of a transient reduced problem, data, together with its initial conditions data0
GridapROMs.RBTransient.SequentialProjection — Type
const SequentialProjection{A<:Projection} = TransientProjection{A,<:AbstractArray{<:Any,3}}TransientProjection computed with a TT-SVD of the snapshots, whose temporal array is the last TT core. The reduced dimension is the rank of this core. Output of a SequentialReduction
GridapROMs.RBTransient.SequentialReduction — Type
struct SequentialReduction{A,B} <: TransientReduction{A,B}
reduction::Reduction{A,B}
endWrapper for sequential reduction methods in high-order problems, e.g. TT-SVD in transient applications
GridapROMs.RBTransient.SequentialStyle — Type
struct SequentialStyle <: InterpolationStyle endSpace-time interpolation with jointly selected space-time indices, as for a SequentialProjection
GridapROMs.RBTransient.SpaceTimeParamOperator — Type
struct SpaceTimeParamOperator <: NonlinearParamOperator
op::ODEParamOperator
r::TransientRealisation
usx::Tuple{Vararg{AbstractParamVector}}
ws::Tuple{Vararg{Real}}
paramcache::AbstractParamCache
endTransient reduced operator op evaluated at r, seen as a single (space-time) nonlinear operator
GridapROMs.RBTransient.SpaceTimeSolver — Type
struct SpaceTimeSolver{A<:ODESolver,B<:NonlinearSolver} <: NonlinearSolver
solver::A
us0::Tuple{Vararg{AbstractParamVector}}
endSolver of a SpaceTimeParamOperator, given the time-marching scheme solver and the initial conditions us0
GridapROMs.RBTransient.TimeAffineHyperReduction — Type
struct TimeAffineHyperReduction{A,R<:HyperReduction{A}} <: TransientHyperReduction{A}
reduction::R
combination::TimeCombination
endHyper-reduction of a form independent of time. Snapshots are computed at the first time step only, the temporal basis is constant, and the online assembly only occurs at the first time step. The form may still depend on the parameter.
Fields
reduction::R: the spatial hyper-reduction.combination::TimeCombination: time-marching combination.
GridapROMs.RBTransient.TimeMarchingReduction — Type
struct TimeMarchingReduction{A,B} <: TransientReduction{A,B}
reduction::Reduction{A,B}
endWrapper for steady reduction methods in high order problems, such as transient ones. In practice, the resulting ROM will still need to run the time marching scheme, since no temporal reduction occurs.
GridapROMs.RBTransient.TransientAffineHRContribution — Type
const TransientAffineHRContribution = AffineContribution{<:TransientAffineHRProjection}GridapROMs.RBTransient.TransientAffineHRContributionTuple — Type
const TransientAffineHRContributionTuple = ContributionTuple{<:TransientAffineHRContribution,T} where TGridapROMs.RBTransient.TransientAffineHyperReduction — Type
struct TransientAffineHyperReduction <: TransientTrivialHyperReduction
combination::TimeCombination
endReduction employed when transient reduced contributions are affine with parameter-independent (μ-independent) structure. As in the no-hyper-reduction case, this uses a single effective parameter sample (num_params = 1) for the hyper-reduction stage.
GridapROMs.RBTransient.TransientDEIMHyperReduction — Type
struct TransientDEIMHyperReduction{A,R<:Reduction{A,EuclideanNorm}} <: TransientHyperReduction{A}Transient hyper-reduction based on the Matrix Discrete Empirical Interpolation Method (DEIM). Combines a spatial TransientReduction with a TimeCombination encoding the ODE time-marching coefficients.
Fields
reduction::R: the underlying spatial reduction.combination::TimeCombination: time-marching combination.
GridapROMs.RBTransient.TransientHyperReduction — Type
abstract type TransientHyperReduction{A} <: HyperReduction{A} endHyper-reduction strategies employed in high-order (e.g. transient) problems.
Every concrete subtype stores a TimeCombination, which encodes the way an ODE time-marching scheme combines contributions from different time levels. See TimeCombination and CombinationOrder for the full treatment; here we summarise the key idea for the simplest case.
Theta method (first-order ODE)
Consider
\[M \dot{u}(t) + A\, u(t) = f(t).\]
The $\theta$-method reads
\[M \frac{u_{n+1} - u_n}{\Delta t} + \theta\, A\, u_{n+1} + (1-\theta)\, A\, u_n = f_{n+\theta},\]
which can be rewritten as the one-step scheme
\[\left( \frac{1}{\Delta t} M + \theta\, A \right) u_{n+1} = \left( \frac{1}{\Delta t} M - (1-\theta)\, A \right) u_n + f_{n+\theta}.\]
Within the ROM framework the two operators $A$ and $M$ are associated with distinct CombinationOrder indices (1 and 2 for a first-order problem). The TimeCombination object stores the scheme parameters ($\theta$, $\Delta t$, …) and the function get_coefficients returns the per-order weights that combine snapshots from successive time levels. Higher-order schemes (Newmark / Generalized-α) follow the same pattern with additional combination orders.
GridapROMs.RBTransient.TransientHyperReduction — Method
TransientHyperReduction(combination, args...; compression=:global, hypred_strategy=:deim, kwargs...)Factory for transient high-dimensional hyper-reduction strategies.
Supported hypred_strategy values:
:deim:sopt:rbf:none(aliases::no,:nohr) ->TransientNoHyperReduction:affine->TransientAffineHyperReduction:time_affine->TimeAffineHyperReduction
When compression=:local, this dispatches to TransientLocalHyperReduction with the selected strategy.
GridapROMs.RBTransient.TransientInterpolation — Type
struct TransientInterpolation{A,B,C} <: Interpolation
style::A
interp_space::B
indices_time::C
endSpace-time interpolation: a spatial interpolation interp_space, and the selected time steps indices_time
GridapROMs.RBTransient.TransientNoHyperReduction — Type
struct TransientNoHyperReduction <: TransientTrivialHyperReduction
combination::TimeCombination
endReduction employed when the input data is independent with respect to the considered realisation. Therefore, simply considering a number of parameters equal to 1 suffices for this type of reduction
GridapROMs.RBTransient.TransientProjection — Type
struct TransientProjection{A<:Projection,B<:AbstractArray} <: Projection
projection_space::A
array_time::B
endSpace-time projection, made of a spatial Projection and a temporal array: a basis for a KroneckerProjection, the last TT core for a SequentialProjection
Interface
get_projection_space(a): return the spatialProjection.get_basis_space(a)/get_basis_time(a): retrieve the spatial basis / the temporal array.
GridapROMs.RBTransient.TransientRBFHyperReduction — Type
struct TransientRBFHyperReduction{A,R<:Reduction{A,EuclideanNorm}} <: TransientHyperReduction{A}Transient hyper-reduction based on radial basis function (RBF) interpolation. In addition to the spatial TransientReduction and TimeCombination, it stores an AbstractRadialBasis strategy that governs the RBF kernel.
Fields
reduction::R: the underlying spatial reduction.combination::TimeCombination: time-marching combination.strategy::AbstractRadialBasis: radial basis function kernel (defaultPHS()).
GridapROMs.RBTransient.TransientRBFInterpolation — Type
const TransientRBFInterpolation{A} = RBFInterpolation{A}GridapROMs.RBTransient.TransientRBOperator — Type
const TransientRBOperator{O<:ODEParamOperatorType,A,B} = RBOperator{O,A,B}RBOperator of a transient problem. Its Jacobian lhs stores one hyper-reduction per time derivative
GridapROMs.RBTransient.TransientROMOperator — Type
const TransientROMOperator{O<:ODEParamOperatorType} = ROMOperator{O}Reduced operator of a transient problem
GridapROMs.RBTransient.TransientReduction — Type
abstract type TransientReduction{A<:ReductionStyle,B<:AssembleOperator} <: Reduction{A,B} endAbstract supertype for reduction methods in high-order (e.g. transient) parametric problems.
Concrete subtypes:
TimeMarchingReduction— wraps a steadyReduction; no temporal compression is applied (the ROM still time-steps).KroneckerReduction— builds a Kronecker (Tucker) product space from independent spatial and temporal reductions.SequentialReduction— uses TT-SVD (tensor-train) decomposition for the snapshot tensor.
Use the generic constructor TransientReduction(args...; kwargs...) to dispatch to the appropriate subtype based on the arguments.
GridapROMs.RBTransient.TransientSOPTHyperReduction — Type
struct TransientSOPTHyperReduction{A,R<:Reduction{A,EuclideanNorm}} <: TransientHyperReduction{A}Transient hyper-reduction based on the SOPT (Second-Order Proper Transformation) strategy. Stores a spatial TransientReduction and a TimeCombination.
Fields
reduction::R: the underlying spatial reduction.combination::TimeCombination: time-marching combination.
GridapROMs.RBTransient.TransientTrivialHyperReduction — Type
abstract type TransientTrivialHyperReduction <: TransientHyperReduction{NoReductionStyle} endTransient counterpart of TrivialHyperReduction
GridapROMs.RBTransient.TransientLocalHyperReduction — Method
TransientLocalHyperReduction(args...;ncentroids=10,kwargs...) -> LocalReductionLocal version of a TransientHyperReduction. See LocalReduction
GridapROMs.RBTransient.get_basis_space — Method
get_basis_space(a::Projection) -> AbstractMatrixSpatial basis of a
GridapROMs.RBTransient.get_basis_time — Method
get_basis_time(a::Projection) -> AbstractArrayTemporal array of a: a matrix, or a TT core for a SequentialProjection
GridapROMs.RBTransient.get_common_time_domain — Method
get_common_time_domain(a...) -> AbstractVector{Int}Union of the time steps selected by the hyper-reductions a
GridapROMs.RBTransient.get_indices_time — Method
get_indices_time(a::Interpolation) -> AbstractVector{Int}Time steps selected by the (space-time) hyper-reduction a
GridapROMs.RBTransient.get_interpolation_style — Method
get_interpolation_style(a::Interpolation) -> InterpolationStyleWhether a interpolates in space and time separately or jointly
GridapROMs.RBTransient.get_projection_space — Method
get_projection_space(a::Projection) -> ProjectionSpatial projection of a (a itself, if not transient)
GridapROMs.RBTransient.get_time_combination — Method
get_time_combination(r::TransientHyperReduction) -> TimeCombinationTime combination of the time-marching scheme associated with r
GridapROMs.RBTransient.space_contractions — Method
space_contractions(proj_left,a,proj_right) -> Tuple{Vararg{AbstractArray}}Spatial factors of the Galerkin projection of the SequentialProjection a
GridapROMs.RBTransient.time_enrichment — Method
time_enrichment(basis_primal::AbstractMatrix,basis_dual::AbstractMatrix;tol=1e-2) -> AbstractMatrixTemporal supremizer enrichment. (Approximate) Procedure:
- for every
b_dual ∈ Col(basis_dual) - compute
Φ_primal_dual = basis_primal'*b_dual - compute
v = kernel(Φ_primal_dual) - compute
v′ = orth_complement(v,basis_primal) - enrich
basis_primal = [basis_primal,v′]
GridapROMs.RBTransient.tucker — Method
tucker(red, A)
tucker(red, A, X...)Compute a Tucker decomposition of the multi-dimensional array A by sequentially applying a truncated POD (via tucker_loop) along each unfolding mode. The vector red provides a Reduction strategy for every mode (its length must equal ndims(A) - 1). When sparse matrices X are supplied they are used as inner-product weights for the corresponding modes.
Returns a Vector{Matrix{T}} of orthonormal basis matrices, one per mode.