test: use t_nounits and D_nounits in tests

Author: AayushSabharwal

test/ccompile.jl

@@ -1,7 +1,8 @@
 using ModelingToolkit, Test
-@parameters t a
+using ModelingToolkit: t_nounits as t, D_nounits as D
+
+@parameters a
 @variables x y
-D = Differential(t)
 eqs = [D(x) ~ a * x - x * y,
     D(y) ~ -3y + x * y]
 f = build_function([x.rhs for x in eqs], [x, y], [a], t, expression = Val{false},

test/clock.jl

@@ -1,5 +1,6 @@
 using ModelingToolkit, Test, Setfield, OrdinaryDiffEq, DiffEqCallbacks
 using ModelingToolkit: Continuous
+using ModelingToolkit: t_nounits as t, D_nounits as D
 
 function infer_clocks(sys)
     ts = TearingState(sys)
@@ -9,9 +10,8 @@ end
 
 @info "Testing hybrid system"
 dt = 0.1
-@variables t x(t) y(t) u(t) yd(t) ud(t) r(t)
+@variables x(t) y(t) u(t) yd(t) ud(t) r(t)
 @parameters kp
-D = Differential(t)
 # u(n + 1) := f(u(n))
 
 eqs = [yd ~ Sample(t, dt)(y)
@@ -89,9 +89,8 @@ d = Clock(t, dt)
 
 @info "Testing shift normalization"
 dt = 0.1
-@variables t x(t) y(t) u(t) yd(t) ud(t) r(t) z(t)
+@variables x(t) y(t) u(t) yd(t) ud(t) r(t) z(t)
 @parameters kp
-D = Differential(t)
 d = Clock(t, dt)
 k = ShiftIndex(d)
 
@@ -161,9 +160,8 @@ sol2 = solve(prob, Tsit5())
 @info "Testing multi-rate hybrid system"
 dt = 0.1
 dt2 = 0.2
-@variables t x(t) y(t) u(t) r(t) yd1(t) ud1(t) yd2(t) ud2(t)
+@variables x(t) y(t) u(t) r(t) yd1(t) ud1(t) yd2(t) ud2(t)
 @parameters kp
-D = Differential(t)
 
 eqs = [
 # controller (time discrete part `dt=0.1`)
@@ -196,14 +194,12 @@ d2 = Clock(t, dt2)
 @info "test composed systems"
 
 dt = 0.5
-@variables t
 d = Clock(t, dt)
 k = ShiftIndex(d)
 timevec = 0:0.1:4
 
 function plant(; name)
     @variables x(t)=1 u(t)=0 y(t)=0
-    D = Differential(t)
     eqs = [D(x) ~ -x + u
         y ~ x]
     ODESystem(eqs, t; name = name)
@@ -253,9 +249,8 @@ ci, varmap = infer_clocks(cl)
 @info "Testing multi-rate hybrid system"
 dt = 0.1
 dt2 = 0.2
-@variables t x(t)=0 y(t)=0 u(t)=0 yd1(t)=0 ud1(t)=0 yd2(t)=0 ud2(t)=0
+@variables x(t)=0 y(t)=0 u(t)=0 yd1(t)=0 ud1(t)=0 yd2(t)=0 ud2(t)=0
 @parameters kp=1 r=1
-D = Differential(t)
 
 eqs = [
 # controller (time discrete part `dt=0.1`)
@@ -326,7 +321,6 @@ end
 using ModelingToolkitStandardLibrary.Blocks
 
 dt = 0.05
-@variables t
 d = Clock(t, dt)
 k = ShiftIndex(d)
 

test/components.jl

@@ -3,6 +3,7 @@ using ModelingToolkit, OrdinaryDiffEq
 using ModelingToolkit: get_component_type
 using ModelingToolkit.BipartiteGraphs
 using ModelingToolkit.StructuralTransformations
+using ModelingToolkit: t_nounits as t, D_nounits as D
 include("../examples/rc_model.jl")
 
 function check_contract(sys)
@@ -155,7 +156,7 @@ sys = structural_simplify(ll_model)
 @test length(equations(sys)) == 2
 u0 = unknowns(sys) .=> 0
 @test_nowarn ODEProblem(sys, u0, (0, 10.0))
-prob = DAEProblem(sys, Differential(t).(unknowns(sys)) .=> 0, u0, (0, 0.5))
+prob = DAEProblem(sys, D.(unknowns(sys)) .=> 0, u0, (0, 0.5))
 sol = solve(prob, DFBDF())
 @test sol.retcode == SciMLBase.ReturnCode.Success
 
@@ -165,17 +166,14 @@ u0 = unknowns(sys) .=> 0
 prob = ODEProblem(sys, u0, (0, 10.0))
 @test_nowarn sol = solve(prob, FBDF())
 
-@variables t x1(t) x2(t) x3(t) x4(t)
-D = Differential(t)
+@variables x1(t) x2(t) x3(t) x4(t)
 @named sys1_inner = ODESystem([D(x1) ~ x1], t)
 @named sys1_partial = compose(ODESystem([D(x2) ~ x2], t; name = :foo), sys1_inner)
 @named sys1 = extend(ODESystem([D(x3) ~ x3], t; name = :foo), sys1_partial)
 @named sys2 = compose(ODESystem([D(x4) ~ x4], t; name = :foo), sys1)
 @test_nowarn sys2.sys1.sys1_inner.x1 # test the correct nesting
 
 # compose tests
-@parameters t
-
 function record_fun(; name)
     pars = @parameters a=10 b=100
     ODESystem(Equation[], t, [], pars; name)

test/dae_jacobian.jl

@@ -1,5 +1,6 @@
 using ModelingToolkit
 using Sundials, Test, SparseArrays
+using ModelingToolkit: t_nounits as t, D_nounits as D
 
 # Comparing solution obtained by defining explicit Jacobian function with solution obtained from
 # symbolically generated Jacobian
@@ -29,11 +30,9 @@ sol1 = solve(prob1, IDA(linear_solver = :KLU))
 
 # Now MTK style solution with generated Jacobian
 
-@variables t u1(t) u2(t)
+@variables u1(t) u2(t)
 @parameters p1 p2
 
-D = Differential(t)
-
 eqs = [D(u1) ~ p1 * u1 - u1 * u2,
     D(u2) ~ u1 * u2 - p2 * u2]
 

test/dep_graphs.jl

@@ -1,13 +1,13 @@
 using Test
 using ModelingToolkit, Graphs, JumpProcesses
-
+using ModelingToolkit: t_nounits as t, D_nounits as D
 import ModelingToolkit: value
 
 #################################
 #  testing for Jumps / all dgs
 #################################
 @parameters k1 k2
-@variables t S(t) I(t) R(t)
+@variables S(t) I(t) R(t)
 j₁ = MassActionJump(k1, [0 => 1], [S => 1])
 j₂ = MassActionJump(k1, [S => 1], [S => -1])
 j₃ = MassActionJump(k2, [S => 1, I => 1], [S => -1, I => 1])
@@ -76,8 +76,7 @@ dg4 = varvar_dependencies(depsbg, deps2)
 #       testing for ODE/SDEs
 #####################################
 @parameters k1 k2
-@variables t S(t) I(t) R(t)
-D = Differential(t)
+@variables S(t) I(t) R(t)
 eqs = [D(S) ~ k1 - k1 * S - k2 * S * I - k1 * k2 / (1 + t) * S,
     D(I) ~ k2 * S * I,
     D(R) ~ -k2 * S^2 * R / 2 + k1 * I + k1 * k2 * S / (1 + t)]
@@ -93,7 +92,7 @@ eq_sdeps = [[S, I], [S, I], [S, I, R]]
 @test all(i -> isequal(Set(eq_sdeps[i]), Set(deps[i])), 1:length(deps))
 
 @parameters k1 k2
-@variables t S(t) I(t) R(t)
+@variables S(t) I(t) R(t)
 @named sdes = SDESystem(eqs, noiseeqs, t, [S, I, R], [k1, k2])
 deps = equation_dependencies(sdes)
 @test all(i -> isequal(Set(eq_sdeps[i]), Set(deps[i])), 1:length(deps))

test/distributed.jl

@@ -3,11 +3,11 @@ using Distributed
 addprocs(2)
 
 @everywhere using ModelingToolkit, OrdinaryDiffEq
+@everywhere using ModelingToolkit: t_nounits as t, D_nounits as D
 
 # create the Lorenz system
-@everywhere @parameters t σ ρ β
+@everywhere @parameters σ ρ β
 @everywhere @variables x(t) y(t) z(t)
-@everywhere D = Differential(t)
 
 @everywhere eqs = [D(x) ~ σ * (y - x),
     D(y) ~ x * (ρ - z) - y,

test/domain_connectors.jl

@@ -1,10 +1,8 @@
 using ModelingToolkit
+using ModelingToolkit: t_nounits as t, D_nounits as D
 using Test
 using IfElse: ifelse
 
-@parameters t
-D = Differential(t)
-
 @connector function HydraulicPort(; p_int, name)
     pars = @parameters begin
         ρ

test/dq_units.jl

@@ -1,9 +1,9 @@
 using ModelingToolkit, OrdinaryDiffEq, JumpProcesses, IfElse, DynamicQuantities
 using Test
 MT = ModelingToolkit
+using ModelingToolkit: t, D
 @parameters τ [unit = u"s"] γ
-@variables t [unit = u"s"] E(t) [unit = u"J"] P(t) [unit = u"W"]
-D = Differential(t)
+@variables E(t) [unit = u"J"] P(t) [unit = u"W"]
 
 # Basic access
 @test MT.get_unit(t) == u"s"
@@ -66,22 +66,11 @@ good_eqs = [connect(p1, p2)]
 @named sys = ODESystem(good_eqs, t, [], [])
 
 # Array variables
-@variables t [unit = u"s"] x(t)[1:3] [unit = u"m"]
+@variables x(t)[1:3] [unit = u"m"]
 @parameters v[1:3]=[1, 2, 3] [unit = u"m/s"]
-D = Differential(t)
 eqs = D.(x) .~ v
 ODESystem(eqs, name = :sys)
 
-# Difference equation
-@parameters t [unit = u"s"] a [unit = u"s"^-1]
-@variables x(t) [unit = u"kg"]
-δ = Differential(t)
-D = Difference(t; dt = 0.1u"s")
-eqs = [
-    δ(x) ~ a * x,
-]
-de = ODESystem(eqs, t, [x], [a], name = :sys)
-
 # Nonlinear system
 @parameters a [unit = u"kg"^-1]
 @variables x [unit = u"kg"]
@@ -92,8 +81,7 @@ eqs = [
 
 # SDE test w/ noise vector
 @parameters τ [unit = u"s"] Q [unit = u"W"]
-@variables t [unit = u"s"] E(t) [unit = u"J"] P(t) [unit = u"W"]
-D = Differential(t)
+@variables E(t) [unit = u"J"] P(t) [unit = u"W"]
 eqs = [D(E) ~ P - E / τ
     P ~ Q]
 
@@ -112,9 +100,8 @@ noiseeqs = [0.1u"W" 0.1u"W"
 @test !MT.validate(eqs, noiseeqs)
 
 # Non-trivial simplifications
-@variables t [unit = u"s"] V(t) [unit = u"m"^3] L(t) [unit = u"m"]
+@variables V(t) [unit = u"m"^3] L(t) [unit = u"m"]
 @parameters v [unit = u"m/s"] r [unit = u"m"^3 / u"s"]
-D = Differential(t)
 eqs = [D(L) ~ v,
     V ~ L^3]
 @named sys = ODESystem(eqs)
@@ -126,7 +113,7 @@ eqs = [D(V) ~ r,
 sys_simple = structural_simplify(sys)
 
 @variables V [unit = u"m"^3] L [unit = u"m"]
-@parameters v [unit = u"m/s"] r [unit = u"m"^3 / u"s"] t [unit = u"s"]
+@parameters v [unit = u"m/s"] r [unit = u"m"^3 / u"s"]
 eqs = [V ~ r * t,
     V ~ L^3]
 @named sys = NonlinearSystem(eqs, [V, L], [t, r])
@@ -138,7 +125,7 @@ eqs = [L ~ v * t,
 sys_simple = structural_simplify(sys)
 
 #Jump System
-@parameters β [unit = u"(mol^2*s)^-1"] γ [unit = u"(mol*s)^-1"] t [unit = u"s"] jumpmol [
+@parameters β [unit = u"(mol^2*s)^-1"] γ [unit = u"(mol*s)^-1"] jumpmol [
     unit = u"mol",
 ]
 @variables S(t) [unit = u"mol"] I(t) [unit = u"mol"] R(t) [unit = u"mol"]
@@ -164,9 +151,9 @@ maj2 = MassActionJump(γ, [I => 1], [I => -1, R => 1])
 @named js3 = JumpSystem([maj1, maj2], t, [S, I, R], [β, γ])
 
 #Test unusual jump system
-@parameters β γ t
+@parameters β γ
 @variables S(t) I(t) R(t)
 
 maj1 = MassActionJump(2.0, [0 => 1], [S => 1])
 maj2 = MassActionJump(γ, [S => 1], [S => -1])
-@named js4 = JumpSystem([maj1, maj2], t, [S], [β, γ])
+@named js4 = JumpSystem([maj1, maj2], ModelingToolkit.t_nounits, [S], [β, γ])

test/funcaffect.jl

@@ -1,9 +1,8 @@
 using ModelingToolkit, Test, OrdinaryDiffEq
+using ModelingToolkit: t_nounits as t, D_nounits as D
 
-@parameters t
 @constants h=1 zr=0
 @variables u(t)
-D = Differential(t)
 
 eqs = [D(u) ~ -u]
 
@@ -168,7 +167,6 @@ function Capacitor2(; name, C = 1.0)
     @named oneport = OnePort()
     @unpack v, i = oneport
     ps = @parameters C = C
-    D = Differential(t)
     eqs = [
         D(v) ~ i / C,
     ]

test/function_registration.jl

@@ -7,9 +7,9 @@
 # ------------------------------------------------
 module MyModule
 using ModelingToolkit, DiffEqBase, LinearAlgebra, Test
-@parameters t x
+using ModelingToolkit: t_nounits as t, D_nounits as Dt
+@parameters x
 @variables u(t)
-Dt = Differential(t)
 
 function do_something(a)
     a + 10
@@ -30,9 +30,9 @@ end
 module MyModule2
 module MyNestedModule
 using ModelingToolkit, DiffEqBase, LinearAlgebra, Test
-@parameters t x
+using ModelingToolkit: t_nounits as t, D_nounits as Dt
+@parameters x
 @variables u(t)
-Dt = Differential(t)
 
 function do_something_2(a)
     a + 20
@@ -52,9 +52,9 @@ end
 # TEST: Function registration outside any modules.
 # ------------------------------------------------
 using ModelingToolkit, DiffEqBase, LinearAlgebra, Test
-@parameters t x
+using ModelingToolkit: t_nounits as t, D_nounits as Dt
+@parameters x
 @variables u(t)
-Dt = Differential(t)
 
 function do_something_3(a)
     a + 30
@@ -72,9 +72,8 @@ u0 = 7.0
 # TEST: Function registration works with derivatives.
 # ---------------------------------------------------
 foo(x, y) = sin(x) * cos(y)
-@parameters t;
 @variables x(t) y(t) z(t);
-D = Differential(t);
+D = Dt
 @register_symbolic foo(x, y)
 
 using ModelingToolkit: value, arguments, operation
@@ -97,9 +96,8 @@ function do_something_4(a)
 end
 @register_symbolic do_something_4(a)
 function build_ode()
-    @parameters t x
+    @parameters x
     @variables u(t)
-    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)