Merge pull request #2443 from AayushSabharwal/as/manual-indepvar

fix!: require explicit independent variable for ODESystem

Author: ChrisRackauckas

src/ModelingToolkit.jl

@@ -192,7 +192,7 @@ const D = Differential(t)
 PrecompileTools.@compile_workload begin
     using ModelingToolkit
     @variables x(ModelingToolkit.t_nounits)
-    @named sys = ODESystem([ModelingToolkit.D_nounits(x) ~ -x])
+    @named sys = ODESystem([ModelingToolkit.D_nounits(x) ~ -x], ModelingToolkit.t_nounits)
     prob = ODEProblem(structural_simplify(sys), [x => 30.0], (0, 100), [], jac = true)
 end
 

src/systems/diffeqs/odesystem.jl

@@ -230,7 +230,7 @@ function ODESystem(deqs::AbstractVector{<:Equation}, iv, dvs, ps;
         metadata, gui_metadata, checks = checks)
 end
 
-function ODESystem(eqs, iv = nothing; kwargs...)
+function ODESystem(eqs, iv; kwargs...)
     eqs = scalarize(eqs)
     # NOTE: this assumes that the order of algebraic equations doesn't matter
     diffvars = OrderedSet()

src/systems/systems.jl

@@ -1,4 +1,4 @@
-function System(eqs::AbstractVector{<:Equation}, iv = nothing, args...; name = nothing,
+function System(eqs::AbstractVector{<:Equation}, iv, args...; name = nothing,
         kw...)
     ODESystem(eqs, iv, args...; name, kw..., checks = false)
 end

test/clock.jl

@@ -22,7 +22,7 @@ eqs = [yd ~ Sample(t, dt)(y)
     u ~ Hold(ud)
     D(x) ~ -x + u
     y ~ x]
-@named sys = ODESystem(eqs)
+@named sys = ODESystem(eqs, t)
 # compute equation and variables' time domains
 #TODO: test linearize
 
@@ -110,7 +110,7 @@ z′(k + 1) ~ z(k) + yd
 z(k + 1)  ~ z′(k)
 =#
 ]
-@named sys = ODESystem(eqs)
+@named sys = ODESystem(eqs, t)
 ss = structural_simplify(sys);
 
 Tf = 1.0
@@ -174,7 +174,7 @@ eqs = [
     u ~ Hold(ud1) + Hold(ud2)
     D(x) ~ -x + u
     y ~ x]
-@named sys = ODESystem(eqs)
+@named sys = ODESystem(eqs, t)
 ci, varmap = infer_clocks(sys)
 
 d = Clock(t, dt)

test/constants.jl

@@ -9,7 +9,7 @@ UMT = ModelingToolkit.UnitfulUnitCheck
 @variables t x(t) w(t)
 D = Differential(t)
 eqs = [D(x) ~ a]
-@named sys = ODESystem(eqs)
+@named sys = ODESystem(eqs, t)
 prob = ODEProblem(complete(sys), [0], [0.0, 1.0], [])
 sol = solve(prob, Tsit5())
 
@@ -19,7 +19,7 @@ newsys = MT.eliminate_constants(sys)
 # Test structural_simplify substitutions & observed values
 eqs = [D(x) ~ 1,
     w ~ a]
-@named sys = ODESystem(eqs)
+@named sys = ODESystem(eqs, t)
 # Now eliminate the constants first
 simp = structural_simplify(sys)
 @test equations(simp) == [D(x) ~ 1.0]
@@ -31,7 +31,7 @@ UMT.get_unit(β)
 @variables t [unit = u"s"] x(t) [unit = u"m"]
 D = Differential(t)
 eqs = [D(x) ~ β]
-@named sys = ODESystem(eqs)
+@named sys = ODESystem(eqs, t)
 simp = structural_simplify(sys)
 
 @test isempty(MT.collect_constants(nothing))

test/dae_jacobian.jl

@@ -36,7 +36,7 @@ sol1 = solve(prob1, IDA(linear_solver = :KLU))
 eqs = [D(u1) ~ p1 * u1 - u1 * u2,
     D(u2) ~ u1 * u2 - p2 * u2]
 
-@named sys = ODESystem(eqs)
+@named sys = ODESystem(eqs, t)
 
 u0 = [u1 => 1.0,
     u2 => 1.0]

test/distributed.jl

@@ -13,7 +13,7 @@ addprocs(2)
     D(y) ~ x * (ρ - z) - y,
     D(z) ~ x * y - β * z]
 
-@everywhere @named de = ODESystem(eqs)
+@everywhere @named de = ODESystem(eqs, t)
 @everywhere de = complete(de)
 @everywhere ode_func = ODEFunction(de, [x, y, z], [σ, ρ, β])
 

test/dq_units.jl

@@ -20,7 +20,7 @@ using ModelingToolkit: t, D
 eqs = [D(E) ~ P - E / τ
     0 ~ P]
 @test MT.validate(eqs)
-@named sys = ODESystem(eqs)
+@named sys = ODESystem(eqs, t)
 
 @test !MT.validate(D(D(E)) ~ P)
 @test !MT.validate(0 ~ P + E * τ)
