Force name specification

Author: YingboMa

examples/rc_model.jl

@@ -14,4 +14,5 @@ rc_eqs = [
           connect(capacitor.n, source.n, ground.g)
          ]
 
-@named rc_model = compose(ODESystem(rc_eqs, t), [resistor, capacitor, source, ground])
+@named rc_model = ODESystem(rc_eqs, t)
+rc_model = compose(rc_model, [resistor, capacitor, source, ground])

examples/serial_inductor.jl

@@ -13,4 +13,5 @@ eqs = [
        connect(source.n, inductor2.n, ground.g)
       ]
 
-@named ll_model = compose(ODESystem(eqs, t), source, resistor, inductor1, inductor2, ground)
+@named ll_model = ODESystem(eqs, t)
+ll_model = compose(ll_model, [source, resistor, inductor1, inductor2, ground])

src/systems/control/controlsystem.jl

@@ -197,5 +197,5 @@ function runge_kutta_discretize(sys::ControlSystem,dt,tspan;
     equalities = vcat(stages,updates,control_equality)
     opt_states = vcat(reduce(vcat,reduce(vcat,states_timeseries)),reduce(vcat,reduce(vcat,k_timeseries)),reduce(vcat,reduce(vcat,control_timeseries)))
 
-    OptimizationSystem(reduce(+,losses, init=0),opt_states,ps,equality_constraints = equalities)
+    OptimizationSystem(reduce(+,losses, init=0),opt_states,ps,equality_constraints = equalities, name=nameof(sys))
 end

src/systems/diffeqs/sdesystem.jl

@@ -148,10 +148,11 @@ $(TYPEDSIGNATURES)
 Choose correction_factor=-1//2 (1//2) to converte Ito -> Stratonovich (Stratonovich->Ito).
 """
 function stochastic_integral_transform(sys::SDESystem, correction_factor)
+    name = nameof(sys)
     # use the general interface
     if typeof(get_noiseeqs(sys)) <: Vector
         eqs = vcat([equations(sys)[i].lhs ~ get_noiseeqs(sys)[i] for i in eachindex(states(sys))]...)
-        de = ODESystem(eqs,get_iv(sys),states(sys),parameters(sys))
+        de = ODESystem(eqs,get_iv(sys),states(sys),parameters(sys),name=name)
 
         jac = calculate_jacobian(de, sparse=false, simplify=false)
         ∇σσ′ = simplify.(jac*get_noiseeqs(sys))
@@ -160,13 +161,13 @@ function stochastic_integral_transform(sys::SDESystem, correction_factor)
     else
         dimstate, m = size(get_noiseeqs(sys))
         eqs = vcat([equations(sys)[i].lhs ~ get_noiseeqs(sys)[i] for i in eachindex(states(sys))]...)
-        de = ODESystem(eqs,get_iv(sys),states(sys),parameters(sys))
+        de = ODESystem(eqs,get_iv(sys),states(sys),parameters(sys),name=name)
 
         jac = calculate_jacobian(de, sparse=false, simplify=false)
         ∇σσ′ = simplify.(jac*get_noiseeqs(sys)[:,1])
         for k = 2:m
             eqs = vcat([equations(sys)[i].lhs ~ get_noiseeqs(sys)[Int(i+(k-1)*dimstate)] for i in eachindex(states(sys))]...)
-            de = ODESystem(eqs,get_iv(sys),states(sys),parameters(sys))
+            de = ODESystem(eqs,get_iv(sys),states(sys),parameters(sys),name=name)
 
             jac = calculate_jacobian(de, sparse=false, simplify=false)
             ∇σσ′ = ∇σσ′ + simplify.(jac*get_noiseeqs(sys)[:,k])
@@ -176,7 +177,7 @@ function stochastic_integral_transform(sys::SDESystem, correction_factor)
     end
 
 
-    SDESystem(deqs,get_noiseeqs(sys),get_iv(sys),states(sys),parameters(sys))
+    SDESystem(deqs,get_noiseeqs(sys),get_iv(sys),states(sys),parameters(sys),name=name)
 end
 
 """

test/controlsystem.jl

@@ -10,7 +10,7 @@ eqs = [
     D(v) ~ p[1]*u^3 + v
 ]
 
-sys = ControlSystem(loss,eqs,t,[x,v],[u],p)
+@named sys = ControlSystem(loss,eqs,t,[x,v],[u],p)
 dt = 0.1
 tspan = (0.0,1.0)
 sys = runge_kutta_discretize(sys,dt,tspan)
@@ -27,5 +27,5 @@ sol = solve(prob,BFGS())
     ]
     sys1 = ControlSystem(loss,eqs_short, t, [x, v], [u], p, name = :sys1)
     sys2 = ControlSystem(loss,eqs_short, t, [x, v], [u], p, name = :sys1)
