"Axes of broadcast not known" with differential matrix equation

[florian-die]

Hi,

I'm trying to create a somewhat generic system of linear differential equations in a matrix form, but it fails.

My code is as follows.

using ModelingToolkit

A = [0. 1. ; 0. 0.] # 2×2 Matrix{Float64}
B = [0. ; 1.0 ;;] # 2×1 Matrix{Float64}

x0 = [0.0 ; 1.0 ;;] # 2×1 Matrix{Float64}
u0 = [0.0 ;;] # 1×1 Matrix{Float64}

dx0 = A*x0 + B*u # 2×1 Matrix{Float64}

function linear_system(A,B;name)
    n = size(A,1) 
    m = size(B,2)

    @variables t x(t)[1:n,1] u(t)[1:m,1]
    D = Differential(t)

    eqs = [ D(x) ~ A*x + B*u ]

    ODESystem(eqs;name)
end

@named double_int = linear_system(A,B)

The last line yields the following error

ERROR: axes of (broadcast(~, Differential(t)((x(t))[1:2,1:1]), broadcast(+, [0.0 1.0; 0.0 0.0]*x(t), [0.0; 1.0;;]*u(t)))) not known
Stacktrace:
  [1] error(s::String)
    @ Base .\error.jl:33
  [2] axes(A::Symbolics.Arr{Any, 2})
    @ Symbolics D:\fdietric\.julia\packages\Symbolics\J8IHJ\src\arrays.jl:527
  [3] scalarize(arr::Symbolics.Arr{Any, 2})
    @ Symbolics D:\fdietric\.julia\packages\Symbolics\J8IHJ\src\arrays.jl:711
  [4] iterate
    @ .\generator.jl:47 [inlined]
  [5] _collect(c::Vector{Symbolics.Arr{Any, 2}}, itr::Base.Generator{Vector{Symbolics.Arr{Any, 2}}, typeof(Symbolics.scalarize)}, #unused#::Base.EltypeUnknown, isz::Base.HasShape{1})
    @ Base .\array.jl:744
  [6] collect_similar
    @ .\array.jl:653 [inlined]
  [7] map
    @ .\abstractarray.jl:2867 [inlined]
  [8] scalarize
    @ D:\fdietric\.julia\packages\Symbolics\J8IHJ\src\arrays.jl:552 [inlined]
  [9] ODESystem(eqs::Vector{Symbolics.Arr{Any, 2}}, iv::Nothing; kwargs::Base.Pairs{Symbol, Symbol, Tuple{Symbol}, NamedTuple{(:name,), Tuple{Symbol}}})
    @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\J4yrw\src\systems\diffeqs\odesystem.jl:191
 [10] linear_system(A::Matrix{Float64}, B::Matrix{Float64}; name::Symbol)
    @ Main d:\fdietric\Documents\Julia\ModelingToolkit\linearsystem\linear_system.jl:22
 [11] top-level scope
    @ d:\fdietric\Documents\Julia\ModelingToolkit\linearsystem\linear_system.jl:25

and the status

(linearsystem) pkg> status
      Status `D:\fdietric\Documents\Julia\ModelingToolkit\linearsystem\Project.toml`
  [0c46a032] DifferentialEquations v7.2.0
  [961ee093] ModelingToolkit v8.18.8
  [91a5bcdd] Plots v1.31.6

I tried to play with the dimensions of the variables x and u, but the error remains the same.

I also tried to put . dots before the operator + and ~ operators.

I usually avoid using .+ by enforcing the size of every matrix/vectors in the equation (mostly for the colum vectors so they are n by 1 matrices).

Maybe I made a mistake in setting the system or I missed something.

Anyway, thanks in advance for your help.

[bowenszhu]

1. D(x) ~ A * x + B * u is a Symbolics.Arr. You don't need to wrap it in a vector.
2. I'm not sure if Differential of Symbolics.Arr works at the moment. We should probably just use D.(x) for now.

The following works for me:

using ModelingToolkit

A = [0.0 1.0; 0.0 0.0] # 2×2 Matrix{Float64}
B = [0.0; 1.0;;] # 2×1 Matrix{Float64}

x0 = [0.0; 1.0;;] # 2×1 Matrix{Float64}
u0 = [0.0;;] # 1×1 Matrix{Float64}

dx0 = A * x0 + B * u0 # 2×1 Matrix{Float64}

function linear_system(A, B; name)
    n = size(A, 1)
    m = size(B, 2)

    @variables t x(t)[1:n, 1] u(t)[1:m, 1]
    D = Differential(t)

    eqs = D.(x) ~ A * x + B * u

    ODESystem(eqs; name)
end

@named double_int = linear_system(A, B)

result:

julia> double_int
Model double_int with 2 equations
States (3):
  (x(t))[1, 1]
  (x(t))[2, 1]
  (u(t))[1, 1]
Parameters (0):

julia> equations(double_int)
2-element Vector{Equation}:
 Differential(t)((x(t))[1, 1]) ~ (x(t))[2, 1]
 Differential(t)((x(t))[2, 1]) ~ (u(t))[1, 1]

[florian-die]

Ok, thanks for the tip !

Should I leave the issue open ?

[florian-die]

Hi,

Continuing with my example, I found some other issues.

I connected a static gain controller to my linear system using vectors (one column matrices) as variables.

This controller has just one matrix/vector algebraic equation u=-K*x (in my example it is even scalar since my control input u is scalar)

My issue is that I cannot recover the control from the ODE solution to plot it.

My code and the error are as follows

using ModelingToolkit
using DifferentialEquations

A = [0. 1. ; 0. 0.] # 2×2 Matrix{Float64}
B = [0. ; 1.0 ;;] # 2×1 Matrix{Float64}

x0 = [0.0 ; 1.0 ;;] # 2×1 Matrix{Float64}
u0 = [0.0 ;;] # 1×1 Matrix{Float64}

dx0 = A*x0 + B*u0 # 2×1 Matrix{Float64}:

function linear_system(A,B;name)
    n = size(A,1) 
    m = size(B,2)

    @variables t x(t)[1:n,1] u(t)[1:m,1]
    D = Differential(t)

    eqs = D.(x) ~ A * x + B * u 

    ODESystem(eqs;name)
end

@named sys = linear_system(A,B)
    # Model sys with 2 equations
    # States (3):
    #   (x(t))[1, 1]
    #   (x(t))[2, 1]
    #   (u(t))[1, 1]
    # Parameters (0):

function static_gain_ctrl(K;name)
    n = size(K,2)
    m = size(K,1)

    @variables t x(t)[1:n,1] u(t)[1:m,1]

    eqs = u ~ - K * x

    ODESystem(eqs;name)
end

kx = 1.0 
kv = 1.0
K = [kx kv]

@named ctrl = static_gain_ctrl(K)
    # @named ctrl = static_gain_ctrl(K)
    # Model ctrl with 1 equations
    # States (3):
    #   (u(t))[1, 1]
    #   (x(t))[1, 1]
    #   (x(t))[2, 1]
    # Parameters (0):

# connections

connections = [ Symbolics.scalarize(ctrl.x ~ sys.x) ;
                Symbolics.scalarize(ctrl.u ~ sys.u) ]
    # 3×1 Matrix{Equation}:
    # (ctrl₊x(t))[1, 1] ~ (sys₊x(t))[1, 1]
    # (ctrl₊x(t))[2, 1] ~ (sys₊x(t))[2, 1]
    # (ctrl₊u(t))[1, 1] ~ (sys₊u(t))[1, 1]

# simplifcation

@named connected = ODESystem(connections)
    # Model connected with 3 equations
    # States (6):
    #   (ctrl₊x(t))[1, 1]
    #   (sys₊x(t))[1, 1]
    #   (ctrl₊x(t))[2, 1]
    # ⋮
    # Parameters (0):

@named sys_con = compose(connected,sys,ctrl)
    # Model sys_con with 6 equations
    # States (6):
    #   (ctrl₊x(t))[1, 1]
    #   (sys₊x(t))[1, 1]
    #   (ctrl₊x(t))[2, 1]
    # ⋮
    # Parameters (0):

full_equations(sys_con)
    # 6-element Vector{Equation}:
    #  (ctrl₊x(t))[1, 1] ~ (sys₊x(t))[1, 1]
    #  (ctrl₊x(t))[2, 1] ~ (sys₊x(t))[2, 1]
    #  (ctrl₊u(t))[1, 1] ~ (sys₊u(t))[1, 1]
    #  Differential(t)((sys₊x(t))[1, 1]) ~ (sys₊x(t))[2, 1]
    #  Differential(t)((sys₊x(t))[2, 1]) ~ (sys₊u(t))[1, 1]
    #  (ctrl₊u(t))[1, 1] ~ -(ctrl₊x(t))[1, 1] - (ctrl₊x(t))[2, 1]

sys_simp = structural_simplify(sys_con)
    # Model sys_con with 2 equations
    # States (2):
    #   (sys₊x(t))[1, 1]
    #   (sys₊x(t))[2, 1]
    # Parameters (0):
    # Incidence matrix:2×5 SparseArrays.SparseMatrixCSC{Num, Int64} with 5 stored entries:
    #  ⋅  ×  ⋅  ×  ⋅
    #  ×  ×  ⋅  ⋅  ×

observed(sys_simp)
    # 4-element Vector{Equation}:
    #  (sys₊u(t))[1, 1] ~ Differential(t)(Differential(t)((sys₊x(t))[1, 1]))
    #  (ctrl₊x(t))[2, 1] ~ Differential(t)((sys₊x(t))[1, 1])
    #  (ctrl₊x(t))[1, 1] ~ (sys₊x(t))[1, 1]
    #  (ctrl₊u(t))[1, 1] ~ -(ctrl₊x(t))[1, 1] - (sys₊x(t))[2, 1]

full_equations(sys_simp)
    # 2-element Vector{Equation}:
    #  Differential(t)((sys₊x(t))[1, 1]) ~ (sys₊x(t))[2, 1]
    #  Differential(t)((sys₊x(t))[2, 1]) ~ -(sys₊x(t))[1, 1] - (sys₊x(t))[2, 1]

states(sys_simp)
    # 2-element Vector{Term{Real, Nothing}}:
    #  (sys₊x(t))[1, 1]
    #  (sys₊x(t))[2, 1]

# solving

tf = 10.0

prob = ODEProblem(sys_simp,x0,(0.0,tf))

sol = solve(prob)

# plots

using Plots

phase_plot = plot(sol,idxs=(sys.x[1],sys.x[2]))
display(phase_plot)

time_plot = plot(sol,idxs=sys.x) 
display(time_plot)

ctrl_plot = plot(sol,idxs=ctrl.u) # ERROR: AssertionError: issymbollike(sym)
display(ctrl_plot)

The error when I try to plot ctrl.u or sys.u

ERROR: AssertionError: issymbollike(sym)
Stacktrace:
  [1] u_n(timeseries::DiffEqArray{Float64, 2, Vector{Vector{Float64}}, Vector{Float64}, Vector{Symbol}, Symbol, ModelingToolkit.var"#496#generated_observed#470"{Bool, ODESystem, Dict{Any, Any}}, Nothing}, sym::Vector{Any}, sol::OrdinaryDiffEq.ODECompositeSolution{Float64, 2, Vector{Vector{Float64}}, Nothing, Nothing, Vector{Float64}, Vector{Vector{Vector{Float64}}}, ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, Nothing, ODEFunction{true, ModelingToolkit.var"#f#463"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0xc0969e52, 0xd2513325, 0xe41c2004, 0x90fc246a, 0x80b13eef)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x6a09ec63, 0xb1f9c724, 0xc71fed88, 0x68029f32, 0x4f3348e0)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#496#generated_observed#470"{Bool, ODESystem, Dict{Any, Any}}, Nothing}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{2, false, GenericLUFactorization{LinearAlgebra.RowMaximum}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, OrdinaryDiffEq.CompositeInterpolationData{ODEFunction{true, ModelingToolkit.var"#f#463"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0xc0969e52, 0xd2513325, 0xe41c2004, 0x90fc246a, 0x80b13eef)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x6a09ec63, 0xb1f9c724, 0xc71fed88, 0x68029f32, 0x4f3348e0)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#496#generated_observed#470"{Bool, ODESystem, Dict{Any, Any}}, Nothing}, Vector{Vector{Float64}}, Vector{Float64}, Vector{Vector{Vector{Float64}}}, OrdinaryDiffEq.CompositeCache{Tuple{OrdinaryDiffEq.Tsit5Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, OrdinaryDiffEq.Tsit5ConstantCache{Float64, Float64}, typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, OrdinaryDiffEq.Rosenbrock23Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Matrix{Float64}, Matrix{Float64}, OrdinaryDiffEq.Rosenbrock23Tableau{Float64}, SciMLBase.TimeGradientWrapper{ODEFunction{true, ModelingToolkit.var"#f#463"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0xc0969e52, 0xd2513325, 0xe41c2004, 0x90fc246a, 0x80b13eef)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x6a09ec63, 0xb1f9c724, 0xc71fed88, 0x68029f32, 
0x4f3348e0)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#496#generated_observed#470"{Bool, ODESystem, Dict{Any, Any}}, Nothing}, Vector{Float64}, Nothing}, SciMLBase.UJacobianWrapper{ODEFunction{true, ModelingToolkit.var"#f#463"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0xc0969e52, 0xd2513325, 
0xe41c2004, 0x90fc246a, 0x80b13eef)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x6a09ec63, 0xb1f9c724, 0xc71fed88, 0x68029f32, 0x4f3348e0)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#496#generated_observed#470"{Bool, ODESystem, Dict{Any, Any}}, Nothing}, Float64, Nothing}, LinearSolve.LinearCache{Matrix{Float64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, GenericLUFactorization{LinearAlgebra.RowMaximum}, LinearAlgebra.LU{Float64, Matrix{Float64}}, LinearSolve.InvPreconditioner{LinearAlgebra.Diagonal{Float64, Vector{Float64}}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, Float64}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, UnitRange{Int64}, Nothing, Val{:forward}(), Float64}, FiniteDiff.GradientCache{Nothing, Vector{Float64}, Vector{Float64}, Float64, Val{:forward}(), Float64, Val{true}()}, Float64, Rosenbrock23{2, false, GenericLUFactorization{LinearAlgebra.RowMaximum}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Nothing}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}}, DiffEqBase.DEStats}, plott::Vector{Float64}, plot_timeseries::DiffEqArray{Float64, 2, Vector{Vector{Float64}}, Vector{Float64}, Vector{Symbol}, Symbol, ModelingToolkit.var"#496#generated_observed#470"{Bool, ODESystem, Dict{Any, Any}}, Nothing})
    @ SciMLBase D:\fdietric\.julia\packages\SciMLBase\ov6DK\src\solutions\solution_interface.jl:621
  [2] solplot_vecs_and_labels(dims::Int64, vars::Vector{Tuple}, plot_timeseries::DiffEqArray{Float64, 2, Vector{Vector{Float64}}, Vector{Float64}, Vector{Symbol}, Symbol, ModelingToolkit.var"#496#generated_observed#470"{Bool, ODESystem, Dict{Any, Any}}, Nothing}, plott::Vector{Float64}, sol::OrdinaryDiffEq.ODECompositeSolution{Float64, 2, Vector{Vector{Float64}}, Nothing, Nothing, Vector{Float64}, Vector{Vector{Vector{Float64}}}, ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, Nothing, ODEFunction{true, ModelingToolkit.var"#f#463"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0xc0969e52, 0xd2513325, 0xe41c2004, 0x90fc246a, 0x80b13eef)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x6a09ec63, 0xb1f9c724, 0xc71fed88, 0x68029f32, 0x4f3348e0)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#496#generated_observed#470"{Bool, ODESystem, Dict{Any, Any}}, Nothing}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{2, false, GenericLUFactorization{LinearAlgebra.RowMaximum}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, OrdinaryDiffEq.CompositeInterpolationData{ODEFunction{true, ModelingToolkit.var"#f#463"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0xc0969e52, 0xd2513325, 0xe41c2004, 
0x90fc246a, 0x80b13eef)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x6a09ec63, 0xb1f9c724, 0xc71fed88, 0x68029f32, 0x4f3348e0)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#496#generated_observed#470"{Bool, ODESystem, Dict{Any, Any}}, Nothing}, Vector{Vector{Float64}}, Vector{Float64}, 
Vector{Vector{Vector{Float64}}}, OrdinaryDiffEq.CompositeCache{Tuple{OrdinaryDiffEq.Tsit5Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, OrdinaryDiffEq.Tsit5ConstantCache{Float64, Float64}, typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, OrdinaryDiffEq.Rosenbrock23Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Matrix{Float64}, Matrix{Float64}, OrdinaryDiffEq.Rosenbrock23Tableau{Float64}, SciMLBase.TimeGradientWrapper{ODEFunction{true, ModelingToolkit.var"#f#463"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0xc0969e52, 0xd2513325, 0xe41c2004, 0x90fc246a, 0x80b13eef)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x6a09ec63, 0xb1f9c724, 0xc71fed88, 0x68029f32, 0x4f3348e0)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#496#generated_observed#470"{Bool, ODESystem, Dict{Any, Any}}, Nothing}, Vector{Float64}, Nothing}, SciMLBase.UJacobianWrapper{ODEFunction{true, ModelingToolkit.var"#f#463"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0xc0969e52, 0xd2513325, 0xe41c2004, 0x90fc246a, 0x80b13eef)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x6a09ec63, 0xb1f9c724, 0xc71fed88, 0x68029f32, 0x4f3348e0)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#496#generated_observed#470"{Bool, ODESystem, Dict{Any, Any}}, Nothing}, Float64, Nothing}, LinearSolve.LinearCache{Matrix{Float64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, GenericLUFactorization{LinearAlgebra.RowMaximum}, LinearAlgebra.LU{Float64, Matrix{Float64}}, LinearSolve.InvPreconditioner{LinearAlgebra.Diagonal{Float64, Vector{Float64}}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, Float64}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, UnitRange{Int64}, Nothing, Val{:forward}(), Float64}, FiniteDiff.GradientCache{Nothing, Vector{Float64}, Vector{Float64}, Float64, Val{:forward}(), Float64, Val{true}()}, Float64, Rosenbrock23{2, false, GenericLUFactorization{LinearAlgebra.RowMaximum}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Nothing}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}}, DiffEqBase.DEStats}, plot_analytic::Bool, plot_analytic_timeseries::Nothing, strs::Vector{String})
    @ SciMLBase D:\fdietric\.julia\packages\SciMLBase\ov6DK\src\solutions\solution_interface.jl:636
  [3] diffeq_to_arrays(sol::OrdinaryDiffEq.ODECompositeSolution{Float64, 2, Vector{Vector{Float64}}, Nothing, Nothing, Vector{Float64}, Vector{Vector{Vector{Float64}}}, ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, Nothing, ODEFunction{true, ModelingToolkit.var"#f#463"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0xc0969e52, 0xd2513325, 0xe41c2004, 0x90fc246a, 0x80b13eef)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x6a09ec63, 0xb1f9c724, 0xc71fed88, 0x68029f32, 0x4f3348e0)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#496#generated_observed#470"{Bool, ODESystem, Dict{Any, Any}}, Nothing}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{2, false, GenericLUFactorization{LinearAlgebra.RowMaximum}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, OrdinaryDiffEq.CompositeInterpolationData{ODEFunction{true, ModelingToolkit.var"#f#463"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0xc0969e52, 0xd2513325, 0xe41c2004, 0x90fc246a, 0x80b13eef)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x6a09ec63, 0xb1f9c724, 0xc71fed88, 0x68029f32, 0x4f3348e0)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#496#generated_observed#470"{Bool, ODESystem, Dict{Any, Any}}, Nothing}, Vector{Vector{Float64}}, Vector{Float64}, Vector{Vector{Vector{Float64}}}, OrdinaryDiffEq.CompositeCache{Tuple{OrdinaryDiffEq.Tsit5Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, OrdinaryDiffEq.Tsit5ConstantCache{Float64, Float64}, typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, OrdinaryDiffEq.Rosenbrock23Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Matrix{Float64}, Matrix{Float64}, OrdinaryDiffEq.Rosenbrock23Tableau{Float64}, SciMLBase.TimeGradientWrapper{ODEFunction{true, ModelingToolkit.var"#f#463"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0xc0969e52, 0xd2513325, 0xe41c2004, 0x90fc246a, 0x80b13eef)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x6a09ec63, 0xb1f9c724, 0xc71fed88, 0x68029f32, 0x4f3348e0)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#496#generated_observed#470"{Bool, ODESystem, Dict{Any, Any}}, Nothing}, Vector{Float64}, Nothing}, SciMLBase.UJacobianWrapper{ODEFunction{true, ModelingToolkit.var"#f#463"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0xc0969e52, 0xd2513325, 0xe41c2004, 0x90fc246a, 
0x80b13eef)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x6a09ec63, 0xb1f9c724, 0xc71fed88, 0x68029f32, 0x4f3348e0)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#496#generated_observed#470"{Bool, ODESystem, Dict{Any, Any}}, Nothing}, Float64, Nothing}, LinearSolve.LinearCache{Matrix{Float64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, GenericLUFactorization{LinearAlgebra.RowMaximum}, LinearAlgebra.LU{Float64, Matrix{Float64}}, LinearSolve.InvPreconditioner{LinearAlgebra.Diagonal{Float64, Vector{Float64}}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, Float64}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, UnitRange{Int64}, Nothing, Val{:forward}(), Float64}, FiniteDiff.GradientCache{Nothing, Vector{Float64}, Vector{Float64}, Float64, Val{:forward}(), Float64, Val{true}()}, Float64, Rosenbrock23{2, false, GenericLUFactorization{LinearAlgebra.RowMaximum}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Nothing}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}}, DiffEqBase.DEStats}, plot_analytic::Bool, denseplot::Bool, plotdensity::Int64, tspan::Nothing, axis_safety::Float64, vars::Vector{Symbolics.Arr{Num, 2}}, int_vars::Vector{Tuple}, tscale::Symbol, strs::Vector{String})
    @ SciMLBase D:\fdietric\.julia\packages\SciMLBase\ov6DK\src\solutions\solution_interface.jl:423
  [4] macro expansion
    @ D:\fdietric\.julia\packages\SciMLBase\ov6DK\src\solutions\solution_interface.jl:199 [inlined]
  [5] apply_recipe(plotattributes::AbstractDict{Symbol, Any}, sol::SciMLBase.AbstractTimeseriesSolution)
    @ SciMLBase D:\fdietric\.julia\packages\RecipesBase\qpxEX\src\RecipesBase.jl:289
  [6] _process_userrecipes!(plt::Any, plotattributes::Any, args::Any)
    @ RecipesPipeline D:\fdietric\.julia\packages\RecipesPipeline\OXGmH\src\user_recipe.jl:36
  [7] recipe_pipeline!(plt::Any, plotattributes::Any, args::Any)
    @ RecipesPipeline D:\fdietric\.julia\packages\RecipesPipeline\OXGmH\src\RecipesPipeline.jl:70
  [8] _plot!(plt::Plots.Plot, plotattributes::Any, args::Any)
    @ Plots D:\fdietric\.julia\packages\Plots\lW9ll\src\plot.jl:209
  [9] plot(args::Any; kw::Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}})
    @ Plots D:\fdietric\.julia\packages\Plots\lW9ll\src\plot.jl:91
 [10] top-level scope
    @ d:\fdietric\Documents\Julia\ModelingToolkit\linearsystem\linear_system.jl:131

