revert index cache

Author: vyudu

src/systems/callbacks.jl

@@ -160,7 +160,7 @@ const Affect = Union{AffectSystem, FunctionalAffect, ImperativeAffect}
 
 """
     SymbolicContinuousCallback(eqs::Vector{Equation}, affect = nothing, iv = nothing; 
-                               affect_neg = affect, initialize = nothing, finalize = nothing, rootfind = SciMLBase.LeftRootFind, algeeqs = Equation[])
+                               affect_neg = affect, initialize = nothing, finalize = nothing, rootfind = SciMLBase.LeftRootFind, alg_eqs = Equation[])
 
 A [`ContinuousCallback`](@ref SciMLBase.ContinuousCallback) specified symbolically. Takes a vector of equations `eq`
 as well as the positive-edge `affect` and negative-edge `affect_neg` that apply when *any* of `eq` are satisfied.
@@ -226,7 +226,7 @@ struct SymbolicContinuousCallback <: AbstractCallback
             rootfind = SciMLBase.LeftRootFind,
             reinitializealg = nothing,
             iv = nothing,
-            algeeqs = Equation[])
+            alg_eqs = Equation[])
         conditions = (conditions isa AbstractVector) ? conditions : [conditions]
 
         if isnothing(reinitializealg)
@@ -236,29 +236,30 @@ struct SymbolicContinuousCallback <: AbstractCallback
             reinitializealg = SciMLBase.NoInit()
         end
 
-        new(conditions, make_affect(affect; iv, algeeqs, discrete_parameters),
-            make_affect(affect_neg; iv, algeeqs, discrete_parameters),
-            make_affect(initialize; iv, algeeqs, discrete_parameters), make_affect(
-                finalize; iv, algeeqs, discrete_parameters),
+        new(conditions, make_affect(affect; iv, alg_eqs, discrete_parameters),
+            make_affect(affect_neg; iv, alg_eqs, discrete_parameters),
+            make_affect(initialize; iv, alg_eqs, discrete_parameters), make_affect(
+                finalize; iv, alg_eqs, discrete_parameters),
             rootfind, reinitializealg)
     end # Default affect to nothing
 end
 
-function SymbolicContinuousCallback(p::Pair, args...; kwargs...)
-    SymbolicContinuousCallback(p[1], p[2], args...; kwargs...)
+SymbolicContinuousCallback(p::Pair, args...; kwargs...) = SymbolicContinuousCallback(p[1], p[2], args...; kwargs...)
+
+function SymbolicContinuousCallback(cb::SymbolicContinuousCallback, args...; iv = nothing, alg_eqs = Equation[], kwargs...)
+    cb
 end
-SymbolicContinuousCallback(cb::SymbolicContinuousCallback, args...; kwargs...) = cb
 
 make_affect(affect::Nothing; kwargs...) = nothing
 make_affect(affect::Tuple; kwargs...) = FunctionalAffect(affect...)
 make_affect(affect::NamedTuple; kwargs...) = FunctionalAffect(; affect...)
 make_affect(affect::Affect; kwargs...) = affect
 
 function make_affect(affect::Vector{Equation}; discrete_parameters::AbstractVector = Any[],
-        iv = nothing, algeeqs::Vector{Equation} = Equation[])
+        iv = nothing, alg_eqs::Vector{Equation} = Equation[])
     isempty(affect) && return nothing
-    isempty(algeeqs) &&
-        @warn "No algebraic equations were found for the callback defined by $(join(affect, ", ")). If the system has no algebraic equations, this can be disregarded. Otherwise pass in `algeeqs` to the SymbolicContinuousCallback constructor."
+    isempty(alg_eqs) &&
+        @warn "No algebraic equations were found for the callback defined by $(join(affect, ", ")). If the system has no algebraic equations, this can be disregarded. Otherwise pass in `alg_eqs` to the SymbolicContinuousCallback constructor."
     if isnothing(iv)
         iv = t_nounits
         @warn "No independent variable specified. Defaulting to t_nounits."
@@ -280,7 +281,7 @@ function make_affect(affect::Vector{Equation}; discrete_parameters::AbstractVect
         diffvs = collect_applied_operators(eq, Differential)
         union!(dvs, diffvs)
     end
-    for eq in algeeqs
+    for eq in alg_eqs
         collect_vars!(dvs, params, eq, iv)
     end
 
@@ -294,10 +295,10 @@ function make_affect(affect::Vector{Equation}; discrete_parameters::AbstractVect
     rev_map = Dict(zip(discrete_parameters, discretes))
     subs = merge(rev_map, Dict(zip(dvs, _dvs)))
     affect = Symbolics.fast_substitute(affect, subs)
-    algeeqs = Symbolics.fast_substitute(algeeqs, subs)
+    alg_eqs = Symbolics.fast_substitute(alg_eqs, subs)
 
     @named affectsys = ImplicitDiscreteSystem(
-        vcat(affect, algeeqs), iv, collect(union(_dvs, discretes)),
+        vcat(affect, alg_eqs), iv, collect(union(_dvs, discretes)),
         collect(union(pre_params, sys_params)))
     affectsys = structural_simplify(affectsys; fully_determined = false)
     # get accessed parameters p from Pre(p) in the callback parameters
@@ -322,7 +323,7 @@ end
 Generate continuous callbacks.
 """
 function SymbolicContinuousCallbacks(events; discrete_parameters = Any[],
-        algeeqs::Vector{Equation} = Equation[], iv = nothing)
+        alg_eqs::Vector{Equation} = Equation[], iv = nothing)
     callbacks = SymbolicContinuousCallback[]
     isnothing(events) && return callbacks
 
