format

Author: vyudu

src/systems/callbacks.jl

@@ -230,15 +230,17 @@ struct SymbolicContinuousCallback <: AbstractCallback
         conditions = (conditions isa AbstractVector) ? conditions : [conditions]
 
         if isnothing(reinitializealg)
-            any(a -> (a isa FunctionalAffect || a isa ImperativeAffect), [affect, affect_neg, initialize, finalize]) ? 
-                reinitializealg = SciMLBase.CheckInit() : 
-                reinitializealg = SciMLBase.NoInit()
+            any(a -> (a isa FunctionalAffect || a isa ImperativeAffect),
+                [affect, affect_neg, initialize, finalize]) ?
+            reinitializealg = SciMLBase.CheckInit() :
+            reinitializealg = SciMLBase.NoInit()
         end
 
         new(conditions, make_affect(affect; iv, algeeqs, discrete_parameters),
             make_affect(affect_neg; iv, algeeqs, discrete_parameters),
             make_affect(initialize; iv, algeeqs, discrete_parameters), make_affect(
-                finalize; iv, algeeqs, discrete_parameters), rootfind, reinitializealg)
+                finalize; iv, algeeqs, discrete_parameters),
+            rootfind, reinitializealg)
     end # Default affect to nothing
 end
 
@@ -286,7 +288,7 @@ function make_affect(affect::Vector{Equation}; discrete_parameters::AbstractVect
     sys_params = collect(setdiff(params, union(discrete_parameters, pre_params)))
     discretes = map(tovar, discrete_parameters)
     dvs = collect(dvs)
-    _dvs = map(default_toterm, dvs) 
+    _dvs = map(default_toterm, dvs)
 
     aff_map = Dict(zip(discretes, discrete_parameters))
     rev_map = Dict(zip(discrete_parameters, discretes))
@@ -446,9 +448,10 @@ struct SymbolicDiscreteCallback <: AbstractCallback
         c = is_timed_condition(condition) ? condition : value(scalarize(condition))
 
         if isnothing(reinitializealg)
-            any(a -> (a isa FunctionalAffect || a isa ImperativeAffect), [affect, initialize, finalize]) ? 
-                reinitializealg = SciMLBase.CheckInit() : 
-                reinitializealg = SciMLBase.NoInit()
+            any(a -> (a isa FunctionalAffect || a isa ImperativeAffect),
+                [affect, initialize, finalize]) ?
+            reinitializealg = SciMLBase.CheckInit() :
+            reinitializealg = SciMLBase.NoInit()
         end
         new(c, make_affect(affect; iv, algeeqs, discrete_parameters),
             make_affect(initialize; iv, algeeqs, discrete_parameters),
@@ -582,7 +585,8 @@ end
 function Base.:(==)(e1::AbstractCallback, e2::AbstractCallback)
     (is_discrete(e1) === is_discrete(e2)) || return false
     (isequal(e1.conditions, e2.conditions) && isequal(e1.affect, e2.affect) &&
-     isequal(e1.initialize, e2.initialize) && isequal(e1.finalize, e2.finalize)) && isequal(e1.reinitializealg, e2.reinitializealg) ||
+     isequal(e1.initialize, e2.initialize) && isequal(e1.finalize, e2.finalize)) &&
+        isequal(e1.reinitializealg, e2.reinitializealg) ||
         return false
     is_discrete(e1) ||
         (isequal(e1.affect_neg, e2.affect_neg) && isequal(e1.rootfind, e2.rootfind))
@@ -619,7 +623,8 @@ function compile_condition(
 
     if !is_discrete(cbs)
         condit = reduce(vcat, flatten_equations(condit))
-        condit = condit isa AbstractVector ? [c.lhs - c.rhs for c in condit] : [condit.lhs - condit.rhs]
+        condit = condit isa AbstractVector ? [c.lhs - c.rhs for c in condit] :
+                 [condit.lhs - condit.rhs]
     end
 
     fs = build_function_wrapper(sys,
@@ -685,15 +690,18 @@ function generate_continuous_callbacks(sys::AbstractSystem, dvs = unknowns(sys),
         ps = parameters(sys; initial_parameters = true); kwargs...)
     cbs = continuous_events(sys)
     isempty(cbs) && return nothing
-    cb_classes = Dict{Tuple{SciMLBase.RootfindOpt, SciMLBase.DAEInitializationAlgorithm}, Vector{SymbolicContinuousCallback}}()
+    cb_classes = Dict{Tuple{SciMLBase.RootfindOpt, SciMLBase.DAEInitializationAlgorithm},
+        Vector{SymbolicContinuousCallback}}()
 
     # Sort the callbacks by their rootfinding method
     for cb in cbs
-        _cbs = get!(() -> SymbolicContinuousCallback[], cb_classes, (cb.rootfind, cb.reinitializealg))
+        _cbs = get!(() -> SymbolicContinuousCallback[],
+            cb_classes, (cb.rootfind, cb.reinitializealg))
         push!(_cbs, cb)
     end
     sort!(OrderedDict(cb_classes), by = cb -> cb[1])
-    compiled_callbacks = [generate_callback(cb, sys; kwargs...) for ((rf, reinit), cb) in cb_classes]
+    compiled_callbacks = [generate_callback(cb, sys; kwargs...)
+                          for ((rf, reinit), cb) in cb_classes]
     if length(compiled_callbacks) == 1
         return only(compiled_callbacks)
     else
@@ -791,7 +799,8 @@ function generate_callback(cb, sys; kwargs...)
             return PresetTimeCallback(trigger, affect; initialize,
                 finalize, initializealg = cb.reinitializealg)
         elseif is_timed
-            return PeriodicCallback(affect, trigger; initialize, finalize, initializealg = cb.reinitializealg)
+            return PeriodicCallback(
+                affect, trigger; initialize, finalize, initializealg = cb.reinitializealg)
         else
             return DiscreteCallback(trigger, affect; initialize,
                 finalize, initializealg = cb.reinitializealg)

src/systems/model_parsing.jl

@@ -137,7 +137,6 @@ function _model_macro(mod, name, expr, isconnector)
             $(d_evts...)
         ]))))
 