-    @test_throws ArgumentError ControlSystem(loss, [sys2.v ~ sys1.v], t, [], [], [], systems = [sys1, sys2])
+    @test_throws ArgumentError ControlSystem(loss, [sys2.v ~ sys1.v], t, [], [], [], systems = [sys1, sys2], name=:foo)
 end

test/dep_graphs.jl

@@ -13,7 +13,7 @@ rxs = [Reaction(k1, nothing, [S]),
        Reaction(k2, [S,R], [S], [2,1], [2]),
        Reaction(k1*I, nothing, [R]),
        Reaction(k1*k2/(1+t), [S], [R])]
-rs = ReactionSystem(rxs, t, [S,I,R], [k1,k2])
+@named rs = ReactionSystem(rxs, t, [S,I,R], [k1,k2])
 
 
 #################################
@@ -98,7 +98,7 @@ s_eqdeps = [[1],[2],[3]]
 eqs = [0 ~ σ*(y-x),
        0 ~ ρ-y,
        0 ~ y - β*z]
-ns = NonlinearSystem(eqs, [x,y,z],[σ,ρ,β])
+@named ns = NonlinearSystem(eqs, [x,y,z],[σ,ρ,β])
 deps = equation_dependencies(ns)
 eq_sdeps = [[x,y],[y],[y,z]]
 @test all(i -> isequal(Set(deps[i]),Set(value.(eq_sdeps[i]))), 1:length(deps))

test/discretesystem.jl

@@ -23,7 +23,7 @@ eqs = [D(S) ~ S-infection,
        D(R) ~ R+recovery]
 
 # System
-sys = DiscreteSystem(eqs,t,[S,I,R],[c,nsteps,δt,β,γ]; controls = [β, γ])
+@named sys = DiscreteSystem(eqs,t,[S,I,R],[c,nsteps,δt,β,γ]; controls = [β, γ])
 
 # Problem
 u0 = [S => 990.0, I => 10.0, R => 0.0]
@@ -55,4 +55,4 @@ p = [0.05,10.0,0.25,0.1];
 prob_map = DiscreteProblem(sir_map!,u0,tspan,p);
 sol_map2 = solve(prob_map,FunctionMap());
 
-@test Array(sol_map) ≈ Array(sol_map2)
+@test Array(sol_map) ≈ Array(sol_map2)

test/distributed.jl

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

test/function_registration.jl

@@ -18,7 +18,7 @@ module MyModule
     @register do_something(a)
 
     eq  = Dt(u) ~ do_something(x) + MyModule.do_something(x)
-    sys = ODESystem([eq], t, [u], [x])
+    @named sys = ODESystem([eq], t, [u], [x])
     fun = ODEFunction(sys)
 
     u0 = 5.0
@@ -41,7 +41,7 @@ module MyModule2
         @register do_something_2(a)
 
         eq  = Dt(u) ~ do_something_2(x) + MyNestedModule.do_something_2(x)
-        sys = ODESystem([eq], t, [u], [x])
+        @named sys = ODESystem([eq], t, [u], [x])
         fun = ODEFunction(sys)
 
         u0 = 3.0
@@ -63,7 +63,7 @@ end
 @register do_something_3(a)
 
 eq  = Dt(u) ~ do_something_3(x) + (@__MODULE__).do_something_3(x)
-sys = ODESystem([eq], t, [u], [x])
+@named sys = ODESystem([eq], t, [u], [x])
 fun = ODEFunction(sys)
 
 u0 = 7.0
@@ -101,7 +101,7 @@ function build_ode()
     @variables u(t)
     Dt = Differential(t)
     eq  = Dt(u) ~ do_something_4(x) + (@__MODULE__).do_something_4(x)
-    sys = ODESystem([eq], t, [u], [x])
+    @named sys = ODESystem([eq], t, [u], [x])
     fun = ODEFunction(sys, eval_expression=false)
 end
 function run_test()

test/jumpsystem.jl

@@ -10,7 +10,7 @@ rate₂   = γ*I+t
 affect₂ = [I ~ I - 1, R ~ R + 1]
 j₁      = ConstantRateJump(rate₁,affect₁)
 j₂      = VariableRateJump(rate₂,affect₂)
-js      = JumpSystem([j₁,j₂], t, [S,I,R], [β,γ])
+@named js = JumpSystem([j₁,j₂], t, [S,I,R], [β,γ])
 statetoid = Dict(MT.value(state) => i for (i,state) in enumerate(states(js)))
 mtjump1 = MT.assemble_crj(js, j₁, statetoid)
 mtjump2 = MT.assemble_vrj(js, j₂, statetoid)
