OGS
ODE Solver Library

## Detailed Description

This ODE solver library has been designed with an implicit first-order quasilinear ODE in mind. However, it is in principle not restricted to such a kind of equation, but can be extended to also solve other equation types. In particular it is possible to introduce equation types that are no ODEs, but are nonlinear equations without time derivative terms.

The aim of the library's design is being able to formulate FEM processes without having to care which time discretization scheme and which nonlinear iteration method will be used to solve it.

The library offers different time discretization schemes, cf. the conceputal remarks on them, namely the forward and backward Euler and Crank-Nicolson methods and Backward Differentiation Formulas. The design follows Gear's method, which also underlies the DASSL algorithm of Petzold et al., cf. Differential-algebraic equations article, section [Numerical methods/Direct discretization] (http://www.scholarpedia.org/article/Differential-algebraic_equations#Numerical_methods.2FDirect_discretization) [8].

A rough overview over the interplay between the various parts of this library is given in the image below. Therein red symbols indicate which classes own which matrices or vectors (for the meaning of the different symbols refer to the documentation of the respective classes). The word own should not be taken too strict in the sense of C++ member ownership, although currently it is implemented as such; but in the future this implementation detail might change. Rather own means that the class is in charge of the respective matrix or vector, i.e., it can read from and write to it or pass it on to functions; or in other words: The class knows about the meaning of that matrix/vector. Note that only matrices and vectors that describe some proper state of the respective classes are shown; those storing only intermediate computations have been omitted from the image.

Interplay of the different parts of the ODE

solver library at the example of a first-order implicit quasilinear ODE."@image latex ode-solver-concept.pdf "Interplay of the different parts of the ODE solver library at the example of a first-order implicit quasilinear ODE." In the ODE solver library the instances of some classes can work together with several instances of other classes throughout there lifetime, whereas they have a strict one-to-one correspondence to objects of some different type. Those relations are given in the following table. <table class="markdownTable"> <tr class="markdownTableHead"> <th class="markdownTableHeadRight"> Class 1

Class 2

Relation

Remarks

1:1

the ODESystem

represents part of the state of the TimeDiscretizedODESystem TimeDiscretizedODESystem | TimeDiscretization | 1:1 | analogous for the TimeDiscretization TimeDiscretizedODESystem | MatrixTranslator | 1:1 | analogous for the MatrixTranslator NonlinearSolver | NonlinearSystem | 1:n | a nonlinear solver can solve various equations, one after the other LinearSolver | NonlinearSolver | 1:n | various NonlinearSolver's can share the same LinearSolver

## Enumerations

enum class  NumLib::IterationResult : char { NumLib::IterationResult::SUCCESS , NumLib::IterationResult::FAILURE , NumLib::IterationResult::REPEAT_ITERATION }
Status flags telling the NonlinearSolver if an iteration succeeded. More...

enum class  NumLib::NonlinearSolverTag : bool { NumLib::NonlinearSolverTag::Picard , NumLib::NonlinearSolverTag::Newton }
Tag used to specify which nonlinear solver will be used. More...

enum class  NumLib::ODESystemTag : char { NumLib::ODESystemTag::FirstOrderImplicitQuasilinear , NumLib::ODESystemTag::NeumannBC }
Tag used to specify the type of ODE. More...

## Functions

template<ODESystemTag ODETag>
std::unique_ptr< MatrixTranslator< ODETag > > NumLib::createMatrixTranslator (TimeDiscretization const &timeDisc)

std::pair< std::unique_ptr< NonlinearSolverBase >, NonlinearSolverTagNumLib::createNonlinearSolver (GlobalLinearSolver &linear_solver, BaseLib::ConfigTree const &config)

## ◆ IterationResult

 enum class NumLib::IterationResult : char
strong

Status flags telling the NonlinearSolver if an iteration succeeded.

Enumerator
SUCCESS
FAILURE
REPEAT_ITERATION

Definition at line 21 of file EquationSystem.h.

## ◆ NonlinearSolverTag

 enum class NumLib::NonlinearSolverTag : bool