@@ -30,13 +30,13 @@ eqs = [D(E) ~ P - E / τ
 ODESystem(eqs, t, [E, P, t], [τ], name = :sys, checks = MT.CheckUnits)
 eqs = [D(E) ~ P - E / τ
     0 ~ P + E * τ]
-@test_throws MT.ValidationError ODESystem(eqs, name = :sys, checks = MT.CheckAll)
-@test_throws MT.ValidationError ODESystem(eqs, name = :sys, checks = true)
-ODESystem(eqs, name = :sys, checks = MT.CheckNone)
-ODESystem(eqs, name = :sys, checks = false)
-@test_throws MT.ValidationError ODESystem(eqs, name = :sys,
+@test_throws MT.ValidationError ODESystem(eqs, t, name = :sys, checks = MT.CheckAll)
+@test_throws MT.ValidationError ODESystem(eqs, t, name = :sys, checks = true)
+ODESystem(eqs, t, name = :sys, checks = MT.CheckNone)
+ODESystem(eqs, t, name = :sys, checks = false)
+@test_throws MT.ValidationError ODESystem(eqs, t, name = :sys,
     checks = MT.CheckComponents | MT.CheckUnits)
-@named sys = ODESystem(eqs, checks = MT.CheckComponents)
+@named sys = ODESystem(eqs, t, checks = MT.CheckComponents)
 @test_throws MT.ValidationError ODESystem(eqs, t, [E, P, t], [τ], name = :sys,
     checks = MT.CheckUnits)
 
@@ -69,7 +69,7 @@ good_eqs = [connect(p1, p2)]
 @variables x(t)[1:3] [unit = u"m"]
 @parameters v[1:3]=[1, 2, 3] [unit = u"m/s"]
 eqs = D.(x) .~ v
-ODESystem(eqs, name = :sys)
+ODESystem(eqs, t, name = :sys)
 
 # Nonlinear system
 @parameters a [unit = u"kg"^-1]
@@ -104,12 +104,12 @@ noiseeqs = [0.1u"W" 0.1u"W"
 @parameters v [unit = u"m/s"] r [unit = u"m"^3 / u"s"]
 eqs = [D(L) ~ v,
     V ~ L^3]
-@named sys = ODESystem(eqs)
+@named sys = ODESystem(eqs, t)
 sys_simple = structural_simplify(sys)
 
 eqs = [D(V) ~ r,
     V ~ L^3]
-@named sys = ODESystem(eqs)
+@named sys = ODESystem(eqs, t)
 sys_simple = structural_simplify(sys)
 
 @variables V [unit = u"m"^3] L [unit = u"m"]

test/extensions/bifurcationkit.jl

@@ -60,7 +60,7 @@ let
     @variables x(t) y(t) z(t)
     eqs = [D(x) ~ -x + a * y + x^2 * y,
         D(y) ~ b - a * y - x^2 * y]
-    @named sys = ODESystem(eqs)
+    @named sys = ODESystem(eqs, t)
     sys = complete(sys)
     # Creates BifurcationProblem
     bprob = BifurcationProblem(sys,

test/input_output_handling.jl

@@ -158,7 +158,7 @@ eqs = [
     D(x) ~ -x + u,
 ]
 
-@named sys = ODESystem(eqs)
+@named sys = ODESystem(eqs, t)
 f, dvs, ps = ModelingToolkit.generate_control_function(sys, simplify = true)
 
 @test isequal(dvs[], x)

test/labelledarrays.jl

@@ -12,7 +12,7 @@ eqs = [D(x) ~ σ * (y - x),
     D(y) ~ t * x * (ρ - z) - y,
     D(z) ~ x * y - β * z]
 
-@named de = ODESystem(eqs)
+@named de = ODESystem(eqs, t)
 de = complete(de)
 ff = ODEFunction(de, [x, y, z], [σ, ρ, β], jac = true)
 

test/linearity.jl

@@ -11,16 +11,16 @@ eqs = [D(x) ~ σ * (y - x),
     D(y) ~ -z - y,
     D(z) ~ y - β * z]
 
-@test ModelingToolkit.islinear(@named sys = ODESystem(eqs))
+@test ModelingToolkit.islinear(@named sys = ODESystem(eqs, t))
 
 eqs2 = [D(x) ~ σ * (y - x),
     D(y) ~ -z - 1 / y,
     D(z) ~ y - β * z]
 
-@test !ModelingToolkit.islinear(@named sys = ODESystem(eqs2))
+@test !ModelingToolkit.islinear(@named sys = ODESystem(eqs2, t))
 
 eqs3 = [D(x) ~ σ * (y - x),
     D(y) ~ -z - y,
     D(z) ~ y - β * z + 1]
 
-@test ModelingToolkit.isaffine(@named sys = ODESystem(eqs))
+@test ModelingToolkit.isaffine(@named sys = ODESystem(eqs, t))

test/lowering_solving.jl

@@ -8,7 +8,7 @@ eqs = [D(D(x)) ~ σ * (y - x),
     D(y) ~ x * (ρ - z) - y,
     D(z) ~ x * y - β * z]
 
-@named sys′ = ODESystem(eqs)
+@named sys′ = ODESystem(eqs, t)
 sys = ode_order_lowering(sys′)
 
 eqs2 = [0 ~ x * y - k,
@@ -46,8 +46,8 @@ eqs = [D(x) ~ σ * (y - x),
     D(y) ~ x * (ρ - z) - y,
     D(z) ~ x * y - β * z]
 
-lorenz1 = ODESystem(eqs, name = :lorenz1)
-lorenz2 = ODESystem(eqs, name = :lorenz2)
+lorenz1 = ODESystem(eqs, t, name = :lorenz1)
+lorenz2 = ODESystem(eqs, t, name = :lorenz2)
 
 @variables α(t)
 @parameters γ

test/nonlinearsystem.jl

@@ -188,7 +188,7 @@ eq = [v1 ~ sin(2pi * t * h)
     v1 - v2 ~ i1
     v2 ~ i2
     i1 ~ i2]
-@named sys = ODESystem(eq)
+@named sys = ODESystem(eq, t)
 @test length(equations(structural_simplify(sys))) == 0
 
 @testset "Issue: 1504" begin