Skip to content

Multistep schemes ​

The multistep classes compute the solution at the new step from the solutions at Ns previous steps. They extend integrator_multistep_object (the multistep Runge-Kutta SSP class extends integrator_multistage_multistep_object) and store the previous steps in their members previous(1:steps), with times t(1:steps) and time steps Dt(1:steps). The first Ns steps must be provided by the caller (start-up), then integrate(U, Dt, t) shifts them by itself if autoupdate is .true. (the default); t is the time of the last stored step. See the quick start for a complete start-up loop.

Below, Un+s denotes the solution at the step n+s and Rn+s=R(tn+s,Un+s). The value of Δt is always provided by the caller; all the schemes but the variable step size LMM-SSP require a constant Δt.

Adams-Bashforth ​

Class adams_bashforth (integrator_adams_bashforth), explicit, schemes adams_bashforth_1 ... adams_bashforth_16, of order Ns equal to the number of steps [7, 12]:

Un+Ns=Un+Ns−1+Δt∑s=1NsbsRn+s−1

adams_bashforth_1 is the forward Euler scheme. The first coefficients are:

Schemeb1b2b3b4
adams_bashforth_11
adams_bashforth_2−1232
adams_bashforth_3512−16122312
adams_bashforth_4−9243724−59245524

Adams-Moulton ​

Class adams_moulton (integrator_adams_moulton), implicit, schemes adams_moulton_0 ... adams_moulton_15, of order Ns+1 [7, 12]:

Un+Ns=Un+Ns−1+Δt[∑s=0Ns−1bsRn+s+bNsR(tn+Ns,Un+Ns)]

The implicit equation is solved by fixed point iterations, their number given by the iterations argument (default 1): each iteration evaluates the residual at the last iterate of Un+Ns, starting from the value of U passed to integrate. adams_moulton_0 is the implicit backward Euler scheme, 1st order, Un+1=Un+ΔtR(tn+1,Un+1), with Un stored in the single register of the previous steps; at least one fixed point iteration is always performed.

Schemeb0b1b2b3
adams_moulton_01
adams_moulton_11212
adams_moulton_2−112812512
adams_moulton_3124−5241924924

Fixed point iterations converge only if Δt is small with respect to the Lipschitz constant of R: on stiff problems they impose a step restriction comparable to the one of an explicit scheme.

Adams-Bashforth-Moulton ​

Class adams_bashforth_moulton (integrator_adams_bashforth_moulton), predictor-corrector, schemes adams_bashforth_moulton_1 ... adams_bashforth_moulton_16. The scheme of number N predicts with the Adams-Bashforth scheme of N steps and corrects with the Adams-Moulton scheme of N−1 steps, both of order N:

Un+N,p=Un+N−1+Δt∑s=1NbspRn+s−1Un+N=Un+N−1+Δt[∑s=0N−2bscRn+s+1+bN−1cR(tn+N,Un+N,p)]

adams_bashforth_moulton_1 is AB(1)-AM(0), forward Euler predictor and backward Euler corrector, 1st order. The iterations argument (default 1) sets the corrector iterations.

Backward Differentiation Formula ​

Class back_df (integrator_back_df), implicit, schemes back_df_1 ... back_df_6, of order Ns:

Un+Ns+∑s=1NsαsUn+Ns−s=ΔtβR(tn+Ns,Un+Ns)

solved by fixed point iterations (iterations, default 1). back_df_1 is the backward Euler scheme.

Stepsβα1α2α3α4α5α6
11−1
223−4313
3611−1811911−211
41225−48253625−1625325
560137−300137300137−20013775137−12137
660147−360147450147−400147225147−7214710147

The BDF schemes are designed for stiff problems, but their stability advantage requires a Newton-like solver of the implicit equation: with fixed point iterations the step is limited as for the Adams-Moulton schemes.

Leapfrog ​

Class leapfrog (integrator_leapfrog), explicit, 2 steps [4]:

Un+2=Un+2ΔtRn+1

The scheme leapfrog is 2nd order accurate, but it is unstable on dissipative problems (its spurious computational mode is amplified): use it for oscillatory, non dissipative problems.

The scheme leapfrog_raw applies the Robert-Asselin-Williams (RAW) filter [5, 6, 20, 21] after each step:

Δ=ν2(Un−2Un+1+Un+2)Un+1←Un+1+αΔUn+2←Un+2+(α−1)Δ

with ν∈(0,1] and α∈(0.5,1], defaults ν=0.01 and α=0.53, set by the nu and alpha arguments. For α=1 the filter reverts to the classic Robert-Asselin filter.

Order of accuracy

With a fixed filter coefficient ν, leapfrog_raw is formally 1st order accurate, as the tests suite measures. The "3rd order accuracy" of Williams (2011) refers to the accuracy of the amplitude of the oscillations, not to the order of the global error.

Linear multistep SSP ​

Class lmm_ssp (integrator_lmm_ssp), explicit, Strong Stability Preserving [16]:

Un+Ns=∑s=1Ns[asUn+s−1+ΔtbsRn+s−1]
SchemeOrderNon-zero coefficients
lmm_ssp_steps_3_order_22a1=14, a3=34, b3=32
lmm_ssp_steps_4_order_33a1=1127, a4=1627, b1=1227, b4=169
lmm_ssp_steps_5_order_33a1=732, a5=2532, b1=516, b5=2516

Linear multistep SSP with variable step size ​

Class lmm_ssp_vss (integrator_lmm_ssp_vss), explicit, SSP, the time step can change from step to step [17]. With

ωi=Δtn+iΔtn+Ns,Ωs=∑i=1sωi,1≤s≤Ns

the 2nd order formula is

Un+Ns=1ΩNs−12Un+ΩNs−12−1ΩNs−12Un+Ns−1+ΩNs−1+1ΩNs−1Δtn+NsR(Un+Ns−1)

and the 3rd order one is

Un+Ns=3ΩNs−1+2ΩNs−13Un+(ΩNs−1+1)2(ΩNs−1−2)ΩNs−13Un+Ns−1+ΩNs−1+1ΩNs−12Δtn+NsR(Un)+(ΩNs−1+1)2ΩNs−12Δtn+NsR(Un+Ns−1)
SchemeOrder
lmm_ssp_vss_steps_2_order_22
lmm_ssp_vss_steps_3_order_22
lmm_ssp_vss_steps_3_order_33
lmm_ssp_vss_steps_4_order_33
lmm_ssp_vss_steps_5_order_33

Multistep Runge-Kutta SSP ​

Class ms_runge_kutta_ssp (integrator_ms_runge_kutta_ssp), explicit, multistep-multistage, SSP [18]. With k steps and s stages:

y1n=unyin=∑l=1kdilun−k+l+Δt∑l=1k−1a^ilR(un−k+l)+Δt∑j=1i−1aijR(yjn),2≤i≤sun+1=∑l=1kθlun−k+l+Δt∑l=1k−1b^lR(un−k+l)+Δt∑j=1sbjR(yjn)
SchemeStepsStagesOrder
ms_runge_kutta_ssp_steps_2_stages_2_order_3223
ms_runge_kutta_ssp_steps_3_stages_2_order_3323
ms_runge_kutta_ssp_steps_4_stages_5_order_8458

The coefficients are in the source, foodie_integrator_ms_runge_kutta_ssp.F90. The 8th order of the last scheme is verified by the polynomial exactness test and observed on the Riccati problem, but it is beyond the orders the convergence test can assert in double precision (see Testing).

The references are numbered as in the bibliography of the catalogue.

Released under the GPL v3, BSD 2-Clause, BSD 3-Clause and MIT licenses.