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 RBTransient

Extension of RBSteady to transient parametric PDEs. Snapshots span space and time, and so do reduced bases and hyper-reductions. Main building blocks:

source
GridapROMs.RBTransient.KroneckerReduction — Type
struct KroneckerReduction{A,B} <: TransientReduction{A,B}
  reductions::AbstractVector{<:Reduction}
end

Wrapper for reduction methods in high order problems, such as transient ones. The reduced subspaces are constructed as Kronecker product spaces

source
GridapROMs.RBTransient.ODERBParamVector — Type
struct ODERBParamVector{T,A<:RBParamVector{T},B<:Tuple{Vararg{RBParamVector{T}}}} <: ParamArray{T,1}
  data::A
  data0::B
end

Solution of a transient reduced problem, data, together with its initial conditions data0

source
GridapROMs.RBTransient.SequentialReduction — Type
struct SequentialReduction{A,B} <: TransientReduction{A,B}
  reduction::Reduction{A,B}
end

Wrapper for sequential reduction methods in high-order problems, e.g. TT-SVD in transient applications

source
GridapROMs.RBTransient.SpaceTimeParamOperator — Type
struct SpaceTimeParamOperator <: NonlinearParamOperator
  op::ODEParamOperator
  r::TransientRealisation
  usx::Tuple{Vararg{AbstractParamVector}}
  ws::Tuple{Vararg{Real}}
  paramcache::AbstractParamCache
end

Transient reduced operator op evaluated at r, seen as a single (space-time) nonlinear operator

source
GridapROMs.RBTransient.TimeAffineHyperReduction — Type
struct TimeAffineHyperReduction{A,R<:HyperReduction{A}} <: TransientHyperReduction{A}
  reduction::R
  combination::TimeCombination
end

Hyper-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.
source
GridapROMs.RBTransient.TimeMarchingReduction — Type
struct TimeMarchingReduction{A,B} <: TransientReduction{A,B}
  reduction::Reduction{A,B}
end

Wrapper 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.

source
GridapROMs.RBTransient.TransientAffineHyperReduction — Type
struct TransientAffineHyperReduction <: TransientTrivialHyperReduction 
  combination::TimeCombination
end

Reduction 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.

source
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.
source
GridapROMs.RBTransient.TransientHyperReduction — Type
abstract type TransientHyperReduction{A} <: HyperReduction{A} end

Hyper-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.

source
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:

When compression=:local, this dispatches to TransientLocalHyperReduction with the selected strategy.

source
GridapROMs.RBTransient.TransientInterpolation — Type
struct TransientInterpolation{A,B,C} <: Interpolation
  style::A
  interp_space::B
  indices_time::C
end

Space-time interpolation: a spatial interpolation interp_space, and the selected time steps indices_time

source
GridapROMs.RBTransient.TransientNoHyperReduction — Type
struct TransientNoHyperReduction <: TransientTrivialHyperReduction 
  combination::TimeCombination
end

Reduction 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

source
GridapROMs.RBTransient.TransientProjection — Type
struct TransientProjection{A<:Projection,B<:AbstractArray} <: Projection
  projection_space::A
  array_time::B
end

Space-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 spatial Projection.
  • get_basis_space(a) / get_basis_time(a): retrieve the spatial basis / the temporal array.
source
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 (default PHS()).
source
GridapROMs.RBTransient.TransientReduction — Type
abstract type TransientReduction{A<:ReductionStyle,B<:AssembleOperator} <: Reduction{A,B} end

Abstract supertype for reduction methods in high-order (e.g. transient) parametric problems.

Concrete subtypes:

  • TimeMarchingReduction — wraps a steady Reduction; 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.

source
GridapROMs.RBTransient.time_enrichment — Method
time_enrichment(basis_primal::AbstractMatrix,basis_dual::AbstractMatrix;tol=1e-2) -> AbstractMatrix

Temporal supremizer enrichment. (Approximate) Procedure:

  1. for every b_dual ∈ Col(basis_dual)
  2. compute Φ_primal_dual = basis_primal'*b_dual
  3. compute v = kernel(Φ_primal_dual)
  4. compute v′ = orth_complement(v,basis_primal)
  5. enrich basis_primal = [basis_primal,v′]
source
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.

source