OrdinaryDiffEqSSPRK

Strong Stability Preserving Runge-Kutta (SSPRK) methods are specialized explicit Runge-Kutta methods designed to preserve important stability properties of the underlying spatial discretization when applied to hyperbolic partial differential equations and conservation laws.

Key Properties

SSPRK methods provide:

Strong stability preservation for convex functionals (total variation, maximum norm, entropy)
Optimal SSP coefficients allowing larger stable timesteps
Non-oscillatory behavior crucial for hyperbolic PDEs and conservation laws
High-order accuracy while maintaining monotonicity properties
Specialized variants for different orders and storage requirements

When to Use SSPRK Methods

SSPRK methods are essential for:

Hyperbolic partial differential equations (Euler equations, shallow water, etc.)
Conservation laws where preserving physical bounds is critical
Discontinuous Galerkin methods and other high-order spatial discretizations
Problems requiring monotonicity preservation or total variation stability
Shock-capturing schemes where spurious oscillations must be avoided
Astrophysical simulations and computational fluid dynamics

SSP Coefficient and CFL Conditions

The SSP coefficient determines the maximum allowable timestep for stability preservation. Use OrdinaryDiffEqCore.ssp_coefficient(alg) to query this value for step size calculations. The timestep must satisfy dt ≤ CFL * dx / max_wavespeed where CFL ≤ SSP coefficient.

Solver Selection Guide

Second-order methods

SSPRK22: Two-stage, second-order (SSP coefficient = 1)
SSPRKMSVS32: Three-step multistep variant

Third-order methods

SSPRK33: Three-stage, third-order, optimal (SSP coefficient = 1)
SSPRK53: Five-stage, third-order, higher SSP coefficient
SSPRK63, SSPRK73, SSPRK83: More stages for larger SSP coefficients
SSPRK43: Four-stage with embedded error estimation
SSPRK432: Low-storage variant

Fourth-order methods

SSPRK54: Five-stage, fourth-order
SSPRK104: Ten-stage, fourth-order, large SSP coefficient

Low-storage variants

SSPRK53_2N1, SSPRK53_2N2, SSPRK53_H: Two-register storage schemes

Discontinuous Galerkin optimized

KYKSSPRK42: Optimized for DG spatial discretizations
KYK2014DGSSPRK_3S2: Specialized DG method

Adaptive methods

SSPRK432: Third-order with error control
SSPRK932: High-stage adaptive method
SSPRKMSVS43: Multistep adaptive variant

Installation

To be able to access the solvers in OrdinaryDiffEqSSPRK, you must first install them use the Julia package manager:

using Pkg
Pkg.add("OrdinaryDiffEqSSPRK")

This will only install the solvers listed at the bottom of this page. If you want to explore other solvers for your problem, you will need to install some of the other libraries listed in the navigation bar on the left.

Example usage

using OrdinaryDiffEqSSPRK

function lorenz!(du, u, p, t)
    du[1] = 10.0 * (u[2] - u[1])
    du[2] = u[1] * (28.0 - u[3]) - u[2]
    du[3] = u[1] * u[2] - (8 / 3) * u[3]
end
u0 = [1.0; 0.0; 0.0]
tspan = (0.0, 100.0)
prob = ODEProblem(lorenz!, u0, tspan)
sol = solve(prob, SSPRK22())

Full list of solvers

OrdinaryDiffEqSSPRK.SSPRK22 — Type

SSPRK22(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
          step_limiter! = OrdinaryDiffEq.trivial_limiter!,
          thread = OrdinaryDiffEq.False())

Explicit Runge-Kutta Method. A second-order, two-stage explicit strong stability preserving (SSP) method. Fixed timestep only.

Keyword Arguments

stage_limiter!: function of the form limiter!(u, integrator, p, t)
step_limiter!: function of the form limiter!(u, integrator, p, t)
thread: determines whether internal broadcasting on appropriate CPU arrays should be serial (thread = OrdinaryDiffEq.False()) or use multiple threads (thread = OrdinaryDiffEq.True()) when Julia is started with multiple threads.

References

Shu, Chi-Wang, and Stanley Osher. Efficient implementation of essentially non-oscillatory shock-capturing schemes. Journal of Computational Physics 77.2 (1988): 439-471. https://doi.org/10.1016/0021-9991(88)90177-5