Search for and replace initial_parameters by initial

Author: hersle

src/inputoutput.jl

@@ -211,7 +211,7 @@ function generate_control_function(sys::AbstractODESystem, inputs = unbound_inpu
     sys, _ = io_preprocessing(sys, inputs, []; simplify, kwargs...)
 
     dvs = unknowns(sys)
-    ps = parameters(sys; initial_parameters = true)
+    ps = parameters(sys; initial = true)
     ps = setdiff(ps, inputs)
     if disturbance_inputs !== nothing
         # remove from inputs since we do not want them as actual inputs to the dynamics

src/linearization.jl

@@ -487,7 +487,7 @@ function linearize_symbolic(sys::AbstractSystem, inputs,
         kwargs...)
     sts = unknowns(sys)
     t = get_iv(sys)
-    ps = parameters(sys; initial_parameters = true)
+    ps = parameters(sys; initial = true)
     p = reorder_parameters(sys, ps)
 
     fun_expr = generate_function(sys, sts, ps; expression = Val{true})[1]

src/systems/abstractsystem.jl

@@ -161,7 +161,7 @@ time-independent systems. If `split=true` (the default) was passed to [`complete
 object.
 """
 function generate_custom_function(sys::AbstractSystem, exprs, dvs = unknowns(sys),
-        ps = parameters(sys; initial_parameters = true);
+        ps = parameters(sys; initial = true);
         expression = Val{true}, eval_expression = false, eval_module = @__MODULE__,
         cachesyms::Tuple = (), kwargs...)
     if !iscomplete(sys)
@@ -512,7 +512,7 @@ function SymbolicIndexingInterface.get_all_timeseries_indexes(sys::AbstractSyste
 end
 
 function SymbolicIndexingInterface.parameter_symbols(sys::AbstractSystem)
-    return parameters(sys; initial_parameters = true)
+    return parameters(sys; initial = true)
 end
 
 function SymbolicIndexingInterface.is_independent_variable(sys::AbstractSystem, sym)
@@ -771,7 +771,7 @@ function complete(
         @set! sys.index_cache = IndexCache(sys)
         # Ideally we'd do `get_ps` but if `flatten = false`
         # we don't get all of them. So we call `parameters`.
-        all_ps = parameters(sys; initial_parameters = true)
+        all_ps = parameters(sys; initial = true)
         if !isempty(all_ps)
             # reorder parameters by portions
             ps_split = reorder_parameters(sys, all_ps)
@@ -1334,13 +1334,13 @@ Get the standard parameters of the system `sys` and its subsystems.
 
 # Keyword arguments
 
-- `initial_parameters`: Whether to include parameters for initial values of variables in the initialization system.
+- `initial`: Whether to include parameters for initial values of variables in the initialization system.
 - `dependent_parameters`: Whether to include parameters that are determined by parameter dependencies.
 
 See also [`full_parameters`](@ref) and [`ModelingToolkit.get_ps`](@ref).
 """
 function parameters(
-        sys::AbstractSystem; initial_parameters = false, dependent_parameters = false)
+        sys::AbstractSystem; initial = false, dependent_parameters = false)
     ps = get_ps(sys)
     if ps == SciMLBase.NullParameters()
         return []
@@ -1351,7 +1351,7 @@ function parameters(
     systems = get_systems(sys)
     ps = unique(isempty(systems) ? ps :
                 [ps; reduce(vcat, namespace_parameters.(systems))])
-    if !initial_parameters && !is_initializesystem(sys)
+    if !initial && !is_initializesystem(sys)
         filter!(x -> !iscall(x) || !isa(operation(x), Initial), ps)
     end
     if dependent_parameters
@@ -1404,7 +1404,7 @@ Get all parameters of the system `sys` and its subsystems, including initial val
 See also [`parameters`](@ref) and [`ModelingToolkit.get_ps`](@ref).
 """
 function full_parameters(sys::AbstractSystem)
-    return parameters(sys; initial_parameters = true, dependent_parameters = true)
+    return parameters(sys; initial = true, dependent_parameters = true)
 end
 
 """

src/systems/callbacks.jl

@@ -712,7 +712,7 @@ function compile_affect(eqs::Vector{Equation}, cb, sys, dvs, ps; outputidxs = no
 end
 
 function generate_rootfinding_callback(sys::AbstractTimeDependentSystem,
-        dvs = unknowns(sys), ps = parameters(sys; initial_parameters = true); kwargs...)
+        dvs = unknowns(sys), ps = parameters(sys; initial = true); kwargs...)
     cbs = continuous_events(sys)
     isempty(cbs) && return nothing
     generate_rootfinding_callback(cbs, sys, dvs, ps; kwargs...)
@@ -723,7 +723,7 @@ generate_rootfinding_callback and thus we can produce a ContinuousCallback inste
 """
 function generate_single_rootfinding_callback(
         eq, cb, sys::AbstractTimeDependentSystem, dvs = unknowns(sys),
-        ps = parameters(sys; initial_parameters = true); kwargs...)
+        ps = parameters(sys; initial = true); kwargs...)
     if !isequal(eq.lhs, 0)
         eq = 0 ~ eq.lhs - eq.rhs
     end
@@ -766,7 +766,7 @@ end
 
 function generate_vector_rootfinding_callback(
         cbs, sys::AbstractTimeDependentSystem, dvs = unknowns(sys),
-        ps = parameters(sys; initial_parameters = true); rootfind = SciMLBase.RightRootFind,
+        ps = parameters(sys; initial = true); rootfind = SciMLBase.RightRootFind,
         reinitialization = SciMLBase.CheckInit(), kwargs...)
     eqs = map(cb -> flatten_equations(cb.eqs), cbs)
     num_eqs = length.(eqs)
@@ -891,7 +891,7 @@ function compile_affect_fn(cb, sys::AbstractTimeDependentSystem, dvs, ps, kwargs
 end
 
 function generate_rootfinding_callback(cbs, sys::AbstractTimeDependentSystem,
-        dvs = unknowns(sys), ps = parameters(sys; initial_parameters = true); kwargs...)
+        dvs = unknowns(sys), ps = parameters(sys; initial = true); kwargs...)
     eqs = map(cb -> flatten_equations(cb.eqs), cbs)
     num_eqs = length.(eqs)
     total_eqs = sum(num_eqs)
@@ -980,7 +980,7 @@ end
 function unassignable_variables(sys, expr)
     assignable_syms = reduce(
         vcat, Symbolics.scalarize.(vcat(
-            unknowns(sys), parameters(sys; initial_parameters = true)));
+            unknowns(sys), parameters(sys; initial = true)));
         init = [])
     written = reduce(vcat, Symbolics.scalarize.(vars(expr)); init = [])
     return filter(
@@ -1107,7 +1107,7 @@ function generate_discrete_callback(cb, sys, dvs, ps; postprocess_affect_expr! =
 end
 
 function generate_discrete_callbacks(sys::AbstractSystem, dvs = unknowns(sys),
-        ps = parameters(sys; initial_parameters = true); kwargs...)
+        ps = parameters(sys; initial = true); kwargs...)
     has_discrete_events(sys) || return nothing
     symcbs = discrete_events(sys)
     isempty(symcbs) && return nothing

src/systems/diffeqs/abstractodesystem.jl

@@ -106,7 +106,7 @@ end
 
 function generate_tgrad(
         sys::AbstractODESystem, dvs = unknowns(sys), ps = parameters(
-            sys; initial_parameters = true);
+            sys; initial = true);
         simplify = false, kwargs...)
     tgrad = calculate_tgrad(sys, simplify = simplify)
     p = reorder_parameters(sys, ps)
@@ -118,7 +118,7 @@ function generate_tgrad(
 end
 
 function generate_jacobian(sys::AbstractODESystem, dvs = unknowns(sys),
-        ps = parameters(sys; initial_parameters = true);
+        ps = parameters(sys; initial = true);
         simplify = false, sparse = false, kwargs...)
     jac = calculate_jacobian(sys; simplify = simplify, sparse = sparse)
     p = reorder_parameters(sys, ps)
@@ -130,15 +130,15 @@ function generate_jacobian(sys::AbstractODESystem, dvs = unknowns(sys),
 end
 
 function generate_control_jacobian(sys::AbstractODESystem, dvs = unknowns(sys),
-        ps = parameters(sys; initial_parameters = true);
+        ps = parameters(sys; initial = true);
         simplify = false, sparse = false, kwargs...)
     jac = calculate_control_jacobian(sys; simplify = simplify, sparse = sparse)
     p = reorder_parameters(sys, ps)
     return build_function_wrapper(sys, jac, dvs, p..., get_iv(sys); kwargs...)
 end
 
 function generate_dae_jacobian(sys::AbstractODESystem, dvs = unknowns(sys),
-        ps = parameters(sys; initial_parameters = true); simplify = false, sparse = false,
+        ps = parameters(sys; initial = true); simplify = false, sparse = false,
         kwargs...)
     jac_u = calculate_jacobian(sys; simplify = simplify, sparse = sparse)
     derivatives = Differential(get_iv(sys)).(unknowns(sys))
@@ -154,7 +154,7 @@ function generate_dae_jacobian(sys::AbstractODESystem, dvs = unknowns(sys),
 end
 
 function generate_function(sys::AbstractODESystem, dvs = unknowns(sys),
-        ps = parameters(sys; initial_parameters = true);
+        ps = parameters(sys; initial = true);
         implicit_dae = false,
         ddvs = implicit_dae ? map(Differential(get_iv(sys)), dvs) :
                nothing,

src/systems/diffeqs/odesystem.jl

@@ -405,7 +405,7 @@ function flatten(sys::ODESystem, noeqs = false)
         return ODESystem(noeqs ? Equation[] : equations(sys),
             get_iv(sys),
             unknowns(sys),
-            parameters(sys; initial_parameters = true),
+            parameters(sys; initial = true),
             parameter_dependencies = parameter_dependencies(sys),
             guesses = guesses(sys),
             observed = observed(sys),
@@ -482,7 +482,7 @@ function build_explicit_observed_function(sys, ts;
         eval_module = @__MODULE__,
         output_type = Array,
         checkbounds = true,
-        ps = parameters(sys; initial_parameters = true),
+        ps = parameters(sys; initial = true),
         return_inplace = false,
         param_only = false,
         op = Operator,

src/systems/diffeqs/sdesystem.jl

@@ -418,7 +418,7 @@ function __get_num_diag_noise(mat)
 end
 
 function generate_diffusion_function(sys::SDESystem, dvs = unknowns(sys),
-        ps = parameters(sys; initial_parameters = true); isdde = false, kwargs...)
+        ps = parameters(sys; initial = true); isdde = false, kwargs...)
     eqs = get_noiseeqs(sys)
     p = reorder_parameters(sys, ps)
     return build_function_wrapper(sys, eqs, dvs, p..., get_iv(sys); kwargs...)

src/systems/index_cache.jl

@@ -194,7 +194,7 @@ function IndexCache(sys::AbstractSystem)
             [BufferTemplate(symtype, length(buf)) for buf in disc_syms_by_partition])
     end
 
-    for p in parameters(sys; initial_parameters = true)
+    for p in parameters(sys; initial = true)
         p = unwrap(p)
         ctype = symtype(p)
         if ctype <: FnType
@@ -492,7 +492,7 @@ function check_index_map(idxmap, sym)
 end
 
 function reorder_parameters(
-        sys::AbstractSystem, ps = parameters(sys; initial_parameters = true); kwargs...)
+        sys::AbstractSystem, ps = parameters(sys; initial = true); kwargs...)
     if has_index_cache(sys) && get_index_cache(sys) !== nothing
         reorder_parameters(get_index_cache(sys), ps; kwargs...)
     elseif ps isa Tuple

src/systems/nonlinear/initializesystem.jl

@@ -121,7 +121,7 @@ function generate_initializesystem(sys::AbstractTimeDependentSystem;
 
     # parameters do not include ones that became initialization unknowns
     pars = Vector{SymbolicParam}(filter(
-        p -> !haskey(paramsubs, p), parameters(sys; initial_parameters = true)))
+        p -> !haskey(paramsubs, p), parameters(sys; initial = true)))
     push!(pars, get_iv(sys))
 
     # 8) use observed equations for guesses of observed variables if not provided
@@ -233,7 +233,7 @@ function generate_initializesystem(sys::AbstractTimeIndependentSystem;
 
     # parameters do not include ones that became initialization unknowns
     pars = Vector{SymbolicParam}(filter(
-        p -> !haskey(paramsubs, p), parameters(sys; initial_parameters = true)))
+        p -> !haskey(paramsubs, p), parameters(sys; initial = true)))
     vars = collect(values(paramsubs))
 
     # even if `p => tovar(p)` is in `paramsubs`, `isparameter(p[1]) === true` after substitution

src/systems/nonlinear/nonlinearsystem.jl

@@ -281,7 +281,7 @@ end
 
 function generate_jacobian(
         sys::NonlinearSystem, vs = unknowns(sys), ps = parameters(
-            sys; initial_parameters = true);
+            sys; initial = true);
         sparse = false, simplify = false, kwargs...)
     jac = calculate_jacobian(sys, sparse = sparse, simplify = simplify)
     p = reorder_parameters(sys, ps)
@@ -302,7 +302,7 @@ end
 
 function generate_hessian(
         sys::NonlinearSystem, vs = unknowns(sys), ps = parameters(
-            sys; initial_parameters = true);
+            sys; initial = true);
         sparse = false, simplify = false, kwargs...)
     hess = calculate_hessian(sys, sparse = sparse, simplify = simplify)
     p = reorder_parameters(sys, ps)
@@ -311,7 +311,7 @@ end
 
 function generate_function(
         sys::NonlinearSystem, dvs = unknowns(sys), ps = parameters(
-            sys; initial_parameters = true);
+            sys; initial = true);
         scalar = false, kwargs...)
     rhss = [deq.rhs for deq in equations(sys)]
     dvs′ = value.(dvs)
@@ -602,7 +602,7 @@ end
 function CacheWriter(sys::AbstractSystem, buffer_types::Vector{TypeT},
         exprs::Dict{TypeT, Vector{Any}}, solsyms, obseqs::Vector{Equation};
         eval_expression = false, eval_module = @__MODULE__)
-    ps = parameters(sys; initial_parameters = true)
+    ps = parameters(sys; initial = true)
     rps = reorder_parameters(sys, ps)
     obs_assigns = [eq.lhs ← eq.rhs for eq in obseqs]
     body = map(eachindex(buffer_types), buffer_types) do i, T
@@ -632,7 +632,7 @@ struct SCCNonlinearFunction{iip} end
 function SCCNonlinearFunction{iip}(
         sys::NonlinearSystem, _eqs, _dvs, _obs, cachesyms; eval_expression = false,
         eval_module = @__MODULE__, kwargs...) where {iip}
-    ps = parameters(sys; initial_parameters = true)
+    ps = parameters(sys; initial = true)
     rps = reorder_parameters(sys, ps)
 
     obs_assignments = [eq.lhs ← eq.rhs for eq in _obs]

src/systems/optimization/constraints_system.jl

@@ -172,7 +172,7 @@ end
 
 function generate_jacobian(
         sys::ConstraintsSystem, vs = unknowns(sys), ps = parameters(
-            sys; initial_parameters = true);
+            sys; initial = true);
         sparse = false, simplify = false, kwargs...)
     jac = calculate_jacobian(sys, sparse = sparse, simplify = simplify)
     p = reorder_parameters(sys, ps)
@@ -192,15 +192,15 @@ end
 
 function generate_hessian(
         sys::ConstraintsSystem, vs = unknowns(sys), ps = parameters(
-            sys; initial_parameters = true);
+            sys; initial = true);
         sparse = false, simplify = false, kwargs...)
     hess = calculate_hessian(sys, sparse = sparse, simplify = simplify)
     p = reorder_parameters(sys, ps)
     return build_function_wrapper(sys, hess, vs, p...; kwargs...)
 end
 
 function generate_function(sys::ConstraintsSystem, dvs = unknowns(sys),
-        ps = parameters(sys; initial_parameters = true);
+        ps = parameters(sys; initial = true);
         kwargs...)
     lhss = generate_canonical_form_lhss(sys)
     p = reorder_parameters(sys, value.(ps))

src/systems/optimization/optimizationsystem.jl

@@ -194,7 +194,7 @@ function calculate_gradient(sys::OptimizationSystem)
 end
 
 function generate_gradient(sys::OptimizationSystem, vs = unknowns(sys),
-        ps = parameters(sys; initial_parameters = true); kwargs...)
+        ps = parameters(sys; initial = true); kwargs...)
     grad = calculate_gradient(sys)
     p = reorder_parameters(sys, ps)
     return build_function_wrapper(sys, grad, vs, p...; kwargs...)
@@ -206,7 +206,7 @@ end
 
 function generate_hessian(
         sys::OptimizationSystem, vs = unknowns(sys), ps = parameters(
-            sys; initial_parameters = true);
+            sys; initial = true);
         sparse = false, kwargs...)
     if sparse
         hess = sparsehessian(objective(sys), unknowns(sys))
@@ -218,7 +218,7 @@ function generate_hessian(
 end
 
 function generate_function(sys::OptimizationSystem, vs = unknowns(sys),
-        ps = parameters(sys; initial_parameters = true);
+        ps = parameters(sys; initial = true);
         kwargs...)
     eqs = objective(sys)
     p = reorder_parameters(sys, ps)

src/systems/parameter_buffer.jl

@@ -34,11 +34,11 @@ function MTKParameters(
     else
         error("Cannot create MTKParameters if system does not have index_cache")
     end
-    all_ps = Set(unwrap.(parameters(sys; initial_parameters = true)))
-    union!(all_ps, default_toterm.(unwrap.(parameters(sys; initial_parameters = true))))
+    all_ps = Set(unwrap.(parameters(sys; initial = true)))
+    union!(all_ps, default_toterm.(unwrap.(parameters(sys; initial = true))))
 
     dvs = unknowns(sys)
-    ps = parameters(sys; initial_parameters = true)
+    ps = parameters(sys; initial = true)
     u0 = to_varmap(u0, dvs)
     symbols_to_symbolics!(sys, u0)
     p = to_varmap(p, ps)

src/systems/problem_utils.jl

@@ -786,7 +786,7 @@ function process_SciMLProblem(
         force_initialization_time_independent = false, algebraic_only = false,
         allow_incomplete = false, is_initializeprob = false, kwargs...)
     dvs = unknowns(sys)
-    ps = parameters(sys; initial_parameters = true)
+    ps = parameters(sys; initial = true)
     iv = has_iv(sys) ? get_iv(sys) : nothing
     eqs = equations(sys)
 
@@ -965,7 +965,7 @@ function get_u0_p(sys,
         use_union = true,
         symbolic_u0 = false)
     dvs = unknowns(sys)
-    ps = parameters(sys; initial_parameters = true)
+    ps = parameters(sys; initial = true)
 
     defs = defaults(sys)
     if t0 !== nothing

src/variables.jl

@@ -419,7 +419,7 @@ end
 ## System interface
 
 """
-    tunable_parameters(sys, p = parameters(sys; initial_parameters = true); default=true)
+    tunable_parameters(sys, p = parameters(sys; initial = true); default=true)
 
 Get all parameters of `sys` that are marked as `tunable`.
 
@@ -439,7 +439,7 @@ call `Symbolics.scalarize(tunable_parameters(sys))` and concatenate the resultin
 See also [`getbounds`](@ref), [`istunable`](@ref), [`MTKParameters`](@ref), [`complete`](@ref)
 """
 function tunable_parameters(
-        sys, p = parameters(sys; initial_parameters = true); default = true)
+        sys, p = parameters(sys; initial = true); default = true)
     filter(x -> istunable(x, default), p)
 end
 

test/split_parameters.jl

@@ -324,6 +324,6 @@ end
     Ms = structural_simplify(M)
 
     @test Set(parameters(Ms)) == Set([P2, I, C])
-    @test Set(parameters(Ms; initial_parameters = true)) == Set([P2, I, C, Initial(P1), Initial(x), Initial(y)])
+    @test Set(parameters(Ms; initial = true)) == Set([P2, I, C, Initial(P1), Initial(x), Initial(y)])
     @test Set(parameters(Ms; dependent_parameters = true)) == Set([P2, I, C, P1])
 end