Additionally, I had trouble with setting the initial conditions for the ODEProblem.

I tried the following but it gave me these errors

julia> X0 = [sys.x => x0]
1-element Vector{Pair{Symbolics.Arr{Num, 2}, Matrix{Float64}}}:
 (sys₊x(t))[1:2,1:1] => [0.0; 1.0;;]

julia> prob = ODEProblem(sys_simp,X0,(0.0,tf))
ERROR: ArgumentError: Term{Real, Nothing}[(sys₊x(t))[1, 1], (sys₊x(t))[2, 1]] are missing from the variable map.
Stacktrace:
 [1] throw_missingvars(vars::Vector{Term{Real, Nothing}})
   @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\fWNRg\src\variables.jl:98
 [2] _varmap_to_vars(varmap::Dict{Symbolics.Arr{Num, 2}, Matrix{Float64}}, varlist::Vector{Term{Real, Nothing}}; defaults::Dict{Any, Any}, check::Bool, toterm::typeof(Symbolics.diff2term))
   @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\fWNRg\src\variables.jl:92
 [3] varmap_to_vars(varmap::Vector{Pair{Symbolics.Arr{Num, 2}, Matrix{Float64}}}, varlist::Vector{Term{Real, Nothing}}; defaults::Dict{Any, Any}, check::Bool, toterm::Function, promotetoconcrete::Nothing, tofloat::Bool, use_union::Bool)
   @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\fWNRg\src\variables.jl:61
 [4] process_DEProblem(constructor::Type, sys::ODESystem, u0map::Vector{Pair{Symbolics.Arr{Num, 2}, Matrix{Float64}}}, parammap::SciMLBase.NullParameters; implicit_dae::Bool, du0map::Nothing, version::Nothing, tgrad::Bool, jac::Bool, checkbounds::Bool, sparse::Bool, simplify::Bool, linenumbers::Bool, parallel::Symbolics.SerialForm, eval_expression::Bool, use_union::Bool, kwargs::Base.Pairs{Symbol, Bool, Tuple{Symbol, Symbol}, NamedTuple{(:has_difference, :check_length), Tuple{Bool, Bool}}})
   @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\fWNRg\src\systems\diffeqs\abstractodesystem.jl:541
 [5] (ODEProblem{true})(sys::ODESystem, u0map::Vector{Pair{Symbolics.Arr{Num, 2}, Matrix{Float64}}}, tspan::Tuple{Float64, Float64}, parammap::SciMLBase.NullParameters; callback::Nothing, check_length::Bool, kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
   @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\fWNRg\src\systems\diffeqs\abstractodesystem.jl:635
 [6] (ODEProblem{true})(sys::ODESystem, u0map::Vector{Pair{Symbolics.Arr{Num, 2}, Matrix{Float64}}}, tspan::Tuple{Float64, Float64}, parammap::SciMLBase.NullParameters) (repeats 2 times)
   @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\fWNRg\src\systems\diffeqs\abstractodesystem.jl:634
 [7] ODEProblem(::ODESystem, ::Vector{Pair{Symbolics.Arr{Num, 2}, Matrix{Float64}}}, ::Vararg{Any}; kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
   @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\fWNRg\src\systems\diffeqs\abstractodesystem.jl:627
 [8] ODEProblem(::ODESystem, ::Vector{Pair{Symbolics.Arr{Num, 2}, Matrix{Float64}}}, ::Vararg{Any})
   @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\fWNRg\src\systems\diffeqs\abstractodesystem.jl:627
 [9] top-level scope
   @ d:\fdietric\Documents\Julia\ModelingToolkit\linearsystem\linear_system.jl:119

julia> X0 = sys.x => x0
(sys₊x(t))[1:2,1:1] => [0.0; 1.0;;]

julia> prob = ODEProblem(sys_simp,X0,(0.0,tf))
ERROR: MethodError: no method matching create_array(::Type{Pair{Symbolics.Arr{Num, 2}, Matrix{Float64}}}, ::Type{Union{Symbolics.Arr{Num, 2}, Matrix{Float64}}}, ::Val{1}, ::Val{2}, ::Symbolics.Arr{Num, 2}, ::Matrix{Float64})
Closest candidates are:
  create_array(::Type{<:LabelledArrays.SLArray}, ::Any, ::Val, ::Val{dims}, ::Any...) where dims at D:\fdietric\.julia\packages\SymbolicUtils\qulQp\src\code.jl:546
  create_array(::Type{<:SubArray{T, N, P, I, L}}, ::Any, ::Val, ::Val, ::Any...) where {T, N, P, I, L} at D:\fdietric\.julia\packages\SymbolicUtils\qulQp\src\code.jl:510       
  create_array(::Type{<:LinearAlgebra.Transpose{T, P}}, ::Any, ::Val, ::Val, ::Any...) where {T, P} at D:\fdietric\.julia\packages\SymbolicUtils\qulQp\src\code.jl:519
  ...
Stacktrace:
 [1] varmap_to_vars(varmap::Pair{Symbolics.Arr{Num, 2}, Matrix{Float64}}, varlist::Vector{Term{Real, Nothing}}; defaults::Dict{Any, Any}, check::Bool, toterm::Function, promotetoconcrete::Nothing, tofloat::Bool, use_union::Bool)
   @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\fWNRg\src\variables.jl:77
 [2] process_DEProblem(constructor::Type, sys::ODESystem, u0map::Pair{Symbolics.Arr{Num, 2}, Matrix{Float64}}, parammap::SciMLBase.NullParameters; implicit_dae::Bool, du0map::Nothing, version::Nothing, tgrad::Bool, jac::Bool, checkbounds::Bool, sparse::Bool, simplify::Bool, linenumbers::Bool, parallel::Symbolics.SerialForm, eval_expression::Bool, use_union::Bool, kwargs::Base.Pairs{Symbol, Bool, Tuple{Symbol, Symbol}, NamedTuple{(:has_difference, :check_length), Tuple{Bool, Bool}}})
   @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\fWNRg\src\systems\diffeqs\abstractodesystem.jl:541
 [3] (ODEProblem{true})(sys::ODESystem, u0map::Pair{Symbolics.Arr{Num, 2}, Matrix{Float64}}, tspan::Tuple{Float64, Float64}, parammap::SciMLBase.NullParameters; callback::Nothing, check_length::Bool, kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
   @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\fWNRg\src\systems\diffeqs\abstractodesystem.jl:635
 [4] (ODEProblem{true})(sys::ODESystem, u0map::Pair{Symbolics.Arr{Num, 2}, Matrix{Float64}}, tspan::Tuple{Float64, Float64}, parammap::SciMLBase.NullParameters) (repeats 2 times)
   @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\fWNRg\src\systems\diffeqs\abstractodesystem.jl:634
 [5] ODEProblem(::ODESystem, ::Pair{Symbolics.Arr{Num, 2}, Matrix{Float64}}, ::Vararg{Any}; kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
   @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\fWNRg\src\systems\diffeqs\abstractodesystem.jl:627
 [6] ODEProblem(::ODESystem, ::Pair{Symbolics.Arr{Num, 2}, Matrix{Float64}}, ::Vararg{Any})
   @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\fWNRg\src\systems\diffeqs\abstractodesystem.jl:627
 [7] top-level scope
   @ d:\fdietric\Documents\Julia\ModelingToolkit\linearsystem\linear_system.jl:119

Also, a note on why I used Symbolics.scalarize() on my connections equations.

When I do as usual, I get an error when creating the connected ODESystem.

julia> connections = [ ctrl.x ~ sys.x , ctrl.u ~ sys.u ]
2-element Vector{Symbolics.Arr{Any, 2}}:
 (broadcast(~, ctrl₊x(t), sys₊x(t)))[1:2,1:1]
 (broadcast(~, ctrl₊u(t), sys₊u(t)))[1:1,1:1]

julia> @named connected = ODESystem(connections)
ERROR: type Array has no field lhs
Stacktrace:
 [1] getproperty(x::Matrix{Equation}, f::Symbol)
   @ Base .\Base.jl:42
 [2] ODESystem(eqs::Vector{Symbolics.Arr{Any, 2}}, iv::Nothing; kwargs::Base.Pairs{Symbol, Symbol, Tuple{Symbol}, NamedTuple{(:name,), Tuple{Symbol}}})
   @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\fWNRg\src\systems\diffeqs\odesystem.jl:202
 [3] top-level scope
   @ d:\fdietric\Documents\Julia\ModelingToolkit\linearsystem\linear_system.jl:66

Thank you for your help =)

[florian-die]

I also have the following error

julia> sol[ctrl.u]
ERROR: The observed variable (sys₊u(t))[1, 1] depends on the differentiated variable Differential(t)(Differential(t)((sys₊x(t))[1, 1])), but it's not explicit solved. Fix file 
an issue if you are sure that the system is valid.
Stacktrace:
  [1] error(s::String)
    @ Base .\error.jl:35
  [2] build_explicit_observed_function(sys::ODESystem, ts::Num; expression::Bool, output_type::Type, checkbounds::Bool)
    @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\5qzZn\src\systems\diffeqs\odesystem.jl:336
  [3] #460
    @ D:\fdietric\.julia\packages\ModelingToolkit\5qzZn\src\systems\diffeqs\abstractodesystem.jl:324 [inlined]
  [4] get!(default::ModelingToolkit.var"#460#470"{Num, Bool, ODESystem}, h::Dict{Any, Any}, key::Term{Real, Nothing})
    @ Base .\dict.jl:481
  [5] (::ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}})(obsvar::Num, u::Vector{Float64}, p::Nothing, t::Float64)
    @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\5qzZn\src\systems\diffeqs\abstractodesystem.jl:323
  [6] _broadcast_getindex_evalf
    @ .\broadcast.jl:670 [inlined]
  [7] _broadcast_getindex
    @ .\broadcast.jl:643 [inlined]
  [8] getindex
    @ .\broadcast.jl:597 [inlined]
  [9] copy
    @ .\broadcast.jl:899 [inlined]
 [10] materialize
    @ .\broadcast.jl:860 [inlined]
 [11] observed(A::OrdinaryDiffEq.ODECompositeSolution{Float64, 2, Vector{Vector{Float64}}, Nothing, Nothing, Vector{Float64}, Vector{Vector{Vector{Float64}}}, ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, Nothing, ODEFunction{true, SciMLBase.FullSpecialize, ModelingToolkit.var"#f#462"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x59c3a7a2, 0xa4f17ef9, 0x74b821e5, 0x3e2a77a5, 0xb270babb)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x143becdc, 0x638a98a3, 0x5e7e8d02, 0xa61258ea, 0xf2dfc407)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}}, Nothing, ODESystem}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{2, false, GenericLUFactorization{LinearAlgebra.RowMaximum}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, OrdinaryDiffEq.CompositeInterpolationData{ODEFunction{true, SciMLBase.FullSpecialize, ModelingToolkit.var"#f#462"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x59c3a7a2, 0xa4f17ef9, 0x74b821e5, 0x3e2a77a5, 0xb270babb)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x143becdc, 0x638a98a3, 0x5e7e8d02, 0xa61258ea, 0xf2dfc407)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}}, Nothing, ODESystem}, Vector{Vector{Float64}}, Vector{Float64}, Vector{Vector{Vector{Float64}}}, OrdinaryDiffEq.CompositeCache{Tuple{OrdinaryDiffEq.Tsit5Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, OrdinaryDiffEq.Tsit5ConstantCache{Float64, Float64}, typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, OrdinaryDiffEq.Rosenbrock23Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Matrix{Float64}, Matrix{Float64}, OrdinaryDiffEq.Rosenbrock23Tableau{Float64}, SciMLBase.TimeGradientWrapper{ODEFunction{true, SciMLBase.FullSpecialize, ModelingToolkit.var"#f#462"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x59c3a7a2, 0xa4f17ef9, 0x74b821e5, 0x3e2a77a5, 0xb270babb)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x143becdc, 0x638a98a3, 0x5e7e8d02, 0xa61258ea, 0xf2dfc407)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}}, Nothing, ODESystem}, Vector{Float64}, 
