fix: fix several tests

Author: vyudu

src/systems/callbacks.jl

@@ -217,14 +217,12 @@ struct SymbolicContinuousCallback <: AbstractCallback
     function SymbolicContinuousCallback(
             conditions::Union{Equation, Vector{Equation}},
             affect = nothing;
-            discrete_parameters = Any[],
             affect_neg = affect,
             initialize = nothing,
             finalize = nothing,
             rootfind = SciMLBase.LeftRootFind,
             reinitializealg = nothing,
-            iv = nothing,
-            alg_eqs = Equation[])
+            kwargs...)
         conditions = (conditions isa AbstractVector) ? conditions : [conditions]
 
         if isnothing(reinitializealg)
@@ -233,11 +231,12 @@ struct SymbolicContinuousCallback <: AbstractCallback
             reinitializealg = SciMLBase.CheckInit() :
             reinitializealg = SciMLBase.NoInit()
         end
+        @show kwargs
 
-        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),
+        new(conditions, make_affect(affect; kwargs...),
+            make_affect(affect_neg; kwargs...),
+            make_affect(initialize; kwargs...), make_affect(
+                finalize; kwargs...),
             rootfind, reinitializealg)
     end # Default affect to nothing
 end
@@ -247,16 +246,23 @@ function SymbolicContinuousCallback(p::Pair, args...; kwargs...)
 end
 SymbolicContinuousCallback(cb::SymbolicContinuousCallback, args...; kwargs...) = cb
 SymbolicContinuousCallback(cb::Nothing, args...; kwargs...) = nothing
+function SymbolicContinuousCallback(cb::Tuple, args...; kwargs...)
+    if length(cb) == 2
+        SymbolicContinuousCallback(cb[1]; kwargs..., cb[2]...)
+    else
+        error("Malformed tuple specifying callback. Should be a condition => affect pair, followed by a vector of kwargs.")
+    end
+end
 
 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 = Any[],
-        iv = nothing, alg_eqs::Vector{Equation} = Equation[])
+        iv = nothing, alg_eqs::Vector{Equation} = Equation[], warn_no_algebraic = true, kwargs...)
     isempty(affect) && return nothing
-    isempty(alg_eqs) &&
+    isempty(alg_eqs) && warn_no_algebraic &&
         @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
@@ -423,7 +429,7 @@ struct SymbolicDiscreteCallback <: AbstractCallback
     function SymbolicDiscreteCallback(
             condition, affect = nothing;
             initialize = nothing, finalize = nothing, iv = nothing,
-            alg_eqs = Equation[], discrete_parameters = Any[], reinitializealg = nothing)
+            reinitializealg = nothing, kwargs...)
         c = is_timed_condition(condition) ? condition : value(scalarize(condition))
 
         if isnothing(reinitializealg)
@@ -432,9 +438,9 @@ struct SymbolicDiscreteCallback <: AbstractCallback
             reinitializealg = SciMLBase.CheckInit() :
             reinitializealg = SciMLBase.NoInit()
         end
-        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)
+        new(c, make_affect(affect; kwargs...),
+            make_affect(initialize; kwargs...),
+            make_affect(finalize; kwargs...), reinitializealg)
     end # Default affect to nothing
 end
 
@@ -443,6 +449,13 @@ function SymbolicDiscreteCallback(p::Pair, args...; kwargs...)
 end
 SymbolicDiscreteCallback(cb::SymbolicDiscreteCallback, args...; kwargs...) = cb
 SymbolicDiscreteCallback(cb::Nothing, args...; kwargs...) = nothing
+function SymbolicDiscreteCallback(cb::Tuple, args...; kwargs...)
+    if length(cb) == 2
+        SymbolicDiscreteCallback(cb[1]; cb[2]...)
+    else
+        error("Malformed tuple specifying callback. Should be a condition => affect pair, followed by a vector of kwargs.")
+    end
+end
 
 function is_timed_condition(condition::T) where {T}
     if T === Num
@@ -861,7 +874,7 @@ Compile an affect defined by a set of equations. Systems with algebraic equation
 function compile_equational_affect(
         aff::Union{AffectSystem, Vector{Equation}}, sys; reset_jumps = false, kwargs...)
     if aff isa AbstractVector
