test: use new problem construction syntax

Author: AayushSabharwal

test/basic_transformations.jl

@@ -14,14 +14,14 @@ D = Differential(t)
     u0 = [x => 1.0, y => 1.0]
     p = [α => 1.5, β => 1.0, δ => 3.0, γ => 1.0]
     tspan = (0.0, 10.0)
-    prob = ODEProblem(sys, u0, tspan, p)
+    prob = ODEProblem(sys, [u0; p], tspan)
     sol = solve(prob, Tsit5())
 
     sys2 = liouville_transform(sys)
     sys2 = complete(sys2)
 
     u0 = [x => 1.0, y => 1.0, sys2.trJ => 1.0]
-    prob = ODEProblem(sys2, u0, tspan, p, jac = true)
+    prob = ODEProblem(sys2, [u0; p], tspan, jac = true)
     sol = solve(prob, Tsit5())
     @test sol[end, end] ≈ 1.0742818931017244
 end
@@ -53,8 +53,8 @@ end
 
     M1 = mtkcompile(M1; allow_symbolic = true)
     M2 = mtkcompile(M2; allow_symbolic = true)
-    prob1 = ODEProblem(M1, [M1.s => 1.0], (1.0, 4.0), [])
-    prob2 = ODEProblem(M2, [], (1.0, 2.0), [])
+    prob1 = ODEProblem(M1, [M1.s => 1.0], (1.0, 4.0))
+    prob2 = ODEProblem(M2, [], (1.0, 2.0))
     sol1 = solve(prob1, Tsit5(); reltol = 1e-10, abstol = 1e-10)
     sol2 = solve(prob2, Tsit5(); reltol = 1e-10, abstol = 1e-10)
     ts = range(0.0, 1.0, length = 50)
@@ -125,7 +125,7 @@ end
     Dx = Differential(Mx.x)
     u0 = [Mx.y => 0.0, Dx(Mx.y) => 1.0, Mx.t => 0.0]
     p = [v => 10.0]
-    prob = ODEProblem(Mx, u0, (0.0, 20.0), p) # 1 = dy/dx = (dy/dt)/(dx/dt) means equal initial horizontal and vertical velocities
+    prob = ODEProblem(Mx, [u0; p], (0.0, 20.0)) # 1 = dy/dx = (dy/dt)/(dx/dt) means equal initial horizontal and vertical velocities
     sol = solve(prob, Tsit5(); reltol = 1e-5)
     @test all(isapprox.(sol[Mx.y], sol[Mx.x - g * (Mx.t)^2 / 2]; atol = 1e-10)) # compare to analytical solution (x(t) = v*t, y(t) = v*t - g*t^2/2)
 end
@@ -138,7 +138,7 @@ end
     Mx = mtkcompile(Mx; allow_symbolic = true)
     Dx = Differential(Mx.x)
     u0 = [Mx.y => 0.0, Dx(Mx.y) => 1.0, Mx.t => 0.0, Mx.xˍt => 10.0]
-    prob = ODEProblem(Mx, u0, (0.0, 20.0), []) # 1 = dy/dx = (dy/dt)/(dx/dt) means equal initial horizontal and vertical velocities
+    prob = ODEProblem(Mx, u0, (0.0, 20.0)) # 1 = dy/dx = (dy/dt)/(dx/dt) means equal initial horizontal and vertical velocities
     sol = solve(prob, Tsit5(); reltol = 1e-5)
     @test all(isapprox.(sol[Mx.y], sol[Mx.x - g * (Mx.t)^2 / 2]; atol = 1e-10)) # compare to analytical solution (x(t) = v*t, y(t) = v*t - g*t^2/2)
 end
@@ -200,7 +200,7 @@ end
 
     _f = LinearInterpolation([1.0, 1.0], [-100.0, +100.0]) # constant value 1
     M2s = mtkcompile(M2; allow_symbolic = true)