Nothing}, SciMLBase.UJacobianWrapper{ODEFunction{true, SciMLBase.FullSpecialize, ModelingToolkit.var"#f#462"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x59c3a7a2, 0xa4f17ef9, 0x74b821e5, 0x3e2a77a5, 0xb270babb)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x143becdc, 0x638a98a3, 0x5e7e8d02, 0xa61258ea, 0xf2dfc407)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}}, Nothing, ODESystem}, Float64, Nothing}, LinearSolve.LinearCache{Matrix{Float64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, GenericLUFactorization{LinearAlgebra.RowMaximum}, LinearAlgebra.LU{Float64, Matrix{Float64}, Vector{Int64}}, LinearSolve.InvPreconditioner{LinearAlgebra.Diagonal{Float64, Vector{Float64}}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, Float64, Nothing}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, UnitRange{Int64}, Nothing, Val{:forward}(), Float64}, FiniteDiff.GradientCache{Nothing, Vector{Float64}, Vector{Float64}, Float64, Val{:forward}(), 
Float64, Val{true}()}, Float64, Rosenbrock23{2, false, GenericLUFactorization{LinearAlgebra.RowMaximum}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Nothing}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}}, DiffEqBase.DEStats}, sym::Num, i::Colon)
    @ SciMLBase D:\fdietric\.julia\packages\SciMLBase\mgXTt\src\solutions\solution_interface.jl:117
 [12] getindex
    @ D:\fdietric\.julia\packages\SciMLBase\mgXTt\src\solutions\solution_interface.jl:78 [inlined]
 [13] (::SciMLBase.var"#393#394"{OrdinaryDiffEq.ODECompositeSolution{Float64, 2, Vector{Vector{Float64}}, Nothing, Nothing, Vector{Float64}, Vector{Vector{Vector{Float64}}}, ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, Nothing, ODEFunction{true, SciMLBase.FullSpecialize, ModelingToolkit.var"#f#462"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x59c3a7a2, 0xa4f17ef9, 0x74b821e5, 0x3e2a77a5, 0xb270babb)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x143becdc, 0x638a98a3, 0x5e7e8d02, 0xa61258ea, 0xf2dfc407)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}}, Nothing, ODESystem}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, 
SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{2, false, GenericLUFactorization{LinearAlgebra.RowMaximum}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, OrdinaryDiffEq.CompositeInterpolationData{ODEFunction{true, SciMLBase.FullSpecialize, ModelingToolkit.var"#f#462"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x59c3a7a2, 0xa4f17ef9, 0x74b821e5, 0x3e2a77a5, 0xb270babb)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x143becdc, 0x638a98a3, 0x5e7e8d02, 0xa61258ea, 0xf2dfc407)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}}, Nothing, ODESystem}, Vector{Vector{Float64}}, Vector{Float64}, Vector{Vector{Vector{Float64}}}, OrdinaryDiffEq.CompositeCache{Tuple{OrdinaryDiffEq.Tsit5Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, OrdinaryDiffEq.Tsit5ConstantCache{Float64, Float64}, typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, OrdinaryDiffEq.Rosenbrock23Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Matrix{Float64}, Matrix{Float64}, OrdinaryDiffEq.Rosenbrock23Tableau{Float64}, SciMLBase.TimeGradientWrapper{ODEFunction{true, SciMLBase.FullSpecialize, ModelingToolkit.var"#f#462"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x59c3a7a2, 0xa4f17ef9, 0x74b821e5, 0x3e2a77a5, 0xb270babb)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x143becdc, 0x638a98a3, 0x5e7e8d02, 0xa61258ea, 0xf2dfc407)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}}, Nothing, ODESystem}, Vector{Float64}, Nothing}, SciMLBase.UJacobianWrapper{ODEFunction{true, SciMLBase.FullSpecialize, ModelingToolkit.var"#f#462"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x59c3a7a2, 0xa4f17ef9, 0x74b821e5, 0x3e2a77a5, 0xb270babb)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x143becdc, 0x638a98a3, 0x5e7e8d02, 0xa61258ea, 0xf2dfc407)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}}, Nothing, ODESystem}, Float64, Nothing}, LinearSolve.LinearCache{Matrix{Float64}, Vector{Float64}, 
Vector{Float64}, SciMLBase.NullParameters, GenericLUFactorization{LinearAlgebra.RowMaximum}, LinearAlgebra.LU{Float64, Matrix{Float64}, Vector{Int64}}, LinearSolve.InvPreconditioner{LinearAlgebra.Diagonal{Float64, Vector{Float64}}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, Float64, Nothing}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, UnitRange{Int64}, Nothing, Val{:forward}(), Float64}, FiniteDiff.GradientCache{Nothing, Vector{Float64}, Vector{Float64}, Float64, Val{:forward}(), Float64, Val{true}()}, Float64, Rosenbrock23{2, false, GenericLUFactorization{LinearAlgebra.RowMaximum}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Nothing}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}}, DiffEqBase.DEStats}})(s::Num)
    @ SciMLBase D:\fdietric\.julia\packages\SciMLBase\mgXTt\src\solutions\solution_interface.jl:66
 [14] iterate
    @ .\generator.jl:47 [inlined]
 [15] _collect(c::Matrix{Num}, itr::Base.Generator{Matrix{Num}, SciMLBase.var"#393#394"{OrdinaryDiffEq.ODECompositeSolution{Float64, 2, Vector{Vector{Float64}}, Nothing, Nothing, Vector{Float64}, Vector{Vector{Vector{Float64}}}, ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, Nothing, ODEFunction{true, SciMLBase.FullSpecialize, ModelingToolkit.var"#f#462"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x59c3a7a2, 0xa4f17ef9, 0x74b821e5, 0x3e2a77a5, 0xb270babb)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x143becdc, 0x638a98a3, 0x5e7e8d02, 0xa61258ea, 0xf2dfc407)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}}, Nothing, ODESystem}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{2, false, GenericLUFactorization{LinearAlgebra.RowMaximum}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, OrdinaryDiffEq.CompositeInterpolationData{ODEFunction{true, SciMLBase.FullSpecialize, 
ModelingToolkit.var"#f#462"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x59c3a7a2, 0xa4f17ef9, 0x74b821e5, 0x3e2a77a5, 0xb270babb)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x143becdc, 0x638a98a3, 0x5e7e8d02, 0xa61258ea, 0xf2dfc407)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}}, Nothing, ODESystem}, Vector{Vector{Float64}}, Vector{Float64}, Vector{Vector{Vector{Float64}}}, OrdinaryDiffEq.CompositeCache{Tuple{OrdinaryDiffEq.Tsit5Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, OrdinaryDiffEq.Tsit5ConstantCache{Float64, Float64}, typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, OrdinaryDiffEq.Rosenbrock23Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Matrix{Float64}, Matrix{Float64}, OrdinaryDiffEq.Rosenbrock23Tableau{Float64}, SciMLBase.TimeGradientWrapper{ODEFunction{true, SciMLBase.FullSpecialize, ModelingToolkit.var"#f#462"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x59c3a7a2, 0xa4f17ef9, 0x74b821e5, 0x3e2a77a5, 0xb270babb)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x143becdc, 0x638a98a3, 0x5e7e8d02, 0xa61258ea, 0xf2dfc407)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}}, Nothing, ODESystem}, Vector{Float64}, Nothing}, SciMLBase.UJacobianWrapper{ODEFunction{true, SciMLBase.FullSpecialize, ModelingToolkit.var"#f#462"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x59c3a7a2, 0xa4f17ef9, 0x74b821e5, 0x3e2a77a5, 0xb270babb)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x143becdc, 0x638a98a3, 0x5e7e8d02, 0xa61258ea, 0xf2dfc407)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}}, Nothing, ODESystem}, Float64, Nothing}, LinearSolve.LinearCache{Matrix{Float64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, GenericLUFactorization{LinearAlgebra.RowMaximum}, LinearAlgebra.LU{Float64, Matrix{Float64}, Vector{Int64}}, LinearSolve.InvPreconditioner{LinearAlgebra.Diagonal{Float64, Vector{Float64}}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, Float64, Nothing}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, UnitRange{Int64}, Nothing, Val{:forward}(), Float64}, FiniteDiff.GradientCache{Nothing, Vector{Float64}, Vector{Float64}, Float64, Val{:forward}(), Float64, Val{true}()}, Float64, Rosenbrock23{2, false, GenericLUFactorization{LinearAlgebra.RowMaximum}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Nothing}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}}, DiffEqBase.DEStats}}}, #unused#::Base.EltypeUnknown, isz::Base.HasShape{2})
    @ Base .\array.jl:807
 [16] collect_similar(cont::Matrix{Num}, itr::Base.Generator{Matrix{Num}, SciMLBase.var"#393#394"{OrdinaryDiffEq.ODECompositeSolution{Float64, 2, Vector{Vector{Float64}}, Nothing, Nothing, Vector{Float64}, Vector{Vector{Vector{Float64}}}, ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, Nothing, ODEFunction{true, SciMLBase.FullSpecialize, ModelingToolkit.var"#f#462"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x59c3a7a2, 0xa4f17ef9, 0x74b821e5, 0x3e2a77a5, 0xb270babb)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x143becdc, 0x638a98a3, 0x5e7e8d02, 0xa61258ea, 0xf2dfc407)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}}, Nothing, ODESystem}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{2, false, GenericLUFactorization{LinearAlgebra.RowMaximum}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, OrdinaryDiffEq.CompositeInterpolationData{ODEFunction{true, SciMLBase.FullSpecialize, ModelingToolkit.var"#f#462"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x59c3a7a2, 0xa4f17ef9, 0x74b821e5, 0x3e2a77a5, 0xb270babb)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x143becdc, 0x638a98a3, 0x5e7e8d02, 0xa61258ea, 0xf2dfc407)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}}, Nothing, ODESystem}, Vector{Vector{Float64}}, Vector{Float64}, Vector{Vector{Vector{Float64}}}, OrdinaryDiffEq.CompositeCache{Tuple{OrdinaryDiffEq.Tsit5Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, OrdinaryDiffEq.Tsit5ConstantCache{Float64, Float64}, typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, OrdinaryDiffEq.Rosenbrock23Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Matrix{Float64}, Matrix{Float64}, OrdinaryDiffEq.Rosenbrock23Tableau{Float64}, SciMLBase.TimeGradientWrapper{ODEFunction{true, SciMLBase.FullSpecialize, ModelingToolkit.var"#f#462"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x59c3a7a2, 0xa4f17ef9, 0x74b821e5, 0x3e2a77a5, 0xb270babb)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x143becdc, 0x638a98a3, 0x5e7e8d02, 0xa61258ea, 0xf2dfc407)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}}, Nothing, ODESystem}, Vector{Float64}, Nothing}, SciMLBase.UJacobianWrapper{ODEFunction{true, SciMLBase.FullSpecialize, ModelingToolkit.var"#f#462"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x59c3a7a2, 0xa4f17ef9, 0x74b821e5, 0x3e2a77a5, 0xb270babb)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x143becdc, 0x638a98a3, 0x5e7e8d02, 0xa61258ea, 0xf2dfc407)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, 
Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}}, Nothing, ODESystem}, Float64, Nothing}, LinearSolve.LinearCache{Matrix{Float64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, GenericLUFactorization{LinearAlgebra.RowMaximum}, LinearAlgebra.LU{Float64, Matrix{Float64}, Vector{Int64}}, LinearSolve.InvPreconditioner{LinearAlgebra.Diagonal{Float64, Vector{Float64}}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, Float64, Nothing}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, UnitRange{Int64}, Nothing, Val{:forward}(), Float64}, FiniteDiff.GradientCache{Nothing, Vector{Float64}, Vector{Float64}, Float64, Val{:forward}(), Float64, Val{true}()}, Float64, Rosenbrock23{2, false, GenericLUFactorization{LinearAlgebra.RowMaximum}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Nothing}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}}, DiffEqBase.DEStats}}})
    @ Base .\array.jl:716
 [17] map(f::Function, A::Matrix{Num})
    @ Base .\abstractarray.jl:2933
 [18] getindex(A::OrdinaryDiffEq.ODECompositeSolution{Float64, 2, Vector{Vector{Float64}}, Nothing, Nothing, Vector{Float64}, Vector{Vector{Vector{Float64}}}, ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, Nothing, ODEFunction{true, SciMLBase.FullSpecialize, ModelingToolkit.var"#f#462"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x59c3a7a2, 0xa4f17ef9, 0x74b821e5, 0x3e2a77a5, 0xb270babb)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x143becdc, 0x638a98a3, 0x5e7e8d02, 0xa61258ea, 0xf2dfc407)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}}, Nothing, ODESystem}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{2, false, GenericLUFactorization{LinearAlgebra.RowMaximum}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}, OrdinaryDiffEq.CompositeInterpolationData{ODEFunction{true, SciMLBase.FullSpecialize, ModelingToolkit.var"#f#462"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x59c3a7a2, 0xa4f17ef9, 0x74b821e5, 0x3e2a77a5, 0xb270babb)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x143becdc, 0x638a98a3, 0x5e7e8d02, 0xa61258ea, 0xf2dfc407)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}}, Nothing, ODESystem}, Vector{Vector{Float64}}, Vector{Float64}, Vector{Vector{Vector{Float64}}}, OrdinaryDiffEq.CompositeCache{Tuple{OrdinaryDiffEq.Tsit5Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, OrdinaryDiffEq.Tsit5ConstantCache{Float64, Float64}, typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, OrdinaryDiffEq.Rosenbrock23Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Matrix{Float64}, Matrix{Float64}, OrdinaryDiffEq.Rosenbrock23Tableau{Float64}, SciMLBase.TimeGradientWrapper{ODEFunction{true, SciMLBase.FullSpecialize, ModelingToolkit.var"#f#462"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x59c3a7a2, 0xa4f17ef9, 0x74b821e5, 0x3e2a77a5, 0xb270babb)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x143becdc, 0x638a98a3, 0x5e7e8d02, 0xa61258ea, 0xf2dfc407)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}}, Nothing, ODESystem}, Vector{Float64}, 
