fix: use new varmap_to_vars

Author: AayushSabharwal

ext/MTKBifurcationKitExt.jl

@@ -113,11 +113,12 @@ function BifurcationKit.BifurcationProblem(nsys::System,
     J = jac ? ofun.jac : nothing
 
     # Converts the input state guess.
-    u0_bif_vals = ModelingToolkit.varmap_to_vars(u0_bif,
-        unknowns(nsys);
-        defaults = ModelingToolkit.get_defaults(nsys))
-    p_vals = ModelingToolkit.varmap_to_vars(
-        ps, parameters(nsys); defaults = ModelingToolkit.get_defaults(nsys))
+    u0_bif = ModelingToolkit.to_varmap(u0_bif, unknowns(nsys))
+    u0_buf = merge(ModelingToolkit.get_defaults(nsys), u0_bif)
+    u0_bif_vals = ModelingToolkit.varmap_to_vars(u0_bif, unknowns(nsys))
+    ps = ModelingToolkit.to_varmap(ps, parameters(nsys))
+    ps = merge(ModelingToolkit.get_defaults(nsys), ps)
+    p_vals = ModelingToolkit.varmap_to_vars(ps, parameters(nsys))
 
     # Computes bifurcation parameter and the plotting function.
     bif_idx = findfirst(isequal(bif_par), parameters(nsys))

src/systems/problem_utils.jl

@@ -1215,11 +1215,11 @@ Keyword arguments:
 - `fully_determined`: Override whether the initialization system is fully determined.
 - `check_initialization_units`: Enable or disable unit checks when constructing the
   initialization problem.
-- `tofloat`: Passed to [`better_varmap_to_vars`](@ref) when building the parameter vector of
+- `tofloat`: Passed to [`varmap_to_vars`](@ref) when building the parameter vector of
   a non-split system.
 - `u0_eltype`: The `eltype` of the `u0` vector. If `nothing`, finds the promoted floating point
   type from `op`.
-- `u0_constructor`: A function to apply to the `u0` value returned from `better_varmap_to_vars`
+- `u0_constructor`: A function to apply to the `u0` value returned from `varmap_to_vars`
   to construct the final `u0` value.
 - `p_constructor`: A function to apply to each array buffer created when constructing the parameter object.
 - `check_length`: Whether to check the number of equations along with number of unknowns and
@@ -1340,11 +1340,10 @@ function process_SciMLProblem(
             @warn "Cycles in unknowns:\n$msg"
         end
     end
-    evaluate_varmap!(op, dvs; limit = substitution_limit)
 
-    u0 = better_varmap_to_vars(
-        op, dvs; buffer_eltype = u0_eltype,
-        container_type = u0Type, allow_symbolic = symbolic_u0, is_initializeprob)
+    u0 = varmap_to_vars(
+        op, dvs; buffer_eltype = u0_eltype, container_type = u0Type,
+        allow_symbolic = symbolic_u0, is_initializeprob, substitution_limit)
 
     if u0 !== nothing
         u0 = u0_constructor(u0)
@@ -1365,15 +1364,15 @@ function process_SciMLProblem(
             @warn "Cycles in parameters:\n$msg"
         end
     end
-    evaluate_varmap!(op, ps; limit = substitution_limit)
+
     if is_split(sys)
         # `pType` is usually `Dict` when the user passes key-value pairs.
         if !(pType <: AbstractArray)
             pType = Array
         end
         p = MTKParameters(sys, op; floatT = floatT, p_constructor)
     else
-        p = p_constructor(better_varmap_to_vars(op, ps; tofloat, container_type = pType))
+        p = p_constructor(varmap_to_vars(op, ps; tofloat, container_type = pType))
     end
 
     if implicit_dae

test/discrete_system.jl

@@ -36,7 +36,7 @@ syss = mtkcompile(sys)
 df = DiscreteFunction(syss)
 # iip
 du = zeros(3)
-u = ModelingToolkit.better_varmap_to_vars(
+u = ModelingToolkit.varmap_to_vars(
     Dict([S(k - 1) => 1, I(k - 1) => 2, R(k - 1) => 3]), unknowns(syss))
 p = MTKParameters(syss, [c, nsteps, δt, β, γ] .=> collect(1:5))
 df.f(du, u, p, 0)

test/extensions/test_infiniteopt.jl

@@ -35,9 +35,9 @@ permutation = [findfirst(isequal(x), expected_state_order) for x in dvs] # This
 
 ##
 
-ub = varmap_to_vars([model.θ => 2pi, model.ω => 10], dvs)
-lb = varmap_to_vars([model.θ => -2pi, model.ω => -10], dvs)
-xf = varmap_to_vars([model.θ => pi, model.ω => 0], dvs)
+ub = varmap_to_vars(Dict{Any, Any}([model.θ => 2pi, model.ω => 10]), dvs)
+lb = varmap_to_vars(Dict{Any, Any}([model.θ => -2pi, model.ω => -10]), dvs)
+xf = varmap_to_vars(Dict{Any, Any}([model.θ => pi, model.ω => 0]), dvs)
 nx = length(dvs)
 nu = length(inputs)
 ny = length(outputs)
@@ -71,8 +71,8 @@ cp = f_obs(x, u, p, τ) # Test that it's possible to trace through an observed f
 @constraint(m, [i = 1:nx], x[i](0)==x0[i]) # Initial condition
 @constraint(m, [i = 1:nx], x[i](1)==xf[i]) # Terminal state
 
-x_scale = varmap_to_vars([model.θ => 1
-                          model.ω => 1], dvs)
+x_scale = varmap_to_vars(Dict{Any, Any}([model.θ => 1
+                                         model.ω => 1]), dvs)
 
 # Add dynamics constraints
 @constraint(m, [i = 1:nx], (∂(x[i], τ) - tf * xp[i]) / x_scale[i]==0)

test/odesystem.jl

@@ -649,7 +649,8 @@ end
 # 1561
 let
     vars = @variables x y
-    arr = ModelingToolkit.varmap_to_vars([x => 0.0, y => [0.0, 1.0]], vars) #error
+    arr = ModelingToolkit.varmap_to_vars(
+        Dict([x => 0.0, y => [0.0, 1.0]]), vars; use_union = true) #error
     sol = Union{Float64, Vector{Float64}}[0.0, [0.0, 1.0]]
     @test arr == sol
     @test typeof(arr) == typeof(sol)

test/symbolic_parameters.jl

@@ -22,8 +22,7 @@ u0 = [
 ]
 ns = System(eqs, [x, y, z], [σ, ρ, β], name = :ns, defaults = [par; u0])
 ModelingToolkit.get_defaults(ns)[y] = u * 1.1
-resolved = ModelingToolkit.varmap_to_vars(Dict(), parameters(ns),
-    defaults = ModelingToolkit.defaults(ns))
+resolved = ModelingToolkit.varmap_to_vars(defaults(ns), parameters(ns))
 @test resolved == [1, 0.1 + 1, (0.1 + 1) * 1.1]
 
 prob = NonlinearProblem(complete(ns), [u => 1.0])
@@ -36,8 +35,7 @@ top = System([0 ~ -a + ns.x + b], [a], [b], systems = [ns], name = :top)
 ModelingToolkit.get_defaults(top)[b] = ns.σ * 0.5
 ModelingToolkit.get_defaults(top)[ns.x] = unknowns(ns, u) * 0.5
 
-res = ModelingToolkit.varmap_to_vars(Dict(), parameters(top),
-    defaults = ModelingToolkit.defaults(top))
+res = ModelingToolkit.varmap_to_vars(defaults(top), parameters(top))
 @test res == [0.5, 1, 0.1 + 1, (0.1 + 1) * 1.1]
 
 top = complete(top)