-        aff = make_affect(aff; iv = get_iv(sys))
+        aff = make_affect(aff; iv = get_iv(sys), warn_no_algebraic = false)
     end
     affsys = system(aff)
     ps_to_update = discretes(aff)

src/systems/diffeqs/odesystem.jl

@@ -321,8 +321,9 @@ 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 = to_cb_vector(SymbolicContinuousCallback.(
-        continuous_events; alg_eqs, iv))
-    disc_callbacks = to_cb_vector(SymbolicDiscreteCallback.(discrete_events; alg_eqs, iv))
+        continuous_events; alg_eqs = alg_eqs, iv = iv, warn_no_algebraic = false))
+    disc_callbacks = to_cb_vector(SymbolicDiscreteCallback.(
+        discrete_events; alg_eqs = alg_eqs, iv = iv, warn_no_algebraic = false))
 
     if is_dde === nothing
         is_dde = _check_if_dde(deqs, iv′, systems)

src/systems/diffeqs/sdesystem.jl

@@ -273,8 +273,9 @@ 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 = to_cb_vector(SymbolicContinuousCallback.(
-        continuous_events; alg_eqs, iv))
-    disc_callbacks = to_cb_vector(SymbolicDiscreteCallback.(discrete_events; alg_eqs, iv))
+        continuous_events; alg_eqs = alg_eqs, iv = iv, warn_no_algebraic = false))
+    disc_callbacks = to_cb_vector(SymbolicDiscreteCallback.(
+        discrete_events; alg_eqs = alg_eqs, iv = iv, warn_no_algebraic = false))
 
     if is_dde === nothing
         is_dde = _check_if_dde(deqs, iv′, systems)

src/systems/jumps/jumpsystem.jl