Nothing}, SciMLBase.UJacobianWrapper{ODEFunction{true, SciMLBase.FullSpecialize, ModelingToolkit.var"#f#462"{RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x59c3a7a2, 0xa4f17ef9, 0x74b821e5, 0x3e2a77a5, 0xb270babb)}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:ˍ₋out, :ˍ₋arg1, :ˍ₋arg2, :t), ModelingToolkit.var"#_RGF_ModTag", ModelingToolkit.var"#_RGF_ModTag", (0x143becdc, 0x638a98a3, 0x5e7e8d02, 0xa61258ea, 0xf2dfc407)}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Symbol}, Symbol, ModelingToolkit.var"#472#generated_observed#469"{Bool, ODESystem, Dict{Any, Any}}, Nothing, ODESystem}, Float64, Nothing}, LinearSolve.LinearCache{Matrix{Float64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, GenericLUFactorization{LinearAlgebra.RowMaximum}, LinearAlgebra.LU{Float64, Matrix{Float64}, Vector{Int64}}, LinearSolve.InvPreconditioner{LinearAlgebra.Diagonal{Float64, Vector{Float64}}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, Float64, Nothing}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, UnitRange{Int64}, Nothing, Val{:forward}(), Float64}, FiniteDiff.GradientCache{Nothing, Vector{Float64}, Vector{Float64}, Float64, Val{:forward}(), 
Float64, Val{true}()}, Float64, Rosenbrock23{2, false, GenericLUFactorization{LinearAlgebra.RowMaximum}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Nothing}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, Nothing, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing}, Rational{Int64}, Int64}}}, DiffEqBase.DEStats}, sym::Symbolics.Arr{Num, 2})
    @ SciMLBase D:\fdietric\.julia\packages\SciMLBase\mgXTt\src\solutions\solution_interface.jl:66
 [19] top-level scope
    @ REPL[49]:1

