Run formatter

Author: BenChung

src/systems/callbacks.jl

@@ -118,12 +118,12 @@ struct SymbolicContinuousCallback
     affect_neg::Union{Vector{Equation}, FunctionalAffect, Nothing}
     rootfind::SciMLBase.RootfindOpt
     reinitializealg::SciMLBase.DAEInitializationAlgorithm
-    function SymbolicContinuousCallback(; 
-        eqs::Vector{Equation}, 
-        affect = NULL_AFFECT,
-        affect_neg = affect, 
-        rootfind = SciMLBase.LeftRootFind,
-        reinitializealg=SciMLBase.CheckInit())
+    function SymbolicContinuousCallback(;
+            eqs::Vector{Equation},
+            affect = NULL_AFFECT,
+            affect_neg = affect,
+            rootfind = SciMLBase.LeftRootFind,
+            reinitializealg = SciMLBase.CheckInit())
         new(eqs, make_affect(affect), make_affect(affect_neg), rootfind, reinitializealg)
     end # Default affect to nothing
 end
@@ -194,8 +194,10 @@ function affect_negs(cbs::Vector{SymbolicContinuousCallback})
 end
 
 reinitialization_alg(cb::SymbolicContinuousCallback) = cb.reinitializealg
-reinitialization_algs(cbs::Vector{SymbolicContinuousCallback}) = 
-    mapreduce(reinitialization_alg, vcat, cbs, init = SciMLBase.DAEInitializationAlgorithm[])
+function reinitialization_algs(cbs::Vector{SymbolicContinuousCallback})
+    mapreduce(
+        reinitialization_alg, vcat, cbs, init = SciMLBase.DAEInitializationAlgorithm[])
+end
 
 namespace_affects(af::Vector, s) = Equation[namespace_affect(a, s) for a in af]
 namespace_affects(af::FunctionalAffect, s) = namespace_affect(af, s)
@@ -241,7 +243,8 @@ struct SymbolicDiscreteCallback
     affects::Any
     reinitializealg::SciMLBase.DAEInitializationAlgorithm
 
-    function SymbolicDiscreteCallback(condition, affects = NULL_AFFECT, reinitializealg=SciMLBase.CheckInit())
+    function SymbolicDiscreteCallback(
+            condition, affects = NULL_AFFECT, reinitializealg = SciMLBase.CheckInit())
         c = scalarize_condition(condition)
         a = scalarize_affects(affects)
         new(c, a, reinitializealg)
@@ -302,8 +305,10 @@ function affects(cbs::Vector{SymbolicDiscreteCallback})
 end
 
 reinitialization_alg(cb::SymbolicDiscreteCallback) = cb.reinitializealg
-reinitialization_algs(cbs::Vector{SymbolicDiscreteCallback}) = 
-    mapreduce(reinitialization_alg, vcat, cbs, init = SciMLBase.DAEInitializationAlgorithm[])
+function reinitialization_algs(cbs::Vector{SymbolicDiscreteCallback})
+    mapreduce(
+        reinitialization_alg, vcat, cbs, init = SciMLBase.DAEInitializationAlgorithm[])
+end
 
 function namespace_callback(cb::SymbolicDiscreteCallback, s)::SymbolicDiscreteCallback
     af = affects(cb)
@@ -598,14 +603,15 @@ function generate_single_rootfinding_callback(
         initfn = SciMLBase.INITIALIZE_DEFAULT
     end
     return ContinuousCallback(
-        cond, affect_function.affect, affect_function.affect_neg, rootfind = cb.rootfind, 
+        cond, affect_function.affect, affect_function.affect_neg, rootfind = cb.rootfind,
         initialize = initfn,
         initializealg = reinitialization_alg(cb))
 end
 
 function generate_vector_rootfinding_callback(
         cbs, sys::AbstractODESystem, dvs = unknowns(sys),
-        ps = parameters(sys); rootfind = SciMLBase.RightRootFind, reinitialization = SciMLBase.CheckInit(), kwargs...)
+        ps = parameters(sys); rootfind = SciMLBase.RightRootFind,
+        reinitialization = SciMLBase.CheckInit(), kwargs...)
     eqs = map(cb -> flatten_equations(cb.eqs), cbs)
     num_eqs = length.(eqs)
     # fuse equations to create VectorContinuousCallback