-    prob = ODEProblem(M2s, [M2s.y => 0.0], (1.0, 4.0), [fc => _f, f => _f])
+    prob = ODEProblem(M2s, [M2s.y => 0.0, fc => _f, f => _f], (1.0, 4.0))
     sol = solve(prob, Tsit5(); abstol = 1e-5)
     @test isapprox(sol(4.0, idxs = M2.y), 12.0; atol = 1e-5) # Anal solution is D(y) ~ 12 => y(t) ~ 12*t + C => y(x) ~ 12*√(x) + C. With y(x=1)=0 => 12*(√(x)-1), so y(x=4) ~ 12
 end
@@ -227,7 +227,7 @@ end
     Mx = mtkcompile(Mx; allow_symbolic = true)
     Dx = Differential(Mx.x)
     u0 = [Mx.y => 0.0, Dx(Mx.y) => 1.0, Mx.t_units => 0.0, Mx.xˍt_units => 10.0]
-    prob = ODEProblem(Mx, u0, (0.0, 20.0), []) # 1 = dy/dx = (dy/dt)/(dx/dt) means equal initial horizontal and vertical velocities
+    prob = ODEProblem(Mx, u0, (0.0, 20.0)) # 1 = dy/dx = (dy/dt)/(dx/dt) means equal initial horizontal and vertical velocities
     sol = solve(prob, Tsit5(); reltol = 1e-5)
     # compare to analytical solution (x(t) = v*t, y(t) = v*t - g*t^2/2)
     @test all(isapprox.(sol[Mx.y], sol[Mx.x - g * (Mx.t_units)^2 / 2]; atol = 1e-10))
@@ -300,7 +300,7 @@ end
     new_sys = change_independent_variable(sys, sys.x; add_old_diff = true)
     ss_new_sys = mtkcompile(new_sys; allow_symbolic = true)
     u0 = [new_sys.y => 0.5, new_sys.t => 0.0]
-    prob = ODEProblem(ss_new_sys, u0, (0.0, 0.5), [])
+    prob = ODEProblem(ss_new_sys, u0, (0.0, 0.5))
     sol = solve(prob, Tsit5(); reltol = 1e-5)
     @test sol[new_sys.y][end] ≈ 0.75
 end

test/bvproblem.jl

@@ -21,11 +21,11 @@ daesolvers = [Ascher2, Ascher4, Ascher6]
     tspan = (0.0, 10.0)
 
     @mtkcompile lotkavolterra = System(eqs, t)
-    op = ODEProblem(lotkavolterra, u0map, tspan, parammap)
+    op = ODEProblem(lotkavolterra, [u0map; parammap], tspan)
     osol = solve(op, Vern9())
 
     bvp = SciMLBase.BVProblem{true, SciMLBase.AutoSpecialize}(
-        lotkavolterra, u0map, tspan, parammap)
+        lotkavolterra, [u0map; parammap], tspan)
 
     for solver in solvers
         sol = solve(bvp, solver(), dt = 0.01)
@@ -35,7 +35,7 @@ daesolvers = [Ascher2, Ascher4, Ascher6]
 
     # Test out of place
     bvp2 = SciMLBase.BVProblem{false, SciMLBase.AutoSpecialize}(
-        lotkavolterra, u0map, tspan, parammap)
+        lotkavolterra, [u0map; parammap], tspan)
 
     for solver in solvers
         sol = solve(bvp2, solver(), dt = 0.01)
@@ -58,10 +58,11 @@ end
     parammap = [:L => 1.0, :g => 9.81]
     tspan = (0.0, 6.0)
 
-    op = ODEProblem(pend, u0map, tspan, parammap)
+    op = ODEProblem(pend, [u0map; parammap], tspan)
     osol = solve(op, Vern9())
 
-    bvp = SciMLBase.BVProblem{true, SciMLBase.AutoSpecialize}(pend, u0map, tspan, parammap)
+    bvp = SciMLBase.BVProblem{true, SciMLBase.AutoSpecialize}(
+        pend, [u0map; parammap], tspan)
     for solver in solvers
         sol = solve(bvp, solver(), dt = 0.01)
         @test isapprox(sol.u[end], osol.u[end]; atol = 0.01)
