Fix CI

Author: ErikQQY

lib/BoundaryValueDiffEqFIRK/src/firk.jl

@@ -719,7 +719,8 @@ end
     return nothing
 end
 
-@views function __firk_loss!(resid, u, p, y::AbstractVector, pt::TwoPointBVProblem, bc!::Tuple{BC1, BC2},
+@views function __firk_loss!(
+        resid, u, p, y::AbstractVector, pt::TwoPointBVProblem, bc!::Tuple{BC1, BC2},
         residual, mesh, cache, _, trait::DiffCacheNeeded) where {BC1, BC2}
     y_ = recursive_unflatten!(y, u)
     resids = [get_tmp(r, u) for r in residual]
@@ -752,8 +753,8 @@ end
     return vcat(resid_bc, mapreduce(vec, vcat, resid_co))
 end
 
-@views function __firk_loss(u, p, y::AbstractVector, pt::TwoPointBVProblem, bc::Tuple{BC1, BC2},
-        mesh, cache, _, trait) where {BC1, BC2}
+@views function __firk_loss(u, p, y::AbstractVector, pt::TwoPointBVProblem,
+        bc::Tuple{BC1, BC2}, mesh, cache, _, trait) where {BC1, BC2}
     y_ = recursive_unflatten!(y, u)
     soly_ = VectorOfArray(y_)
     resid_bca, resid_bcb = eval_bc_residual(pt, bc, y_, p, mesh)

lib/BoundaryValueDiffEqMIRK/src/adaptivity.jl

@@ -129,7 +129,7 @@ end
 
 @views function mesh_selector!(
         cache::MIRKCache{iip, T}, controller::SequentialErrorControl) where {iip, T}
-    (; order, errors, TU, mesh, mesh_dt) = cache
+    (; order, errors, mesh, mesh_dt) = cache
     (abstol, _, _), _ = __split_kwargs(; cache.kwargs...)
     N = length(mesh)
 
@@ -183,7 +183,7 @@ end
 
 @views function mesh_selector!(
         cache::MIRKCache{iip, T}, controller::HybridErrorControl) where {iip, T}
-    (; order, errors, TU, mesh, mesh_dt) = cache
+    (; order, errors, mesh, mesh_dt) = cache
     (abstol, _, _), _ = __split_kwargs(; cache.kwargs...)
     N = length(mesh)
 

lib/BoundaryValueDiffEqMIRK/src/collocation.jl

@@ -91,7 +91,7 @@ end
 @views function Φ(fᵢ_cache, k_discrete, f, TU::MIRKTableau, y, u, p,
         mesh, mesh_dt, stage::Int, ::NoDiffCacheNeeded)
     (; c, v, x, b) = TU
-    residuals = [__similar(yᵢ) for yᵢ in y[1:(end - 1)]]
+    residuals = [safe_similar(yᵢ) for yᵢ in y[1:(end - 1)]]
     tmp = similar(fᵢ_cache)
     T = eltype(u)
     for i in eachindex(k_discrete)

lib/BoundaryValueDiffEqMIRK/src/interpolation.jl

@@ -82,8 +82,8 @@ end
 end
 
 function sum_stages!(z::AbstractArray, id::MIRKInterpolation,
-        cache::MIRKCache{iip, T, use_both, DiffCacheNeeded}, w,
-        i::Int) where {iip, T, use_both}
+        cache::MIRKCache{iip, T, use_both, DiffCacheNeeded},
+        w, i::Int) where {iip, T, use_both}
     (; stage, k_discrete, k_interp) = cache
     (; s_star) = cache.ITU
     dt = cache.mesh_dt[i]
@@ -96,10 +96,11 @@ function sum_stages!(z::AbstractArray, id::MIRKInterpolation,
     return z
 end
 function sum_stages!(z::AbstractArray, id::MIRKInterpolation,
-        cache::MIRKCache{iip, T, use_both, NoDiffCacheNeeded}, w,
-        i::Int, dt = cache.mesh_dt[i]) where {iip, T, use_both}
+        cache::MIRKCache{iip, T, use_both, NoDiffCacheNeeded},
+        w, i::Int) where {iip, T, use_both}
     (; stage, k_discrete, k_interp) = cache
     (; s_star) = cache.ITU
+    dt = cache.mesh_dt[i]
     z .= zero(z)
     __maybe_matmul!(z, k_discrete[i][:, 1:stage], w[1:stage])
     __maybe_matmul!(
@@ -159,7 +160,7 @@ function (s::EvalSol{C})(tval::Number) where {C <: MIRKCache}
     (tval == t[end]) && return last(u)
     z = zero(last(u))
     ii = interval(t, tval)
-    dt = t[ii + 1] - t[ii]
+    dt = cache.mesh_dt[ii]
     τ = (tval - t[ii]) / dt
     w, _ = evalsol_interp_weights(τ, alg)
     K = __needs_diffcache(alg.jac_alg) ? k_discrete[ii].du[:, 1:stage] :

lib/BoundaryValueDiffEqMIRK/src/mirk.jl

@@ -103,10 +103,10 @@ function SciMLBase.__init(prob::BVProblem, alg::AbstractMIRK; dt = 0.0, abstol =
         vecf, vecbc
     end
 
-    prob_ = !(prob.u0 isa AbstractArray) ? remake(prob; u0 = X) : prob
+    #prob_ = !(prob.u0 isa AbstractArray) ? remake(prob; u0 = X) : prob
 
     return MIRKCache{iip, T, use_both, typeof(diffcache)}(
-        alg_order(alg), stage, N, size(X), f, bc, prob_, prob.problem_type,
+        alg_order(alg), stage, N, size(X), f, bc, prob, prob.problem_type,
         prob.p, alg, TU, ITU, bcresid_prototype, mesh, mesh_dt, k_discrete,
         k_interp, y, y₀, residual, fᵢ_cache, fᵢ₂_cache, errors, new_stages,
         resid₁_size, (; abstol, dt, adaptive, controller, kwargs...))
@@ -156,11 +156,11 @@ function SciMLBase.solve!(cache::MIRKCache)
 end
 
 function __perform_mirk_iteration(cache::MIRKCache, abstol, adaptive::Bool,
-        controller; nlsolve_kwargs = (;), kwargs...)
+        controller::AbstractErrorControl; nlsolve_kwargs = (;), kwargs...)
     nlprob = __construct_nlproblem(cache, vec(cache.y₀), copy(cache.y₀))
     nlsolve_alg = __concrete_nonlinearsolve_algorithm(nlprob, cache.alg.nlsolve)
     sol_nlprob = __solve(
-        nlprob, nlsolve_alg; abstol, kwargs..., nlsolve_kwargs..., alias_u0 = true)
+        nlprob, nlsolve_alg; abstol = abstol, kwargs..., nlsolve_kwargs..., alias_u0 = true)
     recursive_unflatten!(cache.y₀, sol_nlprob.u)
 
     error_norm = 2 * abstol
@@ -280,10 +280,9 @@ end
         residual, mesh, cache, _, trait::NoDiffCacheNeeded) where {BC1, BC2}
     y_ = recursive_unflatten!(y, u)
     Φ!(residual[2:end], cache, y_, u, trait)
-    soly_ = VectorOfArray(y_)
     resida = residual[1][1:prod(cache.resid_size[1])]
     residb = residual[1][(prod(cache.resid_size[1]) + 1):end]
-    eval_bc_residual!((resida, residb), pt, bc!, soly_, p, mesh)
+    eval_bc_residual!((resida, residb), pt, bc!, y_, p, mesh)
     recursive_flatten_twopoint!(resid, residual, cache.resid_size)
     return nothing
 end