strong

Tag used to specify which nonlinear solver will be used.

Enumerator
Picard

Picard fixpoint iteration scheme

Newton

Newton-Raphson iteration scheme

Definition at line 19 of file Types.h.

20{
21 Picard ,
22 Newton
23};

## ◆ ODESystemTag

 enum class NumLib::ODESystemTag : char
strong

Tag used to specify the type of ODE.

Enumerator
FirstOrderImplicitQuasilinear

First order implicit quasi-linear ODE

This is an ODE of the form $$M(x,t)\cdot \dot x + K(x,t) \cdot x - b(x,t) =: r(\dot x, x, t) \stackrel{!}{=} 0$$

NeumannBC

Definition at line 26 of file Types.h.

27{
35 NeumannBC // Sure, that's misuse of this enum, so sue me!
36};

## ◆ createMatrixTranslator()

template<ODESystemTag ODETag>
 std::unique_ptr< MatrixTranslator< ODETag > > NumLib::createMatrixTranslator ( TimeDiscretization const & timeDisc )

Creates a GlobalMatrix translator suitable to work together with the given time discretization scheme.

Definition at line 129 of file MatrixTranslator.h.

131{
132 return std::unique_ptr<MatrixTranslator<ODETag>>(
133 new MatrixTranslatorGeneral<ODETag>(timeDisc));
134}

## ◆ createNonlinearSolver()

 std::pair< std::unique_ptr< NonlinearSolverBase >, NonlinearSolverTag > NumLib::createNonlinearSolver ( GlobalLinearSolver & linear_solver, BaseLib::ConfigTree const & config )

Creates a new nonlinear solver from the given configuration.

Parameters
 linear_solver the linear solver that will be used by the nonlinear solver config configuration settings
Returns
a pair (nl_slv, tag) where nl_slv is the generated nonlinear solver instance and the tag indicates if it uses the Picard or Newton-Raphson method
Input File Parameter:
prj__nonlinear_solvers__nonlinear_solver__type
Input File Parameter:
prj__nonlinear_solvers__nonlinear_solver__max_iter
Input File Parameter:
prj__nonlinear_solvers__nonlinear_solver__damping
Input File Parameter:
prj__nonlinear_solvers__nonlinear_solver__prefix

Definition at line 437 of file NonlinearSolver.cpp.

439{
441 auto const type = config.getConfigParameter<std::string>("type");
443 auto const max_iter = config.getConfigParameter<int>("max_iter");
444
445 if (type == "Picard")
446 {
447 auto const tag = NonlinearSolverTag::Picard;
448 using ConcreteNLS = NonlinearSolver<tag>;
449 return std::make_pair(
450 std::make_unique<ConcreteNLS>(linear_solver, max_iter), tag);
451 }
452 if (type == "Newton")
453 {
455 auto const damping = config.getConfigParameter<double>("damping", 1.0);
456 if (damping <= 0)
457 {
458 OGS_FATAL(
459 "The damping factor for the Newon method must be positive, got "
460 "{:g}.",
461 damping);
462 }
463 auto const tag = NonlinearSolverTag::Newton;
464 using ConcreteNLS = NonlinearSolver<tag>;
465 return std::make_pair(
466 std::make_unique<ConcreteNLS>(linear_solver, max_iter, damping),
467 tag);
468 }
469#ifdef USE_PETSC
470 if (boost::iequals(type, "PETScSNES"))
471 {
472 auto prefix =
474 config.getConfigParameter<std::string>("prefix", "");
475 auto const tag = NonlinearSolverTag::Newton;
476 using ConcreteNLS = PETScNonlinearSolver;
477 return std::make_pair(std::make_unique<ConcreteNLS>(
478 linear_solver, max_iter, std::move(prefix)),
479 tag);
480 }
481
482#endif
483 OGS_FATAL("Unsupported nonlinear solver type '{:s}'.", type.c_str());
484}
#define OGS_FATAL(...)
Definition: Error.h:26

Referenced by ProjectData::parseNonlinearSolvers().