Solution Strategy

All physics solvers share a common solution strategy for nonlinear time-dependent problems. Here, we briefly describe the nonlinear solver and the timestepping strategy employed.

Nonlinear Solver

At each time-step, the nonlinear system of discrete residual equations, i.e.

$r(x) = 0$

is solved by employing the Newton-Raphson method. Here, $x$ is the vector of primary unknowns. Thus, each physics solver is responsible for assembling the Jacobian matrix $J$ containing the analytical derivatives of the residual vector $r$ with respect to the primary variables. Then, at each Newton iteration $\nu$ , the following linear system is solved

$J^{\nu} \delta x^{\nu+1} = -r^{\nu},$

where, $\delta x^{\nu+1}$ is the Newton update. This linear system can be solved with a variety of different linear solvers described in Linear Solvers. The Newton update, $\delta x^{\nu+1}$ is then applied to the primary variables:

$x^{\nu+1} = x^{\nu} + \delta x^{\nu+1}.$

This procedure is repeated until convergence is achieved or until the maximum number of iterations is reached.

Line Search

A line search method can be applied along with the Newton’s method to facilitate Nonlinear convergence. After the Newton update, if the residual norm has increased instead of decreased, a line search algorithm is employed to correct the Newton update.

The user can choose between two different behaviors in case the line search fails to provide a reduced residual norm:

accept the solution and move to the next Newton iteration;
reject the solution and request a timestep cut;

Timestepping Strategy

The actual timestep size employed is determined by a combination of several factors. In particular, specific output events may have timestep requirements that force a specific timestep to be used. However, physics solvers do have the possibility of requesting a specific timestep size to the event manager based on their specific requirements. In particular, in case of fast convergence indicated by a small number of Newton iterations, i.e.

$\text{numIterations} < \text{dtIncIterLimit} \cdot \text{newtonMaxIter},$

the physics solver will require to double the timestep size. On the other hand, if a large number of nonlinear iterations are necessary to find the solution at timestep $n$

$\text{numIterations} > \text{dtCutIterLimit} \cdot \text{newtonMaxIter},$

the physics solver will request the next timestep, $n+1$ , to be half the size of timestep $n$ . Here,

Additionally, in case the nonlinear solver fails to converge with the timestep provided by the event manager, the timestep size is cut, i.e.

$\text{dt} = \text{timestepCutFactor} \cdot \text{dt},$

and the nonlinear loop is repeated with the new timestep size.

Parameters

All parameters defining the behavior of the nonlinear solver and determining the timestep size requested by the physics solver are defined in the NonlinearSolverParameters and are presented in the following table.

Name	Type	Default	Description
allowNonConverged	integer	0	Allow non-converged solution to be accepted. (i.e. exit from the Newton loop without achieving the desired tolerance)
couplingType	geos_NonlinearSolverParameters_CouplingType	FullyImplicit	Type of coupling. Valid options: * FullyImplicit * Sequential
lineSearchAction	geos_NonlinearSolverParameters_LineSearchAction	Attempt	How the line search is to be used. Options are: * None - Do not use line search. * Attempt - Use line search. Allow exit from line search without achieving smaller residual than starting residual. * Require - Use line search. If smaller residual than starting resdual is not achieved, cut time step.
lineSearchCutFactor	real64	0.5	Line search cut factor. For instance, a value of 0.5 will result in the effective application of the last solution by a factor of (0.5, 0.25, 0.125, …)
lineSearchInterpolationType	geos_NonlinearSolverParameters_LineSearchInterpolationType	Linear	Strategy to cut the solution update during the line search. Options are: * Linear * Parabolic
lineSearchMaxCuts	integer	4	Maximum number of line search cuts.
lineSearchStartingIteration	integer	0	Iteration when line search starts.
logLevel	integer	0	Log level
maxAllowedResidualNorm	real64	1e+09	Maximum value of residual norm that is allowed in a Newton loop
maxNumConfigurationAttempts	integer	10	Max number of times that the configuration can be changed
maxSubSteps	integer	10	Maximum number of time sub-steps allowed for the solver
maxTimeStepCuts	integer	2	Max number of time step cuts
minNormalizer	real64	1e-12	Value used to make sure that residual normalizers are not too small when computing residual norm.
newtonMaxIter	integer	5	Maximum number of iterations that are allowed in a Newton loop.
newtonMinIter	integer	1	Minimum number of iterations that are required before exiting the Newton loop.
newtonTol	real64	1e-06	The required tolerance in order to exit the Newton iteration loop.
nonlinearAccelerationType	geos_NonlinearSolverParameters_NonlinearAccelerationType	None	Nonlinear acceleration type for sequential solver.
normType	geos_solverBaseKernels_NormType	Linfinity	Norm used by the flow solver to check nonlinear convergence. Valid options: * Linfinity * L2
sequentialConvergenceCriterion	geos_NonlinearSolverParameters_SequentialConvergenceCriterion	ResidualNorm	Criterion used to check outer-loop convergence in sequential schemes. Valid options: * ResidualNorm * NumberOfNonlinearIterations * SolutionIncrements
subcycling	integer	0	Flag to decide whether to iterate between sequentially coupled solvers or not.
timeStepCutFactor	real64	0.5	Factor by which the time step will be cut if a timestep cut is required.
timeStepDecreaseFactor	real64	0.5	Factor by which the time step is decreased when the number of Newton iterations is large.
timeStepDecreaseIterLimit	real64	0.7	Fraction of the max Newton iterations above which the solver asks for the time-step to be decreased for the next time step.
timeStepIncreaseFactor	real64	2	Factor by which the time step is increased when the number of Newton iterations is small.
timeStepIncreaseIterLimit	real64	0.4	Fraction of the max Newton iterations below which the solver asks for the time-step to be increased for the next time step.