format

Author: Brad Carman

src/parameters.jl

@@ -66,7 +66,7 @@ function find_types(array)
     by = let set = Dict{Any, Int}(), counter = Ref(0)
         x -> begin
             # t = typeof(x)
-            
+
             get!(set, typeof(x)) do
                 # if t == Float64
                 #     1
@@ -79,16 +79,14 @@ function find_types(array)
     return by.(array)
 end
 
-
 function split_parameters_by_type(ps)
-
     if ps === SciMLBase.NullParameters()
-        return Float64[],[] #use Float64 to avoid Any type warning
+        return Float64[], [] #use Float64 to avoid Any type warning
     else
         by = let set = Dict{Any, Int}(), counter = Ref(0)
-            x -> begin     
+            x -> begin
                 get!(set, typeof(x)) do
-                    counter[] += 1                    
+                    counter[] += 1
                 end
             end
         end
@@ -103,7 +101,7 @@ function split_parameters_by_type(ps)
         tighten_types = x -> identity.(x)
         split_ps = tighten_types.(Base.Fix1(getindex, ps).(split_idxs))
         if length(split_ps) == 1  #Tuple not needed, only 1 type
-            return split_ps[1], split_idxs 
+            return split_ps[1], split_idxs
         else
             return (split_ps...,), split_idxs
         end

src/structural_transformation/codegen.jl

@@ -528,7 +528,8 @@ function ODAEProblem{iip}(sys,
     tspan,
     parammap = DiffEqBase.NullParameters();
     callback = nothing,
-    use_union = false,
+    use_union = true,
+    tofloat = true,
     check = true,
     kwargs...) where {iip}
     eqs = equations(sys)
