Disable J reuse for CompositeAlgorithm; lower max_jac_age to 20

CompositeAlgorithm (AutoTsit5/Rosenbrock23, AutoVern8/Rosenbrock23, etc.)
already computes a fresh Jacobian every step via do_newJW because rapid
stiff↔nonstiff transitions make reuse counterproductive. The reuse logic
was overriding this, causing excessive step rejections that exhausted the
maxiters budget on the stiffness_detection_test.

Also lower default max_jac_age from 50 to 20 accepted steps for more
conservative reuse that better handles problems with rapidly changing
Jacobians.

Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ChrisRackauckas

lib/OrdinaryDiffEqDifferentiation/src/derivative_utils.jl

@@ -17,15 +17,16 @@ CVODE-inspired Jacobian reuse:
 - Always recompute on first iteration
 - Recompute after step rejection (EEst > 1), since the old J wasn't good enough
 - Recompute when gamma ratio changes too much: |dtgamma/last_dtgamma - 1| > 0.3
-- Recompute every `max_jac_age` accepted steps (default 50)
+- Recompute every `max_jac_age` accepted steps (default 20)
 - Recompute when u_modified (callback modification)
 - Otherwise reuse J but rebuild W from the cached J and current dtgamma.
   The Jacobian evaluation (finite-diff / AD) is the expensive part; W
   construction and LU factorization are comparatively cheap.
 
 Returns `nothing` (delegate to `do_newJW`) for strict Rosenbrock methods,
-linear problems, and mass-matrix (DAE) problems where stale Jacobians
-cause order reduction.
+linear problems, mass-matrix (DAE) problems where stale Jacobians cause
+order reduction, and CompositeAlgorithm where rapid stiff↔nonstiff
+transitions make reuse counterproductive.
 """
 function _rosenbrock_jac_reuse_decision(integrator, cache, dtgamma)
     alg = OrdinaryDiffEqCore.unwrap_alg(integrator, true)
@@ -55,6 +56,14 @@ function _rosenbrock_jac_reuse_decision(integrator, cache, dtgamma)
         return nothing
     end
 
+    # CompositeAlgorithm: delegate to do_newJW, which always recomputes J
+    # for Rosenbrock methods in composite context (the Jacobian may be stale
+    # from a different algorithm, and rapid stiff↔nonstiff transitions make
+    # reuse counterproductive due to increased step rejections).
+    if integrator.alg isa CompositeAlgorithm
+        return nothing
+    end
+
     # First iteration: always compute J and W.
     if integrator.iter <= 1
         return (true, true)

lib/OrdinaryDiffEqRosenbrock/src/rosenbrock_caches.jl

@@ -12,7 +12,7 @@ Jacobian recomputations when conditions allow it.
 Fields:
 - `last_dtgamma`: The dtgamma value from the last Jacobian computation
 - `steps_since_jac`: Number of accepted steps since last Jacobian update
-- `max_jac_age`: Maximum number of accepted steps between Jacobian updates (default 50)
+- `max_jac_age`: Maximum number of accepted steps between Jacobian updates (default 20)
 - `cached_J`: Cached Jacobian for OOP reuse (type-erased for flexibility)
 - `cached_dT`: Cached time derivative for OOP reuse
 - `cached_W`: Cached factorized W for OOP reuse (LU factorization is expensive)
@@ -32,7 +32,7 @@ mutable struct JacReuseState{T}
 end
 
 function JacReuseState(dtgamma::T) where {T}
-    return JacReuseState{T}(dtgamma, dtgamma, 0, 50, nothing, nothing, nothing, 0, 0)
+    return JacReuseState{T}(dtgamma, dtgamma, 0, 20, nothing, nothing, nothing, 0, 0)
 end
 
 # Fake values since non-FSAL

lib/OrdinaryDiffEqRosenbrock/test/jacobian_reuse_test.jl

@@ -120,7 +120,7 @@ strict_rosenbrock = [
         @test jr.last_dtgamma == 0.0
         @test jr.pending_dtgamma == 0.0
         @test jr.last_naccept == 0
-        @test jr.max_jac_age == 50
+        @test jr.max_jac_age == 20
         @test jr.cached_J === nothing
         @test jr.cached_dT === nothing
         @test jr.cached_W === nothing