correct tests

Author: vyudu

src/linearization.jl

@@ -29,8 +29,8 @@ The `simplified_sys` has undergone [`structural_simplify`](@ref) and had any occ
 
 See also [`linearize`](@ref) which provides a higher-level interface.
 """
-function linearization_function(sys::AbstractSystem, inputs,
-        outputs;
+function linearization_function(sys::AbstractSystem, inputs = inputs(sys),
+        outputs = outputs(sys);
         initialize = true,
         initializealg = nothing,
         initialization_abstol = 1e-5,
@@ -396,7 +396,7 @@ Construct a `LinearizationProblem` for linearizing the system `sys` with the giv
 
 All other keyword arguments are forwarded to `linearization_function`.
 """
-function LinearizationProblem(sys::AbstractSystem, inputs, outputs; t = 0.0, kwargs...)
+function LinearizationProblem(sys::AbstractSystem, inputs = inputs(sys), outputs = outputs(sys); t = 0.0, kwargs...)
     linfun = linearization_function(sys, inputs, outputs; kwargs...)
     return LinearizationProblem(linfun, t)
 end
@@ -484,8 +484,8 @@ y &= h(x, z, u)
 ```
 where `x` are differential unknown variables, `z` algebraic variables, `u` inputs and `y` outputs.
 """
-function linearize_symbolic(sys::AbstractSystem, inputs,
-        outputs; allow_input_derivatives = false,
+function linearize_symbolic(sys::AbstractSystem, inputs = inputs(sys),
+        outputs = outputs(sys); allow_input_derivatives = false,
         eval_expression = false, eval_module = @__MODULE__,
         kwargs...)
     diff_idxs, alge_idxs = eq_idxs(sys)
@@ -546,7 +546,7 @@ function linearize_symbolic(sys::AbstractSystem, inputs,
         end
     end
 
-    (; A, B, C, D, f_x, f_z, g_x, g_z, f_u, g_u, h_x, h_z, h_u), sys
+    (; A, B, C, D, f_x, f_z, g_x, g_z, f_u, g_u, h_x, h_z, h_u)
 end
 
 function markio!(state, orig_inputs, inputs, outputs; check = true)
@@ -713,17 +713,17 @@ function linearize(sys, lin_fun::LinearizationFunction; t = 0.0,
     return solve(prob; allow_input_derivatives)
 end
 
-function linearize(sys, inputs, outputs; op = Dict(), t = 0.0,
+function linearize(sys, inputs = inputs(sys), outputs = outputs(sys); op = Dict(), t = 0.0,
         allow_input_derivatives = false,
         zero_dummy_der = false,
         kwargs...)
-    lin_fun, ssys = linearization_function(sys,
+    lin_fun = linearization_function(sys,
         inputs,
         outputs;
         zero_dummy_der,
         op,
         kwargs...)
-    linearize(ssys, lin_fun; op, t, allow_input_derivatives), ssys
+    linearize(sys, lin_fun; op, t, allow_input_derivatives)
 end
 
 """

src/systems/systems.jl

@@ -32,7 +32,7 @@ function structural_simplify(
         disturbance_inputs = Any[],
         kwargs...)
     isscheduled(sys) && throw(RepeatedStructuralSimplificationError())
-    newsys′ = __structural_simplify(sys; simplify,
+    newsys′ = __structural_simplification(sys; simplify,
         allow_symbolic, allow_parameter, conservative, fully_determined,
         inputs, outputs, disturbance_inputs,
         kwargs...)
@@ -64,12 +64,12 @@ function structural_simplify(
     end
 end
 
-function __structural_simplify(sys::JumpSystem, args...; kwargs...)
+function __structural_simplification(sys::JumpSystem, args...; kwargs...)
     return sys
 end
 
-function __structural_simplify(sys::SDESystem, args...; kwargs...)
-    return __structural_simplify(ODESystem(sys), args...; kwargs...)
+function __structural_simplification(sys::SDESystem, args...; kwargs...)
+    return __structural_simplification(ODESystem(sys), args...; kwargs...)
 end
 
 function __structural_simplification(sys::AbstractSystem; simplify = false,

test/downstream/linearize.jl

@@ -13,18 +13,20 @@ eqs = [u ~ kp * (r - y)
        y ~ x]
 
 @named sys = ODESystem(eqs, t)
+sys1 = structural_simplify(sys, inputs = [r], outputs = [y])
 
-lsys, ssys = linearize(sys, [r], [y])
-lprob = LinearizationProblem(sys, [r], [y])
+lsys = linearize(sys1)
+lprob = LinearizationProblem(sys1)
 lsys2 = solve(lprob)
-lsys3, _ = linearize(sys, [r], [y]; autodiff = AutoFiniteDiff())
+lsys3 = linearize(sys1; 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
 
-lsys = linearize(sys, [r], [r])
+sys2 = structural_simplify(sys, inputs = [r], outputs = [r])
+lsys = linearize(sys2)
 
 @test lsys.A[] == -2
 @test lsys.B[] == 1
@@ -86,8 +88,9 @@ 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, [f.u], [p.x])
+lsys0 = linearize(cl)
 desired_order = [f.x, p.x]
 lsys = ModelingToolkit.reorder_unknowns(lsys0, unknowns(cl), desired_order)
 lsys1 = linearize(cl, [f.u], [p.x]; autodiff = AutoFiniteDiff())
@@ -99,7 +102,7 @@ lsys2 = ModelingToolkit.reorder_unknowns(lsys1, unknowns(cl), desired_order)
 @test lsys.D[] == lsys2.D[] == 0
 
 ## Symbolic linearization
-lsyss = ModelingToolkit.linearize_symbolic(cl, [f.u], [p.x])
+lsyss = ModelingToolkit.linearize_symbolic(cl)
 
 @test ModelingToolkit.fixpoint_sub(lsyss.A, ModelingToolkit.defaults(cl)) == lsys.A
 @test ModelingToolkit.fixpoint_sub(lsyss.B, ModelingToolkit.defaults(cl)) == lsys.B
@@ -114,19 +117,18 @@ Nd = 10
 @named pid = LimPID(; k, Ti, Td, Nd)
 
 @unpack reference, measurement, ctr_output = pid
-pid = structural_simplify(pid, inputs = [reference.u, measurement.u], outputs = [ctr_output.u])
-lsys0 = linearize(pid, [reference.u, measurement.u], [ctr_output.u];
-    op = Dict(reference.u => 0.0, measurement.u => 0.0))
-@unpack int, der = 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
 desired_order = [int.x, der.x]
-lsys = ModelingToolkit.reorder_unknowns(lsys0, unknowns(pid), desired_order)
+lsys = ModelingToolkit.reorder_unknowns(lsys0, unknowns(pid_s), 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, [reference.u, measurement.u],
+lsyss = ModelingToolkit.linearize_symbolic(pid_s, [reference.u, measurement.u],
     [ctr_output.u])
 
 @test ModelingToolkit.fixpoint_sub(
@@ -139,7 +141,7 @@ lsyss, _ = ModelingToolkit.linearize_symbolic(pid, [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), reverse(desired_order))
+lsys = ModelingToolkit.reorder_unknowns(lsys, unknowns(pid_s), reverse(desired_order))
 
 @test lsys.A == [-10 0; 0 0]
 @test lsys.B == [10 -10; 2 -2]
@@ -148,17 +150,17 @@ lsys = ModelingToolkit.reorder_unknowns(lsys, unknowns(pid), reverse(desired_ord
 
 ## Test that there is a warning when input is misspecified
 if VERSION >= v"1.8"
-    @test_throws "Some parameters are missing from the variable map." linearize(pid,
+    @test_throws "Some specified inputs were not found in system. The following variables were not found " structural_simplify(pid, inputs = 
         [
             pid.reference.u,
             pid.measurement.u
-        ], [ctr_output.u])
-    @test_throws "Some parameters are missing from the variable map." linearize(pid,
-        [
+           ], outputs = [ctr_output.u])
+    @test_throws "Some specified outputs were not found in system." structural_simplify(pid,
+        inputs = [
             reference.u,
             measurement.u
         ],
-        [pid.ctr_output.u])
+        outputs = [pid.ctr_output.u])
 else # v1.6 does not have the feature to match error message
     @test_throws ErrorException linearize(pid,
         [
@@ -200,7 +202,7 @@ lsys = linearize(sat, [u], [y])
 # @test substitute(lsyss.D, ModelingToolkit.defaults(sat)) == lsys.D
 
 # outside the linear region the derivative is 0
-lsys, ssys = linearize(sat, [u], [y]; op = Dict(u => 2))
+lsys = 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)
@@ -306,12 +308,12 @@ m_ss = 2.4000000003229878
 eqs = [D(x) ~ p * u, x ~ y]
 @named sys = ODESystem(eqs, t)
 
-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
@@ -327,26 +329,28 @@ end
     @parameters p
     eqs = [0 ~ x * log(y) - p]
     @named sys = ODESystem(eqs, t; defaults = [p => 1.0])
-    sys = complete(sys)
+    sys = structural_simplify(sys, inputs = [x])
     @test_throws ModelingToolkit.MissingVariablesError linearize(
-        sys, [x], []; op = Dict(x => 1.0), allow_input_derivatives = true)
+        sys; op = Dict(x => 1.0), allow_input_derivatives = true)
     @test_nowarn linearize(
-        sys, [x], []; op = Dict(x => 1.0), guesses = Dict(y => 1.0),
+        sys; 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, [md_i], [h]; op = Dict(m => m_ss, md_i => 2, ρ => A / K, A => 5))
+        tank_noi; 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, [md_i], [h]; p = [md_i => 1.0])
+        tank_noi; p = [md_i => 1.0])
 end