update to use updated codegen

Author: vyudu

src/systems/diffeqs/abstractodesystem.jl

@@ -881,18 +881,23 @@ function SciMLBase.BVProblem{iip, specialize}(sys::AbstractODESystem, u0map = []
     stidxmap = Dict([v => i for (i, v) in enumerate(sts)])
     u0_idxs = has_alg_eqs(sys) ? collect(1:length(sts)) : [stidxmap[k] for (k,v) in u0map]
 
-    bc = generate_function_bc(sys, u0, u0_idxs, tspan, iip)
+    fns = generate_function_bc(sys, u0, u0_idxs, tspan)
+    bc_oop, bc_iip = eval_or_rgf.(fns; eval_expression, eval_module) 
+    # bc(sol, p, t) = bc_oop(sol, p, t)
+    bc(resid, u, p, t) = bc_iip(resid, u, p, t)
+
     return BVProblem{iip}(f, bc, u0, tspan, p; kwargs...)
 end
 
 get_callback(prob::BVProblem) = error("BVP solvers do not support callbacks.")
 
 """
-    generate_function_bc(sys::ODESystem, u0, u0_idxs, tspan, iip)
+    generate_function_bc(sys::ODESystem, u0, u0_idxs, tspan)
 
     Given an ODESystem with constraints, generate the boundary condition function to pass to boundary value problem solvers.
+    Expression uses the constraints and the provided initial conditions.
 """
-function generate_function_bc(sys::ODESystem, u0, u0_idxs, tspan, iip)
+function generate_function_bc(sys::ODESystem, u0, u0_idxs, tspan; kwargs...)
     iv = get_iv(sys)
     sts = get_unknowns(sys)
     ps = get_ps(sys)
@@ -915,19 +920,6 @@ function generate_function_bc(sys::ODESystem, u0, u0_idxs, tspan, iip)
 
             cons = map(c -> Symbolics.substitute(c, Dict(x(t) => sol(t)[idx])), cons)
         end
-
-        for var in parameters(conssys) 
-            if iscall(var)
-                x = operation(var)
-                t = only(arguments(var))
-                idx = pidxmap[x]
-
-                cons = map(c -> Symbolics.substitute(c, Dict(x(t) => p[idx])), cons)
-            else
-                idx = pidxmap[var]
-                cons = map(c -> Symbolics.substitute(c, Dict(var => p[idx])), cons)
-            end
-        end
     end
 
     init_conds = Any[]
@@ -937,12 +929,9 @@ function generate_function_bc(sys::ODESystem, u0, u0_idxs, tspan, iip)
     end
 
     exprs = vcat(init_conds, cons)
-    bcs = Symbolics.build_function(exprs, sol, p, expression = Val{false})
-    if iip
-        return (resid, u, p, t) -> bcs[2](resid, u, p)
-    else
-        return (u, p, t) -> bcs[1](u, p)
-    end
+    _p = reorder_parameters(sys, ps)
+
+    build_function_wrapper(sys, exprs, sol, _p..., t; kwargs...)
 end
 
 """

test/bvproblem.jl

@@ -1,6 +1,7 @@
 ### TODO: update when BoundaryValueDiffEqAscher is updated to use the normal boundary condition conventions 
 
-using BoundaryValueDiffEq, OrdinaryDiffEq, BoundaryValueDiffEqAscher
+using OrdinaryDiffEqVerner
+using BoundaryValueDiffEqMIRK, BoundaryValueDiffEqAscher
 using BenchmarkTools
 using ModelingToolkit
 using SciMLBase
@@ -207,22 +208,22 @@ let
 
     u0map = []
     tspan = (0.0, 1.0)
-    guesses = [x(t) => 4.0, y(t) => 2.]
+    guess = [x(t) => 4.0, y(t) => 2.0]
     constr = [x(.6) ~ 3.5, x(.3) ~ 7.]
     @mtkbuild lksys = ODESystem(eqs, t; constraints = constr)
 
-    bvp = SciMLBase.BVProblem{true, SciMLBase.AutoSpecialize}(lksys, u0map, tspan; guesses)
+    bvp = SciMLBase.BVProblem{true, SciMLBase.AutoSpecialize}(lksys, u0map, tspan; guesses = guess)
     test_solvers(solvers, bvp, u0map, constr; dt = 0.05)
 
     # Testing that more complicated constraints give correct solutions.
     constr = [y(.2) + x(.8) ~ 3., y(.3) ~ 2.]
     @mtkbuild lksys = ODESystem(eqs, t; constraints = constr)
-    bvp = SciMLBase.BVProblem{false, SciMLBase.FullSpecialize}(lksys, u0map, tspan; guesses)
+    bvp = SciMLBase.BVProblem{false, SciMLBase.FullSpecialize}(lksys, u0map, tspan; guesses = guess)
     test_solvers(solvers, bvp, u0map, constr; dt = 0.05)
 
     constr = [α * β - x(.6) ~ 0.0, y(.2) ~ 3.]
     @mtkbuild lksys = ODESystem(eqs, t; constraints = constr)
-    bvp = SciMLBase.BVProblem{true, SciMLBase.AutoSpecialize}(lksys, u0map, tspan; guesses)
+    bvp = SciMLBase.BVProblem{true, SciMLBase.AutoSpecialize}(lksys, u0map, tspan; guesses = guess)
     test_solvers(solvers, bvp, u0map, constr)
 end