@@ -70,7 +71,7 @@ end
 
     # Test out-of-place
     bvp2 = SciMLBase.BVProblem{false, SciMLBase.FullSpecialize}(
-        pend, u0map, tspan, parammap)
+        pend, [u0map; parammap], tspan)
 
     for solver in solvers
         sol = solve(bvp2, solver(), dt = 0.01)
@@ -289,8 +290,8 @@ end
     @mtkcompile lksys = System(eqs, t; costs, consolidate)
 
     @test_throws ModelingToolkit.SystemCompatibilityError ODEProblem(
-        lksys, u0map, tspan, parammap)
-    prob = ODEProblem(lksys, u0map, tspan, parammap; check_compatibility = false)
+        lksys, [u0map; parammap], tspan)
+    prob = ODEProblem(lksys, [u0map; parammap], tspan; check_compatibility = false)
     sol = solve(prob, Tsit5())
     costfn = ModelingToolkit.generate_cost(
         lksys; expression = Val{false}, wrap_gfw = Val{true})
@@ -304,7 +305,7 @@ end
     @mtkcompile lksys = System(eqs, t; costs, consolidate)
     @test t_c ∈ Set(parameters(lksys))
     push!(parammap, t_c => 0.56)
-    prob = ODEProblem(lksys, u0map, tspan, parammap; check_compatibility = false)
+    prob = ODEProblem(lksys, [u0map; parammap], tspan; check_compatibility = false)
     sol = solve(prob, Tsit5())
     costfn = ModelingToolkit.generate_cost(
         lksys; expression = Val{false}, wrap_gfw = Val{true})

test/clock.jl

