fix: remove the plural constructors

Author: vyudu

docs/src/systems/DiscreteSystem.md

@@ -12,7 +12,6 @@ DiscreteSystem
   - `get_unknowns(sys)` or `unknowns(sys)`: The set of unknowns in the discrete system.
   - `get_ps(sys)` or `parameters(sys)`: The parameters of the discrete system.
   - `get_iv(sys)`: The independent variable of the discrete system
-  - `discrete_events(sys)`: The set of discrete events in the discrete system.
 
 ## Transformations
 

docs/src/systems/ImplicitDiscreteSystem.md

@@ -12,7 +12,6 @@ ImplicitDiscreteSystem
   - `get_unknowns(sys)` or `unknowns(sys)`: The set of unknowns in the implicit discrete system.
   - `get_ps(sys)` or `parameters(sys)`: The parameters of the implicit discrete system.
   - `get_iv(sys)`: The independent variable of the implicit discrete system
-  - `discrete_events(sys)`: The set of discrete events in the implicit discrete system.
 
 ## Transformations
 

src/systems/callbacks.jl

@@ -69,7 +69,6 @@ discretes(a::AffectSystem) = a.discretes
 unknowns(a::AffectSystem) = a.unknowns
 parameters(a::AffectSystem) = a.parameters
 aff_to_sys(a::AffectSystem) = a.aff_to_sys
-previous_vals(a::AffectSystem) = parameters(system(a))
 all_equations(a::AffectSystem) = vcat(equations(system(a)), observed(system(a)))
 
 function Base.show(iio::IO, aff::AffectSystem)
@@ -149,7 +148,6 @@ function (p::Pre)(x)
     end
     return result
 end
-
 haspre(eq::Equation) = haspre(eq.lhs) || haspre(eq.rhs)
 haspre(O) = recursive_hasoperator(Pre, O)
 
@@ -247,11 +245,8 @@ end
 function SymbolicContinuousCallback(p::Pair, args...; kwargs...)
     SymbolicContinuousCallback(p[1], p[2], args...; kwargs...)
 end
-
-function SymbolicContinuousCallback(cb::SymbolicContinuousCallback, args...;
-        iv = nothing, alg_eqs = Equation[], kwargs...)
-    cb
-end
+SymbolicContinuousCallback(cb::SymbolicContinuousCallback, args...; kwargs...) = cb
+SymbolicContinuousCallback(cb::Nothing, args...; kwargs...) = nothing
 
 make_affect(affect::Nothing; kwargs...) = nothing
 make_affect(affect::Tuple; kwargs...) = FunctionalAffect(affect...)
