reset test file

Author: vyudu

test/downstream/linearize.jl

@@ -13,27 +13,25 @@ eqs = [u ~ kp * (r - y)
        y ~ x]
 
 @named sys = ODESystem(eqs, t)
-sys1 = structural_simplify(sys, inputs = [r], outputs = [y])
 
-lsys = linearize(sys1)
-lprob = LinearizationProblem(sys1)
+lsys, ssys = linearize(sys, [r], [y])
+lprob = LinearizationProblem(sys, [r], [y])
 lsys2 = solve(lprob)
-lsys3 = linearize(sys1; autodiff = AutoFiniteDiff())
+lsys3, _ = linearize(sys, [r], [y]; autodiff = AutoFiniteDiff())
 
 @test lsys.A[] == lsys2.A[] == lsys3.A[] == -2
 @test lsys.B[] == lsys2.B[] == lsys3.B[] == 1
 @test lsys.C[] == lsys2.C[] == lsys3.C[] == 1
 @test lsys.D[] == lsys2.D[] == lsys3.D[] == 0
 
-sys2 = structural_simplify(sys, inputs = [r], outputs = [r])
-lsys = linearize(sys2)
+lsys, ssys = linearize(sys, [r], [r])
 
 @test lsys.A[] == -2
 @test lsys.B[] == 1
 @test lsys.C[] == 0
 @test lsys.D[] == 1
 
-lsys = linearize(sys2, r, r) # Test allow scalars
+lsys, ssys = linearize(sys, r, r) # Test allow scalars
 
 @test lsys.A[] == -2
 @test lsys.B[] == 1
@@ -88,21 +86,20 @@ connections = [f.y ~ c.r # filtered reference to controller reference
                p.y ~ c.y]
 
 @named cl = ODESystem(connections, t, systems = [f, c, p])
-cl = structural_simplify(cl, inputs = [f.u], outputs = [p.x])
 
-lsys0 = linearize(cl)
+lsys0, ssys = linearize(cl, [f.u], [p.x])
 desired_order = [f.x, p.x]
-lsys = ModelingToolkit.reorder_unknowns(lsys0, unknowns(cl), desired_order)
-lsys1 = linearize(cl, [f.u], [p.x]; autodiff = AutoFiniteDiff())
-lsys2 = ModelingToolkit.reorder_unknowns(lsys1, unknowns(cl), desired_order)
+lsys = ModelingToolkit.reorder_unknowns(lsys0, unknowns(ssys), desired_order)
+lsys1, ssys = linearize(cl, [f.u], [p.x]; autodiff = AutoFiniteDiff())
+lsys2 = ModelingToolkit.reorder_unknowns(lsys1, unknowns(ssys), desired_order)
 
 @test lsys.A == lsys2.A == [-2 0; 1 -2]
 @test lsys.B == lsys2.B == reshape([1, 0], 2, 1)
 @test lsys.C == lsys2.C == [0 1]
 @test lsys.D[] == lsys2.D[] == 0
 
 ## Symbolic linearization
-lsyss = ModelingToolkit.linearize_symbolic(cl)
+lsyss, _ = ModelingToolkit.linearize_symbolic(cl, [f.u], [p.x])
 
 @test ModelingToolkit.fixpoint_sub(lsyss.A, ModelingToolkit.defaults(cl)) == lsys.A
 @test ModelingToolkit.fixpoint_sub(lsyss.B, ModelingToolkit.defaults(cl)) == lsys.B
@@ -117,18 +114,18 @@ Nd = 10
 @named pid = LimPID(; k, Ti, Td, Nd)
 
 @unpack reference, measurement, ctr_output = pid
-pid_s = structural_simplify(pid, inputs = [reference.u, measurement.u], outputs = [ctr_output.u])
-lsys0 = linearize(pid_s; op = Dict(reference.u => 0.0, measurement.u => 0.0))
-@unpack int, der = pid_s
+lsys0, ssys = linearize(pid, [reference.u, measurement.u], [ctr_output.u];
+    op = Dict(reference.u => 0.0, measurement.u => 0.0))
+@unpack int, der = pid
 desired_order = [int.x, der.x]