@@ -54,7 +54,7 @@ jump2.affect!(integrator)
 rate₃   = γ*I
 affect₃ = [I ~ I - 1, R ~ R + 1]
 j₃ = ConstantRateJump(rate₃,affect₃)
-js2 = JumpSystem([j₁,j₃], t, [S,I,R], [β,γ])
+@named js2 = JumpSystem([j₁,j₃], t, [S,I,R], [β,γ])
 u₀ = [999,1,0]; p = (0.1/1000,0.01); tspan = (0.,250.)
 u₀map = [S => 999, I => 1, R => 0]
 parammap = [β => .1/1000, γ => .01]
@@ -115,14 +115,14 @@ m2 = getmean(jprob,Nsims)
 # mass action jump tests for SIR model
 maj1 = MassActionJump(2*β/2, [S => 1, I => 1], [S => -1, I => 1])
 maj2 = MassActionJump(γ, [I => 1], [I => -1, R => 1])
-js3   = JumpSystem([maj1,maj2], t, [S,I,R], [β,γ])
+@named js3 = JumpSystem([maj1,maj2], t, [S,I,R], [β,γ])
 dprob = DiscreteProblem(js3, u₀map, tspan, parammap)
 jprob = JumpProblem(js3, dprob, Direct())
 m3 = getmean(jprob,Nsims)
 @test abs(m-m3)/m < .01
 
 # maj jump test with various dep graphs
-js3b = JumpSystem([maj1,maj2], t, [S,I,R], [β,γ])
+@named js3b = JumpSystem([maj1,maj2], t, [S,I,R], [β,γ])
 jprobb = JumpProblem(js3b, dprob, NRM())
 m4 = getmean(jprobb,Nsims)
 @test abs(m-m4)/m < .01
@@ -133,7 +133,7 @@ m4 = getmean(jprobc,Nsims)
 # mass action jump tests for other reaction types (zero order, decay)
 maj1 = MassActionJump(2.0, [0 => 1], [S => 1])
 maj2 = MassActionJump(γ, [S => 1], [S => -1])
-js4   = JumpSystem([maj1,maj2], t, [S], [β,γ])
+@named js4 = JumpSystem([maj1,maj2], t, [S], [β,γ])
 dprob = DiscreteProblem(js4, [S => 999], (0,1000.), [β => 100.,γ => .01])
 jprob = JumpProblem(js4, dprob, Direct())
 m4 = getmean(jprob,Nsims)
@@ -142,7 +142,7 @@ m4 = getmean(jprob,Nsims)
 # test second order rx runs
 maj1 = MassActionJump(2.0, [0 => 1], [S => 1])
 maj2 = MassActionJump(γ, [S => 2], [S => -1])
-js4   = JumpSystem([maj1,maj2], t, [S], [β,γ])
+@named js4 = JumpSystem([maj1,maj2], t, [S], [β,γ])
 dprob = DiscreteProblem(js4, [S => 999], (0,1000.), [β => 100.,γ => .01])
 jprob = JumpProblem(js4, dprob, Direct())
 sol = solve(jprob, SSAStepper());
@@ -151,15 +151,15 @@ sol = solve(jprob, SSAStepper());
 @testset "Combined system name collisions" begin
   sys1 = JumpSystem([maj1, maj2], t, [S], [β, γ], name = :sys1)
   sys2 = JumpSystem([maj1, maj2], t, [S], [β, γ], name = :sys1)
-  @test_throws ArgumentError JumpSystem([sys1.γ ~ sys2.γ], t, [], [], systems = [sys1, sys2])
+  @test_throws ArgumentError JumpSystem([sys1.γ ~ sys2.γ], t, [], [], systems = [sys1, sys2], name=:foo)
 end
 
 # test if param mapper is setup correctly for callbacks
 @parameters k1 k2 k3
 @variables A(t) B(t)
 maj1 = MassActionJump(k1*k3, [0 => 1], [A => -1, B => 1])
 maj2 = MassActionJump(k2, [B => 1], [A => 1, B => -1])
-js5 = JumpSystem([maj1,maj2], t, [A,B], [k1,k2,k3])
+@named js5 = JumpSystem([maj1,maj2], t, [A,B], [k1,k2,k3])
 p  = [k1 => 2.0, k2 => 0.0, k3 => .5]
 u₀ = [A => 100, B => 0]
 tspan = (0.0,2000.0)

test/labelledarrays.jl

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

test/linearity.jl

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

test/lowering_solving.jl

@@ -8,14 +8,14 @@ eqs = [D(D(x)) ~ σ*(y-x),
        D(y) ~ x*(ρ-z)-y,
        D(z) ~ x*y - β*z]
 
