MTK doesn't support complex equations of motion since MTK@v9.73

[oameye]

In MTK@v9.73, the function float_type_from_varmap was introduced, but doesn't cover complex eqautions of motion.

ModelingToolkit.jl/src/systems/problem_utils.jl

Lines 1175 to 1193 in 5449800

	"""
	$(TYPEDSIGNATURES)
	Calculate the floating point type to use from the given `varmap` by looking at variables
	with a constant value.
	"""
	function float_type_from_varmap(varmap, floatT = Bool)
	for (k, v) in varmap
	symbolic_type(v) == NotSymbolic() || continue
	is_array_of_symbolics(v) && continue
	if v isa AbstractArray
	floatT = promote_type(floatT, eltype(v))
	elseif v isa Real
	floatT = promote_type(floatT, typeof(v))
	end
	end
	return float(floatT)
	end

This will make it one solves the system with OrdinaryDiffEq, one hits:

ERROR: InexactError: Float64(0.0 + 5.0im)
Stacktrace:
  [1] Real
    @ ./complex.jl:44 [inlined]
  [2] _broadcast_getindex_evalf
    @ ./broadcast.jl:709 [inlined]
  [3] _broadcast_getindex
    @ ./broadcast.jl:682 [inlined]
  [4] getindex
    @ ./broadcast.jl:636 [inlined]
  [5] macro expansion
    @ ./broadcast.jl:1004 [inlined]
  [6] macro expansion
    @ ./simdloop.jl:77 [inlined]
  [7] copyto!
    @ ./broadcast.jl:1003 [inlined]
  [8] copyto!
    @ ./broadcast.jl:956 [inlined]
  [9] copy
    @ ./broadcast.jl:928 [inlined]
 [10] materialize(bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{…}, Nothing, Type{…}, Tuple{…}})
    @ Base.Broadcast ./broadcast.jl:903
 [11] better_varmap_to_vars(varmap::Dict{…}, vars::Vector{…}; tofloat::Bool, container_type::Type, floatT::Type, toterm::Function, promotetoconcrete::Nothing, check::Bool, allow_symbolic::Bool, is_initializeprob::Bool)
    @ ModelingToolkit ~/.julia/packages/ModelingToolkit/15RQb/src/systems/problem_utils.jl:370
 [12] process_SciMLProblem(constructor::Type, sys::ODESystem, u0map::Vector{…}, pmap::Vector{…}; build_initializeprob::Bool, implicit_dae::Bool, t::Float64, guesses::Dict{…}, warn_initialize_determined::Bool, initialization_eqs::Vector{…}, eval_expression::Bool, eval_module::Module, fully_determined::Nothing, check_initialization_units::Bool, tofloat::Bool, u0_constructor::typeof(identity), du0map::Nothing, check_length::Bool, symbolic_u0::Bool, warn_cyclic_dependency::Bool, circular_dependency_max_cycle_length::Int64, circular_dependency_max_cycles::Int64, substitution_limit::Int64, use_scc::Bool, force_initialization_time_independent::Bool, algebraic_only::Bool, allow_incomplete::Bool, is_initializeprob::Bool, kwargs::@Kwargs{})
    @ ModelingToolkit ~/.julia/packages/ModelingToolkit/15RQb/src/systems/problem_utils.jl:888
 [13] (ODEProblem{…})(sys::ODESystem, u0map::Vector{…}, tspan::Tuple{…}, parammap::Vector{…}; allow_cost::Bool, callback::Nothing, check_length::Bool, warn_initialize_determined::Bool, eval_expression::Bool, eval_module::Module, kwargs::@Kwargs{})
    @ ModelingToolkit ~/.julia/packages/ModelingToolkit/15RQb/src/systems/diffeqs/abstractodesystem.jl:801
 [14] (ODEProblem{…})(sys::ODESystem, u0map::Vector{…}, tspan::Tuple{…}, parammap::Vector{…})
    @ ModelingToolkit ~/.julia/packages/ModelingToolkit/15RQb/src/systems/diffeqs/abstractodesystem.jl:776
 [15] (ODEProblem{true})(::ODESystem, ::Vector{ComplexF64}, ::Vararg{Any}; kwargs::@Kwargs{})
    @ ModelingToolkit ~/.julia/packages/ModelingToolkit/15RQb/src/systems/diffeqs/abstractodesystem.jl:769
 [16] (ODEProblem{true})(::ODESystem, ::Vector{ComplexF64}, ::Vararg{Any})
    @ ModelingToolkit ~/.julia/packages/ModelingToolkit/15RQb/src/systems/diffeqs/abstractodesystem.jl:768
 [17] ODEProblem(::ODESystem, ::Vector{ComplexF64}, ::Vararg{Any}; kwargs::@Kwargs{})
    @ ModelingToolkit ~/.julia/packages/ModelingToolkit/15RQb/src/systems/diffeqs/abstractodesystem.jl:758
 [18] ODEProblem(::ODESystem, ::Vector{ComplexF64}, ::Vararg{Any})
    @ ModelingToolkit ~/.julia/packages/ModelingToolkit/15RQb/src/systems/diffeqs/abstractodesystem.jl:757
 [19] top-level scope
    @ ~/Documents/QuantumCumulants.jl/test/MTK@9.73.jl:68

