format

Author: isaacsas

src/systems/callbacks.jl

@@ -678,8 +678,8 @@ function compile_affect(eqs::Vector{Equation}, cb, sys, dvs, ps; outputidxs = no
     end
 end
 
-function generate_rootfinding_callback(sys::AbstractTimeDependentSystem, dvs = unknowns(sys),
-        ps = parameters(sys); kwargs...)
+function generate_rootfinding_callback(sys::AbstractTimeDependentSystem,
+        dvs = unknowns(sys), ps = parameters(sys); kwargs...)
     cbs = continuous_events(sys)
     isempty(cbs) && return nothing
     generate_rootfinding_callback(cbs, sys, dvs, ps; kwargs...)
@@ -860,8 +860,8 @@ function compile_affect_fn(cb, sys::AbstractTimeDependentSystem, dvs, ps, kwargs
     (affect = affect, affect_neg = affect_neg, initialize = initialize, finalize = finalize)
 end
 
-function generate_rootfinding_callback(cbs, sys::AbstractTimeDependentSystem, dvs = unknowns(sys),
-        ps = parameters(sys); kwargs...)
+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)
     total_eqs = sum(num_eqs)

src/systems/jumps/jumpsystem.jl

@@ -140,7 +140,7 @@ struct JumpSystem{U <: ArrayPartition} <: AbstractTimeDependentSystem
         end
         new{U}(tag, ap, iv, unknowns, ps, var_to_name,
             observed, name, description, systems, defaults,
-            connector_type, cevents, devents, parameter_dependencies, metadata, 
+            connector_type, cevents, devents, parameter_dependencies, metadata,
             gui_metadata, complete, index_cache, isscheduled)
     end
 end
@@ -494,17 +494,17 @@ function DiffEqBase.ODEProblem(sys::JumpSystem, u0map, tspan::Union{Tuple, Nothi
     if has_equations(sys)
         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), 
+            systems = get_systems(sys), defaults = defaults(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 = false, kwargs...)
     else
         _, u0, p = process_SciMLProblem(EmptySciMLFunction, sys, u0map, parammap;
-            t = tspan === nothing ? nothing : tspan[1], use_union, tofloat = false, 
+            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)    
+        observedfun = ObservedFunctionCache(sys; eval_expression, eval_module)
         df = ODEFunction(f; sys, observed = observedfun)
         return ODEProblem(df, u0, tspan, p; kwargs...)
     end

test/jumpsystem.jl

@@ -301,7 +301,7 @@ end
 # basic VariableRateJump test
 let
     N = 1000  # number of simulations for testing solve accuracy
-    Random.seed!(rng, 1111) 
+    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])
@@ -425,17 +425,19 @@ end
 
 # PDMP test
 let
-    Random.seed!(rng, 1111)  
+    Random.seed!(rng, 1111)
     @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))
-    eqs = [D(X) ~ k2, D(Y) ~ -k2/10*Y]
+    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)
-    X0 = 0.0; Y0 = 0.0
+    X0 = 0.0
+    Y0 = 0.0
     u0 = [X => X0, Y => Y0]
-    k1val = 1.0; k2val = 20.0
+    k1val = 1.0
+    k2val = 20.0
     p = [k1 => k1val, k2 => k2val]
     tspan = (0.0, 10.0)
     oprob = ODEProblem(jsys, u0, tspan, p)
@@ -447,27 +449,30 @@ let
     Yv = zeros(length(times))
     for n in 1:Nsims
         sol = solve(jprob, Tsit5(); saveat = times)
-        Xv .+= sol[1,:] 
-        Yv .+= sol[2,:]
+        Xv .+= sol[1, :]
+        Yv .+= sol[2, :]
     end
-    Xv ./= Nsims; Yv ./= Nsims;
+    Xv ./= Nsims
+    Yv ./= Nsims
 
     Xact(t) = X0 * exp(-k1val * t) + (k2val / k1val) * (1 - exp(-k1val * t))
-    Yact(t) = Y0 * exp(-k2val/10 * t) + (k1val / (k2val/10)) * (1 - exp(-k2val/10 * t))
+    function Yact(t)
+        Y0 * exp(-k2val / 10 * t) + (k1val / (k2val / 10)) * (1 - exp(-k2val / 10 * t))
+    end
     @test all(abs.(Xv .- Xact.(times)) .<= 0.05 .* Xv)