@@ -212,8 +212,10 @@ function JumpSystem(eqs, iv, unknowns, ps;
         end
     end
 
-    disc_callbacks = to_cb_vector(SymbolicDiscreteCallback.(discrete_events; iv))
-    cont_callbacks = to_cb_vector(SymbolicContinuousCallback.(continuous_events; iv))
+    disc_callbacks = to_cb_vector(SymbolicDiscreteCallback.(
+        discrete_events; iv = iv, warn_no_algebraic = false))
+    cont_callbacks = to_cb_vector(SymbolicContinuousCallback.(
+        continuous_events; iv = iv, warn_no_algebraic = false))
 
     JumpSystem{typeof(ap)}(Threads.atomic_add!(SYSTEM_COUNT, UInt(1)),
         ap, iv′, us′, ps′, var_to_name, observed, name, description, systems,

src/systems/model_parsing.jl

@@ -127,6 +127,7 @@ function _model_macro(mod, fullname::Union{Expr, Symbol}, expr, isconnector)
 
     sys = :($ODESystem($(flatten_equations)(equations), $iv, variables, parameters;
         name, description = $description, systems, gui_metadata = $gui_metadata,
+        continuous_events = [$(c_evts...)], discrete_events = [$(d_evts...)],
         defaults))
 
     if length(ext) == 0
@@ -138,25 +139,6 @@ function _model_macro(mod, fullname::Union{Expr, Symbol}, expr, isconnector)
     isconnector && push!(exprs.args,
         :($Setfield.@set!(var"#___sys___".connector_type=$connector_type(var"#___sys___"))))
 
-    if !isempty(d_evts) || !isempty(c_evts)
-        push!(exprs.args, :(alg_eqs = $(alg_equations)(var"#___sys___")))
-        !isempty(d_evts) && begin
-            d_exprs = [:($(SymbolicDiscreteCallback)(
-                           $(evt.args[1]); iv = $iv, alg_eqs, $(evt.args[2])...))
-                       for evt in d_evts]
-            push!(exprs.args,
-                :($Setfield.@set!(var"#___sys___".discrete_events=[$(d_exprs...)])))
-        end
-
-        !isempty(c_evts) && begin
-            c_exprs = [:($(SymbolicContinuousCallback)(
-                           $(evt.args[1]); iv = $iv, alg_eqs, $(evt.args[2])...))
-                       for evt in c_evts]
-            push!(exprs.args,
-                :($Setfield.@set!(var"#___sys___".continuous_events=[$(c_exprs...)])))
-        end
-    end
-
     f = if length(where_types) == 0
         :($(Symbol(:__, name, :__))(; name, $(kwargs...)) = $exprs)
     else

test/extensions/ad.jl

@@ -59,7 +59,8 @@ end
 @parameters a b[1:3] c(t) d::Integer e[1:3] f[1:3, 1:3]::Int g::Vector{AbstractFloat} h::String
 @named sys = ODESystem(
     Equation[], t, [], [a, b, c, d, e, f, g, h],
-    continuous_events = [[a ~ 0] => [c ~ 0]])
+    continuous_events = [ModelingToolkit.SymbolicContinuousCallback(
+        [a ~ 0] => [c ~ 0], discrete_parameters = c)])
 sys = complete(sys)
 
 ivs = Dict(c => 3a, b => ones(3), a => 1.0, d => 4, e => [5.0, 6.0, 7.0],

test/jumpsystem.jl

@@ -80,7 +80,7 @@ function getmean(jprob, Nsims; use_stepper = true)
     end
     m / Nsims
 end
-@btime m = $getmean($jprob, $Nsims)
+m = getmean(jprob, Nsims)
 
 # test auto-alg selection works
 jprobb = JumpProblem(js2, dprob; save_positions = (false, false), rng)
@@ -248,7 +248,7 @@ end
 rate = k
 affect = [X ~ X - 1]
 
-crj = ConstantRateJump(1.0, [X ~ X - 1])
+crj = ConstantRateJump(1.0, [X ~ Pre(X) - 1])
 js1 = complete(JumpSystem([crj], t, [X], [k]; name = :js1))
 js2 = complete(JumpSystem([crj], t, [X], []; name = :js2))
 
@@ -275,18 +275,18 @@ dp4 = DiscreteProblem(js4, u0, tspan)
 @parameters k
 @variables X(t)
 rate = k
-affect = [X ~ X - 1]
+affect = [X ~ Pre(X) - 1]
 
-j1 = ConstantRateJump(k, [X ~ X - 1])
+j1 = ConstantRateJump(k, [X ~ Pre(X) - 1])
 @test_nowarn @mtkbuild js1 = JumpSystem([j1], t, [X], [k])
 
 # test correct autosolver is selected, which implies appropriate dep graphs are available
 let
     @parameters k
     @variables X(t)
     rate = k
-    affect = [X ~ X - 1]
-    j1 = ConstantRateJump(k, [X ~ X - 1])
+    affect = [X ~ Pre(X) - 1]
+    j1 = ConstantRateJump(k, [X ~ Pre(X) - 1])
 
     Nv = [1, JumpProcesses.USE_DIRECT_THRESHOLD + 1, JumpProcesses.USE_RSSA_THRESHOLD + 1]
     algtypes = [Direct, RSSA, RSSACR]
@@ -305,7 +305,7 @@ let
     Random.seed!(rng, 1111)
     @variables A(t) B(t) C(t)
     @parameters k
-    vrj = VariableRateJump(k * (sin(t) + 1), [A ~ A + 1, C ~ C + 2])
+    vrj = VariableRateJump(k * (sin(t) + 1), [A ~ Pre(A) + 1, C ~ Pre(C) + 2])
     js = complete(JumpSystem([vrj], t, [A, C], [k]; name = :js, observed = [B ~ C * A]))
     oprob = ODEProblem(js, [A => 0, C => 0], (0.0, 10.0), [k => 1.0])
     jprob = JumpProblem(js, oprob, Direct(); rng)
@@ -346,9 +346,9 @@ end
 let
     @variables x1(t) x2(t) x3(t) x4(t) x5(t)
     @parameters p1 p2 p3 p4 p5
-    j1 = ConstantRateJump(p1, [x1 ~ x1 + 1])
+    j1 = ConstantRateJump(p1, [x1 ~ Pre(x1) + 1])
     j2 = MassActionJump(p2, [x2 => 1], [x3 => -1])
-    j3 = VariableRateJump(p3, [x3 ~ x3 + 1, x4 ~ x4 + 1])
+    j3 = VariableRateJump(p3, [x3 ~ Pre(x3) + 1, x4 ~ Pre(x4) + 1])
     j4 = MassActionJump(p4 * p5, [x1 => 1, x5 => 1], [x1 => -1, x5 => -1, x2 => 1])
     us = Set()
     ps = Set()
@@ -390,9 +390,9 @@ let
     p4 = DelayParentScope(p4)
     p5 = GlobalScope(p5)
 
-    j1 = ConstantRateJump(p1, [x1 ~ x1 + 1])
+    j1 = ConstantRateJump(p1, [x1 ~ Pre(x1) + 1])
     j2 = MassActionJump(p2, [x2 => 1], [x3 => -1])
-    j3 = VariableRateJump(p3, [x3 ~ x3 + 1, x4 ~ x4 + 1])
+    j3 = VariableRateJump(p3, [x3 ~ Pre(x3) + 1, x4 ~ Pre(x4) + 1])
     j4 = MassActionJump(p4 * p5, [x1 => 1, x5 => 1], [x1 => -1, x5 => -1, x2 => 1])
     @named js = JumpSystem([j1, j2, j3, j4], t, [x1, x2, x3, x4, x5], [p1, p2, p3, p4, p5])
 
@@ -430,8 +430,8 @@ let
     Random.seed!(rng, seed)
     @variables X(t) Y(t)
     @parameters k1 k2
-    vrj1 = VariableRateJump(k1 * X, [X ~ X - 1]; save_positions = (false, false))
-    vrj2 = VariableRateJump(k1, [Y ~ Y + 1]; save_positions = (false, false))
+    vrj1 = VariableRateJump(k1 * X, [X ~ Pre(X) - 1]; save_positions = (false, false))
+    vrj2 = VariableRateJump(k1, [Y ~ Pre(Y) + 1]; save_positions = (false, false))
     eqs = [D(X) ~ k2, D(Y) ~ -k2 / 10 * Y]
     @named jsys = JumpSystem([vrj1, vrj2, eqs[1], eqs[2]], t, [X, Y], [k1, k2])
     jsys = complete(jsys)
@@ -472,8 +472,8 @@ let
     Random.seed!(rng, seed)
     @variables X(t) Y(t)
     @parameters α β
-    vrj = VariableRateJump(β * X, [X ~ X - 1]; save_positions = (false, false))
-    crj = ConstantRateJump(β * Y, [Y ~ Y - 1])
+    vrj = VariableRateJump(β * X, [X ~ Pre(X) - 1]; save_positions = (false, false))
+    crj = ConstantRateJump(β * Y, [Y ~ Pre(Y) - 1])
     maj = MassActionJump(α, [0 => 1], [Y => 1])
     eqs = [D(X) ~ α * (1 + Y)]
     @named jsys = JumpSystem([maj, crj, vrj, eqs[1]], t, [X, Y], [α, β])
@@ -540,8 +540,8 @@ end
     @variables X(t)
     rate1 = p
     rate2 = X * d
-    affect1 = [X ~ X + 1]
-    affect2 = [X ~ X - 1]
+    affect1 = [X ~ Pre(X) + 1]
+    affect2 = [X ~ Pre(X) - 1]
     j1 = ConstantRateJump(rate1, affect1)
     j2 = ConstantRateJump(rate2, affect2)
 

test/mtkparameters.jl

@@ -10,7 +10,8 @@ using JET
 @parameters a b c(t) d::Integer e[1:3] f[1:3, 1:3]::Int g::Vector{AbstractFloat} h::String
 @named sys = ODESystem(
     Equation[], t, [], [a, c, d, e, f, g, h], parameter_dependencies = [b ~ 2a],
-    continuous_events = [[a ~ 0] => [c ~ 0]], defaults = Dict(a => 0.0))
+    continuous_events = [ModelingToolkit.SymbolicContinuousCallback(
+        [a ~ 0] => [c ~ 0], discrete_parameters = c)], defaults = Dict(a => 0.0))
 sys = complete(sys)
 
 ivs = Dict(c => 3a, d => 4, e => [5.0, 6.0, 7.0],