@@ -670,7 +676,8 @@ function generate_vector_rootfinding_callback(
         initfn = SciMLBase.INITIALIZE_DEFAULT
     end
     return VectorContinuousCallback(
-        cond, affect, affect_neg, length(eqs), rootfind = rootfind, initialize = initfn, initializealg = reinitialization)
+        cond, affect, affect_neg, length(eqs), rootfind = rootfind,
+        initialize = initfn, initializealg = reinitialization)
 end
 
 """
@@ -711,21 +718,23 @@ function generate_rootfinding_callback(cbs, sys::AbstractODESystem, dvs = unknow
     # groupby would be very useful here, but alas
     cb_classes = Dict{
         @NamedTuple{
-            rootfind::SciMLBase.RootfindOpt, 
+            rootfind::SciMLBase.RootfindOpt,
             reinitialization::SciMLBase.DAEInitializationAlgorithm}, Vector{SymbolicContinuousCallback}}()
     for cb in cbs
         push!(
-            get!(() -> SymbolicContinuousCallback[], cb_classes, (
-                rootfind = cb.rootfind, 
-                reinitialization = reinitialization_alg(cb))),
+            get!(() -> SymbolicContinuousCallback[], cb_classes,
+                (
+                    rootfind = cb.rootfind,
+                    reinitialization = reinitialization_alg(cb))),
             cb)
     end
 
     # generate the callbacks out; we sort by the equivalence class to ensure a deterministic preference order
     compiled_callbacks = map(collect(pairs(sort!(
         OrderedDict(cb_classes); by = p -> p.rootfind)))) do (equiv_class, cbs_in_class)
         return generate_vector_rootfinding_callback(
-            cbs_in_class, sys, dvs, ps; rootfind = equiv_class.rootfind, reinitialization=equiv_class.reinitialization, kwargs...)
+            cbs_in_class, sys, dvs, ps; rootfind = equiv_class.rootfind,
+            reinitialization = equiv_class.reinitialization, kwargs...)
     end
     if length(compiled_callbacks) == 1
         return compiled_callbacks[]
@@ -796,10 +805,12 @@ function generate_timed_callback(cb, sys, dvs, ps; postprocess_affect_expr! = no
     end
     if cond isa AbstractVector
         # Preset Time
-        return PresetTimeCallback(cond, as; initialize = initfn, initializealg=reinitialization_alg(cb))
+        return PresetTimeCallback(
+            cond, as; initialize = initfn, initializealg = reinitialization_alg(cb))
     else
         # Periodic
-        return PeriodicCallback(as, cond; initialize = initfn, initializealg=reinitialization_alg(cb))
+        return PeriodicCallback(
+            as, cond; initialize = initfn, initializealg = reinitialization_alg(cb))
     end
 end
 
@@ -824,7 +835,8 @@ function generate_discrete_callback(cb, sys, dvs, ps; postprocess_affect_expr! =
         else
             initfn = SciMLBase.INITIALIZE_DEFAULT
         end
-        return DiscreteCallback(c, as; initialize = initfn, initializealg=reinitialization_alg(cb))
+        return DiscreteCallback(
+            c, as; initialize = initfn, initializealg = reinitialization_alg(cb))
     end
 end
 

test/symbolic_events.jl

@@ -890,13 +890,14 @@ end
 
 @testset "Discrete event reinitialization (#3142)" begin
     @connector LiquidPort begin
-        p(t)::Float64, [    description = "Set pressure in bar", 
-                            guess = 1.01325]
-        Vdot(t)::Float64, [ description = "Volume flow rate in L/min", 
-                            guess = 0.0, 
-                            connect = Flow]
+        p(t)::Float64, [description = "Set pressure in bar",
+            guess = 1.01325]
+        Vdot(t)::Float64,
+        [description = "Volume flow rate in L/min",
+            guess = 0.0,
+            connect = Flow]
     end
-    
+
     @mtkmodel PressureSource begin
         @components begin
             port = LiquidPort()
@@ -908,7 +909,7 @@ end
             port.p ~ p_set
         end
     end
-    
+
     @mtkmodel BinaryValve begin
         @constants begin
             p_ref::Float64 = 1.0, [description = "Reference pressure drop in bar"]
@@ -918,7 +919,7 @@ end
             port_in = LiquidPort()
             port_out = LiquidPort()
         end
-        @parameters begin 
+        @parameters begin
             k_V::Float64 = 1.0, [description = "Valve coefficient in L/min/bar"]
             k_leakage::Float64 = 1e-08, [description = "Leakage coefficient in L/min/bar"]
             ρ::Float64 = 1000.0, [description = "Density in kg/m^3"]
@@ -935,16 +936,16 @@ end
             Δp ~ port_in.p - port_out.p
             # System behavior
             D(S) ~ 0.0
-            Vdot ~ S*k_V*sign(Δp)*sqrt(abs(Δp)/p_ref * ρ_ref/ρ) + k_leakage*Δp # softplus alpha function to avoid negative values under the sqrt
+            Vdot ~ S * k_V * sign(Δp) * sqrt(abs(Δp) / p_ref * ρ_ref / ρ) + k_leakage * Δp # softplus alpha function to avoid negative values under the sqrt
         end
     end
-    
+
     # Test System
     @mtkmodel TestSystem begin
         @components begin
             pressure_source_1 = PressureSource(p_set = 2.0)
-            binary_valve_1 = BinaryValve(S = 1.0, k_leakage=0.0)
-            binary_valve_2 = BinaryValve(S = 1.0, k_leakage=0.0)
+            binary_valve_1 = BinaryValve(S = 1.0, k_leakage = 0.0)
+            binary_valve_2 = BinaryValve(S = 1.0, k_leakage = 0.0)
             pressure_source_2 = PressureSource(p_set = 1.0)
         end
         @equations begin
@@ -953,22 +954,22 @@ end
             connect(binary_valve_2.port_out, pressure_source_2.port)
         end
         @discrete_events begin
-            [30] => [binary_valve_1.S ~ 0.0, binary_valve_2.Δp ~ 0.0 ]
-            [60] => [binary_valve_1.S ~ 1.0, binary_valve_2.S ~ 0.0, binary_valve_2.Δp ~ 1.0 ]
-            [120] => [binary_valve_1.S ~ 0.0, binary_valve_2.Δp ~ 0.0 ]
+            [30] => [binary_valve_1.S ~ 0.0, binary_valve_2.Δp ~ 0.0]
+            [60] => [
+                binary_valve_1.S ~ 1.0, binary_valve_2.S ~ 0.0, binary_valve_2.Δp ~ 1.0]
+            [120] => [binary_valve_1.S ~ 0.0, binary_valve_2.Δp ~ 0.0]
         end
     end
-    
+
     # Test Simulation
     @mtkbuild sys = TestSystem()
-    
+
     # Test Simulation
     prob = ODEProblem(sys, [], (0.0, 150.0))
     sol = solve(prob)
     @test sol[end] == [0.0, 0.0, 0.0]
 end
 
-
 @testset "Discrete variable timeseries" begin
     @variables x(t)
     @parameters a(t) b(t) c(t)
@@ -991,20 +992,20 @@ end
 end
 
 @testset "Bump" begin
-    @variables x(t) [irreducible=true] y(t) [irreducible=true]
+    @variables x(t) [irreducible = true] y(t) [irreducible = true]
     eqs = [x ~ y, D(x) ~ -1]
     cb = [x ~ 0.0] => [x ~ 0, y ~ 1]
-    @mtkbuild pend = ODESystem(eqs, t;continuous_events = [cb])
+    @mtkbuild pend = ODESystem(eqs, t; continuous_events = [cb])
     prob = ODEProblem(pend, [x => 1], (0.0, 3.0), guesses = [y => x])
     @test_throws "initialization not satisifed" solve(prob, Rodas5())
-    
+
     cb = [x ~ 0.0] => [y ~ 1]
-    @mtkbuild pend = ODESystem(eqs, t;continuous_events = [cb])
+    @mtkbuild pend = ODESystem(eqs, t; continuous_events = [cb])
     prob = ODEProblem(pend, [x => 1], (0.0, 3.0), guesses = [y => x])
     @test_broken !SciMLBase.successful_retcode(solve(prob, Rodas5()))
 
     cb = [x ~ 0.0] => [x ~ 1, y ~ 1]
-    @mtkbuild pend = ODESystem(eqs, t;continuous_events = [cb])
+    @mtkbuild pend = ODESystem(eqs, t; continuous_events = [cb])
     prob = ODEProblem(pend, [x => 1], (0.0, 3.0), guesses = [y => x])
-    @test all(≈(0.0; atol=1e-9), solve(prob, Rodas5())[[x,y]][end])
-end
+    @test all(≈(0.0; atol = 1e-9), solve(prob, Rodas5())[[x, y]][end])
+end