diff --git a/.gitignore b/.gitignore index 98ec239070..b3c0a4b40d 100644 --- a/.gitignore +++ b/.gitignore @@ -8,3 +8,5 @@ Manifest.toml profile.pb.gz .*.swp LocalPreferences.toml + +docs/build \ No newline at end of file diff --git a/docs/Project.toml b/docs/Project.toml index 3a52a5db24..6bb99e1024 100644 --- a/docs/Project.toml +++ b/docs/Project.toml @@ -1,5 +1,6 @@ [deps] Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4" +OrdinaryDiffEq = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed" [compat] Documenter = "0.27" diff --git a/src/OrdinaryDiffEq.jl b/src/OrdinaryDiffEq.jl index b7f9de6293..5a91cc2742 100644 --- a/src/OrdinaryDiffEq.jl +++ b/src/OrdinaryDiffEq.jl @@ -126,7 +126,10 @@ import Preferences DEFAULT_PRECS(W, du, u, p, t, newW, Plprev, Prprev, solverdata) = nothing, nothing include("misc_utils.jl") + include("algorithms.jl") +include("algorithms/explicit_rk.jl") + include("alg_utils.jl") include("nlsolve/type.jl") diff --git a/src/alg_utils.jl b/src/alg_utils.jl index 6edb7bcf1e..17d0fe95a6 100644 --- a/src/alg_utils.jl +++ b/src/alg_utils.jl @@ -921,6 +921,7 @@ Return the SSP coefficient of the ODE algorithm `alg`. If one time step of size with step sizes `cᵢ * dt`, the SSP coefficient is the minimal value of `1/cᵢ`. # Examples + ```julia-repl julia> ssp_coefficient(SSPRK104()) 6 diff --git a/src/algorithms.jl b/src/algorithms.jl index 0b588e8271..972d8aa0b6 100644 --- a/src/algorithms.jl +++ b/src/algorithms.jl @@ -85,24 +85,10 @@ ExplicitRK(; tableau = ODE_DEFAULT_TABLEAU) = ExplicitRK(tableau) TruncatedStacktraces.@truncate_stacktrace ExplicitRK @inline trivial_limiter!(u, integrator, p, t) = nothing -""" -Euler - The canonical forward Euler method. Fixed timestep only. -""" -struct Euler <: OrdinaryDiffEqAlgorithm end -""" -KuttaPRK2p5: Parallel Explicit Runge-Kutta Method - A 5 parallel, 2 processor explicit Runge-Kutta method of 5th order. - These methods utilize multithreading on the f calls to parallelize the problem. - This requires that simultaneous calls to f are thread-safe. -""" -struct KuttaPRK2p5{TO} <: OrdinaryDiffEqAlgorithm - threading::TO -end -KuttaPRK2p5(; threading = true) = KuttaPRK2p5(threading) """ AitkenNeville: Parallelized Explicit Extrapolation Method - Euler extrapolation using Aitken-Neville with the Romberg Sequence. +Euler extrapolation using Aitken-Neville with the Romberg Sequence. """ struct AitkenNeville{TO} <: OrdinaryDiffEqExtrapolationVarOrderVarStepAlgorithm max_order::Int @@ -115,8 +101,8 @@ function AitkenNeville(; max_order = 10, min_order = 1, init_order = 5, threadin end """ ImplicitEulerExtrapolation: Parallelized Implicit Extrapolation Method - Extrapolation of implicit Euler method with Romberg sequence. - Similar to Hairer's SEULEX. +Extrapolation of implicit Euler method with Romberg sequence. +Similar to Hairer's SEULEX. """ struct ImplicitEulerExtrapolation{CS, AD, F, P, FDT, ST, CJ, TO} <: OrdinaryDiffEqImplicitExtrapolationAlgorithm{CS, AD, FDT, ST, CJ} @@ -171,7 +157,7 @@ Initial order: " * lpad(init_order, 2, " ") * " --> " * lpad(init_order, 2, " ") end """ ExtrapolationMidpointDeuflhard: Parallelized Explicit Extrapolation Method - Midpoint extrapolation using Barycentric coordinates +Midpoint extrapolation using Barycentric coordinates """ struct ExtrapolationMidpointDeuflhard{TO} <: OrdinaryDiffEqExtrapolationVarOrderVarStepAlgorithm @@ -224,7 +210,7 @@ Initial order: " * lpad(init_order, 2, " ") * " --> " * lpad(init_order, 2, " ") end """ ImplicitDeuflhardExtrapolation: Parallelized Implicit Extrapolation Method - Midpoint extrapolation using Barycentric coordinates +Midpoint extrapolation using Barycentric coordinates """ struct ImplicitDeuflhardExtrapolation{CS, AD, F, P, FDT, ST, CJ, TO} <: OrdinaryDiffEqImplicitExtrapolationAlgorithm{CS, AD, FDT, ST, CJ} @@ -282,7 +268,7 @@ Initial order: " * lpad(init_order, 2, " ") * " --> " * lpad(init_order, 2, " ") end """ ExtrapolationMidpointHairerWanner: Parallelized Explicit Extrapolation Method - Midpoint extrapolation using Barycentric coordinates, following Hairer's ODEX in the adaptivity behavior. +Midpoint extrapolation using Barycentric coordinates, following Hairer's ODEX in the adaptivity behavior. """ struct ExtrapolationMidpointHairerWanner{TO} <: OrdinaryDiffEqExtrapolationVarOrderVarStepAlgorithm @@ -336,7 +322,7 @@ Initial order: " * lpad(init_order, 2, " ") * " --> " * lpad(init_order, 2, " ") end """ ImplicitHairerWannerExtrapolation: Parallelized Implicit Extrapolation Method - Midpoint extrapolation using Barycentric coordinates, following Hairer's SODEX in the adaptivity behavior. +Midpoint extrapolation using Barycentric coordinates, following Hairer's SODEX in the adaptivity behavior. """ struct ImplicitHairerWannerExtrapolation{CS, AD, F, P, FDT, ST, CJ, TO} <: OrdinaryDiffEqImplicitExtrapolationAlgorithm{CS, AD, FDT, ST, CJ} @@ -397,7 +383,7 @@ end """ ImplicitEulerBarycentricExtrapolation: Parallelized Implicit Extrapolation Method - Euler extrapolation using Barycentric coordinates, following Hairer's SODEX in the adaptivity behavior. +Euler extrapolation using Barycentric coordinates, following Hairer's SODEX in the adaptivity behavior. """ struct ImplicitEulerBarycentricExtrapolation{CS, AD, F, P, FDT, ST, CJ, TO} <: OrdinaryDiffEqImplicitExtrapolationAlgorithm{CS, AD, FDT, ST, CJ} @@ -465,12 +451,11 @@ Initial order: " * lpad(init_order, 2, " ") * " --> " * lpad(init_order, 2, " ") end """ - RK46NL(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + MSRK6(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, step_limiter! = OrdinaryDiffEq.trivial_limiter!, thread = OrdinaryDiffEq.False()) -6-stage, fourth order low-stage, low-dissipation, low-dispersion scheme. -Fixed timestep only. +6th order Explicit RK method. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -482,43 +467,41 @@ default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. ## Reference -- 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 + +Misha Stepanov - https://arxiv.org/pdf/2202.08443.pdf : Table 4. """ -struct RK46NL{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct MSRK6{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function RK46NL(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function MSRK6(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - RK46NL{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + MSRK6{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function RK46NL(stage_limiter!, step_limiter! = trivial_limiter!) - RK46NL{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function MSRK6(stage_limiter!, step_limiter! = trivial_limiter!) + MSRK6{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::RK46NL) - print(io, "RK46NL(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::MSRK6) + print(io, "MSRK6(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - Heun(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + Stepanov5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -Explicit Runge-Kutta Method -The second order Heun's method. Uses embedded Euler method for adaptivity. +5th order Explicit RK method. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -528,40 +511,49 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. + +## Reference + +@article{Stepanov2021Embedded5, +title={Embedded (4, 5) pairs of explicit 7-stage Runge–Kutta methods with FSAL property}, +author={Misha Stepanov}, +journal={Calcolo}, +year={2021}, +volume={59} +} """ -struct Heun{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct Stepanov5{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function Heun(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function Stepanov5(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - Heun{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + Stepanov5{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function Heun(stage_limiter!, step_limiter! = trivial_limiter!) - Heun{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function Stepanov5(stage_limiter!, step_limiter! = trivial_limiter!) + Stepanov5{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::Heun) - print(io, "Heun(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::Stepanov5) + print(io, "Stepanov5(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - Ralston(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + SIR54(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, step_limiter! = OrdinaryDiffEq.trivial_limiter!, thread = OrdinaryDiffEq.False()) -Explicit Runge-Kutta Method -The optimized second order midpoint method. Uses embedded Euler method for adaptivity. +5th order Explicit RK method suited for SIR-type epidemic models. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -571,40 +563,53 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. + +## Reference + +@article{Kovalnogov2020RungeKuttaPS, +title={Runge–Kutta pairs suited for SIR‐type epidemic models}, +author={Vladislav N. Kovalnogov and Theodore E. Simos and Ch. Tsitouras}, +journal={Mathematical Methods in the Applied Sciences}, +year={2020}, +volume={44}, +pages={5210 - 5216} +} """ -struct Ralston{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct SIR54{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function Ralston(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function SIR54(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - Ralston{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + SIR54{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function Ralston(stage_limiter!, step_limiter! = trivial_limiter!) - Ralston{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function SIR54(stage_limiter!, step_limiter! = trivial_limiter!) + SIR54{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::Ralston) - print(io, "Ralston(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::SIR54) + print(io, "SIR54(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - Ralston(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + CarpenterKennedy2N54(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False(), + williamson_condition = true) -Explicit Runge-Kutta Method -The second order midpoint method. Uses embedded Euler method for adaptivity. +A fourth-order, five-stage explicit low-storage method of Carpenter and Kennedy +(free 3rd order Hermite interpolant). Fixed timestep only. Designed for +hyperbolic PDEs (stability properties). Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -614,41 +619,54 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. + +## References + +@article{carpenter1994fourth, +title={Fourth-order 2N-storage Runge-Kutta schemes}, +author={Carpenter, Mark H and Kennedy, Christopher A}, +year={1994} +} """ -struct Midpoint{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct CarpenterKennedy2N54{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread + williamson_condition::Bool end -function Midpoint(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - Midpoint{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function CarpenterKennedy2N54(; stage_limiter! = trivial_limiter!, + step_limiter! = trivial_limiter!, thread = False(), + williamson_condition = true) + CarpenterKennedy2N54{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, - thread) + thread, + williamson_condition) end # for backwards compatibility -function Midpoint(stage_limiter!, step_limiter! = trivial_limiter!) - Midpoint{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function CarpenterKennedy2N54(stage_limiter!, step_limiter! = trivial_limiter!; + williamson_condition = true) + CarpenterKennedy2N54{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, - False()) + False(), + williamson_condition) end -function Base.show(io::IO, alg::Midpoint) - print(io, "Midpoint(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::CarpenterKennedy2N54) + print(io, "CarpenterKennedy2N54(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") + ", thread = ", alg.thread, + ", williamson_condition = ", alg.williamson_condition, ")") end """ - RK4(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + SHLDDRK64(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False(), + williamson_condition = true) -Explicit Runge-Kutta Method -The canonical Runge-Kutta Order 4 method. -Uses a defect control for adaptive stepping using maximum error over the whole interval. +A fourth-order, six-stage explicit low-storage method. Fixed timestep only. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -659,121 +677,104 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. -## Reference -@article{shampine2005solving, - title={Solving ODEs and DDEs with residual control}, - author={Shampine, LF}, - journal={Applied Numerical Mathematics}, - volume={52}, - number={1}, - pages={113--127}, - year={2005}, - publisher={Elsevier} -} +## 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 """ -struct RK4{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct SHLDDRK64{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread + williamson_condition::Bool end -function RK4(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - RK4{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function SHLDDRK64(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, + thread = False(), williamson_condition = true) + SHLDDRK64{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, - thread) + thread, + williamson_condition) end # for backwards compatibility -function RK4(stage_limiter!, step_limiter! = trivial_limiter!) - RK4{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) +function SHLDDRK64(stage_limiter!, step_limiter! = trivial_limiter!; + williamson_condition = true) + SHLDDRK64{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, False(), + williamson_condition) end -function Base.show(io::IO, alg::RK4) - print(io, "RK4(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::SHLDDRK64) + print(io, "SHLDDRK64(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") + ", thread = ", alg.thread, + ", williamson_condition = ", alg.williamson_condition, ")") end -struct RKM{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct SHLDDRK52{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function RKM(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function SHLDDRK52(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - RKM{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + SHLDDRK52{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function RKM(stage_limiter!, step_limiter! = trivial_limiter!) - RKM{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function SHLDDRK52(stage_limiter!, step_limiter! = trivial_limiter!) + SHLDDRK52{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::RKM) - print(io, "RKM(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::SHLDDRK52) + print(io, "SHLDDRK52(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end -""" - MSRK5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -5th order Explicit RK method. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. - -## Reference -Misha Stepanov - https://arxiv.org/pdf/2202.08443.pdf : Figure 3. -""" -struct MSRK5{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct SHLDDRK_2N{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function MSRK5(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function SHLDDRK_2N(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - MSRK5{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + SHLDDRK_2N{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function MSRK5(stage_limiter!, step_limiter! = trivial_limiter!) - MSRK5{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function SHLDDRK_2N(stage_limiter!, step_limiter! = trivial_limiter!) + SHLDDRK_2N{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::MSRK5) - print(io, "MSRK5(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::SHLDDRK_2N) + print(io, "SHLDDRK_2N(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - MSRK6(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + HSLDDRK64(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, step_limiter! = OrdinaryDiffEq.trivial_limiter!, thread = OrdinaryDiffEq.False()) -6th order Explicit RK method. +Low-Storage Method +6-stage, fourth order low-stage, low-dissipation, low-dispersion scheme. +Fixed timestep only. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -783,42 +784,38 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. - -## Reference -Misha Stepanov - https://arxiv.org/pdf/2202.08443.pdf : Table 4. """ -struct MSRK6{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct HSLDDRK64{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread + williamson_condition::Bool + function HSLDDRK64(stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!; + williamson_condition = true) + Base.depwarn("HSLDDRK64 is deprecated, use SHLDDRK64 instead.", :HSLDDRK64) + SHLDDRK64(stage_limiter!, step_limiter!, thread; + williamson_condition = williamson_condition) + end end -function MSRK6(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - MSRK6{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function MSRK6(stage_limiter!, step_limiter! = trivial_limiter!) - MSRK6{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::MSRK6) - print(io, "MSRK6(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::HSLDDRK64) + print(io, "HSLDDRK64(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") + ", thread = ", alg.thread, + ", williamson_condition = ", alg.williamson_condition, + ")") end """ - Stepanov5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + DGLDDRK73_C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False(), + williamson_condition = true) -5th order Explicit RK method. +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. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -829,47 +826,55 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. -## Reference -@article{Stepanov2021Embedded5, - title={Embedded (4, 5) pairs of explicit 7-stage Runge–Kutta methods with FSAL property}, - author={Misha Stepanov}, - journal={Calcolo}, - year={2021}, - volume={59} -} +## 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 """ -struct Stepanov5{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct DGLDDRK73_C{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread + williamson_condition::Bool end -function Stepanov5(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - Stepanov5{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function DGLDDRK73_C(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, + thread = False(), williamson_condition = true) + DGLDDRK73_C{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, - thread) + thread, + williamson_condition) end # for backwards compatibility -function Stepanov5(stage_limiter!, step_limiter! = trivial_limiter!) - Stepanov5{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function DGLDDRK73_C(stage_limiter!, step_limiter! = trivial_limiter!; + williamson_condition = true) + DGLDDRK73_C{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, - False()) + False(), + williamson_condition) end -function Base.show(io::IO, alg::Stepanov5) - print(io, "Stepanov5(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::DGLDDRK73_C) + print(io, "DGLDDRK73_C(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") + ", thread = ", alg.thread, + ", williamson_condition = ", alg.williamson_condition, ")") end """ - SIR54(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + DGLDDRK84_C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False(), + williamson_condition = true) -5th order Explicit RK method suited for SIR-type epidemic models. +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. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -880,51 +885,55 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. +## References -## Reference -@article{Kovalnogov2020RungeKuttaPS, - title={Runge–Kutta pairs suited for SIR‐type epidemic models}, - author={Vladislav N. Kovalnogov and Theodore E. Simos and Ch. Tsitouras}, - journal={Mathematical Methods in the Applied Sciences}, - year={2020}, - volume={44}, - pages={5210 - 5216} -} + - 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 """ -struct SIR54{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct DGLDDRK84_C{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread + williamson_condition::Bool end -function SIR54(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - SIR54{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread) +function DGLDDRK84_C(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, + thread = False(), williamson_condition = true) + DGLDDRK84_C{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + step_limiter!, + thread, + williamson_condition) end # for backwards compatibility -function SIR54(stage_limiter!, step_limiter! = trivial_limiter!) - SIR54{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function DGLDDRK84_C(stage_limiter!, step_limiter! = trivial_limiter!; + williamson_condition = true) + DGLDDRK84_C{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, - False()) + False(), + williamson_condition) end -function Base.show(io::IO, alg::SIR54) - print(io, "SIR54(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::DGLDDRK84_C) + print(io, "DGLDDRK84_C(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") + ", thread = ", alg.thread, + ", williamson_condition = ", alg.williamson_condition, ")") end """ - Anas5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + DGLDDRK84_F(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False(), + williamson_condition = true) -Explicit Runge-Kutta Method - 4th order Runge-Kutta method designed for periodic problems. - Requires a periodicity estimate, which when accurate the method becomes 5th order (and is otherwise 4th order with less error for better estimates). +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. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -934,45 +943,54 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. + +## 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 """ -struct Anas5{StageLimiter, StepLimiter, Thread, T} <: OrdinaryDiffEqAlgorithm +struct DGLDDRK84_F{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread - w::T + williamson_condition::Bool end -function Anas5(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False(), w = 1) - Anas5{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread), typeof(w)}(stage_limiter!, +function DGLDDRK84_F(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, + thread = False(), williamson_condition = true) + DGLDDRK84_F{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread, - w) + williamson_condition) end # for backwards compatibility -function Anas5(stage_limiter!, step_limiter! = trivial_limiter!; w = 1) - Anas5{typeof(stage_limiter!), typeof(step_limiter!), False, typeof(w)}(stage_limiter!, +function DGLDDRK84_F(stage_limiter!, step_limiter! = trivial_limiter!; + williamson_condition = true) + DGLDDRK84_F{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, - False(), w) + False(), + williamson_condition) end -function Base.show(io::IO, alg::Anas5) - print(io, "Anas5(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! =", alg.step_limiter!, +function Base.show(io::IO, alg::DGLDDRK84_F) + print(io, "DGLDDRK84_F(stage_limiter! = ", alg.stage_limiter!, + ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, - ", periodicity estimate = ", alg.w, - ")") + ", williamson_condition = ", alg.williamson_condition, ")") end """ - ORK256(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False(), - williamson_condition = true) + NDBLSRK124(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False(), + williamson_condition = true) -A second-order, five-stage explicit Runge-Kutta method for wave propagation -equations. Fixed timestep only. +12-stage, fourth order low-storage method with optimized stability regions for +advection-dominated problems. Fixed timestep only. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -984,51 +1002,50 @@ default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. ## 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 + + - 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 """ -struct ORK256{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct NDBLSRK124{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread williamson_condition::Bool end -function ORK256(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function NDBLSRK124(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False(), williamson_condition = true) - ORK256{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + NDBLSRK124{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread, williamson_condition) end # for backwards compatibility -function ORK256(stage_limiter!, step_limiter! = trivial_limiter!; +function NDBLSRK124(stage_limiter!, step_limiter! = trivial_limiter!; williamson_condition = true) - ORK256{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + NDBLSRK124{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False(), williamson_condition) end -function Base.show(io::IO, alg::ORK256) - print(io, "ORK256(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::NDBLSRK124) + print(io, "NDBLSRK124(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ", williamson_condition = ", alg.williamson_condition, ")") end """ - CarpenterKennedy2N54(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False(), - williamson_condition = true) + NDBLSRK134(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False(), + williamson_condition = true) -A fourth-order, five-stage explicit low-storage method of Carpenter and Kennedy -(free 3rd order Hermite interpolant). Fixed timestep only. Designed for -hyperbolic PDEs (stability properties). +13-stage, fourth order low-storage method with optimized stability regions for +advection-dominated problems. Fixed timestep only. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -1040,51 +1057,50 @@ default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. ## References -@article{carpenter1994fourth, - title={Fourth-order 2N-storage Runge-Kutta schemes}, - author={Carpenter, Mark H and Kennedy, Christopher A}, - year={1994} -} + + - 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 """ -struct CarpenterKennedy2N54{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct NDBLSRK134{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread williamson_condition::Bool end -function CarpenterKennedy2N54(; stage_limiter! = trivial_limiter!, - step_limiter! = trivial_limiter!, thread = False(), - williamson_condition = true) - CarpenterKennedy2N54{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function NDBLSRK134(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, + thread = False(), williamson_condition = true) + NDBLSRK134{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread, williamson_condition) end # for backwards compatibility -function CarpenterKennedy2N54(stage_limiter!, step_limiter! = trivial_limiter!; +function NDBLSRK134(stage_limiter!, step_limiter! = trivial_limiter!; williamson_condition = true) - CarpenterKennedy2N54{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False(), + NDBLSRK134{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, False(), williamson_condition) end -function Base.show(io::IO, alg::CarpenterKennedy2N54) - print(io, "CarpenterKennedy2N54(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::NDBLSRK134) + print(io, "NDBLSRK134(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ", williamson_condition = ", alg.williamson_condition, ")") end """ - SHLDDRK64(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False(), - williamson_condition = true) + NDBLSRK144(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False(), + williamson_condition = true) -A fourth-order, six-stage explicit low-storage method. Fixed timestep only. +14-stage, fourth order low-storage method with optimized stability regions for +advection-dominated problems. Fixed timestep only. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -1096,102 +1112,149 @@ default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. ## 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 + + - 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 """ -struct SHLDDRK64{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct NDBLSRK144{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread williamson_condition::Bool end -function SHLDDRK64(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function NDBLSRK144(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False(), williamson_condition = true) - SHLDDRK64{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + NDBLSRK144{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread, williamson_condition) end # for backwards compatibility -function SHLDDRK64(stage_limiter!, step_limiter! = trivial_limiter!; +function NDBLSRK144(stage_limiter!, step_limiter! = trivial_limiter!; williamson_condition = true) - SHLDDRK64{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + NDBLSRK144{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False(), williamson_condition) end -function Base.show(io::IO, alg::SHLDDRK64) - print(io, "SHLDDRK64(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::NDBLSRK144) + print(io, "NDBLSRK144(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ", williamson_condition = ", alg.williamson_condition, ")") end -struct SHLDDRK52{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +""" + CFRLDDRK64(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) + +Low-Storage Method +6-stage, fourth order low-storage, low-dissipation, low-dispersion scheme. +Fixed timestep only. + +Like SSPRK methods, this method also takes optional arguments `stage_limiter!` +and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions +of the form `limiter!(u, integrator, p, t)`. + +The argument `thread` determines whether internal broadcasting on +appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, +default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when +Julia is started with multiple threads. + +## Reference + +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 +""" +struct CFRLDDRK64{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function SHLDDRK52(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function CFRLDDRK64(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - SHLDDRK52{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + CFRLDDRK64{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function SHLDDRK52(stage_limiter!, step_limiter! = trivial_limiter!) - SHLDDRK52{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function CFRLDDRK64(stage_limiter!, step_limiter! = trivial_limiter!) + CFRLDDRK64{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::SHLDDRK52) - print(io, "SHLDDRK52(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::CFRLDDRK64) + print(io, "CFRLDDRK64(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end -struct SHLDDRK_2N{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +""" + Ralston(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) + +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. + +Like SSPRK methods, this method also takes optional arguments `stage_limiter!` +and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions +of the form `limiter!(u, integrator, p, t)`. + +The argument `thread` determines whether internal broadcasting on +appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, +default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when +Julia is started with multiple threads. + +#Reference +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 +""" +struct TSLDDRK74{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function SHLDDRK_2N(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function TSLDDRK74(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - SHLDDRK_2N{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + TSLDDRK74{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function SHLDDRK_2N(stage_limiter!, step_limiter! = trivial_limiter!) - SHLDDRK_2N{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function TSLDDRK74(stage_limiter!, step_limiter! = trivial_limiter!) + TSLDDRK74{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::SHLDDRK_2N) - print(io, "SHLDDRK_2N(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::TSLDDRK74) + print(io, "TSLDDRK74(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") + ", thread = ", alg.thread, + ")") end """ - HSLDDRK64(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + CKLLSRK43_2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, step_limiter! = OrdinaryDiffEq.trivial_limiter!, thread = OrdinaryDiffEq.False()) Low-Storage Method -6-stage, fourth order low-stage, low-dissipation, low-dispersion scheme. -Fixed timestep only. +4-stage, third order low-storage scheme, optimized for compressible Navier–Stokes equations. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -1202,37 +1265,40 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. """ -struct HSLDDRK64{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct CKLLSRK43_2{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread - williamson_condition::Bool - function HSLDDRK64(stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!; - williamson_condition = true) - Base.depwarn("HSLDDRK64 is deprecated, use SHLDDRK64 instead.", :HSLDDRK64) - SHLDDRK64(stage_limiter!, step_limiter!, thread; - williamson_condition = williamson_condition) - end end -function Base.show(io::IO, alg::HSLDDRK64) - print(io, "HSLDDRK64(stage_limiter! = ", alg.stage_limiter!, +function CKLLSRK43_2(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, + thread = False()) + CKLLSRK43_2{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + step_limiter!, + thread) +end + +# for backwards compatibility +function CKLLSRK43_2(stage_limiter!, step_limiter! = trivial_limiter!) + CKLLSRK43_2{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, + False()) +end + +function Base.show(io::IO, alg::CKLLSRK43_2) + print(io, "CKLLSRK43_2(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, - ", williamson_condition = ", alg.williamson_condition, ")") end """ - DGLDDRK73_C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False(), - williamson_condition = true) + CKLLSRK54_3C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -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. +Low-Storage Method +5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -1242,1262 +1308,41 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. - -## 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 """ -struct DGLDDRK73_C{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct CKLLSRK54_3C{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread - williamson_condition::Bool end -function DGLDDRK73_C(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False(), williamson_condition = true) - DGLDDRK73_C{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread, - williamson_condition) -end - -# for backwards compatibility -function DGLDDRK73_C(stage_limiter!, step_limiter! = trivial_limiter!; - williamson_condition = true) - DGLDDRK73_C{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False(), - williamson_condition) -end - -function Base.show(io::IO, alg::DGLDDRK73_C) - print(io, "DGLDDRK73_C(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, - ", williamson_condition = ", alg.williamson_condition, ")") -end - -""" - DGLDDRK84_C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False(), - williamson_condition = true) - -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. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. - -## 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 -""" -struct DGLDDRK84_C{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread - williamson_condition::Bool -end - -function DGLDDRK84_C(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False(), williamson_condition = true) - DGLDDRK84_C{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread, - williamson_condition) -end - -# for backwards compatibility -function DGLDDRK84_C(stage_limiter!, step_limiter! = trivial_limiter!; - williamson_condition = true) - DGLDDRK84_C{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False(), - williamson_condition) -end - -function Base.show(io::IO, alg::DGLDDRK84_C) - print(io, "DGLDDRK84_C(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, - ", williamson_condition = ", alg.williamson_condition, ")") -end - -""" - DGLDDRK84_F(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False(), - williamson_condition = true) - -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. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. - -## 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 -""" -struct DGLDDRK84_F{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread - williamson_condition::Bool -end - -function DGLDDRK84_F(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False(), williamson_condition = true) - DGLDDRK84_F{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread, - williamson_condition) -end - -# for backwards compatibility -function DGLDDRK84_F(stage_limiter!, step_limiter! = trivial_limiter!; - williamson_condition = true) - DGLDDRK84_F{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False(), - williamson_condition) -end - -function Base.show(io::IO, alg::DGLDDRK84_F) - print(io, "DGLDDRK84_F(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, - ", williamson_condition = ", alg.williamson_condition, ")") -end - -""" - NDBLSRK124(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False(), - williamson_condition = true) - -12-stage, fourth order low-storage method with optimized stability regions for -advection-dominated problems. Fixed timestep only. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. - -## 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 -""" -struct NDBLSRK124{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread - williamson_condition::Bool -end - -function NDBLSRK124(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False(), williamson_condition = true) - NDBLSRK124{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread, - williamson_condition) -end - -# for backwards compatibility -function NDBLSRK124(stage_limiter!, step_limiter! = trivial_limiter!; - williamson_condition = true) - NDBLSRK124{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, False(), - williamson_condition) -end - -function Base.show(io::IO, alg::NDBLSRK124) - print(io, "NDBLSRK124(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, - ", williamson_condition = ", alg.williamson_condition, ")") -end - -""" - NDBLSRK134(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False(), - williamson_condition = true) - -13-stage, fourth order low-storage method with optimized stability regions for -advection-dominated problems. Fixed timestep only. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. - -## 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 -""" -struct NDBLSRK134{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread - williamson_condition::Bool -end - -function NDBLSRK134(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False(), williamson_condition = true) - NDBLSRK134{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread, - williamson_condition) -end - -# for backwards compatibility -function NDBLSRK134(stage_limiter!, step_limiter! = trivial_limiter!; - williamson_condition = true) - NDBLSRK134{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, False(), - williamson_condition) -end - -function Base.show(io::IO, alg::NDBLSRK134) - print(io, "NDBLSRK134(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, - ", williamson_condition = ", alg.williamson_condition, ")") -end - -""" - NDBLSRK144(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False(), - williamson_condition = true) - -14-stage, fourth order low-storage method with optimized stability regions for -advection-dominated problems. Fixed timestep only. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. - -## 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 -""" -struct NDBLSRK144{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread - williamson_condition::Bool -end - -function NDBLSRK144(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False(), williamson_condition = true) - NDBLSRK144{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread, - williamson_condition) -end - -# for backwards compatibility -function NDBLSRK144(stage_limiter!, step_limiter! = trivial_limiter!; - williamson_condition = true) - NDBLSRK144{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, False(), - williamson_condition) -end - -function Base.show(io::IO, alg::NDBLSRK144) - print(io, "NDBLSRK144(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, - ", williamson_condition = ", alg.williamson_condition, ")") -end - -""" - CFRLDDRK64(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -Low-Storage Method -6-stage, fourth order low-storage, low-dissipation, low-dispersion scheme. -Fixed timestep only. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. - -## Reference -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 -""" -struct CFRLDDRK64{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function CFRLDDRK64(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - CFRLDDRK64{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function CFRLDDRK64(stage_limiter!, step_limiter! = trivial_limiter!) - CFRLDDRK64{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::CFRLDDRK64) - print(io, "CFRLDDRK64(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") -end - -""" - Ralston(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -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. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. - -#Reference -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 -""" -struct TSLDDRK74{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function TSLDDRK74(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - TSLDDRK74{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function TSLDDRK74(stage_limiter!, step_limiter! = trivial_limiter!) - TSLDDRK74{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::TSLDDRK74) - print(io, "TSLDDRK74(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, - ")") -end - -""" - CKLLSRK43_2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -Low-Storage Method - 4-stage, third order low-storage scheme, optimized for compressible Navier–Stokes equations. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. -""" -struct CKLLSRK43_2{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function CKLLSRK43_2(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - CKLLSRK43_2{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function CKLLSRK43_2(stage_limiter!, step_limiter! = trivial_limiter!) - CKLLSRK43_2{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::CKLLSRK43_2) - print(io, "CKLLSRK43_2(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, - ")") -end - -""" - CKLLSRK54_3C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -Low-Storage Method -5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. -""" -struct CKLLSRK54_3C{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function CKLLSRK54_3C(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - CKLLSRK54_3C{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function CKLLSRK54_3C(stage_limiter!, step_limiter! = trivial_limiter!) - CKLLSRK54_3C{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::CKLLSRK54_3C) - print(io, "CKLLSRK54_3C(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, - ")") -end - -""" -CKLLSRK95_4S(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -Low-Storage Method - 9-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations. - - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. -""" -struct CKLLSRK95_4S{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function CKLLSRK95_4S(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - CKLLSRK95_4S{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function CKLLSRK95_4S(stage_limiter!, step_limiter! = trivial_limiter!) - CKLLSRK95_4S{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::CKLLSRK95_4S) - print(io, "CKLLSRK95_4S(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") -end - -""" - CKLLSRK95_4C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -Low-Storage Method - 9-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. -""" -struct CKLLSRK95_4C{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function CKLLSRK95_4C(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - CKLLSRK95_4C{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function CKLLSRK95_4C(stage_limiter!, step_limiter! = trivial_limiter!) - CKLLSRK95_4C{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::CKLLSRK95_4C) - print(io, "CKLLSRK95_4C(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") -end - -""" - CKLLSRK95_4M(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -Low-Storage Method - 9-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. -""" -struct CKLLSRK95_4M{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function CKLLSRK95_4M(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - CKLLSRK95_4M{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function CKLLSRK95_4M(stage_limiter!, step_limiter! = trivial_limiter!) - CKLLSRK95_4M{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::CKLLSRK95_4M) - print(io, "CKLLSRK95_4M(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, - ")") -end - -""" - CKLLSRK54_3C_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -Low-Storage Method - 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. -""" -struct CKLLSRK54_3C_3R{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function CKLLSRK54_3C_3R(; stage_limiter! = trivial_limiter!, - step_limiter! = trivial_limiter!, thread = False()) - CKLLSRK54_3C_3R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function CKLLSRK54_3C_3R(stage_limiter!, step_limiter! = trivial_limiter!) - CKLLSRK54_3C_3R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::CKLLSRK54_3C_3R) - print(io, "CKLLSRK54_3C_3R(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, - ")") -end - -""" - CKLLSRK54_3M_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -Low-Storage Method - 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. -""" -struct CKLLSRK54_3M_3R{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function CKLLSRK54_3M_3R(; stage_limiter! = trivial_limiter!, - step_limiter! = trivial_limiter!, thread = False()) - CKLLSRK54_3M_3R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function CKLLSRK54_3M_3R(stage_limiter!, step_limiter! = trivial_limiter!) - CKLLSRK54_3M_3R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::CKLLSRK54_3M_3R) - print(io, "CKLLSRK54_3M_3R(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") -end - -""" - CKLLSRK54_3N_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -Low-Storage Method - 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. -""" -struct CKLLSRK54_3N_3R{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function CKLLSRK54_3N_3R(; stage_limiter! = trivial_limiter!, - step_limiter! = trivial_limiter!, thread = False()) - CKLLSRK54_3N_3R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function CKLLSRK54_3N_3R(stage_limiter!, step_limiter! = trivial_limiter!) - CKLLSRK54_3N_3R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::CKLLSRK54_3N_3R) - print(io, "CKLLSRK54_3N_3R(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") -end - -""" - CKLLSRK85_4M_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -Low-Storage Method - 8-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. -""" -struct CKLLSRK85_4C_3R{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function CKLLSRK85_4C_3R(; stage_limiter! = trivial_limiter!, - step_limiter! = trivial_limiter!, thread = False()) - CKLLSRK85_4C_3R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function CKLLSRK85_4C_3R(stage_limiter!, step_limiter! = trivial_limiter!) - CKLLSRK85_4C_3R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::CKLLSRK85_4C_3R) - print(io, "CKLLSRK85_4C_3R(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") -end - -""" - CKLLSRK85_4M_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -Low-Storage Method - 8-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. -""" -struct CKLLSRK85_4M_3R{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function CKLLSRK85_4M_3R(; stage_limiter! = trivial_limiter!, - step_limiter! = trivial_limiter!, thread = False()) - CKLLSRK85_4M_3R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function CKLLSRK85_4M_3R(stage_limiter!, step_limiter! = trivial_limiter!) - CKLLSRK85_4M_3R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::CKLLSRK85_4M_3R) - print(io, "CKLLSRK85_4M_3R(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") -end - -""" - CKLLSRK85_4P_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -Low-Storage Method - 8-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. -""" -struct CKLLSRK85_4P_3R{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function CKLLSRK85_4P_3R(; stage_limiter! = trivial_limiter!, - step_limiter! = trivial_limiter!, thread = False()) - CKLLSRK85_4P_3R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function CKLLSRK85_4P_3R(stage_limiter!, step_limiter! = trivial_limiter!) - CKLLSRK85_4P_3R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::CKLLSRK85_4P_3R) - print(io, "CKLLSRK85_4P_3R(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") -end - -""" - CKLLSRK54_3N_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -Low-Storage Method - 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. -""" -struct CKLLSRK54_3N_4R{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function CKLLSRK54_3N_4R(; stage_limiter! = trivial_limiter!, - step_limiter! = trivial_limiter!, thread = False()) - CKLLSRK54_3N_4R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function CKLLSRK54_3N_4R(stage_limiter!, step_limiter! = trivial_limiter!) - CKLLSRK54_3N_4R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::CKLLSRK54_3N_4R) - print(io, "CKLLSRK54_3N_4R(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") -end - -""" - CKLLSRK54_3M_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -Low-Storage Method - 5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. -""" -struct CKLLSRK54_3M_4R{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function CKLLSRK54_3M_4R(; stage_limiter! = trivial_limiter!, - step_limiter! = trivial_limiter!, thread = False()) - CKLLSRK54_3M_4R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function CKLLSRK54_3M_4R(stage_limiter!, step_limiter! = trivial_limiter!) - CKLLSRK54_3M_4R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::CKLLSRK54_3M_4R) - print(io, "CKLLSRK54_3M_4R(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") -end - -""" - CKLLSRK65_4M_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -6-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. -""" -struct CKLLSRK65_4M_4R{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function CKLLSRK65_4M_4R(; stage_limiter! = trivial_limiter!, - step_limiter! = trivial_limiter!, thread = False()) - CKLLSRK65_4M_4R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function CKLLSRK65_4M_4R(stage_limiter!, step_limiter! = trivial_limiter!) - CKLLSRK65_4M_4R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::CKLLSRK65_4M_4R) - print(io, "CKLLSRK65_4M_4R(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") -end - -""" - CKLLSRK85_4FM_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -Low-Storage Method - 8-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. -""" -struct CKLLSRK85_4FM_4R{StageLimiter, StepLimiter, Thread} <: - OrdinaryDiffEqAdaptiveAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function CKLLSRK85_4FM_4R(; stage_limiter! = trivial_limiter!, - step_limiter! = trivial_limiter!, thread = False()) - CKLLSRK85_4FM_4R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function CKLLSRK85_4FM_4R(stage_limiter!, step_limiter! = trivial_limiter!) - CKLLSRK85_4FM_4R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::CKLLSRK85_4FM_4R) - print(io, "CKLLSRK85_4FM_4R(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") -end - -""" -CKLLSRK75_4M_5R: Low-Storage Method - 7-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations. -""" -struct CKLLSRK75_4M_5R{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function CKLLSRK75_4M_5R(; stage_limiter! = trivial_limiter!, - step_limiter! = trivial_limiter!, thread = False()) - CKLLSRK75_4M_5R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function CKLLSRK75_4M_5R(stage_limiter!, step_limiter! = trivial_limiter!) - CKLLSRK75_4M_5R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::CKLLSRK75_4M_5R) - print(io, "CKLLSRK75_4M_5R(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") -end - -""" - ParsaniKetchesonDeconinck3S32(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -Low-Storage Method - 3-stage, second order (3S) low-storage scheme, optimized the spectral difference method applied to wave propagation problems. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. - -## Reference -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 -""" -struct ParsaniKetchesonDeconinck3S32{StageLimiter, StepLimiter, Thread} <: - OrdinaryDiffEqAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function ParsaniKetchesonDeconinck3S32(; stage_limiter! = trivial_limiter!, - step_limiter! = trivial_limiter!, thread = False()) - ParsaniKetchesonDeconinck3S32{typeof(stage_limiter!), typeof(step_limiter!), - typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function ParsaniKetchesonDeconinck3S32(stage_limiter!, step_limiter! = trivial_limiter!) - ParsaniKetchesonDeconinck3S32{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::ParsaniKetchesonDeconinck3S32) - print(io, "ParsaniKetchesonDeconinck3S32(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") -end - -""" - ParsaniKetchesonDeconinck3S82(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -Low-Storage Method - 8-stage, second order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. - -## Reference -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 -""" -struct ParsaniKetchesonDeconinck3S82{StageLimiter, StepLimiter, Thread} <: - OrdinaryDiffEqAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function ParsaniKetchesonDeconinck3S82(; stage_limiter! = trivial_limiter!, - step_limiter! = trivial_limiter!, thread = False()) - ParsaniKetchesonDeconinck3S82{typeof(stage_limiter!), typeof(step_limiter!), - typeof(thread)}(stage_limiter!, - step_limiter!, - thread) -end - -# for backwards compatibility -function ParsaniKetchesonDeconinck3S82(stage_limiter!, step_limiter! = trivial_limiter!) - ParsaniKetchesonDeconinck3S82{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) -end - -function Base.show(io::IO, alg::ParsaniKetchesonDeconinck3S82) - print(io, "ParsaniKetchesonDeconinck3S82(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") -end - -""" - ParsaniKetchesonDeconinck3S53(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -Low-Storage Method - 5-stage, third order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems. - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. - -## Reference -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 -""" -struct ParsaniKetchesonDeconinck3S53{StageLimiter, StepLimiter, Thread} <: - OrdinaryDiffEqAlgorithm - stage_limiter!::StageLimiter - step_limiter!::StepLimiter - thread::Thread -end - -function ParsaniKetchesonDeconinck3S53(; stage_limiter! = trivial_limiter!, - step_limiter! = trivial_limiter!, thread = False()) - ParsaniKetchesonDeconinck3S53{typeof(stage_limiter!), typeof(step_limiter!), - typeof(thread)}(stage_limiter!, +function CKLLSRK54_3C(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, + thread = False()) + CKLLSRK54_3C{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function ParsaniKetchesonDeconinck3S53(stage_limiter!, step_limiter! = trivial_limiter!) - ParsaniKetchesonDeconinck3S53{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function CKLLSRK54_3C(stage_limiter!, step_limiter! = trivial_limiter!) + CKLLSRK54_3C{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::ParsaniKetchesonDeconinck3S53) - print(io, "ParsaniKetchesonDeconinck3S53(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::CKLLSRK54_3C) + print(io, "CKLLSRK54_3C(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") + ", thread = ", alg.thread, + ")") end """ - ParsaniKetchesonDeconinck3S173(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) +CKLLSRK95_4S(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, +step_limiter! = OrdinaryDiffEq.trivial_limiter!, +thread = OrdinaryDiffEq.False()) Low-Storage Method - 17-stage, third order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems. +9-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -2507,48 +1352,40 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. - -## Reference -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 """ -struct ParsaniKetchesonDeconinck3S173{StageLimiter, StepLimiter, Thread} <: - OrdinaryDiffEqAlgorithm +struct CKLLSRK95_4S{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function ParsaniKetchesonDeconinck3S173(; stage_limiter! = trivial_limiter!, - step_limiter! = trivial_limiter!, thread = False()) - ParsaniKetchesonDeconinck3S173{typeof(stage_limiter!), typeof(step_limiter!), - typeof(thread)}(stage_limiter!, +function CKLLSRK95_4S(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, + thread = False()) + CKLLSRK95_4S{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function ParsaniKetchesonDeconinck3S173(stage_limiter!, step_limiter! = trivial_limiter!) - ParsaniKetchesonDeconinck3S173{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function CKLLSRK95_4S(stage_limiter!, step_limiter! = trivial_limiter!) + CKLLSRK95_4S{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::ParsaniKetchesonDeconinck3S173) - print(io, "ParsaniKetchesonDeconinck3S173(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::CKLLSRK95_4S) + print(io, "CKLLSRK95_4S(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - ParsaniKetchesonDeconinck3S94(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + CKLLSRK95_4C(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, step_limiter! = OrdinaryDiffEq.trivial_limiter!, thread = OrdinaryDiffEq.False()) Low-Storage Method - 9-stage, fourth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems. +9-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -2558,48 +1395,40 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. - -## Reference -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 """ -struct ParsaniKetchesonDeconinck3S94{StageLimiter, StepLimiter, Thread} <: - OrdinaryDiffEqAlgorithm +struct CKLLSRK95_4C{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function ParsaniKetchesonDeconinck3S94(; stage_limiter! = trivial_limiter!, - step_limiter! = trivial_limiter!, thread = False()) - ParsaniKetchesonDeconinck3S94{typeof(stage_limiter!), typeof(step_limiter!), - typeof(thread)}(stage_limiter!, +function CKLLSRK95_4C(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, + thread = False()) + CKLLSRK95_4C{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function ParsaniKetchesonDeconinck3S94(stage_limiter!, step_limiter! = trivial_limiter!) - ParsaniKetchesonDeconinck3S94{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function CKLLSRK95_4C(stage_limiter!, step_limiter! = trivial_limiter!) + CKLLSRK95_4C{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::ParsaniKetchesonDeconinck3S94) - print(io, "ParsaniKetchesonDeconinck3S94(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::CKLLSRK95_4C) + print(io, "CKLLSRK95_4C(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - ParsaniKetchesonDeconinck3S184(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + CKLLSRK95_4M(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, step_limiter! = OrdinaryDiffEq.trivial_limiter!, thread = OrdinaryDiffEq.False()) Low-Storage Method - 18-stage, fourth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems. +9-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -2609,48 +1438,41 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. - -## Reference -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 """ -struct ParsaniKetchesonDeconinck3S184{StageLimiter, StepLimiter, Thread} <: - OrdinaryDiffEqAlgorithm +struct CKLLSRK95_4M{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function ParsaniKetchesonDeconinck3S184(; stage_limiter! = trivial_limiter!, - step_limiter! = trivial_limiter!, thread = False()) - ParsaniKetchesonDeconinck3S184{typeof(stage_limiter!), typeof(step_limiter!), - typeof(thread)}(stage_limiter!, +function CKLLSRK95_4M(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, + thread = False()) + CKLLSRK95_4M{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function ParsaniKetchesonDeconinck3S184(stage_limiter!, step_limiter! = trivial_limiter!) - ParsaniKetchesonDeconinck3S184{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function CKLLSRK95_4M(stage_limiter!, step_limiter! = trivial_limiter!) + CKLLSRK95_4M{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::ParsaniKetchesonDeconinck3S184) - print(io, "ParsaniKetchesonDeconinck3S184(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::CKLLSRK95_4M) + print(io, "CKLLSRK95_4M(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") + ", thread = ", alg.thread, + ")") end """ - ParsaniKetchesonDeconinck3S105(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + CKLLSRK54_3C_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, step_limiter! = OrdinaryDiffEq.trivial_limiter!, thread = OrdinaryDiffEq.False()) Low-Storage Method - 10-stage, fifth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems. +5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -2660,48 +1482,41 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. - -## Reference -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 """ -struct ParsaniKetchesonDeconinck3S105{StageLimiter, StepLimiter, Thread} <: - OrdinaryDiffEqAlgorithm +struct CKLLSRK54_3C_3R{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function ParsaniKetchesonDeconinck3S105(; stage_limiter! = trivial_limiter!, +function CKLLSRK54_3C_3R(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - ParsaniKetchesonDeconinck3S105{typeof(stage_limiter!), typeof(step_limiter!), - typeof(thread)}(stage_limiter!, + CKLLSRK54_3C_3R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function ParsaniKetchesonDeconinck3S105(stage_limiter!, step_limiter! = trivial_limiter!) - ParsaniKetchesonDeconinck3S105{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function CKLLSRK54_3C_3R(stage_limiter!, step_limiter! = trivial_limiter!) + CKLLSRK54_3C_3R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::ParsaniKetchesonDeconinck3S105) - print(io, "ParsaniKetchesonDeconinck3S105(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::CKLLSRK54_3C_3R) + print(io, "CKLLSRK54_3C_3R(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") + ", thread = ", alg.thread, + ")") end """ - ParsaniKetchesonDeconinck3S205(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + CKLLSRK54_3M_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, step_limiter! = OrdinaryDiffEq.trivial_limiter!, thread = OrdinaryDiffEq.False()) Low-Storage Method - 20-stage, fifth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems. +5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -2711,48 +1526,40 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. - -## Reference -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 """ -struct ParsaniKetchesonDeconinck3S205{StageLimiter, StepLimiter, Thread} <: - OrdinaryDiffEqAlgorithm +struct CKLLSRK54_3M_3R{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function ParsaniKetchesonDeconinck3S205(; stage_limiter! = trivial_limiter!, +function CKLLSRK54_3M_3R(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - ParsaniKetchesonDeconinck3S205{typeof(stage_limiter!), typeof(step_limiter!), - typeof(thread)}(stage_limiter!, + CKLLSRK54_3M_3R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function ParsaniKetchesonDeconinck3S205(stage_limiter!, step_limiter! = trivial_limiter!) - ParsaniKetchesonDeconinck3S205{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function CKLLSRK54_3M_3R(stage_limiter!, step_limiter! = trivial_limiter!) + CKLLSRK54_3M_3R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::ParsaniKetchesonDeconinck3S205) - print(io, "ParsaniKetchesonDeconinck3S205(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::CKLLSRK54_3M_3R) + print(io, "CKLLSRK54_3M_3R(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - RDPK3Sp35(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + CKLLSRK54_3N_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A third-order, five-stage explicit Runge-Kutta method with embedded error estimator -designed for spectral element discretizations of compressible fluid mechanics. +Low-Storage Method +5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -2762,46 +1569,40 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. - -## 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) """ -struct RDPK3Sp35{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct CKLLSRK54_3N_3R{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function RDPK3Sp35(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - RDPK3Sp35{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function CKLLSRK54_3N_3R(; stage_limiter! = trivial_limiter!, + step_limiter! = trivial_limiter!, thread = False()) + CKLLSRK54_3N_3R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function RDPK3Sp35(stage_limiter!, step_limiter! = trivial_limiter!) - RDPK3Sp35{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, False()) +function CKLLSRK54_3N_3R(stage_limiter!, step_limiter! = trivial_limiter!) + CKLLSRK54_3N_3R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, + False()) end -function Base.show(io::IO, alg::RDPK3Sp35) - print(io, "RDPK3Sp35(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::CKLLSRK54_3N_3R) + print(io, "CKLLSRK54_3N_3R(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - RDPK3SpFSAL35(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + CKLLSRK85_4M_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A third-order, five-stage explicit Runge-Kutta method with embedded error estimator -using the FSAL property designed for spectral element discretizations of -compressible fluid mechanics. +Low-Storage Method +8-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -2811,46 +1612,40 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. - -## 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) """ -struct RDPK3SpFSAL35{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct CKLLSRK85_4C_3R{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function RDPK3SpFSAL35(; stage_limiter! = trivial_limiter!, +function CKLLSRK85_4C_3R(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - RDPK3SpFSAL35{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + CKLLSRK85_4C_3R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function RDPK3SpFSAL35(stage_limiter!, step_limiter! = trivial_limiter!) - RDPK3SpFSAL35{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function CKLLSRK85_4C_3R(stage_limiter!, step_limiter! = trivial_limiter!) + CKLLSRK85_4C_3R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::RDPK3SpFSAL35) - print(io, "RDPK3SpFSAL35(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::CKLLSRK85_4C_3R) + print(io, "CKLLSRK85_4C_3R(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - RDPK3Sp49(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + CKLLSRK85_4M_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A fourth-order, nine-stage explicit Runge-Kutta method with embedded error estimator -designed for spectral element discretizations of compressible fluid mechanics. +Low-Storage Method +8-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -2860,46 +1655,40 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. - -## 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) """ -struct RDPK3Sp49{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct CKLLSRK85_4M_3R{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function RDPK3Sp49(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - RDPK3Sp49{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function CKLLSRK85_4M_3R(; stage_limiter! = trivial_limiter!, + step_limiter! = trivial_limiter!, thread = False()) + CKLLSRK85_4M_3R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function RDPK3Sp49(stage_limiter!, step_limiter! = trivial_limiter!) - RDPK3Sp49{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, False()) +function CKLLSRK85_4M_3R(stage_limiter!, step_limiter! = trivial_limiter!) + CKLLSRK85_4M_3R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, + False()) end -function Base.show(io::IO, alg::RDPK3Sp49) - print(io, "RDPK3Sp49(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::CKLLSRK85_4M_3R) + print(io, "CKLLSRK85_4M_3R(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - RDPK3SpFSAL49(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + CKLLSRK85_4P_3R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A fourth-order, nine-stage explicit Runge-Kutta method with embedded error estimator -using the FSAL property designed for spectral element discretizations of -compressible fluid mechanics. +Low-Storage Method +8-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -2909,46 +1698,40 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. - -## 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) """ -struct RDPK3SpFSAL49{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct CKLLSRK85_4P_3R{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function RDPK3SpFSAL49(; stage_limiter! = trivial_limiter!, +function CKLLSRK85_4P_3R(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - RDPK3SpFSAL49{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + CKLLSRK85_4P_3R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function RDPK3SpFSAL49(stage_limiter!, step_limiter! = trivial_limiter!) - RDPK3SpFSAL49{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function CKLLSRK85_4P_3R(stage_limiter!, step_limiter! = trivial_limiter!) + CKLLSRK85_4P_3R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::RDPK3SpFSAL49) - print(io, "RDPK3SpFSAL49(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::CKLLSRK85_4P_3R) + print(io, "CKLLSRK85_4P_3R(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - RDPK3Sp510(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + CKLLSRK54_3N_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A fifth-order, ten-stage explicit Runge-Kutta method with embedded error estimator -designed for spectral element discretizations of compressible fluid mechanics. +Low-Storage Method +5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -2958,46 +1741,40 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. - -## 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) """ -struct RDPK3Sp510{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct CKLLSRK54_3N_4R{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function RDPK3Sp510(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - RDPK3Sp510{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function CKLLSRK54_3N_4R(; stage_limiter! = trivial_limiter!, + step_limiter! = trivial_limiter!, thread = False()) + CKLLSRK54_3N_4R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function RDPK3Sp510(stage_limiter!, step_limiter! = trivial_limiter!) - RDPK3Sp510{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, False()) +function CKLLSRK54_3N_4R(stage_limiter!, step_limiter! = trivial_limiter!) + CKLLSRK54_3N_4R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, + False()) end -function Base.show(io::IO, alg::RDPK3Sp510) - print(io, "RDPK3Sp510(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::CKLLSRK54_3N_4R) + print(io, "CKLLSRK54_3N_4R(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - RDPK3SpFSAL510(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + CKLLSRK54_3M_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A fifth-order, ten-stage explicit Runge-Kutta method with embedded error estimator -using the FSAL property designed for spectral element discretizations of -compressible fluid mechanics. +Low-Storage Method +5-stage, fourth order low-storage scheme, optimized for compressible Navier–Stokes equations. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -3007,71 +1784,82 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. - -## 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) """ -struct RDPK3SpFSAL510{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct CKLLSRK54_3M_4R{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function RDPK3SpFSAL510(; stage_limiter! = trivial_limiter!, +function CKLLSRK54_3M_4R(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - RDPK3SpFSAL510{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + CKLLSRK54_3M_4R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function RDPK3SpFSAL510(stage_limiter!, step_limiter! = trivial_limiter!) - RDPK3SpFSAL510{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function CKLLSRK54_3M_4R(stage_limiter!, step_limiter! = trivial_limiter!) + CKLLSRK54_3M_4R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::RDPK3SpFSAL510) - print(io, "RDPK3SpFSAL510(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::CKLLSRK54_3M_4R) + print(io, "CKLLSRK54_3M_4R(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end -struct KYK2014DGSSPRK_3S2{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +""" + CKLLSRK65_4M_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) + +6-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations. + +Like SSPRK methods, this method also takes optional arguments `stage_limiter!` +and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions +of the form `limiter!(u, integrator, p, t)`. + +The argument `thread` determines whether internal broadcasting on +appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, +default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when +Julia is started with multiple threads. +""" +struct CKLLSRK65_4M_4R{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function KYK2014DGSSPRK_3S2(; stage_limiter! = trivial_limiter!, +function CKLLSRK65_4M_4R(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - KYK2014DGSSPRK_3S2{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + CKLLSRK65_4M_4R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function KYK2014DGSSPRK_3S2(stage_limiter!, step_limiter! = trivial_limiter!) - KYK2014DGSSPRK_3S2{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function CKLLSRK65_4M_4R(stage_limiter!, step_limiter! = trivial_limiter!) + CKLLSRK65_4M_4R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::KYK2014DGSSPRK_3S2) - print(io, "KYK2014DGSSPRK_3S2(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::CKLLSRK65_4M_4R) + print(io, "CKLLSRK65_4M_4R(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - RKO65(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + CKLLSRK85_4FM_4R(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A fifth-order six-stage explicit Runge-Kutta method. +Low-Storage Method +8-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -3081,95 +1869,73 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. - -## Reference -Tsitouras, Ch. "Explicit Runge–Kutta methods for starting integration of -Lane–Emden problem." Applied Mathematics and Computation 354 (2019): 353-364. -doi: https://doi.org/10.1016/j.amc.2019.02.047 """ -struct RKO65{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct CKLLSRK85_4FM_4R{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function RKO65(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - RKO65{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function CKLLSRK85_4FM_4R(; stage_limiter! = trivial_limiter!, + step_limiter! = trivial_limiter!, thread = False()) + CKLLSRK85_4FM_4R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function RKO65(stage_limiter!, step_limiter! = trivial_limiter!) - RKO65{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function CKLLSRK85_4FM_4R(stage_limiter!, step_limiter! = trivial_limiter!) + CKLLSRK85_4FM_4R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::RKO65) - print(io, "RKO65(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::CKLLSRK85_4FM_4R) + print(io, "CKLLSRK85_4FM_4R(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - SSPRK22(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -A second-order, two-stage explicit strong stability preserving (SSP) method. -Fixed timestep only. - -Like all SSPRK methods, this method takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) 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 +CKLLSRK75_4M_5R: Low-Storage Method +7-stage, fifth order low-storage scheme, optimized for compressible Navier–Stokes equations. """ -struct SSPRK22{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct CKLLSRK75_4M_5R{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function SSPRK22(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - SSPRK22{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function CKLLSRK75_4M_5R(; stage_limiter! = trivial_limiter!, + step_limiter! = trivial_limiter!, thread = False()) + CKLLSRK75_4M_5R{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function SSPRK22(stage_limiter!, step_limiter! = trivial_limiter!) - SSPRK22{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, False()) +function CKLLSRK75_4M_5R(stage_limiter!, step_limiter! = trivial_limiter!) + CKLLSRK75_4M_5R{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, + False()) end -function Base.show(io::IO, alg::SSPRK22) - print(io, "SSPRK22(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::CKLLSRK75_4M_5R) + print(io, "CKLLSRK75_4M_5R(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - SSPRK33(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + ParsaniKetchesonDeconinck3S32(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A third-order, three-stage explicit strong stability preserving (SSP) method. -Fixed timestep only. +Low-Storage Method +3-stage, second order (3S) low-storage scheme, optimized the spectral difference method applied to wave propagation problems. -Like all SSPRK methods, this method takes optional arguments `stage_limiter!` +Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -3178,46 +1944,50 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) 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 +## Reference + +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 """ -struct SSPRK33{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct ParsaniKetchesonDeconinck3S32{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function SSPRK33(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - SSPRK33{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function ParsaniKetchesonDeconinck3S32(; stage_limiter! = trivial_limiter!, + step_limiter! = trivial_limiter!, thread = False()) + ParsaniKetchesonDeconinck3S32{typeof(stage_limiter!), typeof(step_limiter!), + typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function SSPRK33(stage_limiter!, step_limiter! = trivial_limiter!) - SSPRK33{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, False()) +function ParsaniKetchesonDeconinck3S32(stage_limiter!, step_limiter! = trivial_limiter!) + ParsaniKetchesonDeconinck3S32{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, + False()) end -function Base.show(io::IO, alg::SSPRK33) - print(io, "SSPRK33(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::ParsaniKetchesonDeconinck3S32) + print(io, "ParsaniKetchesonDeconinck3S32(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - SSPRK53(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + ParsaniKetchesonDeconinck3S82(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A third-order, five-stage explicit strong stability preserving (SSP) method. -Fixed timestep only. +Low-Storage Method +8-stage, second order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems. -Like all SSPRK methods, this method takes optional arguments `stage_limiter!` +Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -3226,71 +1996,102 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. -## References -- Ruuth, Steven. - "Global optimization of explicit strong-stability-preserving Runge-Kutta methods." - Mathematics of Computation 75.253 (2006): 183-207. +## Reference + +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 """ -struct SSPRK53{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct ParsaniKetchesonDeconinck3S82{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function SSPRK53(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - SSPRK53{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function ParsaniKetchesonDeconinck3S82(; stage_limiter! = trivial_limiter!, + step_limiter! = trivial_limiter!, thread = False()) + ParsaniKetchesonDeconinck3S82{typeof(stage_limiter!), typeof(step_limiter!), + typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function SSPRK53(stage_limiter!, step_limiter! = trivial_limiter!) - SSPRK53{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, False()) +function ParsaniKetchesonDeconinck3S82(stage_limiter!, step_limiter! = trivial_limiter!) + ParsaniKetchesonDeconinck3S82{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, + False()) +end + +function Base.show(io::IO, alg::ParsaniKetchesonDeconinck3S82) + print(io, "ParsaniKetchesonDeconinck3S82(stage_limiter! = ", alg.stage_limiter!, + ", step_limiter! = ", alg.step_limiter!, + ", thread = ", alg.thread, ")") end -function Base.show(io::IO, alg::SSPRK53) - print(io, "SSPRK53(stage_limiter! = ", alg.stage_limiter!, - ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, ")") -end +""" + ParsaniKetchesonDeconinck3S53(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) + +Low-Storage Method +5-stage, third order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems. + +Like SSPRK methods, this method also takes optional arguments `stage_limiter!` +and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions +of the form `limiter!(u, integrator, p, t)`. + +The argument `thread` determines whether internal broadcasting on +appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, +default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when +Julia is started with multiple threads. + +## Reference -struct KYKSSPRK42{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +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 +""" +struct ParsaniKetchesonDeconinck3S53{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function KYKSSPRK42(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - KYKSSPRK42{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function ParsaniKetchesonDeconinck3S53(; stage_limiter! = trivial_limiter!, + step_limiter! = trivial_limiter!, thread = False()) + ParsaniKetchesonDeconinck3S53{typeof(stage_limiter!), typeof(step_limiter!), + typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function KYKSSPRK42(stage_limiter!, step_limiter! = trivial_limiter!) - KYKSSPRK42{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function ParsaniKetchesonDeconinck3S53(stage_limiter!, step_limiter! = trivial_limiter!) + ParsaniKetchesonDeconinck3S53{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::KYKSSPRK42) - print(io, "KYKSSPRK42(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::ParsaniKetchesonDeconinck3S53) + print(io, "ParsaniKetchesonDeconinck3S53(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - SSPRK53_2N1(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + ParsaniKetchesonDeconinck3S173(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A third-order, five-stage explicit strong stability preserving (SSP) low-storage method. -Fixed timestep only. +Low-Storage Method +17-stage, third order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems. -Like all SSPRK methods, this method takes optional arguments `stage_limiter!` +Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -3299,46 +2100,50 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. -## References -- Higueras and T. Roldán. - "New third order low-storage SSP explicit Runge–Kutta methods". - arXiv:1809.04807v1. +## Reference + +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 """ -struct SSPRK53_2N1{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct ParsaniKetchesonDeconinck3S173{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function SSPRK53_2N1(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - SSPRK53_2N1{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function ParsaniKetchesonDeconinck3S173(; stage_limiter! = trivial_limiter!, + step_limiter! = trivial_limiter!, thread = False()) + ParsaniKetchesonDeconinck3S173{typeof(stage_limiter!), typeof(step_limiter!), + typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function SSPRK53_2N1(stage_limiter!, step_limiter! = trivial_limiter!) - SSPRK53_2N1{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function ParsaniKetchesonDeconinck3S173(stage_limiter!, step_limiter! = trivial_limiter!) + ParsaniKetchesonDeconinck3S173{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::SSPRK53_2N1) - print(io, "SSPRK53_2N1(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::ParsaniKetchesonDeconinck3S173) + print(io, "ParsaniKetchesonDeconinck3S173(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - SSPRK53_2N2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + ParsaniKetchesonDeconinck3S94(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A third-order, five-stage explicit strong stability preserving (SSP) low-storage method. -Fixed timestep only. +Low-Storage Method +9-stage, fourth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems. -Like all SSPRK methods, this method takes optional arguments `stage_limiter!` +Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -3347,46 +2152,50 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. -## References -- Higueras and T. Roldán. - "New third order low-storage SSP explicit Runge–Kutta methods". - arXiv:1809.04807v1. +## Reference + +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 """ -struct SSPRK53_2N2{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct ParsaniKetchesonDeconinck3S94{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function SSPRK53_2N2(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - SSPRK53_2N2{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function ParsaniKetchesonDeconinck3S94(; stage_limiter! = trivial_limiter!, + step_limiter! = trivial_limiter!, thread = False()) + ParsaniKetchesonDeconinck3S94{typeof(stage_limiter!), typeof(step_limiter!), + typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function SSPRK53_2N2(stage_limiter!, step_limiter! = trivial_limiter!) - SSPRK53_2N2{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function ParsaniKetchesonDeconinck3S94(stage_limiter!, step_limiter! = trivial_limiter!) + ParsaniKetchesonDeconinck3S94{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::SSPRK53_2N2) - print(io, "SSPRK53_2N2(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::ParsaniKetchesonDeconinck3S94) + print(io, "ParsaniKetchesonDeconinck3S94(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - SSPRK53_H(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + ParsaniKetchesonDeconinck3S184(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A third-order, five-stage explicit strong stability preserving (SSP) low-storage method. -Fixed timestep only. +Low-Storage Method +18-stage, fourth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems. -Like all SSPRK methods, this method takes optional arguments `stage_limiter!` +Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -3395,45 +2204,50 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. -## References -- Higueras and T. Roldán. - "New third order low-storage SSP explicit Runge–Kutta methods". - arXiv:1809.04807v1. +## Reference + +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 """ -struct SSPRK53_H{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct ParsaniKetchesonDeconinck3S184{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function SSPRK53_H(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - SSPRK53_H{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function ParsaniKetchesonDeconinck3S184(; stage_limiter! = trivial_limiter!, + step_limiter! = trivial_limiter!, thread = False()) + ParsaniKetchesonDeconinck3S184{typeof(stage_limiter!), typeof(step_limiter!), + typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function SSPRK53_H(stage_limiter!, step_limiter! = trivial_limiter!) - SSPRK53_H{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, False()) +function ParsaniKetchesonDeconinck3S184(stage_limiter!, step_limiter! = trivial_limiter!) + ParsaniKetchesonDeconinck3S184{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, + False()) end -function Base.show(io::IO, alg::SSPRK53_H) - print(io, "SSPRK53_H(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::ParsaniKetchesonDeconinck3S184) + print(io, "ParsaniKetchesonDeconinck3S184(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - SSPRK63(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + ParsaniKetchesonDeconinck3S105(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A third-order, six-stage explicit strong stability preserving (SSP) method. -Fixed timestep only. +Low-Storage Method +10-stage, fifth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems. -Like all SSPRK methods, this method takes optional arguments `stage_limiter!` +Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -3442,45 +2256,50 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. -## References -- Ruuth, Steven. - "Global optimization of explicit strong-stability-preserving Runge-Kutta methods." - Mathematics of Computation 75.253 (2006): 183-207. +## Reference + +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 """ -struct SSPRK63{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct ParsaniKetchesonDeconinck3S105{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function SSPRK63(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - SSPRK63{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function ParsaniKetchesonDeconinck3S105(; stage_limiter! = trivial_limiter!, + step_limiter! = trivial_limiter!, thread = False()) + ParsaniKetchesonDeconinck3S105{typeof(stage_limiter!), typeof(step_limiter!), + typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function SSPRK63(stage_limiter!, step_limiter! = trivial_limiter!) - SSPRK63{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, False()) +function ParsaniKetchesonDeconinck3S105(stage_limiter!, step_limiter! = trivial_limiter!) + ParsaniKetchesonDeconinck3S105{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, + False()) end -function Base.show(io::IO, alg::SSPRK63) - print(io, "SSPRK63(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::ParsaniKetchesonDeconinck3S105) + print(io, "ParsaniKetchesonDeconinck3S105(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - SSPRK73(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + ParsaniKetchesonDeconinck3S205(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A third-order, seven-stage explicit strong stability preserving (SSP) method. -Fixed timestep only. +Low-Storage Method +20-stage, fifth order (3S) low-storage scheme, optimized for the spectral difference method applied to wave propagation problems. -Like all SSPRK methods, this method takes optional arguments `stage_limiter!` +Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -3489,45 +2308,50 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. -## References -- Ruuth, Steven. - "Global optimization of explicit strong-stability-preserving Runge-Kutta methods." - Mathematics of Computation 75.253 (2006): 183-207. +## Reference + +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 """ -struct SSPRK73{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct ParsaniKetchesonDeconinck3S205{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function SSPRK73(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - SSPRK73{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function ParsaniKetchesonDeconinck3S205(; stage_limiter! = trivial_limiter!, + step_limiter! = trivial_limiter!, thread = False()) + ParsaniKetchesonDeconinck3S205{typeof(stage_limiter!), typeof(step_limiter!), + typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function SSPRK73(stage_limiter!, step_limiter! = trivial_limiter!) - SSPRK73{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, False()) +function ParsaniKetchesonDeconinck3S205(stage_limiter!, step_limiter! = trivial_limiter!) + ParsaniKetchesonDeconinck3S205{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, + False()) end -function Base.show(io::IO, alg::SSPRK73) - print(io, "SSPRK73(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::ParsaniKetchesonDeconinck3S205) + print(io, "ParsaniKetchesonDeconinck3S205(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - SSPRK83(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + RDPK3Sp35(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A third-order, eight-stage explicit strong stability preserving (SSP) method. -Fixed timestep only. +A third-order, five-stage explicit Runge-Kutta method with embedded error estimator +designed for spectral element discretizations of compressible fluid mechanics. -Like all SSPRK methods, this method takes optional arguments `stage_limiter!` +Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -3537,43 +2361,47 @@ default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. ## References -- Ruuth, Steven. - "Global optimization of explicit strong-stability-preserving Runge-Kutta methods." - Mathematics of Computation 75.253 (2006): 183-207. + + - 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) """ -struct SSPRK83{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct RDPK3Sp35{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function SSPRK83(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function RDPK3Sp35(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - SSPRK83{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + RDPK3Sp35{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function SSPRK83(stage_limiter!, step_limiter! = trivial_limiter!) - SSPRK83{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function RDPK3Sp35(stage_limiter!, step_limiter! = trivial_limiter!) + RDPK3Sp35{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::SSPRK83) - print(io, "SSPRK83(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::RDPK3Sp35) + print(io, "RDPK3Sp35(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - SSPRK43(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + RDPK3SpFSAL35(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A third-order, four-stage explicit strong stability preserving (SSP) method. +A third-order, five-stage explicit Runge-Kutta method with embedded error estimator +using the FSAL property designed for spectral element discretizations of +compressible fluid mechanics. -Like all SSPRK methods, this method takes optional arguments `stage_limiter!` +Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -3583,60 +2411,47 @@ default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. ## References -Optimal third-order explicit SSP method with four stages discovered by -- J. F. B. M. Kraaijevanger. - "Contractivity of Runge-Kutta methods." - In: BIT Numerical Mathematics 31.3 (1991), pp. 482–528. - [DOI: 10.1007/BF01933264](https://doi.org/10.1007/BF01933264). - -Embedded method constructed by -- Sidafa Conde, Imre Fekete, John N. Shadid. - "Embedded error estimation and adaptive step-size control for - optimal explicit strong stability preserving Runge–Kutta methods." - [arXiv: 1806.08693](https://arXiv.org/abs/1806.08693) -Efficient implementation (and optimized controller) developed by -- Hendrik Ranocha, Lisandro Dalcin, Matteo Parsani, David I. 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) + - 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) """ -struct SSPRK43{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct RDPK3SpFSAL35{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function SSPRK43(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - SSPRK43{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function RDPK3SpFSAL35(; stage_limiter! = trivial_limiter!, + step_limiter! = trivial_limiter!, thread = False()) + RDPK3SpFSAL35{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function SSPRK43(stage_limiter!, step_limiter! = trivial_limiter!) - SSPRK43{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, False()) +function RDPK3SpFSAL35(stage_limiter!, step_limiter! = trivial_limiter!) + RDPK3SpFSAL35{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, + False()) end -function Base.show(io::IO, alg::SSPRK43) - print(io, "SSPRK43(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::RDPK3SpFSAL35) + print(io, "RDPK3SpFSAL35(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - SSPRK432(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -A third-order, four-stage explicit strong stability preserving (SSP) method. + RDPK3Sp49(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -Consider using `SSPRK43` instead, which uses the same main method and an -improved embedded method. +A fourth-order, nine-stage explicit Runge-Kutta method with embedded error estimator +designed for spectral element discretizations of compressible fluid mechanics. -Like all SSPRK methods, this method takes optional arguments `stage_limiter!` +Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -3646,46 +2461,47 @@ default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. ## References -- Gottlieb, Sigal, David I. Ketcheson, and Chi-Wang Shu. - Strong stability preserving Runge-Kutta and multistep time discretizations. - World Scientific, 2011. - Example 6.1. + + - 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) """ -struct SSPRK432{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct RDPK3Sp49{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function SSPRK432(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function RDPK3Sp49(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - SSPRK432{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + RDPK3Sp49{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function SSPRK432(stage_limiter!, step_limiter! = trivial_limiter!) - SSPRK432{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function RDPK3Sp49(stage_limiter!, step_limiter! = trivial_limiter!) + RDPK3Sp49{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::SSPRK432) - print(io, "SSPRK432(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::RDPK3Sp49) + print(io, "RDPK3Sp49(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - SSPRKMSVS43(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + RDPK3SpFSAL49(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A third-order, four-step explicit strong stability preserving (SSP) linear multistep method. -This method does not come with an error estimator and requires a fixed time step -size. +A fourth-order, nine-stage explicit Runge-Kutta method with embedded error estimator +using the FSAL property designed for spectral element discretizations of +compressible fluid mechanics. -Like all SSPRK methods, this method also takes optional arguments `stage_limiter!` +Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -3695,47 +2511,47 @@ default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. ## References -- Shu, Chi-Wang. - "Total-variation-diminishing time discretizations." - SIAM Journal on Scientific and Statistical Computing 9, no. 6 (1988): 1073-1084. - [DOI: 10.1137/0909073](https://doi.org/10.1137/0909073) + + - 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) """ -struct SSPRKMSVS43{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct RDPK3SpFSAL49{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function SSPRKMSVS43(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - SSPRKMSVS43{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function RDPK3SpFSAL49(; stage_limiter! = trivial_limiter!, + step_limiter! = trivial_limiter!, thread = False()) + RDPK3SpFSAL49{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function SSPRKMSVS43(stage_limiter!, step_limiter! = trivial_limiter!) - SSPRKMSVS43{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function RDPK3SpFSAL49(stage_limiter!, step_limiter! = trivial_limiter!) + RDPK3SpFSAL49{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::SSPRKMSVS43) - print(io, "SSPRKMSVS43(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::RDPK3SpFSAL49) + print(io, "RDPK3SpFSAL49(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - SSPRKMSVS32(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + RDPK3Sp510(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A second-order, three-step explicit strong stability preserving (SSP) linear multistep method. -This method does not come with an error estimator and requires a fixed time step -size. +A fifth-order, ten-stage explicit Runge-Kutta method with embedded error estimator +designed for spectral element discretizations of compressible fluid mechanics. -Like all SSPRK methods, this method also takes optional arguments `stage_limiter!` +Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -3745,48 +2561,47 @@ default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. ## References -- Shu, Chi-Wang. - "Total-variation-diminishing time discretizations." - SIAM Journal on Scientific and Statistical Computing 9, no. 6 (1988): 1073-1084. - [DOI: 10.1137/0909073](https://doi.org/10.1137/0909073) + + - 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) """ -struct SSPRKMSVS32{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct RDPK3Sp510{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function SSPRKMSVS32(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function RDPK3Sp510(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - SSPRKMSVS32{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + RDPK3Sp510{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function SSPRKMSVS32(stage_limiter!, step_limiter! = trivial_limiter!) - SSPRKMSVS32{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) +function RDPK3Sp510(stage_limiter!, step_limiter! = trivial_limiter!) + RDPK3Sp510{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, False()) end -function Base.show(io::IO, alg::SSPRKMSVS32) - print(io, "SSPRKMSVS32(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::RDPK3Sp510) + print(io, "RDPK3Sp510(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - SSPRK932(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -A third-order, nine-stage explicit strong stability preserving (SSP) method. + RDPK3SpFSAL510(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -Consider using `SSPRK43` instead, which uses the same main method and an -improved embedded method. +A fifth-order, ten-stage explicit Runge-Kutta method with embedded error estimator +using the FSAL property designed for spectral element discretizations of +compressible fluid mechanics. -Like all SSPRK methods, this method takes optional arguments `stage_limiter!` +Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -3796,88 +2611,70 @@ default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. ## References -- Gottlieb, Sigal, David I. Ketcheson, and Chi-Wang Shu. - Strong stability preserving Runge-Kutta and multistep time discretizations. - World Scientific, 2011. + + - 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) """ -struct SSPRK932{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct RDPK3SpFSAL510{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function SSPRK932(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - SSPRK932{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function RDPK3SpFSAL510(; stage_limiter! = trivial_limiter!, + step_limiter! = trivial_limiter!, thread = False()) + RDPK3SpFSAL510{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function SSPRK932(stage_limiter!, step_limiter! = trivial_limiter!) - SSPRK932{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, False()) +function RDPK3SpFSAL510(stage_limiter!, step_limiter! = trivial_limiter!) + RDPK3SpFSAL510{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, + False()) end -function Base.show(io::IO, alg::SSPRK932) - print(io, "SSPRK932(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::RDPK3SpFSAL510) + print(io, "RDPK3SpFSAL510(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end -""" - SSPRK54(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -A fourth-order, five-stage explicit strong stability preserving (SSP) method. -Fixed timestep only. - -Like all SSPRK methods, this method takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. - -## References -- Ruuth, Steven. - "Global optimization of explicit strong-stability-preserving Runge-Kutta methods." - Mathematics of Computation 75.253 (2006): 183-207. -""" -struct SSPRK54{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct KYK2014DGSSPRK_3S2{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function SSPRK54(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False()) - SSPRK54{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function KYK2014DGSSPRK_3S2(; stage_limiter! = trivial_limiter!, + step_limiter! = trivial_limiter!, thread = False()) + KYK2014DGSSPRK_3S2{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function SSPRK54(stage_limiter!, step_limiter! = trivial_limiter!) - SSPRK54{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, False()) +function KYK2014DGSSPRK_3S2(stage_limiter!, step_limiter! = trivial_limiter!) + KYK2014DGSSPRK_3S2{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, + False()) end -function Base.show(io::IO, alg::SSPRK54) - print(io, "SSPRK54(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::KYK2014DGSSPRK_3S2) + print(io, "KYK2014DGSSPRK_3S2(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - SSPRK104(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + SSPRK22(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A fourth-order, ten-stage explicit strong stability preserving (SSP) method. +A second-order, two-stage explicit strong stability preserving (SSP) method. Fixed timestep only. Like all SSPRK methods, this method takes optional arguments `stage_limiter!` @@ -3890,45 +2687,46 @@ default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. ## References -- Ketcheson, David I. - "Highly efficient strong stability-preserving Runge–Kutta methods with - low-storage implementations." - SIAM Journal on Scientific Computing 30.4 (2008): 2113-2136. + + - 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 """ -struct SSPRK104{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct SSPRK22{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function SSPRK104(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function SSPRK22(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - SSPRK104{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + SSPRK22{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function SSPRK104(stage_limiter!, step_limiter! = trivial_limiter!) - SSPRK104{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function SSPRK22(stage_limiter!, step_limiter! = trivial_limiter!) + SSPRK22{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::SSPRK104) - print(io, "SSPRK104(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::SSPRK22) + print(io, "SSPRK22(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - OwrenZen3(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + SSPRK33(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -Explicit Runge-Kutta Method - Owren-Zennaro optimized interpolation 3/2 method (free 3rd order interpolant). +A third-order, three-stage explicit strong stability preserving (SSP) method. +Fixed timestep only. -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` +Like all SSPRK methods, this method takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -3937,53 +2735,47 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. -## Reference -@article{owren1992derivation, - title={Derivation of efficient, continuous, explicit Runge--Kutta methods}, - author={Owren, Brynjulf and Zennaro, Marino}, - journal={SIAM journal on scientific and statistical computing}, - volume={13}, - number={6}, - pages={1488--1501}, - year={1992}, - publisher={SIAM} -} +## 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 """ -struct OwrenZen3{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct SSPRK33{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function OwrenZen3(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function SSPRK33(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - OwrenZen3{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + SSPRK33{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function OwrenZen3(stage_limiter!, step_limiter! = trivial_limiter!) - OwrenZen3{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) +function SSPRK33(stage_limiter!, step_limiter! = trivial_limiter!) + SSPRK33{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, False()) end -function Base.show(io::IO, alg::OwrenZen3) - print(io, "OwrenZen3(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::SSPRK33) + print(io, "SSPRK33(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - OwrenZen4(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + SSPRK53(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -Explicit Runge-Kutta Method - Owren-Zennaro optimized interpolation 4/3 method (free 4th order interpolant). +A third-order, five-stage explicit strong stability preserving (SSP) method. +Fixed timestep only. -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` +Like all SSPRK methods, this method takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -3992,107 +2784,72 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. -## Reference -@article{owren1992derivation, - title={Derivation of efficient, continuous, explicit Runge--Kutta methods}, - author={Owren, Brynjulf and Zennaro, Marino}, - journal={SIAM journal on scientific and statistical computing}, - volume={13}, - number={6}, - pages={1488--1501}, - year={1992}, - publisher={SIAM} -} +## References + + - Ruuth, Steven. + "Global optimization of explicit strong-stability-preserving Runge-Kutta methods." + Mathematics of Computation 75.253 (2006): 183-207. """ -struct OwrenZen4{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct SSPRK53{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function OwrenZen4(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function SSPRK53(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - OwrenZen4{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + SSPRK53{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end -# for backwards compatibility -function OwrenZen4(stage_limiter!, step_limiter! = trivial_limiter!) - OwrenZen4{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) +# for backwards compatibility +function SSPRK53(stage_limiter!, step_limiter! = trivial_limiter!) + SSPRK53{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, False()) end -function Base.show(io::IO, alg::OwrenZen4) - print(io, "OwrenZen4(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::SSPRK53) + print(io, "SSPRK53(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end -""" - OwrenZen5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) - -Explicit Runge-Kutta Method - Owren-Zennaro optimized interpolation 5/4 method (free 5th order interpolant). - -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` -and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions -of the form `limiter!(u, integrator, p, t)`. - -The argument `thread` determines whether internal broadcasting on -appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, -default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when -Julia is started with multiple threads. - -## Reference -@article{owren1992derivation, - title={Derivation of efficient, continuous, explicit Runge--Kutta methods}, - author={Owren, Brynjulf and Zennaro, Marino}, - journal={SIAM journal on scientific and statistical computing}, - volume={13}, - number={6}, - pages={1488--1501}, - year={1992}, - publisher={SIAM} -} -""" -struct OwrenZen5{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct KYKSSPRK42{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function OwrenZen5(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function KYKSSPRK42(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - OwrenZen5{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + KYKSSPRK42{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function OwrenZen5(stage_limiter!, step_limiter! = trivial_limiter!) - OwrenZen5{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function KYKSSPRK42(stage_limiter!, step_limiter! = trivial_limiter!) + KYKSSPRK42{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::OwrenZen5) - print(io, "OwrenZen5(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::KYKSSPRK42) + print(io, "KYKSSPRK42(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - Alshina2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + SSPRK53_2N1(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -2nd order, 2-stage Explicit Runge-Kutta Method with optimal parameters. +A third-order, five-stage explicit strong stability preserving (SSP) low-storage method. +Fixed timestep only. -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` +Like all SSPRK methods, this method takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -4101,54 +2858,47 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. -## Reference -@article{Alshina2008, - doi = {10.1134/s0965542508030068}, - url = {https://doi.org/10.1134/s0965542508030068}, - year = {2008}, - month = mar, - publisher = {Pleiades Publishing Ltd}, - volume = {48}, - number = {3}, - pages = {395--405}, - author = {E. A. Alshina and E. M. Zaks and N. N. Kalitkin}, - title = {Optimal first- to sixth-order accurate Runge-Kutta schemes}, - journal = {Computational Mathematics and Mathematical Physics} -} +## References + + - Higueras and T. Roldán. + "New third order low-storage SSP explicit Runge–Kutta methods". + arXiv:1809.04807v1. """ -struct Alshina2{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct SSPRK53_2N1{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function Alshina2(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function SSPRK53_2N1(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - Alshina2{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + SSPRK53_2N1{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end -function Alshina2(stage_limiter!, step_limiter! = trivial_limiter!) - Alshina2{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +# for backwards compatibility +function SSPRK53_2N1(stage_limiter!, step_limiter! = trivial_limiter!) + SSPRK53_2N1{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::Alshina2) - print(io, "Alshina2(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::SSPRK53_2N1) + print(io, "SSPRK53_2N1(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - Alshina3(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + SSPRK53_2N2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -3rd order, 3-stage Explicit Runge-Kutta Method with optimal parameters. +A third-order, five-stage explicit strong stability preserving (SSP) low-storage method. +Fixed timestep only. -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` +Like all SSPRK methods, this method takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -4157,54 +2907,47 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. -## Reference -@article{Alshina2008, - doi = {10.1134/s0965542508030068}, - url = {https://doi.org/10.1134/s0965542508030068}, - year = {2008}, - month = mar, - publisher = {Pleiades Publishing Ltd}, - volume = {48}, - number = {3}, - pages = {395--405}, - author = {E. A. Alshina and E. M. Zaks and N. N. Kalitkin}, - title = {Optimal first- to sixth-order accurate Runge-Kutta schemes}, - journal = {Computational Mathematics and Mathematical Physics} -} +## References + + - Higueras and T. Roldán. + "New third order low-storage SSP explicit Runge–Kutta methods". + arXiv:1809.04807v1. """ -struct Alshina3{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct SSPRK53_2N2{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function Alshina3(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function SSPRK53_2N2(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - Alshina3{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + SSPRK53_2N2{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end -function Alshina3(stage_limiter!, step_limiter! = trivial_limiter!) - Alshina3{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +# for backwards compatibility +function SSPRK53_2N2(stage_limiter!, step_limiter! = trivial_limiter!) + SSPRK53_2N2{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::Alshina3) - print(io, "Alshina3(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::SSPRK53_2N2) + print(io, "SSPRK53_2N2(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - Alshina6(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + SSPRK53_H(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -6th order, 7-stage Explicit Runge-Kutta Method with optimal parameters. +A third-order, five-stage explicit strong stability preserving (SSP) low-storage method. +Fixed timestep only. -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` +Like all SSPRK methods, this method takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -4213,55 +2956,46 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. -## Reference -@article{Alshina2008, - doi = {10.1134/s0965542508030068}, - url = {https://doi.org/10.1134/s0965542508030068}, - year = {2008}, - month = mar, - publisher = {Pleiades Publishing Ltd}, - volume = {48}, - number = {3}, - pages = {395--405}, - author = {E. A. Alshina and E. M. Zaks and N. N. Kalitkin}, - title = {Optimal first- to sixth-order accurate Runge-Kutta schemes}, - journal = {Computational Mathematics and Mathematical Physics} -} +## References + + - Higueras and T. Roldán. + "New third order low-storage SSP explicit Runge–Kutta methods". + arXiv:1809.04807v1. """ -struct Alshina6{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm +struct SSPRK53_H{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function Alshina6(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function SSPRK53_H(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - Alshina6{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + SSPRK53_H{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end -function Alshina6(stage_limiter!, step_limiter! = trivial_limiter!) - Alshina6{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) +# for backwards compatibility +function SSPRK53_H(stage_limiter!, step_limiter! = trivial_limiter!) + SSPRK53_H{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, False()) end -function Base.show(io::IO, alg::Alshina6) - print(io, "Alshina6(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::SSPRK53_H) + print(io, "SSPRK53_H(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - BS3(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + SSPRK63(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A third-order, four-stage explicit FSAL Runge-Kutta method with embedded error -estimator of Bogacki and Shampine. +A third-order, six-stage explicit strong stability preserving (SSP) method. +Fixed timestep only. -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` +Like all SSPRK methods, this method takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -4271,52 +3005,45 @@ default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. ## References -@article{bogacki19893, - title={A 3 (2) pair of Runge-Kutta formulas}, - author={Bogacki, Przemyslaw and Shampine, Lawrence F}, - journal={Applied Mathematics Letters}, - volume={2}, - number={4}, - pages={321--325}, - year={1989}, - publisher={Elsevier} -} + + - Ruuth, Steven. + "Global optimization of explicit strong-stability-preserving Runge-Kutta methods." + Mathematics of Computation 75.253 (2006): 183-207. """ -struct BS3{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct SSPRK63{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function BS3(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function SSPRK63(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - BS3{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + SSPRK63{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function BS3(stage_limiter!, step_limiter! = trivial_limiter!) - BS3{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) +function SSPRK63(stage_limiter!, step_limiter! = trivial_limiter!) + SSPRK63{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, False()) end -function Base.show(io::IO, alg::BS3) - print(io, "BS3(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::SSPRK63) + print(io, "SSPRK63(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - DP5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + SSPRK73(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -Explicit Runge-Kutta Method - Dormand-Prince's 5/4 Runge-Kutta method. (free 4th order interpolant). +A third-order, seven-stage explicit strong stability preserving (SSP) method. +Fixed timestep only. -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` +Like all SSPRK methods, this method takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -4325,52 +3052,46 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. -## Reference -@article{dormand1980family, - title={A family of embedded Runge-Kutta formulae}, - author={Dormand, John R and Prince, Peter J}, - journal={Journal of computational and applied mathematics}, - volume={6}, - number={1}, - pages={19--26}, - year={1980}, - publisher={Elsevier} -} +## References + + - Ruuth, Steven. + "Global optimization of explicit strong-stability-preserving Runge-Kutta methods." + Mathematics of Computation 75.253 (2006): 183-207. """ -struct DP5{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct SSPRK73{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function DP5(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function SSPRK73(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - DP5{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + SSPRK73{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function DP5(stage_limiter!, step_limiter! = trivial_limiter!) - DP5{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function SSPRK73(stage_limiter!, step_limiter! = trivial_limiter!) + SSPRK73{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::DP5) - print(io, "DP5(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::SSPRK73) + print(io, "SSPRK73(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - Tsit5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + SSPRK83(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -A fifth-order explicit Runge-Kutta method with embedded error -estimator of Tsitouras. Free 4th order interpolant. +A third-order, eight-stage explicit strong stability preserving (SSP) method. +Fixed timestep only. -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` +Like all SSPRK methods, this method takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -4380,53 +3101,44 @@ default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. ## References -@article{tsitouras2011runge, - title={Runge--Kutta pairs of order 5 (4) satisfying only the first column simplifying assumption}, - author={Tsitouras, Ch}, - journal={Computers \\& Mathematics with Applications}, - volume={62}, - number={2}, - pages={770--775}, - year={2011}, - publisher={Elsevier} -} + + - Ruuth, Steven. + "Global optimization of explicit strong-stability-preserving Runge-Kutta methods." + Mathematics of Computation 75.253 (2006): 183-207. """ -struct Tsit5{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct SSPRK83{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -TruncatedStacktraces.@truncate_stacktrace Tsit5 3 - -function Tsit5(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function SSPRK83(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - Tsit5{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + SSPRK83{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function Tsit5(stage_limiter!, step_limiter! = trivial_limiter!) - Tsit5{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function SSPRK83(stage_limiter!, step_limiter! = trivial_limiter!) + SSPRK83{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::Tsit5) - print(io, "Tsit5(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::SSPRK83) + print(io, "SSPRK83(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - DP8(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + SSPRK43(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -Explicit Runge-Kutta Method - Hairer's 8/5/3 adaption of the Dormand-Prince Runge-Kutta method. (7th order interpolant). +A third-order, four-stage explicit strong stability preserving (SSP) method. -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` +Like all SSPRK methods, this method takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -4435,46 +3147,65 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. -## Reference -E. Hairer, S.P. Norsett, G. Wanner, (1993) Solving Ordinary Differential Equations I. -Nonstiff Problems. 2nd Edition. Springer Series in Computational Mathematics, -Springer-Verlag. +## References + +Optimal third-order explicit SSP method with four stages discovered by + + - J. F. B. M. Kraaijevanger. + "Contractivity of Runge-Kutta methods." + In: BIT Numerical Mathematics 31.3 (1991), pp. 482–528. + [DOI: 10.1007/BF01933264](https://doi.org/10.1007/BF01933264). + +Embedded method constructed by + + - Sidafa Conde, Imre Fekete, John N. Shadid. + "Embedded error estimation and adaptive step-size control for + optimal explicit strong stability preserving Runge–Kutta methods." + [arXiv: 1806.08693](https://arXiv.org/abs/1806.08693) + +Efficient implementation (and optimized controller) developed by + + - Hendrik Ranocha, Lisandro Dalcin, Matteo Parsani, David I. 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) """ -struct DP8{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct SSPRK43{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function DP8(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function SSPRK43(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - DP8{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + SSPRK43{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function DP8(stage_limiter!, step_limiter! = trivial_limiter!) - DP8{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) +function SSPRK43(stage_limiter!, step_limiter! = trivial_limiter!) + SSPRK43{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, False()) end -function Base.show(io::IO, alg::DP8) - print(io, "DP8(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::SSPRK43) + print(io, "SSPRK43(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - TanYam7(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + SSPRK432(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -Explicit Runge-Kutta Method - Tanaka-Yamashita 7 Runge-Kutta method. +A third-order, four-stage explicit strong stability preserving (SSP) method. -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` +Consider using `SSPRK43` instead, which uses the same main method and an +improved embedded method. + +Like all SSPRK methods, this method takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -4483,46 +3214,48 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. -## Reference -Tanaka M., Muramatsu S., Yamashita S., (1992), On the Optimization of Some Nine-Stage -Seventh-order Runge-Kutta Method, Information Processing Society of Japan, -33 (12), pp. 1512-1526. +## References + + - Gottlieb, Sigal, David I. Ketcheson, and Chi-Wang Shu. + Strong stability preserving Runge-Kutta and multistep time discretizations. + World Scientific, 2011. + Example 6.1. """ -struct TanYam7{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct SSPRK432{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function TanYam7(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function SSPRK432(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - TanYam7{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + SSPRK432{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function TanYam7(stage_limiter!, step_limiter! = trivial_limiter!) - TanYam7{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False()) +function SSPRK432(stage_limiter!, step_limiter! = trivial_limiter!) + SSPRK432{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, False()) end -function Base.show(io::IO, alg::TanYam7) - print(io, "TanYam7(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::SSPRK432) + print(io, "SSPRK432(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ - TsitPap8(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + SSPRKMSVS43(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -Explicit Runge-Kutta Method - Tsitouras-Papakostas 8/7 Runge-Kutta method. +A third-order, four-step explicit strong stability preserving (SSP) linear multistep method. +This method does not come with an error estimator and requires a fixed time step +size. -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` +Like all SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -4530,78 +3263,50 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. + +## References + + - Shu, Chi-Wang. + "Total-variation-diminishing time discretizations." + SIAM Journal on Scientific and Statistical Computing 9, no. 6 (1988): 1073-1084. + [DOI: 10.1137/0909073](https://doi.org/10.1137/0909073) """ -struct TsitPap8{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct SSPRKMSVS43{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread end -function TsitPap8(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, +function SSPRKMSVS43(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, thread = False()) - TsitPap8{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, + SSPRKMSVS43{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, thread) end # for backwards compatibility -function TsitPap8(stage_limiter!, step_limiter! = trivial_limiter!) - TsitPap8{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function SSPRKMSVS43(stage_limiter!, step_limiter! = trivial_limiter!) + SSPRKMSVS43{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, False()) end -function Base.show(io::IO, alg::TsitPap8) - print(io, "TsitPap8(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::SSPRKMSVS43) + print(io, "SSPRKMSVS43(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, ", thread = ", alg.thread, ")") end """ -@article{feagin2012high, - title={High-order explicit Runge-Kutta methods using m-symmetry}, - author={Feagin, Terry}, - year={2012}, - publisher={Neural, Parallel \\& Scientific Computations} -} - -Feagin10: Explicit Runge-Kutta Method - Feagin's 10th-order Runge-Kutta method. -""" -struct Feagin10 <: OrdinaryDiffEqAdaptiveAlgorithm end - -""" -@article{feagin2012high, - title={High-order explicit Runge-Kutta methods using m-symmetry}, - author={Feagin, Terry}, - year={2012}, - publisher={Neural, Parallel \\& Scientific Computations} -} - -Feagin12: Explicit Runge-Kutta Method - Feagin's 12th-order Runge-Kutta method. -""" -struct Feagin12 <: OrdinaryDiffEqAdaptiveAlgorithm end - -""" -Feagin, T., “An Explicit Runge-Kutta Method of Order Fourteen,” Numerical -Algorithms, 2009 - -Feagin14: Explicit Runge-Kutta Method - Feagin's 14th-order Runge-Kutta method. -""" -struct Feagin14 <: OrdinaryDiffEqAdaptiveAlgorithm end - -""" - BS5(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False(), - lazy = true) + SSPRKMSVS32(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -Explicit Runge-Kutta Method - Bogacki-Shampine 5/4 Runge-Kutta method. (lazy 5th order interpolant). +A second-order, three-step explicit strong stability preserving (SSP) linear multistep method. +This method does not come with an error estimator and requires a fixed time step +size. -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` +Like all SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -4610,59 +3315,50 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. -## Reference -@article{bogacki1996efficient, - title={An efficient runge-kutta (4, 5) pair}, - author={Bogacki, P and Shampine, Lawrence F}, - journal={Computers \\& Mathematics with Applications}, - volume={32}, - number={6}, - pages={15--28}, - year={1996}, - publisher={Elsevier} -} +## References + + - Shu, Chi-Wang. + "Total-variation-diminishing time discretizations." + SIAM Journal on Scientific and Statistical Computing 9, no. 6 (1988): 1073-1084. + [DOI: 10.1137/0909073](https://doi.org/10.1137/0909073) """ -struct BS5{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct SSPRKMSVS32{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread - lazy::Bool end -function BS5(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False(), lazy = true) - BS5{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function SSPRKMSVS32(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, + thread = False()) + SSPRKMSVS32{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, - thread, - lazy) + thread) end # for backwards compatibility -function BS5(stage_limiter!, step_limiter! = trivial_limiter!; lazy = true) - BS5{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function SSPRKMSVS32(stage_limiter!, step_limiter! = trivial_limiter!) + SSPRKMSVS32{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, - False(), - lazy) + False()) end -function Base.show(io::IO, alg::BS5) - print(io, "BS5(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::SSPRKMSVS32) + print(io, "SSPRKMSVS32(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, - ", lazy = ", alg.lazy, - ")") + ", thread = ", alg.thread, ")") end """ - Vern6(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False(), - lazy = true) + SSPRK932(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -Explicit Runge-Kutta Method - Verner's “Most Efficient” 6/5 Runge-Kutta method. (lazy 6th order interpolant). +A third-order, nine-stage explicit strong stability preserving (SSP) method. -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` +Consider using `SSPRK43` instead, which uses the same main method and an +improved embedded method. + +Like all SSPRK methods, this method takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -4671,60 +3367,46 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. -## Reference -@article{verner2010numerically, - title={Numerically optimal Runge--Kutta pairs with interpolants}, - author={Verner, James H}, - journal={Numerical Algorithms}, - volume={53}, - number={2-3}, - pages={383--396}, - year={2010}, - publisher={Springer} -} +## References + + - Gottlieb, Sigal, David I. Ketcheson, and Chi-Wang Shu. + Strong stability preserving Runge-Kutta and multistep time discretizations. + World Scientific, 2011. """ -struct Vern6{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct SSPRK932{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread - lazy::Bool end -TruncatedStacktraces.@truncate_stacktrace Vern6 3 - -function Vern6(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False(), lazy = true) - Vern6{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function SSPRK932(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, + thread = False()) + SSPRK932{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, - thread, - lazy) + thread) end # for backwards compatibility -function Vern6(stage_limiter!, step_limiter! = trivial_limiter!; lazy = true) - Vern6{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False(), - lazy) +function SSPRK932(stage_limiter!, step_limiter! = trivial_limiter!) + SSPRK932{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, False()) end -function Base.show(io::IO, alg::Vern6) - print(io, "Vern6(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::SSPRK932) + print(io, "SSPRK932(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, - ", lazy = ", alg.lazy, - ")") + ", thread = ", alg.thread, ")") end """ - Vern7(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False()) + SSPRK54(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -Explicit Runge-Kutta Method - Verner's “Most Efficient” 7/6 Runge-Kutta method. (lazy 7th order interpolant). +A fourth-order, five-stage explicit strong stability preserving (SSP) method. +Fixed timestep only. -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` +Like all SSPRK methods, this method takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -4733,61 +3415,46 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. -## Reference -@article{verner2010numerically, - title={Numerically optimal Runge--Kutta pairs with interpolants}, - author={Verner, James H}, - journal={Numerical Algorithms}, - volume={53}, - number={2-3}, - pages={383--396}, - year={2010}, - publisher={Springer} -} +## References + + - Ruuth, Steven. + "Global optimization of explicit strong-stability-preserving Runge-Kutta methods." + Mathematics of Computation 75.253 (2006): 183-207. """ -struct Vern7{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct SSPRK54{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread - lazy::Bool end -TruncatedStacktraces.@truncate_stacktrace Vern7 3 - -function Vern7(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False(), lazy = true) - Vern7{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function SSPRK54(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, + thread = False()) + SSPRK54{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, - thread, - lazy) + thread) end # for backwards compatibility -function Vern7(stage_limiter!, step_limiter! = trivial_limiter!; lazy = true) - Vern7{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False(), - lazy) +function SSPRK54(stage_limiter!, step_limiter! = trivial_limiter!) + SSPRK54{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, False()) end -function Base.show(io::IO, alg::Vern7) - print(io, "Vern7(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::SSPRK54) + print(io, "SSPRK54(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, - ", lazy = ", alg.lazy, - ")") + ", thread = ", alg.thread, ")") end """ - Vern8(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, - step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False(), - lazy = true) + SSPRK104(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False()) -Explicit Runge-Kutta Method - Verner's “Most Efficient” 8/7 Runge-Kutta method. (lazy 8th order interpolant) +A fourth-order, ten-stage explicit strong stability preserving (SSP) method. +Fixed timestep only. -Like SSPRK methods, this method also takes optional arguments `stage_limiter!` +Like all SSPRK methods, this method takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions of the form `limiter!(u, integrator, p, t)`. @@ -4796,59 +3463,44 @@ appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. -## Reference -@article{verner2010numerically, - title={Numerically optimal Runge--Kutta pairs with interpolants}, - author={Verner, James H}, - journal={Numerical Algorithms}, - volume={53}, - number={2-3}, - pages={383--396}, - year={2010}, - publisher={Springer} -} +## References + + - Ketcheson, David I. + "Highly efficient strong stability-preserving Runge–Kutta methods with + low-storage implementations." + SIAM Journal on Scientific Computing 30.4 (2008): 2113-2136. """ -struct Vern8{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct SSPRK104{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread - lazy::Bool end -TruncatedStacktraces.@truncate_stacktrace Vern8 3 - -function Vern8(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False(), lazy = true) - Vern8{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function SSPRK104(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, + thread = False()) + SSPRK104{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, - thread, - lazy) + thread) end # for backwards compatibility -function Vern8(stage_limiter!, step_limiter! = trivial_limiter!; lazy = true) - Vern8{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, - step_limiter!, - False(), - lazy) +function SSPRK104(stage_limiter!, step_limiter! = trivial_limiter!) + SSPRK104{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, + step_limiter!, False()) end -function Base.show(io::IO, alg::Vern8) - print(io, "Vern8(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::SSPRK104) + print(io, "SSPRK104(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, - ", lazy = ", alg.lazy, - ")") + ", thread = ", alg.thread, ")") end """ - Vern9(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + Alshina2(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False(), - lazy = true) + thread = OrdinaryDiffEq.False()) -Explicit Runge-Kutta Method - Verner's “Most Efficient” 9/8 Runge-Kutta method. (lazy 9th order interpolant) +2nd order, 2-stage Explicit Runge-Kutta Method with optimal parameters. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -4860,59 +3512,52 @@ default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. ## Reference -@article{verner2010numerically, - title={Numerically optimal Runge--Kutta pairs with interpolants}, - author={Verner, James H}, - journal={Numerical Algorithms}, - volume={53}, - number={2-3}, - pages={383--396}, - year={2010}, - publisher={Springer} + +@article{Alshina2008, +doi = {10.1134/s0965542508030068}, +url = {https://doi.org/10.1134/s0965542508030068}, +year = {2008}, +month = mar, +publisher = {Pleiades Publishing Ltd}, +volume = {48}, +number = {3}, +pages = {395--405}, +author = {E. A. Alshina and E. M. Zaks and N. N. Kalitkin}, +title = {Optimal first- to sixth-order accurate Runge-Kutta schemes}, +journal = {Computational Mathematics and Mathematical Physics} } """ -struct Vern9{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm +struct Alshina2{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread - lazy::Bool end -TruncatedStacktraces.@truncate_stacktrace Vern9 3 - -function Vern9(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False(), lazy = true) - Vern9{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, +function Alshina2(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, + thread = False()) + Alshina2{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, - thread, - lazy) + thread) end -# for backwards compatibility -function Vern9(stage_limiter!, step_limiter! = trivial_limiter!; lazy = true) - Vern9{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, +function Alshina2(stage_limiter!, step_limiter! = trivial_limiter!) + Alshina2{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, - False(), - lazy) + False()) end -function Base.show(io::IO, alg::Vern9) - print(io, "Vern9(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::Alshina2) + print(io, "Alshina2(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, - ", lazy = ", alg.lazy, - ")") + ", thread = ", alg.thread, ")") end """ - FRK65(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + Alshina3(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False(), - omega = 0.0) + thread = OrdinaryDiffEq.False()) -Explicit Runge-Kutta - Zero Dissipation Runge-Kutta of 6th order. - Takes an optional argument omega to for the periodicity phase, in which case this method results in zero numerical dissipation. +3rd order, 3-stage Explicit Runge-Kutta Method with optimal parameters. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -4922,47 +3567,54 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. + +## Reference + +@article{Alshina2008, +doi = {10.1134/s0965542508030068}, +url = {https://doi.org/10.1134/s0965542508030068}, +year = {2008}, +month = mar, +publisher = {Pleiades Publishing Ltd}, +volume = {48}, +number = {3}, +pages = {395--405}, +author = {E. A. Alshina and E. M. Zaks and N. N. Kalitkin}, +title = {Optimal first- to sixth-order accurate Runge-Kutta schemes}, +journal = {Computational Mathematics and Mathematical Physics} +} """ -struct FRK65{StageLimiter, StepLimiter, Thread, T} <: OrdinaryDiffEqAdaptiveAlgorithm +struct Alshina3{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread - omega::T end -function FRK65(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False(), omega = 0.0) - FRK65{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread), typeof(omega)}(stage_limiter!, +function Alshina3(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, + thread = False()) + Alshina3{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, - thread, - omega) + thread) end -# for backwards compatibility -function FRK65(stage_limiter!, step_limiter! = trivial_limiter!; omega = 0.0) - FRK65{typeof(stage_limiter!), typeof(step_limiter!), False, typeof(omega)}(stage_limiter!, +function Alshina3(stage_limiter!, step_limiter! = trivial_limiter!) + Alshina3{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, - False(), - omega) + False()) end -function Base.show(io::IO, alg::FRK65) - print(io, "FRK65(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::Alshina3) + print(io, "Alshina3(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, - ", periodicity phase = ", alg.omega, - ")") + ", thread = ", alg.thread, ")") end """ - PFRK87(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + Alshina6(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, step_limiter! = OrdinaryDiffEq.trivial_limiter!, - thread = OrdinaryDiffEq.False(), - omega = 0.0) + thread = OrdinaryDiffEq.False()) -Explicit Runge-Kutta - Phase-fitted Runge-Kutta of 8th order. - Takes an optional argument w to for the periodicity phase, in which case this method results in zero numerical dissipation. +6th order, 7-stage Explicit Runge-Kutta Method with optimal parameters. Like SSPRK methods, this method also takes optional arguments `stage_limiter!` and `step_limiter!`, where `stage_limiter!` and `step_limiter!` are functions @@ -4972,36 +3624,46 @@ The argument `thread` determines whether internal broadcasting on appropriate CPU arrays should be serial (`thread = OrdinaryDiffEq.False()`, default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when Julia is started with multiple threads. + +## Reference + +@article{Alshina2008, +doi = {10.1134/s0965542508030068}, +url = {https://doi.org/10.1134/s0965542508030068}, +year = {2008}, +month = mar, +publisher = {Pleiades Publishing Ltd}, +volume = {48}, +number = {3}, +pages = {395--405}, +author = {E. A. Alshina and E. M. Zaks and N. N. Kalitkin}, +title = {Optimal first- to sixth-order accurate Runge-Kutta schemes}, +journal = {Computational Mathematics and Mathematical Physics} +} """ -struct PFRK87{StageLimiter, StepLimiter, Thread, T} <: OrdinaryDiffEqAdaptiveAlgorithm +struct Alshina6{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm stage_limiter!::StageLimiter step_limiter!::StepLimiter thread::Thread - omega::T end -function PFRK87(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, - thread = False(), omega = 0.0) - PFRK87{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread), typeof(omega)}(stage_limiter!, +function Alshina6(; stage_limiter! = trivial_limiter!, step_limiter! = trivial_limiter!, + thread = False()) + Alshina6{typeof(stage_limiter!), typeof(step_limiter!), typeof(thread)}(stage_limiter!, step_limiter!, - thread, - omega) + thread) end -# for backwards compatibility -function PFRK87(stage_limiter!, step_limiter! = trivial_limiter!; omega = 0.0) - PFRK87{typeof(stage_limiter!), typeof(step_limiter!), False, typeof(omega)}(stage_limiter!, +function Alshina6(stage_limiter!, step_limiter! = trivial_limiter!) + Alshina6{typeof(stage_limiter!), typeof(step_limiter!), False}(stage_limiter!, step_limiter!, - False(), - omega) + False()) end -function Base.show(io::IO, alg::PFRK87) - print(io, "PFRK87(stage_limiter! = ", alg.stage_limiter!, +function Base.show(io::IO, alg::Alshina6) + print(io, "Alshina6(stage_limiter! = ", alg.stage_limiter!, ", step_limiter! = ", alg.step_limiter!, - ", thread = ", alg.thread, - ", periodicity phase = ", alg.omega, - ")") + ", thread = ", alg.thread, ")") end ################################################################################ @@ -5012,97 +3674,97 @@ struct SymplecticEuler <: OrdinaryDiffEqPartitionedAlgorithm end """ @article{verlet1967computer, - title={Computer" experiments" on classical fluids. I. Thermodynamical properties of Lennard-Jones molecules}, - author={Verlet, Loup}, - journal={Physical review}, - volume={159}, - number={1}, - pages={98}, - year={1967}, - publisher={APS} +title={Computer" experiments" on classical fluids. I. Thermodynamical properties of Lennard-Jones molecules}, +author={Verlet, Loup}, +journal={Physical review}, +volume={159}, +number={1}, +pages={98}, +year={1967}, +publisher={APS} } """ struct VelocityVerlet <: OrdinaryDiffEqPartitionedAlgorithm end """ @article{verlet1967computer, - title={Computer" experiments" on classical fluids. I. Thermodynamical properties of Lennard-Jones molecules}, - author={Verlet, Loup}, - journal={Physical review}, - volume={159}, - number={1}, - pages={98}, - year={1967}, - publisher={APS} +title={Computer" experiments" on classical fluids. I. Thermodynamical properties of Lennard-Jones molecules}, +author={Verlet, Loup}, +journal={Physical review}, +volume={159}, +number={1}, +pages={98}, +year={1967}, +publisher={APS} } """ struct VerletLeapfrog <: OrdinaryDiffEqPartitionedAlgorithm end """ @article{verlet1967computer, - title={Computer" experiments" on classical fluids. I. Thermodynamical properties of Lennard-Jones molecules}, - author={Verlet, Loup}, - journal={Physical review}, - volume={159}, - number={1}, - pages={98}, - year={1967}, - publisher={APS} +title={Computer" experiments" on classical fluids. I. Thermodynamical properties of Lennard-Jones molecules}, +author={Verlet, Loup}, +journal={Physical review}, +volume={159}, +number={1}, +pages={98}, +year={1967}, +publisher={APS} } """ struct PseudoVerletLeapfrog <: OrdinaryDiffEqPartitionedAlgorithm end """ @article{mclachlan1992accuracy, - title={The accuracy of symplectic integrators}, - author={McLachlan, Robert I and Atela, Pau}, - journal={Nonlinearity}, - volume={5}, - number={2}, - pages={541}, - year={1992}, - publisher={IOP Publishing} +title={The accuracy of symplectic integrators}, +author={McLachlan, Robert I and Atela, Pau}, +journal={Nonlinearity}, +volume={5}, +number={2}, +pages={541}, +year={1992}, +publisher={IOP Publishing} } """ struct McAte2 <: OrdinaryDiffEqPartitionedAlgorithm end """ @article{ruth1983canonical, - title={A canonical integration technique}, - author={Ruth, Ronald D}, - journal={IEEE Trans. Nucl. Sci.}, - volume={30}, - number={CERN-LEP-TH-83-14}, - pages={2669--2671}, - year={1983} +title={A canonical integration technique}, +author={Ruth, Ronald D}, +journal={IEEE Trans. Nucl. Sci.}, +volume={30}, +number={CERN-LEP-TH-83-14}, +pages={2669--2671}, +year={1983} } """ struct Ruth3 <: OrdinaryDiffEqPartitionedAlgorithm end """ @article{mclachlan1992accuracy, - title={The accuracy of symplectic integrators}, - author={McLachlan, Robert I and Atela, Pau}, - journal={Nonlinearity}, - volume={5}, - number={2}, - pages={541}, - year={1992}, - publisher={IOP Publishing} +title={The accuracy of symplectic integrators}, +author={McLachlan, Robert I and Atela, Pau}, +journal={Nonlinearity}, +volume={5}, +number={2}, +pages={541}, +year={1992}, +publisher={IOP Publishing} } """ struct McAte3 <: OrdinaryDiffEqPartitionedAlgorithm end """ @article{candy1991symplectic, - title={A symplectic integration algorithm for separable Hamiltonian functions}, - author={Candy, J and Rozmus, W}, - journal={Journal of Computational Physics}, - volume={92}, - number={1}, - pages={230--256}, - year={1991}, - publisher={Elsevier} +title={A symplectic integration algorithm for separable Hamiltonian functions}, +author={Candy, J and Rozmus, W}, +journal={Journal of Computational Physics}, +volume={92}, +number={1}, +pages={230--256}, +year={1991}, +publisher={Elsevier} } """ struct CandyRoz4 <: OrdinaryDiffEqPartitionedAlgorithm end @@ -5110,110 +3772,110 @@ struct McAte4 <: OrdinaryDiffEqPartitionedAlgorithm end """ @article{sanz1993symplectic, - title={Symplectic numerical methods for Hamiltonian problems}, - author={Sanz-Serna, Jes{\'u}s Maria and Calvo, Mari-Paz}, - journal={International Journal of Modern Physics C}, - volume={4}, - number={02}, - pages={385--392}, - year={1993}, - publisher={World Scientific} +title={Symplectic numerical methods for Hamiltonian problems}, +author={Sanz-Serna, Jes{\'u}s Maria and Calvo, Mari-Paz}, +journal={International Journal of Modern Physics C}, +volume={4}, +number={02}, +pages={385--392}, +year={1993}, +publisher={World Scientific} } """ struct CalvoSanz4 <: OrdinaryDiffEqPartitionedAlgorithm end """ @article{mclachlan1992accuracy, - title={The accuracy of symplectic integrators}, - author={McLachlan, Robert I and Atela, Pau}, - journal={Nonlinearity}, - volume={5}, - number={2}, - pages={541}, - year={1992}, - publisher={IOP Publishing} +title={The accuracy of symplectic integrators}, +author={McLachlan, Robert I and Atela, Pau}, +journal={Nonlinearity}, +volume={5}, +number={2}, +pages={541}, +year={1992}, +publisher={IOP Publishing} } """ struct McAte42 <: OrdinaryDiffEqPartitionedAlgorithm end """ @article{mclachlan1992accuracy, - title={The accuracy of symplectic integrators}, - author={McLachlan, Robert I and Atela, Pau}, - journal={Nonlinearity}, - volume={5}, - number={2}, - pages={541}, - year={1992}, - publisher={IOP Publishing} +title={The accuracy of symplectic integrators}, +author={McLachlan, Robert I and Atela, Pau}, +journal={Nonlinearity}, +volume={5}, +number={2}, +pages={541}, +year={1992}, +publisher={IOP Publishing} } """ struct McAte5 <: OrdinaryDiffEqPartitionedAlgorithm end """ @article{yoshida1990construction, - title={Construction of higher order symplectic integrators}, - author={Yoshida, Haruo}, - journal={Physics letters A}, - volume={150}, - number={5-7}, - pages={262--268}, - year={1990}, - publisher={Elsevier} +title={Construction of higher order symplectic integrators}, +author={Yoshida, Haruo}, +journal={Physics letters A}, +volume={150}, +number={5-7}, +pages={262--268}, +year={1990}, +publisher={Elsevier} } """ struct Yoshida6 <: OrdinaryDiffEqPartitionedAlgorithm end """ @article{kahan1997composition, - title={Composition constants for raising the orders of unconventional schemes for ordinary differential equations}, - author={Kahan, William and Li, Ren-Cang}, - journal={Mathematics of computation}, - volume={66}, - number={219}, - pages={1089--1099}, - year={1997} +title={Composition constants for raising the orders of unconventional schemes for ordinary differential equations}, +author={Kahan, William and Li, Ren-Cang}, +journal={Mathematics of computation}, +volume={66}, +number={219}, +pages={1089--1099}, +year={1997} } """ struct KahanLi6 <: OrdinaryDiffEqPartitionedAlgorithm end """ @article{mclachlan1995numerical, - title={On the numerical integration of ordinary differential equations by symmetric composition methods}, - author={McLachlan, Robert I}, - journal={SIAM Journal on Scientific Computing}, - volume={16}, - number={1}, - pages={151--168}, - year={1995}, - publisher={SIAM} +title={On the numerical integration of ordinary differential equations by symmetric composition methods}, +author={McLachlan, Robert I}, +journal={SIAM Journal on Scientific Computing}, +volume={16}, +number={1}, +pages={151--168}, +year={1995}, +publisher={SIAM} } """ struct McAte8 <: OrdinaryDiffEqPartitionedAlgorithm end """ @article{kahan1997composition, - title={Composition constants for raising the orders of unconventional schemes for ordinary differential equations}, - author={Kahan, William and Li, Ren-Cang}, - journal={Mathematics of computation}, - volume={66}, - number={219}, - pages={1089--1099}, - year={1997} +title={Composition constants for raising the orders of unconventional schemes for ordinary differential equations}, +author={Kahan, William and Li, Ren-Cang}, +journal={Mathematics of computation}, +volume={66}, +number={219}, +pages={1089--1099}, +year={1997} } """ struct KahanLi8 <: OrdinaryDiffEqPartitionedAlgorithm end """ @article{sofroniou2005derivation, - title={Derivation of symmetric composition constants for symmetric integrators}, - author={Sofroniou, Mark and Spaletta, Giulia}, - journal={Optimization Methods and Software}, - volume={20}, - number={4-5}, - pages={597--613}, - year={2005}, - publisher={Taylor \\& Francis} +title={Derivation of symmetric composition constants for symmetric integrators}, +author={Sofroniou, Mark and Spaletta, Giulia}, +journal={Optimization Methods and Software}, +volume={20}, +number={4-5}, +pages={597--613}, +year={2005}, +publisher={Taylor \\& Francis} } """ struct SofSpa10 <: OrdinaryDiffEqPartitionedAlgorithm end @@ -5228,10 +3890,11 @@ Improved Runge-Kutta-Nyström method of order three, which minimizes the amount Second order ODE should not depend on the first derivative. ## References + @article{rabiei2012numerical, - title={Numerical Solution of Second-Order Ordinary Differential Equations by Improved Runge-Kutta Nystrom Method}, - author={Rabiei, Faranak and Ismail, Fudziah and Norazak, S and Emadi, Saeid}, - publisher={Citeseer} +title={Numerical Solution of Second-Order Ordinary Differential Equations by Improved Runge-Kutta Nystrom Method}, +author={Rabiei, Faranak and Ismail, Fudziah and Norazak, S and Emadi, Saeid}, +publisher={Citeseer} } """ struct IRKN3 <: OrdinaryDiffEqPartitionedAlgorithm end @@ -5241,13 +3904,14 @@ struct IRKN3 <: OrdinaryDiffEqPartitionedAlgorithm end A 4th order explicit Runge-Kutta-Nyström method which can be applied directly on second order ODEs. Can only be used with fixed time steps. -In case the ODE Problem is not dependent on the first derivative consider using +In case the ODE Problem is not dependent on the first derivative consider using [`Nystrom4VelocityIndependent`](@ref) to increase performance. ## References + E. Hairer, S.P. Norsett, G. Wanner, (1993) Solving Ordinary Differential Equations I. - Nonstiff Problems. 2nd Edition. Springer Series in Computational Mathematics, - Springer-Verlag. +Nonstiff Problems. 2nd Edition. Springer Series in Computational Mathematics, +Springer-Verlag. """ struct Nystrom4 <: OrdinaryDiffEqPartitionedAlgorithm end @@ -5258,6 +3922,7 @@ A 4th order explicit Runge-Kutta-Nyström method which can be applied directly t In particular, this method allows the acceleration equation to depend on the velocity. ## References + ``` @article{fine1987low, title={Low order practical {R}unge-{K}utta-{N}ystr{\"o}m methods}, @@ -5280,6 +3945,7 @@ A 5th order explicit Runge-Kutta-Nyström method which can be applied directly t In particular, this method allows the acceleration equation to depend on the velocity. ## References + ``` @article{fine1987low, title={Low order practical {R}unge-{K}utta-{N}ystr{\"o}m methods}, @@ -5305,9 +3971,10 @@ More efficient then [`Nystrom4`](@ref) on velocity independent problems, since l Fixed time steps only. ## References + E. Hairer, S.P. Norsett, G. Wanner, (1993) Solving Ordinary Differential Equations I. - Nonstiff Problems. 2nd Edition. Springer Series in Computational Mathematics, - Springer-Verlag. +Nonstiff Problems. 2nd Edition. Springer Series in Computational Mathematics, +Springer-Verlag. """ struct Nystrom4VelocityIndependent <: OrdinaryDiffEqPartitionedAlgorithm end @@ -5321,10 +3988,11 @@ Second order ODE should not be dependent on the first derivative. Recommended for smooth problems with expensive functions to evaluate. ## References + @article{rabiei2012numerical, - title={Numerical Solution of Second-Order Ordinary Differential Equations by Improved Runge-Kutta Nystrom Method}, - author={Rabiei, Faranak and Ismail, Fudziah and Norazak, S and Emadi, Saeid}, - publisher={Citeseer} +title={Numerical Solution of Second-Order Ordinary Differential Equations by Improved Runge-Kutta Nystrom Method}, +author={Rabiei, Faranak and Ismail, Fudziah and Norazak, S and Emadi, Saeid}, +publisher={Citeseer} } """ struct IRKN4 <: OrdinaryDiffEqPartitionedAlgorithm end @@ -5336,9 +4004,10 @@ A 5th order explicit Runkge-Kutta-Nyström method. Used directly on second order Fixed time steps only. ## References + E. Hairer, S.P. Norsett, G. Wanner, (1993) Solving Ordinary Differential Equations I. - Nonstiff Problems. 2nd Edition. Springer Series in Computational Mathematics, - Springer-Verlag. +Nonstiff Problems. 2nd Edition. Springer Series in Computational Mathematics, +Springer-Verlag. """ struct Nystrom5VelocityIndependent <: OrdinaryDiffEqPartitionedAlgorithm end @@ -5348,13 +4017,14 @@ struct Nystrom5VelocityIndependent <: OrdinaryDiffEqPartitionedAlgorithm end 4th order explicit Runge-Kutta-Nyström methods. The second order ODE should not depend on the first derivative. ## References + @article{Dormand1987FamiliesOR, - title={Families of Runge-Kutta-Nystrom Formulae}, - author={J. R. Dormand and Moawwad E. A. El-Mikkawy and P. J. Prince}, - journal={Ima Journal of Numerical Analysis}, - year={1987}, - volume={7}, - pages={235-250} +title={Families of Runge-Kutta-Nystrom Formulae}, +author={J. R. Dormand and Moawwad E. A. El-Mikkawy and P. J. Prince}, +journal={Ima Journal of Numerical Analysis}, +year={1987}, +volume={7}, +pages={235-250} } """ struct DPRKN4 <: OrdinaryDiffEqAdaptivePartitionedAlgorithm end @@ -5365,14 +4035,15 @@ struct DPRKN4 <: OrdinaryDiffEqAdaptivePartitionedAlgorithm end 5th order explicit Runge-Kutta-Nyström mehod. The second order ODE should not depend on the first derivative. ## References + @article{Bettis1973ARN, - title={A Runge-Kutta Nystrom algorithm}, - author={Dale G. Bettis}, - journal={Celestial mechanics}, - year={1973}, - volume={8}, - pages={229-233}, - publisher={Springer} +title={A Runge-Kutta Nystrom algorithm}, +author={Dale G. Bettis}, +journal={Celestial mechanics}, +year={1973}, +volume={8}, +pages={229-233}, +publisher={Springer} } """ struct DPRKN5 <: OrdinaryDiffEqAdaptivePartitionedAlgorithm end @@ -5383,15 +4054,16 @@ struct DPRKN5 <: OrdinaryDiffEqAdaptivePartitionedAlgorithm end 6th order explicit Runge-Kutta-Nyström method. The second order ODE should not depend on the first derivative. Free 6th order interpolant. ## References + @article{dormand1987runge, - title={Runge-kutta-nystrom triples}, - author={Dormand, JR and Prince, PJ}, - journal={Computers \\& Mathematics with Applications}, - volume={13}, - number={12}, - pages={937--949}, - year={1987}, - publisher={Elsevier} +title={Runge-kutta-nystrom triples}, +author={Dormand, JR and Prince, PJ}, +journal={Computers \\& Mathematics with Applications}, +volume={13}, +number={12}, +pages={937--949}, +year={1987}, +publisher={Elsevier} } """ struct DPRKN6 <: OrdinaryDiffEqAdaptivePartitionedAlgorithm end @@ -5405,13 +4077,14 @@ Compared to [`DPRKN6`](@ref), this method has smaller truncation error coefficie when only the main solution points are considered. ## References + @article{Dormand1987FamiliesOR, - title={Families of Runge-Kutta-Nystrom Formulae}, - author={J. R. Dormand and Moawwad E. A. El-Mikkawy and P. J. Prince}, - journal={Ima Journal of Numerical Analysis}, - year={1987}, - volume={7}, - pages={235-250} +title={Families of Runge-Kutta-Nystrom Formulae}, +author={J. R. Dormand and Moawwad E. A. El-Mikkawy and P. J. Prince}, +journal={Ima Journal of Numerical Analysis}, +year={1987}, +volume={7}, +pages={235-250} } """ struct DPRKN6FM <: OrdinaryDiffEqAdaptivePartitionedAlgorithm end @@ -5425,15 +4098,16 @@ Not as efficient as [`DPRKN12`](@ref) when high accuracy is needed, however this [`DPRKN6`](@ref) at lax tolerances and, depending on the problem, might be a good option between performance and accuracy. ## References + @article{dormand1987high, - title={High-order embedded Runge-Kutta-Nystrom formulae}, - author={Dormand, JR and El-Mikkawy, MEA and Prince, PJ}, - journal={IMA Journal of Numerical Analysis}, - volume={7}, - number={4}, - pages={423--430}, - year={1987}, - publisher={Oxford University Press} +title={High-order embedded Runge-Kutta-Nystrom formulae}, +author={Dormand, JR and El-Mikkawy, MEA and Prince, PJ}, +journal={IMA Journal of Numerical Analysis}, +volume={7}, +number={4}, +pages={423--430}, +year={1987}, +publisher={Oxford University Press} } """ struct DPRKN8 <: OrdinaryDiffEqAdaptivePartitionedAlgorithm end @@ -5446,15 +4120,16 @@ struct DPRKN8 <: OrdinaryDiffEqAdaptivePartitionedAlgorithm end Most efficient when high accuracy is needed. ## References + @article{dormand1987high, - title={High-order embedded Runge-Kutta-Nystrom formulae}, - author={Dormand, JR and El-Mikkawy, MEA and Prince, PJ}, - journal={IMA Journal of Numerical Analysis}, - volume={7}, - number={4}, - pages={423--430}, - year={1987}, - publisher={Oxford University Press} +title={High-order embedded Runge-Kutta-Nystrom formulae}, +author={Dormand, JR and El-Mikkawy, MEA and Prince, PJ}, +journal={IMA Journal of Numerical Analysis}, +volume={7}, +number={4}, +pages={423--430}, +year={1987}, +publisher={Oxford University Press} } """ struct DPRKN12 <: OrdinaryDiffEqAdaptivePartitionedAlgorithm end @@ -5469,14 +4144,15 @@ The second order ODE should not depend on the first derivative. Uses adaptive step size control. This method is extra efficient on periodic problems. ## References + @article{demba2017embedded, - title={An Embedded 4 (3) Pair of Explicit Trigonometrically-Fitted Runge-Kutta-Nystr{\"o}m Method for Solving Periodic Initial Value Problems}, - author={Demba, MA and Senu, N and Ismail, F}, - journal={Applied Mathematical Sciences}, - volume={11}, - number={17}, - pages={819--838}, - year={2017} +title={An Embedded 4 (3) Pair of Explicit Trigonometrically-Fitted Runge-Kutta-Nystr{\"o}m Method for Solving Periodic Initial Value Problems}, +author={Demba, MA and Senu, N and Ismail, F}, +journal={Applied Mathematical Sciences}, +volume={11}, +number={17}, +pages={819--838}, +year={2017} } """ struct ERKN4 <: OrdinaryDiffEqAdaptivePartitionedAlgorithm end @@ -5491,15 +4167,16 @@ The second order ODE should not depend on the first derivative. Uses adaptive step size control. This method is extra efficient on periodic problems. ## References + @article{demba20165, - title={A 5 (4) Embedded Pair of Explicit Trigonometrically-Fitted Runge--Kutta--Nystr{\"o}m Methods for the Numerical Solution of Oscillatory Initial Value Problems}, - author={Demba, Musa A and Senu, Norazak and Ismail, Fudziah}, - journal={Mathematical and Computational Applications}, - volume={21}, - number={4}, - pages={46}, - year={2016}, - publisher={Multidisciplinary Digital Publishing Institute} +title={A 5 (4) Embedded Pair of Explicit Trigonometrically-Fitted Runge--Kutta--Nystr{\"o}m Methods for the Numerical Solution of Oscillatory Initial Value Problems}, +author={Demba, Musa A and Senu, Norazak and Ismail, Fudziah}, +journal={Mathematical and Computational Applications}, +volume={21}, +number={4}, +pages={46}, +year={2016}, +publisher={Multidisciplinary Digital Publishing Institute} } """ struct ERKN5 <: OrdinaryDiffEqAdaptivePartitionedAlgorithm end @@ -5514,12 +4191,13 @@ The second order ODE should not depend on the first derivative. Uses adaptive step size control. This method is extra efficient on periodic Problems. ## References + @article{SimosOnHO, - title={On high order Runge-Kutta-Nystr{\"o}m pairs}, - author={Theodore E. Simos and Ch. Tsitouras}, - journal={J. Comput. Appl. Math.}, - volume={400}, - pages={113753} +title={On high order Runge-Kutta-Nystr{\"o}m pairs}, +author={Theodore E. Simos and Ch. Tsitouras}, +journal={J. Comput. Appl. Math.}, +volume={400}, +pages={113753} } """ struct ERKN7 <: OrdinaryDiffEqAdaptivePartitionedAlgorithm end @@ -5534,7 +4212,7 @@ Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1 AB3: Adams-Bashforth Explicit Method - The 3-step third order multistep method. Ralston's Second Order Method is used to calculate starting values. +The 3-step third order multistep method. Ralston's Second Order Method is used to calculate starting values. """ struct AB3 <: OrdinaryDiffEqAlgorithm end @@ -5544,7 +4222,7 @@ Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1 AB4: Adams-Bashforth Explicit Method - The 4-step fourth order multistep method. Runge-Kutta method of order 4 is used to calculate starting values. +The 4-step fourth order multistep method. Runge-Kutta method of order 4 is used to calculate starting values. """ struct AB4 <: OrdinaryDiffEqAlgorithm end @@ -5554,7 +4232,7 @@ Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1 AB5: Adams-Bashforth Explicit Method - The 3-step third order multistep method. Ralston's Second Order Method is used to calculate starting values. +The 3-step third order multistep method. Ralston's Second Order Method is used to calculate starting values. """ struct AB5 <: OrdinaryDiffEqAlgorithm end @@ -5564,8 +4242,8 @@ Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1 ABM32: Adams-Bashforth Explicit Method - It is third order method. In ABM32, AB3 works as predictor and Adams Moulton 2-steps method works as Corrector. - Ralston's Second Order Method is used to calculate starting values. +It is third order method. In ABM32, AB3 works as predictor and Adams Moulton 2-steps method works as Corrector. +Ralston's Second Order Method is used to calculate starting values. """ struct ABM32 <: OrdinaryDiffEqAlgorithm end @@ -5575,8 +4253,8 @@ Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1 ABM43: Adams-Bashforth Explicit Method - It is fourth order method. In ABM43, AB4 works as predictor and Adams Moulton 3-steps method works as Corrector. - Runge-Kutta method of order 4 is used to calculate starting values. +It is fourth order method. In ABM43, AB4 works as predictor and Adams Moulton 3-steps method works as Corrector. +Runge-Kutta method of order 4 is used to calculate starting values. """ struct ABM43 <: OrdinaryDiffEqAlgorithm end @@ -5586,8 +4264,8 @@ Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1 ABM54: Adams-Bashforth Explicit Method - It is fifth order method. In ABM54, AB5 works as predictor and Adams Moulton 4-steps method works as Corrector. - Runge-Kutta method of order 4 is used to calculate starting values. +It is fifth order method. In ABM54, AB5 works as predictor and Adams Moulton 4-steps method works as Corrector. +Runge-Kutta method of order 4 is used to calculate starting values. """ struct ABM54 <: OrdinaryDiffEqAlgorithm end @@ -5599,7 +4277,7 @@ Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1 VCAB3: Adaptive step size Adams explicit Method - The 3rd order Adams method. Bogacki-Shampine 3/2 method is used to calculate starting values. +The 3rd order Adams method. Bogacki-Shampine 3/2 method is used to calculate starting values. """ struct VCAB3 <: OrdinaryDiffEqAdaptiveAlgorithm end @@ -5609,7 +4287,7 @@ Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1 VCAB4: Adaptive step size Adams explicit Method - The 4th order Adams method. Runge-Kutta 4 is used to calculate starting values. +The 4th order Adams method. Runge-Kutta 4 is used to calculate starting values. """ struct VCAB4 <: OrdinaryDiffEqAdaptiveAlgorithm end @@ -5619,7 +4297,7 @@ Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1 VCAB5: Adaptive step size Adams explicit Method - The 5th order Adams method. Runge-Kutta 4 is used to calculate starting values. +The 5th order Adams method. Runge-Kutta 4 is used to calculate starting values. """ struct VCAB5 <: OrdinaryDiffEqAdaptiveAlgorithm end @@ -5629,7 +4307,7 @@ Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1 VCABM3: Adaptive step size Adams explicit Method - The 3rd order Adams-Moulton method. Bogacki-Shampine 3/2 method is used to calculate starting values. +The 3rd order Adams-Moulton method. Bogacki-Shampine 3/2 method is used to calculate starting values. """ struct VCABM3 <: OrdinaryDiffEqAdaptiveAlgorithm end @@ -5639,7 +4317,7 @@ Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1 VCABM4: Adaptive step size Adams explicit Method - The 4th order Adams-Moulton method. Runge-Kutta 4 is used to calculate starting values. +The 4th order Adams-Moulton method. Runge-Kutta 4 is used to calculate starting values. """ struct VCABM4 <: OrdinaryDiffEqAdaptiveAlgorithm end @@ -5649,7 +4327,7 @@ Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1 VCABM5: Adaptive step size Adams explicit Method - The 5th order Adams-Moulton method. Runge-Kutta 4 is used to calculate starting values. +The 5th order Adams-Moulton method. Runge-Kutta 4 is used to calculate starting values. """ struct VCABM5 <: OrdinaryDiffEqAdaptiveAlgorithm end @@ -5661,8 +4339,8 @@ Problems. Computational Mathematics (2nd revised ed.), Springer (1996) doi: https://doi.org/10.1007/978-3-540-78862-1 VCABM: Adaptive step size Adams explicit Method - An adaptive order adaptive time Adams Moulton method. - It uses an order adaptivity algorithm is derived from Shampine's DDEABM. +An adaptive order adaptive time Adams Moulton method. +It uses an order adaptivity algorithm is derived from Shampine's DDEABM. """ struct VCABM <: OrdinaryDiffEqAdamsVarOrderVarStepAlgorithm end @@ -5707,8 +4385,8 @@ end """ QNDF1: Multistep Method - An adaptive order 1 quasi-constant timestep L-stable numerical differentiation function (NDF) method. - Optional parameter kappa defaults to Shampine's accuracy-optimal -0.1850. +An adaptive order 1 quasi-constant timestep L-stable numerical differentiation function (NDF) method. +Optional parameter kappa defaults to Shampine's accuracy-optimal -0.1850. See also `QNDF`. """ @@ -5746,7 +4424,7 @@ QBDF1(; kwargs...) = QNDF1(; kappa = 0, kwargs...) """ QNDF2: Multistep Method - An adaptive order 2 quasi-constant timestep L-stable numerical differentiation function (NDF) method. +An adaptive order 2 quasi-constant timestep L-stable numerical differentiation function (NDF) method. See also `QNDF`. """ @@ -5784,18 +4462,18 @@ QBDF2(; kwargs...) = QNDF2(; kappa = 0, kwargs...) """ QNDF: Multistep Method - An adaptive order quasi-constant timestep NDF method. - Utilizes Shampine's accuracy-optimal kappa values as defaults (has a keyword argument for a tuple of kappa coefficients). +An adaptive order quasi-constant timestep NDF method. +Utilizes Shampine's accuracy-optimal kappa values as defaults (has a keyword argument for a tuple of kappa coefficients). @article{shampine1997matlab, - title={The matlab ode suite}, - author={Shampine, Lawrence F and Reichelt, Mark W}, - journal={SIAM journal on scientific computing}, - volume={18}, - number={1}, - pages={1--22}, - year={1997}, - publisher={SIAM} +title={The matlab ode suite}, +author={Shampine, Lawrence F and Reichelt, Mark W}, +journal={SIAM journal on scientific computing}, +volume={18}, +number={1}, +pages={1--22}, +year={1997}, +publisher={SIAM} } """ struct QNDF{MO, CS, AD, F, F2, P, FDT, ST, CJ, K, T, κType} <: @@ -5841,10 +4519,10 @@ An adaptive order quasi-constant timestep NDF method. Utilizes Shampine's accuracy-optimal kappa values as defaults (has a keyword argument for a tuple of kappa coefficients). @article{shampine2002solving, - title={Solving 0= F (t, y (t), y′(t)) in Matlab}, - author={Shampine, Lawrence F}, - year={2002}, - publisher={Walter de Gruyter GmbH \\& Co. KG} +title={Solving 0= F (t, y (t), y′(t)) in Matlab}, +author={Shampine, Lawrence F}, +year={2002}, +publisher={Walter de Gruyter GmbH \\& Co. KG} } """ struct FBDF{MO, CS, AD, F, F2, P, FDT, ST, CJ, K, T} <: @@ -5932,17 +4610,20 @@ end The one-step version of the IMEX multistep methods of -- Uri M. Ascher, Steven J. Ruuth, Brian T. R. Wetton. - Implicit-Explicit Methods for Time-Dependent Partial Differential Equations. - Society for Industrial and Applied Mathematics. - Journal on Numerical Analysis, 32(3), pp 797-823, 1995. - doi: [https://doi.org/10.1137/0732037](https://doi.org/10.1137/0732037) + - Uri M. Ascher, Steven J. Ruuth, Brian T. R. Wetton. + Implicit-Explicit Methods for Time-Dependent Partial Differential Equations. + Society for Industrial and Applied Mathematics. + Journal on Numerical Analysis, 32(3), pp 797-823, 1995. + doi: [https://doi.org/10.1137/0732037](https://doi.org/10.1137/0732037) When applied to a `SplitODEProblem` of the form + ``` u'(t) = f1(u) + f2(u) ``` + The default `IMEXEuler()` method uses an update of the form + ``` unew = uold + dt * (f1(unew) + f2(uold)) ``` @@ -5956,19 +4637,22 @@ IMEXEuler(; kwargs...) = SBDF(1; kwargs...) The one-step version of the IMEX multistep methods of -- Uri M. Ascher, Steven J. Ruuth, Brian T. R. Wetton. - Implicit-Explicit Methods for Time-Dependent Partial Differential Equations. - Society for Industrial and Applied Mathematics. - Journal on Numerical Analysis, 32(3), pp 797-823, 1995. - doi: [https://doi.org/10.1137/0732037](https://doi.org/10.1137/0732037) + - Uri M. Ascher, Steven J. Ruuth, Brian T. R. Wetton. + Implicit-Explicit Methods for Time-Dependent Partial Differential Equations. + Society for Industrial and Applied Mathematics. + Journal on Numerical Analysis, 32(3), pp 797-823, 1995. + doi: [https://doi.org/10.1137/0732037](https://doi.org/10.1137/0732037) When applied to a `SplitODEProblem` of the form + ``` u'(t) = f1(u) + f2(u) ``` + A classical additive Runge-Kutta method in the sense of [Araújo, Murua, Sanz-Serna (1997)](https://doi.org/10.1137/S0036142995292128) consisting of the implicit and the explicit Euler method given by + ``` y1 = uold + dt * f1(y1) unew = uold + dt * (f1(unew) + f2(y1)) @@ -5983,11 +4667,11 @@ IMEXEulerARK(; kwargs...) = SBDF(1; ark = true, kwargs...) The two-step version of the IMEX multistep methods of -- Uri M. Ascher, Steven J. Ruuth, Brian T. R. Wetton. - Implicit-Explicit Methods for Time-Dependent Partial Differential Equations. - Society for Industrial and Applied Mathematics. - Journal on Numerical Analysis, 32(3), pp 797-823, 1995. - doi: [https://doi.org/10.1137/0732037](https://doi.org/10.1137/0732037) + - Uri M. Ascher, Steven J. Ruuth, Brian T. R. Wetton. + Implicit-Explicit Methods for Time-Dependent Partial Differential Equations. + Society for Industrial and Applied Mathematics. + Journal on Numerical Analysis, 32(3), pp 797-823, 1995. + doi: [https://doi.org/10.1137/0732037](https://doi.org/10.1137/0732037) See also `SBDF`. """ @@ -5998,11 +4682,11 @@ SBDF2(; kwargs...) = SBDF(2; kwargs...) The three-step version of the IMEX multistep methods of -- Uri M. Ascher, Steven J. Ruuth, Brian T. R. Wetton. - Implicit-Explicit Methods for Time-Dependent Partial Differential Equations. - Society for Industrial and Applied Mathematics. - Journal on Numerical Analysis, 32(3), pp 797-823, 1995. - doi: [https://doi.org/10.1137/0732037](https://doi.org/10.1137/0732037) + - Uri M. Ascher, Steven J. Ruuth, Brian T. R. Wetton. + Implicit-Explicit Methods for Time-Dependent Partial Differential Equations. + Society for Industrial and Applied Mathematics. + Journal on Numerical Analysis, 32(3), pp 797-823, 1995. + doi: [https://doi.org/10.1137/0732037](https://doi.org/10.1137/0732037) See also `SBDF`. """ @@ -6013,11 +4697,11 @@ SBDF3(; kwargs...) = SBDF(3; kwargs...) The four-step version of the IMEX multistep methods of -- Uri M. Ascher, Steven J. Ruuth, Brian T. R. Wetton. - Implicit-Explicit Methods for Time-Dependent Partial Differential Equations. - Society for Industrial and Applied Mathematics. - Journal on Numerical Analysis, 32(3), pp 797-823, 1995. - doi: [https://doi.org/10.1137/0732037](https://doi.org/10.1137/0732037) + - Uri M. Ascher, Steven J. Ruuth, Brian T. R. Wetton. + Implicit-Explicit Methods for Time-Dependent Partial Differential Equations. + Society for Industrial and Applied Mathematics. + Journal on Numerical Analysis, 32(3), pp 797-823, 1995. + doi: [https://doi.org/10.1137/0732037](https://doi.org/10.1137/0732037) See also `SBDF`. """ @@ -6026,7 +4710,7 @@ SBDF4(; kwargs...) = SBDF(4; kwargs...) # Adams/BDF methods in Nordsieck forms """ AN5: Adaptive step size Adams explicit Method - An adaptive 5th order fixed-leading coefficient Adams method in Nordsieck form. +An adaptive 5th order fixed-leading coefficient Adams method in Nordsieck form. """ struct AN5 <: OrdinaryDiffEqAdaptiveAlgorithm end struct JVODE{bType, aType} <: OrdinaryDiffEqAdamsVarOrderVarStepAlgorithm @@ -6051,17 +4735,16 @@ Assyr Abdulle, Alexei A. Medovikov. Second Order Chebyshev Methods based on Orth Numerische Mathematik, 90 (1), pp 1-18, 2001. doi: https://dx.doi.org/10.1007/s002110100292 ROCK2: Stabilized Explicit Method. - Second order stabilized Runge-Kutta method. - Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues. +Second order stabilized Runge-Kutta method. +Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues. -This method takes optional keyword arguments `min_stages`, `max_stages`, and `eigen_est`. -The function `eigen_est` should be of the form - - `eigen_est = (integrator) -> integrator.eigen_est = upper_bound`, +This method takes optional keyword arguments `min_stages`, `max_stages`, and `eigen_est`. +The function `eigen_est` should be of the form -where `upper_bound` is an estimated upper bound on the spectral radius of the Jacobian matrix. If `eigen_est` -is not provided, `upper_bound` will be estimated using the power iteration. +`eigen_est = (integrator) -> integrator.eigen_est = upper_bound`, +where `upper_bound` is an estimated upper bound on the spectral radius of the Jacobian matrix. If `eigen_est` +is not provided, `upper_bound` will be estimated using the power iteration. """ struct ROCK2{E} <: OrdinaryDiffEqAdaptiveAlgorithm min_stages::Int @@ -6074,23 +4757,22 @@ end """ ROCK4(; min_stages = 0, max_stages = 152, eigen_est = nothing) - + Assyr Abdulle. Fourth Order Chebyshev Methods With Recurrence Relation. 2002 Society for Industrial and Applied Mathematics Journal on Scientific Computing, 23(6), pp 2041-2054, 2001. doi: https://doi.org/10.1137/S1064827500379549 ROCK4: Stabilized Explicit Method. - Fourth order stabilized Runge-Kutta method. - Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues. +Fourth order stabilized Runge-Kutta method. +Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues. -This method takes optional keyword arguments `min_stages`, `max_stages`, and `eigen_est`. -The function `eigen_est` should be of the form - - `eigen_est = (integrator) -> integrator.eigen_est = upper_bound`, +This method takes optional keyword arguments `min_stages`, `max_stages`, and `eigen_est`. +The function `eigen_est` should be of the form -where `upper_bound` is an estimated upper bound on the spectral radius of the Jacobian matrix. If `eigen_est` -is not provided, `upper_bound` will be estimated using the power iteration. +`eigen_est = (integrator) -> integrator.eigen_est = upper_bound`, +where `upper_bound` is an estimated upper bound on the spectral radius of the Jacobian matrix. If `eigen_est` +is not provided, `upper_bound` will be estimated using the power iteration. """ struct ROCK4{E} <: OrdinaryDiffEqAdaptiveAlgorithm min_stages::Int @@ -6116,39 +4798,39 @@ end RKC(; eigen_est = nothing) B. P. Sommeijer, L. F. Shampine, J. G. Verwer. RKC: An Explicit Solver for Parabolic PDEs, - Journal of Computational and Applied Mathematics, 88(2), pp 315-326, 1998. doi: - https://doi.org/10.1016/S0377-0427(97)00219-7 +Journal of Computational and Applied Mathematics, 88(2), pp 315-326, 1998. doi: +https://doi.org/10.1016/S0377-0427(97)00219-7 RKC: Stabilized Explicit Method. - Second order stabilized Runge-Kutta method. - Exhibits high stability for real eigenvalues. - -This method takes the keyword argument `eigen_est` of the form +Second order stabilized Runge-Kutta method. +Exhibits high stability for real eigenvalues. + +This method takes the keyword argument `eigen_est` of the form - `eigen_est = (integrator) -> integrator.eigen_est = upper_bound`, +`eigen_est = (integrator) -> integrator.eigen_est = upper_bound`, -where `upper_bound` is an estimated upper bound on the spectral radius of the Jacobian matrix. If `eigen_est` -is not provided, `upper_bound` will be estimated using the power iteration. +where `upper_bound` is an estimated upper bound on the spectral radius of the Jacobian matrix. If `eigen_est` +is not provided, `upper_bound` will be estimated using the power iteration. """ function RKC end """ ESERK4(; eigen_est = nothing) -J. Martín-Vaquero, B. Kleefeld. Extrapolated stabilized explicit Runge-Kutta methods, - Journal of Computational Physics, 326, pp 141-155, 2016. doi: - https://doi.org/10.1016/j.jcp.2016.08.042. +J. Martín-Vaquero, B. Kleefeld. Extrapolated stabilized explicit Runge-Kutta methods, +Journal of Computational Physics, 326, pp 141-155, 2016. doi: +https://doi.org/10.1016/j.jcp.2016.08.042. ESERK4: Stabilized Explicit Method. - Fourth order extrapolated stabilized Runge-Kutta method. - Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues. +Fourth order extrapolated stabilized Runge-Kutta method. +Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues. -This method takes the keyword argument `eigen_est` of the form - - `eigen_est = (integrator) -> integrator.eigen_est = upper_bound`, +This method takes the keyword argument `eigen_est` of the form -where `upper_bound` is an estimated upper bound on the spectral radius of the Jacobian matrix. -If `eigen_est` is not provided, `upper_bound` will be estimated using the power iteration. +`eigen_est = (integrator) -> integrator.eigen_est = upper_bound`, + +where `upper_bound` is an estimated upper bound on the spectral radius of the Jacobian matrix. +If `eigen_est` is not provided, `upper_bound` will be estimated using the power iteration. """ function ESERK4 end @@ -6156,19 +4838,19 @@ function ESERK4 end ESERK5(; eigen_est = nothing) J. Martín-Vaquero, A. Kleefeld. ESERK5: A fifth-order extrapolated stabilized explicit Runge-Kutta method, - Journal of Computational and Applied Mathematics, 356, pp 22-36, 2019. doi: - https://doi.org/10.1016/j.cam.2019.01.040. +Journal of Computational and Applied Mathematics, 356, pp 22-36, 2019. doi: +https://doi.org/10.1016/j.cam.2019.01.040. ESERK5: Stabilized Explicit Method. - Fifth order extrapolated stabilized Runge-Kutta method. - Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues. +Fifth order extrapolated stabilized Runge-Kutta method. +Exhibits high stability for real eigenvalues and is smoothened to allow for moderate sized complex eigenvalues. + +This method takes the keyword argument `eigen_est` of the form -This method takes the keyword argument `eigen_est` of the form - - `eigen_est = (integrator) -> integrator.eigen_est = upper_bound`, +`eigen_est = (integrator) -> integrator.eigen_est = upper_bound`, -where `upper_bound` is an estimated upper bound on the spectral radius of the Jacobian matrix. -If `eigen_est` is not provided, `upper_bound` will be estimated using the power iteration. +where `upper_bound` is an estimated upper bound on the spectral radius of the Jacobian matrix. +If `eigen_est` is not provided, `upper_bound` will be estimated using the power iteration. """ function ESERK5 end @@ -6248,18 +4930,18 @@ struct CayleyEuler <: OrdinaryDiffEqAlgorithm end """ @article{hairer1999stiff, - title={Stiff differential equations solved by Radau methods}, - author={Hairer, Ernst and Wanner, Gerhard}, - journal={Journal of Computational and Applied Mathematics}, - volume={111}, - number={1-2}, - pages={93--111}, - year={1999}, - publisher={Elsevier} +title={Stiff differential equations solved by Radau methods}, +author={Hairer, Ernst and Wanner, Gerhard}, +journal={Journal of Computational and Applied Mathematics}, +volume={111}, +number={1-2}, +pages={93--111}, +year={1999}, +publisher={Elsevier} } RadauIIA3: Fully-Implicit Runge-Kutta Method - An A-B-L stable fully implicit Runge-Kutta method with internal tableau complex basis transform for efficiency. +An A-B-L stable fully implicit Runge-Kutta method with internal tableau complex basis transform for efficiency. """ struct RadauIIA3{CS, AD, F, P, FDT, ST, CJ, Tol, C1, C2} <: OrdinaryDiffEqNewtonAdaptiveAlgorithm{CS, AD, FDT, ST, CJ} @@ -6296,18 +4978,18 @@ TruncatedStacktraces.@truncate_stacktrace RadauIIA3 """ @article{hairer1999stiff, - title={Stiff differential equations solved by Radau methods}, - author={Hairer, Ernst and Wanner, Gerhard}, - journal={Journal of Computational and Applied Mathematics}, - volume={111}, - number={1-2}, - pages={93--111}, - year={1999}, - publisher={Elsevier} +title={Stiff differential equations solved by Radau methods}, +author={Hairer, Ernst and Wanner, Gerhard}, +journal={Journal of Computational and Applied Mathematics}, +volume={111}, +number={1-2}, +pages={93--111}, +year={1999}, +publisher={Elsevier} } RadauIIA5: Fully-Implicit Runge-Kutta Method - An A-B-L stable fully implicit Runge-Kutta method with internal tableau complex basis transform for efficiency. +An A-B-L stable fully implicit Runge-Kutta method with internal tableau complex basis transform for efficiency. """ struct RadauIIA5{CS, AD, F, P, FDT, ST, CJ, Tol, C1, C2} <: OrdinaryDiffEqNewtonAdaptiveAlgorithm{CS, AD, FDT, ST, CJ} @@ -6348,8 +5030,8 @@ TruncatedStacktraces.@truncate_stacktrace RadauIIA5 # SDIRK Methods """ ImplicitEuler: SDIRK Method - A 1st order implicit solver. A-B-L-stable. Adaptive timestepping through a divided differences estimate via memory. - Strong-stability preserving (SSP). +A 1st order implicit solver. A-B-L-stable. Adaptive timestepping through a divided differences estimate via memory. +Strong-stability preserving (SSP). """ struct ImplicitEuler{CS, AD, F, F2, P, FDT, ST, CJ} <: OrdinaryDiffEqNewtonAdaptiveAlgorithm{CS, AD, FDT, ST, CJ} @@ -6373,8 +5055,8 @@ function ImplicitEuler(; chunk_size = Val{0}(), autodiff = Val{true}(), end """ ImplicitMidpoint: SDIRK Method - A second order A-stable symplectic and symmetric implicit solver. - Good for highly stiff equations which need symplectic integration. +A second order A-stable symplectic and symmetric implicit solver. +Good for highly stiff equations which need symplectic integration. """ struct ImplicitMidpoint{CS, AD, F, F2, P, FDT, ST, CJ} <: OrdinaryDiffEqNewtonAlgorithm{CS, AD, FDT, ST, CJ} @@ -6399,12 +5081,12 @@ end """ Andre Vladimirescu. 1994. The Spice Book. John Wiley & Sons, Inc., New York, - NY, USA. +NY, USA. Trapezoid: SDIRK Method A second order A-stable symmetric ESDIRK method. "Almost symplectic" without numerical dampening. - Also known as Crank-Nicolson when applied to PDEs. Adaptive timestepping via divided +Also known as Crank-Nicolson when applied to PDEs. Adaptive timestepping via divided differences approximation to the second derivative terms in the local truncation error estimate (the SPICE approximation strategy). """ @@ -6434,19 +5116,19 @@ end """ @article{hosea1996analysis, - title={Analysis and implementation of TR-BDF2}, - author={Hosea, ME and Shampine, LF}, - journal={Applied Numerical Mathematics}, - volume={20}, - number={1-2}, - pages={21--37}, - year={1996}, - publisher={Elsevier} +title={Analysis and implementation of TR-BDF2}, +author={Hosea, ME and Shampine, LF}, +journal={Applied Numerical Mathematics}, +volume={20}, +number={1-2}, +pages={21--37}, +year={1996}, +publisher={Elsevier} } TRBDF2: SDIRK Method - A second order A-B-L-S-stable one-step ESDIRK method. - Includes stiffness-robust error estimates for accurate adaptive timestepping, smoothed derivatives for highly stiff and oscillatory problems. +A second order A-B-L-S-stable one-step ESDIRK method. +Includes stiffness-robust error estimates for accurate adaptive timestepping, smoothed derivatives for highly stiff and oscillatory problems. """ struct TRBDF2{CS, AD, F, F2, P, FDT, ST, CJ} <: OrdinaryDiffEqNewtonAdaptiveAlgorithm{CS, AD, FDT, ST, CJ} @@ -6473,18 +5155,18 @@ TruncatedStacktraces.@truncate_stacktrace TRBDF2 """ @article{hindmarsh2005sundials, - title={{SUNDIALS}: Suite of nonlinear and differential/algebraic equation solvers}, - author={Hindmarsh, Alan C and Brown, Peter N and Grant, Keith E and Lee, Steven L and Serban, Radu and Shumaker, Dan E and Woodward, Carol S}, - journal={ACM Transactions on Mathematical Software (TOMS)}, - volume={31}, - number={3}, - pages={363--396}, - year={2005}, - publisher={ACM} +title={{SUNDIALS}: Suite of nonlinear and differential/algebraic equation solvers}, +author={Hindmarsh, Alan C and Brown, Peter N and Grant, Keith E and Lee, Steven L and Serban, Radu and Shumaker, Dan E and Woodward, Carol S}, +journal={ACM Transactions on Mathematical Software (TOMS)}, +volume={31}, +number={3}, +pages={363--396}, +year={2005}, +publisher={ACM} } SDIRK2: SDIRK Method - An A-B-L stable 2nd order SDIRK method +An A-B-L stable 2nd order SDIRK method """ struct SDIRK2{CS, AD, F, F2, P, FDT, ST, CJ} <: OrdinaryDiffEqNewtonAdaptiveAlgorithm{CS, AD, FDT, ST, CJ} @@ -6554,18 +5236,18 @@ end """ @article{kvaerno2004singly, - title={Singly diagonally implicit Runge--Kutta methods with an explicit first stage}, - author={Kv{\\ae}rn{\\o}, Anne}, - journal={BIT Numerical Mathematics}, - volume={44}, - number={3}, - pages={489--502}, - year={2004}, - publisher={Springer} +title={Singly diagonally implicit Runge--Kutta methods with an explicit first stage}, +author={Kv{\\ae}rn{\\o}, Anne}, +journal={BIT Numerical Mathematics}, +volume={44}, +number={3}, +pages={489--502}, +year={2004}, +publisher={Springer} } Kvaerno3: SDIRK Method - An A-L stable stiffly-accurate 3rd order ESDIRK method +An A-L stable stiffly-accurate 3rd order ESDIRK method """ struct Kvaerno3{CS, AD, F, F2, P, FDT, ST, CJ} <: OrdinaryDiffEqNewtonAdaptiveAlgorithm{CS, AD, FDT, ST, CJ} @@ -6590,14 +5272,14 @@ end """ @book{kennedy2001additive, - title={Additive Runge-Kutta schemes for convection-diffusion-reaction equations}, - author={Kennedy, Christopher Alan}, - year={2001}, - publisher={National Aeronautics and Space Administration, Langley Research Center} +title={Additive Runge-Kutta schemes for convection-diffusion-reaction equations}, +author={Kennedy, Christopher Alan}, +year={2001}, +publisher={National Aeronautics and Space Administration, Langley Research Center} } KenCarp3: SDIRK Method - An A-L stable stiffly-accurate 3rd order ESDIRK method with splitting +An A-L stable stiffly-accurate 3rd order ESDIRK method with splitting """ struct KenCarp3{CS, AD, F, F2, P, FDT, ST, CJ} <: OrdinaryDiffEqNewtonAdaptiveAlgorithm{CS, AD, FDT, ST, CJ} @@ -6642,18 +5324,18 @@ end """ @article{hindmarsh2005sundials, - title={{SUNDIALS}: Suite of nonlinear and differential/algebraic equation solvers}, - author={Hindmarsh, Alan C and Brown, Peter N and Grant, Keith E and Lee, Steven L and Serban, Radu and Shumaker, Dan E and Woodward, Carol S}, - journal={ACM Transactions on Mathematical Software (TOMS)}, - volume={31}, - number={3}, - pages={363--396}, - year={2005}, - publisher={ACM} +title={{SUNDIALS}: Suite of nonlinear and differential/algebraic equation solvers}, +author={Hindmarsh, Alan C and Brown, Peter N and Grant, Keith E and Lee, Steven L and Serban, Radu and Shumaker, Dan E and Woodward, Carol S}, +journal={ACM Transactions on Mathematical Software (TOMS)}, +volume={31}, +number={3}, +pages={363--396}, +year={2005}, +publisher={ACM} } Cash4: SDIRK Method - An A-L stable 4th order SDIRK method +An A-L stable 4th order SDIRK method """ struct Cash4{CS, AD, F, F2, P, FDT, ST, CJ} <: OrdinaryDiffEqNewtonAdaptiveAlgorithm{CS, AD, FDT, ST, CJ} @@ -6786,11 +5468,11 @@ end """ E. Hairer, G. Wanner, Solving ordinary differential equations II, stiff and - differential-algebraic problems. Computational mathematics (2nd revised ed.), - Springer (1996) +differential-algebraic problems. Computational mathematics (2nd revised ed.), +Springer (1996) Hairer4: SDIRK Method - An A-L stable 4th order SDIRK method +An A-L stable 4th order SDIRK method """ struct Hairer4{CS, AD, F, F2, P, FDT, ST, CJ} <: OrdinaryDiffEqNewtonAdaptiveAlgorithm{CS, AD, FDT, ST, CJ} @@ -6814,11 +5496,11 @@ end """ E. Hairer, G. Wanner, Solving ordinary differential equations II, stiff and - differential-algebraic problems. Computational mathematics (2nd revised ed.), - Springer (1996) +differential-algebraic problems. Computational mathematics (2nd revised ed.), +Springer (1996) Hairer42: SDIRK Method - An A-L stable 4th order SDIRK method +An A-L stable 4th order SDIRK method """ struct Hairer42{CS, AD, F, F2, P, FDT, ST, CJ} <: OrdinaryDiffEqNewtonAdaptiveAlgorithm{CS, AD, FDT, ST, CJ} @@ -6843,18 +5525,18 @@ end """ @article{kvaerno2004singly, - title={Singly diagonally implicit Runge--Kutta methods with an explicit first stage}, - author={Kv{\\ae}rn{\\o}, Anne}, - journal={BIT Numerical Mathematics}, - volume={44}, - number={3}, - pages={489--502}, - year={2004}, - publisher={Springer} +title={Singly diagonally implicit Runge--Kutta methods with an explicit first stage}, +author={Kv{\\ae}rn{\\o}, Anne}, +journal={BIT Numerical Mathematics}, +volume={44}, +number={3}, +pages={489--502}, +year={2004}, +publisher={Springer} } Kvaerno4: SDIRK Method - An A-L stable stiffly-accurate 4th order ESDIRK method. +An A-L stable stiffly-accurate 4th order ESDIRK method. """ struct Kvaerno4{CS, AD, F, F2, P, FDT, ST, CJ} <: OrdinaryDiffEqNewtonAdaptiveAlgorithm{CS, AD, FDT, ST, CJ} @@ -6879,18 +5561,18 @@ end """ @article{kvaerno2004singly, - title={Singly diagonally implicit Runge--Kutta methods with an explicit first stage}, - author={Kv{\\ae}rn{\\o}, Anne}, - journal={BIT Numerical Mathematics}, - volume={44}, - number={3}, - pages={489--502}, - year={2004}, - publisher={Springer} +title={Singly diagonally implicit Runge--Kutta methods with an explicit first stage}, +author={Kv{\\ae}rn{\\o}, Anne}, +journal={BIT Numerical Mathematics}, +volume={44}, +number={3}, +pages={489--502}, +year={2004}, +publisher={Springer} } Kvaerno5: SDIRK Method - An A-L stable stiffly-accurate 5th order ESDIRK method +An A-L stable stiffly-accurate 5th order ESDIRK method """ struct Kvaerno5{CS, AD, F, F2, P, FDT, ST, CJ} <: OrdinaryDiffEqNewtonAdaptiveAlgorithm{CS, AD, FDT, ST, CJ} @@ -6915,14 +5597,14 @@ end """ @book{kennedy2001additive, - title={Additive Runge-Kutta schemes for convection-diffusion-reaction equations}, - author={Kennedy, Christopher Alan}, - year={2001}, - publisher={National Aeronautics and Space Administration, Langley Research Center} +title={Additive Runge-Kutta schemes for convection-diffusion-reaction equations}, +author={Kennedy, Christopher Alan}, +year={2001}, +publisher={National Aeronautics and Space Administration, Langley Research Center} } KenCarp4: SDIRK Method - An A-L stable stiffly-accurate 4th order ESDIRK method with splitting +An A-L stable stiffly-accurate 4th order ESDIRK method with splitting """ struct KenCarp4{CS, AD, F, F2, P, FDT, ST, CJ} <: OrdinaryDiffEqNewtonAdaptiveAlgorithm{CS, AD, FDT, ST, CJ} @@ -6949,17 +5631,17 @@ TruncatedStacktraces.@truncate_stacktrace KenCarp4 """ @article{kennedy2019higher, - title={Higher-order additive Runge--Kutta schemes for ordinary differential equations}, - author={Kennedy, Christopher A and Carpenter, Mark H}, - journal={Applied Numerical Mathematics}, - volume={136}, - pages={183--205}, - year={2019}, - publisher={Elsevier} +title={Higher-order additive Runge--Kutta schemes for ordinary differential equations}, +author={Kennedy, Christopher A and Carpenter, Mark H}, +journal={Applied Numerical Mathematics}, +volume={136}, +pages={183--205}, +year={2019}, +publisher={Elsevier} } KenCarp47: SDIRK Method - An A-L stable stiffly-accurate 4th order seven-stage ESDIRK method with splitting +An A-L stable stiffly-accurate 4th order seven-stage ESDIRK method with splitting """ struct KenCarp47{CS, AD, F, F2, P, FDT, ST, CJ} <: OrdinaryDiffEqNewtonAdaptiveAlgorithm{CS, AD, FDT, ST, CJ} @@ -6984,14 +5666,14 @@ end """ @book{kennedy2001additive, - title={Additive Runge-Kutta schemes for convection-diffusion-reaction equations}, - author={Kennedy, Christopher Alan}, - year={2001}, - publisher={National Aeronautics and Space Administration, Langley Research Center} +title={Additive Runge-Kutta schemes for convection-diffusion-reaction equations}, +author={Kennedy, Christopher Alan}, +year={2001}, +publisher={National Aeronautics and Space Administration, Langley Research Center} } KenCarp5: SDIRK Method - An A-L stable stiffly-accurate 5th order ESDIRK method with splitting +An A-L stable stiffly-accurate 5th order ESDIRK method with splitting """ struct KenCarp5{CS, AD, F, F2, P, FDT, ST, CJ} <: OrdinaryDiffEqNewtonAdaptiveAlgorithm{CS, AD, FDT, ST, CJ} @@ -7015,17 +5697,17 @@ function KenCarp5(; chunk_size = Val{0}(), autodiff = Val{true}(), end """ @article{kennedy2019higher, - title={Higher-order additive Runge--Kutta schemes for ordinary differential equations}, - author={Kennedy, Christopher A and Carpenter, Mark H}, - journal={Applied Numerical Mathematics}, - volume={136}, - pages={183--205}, - year={2019}, - publisher={Elsevier} +title={Higher-order additive Runge--Kutta schemes for ordinary differential equations}, +author={Kennedy, Christopher A and Carpenter, Mark H}, +journal={Applied Numerical Mathematics}, +volume={136}, +pages={183--205}, +year={2019}, +publisher={Elsevier} } KenCarp58: SDIRK Method - An A-L stable stiffly-accurate 5th order eight-stage ESDIRK method with splitting +An A-L stable stiffly-accurate 5th order eight-stage ESDIRK method with splitting """ struct KenCarp58{CS, AD, F, F2, P, FDT, ST, CJ} <: OrdinaryDiffEqNewtonAdaptiveAlgorithm{CS, AD, FDT, ST, CJ} @@ -7070,12 +5752,12 @@ end """ @article{Kennedy2019DiagonallyIR, - title={Diagonally implicit Runge–Kutta methods for stiff ODEs}, - author={Christopher A. Kennedy and Mark H. Carpenter}, - journal={Applied Numerical Mathematics}, - year={2019}, - volume={146}, - pages={221-244} +title={Diagonally implicit Runge–Kutta methods for stiff ODEs}, +author={Christopher A. Kennedy and Mark H. Carpenter}, +journal={Applied Numerical Mathematics}, +year={2019}, +volume={146}, +pages={221-244} } """ struct ESDIRK436L2SA2{CS, AD, F, F2, P, FDT, ST, CJ} <: @@ -7099,12 +5781,12 @@ end """ @article{Kennedy2019DiagonallyIR, - title={Diagonally implicit Runge–Kutta methods for stiff ODEs}, - author={Christopher A. Kennedy and Mark H. Carpenter}, - journal={Applied Numerical Mathematics}, - year={2019}, - volume={146}, - pages={221-244} +title={Diagonally implicit Runge–Kutta methods for stiff ODEs}, +author={Christopher A. Kennedy and Mark H. Carpenter}, +journal={Applied Numerical Mathematics}, +year={2019}, +volume={146}, +pages={221-244} } """ struct ESDIRK437L2SA{CS, AD, F, F2, P, FDT, ST, CJ} <: @@ -7128,12 +5810,12 @@ end """ @article{Kennedy2019DiagonallyIR, - title={Diagonally implicit Runge–Kutta methods for stiff ODEs}, - author={Christopher A. Kennedy and Mark H. Carpenter}, - journal={Applied Numerical Mathematics}, - year={2019}, - volume={146}, - pages={221-244} +title={Diagonally implicit Runge–Kutta methods for stiff ODEs}, +author={Christopher A. Kennedy and Mark H. Carpenter}, +journal={Applied Numerical Mathematics}, +year={2019}, +volume={146}, +pages={221-244} } """ struct ESDIRK547L2SA2{CS, AD, F, F2, P, FDT, ST, CJ} <: @@ -7157,15 +5839,15 @@ end """ @article{Kennedy2019DiagonallyIR, - title={Diagonally implicit Runge–Kutta methods for stiff ODEs}, - author={Christopher A. Kennedy and Mark H. Carpenter}, - journal={Applied Numerical Mathematics}, - year={2019}, - volume={146}, - pages={221-244} - - Currently has STABILITY ISSUES, causing it to fail the adaptive tests. - Check issue https://github.com/SciML/OrdinaryDiffEq.jl/issues/1933 for more details. +title={Diagonally implicit Runge–Kutta methods for stiff ODEs}, +author={Christopher A. Kennedy and Mark H. Carpenter}, +journal={Applied Numerical Mathematics}, +year={2019}, +volume={146}, +pages={221-244} + +Currently has STABILITY ISSUES, causing it to fail the adaptive tests. +Check issue https://github.com/SciML/OrdinaryDiffEq.jl/issues/1933 for more details. } """ struct ESDIRK659L2SA{CS, AD, F, F2, P, FDT, ST, CJ} <: @@ -7295,7 +5977,7 @@ function GeneralRosenbrock(; chunk_size = Val{0}(), autodiff = true, end """ RosenbrockW6S4OS: Rosenbrock-W Method - A 4th order L-stable Rosenbrock-W method (fixed step only). +A 4th order L-stable Rosenbrock-W method (fixed step only). """ struct RosenbrockW6S4OS{CS, AD, F, P, FDT, ST, CJ} <: OrdinaryDiffEqRosenbrockAlgorithm{CS, AD, FDT, ST, CJ} @@ -7372,7 +6054,7 @@ struct SplitEuler <: OrdinaryDiffEqExponentialAlgorithm{0, false, Val{:forward}, Val{true}, nothing} end """ ETD2: Exponential Runge-Kutta Method - Second order Exponential Time Differencing method (in development). +Second order Exponential Time Differencing method (in development). """ struct ETD2 <: OrdinaryDiffEqExponentialAlgorithm{0, false, Val{:forward}, Val{true}, nothing} end @@ -7385,7 +6067,7 @@ an Adaptive BDF2 Formula and Comparison with The MATLAB Ode15s. Procedia Compute 29, pp 1014-1026, 2014. doi: https://doi.org/10.1016/j.procs.2014.05.091 ABDF2: Multistep Method - An adaptive order 2 L-stable fixed leading coefficient multistep BDF method. +An adaptive order 2 L-stable fixed leading coefficient multistep BDF method. """ struct ABDF2{CS, AD, F, F2, P, FDT, ST, CJ, K, T} <: OrdinaryDiffEqNewtonAdaptiveAlgorithm{CS, AD, FDT, ST, CJ} @@ -7426,8 +6108,8 @@ end ################################################################################ """ MEBDF2: Multistep Method - The second order Modified Extended BDF method, which has improved stability properties over the standard BDF. - Fixed timestep only. +The second order Modified Extended BDF method, which has improved stability properties over the standard BDF. +Fixed timestep only. """ struct MEBDF2{CS, AD, F, F2, P, FDT, ST, CJ} <: OrdinaryDiffEqNewtonAlgorithm{CS, AD, FDT, ST, CJ} @@ -7451,7 +6133,7 @@ end ################################################# """ PDIRK44: Parallel Diagonally Implicit Runge-Kutta Method - A 2 processor 4th order diagonally non-adaptive implicit method. +A 2 processor 4th order diagonally non-adaptive implicit method. """ struct PDIRK44{CS, AD, F, F2, P, FDT, ST, CJ, TO} <: OrdinaryDiffEqNewtonAlgorithm{CS, AD, FDT, ST, CJ} diff --git a/src/algorithms/explicit_rk.jl b/src/algorithms/explicit_rk.jl new file mode 100644 index 0000000000..0e6538fdb4 --- /dev/null +++ b/src/algorithms/explicit_rk.jl @@ -0,0 +1,593 @@ +function Base.show(io::IO, alg::OrdinaryDiffEqAlgorithm) + print(io, String(typeof(alg).name.name), "(;") + for fieldname in fieldnames(typeof(alg)) + print(io, " ", fieldname, " = ", getfield(alg, fieldname), ",") + end + print(io, ")") +end +function explicit_rk_docstring(description::String, + name::String; + references::String = "", + extra_keyword_description = "", + extra_keyword_default = "") + if !isempty(extra_keyword_default) + extra_keyword_default = "\n" * repeat(" ", 8) * extra_keyword_default + end + start_docstring = """ + ```julia + $name(; stage_limiter! = OrdinaryDiffEq.trivial_limiter!, + step_limiter! = OrdinaryDiffEq.trivial_limiter!, + thread = OrdinaryDiffEq.False(),$extra_keyword_default) + ``` + + Explicit Runge-Kutta Method. + """ + keyword_docstring = """ + + ### 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()`, + default) or use multiple threads (`thread = OrdinaryDiffEq.True()`) when + Julia is started with multiple threads. + """ + start_docstring * description * keyword_docstring * extra_keyword_description * + "## References\n" * references +end + +@doc explicit_rk_docstring("The second order Heun's method. Uses embedded Euler method for adaptivity.", + "Heun") +Base.@kwdef struct Heun{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAdaptiveAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() +end +# for backwards compatibility +function Heun(stage_limiter!, step_limiter! = trivial_limiter!) + Heun(stage_limiter!, step_limiter!, False()) +end + +@doc explicit_rk_docstring("The optimized second order midpoint method. Uses embedded Euler method for adaptivity.", + "Ralston") +Base.@kwdef struct Ralston{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAdaptiveAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() +end +# for backwards compatibility +function Ralston(stage_limiter!, step_limiter! = trivial_limiter!) + Ralston(stage_limiter!, step_limiter!, False()) +end + +@doc explicit_rk_docstring("The second order midpoint method. Uses embedded Euler method for adaptivity.", + "Midpoint") +Base.@kwdef struct Midpoint{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAdaptiveAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() +end +# for backwards compatibility +function Midpoint(stage_limiter!, step_limiter! = trivial_limiter!) + Midpoint(stage_limiter!, step_limiter!, False()) +end + +@doc explicit_rk_docstring("The canonical Runge-Kutta Order 4 method. +Uses a defect control for adaptive stepping using maximum error over the whole interval.", + "RK4", + references = "@article{shampine2005solving, + title={Solving ODEs and DDEs with residual control}, + author={Shampine, LF}, + journal={Applied Numerical Mathematics}, + volume={52}, + number={1}, + pages={113--127}, + year={2005}, + publisher={Elsevier} + }") +Base.@kwdef struct RK4{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() +end +# for backwards compatibility +function RK4(stage_limiter!, step_limiter! = trivial_limiter!) + RK4(stage_limiter!, step_limiter!, False()) +end + +@doc explicit_rk_docstring("TBD", "RKM") +Base.@kwdef struct RKM{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() +end +# for backwards compatibility +function RKM(stage_limiter!, step_limiter! = trivial_limiter!) + RKM(stage_limiter!, step_limiter!, False()) +end + +@doc explicit_rk_docstring("5th order Explicit RK method.", "MSRK5", + references = "Misha Stepanov - https://arxiv.org/pdf/2202.08443.pdf : Figure 3.") +Base.@kwdef struct MSRK5{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() +end +# for backwards compatibility +function MSRK5(stage_limiter!, step_limiter! = trivial_limiter!) + MSRK5(stage_limiter!, step_limiter!, False()) +end + +@doc explicit_rk_docstring("4th order Runge-Kutta method designed for periodic problems.", + "Anas5", + extra_keyword_description = """- `w`: a periodicity estimate, which when accurate the method becomes 5th order + (and is otherwise 4th order with less error for better estimates). + """, + extra_keyword_default = "w = 1") +Base.@kwdef struct Anas5{StageLimiter, StepLimiter, Thread, T} <: OrdinaryDiffEqAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() + w::T = 1 +end +# for backwards compatibility +function Anas5(stage_limiter!, step_limiter! = trivial_limiter!; w = 1) + Anas5(stage_limiter!, step_limiter!, False(), w) +end + +@doc explicit_rk_docstring("5th order Explicit RK method.", "RKO5", + references = "Tsitouras, Ch. \"Explicit Runge–Kutta methods for starting integration of + Lane–Emden problem.\" Applied Mathematics and Computation 354 (2019): 353-364. + doi: https://doi.org/10.1016/j.amc.2019.02.047") +Base.@kwdef struct RKO65{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() +end +# for backwards compatibility +function RKO65(stage_limiter!, step_limiter! = trivial_limiter!) + RKO65(stage_limiter!, step_limiter!, False()) +end + +@doc explicit_rk_docstring("Owren-Zennaro optimized interpolation 3/2 method (free 3rd order interpolant).", + "OwrenZen3", + references = "@article{owren1992derivation, + title={Derivation of efficient, continuous, explicit Runge--Kutta methods}, + author={Owren, Brynjulf and Zennaro, Marino}, + journal={SIAM journal on scientific and statistical computing}, + volume={13}, + number={6}, + pages={1488--1501}, + year={1992}, + publisher={SIAM} + }") +Base.@kwdef struct OwrenZen3{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAdaptiveAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() +end +# for backwards compatibility +function OwrenZen3(stage_limiter!, step_limiter! = trivial_limiter!) + OwrenZen3(stage_limiter!, step_limiter!, False()) +end + +@doc explicit_rk_docstring("Owren-Zennaro optimized interpolation 4/3 method (free 4th order interpolant).", + "OwrenZen4", + references = "@article{owren1992derivation, + title={Derivation of efficient, continuous, explicit Runge--Kutta methods}, + author={Owren, Brynjulf and Zennaro, Marino}, + journal={SIAM journal on scientific and statistical computing}, + volume={13}, + number={6}, + pages={1488--1501}, + year={1992}, + publisher={SIAM} + }") +Base.@kwdef struct OwrenZen4{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAdaptiveAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() +end +# for backwards compatibility +function OwrenZen4(stage_limiter!, step_limiter! = trivial_limiter!) + OwrenZen4(stage_limiter!, step_limiter!, False()) +end + +@doc explicit_rk_docstring("Owren-Zennaro optimized interpolation 5/4 method (free 5th order interpolant).", + "OwrenZen5", + references = "@article{owren1992derivation, + title={Derivation of efficient, continuous, explicit Runge--Kutta methods}, + author={Owren, Brynjulf and Zennaro, Marino}, + journal={SIAM journal on scientific and statistical computing}, + volume={13}, + number={6}, + pages={1488--1501}, + year={1992}, + publisher={SIAM} + }") +Base.@kwdef struct OwrenZen5{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAdaptiveAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() +end +# for backwards compatibility +function OwrenZen5(stage_limiter!, step_limiter! = trivial_limiter!) + OwrenZen5(stage_limiter!, step_limiter!, False()) +end + +@doc explicit_rk_docstring("Owren-Zennaro optimized interpolation 5/4 method (free 5th order interpolant).", + "OwrenZen5", + references = "@article{bogacki19893, + title={A 3 (2) pair of Runge-Kutta formulas}, + author={Bogacki, Przemyslaw and Shampine, Lawrence F}, + journal={Applied Mathematics Letters}, + volume={2}, + number={4}, + pages={321--325}, + year={1989}, + publisher={Elsevier} + }") +Base.@kwdef struct BS3{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() +end +# for backwards compatibility +function BS3(stage_limiter!, step_limiter! = trivial_limiter!) + BS3(stage_limiter!, step_limiter!, False()) +end + +@doc explicit_rk_docstring("Dormand-Prince's 5/4 Runge-Kutta method. (free 4th order interpolant).", + "DP5", + references = "@article{dormand1980family, + title={A family of embedded Runge-Kutta formulae}, + author={Dormand, John R and Prince, Peter J}, + journal={Journal of computational and applied mathematics}, + volume={6}, + number={1}, + pages={19--26}, + year={1980}, + publisher={Elsevier} + }") +Base.@kwdef struct DP5{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() +end +# for backwards compatibility +function DP5(stage_limiter!, step_limiter! = trivial_limiter!) + DP5(stage_limiter!, step_limiter!, False()) +end + +@doc explicit_rk_docstring("A fifth-order explicit Runge-Kutta method with embedded error +estimator of Tsitouras. Free 4th order interpolant.", "Tsit5", + references = "@article{tsitouras2011runge, + title={Runge--Kutta pairs of order 5 (4) satisfying only the first column simplifying assumption}, + author={Tsitouras, Ch}, + journal={Computers \\& Mathematics with Applications}, + volume={62}, + number={2}, + pages={770--775}, + year={2011}, + publisher={Elsevier} + }") +Base.@kwdef struct Tsit5{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAdaptiveAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() +end +TruncatedStacktraces.@truncate_stacktrace Tsit5 3 +# for backwards compatibility +function Tsit5(stage_limiter!, step_limiter! = trivial_limiter!) + Tsit5(stage_limiter!, step_limiter!, False()) +end + +@doc explicit_rk_docstring("Hairer's 8/5/3 adaption of the Dormand-Prince Runge-Kutta method. (7th order interpolant).", + "DP8", + references = "E. Hairer, S.P. Norsett, G. Wanner, (1993) Solving Ordinary Differential Equations I. + Nonstiff Problems. 2nd Edition. Springer Series in Computational Mathematics, + Springer-Verlag.") +Base.@kwdef struct DP8{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() +end +# for backwards compatibility +function DP8(stage_limiter!, step_limiter! = trivial_limiter!) + DP8(stage_limiter!, step_limiter!, False()) +end + +@doc explicit_rk_docstring("Tanaka-Yamashita 7 Runge-Kutta method. (7th order interpolant).", + "TanYam7", + references = "Tanaka M., Muramatsu S., Yamashita S., (1992), On the Optimization of Some Nine-Stage + Seventh-order Runge-Kutta Method, Information Processing Society of Japan, + 33 (12), pp. 1512-1526.") +Base.@kwdef struct TanYam7{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAdaptiveAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() +end +# for backwards compatibility +function TanYam7(stage_limiter!, step_limiter! = trivial_limiter!) + TanYam7(stage_limiter!, step_limiter!, False()) +end + +@doc explicit_rk_docstring("Tsitouras-Papakostas 8/7 Runge-Kutta method.", "TsitPap8") +Base.@kwdef struct TsitPap8{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAdaptiveAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() +end +# for backwards compatibility +function TsitPap8(stage_limiter!, step_limiter! = trivial_limiter!) + TsitPap8(stage_limiter!, step_limiter!, False()) +end + +""" +@article{feagin2012high, +title={High-order explicit Runge-Kutta methods using m-symmetry}, +author={Feagin, Terry}, +year={2012}, +publisher={Neural, Parallel \\& Scientific Computations} +} + +Feagin10: Explicit Runge-Kutta Method +Feagin's 10th-order Runge-Kutta method. +""" +struct Feagin10 <: OrdinaryDiffEqAdaptiveAlgorithm end + +""" +@article{feagin2012high, +title={High-order explicit Runge-Kutta methods using m-symmetry}, +author={Feagin, Terry}, +year={2012}, +publisher={Neural, Parallel \\& Scientific Computations} +} + +Feagin12: Explicit Runge-Kutta Method +Feagin's 12th-order Runge-Kutta method. +""" +struct Feagin12 <: OrdinaryDiffEqAdaptiveAlgorithm end + +""" +Feagin, T., “An Explicit Runge-Kutta Method of Order Fourteen,” Numerical +Algorithms, 2009 + +Feagin14: Explicit Runge-Kutta Method +Feagin's 14th-order Runge-Kutta method. +""" +struct Feagin14 <: OrdinaryDiffEqAdaptiveAlgorithm end + +@doc explicit_rk_docstring("Zero Dissipation Runge-Kutta of 6th order.", "FRK65", + extra_keyword_description = """- `omega`: a periodicity phase estimate, + when accurate this method results in zero numerical dissipation. + """, + extra_keyword_default = "omega = 0.0") +Base.@kwdef struct FRK65{StageLimiter, StepLimiter, Thread, T} <: + OrdinaryDiffEqAdaptiveAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() + omega::T = 0.0 +end + +# for backwards compatibility +function FRK65(stage_limiter!, step_limiter! = trivial_limiter!; omega = 0.0) + FRK65(stage_limiter!, step_limiter!, False(), omega) +end + +@doc explicit_rk_docstring("Phase-fitted Runge-Kutta of 8th order.", "PFRK87", + extra_keyword_description = """- `omega`: a periodicity phase estimate, + when accurate this method results in zero numerical dissipation. + """, + extra_keyword_default = "omega = 0.0") +Base.@kwdef struct PFRK87{StageLimiter, StepLimiter, Thread, T} <: + OrdinaryDiffEqAdaptiveAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() + omega::T = 0.0 +end +# for backwards compatibility +function PFRK87(stage_limiter!, step_limiter! = trivial_limiter!; omega = 0.0) + PFRK87(stage_limiter!, step_limiter!, False(), omega) +end + +@doc explicit_rk_docstring("Bogacki-Shampine 5/4 Runge-Kutta method. (lazy 5th order interpolant).", + "BS5", + references = "@article{bogacki1996efficient, + title={An efficient runge-kutta (4, 5) pair}, + author={Bogacki, P and Shampine, Lawrence F}, + journal={Computers \\& Mathematics with Applications}, + volume={32}, + number={6}, + pages={15--28}, + year={1996}, + publisher={Elsevier} + }", + extra_keyword_description = """- `lazy`: determines if the lazy interpolant is used. + """, + extra_keyword_default = "lazy = true") +Base.@kwdef struct BS5{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAdaptiveAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() + lazy::Bool = true +end +# for backwards compatibility +function BS5(stage_limiter!, step_limiter! = trivial_limiter!; lazy = true) + BS5(stage_limiter!, step_limiter!, False(), lazy) +end + +@doc explicit_rk_docstring("Verner's “Most Efficient” 6/5 Runge-Kutta method. (lazy 6th order interpolant).", + "Vern6", + references = "@article{verner2010numerically, + title={Numerically optimal Runge--Kutta pairs with interpolants}, + author={Verner, James H}, + journal={Numerical Algorithms}, + volume={53}, + number={2-3}, + pages={383--396}, + year={2010}, + publisher={Springer} + }", + extra_keyword_description = """- `lazy`: determines if the lazy interpolant is used. + """, + extra_keyword_default = "lazy = true") +Base.@kwdef struct Vern6{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAdaptiveAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() + lazy::Bool = true +end +TruncatedStacktraces.@truncate_stacktrace Vern6 3 +# for backwards compatibility +function Vern6(stage_limiter!, step_limiter! = trivial_limiter!; lazy = true) + Vern6(stage_limiter!, step_limiter!, False(), lazy) +end + +@doc explicit_rk_docstring("Verner's “Most Efficient” 7/6 Runge-Kutta method. (lazy 7th order interpolant).", + "Vern7", + references = "@article{verner2010numerically, + title={Numerically optimal Runge--Kutta pairs with interpolants}, + author={Verner, James H}, + journal={Numerical Algorithms}, + volume={53}, + number={2-3}, + pages={383--396}, + year={2010}, + publisher={Springer} + }", + extra_keyword_description = """- `lazy`: determines if the lazy interpolant is used. + """, + extra_keyword_default = "lazy = true") +Base.@kwdef struct Vern7{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAdaptiveAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() + lazy::Bool = true +end +TruncatedStacktraces.@truncate_stacktrace Vern7 3 +# for backwards compatibility +function Vern7(stage_limiter!, step_limiter! = trivial_limiter!; lazy = true) + Vern7(stage_limiter!, step_limiter!, False(), lazy) +end + +@doc explicit_rk_docstring("Verner's “Most Efficient” 8/7 Runge-Kutta method. (lazy 8th order interpolant).", + "Vern8", + references = "@article{verner2010numerically, + title={Numerically optimal Runge--Kutta pairs with interpolants}, + author={Verner, James H}, + journal={Numerical Algorithms}, + volume={53}, + number={2-3}, + pages={383--396}, + year={2010}, + publisher={Springer} + }", + extra_keyword_description = """- `lazy`: determines if the lazy interpolant is used. + """, + extra_keyword_default = "lazy = true") +Base.@kwdef struct Vern8{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAdaptiveAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() + lazy::Bool = true +end +TruncatedStacktraces.@truncate_stacktrace Vern8 3 +# for backwards compatibility +function Vern8(stage_limiter!, step_limiter! = trivial_limiter!; lazy = true) + Vern8(stage_limiter!, step_limiter!, False(), lazy) +end + +@doc explicit_rk_docstring("Verner's “Most Efficient” 9/8 Runge-Kutta method. (lazy9th order interpolant).", + "Vern9", + references = "@article{verner2010numerically, + title={Numerically optimal Runge--Kutta pairs with interpolants}, + author={Verner, James H}, + journal={Numerical Algorithms}, + volume={53}, + number={2-3}, + pages={383--396}, + year={2010}, + publisher={Springer} + }", + extra_keyword_description = """- `lazy`: determines if the lazy interpolant is used. + """, extra_keyword_default = "lazy = true") +Base.@kwdef struct Vern9{StageLimiter, StepLimiter, Thread} <: + OrdinaryDiffEqAdaptiveAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() + lazy::Bool = true +end +TruncatedStacktraces.@truncate_stacktrace Vern9 3 +# for backwards compatibility +function Vern9(stage_limiter!, step_limiter! = trivial_limiter!; lazy = true) + Vern9(stage_limiter!, step_limiter!, False(), lazy) +end + +""" +Euler - The canonical forward Euler method. Fixed timestep only. +""" +struct Euler <: OrdinaryDiffEqAlgorithm 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") +Base.@kwdef struct RK46NL{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() +end +# for backwards compatibility +function RK46NL(stage_limiter!, step_limiter! = trivial_limiter!) + RK46NL(stage_limiter!, step_limiter!, False()) +end + +@doc explicit_rk_docstring("A second-order, five-stage explicit Runge-Kutta 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 = true") +Base.@kwdef struct ORK256{StageLimiter, StepLimiter, Thread} <: OrdinaryDiffEqAlgorithm + stage_limiter!::StageLimiter = trivial_limiter! + step_limiter!::StepLimiter = trivial_limiter! + thread::Thread = False() + williamson_condition::Bool = true +end +# for backwards compatibility +function ORK256(stage_limiter!, + step_limiter! = trivial_limiter!; + williamson_condition = true) + ORK256(stage_limiter!, step_limiter!, False(), williamson_condition) +end + +""" +KuttaPRK2p5: Parallel Explicit Runge-Kutta Method +A 5 parallel, 2 processor explicit Runge-Kutta method of 5th order. + +These methods utilize multithreading on the f calls to parallelize the problem. +This requires that simultaneous calls to f are thread-safe. +""" +Base.@kwdef struct KuttaPRK2p5{TO} <: OrdinaryDiffEqAlgorithm + threading::TO = true +end diff --git a/src/dense/interpolants.jl b/src/dense/interpolants.jl index 50067ce777..bb9c15b208 100644 --- a/src/dense/interpolants.jl +++ b/src/dense/interpolants.jl @@ -705,7 +705,6 @@ end end """ - """ @def owrenzen3unpack begin if typeof(cache) <: OrdinaryDiffEqMutableCache @@ -890,7 +889,6 @@ end end """ - """ @def owrenzen4unpack begin if typeof(cache) <: OrdinaryDiffEqMutableCache @@ -1143,7 +1141,6 @@ end end """ - """ @def owrenzen5unpack begin if typeof(cache) <: OrdinaryDiffEqMutableCache @@ -2701,7 +2698,6 @@ end end """ - """ @muladd function _ode_interpolant(Θ, dt, y₀, y₁, k, cache::Union{DP8ConstantCache, DP8Cache}, idxs::Nothing, @@ -2843,7 +2839,6 @@ end end """ - """ @def dprkn6unpack begin if typeof(cache) <: OrdinaryDiffEqMutableCache diff --git a/src/dense/low_order_rk_addsteps.jl b/src/dense/low_order_rk_addsteps.jl index 9436771250..79d0a4f599 100644 --- a/src/dense/low_order_rk_addsteps.jl +++ b/src/dense/low_order_rk_addsteps.jl @@ -182,7 +182,7 @@ end """ An Efficient Runge-Kutta (4,5) Pair by P.Bogacki and L.F.Shampine - Computers and Mathematics with Applications, Vol. 32, No. 6, 1996, pages 15 to 28 +Computers and Mathematics with Applications, Vol. 32, No. 6, 1996, pages 15 to 28 Called to add the extra k9, k10, k11 steps for the Order 5 interpolation when needed """ @@ -591,7 +591,7 @@ end """ An Efficient Runge-Kutta (4,5) Pair by P.Bogacki and L.F.Shampine - Computers and Mathematics with Applications, Vol. 32, No. 6, 1996, pages 15 to 28 +Computers and Mathematics with Applications, Vol. 32, No. 6, 1996, pages 15 to 28 Called to add the extra k9, k10, k11 steps for the Order 5 interpolation when needed """ diff --git a/src/integrators/controllers.jl b/src/integrators/controllers.jl index afef2aa8fa..cb3e74c2e2 100644 --- a/src/integrators/controllers.jl +++ b/src/integrators/controllers.jl @@ -33,9 +33,11 @@ many problems/algorithms. Construct an integral (I) step size controller adapting the time step based on the formula + ``` Δtₙ₊₁ = εₙ₊₁^(1/k) * Δtₙ ``` + where `k = get_current_adaptive_order(alg, integrator.cache) + 1` and `εᵢ` is the inverse of the error estimate `integrator.EEst` scaled by the tolerance (Hairer, Nørsett, Wanner, 2008, Section II.4). @@ -46,9 +48,10 @@ less than or equal to unity. Otherwise, the step is rejected and re-tried with the predicted step size. ## References -- Hairer, Nørsett, Wanner (2008) - Solving Ordinary Differential Equations I Nonstiff Problems - [DOI: 10.1007/978-3-540-78862-1](https://doi.org/10.1007/978-3-540-78862-1) + + - Hairer, Nørsett, Wanner (2008) + Solving Ordinary Differential Equations I Nonstiff Problems + [DOI: 10.1007/978-3-540-78862-1](https://doi.org/10.1007/978-3-540-78862-1) """ struct IController <: AbstractController end @@ -92,9 +95,11 @@ with improved stability properties compared to the [`IController`](@ref). This controller is the default for most algorithms in OrdinaryDiffEq.jl. Construct a PI step size controller adapting the time step based on the formula + ``` Δtₙ₊₁ = εₙ₊₁^β₁ * εₙ^β₂ * Δtₙ ``` + where `εᵢ` are inverses of the error estimates scaled by the tolerance (Hairer, Nørsett, Wanner, 2010, Section IV.2). The step size factor is multiplied by the safety factor `gamma` and clipped to @@ -104,17 +109,19 @@ less than or equal to unity. Otherwise, the step is rejected and re-tried with the predicted step size. !!! note + The coefficients `beta1, beta2` are not scaled by the order of the method, in contrast to the [`PIDController`](@ref). For the `PIController`, this scaling by the order must be done when the controller is constructed. ## References -- Hairer, Nørsett, Wanner (2010) - Solving Ordinary Differential Equations II Stiff and Differential-Algebraic Problems - [DOI: 10.1007/978-3-642-05221-7](https://doi.org/10.1007/978-3-642-05221-7) -- Hairer, Nørsett, Wanner (2008) - Solving Ordinary Differential Equations I Nonstiff Problems - [DOI: 10.1007/978-3-540-78862-1](https://doi.org/10.1007/978-3-540-78862-1) + + - Hairer, Nørsett, Wanner (2010) + Solving Ordinary Differential Equations II Stiff and Differential-Algebraic Problems + [DOI: 10.1007/978-3-642-05221-7](https://doi.org/10.1007/978-3-642-05221-7) + - Hairer, Nørsett, Wanner (2008) + Solving Ordinary Differential Equations I Nonstiff Problems + [DOI: 10.1007/978-3-540-78862-1](https://doi.org/10.1007/978-3-540-78862-1) """ mutable struct PIController{QT} <: AbstractController beta1::QT @@ -174,15 +181,19 @@ The proportional-integral-derivative (PID) controller is a generalization of the [`PIController`](@ref) and can have improved stability and efficiency properties. Construct a PID step size controller adapting the time step based on the formula + ``` Δtₙ₊₁ = εₙ₊₁^(β₁/k) * εₙ^(β₂/k) * εₙ₋₁^(β₃/ k) * Δtₙ ``` + where `k = min(alg_order, alg_adaptive_order) + 1` and `εᵢ` are inverses of the error estimates scaled by the tolerance (Söderlind, 2003). The step size factor is limited by the `limiter` with default value + ``` limiter(x) = one(x) + atan(x - one(x)) ``` + as proposed by Söderlind and Wang (2006). A step will be accepted whenever the predicted step size change is bigger than `accept_safety`. Otherwise, the step is rejected and re-tried with the predicted step size. @@ -190,20 +201,22 @@ is rejected and re-tried with the predicted step size. Some standard controller parameters suggested in the literature are | Controller | `beta1` | `beta2` | `beta3` | -|:-----------|--------:|--------:|:-------:| -| basic | `1.00` | `0.00` | `0` | -| PI42 | `0.60` | `-0.20` | `0` | -| PI33 | `2//3` | `-1//3` | `0` | -| PI34 | `0.70` | `-0.40` | `0` | -| H211PI | `1//6` | `1//6` | `0` | -| H312PID | `1//18` | `1//9` | `1//18` | +|:---------- | -------:| -------:|:-------:| +| basic | `1.00` | `0.00` | `0` | +| PI42 | `0.60` | `-0.20` | `0` | +| PI33 | `2//3` | `-1//3` | `0` | +| PI34 | `0.70` | `-0.40` | `0` | +| H211PI | `1//6` | `1//6` | `0` | +| H312PID | `1//18` | `1//9` | `1//18` | !!! note + In contrast to the [`PIController`](@ref), the coefficients `beta1, beta2, beta3` are scaled by the order of the method. Thus, standard controllers such as PI42 can use the same coefficients `beta1, beta2, beta3` for different algorithms. !!! note + In contrast to other controllers, the `PIDController` does not use the keyword arguments `qmin, qmax` to limit the step size change or the safety factor `gamma`. These common keyword arguments are replaced by the `limiter` and `accept_safety` @@ -212,16 +225,17 @@ Some standard controller parameters suggested in the literature are even if `beta1, beta2` are adapted accordingly and `iszero(beta3)`. ## References -- Söderlind (2003) - Digital Filters in Adaptive Time-Stepping - [DOI: 10.1145/641876.641877](https://doi.org/10.1145/641876.641877) -- Söderlind, Wang (2006) - Adaptive time-stepping and computational stability - [DOI: 10.1016/j.cam.2005.03.008](https://doi.org/10.1016/j.cam.2005.03.008) -- 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) + + - Söderlind (2003) + Digital Filters in Adaptive Time-Stepping + [DOI: 10.1145/641876.641877](https://doi.org/10.1145/641876.641877) + - Söderlind, Wang (2006) + Adaptive time-stepping and computational stability + [DOI: 10.1016/j.cam.2005.03.008](https://doi.org/10.1016/j.cam.2005.03.008) # controller coefficients + - Ranocha, Dalcin, Parsani, Ketcheson (2021) # history of the error estimates + Optimized Runge-Kutta Methods with Automatic Step Size Control for # accept a step if the predicted change of the step size + Compressible Computational Fluid Dynamics # is bigger than this parameter + [arXiv:2104.06836](https://arxiv.org/abs/2104.06836) # limiter of the dt factor (before clipping) """ struct PIDController{QT, Limiter} <: AbstractController beta::MVector{3, QT} # controller coefficients @@ -326,39 +340,47 @@ for algorithms like the (E)SDIRK methods. ```julia gamma = integrator.opts.gamma niters = integrator.cache.newton_iters -fac = min(gamma,(1+2*integrator.alg.max_newton_iter)*gamma/(niters+2*integrator.alg.max_newton_iter)) -expo = 1/(alg_order(integrator.alg)+1) -qtmp = (integrator.EEst^expo)/fac -@fastmath q = max(inv(integrator.opts.qmax),min(inv(integrator.opts.qmin),qtmp)) +fac = min(gamma, + (1 + 2 * integrator.alg.max_newton_iter) * gamma / + (niters + 2 * integrator.alg.max_newton_iter)) +expo = 1 / (alg_order(integrator.alg) + 1) +qtmp = (integrator.EEst^expo) / fac +@fastmath q = max(inv(integrator.opts.qmax), min(inv(integrator.opts.qmin), qtmp)) if q <= integrator.opts.qsteady_max && q >= integrator.opts.qsteady_min - q = one(q) + q = one(q) end integrator.qold = q q ``` + In this case, `niters` is the number of Newton iterations which was required in the most recent step of the algorithm. Note that these values are used differently depending on acceptance and rejectance. When the step is accepted, the following logic is applied: + ```julia if integrator.success_iter > 0 - expo = 1/(alg_adaptive_order(integrator.alg)+1) - qgus=(integrator.dtacc/integrator.dt)*(((integrator.EEst^2)/integrator.erracc)^expo) - qgus = max(inv(integrator.opts.qmax),min(inv(integrator.opts.qmin),qgus/integrator.opts.gamma)) - qacc=max(q,qgus) + expo = 1 / (alg_adaptive_order(integrator.alg) + 1) + qgus = (integrator.dtacc / integrator.dt) * + (((integrator.EEst^2) / integrator.erracc)^expo) + qgus = max(inv(integrator.opts.qmax), + min(inv(integrator.opts.qmin), qgus / integrator.opts.gamma)) + qacc = max(q, qgus) else - qacc = q + qacc = q end integrator.dtacc = integrator.dt -integrator.erracc = max(1e-2,integrator.EEst) -integrator.dt/qacc +integrator.erracc = max(1e-2, integrator.EEst) +integrator.dt / qacc ``` + When it rejects, it's the same as the [`IController`](@ref): + ```julia if integrator.success_iter == 0 - integrator.dt *= 0.1 + integrator.dt *= 0.1 else - integrator.dt = integrator.dt/integrator.qold + integrator.dt = integrator.dt / integrator.qold end ``` """ diff --git a/src/integrators/type.jl b/src/integrators/type.jl index e0df3e20f7..070f098816 100644 --- a/src/integrators/type.jl +++ b/src/integrators/type.jl @@ -51,6 +51,7 @@ TruncatedStacktraces.@truncate_stacktrace DEOptions """ ODEIntegrator + Fundamental `struct` allowing interactively stepping through the numerical solving of a differential equation. The full documentation is hosted here: [https://diffeq.sciml.ai/latest/basics/integrator/](https://diffeq.sciml.ai/latest/basics/integrator/). @@ -60,23 +61,24 @@ Initialize using `integrator = init(prob::ODEProblem, alg; kwargs...)`. The keyw [common solver options](https://diffeq.sciml.ai/latest/basics/common_solver_opts/) used by `solve`. - For reference, relevant fields of the `ODEIntegrator` are: -* `t` - time of the proposed step -* `u` - value at the proposed step -* `opts` - common solver options -* `alg` - the algorithm associated with the solution -* `f` - the function being solved -* `sol` - the current state of the solution -* `tprev` - the last timepoint -* `uprev` - the value at the last timepoint + - `t` - time of the proposed step + - `u` - value at the proposed step + - `opts` - common solver options + - `alg` - the algorithm associated with the solution + - `f` - the function being solved + - `sol` - the current state of the solution + - `tprev` - the last timepoint + - `uprev` - the value at the last timepoint `opts` holds all of the common solver options, and can be mutated to change the solver characteristics. For example, to modify the absolute tolerance for the future timesteps, one can do: + ```julia integrator.opts.abstol = 1e-9 ``` + For more info see the linked documentation page. """ mutable struct ODEIntegrator{algType <: Union{OrdinaryDiffEqAlgorithm, DAEAlgorithm}, IIP, diff --git a/src/nlsolve/functional.jl b/src/nlsolve/functional.jl index dd7083a6bd..5b358b7ee0 100644 --- a/src/nlsolve/functional.jl +++ b/src/nlsolve/functional.jl @@ -29,9 +29,11 @@ end compute_step!(nlsolver::NLSolver{<:Union{NLFunctional,NLAnderson}}, integrator) Compute the next step of the fixed-point iteration + ```math g(z) = dt⋅f(tmp + γ⋅z, p, t + c⋅dt), ``` + and return the norm of ``g(z) - z``. # References diff --git a/src/nlsolve/nlsolve.jl b/src/nlsolve/nlsolve.jl index 1bb36da682..b522239ae3 100644 --- a/src/nlsolve/nlsolve.jl +++ b/src/nlsolve/nlsolve.jl @@ -4,9 +4,11 @@ nlsolve!(nlsolver::AbstractNLSolver, integrator) Solve + ```math dt⋅f(innertmp + γ⋅z, p, t + c⋅dt) + outertmp = z ``` + where `dt` is the step size and `γ` and `c` are constants, and return the solution `z`. """ function nlsolve!(nlsolver::AbstractNLSolver, integrator::DiffEqBase.DEIntegrator, diff --git a/src/rkc_utils.jl b/src/rkc_utils.jl index e9742d89c2..8bb05391d5 100644 --- a/src/rkc_utils.jl +++ b/src/rkc_utils.jl @@ -208,7 +208,7 @@ and `cache.start` (the start index of recurrence parameters for that degree), where `recf` are the `μ,κ` pairs for the `mdeg` degree method. The `κ` for `stage-1` for every degree is 0 therefore it's not included in `recf` - """ +""" function choosedeg!(cache::T) where {T} isconst = T <: OrdinaryDiffEqConstantCache isconst || (cache = cache.constantcache) diff --git a/src/tableaus/feagin_tableaus.jl b/src/tableaus/feagin_tableaus.jl index 9ca7277b5c..64a056e0c9 100644 --- a/src/tableaus/feagin_tableaus.jl +++ b/src/tableaus/feagin_tableaus.jl @@ -123,7 +123,6 @@ end """ constructFeagin10 - """ function Feagin10ConstantCache(T::Type{<:CompiledFloats}, T2::Type{<:CompiledFloats}) adaptiveConst = convert(T, 0.002777777777777778) @@ -279,7 +278,6 @@ end """ constructFeagin10 - """ function Feagin10ConstantCache(T::Type, T2::Type) adaptiveConst = convert(T, 1 // 360) @@ -669,7 +667,6 @@ end """ constructFeagin12 - """ function Feagin12ConstantCache(T::Type{<:CompiledFloats}, T2::Type{<:CompiledFloats}) adaptiveConst = convert(T, 49 // 640) @@ -944,7 +941,6 @@ end """ constructFeagin12 - """ function Feagin12ConstantCache(T::Type, T2::Type) adaptiveConst = convert(T, 49 // 640) @@ -1648,7 +1644,6 @@ end """ constructFeagin14 - """ function Feagin14ConstantCache(T::Type{<:CompiledFloats}, T2::Type{<:CompiledFloats}) adaptiveConst = convert(T, 1 // 1000) @@ -2126,7 +2121,6 @@ end """ constructFeagin14 - """ function Feagin14ConstantCache(T::Type, T2::Type) adaptiveConst = convert(T, 1 // 1000) diff --git a/src/tableaus/high_order_rk_tableaus.jl b/src/tableaus/high_order_rk_tableaus.jl index 4f3e9b1b2d..21350ad02f 100644 --- a/src/tableaus/high_order_rk_tableaus.jl +++ b/src/tableaus/high_order_rk_tableaus.jl @@ -391,7 +391,7 @@ end """ Cheap Error Estimation for Runge-Kutta methods, by Ch. Tsitouras and S.N. Papakostas, - Siam Journal on Scientific Computing, Vol. 20, Issue 6, Nov 1999. +Siam Journal on Scientific Computing, Vol. 20, Issue 6, Nov 1999. """ function TsitPap8ConstantCache(T::Type{<:CompiledFloats}, T2::Type{<:CompiledFloats}) c1 = convert(T2, 0.06338028169014084) @@ -500,7 +500,7 @@ end """ Cheap Error Estimation for Runge-Kutta methods, by Ch. Tsitouras and S.N. Papakostas, - Siam Journal on Scientific Computing, Vol. 20, Issue 6, Nov 1999. +Siam Journal on Scientific Computing, Vol. 20, Issue 6, Nov 1999. """ function TsitPap8ConstantCache(T::Type, T2::Type) c1 = convert(T2, 9 // 142) diff --git a/src/tableaus/low_order_rk_tableaus.jl b/src/tableaus/low_order_rk_tableaus.jl index 757d19c9ff..cda68ffb71 100644 --- a/src/tableaus/low_order_rk_tableaus.jl +++ b/src/tableaus/low_order_rk_tableaus.jl @@ -881,9 +881,8 @@ struct BS5ConstantCache{T, T2} <: OrdinaryDiffEqConstantCache end """ - An Efficient Runge-Kutta (4,5) Pair by P.Bogacki and L.F.Shampine - Computers and Mathematics with Applications, Vol. 32, No. 6, 1996, pages 15 to 28 +Computers and Mathematics with Applications, Vol. 32, No. 6, 1996, pages 15 to 28 """ function BS5ConstantCache(T::Type{<:CompiledFloats}, T2::Type{<:CompiledFloats}) c1 = convert(T2, 0.16666666666666666) @@ -956,9 +955,8 @@ function BS5ConstantCache(T::Type{<:CompiledFloats}, T2::Type{<:CompiledFloats}) end """ - An Efficient Runge-Kutta (4,5) Pair by P.Bogacki and L.F.Shampine - Computers and Mathematics with Applications, Vol. 32, No. 6, 1996, pages 15 to 28 +Computers and Mathematics with Applications, Vol. 32, No. 6, 1996, pages 15 to 28 """ function BS5ConstantCache(T::Type, T2::Type) c1 = convert(T2, 1 // 6) @@ -1031,10 +1029,8 @@ function BS5ConstantCache(T::Type, T2::Type) end """ - An Efficient Runge-Kutta (4,5) Pair by P.Bogacki and L.F.Shampine - Computers and Mathematics with Applications, Vol. 32, No. 6, 1996, pages 15 to 28 - +Computers and Mathematics with Applications, Vol. 32, No. 6, 1996, pages 15 to 28 Used in the lazy construction of the dense output @@ -1078,10 +1074,8 @@ function BS5Interp(T::Type{<:CompiledFloats}, T2::Type{<:CompiledFloats}) end """ - An Efficient Runge-Kutta (4,5) Pair by P.Bogacki and L.F.Shampine - Computers and Mathematics with Applications, Vol. 32, No. 6, 1996, pages 15 to 28 - +Computers and Mathematics with Applications, Vol. 32, No. 6, 1996, pages 15 to 28 Used in the lazy construction of the dense output diff --git a/src/tableaus/verner_tableaus.jl b/src/tableaus/verner_tableaus.jl index 5316c8a68a..63ef03b18c 100644 --- a/src/tableaus/verner_tableaus.jl +++ b/src/tableaus/verner_tableaus.jl @@ -3262,7 +3262,7 @@ function Vern9InterpolationCoefficients(T) end """ -From Verner's Website +From Verner's Website """ struct Vern9Tableau{T, T2} c1::T2