@@ -332,7 +333,7 @@ function SymbolicContinuousCallbacks(events; discrete_parameters = Any[],
     for event in events
         cond, affs = event isa Pair ? (event[1], event[2]) : (event, nothing)
         push!(callbacks,
-            SymbolicContinuousCallback(cond, affs; iv, algeeqs, discrete_parameters))
+            SymbolicContinuousCallback(cond, affs; iv, alg_eqs, discrete_parameters))
     end
     callbacks
 end
@@ -421,7 +422,7 @@ end
 # TODO: Iterative callbacks
 """
     SymbolicDiscreteCallback(conditions::Vector{Equation}, affect = nothing, iv = nothing;
-                             initialize = nothing, finalize = nothing, algeeqs = Equation[])
+                             initialize = nothing, finalize = nothing, alg_eqs = Equation[])
 
 A callback that triggers at the first timestep that the conditions are satisfied.
 
@@ -432,7 +433,7 @@ The condition can be one of:
 
 Arguments: 
 - iv: The independent variable of the system. This must be specified if the independent variable appaers in one of the equations explicitly, as in x ~ t + 1.
-- algeeqs: Algebraic equations of the system that must be satisfied after the callback occurs.
+- alg_eqs: Algebraic equations of the system that must be satisfied after the callback occurs.
 """
 struct SymbolicDiscreteCallback <: AbstractCallback
     conditions::Any
@@ -444,7 +445,7 @@ struct SymbolicDiscreteCallback <: AbstractCallback
     function SymbolicDiscreteCallback(
             condition, affect = nothing;
             initialize = nothing, finalize = nothing, iv = nothing,
-            algeeqs = Equation[], discrete_parameters = Any[], reinitializealg = nothing)
+            alg_eqs = Equation[], discrete_parameters = Any[], reinitializealg = nothing)
         c = is_timed_condition(condition) ? condition : value(scalarize(condition))
 
         if isnothing(reinitializealg)
@@ -453,9 +454,9 @@ struct SymbolicDiscreteCallback <: AbstractCallback
             reinitializealg = SciMLBase.CheckInit() :
             reinitializealg = SciMLBase.NoInit()
         end
-        new(c, make_affect(affect; iv, algeeqs, discrete_parameters),
-            make_affect(initialize; iv, algeeqs, discrete_parameters),
-            make_affect(finalize; iv, algeeqs, discrete_parameters), reinitializealg)
+        new(c, make_affect(affect; iv, alg_eqs, discrete_parameters),
+            make_affect(initialize; iv, alg_eqs, discrete_parameters),
+            make_affect(finalize; iv, alg_eqs, discrete_parameters), reinitializealg)
     end # Default affect to nothing
 end
 
