OrdinaryDiffEqLowStorageRK

Low-storage Runge-Kutta methods are specialized explicit schemes designed to minimize memory requirements while maintaining high-order accuracy. These methods are essential for large-scale computational fluid dynamics and wave propagation problems where memory constraints are critical.

Key Properties

Low-storage RK methods provide:

Drastically reduced memory usage (typically 2-4 registers vs 7-10 for standard RK)
High-order accuracy comparable to standard RK methods
Preservation of important stability properties (low dissipation/dispersion)
Scalability to very large PDE discretizations

When to Use Low-Storage RK Methods

These methods are recommended for:

Large-scale PDE discretizations where memory is the limiting factor
Computational fluid dynamics and wave propagation simulations
High-performance computing applications with memory constraints
GPU computations where memory bandwidth is critical
Compressible flow simulations and aerodynamics
Seismic wave propagation and acoustic simulations
Problems with millions or billions of unknowns

Memory Efficiency Comparison

Registers refer to the number of copies of the u0 vector that must be stored in memory during integration:

Standard Tsit5: ~9 registers (copies of the state vector)
Low-storage methods: 2-4 registers (copies of the state vector)
Practical example: If u0 is from a PDE semi-discretization requiring 2 GB, then Tsit5 needs 18 GB of working memory, while a 2-register method only needs 4 GB and can achieve the same order
Trade-off: These methods achieve memory reduction by being less computationally efficient, trading compute performance for lower memory requirements

Solver Selection Guide

General-purpose low-storage

CarpenterKennedy2N54: Fourth-order, 5-stage, excellent general choice
RDPK3Sp510: Fifth-order with only 3 registers, very memory efficient

Wave propagation optimized

ORK256: Second-order, 5-stage, optimized for wave equations
CFRLDDRK64: Low-dissipation and low-dispersion variant
TSLDDRK74: Seventh-order for high accuracy wave propagation

Discontinuous Galerkin optimized

DGLDDRK73_C: Optimized for DG discretizations (constrained)
DGLDDRK84_C, DGLDDRK84_F: Fourth-order DG variants

Specialized high-order

NDBLSRK124, NDBLSRK144: Multi-stage fourth-order methods
SHLDDRK64: Low dissipation and dispersion properties
RK46NL: Six-stage fourth-order method

Computational fluid dynamics

Carpenter-Kennedy-Lewis series (CKLLSRK*): Optimized for Navier-Stokes equations
Parsani-Ketcheson-Deconinck series (ParsaniKetcheson*): CFD-optimized variants
Ranocha-Dalcin-Parsani-Ketcheson series (RDPK*): Modern CFD methods

Performance Considerations

Use only when memory-bound: Standard RK methods are often more efficient when memory is not limiting
Best for large systems: Most beneficial for problems with >10⁶ unknowns
GPU acceleration: Particularly effective on memory-bandwidth limited hardware

Installation

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

using Pkg
Pkg.add("OrdinaryDiffEqLowStorageRK")

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 OrdinaryDiffEqLowStorageRK

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, CarpenterKennedy2N54())

Full list of solvers

OrdinaryDiffEqLowStorageRK.ORK256 — Type

ORK256(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!,
         step_limiter! = OrdinaryDiffEq.trivial_limiter!,
         thread = OrdinaryDiffEq.False(),
         williamson_condition = true)

Explicit Runge-Kutta Method. A second-order, five-stage method for wave propagation equations. 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.
williamson_condition: allows for an optimization that allows fusing broadcast expressions with the function call f. However, it only works for Array types.

References

Matteo Bernardini, Sergio Pirozzoli. A General Strategy for the Optimization of Runge-Kutta Schemes for Wave Propagation Phenomena. Journal of Computational Physics, 228(11), pp 4182-4199, 2009. doi: https://doi.org/10.1016/j.jcp.2009.02.032