As this sliped through the cracks, on should probably add a complex equations of motion system to the test suite.

[oameye]

It's not only float_type_from_varmap, but also IndexCache assumes Real such that tunable_buffer and initials_buffer assume real.

ModelingToolkit.jl/src/systems/index_cache.jl

Lines 380 to 397 in 5449800

	return IndexCache(
	unk_idxs,
	disc_idxs,
	callback_to_clocks,
	tunable_idxs,
	initials_idxs,
	const_idxs,
	nonnumeric_idxs,
	observed_syms_to_timeseries,
	dependent_pars_to_timeseries,
	disc_buffer_templates,
	BufferTemplate(Real, tunable_buffer_size),
	BufferTemplate(Real, initials_buffer_size),
	const_buffer_sizes,
	nonnumeric_buffer_sizes,
	symbol_to_variable
	)
	end

ModelingToolkit.jl/src/systems/parameter_buffer.jl

Lines 71 to 107 in 5449800

	tunable_buffer = Vector{ic.tunable_buffer_size.type}(
	undef, ic.tunable_buffer_size.length)
	initials_buffer = Vector{ic.initials_buffer_size.type}(
	undef, ic.initials_buffer_size.length)
	disc_buffer = Tuple(BlockedArray(
	Vector{subbuffer_sizes[1].type}(
	undef, sum(x -> x.length, subbuffer_sizes)),
	map(x -> x.length, subbuffer_sizes))
	for subbuffer_sizes in ic.discrete_buffer_sizes)
	const_buffer = Tuple(Vector{temp.type}(undef, temp.length)
	for temp in ic.constant_buffer_sizes)
	nonnumeric_buffer = Tuple(Vector{temp.type}(undef, temp.length)
	for temp in ic.nonnumeric_buffer_sizes)
	function set_value(sym, val)
	done = true
	if haskey(ic.tunable_idx, sym)
	idx = ic.tunable_idx[sym]
	tunable_buffer[idx] = val
	elseif haskey(ic.initials_idx, sym)
	idx = ic.initials_idx[sym]
	initials_buffer[idx] = val
	elseif haskey(ic.discrete_idx, sym)
	idx = ic.discrete_idx[sym]
	disc_buffer[idx.buffer_idx][idx.idx_in_buffer] = val
	elseif haskey(ic.constant_idx, sym)
	i, j = ic.constant_idx[sym]
	const_buffer[i][j] = val
	elseif haskey(ic.nonnumeric_idx, sym)
	i, j = ic.nonnumeric_idx[sym]
	nonnumeric_buffer[i][j] = val
	elseif !isequal(default_toterm(sym), sym)
	done = set_value(default_toterm(sym), val)
	else
	done = false
	end
	return done
	end