Time discretization

The spatially discretized Navier-Stokes equations form a differential-algebraic system, with an ODE for the velocity

\frac{d u}{d t} = F (u, t) - (G p + y_{G})

subject to the algebraic constraint formed by the mass equation

M u + y_{M} = 0.

In the end of the previous section, we differentiated the mass equation in time to obtain a discrete pressure Poisson equation. This equation includes the term $\frac{d y_{M}}{d t}$ , which is non-zero if an unsteady flow of mass is added to the domain (Dirichlet boundary conditions). This term ensures that the time-continuous discrete velocity field $u (t)$ stays divergence free (conserves mass). However, if we directly discretize this system in time, the mass preservation may actually not be respected. For this, we will change the definition of the pressure such that the time-discretized velocity field is divergence free at each time step and each time sub-step (to be defined in the following).

Consider the interval $[0, T]$ for some simulation time $T$ . We will divide it into $N$ sub-intervals $[t^{n}, t^{n + 1}]$ for $n = 0, \dots, N - 1$ , with $t^{0} = 0$ , $t^{N} = T$ , and increment $Δ t^{n} = t^{n + 1} - t^{n}$ . We define $u^{n} \approx u (t^{n})$ as an approximation to the exact discrete velocity field $u (t^{n})$ , with $u^{0} = u (0)$ starting from the exact initial conditions. We say that the time integration scheme (definition of $u^{n}$ ) is accurate to the order $r$ if $u^{n} = u (t^{n}) + O (Δ t^{r})$ for all $n$ .

IncompressibleNavierStokes provides a collection of explicit and implicit Runge-Kutta methods, in addition to Adams-Bashforth Crank-Nicolson and one-leg beta method time steppers.

The code is currently not adapted to time steppers from DifferentialEquations.jl, but they may be integrated in the future.

# IncompressibleNavierStokes.AbstractODEMethod — Type.

julia

abstract type AbstractODEMethod{T}

Abstract ODE method.

Fields

# IncompressibleNavierStokes.isexplicit — Function.

julia

isexplicit(method)

Return true if method is explicit, i.e. the value at a certain time step is given explicitly as a function of the previous time steps only.

# IncompressibleNavierStokes.lambda_conv_max — Function.

julia

lambda_conv_max(method)

Get maximum value of stability region for the convection operator (not a very good indication for the methods that do not include the imaginary axis)

# IncompressibleNavierStokes.lambda_diff_max — Function.

julia

lambda_diff_max(method)

Get maximum value of stability region for the diffusion operator.

# IncompressibleNavierStokes.ode_method_cache — Function.

julia

ode_method_cache(method, setup, u, temp)

Get time stepper cache for the given ODE method.

# IncompressibleNavierStokes.runge_kutta_method — Function.

julia

runge_kutta_method(
    A,
    b,
    c,
    r;
    T,
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod, IncompressibleNavierStokes.ImplicitRungeKuttaMethod}

Get Runge Kutta method. The function checks whether the method is explicit.

p_add_solve: whether to add a pressure solve step to the method.

For implicit RK methods: newton_type, maxiter, abstol, reltol.

# IncompressibleNavierStokes.timestep — Function.

julia

timestep(method, stepper, Δt; θ = nothing)

Perform one time step.

Non-mutating/allocating/out-of-place version.

See also timestep!.

# IncompressibleNavierStokes.timestep! — Function.

julia

timestep!(method, stepper, Δt; θ = nothing, cache)

Perform one time step>

Mutating/non-allocating/in-place version.

See also timestep.

Adams-Bashforth Crank-Nicolson method

# IncompressibleNavierStokes.AdamsBashforthCrankNicolsonMethod — Type.

julia

struct AdamsBashforthCrankNicolsonMethod{T, M} <: IncompressibleNavierStokes.AbstractODEMethod{T}

IMEX AB-CN: Adams-Bashforth for explicit convection (parameters α₁ and α₂) and Crank-Nicolson for implicit diffusion (implicitness θ). The method is second order for θ = 1/2.

The LU decomposition of the LHS matrix is computed every time the time step changes.

