@doc explicit_rk_docstring(
    "A second-order, five-stage method for wave propagation
equations. Fixed timestep only.", "ORK256",
    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",
    extra_keyword_description = """- `williamson_condition`: allows for an optimization that allows fusing broadcast expressions with the function call `f`. However, it only works for `Array` types.
    """,
    extra_keyword_default = "williamson_condition = false"
)
Base.@kwdef struct ORK256{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
    williamson_condition::Bool = false
end

@doc explicit_rk_docstring(
    "7-stage, third order low-storage low-dissipation, low-dispersion scheme for
discontinuous Galerkin space discretizations applied to wave propagation problems.
Optimized for PDE discretizations when maximum spatial step is small due to
geometric features of computational domain. Fixed timestep only.",
    "DGLDDRK73_C",
    references = "T. Toulorge, W. Desmet.
    Optimal Runge–Kutta Schemes for Discontinuous Galerkin Space Discretizations
    Applied to Wave Propagation Problems.
    Journal of Computational Physics, 231(4), pp 2067-2091, 2012.
    doi: https://doi.org/10.1016/j.jcp.2011.11.024",
    extra_keyword_description = """- `williamson_condition`: allows for an optimization that allows fusing broadcast expressions with the function call `f`. However, it only works for `Array` types.
    """,
    extra_keyword_default = "williamson_condition = false"
)
Base.@kwdef struct DGLDDRK73_C{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
    williamson_condition::Bool = false
end

@doc explicit_rk_docstring(
    "A fourth-order, five-stage low-storage method of Carpenter and Kennedy
(free 3rd order Hermite interpolant). Fixed timestep only. Designed for
hyperbolic PDEs (stability properties).",
    "CarpenterKennedy2N54",
    references = "@article{carpenter1994fourth,
    title={Fourth-order 2N-storage Runge-Kutta schemes},
    author={Carpenter, Mark H and Kennedy, Christopher A},
    year={1994}
    }",
    extra_keyword_description = """- `williamson_condition`: allows for an optimization that allows fusing broadcast expressions with the function call `f`. However, it only works for `Array` types.
    """,
    extra_keyword_default = "williamson_condition = false"
)
Base.@kwdef struct CarpenterKennedy2N54{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
    williamson_condition::Bool = false
end

@doc explicit_rk_docstring(
    "12-stage, fourth order low-storage method with optimized stability regions for
advection-dominated problems. Fixed timestep only.",
    "NDBLSRK124",
    references = "Jens Niegemann, Richard Diehl, Kurt Busch.
    Efficient Low-Storage Runge–Kutta Schemes with Optimized Stability Regions.
    Journal of Computational Physics, 231, pp 364-372, 2012.
    doi: https://doi.org/10.1016/j.jcp.2011.09.003",
    extra_keyword_description = """- `williamson_condition`: allows for an optimization that allows fusing broadcast expressions with the function call `f`. However, it only works for `Array` types.
    """,
    extra_keyword_default = "williamson_condition = false"
)
Base.@kwdef struct NDBLSRK124{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
    williamson_condition::Bool = false
end

@doc explicit_rk_docstring(
    "14-stage, fourth order low-storage method with optimized stability regions for
advection-dominated problems. Fixed timestep only.",
    "NDBLSRK144",
    references = "Jens Niegemann, Richard Diehl, Kurt Busch.
    Efficient Low-Storage Runge–Kutta Schemes with Optimized Stability Regions.
    Journal of Computational Physics, 231, pp 364-372, 2012.
    doi: https://doi.org/10.1016/j.jcp.2011.09.003",
    extra_keyword_description = """- `williamson_condition`: allows for an optimization that allows fusing broadcast expressions with the function call `f`. However, it only works for `Array` types.
    """,
    extra_keyword_default = "williamson_condition = false"
)
Base.@kwdef struct NDBLSRK144{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
    williamson_condition::Bool = false
end

@doc explicit_rk_docstring(
    "Low-Storage Method
6-stage, fourth order low-storage, low-dissipation, low-dispersion scheme.
Fixed timestep only.", "CFRLDDRK64",
    references = "M. Calvo, J. M. Franco, L. Randez. A New Minimum Storage Runge–Kutta Scheme
    for Computational Acoustics. Journal of Computational Physics, 201, pp 1-12, 2004.
    doi: https://doi.org/10.1016/j.jcp.2004.05.012"
)
Base.@kwdef struct CFRLDDRK64{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
7-stage, fourth order low-storage low-dissipation, low-dispersion scheme with maximal accuracy and stability limit along the imaginary axes.
Fixed timestep only.",
    "TSLDDRK74",
    references = "Kostas Tselios, T. E. Simos. Optimized Runge–Kutta Methods with Minimal Dispersion and Dissipation
    for Problems arising from Computational Acoustics. Physics Letters A, 393(1-2), pp 38-47, 2007.
    doi: https://doi.org/10.1016/j.physleta.2006.10.072"
)
Base.@kwdef struct TSLDDRK74{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

@doc explicit_rk_docstring(
    "8-stage, fourth order low-storage low-dissipation, low-dispersion scheme for
discontinuous Galerkin space discretizations applied to wave propagation problems.
Optimized for PDE discretizations when maximum spatial step is small due to
geometric features of computational domain. Fixed timestep only.",
    "DGLDDRK84_C",
    references = "T. Toulorge, W. Desmet.
    Optimal Runge–Kutta Schemes for Discontinuous Galerkin Space Discretizations
    Applied to Wave Propagation Problems.
    Journal of Computational Physics, 231(4), pp 2067-2091, 2012.
    doi: https://doi.org/10.1016/j.jcp.2011.11.024",
    extra_keyword_description = """- `williamson_condition`: allows for an optimization that allows fusing broadcast expressions with the function call `f`. However, it only works for `Array` types.
    """,
    extra_keyword_default = "williamson_condition = false"
)
Base.@kwdef struct DGLDDRK84_C{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
    williamson_condition::Bool = false
end

@doc explicit_rk_docstring(
    "8-stage, fourth order low-storage low-dissipation, low-dispersion scheme for
discontinuous Galerkin space discretizations applied to wave propagation problems.
Optimized for PDE discretizations when the maximum spatial step size is not
constrained. Fixed timestep only.",
    "DGLDDRK84_F",
    references = "T. Toulorge, W. Desmet.
    Optimal Runge–Kutta Schemes for Discontinuous Galerkin Space Discretizations
    Applied to Wave Propagation Problems.
    Journal of Computational Physics, 231(4), pp 2067-2091, 2012.
    doi: https://doi.org/10.1016/j.jcp.2011.11.024",
    extra_keyword_description = """- `williamson_condition`: allows for an optimization that allows fusing broadcast expressions with the function call `f`. However, it only works for `Array` types.
    """,
    extra_keyword_default = "williamson_condition = false"
)
Base.@kwdef struct DGLDDRK84_F{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
    williamson_condition::Bool = false
end

@doc explicit_rk_docstring(
    "A fourth-order, six-stage low-storage method. Fixed timestep only.",
    "SHLDDRK64",
    references = "D. Stanescu, W. G. Habashi.
    2N-Storage Low Dissipation and Dispersion Runge-Kutta Schemes for Computational
    Acoustics.
    Journal of Computational Physics, 143(2), pp 674-681, 1998.
    doi: https://doi.org/10.1006/jcph.1998.5986
    }",
    extra_keyword_description = """- `williamson_condition`: allows for an optimization that allows fusing broadcast expressions with the function call `f`. However, it only works for `Array` types.
    """,
    extra_keyword_default = "williamson_condition = false"
)
Base.@kwdef struct SHLDDRK64{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
    williamson_condition::Bool = false
end

@doc explicit_rk_docstring(
    "6-stage, fourth order low-stage, low-dissipation, low-dispersion scheme.
Fixed timestep only.", "RK46NL",
    references = "Julien Berland, Christophe Bogey, Christophe Bailly. Low-Dissipation and Low-Dispersion Fourth-Order Runge-Kutta Algorithm. Computers & Fluids, 35(10), pp 1459-1463, 2006. doi: https://doi.org/10.1016/j.compfluid.2005.04.003",
    extra_keyword_description = """- `williamson_condition`: allows for an optimization that allows fusing broadcast expressions with the function call `f`. However, it only works for `Array` types.
    """,
    extra_keyword_default = "williamson_condition = false"
)
Base.@kwdef struct RK46NL{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
    williamson_condition::Bool = false
end

@doc explicit_rk_docstring(
    "Low-Storage Method
3-stage, second order (3S) low-storage scheme, optimized  the spectral difference method applied to wave propagation problems.",
    "ParsaniKetchesonDeconinck3S32",
    references = "Parsani, Matteo, David I. Ketcheson, and W. Deconinck.
    Optimized explicit Runge--Kutta schemes for the spectral difference method applied to wave propagation problems.
    SIAM Journal on Scientific Computing 35.2 (2013): A957-A986.
    doi: https://doi.org/10.1137/120885899"
)
Base.@kwdef struct ParsaniKetchesonDeconinck3S32{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 spectral difference method applied to wave propagation problems.",
    "ParsaniKetchesonDeconinck3S82",
    references = "Parsani, Matteo, David I. Ketcheson, and W. Deconinck.
    Optimized explicit Runge--Kutta schemes for the spectral difference method applied to wave propagation problems.
    SIAM Journal on Scientific Computing 35.2 (2013): A957-A986.
    doi: https://doi.org/10.1137/120885899"
)
Base.@kwdef struct ParsaniKetchesonDeconinck3S82{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 spectral difference method applied to wave propagation problems.",
    "ParsaniKetchesonDeconinck3S53",
    references = "Parsani, Matteo, David I. Ketcheson, and W. Deconinck.
    Optimized explicit Runge--Kutta schemes for the spectral difference method applied to wave propagation problems.
    SIAM Journal on Scientific Computing 35.2 (2013): A957-A986.
    doi: https://doi.org/10.1137/120885899"
)
Base.@kwdef struct ParsaniKetchesonDeconinck3S53{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
17-stage, third order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.",
    "ParsaniKetchesonDeconinck3S173",
    references = "Parsani, Matteo, David I. Ketcheson, and W. Deconinck.
    Optimized explicit Runge--Kutta schemes for the spectral difference method applied to wave propagation problems.
    SIAM Journal on Scientific Computing 35.2 (2013): A957-A986.
    doi: https://doi.org/10.1137/120885899"
)
Base.@kwdef struct ParsaniKetchesonDeconinck3S173{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
9-stage, fourth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.",
    "ParsaniKetchesonDeconinck3S94",
    references = "Parsani, Matteo, David I. Ketcheson, and W. Deconinck.
    Optimized explicit Runge--Kutta schemes for the spectral difference method applied to wave propagation problems.
    SIAM Journal on Scientific Computing 35.2 (2013): A957-A986.
    doi: https://doi.org/10.1137/120885899"
)
Base.@kwdef struct ParsaniKetchesonDeconinck3S94{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
18-stage, fourth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.",
    "ParsaniKetchesonDeconinck3S184",
    references = "Parsani, Matteo, David I. Ketcheson, and W. Deconinck.
    Optimized explicit Runge--Kutta schemes for the spectral difference method applied to wave propagation problems.
    SIAM Journal on Scientific Computing 35.2 (2013): A957-A986.
    doi: https://doi.org/10.1137/120885899"
)
Base.@kwdef struct ParsaniKetchesonDeconinck3S184{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
10-stage, fifth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.",
    "ParsaniKetchesonDeconinck3S105",
    references = "Parsani, Matteo, David I. Ketcheson, and W. Deconinck.
    Optimized explicit Runge--Kutta schemes for the spectral difference method applied to wave propagation problems.
    SIAM Journal on Scientific Computing 35.2 (2013): A957-A986.
    doi: https://doi.org/10.1137/120885899"
)
Base.@kwdef struct ParsaniKetchesonDeconinck3S105{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
20-stage, fifth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems.",
    "ParsaniKetchesonDeconinck3S205",
    references = "Parsani, Matteo, David I. Ketcheson, and W. Deconinck.
    Optimized explicit Runge--Kutta schemes for the spectral difference method applied to wave propagation problems.
    SIAM Journal on Scientific Computing 35.2 (2013): A957-A986.
    doi: https://doi.org/10.1137/120885899"
)
Base.@kwdef struct ParsaniKetchesonDeconinck3S205{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    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.
", "CKLLSRK43_2",
    references = """@article{kennedy2000low,
    title={Low-storage, explicit Runge--Kutta schemes for the compressible Navier--Stokes equations},
    author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael},
    journal={Applied numerical mathematics},
    volume={35},
    number={3},
    pages={177--219},
    year={2000},
    publisher={Elsevier}}"""
)
Base.@kwdef struct CKLLSRK43_2{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

@doc explicit_rk_docstring(
    "Low-Storage Method
5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.
", "CKLLSRK54_3C",
    references = """@article{kennedy2000low,
    title={Low-storage, explicit Runge--Kutta schemes for the compressible Navier--Stokes equations},
    author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael},
    journal={Applied numerical mathematics},
    volume={35},
    number={3},
    pages={177--219},
    year={2000},
    publisher={Elsevier}}"""
)
Base.@kwdef struct CKLLSRK54_3C{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

@doc explicit_rk_docstring(
    "Low-Storage Method
9-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.
", "CKLLSRK95_4S",
    references = """@article{kennedy2000low,
    title={Low-storage, explicit Runge--Kutta schemes for the compressible Navier--Stokes equations},
    author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael},
    journal={Applied numerical mathematics},
    volume={35},
    number={3},
    pages={177--219},
    year={2000},
    publisher={Elsevier}}"""
)
Base.@kwdef struct CKLLSRK95_4S{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

@doc explicit_rk_docstring(
    "Low-Storage Method
9-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.
", "CKLLSRK95_4C",
    references = """@article{kennedy2000low,
    title={Low-storage, explicit Runge--Kutta schemes for the compressible Navier--Stokes equations},
    author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael},
    journal={Applied numerical mathematics},
    volume={35},
    number={3},
    pages={177--219},
    year={2000},
    publisher={Elsevier}}"""
)
Base.@kwdef struct CKLLSRK95_4C{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

@doc explicit_rk_docstring(
    "Low-Storage Method
9-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.
", "CKLLSRK95_4M",
    references = """@article{kennedy2000low,
    title={Low-storage, explicit Runge--Kutta schemes for the compressible Navier--Stokes equations},
    author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael},
    journal={Applied numerical mathematics},
    volume={35},
    number={3},
    pages={177--219},
    year={2000},
    publisher={Elsevier}}"""
)
Base.@kwdef struct CKLLSRK95_4M{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

@doc explicit_rk_docstring(
    "Low-Storage Method
5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.
", "CKLLSRK54_3C_3R",
    references = """@article{kennedy2000low,
    title={Low-storage, explicit Runge--Kutta schemes for the compressible Navier--Stokes equations},
    author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael},
    journal={Applied numerical mathematics},
    volume={35},
    number={3},
    pages={177--219},
    year={2000},
    publisher={Elsevier}}"""
)
Base.@kwdef struct CKLLSRK54_3C_3R{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

@doc explicit_rk_docstring(
    "Low-Storage Method
5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.
", "CKLLSRK54_3M_3R",
    references = """@article{kennedy2000low,
    title={Low-storage, explicit Runge--Kutta schemes for the compressible Navier--Stokes equations},
    author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael},
    journal={Applied numerical mathematics},
    volume={35},
    number={3},
    pages={177--219},
    year={2000},
    publisher={Elsevier}}"""
)
Base.@kwdef struct CKLLSRK54_3M_3R{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

@doc explicit_rk_docstring(
    "Low-Storage Method
5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.
", "CKLLSRK54_3N_3R",
    references = """@article{kennedy2000low,
    title={Low-storage, explicit Runge--Kutta schemes for the compressible Navier--Stokes equations},
    author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael},
    journal={Applied numerical mathematics},
    volume={35},
    number={3},
    pages={177--219},
    year={2000},
    publisher={Elsevier}}"""
)
Base.@kwdef struct CKLLSRK54_3N_3R{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    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 low-storage scheme, optimized for compressible Navier–Stokes equations.
", "CKLLSRK85_4C_3R",
    references = """@article{kennedy2000low,
    title={Low-storage, explicit Runge--Kutta schemes for the compressible Navier--Stokes equations},
    author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael},
    journal={Applied numerical mathematics},
    volume={35},
    number={3},
    pages={177--219},
    year={2000},
    publisher={Elsevier}}"""
)
Base.@kwdef struct CKLLSRK85_4C_3R{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    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 low-storage scheme, optimized for compressible Navier–Stokes equations.
", "CKLLSRK85_4M_3R",
    references = """@article{kennedy2000low,
    title={Low-storage, explicit Runge--Kutta schemes for the compressible Navier--Stokes equations},
    author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael},
    journal={Applied numerical mathematics},
    volume={35},
    number={3},
    pages={177--219},
    year={2000},
    publisher={Elsevier}}"""
)
Base.@kwdef struct CKLLSRK85_4M_3R{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    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 low-storage scheme, optimized for compressible Navier–Stokes equations.
", "CKLLSRK85_4P_3R",
    references = """@article{kennedy2000low,
    title={Low-storage, explicit Runge--Kutta schemes for the compressible Navier--Stokes equations},
    author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael},
    journal={Applied numerical mathematics},
    volume={35},
    number={3},
    pages={177--219},
    year={2000},
    publisher={Elsevier}}"""
)
Base.@kwdef struct CKLLSRK85_4P_3R{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

@doc explicit_rk_docstring(
    "Low-Storage Method
5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.
", "CKLLSRK54_3N_4R",
    references = """@article{kennedy2000low,
    title={Low-storage, explicit Runge--Kutta schemes for the compressible Navier--Stokes equations},
    author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael},
    journal={Applied numerical mathematics},
    volume={35},
    number={3},
    pages={177--219},
    year={2000},
    publisher={Elsevier}}"""
)
Base.@kwdef struct CKLLSRK54_3N_4R{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

@doc explicit_rk_docstring(
    "Low-Storage Method
5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations.
", "CKLLSRK54_3M_4R",
    references = """@article{kennedy2000low,
    title={Low-storage, explicit Runge--Kutta schemes for the compressible Navier--Stokes equations},
    author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael},
    journal={Applied numerical mathematics},
    volume={35},
    number={3},
    pages={177--219},
    year={2000},
    publisher={Elsevier}}"""
)
Base.@kwdef struct CKLLSRK54_3M_4R{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

@doc explicit_rk_docstring(
    "6-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.",
    "CKLLSRK65_4M_4R",
    references = """@article{kennedy2000low,
    title={Low-storage, explicit Runge--Kutta schemes for the compressible Navier--Stokes equations},
    author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael},
    journal={Applied numerical mathematics},
    volume={35},
    number={3},
    pages={177--219},
    year={2000},
    publisher={Elsevier}}"""
)
Base.@kwdef struct CKLLSRK65_4M_4R{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    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 low-storage scheme, optimized for compressible Navier–Stokes equations.",
    "CKLLSRK85_4FM_4R",
    references = """@article{kennedy2000low,
    title={Low-storage, explicit Runge--Kutta schemes for the compressible Navier--Stokes equations},
    author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael},
    journal={Applied numerical mathematics},
    volume={35},
    number={3},
    pages={177--219},
    year={2000},
    publisher={Elsevier}}"""
)
Base.@kwdef struct CKLLSRK85_4FM_4R{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

@doc explicit_rk_docstring(
    "CKLLSRK75_4M_5R: Low-Storage Method
7-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations.",
    "CKLLSRK75_4M_5R",
    references = """@article{kennedy2000low,
    title={Low-storage, explicit Runge--Kutta schemes for the compressible Navier--Stokes equations},
    author={Kennedy, Christopher A and Carpenter, Mark H and Lewis, R Michael},
    journal={Applied numerical mathematics},
    volume={35},
    number={3},
    pages={177--219},
    year={2000},
    publisher={Elsevier}}"""
)
Base.@kwdef struct CKLLSRK75_4M_5R{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

@doc explicit_rk_docstring(
    "A third-order, five-stage method with embedded error estimator
designed for spectral element discretizations of compressible fluid mechanics.",
    "RDPK3Sp35",
    references = "Ranocha, Dalcin, Parsani, Ketcheson (2021)
    Optimized Runge-Kutta Methods with Automatic Step Size Control for
    Compressible Computational Fluid Dynamics
    [arXiv:2104.06836](https://arxiv.org/abs/2104.06836)"
)
Base.@kwdef struct RDPK3Sp35{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

@doc explicit_rk_docstring(
    "A third-order, five-stage method with embedded error estimator
using the FSAL property designed for spectral element discretizations of
compressible fluid mechanics.",
    "RDPK3SpFSAL35",
    references = "Ranocha, Dalcin, Parsani, Ketcheson (2021)
    Optimized Runge-Kutta Methods with Automatic Step Size Control for
    Compressible Computational Fluid Dynamics
    [arXiv:2104.06836](https://arxiv.org/abs/2104.06836)"
)
Base.@kwdef struct RDPK3SpFSAL35{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

@doc explicit_rk_docstring(
    "A fourth-order, nine-stage method with embedded error estimator
designed for spectral element discretizations of compressible fluid mechanics.",
    "RDPK3Sp49",
    references = "Ranocha, Dalcin, Parsani, Ketcheson (2021)
    Optimized Runge-Kutta Methods with Automatic Step Size Control for
    Compressible Computational Fluid Dynamics
    [arXiv:2104.06836](https://arxiv.org/abs/2104.06836)"
)
Base.@kwdef struct RDPK3Sp49{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

@doc explicit_rk_docstring(
    "A fourth-order, nine-stage method with embedded error estimator
using the FSAL property designed for spectral element discretizations of
compressible fluid mechanics.",
    "RDPK3SpFSAL49",
    references = "Ranocha, Dalcin, Parsani, Ketcheson (2021)
    Optimized Runge-Kutta Methods with Automatic Step Size Control for
    Compressible Computational Fluid Dynamics
    [arXiv:2104.06836](https://arxiv.org/abs/2104.06836)"
)
Base.@kwdef struct RDPK3SpFSAL49{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

@doc explicit_rk_docstring(
    "A fifth-order, ten-stage method with embedded error estimator
designed for spectral element discretizations of compressible fluid mechanics.",
    "RDPK3Sp510",
    references = "Ranocha, Dalcin, Parsani, Ketcheson (2021)
    Optimized Runge-Kutta Methods with Automatic Step Size Control for
    Compressible Computational Fluid Dynamics
    [arXiv:2104.06836](https://arxiv.org/abs/2104.06836)"
)
Base.@kwdef struct RDPK3Sp510{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

@doc explicit_rk_docstring(
    "A fifth-order, ten-stage method with embedded error estimator
using the FSAL property designed for spectral element discretizations of
compressible fluid mechanics.",
    "RDPK3SpFSAL510",
    references = "Ranocha, Dalcin, Parsani, Ketcheson (2021)
    Optimized Runge-Kutta Methods with Automatic Step Size Control for
    Compressible Computational Fluid Dynamics
    [arXiv:2104.06836](https://arxiv.org/abs/2104.06836)"
)
Base.@kwdef struct RDPK3SpFSAL510{StageLimiter, StepLimiter, Thread} <:
    OrdinaryDiffEqAdaptiveAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

#Low Storage Explicit Runge-Kutta Methods

@doc explicit_rk_docstring(
    "13-stage, fourth order low-storage method with optimized stability regions for
advection-dominated problems. Fixed timestep only.",
    "NDBLSRK134",
    references = "Jens Niegemann, Richard Diehl, Kurt Busch.
    Efficient Low-Storage Runge–Kutta Schemes with Optimized Stability Regions.
    Journal of Computational Physics, 231, pp 364-372, 2012.
    doi: https://doi.org/10.1016/j.jcp.2011.09.003",
    extra_keyword_description = """- `williamson_condition`: allows for an optimization that allows fusing broadcast expressions with the function call `f`. However, it only works for `Array` types.
    """,
    extra_keyword_default = "williamson_condition = false"
)
Base.@kwdef struct NDBLSRK134{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
    williamson_condition::Bool = false
end

@doc explicit_rk_docstring(
    "Low dissipation and dispersion Runge-Kutta schemes for computational acoustics",
    "SHLDDRK_2N",
    references = "@article{stanescu19982n,
    title={2N-storage low dissipation and dispersion Runge-Kutta schemes for computational acoustics},
    author={Stanescu, D and Habashi, WG},
    journal={Journal of Computational Physics},
    volume={143},
    number={2},
    pages={674--681},
    year={1998},
    publisher={Elsevier}}"
)
Base.@kwdef struct SHLDDRK_2N{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

@doc explicit_rk_docstring(
    "Low dissipation and dispersion Runge-Kutta schemes for computational acoustics",
    "SHLDDRK52",
    references = "@article{stanescu19982n,
    title={2N-storage low dissipation and dispersion Runge-Kutta schemes for computational acoustics},
    author={Stanescu, D and Habashi, WG},
    journal={Journal of Computational Physics},
    volume={143},
    number={2},
    pages={674--681},
    year={1998},
    publisher={Elsevier}}"
)
Base.@kwdef struct SHLDDRK52{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm
    stage_limiter!::StageLimiter = trivial_limiter!
    step_limiter!::StepLimiter = trivial_limiter!
    thread::Thread = Serial()
end

OrdinaryDiffEqCore.has_stage_limiter(
    ::Union{
        CarpenterKennedy2N54, DGLDDRK73_C, DGLDDRK84_C, DGLDDRK84_F, NDBLSRK124,
        NDBLSRK134, NDBLSRK144, ORK256, RDPK3Sp35, RDPK3Sp49, RDPK3Sp510, RDPK3SpFSAL35,
        RDPK3SpFSAL49, RDPK3SpFSAL510, RK46NL, SHLDDRK52, SHLDDRK64, SHLDDRK_2N,
    },
) = true
