Add get_qmin to the controller interface

`qmin` (alongside `qmax`, `gamma`, `beta1/beta2`, `qsteady_*`,
`qoldinit`) moved off `DEOptions` and onto the controller object in v7.
The out-of-domain rejection path in `handle_step_rejection!` was still
reaching for the old `integrator.opts.qmin`, which throws on the v7
`DEOptions` struct — only the legacy DelayDiffEq constructor still
mentions it.

Surface this through the controller interface rather than a one-off
`hasfield` walk: a new `get_qmin(integrator)` (with implementations
dispatched on each concrete controller cache) returns the minimum
step-size shrinkage factor used by the integrator's controller.
`handle_step_rejection!` calls it instead of `integrator.opts.qmin`.

Per-cache implementations:

- `IControllerCache`, `PIControllerCache`, `PredictiveControllerCache`
  return their controller's `qmin` field.
- `PIDControllerCache` has no `qmin` (it limits dt via `limiter` +
  `accept_safety` instead) and returns the historical default `1 // 5`
  so the out-of-domain shrink path still has something to multiply by.
- `DummyControllerCache` (BDF / Nordsieck — algorithms that own the
  step-size logic) reads `integrator.alg.qmin` if present, else falls
  back to the historical default.
- `CompositeControllerCache` delegates to the currently active
  sub-cache, mirroring how `stepsize_controller!` and friends dispatch.

Refresh the `PredictiveController` docstring (which still showed the
old `integrator.opts.qmin/qmax/qsteady_*/gamma` interface) to match the
actual v7 implementation that destructures from `cache.controller`,
and update two stale `# equivalent to integrator.opts.gamma` comments
in `lib/OrdinaryDiffEqBDF/src/controllers.jl`.

Reported in
NumericalMathematics/PositiveIntegrators.jl#194 (comment)

Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Author: ChrisRackauckas

lib/OrdinaryDiffEqBDF/src/controllers.jl