-
     f = if length(where_types) == 0
         :($(Symbol(:__, name, :__))(; name, $(kwargs...)) = $exprs)
     else

src/systems/systems.jl

@@ -155,7 +155,9 @@ function __structural_simplify(sys::AbstractSystem, io = nothing; simplify = fal
             get_iv(ode_sys), unknowns(ode_sys), parameters(ode_sys);
             name = nameof(ode_sys), is_scalar_noise, observed = observed(ode_sys), defaults = defaults(sys),
             parameter_dependencies = parameter_dependencies(sys), assertions = assertions(sys),
-            guesses = guesses(sys), initialization_eqs = initialization_equations(sys), continuous_events = continuous_events(sys), discrete_events = discrete_events(sys))
+            guesses = guesses(sys), initialization_eqs = initialization_equations(sys),
+            continuous_events = continuous_events(sys),
+            discrete_events = discrete_events(sys))
     end
 end
 

test/fmi/fmi.jl

@@ -157,7 +157,8 @@ end
     @testset "v2, CS" begin
         fmu = loadFMU(joinpath(FMU_DIR, "SimpleAdder.fmu"); type = :CS)
         @named adder = MTK.FMIComponent(
-                                        Val(2); fmu, type = :CS, communication_step_size = 1e-6, reinitializealg = BrownFullBasicInit())
+            Val(2); fmu, type = :CS, communication_step_size = 1e-6,
+            reinitializealg = BrownFullBasicInit())
         @test MTK.isinput(adder.a)
         @test MTK.isinput(adder.b)
         @test MTK.isoutput(adder.out)
@@ -209,7 +210,8 @@ end
     @testset "v3, CS" begin
         fmu = loadFMU(joinpath(FMU_DIR, "StateSpace.fmu"); type = :CS)
         @named sspace = MTK.FMIComponent(
-                                         Val(3); fmu, communication_step_size = 1e-6, type = :CS, reinitializealg = BrownFullBasicInit())
+            Val(3); fmu, communication_step_size = 1e-6, type = :CS,
+            reinitializealg = BrownFullBasicInit())
         @test MTK.isinput(sspace.u)
         @test MTK.isoutput(sspace.y)
         @test !MTK.isinput(sspace.x) && !MTK.isoutput(sspace.x)

test/odesystem.jl

@@ -1038,18 +1038,19 @@ prob = ODEProblem(sys, [x => 1.0], (0.0, 10.0))
     eqs = [
         D(x) ~ p * x
     ]
-    @mtkbuild sys = ODESystem(eqs, t; continuous_events = [[norm(x) ~ 3.0] => [x ~ ones(3)]])
+    @mtkbuild sys = ODESystem(
+        eqs, t; continuous_events = [[norm(x) ~ 3.0] => [x ~ ones(3)]])
     # array affect equations used to not work
     prob1 = @test_nowarn ODEProblem(sys, [x => ones(3)], (0.0, 10.0), [p => ones(3, 3)])
     sol1 = @test_nowarn solve(prob1, Tsit5())
-    
+
     # array condition equations also used to not work
     @mtkbuild sys = ODESystem(
         eqs, t; continuous_events = [[x ~ sqrt(3) * ones(3)] => [x ~ ones(3)]])
     # array affect equations used to not work
     prob2 = @test_nowarn ODEProblem(sys, [x => ones(3)], (0.0, 10.0), [p => ones(3, 3)])
     sol2 = @test_nowarn solve(prob2, Tsit5())
-    
+
     @test sol1.u ≈ sol2.u[2:end]
 end
 
