refactor: remove references to ODESystem in source code

Author: AayushSabharwal

src/ModelingToolkit.jl

@@ -214,7 +214,7 @@ const D = Differential(t)
 PrecompileTools.@compile_workload begin
     using ModelingToolkit
     @variables x(ModelingToolkit.t_nounits)
-    @named sys = ODESystem([ModelingToolkit.D_nounits(x) ~ -x], ModelingToolkit.t_nounits)
+    @named sys = System([ModelingToolkit.D_nounits(x) ~ -x], ModelingToolkit.t_nounits)
     prob = ODEProblem(structural_simplify(sys), [x => 30.0], (0, 100), [], jac = true)
     @mtkmodel __testmod__ begin
         @constants begin

src/inputoutput.jl

@@ -161,7 +161,7 @@ has_var(ex, x) = x ∈ Set(get_variables(ex))
 
 """
     (f_oop, f_ip), x_sym, p_sym, io_sys = generate_control_function(
-            sys::AbstractODESystem,
+            sys::System,
             inputs             = unbound_inputs(sys),
             disturbance_inputs = nothing;
             implicit_dae       = false,
@@ -193,7 +193,7 @@ t = 0
 f[1](x, inputs, p, t)
 ```
 """
-function generate_control_function(sys::AbstractODESystem, inputs = unbound_inputs(sys),
+function generate_control_function(sys::AbstractSystem, inputs = unbound_inputs(sys),
         disturbance_inputs = disturbances(sys);
         disturbance_argument = false,
         implicit_dae = false,
@@ -344,7 +344,7 @@ The structure represents a model of a disturbance, along with the input variable
 # Fields:
 
   - `input`: The variable affected by the disturbance.
-  - `model::M`: A model of the disturbance. This is typically an `ODESystem`, but type that implements [`ModelingToolkit.get_disturbance_system`](@ref)`(dist::DisturbanceModel) -> ::ODESystem` is supported.
+  - `model::M`: A model of the disturbance. This is typically a `System`, but type that implements [`ModelingToolkit.get_disturbance_system`](@ref)`(dist::DisturbanceModel) -> ::System` is supported.
 """
 struct DisturbanceModel{M}
     input::Any
@@ -354,7 +354,7 @@ end
 DisturbanceModel(input, model; name) = DisturbanceModel(input, model, name)
 
 # Point of overloading for libraries, e.g., to be able to support disturbance models from ControlSystemsBase
-function get_disturbance_system(dist::DisturbanceModel{<:ODESystem})
+function get_disturbance_system(dist::DisturbanceModel{System})
     dist.model
 end
 
@@ -395,7 +395,7 @@ c = 10   # Damping coefficient
 eqs = [connect(torque.flange, inertia1.flange_a)
        connect(inertia1.flange_b, spring.flange_a, damper.flange_a)
        connect(inertia2.flange_a, spring.flange_b, damper.flange_b)]
-model = ODESystem(eqs, t; systems = [torque, inertia1, inertia2, spring, damper],
+model = System(eqs, t; systems = [torque, inertia1, inertia2, spring, damper],
                   name = :model)
 model = complete(model)
 model_outputs = [model.inertia1.w, model.inertia2.w, model.inertia1.phi, model.inertia2.phi]
@@ -427,7 +427,7 @@ function add_input_disturbance(sys, dist::DisturbanceModel, inputs = nothing; kw
 
     eqs = [dsys.input.u[1] ~ d
            dist.input ~ u + dsys.output.u[1]]
-    augmented_sys = ODESystem(eqs, t, systems = [dsys], name = gensym(:outer))
+    augmented_sys = System(eqs, t, systems = [dsys], name = gensym(:outer))
     augmented_sys = extend(augmented_sys, sys)
 
     (f_oop, f_ip), dvs, p, io_sys = generate_control_function(augmented_sys, all_inputs,

src/linearization.jl

@@ -19,7 +19,7 @@ The `simplified_sys` has undergone [`structural_simplify`](@ref) and had any occ
 
 # Arguments:
 
-  - `sys`: An [`ODESystem`](@ref). This function will automatically apply simplification passes on `sys` and return the resulting `simplified_sys`.
+  - `sys`: A [`System`](@ref) of ODEs. This function will automatically apply simplification passes on `sys` and return the resulting `simplified_sys`.
   - `inputs`: A vector of variables that indicate the inputs of the linearized input-output model.
   - `outputs`: A vector of variables that indicate the outputs of the linearized input-output model.
   - `simplify`: Apply simplification in tearing.
@@ -640,15 +640,15 @@ function plant(; name)
     @variables u(t)=0 y(t)=0
     eqs = [D(x) ~ -x + u
            y ~ x]
-    ODESystem(eqs, t; name = name)
+    System(eqs, t; name = name)
 end
 
 function ref_filt(; name)
     @variables x(t)=0 y(t)=0
     @variables u(t)=0 [input = true]
     eqs = [D(x) ~ -2 * x + u
            y ~ x]
-    ODESystem(eqs, t, name = name)
+    System(eqs, t, name = name)
 end
 
 function controller(kp; name)
@@ -657,7 +657,7 @@ function controller(kp; name)
     eqs = [
         u ~ kp * (r - y),
     ]
-    ODESystem(eqs, t; name = name)
+    System(eqs, t; name = name)
 end
 
 @named f = ref_filt()
@@ -668,7 +668,7 @@ connections = [f.y ~ c.r # filtered reference to controller reference
                c.u ~ p.u # controller output to plant input
                p.y ~ c.y]
 
-@named cl = ODESystem(connections, t, systems = [f, c, p])
+@named cl = System(connections, t, systems = [f, c, p])
 
 lsys0, ssys = linearize(cl, [f.u], [p.x])
 desired_order = [f.x, p.x]

src/structural_transformation/StructuralTransformations.jl

@@ -11,7 +11,7 @@ using SymbolicUtils.Rewriters
 using SymbolicUtils: maketerm, iscall
 
 using ModelingToolkit
-using ModelingToolkit: ODESystem, AbstractSystem, var_from_nested_derivative, Differential,
+using ModelingToolkit: System, AbstractSystem, var_from_nested_derivative, Differential,
                        unknowns, equations, vars, Symbolic, diff2term_with_unit,
                        shift2term_with_unit, value,
                        operation, arguments, Sym, Term, simplify, symbolic_linear_solve,

src/structural_transformation/pantelides.jl

@@ -195,7 +195,7 @@ function pantelides!(
             eq′ = eq_to_diff[eq′]
         end # for _ in 1:maxiters
         pathfound ||
-            error("maxiters=$maxiters reached! File a bug report if your system has a reasonable index (<100), and you are using the default `maxiters`. Try to increase the maxiters by `pantelides(sys::ODESystem; maxiters=1_000_000)` if your system has an incredibly high index and it is truly extremely large.")
+            error("maxiters=$maxiters reached! File a bug report if your system has a reasonable index (<100), and you are using the default `maxiters`. Try to increase the maxiters by `pantelides(sys::System; maxiters=1_000_000)` if your system has an incredibly high index and it is truly extremely large.")
     end # for k in 1:neqs′
 
     finalize && for var in 1:ndsts(graph)
@@ -206,13 +206,13 @@ function pantelides!(
 end
 
 """
-    dae_index_lowering(sys::ODESystem; kwargs...) -> ODESystem
+    dae_index_lowering(sys::System; kwargs...) -> System
 
 Perform the Pantelides algorithm to transform a higher index DAE to an index 1
 DAE. `kwargs` are forwarded to [`pantelides!`](@ref). End users are encouraged to call [`structural_simplify`](@ref)
 instead, which calls this function internally.
 """
-function dae_index_lowering(sys::ODESystem; kwargs...)
+function dae_index_lowering(sys::System; kwargs...)
     state = TearingState(sys)
     var_eq_matching = pantelides!(state; finalize = false, kwargs...)
     return invalidate_cache!(pantelides_reassemble(state, var_eq_matching))

src/structural_transformation/symbolics_tearing.jl

@@ -40,7 +40,7 @@ function var_derivative_graph!(s::SystemStructure, v::Int)
     return var_diff
 end
 
-function var_derivative!(ts::TearingState{ODESystem}, v::Int)
+function var_derivative!(ts::TearingState, v::Int)
     s = ts.structure
     var_diff = var_derivative_graph!(s, v)
     sys = ts.sys
@@ -58,7 +58,7 @@ function eq_derivative_graph!(s::SystemStructure, eq::Int)
     return eq_diff
 end
 
-function eq_derivative!(ts::TearingState{ODESystem}, ieq::Int; kwargs...)
+function eq_derivative!(ts::TearingState, ieq::Int; kwargs...)
     s = ts.structure
 
     eq_diff = eq_derivative_graph!(s, ieq)

src/systems/abstractsystem.jl

@@ -1650,7 +1650,7 @@ function defaults(sys::AbstractSystem)
     # `mapfoldr` is really important!!! We should prefer the base model for
     # defaults, because people write:
     #
-    # `compose(ODESystem(...; defaults=defs), ...)`
+    # `compose(System(...; defaults=defs), ...)`
     #
     # Thus, right associativity is required and crucial for correctness.
     isempty(systems) ? defs : mapfoldr(namespace_defaults, merge, systems; init = defs)
@@ -2864,7 +2864,7 @@ using ModelingToolkit: t, D
 
 @parameters p = 1.0, [description = "My parameter", tunable = false] q = 2.0, [description = "Other parameter"]
 @variables x(t) = 3.0 [unit = u"m"]
-@named sys = ODESystem(Equation[], t, [x], [p, q])
+@named sys = System(Equation[], t, [x], [p, q])
 ModelingToolkit.dump_parameters(sys)
 ```
 
@@ -2905,7 +2905,7 @@ using ModelingToolkit: t, D
 
 @parameters p = 1.0, [description = "My parameter", tunable = false] q = 2.0, [description = "Other parameter"]
 @variables x(t) = 3.0 [unit = u"m"]
-@named sys = ODESystem(Equation[], t, [x], [p, q])
+@named sys = System(Equation[], t, [x], [p, q])
 ModelingToolkit.dump_unknowns(sys)
 ```
 
@@ -3083,7 +3083,7 @@ using ModelingToolkit: t_nounits as t, D_nounits as D
 @variables X(t)
 eq1 = D(X) ~ p - d*X
 eq2 = 0 ~ p - d*X
-@named osys = ODESystem([eq1, eq2], t)
+@named osys = System([eq1, eq2], t)
 
 alg_equations(osys) # returns `[0 ~ p - d*X(t)]`.
 """
@@ -3102,7 +3102,7 @@ using ModelingToolkit: t_nounits as t, D_nounits as D
 @variables X(t)
 eq1 = D(X) ~ p - d*X
 eq2 = 0 ~ p - d*X
-@named osys = ODESystem([eq1, eq2], t)
+@named osys = System([eq1, eq2], t)
 
 diff_equations(osys) # returns `[Differential(t)(X(t)) ~ p - d*X(t)]`.
 """
@@ -3122,8 +3122,8 @@ using ModelingToolkit: t_nounits as t, D_nounits as D
 @variables X(t)
 eq1 = D(X) ~ p - d*X
 eq2 = 0 ~ p - d*X
-@named osys1 = ODESystem([eq1], t)
-@named osys2 = ODESystem([eq2], t)
+@named osys1 = System([eq1], t)
+@named osys2 = System([eq2], t)
 
 has_alg_equations(osys1) # returns `false`.
 has_alg_equations(osys2) # returns `true`.
@@ -3144,8 +3144,8 @@ using ModelingToolkit: t_nounits as t, D_nounits as D
 @variables X(t)
 eq1 = D(X) ~ p - d*X
 eq2 = 0 ~ p - d*X
-@named osys1 = ODESystem([eq1], t)
-@named osys2 = ODESystem([eq2], t)
+@named osys1 = System([eq1], t)
+@named osys2 = System([eq2], t)
 
 has_diff_equations(osys1) # returns `true`.
 has_diff_equations(osys2) # returns `false`.
@@ -3167,9 +3167,9 @@ using ModelingToolkit: t_nounits as t, D_nounits as D
 @variables X(t)
 eq1 = D(X) ~ p - d*X
 eq2 = 0 ~ p - d*X
-@named osys1 = ODESystem([eq1], t)
-@named osys2 = ODESystem([eq2], t)
-osys12 = compose(osys1, [osys2])
+@named osys1 = ([eq1], t)
+@named osys2 = ([eq2], t)
+osys12 = compose(sys1, [osys2])
 osys21 = compose(osys2, [osys1])
 
 get_alg_eqs(osys12) # returns `Equation[]`.
@@ -3192,8 +3192,8 @@ using ModelingToolkit: t_nounits as t, D_nounits as D
 @variables X(t)
 eq1 = D(X) ~ p - d*X
 eq2 = 0 ~ p - d*X
-@named osys1 = ODESystem([eq1], t)
-@named osys2 = ODESystem([eq2], t)
+@named osys1 = tem([eq1], t)
+@named osys2 = tem([eq2], t)
 osys12 = compose(osys1, [osys2])
 osys21 = compose(osys2, [osys1])
 
@@ -3217,8 +3217,8 @@ using ModelingToolkit: t_nounits as t, D_nounits as D
 @variables X(t)
 eq1 = D(X) ~ p - d*X
 eq2 = 0 ~ p - d*X
-@named osys1 = ODESystem([eq1], t)
-@named osys2 = ODESystem([eq2], t)
+@named osys1 = System([eq1], t)
+@named osys2 = System([eq2], t)
 osys12 = compose(osys1, [osys2])
 osys21 = compose(osys2, [osys1])
 
@@ -3243,8 +3243,8 @@ using ModelingToolkit: t_nounits as t, D_nounits as D
 @variables X(t)
 eq1 = D(X) ~ p - d*X
 eq2 = 0 ~ p - d*X
-@named osys1 = ODESystem([eq1], t)
-@named osys2 = ODESystem([eq2], t)
+@named osys1 = tem([eq1], t)
+@named osys2 = tem([eq2], t)
 osys12 = compose(osys1, [osys2])
 osys21 = compose(osys2, [osys1])
 

src/systems/analysis_points.jl

@@ -31,7 +31,7 @@ t = ModelingToolkit.get_iv(P)
 
 eqs = [connect(P.output, C.input)
        connect(C.output, :plant_input, P.input)]
-sys = ODESystem(eqs, t, systems = [P, C], name = :feedback_system)
+sys = System(eqs, t, systems = [P, C], name = :feedback_system)
 
 matrices_S, _ = get_sensitivity(sys, :plant_input) # Compute the matrices of a state-space representation of the (input) sensitivity function.
 matrices_T, _ = get_comp_sensitivity(sys, :plant_input)
@@ -1007,12 +1007,12 @@ See also [`get_sensitivity`](@ref), [`get_comp_sensitivity`](@ref), [`open_loop`
 # 
 
 """
-    generate_control_function(sys::ModelingToolkit.AbstractODESystem, input_ap_name::Union{Symbol, Vector{Symbol}, AnalysisPoint, Vector{AnalysisPoint}}, dist_ap_name::Union{Symbol, Vector{Symbol}, AnalysisPoint, Vector{AnalysisPoint}}; system_modifier = identity, kwargs)
+    generate_control_function(sys::ModelingToolkit.AbstractSystem, input_ap_name::Union{Symbol, Vector{Symbol}, AnalysisPoint, Vector{AnalysisPoint}}, dist_ap_name::Union{Symbol, Vector{Symbol}, AnalysisPoint, Vector{AnalysisPoint}}; system_modifier = identity, kwargs)
 
 When called with analysis points as input arguments, we assume that all analysis points corresponds to connections that should be opened (broken). The use case for this is to get rid of input signal blocks, such as `Step` or `Sine`, since these are useful for simulation but are not needed when using the plant model in a controller or state estimator.
 """
 function generate_control_function(
-        sys::ModelingToolkit.AbstractODESystem, input_ap_name::Union{
+        sys::ModelingToolkit.AbstractSystem, input_ap_name::Union{
             Symbol, Vector{Symbol}, AnalysisPoint, Vector{AnalysisPoint}},
         dist_ap_name::Union{
             Nothing, Symbol, Vector{Symbol}, AnalysisPoint, Vector{AnalysisPoint}} = nothing;

src/systems/diffeqs/basic_transformations.jl

@@ -21,7 +21,7 @@ using ModelingToolkit, OrdinaryDiffEq
 @variables x(t) y(t)
 D = Differential(t)
 eqs = [D(x) ~ α*x - β*x*y, D(y) ~ -δ*y + γ*x*y]
-@named sys = ODESystem(eqs, t)
+@named sys = System(eqs, t)
 
 sys2 = liouville_transform(sys)
 sys2 = complete(sys2)
@@ -40,22 +40,22 @@ Optimal Transport Approach
 Abhishek Halder, Kooktae Lee, and Raktim Bhattacharya
 https://abhishekhalder.bitbucket.io/F16ACC2013Final.pdf
 """
-function liouville_transform(sys::AbstractODESystem; kwargs...)
+function liouville_transform(sys::System; kwargs...)
     t = get_iv(sys)
     @variables trJ
-    D = ModelingToolkit.Differential(t)
+    D = Differential(t)
     neweq = D(trJ) ~ trJ * -tr(calculate_jacobian(sys))
     neweqs = [equations(sys); neweq]
     vars = [unknowns(sys); trJ]
-    ODESystem(
+    System(
         neweqs, t, vars, parameters(sys);
         checks = false, name = nameof(sys), kwargs...
     )
 end
 
 """
     change_independent_variable(
-        sys::AbstractODESystem, iv, eqs = [];
+        sys::System, iv, eqs = [];
         add_old_diff = false, simplify = true, fold = false
     )
 
@@ -95,7 +95,7 @@ By changing the independent variable, it can be reformulated for vertical positi
 ```julia
 julia> @variables x(t) y(t);
 
-julia> @named M = ODESystem([D(D(y)) ~ -9.81, D(D(x)) ~ 0.0], t);
+julia> @named M = System([D(D(y)) ~ -9.81, D(D(x)) ~ 0.0], t);
 
 julia> M = change_independent_variable(M, x);
 
@@ -109,7 +109,7 @@ julia> unknowns(M)
 ```
 """
 function change_independent_variable(
-        sys::AbstractODESystem, iv, eqs = [];
+        sys::System, iv, eqs = [];
         add_old_diff = false, simplify = true, fold = false
 )
     iv2_of_iv1 = unwrap(iv) # e.g. u(t)
@@ -166,7 +166,7 @@ function change_independent_variable(
     end
 
     # Use the utility function to transform everything in the system!
-    function transform(sys::AbstractODESystem)
+    function transform(sys::System)
         eqs = map(transform, get_eqs(sys))
         unknowns = map(transform, get_unknowns(sys))
         unknowns = filter(var -> !isequal(var, iv2), unknowns) # remove e.g. u

src/systems/diffeqs/first_order_transform.jl

@@ -1,18 +1,18 @@
 """
 $(TYPEDSIGNATURES)
 
-Takes a Nth order ODESystem and returns a new ODESystem written in first order
+Takes a Nth order System and returns a new System written in first order
 form by defining new variables which represent the N-1 derivatives.
 """
-function ode_order_lowering(sys::ODESystem)
+function ode_order_lowering(sys::System)
     iv = get_iv(sys)
     eqs_lowered, new_vars = ode_order_lowering(equations(sys), iv, unknowns(sys))
     @set! sys.eqs = eqs_lowered
     @set! sys.unknowns = new_vars
     return sys
 end
 
-function dae_order_lowering(sys::ODESystem)
+function dae_order_lowering(sys::System)
     iv = get_iv(sys)
     eqs_lowered, new_vars = dae_order_lowering(equations(sys), iv, unknowns(sys))
     @set! sys.eqs = eqs_lowered