Controller interface for v7

lib/ImplicitDiscreteSolve/src/ImplicitDiscreteSolve.jl

@@ -10,13 +10,7 @@ import OrdinaryDiffEqCore: OrdinaryDiffEqAlgorithm, alg_cache, OrdinaryDiffEqMut
     alg_order, beta2_default, beta1_default, dt_required,
     _initialize_dae!, DefaultInit, BrownFullBasicInit, OverrideInit,
     @muladd, @.., _unwrap_val, OrdinaryDiffEqCore, isadaptive,
-    AbstractController
-
-@static if Base.pkgversion(OrdinaryDiffEqCore) >= v"3.4"
-    @eval begin
-        import OrdinaryDiffEqCore: AbstractControllerCache
-    end
-end
+    AbstractController, AbstractControllerCache
 
 using Reexport
 @reexport using SciMLBase

lib/ImplicitDiscreteSolve/src/controller.jl

@@ -36,133 +36,73 @@ Base.@kwdef struct KantorovichTypeController{T} <: AbstractController
     strict::Bool = true
 end
 
-@static if Base.pkgversion(OrdinaryDiffEqCore) >= v"3.4"
-    @eval begin
-        mutable struct KantorovichTypeControllerCache{T} <: AbstractControllerCache
-            controller::KantorovichTypeController{T}
-            # Proposed scaling factor for the time step length
-            q::T
-        end
+struct KantorovichTypeControllerCache{T} <: AbstractControllerCache
+    controller::KantorovichTypeController{T}
+end
 