@@ -310,7 +305,6 @@ function make_affect(affect::Vector{Equation}; discrete_parameters = Any[],
 
     # add scalarized unknowns to the map.
     _dvs = reduce(vcat, map(scalarize, _dvs), init = Any[])
-    @show _dvs
     for u in _dvs
         aff_map[u] = u
     end
@@ -323,25 +317,6 @@ function make_affect(affect; kwargs...)
     error("Malformed affect $(affect). This should be a vector of equations or a tuple specifying a functional affect.")
 end
 
-"""
-Generate continuous callbacks.
-"""
-function SymbolicContinuousCallbacks(events; discrete_parameters = Any[],
-        alg_eqs::Vector{Equation} = Equation[], iv = nothing)
-    callbacks = SymbolicContinuousCallback[]
-    isnothing(events) && return callbacks
-
-    events isa AbstractVector || (events = [events])
-    isempty(events) && return callbacks
-
-    for event in events
-        cond, affs = event isa Pair ? (event[1], event[2]) : (event, nothing)
-        push!(callbacks,
-            SymbolicContinuousCallback(cond, affs; iv, alg_eqs, discrete_parameters))
-    end
-    callbacks
-end
-
 function Base.show(io::IO, cb::AbstractCallback)
     indent = get(io, :indent, 0)
     iio = IOContext(io, :indent => indent + 1)
@@ -422,8 +397,6 @@ end
 ################################
 ######## Discrete events #######
 ################################
-
-# TODO: Iterative callbacks
 """
     SymbolicDiscreteCallback(conditions::Vector{Equation}, affect = nothing, iv = nothing;
                              initialize = nothing, finalize = nothing, alg_eqs = Equation[])
@@ -468,25 +441,7 @@ function SymbolicDiscreteCallback(p::Pair, args...; kwargs...)
     SymbolicDiscreteCallback(p[1], p[2], args...; kwargs...)
 end
 SymbolicDiscreteCallback(cb::SymbolicDiscreteCallback, args...; kwargs...) = cb
-
-"""
-Generate discrete callbacks.
-"""
-function SymbolicDiscreteCallbacks(events; discrete_parameters::Vector = Any[],
-        alg_eqs::Vector{Equation} = Equation[], iv = nothing)
-    callbacks = SymbolicDiscreteCallback[]
-
-    isnothing(events) && return callbacks
-    events isa AbstractVector || (events = [events])
-    isempty(events) && return callbacks
-
-    for event in events
-        cond, affs = event isa Pair ? (event[1], event[2]) : (event, nothing)
-        push!(callbacks,
-            SymbolicDiscreteCallback(cond, affs; iv, alg_eqs, discrete_parameters))
-    end
-    callbacks
-end
+SymbolicDiscreteCallback(cb::Nothing, args...; kwargs...) = nothing
 
 function is_timed_condition(condition::T) where {T}
     if T === Num
@@ -500,10 +455,14 @@ function is_timed_condition(condition::T) where {T}
     end
 end
 
+to_cb_vector(cbs::Vector{<:AbstractCallback}) = cbs
+to_cb_vector(cbs::Vector) = Vector{AbstractCallback}(cbs)
+to_cb_vector(cbs::Nothing) = AbstractCallback[]
+to_cb_vector(cb::AbstractCallback) = [cb]
+
 ############################################
 ########## Namespacing Utilities ###########
 ############################################
-
 function namespace_affects(affect::FunctionalAffect, s)
     FunctionalAffect(func(affect),
         renamespace.((s,), unknowns(affect)),
@@ -530,7 +489,7 @@ function namespace_callback(cb::SymbolicContinuousCallback, s)::SymbolicContinuo
         affect_neg = namespace_affects(affect_negs(cb), s),
         initialize = namespace_affects(initialize_affects(cb), s),
         finalize = namespace_affects(finalize_affects(cb), s),
-        rootfind = cb.rootfind)
+        rootfind = cb.rootfind, reinitializealg = cb.reinitializealg)
 end
 
 function namespace_conditions(condition, s)
@@ -542,7 +501,7 @@ function namespace_callback(cb::SymbolicDiscreteCallback, s)::SymbolicDiscreteCa
         namespace_conditions(conditions(cb), s),
         namespace_affects(affects(cb), s),
         initialize = namespace_affects(initialize_affects(cb), s),
-        finalize = namespace_affects(finalize_affects(cb), s))
+        finalize = namespace_affects(finalize_affects(cb), s), reinitializealg = cb.reinitializealg)
 end
 
 function Base.hash(cb::AbstractCallback, s::UInt)

src/systems/diffeqs/odesystem.jl

@@ -313,8 +313,11 @@ function ODESystem(deqs::AbstractVector{<:Equation}, iv, dvs, ps;
 
     alg_eqs = filter(eq -> eq.lhs isa Union{Symbolic, Number} && !is_diff_equation(eq),
         deqs)
-    cont_callbacks = SymbolicContinuousCallbacks(continuous_events; alg_eqs, iv)
-    disc_callbacks = SymbolicDiscreteCallbacks(discrete_events; alg_eqs, iv)
+    @show continuous_events
+    @show discrete_events
+    cont_callbacks = to_cb_vector(SymbolicContinuousCallback.(
+        continuous_events; alg_eqs, iv))
+    disc_callbacks = to_cb_vector(SymbolicDiscreteCallback.(discrete_events; alg_eqs, iv))
 
     if is_dde === nothing
         is_dde = _check_if_dde(deqs, iv′, systems)

src/systems/diffeqs/sdesystem.jl

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

src/systems/jumps/jumpsystem.jl

@@ -1,19 +1,5 @@
 const JumpType = Union{VariableRateJump, ConstantRateJump, MassActionJump}
 
-# modifies the expression representing an affect function to
-# call reset_aggregated_jumps!(integrator).
-# assumes iip
-function _reset_aggregator!(expr, integrator)
-    @assert Meta.isexpr(expr, :function)
-    body = expr.args[end]
-    body = quote
-        $body
-        $reset_aggregated_jumps!($integrator)
-    end
-    expr.args[end] = body
-    return nothing
-end
-
 """
 $(TYPEDEF)
 
@@ -90,11 +76,6 @@ struct JumpSystem{U <: ArrayPartition} <: AbstractTimeDependentSystem
     """
     connector_type::Any
     """
-    A `Vector{SymbolicContinuousCallback}` that model events.
-    The integrator will use root finding to guarantee that it steps at each zero crossing.
-    """
-    continuous_events::Vector{SymbolicContinuousCallback}
-    """
     A `Vector{SymbolicDiscreteCallback}` that models events. Symbolic
     analog to `SciMLBase.DiscreteCallback` that executes an affect when a given condition is
     true at the end of an integration step. Note, one must make sure to call
@@ -230,8 +211,7 @@ function JumpSystem(eqs, iv, unknowns, ps;
         end
     end
 
-    cont_callbacks = SymbolicContinuousCallbacks(continuous_events; iv)
-    disc_callbacks = SymbolicDiscreteCallbacks(discrete_events; iv)
+    disc_callbacks = to_cb_vector(SymbolicDiscreteCallback.(discrete_events; iv))
 
     JumpSystem{typeof(ap)}(Threads.atomic_add!(SYSTEM_COUNT, UInt(1)),
         ap, iv′, us′, ps′, var_to_name, observed, name, description, systems,

test/symbolic_events.jl

@@ -1,9 +1,7 @@
 using ModelingToolkit, OrdinaryDiffEq, StochasticDiffEq, JumpProcesses, Test
 using SciMLStructures: canonicalize, Discrete
 using ModelingToolkit: SymbolicContinuousCallback,
-                       SymbolicContinuousCallbacks,
                        SymbolicDiscreteCallback,
-                       SymbolicDiscreteCallbacks,
                        get_callback,
                        t_nounits as t,
                        D_nounits as D,
@@ -88,37 +86,6 @@ affect_neg = [x ~ 1]
     @test e isa SymbolicContinuousCallback
     @test isequal(equations(e), eqs)
     @test e.rootfind == SciMLBase.LeftRootFind
-
-    # test plural constructor
-    e = SymbolicContinuousCallbacks(eqs[])
-    @test e isa Vector{SymbolicContinuousCallback}
-    @test isequal(equations(e[]), eqs)
-    @test e[].affect == nothing
-
-    e = SymbolicContinuousCallbacks(eqs)
-    @test e isa Vector{SymbolicContinuousCallback}
-    @test isequal(equations(e[]), eqs)
-    @test e[].affect == nothing
-
-    e = SymbolicContinuousCallbacks(eqs[] => affect)
-    @test e isa Vector{SymbolicContinuousCallback}
-    @test isequal(equations(e[]), eqs)
-    @test e[].affect isa AffectSystem
-
-    e = SymbolicContinuousCallbacks(eqs => affect)
-    @test e isa Vector{SymbolicContinuousCallback}
-    @test isequal(equations(e[]), eqs)
-    @test e[].affect isa AffectSystem
-
-    e = SymbolicContinuousCallbacks([eqs[] => affect])
-    @test e isa Vector{SymbolicContinuousCallback}
-    @test isequal(equations(e[]), eqs)
-    @test e[].affect isa AffectSystem
-
-    e = SymbolicContinuousCallbacks([eqs => affect])
-    @test e isa Vector{SymbolicContinuousCallback}
-    @test isequal(equations(e[]), eqs)
-    @test e[].affect isa AffectSystem
 end
 
 @testset "ImperativeAffect constructors" begin

test/symbolic_indexing_interface.jl

@@ -1,5 +1,6 @@
 using ModelingToolkit, SymbolicIndexingInterface, SciMLBase
-using ModelingToolkit: t_nounits as t, D_nounits as D, ParameterIndex
+using ModelingToolkit: t_nounits as t, D_nounits as D, ParameterIndex,
+                       SymbolicContinuousCallback
 using SciMLStructures: Tunable
 
 @testset "ODESystem" begin