GridapROMs.ParamSteady

GridapROMs.ParamSteady — Module
module ParamSteady

Parametric FE operators and solvers for steady parametric PDEs.

Extends Gridap's FEOperator/FESpaces layer with parameter awareness, so that residuals and Jacobians can be evaluated at a Realisation (a batch of parameter samples). The module introduces:

  • Operator types — LinearParamEq, NonlinearParamEq, LinearNonlinearParamEq tag whether a parametric operator is linear, nonlinear, or a split linear + nonlinear combination.
  • Low-level algebraic operators — ParamOperator, LinearParamOperator, LinearNonlinearParamOperator wrap assembled matrices/vectors and expose the residual!/jacobian! interface at parameter level.
  • FE-level operators — ParamFEOperator, LinearParamFEOperator manage Gridap assemblers, FE domains, and parameter-to-sample dispatch. A linear + nonlinear split operator is just a ParamFEOperator (O=LinearNonlinearParamEq) whose res/jac/domains fields are each a Bundle of the linear and nonlinear halves; get_linear_part/get_nonlinear_part split it back apart.
  • Solvers — thin wrappers in ParamFESolvers.jl dispatch parametric solves to the underlying Gridap / GridapSolvers linear or nonlinear solvers.

Downstream modules (ParamODEs, RBSteady, Extensions) all build on the abstractions defined here.

source
GridapROMs.ParamSteady.ParamFEOpFromWeakForm — Type
struct ParamFEOpFromWeakForm{O<:UnEvalOperatorType} <: ParamFEOperator{O}
  res::Union{Function,Bundle}
  jac::Union{Function,Bundle}
  pspace::ParamSpace
  assem::Assembler
  trial::FESpace
  test::FESpace
  domains::Union{FEDomains,Bundle}
end

Instance of ParamFEOperator, used for nonlinear (O=NonlinearParamEq), linear (O=LinearParamEq), and linear+nonlinear split (O=LinearNonlinearParamEq, res/jac/domains each a Bundle) steady problems alike

source
GridapROMs.ParamSteady.ParamFEOperator — Type
abstract type ParamFEOperator{O<:UnEvalOperatorType} <: FEOperator end

Parametric extension of a FEOperator in Gridap. Compared to a standard FEOperator, there are the following novelties:

  • a ParamSpace is provided, so that parametric realisations can be extracted directly from the ParamFEOperator
  • a function representing a norm matrix is provided, so that errors in the desired norm can be automatically computed

Subtypes:

source
GridapROMs.ParamSteady.ParamFEOperator — Method
ParamFEOperator(res::Bundle,jac::Bundle,pspace,trial,test,domains::Bundle=Bundle(FEDomains(),FEDomains())
  ) -> ParamFEOperator{LinearNonlinearParamEq}

Returns a parametric FE operator that bundles a linear and a nonlinear part

source
GridapROMs.ParamSteady.ParamOperator — Type
abstract type ParamOperator{O<:UnEvalOperatorType} <: NonlinearParamOperator end

Type representing algebraic operators when solving parametric differential problems

source
GridapROMs.ParamSteady.ParamOperator — Method
ParamOperator(res,jac,pspace,trial,test[,domains]) -> ParamOperator

Nonlinear parametric algebraic operator, built from the residual res(μ,u,v), the Jacobian jac(μ,u,du,v), a ParamSpace pspace, the trial and test spaces, and optionally the FEDomains on which res and jac are integrated. When res, jac and domains are Bundles, the operator is split into a linear part (written as in LinearParamOperator) and a nonlinear part

source
GridapROMs.ParamSteady.UnEvalOperatorType — Type
abstract type UnEvalOperatorType <: GridapType end

Type representing operators that are not evaluated yet. This may include operators representing transient problems (although the implementation in Gridap differs), parametric problems, and a combination thereof. Could become a supertype of ODEOperatorType in Gridap

source
GridapROMs.ParamSteady.LinearParamFEOperator — Method
LinearParamFEOperator(rhs::Function,jac::Function,pspace,trial,test,args...
  ) -> ParamFEOperator{LinearParamEq}

Returns a linear parametric FE operator. Unlike ParamFEOperator, which takes a residual res(μ,u,v), this takes the right-hand side rhs(μ,v) directly: a genuinely linear problem has no residual to evaluate at a current state u, only a (μ-dependent, but not u-dependent) jacobian and right-hand side. Assembling allocate_residual/residual! on the resulting operator therefore just assembles rhs(μ,v), and solving accounts for the sign accordingly (see ParamSolvers)

source
GridapROMs.ParamSteady.LinearParamOperator — Method
LinearParamOperator(rhs,jac,pspace,trial,test[,domains]) -> ParamOperator

Linear parametric algebraic operator, built from the right-hand side rhs(μ,v), the bilinear form jac(μ,du,v), a ParamSpace pspace, the trial and test spaces, and optionally the FEDomains on which rhs and jac are integrated

source
GridapROMs.ParamSteady.get_jac — Method
get_jac(op) -> Function

Jacobian of the operator op, as a function (μ,u,du,v) -> ... (with an additional time argument in transient problems)

source
GridapROMs.ParamSteady.get_param_space — Method
get_param_space(feop::ParamFEOperator) -> ParamSpace
get_param_space(feop::TransientParamFEOperator) -> TransientParamSpace

Returns the space of parameters contained in feop

source
GridapROMs.Utils.change_domains — Method
change_domains(op::ParamFEOperator,args...) -> ParamFEOperator

Changes the triangulations for residual/jacobian, keeping everything else unchanged

source
GridapROMs.Utils.get_linear_part — Method
get_linear_part(op::ParamFEOpFromWeakForm{LinearNonlinearParamEq}) -> ParamFEOpFromWeakForm{LinearParamEq}
get_nonlinear_part(op::ParamFEOpFromWeakForm{LinearNonlinearParamEq}) -> ParamFEOpFromWeakForm{NonlinearParamEq}

Splits a Bundle-based linear+nonlinear operator back into its two plainly-tagged halves

source
GridapROMs.Utils.set_domains — Method
set_domains(op::ParamFEOperator,args...) -> ParamFEOperator

A no-op: residual/jacobian assembly no longer depends on whether triangulations were explicitly tracked, so there is nothing left to "fix"

source