@@ -1541,7 +1542,12 @@ end
 @testset "Observed variables dependent on discrete parameters" begin
     @variables x(t) obs(t)
     @parameters c(t)
-    @mtkbuild sys = ODESystem([D(x) ~ c * cos(x), obs ~ c], t, [x], [c]; discrete_events = [SymbolicDiscreteCallback(1.0 => [c ~ Pre(c) + 1], discrete_parameters = [c])])
+    @mtkbuild sys = ODESystem([D(x) ~ c * cos(x), obs ~ c],
+        t,
+        [x],
+        [c];
+        discrete_events = [SymbolicDiscreteCallback(
+            1.0 => [c ~ Pre(c) + 1], discrete_parameters = [c])])
     prob = ODEProblem(sys, [x => 0.0], (0.0, 2pi), [c => 1.0])
     sol = solve(prob, Tsit5())
     @test sol[obs] ≈ 1:7
@@ -1609,7 +1615,8 @@ end
     @test osys1 == osys2 # true
 
     continuous_events = [[X ~ 1.0] => [X ~ Pre(X) + 5.0]]
-    discrete_events = [SymbolicDiscreteCallback(5.0 => [d ~ d / 2.0], discrete_parameters = [d])]
+    discrete_events = [SymbolicDiscreteCallback(
+        5.0 => [d ~ d / 2.0], discrete_parameters = [d])]
 
     osys1 = complete(ODESystem([eq], t; name = :osys, continuous_events))
     osys2 = complete(ODESystem([eq], t; name = :osys))

test/parameter_dependencies.jl

@@ -1,6 +1,7 @@
 using ModelingToolkit
 using Test
-using ModelingToolkit: t_nounits as t, D_nounits as D, SymbolicDiscreteCallback, SymbolicContinuousCallback
+using ModelingToolkit: t_nounits as t, D_nounits as D, SymbolicDiscreteCallback,
+                       SymbolicContinuousCallback
 using OrdinaryDiffEq
 using StochasticDiffEq
 using JumpProcesses
@@ -225,7 +226,8 @@ end
         @test_nowarn solve(prob, Tsit5())
 
         @mtkbuild sys = ODESystem(eqs, t; parameter_dependencies = [kq => 2kp],
-                                  discrete_events = [SymbolicDiscreteCallback([0.5] => [kp ~ 2.0], discrete_parameters = [kp])])
+            discrete_events = [SymbolicDiscreteCallback(
+                [0.5] => [kp ~ 2.0], discrete_parameters = [kp])])
         prob = ODEProblem(sys, [x => 0.0, y => 0.0], (0.0, Tf),
             [kp => 1.0; z(k - 1) => 3.0; yd(k - 1) => 0.0; z(k - 2) => 4.0;
              yd(k - 2) => 2.0])
@@ -269,7 +271,8 @@ end
 
     @named sys = ODESystem(eqs, t)
     @named sdesys = SDESystem(sys, noiseeqs; parameter_dependencies = [ρ => 2σ],
-                              discrete_events = [SymbolicDiscreteCallback([10.0] => [σ ~ 15.0], discrete_parameters = [σ])])
+        discrete_events = [SymbolicDiscreteCallback(
+            [10.0] => [σ ~ 15.0], discrete_parameters = [σ])])
     sdesys = complete(sdesys)
     prob = SDEProblem(
         sdesys, [x => 1.0, y => 0.0, z => 0.0], (0.0, 100.0), [σ => 10.0, β => 2.33])
@@ -308,7 +311,8 @@ end
 
     @named js2 = JumpSystem(
         [j₁, j₃], t, [S, I, R], [γ]; parameter_dependencies = [β => 0.01γ],
-        discrete_events = [SymbolicDiscreteCallback([10.0] => [γ ~ 0.02], discrete_parameters = [γ])])
+        discrete_events = [SymbolicDiscreteCallback(
+            [10.0] => [γ ~ 0.02], discrete_parameters = [γ])])
     js2 = complete(js2)
     dprob = DiscreteProblem(js2, u₀map, tspan, parammap)
     jprob = JumpProblem(js2, dprob, Direct(), save_positions = (false, false), rng = rng)

test/symbolic_events.jl

@@ -1100,7 +1100,7 @@ end
     f = ModelingToolkit.FunctionalAffect(
         f = (i, u, p, c) -> seen = true, sts = [], pars = [], discretes = [])
     cb1 = ModelingToolkit.SymbolicContinuousCallback(
-                                                     [x ~ 0], nothing, initialize = [x ~ 1.5], finalize = f)
+        [x ~ 0], nothing, initialize = [x ~ 1.5], finalize = f)
     @mtkbuild sys = ODESystem(D(x) ~ -1, t, [x], []; continuous_events = [cb1])
     prob = ODEProblem(sys, [x => 1.0], (0.0, 2), [])
     sol = solve(prob, Tsit5(); dtmax = 0.01)