Step 1: Make sure atmp is present when it should be.

Author: termi-official

lib/OrdinaryDiffEqCore/src/integrators/controllers.jl

@@ -4,7 +4,7 @@ abstract type AbstractLegacyController <: AbstractController end
 abstract type AbstractControllerCache end
 
 """
-    setup_controller_cache(alg, controller::AbstractController)::AbstractControllerCache
+    setup_controller_cache(alg, atmp, controller::AbstractController)::AbstractControllerCache
 
 This function takes a controller together with the time stepping algorithm to
 construct and initialize the respective cache for the controller.
@@ -55,7 +55,7 @@ step_reject_controller!
 
 
 # The legacy controllers do not have this concept.
-setup_controller_cache(alg, controller::AbstractLegacyController) = controller
+setup_controller_cache(alg, atmp, controller::AbstractLegacyController) = controller
 
 # checks whether the controller should accept a step based on the error estimate
 @inline function accept_step_controller(integrator, controller_or_cache::Union{<:AbstractLegacyController, <:AbstractControllerCache})
@@ -99,7 +99,7 @@ end
 struct DummyController <: AbstractController
 end
 
-setup_controller_cache(alg, controller::DummyController) = controller
+setup_controller_cache(alg, atmp, controller::DummyController) = controller
 
 @inline function accept_step_controller(integrator, controller::DummyController)
     return integrator.EEst <= 1
@@ -191,19 +191,21 @@ function NewIController(QT, alg; qmin = nothing, qmax = nothing, gamma = nothing
     )
 end
 
-mutable struct IControllerCache{C, T} <: AbstractControllerCache
+mutable struct IControllerCache{C, T, UT} <: AbstractControllerCache
     controller::C
     q::T
     dtreject::T
     # I believe this should go here or in the algorithm cache, but not in the integrator itself.
     # EEst::T
+    atmp::UT
 end
 
-function setup_controller_cache(alg, controller::NewIController{T}) where T
+function setup_controller_cache(alg, atmp, controller::NewIController{T}) where T
     IControllerCache(
         controller,
         T(1),
         T(1 // 10^4), # TODO which value?
+        atmp,
     )
 end
 
@@ -356,23 +358,24 @@ function NewPIController(QT, alg; beta1 = nothing, beta2 = nothing, qmin = nothi
     )
 end
 
-mutable struct PIControllerCache{T} <: AbstractControllerCache
+mutable struct PIControllerCache{T, UT} <: AbstractControllerCache
     controller::NewPIController{T}
     # Propsoed scaling factor for the time step length
     q::T
     # Cached εₙ₊₁^β₁
     q11::T
     # Previous EEst
     errold::T
+    atmp::UT
 end
 
-
-function setup_controller_cache(alg, controller::NewPIController{T}) where T
+function setup_controller_cache(alg, atmp, controller::NewPIController{T}) where T
     PIControllerCache(
         controller,
         T(1),
         T(1),
         T(1 // 10^4),
+        atmp,
     )
 end
 
@@ -612,18 +615,20 @@ function Base.show(io::IO, controller::NewPIDController)
         ")")
 end
 
-mutable struct PIDControllerCache{T, Limiter} <: AbstractControllerCache
+mutable struct PIDControllerCache{T, Limiter, UT} <: AbstractControllerCache
     controller::NewPIDController{T, Limiter}
     err::MVector{3, T} # history of the error estimates
     dt_factor::T
+    atmp::UT
 end
 
-function setup_controller_cache(alg, controller::NewPIDController{QT}) where QT
+function setup_controller_cache(alg, atmp, controller::NewPIDController{QT}) where QT
     err = MVector{3, QT}(true, true, true)
     PIDControllerCache(
         controller,
         err,
         QT(1 // 10^4),
+        atmp,
     )
 end
 
@@ -829,21 +834,23 @@ function NewPredictiveController(QT, alg; qmin = nothing, qmax = nothing, gamma
     )
 end
 
-mutable struct PredictiveControllerCache{T} <: AbstractControllerCache
+mutable struct PredictiveControllerCache{T, UT} <: AbstractControllerCache
     controller::NewPredictiveController{T}
     dtacc::T
     erracc::T
     qold::T
     q::T
+    atmp::UT
 end
 
-function setup_controller_cache(alg, controller::NewPredictiveController{T}) where T
+function setup_controller_cache(alg, atmp, controller::NewPredictiveController{T}) where T
     PredictiveControllerCache{T}(
         controller,
         T(1),
         T(1),
         T(1),
-        T(1)
+        T(1),
+        atmp,
     )
 end
 
@@ -909,13 +916,15 @@ struct CompositeController{T} <: AbstractController
     controllers::T
 end
 
-struct CompositeControllerCache{T} <: AbstractControllerCache
+struct CompositeControllerCache{T, UT} <: AbstractControllerCache
     caches::T
+    atmp::UT # This is just here for easy access
 end
 
-function setup_controller_cache(alg::CompositeAlgorithm, cc::CompositeController)
+function setup_controller_cache(alg::CompositeAlgorithm, atmp, cc::CompositeController)
     CompositeControllerCache(
-        map((alg, controller)->setup_controller_cache(alg, controller), alg.algs, cc.controllers)
+        map((alg, controller)->setup_controller_cache(alg, atmp, controller), alg.algs, cc.controllers),
+        atmp,
     )
 end
 

lib/OrdinaryDiffEqCore/src/solve.jl

@@ -463,7 +463,13 @@ function SciMLBase.__init(
         qoldinit = hasfield(typeof(controller), :qoldinit) ? controller.qoldinit : (anyadaptive(alg) ? 1 // 10^4 : 0)
     end
 
-    controller_cache = setup_controller_cache(_alg, controller)
+
+    atmp = if hasfield(typeof(cache), :atmp)
+            cache.atmp
+        else
+            nothing
+        end
+    controller_cache = setup_controller_cache(_alg, atmp, controller)
 
     save_end_user = save_end
     save_end = save_end === nothing ?

lib/OrdinaryDiffEqExtrapolation/src/controllers.jl

@@ -21,17 +21,19 @@ function NewExtrapolationController(QT, alg; qmin = nothing, qmax = nothing, gam
     )
 end
 
-mutable struct ExtrapolationControllerCache{QT} <: AbstractControllerCache
+mutable struct ExtrapolationControllerCache{QT, UT} <: AbstractControllerCache
     controller::NewExtrapolationController{QT}
     beta1::QT
     gamma::QT
+    atmp::UT
 end
 
-function setup_controller_cache(alg, controller::NewExtrapolationController{T}) where T
-    ExtrapolationControllerCache{T}(
+function setup_controller_cache(alg, atmp, controller::NewExtrapolationController{T}) where T
+    ExtrapolationControllerCache(
         controller,
         T(1),
-        T(1)
+        T(1),
+        atmp,
     )
 end
 

lib/OrdinaryDiffEqExtrapolation/src/extrapolation_caches.jl

@@ -124,7 +124,6 @@ end
     n_curr::Int # Storage for the current extrapolation order
     n_old::Int # Storage for the extrapolation order n_curr before perform_step! changes the latter
     sigma::Rational{Int} # Parameter for order selection
-    res::uNoUnitsType # Storage for the scaled residual of u and utilde
 
     #Stepsizing caches
     work::Array{QType, 1}
@@ -285,7 +284,6 @@ function alg_cache(alg::ImplicitEulerExtrapolation, u, rate_prototype,
         #Pr = Diagonal(_vec(weight)))
     end
 
-    res = uEltypeNoUnits.(zero(u))
     grad_config = build_grad_config(alg, f, tf, du1, t)
     jac_config = build_jac_config(alg, f, uf, du1, uprev, u, du1, du2)
     sequence = generate_sequence(constvalue(uBottomEltypeNoUnits), alg)
@@ -301,7 +299,7 @@ function alg_cache(alg::ImplicitEulerExtrapolation, u, rate_prototype,
         dtpropose, T, A, step_no,
         du1, du2, J, W, tf, uf, linsolve_tmps, linsolve,
         jac_config, grad_config, sequence, cc.stage_number,
-        cc.Q, cc.n_curr, cc.n_old, cc.sigma, res, cc.work,
+        cc.Q, cc.n_curr, cc.n_old, cc.sigma, cc.work,
         cc.dt_new, diff1, diff2)
 end
 
@@ -942,7 +940,7 @@ end
     u_temp4::Array{uType, 1}
     tmp::uType # for get_tmp_cache()
     T::Array{uType, 1}  # Storage for the internal discretisations obtained by the explicit midpoint rule
-    res::uNoUnitsType # Storage for the scaled residual of u and utilde
+    atmp::uNoUnitsType # Storage for the scaled residual of u and utilde
 
     fsalfirst::rateType
     k::rateType
@@ -1026,7 +1024,7 @@ end
     u_temp4::Array{uType, 1}
     tmp::uType # for get_tmp_cache()
     T::Array{uType, 1}  # Storage for the internal discretisations obtained by the explicit midpoint rule
-    res::uNoUnitsType # Storage for the scaled residual of u and utilde
+    atmp::uNoUnitsType # Storage for the scaled residual of u and utilde
 
     fsalfirst::rateType
     k::rateType
@@ -1251,7 +1249,7 @@ end
     u_temp4::Array{uType, 1}
     tmp::uType # for get_tmp_cache()
     T::Array{uType, 1}  # Storage for the internal discretisations obtained by the explicit midpoint rule
-    res::uNoUnitsType # Storage for the scaled residual of u and utilde
+    atmp::uNoUnitsType # Storage for the scaled residual of u and utilde
 
     fsalfirst::rateType
     k::rateType
@@ -1394,7 +1392,7 @@ end
     u_temp4::Array{uType, 1}
     tmp::uType # for get_tmp_cache()
     T::Array{uType, 1}  # Storage for the internal discretisations obtained by the explicit midpoint rule
-    res::uNoUnitsType # Storage for the scaled residual of u and utilde
+    atmp::uNoUnitsType # Storage for the scaled residual of u and utilde
 
     fsalfirst::rateType
     k::rateType
@@ -1593,7 +1591,7 @@ end
     u_temp4::Array{uType, 1}
     tmp::uType # for get_tmp_cache()
     T::Array{uType, 1}  # Storage for the internal discretisations obtained by the explicit midpoint rule
-    res::uNoUnitsType # Storage for the scaled residual of u and utilde
+    atmp::uNoUnitsType # Storage for the scaled residual of u and utilde
 
     fsalfirst::rateType
     k::rateType