Note that, in contrast to explicit methods, the pressure from previous time steps has an influence on the accuracy of the velocity.

We here require that the time step $Δ t$ is constant. This methods uses Adams-Bashforth for the convective terms and Crank-Nicolson stepping for the diffusion and body force terms. Given the velocity field $u_{0} = u (t_{0})$ at a time $t_{0}$ and its previous value $u_{- 1} = u (t_{0} - Δ t)$ at the previous time $t_{- 1} = t_{0} - Δ t$ , the predicted velocity field $u$ at the time $t = t_{0} + Δ t$ is defined by first computing a tentative velocity:

\begin{aligned} \frac{v - u_{0}}{Δ t} & = - (α_{0} C (u_{0}, t_{0}) + α_{- 1} C (u_{- 1}, t_{- 1})) \\ + θ (D u_{0} + y_{D} (t_{0})) + (1 - θ) (D v + y_{D} (t)) \\ + θ f (t_{0}) + (1 - θ) f (t) \\ - (G p_{0} + y_{G} (t_{0})), \end{aligned}

where $θ \in [0, 1]$ is the Crank-Nicolson parameter ( $θ = \frac{1}{2}$ for second order convergence), $(α_{0}, α_{- 1}) = (\frac{3}{2}, - \frac{1}{2})$ are the Adams-Bashforth coefficients, and $v$ is a tentative velocity yet to be made divergence free. We can group the terms containing $v$ on the left hand side, to obtain

\begin{aligned} (\frac{1}{Δ t} I - (1 - θ) D) v & = (\frac{1}{Δ t} I - θ D) u_{0} \\ - (α_{0} C (u_{0}, t_{0}) + α_{- 1} C (u_{- 1}, t_{- 1})) \\ + θ y_{D} (t_{0}) + (1 - θ) y_{D} (t) \\ + θ f (t_{0}) + (1 - θ) f (t) \\ - (G p_{0} + y_{G} (t_{0})) . \end{aligned}

We can compute $v$ by inverting the positive definite matrix $(\frac{1}{Δ t} I - θ D)$ for the given right hand side using a suitable linear solver. Assuming $Δ t$ is constant, we can precompute a Cholesky factorization of this matrix before starting time stepping.

We then compute the pressure difference $Δ p$ by solving

L Δ p = W \frac{M v + y_{M} (t)}{Δ t} - W M (y_{G} (t) - y_{G} (t_{0})),

after which a divergence free velocity $u$ can be enforced:

u = v - Δ t (G Δ p + y_{G} (t) - y_{G} (t_{0})) .

A first order accurate prediction of the corresponding pressure is $p = p_{0} + Δ p$ . However, since this pressure is reused in the next time step, we perform an additional pressure solve to avoid accumulating first order errors. The resulting pressure $p$ is then accurate to the same order as $u$ .

Fields

α₁
α₂
θ
p_add_solve
method_startup

One-leg beta method

# IncompressibleNavierStokes.OneLegMethod — Type.

julia

struct OneLegMethod{T, M} <: IncompressibleNavierStokes.AbstractODEMethod{T}

Explicit one-leg β-method following symmetry-preserving discretization of turbulent flow. See Verstappen and Veldman [15] [17] for details.

We here require that the time step $Δ t$ is constant. Given the velocity $u_{0}$ and pressure $p_{0}$ at the current time $t_{0}$ and their previous values $u_{- 1}$ and $p_{- 1}$ at the time $t_{- 1} = t_{0} - Δ t$ , we start by computing the "offstep" values $v = (1 + β) v_{0} - β v_{- 1}$ and $Q = (1 + β) p_{0} - β p_{- 1}$ for some $β = \frac{1}{2}$ .

A tentative velocity field $\tilde{v}$ is then computed as follows:

\tilde{v} = \frac{1}{β + \frac{1}{2}} (2 β u_{0} - (β - \frac{1}{2}) u_{- 1} + Δ t F (v, t) - Δ t (G Q + y_{G} (t))) .

A pressure correction $Δ p$ is obtained by solving the Poisson equation

L Δ p = \frac{β + \frac{1}{2}}{Δ t} W (M \tilde{v} + y_{M} (t)) .

