Add ES-DG optimized 3S* low-storage RK methods (Al Jahdali et al. 2022) (#3241)

* Add ES-DG optimized 3S* low-storage RK methods (Al Jahdali et al. 2022)

- Implement 16 new methods (advection- and vortex-optimized)
- Reuse existing LowStorageRK3S cache structures (no allocations)
- Add tableau constructors and alg_cache implementations
- Register methods in alg_utils and exports
- All tests pass (517 + JET + Aqua)

* Fix AlJahdali 3S* methods for post-approval API drift

Adapt the 16 constant-cache constructors to upstream changes that
landed after the March review: LowStorageRK3SConstantCache moved its
fields from SVector to NTuple and the sublibrary dropped StaticArrays,
so the SVector construction that was correct at approval time no
longer builds. Switched to plain tuples matching the sibling
ParsaniKetcheson* constructors, and the thread default changed
False() -> Serial() with the same upstream drift.

Also Runic-reformats the added AlJahdali constructors (numeric
literal style drifted from current convention); no other lines
touched.

* Add convergence test coverage for the 16 AlJahdali 3S* methods

The approved PR shipped with no test coverage for these methods at
all. Adds a compact loop over all 16 checking convergence order
against an analytic reference (test_problems_only_time), matching
each method's alg_order.

Unlike ParsaniKetchesonDeconinck3S*, these don't show a consistent
+1 pure-quadrature super-convergence bump at the same dts range
(some do, some measure close to their claimed order, some land
between), so atol is looser (1.25) than the family's usual testTol
(0.25) rather than hand-tuning dts per method. Still catches an
actually wrong coefficient set, which would land further off.

* typos: allow Vor in AlJahdaliVor3S* method family names

Spell Check CI flagged every occurrence of Vor (the vorticity-
optimized half of the AlJahdali 3S* family, paired with Adv for
advection-optimized) as a typo for For.

* Consolidate AlJahdali alg_cache into the generic 3S dispatch

Route the 16 AlJahdali methods through LowStorageRK3SAlgorithm and
_lowstorage_3s_tableau like the ParsaniKetcheson family, deleting the
32 hand-written per-method alg_cache definitions. Drop the positional
compatibility constructors: the methods are new so there is nothing to
be compatible with, and the positional form silently discarded a
passed stage limiter (the 3S kernel does not apply stage limiters).

Also document the 16 exports in the LowStorageRK docs page, match the
ConstantCache constructor signatures to the sibling families, and bump
OrdinaryDiffEqLowStorageRK to 3.3.0 for the new exports.

Verified behavior-preserving: end states for all 16 methods are
bit-identical to the pre-consolidation dispatch on in-place and
out-of-place problems, and the full LowStorageRK test file passes.

---------

Co-authored-by: Harsh Singh <harsh@Harshs-MacBook-Air.local>

Author: singhharsh1708

.typos.toml

@@ -54,6 +54,7 @@ Darmstadt = "Darmstadt"
 "problèmes" = "problèmes"
 problemes = "problemes"  # French word in citation without accent
 Ono = "Ono"  # Hiroshi Ono, author of Ono10/Ono12 RK methods
+Vor = "Vor"  # vorticity-optimized AlJahdaliVor3S* method family (Al Jahdali et al. 2022)
 padd = "padd"  # variable name in analyticless_convergence_tests.jl
 Preprint = "Preprint"
 Nr = "Nr"

docs/src/explicit/LowStorageRK.md

@@ -99,6 +99,22 @@ ParsaniKetchesonDeconinck3S94
 ParsaniKetchesonDeconinck3S184
 ParsaniKetchesonDeconinck3S105
 ParsaniKetchesonDeconinck3S205
+AlJahdaliAdv3S42
+AlJahdaliAdv3S82
+AlJahdaliAdv3S53
+AlJahdaliAdv3S113
+AlJahdaliAdv3S64
+AlJahdaliAdv3S154
+AlJahdaliAdv3S85
+AlJahdaliAdv3S165
+AlJahdaliVor3S42
+AlJahdaliVor3S82
+AlJahdaliVor3S53
+AlJahdaliVor3S113
+AlJahdaliVor3S64
+AlJahdaliVor3S154
+AlJahdaliVor3S85
+AlJahdaliVor3S165
 CKLLSRK43_2
 CKLLSRK54_3C
 CKLLSRK95_4S

lib/OrdinaryDiffEqLowStorageRK/Project.toml

@@ -1,7 +1,7 @@
 name = "OrdinaryDiffEqLowStorageRK"
 uuid = "b0944070-b475-4768-8dec-fb6eb410534d"
 authors = ["ParamThakkar123 <paramthakkar864@gmail.com>"]
-version = "3.2.2"
+version = "3.3.0"
 
 [deps]
 CommonSolve = "38540f10-b2f7-11e9-35d8-d573e4eb0ff2"

lib/OrdinaryDiffEqLowStorageRK/src/OrdinaryDiffEqLowStorageRK.jl

@@ -146,6 +146,10 @@ export ORK256, CarpenterKennedy2N54, SHLDDRK64, DGLDDRK73_C, DGLDDRK84_C,
     ParsaniKetchesonDeconinck3S53, ParsaniKetchesonDeconinck3S173,
     ParsaniKetchesonDeconinck3S94, ParsaniKetchesonDeconinck3S184,
     ParsaniKetchesonDeconinck3S105, ParsaniKetchesonDeconinck3S205,
+    AlJahdaliAdv3S42, AlJahdaliAdv3S82, AlJahdaliAdv3S53, AlJahdaliAdv3S113,
+    AlJahdaliAdv3S64, AlJahdaliAdv3S154, AlJahdaliAdv3S85, AlJahdaliAdv3S165,
+    AlJahdaliVor3S42, AlJahdaliVor3S82, AlJahdaliVor3S53, AlJahdaliVor3S113,
+    AlJahdaliVor3S64, AlJahdaliVor3S154, AlJahdaliVor3S85, AlJahdaliVor3S165,
     RDPK3Sp35, RDPK3SpFSAL35, RDPK3Sp49, RDPK3SpFSAL49, RDPK3Sp510, RDPK3SpFSAL510,
     RK46NL, SHLDDRK_2N, SHLDDRK52
 end

lib/OrdinaryDiffEqLowStorageRK/src/alg_utils.jl

@@ -18,6 +18,22 @@ alg_order(alg::ParsaniKetchesonDeconinck3S94) = 4
 alg_order(alg::ParsaniKetchesonDeconinck3S184) = 4
 alg_order(alg::ParsaniKetchesonDeconinck3S105) = 5
 alg_order(alg::ParsaniKetchesonDeconinck3S205) = 5
+alg_order(alg::AlJahdaliAdv3S42) = 2
+alg_order(alg::AlJahdaliAdv3S82) = 2
+alg_order(alg::AlJahdaliAdv3S53) = 3
+alg_order(alg::AlJahdaliAdv3S113) = 3
+alg_order(alg::AlJahdaliAdv3S64) = 4
+alg_order(alg::AlJahdaliAdv3S154) = 4
+alg_order(alg::AlJahdaliAdv3S85) = 5
+alg_order(alg::AlJahdaliAdv3S165) = 5
+alg_order(alg::AlJahdaliVor3S42) = 2
+alg_order(alg::AlJahdaliVor3S82) = 2
+alg_order(alg::AlJahdaliVor3S53) = 3
+alg_order(alg::AlJahdaliVor3S113) = 3
+alg_order(alg::AlJahdaliVor3S64) = 4
+alg_order(alg::AlJahdaliVor3S154) = 4
+alg_order(alg::AlJahdaliVor3S85) = 5
+alg_order(alg::AlJahdaliVor3S165) = 5
 alg_order(alg::CKLLSRK43_2) = 3
 alg_order(alg::CKLLSRK54_3C) = 4
 alg_order(alg::CKLLSRK95_4S) = 5

lib/OrdinaryDiffEqLowStorageRK/src/algorithms.jl

@@ -331,6 +331,283 @@ Base.@kwdef struct ParsaniKetchesonDeconinck3S205{StageLimiter, StepLimiter, Thr
     thread::Thread = Serial()
 end
 
+# Al Jahdali et al. (2022) 3S* low-storage methods
+# Advection-optimized schemes
+
+@doc explicit_rk_docstring(
+    "Low-Storage Method
+4-stage, second order (3S) low-storage scheme, optimized for the 2D advection equation.
+Fixed timestep only.", "AlJahdaliAdv3S42",
+    references = "Al Jahdali, Dalcin, Boukharfane, Nolasco, Keyes, Parsani (2022)
+    Optimized explicit Runge-Kutta schemes for high-order collocated discontinuous
+    Galerkin methods for compressible fluid dynamics.
+    Computers & Mathematics with Applications, 118, pp. 27-44.
+    doi: https://doi.org/10.1016/j.camwa.2022.05.006"
+)
+Base.@kwdef struct AlJahdaliAdv3S42{StageLimiter, StepLimiter, Thread} <:
+    OrdinaryDiffEqAlgorithm
+    stage_limiter!::StageLimiter = trivial_limiter!
+    step_limiter!::StepLimiter = trivial_limiter!
+    thread::Thread = Serial()
+end
+
+@doc explicit_rk_docstring(
+    "Low-Storage Method
+8-stage, second order (3S) low-storage scheme, optimized for the 2D advection equation.
+Fixed timestep only.", "AlJahdaliAdv3S82",
+    references = "Al Jahdali, Dalcin, Boukharfane, Nolasco, Keyes, Parsani (2022)
+    Optimized explicit Runge-Kutta schemes for high-order collocated discontinuous
+    Galerkin methods for compressible fluid dynamics.
+    Computers & Mathematics with Applications, 118, pp. 27-44.
+    doi: https://doi.org/10.1016/j.camwa.2022.05.006"
+)
+Base.@kwdef struct AlJahdaliAdv3S82{StageLimiter, StepLimiter, Thread} <:
+    OrdinaryDiffEqAlgorithm
+    stage_limiter!::StageLimiter = trivial_limiter!
+    step_limiter!::StepLimiter = trivial_limiter!
+    thread::Thread = Serial()
+end
+
+@doc explicit_rk_docstring(
+    "Low-Storage Method
+5-stage, third order (3S) low-storage scheme, optimized for the 2D advection equation.
+Fixed timestep only.", "AlJahdaliAdv3S53",
+    references = "Al Jahdali, Dalcin, Boukharfane, Nolasco, Keyes, Parsani (2022)
+    Optimized explicit Runge-Kutta schemes for high-order collocated discontinuous
+    Galerkin methods for compressible fluid dynamics.
+    Computers & Mathematics with Applications, 118, pp. 27-44.
+    doi: https://doi.org/10.1016/j.camwa.2022.05.006"
+)
+Base.@kwdef struct AlJahdaliAdv3S53{StageLimiter, StepLimiter, Thread} <:
+    OrdinaryDiffEqAlgorithm
+    stage_limiter!::StageLimiter = trivial_limiter!
+    step_limiter!::StepLimiter = trivial_limiter!
+    thread::Thread = Serial()
+end
+
+@doc explicit_rk_docstring(
+    "Low-Storage Method
+11-stage, third order (3S) low-storage scheme, optimized for the 2D advection equation.
+Fixed timestep only.", "AlJahdaliAdv3S113",
+    references = "Al Jahdali, Dalcin, Boukharfane, Nolasco, Keyes, Parsani (2022)
+    Optimized explicit Runge-Kutta schemes for high-order collocated discontinuous
+    Galerkin methods for compressible fluid dynamics.
+    Computers & Mathematics with Applications, 118, pp. 27-44.
+    doi: https://doi.org/10.1016/j.camwa.2022.05.006"
+)
+Base.@kwdef struct AlJahdaliAdv3S113{StageLimiter, StepLimiter, Thread} <:
+    OrdinaryDiffEqAlgorithm
+    stage_limiter!::StageLimiter = trivial_limiter!
+    step_limiter!::StepLimiter = trivial_limiter!
+    thread::Thread = Serial()
+end
+
+@doc explicit_rk_docstring(
+    "Low-Storage Method
+6-stage, fourth order (3S) low-storage scheme, optimized for the 2D advection equation.
+Fixed timestep only.", "AlJahdaliAdv3S64",
+    references = "Al Jahdali, Dalcin, Boukharfane, Nolasco, Keyes, Parsani (2022)
+    Optimized explicit Runge-Kutta schemes for high-order collocated discontinuous
+    Galerkin methods for compressible fluid dynamics.
+    Computers & Mathematics with Applications, 118, pp. 27-44.
+    doi: https://doi.org/10.1016/j.camwa.2022.05.006"
+)
+Base.@kwdef struct AlJahdaliAdv3S64{StageLimiter, StepLimiter, Thread} <:
+    OrdinaryDiffEqAlgorithm
+    stage_limiter!::StageLimiter = trivial_limiter!
+    step_limiter!::StepLimiter = trivial_limiter!
+    thread::Thread = Serial()
+end
+
+@doc explicit_rk_docstring(
+    "Low-Storage Method
+15-stage, fourth order (3S) low-storage scheme, optimized for the 2D advection equation.
+Fixed timestep only.", "AlJahdaliAdv3S154",
+    references = "Al Jahdali, Dalcin, Boukharfane, Nolasco, Keyes, Parsani (2022)
+    Optimized explicit Runge-Kutta schemes for high-order collocated discontinuous
+    Galerkin methods for compressible fluid dynamics.
+    Computers & Mathematics with Applications, 118, pp. 27-44.
+    doi: https://doi.org/10.1016/j.camwa.2022.05.006"
+)
+Base.@kwdef struct AlJahdaliAdv3S154{StageLimiter, StepLimiter, Thread} <:
+    OrdinaryDiffEqAlgorithm
+    stage_limiter!::StageLimiter = trivial_limiter!
+    step_limiter!::StepLimiter = trivial_limiter!
+    thread::Thread = Serial()
+end
+
+@doc explicit_rk_docstring(
+    "Low-Storage Method
+8-stage, fifth order (3S) low-storage scheme, optimized for the 2D advection equation.
+Fixed timestep only.", "AlJahdaliAdv3S85",
+    references = "Al Jahdali, Dalcin, Boukharfane, Nolasco, Keyes, Parsani (2022)
+    Optimized explicit Runge-Kutta schemes for high-order collocated discontinuous
+    Galerkin methods for compressible fluid dynamics.
+    Computers & Mathematics with Applications, 118, pp. 27-44.
+    doi: https://doi.org/10.1016/j.camwa.2022.05.006"
+)
+Base.@kwdef struct AlJahdaliAdv3S85{StageLimiter, StepLimiter, Thread} <:
+    OrdinaryDiffEqAlgorithm
+    stage_limiter!::StageLimiter = trivial_limiter!
+    step_limiter!::StepLimiter = trivial_limiter!
+    thread::Thread = Serial()
+end
+
+@doc explicit_rk_docstring(
+    "Low-Storage Method
+16-stage, fifth order (3S) low-storage scheme, optimized for the 2D advection equation.
+Fixed timestep only.", "AlJahdaliAdv3S165",
+    references = "Al Jahdali, Dalcin, Boukharfane, Nolasco, Keyes, Parsani (2022)
+    Optimized explicit Runge-Kutta schemes for high-order collocated discontinuous
+    Galerkin methods for compressible fluid dynamics.
+    Computers & Mathematics with Applications, 118, pp. 27-44.
+    doi: https://doi.org/10.1016/j.camwa.2022.05.006"
+)
+Base.@kwdef struct AlJahdaliAdv3S165{StageLimiter, StepLimiter, Thread} <:
+    OrdinaryDiffEqAlgorithm
+    stage_limiter!::StageLimiter = trivial_limiter!
+    step_limiter!::StepLimiter = trivial_limiter!
+    thread::Thread = Serial()
+end
+
+# Vortex-optimized schemes
+
+@doc explicit_rk_docstring(
+    "Low-Storage Method
+4-stage, second order (3S) low-storage scheme, optimized for the isentropic vortex propagation problem.
+Fixed timestep only.", "AlJahdaliVor3S42",
+    references = "Al Jahdali, Dalcin, Boukharfane, Nolasco, Keyes, Parsani (2022)
+    Optimized explicit Runge-Kutta schemes for high-order collocated discontinuous
+    Galerkin methods for compressible fluid dynamics.
+    Computers & Mathematics with Applications, 118, pp. 27-44.
+    doi: https://doi.org/10.1016/j.camwa.2022.05.006"
+)
+Base.@kwdef struct AlJahdaliVor3S42{StageLimiter, StepLimiter, Thread} <:
+    OrdinaryDiffEqAlgorithm
+    stage_limiter!::StageLimiter = trivial_limiter!
+    step_limiter!::StepLimiter = trivial_limiter!
+    thread::Thread = Serial()
+end
+
+@doc explicit_rk_docstring(
+    "Low-Storage Method
+8-stage, second order (3S) low-storage scheme, optimized for the isentropic vortex propagation problem.
+Fixed timestep only.", "AlJahdaliVor3S82",
+    references = "Al Jahdali, Dalcin, Boukharfane, Nolasco, Keyes, Parsani (2022)
+    Optimized explicit Runge-Kutta schemes for high-order collocated discontinuous
+    Galerkin methods for compressible fluid dynamics.
+    Computers & Mathematics with Applications, 118, pp. 27-44.
+    doi: https://doi.org/10.1016/j.camwa.2022.05.006"
+)
+Base.@kwdef struct AlJahdaliVor3S82{StageLimiter, StepLimiter, Thread} <:
+    OrdinaryDiffEqAlgorithm
+    stage_limiter!::StageLimiter = trivial_limiter!
+    step_limiter!::StepLimiter = trivial_limiter!
+    thread::Thread = Serial()
+end
+
+@doc explicit_rk_docstring(
+    "Low-Storage Method
+5-stage, third order (3S) low-storage scheme, optimized for the isentropic vortex propagation problem.
+Fixed timestep only.", "AlJahdaliVor3S53",
+    references = "Al Jahdali, Dalcin, Boukharfane, Nolasco, Keyes, Parsani (2022)
+    Optimized explicit Runge-Kutta schemes for high-order collocated discontinuous
+    Galerkin methods for compressible fluid dynamics.
+    Computers & Mathematics with Applications, 118, pp. 27-44.
+    doi: https://doi.org/10.1016/j.camwa.2022.05.006"
+)
+Base.@kwdef struct AlJahdaliVor3S53{StageLimiter, StepLimiter, Thread} <:
+    OrdinaryDiffEqAlgorithm
+    stage_limiter!::StageLimiter = trivial_limiter!
+    step_limiter!::StepLimiter = trivial_limiter!
+    thread::Thread = Serial()
+end
+
+@doc explicit_rk_docstring(
+    "Low-Storage Method
+11-stage, third order (3S) low-storage scheme, optimized for the isentropic vortex propagation problem.
+Fixed timestep only.", "AlJahdaliVor3S113",
+    references = "Al Jahdali, Dalcin, Boukharfane, Nolasco, Keyes, Parsani (2022)
+    Optimized explicit Runge-Kutta schemes for high-order collocated discontinuous
+    Galerkin methods for compressible fluid dynamics.
+    Computers & Mathematics with Applications, 118, pp. 27-44.
+    doi: https://doi.org/10.1016/j.camwa.2022.05.006"
+)
+Base.@kwdef struct AlJahdaliVor3S113{StageLimiter, StepLimiter, Thread} <:
+    OrdinaryDiffEqAlgorithm
+    stage_limiter!::StageLimiter = trivial_limiter!
+    step_limiter!::StepLimiter = trivial_limiter!
+    thread::Thread = Serial()
+end
+
+@doc explicit_rk_docstring(
+    "Low-Storage Method
+6-stage, fourth order (3S) low-storage scheme, optimized for the isentropic vortex propagation problem.
+Fixed timestep only.", "AlJahdaliVor3S64",
+    references = "Al Jahdali, Dalcin, Boukharfane, Nolasco, Keyes, Parsani (2022)
+    Optimized explicit Runge-Kutta schemes for high-order collocated discontinuous
+    Galerkin methods for compressible fluid dynamics.
+    Computers & Mathematics with Applications, 118, pp. 27-44.
+    doi: https://doi.org/10.1016/j.camwa.2022.05.006"
+)
+Base.@kwdef struct AlJahdaliVor3S64{StageLimiter, StepLimiter, Thread} <:
+    OrdinaryDiffEqAlgorithm
+    stage_limiter!::StageLimiter = trivial_limiter!
+    step_limiter!::StepLimiter = trivial_limiter!
+    thread::Thread = Serial()
+end
+
+@doc explicit_rk_docstring(
+    "Low-Storage Method
+15-stage, fourth order (3S) low-storage scheme, optimized for the isentropic vortex propagation problem.
+Fixed timestep only.", "AlJahdaliVor3S154",
+    references = "Al Jahdali, Dalcin, Boukharfane, Nolasco, Keyes, Parsani (2022)
+    Optimized explicit Runge-Kutta schemes for high-order collocated discontinuous
+    Galerkin methods for compressible fluid dynamics.
+    Computers & Mathematics with Applications, 118, pp. 27-44.
+    doi: https://doi.org/10.1016/j.camwa.2022.05.006"
+)
+Base.@kwdef struct AlJahdaliVor3S154{StageLimiter, StepLimiter, Thread} <:
+    OrdinaryDiffEqAlgorithm
+    stage_limiter!::StageLimiter = trivial_limiter!
+    step_limiter!::StepLimiter = trivial_limiter!
+    thread::Thread = Serial()
+end
+
+@doc explicit_rk_docstring(
+    "Low-Storage Method
+8-stage, fifth order (3S) low-storage scheme, optimized for the isentropic vortex propagation problem.
+Fixed timestep only.", "AlJahdaliVor3S85",
+    references = "Al Jahdali, Dalcin, Boukharfane, Nolasco, Keyes, Parsani (2022)
+    Optimized explicit Runge-Kutta schemes for high-order collocated discontinuous
+    Galerkin methods for compressible fluid dynamics.
+    Computers & Mathematics with Applications, 118, pp. 27-44.
+    doi: https://doi.org/10.1016/j.camwa.2022.05.006"
+)
+Base.@kwdef struct AlJahdaliVor3S85{StageLimiter, StepLimiter, Thread} <:
+    OrdinaryDiffEqAlgorithm
+    stage_limiter!::StageLimiter = trivial_limiter!
+    step_limiter!::StepLimiter = trivial_limiter!
+    thread::Thread = Serial()
+end
+
+@doc explicit_rk_docstring(
+    "Low-Storage Method
+16-stage, fifth order (3S) low-storage scheme, optimized for the isentropic vortex propagation problem.
+Fixed timestep only.", "AlJahdaliVor3S165",
+    references = "Al Jahdali, Dalcin, Boukharfane, Nolasco, Keyes, Parsani (2022)
+    Optimized explicit Runge-Kutta schemes for high-order collocated discontinuous
+    Galerkin methods for compressible fluid dynamics.
+    Computers & Mathematics with Applications, 118, pp. 27-44.
+    doi: https://doi.org/10.1016/j.camwa.2022.05.006"
+)
+Base.@kwdef struct AlJahdaliVor3S165{StageLimiter, StepLimiter, Thread} <:
+    OrdinaryDiffEqAlgorithm
+    stage_limiter!::StageLimiter = trivial_limiter!
+    step_limiter!::StepLimiter = trivial_limiter!
+    thread::Thread = Serial()
+end
+
 @doc explicit_rk_docstring(
     "Low-Storage Method
 4-stage, third order low-storage scheme, optimized for compressible Navier–Stokes equations.