@@ -26,7 +26,7 @@ function step_accept_controller!(integrator, cache::Union{QNDFCache, QNDFConstan
         h = integrator.dt
         k = cache.order
         prefer_const_step = cache.nconsteps < cache.order + 2
-        zₛ = 1.2 # equivalent to integrator.opts.gamma
+        zₛ = 1.2 # equivalent to controller `gamma`
         zᵤ = 0.1
         Fᵤ = 10
         expo = 1 / (k + 1)
@@ -100,7 +100,7 @@ function bdf_step_reject_controller!(integrator, cache, EEst1)
     if cache.consfailcnt > 1
         h = h / 2
     end
-    zₛ = 1.2  # equivalent to integrator.opts.gamma
+    zₛ = 1.2  # equivalent to controller `gamma`
     expo = 1 / (k + 1)
     z = zₛ * ((OrdinaryDiffEqCore.get_EEst(integrator))^expo)
     F = inv(z)

lib/OrdinaryDiffEqCore/src/integrators/controllers.jl

@@ -157,6 +157,35 @@ See also: https://github.com/SciML/DifferentialEquations.jl/issues/299
     return qmax
 end
 
+"""
+    get_qmin(integrator)
+    get_qmin(integrator, controller_cache)
+
+Return the minimum step-size shrinkage factor `qmin` for the integrator's
+controller. Used by the out-of-domain rejection path in
+`handle_step_rejection!` to retry with a smaller step after the
+`isoutofdomain` predicate fires.
+
+Each concrete `AbstractControllerCache` implements its own
+`get_qmin(integrator, cache)` method:
+
+- `IController`, `PIController`, `PredictiveController` return their
+  `qmin` field.
+- `PIDController` has no `qmin` (it uses `limiter` + `accept_safety`
+  instead) and returns the historical default `1 // 5` so the
+  out-of-domain path still has something to shrink by.
+- `DummyController` (BDF / Nordsieck — algorithms that own the
+  step-size logic) reads `integrator.alg.qmin` if present, else falls
+  back to the historical default.
+- `CompositeController` delegates to the currently active sub-cache.
+"""
+@inline get_qmin(integrator::SciMLBase.DEIntegrator) =
+    get_qmin(integrator, integrator.controller_cache)
+
+# Default fallback for any AbstractControllerCache that hasn't overridden
+# this — used by the historical step-size shrink behavior.
+@inline get_qmin(integrator, ::AbstractControllerCache) = 1 // 5
+
 reset_alg_dependent_opts!(controller::AbstractControllerCache, alg1, alg2) = nothing
 
 reinit_controller!(integrator::SciMLBase.DEIntegrator, controller::AbstractControllerCache) = nothing
@@ -210,6 +239,10 @@ end
     post_newton_controller!(integrator, alg)
 @inline accept_step_controller(integrator, cache::DummyControllerCache, alg) =
     get_EEst(cache) <= 1
+# BDF / Nordsieck-style algorithms with integrated controllers store the
+# step-size knobs on the algorithm itself.
+@inline get_qmin(integrator, ::DummyControllerCache) =
+    hasfield(typeof(integrator.alg), :qmin) ? integrator.alg.qmin : 1 // 5
 
 
 # Standard integral (I) step size controller
@@ -323,6 +356,8 @@ function step_reject_controller!(integrator, cache::IControllerCache, alg)
     return integrator.dt = cache.dtreject
 end
 
+@inline get_qmin(integrator, cache::IControllerCache) = cache.controller.qmin
+
 reinit_controller!(integrator::SciMLBase.DEIntegrator, cache::IControllerCache) = nothing
 
 function sync_controllers!(cache1::IControllerCache, cache2::IControllerCache)
@@ -468,6 +503,8 @@ function step_reject_controller!(integrator, cache::PIControllerCache, alg)
     return integrator.dt /= min(inv(qmin), q11 / gamma)
 end
 
+@inline get_qmin(integrator, cache::PIControllerCache) = cache.controller.qmin
+
 function reinit_controller!(integrator::SciMLBase.DEIntegrator, cache::PIControllerCache{T}) where {T}
     cache.q11 = one(T)
     return cache.errold = T(cache.controller.qoldinit)
@@ -686,6 +723,10 @@ function step_reject_controller!(integrator, cache::PIDControllerCache, alg)
     return integrator.dt *= cache.dt_factor
 end
 
+# PIDController has no `qmin`; it limits dt via `limiter` + `accept_safety`.
+# Fall back to the historical default for the out-of-domain rejection path.
+@inline get_qmin(integrator, ::PIDControllerCache) = 1 // 5
+
 function sync_controllers!(cache1::PIDControllerCache, cache2::PIDControllerCache)
     cache1.err = cache2.err
     cache1.dt_factor = cache2.dt_factor
@@ -702,38 +743,42 @@ well-suited for stiff solvers where this can be expected, and is the default
 for algorithms like the (E)SDIRK methods.
 
 ```julia
-gamma = integrator.opts.gamma
-niters = integrator.cache.newton_iters
+(; qmin, qmax, gamma) = controller
+qmax = get_current_qmax(integrator, qmax)
+niters = integrator.cache.nlsolver.iter
 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 = (get_EEst(integrator)^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)
-end
-integrator.controller_cache.qold = q
+    (1 + 2 * integrator.cache.nlsolver.maxiters) * gamma /
+    (niters + 2 * integrator.cache.nlsolver.maxiters))
+expo = 1 / (get_current_adaptive_order(alg, integrator.cache) + 1)
+qtmp = fastpower(get_EEst(integrator), expo) / fac
+@fastmath q = max(inv(qmax), min(inv(qmin), qtmp))
+cache.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:
+where `controller` and `cache` are the controller and its cache stored in
+`integrator.controller_cache`. `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
+(; dtacc, erracc) = cache
+(; qmin, qmax, gamma, qsteady_min, qsteady_max) = controller
+qmax = get_current_qmax(integrator, qmax)
 if integrator.success_iter > 0
-    expo = 1 / (alg_adaptive_order(integrator.alg) + 1)
-    qgus = (integrator.dtacc / integrator.dt) * (((get_EEst(integrator)^2) / integrator.erracc)^expo)
-    qgus = max(inv(integrator.opts.qmax),
-        min(inv(integrator.opts.qmin), qgus / integrator.opts.gamma))
+    expo = 1 / (get_current_adaptive_order(alg, integrator.cache) + 1)
+    qgus = (dtacc / integrator.dt) * fastpower((get_EEst(integrator)^2) / erracc, expo)
+    qgus = max(inv(qmax), min(inv(qmin), qgus / gamma))
     qacc = max(q, qgus)
 else
     qacc = q
 end
-integrator.dtacc = integrator.dt
-integrator.erracc = max(1e-2, get_EEst(integrator))
+if qsteady_min <= qacc <= qsteady_max
+    qacc = one(qacc)
+end
+cache.dtacc = integrator.dt
+cache.erracc = max(1e-2, get_EEst(integrator))
 integrator.dt / qacc
 ```
 
@@ -743,7 +788,7 @@ When it rejects, it's the same as the [`IController`](@ref):
 if integrator.success_iter == 0
     integrator.dt *= 0.1
 else
-    integrator.dt = integrator.dt / integrator.controller_cache.qold
+    integrator.dt = integrator.dt / cache.qold
 end
 ```
 """
@@ -871,6 +916,8 @@ function step_reject_controller!(integrator, cache::PredictiveControllerCache, a
     return integrator.dt = success_iter == 0 ? 0.1 * dt : dt / qold
 end
 
+@inline get_qmin(integrator, cache::PredictiveControllerCache) = cache.controller.qmin
+
 # For a composite algorithm the default strategy is to switch forth and back between the controllers of the individual algorithms
 struct CompositeController{T} <: AbstractController
     controllers::T
@@ -931,6 +978,11 @@ end
     return post_newton_controller!(integrator, @inbounds(cache.caches[current_idx]), alg)
 end
 
+@inline function get_qmin(integrator, cache::CompositeControllerCache)
+    current_idx = integrator.cache.current
+    return get_qmin(integrator, @inbounds(cache.caches[current_idx]))
+end
+
 function setup_controller_cache(alg::CompositeAlgorithm, caches::DefaultCache, controller::CompositeController, ::Type{E}) where {E}
     sub = (
         setup_controller_cache(alg.algs[1], caches, controller.controllers[1], E),

lib/OrdinaryDiffEqCore/src/integrators/integrator_utils.jl

@@ -68,7 +68,7 @@ function handle_step_rejection!(integrator)
         integrator.opts.verbose, :step_rejected
     )
     if integrator.isout
-        integrator.dt = integrator.dt * integrator.opts.qmin
+        integrator.dt = integrator.dt * get_qmin(integrator)
     elseif !integrator.force_stepfail
         step_reject_controller!(integrator, integrator.alg)
     end