-    @test all(abs.(Yv .- Yact.(times)) .<= 0.1 .* Yv)    
+    @test all(abs.(Yv .- Yact.(times)) .<= 0.1 .* Yv)
 end
 
 # that mixes ODEs and jump types, and then contin events
 let
-    Random.seed!(rng, 1111)  
+    Random.seed!(rng, 1111)
     @variables X(t) Y(t)
     @parameters α β
     vrj = VariableRateJump(β * X, [X ~ X - 1]; save_positions = (false, false))
-    crj = ConstantRateJump(β*Y, [Y ~ Y - 1])
+    crj = ConstantRateJump(β * Y, [Y ~ Y - 1])
     maj = MassActionJump(α, [0 => 1], [Y => 1])
-    eqs = [D(X) ~ α*(1 + Y)]
-    @named jsys = JumpSystem([maj, crj, vrj, eqs[1]], t, [X, Y], [α, β])    
+    eqs = [D(X) ~ α * (1 + Y)]
+    @named jsys = JumpSystem([maj, crj, vrj, eqs[1]], t, [X, Y], [α, β])
     jsys = complete(jsys)
     p = (α = 6.0, β = 2.0, X₀ = 2.0, Y₀ = 1.0)
     u0map = [X => p.X₀, Y => p.Y₀]
@@ -481,32 +486,34 @@ let
     Yv = zeros(length(times))
     for n in 1:Nsims
         sol = solve(jprob, Tsit5(); saveat = times)
-        Xv .+= sol[1,:] 
-        Yv .+= sol[2,:]
+        Xv .+= sol[1, :]
+        Yv .+= sol[2, :]
     end
-    Xv ./= Nsims; Yv ./= Nsims;
+    Xv ./= Nsims
+    Yv ./= Nsims
 
     function Yf(t, p)
         local α, β, X₀, Y₀ = p
         return (α / β) + (Y₀ - α / β) * exp(-β * t)
     end
     function Xf(t, p)
         local α, β, X₀, Y₀ = p
-        return (α / β) + (α^2 / β^2) + α * (Y₀ - α / β) * t * exp(-β * t) + (X₀ - α / β - α^2 / β^2) * exp(-β * t)
+        return (α / β) + (α^2 / β^2) + α * (Y₀ - α / β) * t * exp(-β * t) +
+               (X₀ - α / β - α^2 / β^2) * exp(-β * t)
     end
-    Xact = [Xf(t,p) for t in times]
-    Yact = [Yf(t,p) for t in times]
+    Xact = [Xf(t, p) for t in times]
+    Yact = [Yf(t, p) for t in times]
     @test all(abs.(Xv .- Xact) .<= 0.05 .* Xv)
-    @test all(abs.(Yv .- Yact) .<= 0.05 .* Yv)    
-   
+    @test all(abs.(Yv .- Yact) .<= 0.05 .* Yv)
+
     function affect!(integ, u, p, ctx)
         savevalues!(integ, true)
         terminate!(integ)
         nothing
     end
-    cevents = [t ~ .2] => (affect!, [], [], [], nothing)
-    @named jsys = JumpSystem([maj, crj, vrj, eqs[1]], t, [X, Y], [α, β]; 
-        continuous_events = cevents)    
+    cevents = [t ~ 0.2] => (affect!, [], [], [], nothing)
+    @named jsys = JumpSystem([maj, crj, vrj, eqs[1]], t, [X, Y], [α, β];
+        continuous_events = cevents)
     jsys = complete(jsys)
     tspan = (0.0, 200.0)
     oprob = ODEProblem(jsys, u0map, tspan, pmap)
@@ -516,8 +523,8 @@ let
     for n in 1:Nsims
         sol = solve(jprob, Tsit5(), saveat = tspan[2])
         @test sol.retcode == ReturnCode.Terminated
-        Xsamp += sol[1,end]
+        Xsamp += sol[1, end]
     end
     Xsamp /= Nsims
-    @test abs(Xsamp - Xf(.2,p) < .05 * Xf(.2,p))
-end
+    @test abs(Xsamp - Xf(0.2, p) < 0.05 * Xf(0.2, p))
+end