Add continuous event support

Author: isaacsas

src/systems/callbacks.jl

@@ -1,6 +1,6 @@
 #################################### system operations #####################################
 get_continuous_events(sys::AbstractSystem) = SymbolicContinuousCallback[]
-get_continuous_events(sys::AbstractODESystem) = getfield(sys, :continuous_events)
+get_continuous_events(sys::AbstractTimeDependentSystem) = getfield(sys, :continuous_events)
 has_continuous_events(sys::AbstractSystem) = isdefined(sys, :continuous_events)
 
 has_discrete_events(sys::AbstractSystem) = isdefined(sys, :discrete_events)
@@ -560,7 +560,7 @@ function compile_affect(eqs::Vector{Equation}, cb, sys, dvs, ps; outputidxs = no
     end
 end
 
-function generate_rootfinding_callback(sys::AbstractODESystem, dvs = unknowns(sys),
+function generate_rootfinding_callback(sys::AbstractTimeDependentSystem, dvs = unknowns(sys),
         ps = parameters(sys); kwargs...)
     cbs = continuous_events(sys)
     isempty(cbs) && return nothing
@@ -571,7 +571,7 @@ Generate a single rootfinding callback; this happens if there is only one equati
 generate_rootfinding_callback and thus we can produce a ContinuousCallback instead of a VectorContinuousCallback.
 """
 function generate_single_rootfinding_callback(
-        eq, cb, sys::AbstractODESystem, dvs = unknowns(sys),
+        eq, cb, sys::AbstractTimeDependentSystem, dvs = unknowns(sys),
         ps = parameters(sys); kwargs...)
     if !isequal(eq.lhs, 0)
         eq = 0 ~ eq.lhs - eq.rhs
@@ -609,7 +609,7 @@ function generate_single_rootfinding_callback(
 end
 
 function generate_vector_rootfinding_callback(
-        cbs, sys::AbstractODESystem, dvs = unknowns(sys),
+        cbs, sys::AbstractTimeDependentSystem, dvs = unknowns(sys),
         ps = parameters(sys); rootfind = SciMLBase.RightRootFind,
         reinitialization = SciMLBase.CheckInit(), kwargs...)
     eqs = map(cb -> flatten_equations(cb.eqs), cbs)
@@ -683,7 +683,7 @@ end
 """
 Compile a single continuous callback affect function(s).
 """
-function compile_affect_fn(cb, sys::AbstractODESystem, dvs, ps, kwargs)
+function compile_affect_fn(cb, sys::AbstractTimeDependentSystem, dvs, ps, kwargs)
     eq_aff = affects(cb)
     eq_neg_aff = affect_negs(cb)
     affect = compile_affect(eq_aff, cb, sys, dvs, ps; expression = Val{false}, kwargs...)
@@ -698,7 +698,7 @@ function compile_affect_fn(cb, sys::AbstractODESystem, dvs, ps, kwargs)
     (affect = affect, affect_neg = affect_neg)
 end
 
-function generate_rootfinding_callback(cbs, sys::AbstractODESystem, dvs = unknowns(sys),
+function generate_rootfinding_callback(cbs, sys::AbstractTimeDependentSystem, dvs = unknowns(sys),
         ps = parameters(sys); kwargs...)
     eqs = map(cb -> flatten_equations(cb.eqs), cbs)
     num_eqs = length.(eqs)
@@ -859,12 +859,12 @@ merge_cb(x, ::Nothing) = x
 merge_cb(x, y) = CallbackSet(x, y)
 
 function process_events(sys; callback = nothing, kwargs...)
-    if has_continuous_events(sys)
+    if has_continuous_events(sys) && !isempty(continuous_events(sys))
         contin_cb = generate_rootfinding_callback(sys; kwargs...)
     else
         contin_cb = nothing
     end
-    if has_discrete_events(sys)
+    if has_discrete_events(sys) && !isempty(discrete_events(sys))
         discrete_cb = generate_discrete_callbacks(sys; kwargs...)
     else
         discrete_cb = nothing

src/systems/jumps/jumpsystem.jl

@@ -485,7 +485,6 @@ function DiffEqBase.ODEProblem(sys::JumpSystem, u0map, tspan::Union{Tuple, Nothi
         use_union = false,
         eval_expression = false,
         eval_module = @__MODULE__,
-        check_length = false,
         kwargs...)
     if !iscomplete(sys)
         error("A completed `JumpSystem` is required. Call `complete` or `structural_simplify` on the system before creating a `DiscreteProblem`")
@@ -496,19 +495,18 @@ function DiffEqBase.ODEProblem(sys::JumpSystem, u0map, tspan::Union{Tuple, Nothi
         osys = ODESystem(equations(sys).x[4], get_iv(sys), unknowns(sys), parameters(sys);
             observed = observed(sys), name = nameof(sys), description = description(sys),
             systems = get_systems(sys), defaults = defaults(sys), 
-            continuous_events = continuous_events(sys),
             parameter_dependencies = parameter_dependencies(sys),
             metadata = get_metadata(sys), gui_metadata = get_gui_metadata(sys))
         osys = complete(osys)
-        return ODEProblem(osys, u0map, tspan, parammap; check_length, kwargs...)
+        return ODEProblem(osys, u0map, tspan, parammap; check_length = false, kwargs...)
     else
         _, u0, p = process_SciMLProblem(EmptySciMLFunction, sys, u0map, parammap;
             t = tspan === nothing ? nothing : tspan[1], use_union, tofloat = false, 
             check_length = false)
         f = (du, u, p, t) -> (du .= 0; nothing)
         observedfun = ObservedFunctionCache(sys; eval_expression, eval_module)    
         df = ODEFunction(f; sys, observed = observedfun)
-        return ODEProblem(df, u0, tspan, p; check_length, kwargs...)
+        return ODEProblem(df, u0, tspan, p; kwargs...)
     end
 end