-        function OrdinaryDiffEqCore.default_controller_v7(
-                QT, alg::IDSolve,
-            )
-            return KantorovichTypeController{QT}(; Θmin = QT(1 // 8), p = 1)
-        end
+function OrdinaryDiffEqCore.default_controller(
+        QT, alg::IDSolve,
+    )
+    return KantorovichTypeController{QT}(; Θmin = QT(1 // 8), p = 1)
+end
 
-        function OrdinaryDiffEqCore.setup_controller_cache(alg, atmp, controller::KantorovichTypeController{T}) where {T}
-            return KantorovichTypeControllerCache(
-                controller,
-                T(1),
-            )
-        end
+function OrdinaryDiffEqCore.setup_controller_cache(alg, cache, controller::KantorovichTypeController{T}) where {T}
+    return KantorovichTypeControllerCache(
+        controller,
+    )
+end
 
-        function OrdinaryDiffEqCore.stepsize_controller!(
-                integrator, cache::KantorovichTypeControllerCache, alg::IDSolve
-            )
-            (; controller) = cache
-            @inline g(x) = √(1 + 4x) - 1
+function OrdinaryDiffEqCore.stepsize_controller!(
+        integrator, cache::KantorovichTypeControllerCache, alg::IDSolve
+    )
+    (; controller) = cache
+    @inline g(x) = √(1 + 4x) - 1
 
-            # Adapt dt with a priori estimate (Eq. 5.24)
-            (; Θks) = integrator.cache
-            (; Θbar, γ, Θmin, qmin, qmax, p) = controller
+    # Adapt dt with a priori estimate (Eq. 5.24)
+    (; Θks) = integrator.cache
+    (; Θbar, γ, Θmin, qmin, qmax, p) = controller
 
-            Θ₀ = length(Θks) > 0 ? max(first(Θks), Θmin) : Θmin
-            cache.q = clamp(γ * (g(Θbar) / (g(Θ₀)))^(1 / p), qmin, qmax)
+    Θ₀ = length(Θks) > 0 ? max(first(Θks), Θmin) : Θmin
+    q = clamp(γ * (g(Θbar) / (g(Θ₀)))^(1 / p), qmin, qmax)
 
-            return cache.q
-        end
+    return q
+end
 
-        function OrdinaryDiffEqCore.step_accept_controller!(
-                integrator, cache::KantorovichTypeControllerCache, alg::IDSolve, q
-            )
-            @assert q ≈ cache.q "Controller cache went out of sync with time stepping logic."
-            return cache.q * integrator.dt
-        end
+function OrdinaryDiffEqCore.step_accept_controller!(
+        integrator, cache::KantorovichTypeControllerCache, alg::IDSolve, q
+    )
+    return q * integrator.dt
+end
 
-        function OrdinaryDiffEqCore.step_reject_controller!(
-                integrator, cache::KantorovichTypeControllerCache, alg::IDSolve
-            )
-            (; controller) = cache
-            @inline g(x) = √(1 + 4x) - 1
-
-            # Shorten dt according to (Eq. 5.24)
-            (; Θks) = integrator.cache
-            (; Θbar, Θreject, γ, Θmin, qmin, qmax, p) = controller
-            for Θk in Θks
-                if Θk > Θreject
-                    q = clamp(γ * (g(Θbar) / g(Θk))^(1 / p), qmin, qmax)
-                    integrator.dt = q * integrator.dt
-                    return
-                end
-            end
+function OrdinaryDiffEqCore.step_reject_controller!(
+        integrator, cache::KantorovichTypeControllerCache, alg::IDSolve
+    )
+    (; controller) = cache
+    @inline g(x) = √(1 + 4x) - 1
+
+    # Shorten dt according to (Eq. 5.24)
+    (; Θks) = integrator.cache
+    (; Θbar, Θreject, γ, Θmin, qmin, qmax, p) = controller
+    for Θk in Θks
+        if Θk > Θreject
+            q = clamp(γ * (g(Θbar) / g(Θk))^(1 / p), qmin, qmax)
+            integrator.dt = q * integrator.dt
             return
         end
-
-        function OrdinaryDiffEqCore.accept_step_controller(integrator, cache::KantorovichTypeControllerCache)
-            (; controller) = cache
-            (; Θks) = integrator.cache
-            if controller.strict
-                return all(controller.Θreject .< Θks)
-            else
-                return true
-            end
-        end
     end
-else
-    @eval begin
-        function OrdinaryDiffEqCore.default_controller(
-                alg::IDSolve, cache::IDSolveCache, _1, _2, _3
-            )
-            return KantorovichTypeController(; Θmin = float(1 // 8), p = 1)
-        end
-
-        function OrdinaryDiffEqCore.stepsize_controller!(
-                integrator, controller::KantorovichTypeController, alg::IDSolve
-            )
-            @inline g(x) = √(1 + 4x) - 1
-
-            # Adapt dt with a priori estimate (Eq. 5.24)
-            (; Θks) = integrator.cache
-            (; Θbar, γ, Θmin, qmin, qmax, p) = controller
-
-            Θ₀ = length(Θks) > 0 ? max(first(Θks), Θmin) : Θmin
-            q = clamp(γ * (g(Θbar) / (g(Θ₀)))^(1 / p), qmin, qmax)
-
-            return q
-        end
-
-        function OrdinaryDiffEqCore.step_accept_controller!(
-                integrator, controller::KantorovichTypeController, alg::IDSolve, q
-            )
-            return q * integrator.dt
-        end
-
-        function OrdinaryDiffEqCore.step_reject_controller!(
-                integrator, controller::KantorovichTypeController, alg::IDSolve
-            )
-            @inline g(x) = √(1 + 4x) - 1
-
-            # Shorten dt according to (Eq. 5.24)
-            (; Θks) = integrator.cache
-            (; Θbar, Θreject, γ, Θmin, qmin, qmax, p) = controller
-            for Θk in Θks
-                if Θk > Θreject
-                    q = clamp(γ * (g(Θbar) / g(Θk))^(1 / p), qmin, qmax)
-                    integrator.dt = q * integrator.dt
-                    return
-                end
-            end
-            return
-        end
+    return
+end
 
-        function OrdinaryDiffEqCore.accept_step_controller(integrator, controller::KantorovichTypeController)
-            (; Θks) = integrator.cache
-            if controller.strict
-                return all(controller.Θreject .< Θks)
-            else
-                return true
-            end
-        end
+function OrdinaryDiffEqCore.accept_step_controller(integrator, cache::KantorovichTypeControllerCache, alg)
+    (; controller) = cache
+    (; Θks) = integrator.cache
+    if controller.strict
+        return all(controller.Θreject .< Θks)
+    else
+        return true
     end
 end
+
+function OrdinaryDiffEqCore.sync_controllers!(cache1::KantorovichTypeControllerCache, cache2::KantorovichTypeControllerCache)
+    return nothing
+end

lib/OrdinaryDiffEqBDF/src/OrdinaryDiffEqBDF.jl

@@ -3,7 +3,7 @@ module OrdinaryDiffEqBDF
 import OrdinaryDiffEqCore: alg_order, calculate_residuals!,
     initialize!, perform_step!, unwrap_alg,
     calculate_residuals, alg_extrapolates,
-    OrdinaryDiffEqAlgorithm,
+    OrdinaryDiffEqAlgorithm, isstandard,
     OrdinaryDiffEqMutableCache, OrdinaryDiffEqConstantCache,
     OrdinaryDiffEqNewtonAdaptiveAlgorithm,
     OrdinaryDiffEqNewtonAlgorithm,
@@ -35,17 +35,7 @@ using LinearAlgebra: mul!, I
 import ArrayInterface
 using ArrayInterface: ismutable
 import OrdinaryDiffEqCore
-
-@static if Base.pkgversion(OrdinaryDiffEqCore) >= v"3.4"
-    @eval begin
-        import OrdinaryDiffEqCore: default_controller_v7,
-            legacy_default_controller
-    end
-else
-    @eval begin
-        import OrdinaryDiffEqCore: default_controller
-    end
-end
+import OrdinaryDiffEqCore: default_controller
 
 @static if Base.pkgversion(OrdinaryDiffEqCore) >= v"3.10"
     @eval begin

lib/OrdinaryDiffEqBDF/src/alg_utils.jl

@@ -31,6 +31,12 @@ isadaptive(alg::DFBDF) = true
 
 has_special_newton_error(alg::QNDF) = true
 
+isstandard(::DImplicitEuler) = true
+isstandard(::ABDF2) = true
+isstandard(::QNDF1) = true
+isstandard(::QNDF2) = true
+isstandard(::DABDF2) = true
+
 alg_extrapolates(alg::DImplicitEuler) = true
 alg_extrapolates(alg::DABDF2) = true