@@ -468,7 +469,7 @@ SymbolicDiscreteCallback(cb::SymbolicDiscreteCallback, args...; kwargs...) = cb
 Generate discrete callbacks.
 """
 function SymbolicDiscreteCallbacks(events; discrete_parameters::Vector = Any[],
-        algeeqs::Vector{Equation} = Equation[], iv = nothing)
+        alg_eqs::Vector{Equation} = Equation[], iv = nothing)
     callbacks = SymbolicDiscreteCallback[]
 
     isnothing(events) && return callbacks
@@ -478,7 +479,7 @@ function SymbolicDiscreteCallbacks(events; discrete_parameters::Vector = Any[],
     for event in events
         cond, affs = event isa Pair ? (event[1], event[2]) : (event, nothing)
         push!(callbacks,
-            SymbolicDiscreteCallback(cond, affs; iv, algeeqs, discrete_parameters))
+            SymbolicDiscreteCallback(cond, affs; iv, alg_eqs, discrete_parameters))
     end
     callbacks
 end

src/systems/diffeqs/odesystem.jl

@@ -311,10 +311,10 @@ function ODESystem(deqs::AbstractVector{<:Equation}, iv, dvs, ps;
         throw(ArgumentError("System names must be unique."))
     end
 
-    algeeqs = filter(eq -> eq.lhs isa Union{Symbolic, Number} && !is_diff_equation(eq),
+    alg_eqs = filter(eq -> eq.lhs isa Union{Symbolic, Number} && !is_diff_equation(eq),
         deqs)
-    cont_callbacks = SymbolicContinuousCallbacks(continuous_events; algeeqs, iv)
-    disc_callbacks = SymbolicDiscreteCallbacks(discrete_events; algeeqs, iv)
+    cont_callbacks = SymbolicContinuousCallbacks(continuous_events; alg_eqs, iv)
+    disc_callbacks = SymbolicDiscreteCallbacks(discrete_events; alg_eqs, iv)
 
     if is_dde === nothing
         is_dde = _check_if_dde(deqs, iv′, systems)

src/systems/diffeqs/sdesystem.jl

@@ -268,10 +268,10 @@ function SDESystem(deqs::AbstractVector{<:Equation}, neqs::AbstractArray, iv, dv
     Wfact = RefValue(EMPTY_JAC)
     Wfact_t = RefValue(EMPTY_JAC)
 
-    algeeqs = filter(eq -> eq.lhs isa Union{Symbolic, Number} && !is_diff_equation(eq),
+    alg_eqs = filter(eq -> eq.lhs isa Union{Symbolic, Number} && !is_diff_equation(eq),
         deqs)
-    cont_callbacks = SymbolicContinuousCallbacks(continuous_events; algeeqs, iv)
-    disc_callbacks = SymbolicDiscreteCallbacks(discrete_events; algeeqs, iv)
+    cont_callbacks = SymbolicContinuousCallbacks(continuous_events; alg_eqs, iv)
+    disc_callbacks = SymbolicDiscreteCallbacks(discrete_events; alg_eqs, iv)
     if is_dde === nothing
         is_dde = _check_if_dde(deqs, iv′, systems)
     end

src/systems/index_cache.jl

@@ -345,13 +345,8 @@ function IndexCache(sys::AbstractSystem)
             vs = vars(eq.rhs; op = Nothing)
             timeseries = TimeseriesSetType()
             if is_time_dependent(sys)
-                unknown_set = Set(unknowns(sys))
                 for v in vs
-                    if in(v, unknown_set)
-                        empty!(timeseries)
-                        push!(timeseries, ContinuousTimeseries())
-                        break
-                    elseif (idx = get(disc_idxs, v, nothing)) !== nothing
+                    if (idx = get(disc_idxs, v, nothing)) !== nothing
                         push!(timeseries, idx.clock_idx)
                     elseif iscall(v) && operation(v) === getindex &&
                            (idx = get(disc_idxs, arguments(v)[1], nothing)) !== nothing

test/accessor_functions.jl

@@ -152,9 +152,9 @@ let
     # as I stored the same single event in all systems). Don't check for non-toplevel cases as
     # technically not needed for these tests and name spacing the events is a mess.
     bot_cev = ModelingToolkit.SymbolicContinuousCallback(
-        cevs[1], algeeqs = [O ~ (d + p_bot) * X_bot + Y])
+        cevs[1], alg_eqs = [O ~ (d + p_bot) * X_bot + Y])
     mid_dev = ModelingToolkit.SymbolicDiscreteCallback(
-        devs[1], algeeqs = [O ~ (d + p_mid1) * X_mid1 + Y])
+        devs[1], alg_eqs = [O ~ (d + p_mid1) * X_mid1 + Y])
     @test all_sets_equal(
         continuous_events_toplevel.([sys_bot, sys_bot_comp, sys_bot_ss])...,
         [bot_cev])

test/symbolic_events.jl

@@ -1321,15 +1321,15 @@ end
     @test ≈(sol(5.0000001, idxs = x) - sol(4.999999, idxs = x), 0.1, rtol = 1e-4)
 
     # Proper re-initialization after parameter change
-    eqs = [y ~ g^2 - x, D(x) ~ x]
+    eqs = [y ~ g^2, D(x) ~ x]
     c_evt = SymbolicContinuousCallback(
         [t ~ 5.0], [x ~ Pre(x) + 1, g ~ Pre(g) + 1], discrete_parameters = [g], iv = t)
     @mtkbuild sys = ODESystem(eqs, t, continuous_events = c_evt)
     prob = ODEProblem(sys, [x => 1.0], (0.0, 10.0), [g => 2])
     sol = solve(prob, FBDF())
     @test sol.ps[g] ≈ [2.0, 3.0]
     @test ≈(sol(5.00000001, idxs = x) - sol(4.9999999, idxs = x), 1; rtol = 1e-4)
-    @test ≈(sol(5.00000001, idxs = y), 9 - sol(5.00000001, idxs = x), rtol = 1e-4)
+    @test ≈(sol(5.00000001, idxs = y), 9, rtol = 1e-4)
 
     # Parameters that don't appear in affects should not be mutated.
     c_evt = [t ~ 5.0] => [x ~ Pre(x) + 1]
@@ -1338,4 +1338,3 @@ end
     sol = solve(prob, FBDF())
     @test prob.ps[g] == sol.ps[g]
 end
-# - explicit equation of t in a functional affect