@@ -540,8 +541,7 @@ function ODAEProblem{iip}(sys,
     defs = ModelingToolkit.mergedefaults(defs, parammap, ps)
     defs = ModelingToolkit.mergedefaults(defs, u0map, dvs)
     u0 = ModelingToolkit.varmap_to_vars(u0map, dvs; defaults = defs, tofloat = true)
-    p = ModelingToolkit.varmap_to_vars(parammap, ps; defaults = defs, tofloat = !use_union,
-        use_union)
+    p = ModelingToolkit.varmap_to_vars(parammap, ps; defaults = defs, tofloat, use_union)
 
     has_difference = any(isdifferenceeq, eqs)
     cbs = process_events(sys; callback, has_difference, kwargs...)

src/systems/diffeqs/abstractodesystem.jl

@@ -153,11 +153,12 @@ function generate_function(sys::AbstractODESystem, dvs = states(sys), ps = param
                 kwargs...)
         else
             if p isa Tuple
-                build_function(rhss, u, p..., t; postprocess_fbody = pre, states = sol_states,
+                build_function(rhss, u, p..., t; postprocess_fbody = pre,
+                    states = sol_states,
                     kwargs...)
             else
                 build_function(rhss, u, p, t; postprocess_fbody = pre, states = sol_states,
-                kwargs...)
+                    kwargs...)
             end
         end
     end
@@ -332,7 +333,7 @@ function DiffEqBase.ODEFunction{iip, specialize}(sys::AbstractODESystem, dvs = s
     analytic = nothing,
     kwargs...) where {iip, specialize}
     f_gen = generate_function(sys, dvs, ps; expression = Val{eval_expression},
-        expression_module = eval_module, checkbounds = checkbounds, 
+        expression_module = eval_module, checkbounds = checkbounds,
         kwargs...)
     f_oop, f_iip = eval_expression ?
                    (drop_expr(@RuntimeGeneratedFunction(eval_module, ex)) for ex in f_gen) :
@@ -689,7 +690,7 @@ function ODEFunctionExpr{iip}(sys::AbstractODESystem, dvs = states(sys),
 end
 
 """
-    u0, p, defs = get_u0_p(sys, u0map, parammap; use_union=false, tofloat=!use_union)
+    u0, p, defs = get_u0_p(sys, u0map, parammap; use_union=true, tofloat=true)
 
 Take dictionaries with initial conditions and parameters and convert them to numeric arrays `u0` and `p`. Also return the merged dictionary `defs` containing the entire operating point.
 """
@@ -743,11 +744,11 @@ function process_DEProblem(constructor, sys::AbstractODESystem, u0map, parammap;
         symbolic_u0)
 
     # if split_parameters
-        p, split_idxs = split_parameters_by_type(p)
-        if p isa Tuple
-            ps = Base.Fix1(getindex, parameters(sys)).(split_idxs)
-            ps = (ps...,) #if p is Tuple, ps should be Tuple
-        end
+    p, split_idxs = split_parameters_by_type(p)
+    if p isa Tuple
+        ps = Base.Fix1(getindex, parameters(sys)).(split_idxs)
+        ps = (ps...,) #if p is Tuple, ps should be Tuple
+    end
     # end
 
     if implicit_dae && du0map !== nothing
@@ -765,7 +766,7 @@ function process_DEProblem(constructor, sys::AbstractODESystem, u0map, parammap;
     f = constructor(sys, dvs, ps, u0; ddvs = ddvs, tgrad = tgrad, jac = jac,
         checkbounds = checkbounds, p = p,
         linenumbers = linenumbers, parallel = parallel, simplify = simplify,
-        sparse = sparse, eval_expression = eval_expression, 
+        sparse = sparse, eval_expression = eval_expression,
         kwargs...)
     implicit_dae ? (f, du0, u0, p) : (f, u0, p)
 end

src/utils.jl

@@ -670,7 +670,7 @@ end
     throw(ArgumentError("$vars are either missing from the variable map or missing from the system's states/parameters list."))
 end
 
-function promote_to_concrete(vs; tofloat = true, use_union = false)
+function promote_to_concrete(vs; tofloat = true, use_union = true)
     if isempty(vs)
         return vs
     end

test/odesystem.jl

@@ -734,18 +734,23 @@ let
     u0map = [A => 1.0]
     pmap = (k1 => 1.0, k2 => 1)
     tspan = (0.0, 1.0)
-    prob = ODEProblem(sys, u0map, tspan, pmap; tofloat=false)
-
+    prob = ODEProblem(sys, u0map, tspan, pmap; tofloat = false)
     @test prob.p == ([1], [1.0]) #Tuple([(Dict(pmap))[k] for k in values(parameters(sys))])
 
+    prob = ODEProblem(sys, u0map, tspan, pmap)
+    @test prob.p isa Vector{Float64}
+
     pmap = [k1 => 1, k2 => 1]
     tspan = (0.0, 1.0)
     prob = ODEProblem(sys, u0map, tspan, pmap)
     @test eltype(prob.p) === Float64
-    
-    prob = ODEProblem(sys, u0map, tspan, pmap; tofloat=false)
+
+    prob = ODEProblem(sys, u0map, tspan, pmap; tofloat = false)
     @test eltype(prob.p) === Int
 
+    prob = ODEProblem(sys, u0map, tspan, pmap)
+    @test prob.p isa Vector{Float64}
+
     # No longer supported, Tuple used instead
     # pmap = Pair{Any, Union{Int, Float64}}[k1 => 1, k2 => 1.0]
     # tspan = (0.0, 1.0)

test/split_parameters.jl

@@ -2,8 +2,6 @@ using ModelingToolkit, Test
 using ModelingToolkitStandardLibrary.Blocks
 using OrdinaryDiffEq
 
-
-
 # ------------------------ Mixed Single Values and Vector
 
 dt = 4e-4
@@ -14,11 +12,10 @@ x = @. time^2 + 1.0
 @parameters t
 D = Differential(t)
 
-get_value(data, t, dt) = data[round(Int, t/dt+1)]
+get_value(data, t, dt) = data[round(Int, t / dt + 1)]
 @register_symbolic get_value(data, t, dt)
 
-
-function Sampled(; name, data=Float64[], dt=0.0)
+function Sampled(; name, data = Float64[], dt = 0.0)
     pars = @parameters begin
         data = data
         dt = dt
@@ -30,7 +27,7 @@ function Sampled(; name, data=Float64[], dt=0.0)
     end
 
     eqs = [
-        output.u ~ get_value(data, t, dt)
+        output.u ~ get_value(data, t, dt),
     ]
 
     return ODESystem(eqs, t, vars, pars; name, systems,
@@ -54,15 +51,13 @@ prob = ODEProblem(sys, [], (0.0, t_end), [s.src.data => x])
 sol = solve(prob, ImplicitEuler());
 @test sol.retcode == ReturnCode.Success
 
-
 # ------------------------ Mixed Type Converted to float (default behavior)
 
 vars = @variables y(t)=1 dy(t)=0 ddy(t)=0
 pars = @parameters a=1.0 b=2.0 c=3
-eqs = [
-    D(y) ~ dy*a
-    D(dy) ~ ddy*b
-    ddy ~ sin(t)*c]
+eqs = [D(y) ~ dy * a
+    D(dy) ~ ddy * b
+    ddy ~ sin(t) * c]
 
 @named sys = ODESystem(eqs, t, vars, pars)
 sys = structural_simplify(sys)
@@ -74,14 +69,10 @@ prob = ODEProblem(sys, [], tspan, [])
 sol = solve(prob, ImplicitEuler());
 @test sol.retcode == ReturnCode.Success
 
-
 # ------------------------ Mixed Type Conserved
 
-prob = ODEProblem(sys, [], tspan, []; tofloat=false)
+prob = ODEProblem(sys, [], tspan, []; tofloat = false)
 
 @test prob.p isa Tuple{Vector{Float64}, Vector{Int64}}
 sol = solve(prob, ImplicitEuler());
 @test sol.retcode == ReturnCode.Success
-
-
-