[florian-die]

This works as expected

using ModelingToolkit
using DifferentialEquations
using Symbolics: scalarize

function system(A,B;name)
    nx = size(A,1)
    nu = size(B,2)
    @variables t x(t)[1:nx,1] u(t)[1:nu,1]
    δ = Differential(t)
    eqs = scalarize(δ.(x) ~ A * x + B * u)
    ODESystem(eqs[:],t,[x...,u...],[];name)
end

function static_controller(K;name)
    nx = size(K,2)
    nu = size(K,1)
    @variables t x(t)[1:nx,1] u(t)[1:nu,1]
    eqs = scalarize(u ~ K * x)
    ODESystem(eqs[:],t,[x...,u...],[];name)
end

A = [0. 1. ; 0. 0.]
B = [0. ; 1. ;;]

K = [-1. -1.]

@named double_integrator = system(A,B)
@named controller = static_controller(K)

connections = [ 
    scalarize(double_integrator.x ~ controller.x)
    scalarize(double_integrator.u ~ controller.u)
    ][:]
    # Matrix{Equation}[:] = Vector{Equation} 

@named connected = ODESystem(connections)

@named sys_con = compose(connected,double_integrator,controller)

sys_simp = structural_simplify(sys_con)

tf = 10.0

X0 = [double_integrator.x[1,1] => 1., double_integrator.x[2,1] => 0.]

