Persistent callbacks

Author: BenLauwens

src/base.jl

@@ -14,12 +14,11 @@ end
 mutable struct BaseEvent
   env :: Environment
   id :: UInt
-  cid :: UInt
-  callbacks :: DataStructures.PriorityQueue{Function, UInt}
+  callbacks :: Vector{Function}
   state :: EVENT_STATE
   value :: Any
   function BaseEvent(env::Environment)
-    new(env, env.eid+=one(UInt), zero(UInt), DataStructures.PriorityQueue(Function, UInt), idle, nothing)
+    new(env, env.eid+=one(UInt), Vector{Function}(), idle, nothing)
   end
 end
 
@@ -42,7 +41,7 @@ end
 function append_callback(func::Function, ev::AbstractEvent, args::Any...) :: Function
   ev.bev.state == triggered && throw(EventTriggered(ev))
   cb = ()->func(ev, args...)
-  ev.bev.callbacks[cb] = ev.bev.cid+=one(UInt)
+  push!(ev.bev.callbacks, cb)
   cb
 end
 
@@ -54,7 +53,8 @@ macro callback(expr::Expr)
 end
 
 function remove_callback(cb::Function, ev::AbstractEvent)
-  DataStructures.dequeue!(ev.bev.callbacks, cb)
+  i = indexin(ev.bev.callbacks, [cb])[1]
+  deleteat!(ev.bev.callbacks, i)
 end
 
 function schedule(ev::AbstractEvent, delay::Number=zero(Float64); priority::Int8=zero(Int8), value::Any=nothing)

src/continuous.jl

@@ -41,11 +41,9 @@ struct Continuous <: AbstractProcess
   end
 end
 
-function Continuous{I<:Integrator}(model::Model, env::Environment, ::Type{I}, x₀::Vector{Float64}, p::Vector{Float64}=Float64[]; args...)
-  for p₀ in p
-    push!(model.p, p₀)
-  end
-  integrator = I(model, now(env), x₀; args...)
+function Continuous{I<:Integrator}(model::Model, env::Environment, ::Type{I},
+    x₀::Vector{Float64}, p::Vector{Float64}=Float64[]; args...)
+  integrator = I(model, now(env), x₀, p; args...)
   Continuous(env, integrator)
 end
 

src/odes/QSS.jl

@@ -3,21 +3,22 @@
 struct QSS{T} <: Integrator
   order :: UInt8
   model :: Model
+  p :: Vector{Float64}
   q :: Vector{Taylor1}
   t :: Vector{Float64}
   Δrel :: Float64
   Δabs :: Float64
-  function QSS{T}(model::Model, t::Float64, x₀::Vector{Float64};
+  function QSS{T}(model::Model, t::Float64, x₀::Vector{Float64}, p::Vector{Float64};
                   order::Number=4, Δrel::Float64=1e-6, Δabs::Float64=1e-6) where T
-    qss = new(UInt8(order), model, Vector{Taylor1}(), Vector{Float64}(), Δrel, Δabs)
+    qss = new(UInt8(order), model, p, Vector{Taylor1}(), Vector{Float64}(), Δrel, Δabs)
     t₀ = t + Taylor1(Float64, qss.order+1)
     for q₀ in x₀
       push!(qss.t, t)
       push!(qss.q, q₀ + Taylor1(zeros(Float64, qss.order+1)))
     end
     for i in 1:qss.order-1
       for (j, q₀) in enumerate(x₀)
-        qss.q[j] = integrate(model.f[j](t₀, qss.q, model.p), q₀)
+        qss.q[j] = integrate(model.f[j](t₀, qss.q, p), q₀)
       end
     end
     qss
@@ -34,7 +35,7 @@ function initial_values(qss::QSS, t::Float64)
   t₀ = t + Taylor1(Float64, qss.order+1)
   x₀ = Vector{Taylor1}()
   for (i, f) in enumerate(qss.model.f)
-    push!(x₀, integrate(f(t₀, qss.q, qss.model.p), qss.q[i].coeffs[1]))
+    push!(x₀, integrate(f(t₀, qss.q, qss.p), qss.q[i].coeffs[1]))
   end
   x₀
 end
@@ -56,7 +57,7 @@ function step(var::Variable, cont::Continuous, qss::QSS)
     for k in filter(k->qss.model.deps[j,k], 1:n)
       advance_time(qss, k, t)
     end
-    dep.x = integrate(qss.model.f[j](t₀, qss.q, qss.model.p), x₀)
+    dep.x = integrate(qss.model.f[j](t₀, qss.q, qss.p), x₀)
     Δt = recompute_next_time(qss, var.x, qss.q[j], max(qss.Δrel*x₀, qss.Δabs))
     schedule(dep, cont, qss, Δt)
   end

src/odes/base.jl

@@ -2,9 +2,8 @@ abstract type Integrator end
 
 struct Model
   f :: Vector{Function}
-  p :: Vector{Float64}
   deps :: Matrix{Bool}
   function Model(f::Vector{Function}, deps::Matrix{Bool})
-    new(f, Vector{Float64}(), deps)
+    new(f, deps)
   end
 end

src/simulations.jl

@@ -34,8 +34,8 @@ function step(sim::Simulation)
   DataStructures.dequeue!(sim.heap)
   sim.time = key.time
   bev.state = triggered
-  while !isempty(bev.callbacks)
-    DataStructures.dequeue!(bev.callbacks)()
+  for callback in bev.callbacks
+    callback()
   end
 end
 

test/continuous.jl

@@ -15,7 +15,7 @@ end
 sim = Simulation()
 cont = @continuous diffeq(sim, [0.0, 20.0], [2020.0]; stiff=false, order=4)
 zc = @zerocrossing less_prey(cont)
-run(sim, 500.0)
+run(sim, 10.0)
 for var in cont.vars
   println(var.x)
 end