diff --git a/src/problems/ode_problems.jl b/src/problems/ode_problems.jl index bb228e84d..bc9be9400 100644 --- a/src/problems/ode_problems.jl +++ b/src/problems/ode_problems.jl @@ -174,6 +174,17 @@ function Base.setproperty!(prob::ODEProblem, s::Symbol, v, order::Symbol) Base.setfield!(prob, s, v, order) end +function ConstructionBase.constructorof(::Type{P}) where {P <: ODEProblem} + function ctor(f, u0, tspan, p, kw, pt) + if f isa AbstractODEFunction + iip = isinplace(f) + else + iip = isinplace(f, 4) + end + return ODEProblem{iip}(f, u0, tspan, p, pt; kw...) + end +end + """ ODEProblem(f::ODEFunction,u0,tspan,p=NullParameters(),callback=CallbackSet()) diff --git a/src/remake.jl b/src/remake.jl index fcececb79..6de145f8d 100644 --- a/src/remake.jl +++ b/src/remake.jl @@ -112,20 +112,24 @@ function remake(prob::ODEProblem; f = missing, p = missing, kwargs = missing, interpret_symbolicmap = true, + build_initializeprob = true, use_defaults = false, _kwargs...) if tspan === missing tspan = prob.tspan end - newu0, newp = updated_u0_p(prob, u0, p; interpret_symbolicmap, use_defaults) + newu0, newp = updated_u0_p(prob, u0, p, tspan[1]; interpret_symbolicmap, use_defaults) iip = isinplace(prob) if f === missing - initializeprob, initializeprobmap = remake_initializeprob( - prob.f.sys, prob.f, u0 === missing ? newu0 : u0, - tspan[1], p === missing ? newp : p) + if build_initializeprob + initializeprob, update_initializeprob!, initializeprobmap, initializeprobpmap = remake_initializeprob( + prob.f.sys, prob.f, u0, tspan[1], p) + else + initializeprob = update_initializeprob! = initializeprobmap = initializeprobpmap = nothing + end if specialization(prob.f) === FunctionWrapperSpecialize ptspan = promote_tspan(tspan) if iip @@ -134,14 +138,14 @@ function remake(prob::ODEProblem; f = missing, unwrapped_f(prob.f.f), (newu0, newu0, newp, ptspan[1])); - initializeprob, initializeprobmap) + initializeprob, update_initializeprob!, initializeprobmap, initializeprobpmap) else _f = ODEFunction{iip, FunctionWrapperSpecialize}( wrapfun_oop( unwrapped_f(prob.f.f), (newu0, newp, ptspan[1])); - initializeprob, initializeprobmap) + initializeprob, update_initializeprob!, initializeprobmap, initializeprobpmap) end else _f = prob.f @@ -152,6 +156,13 @@ function remake(prob::ODEProblem; f = missing, _f = parameterless_type(_f){ iip, specialization(_f), map(typeof, props)...}(props...) end + if __has_update_initializeprob!(_f) + props = getproperties(_f) + @reset props.update_initializeprob! = update_initializeprob! + props = values(props) + _f = parameterless_type(_f){ + iip, specialization(_f), map(typeof, props)...}(props...) + end if __has_initializeprobmap(_f) props = getproperties(_f) @reset props.initializeprobmap = initializeprobmap @@ -159,6 +170,13 @@ function remake(prob::ODEProblem; f = missing, _f = parameterless_type(_f){ iip, specialization(_f), map(typeof, props)...}(props...) end + if __has_initializeprobpmap(_f) + props = getproperties(_f) + @reset props.initializeprobpmap = initializeprobpmap + props = values(props) + _f = parameterless_type(_f){ + iip, specialization(_f), map(typeof, props)...}(props...) + end end elseif f isa AbstractODEFunction _f = f @@ -189,15 +207,20 @@ end remake_initializeprob(sys, scimlfn, u0, t0, p) Re-create the initialization problem present in the function `scimlfn`, using the -associated system `sys`, and the new values of `u0`, initial time `t0` and `p`. By -default, returns `nothing, nothing` if `scimlfn` does not have an initialization -problem, and `scimlfn.initializeprob, scimlfn.initializeprobmap` if it does. +associated system `sys`, and the user-provided new values of `u0`, initial time `t0` and +`p`. By default, returns `nothing, nothing, nothing, nothing` if `scimlfn` does not have an +initialization problem, and +`scimlfn.initializeprob, scimlfn.update_initializeprob!, scimlfn.initializeprobmap, scimlfn.initializeprobpmap` +if it does. + +Note that `u0` or `p` may be `missing` if the user does not provide a value for them. """ function remake_initializeprob(sys, scimlfn, u0, t0, p) if !has_initializeprob(scimlfn) - return nothing, nothing + return nothing, nothing, nothing, nothing end - return scimlfn.initializeprob, scimlfn.initializeprobmap + return scimlfn.initializeprob, + scimlfn.update_initializeprob!, scimlfn.initializeprobmap, scimlfn.initializeprobpmap end """ @@ -214,7 +237,7 @@ function remake(prob::BVProblem{uType, tType, iip, nlls}; f = missing, bc = miss tspan = prob.tspan end - u0, p = updated_u0_p(prob, u0, p; interpret_symbolicmap, use_defaults) + u0, p = updated_u0_p(prob, u0, p, tspan[1]; interpret_symbolicmap, use_defaults) if problem_type === missing problem_type = prob.problem_type @@ -280,7 +303,7 @@ function remake(prob::SDEProblem; tspan = prob.tspan end - u0, p = updated_u0_p(prob, u0, p; interpret_symbolicmap, use_defaults) + u0, p = updated_u0_p(prob, u0, p, tspan[1]; interpret_symbolicmap, use_defaults) if noise === missing noise = prob.noise @@ -496,35 +519,35 @@ anydict(d) = Dict{Any, Any}(d) anydict() = Dict{Any, Any}() function _updated_u0_p_internal( - prob, ::Missing, ::Missing; interpret_symbolicmap = true, use_defaults = false) + prob, ::Missing, ::Missing, t0; interpret_symbolicmap = true, use_defaults = false) return state_values(prob), parameter_values(prob) end function _updated_u0_p_internal( - prob, ::Missing, p; interpret_symbolicmap = true, use_defaults = false) + prob, ::Missing, p, t0; interpret_symbolicmap = true, use_defaults = false) u0 = state_values(prob) if p isa AbstractArray && isempty(p) return _updated_u0_p_internal( - prob, u0, parameter_values(prob); interpret_symbolicmap) + prob, u0, parameter_values(prob), t0; interpret_symbolicmap) end eltype(p) <: Pair && interpret_symbolicmap || return u0, p defs = default_values(prob) p = fill_p(prob, anydict(p); defs, use_defaults) - return _updated_u0_p_symmap(prob, u0, Val(false), p, Val(true)) + return _updated_u0_p_symmap(prob, u0, Val(false), p, Val(true), t0) end function _updated_u0_p_internal( - prob, u0, ::Missing; interpret_symbolicmap = true, use_defaults = false) + prob, u0, ::Missing, t0; interpret_symbolicmap = true, use_defaults = false) p = parameter_values(prob) eltype(u0) <: Pair || return u0, p defs = default_values(prob) u0 = fill_u0(prob, anydict(u0); defs, use_defaults) - return _updated_u0_p_symmap(prob, u0, Val(true), p, Val(false)) + return _updated_u0_p_symmap(prob, u0, Val(true), p, Val(false), t0) end function _updated_u0_p_internal( - prob, u0, p; interpret_symbolicmap = true, use_defaults = false) + prob, u0, p, t0; interpret_symbolicmap = true, use_defaults = false) isu0symbolic = eltype(u0) <: Pair ispsymbolic = eltype(p) <: Pair && interpret_symbolicmap @@ -538,7 +561,7 @@ function _updated_u0_p_internal( if ispsymbolic p = fill_p(prob, anydict(p); defs, use_defaults) end - return _updated_u0_p_symmap(prob, u0, Val(isu0symbolic), p, Val(ispsymbolic)) + return _updated_u0_p_symmap(prob, u0, Val(isu0symbolic), p, Val(ispsymbolic), t0) end function fill_u0(prob, u0; defs = nothing, use_defaults = false) @@ -629,7 +652,7 @@ function fill_p(prob, p; defs = nothing, use_defaults = false) return newvals end -function _updated_u0_p_symmap(prob, u0, ::Val{true}, p, ::Val{false}) +function _updated_u0_p_symmap(prob, u0, ::Val{true}, p, ::Val{false}, t0) isdep = any(symbolic_type(v) !== NotSymbolic() for (_, v) in u0) isdep || return remake_buffer(prob, state_values(prob), keys(u0), values(u0)), p @@ -642,13 +665,13 @@ function _updated_u0_p_symmap(prob, u0, ::Val{true}, p, ::Val{false}) # FIXME: need to provide `u` since the observed function expects it. # This is sort of an implicit dependency on MTK. The values of `u` won't actually be # used, since any state symbols in the expression were substituted out earlier. - temp_state = ProblemState(; u = state_values(prob), p = p) + temp_state = ProblemState(; u = state_values(prob), p = p, t = t0) u0 = anydict(k => symbolic_type(v) === NotSymbolic() ? v : getu(prob, v)(temp_state) for (k, v) in u0) return remake_buffer(prob, state_values(prob), keys(u0), values(u0)), p end -function _updated_u0_p_symmap(prob, u0, ::Val{false}, p, ::Val{true}) +function _updated_u0_p_symmap(prob, u0, ::Val{false}, p, ::Val{true}, t0) isdep = any(symbolic_type(v) !== NotSymbolic() for (_, v) in p) isdep || return u0, remake_buffer(prob, parameter_values(prob), keys(p), values(p)) @@ -661,13 +684,13 @@ function _updated_u0_p_symmap(prob, u0, ::Val{false}, p, ::Val{true}) # FIXME: need to provide `p` since the observed function expects an `MTKParameters` # this is sort of an implicit dependency on MTK. The values of `p` won't actually be # used, since any parameter symbols in the expression were substituted out earlier. - temp_state = ProblemState(; u = u0, p = parameter_values(prob)) + temp_state = ProblemState(; u = u0, p = parameter_values(prob), t = t0) p = anydict(k => symbolic_type(v) === NotSymbolic() ? v : getu(prob, v)(temp_state) for (k, v) in p) return u0, remake_buffer(prob, parameter_values(prob), keys(p), values(p)) end -function _updated_u0_p_symmap(prob, u0, ::Val{true}, p, ::Val{true}) +function _updated_u0_p_symmap(prob, u0, ::Val{true}, p, ::Val{true}, t0) isu0dep = any(symbolic_type(v) !== NotSymbolic() for (_, v) in u0) ispdep = any(symbolic_type(v) !== NotSymbolic() for (_, v) in p) @@ -677,11 +700,11 @@ function _updated_u0_p_symmap(prob, u0, ::Val{true}, p, ::Val{true}) end if !isu0dep u0 = remake_buffer(prob, state_values(prob), keys(u0), values(u0)) - return _updated_u0_p_symmap(prob, u0, Val(false), p, Val(true)) + return _updated_u0_p_symmap(prob, u0, Val(false), p, Val(true), t0) end if !ispdep p = remake_buffer(prob, parameter_values(prob), keys(p), values(p)) - return _updated_u0_p_symmap(prob, u0, Val(true), p, Val(false)) + return _updated_u0_p_symmap(prob, u0, Val(true), p, Val(false), t0) end varmap = merge(u0, p) @@ -693,7 +716,8 @@ function _updated_u0_p_symmap(prob, u0, ::Val{true}, p, ::Val{true}) remake_buffer(prob, parameter_values(prob), keys(p), values(p)) end -function updated_u0_p(prob, u0, p; interpret_symbolicmap = true, use_defaults = false) +function updated_u0_p( + prob, u0, p, t0 = nothing; interpret_symbolicmap = true, use_defaults = false) if u0 === missing && p === missing return state_values(prob), parameter_values(prob) end @@ -712,7 +736,7 @@ function updated_u0_p(prob, u0, p; interpret_symbolicmap = true, use_defaults = return (u0 === missing ? state_values(prob) : u0), (p === missing ? parameter_values(prob) : p) end - return _updated_u0_p_internal(prob, u0, p; interpret_symbolicmap, use_defaults) + return _updated_u0_p_internal(prob, u0, p, t0; interpret_symbolicmap, use_defaults) end # overloaded in MTK to intercept symbolic remake diff --git a/src/scimlfunctions.jl b/src/scimlfunctions.jl index 50370c36d..0b41d59d9 100644 --- a/src/scimlfunctions.jl +++ b/src/scimlfunctions.jl @@ -402,7 +402,7 @@ numerically-defined functions. """ struct ODEFunction{iip, specialize, F, TMM, Ta, Tt, TJ, JVP, VJP, JP, SP, TW, TWt, WP, TPJ, O, TCV, - SYS, IProb, IProbMap} <: AbstractODEFunction{iip} + SYS, IProb, UIProb, IProbMap, IProbPmap} <: AbstractODEFunction{iip} f::F mass_matrix::TMM analytic::Ta @@ -420,7 +420,9 @@ struct ODEFunction{iip, specialize, F, TMM, Ta, Tt, TJ, JVP, VJP, JP, SP, TW, TW colorvec::TCV sys::SYS initializeprob::IProb + update_initializeprob!::UIProb initializeprobmap::IProbMap + initializeprobpmap::IProbPmap end @doc doc""" @@ -518,7 +520,7 @@ information on generating the SplitFunction from this symbolic engine. struct SplitFunction{ iip, specialize, F1, F2, TMM, C, Ta, Tt, TJ, JVP, VJP, JP, SP, TW, TWt, TPJ, O, - TCV, SYS, IProb, IProbMap} <: AbstractODEFunction{iip} + TCV, SYS, IProb, UIProb, IProbMap, IProbPmap} <: AbstractODEFunction{iip} f1::F1 f2::F2 mass_matrix::TMM @@ -537,7 +539,9 @@ struct SplitFunction{ colorvec::TCV sys::SYS initializeprob::IProb + update_initializeprob!::UIProb initializeprobmap::IProbMap + initializeprobpmap::IProbPmap end @doc doc""" @@ -1506,7 +1510,7 @@ automatically symbolically generating the Jacobian and more from the numerically-defined functions. """ struct DAEFunction{iip, specialize, F, Ta, Tt, TJ, JVP, VJP, JP, SP, TW, TWt, TPJ, O, TCV, - SYS, IProb, IProbMap} <: + SYS, IProb, UIProb, IProbMap, IProbPmap} <: AbstractDAEFunction{iip} f::F analytic::Ta @@ -1523,7 +1527,9 @@ struct DAEFunction{iip, specialize, F, Ta, Tt, TJ, JVP, VJP, JP, SP, TW, TWt, TP colorvec::TCV sys::SYS initializeprob::IProb + update_initializeprob!::UIProb initializeprobmap::IProbMap + initializeprobpmap::IProbPmap end """ @@ -2410,7 +2416,10 @@ function ODEFunction{iip, specialize}(f; colorvec = __has_colorvec(f) ? f.colorvec : nothing, sys = __has_sys(f) ? f.sys : nothing, initializeprob = __has_initializeprob(f) ? f.initializeprob : nothing, - initializeprobmap = __has_initializeprobmap(f) ? f.initializeprobmap : nothing + update_initializeprob! = __has_update_initializeprob!(f) ? + f.update_initializeprob! : nothing, + initializeprobmap = __has_initializeprobmap(f) ? f.initializeprobmap : nothing, + initializeprobpmap = __has_initializeprobpmap(f) ? f.initializeprobpmap : nothing ) where {iip, specialize } @@ -2468,10 +2477,11 @@ function ODEFunction{iip, specialize}(f; typeof(sparsity), Any, Any, typeof(W_prototype), Any, Any, typeof(_colorvec), - typeof(sys), Any, Any}(_f, mass_matrix, analytic, tgrad, jac, + typeof(sys), Any, Any, Any, Any}(_f, mass_matrix, analytic, tgrad, jac, jvp, vjp, jac_prototype, sparsity, Wfact, Wfact_t, W_prototype, paramjac, - observed, _colorvec, sys, initializeprob, initializeprobmap) + observed, _colorvec, sys, initializeprob, update_initializeprob!, initializeprobmap, + initializeprobpmap) elseif specialize === false ODEFunction{iip, FunctionWrapperSpecialize, typeof(_f), typeof(mass_matrix), typeof(analytic), typeof(tgrad), @@ -2480,11 +2490,13 @@ function ODEFunction{iip, specialize}(f; typeof(paramjac), typeof(observed), typeof(_colorvec), - typeof(sys), typeof(initializeprob), - typeof(initializeprobmap)}(_f, mass_matrix, analytic, tgrad, jac, + typeof(sys), typeof(initializeprob), typeof(update_initializeprob!), + typeof(initializeprobmap), typeof(initializeprobpmap)}(_f, mass_matrix, + analytic, tgrad, jac, jvp, vjp, jac_prototype, sparsity, Wfact, Wfact_t, W_prototype, paramjac, - observed, _colorvec, sys, initializeprob, initializeprobmap) + observed, _colorvec, sys, initializeprob, update_initializeprob!, initializeprobmap, + initializeprobpmap) else ODEFunction{iip, specialize, typeof(_f), typeof(mass_matrix), typeof(analytic), typeof(tgrad), @@ -2493,11 +2505,13 @@ function ODEFunction{iip, specialize}(f; typeof(paramjac), typeof(observed), typeof(_colorvec), - typeof(sys), typeof(initializeprob), - typeof(initializeprobmap)}(_f, mass_matrix, analytic, tgrad, jac, + typeof(sys), typeof(initializeprob), typeof(update_initializeprob!), + typeof(initializeprobmap), + typeof(initializeprobpmap)}(_f, mass_matrix, analytic, tgrad, jac, jvp, vjp, jac_prototype, sparsity, Wfact, Wfact_t, W_prototype, paramjac, - observed, _colorvec, sys, initializeprob, initializeprobmap) + observed, _colorvec, sys, initializeprob, update_initializeprob!, initializeprobmap, + initializeprobpmap) end end @@ -2514,10 +2528,13 @@ function unwrapped_f(f::ODEFunction, newf = unwrapped_f(f.f)) Any, Any, Any, Any, typeof(f.jac_prototype), typeof(f.sparsity), Any, Any, Any, Any, typeof(f.colorvec), - typeof(f.sys), Any, Any}(newf, f.mass_matrix, f.analytic, f.tgrad, f.jac, + typeof(f.sys), Any, Any, Any, Any}( + newf, f.mass_matrix, f.analytic, f.tgrad, f.jac, f.jvp, f.vjp, f.jac_prototype, f.sparsity, f.Wfact, f.Wfact_t, f.W_prototype, f.paramjac, - f.observed, f.colorvec, f.sys, f.initializeprob, f.initializeprobmap) + f.observed, f.colorvec, f.sys, f.initializeprob, + f.update_initializeprob!, f.initializeprobmap, + f.initializeprobpmap) else ODEFunction{isinplace(f), specialization(f), typeof(newf), typeof(f.mass_matrix), typeof(f.analytic), typeof(f.tgrad), @@ -2525,12 +2542,13 @@ function unwrapped_f(f::ODEFunction, newf = unwrapped_f(f.f)) typeof(f.sparsity), typeof(f.Wfact), typeof(f.Wfact_t), typeof(f.W_prototype), typeof(f.paramjac), typeof(f.observed), typeof(f.colorvec), - typeof(f.sys), typeof(f.initializeprob), - typeof(f.initializeprobmap)}(newf, f.mass_matrix, f.analytic, f.tgrad, f.jac, + typeof(f.sys), typeof(f.initializeprob), typeof(f.update_initializeprob!), + typeof(f.initializeprobmap), + typeof(f.initializeprobpmap)}(newf, f.mass_matrix, f.analytic, f.tgrad, f.jac, f.jvp, f.vjp, f.jac_prototype, f.sparsity, f.Wfact, f.Wfact_t, f.W_prototype, f.paramjac, - f.observed, f.colorvec, f.sys, f.initializeprob, - f.initializeprobmap) + f.observed, f.colorvec, f.sys, f.initializeprob, f.update_initializeprob!, + f.initializeprobmap, f.initializeprobpmap) end end @@ -2632,7 +2650,8 @@ end @add_kwonly function SplitFunction(f1, f2, mass_matrix, cache, analytic, tgrad, jac, jvp, vjp, jac_prototype, sparsity, Wfact, Wfact_t, paramjac, - observed, colorvec, sys, initializeprob, initializeprobmap) + observed, colorvec, sys, initializeprob, update_initializeprob!, + initializeprobmap, initializeprobpmap) f1 = ODEFunction(f1) f2 = ODEFunction(f2) @@ -2646,11 +2665,12 @@ end typeof(cache), typeof(analytic), typeof(tgrad), typeof(jac), typeof(jvp), typeof(vjp), typeof(jac_prototype), typeof(sparsity), typeof(Wfact), typeof(Wfact_t), typeof(paramjac), typeof(observed), typeof(colorvec), - typeof(sys), typeof(initializeprob), typeof(initializeprobmap)}( + typeof(sys), typeof(initializeprob), typeof(update_initializeprob!), typeof(initializeprobmap), + typeof(initializeprobpmap)}( f1, f2, mass_matrix, cache, analytic, tgrad, jac, jvp, vjp, jac_prototype, sparsity, Wfact, Wfact_t, paramjac, observed, colorvec, sys, - initializeprob, initializeprobmap) + initializeprob, update_initializeprob!, initializeprobmap, initializeprobpmap) end function SplitFunction{iip, specialize}(f1, f2; mass_matrix = __has_mass_matrix(f1) ? @@ -2680,7 +2700,10 @@ function SplitFunction{iip, specialize}(f1, f2; nothing, sys = __has_sys(f1) ? f1.sys : nothing, initializeprob = __has_initializeprob(f1) ? f1.initializeprob : nothing, - initializeprobmap = __has_initializeprobmap(f1) ? f1.initializeprobmap : nothing + update_initializeprob! = __has_update_initializeprob!(f1) ? + f1.update_initializeprob! : nothing, + initializeprobmap = __has_initializeprobmap(f1) ? f1.initializeprobmap : nothing, + initializeprobpmap = __has_initializeprobpmap(f1) ? f1.initializeprobpmap : nothing ) where {iip, specialize } @@ -2690,12 +2713,13 @@ function SplitFunction{iip, specialize}(f1, f2; if specialize === NoSpecialize SplitFunction{iip, specialize, Any, Any, Any, Any, Any, Any, Any, Any, Any, - Any, Any, Any, Any, Any, - Any, Any, Any, Any, Any}(f1, f2, mass_matrix, _func_cache, + Any, Any, Any, Any, Any, Any, + Any, Any, Any, Any, Any, Any}(f1, f2, mass_matrix, _func_cache, analytic, tgrad, jac, jvp, vjp, jac_prototype, sparsity, Wfact, Wfact_t, paramjac, - observed, colorvec, sys, initializeprob, initializeprobmap) + observed, colorvec, sys, initializeprob.update_initializeprob!, initializeprobmap, + initializeprobpmap, initializeprobpmap) else SplitFunction{iip, specialize, typeof(f1), typeof(f2), typeof(mass_matrix), typeof(_func_cache), typeof(analytic), @@ -2703,11 +2727,13 @@ function SplitFunction{iip, specialize}(f1, f2; typeof(jac_prototype), typeof(sparsity), typeof(Wfact), typeof(Wfact_t), typeof(paramjac), typeof(observed), typeof(colorvec), - typeof(sys), typeof(initializeprob), typeof(initializeprobmap)}(f1, f2, + typeof(sys), typeof(initializeprob), typeof(update_initializeprob!), + typeof(initializeprobmap), + typeof(initializeprobpmap)}(f1, f2, mass_matrix, _func_cache, analytic, tgrad, jac, jvp, vjp, jac_prototype, sparsity, Wfact, Wfact_t, paramjac, observed, colorvec, sys, - initializeprob, initializeprobmap) + initializeprob, update_initializeprob!, initializeprobmap, initializeprobpmap) end end @@ -3333,7 +3359,10 @@ function DAEFunction{iip, specialize}(f; colorvec = __has_colorvec(f) ? f.colorvec : nothing, sys = __has_sys(f) ? f.sys : nothing, initializeprob = __has_initializeprob(f) ? f.initializeprob : nothing, - initializeprobmap = __has_initializeprobmap(f) ? f.initializeprobmap : nothing) where { + update_initializeprob! = __has_update_initializeprob!(f) ? + f.update_initializeprob! : nothing, + initializeprobmap = __has_initializeprobmap(f) ? f.initializeprobmap : nothing, + initializeprobpmap = __has_initializeprobpmap(f) ? f.initializeprobpmap : nothing) where { iip, specialize } @@ -3373,21 +3402,25 @@ function DAEFunction{iip, specialize}(f; DAEFunction{iip, specialize, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, Any, - Any, typeof(_colorvec), Any, Any, Any}(_f, analytic, tgrad, jac, jvp, + Any, typeof(_colorvec), Any, Any, Any, Any, Any}(_f, analytic, tgrad, jac, jvp, vjp, jac_prototype, sparsity, Wfact, Wfact_t, paramjac, observed, - _colorvec, sys, initializeprob, initializeprobmap) + _colorvec, sys, initializeprob, update_initializeprob!, + initializeprobmap, initializeprobpmap) else DAEFunction{iip, specialize, typeof(_f), typeof(analytic), typeof(tgrad), typeof(jac), typeof(jvp), typeof(vjp), typeof(jac_prototype), typeof(sparsity), typeof(Wfact), typeof(Wfact_t), typeof(paramjac), typeof(observed), typeof(_colorvec), - typeof(sys), typeof(initializeprob), typeof(initializeprobmap)}( + typeof(sys), typeof(initializeprob), typeof(update_initializeprob!), + typeof(initializeprobmap), + typeof(initializeprobpmap)}( _f, analytic, tgrad, jac, jvp, vjp, jac_prototype, sparsity, Wfact, Wfact_t, paramjac, observed, - _colorvec, sys, initializeprob, initializeprobmap) + _colorvec, sys, initializeprob, update_initializeprob!, + initializeprobmap, initializeprobpmap) end end @@ -4330,7 +4363,9 @@ __has_sys(f) = isdefined(f, :sys) __has_analytic_full(f) = isdefined(f, :analytic_full) __has_resid_prototype(f) = isdefined(f, :resid_prototype) __has_initializeprob(f) = isdefined(f, :initializeprob) +__has_update_initializeprob!(f) = isdefined(f, :update_initializeprob!) __has_initializeprobmap(f) = isdefined(f, :initializeprobmap) +__has_initializeprobpmap(f) = isdefined(f, :initializeprobpmap) # compatibility has_invW(f::AbstractSciMLFunction) = false @@ -4346,9 +4381,15 @@ has_sys(f::AbstractSciMLFunction) = __has_sys(f) && f.sys !== nothing function has_initializeprob(f::AbstractSciMLFunction) __has_initializeprob(f) && f.initializeprob !== nothing end +function has_update_initializeprob!(f::AbstractSciMLFunction) + __has_update_initializeprob!(f) && f.update_initializeprob! !== nothing +end function has_initializeprobmap(f::AbstractSciMLFunction) __has_initializeprobmap(f) && f.initializeprobmap !== nothing end +function has_initializeprobpmap(f::AbstractSciMLFunction) + __has_initializeprobpmap(f) && f.initializeprobpmap !== nothing +end function has_syms(f::AbstractSciMLFunction) if __has_syms(f)