-sys′ = ODESystem(eqs)
+@named sys′ = ODESystem(eqs)
 sys = ode_order_lowering(sys′)
 
 eqs2 = [0 ~ x*y - k,
         D(D(x)) ~ σ*(y-x),
         D(y) ~ x*(ρ-z)-y,
         D(z) ~ x*y - β*z]
-sys2 = ODESystem(eqs2, t, [x, y, z, k], parameters(sys′))
+@named sys2 = ODESystem(eqs2, t, [x, y, z, k], parameters(sys′))
 sys2 = ode_order_lowering(sys2)
 # test equation/varible ordering
 ModelingToolkit.calculate_massmatrix(sys2) == Diagonal([1, 1, 1, 1, 0])
@@ -51,7 +51,7 @@ lorenz2 = ODESystem(eqs,name=:lorenz2)
 @variables α(t)
 @parameters γ
 connections = [0 ~ lorenz1.x + lorenz2.y + α*γ]
-connected = ODESystem(connections,t,[α],[γ],systems=[lorenz1,lorenz2])
+@named connected = ODESystem(connections,t,[α],[γ],systems=[lorenz1,lorenz2])
 
 u0 = [lorenz1.x => 1.0,
       lorenz1.y => 0.0,

test/mass_matrix.jl

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

test/nonlinearsystem.jl

@@ -21,7 +21,7 @@ end
 eqs = [0 ~ σ*(y-x),
        0 ~ x*(ρ-z)-y,
        0 ~ x*y - β*z]
-ns = NonlinearSystem(eqs, [x,y,z], [σ,ρ,β], defaults = Dict(x => 2))
+@named ns = NonlinearSystem(eqs, [x,y,z], [σ,ρ,β], defaults = Dict(x => 2))
 @test eval(toexpr(ns)) == ns
 test_nlsys_inference("standard", ns, (x, y, z), (σ, ρ, β))
 @test begin
@@ -39,7 +39,7 @@ end
 eqs = [0 ~ σ*(y-x),
        y ~ x*(ρ-z),
        β*z ~ x*y]
-ns = NonlinearSystem(eqs, [x,y,z], [σ,ρ,β])
+@named ns = NonlinearSystem(eqs, [x,y,z], [σ,ρ,β])
 jac = calculate_jacobian(ns)
 @testset "nlsys jacobian" begin
     @test canonequal(jac[1,1], σ * -1)
@@ -62,7 +62,7 @@ a = y - x
 eqs = [0 ~ σ*a,
        0 ~ x*(ρ-z)-y,
        0 ~ x*y - β*z]
-ns = NonlinearSystem(eqs, [x,y,z], [σ,ρ,β])
+@named ns = NonlinearSystem(eqs, [x,y,z], [σ,ρ,β])
 nlsys_func = generate_function(ns, [x,y,z], [σ,ρ,β])
 nf = NonlinearFunction(ns)
 jac = calculate_jacobian(ns)
@@ -90,7 +90,7 @@ lorenz = name -> NonlinearSystem(eqs1, [x,y,z,u,F], [σ,ρ,β], name=name)
 lorenz1 = lorenz(:lorenz1)
 @test_throws ArgumentError NonlinearProblem(lorenz1, zeros(5))
 lorenz2 = lorenz(:lorenz2)
-connected = NonlinearSystem([s ~ a + lorenz1.x
+@named connected = NonlinearSystem([s ~ a + lorenz1.x
                              lorenz2.y ~ s
                              lorenz1.F ~ lorenz2.u
                              lorenz2.F ~ lorenz1.u], [s, a], [], systems=[lorenz1,lorenz2])
@@ -116,7 +116,7 @@ sol = solve(prob, Rodas5())
 eqs = [0 ~ σ*(y-x),
        0 ~ x*(ρ-z)-y,
        0 ~ x*y - β*z]
-ns = NonlinearSystem(eqs, [x,y,z], [σ,ρ,β])
+@named ns = NonlinearSystem(eqs, [x,y,z], [σ,ρ,β])
 np = NonlinearProblem(ns, [0,0,0], [1,2,3], jac=true, sparse=true)
 @test calculate_jacobian(ns, sparse=true) isa SparseMatrixCSC
 
@@ -132,7 +132,7 @@ np = NonlinearProblem(ns, [0,0,0], [1,2,3], jac=true, sparse=true)
        function issue819()
            sys1 = makesys(:sys1)
            sys2 = makesys(:sys1)
-           @test_throws ArgumentError NonlinearSystem([sys2.f ~ sys1.x, sys1.f ~ 0], [], [], systems = [sys1, sys2])
+           @test_throws ArgumentError NonlinearSystem([sys2.f ~ sys1.x, sys1.f ~ 0], [], [], systems = [sys1, sys2], name=:foo)
        end
        issue819()
 end