-lsys = ModelingToolkit.reorder_unknowns(lsys0, unknowns(pid_s), desired_order)
+lsys = ModelingToolkit.reorder_unknowns(lsys0, unknowns(ssys), desired_order)
 
 @test lsys.A == [0 0; 0 -10]
 @test lsys.B == [2 -2; 10 -10]
 @test lsys.C == [400 -4000]
 @test lsys.D == [4400 -4400]
 
-lsyss = ModelingToolkit.linearize_symbolic(pid_s, [reference.u, measurement.u],
+lsyss, _ = ModelingToolkit.linearize_symbolic(pid, [reference.u, measurement.u],
     [ctr_output.u])
 
 @test ModelingToolkit.fixpoint_sub(
@@ -141,7 +138,7 @@ lsyss = ModelingToolkit.linearize_symbolic(pid_s, [reference.u, measurement.u],
     lsyss.D, ModelingToolkit.defaults_and_guesses(pid)) == lsys.D
 
 # Test with the reverse desired unknown order as well to verify that similarity transform and reoreder_unknowns really works
-lsys = ModelingToolkit.reorder_unknowns(lsys, unknowns(pid_s), reverse(desired_order))
+lsys = ModelingToolkit.reorder_unknowns(lsys, unknowns(ssys), reverse(desired_order))
 
 @test lsys.A == [-10 0; 0 0]
 @test lsys.B == [10 -10; 2 -2]
@@ -150,17 +147,17 @@ lsys = ModelingToolkit.reorder_unknowns(lsys, unknowns(pid_s), reverse(desired_o
 
 ## Test that there is a warning when input is misspecified
 if VERSION >= v"1.8"
-    @test_throws "Some specified inputs were not found in system. The following variables were not found " structural_simplify(pid, inputs = 
+    @test_throws "Some specified inputs were not found" linearize(pid,
         [
             pid.reference.u,
             pid.measurement.u
-           ], outputs = [ctr_output.u])
-    @test_throws "Some specified outputs were not found in system." structural_simplify(pid,
-        inputs = [
+        ], [ctr_output.u])
+    @test_throws "Some specified outputs were not found" linearize(pid,
+        [
             reference.u,
             measurement.u
         ],
-        outputs = [pid.ctr_output.u])
+        [pid.ctr_output.u])
 else # v1.6 does not have the feature to match error message
     @test_throws ErrorException linearize(pid,
         [
@@ -186,23 +183,22 @@ function saturation(; y_max, y_min = y_max > 0 ? -y_max : -Inf, name)
     ODESystem(eqs, t, name = name)
 end
 @named sat = saturation(; y_max = 1)
-sat = structural_simplify(sat, inputs = [u], outputs = [y])
 # inside the linear region, the function is identity
 @unpack u, y = sat
-lsys = linearize(sat, [u], [y])
+lsys, ssys = linearize(sat, [u], [y])
 @test isempty(lsys.A) # there are no differential variables in this system
 @test isempty(lsys.B)
 @test isempty(lsys.C)
 @test lsys.D[] == 1
 
-@test_skip lsyss = ModelingToolkit.linearize_symbolic(sat, [u], [y]) # Code gen replaces ifelse with if statements causing symbolic evaluation to fail
+@test_skip lsyss, _ = ModelingToolkit.linearize_symbolic(sat, [u], [y]) # Code gen replaces ifelse with if statements causing symbolic evaluation to fail
 # @test substitute(lsyss.A, ModelingToolkit.defaults(sat)) == lsys.A
 # @test substitute(lsyss.B, ModelingToolkit.defaults(sat)) == lsys.B
 # @test substitute(lsyss.C, ModelingToolkit.defaults(sat)) == lsys.C
 # @test substitute(lsyss.D, ModelingToolkit.defaults(sat)) == lsys.D
 
 # outside the linear region the derivative is 0
-lsys = linearize(sat, [u], [y]; op = Dict(u => 2))
+lsys, ssys = linearize(sat, [u], [y]; op = Dict(u => 2))
 @test isempty(lsys.A) # there are no differential variables in this system
 @test isempty(lsys.B)
 @test isempty(lsys.C)
@@ -269,8 +265,7 @@ closed_loop = ODESystem(connections, t, systems = [model, pid, filt, sensor, r,
         filt.xd => 0.0
     ])
 
-closed_loop = structural_simplify(closed_loop, inputs = :r, outputs = :y)
-linearize(closed_loop; warn_empty_op = false)
+@test_nowarn linearize(closed_loop, :r, :y; warn_empty_op = false)
 
 # https://discourse.julialang.org/t/mtk-change-in-linearize/115760/3
 @mtkmodel Tank_noi begin
@@ -300,7 +295,6 @@ end
 
 @named tank_noi = Tank_noi()
 @unpack md_i, h, m = tank_noi
-tank_noi = structural_simplify(tank_noi, inputs = [md_i], outputs = [h])
 m_ss = 2.4000000003229878
 @test_nowarn linearize(tank_noi, [md_i], [h]; op = Dict(m => m_ss, md_i => 2))
 
@@ -309,14 +303,13 @@ m_ss = 2.4000000003229878
 @parameters p = 1.0
 eqs = [D(x) ~ p * u, x ~ y]
 @named sys = ODESystem(eqs, t)
-sys = structural_simplify(sys, inputs = [u])
 
-matrices1 = linearize(sys, [u], []; op = Dict(x => 2.0))
-matrices2 = linearize(sys, [u], []; op = Dict(y => 2.0))
+matrices1, _ = linearize(sys, [u], []; op = Dict(x => 2.0))
+matrices2, _ = linearize(sys, [u], []; op = Dict(y => 2.0))
 @test matrices1 == matrices2
 
 # Ensure parameter values passed as `Dict` are respected
-linfun = linearization_function(sys, [u], []; op = Dict(x => 2.0))
+linfun, _ = linearization_function(sys, [u], []; op = Dict(x => 2.0))
 matrices = linfun([1.0], Dict(p => 3.0), 1.0)
 # this would be 1 if the parameter value isn't respected
 @test matrices.f_u[] == 3.0
@@ -332,28 +325,26 @@ end
     @parameters p
     eqs = [0 ~ x * log(y) - p]
     @named sys = ODESystem(eqs, t; defaults = [p => 1.0])
-    sys = structural_simplify(sys, inputs = [x])
+    sys = complete(sys)
     @test_throws ModelingToolkit.MissingVariablesError linearize(
-        sys; op = Dict(x => 1.0), allow_input_derivatives = true)
+        sys, [x], []; op = Dict(x => 1.0), allow_input_derivatives = true)
     @test_nowarn linearize(
-        sys; op = Dict(x => 1.0), guesses = Dict(y => 1.0),
+        sys, [x], []; op = Dict(x => 1.0), guesses = Dict(y => 1.0),
         allow_input_derivatives = true)
 end
 
 @testset "Symbolic values for parameters in `linearize`" begin
     @named tank_noi = Tank_noi()
     @unpack md_i, h, m, ρ, A, K = tank_noi
-    tank_noi = structural_simplify(tank_noi, inputs = [md_i], outputs = [h])
     m_ss = 2.4000000003229878
     @test_nowarn linearize(
-        tank_noi; op = Dict(m => m_ss, md_i => 2, ρ => A / K, A => 5))
+        tank_noi, [md_i], [h]; op = Dict(m => m_ss, md_i => 2, ρ => A / K, A => 5))
 end
 
 @testset "Warn on empty operating point" begin
     @named tank_noi = Tank_noi()
     @unpack md_i, h, m = tank_noi
-    tank_noi = structural_simplify(tank_noi, inputs = [md_i], outputs = [h])
     m_ss = 2.4000000003229878
     @test_warn ["empty operating point", "warn_empty_op"] linearize(
-        tank_noi; p = [md_i => 1.0])
+        tank_noi, [md_i], [h]; p = [md_i => 1.0])
 end