prob = ODEProblem(sys_simp,X0,(0.0,tf))

sol = solve(prob)

using Plots
plotlyjs()
plot(sol)

ctrl_plot = plot(sol,idxs=double_integrator.u) 
display(ctrl_plot)

But it fails if I change to K = [-1. 0.], due to a variable wrongly named var"double_integrator₊x(t)[21]ˍt"

julia> sys_simp = structural_simplify(sys_con)
Model sys_con with 2 equations
States (2):
  (double_integrator₊x(t))[2, 1]
  var"double_integrator₊x(t)[21]ˍt"
Parameters (0):
Incidence matrix:2×5 SparseArrays.SparseMatrixCSC{Num, Int64} with 4 stored entries:
 ⋅  ×  ⋅  ×  ⋅
 ×  ⋅  ⋅  ⋅  ×

julia> X0 = [double_integrator.x[1,1] => 1., double_integrator.x[2,1] => 0.]
2-element Vector{Pair{Num, Float64}}:
 (double_integrator₊x(t))[1, 1] => 1.0
 (double_integrator₊x(t))[2, 1] => 0.0

julia> prob = ODEProblem(sys_simp,X0,(0.0,tf))
ERROR: ArgumentError: SymbolicUtils.Symbolic{Real}[var"double_integrator₊x(t)[21]ˍt"] are missing from the variable map.
Stacktrace:
  [1] throw_missingvars(vars::Vector{SymbolicUtils
.Symbolic{Real}})
    @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\Dukjb\src\variables.jl:98
  [2] _varmap_to_vars(varmap::Dict{Num, Float64}, varlist::Vector{SymbolicUtils.Symbolic{Real}}; defaults::Dict{Any, Any}, check::Bool, toterm::typeof(Symbolics.diff2term))
    @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\Dukjb\src\variables.jl:92
  [3] varmap_to_vars(varmap::Vector{Pair{Num, Float64}}, varlist::Vector{SymbolicUtils.Symbolic{Real}}; defaults::Dict{Any, Any}, check::Bool, toterm::Function, promotetoconcrete::Nothing, tofloat::Bool, use_union::Bool)
    @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\Dukjb\src\variables.jl:61
  [4] process_DEProblem(constructor::Type, sys::ODESystem, u0map::Vector{Pair{Num, Float64}}, parammap::SciMLBase.NullParameters; implicit_dae::Bool, du0map::Nothing, version::Nothing, 
tgrad::Bool, jac::Bool, checkbounds::Bool, sparse::Bool, simplify::Bool, linenumbers::Bool, parallel::Nothing, eval_expression::Bool, use_union::Bool, kwargs::Base.Pairs{Symbol, Real, Tuple{Symbol, Symbol, Symbol}, NamedTuple{(:t, :has_difference, :check_length), Tuple{Float64, Bool, Bool}}})
    @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\Dukjb\src\systems\diffeqs\abstractodesystem.jl:561
  [5] (ODEProblem{true, SciMLBase.AutoSpecialize})(sys::ODESystem, u0map::Vector{Pair{Num, Float64}}, tspan::Tuple{Float64, Float64}, parammap::SciMLBase.NullParameters; callback::Nothing, check_length::Bool, kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
    @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\Dukjb\src\systems\diffeqs\abstractodesystem.jl:666
  [6] (ODEProblem{true, SciMLBase.AutoSpecialize})(sys::ODESystem, u0map::Vector{Pair{Num, Float64}}, tspan::Tuple{Float64, Float64}, parammap::SciMLBase.NullParameters) (repeats 2 times)
    @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\Dukjb\src\systems\diffeqs\abstractodesystem.jl:660
  [7] (ODEProblem{true})(::ODESystem, ::Vector{Pair{Num, Float64}}, ::Vararg{Any}; kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
    @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\Dukjb\src\systems\diffeqs\abstractodesystem.jl:653
  [8] (ODEProblem{true})(::ODESystem, ::Vector{Pair{Num, Float64}}, ::Vararg{Any})
    @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\Dukjb\src\systems\diffeqs\abstractodesystem.jl:652
  [9] ODEProblem(::ODESystem, ::Vector{Pair{Num, Float64}}, ::Vararg{Any}; kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
    @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\Dukjb\src\systems\diffeqs\abstractodesystem.jl:649
 [10] ODEProblem(::ODESystem, ::Vector{Pair{Num, Float64}}, ::Vararg{Any})
    @ ModelingToolkit D:\fdietric\.julia\packages\ModelingToolkit\Dukjb\src\systems\diffeqs\abstractodesystem.jl:648
 [11] top-level scope
    @ d:\fdietric\Documents\Julia\ModelingToolkit\mixed\vector_system.jl:55

[AayushSabharwal]

This works:

julia> function linear_system(A,B;name)
           n = size(A,1)
           m = size(B,2)

           @variables x(t)[1:n,1] u(t)[1:m,1]

           eqs = [ D(x) ~ A*x + B*u ]

           ODESystem(eqs, t;name)
       end
julia> function static_gain_ctrl(K;name)
           n = size(K,2)
           m = size(K,1)

           @variables x(t)[1:n,1] u(t)[1:m,1]

           eqs = u ~ - K * x

           ODESystem(eqs, t;name)
       end
julia> @named sys = linear_system(A,B)
julia> kx = 1.0 
julia> kv = 1.0
julia> K = [kx kv]
julia> @named ctrl = static_gain_ctrl(K)
julia> connections = [ ctrl.x ~ sys.x
                ctrl.u ~ sys.u ]
julia> @named connected = ODESystem(connections, t)
julia> @named sys_con = compose(connected,sys,ctrl)
julia> full_equations(sys_con)
4-element Vector{Equation}:
 ctrl₊x(t) ~ sys₊x(t)
 ctrl₊u(t) ~ sys₊u(t)
 Differential(t)(sys₊x(t)) ~ broadcast(+, [0.0 1.0; 0.0 0.0]*sys₊x(t), [0.0; 1.0;;]*sys₊u(t))
 ctrl₊u(t) ~ [-1.0 -1.0]*ctrl₊x(t)
julia> sys_simp = structural_simplify(sys_con)
julia> observed(sys_simp)
4-element Vector{Equation}:
 (ctrl₊x(t))[1, 1] ~ (sys₊x(t))[1, 1]
 (ctrl₊x(t))[2, 1] ~ (sys₊x(t))[2, 1]
 (sys₊u(t))[1, 1] ~ -(sys₊x(t))[1, 1] - (sys₊x(t))[2, 1]
 (ctrl₊u(t))[1, 1] ~ (sys₊u(t))[1, 1]
julia> full_equations(sys_simp)
2-element Vector{Equation}:
 Differential(t)((sys₊x(t))[1, 1]) ~ (sys₊x(t))[2, 1]
 Differential(t)((sys₊x(t))[2, 1]) ~ -(sys₊x(t))[1, 1] - (sys₊x(t))[2, 1]
julia> unknowns(sys_simp)
2-element Vector{SymbolicUtils.BasicSymbolic{Real}}:
 (sys₊x(t))[1, 1]
 (sys₊x(t))[2, 1]
julia> tf = 10.0
julia> prob = ODEProblem(sys_simp,x0,(0.0,tf))
julia> sol = solve(prob, Tsit5())
julia> sol = solve(prob, Tsit5())
retcode: Success
Interpolation: specialized 4th order "free" interpolation
t: 22-element Vector{Float64}:
  0.0
  0.0009990005004983772
  0.010989005505482149
# ...
julia> sol[ctrl.u]
22-element Vector{Vector{Float64}}:
 [-1.0]
 [-0.9999995011651673]
 [-0.9999398420464983]
 [-0.996899837558176]
# ...

Also, this method of problem construction works:

julia> X0 = [sys.x => x0]
julia> prob = ODEProblem(sys_simp,X0,(0.0,tf))

Your later example involving changing K to [-1. 0.] also works.