Update tests

Author: YingboMa

test/reduction.jl

@@ -29,20 +29,21 @@ D = Differential(t)
 
 test_equal(a, b) = @test isequal(simplify(a, polynorm=true), simplify(b, polynorm=true))
 
-eqs = [D(x) ~ σ*(y-x),
-       D(y) ~ x*(ρ-z)-y + β,
-       0 ~ sin(z) - x + y,
-       sin(u) ~ x + y,
-       2β ~ 2,
-       x ~ a,
+eqs = [
+       D(x) ~ σ*(y-x)
+       D(y) ~ x*(ρ-z)-y + β
+       0 ~ sin(z) - x + y
+       sin(u) ~ x + y
+       2β ~ 2
+       x ~ a
       ]
 
-lorenz1 = ODESystem(eqs,t,[u,x,y,z,a],[σ,ρ,β],name=:lorenz1)
+lorenz1 = ODESystem(eqs,t,name=:lorenz1)
 
 lorenz1_aliased = alias_elimination(lorenz1)
 reduced_eqs = [
                D(x) ~ σ * (y - x),
-               D(y) ~ x*(ρ-z)-y + 1,
+               D(y) ~ x*(ρ-z)-y + β,
                0 ~ sin(z) - x + y,
                0 ~ x + y - sin(u),
               ]
@@ -62,63 +63,57 @@ eqs1 = [
         u ~ x + y - z,
        ]
 
-lorenz1 = ODESystem(eqs1,pins=[F],name=:lorenz1)
-
-eqs2 = [
-        D(x) ~ F,
-        D(y) ~ x*(ρ-z)-x,
-        D(z) ~ x*y - β*z,
-        u ~ x - y - z
-       ]
-
-lorenz2 = ODESystem(eqs2,pins=[F],name=:lorenz2)
+lorenz = name -> ODESystem(eqs1,t,pins=[F],name=name)
+lorenz1 = lorenz(:lorenz1)
+lorenz2 = lorenz(:lorenz2)
 
-connected = ODESystem([lorenz2.y ~ a + lorenz1.x,
-                       lorenz1.F ~ lorenz2.u,
-                       lorenz2.F ~ lorenz1.u],t,[a],[],systems=[lorenz1,lorenz2])
+connected = ODESystem([s ~ a + lorenz1.x
+                       lorenz2.y ~ s
+                       lorenz1.F ~ lorenz2.u
+                       lorenz2.F ~ lorenz1.u],t,systems=[lorenz1,lorenz2])
 
 # Reduced Flattened System
 
 flattened_system = ModelingToolkit.flatten(connected)
 
 aliased_flattened_system = alias_elimination(flattened_system)
 
-@test isequal(states(aliased_flattened_system), [
+@test setdiff(states(aliased_flattened_system), [
         a
         lorenz1.x
         lorenz1.y
         lorenz1.z
         lorenz2.x
         lorenz2.y
         lorenz2.z
-       ])
+       ]) |> isempty
 
 @test setdiff(parameters(aliased_flattened_system), [
         lorenz1.σ
         lorenz1.ρ
         lorenz1.β
-        lorenz1.F
-        lorenz2.F
+        lorenz2.σ
         lorenz2.ρ
         lorenz2.β
        ]) |> isempty
 
 reduced_eqs = [
-               0 ~ a + lorenz1.x - lorenz2.y, # irreducible by alias elimination
-               D(lorenz1.x) ~ lorenz1.σ*(lorenz1.y-lorenz1.x) + lorenz2.x - lorenz2.y - lorenz2.z,
-               D(lorenz1.y) ~ lorenz1.x*(lorenz1.ρ-lorenz1.z)-(lorenz1.x + lorenz1.y - lorenz1.z),
-               D(lorenz1.z) ~ lorenz1.x*lorenz1.y - lorenz1.β*lorenz1.z,
-               D(lorenz2.x) ~ lorenz1.x + lorenz1.y - lorenz1.z,
-               D(lorenz2.y) ~ lorenz2.x*(lorenz2.ρ-lorenz2.z)-lorenz2.x,
-               D(lorenz2.z) ~ lorenz2.x*lorenz2.y - lorenz2.β*lorenz2.z
+               0 ~ s - lorenz2.y
+               D(lorenz1.x) ~ lorenz1.F + lorenz1.σ*(lorenz1.y + -1lorenz1.x)
+               D(lorenz1.y) ~ -1lorenz1.u + lorenz1.x*(lorenz1.ρ + -1lorenz1.z)
+               D(lorenz1.z) ~ lorenz1.x*lorenz1.y + -1lorenz1.β*lorenz1.z
+               D(lorenz2.x) ~ lorenz2.F + lorenz2.σ*(lorenz2.y + -1lorenz2.x)
+               D(lorenz2.y) ~ -1lorenz2.u + lorenz2.x*(lorenz2.ρ + -1lorenz2.z)
+               D(lorenz2.z) ~ lorenz2.x*lorenz2.y + -1lorenz2.β*lorenz2.z
               ]
 test_equal.(equations(aliased_flattened_system), reduced_eqs)
 
 observed_eqs = [
-                lorenz1.F ~ lorenz2.u,
-                lorenz2.F ~ lorenz1.u,
-                lorenz1.u ~ lorenz1.x + lorenz1.y - lorenz1.z,
-                lorenz2.u ~ lorenz2.x - lorenz2.y - lorenz2.z,
+                s ~ a + lorenz1.x
+                lorenz1.u ~ lorenz1.x + lorenz1.y - lorenz1.z
+                lorenz2.u ~ lorenz2.x + lorenz2.y - lorenz2.z
+                lorenz2.F ~ lorenz1.u
+                lorenz1.F ~ lorenz2.u
                ]
 test_equal.(observed(aliased_flattened_system), observed_eqs)
 
@@ -131,10 +126,10 @@ let
         D(x) ~ x + y
         x ~ y
     ]
-    sys = ODESystem(eqs, t, [x], [])
+    sys = ODESystem(eqs, t)
     asys = alias_elimination(flatten(sys))
 
-    test_equal.(asys.eqs, [D(x) ~ 2x])
+    test_equal.(asys.eqs, [D(x) ~ x + y])
     test_equal.(asys.observed, [y ~ x])
 end
 
@@ -149,17 +144,17 @@ let
     @parameters k_P
     pc = ODESystem(Equation[u_c ~ k_P * y_c], t, pins=[y_c], name=:pc)
     connections = [
-        ol.u ~ pc.u_c,
+        ol.u ~ pc.u_c
         pc.y_c ~ ol.y
     ]
     connected = ODESystem(connections, t, systems=[ol, pc])
     @test equations(connected) isa Vector{Equation}
     sys = flatten(connected)
     reduced_sys = alias_elimination(sys)
     ref_eqs = [
-               D(ol.x) ~ ol.a*ol.x + ol.b*pc.u_c
-               0 ~ ol.c*ol.x + ol.d*pc.u_c - ol.y
-               0 ~ pc.k_P*ol.y - pc.u_c
+               D(ol.x) ~ ol.a*ol.x + ol.b*ol.u
+               0 ~ ol.c*ol.x + ol.d*ol.u + -1ol.y
+               0 ~ pc.k_P*pc.y_c + -1pc.u_c
               ]
     @test ref_eqs == equations(reduced_sys)
 end