File imex-bdf2.hxx

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

IMEX-BDF2 time integration solver

Scheme taken from this paper: http://homepages.cwi.nl/~willem/DOCART/JCP07.pdf

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

IMEXBDF2(Options *opt = nullptr)
~IMEXBDF2()
BoutReal getCurrentTimestep()

Returns the current internal timestep.

int init(int nout, BoutReal tstep)

Initialise solver. Must be called once and only once

Initialisation routine. Called once before solve.

Parameters
  • nout: Number of outputs
  • tstep: Time between outputs. NB: Not internal timestep

int run()

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

Parameters
  • x: The state vector
  • f: The vector for the result f(x)
  • linear: 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.

Parameters
  • x: The vector to be operated on
  • f: 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).

Parameters
  • curtime: The current simulation time
  • dt: The time step to take
  • order: The order of accuracy

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

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

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 out_timestep

The output timestep.

int nsteps

Number of output steps.

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 dtMin

Minimum timestep we want to use.

BoutReal dtMax

Maximum timestep we want to use.

BoutReal dtMinFatal

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

std::vector<BoutReal> uFac
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
BoutReal implicit_curtime
int predictor

Predictor method.

PetscLib lib

Handles initialising, finalising PETSc.

Vec snes_f

Used by SNES to store function.

Vec snes_x

Result of SNES.

SNES snes

SNES context.

SNES snesAlt

Alternative SNES object for adaptive checks.

SNES snesUse

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

Mat Jmf

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

const int MAX_SUPPORTED_ORDER = 4