@@ -120,22 +120,22 @@ eqs = [yd ~ Sample(dt)(y)
 
 @test_skip begin
     Tf = 1.0
-    prob = ODEProblem(ss, [x => 0.1], (0.0, Tf),
-        [kp => 1.0; ud(k - 1) => 2.1; ud(k - 2) => 2.0])
+    prob = ODEProblem(
+        ss, [x => 0.1, kp => 1.0; ud(k - 1) => 2.1; ud(k - 2) => 2.0], (0.0, Tf))
     # create integrator so callback is evaluated at t=0 and we can test correct param values
     int = init(prob, Tsit5(); kwargshandle = KeywordArgSilent)
     @test sort(vcat(int.p...)) == [0.1, 1.0, 2.1, 2.1, 2.1] # yd, kp, ud(k-1), ud, Hold(ud)
-    prob = ODEProblem(ss, [x => 0.1], (0.0, Tf),
-        [kp => 1.0; ud(k - 1) => 2.1; ud(k - 2) => 2.0]) # recreate problem to empty saved values
+    prob = ODEProblem(
+        ss, [x => 0.1, kp => 1.0; ud(k - 1) => 2.1; ud(k - 2) => 2.0], (0.0, Tf)) # recreate problem to empty saved values
     sol = solve(prob, Tsit5(), kwargshandle = KeywordArgSilent)
 
     ss_nosplit = mtkcompile(sys; split = false)
-    prob_nosplit = ODEProblem(ss_nosplit, [x => 0.1], (0.0, Tf),
-        [kp => 1.0; ud(k - 1) => 2.1; ud(k - 2) => 2.0])
+    prob_nosplit = ODEProblem(
+        ss_nosplit, [x => 0.1, kp => 1.0; ud(k - 1) => 2.1; ud(k - 2) => 2.0], (0.0, Tf))
     int = init(prob_nosplit, Tsit5(); kwargshandle = KeywordArgSilent)
     @test sort(int.p) == [0.1, 1.0, 2.1, 2.1, 2.1] # yd, kp, ud(k-1), ud, Hold(ud)
-    prob_nosplit = ODEProblem(ss_nosplit, [x => 0.1], (0.0, Tf),
-        [kp => 1.0; ud(k - 1) => 2.1; ud(k - 2) => 2.0]) # recreate problem to empty saved values
+    prob_nosplit = ODEProblem(
+        ss_nosplit, [x => 0.1, kp => 1.0; ud(k - 1) => 2.1; ud(k - 2) => 2.0], (0.0, Tf)) # recreate problem to empty saved values
     sol_nosplit = solve(prob_nosplit, Tsit5(), kwargshandle = KeywordArgSilent)
     # For all inputs in parameters, just initialize them to 0.0, and then set them
     # in the callback.
@@ -299,8 +299,8 @@ eqs = [yd ~ Sample(dt)(y)
     ss_nosplit = mtkcompile(cl; split = false)
 
     if VERSION >= v"1.7"
-        prob = ODEProblem(ss, [x => 0.0], (0.0, 1.0), [kp => 1.0])
-        prob_nosplit = ODEProblem(ss_nosplit, [x => 0.0], (0.0, 1.0), [kp => 1.0])
+        prob = ODEProblem(ss, [x => 0.0, kp => 1.0], (0.0, 1.0))
+        prob_nosplit = ODEProblem(ss_nosplit, [x => 0.0, kp => 1.0], (0.0, 1.0))
         sol = solve(prob, Tsit5(), kwargshandle = KeywordArgSilent)
         sol_nosplit = solve(prob_nosplit, Tsit5(), kwargshandle = KeywordArgSilent)
 
@@ -535,8 +535,8 @@ eqs = [yd ~ Sample(dt)(y)
     @test int.ps[x] == 2.0
     @test int.ps[x(k - 1)] == 1.0
 
-    @test_throws ErrorException ODEProblem(sys, [], (0.0, 10.0), [x => 2.0])
-    prob = ODEProblem(sys, [], (0.0, 10.0), [x(k - 1) => 2.0])
+    @test_throws ErrorException ODEProblem(sys, [x => 2.0], (0.0, 10.0))
+    prob = ODEProblem(sys, [x(k - 1) => 2.0], (0.0, 10.0))
     int = init(prob, Tsit5(); kwargshandle = KeywordArgSilent)
     @test int.ps[x] == 3.0
     @test int.ps[x(k - 1)] == 2.0

test/code_generation.jl

@@ -59,7 +59,7 @@ end
     @variables x(t)
     @parameters p[0:2] (f::Function)(..)
     @mtkcompile sys = System(D(x) ~ p[0] * x + p[1] * t + p[2] + f(p), t)
-    prob = ODEProblem(sys, [x => 1.0], (0.0, 1.0), [p => [1.0, 2.0, 3.0], f => sum])
+    prob = ODEProblem(sys, [x => 1.0, p => [1.0, 2.0, 3.0], f => sum], (0.0, 1.0))
     @test prob.ps[p] == [1.0, 2.0, 3.0]
     @test prob.ps[p[0]] == 1.0
     sol = solve(prob, Tsit5())
@@ -72,8 +72,9 @@ end
             [D(x[0]) ~ p[1] * x[0] + x[2], D(x[1]) ~ p[2] * f(x) + x[2]], t)
         sys = mtkcompile(sys, inputs = [x[2]], outputs = [])
         @test is_parameter(sys, x[2])
-        prob = ODEProblem(sys, [x[0] => 1.0, x[1] => 1.0], (0.0, 1.0),
-            [p => ones(2), f => sum, x[2] => 2.0])
+        prob = ODEProblem(
+            sys, [x[0] => 1.0, x[1] => 1.0, x[2] => 2.0, p => ones(2), f => sum],
+            (0.0, 1.0))
         sol = solve(prob, Tsit5())
         @test SciMLBase.successful_retcode(sol)
     end

test/components.jl

@@ -119,15 +119,16 @@ include("common/serial_inductor.jl")
     u0 = unknowns(sys) .=> 0
     @test_nowarn ODEProblem(
         sys, [], (0, 10.0), guesses = u0, warn_initialize_determined = false)
-    prob = DAEProblem(sys, D.(unknowns(sys)) .=> 0, [], (0, 0.5), guesses = u0)
+    prob = DAEProblem(sys, D.(unknowns(sys)) .=> 0, (0, 0.5), guesses = u0)
     sol = solve(prob, DFBDF())
     @test sol.retcode == SciMLBase.ReturnCode.Success
 
     sys2 = mtkcompile(ll2_model)
     @test length(equations(sys2)) == 3
-    u0 = unknowns(sys) .=> 0
+    u0 = [sys.inductor2.i => 0]
     prob = ODEProblem(sys, u0, (0, 10.0))
-    @test_nowarn sol = solve(prob, FBDF())
+    sol = solve(prob, FBDF())
+    @test SciMLBase.successful_retcode(sol)
 end
 
 @testset "Compose/extend" begin

test/constants.jl

@@ -12,7 +12,7 @@ UMT = ModelingToolkit.UnitfulUnitCheck
 D = Differential(t)
 eqs = [D(x) ~ a]
 @named sys = System(eqs, t)
-prob = ODEProblem(complete(sys), [0], [0.0, 1.0], [])
+prob = ODEProblem(complete(sys), [0], [0.0, 1.0])
 sol = solve(prob, Tsit5())
 
 # Test mtkcompile substitutions & observed values
@@ -43,7 +43,7 @@ simp = mtkcompile(sys)
 
     @mtkcompile fol_model = System(eqs, MT.t_nounits)
 
-    prob = ODEProblem(fol_model, [], (0.0, 10.0), [h => 1])
+    prob = ODEProblem(fol_model, [h => 1], (0.0, 10.0))
     @test prob[x] ≈ 1
     @test prob.ps[τ] ≈ 0.5
 end

test/dae_jacobian.jl

@@ -43,12 +43,12 @@ u0 = [u1 => 1.0,
 
 tspan = (0.0, 10.0)
 
-du0 = [0.5, -2.0]
+du0 = [D(u1) => 0.5, D(u2) => -2.0]
 
 p = [p1 => 1.5,
     p2 => 3.0]
 
-prob = DAEProblem(complete(sys), du0, u0, tspan, p, jac = true, sparse = true)
+prob = DAEProblem(complete(sys), [du0; u0; p], tspan, jac = true, sparse = true)
 sol = solve(prob, IDA(linear_solver = :KLU))
 
 @test maximum(sol - sol1) < 1e-12

test/discrete_system.jl

@@ -51,7 +51,7 @@ reorderer = getu(syss, [S, I, R])
 u0 = [S(k - 1) => 990.0, I(k - 1) => 10.0, R(k - 1) => 0.0]
 p = [β => 0.05, c => 10.0, γ => 0.25, δt => 0.1, nsteps => 400]
 tspan = (0.0, ModelingToolkit.value(substitute(nsteps, p))) # value function (from Symbolics) is used to convert a Num to Float64
-prob_map = DiscreteProblem(syss, u0, tspan, p)
+prob_map = DiscreteProblem(syss, [u0; p], tspan)
 @test prob_map.f.sys === syss
 
 # Solution

test/distributed.jl

@@ -16,10 +16,10 @@ addprocs(2)
 @everywhere @named de = System(eqs, t)
 @everywhere de = complete(de)
 
-@everywhere u0 = [19.0, 20.0, 50.0]
-@everywhere params = [16.0, 45.92, 4]
+@everywhere u0 = unknowns(de) .=> [19.0, 20.0, 50.0]
+@everywhere params = parameters(de) .=> [16.0, 45.92, 4]
 
-@everywhere ode_prob = ODEProblem(de, u0, (0.0, 10.0), params)
+@everywhere ode_prob = ODEProblem(de, [u0; params], (0.0, 10.0))
 
 @everywhere begin
     using OrdinaryDiffEq

test/dq_units.jl

@@ -216,7 +216,7 @@ end
     p = [pend.g => 1.0, pend.L => 1.0]
     guess = [pend.λ => 0.0]
     @test prob = ODEProblem(
-        pend, u0, (0.0, 1.0), p; guesses = guess, check_units = false) isa Any
+        pend, [u0; p], (0.0, 1.0); guesses = guess, check_units = false) isa Any
 end
 
 @parameters p [unit = u"L/s"] d [unit = u"s^(-1)"]