feat: reduce reliance on metadata in structural_simplify

src/inputoutput.jl

@@ -319,7 +319,7 @@ function inputs_to_parameters!(state::TransformationState, inputsyms)
 
     @set! sys.ps = [ps; new_parameters]
     @set! state.sys = sys
-    @set! state.fullvars = new_fullvars
+    @set! state.fullvars = Vector{BasicSymbolic}(new_fullvars)
     @set! state.structure = structure
     return state
 end

src/structural_transformation/StructuralTransformations.jl

@@ -40,6 +40,7 @@ using ModelingToolkit: algeqs, EquationsView,
                        dervars_range, diffvars_range, algvars_range,
                        DiffGraph, complete!,
                        get_fullvars, system_subset
+using SymbolicIndexingInterface: symbolic_type, ArraySymbolic
 
 using ModelingToolkit.DiffEqBase
 using ModelingToolkit.StaticArrays

src/structural_transformation/utils.jl

@@ -228,9 +228,15 @@ function find_eq_solvables!(state::TearingState, ieq, to_rm = Int[], coeffs = no
             all_int_vars = false
             if !allow_symbolic
                 if allow_parameter
-                    all(
-                        x -> ModelingToolkit.isparameter(x),
-                        vars(a)) || continue
+                    # if any of the variables in `a` are present in fullvars (taking into account arrays)
+                    if any(
+                        v -> any(isequal(v), fullvars) ||
+                            symbolic_type(v) == ArraySymbolic() &&
+                                Symbolics.shape(v) != Symbolics.Unknown() &&
+                                any(x -> any(isequal(x), fullvars), collect(v)),
+                        vars(a))
+                        continue
+                    end
                 else
                     continue
                 end

src/systems/abstractsystem.jl

@@ -648,14 +648,14 @@ function (f::Initial)(x)
     iscall(x) && operation(x) isa Initial && return x
     result = if symbolic_type(x) == ArraySymbolic()
         # create an array for `Initial(array)`
-        Symbolics.array_term(f, toparam(x))
+        Symbolics.array_term(f, x)
     elseif iscall(x) && operation(x) == getindex
         # instead of `Initial(x[1])` create `Initial(x)[1]`
         # which allows parameter indexing to handle this case automatically.
         arr = arguments(x)[1]
-        term(getindex, f(toparam(arr)), arguments(x)[2:end]...)
+        term(getindex, f(arr), arguments(x)[2:end]...)
     else
-        term(f, toparam(x))
+        term(f, x)
     end
     # the result should be a parameter
     result = toparam(result)

src/systems/analysis_points.jl

@@ -950,7 +950,7 @@ function linearization_function(sys::AbstractSystem,
         if output isa AnalysisPoint
             sys, (output_var,) = apply_transformation(AddVariable(output), sys)
             sys, (input_var,) = apply_transformation(GetInput(output), sys)
-            push!(get_eqs(sys), output_var ~ input_var)
+            @set! sys.eqs = [get_eqs(sys); output_var ~ input_var]
         else
             output_var = output
         end

src/systems/diffeqs/basic_transformations.jl

@@ -482,7 +482,7 @@ function noise_to_brownians(sys::System; names::Union{Symbol, Vector{Symbol}} =
         """))
     end
     brownvars = map(names) do name
-        only(@brownian $name)
+        unwrap(only(@brownian $name))
     end
 
     terms = if ndims(neqs) == 1

src/systems/nonlinear/initializesystem.jl

@@ -214,7 +214,15 @@ function generate_initializesystem_timeindependent(sys::AbstractSystem;
     initialization_eqs = filter(initialization_eqs) do eq
         empty!(vs)
         vars!(vs, eq; op = Initial)
-        non_params = filter(!isparameter, vs)
+        allpars = full_parameters(sys)
+        for p in allpars
+            if symbolic_type(p) == ArraySymbolic() &&
+               Symbolics.shape(p) != Symbolics.Unknown()
+                append!(allpars, Symbolics.scalarize(p))
+            end
+        end
+        allpars = Set(allpars)
+        non_params = filter(!in(allpars), vs)
         # error if non-parameters are present in the initialization equations
         if !isempty(non_params)
             throw(UnknownsInTimeIndependentInitializationError(eq, non_params))

src/systems/system.jl

@@ -206,7 +206,7 @@ function System(eqs::Vector{Equation}, iv; kwargs...)
     diffeqs = Equation[]
     othereqs = Equation[]
     for eq in eqs
-        if !(eq.lhs isa Union{Symbolic, Number})
+        if !(eq.lhs isa Union{Symbolic, Number, AbstractArray})
             push!(othereqs, eq)
             continue
         end