Finally, the divergence free velocity field is given by

u = \tilde{v} - \frac{Δ t}{β + \frac{1}{2}} G Δ p,

while the second order accurate pressure is given by

p = 2 p_{0} - p_{- 1} + \frac{4}{3} Δ p .

Fields

β
p_add_solve
method_startup

Runge-Kutta methods

# IncompressibleNavierStokes.AbstractRungeKuttaMethod — Type.

julia

abstract type AbstractRungeKuttaMethod{T} <: IncompressibleNavierStokes.AbstractODEMethod{T}

Abstract Runge Kutta method.

Fields

# IncompressibleNavierStokes.ExplicitRungeKuttaMethod — Type.

julia

struct ExplicitRungeKuttaMethod{T} <: IncompressibleNavierStokes.AbstractRungeKuttaMethod{T}

Explicit Runge Kutta method. See Sanderse [18].

Consider the velocity field $u_{0}$ at a certain time $t_{0}$ . We will now perform one time step to $t = t_{0} + Δ t$ . For explicit Runge-Kutta methods, this time step is divided into $s$ sub-steps $t_{i} = t_{0} + Δ t_{i}$ with increment $Δ t_{i} = c_{i} Δ t$ . The final substep performs the full time step $Δ t_{s} = Δ t$ such that $t_{s} = t$ .

For $i = 1, \dots, s$ , the intermediate velocity $u_{i}$ and pressure $p_{i}$ are computed as follows:

\begin{aligned} k_{i} & = F (u_{i - 1}, t_{i - 1}) - y_{G} (t_{i - 1}) \\ v_{i} & = u_{0} + Δ t \sum_{j = 1}^{i} a_{i j} k_{j} \\ L p_{i} & = W M \frac{1}{c_{i}} \sum_{j = 1}^{i} a_{i j} k_{j} + W \frac{y_{M} (t_{i}) - y_{M} (t_{0})}{Δ t_{i}} \\ = W \frac{(M v_{i} + y_{M} (t_{i})) - (M u_{0} + y_{M} (t_{0}))}{Δ t_{i}^{n}} \\ = W \frac{M v_{i} + y_{M} (t_{i})}{Δ t_{i}^{n}} \\ u_{i} & = v_{i} - Δ t_{i} G p_{i}, \end{aligned}

where $(a_{i j})_{i j}$ are the Butcher tableau coefficients of the RK-method, with the convention $c_{i} = \sum_{j = 1}^{i} a_{i j}$ .

Finally, we return $u_{s}$ . If $u_{0} = u (t_{0})$ , we get the accuracy $u_{s} = u (t) + O (Δ t^{r + 1})$ , where $r$ is the order of the RK-method. If we perform $n$ RK time steps instead of one, starting at exact initial conditions $u^{0} = u (0)$ , then $u^{n} = u (t^{n}) + O (Δ t^{r})$ for all $n \in {1, \dots, N}$ . Note that for a given $u$ , the corresponding pressure $p$ can be calculated to the same accuracy as $u$ by doing an additional pressure projection after each outer time step $Δ t$ (if we know $\frac{d y_{M}}{d t} (t)$ ), or to first order accuracy by simply returning $p_{s}$ .

Note that each of the sub-step velocities $u_{i}$ is divergence free, after projecting the tentative velocities $v_{i}$ . This is ensured due to the judiciously chosen replacement of $\frac{d y_{M}}{d t} (t_{i})$ with $(y_{M} (t_{i}) - y_{M} (t_{0})) / Δ t_{i}$ . The space-discrete divergence-freeness is thus perfectly preserved, even though the time discretization introduces other errors.

Fields

A
b
c
r
p_add_solve

# IncompressibleNavierStokes.ImplicitRungeKuttaMethod — Type.

julia

struct ImplicitRungeKuttaMethod{T} <: IncompressibleNavierStokes.AbstractRungeKuttaMethod{T}

Implicit Runge Kutta method. See Sanderse [19].

The implicit linear system is solved at each time step using Newton's method. The newton_type may be one of the following:

