File imex-bdf2.hxx#

class IMEXBDF2 : public Solver#
#include <imex-bdf2.hxx>

IMEX-BDF2 time integration solver

Scheme taken from this paper:

W.Hundsdorfer, S.J.Ruuth “IMEX extensions of linear multistep methods with general

monotonicity and boundedness properties” JCP 225 (2007) 2016-2042

The method has been extended to variable order, variable timestep, and includes some adaptive capabilities

Public Functions

explicit IMEXBDF2(Options *opt = nullptr)#
inline virtual BoutReal getCurrentTimestep() override#

Returns the current internal timestep.

virtual int init() override#

Initialise solver. Must be called once and only once.

Initialisation routine. Called once before solve.

virtual int run() override#

Run the simulation.

PetscErrorCode snes_function(Vec x, Vec f, bool linear)#

Nonlinear function. This is called by PETSc SNES object via a static C-style function. For implicit time integration this function calculates:

f = (x - gamma*G(x)) - rhs

  • x[in] The state vector

  • f[out] The vector for the result f(x)

  • linear[in] Specifies that the SNES solver is in a linear (KSP) inner loop, so the operator should be linearised if possible

PetscErrorCode precon(Vec x, Vec f)#

Preconditioner. Called by PCapply via a C-style static function.

  • x[in] The vector to be operated on

  • f[out] The result of the operation

Private Functions

void take_step(BoutReal curtime, BoutReal dt, int order = 2)#

Take a full step at requested order

Take a full IMEX-BDF step of order “order”. Note that this assumes that enough time points are already available (in u and f).

Inputs: u* - Solution history f* - Non-stiff component history

Outputs: u - Latest Solution f1 - Non-stiff time derivative at current time

  • curtime[in] The current simulation time

  • dt[in] The time step to take

  • order[in] The order of accuracy

void constructSNES(SNES *snesIn)#

Setup a SNES object This includes creating, setting functions, options, and internal (KSP) solver, and Jacobian options including coloring.

void shuffleState()#

Shuffle state along one step.

void calculateCoeffs(int order)#

Populate the *Fac vectors and dtImp with appropriate coefficients for this order.

PetscErrorCode solve_implicit(BoutReal curtime, BoutReal gamma)#
template<class Op>
void loopVars(BoutReal *u)#

Loop over arrays, using template parameter to specify the operation to be performed at each point

void saveVars(BoutReal *u)#

Save variables from BOUT++ fields into a pre-allocated array u

Copy data from fields into array

void loadVars(BoutReal *u)#

Load variables from input vector u into BOUT++ fields.

Copy data from array into fields

void saveDerivs(BoutReal *u)#

Save time derivatives from ddt() fields into a preallocated array u.

Copy time derivatives from fields into array

Private Members

int maxOrder#

Specify the maximum order of the scheme to use (1/2/3)

BoutReal timestep#

The internal timestep.

int ninternal#

Number of internal steps per output.

int mxstep#

Maximum number of internal steps between outputs.

bool adaptive#

Use adaptive timestepping?

int nadapt#

How often do we check the error.

int mxstepAdapt#

Maximum no. consecutive times we try to reduce timestep.

BoutReal scaleCushUp#

Don’t increase timestep if scale factor < 1.0+scaleCushUp.

BoutReal scaleCushDown#

Don’t decrease timestep if scale factor > 1.0-scaleCushDown.

BoutReal adaptRtol#

Target relative error for adaptivity.

BoutReal dtMax#

Maximum timestep we want to use.

BoutReal dtMinFatal#

If timestep wants to drop below this we abort. Set -ve to deactivate

BoutReal dtMin#

Minimum timestep we want to use.

bool matrix_free#

Default is matrix free.

bool use_coloring#

Use matrix coloring.

BoutReal atol#

Absolute tolerance.

BoutReal rtol#

Relative tolerance.

int max_nonlinear_it#

Maximum number of nonlinear iterations per SNES solve.

int lag_jacobian#

How often to rebuild Jacobian.

bool use_precon#

Use preconditioner.

bool kspsetinitialguessnonzero#

Set initial guess non-zerp.

int maxl#

Maximum number of iterations.

std::vector<BoutReal> uFac#

Scheme coefficients.

std::vector<BoutReal> fFac#
std::vector<BoutReal> gFac#
BoutReal dtImp#
int nlocal#
int neq#

Number of variables on local processor and in total.

Array<BoutReal> u#

System state at current time.

std::vector<Array<BoutReal>> uV#

The solution history.

std::vector<Array<BoutReal>> fV#

The non-stiff solution history.

std::vector<BoutReal> timesteps#

Timestep history.

Array<BoutReal> rhs#
Array<BoutReal> err#
BoutReal implicit_gamma = {0.0}#
BoutReal implicit_curtime = {0.0}#
int predictor#

Predictor method.

PetscLib lib#

Handles initialising, finalising PETSc.

Vec snes_f = {nullptr}#

Used by SNES to store function.

Vec snes_x = {nullptr}#

Result of SNES.

SNES snes = {nullptr}#

SNES context.

SNES snesAlt = {nullptr}#

Alternative SNES object for adaptive checks.

SNES snesUse{nullptr}#

The snes object to use in solve stage. Allows easy switching.

Mat Jmf = {nullptr}#

Matrix-free Jacobian.

bool diagnose#

Output diagnostics every timestep.

bool verbose#

Gives a more verbose output for each timestep.

int linear_fails#

Number of linear (KSP) convergence failures.

int nonlinear_fails#

Numbef of nonlinear (SNES) convergence failures.

bool have_constraints#

Are there any constraint variables?

Array<BoutReal> is_dae#

If using constraints, 1 -> DAE, 0 -> AE.

MatFDColoring fdcoloring#

Matrix coloring context, used for finite difference Jacobian evaluation

Private Static Attributes

static constexpr int MAX_SUPPORTED_ORDER = 4#