refactor: rename structural_simplify to mtkcompile

Author: AayushSabharwal

src/ModelingToolkit.jl

@@ -233,7 +233,7 @@ PrecompileTools.@compile_workload begin
     using ModelingToolkit
     @variables 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)
+    prob = ODEProblem(mtkcompile(sys), [x => 30.0], (0, 100), [], jac = true)
     @mtkmodel __testmod__ begin
         @constants begin
             c = 1.0
@@ -304,7 +304,7 @@ export SymScope, LocalScope, ParentScope, GlobalScope
 export independent_variable, equations, controls, observed, full_equations, jumps, cost,
        brownians
 export initialization_equations, guesses, defaults, parameter_dependencies, hierarchy
-export structural_simplify, expand_connections, linearize, linearization_function,
+export mtkcompile, expand_connections, linearize, linearization_function,
        LinearizationProblem
 export solve
 export Pre

src/inputoutput.jl

@@ -202,7 +202,7 @@ function generate_control_function(sys::AbstractSystem, inputs = unbound_inputs(
         kwargs...)
     # Remove this when the ControlFunction gets merged.
     if check_simplified && !iscomplete(sys)
-        error("A completed `ODESystem` is required. Call `complete` or `structural_simplify` on the system before creating the control function.")
+        error("A completed `ODESystem` is required. Call `complete` or `mtkcompile` on the system before creating the control function.")
     end
     isempty(inputs) && @warn("No unbound inputs were found in system.")
     if disturbance_inputs !== nothing
@@ -417,7 +417,7 @@ function add_input_disturbance(sys, dist::DisturbanceModel, inputs = Any[]; kwar
            dist.input ~ u + dsys.output.u[1]]
     augmented_sys = System(eqs, t, systems = [dsys], name = gensym(:outer))
     augmented_sys = extend(augmented_sys, sys)
-    ssys = structural_simplify(augmented_sys, inputs = all_inputs, disturbance_inputs = [d])
+    ssys = mtkcompile(augmented_sys, inputs = all_inputs, disturbance_inputs = [d])
 
     f, dvs, p, io_sys = generate_control_function(ssys, all_inputs,
         [d]; kwargs...)

src/linearization.jl

@@ -15,7 +15,7 @@ y &= h(x, z, u)
 
 where `x` are differential unknown variables, `z` algebraic variables, `u` inputs and `y` outputs. To obtain a linear statespace representation, see [`linearize`](@ref). The input argument `variables` is a vector defining the operating point, corresponding to `unknowns(simplified_sys)` and `p` is a vector corresponding to the parameters of `simplified_sys`. Note: all variables in `inputs` have been converted to parameters in `simplified_sys`.
 
-The `simplified_sys` has undergone [`structural_simplify`](@ref) and had any occurring input or output variables replaced with the variables provided in arguments `inputs` and `outputs`. The unknowns of this system also indicate the order of the unknowns that holds for the linearized matrices.
+The `simplified_sys` has undergone [`mtkcompile`](@ref) and had any occurring input or output variables replaced with the variables provided in arguments `inputs` and `outputs`. The unknowns of this system also indicate the order of the unknowns that holds for the linearized matrices.
 
 # Arguments:
 
@@ -58,7 +58,7 @@ function linearization_function(sys::AbstractSystem, inputs,
     outputs = mapreduce(vcat, outputs; init = []) do var
         symbolic_type(var) == ArraySymbolic() ? collect(var) : [var]
     end
-    ssys = structural_simplify(sys; inputs, outputs, simplify, kwargs...)
+    ssys = mtkcompile(sys; inputs, outputs, simplify, kwargs...)
     diff_idxs, alge_idxs = eq_idxs(ssys)
     if zero_dummy_der
         dummyder = setdiff(unknowns(ssys), unknowns(sys))
@@ -498,7 +498,7 @@ function linearize_symbolic(sys::AbstractSystem, inputs,
         outputs; simplify = false, allow_input_derivatives = false,
         eval_expression = false, eval_module = @__MODULE__,
         kwargs...)
-    sys = structural_simplify(sys; inputs, outputs, simplify, kwargs...)
+    sys = mtkcompile(sys; inputs, outputs, simplify, kwargs...)
     diff_idxs, alge_idxs = eq_idxs(sys)
     sts = unknowns(sys)
     t = get_iv(sys)

src/problems/compatibility.jl

@@ -120,7 +120,7 @@ function check_has_noise(sys::System, T)
         if !isempty(brownians(sys))
             msg = """
             Systems constructed by defining Brownian variables with `@brownian` must be \
-            simplified by calling `structural_simplify` before a `$T` can be constructed.
+            simplified by calling `mtkcompile` before a `$T` can be constructed.
             """
         end
         throw(SystemCompatibilityError(msg))
@@ -131,7 +131,7 @@ function check_is_discrete(sys::System, T)
     if !is_discrete_system(sys)
         throw(SystemCompatibilityError("""
         `$T` expects a discrete system. Consider an `ODEProblem` instead. If your system \
-        is discrete, ensure `structural_simplify` has been run on it.
+        is discrete, ensure `mtkcompile` has been run on it.
         """))
     end
 end

src/problems/initializationproblem.jl

@@ -35,7 +35,7 @@ initial conditions for the given DAE.
         time_dependent_init = is_time_dependent(sys),
         kwargs...) where {iip, specialize}
     if !iscomplete(sys)
-        error("A completed system is required. Call `complete` or `structural_simplify` on the system before creating an `ODEProblem`")
+        error("A completed system is required. Call `complete` or `mtkcompile` on the system before creating an `ODEProblem`")
     end
     if isempty(u0map) && get_initializesystem(sys) !== nothing
         isys = get_initializesystem(sys; initialization_eqs, check_units)
@@ -60,7 +60,7 @@ initial conditions for the given DAE.
     end
 
     if simplify_system
-        isys = structural_simplify(isys; fully_determined, split = is_split(sys))
+        isys = mtkcompile(isys; fully_determined, split = is_split(sys))
     end
 
     ts = get_tearing_state(isys)

src/problems/sccnonlinearproblem.jl

@@ -73,11 +73,11 @@ function SciMLBase.SCCNonlinearProblem{iip}(sys::System, u0map,
         parammap = SciMLBase.NullParameters(); eval_expression = false, eval_module = @__MODULE__,
         cse = true, kwargs...) where {iip}
     if !iscomplete(sys) || get_tearing_state(sys) === nothing
-        error("A simplified `System` is required. Call `structural_simplify` on the system before creating an `SCCNonlinearProblem`.")
+        error("A simplified `System` is required. Call `mtkcompile` on the system before creating an `SCCNonlinearProblem`.")
     end
 
     if !is_split(sys)
-        error("The system has been simplified with `split = false`. `SCCNonlinearProblem` is not compatible with this system. Pass `split = true` to `structural_simplify` to use `SCCNonlinearProblem`.")
+        error("The system has been simplified with `split = false`. `SCCNonlinearProblem` is not compatible with this system. Pass `split = true` to `mtkcompile` to use `SCCNonlinearProblem`.")
     end
 
     ts = get_tearing_state(sys)

src/structural_transformation/StructuralTransformations.jl

@@ -35,7 +35,7 @@ import ModelingToolkit: var_derivative!, var_derivative_graph!
 using Graphs
 using ModelingToolkit: algeqs, EquationsView,
                        SystemStructure, TransformationState, TearingState,
-                       structural_simplify!,
+                       mtkcompile!,
                        isdiffvar, isdervar, isalgvar, isdiffeq, algeqs, is_only_discrete,
                        dervars_range, diffvars_range, algvars_range,
                        DiffGraph, complete!,

src/structural_transformation/pantelides.jl

@@ -210,7 +210,7 @@ end
     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)
