refactor: change problem constructors to XProblem(sys, op[, tspan])

ext/MTKCasADiDynamicOptExt.jl

@@ -76,8 +76,10 @@ function MTK.CasADiDynamicOptProblem(sys::System, u0map, tspan, pmap;
         steps = nothing,
         guesses = Dict(), kwargs...)
     MTK.warn_overdetermined(sys, u0map)
-    _u0map = has_alg_eqs(sys) ? u0map : merge(Dict(u0map), Dict(guesses))
-    f, u0, p = MTK.process_SciMLProblem(ODEInputFunction, sys, _u0map, pmap;
+    _u0map = has_alg_eqs(sys) ? MTK.to_varmap(u0map, unknowns(sys)) :
+             merge(Dict(u0map), Dict(guesses))
+    pmap = MTK.to_varmap(pmap, parameters(sys))
+    f, u0, p = MTK.process_SciMLProblem(ODEInputFunction, sys, merge(_u0map, pmap);
         t = tspan !== nothing ? tspan[1] : tspan, output_type = MX, kwargs...)
 
     pmap = MTK.recursive_unwrap(MTK.AnyDict(pmap))

ext/MTKInfiniteOptExt.jl

@@ -59,8 +59,10 @@ function MTK.JuMPDynamicOptProblem(sys::System, u0map, tspan, pmap;
         steps = nothing,
         guesses = Dict(), kwargs...)
     MTK.warn_overdetermined(sys, u0map)
-    _u0map = has_alg_eqs(sys) ? u0map : merge(Dict(u0map), Dict(guesses))
-    f, u0, p = MTK.process_SciMLProblem(ODEInputFunction, sys, _u0map, pmap;
+    _u0map = has_alg_eqs(sys) ? MTK.to_varmap(u0map, unknowns(sys)) :
+             merge(Dict(u0map), Dict(guesses))
+    pmap = MTK.to_varmap(pmap, parameters(sys))
+    f, u0, p = MTK.process_SciMLProblem(ODEInputFunction, sys, merge(_u0map, pmap);
         t = tspan !== nothing ? tspan[1] : tspan, kwargs...)
 
     pmap = MTK.recursive_unwrap(MTK.AnyDict(pmap))
@@ -86,8 +88,10 @@ function MTK.InfiniteOptDynamicOptProblem(sys::System, u0map, tspan, pmap;
         steps = nothing,
         guesses = Dict(), kwargs...)
     MTK.warn_overdetermined(sys, u0map)
-    _u0map = has_alg_eqs(sys) ? u0map : merge(Dict(u0map), Dict(guesses))
-    f, u0, p = MTK.process_SciMLProblem(ODEInputFunction, sys, _u0map, pmap;
+    _u0map = has_alg_eqs(sys) ? MTK.to_varmap(u0map, unknowns(sys)) :
+             merge(Dict(u0map), Dict(guesses))
+    pmap = MTK.to_varmap(pmap, parameters(sys))
+    f, u0, p = MTK.process_SciMLProblem(ODEInputFunction, sys, merge(_u0map, pmap);
         t = tspan !== nothing ? tspan[1] : tspan, kwargs...)
 
     pmap = MTK.recursive_unwrap(MTK.AnyDict(pmap))

src/ModelingToolkit.jl

@@ -234,7 +234,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(mtkcompile(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

src/deprecations.jl

@@ -8,4 +8,3 @@ macro mtkbuild(exprs...)
         @mtkcompile $(exprs...)
     end |> esc
 end
-

src/linearization.jl

@@ -73,7 +73,7 @@ function linearization_function(sys::AbstractSystem, inputs,
     end
 
     prob = ODEProblem{true, SciMLBase.FullSpecialize}(
-        sys, op, (nothing, nothing), p; allow_incomplete = true,
+        sys, merge(op, anydict(p)), (nothing, nothing); allow_incomplete = true,
         algebraic_only = true, guesses)
     u0 = state_values(prob)
 

src/problems/bvproblem.jl

@@ -44,7 +44,7 @@ If the `System` has algebraic equations, like `x(t)^2 + y(t)^2`, the resulting
 `BVProblem` must be solved using BVDAE solvers, such as Ascher.
 """
 @fallback_iip_specialize function SciMLBase.BVProblem{iip, spec}(
-        sys::System, u0map, tspan, parammap = SciMLBase.NullParameters();
+        sys::System, op, tspan;
         check_compatibility = true, cse = true,
         checkbounds = false, eval_expression = false, eval_module = @__MODULE__,
         expression = Val{false}, guesses = Dict(), callback = nothing,
@@ -55,22 +55,23 @@ If the `System` has algebraic equations, like `x(t)^2 + y(t)^2`, the resulting
 
     # Systems without algebraic equations should use both fixed values + guesses
     # for initialization.
-    _u0map = has_alg_eqs(sys) ? u0map : merge(Dict(u0map), Dict(guesses))
+    _op = has_alg_eqs(sys) ? op : merge(Dict(op), Dict(guesses))
 
     fode, u0, p = process_SciMLProblem(
-        ODEFunction{iip, spec}, sys, _u0map, parammap; guesses,
+        ODEFunction{iip, spec}, sys, _op; guesses,
         t = tspan !== nothing ? tspan[1] : tspan, check_compatibility = false, cse,
         checkbounds, time_dependent_init = false, expression, kwargs...)
 
     dvs = unknowns(sys)
     stidxmap = Dict([v => i for (i, v) in enumerate(dvs)])
-    u0_idxs = has_alg_eqs(sys) ? collect(1:length(dvs)) : [stidxmap[k] for (k, v) in u0map]
+    u0_idxs = has_alg_eqs(sys) ? collect(1:length(dvs)) :
+              [stidxmap[k] for (k, v) in op if haskey(stidxmap, k)]
     fbc = generate_boundary_conditions(
         sys, u0, u0_idxs, tspan[1]; expression = Val{false},
         wrap_gfw = Val{true}, cse, checkbounds)
 
-    if (length(constraints(sys)) + length(u0map) > length(dvs))
-        @warn "The BVProblem is overdetermined. The total number of conditions (# constraints + # fixed initial values given by u0map) exceeds the total number of states. The BVP solvers will default to doing a nonlinear least-squares optimization."
+    if (length(constraints(sys)) + length(op) > length(dvs))
+        @warn "The BVProblem is overdetermined. The total number of conditions (# constraints + # fixed initial values given by op) exceeds the total number of states. The BVP solvers will default to doing a nonlinear least-squares optimization."
     end
 
     kwargs = process_kwargs(sys; expression, kwargs...)

src/problems/daeproblem.jl

@@ -62,15 +62,15 @@
 end
 
 @fallback_iip_specialize function SciMLBase.DAEProblem{iip, spec}(
-        sys::System, du0map, u0map, tspan, parammap = SciMLBase.NullParameters();
+        sys::System, op, tspan;
         callback = nothing, check_length = true, eval_expression = false,
         eval_module = @__MODULE__, check_compatibility = true,
         expression = Val{false}, kwargs...) where {iip, spec}
     check_complete(sys, DAEProblem)
     check_compatibility && check_compatible_system(DAEProblem, sys)
 
-    f, du0, u0, p = process_SciMLProblem(DAEFunction{iip, spec}, sys, u0map, parammap;
-        du0map, t = tspan !== nothing ? tspan[1] : tspan, check_length, eval_expression,
+    f, du0, u0, p = process_SciMLProblem(DAEFunction{iip, spec}, sys, op;
+        t = tspan !== nothing ? tspan[1] : tspan, check_length, eval_expression,
         eval_module, check_compatibility, implicit_dae = true, expression, kwargs...)
 
     kwargs = process_kwargs(sys; expression, callback, eval_expression, eval_module,

src/problems/ddeproblem.jl

@@ -42,14 +42,14 @@
 end
 
 @fallback_iip_specialize function SciMLBase.DDEProblem{iip, spec}(
-        sys::System, u0map, tspan, parammap = SciMLBase.NullParameters();
+        sys::System, op, tspan;
         callback = nothing, check_length = true, cse = true, checkbounds = false,
         eval_expression = false, eval_module = @__MODULE__, check_compatibility = true,
         u0_constructor = identity, expression = Val{false}, kwargs...) where {iip, spec}
     check_complete(sys, DDEProblem)
     check_compatibility && check_compatible_system(DDEProblem, sys)
 
-    f, u0, p = process_SciMLProblem(DDEFunction{iip, spec}, sys, u0map, parammap;
+    f, u0, p = process_SciMLProblem(DDEFunction{iip, spec}, sys, op;
         t = tspan !== nothing ? tspan[1] : tspan, check_length, cse, checkbounds,
         eval_expression, eval_module, check_compatibility, symbolic_u0 = true,
         expression, u0_constructor, kwargs...)

src/problems/discreteproblem.jl

@@ -39,15 +39,15 @@
 end
 
 @fallback_iip_specialize function SciMLBase.DiscreteProblem{iip, spec}(
-        sys::System, u0map, tspan, parammap = SciMLBase.NullParameters();
+        sys::System, op, tspan;
         check_compatibility = true, expression = Val{false}, kwargs...) where {iip, spec}
     check_complete(sys, DiscreteProblem)
     check_compatibility && check_compatible_system(DiscreteProblem, sys)
 
     dvs = unknowns(sys)
     u0map = to_varmap(u0map, dvs)
     add_toterms!(u0map; replace = true)
-    f, u0, p = process_SciMLProblem(DiscreteFunction{iip, spec}, sys, u0map, parammap;
+    f, u0, p = process_SciMLProblem(DiscreteFunction{iip, spec}, sys, op;
         t = tspan !== nothing ? tspan[1] : tspan, check_compatibility, expression,
         kwargs...)
 

src/problems/implicitdiscreteproblem.jl

@@ -43,16 +43,16 @@
 end
 
 @fallback_iip_specialize function SciMLBase.ImplicitDiscreteProblem{iip, spec}(
-        sys::System, u0map, tspan, parammap = SciMLBase.NullParameters();
+        sys::System, op, tspan;
         check_compatibility = true, expression = Val{false}, kwargs...) where {iip, spec}
     check_complete(sys, ImplicitDiscreteProblem)
     check_compatibility && check_compatible_system(ImplicitDiscreteProblem, sys)
 
     dvs = unknowns(sys)
-    u0map = to_varmap(u0map, dvs)
-    add_toterms!(u0map; replace = true)
+    op = to_varmap(op, dvs)
+    add_toterms!(op; replace = true)
     f, u0, p = process_SciMLProblem(
-        ImplicitDiscreteFunction{iip, spec}, sys, u0map, parammap;
+        ImplicitDiscreteFunction{iip, spec}, sys, op;
         t = tspan !== nothing ? tspan[1] : tspan, check_compatibility,
         expression, kwargs...)
 

src/problems/initializationproblem.jl

@@ -2,8 +2,7 @@ struct InitializationProblem{iip, specialization} end
 
 """
 ```julia
-InitializationProblem{iip}(sys::AbstractSystem, t, u0map,
-                           parammap = DiffEqBase.NullParameters();
+InitializationProblem{iip}(sys::AbstractSystem, t, op;
                            version = nothing, tgrad = false,
                            jac = false,
                            checkbounds = false, sparse = false,
@@ -20,8 +19,7 @@ initial conditions for the given DAE.
 """
 @fallback_iip_specialize function InitializationProblem{iip, specialize}(
         sys::AbstractSystem,
-        t, u0map = [],
-        parammap = DiffEqBase.NullParameters();
+        t, op = Dict();
         guesses = [],
         check_length = true,
         warn_initialize_determined = true,
@@ -37,18 +35,24 @@ initial conditions for the given DAE.
     if !iscomplete(sys)
         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
+    has_u0_ics = false
+    op = copy(anydict(op))
+    for k in keys(op)
+        has_u0_ics |= is_variable(sys, k) || isdifferential(k) ||
+                      symbolic_type(k) == ArraySymbolic() &&
+                      is_sized_array_symbolic(k) && is_variable(sys, first(collect(k)))
+    end
+    if !has_u0_ics && get_initializesystem(sys) !== nothing
         isys = get_initializesystem(sys; initialization_eqs, check_units)
         simplify_system = false
-    elseif isempty(u0map) && get_initializesystem(sys) === nothing
+    elseif !has_u0_ics && get_initializesystem(sys) === nothing
         isys = generate_initializesystem(
-            sys; initialization_eqs, check_units, pmap = parammap,
-            guesses, algebraic_only)
+            sys; initialization_eqs, check_units, op, guesses, algebraic_only)
         simplify_system = true
     else
         isys = generate_initializesystem(
-            sys; u0map, initialization_eqs, check_units, time_dependent_init,
-            pmap = parammap, guesses, algebraic_only)
+            sys; op, initialization_eqs, check_units, time_dependent_init,
+            guesses, algebraic_only)
         simplify_system = true
     end
 
@@ -106,20 +110,17 @@ initial conditions for the given DAE.
         @warn "Initialization system is underdetermined. $neqs equations for $nunknown unknowns. Initialization will default to using least squares. $(scc_message)To suppress this warning pass warn_initialize_determined = false. To make this warning into an error, pass fully_determined = true"
     end
 
-    parammap = recursive_unwrap(anydict(parammap))
     if t !== nothing
-        parammap[get_iv(sys)] = t
+        op[get_iv(sys)] = t
     end
-    filter!(kvp -> kvp[2] !== missing, parammap)
+    filter!(kvp -> kvp[2] !== missing, op)
 
-    u0map = to_varmap(u0map, unknowns(sys))
     if isempty(guesses)
         guesses = Dict()
     end
 
-    filter_missing_values!(u0map)
-    filter_missing_values!(parammap)
-    u0map = merge(ModelingToolkit.guesses(sys), todict(guesses), u0map)
+    filter_missing_values!(op)
+    op = merge(ModelingToolkit.guesses(sys), todict(guesses), op)
 
     TProb = if neqs == nunknown && isempty(unassigned_vars)
         if use_scc && neqs > 0
@@ -135,8 +136,7 @@ initial conditions for the given DAE.
     else
         NonlinearLeastSquaresProblem
     end
-    TProb{iip}(isys, u0map, parammap; kwargs...,
-        build_initializeprob = false, is_initializeprob = true)
+    TProb{iip}(isys, op; kwargs..., build_initializeprob = false, is_initializeprob = true)
 end
 
 const INCOMPLETE_INITIALIZATION_MESSAGE = """

src/problems/intervalnonlinearproblem.jl

@@ -33,7 +33,9 @@ function SciMLBase.IntervalNonlinearProblem(
     check_compatibility && check_compatible_system(IntervalNonlinearProblem, sys)
 
     u0map = unknowns(sys) .=> uspan[1]
-    f, u0, p = process_SciMLProblem(IntervalNonlinearFunction, sys, u0map, parammap;
+    op = anydict([unknowns(sys)[1] => uspan[1]])
+    merge!(op, to_varmap(parammap, parameters(sys)))
+    f, u0, p = process_SciMLProblem(IntervalNonlinearFunction, sys, op;
         check_compatibility, expression, kwargs...)
 
     kwargs = process_kwargs(sys; kwargs...)

src/problems/jumpproblem.jl

@@ -1,5 +1,5 @@
 @fallback_iip_specialize function JumpProcesses.JumpProblem{iip, spec}(
-        sys::System, u0map, tspan::Union{Tuple, Nothing}, pmap = SciMLBase.NullParameters();
+        sys::System, op, tspan::Union{Tuple, Nothing};
         check_compatibility = true, eval_expression = false, eval_module = @__MODULE__,
         checkbounds = false, cse = true, aggregator = JumpProcesses.NullAggregator(),
         callback = nothing, rng = nothing, kwargs...) where {iip, spec}
@@ -13,27 +13,27 @@
     if (has_vrjs || has_eqs)
         if has_eqs && has_noise
             prob = SDEProblem{iip, spec}(
-                sys, u0map, tspan, pmap; check_compatibility = false,
+                sys, op, tspan; check_compatibility = false,
                 build_initializeprob = false, checkbounds, cse, check_length = false,
                 kwargs...)
         elseif has_eqs
             prob = ODEProblem{iip, spec}(
-                sys, u0map, tspan, pmap; check_compatibility = false,
+                sys, op, tspan; check_compatibility = false,
                 build_initializeprob = false, checkbounds, cse, check_length = false,
                 kwargs...)
         else
-            _, u0, p = process_SciMLProblem(EmptySciMLFunction{iip}, sys, u0map, pmap;
-                t = tspan === nothing ? nothing : tspan[1], tofloat = false,
-                check_length = false, build_initializeprob = false)
+            _, u0, p = process_SciMLProblem(EmptySciMLFunction{iip}, sys, op;
+                t = tspan === nothing ? nothing : tspan[1],
+                check_length = false, build_initializeprob = false, kwargs...)
             observedfun = ObservedFunctionCache(sys; eval_expression, eval_module,
                 checkbounds, cse)
             f = (du, u, p, t) -> (du .= 0; nothing)
             df = ODEFunction{true, spec}(f; sys, observed = observedfun)
             prob = ODEProblem{true}(df, u0, tspan, p; kwargs...)
         end
     else
-        _f, u0, p = process_SciMLProblem(EmptySciMLFunction{iip}, sys, u0map, pmap;
-            t = tspan === nothing ? nothing : tspan[1], tofloat = false, check_length = false, build_initializeprob = false, cse)
+        _f, u0, p = process_SciMLProblem(EmptySciMLFunction{iip}, sys, op;
+            t = tspan === nothing ? nothing : tspan[1], check_length = false, build_initializeprob = false, cse, kwargs...)
         f = DiffEqBase.DISCRETE_INPLACE_DEFAULT
 
         observedfun = ObservedFunctionCache(

src/problems/nonlinearproblem.jl

@@ -57,15 +57,15 @@
 end
 
 @fallback_iip_specialize function SciMLBase.NonlinearProblem{iip, spec}(
-        sys::System, u0map, parammap = SciMLBase.NullParameters(); expression = Val{false},
+        sys::System, op; expression = Val{false},
         check_length = true, check_compatibility = true, kwargs...) where {iip, spec}
     check_complete(sys, NonlinearProblem)
     if is_time_dependent(sys)
         sys = NonlinearSystem(sys)
     end
     check_compatibility && check_compatible_system(NonlinearProblem, sys)
 
-    f, u0, p = process_SciMLProblem(NonlinearFunction{iip, spec}, sys, u0map, parammap;
+    f, u0, p = process_SciMLProblem(NonlinearFunction{iip, spec}, sys, op;
         check_length, check_compatibility, expression, kwargs...)
 
     kwargs = process_kwargs(sys; kwargs...)
@@ -75,12 +75,12 @@ end
 end
 
 @fallback_iip_specialize function SciMLBase.NonlinearLeastSquaresProblem{iip, spec}(
-        sys::System, u0map, parammap = DiffEqBase.NullParameters(); check_length = false,
+        sys::System, op; check_length = false,
         check_compatibility = true, expression = Val{false}, kwargs...) where {iip, spec}
     check_complete(sys, NonlinearLeastSquaresProblem)
     check_compatibility && check_compatible_system(NonlinearLeastSquaresProblem, sys)
 
-    f, u0, p = process_SciMLProblem(NonlinearFunction{iip}, sys, u0map, parammap;
+    f, u0, p = process_SciMLProblem(NonlinearFunction{iip}, sys, op;
         check_length, expression, kwargs...)
 
     kwargs = process_kwargs(sys; kwargs...)

src/problems/odeproblem.jl

@@ -65,14 +65,14 @@
 end
 
 @fallback_iip_specialize function SciMLBase.ODEProblem{iip, spec}(
-        sys::System, u0map, tspan, parammap = SciMLBase.NullParameters();
+        sys::System, op, tspan;
         callback = nothing, check_length = true, eval_expression = false,
         expression = Val{false}, eval_module = @__MODULE__, check_compatibility = true,
         kwargs...) where {iip, spec}
     check_complete(sys, ODEProblem)
     check_compatibility && check_compatible_system(ODEProblem, sys)
 
-    f, u0, p = process_SciMLProblem(ODEFunction{iip, spec}, sys, u0map, parammap;
+    f, u0, p = process_SciMLProblem(ODEFunction{iip, spec}, sys, op;
         t = tspan !== nothing ? tspan[1] : tspan, check_length, eval_expression,
         eval_module, expression, check_compatibility, kwargs...)
 
@@ -98,12 +98,12 @@ Generates an SteadyStateProblem from a `System` of ODEs and allows for automatic
 symbolically calculating numerical enhancements.
 """
 @fallback_iip_specialize function DiffEqBase.SteadyStateProblem{iip, spec}(
-        sys::System, u0map, parammap; check_length = true, check_compatibility = true,
+        sys::System, op; check_length = true, check_compatibility = true,
         expression = Val{false}, kwargs...) where {iip, spec}
     check_complete(sys, SteadyStateProblem)
     check_compatibility && check_compatible_system(SteadyStateProblem, sys)
 
-    f, u0, p = process_SciMLProblem(ODEFunction{iip}, sys, u0map, parammap;
+    f, u0, p = process_SciMLProblem(ODEFunction{iip}, sys, op;
         steady_state = true, check_length, check_compatibility, expression,
         force_initialization_time_independent = true, kwargs...)