:no: Replace iteration matrix with I/Δt (no Jacobian)
:approximate: Build Jacobian once before iterations only
:full: Build Jacobian at each iteration

Fields

A
b
c
r
newton_type
maxiter
abstol
reltol
p_add_solve

# IncompressibleNavierStokes.RKMethods — Module.

Set up Butcher arrays A, b, and c, as well as and SSP coefficient r. For families of methods, optional input s is the number of stages.

Original (MATLAB) by David Ketcheson, extended by Benjamin Sanderse.

Exports

Explicit Methods

# IncompressibleNavierStokes.RKMethods.FE11 — Function.

julia

FE11(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

FE11 (Forward Euler).

# IncompressibleNavierStokes.RKMethods.SSP22 — Function.

julia

SSP22(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

SSP22.

# IncompressibleNavierStokes.RKMethods.SSP42 — Function.

julia

SSP42(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

SSP42.

# IncompressibleNavierStokes.RKMethods.SSP33 — Function.

julia

SSP33(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

SSP33.

# IncompressibleNavierStokes.RKMethods.SSP43 — Function.

julia

SSP43(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

SSP43.

# IncompressibleNavierStokes.RKMethods.SSP104 — Function.

julia

SSP104(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

SSP104.

# IncompressibleNavierStokes.RKMethods.rSSPs2 — Function.

julia

rSSPs2(
;
    ...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod, IncompressibleNavierStokes.ImplicitRungeKuttaMethod}
rSSPs2(
    s;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod, IncompressibleNavierStokes.ImplicitRungeKuttaMethod}

Rational (optimal, low-storage) s-stage 2nd order SSP.

# IncompressibleNavierStokes.RKMethods.rSSPs3 — Function.

julia

rSSPs3(
;
    ...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod, IncompressibleNavierStokes.ImplicitRungeKuttaMethod}
rSSPs3(
    s;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod, IncompressibleNavierStokes.ImplicitRungeKuttaMethod}

Rational (optimal, low-storage) s^2-stage 3rd order SSP.

# IncompressibleNavierStokes.RKMethods.Wray3 — Function.

julia

Wray3(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

Wray's RK3.

# IncompressibleNavierStokes.RKMethods.RK56 — Function.

julia

RK56(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

RK56.

# IncompressibleNavierStokes.RKMethods.DOPRI6 — Function.

julia

DOPRI6(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

Dormand-Price pair.

Implicit Methods

# IncompressibleNavierStokes.RKMethods.BE11 — Function.

julia

BE11(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

Backward Euler.

# IncompressibleNavierStokes.RKMethods.SDIRK34 — Function.

julia

SDIRK34(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

3-stage, 4th order singly diagonally implicit (SSP).

# IncompressibleNavierStokes.RKMethods.ISSPm2 — Function.

julia

ISSPm2(
;
    ...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}
ISSPm2(
    s;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod, IncompressibleNavierStokes.ImplicitRungeKuttaMethod}

Optimal DIRK SSP schemes of order 2.

# IncompressibleNavierStokes.RKMethods.ISSPs3 — Function.

julia

ISSPs3(
;
    ...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}
ISSPs3(
    s;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod, IncompressibleNavierStokes.ImplicitRungeKuttaMethod}

Optimal DIRK SSP schemes of order 3.

Half explicit methods

# IncompressibleNavierStokes.RKMethods.HEM3 — Function.

julia

HEM3(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

Brasey and Hairer.

# IncompressibleNavierStokes.RKMethods.HEM3BS — Function.

julia

HEM3BS(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

HEM3BS.

# IncompressibleNavierStokes.RKMethods.HEM5 — Function.

julia

HEM5(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

Brasey and Hairer, 5 stage, 4th order.

Classical Methods

# IncompressibleNavierStokes.RKMethods.GL1 — Function.

julia

GL1(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

GL1.

# IncompressibleNavierStokes.RKMethods.GL2 — Function.

julia

GL2(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

GL2.

# IncompressibleNavierStokes.RKMethods.GL3 — Function.

julia

GL3(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

GL3.

# IncompressibleNavierStokes.RKMethods.RIA1 — Function.

julia

RIA1(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

This is implicit Euler.

# IncompressibleNavierStokes.RKMethods.RIA2 — Function.

julia

RIA2(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

RIA2.

# IncompressibleNavierStokes.RKMethods.RIA3 — Function.

julia

RIA3(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

RIA3.

# IncompressibleNavierStokes.RKMethods.RIIA1 — Function.

julia

RIIA1(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

RIIA1.

# IncompressibleNavierStokes.RKMethods.RIIA2 — Function.

julia

RIIA2(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

RIIA2.

# IncompressibleNavierStokes.RKMethods.RIIA3 — Function.

julia

RIIA3(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

RIIA3.

# IncompressibleNavierStokes.RKMethods.LIIIA2 — Function.

julia

LIIIA2(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

LIIIA2.

# IncompressibleNavierStokes.RKMethods.LIIIA3 — Function.

julia

LIIIA3(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

LIIIA3.

Chebyshev methods

# IncompressibleNavierStokes.RKMethods.CHDIRK3 — Function.

julia

CHDIRK3(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

Chebyshev based DIRK (not algebraically stable).

# IncompressibleNavierStokes.RKMethods.CHCONS3 — Function.

julia

CHCONS3(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

CHCONS3.

# IncompressibleNavierStokes.RKMethods.CHC3 — Function.

julia

CHC3(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

Chebyshev quadrature and C(3) satisfied. Note this equals Lobatto IIIA.

# IncompressibleNavierStokes.RKMethods.CHC5 — Function.

julia

CHC5(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

CHC5.

Miscellaneous Methods

# IncompressibleNavierStokes.RKMethods.Mid22 — Function.

julia

Mid22(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

Midpoint 22 method.

# IncompressibleNavierStokes.RKMethods.MTE22 — Function.

julia

MTE22(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

Minimal truncation error 22 method (Heun).

# IncompressibleNavierStokes.RKMethods.CN22 — Function.

julia

CN22(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

Crank-Nicholson.

# IncompressibleNavierStokes.RKMethods.Heun33 — Function.

julia

Heun33(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

Heun33.

# IncompressibleNavierStokes.RKMethods.RK33C2 — Function.

julia

RK33C2(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

RK3 satisfying C(2) for i=3.

# IncompressibleNavierStokes.RKMethods.RK33P2 — Function.

julia

RK33P2(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

RK3 satisfying the second order condition for the pressure.

# IncompressibleNavierStokes.RKMethods.RK44 — Function.

julia

RK44(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

Classical fourth order.

# IncompressibleNavierStokes.RKMethods.RK44C2 — Function.

julia

RK44C2(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

RK4 satisfying C(2) for i=3.

# IncompressibleNavierStokes.RKMethods.RK44C23 — Function.

julia

RK44C23(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

RK4 satisfying C(2) for i=3 and c2=c3.

# IncompressibleNavierStokes.RKMethods.RK44P2 — Function.

julia

RK44P2(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

RK4 satisfying the second order condition for the pressure (but not third order).

DSRK Methods

# IncompressibleNavierStokes.RKMethods.DSso2 — Function.

julia

DSso2(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

CBM's DSRKso2.

# IncompressibleNavierStokes.RKMethods.DSRK2 — Function.

julia

DSRK2(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

CBM's DSRK2.

# IncompressibleNavierStokes.RKMethods.DSRK3 — Function.

julia

DSRK3(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

Zennaro's DSRK3.

"Non-SSP" Methods of Wong & Spiteri

# IncompressibleNavierStokes.RKMethods.NSSP21 — Function.

julia

NSSP21(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

NSSP21.

# IncompressibleNavierStokes.RKMethods.NSSP32 — Function.

julia

NSSP32(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

NSSP32.

# IncompressibleNavierStokes.RKMethods.NSSP33 — Function.

julia

NSSP33(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

NSSP33.

# IncompressibleNavierStokes.RKMethods.NSSP53 — Function.

julia

NSSP53(
;
    kwargs...
) -> Union{IncompressibleNavierStokes.ExplicitRungeKuttaMethod{Float64}, IncompressibleNavierStokes.ImplicitRungeKuttaMethod{Float64}}

NSSP53.