refactor!: require systems to be completed before creating an XFunction/XFunctionExpr

Author: AayushSabharwal

src/systems/diffeqs/abstractodesystem.jl

@@ -308,6 +308,9 @@ function DiffEqBase.ODEFunction{iip, specialize}(sys::AbstractODESystem, dvs = u
         analytic = nothing,
         split_idxs = nothing,
         kwargs...) where {iip, specialize}
+    if !iscomplete(sys)
+        error("A completed system is required. Call `complete` or `structural_simplify` on the system before creating an `ODEFunction`")
+    end
     f_gen = generate_function(sys, dvs, ps; expression = Val{eval_expression},
         expression_module = eval_module, checkbounds = checkbounds,
         kwargs...)
@@ -504,6 +507,9 @@ function DiffEqBase.DAEFunction{iip}(sys::AbstractODESystem, dvs = unknowns(sys)
         eval_module = @__MODULE__,
         checkbounds = false,
         kwargs...) where {iip}
+    if !iscomplete(sys)
+        error("A completed system is required. Call `complete` or `structural_simplify` on the system before creating a `DAEFunction`")
+    end
     f_gen = generate_function(sys, dvs, ps; implicit_dae = true,
         expression = Val{eval_expression},
         expression_module = eval_module, checkbounds = checkbounds,
@@ -579,6 +585,9 @@ function DiffEqBase.DDEFunction{iip}(sys::AbstractODESystem, dvs = unknowns(sys)
         eval_module = @__MODULE__,
         checkbounds = false,
         kwargs...) where {iip}
+    if !iscomplete(sys)
+        error("A completed system is required. Call `complete` or `structural_simplify` on the system before creating an `DDEFunction`")
+    end
     f_gen = generate_function(sys, dvs, ps; isdde = true,
         expression = Val{true},
         expression_module = eval_module, checkbounds = checkbounds,
@@ -603,6 +612,9 @@ function DiffEqBase.SDDEFunction{iip}(sys::AbstractODESystem, dvs = unknowns(sys
         eval_module = @__MODULE__,
         checkbounds = false,
         kwargs...) where {iip}
+    if !iscomplete(sys)
+        error("A completed system is required. Call `complete` or `structural_simplify` on the system before creating an `SDDEFunction`")
+    end
     f_gen = generate_function(sys, dvs, ps; isdde = true,
         expression = Val{true},
         expression_module = eval_module, checkbounds = checkbounds,
@@ -656,6 +668,9 @@ function ODEFunctionExpr{iip}(sys::AbstractODESystem, dvs = unknowns(sys),
         sparsity = false,
         observedfun_exp = nothing,
         kwargs...) where {iip}
+    if !iscomplete(sys)
+        error("A completed system is required. Call `complete` or `structural_simplify` on the system before creating an `ODEFunctionExpr`")
+    end
     f_oop, f_iip = generate_function(sys, dvs, ps; expression = Val{true}, kwargs...)
 
     dict = Dict()
@@ -830,6 +845,9 @@ function DAEFunctionExpr{iip}(sys::AbstractODESystem, dvs = unknowns(sys),
         linenumbers = false,
         sparse = false, simplify = false,
         kwargs...) where {iip}
+    if !iscomplete(sys)
+        error("A completed system is required. Call `complete` or `structural_simplify` on the system before creating an `DAEFunctionExpr`")
+    end
     f_oop, f_iip = generate_function(sys, dvs, ps; expression = Val{true},
         implicit_dae = true, kwargs...)
     fsym = gensym(:f)

src/systems/diffeqs/sdesystem.jl

@@ -393,6 +393,9 @@ function DiffEqBase.SDEFunction{iip}(sys::SDESystem, dvs = unknowns(sys),
         jac = false, Wfact = false, eval_expression = true,
         checkbounds = false,
         kwargs...) where {iip}
+    if !iscomplete(sys)
+        error("A completed `SDESystem` is required. Call `complete` or `structural_simplify` on the system before creating an `SDEFunction`")
+    end
     dvs = scalarize.(dvs)
     ps = scalarize.(ps)
 
@@ -515,6 +518,9 @@ function SDEFunctionExpr{iip}(sys::SDESystem, dvs = unknowns(sys),
         jac = false, Wfact = false,
         sparse = false, linenumbers = false,
         kwargs...) where {iip}
+    if !iscomplete(sys)
+        error("A completed `SDESystem` is required. Call `complete` or `structural_simplify` on the system before creating an `SDEFunctionExpr`")
+    end
     idx = iip ? 2 : 1
     f = generate_function(sys, dvs, ps; expression = Val{true}, kwargs...)[idx]
     g = generate_diffusion_function(sys, dvs, ps; expression = Val{true}, kwargs...)[idx]

src/systems/nonlinear/nonlinearsystem.jl

@@ -234,6 +234,9 @@ function SciMLBase.NonlinearFunction{iip}(sys::NonlinearSystem, dvs = unknowns(s
         eval_expression = true,
         sparse = false, simplify = false,
         kwargs...) where {iip}
+    if !iscomplete(sys)
+        error("A completed `NonlinearSystem` is required. Call `complete` or `structural_simplify` on the system before creating a `NonlinearFunction`")
+    end
     f_gen = generate_function(sys, dvs, ps; expression = Val{eval_expression}, kwargs...)
     f_oop, f_iip = eval_expression ?
                    (drop_expr(@RuntimeGeneratedFunction(ex)) for ex in f_gen) : f_gen
@@ -296,6 +299,9 @@ function NonlinearFunctionExpr{iip}(sys::NonlinearSystem, dvs = unknowns(sys),
         linenumbers = false,
         sparse = false, simplify = false,
         kwargs...) where {iip}
+    if !iscomplete(sys)
+        error("A completed `NonlinearSystem` is required. Call `complete` or `structural_simplify` on the system before creating a `NonlinearFunctionExpr`")
+    end
     idx = iip ? 2 : 1
     f = generate_function(sys, dvs, ps; expression = Val{true}, kwargs...)[idx]
 

test/distributed.jl

@@ -14,6 +14,7 @@ addprocs(2)
     D(z) ~ x * y - β * z]
 
 @everywhere @named de = ODESystem(eqs)
+@everywhere de = complete(de)
 @everywhere ode_func = ODEFunction(de, [x, y, z], [σ, ρ, β])
 
 @everywhere u0 = [19.0, 20.0, 50.0]

test/function_registration.jl

@@ -18,6 +18,7 @@ end
 
 eq = Dt(u) ~ do_something(x) + MyModule.do_something(x)
 @named sys = ODESystem([eq], t, [u], [x])
+sys = complete(sys)
 fun = ODEFunction(sys)
 
 u0 = 5.0
@@ -40,6 +41,7 @@ end
 
 eq = Dt(u) ~ do_something_2(x) + MyNestedModule.do_something_2(x)
 @named sys = ODESystem([eq], t, [u], [x])
+sys = complete(sys)
 fun = ODEFunction(sys)
 
 u0 = 3.0
@@ -61,6 +63,7 @@ end
 
 eq = Dt(u) ~ do_something_3(x) + (@__MODULE__).do_something_3(x)
 @named sys = ODESystem([eq], t, [u], [x])
+sys = complete(sys)
 fun = ODEFunction(sys)
 
 u0 = 7.0
@@ -99,6 +102,7 @@ function build_ode()
     Dt = Differential(t)
     eq = Dt(u) ~ do_something_4(x) + (@__MODULE__).do_something_4(x)
     @named sys = ODESystem([eq], t, [u], [x])
+    sys = complete(sys)
     fun = ODEFunction(sys, eval_expression = false)
 end
 function run_test()

test/labelledarrays.jl

@@ -13,6 +13,7 @@ eqs = [D(x) ~ σ * (y - x),
     D(z) ~ x * y - β * z]
 
 @named de = ODESystem(eqs)
+de = complete(de)
 ff = ODEFunction(de, [x, y, z], [σ, ρ, β], jac = true)
 
 a = @SVector [1.0, 2.0, 3.0]

test/mass_matrix.jl

@@ -9,6 +9,7 @@ eqs = [D(y[1]) ~ -k[1] * y[1] + k[3] * y[2] * y[3],
     0 ~ y[1] + y[2] + y[3] - 1]
 
 @named sys = ODESystem(eqs, t, y, k)
+sys = complete(sys)
 @test_throws ArgumentError ODESystem(eqs, y[1])
 M = calculate_massmatrix(sys)
 @test M == [1 0 0

test/odesystem.jl

@@ -51,6 +51,7 @@ jac_expr = generate_jacobian(de)
 jac = calculate_jacobian(de)
 jacfun = eval(jac_expr[2])
 
+de = complete(de)
 for f in [
     ODEFunction(de, [x, y, z], [σ, ρ, β], tgrad = true, jac = true),
     eval(ODEFunctionExpr(de, [x, y, z], [σ, ρ, β], tgrad = true, jac = true)),
@@ -167,7 +168,7 @@ lowered_eqs = [D(uˍtt) ~ 2uˍtt + uˍt + xˍt + 1
 
 test_diffeq_inference("first-order transform", de1, t, [uˍtt, xˍt, uˍt, u, x], [])
 du = zeros(5)
-ODEFunction(de1, [uˍtt, xˍt, uˍt, u, x], [])(du, ones(5), nothing, 0.1)
+ODEFunction(complete(de1), [uˍtt, xˍt, uˍt, u, x], [])(du, ones(5), nothing, 0.1)
 @test du == [5.0, 3.0, 1.0, 1.0, 1.0]
 
 # Internal calculations
@@ -182,7 +183,7 @@ jac = calculate_jacobian(de)
 @test ModelingToolkit.jacobian_sparsity(de).colptr == sparse(jac).colptr
 @test ModelingToolkit.jacobian_sparsity(de).rowval == sparse(jac).rowval
 
-f = ODEFunction(de, [x, y, z], [σ, ρ, β])
+f = ODEFunction(complete(de), [x, y, z], [σ, ρ, β])
 
 D = Differential(t)
 @parameters A B C
@@ -208,7 +209,7 @@ function lotka(u, p, t)
 end
 
 prob = ODEProblem(ODEFunction{false}(lotka), [1.0, 1.0], (0.0, 1.0), [1.5, 1.0, 3.0, 1.0])
-de = modelingtoolkitize(prob)
+de = complete(modelingtoolkitize(prob))
 ODEFunction(de)(similar(prob.u0), prob.u0, prob.p, 0.1)
 
 function lotka(du, u, p, t)
@@ -220,7 +221,7 @@ end
 
 prob = ODEProblem(lotka, [1.0, 1.0], (0.0, 1.0), [1.5, 1.0, 3.0, 1.0])
 
-de = modelingtoolkitize(prob)
+de = complete(modelingtoolkitize(prob))
 ODEFunction(de)(similar(prob.u0), prob.u0, prob.p, 0.1)
 
 # automatic unknown detection for DAEs
@@ -579,11 +580,13 @@ eqs = [
 ]
 
 @named sys = ODESystem(eqs, t, [x, y, z], [α, β])
+sys = complete(sys)
 @test_throws Any ODEFunction(sys)
 
 eqs = copy(eqs)
 eqs[end] = D(D(z)) ~ α * x - β * y
 @named sys = ODESystem(eqs, t, [x, y, z], [α, β])
+sys = complete(sys)
 @test_throws Any ODEFunction(sys)
 
 @testset "Preface tests" begin

test/precompile_test/ODEPrecompileTest.jl

@@ -13,6 +13,7 @@ function system(; kwargs...)
         D(z) ~ x * y - β * z]
 
     @named de = ODESystem(eqs)
+    de = complete(de)
     return ODEFunction(de, [x, y, z], [σ, ρ, β]; kwargs...)
 end
 

test/structural_transformation/index_reduction.jl

@@ -59,7 +59,7 @@ idx1_pendulum = [D(x) ~ w,
     # substitute the rhs
     0 ~ 2x * (T * x) + 2 * xˍt * xˍt + 2y * (T * y - g) + 2 * yˍt * yˍt]
 @named idx1_pendulum = ODESystem(idx1_pendulum, t, [x, y, w, z, xˍt, yˍt, T], [L, g])
-first_order_idx1_pendulum = ode_order_lowering(idx1_pendulum)
+first_order_idx1_pendulum = complete(ode_order_lowering(idx1_pendulum))
 
 using OrdinaryDiffEq
 using LinearAlgebra