+DAE. `kwargs` are forwarded to [`pantelides!`](@ref). End users are encouraged to call [`mtkcompile`](@ref)
 instead, which calls this function internally.
 """
 function dae_index_lowering(sys::System; kwargs...)

src/structural_transformation/symbolics_tearing.jl

@@ -989,7 +989,7 @@ end
     tearing(sys; simplify=false)
 
 Tear the nonlinear equations in system. When `simplify=true`, we simplify the
-new residual equations after tearing. End users are encouraged to call [`structural_simplify`](@ref)
+new residual equations after tearing. End users are encouraged to call [`mtkcompile`](@ref)
 instead, which calls this function internally.
 """
 function tearing(sys::AbstractSystem, state = TearingState(sys); mm = nothing,

src/systems/abstractsystem.jl

@@ -146,15 +146,15 @@ may be subsetted using `dvs` and `ps`. All `kwargs` are passed to the internal
 [`build_function`](@ref) call. The returned function can be called as `f(u, p, t)` or
 `f(du, u, p, t)` for time-dependent systems and `f(u, p)` or `f(du, u, p)` for
 time-independent systems. If `split=true` (the default) was passed to [`complete`](@ref),
-[`structural_simplify`](@ref) or [`@mtkcompile`](@ref), `p` is expected to be an `MTKParameters`
+[`mtkcompile`](@ref) or [`@mtkcompile`](@ref), `p` is expected to be an `MTKParameters`
 object.
 """
 function generate_custom_function(sys::AbstractSystem, exprs, dvs = unknowns(sys),
         ps = parameters(sys; initial_parameters = true);
         expression = Val{true}, eval_expression = false, eval_module = @__MODULE__,
         cachesyms::Tuple = (), kwargs...)
     if !iscomplete(sys)
-        error("A completed system is required. Call `complete` or `structural_simplify` on the system.")
+        error("A completed system is required. Call `complete` or `mtkcompile` on the system.")
     end
     p = (reorder_parameters(sys, unwrap.(ps))..., cachesyms...)
     isscalar = !(exprs isa AbstractArray)
@@ -751,7 +751,7 @@ function complete(
     newparams = OrderedSet()
     iv = has_iv(sys) ? get_iv(sys) : nothing
     collect_scoped_vars!(newunknowns, newparams, sys, iv; depth = -1)
-    # don't update unknowns to not disturb `structural_simplify` order
+    # don't update unknowns to not disturb `mtkcompile` order
     # `GlobalScope`d unknowns will be picked up and added there
     @set! sys.ps = unique!(vcat(get_ps(sys), collect(newparams)))
 
@@ -1178,7 +1178,7 @@ end
 Denotes that a variable belongs to the root system in the hierarchy, regardless of which
 equations of subsystems in the hierarchy it is involved in. Variables with this scope
 are never namespaced and only added to the unknowns/parameters of a system when calling
-`complete` or `structural_simplify`.
+`complete` or `mtkcompile`.
 """
 struct GlobalScope <: SymScope end
 
@@ -2484,7 +2484,7 @@ macro mtkcompile(exprs...)
     else
         kwargs = (Expr(:parameters, kwargs...),)
     end
-    call_expr = Expr(:call, structural_simplify, kwargs..., name)
+    call_expr = Expr(:call, mtkcompile, kwargs..., name)
     esc(quote
         $named_expr
         $name = $call_expr
@@ -2523,7 +2523,7 @@ function debug_system(
         functions = Set(functions) # more efficient "in" lookup
     end
     if has_systems(sys) && !isempty(get_systems(sys))
-        error("debug_system(sys) only works on systems with no sub-systems! Consider flattening it with flatten(sys) or structural_simplify(sys) first.")
+        error("debug_system(sys) only works on systems with no sub-systems! Consider flattening it with flatten(sys) or mtkcompile(sys) first.")
     end
     if has_eqs(sys)
         eqs = debug_sub.(equations(sys), Ref(functions); kw...)
@@ -2608,10 +2608,10 @@ end
 
 function check_array_equations_unknowns(eqs, dvs)
     if any(eq -> eq isa Equation && Symbolics.isarraysymbolic(eq.lhs), eqs)
-        throw(ArgumentError("The system has array equations. Call `structural_simplify` to handle such equations or scalarize them manually."))
+        throw(ArgumentError("The system has array equations. Call `mtkcompile` to handle such equations or scalarize them manually."))
     end
     if any(x -> Symbolics.isarraysymbolic(x), dvs)
-        throw(ArgumentError("The system has array unknowns. Call `structural_simplify` to handle this or scalarize them manually."))
+        throw(ArgumentError("The system has array unknowns. Call `mtkcompile` to handle this or scalarize them manually."))
     end
 end