From da3146dfc77a07fe0288883495ee44e678022d08 Mon Sep 17 00:00:00 2001
From: Mahmoud Bentriou <mahmoud.bentriou@centralesupelec.fr>
Date: Sat, 16 Jan 2021 11:15:56 +0100
Subject: [PATCH] Improvement of the distributed simulation paradigm of the
package. Simulation of synchronized models is easily distributable. Change of
the signature of check_constraints and update_state in order to access the
model parameters. Test about distributed simulations was renamed and
completed.
---
automata/automaton_F.jl | 46 +++----
automata/automaton_G.jl | 120 +++++++++---------
automata/automaton_G_and_F.jl | 117 ++++++++---------
core/lha.jl | 19 +--
core/model.jl | 16 +--
tests/run_unit.jl | 2 +-
...stributed.jl => distributed_simulation.jl} | 12 ++
7 files changed, 175 insertions(+), 157 deletions(-)
rename tests/unit/{macro_network_model_distributed.jl => distributed_simulation.jl} (82%)
diff --git a/automata/automaton_F.jl b/automata/automaton_F.jl
index 3c59e86..caea4d0 100644
--- a/automata/automaton_F.jl
+++ b/automata/automaton_F.jl
@@ -32,72 +32,74 @@ function create_automaton_F(m::ContinuousTimeModel, x1::Float64, x2::Float64, t1
end
istrue(val::Float64) = convert(Bool, val)
+ sym_isabs_func = Symbol(m.isabsorbing)
+
# l0 loc : we construct the edges of the form l0 => (..)
# "cc" as check_constraints
tuple = (:l0, :l1)
- cc_aut_F_l0l1_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) = true
- us_aut_F_l0l1_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ cc_aut_F_l0l1_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) = true
+ us_aut_F_l0l1_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l1;
S[:n] = get_value(S, x, sym_obs);
S[:d] = Inf;
- S[:isabs] = getfield(m, :isabsorbing)(getfield(m, :p),x))
+ S[:isabs] = getfield(Main, sym_isabs_func)(p, x))
edge1 = Edge([nothing], cc_aut_F_l0l1_1, us_aut_F_l0l1_1!)
map_edges[:l0][:l1] = [edge1]
# l1 loc : we construct the edges of the form l1 => (..)
tuple = (:l1, :l2)
- cc_aut_F_l1l2_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ cc_aut_F_l1l2_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
getfield(S, :time) >= constants[:t1] &&
(constants[:x1] <= S[:n] <= constants[:x2])
- us_aut_F_l1l2_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_F_l1l2_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2;
S[:d] = 0)
edge1 = Edge([nothing], cc_aut_F_l1l2_1, us_aut_F_l1l2_1!)
- cc_aut_F_l1l2_4(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ cc_aut_F_l1l2_4(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
getfield(S, :time) >= constants[:t1] &&
S[:d] == 0
- us_aut_F_l1l2_4!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_F_l1l2_4!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2)
edge4 = Edge([nothing], cc_aut_F_l1l2_4, us_aut_F_l1l2_4!)
- cc_aut_F_l1l2_2(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ cc_aut_F_l1l2_2(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(getfield(S, :time) >= constants[:t2]) &&
(S[:n] < constants[:x1] || S[:n] > constants[:x2])
- us_aut_F_l1l2_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_F_l1l2_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2;
S[:d] = min(abs(S[:n] - constants[:x1]), abs(S[:n] - constants[:x2])))
edge2 = Edge([nothing], cc_aut_F_l1l2_2, us_aut_F_l1l2_2!)
- cc_aut_F_l1l2_3(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ cc_aut_F_l1l2_3(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
istrue(S[:isabs]) && getfield(S, :time) <= constants[:t2]
- us_aut_F_l1l2_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_F_l1l2_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2)
edge3 = Edge([nothing], cc_aut_F_l1l2_3, us_aut_F_l1l2_3!)
map_edges[:l1][:l2] = [edge1, edge2, edge3, edge4]
tuple = (:l1, :l3)
- cc_aut_F_l1l3_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ cc_aut_F_l1l3_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(constants[:x1] <= S[:n] <= constants[:x2])
- us_aut_F_l1l3_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_F_l1l3_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l3;
S[:d] = 0;)
edge1 = Edge([nothing], cc_aut_F_l1l3_1, us_aut_F_l1l3_1!)
- cc_aut_F_l1l3_2(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ cc_aut_F_l1l3_2(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S[:n] < constants[:x1] || S[:n] > constants[:x2]) &&
(getfield(S, :time) <= constants[:t1])
- us_aut_F_l1l3_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_F_l1l3_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l3;
S[:d] = min(sqrt((getfield(S, :time) - constants[:t1])^2 + (S[:n] - constants[:x2])^2),
sqrt((getfield(S, :time) - constants[:t1])^2 + (S[:n] - constants[:x1])^2)))
edge2 = Edge([nothing], cc_aut_F_l1l3_2, us_aut_F_l1l3_2!)
- cc_aut_F_l1l3_3(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ cc_aut_F_l1l3_3(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S[:n] < constants[:x1] || S[:n] > constants[:x2]) &&
(constants[:t1] <= getfield(S, :time) <= constants[:t2])
- us_aut_F_l1l3_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_F_l1l3_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l3;
S[:d] = min(S[:d], min(abs(S[:n] - constants[:x1]), abs(S[:n] - constants[:x2]))))
edge3 = Edge([nothing], cc_aut_F_l1l3_3, us_aut_F_l1l3_3!)
@@ -105,19 +107,19 @@ function create_automaton_F(m::ContinuousTimeModel, x1::Float64, x2::Float64, t1
# l3 loc
tuple = (:l3, :l1)
- cc_aut_F_l3l1_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) = true
- us_aut_F_l3l1_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ cc_aut_F_l3l1_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) = true
+ us_aut_F_l3l1_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l1;
S[:n] = get_value(S, x, sym_obs);
- S[:isabs] = getfield(m, :isabsorbing)(getfield(m, :p),x))
+ S[:isabs] = getfield(Main, sym_isabs_func)(p, x))
edge1 = Edge([:ALL], cc_aut_F_l3l1_1, us_aut_F_l3l1_1!)
map_edges[:l3][:l1] = [edge1]
tuple = (:l3, :l2)
- cc_aut_F_l3l2_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ cc_aut_F_l3l2_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(getfield(S, :time) >= constants[:t2])
- us_aut_F_l3l2_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_F_l3l2_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2)
edge1 = Edge([nothing], cc_aut_F_l3l2_1, us_aut_F_l3l2_1!)
map_edges[:l3][:l2] = [edge1]
diff --git a/automata/automaton_G.jl b/automata/automaton_G.jl
index 76f7e62..e0d2bce 100644
--- a/automata/automaton_G.jl
+++ b/automata/automaton_G.jl
@@ -5,10 +5,10 @@ function create_automaton_G(m::ContinuousTimeModel, x1::Float64, x2::Float64, t1
locations = [:l0, :l1, :l2, :l3, :l4]
# Invariant predicates
- true_inv_predicate(x::Vector{Int}) = true
- Λ_F = Dict(:l0 => true_inv_predicate, :l1 => true_inv_predicate,
- :l2 => true_inv_predicate, :l3 => true_inv_predicate,
- :l4 => true_inv_predicate)
+ @everywhere true_inv_predicate(x::Vector{Int}) = true
+ Λ_F = Dict(:l0 => getfield(Main, :true_inv_predicate), :l1 => getfield(Main, :true_inv_predicate),
+ :l2 => getfield(Main, :true_inv_predicate), :l3 => getfield(Main, :true_inv_predicate),
+ :l4 => getfield(Main, :true_inv_predicate))
## Init and final loc
locations_init = [:l0]
@@ -30,163 +30,165 @@ function create_automaton_G(m::ContinuousTimeModel, x1::Float64, x2::Float64, t1
for loc in locations
map_edges[loc] = Dict{Location, Vector{Edge}}()
end
- istrue(val::Float64) = convert(Bool, val)
+ @everywhere istrue(val::Float64) = convert(Bool, val)
+
+ sym_isabs_func = Symbol(m.isabsorbing)
# l0 loc
tuple = (:l0, :l1)
- cc_aut_G_l0l1_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) = true
- us_aut_G_l0l1_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ @everywhere cc_aut_G_l0l1_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) = true
+ @everywhere us_aut_G_l0l1_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l1;
S[:d] = 0;
- S[:n] = get_value(S, x, sym_obs);
+ S[:n] = get_value(S, x, $(Meta.quot(sym_obs)));
S[:in] = true;
- S[:isabs] = getfield(m, :isabsorbing)(getfield(m, :p),x))
- edge1 = Edge([nothing], cc_aut_G_l0l1_1, us_aut_G_l0l1_1!)
+ S[:isabs] = getfield(Main, $(Meta.quot(sym_isabs_func)))(p, x))
+ edge1 = Edge([nothing], getfield(Main, :cc_aut_G_l0l1_1), getfield(Main, :us_aut_G_l0l1_1!))
map_edges[:l0][:l1] = [edge1]
# l1 loc
tuple = (:l1, :l3)
- cc_aut_G_l1l3_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ @everywhere cc_aut_G_l1l3_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
getfield(S, :time) <= constants[:t1] &&
S[:n] < constants[:x1] || S[:n] > constants[:x2]
- us_aut_G_l1l3_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ @everywhere us_aut_G_l1l3_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l3;
S[:d] = min(abs(constants[:x1] - S[:n]), abs(constants[:x2] - S[:n]));
S[:in] = false)
- edge1 = Edge([nothing], cc_aut_G_l1l3_1, us_aut_G_l1l3_1!)
+ edge1 = Edge([nothing], getfield(Main, :cc_aut_G_l1l3_1), getfield(Main, :us_aut_G_l1l3_1!))
- cc_aut_G_l1l3_3(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ @everywhere cc_aut_G_l1l3_3(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
!istrue(S[:in]) &&
(constants[:t1] <= getfield(S, :time) <= constants[:t2]) &&
(constants[:x1] <= S[:n] <= constants[:x2])
- us_aut_G_l1l3_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ @everywhere us_aut_G_l1l3_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l3;
S[:d] = S[:d] * (getfield(S, :time) - constants[:t1]);
S[:tprime] = 0.0)
- edge3 = Edge([nothing], cc_aut_G_l1l3_3, us_aut_G_l1l3_3!)
+ edge3 = Edge([nothing], getfield(Main, :cc_aut_G_l1l3_3), getfield(Main, :us_aut_G_l1l3_3!))
- cc_aut_G_l1l3_2(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ @everywhere cc_aut_G_l1l3_2(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(getfield(S, :time) <= constants[:t1]) &&
(constants[:x1] <= S[:n] <= constants[:x2])
- us_aut_G_l1l3_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ @everywhere us_aut_G_l1l3_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l3;
S[:d] = 0;
S[:in] = false)
- edge2 = Edge([nothing], cc_aut_G_l1l3_2, us_aut_G_l1l3_2!)
+ edge2 = Edge([nothing], getfield(Main, :cc_aut_G_l1l3_2), getfield(Main, :us_aut_G_l1l3_2!))
- cc_aut_G_l1l3_4(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ @everywhere cc_aut_G_l1l3_4(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
istrue(S[:in]) &&
(constants[:t1] <= getfield(S, :time) <= constants[:t2]) &&
(constants[:x1] <= S[:n] <= constants[:x2])
- us_aut_G_l1l3_4!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ @everywhere us_aut_G_l1l3_4!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l3;
S[:tprime] = 0.0)
- edge4 = Edge([nothing], cc_aut_G_l1l3_4, us_aut_G_l1l3_4!)
+ edge4 = Edge([nothing], getfield(Main, :cc_aut_G_l1l3_4), getfield(Main, :us_aut_G_l1l3_4!))
map_edges[:l1][:l3] = [edge1, edge2, edge3, edge4]
tuple = (:l1, :l4)
- cc_aut_G_l1l4_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ @everywhere cc_aut_G_l1l4_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
!istrue(S[:in]) &&
(constants[:t1] <= getfield(S, :time) <= constants[:t2]) &&
(S[:n] < constants[:x1] || S[:n] > constants[:x2])
- us_aut_G_l1l4_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ @everywhere us_aut_G_l1l4_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l4;
S[:d] += S[:d] * (getfield(S, :time) - constants[:t1]))
- edge1 = Edge([nothing], cc_aut_G_l1l4_1, us_aut_G_l1l4_1!)
- cc_aut_G_l1l4_2(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ edge1 = Edge([nothing], getfield(Main, :cc_aut_G_l1l4_1), getfield(Main, :us_aut_G_l1l4_1!))
+ @everywhere cc_aut_G_l1l4_2(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
istrue(S[:in]) &&
(constants[:t1] <= getfield(S, :time) <= constants[:t2]) &&
(S[:n] < constants[:x1] || S[:n] > constants[:x2])
- us_aut_G_l1l4_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ @everywhere us_aut_G_l1l4_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l4)
- edge2 = Edge([nothing], cc_aut_G_l1l4_2, us_aut_G_l1l4_2!)
+ edge2 = Edge([nothing], getfield(Main, :cc_aut_G_l1l4_2), getfield(Main, :us_aut_G_l1l4_2!))
map_edges[:l1][:l4] = [edge1, edge2]
tuple = (:l1, :l2)
- cc_aut_G_l1l2_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ @everywhere cc_aut_G_l1l2_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
istrue(S[:in]) &&
getfield(S, :time) >= constants[:t2]
- us_aut_G_l1l2_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ @everywhere us_aut_G_l1l2_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2)
- edge1 = Edge([nothing], cc_aut_G_l1l2_1, us_aut_G_l1l2_1!)
- cc_aut_G_l1l2_2(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ edge1 = Edge([nothing], getfield(Main, :cc_aut_G_l1l2_1), getfield(Main, :us_aut_G_l1l2_1!))
+ @everywhere cc_aut_G_l1l2_2(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
!istrue(S[:in]) &&
getfield(S, :time) >= constants[:t2]
- us_aut_G_l1l2_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ @everywhere us_aut_G_l1l2_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2;
S[:d] = S[:d] * (constants[:t2] - constants[:t1]))
- edge2 = Edge([nothing], cc_aut_G_l1l2_2, us_aut_G_l1l2_2!)
- cc_aut_G_l1l2_3(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ edge2 = Edge([nothing], getfield(Main, :cc_aut_G_l1l2_2), getfield(Main, :us_aut_G_l1l2_2!))
+ @everywhere cc_aut_G_l1l2_3(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
istrue(S[:isabs]) &&
getfield(S, :time) <= constants[:t1]
- us_aut_G_l1l2_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ @everywhere us_aut_G_l1l2_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2;
S[:d] = (constants[:t2] - constants[:t1]) *
min(abs(constants[:x1] - S[:n]), abs(constants[:x2] - S[:n])))
- edge3 = Edge([nothing], cc_aut_G_l1l2_3, us_aut_G_l1l2_3!)
- cc_aut_G_l1l2_4(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ edge3 = Edge([nothing], getfield(Main, :cc_aut_G_l1l2_3), getfield(Main, :us_aut_G_l1l2_3!))
+ @everywhere cc_aut_G_l1l2_4(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
istrue(S[:isabs]) &&
(constants[:t1] <= getfield(S, :time) <= constants[:t2])
- us_aut_G_l1l2_4!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ @everywhere us_aut_G_l1l2_4!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2;
S[:d] += (constants[:t2] - getfield(S, :time)) *
min(abs(constants[:x1] - S[:n]), abs(constants[:x2] - S[:n])))
- edge4 = Edge([nothing], cc_aut_G_l1l2_4, us_aut_G_l1l2_4!)
+ edge4 = Edge([nothing], getfield(Main, :cc_aut_G_l1l2_4), getfield(Main, :us_aut_G_l1l2_4!))
map_edges[:l1][:l2] = [edge1, edge2, edge3, edge4]
# l3 loc
tuple = (:l3, :l1)
- cc_aut_G_l3l1_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) = true
- us_aut_G_l3l1_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ @everywhere cc_aut_G_l3l1_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) = true
+ @everywhere us_aut_G_l3l1_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l1;
- S[:n] = get_value(S, x, sym_obs);
- S[:isabs] = getfield(m, :isabsorbing)(getfield(m, :p),x))
- edge1 = Edge([:ALL], cc_aut_G_l3l1_1, us_aut_G_l3l1_1!)
+ S[:n] = get_value(S, x, $(Meta.quot(sym_obs)));
+ S[:isabs] = getfield(Main, $(Meta.quot(sym_isabs_func)))(p, x))
+ edge1 = Edge([:ALL], getfield(Main, :cc_aut_G_l3l1_1), getfield(Main, :us_aut_G_l3l1_1!))
map_edges[:l3][:l1] = [edge1]
tuple = (:l3, :l2)
- cc_aut_G_l3l2_2(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ @everywhere cc_aut_G_l3l2_2(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
istrue(S[:in]) &&
getfield(S, :time) >= constants[:t2]
- us_aut_G_l3l2_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ @everywhere us_aut_G_l3l2_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2;
S[:d] = S[:d] * (constants[:t2] - constants[:t1]))
- edge2 = Edge([nothing], cc_aut_G_l3l2_2, us_aut_G_l3l2_2!)
- cc_aut_G_l3l2_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ edge2 = Edge([nothing], getfield(Main, :cc_aut_G_l3l2_2), getfield(Main, :us_aut_G_l3l2_2!))
+ @everywhere cc_aut_G_l3l2_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
!istrue(S[:in]) &&
getfield(S, :time) >= constants[:t2]
- us_aut_G_l3l2_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ @everywhere us_aut_G_l3l2_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2)
- edge1 = Edge([nothing], cc_aut_G_l3l2_1, us_aut_G_l3l2_1!)
+ edge1 = Edge([nothing], getfield(Main, :cc_aut_G_l3l2_1), getfield(Main, :us_aut_G_l3l2_1!))
map_edges[:l3][:l2] = [edge1, edge2]
# l4 loc
tuple = (:l4, :l1)
- cc_aut_G_l4l1_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) = true
- us_aut_G_l4l1_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ @everywhere cc_aut_G_l4l1_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) = true
+ @everywhere us_aut_G_l4l1_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l1;
S[:d] += S[:tprime] * min(abs(constants[:x1] - S[:n]), abs(constants[:x2] - S[:n]));
S[:tprime] = 0.0;
- S[:n] = get_value(S, x, sym_obs);
+ S[:n] = get_value(S, x, $(Meta.quot(sym_obs)));
S[:in] = true;
- S[:isabs] = getfield(m, :isabsorbing)(getfield(m, :p),x))
- edge1 = Edge([:ALL], cc_aut_G_l4l1_1, us_aut_G_l4l1_1!)
+ S[:isabs] = getfield(Main, $(Meta.quot(sym_isabs_func)))(p, x))
+ edge1 = Edge([:ALL], getfield(Main, :cc_aut_G_l4l1_1), getfield(Main, :us_aut_G_l4l1_1!))
map_edges[:l4][:l1] = [edge1]
tuple = (:l4, :l2)
- cc_aut_G_l4l2_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ @everywhere cc_aut_G_l4l2_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(getfield(S, :time) >= constants[:t2])
- us_aut_G_l4l2_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ @everywhere us_aut_G_l4l2_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2;
S[:d] += S[:tprime] * min(abs(constants[:x1] - S[:n]), abs(constants[:x2] - S[:n]));
S[:tprime] = 0.0)
- edge1 = Edge([nothing], cc_aut_G_l4l2_1, us_aut_G_l4l2_1!)
+ edge1 = Edge([nothing], getfield(Main, :cc_aut_G_l4l2_1), getfield(Main, :us_aut_G_l4l2_1!))
map_edges[:l4][:l2] = [edge1]
diff --git a/automata/automaton_G_and_F.jl b/automata/automaton_G_and_F.jl
index 87c79b5..f17caf2 100644
--- a/automata/automaton_G_and_F.jl
+++ b/automata/automaton_G_and_F.jl
@@ -40,56 +40,57 @@ function create_automaton_G_and_F(m::ContinuousTimeModel, x1::Float64, x2::Float
for loc in locations
map_edges[loc] = Dict{Location, Vector{Edge}}()
end
-
istrue(val::Float64) = convert(Bool, val)
+
+ sym_isabs_func = Symbol(m.isabsorbing)
# l0G loc
tuple = (:l0G, :l1G)
- cc_aut_G_l0Gl1G_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) = true
- us_aut_G_l0Gl1G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ cc_aut_G_l0Gl1G_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) = true
+ us_aut_G_l0Gl1G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l1G;
S[:d] = 0;
S[:n] = get_value(S, x, sym_obs_G);
S[:in] = true;
- S[:isabs] = getfield(m, :isabsorbing)(getfield(m, :p),x))
+ S[:isabs] = getfield(Main, sym_isabs_func)(p, x))
edge1 = Edge([nothing], cc_aut_G_l0Gl1G_1, us_aut_G_l0Gl1G_1!)
map_edges[:l0G][:l1G] = [edge1]
# l1G loc
tuple = (:l1G, :l3G)
- cc_aut_G_l1Gl3G_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_G_l1Gl3G_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
getfield(S, :time) <= constants[:t1] &&
S[:n] < constants[:x1] || S[:n] > constants[:x2]
- us_aut_G_l1Gl3G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_G_l1Gl3G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l3G;
S[:d] = min(abs(constants[:x1] - S[:n]), abs(constants[:x2] - S[:n]));
S[:in] = false)
edge1 = Edge([nothing], cc_aut_G_l1Gl3G_1, us_aut_G_l1Gl3G_1!)
- cc_aut_G_l1Gl3G_3(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_G_l1Gl3G_3(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
!istrue(S[:in]) &&
(constants[:t1] <= getfield(S, :time) <= constants[:t2]) &&
(constants[:x1] <= S[:n] <= constants[:x2])
- us_aut_G_l1Gl3G_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_G_l1Gl3G_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l3G;
S[:d] = S[:d] * (getfield(S, :time) - constants[:t1]);
S[:tprime] = 0.0)
edge3 = Edge([nothing], cc_aut_G_l1Gl3G_3, us_aut_G_l1Gl3G_3!)
- cc_aut_G_l1Gl3G_2(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_G_l1Gl3G_2(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(getfield(S, :time) <= constants[:t1]) &&
(constants[:x1] <= S[:n] <= constants[:x2])
- us_aut_G_l1Gl3G_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_G_l1Gl3G_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l3G;
S[:d] = 0;
S[:in] = false)
edge2 = Edge([nothing], cc_aut_G_l1Gl3G_2, us_aut_G_l1Gl3G_2!)
- cc_aut_G_l1Gl3G_4(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_G_l1Gl3G_4(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
istrue(S[:in]) &&
(constants[:t1] <= getfield(S, :time) <= constants[:t2]) &&
(constants[:x1] <= S[:n] <= constants[:x2])
- us_aut_G_l1Gl3G_4!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_G_l1Gl3G_4!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l3G;
S[:tprime] = 0.0)
edge4 = Edge([nothing], cc_aut_G_l1Gl3G_4, us_aut_G_l1Gl3G_4!)
@@ -97,52 +98,52 @@ function create_automaton_G_and_F(m::ContinuousTimeModel, x1::Float64, x2::Float
map_edges[:l1G][:l3G] = [edge1, edge2, edge3, edge4]
tuple = (:l1G, :l4G)
- cc_aut_G_l1Gl4G_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_G_l1Gl4G_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
!istrue(S[:in]) &&
(constants[:t1] <= getfield(S, :time) <= constants[:t2]) &&
(S[:n] < constants[:x1] || S[:n] > constants[:x2])
- us_aut_G_l1Gl4G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_G_l1Gl4G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l4G;
S[:d] += S[:d] * (getfield(S, :time) - constants[:t1]))
edge1 = Edge([nothing], cc_aut_G_l1Gl4G_1, us_aut_G_l1Gl4G_1!)
- cc_aut_G_l1Gl4G_2(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_G_l1Gl4G_2(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
istrue(S[:in]) &&
(constants[:t1] <= getfield(S, :time) <= constants[:t2]) &&
(S[:n] < constants[:x1] || S[:n] > constants[:x2])
- us_aut_G_l1Gl4G_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_G_l1Gl4G_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l4G)
edge2 = Edge([nothing], cc_aut_G_l1Gl4G_2, us_aut_G_l1Gl4G_2!)
map_edges[:l1G][:l4G] = [edge1, edge2]
tuple = (:l1G, :l2G)
- cc_aut_G_l1Gl2G_3(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_G_l1Gl2G_3(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
istrue(S[:isabs]) &&
getfield(S, :time) <= constants[:t1]
- us_aut_G_l1Gl2G_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_G_l1Gl2G_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2G;
S[:d] = (constants[:t2] - constants[:t1]) *
min(abs(constants[:x1] - S[:n]), abs(constants[:x2] - S[:n])))
edge3 = Edge([nothing], cc_aut_G_l1Gl2G_3, us_aut_G_l1Gl2G_3!)
- cc_aut_G_l1Gl2G_4(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_G_l1Gl2G_4(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
istrue(S[:isabs]) &&
(constants[:t1] <= getfield(S, :time) <= constants[:t2])
- us_aut_G_l1Gl2G_4!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_G_l1Gl2G_4!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2G;
S[:d] += (constants[:t2] - getfield(S, :time)) *
min(abs(constants[:x1] - S[:n]), abs(constants[:x2] - S[:n])))
edge4 = Edge([nothing], cc_aut_G_l1Gl2G_4, us_aut_G_l1Gl2G_4!)
- cc_aut_G_l1Gl2G_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_G_l1Gl2G_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
istrue(S[:in]) &&
getfield(S, :time) >= constants[:t2]
- us_aut_G_l1Gl2G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_G_l1Gl2G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2G)
edge1 = Edge([nothing], cc_aut_G_l1Gl2G_1, us_aut_G_l1Gl2G_1!)
- cc_aut_G_l1Gl2G_2(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_G_l1Gl2G_2(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
!istrue(S[:in]) &&
getfield(S, :time) >= constants[:t2]
- us_aut_G_l1Gl2G_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_G_l1Gl2G_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2G;
S[:d] = S[:d] * (constants[:t2] - constants[:t1]))
edge2 = Edge([nothing], cc_aut_G_l1Gl2G_2, us_aut_G_l1Gl2G_2!)
@@ -151,27 +152,27 @@ function create_automaton_G_and_F(m::ContinuousTimeModel, x1::Float64, x2::Float
# l3G loc
tuple = (:l3G, :l1G)
- cc_aut_G_l3Gl1G_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) = true
- us_aut_G_l3Gl1G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ cc_aut_G_l3Gl1G_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) = true
+ us_aut_G_l3Gl1G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l1G;
S[:n] = get_value(S, x, sym_obs_G);
- S[:isabs] = getfield(m, :isabsorbing)(getfield(m, :p),x))
+ S[:isabs] = getfield(Main, sym_isabs_func)(p, x))
edge1 = Edge([:ALL], cc_aut_G_l3Gl1G_1, us_aut_G_l3Gl1G_1!)
map_edges[:l3G][:l1G] = [edge1]
tuple = (:l3G, :l2G)
- cc_aut_G_l3Gl2G_2(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_G_l3Gl2G_2(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
istrue(S[:in]) &&
getfield(S, :time) >= constants[:t2]
- us_aut_G_l3Gl2G_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_G_l3Gl2G_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2G;
S[:d] = S[:d] * (constants[:t2] - constants[:t1]))
edge2 = Edge([nothing], cc_aut_G_l3Gl2G_2, us_aut_G_l3Gl2G_2!)
- cc_aut_G_l3Gl2G_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_G_l3Gl2G_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
!istrue(S[:in]) &&
getfield(S, :time) >= constants[:t2]
- us_aut_G_l3Gl2G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_G_l3Gl2G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2G)
edge1 = Edge([nothing], cc_aut_G_l3Gl2G_1, us_aut_G_l3Gl2G_1!)
@@ -179,22 +180,22 @@ function create_automaton_G_and_F(m::ContinuousTimeModel, x1::Float64, x2::Float
# l4G loc
tuple = (:l4G, :l1G)
- cc_aut_G_l4Gl1G_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) = true
- us_aut_G_l4Gl1G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ cc_aut_G_l4Gl1G_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) = true
+ us_aut_G_l4Gl1G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l1G;
S[:d] += S[:tprime] * min(abs(constants[:x1] - S[:n]), abs(constants[:x2] - S[:n]));
S[:tprime] = 0.0;
S[:n] = get_value(S, x, sym_obs_G);
S[:in] = true;
- S[:isabs] = getfield(m, :isabsorbing)(getfield(m, :p),x))
+ S[:isabs] = getfield(Main, sym_isabs_func)(p, x))
edge1 = Edge([:ALL], cc_aut_G_l4Gl1G_1, us_aut_G_l4Gl1G_1!)
map_edges[:l4G][:l1G] = [edge1]
tuple = (:l4G, :l2G)
- cc_aut_G_l4Gl2G_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_G_l4Gl2G_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(getfield(S, :time) >= constants[:t2])
- us_aut_G_l4Gl2G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_G_l4Gl2G_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2G;
S[:d] += S[:tprime] * min(abs(constants[:x1] - S[:n]), abs(constants[:x2] - S[:n]));
S[:tprime] = 0.0)
@@ -204,44 +205,44 @@ function create_automaton_G_and_F(m::ContinuousTimeModel, x1::Float64, x2::Float
# Connection between the two automata: l2G => l1F
tuple = (:l2G, :l1F)
- cc_aut_F_l2Gl1F_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) = true
- us_aut_F_l2Gl1F_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ cc_aut_F_l2Gl1F_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) = true
+ us_aut_F_l2Gl1F_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l1F;
S[:n] = get_value(S, x, sym_obs_F);
S[:dprime] = Inf;
- S[:isabs] = getfield(m, :isabsorbing)(getfield(m, :p),x))
+ S[:isabs] = getfield(Main, sym_isabs_func)(p, x))
edge1 = Edge([nothing], cc_aut_F_l2Gl1F_1, us_aut_F_l2Gl1F_1!)
map_edges[:l2G][:l1F] = [edge1]
# l1F loc : we construct the edges of the form l1F => (..)
tuple = (:l1F, :l2F)
- cc_aut_F_l1Fl2F_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_F_l1Fl2F_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
getfield(S, :time) >= constants[:t3] &&
(constants[:x3] <= S[:n] <= constants[:x4])
- us_aut_F_l1Fl2F_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_F_l1Fl2F_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2F;
S[:dprime] = 0)
edge1 = Edge([nothing], cc_aut_F_l1Fl2F_1, us_aut_F_l1Fl2F_1!)
- cc_aut_F_l1Fl2F_4(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_F_l1Fl2F_4(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
getfield(S, :time) >= constants[:t3] &&
S[:dprime] == 0
- us_aut_F_l1Fl2F_4!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_F_l1Fl2F_4!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2F)
edge4 = Edge([nothing], cc_aut_F_l1Fl2F_4, us_aut_F_l1Fl2F_4!)
- cc_aut_F_l1Fl2F_2(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_F_l1Fl2F_2(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(getfield(S, :time) >= constants[:t4]) &&
(S[:n] < constants[:x3] || S[:n] > constants[:x4])
- us_aut_F_l1Fl2F_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_F_l1Fl2F_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2F;
S[:dprime] = min(abs(S[:n] - constants[:x3]), abs(S[:n] - constants[:x4]));
S[:d] += S[:dprime])
edge2 = Edge([nothing], cc_aut_F_l1Fl2F_2, us_aut_F_l1Fl2F_2!)
- cc_aut_F_l1Fl2F_3(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_F_l1Fl2F_3(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
istrue(S[:isabs]) && getfield(S, :time) <= constants[:t4]
- us_aut_F_l1Fl2F_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_F_l1Fl2F_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2F;
S[:d] += S[:dprime])
edge3 = Edge([nothing], cc_aut_F_l1Fl2F_3, us_aut_F_l1Fl2F_3!)
@@ -249,26 +250,26 @@ function create_automaton_G_and_F(m::ContinuousTimeModel, x1::Float64, x2::Float
map_edges[:l1F][:l2F] = [edge1, edge4, edge3, edge2]
tuple = (:l1F, :l3F)
- cc_aut_F_l1Fl3F_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_F_l1Fl3F_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(constants[:x3] <= S[:n] <= constants[:x4])
- us_aut_F_l1Fl3F_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_F_l1Fl3F_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l3F;
S[:dprime] = 0;)
edge1 = Edge([nothing], cc_aut_F_l1Fl3F_1, us_aut_F_l1Fl3F_1!)
- cc_aut_F_l1Fl3F_2(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_F_l1Fl3F_2(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S[:n] < constants[:x3] || S[:n] > constants[:x4]) &&
(getfield(S, :time) <= constants[:t3])
- us_aut_F_l1Fl3F_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_F_l1Fl3F_2!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l3F;
S[:dprime] = min(sqrt((getfield(S, :time) - constants[:t3])^2 + (S[:n] - constants[:x4])^2),
sqrt((getfield(S, :time) - constants[:t3])^2 + (S[:n] - constants[:x3])^2)))
edge2 = Edge([nothing], cc_aut_F_l1Fl3F_2, us_aut_F_l1Fl3F_2!)
- cc_aut_F_l1Fl3F_3(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_F_l1Fl3F_3(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S[:n] < constants[:x3] || S[:n] > constants[:x4]) &&
(constants[:t3] <= getfield(S, :time) <= constants[:t4])
- us_aut_F_l1Fl3F_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_F_l1Fl3F_3!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l3F;
S[:dprime] = min(S[:dprime], min(abs(S[:n] - constants[:x3]), abs(S[:n] - constants[:x4]))))
edge3 = Edge([nothing], cc_aut_F_l1Fl3F_3, us_aut_F_l1Fl3F_3!)
@@ -277,19 +278,19 @@ function create_automaton_G_and_F(m::ContinuousTimeModel, x1::Float64, x2::Float
# l3F loc
tuple = (:l3F, :l1F)
- cc_aut_F_l3Fl1F_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) = true
- us_aut_F_l3Fl1F_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ cc_aut_F_l3Fl1F_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) = true
+ us_aut_F_l3Fl1F_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l1F;
S[:n] = get_value(S, x, sym_obs_F);
- S[:isabs] = getfield(m, :isabsorbing)(getfield(m, :p),x))
+ S[:isabs] = getfield(Main, sym_isabs_func)(p, x))
edge1 = Edge([:ALL], cc_aut_F_l3Fl1F_1, us_aut_F_l3Fl1F_1!)
map_edges[:l3F][:l1F] = [edge1]
tuple = (:l3F, :l2F)
- cc_aut_F_l3Fl2F_1(S::StateLHA, constants::Dict{Symbol,Float64}, xn::Vector{Int}) =
+ cc_aut_F_l3Fl2F_1(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(getfield(S, :time) >= constants[:t4])
- us_aut_F_l3Fl2F_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}) =
+ us_aut_F_l3Fl2F_1!(S::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int}, p::Vector{Float64}) =
(S.loc = :l2F)
edge1 = Edge([nothing], cc_aut_F_l3Fl2F_1, us_aut_F_l3Fl2F_1!)
diff --git a/core/lha.jl b/core/lha.jl
index 8bf648b..c28ad56 100644
--- a/core/lha.jl
+++ b/core/lha.jl
@@ -105,12 +105,13 @@ end
function _find_edge_candidates!(edge_candidates::Vector{Edge},
edges_from_current_loc::Dict{Location,Vector{Edge}},
Λ::Dict{Location,Function},
- Snplus1::StateLHA, constants::Dict{Symbol,Float64}, x::Vector{Int},
+ Snplus1::StateLHA, constants::Dict{Symbol,Float64},
+ x::Vector{Int}, p::Vector{Float64},
only_asynchronous::Bool)
nbr_candidates = 0
for target_loc in keys(edges_from_current_loc)
for edge in edges_from_current_loc[target_loc]
- if Λ[target_loc](x) && getfield(edge, :check_constraints)(Snplus1, constants, x)
+ if Λ[target_loc](x) && getfield(edge, :check_constraints)(Snplus1, constants, x, p)
if edge.transitions[1] == nothing
_push_edge!(edge_candidates, edge, nbr_candidates)
nbr_candidates += 1
@@ -150,7 +151,7 @@ end
function next_state!(Snplus1::StateLHA, A::LHA,
xnplus1::Vector{Int}, tnplus1::Float64, tr_nplus1::Transition,
- Sn::StateLHA, xn::Vector{Int}; verbose::Bool = false)
+ Sn::StateLHA, xn::Vector{Int}, p::Vector{Float64}; verbose::Bool = false)
# En fait d'apres observation de Cosmos, après qu'on ait lu la transition on devrait stop.
edge_candidates = Vector{Edge}(undef, 2)
first_round::Bool = true
@@ -172,14 +173,14 @@ function next_state!(Snplus1::StateLHA, A::LHA,
current_loc = getfield(Snplus1, :loc)
edges_from_current_loc = getfield(A, :map_edges)[current_loc]
# Save all edges that satisfies transition predicate (asynchronous ones)
- nbr_candidates = _find_edge_candidates!(edge_candidates, edges_from_current_loc, getfield(A, :Λ), Snplus1, constants, xn, true)
+ nbr_candidates = _find_edge_candidates!(edge_candidates, edges_from_current_loc, getfield(A, :Λ), Snplus1, constants, xn, p, true)
# Search the one we must chose, here the event is nothing because
# we're not processing yet the next event
ind_edge, detected_event = _get_edge_index(edge_candidates, nbr_candidates, detected_event, nothing)
# Update the state with the chosen one (if it exists)
# Should be xn here
if ind_edge > 0
- getfield(edge_candidates[ind_edge], :update_state!)(Snplus1, constants, xn)
+ getfield(edge_candidates[ind_edge], :update_state!)(Snplus1, constants, xn, p)
end
first_round = false
if verbose
@@ -200,7 +201,7 @@ function next_state!(Snplus1::StateLHA, A::LHA,
@show tnplus1, tr_nplus1, xnplus1
@show edge_candidates
for edge in edge_candidates
- @show getfield(edge, :check_constraints)(Snplus1, constants, x)
+ @show getfield(edge, :check_constraints)(Snplus1, constants, x, p)
end
error("Unpredicted behavior automaton")
end
@@ -227,7 +228,7 @@ function next_state!(Snplus1::StateLHA, A::LHA,
current_loc = getfield(Snplus1, :loc)
edges_from_current_loc = getfield(A, :map_edges)[current_loc]
# Save all edges that satisfies transition predicate (synchronous ones)
- nbr_candidates = _find_edge_candidates!(edge_candidates, edges_from_current_loc, getfield(A, :Λ), Snplus1, constants, xnplus1, false)
+ nbr_candidates = _find_edge_candidates!(edge_candidates, edges_from_current_loc, getfield(A, :Λ), Snplus1, constants, xnplus1, p, false)
# Search the one we must chose
ind_edge, detected_event = _get_edge_index(edge_candidates, nbr_candidates, detected_event, tr_nplus1)
# Update the state with the chosen one (if it exists)
@@ -237,7 +238,7 @@ function next_state!(Snplus1::StateLHA, A::LHA,
@show ind_edge, detected_event, nbr_candidates
end
if ind_edge > 0
- getfield(edge_candidates[ind_edge], :update_state!)(Snplus1, constants, xnplus1)
+ getfield(edge_candidates[ind_edge], :update_state!)(Snplus1, constants, xnplus1, p)
end
first_round = false
if verbose
@@ -256,7 +257,7 @@ function next_state!(Snplus1::StateLHA, A::LHA,
@show tnplus1, tr_nplus1, xnplus1
@show edge_candidates
for edge in edge_candidates
- @show getfield(edge, :check_constraints)(Snplus1, constants, x)
+ @show getfield(edge, :check_constraints)(Snplus1, constants, x, p)
end
error("Unpredicted behavior automaton")
end
diff --git a/core/model.jl b/core/model.jl
index 431e528..c636424 100644
--- a/core/model.jl
+++ b/core/model.jl
@@ -166,7 +166,7 @@ function simulate(product::SynchronizedModel; p::Union{Nothing,AbstractVector{Fl
_finish_bounded_trajectory!(values, times, transitions, time_bound)
end
if isabsorbing && !isacceptedLHA
- next_state!(Snplus1, A, xn, time_bound, nothing, Sn, xn; verbose = verbose)
+ next_state!(Snplus1, A, xn, time_bound, nothing, Sn, xn, p_sim; verbose = verbose)
copyto!(Sn, Snplus1)
end
return SynchronizedTrajectory(Sn, product, values, times, transitions)
@@ -180,7 +180,7 @@ function simulate(product::SynchronizedModel; p::Union{Nothing,AbstractVector{Fl
break
end
n += 1
- next_state!(Snplus1, A, vec_x, l_t[1], l_tr[1], Sn, xn; verbose = verbose)
+ next_state!(Snplus1, A, vec_x, l_t[1], l_tr[1], Sn, xn, p_sim; verbose = verbose)
copyto!(xn, vec_x)
tn = l_t[1]
tr_n = l_tr[1]
@@ -199,7 +199,7 @@ function simulate(product::SynchronizedModel; p::Union{Nothing,AbstractVector{Fl
_finish_bounded_trajectory!(values, times, transitions, time_bound)
end
if isabsorbing && !isacceptedLHA
- next_state!(Snplus1, A, xn, time_bound, nothing, Sn, xn; verbose = verbose)
+ next_state!(Snplus1, A, xn, time_bound, nothing, Sn, xn, p_sim; verbose = verbose)
copyto!(Sn, Snplus1)
end
return SynchronizedTrajectory(Sn, product, values, times, transitions)
@@ -223,7 +223,7 @@ function simulate(product::SynchronizedModel; p::Union{Nothing,AbstractVector{Fl
i -= 1
break
end
- next_state!(Snplus1, A, vec_x, l_t[1], l_tr[1], Sn, xn; verbose = verbose)
+ next_state!(Snplus1, A, vec_x, l_t[1], l_tr[1], Sn, xn, p_sim; verbose = verbose)
copyto!(xn, vec_x)
tn = l_t[1]
tr_n = l_tr[1]
@@ -249,7 +249,7 @@ function simulate(product::SynchronizedModel; p::Union{Nothing,AbstractVector{Fl
_finish_bounded_trajectory!(values, times, transitions, time_bound)
end
if isabsorbing && !isacceptedLHA
- next_state!(Snplus1, A, xn, time_bound, nothing, Sn, xn; verbose = verbose)
+ next_state!(Snplus1, A, xn, time_bound, nothing, Sn, xn, p_sim; verbose = verbose)
copyto!(Sn, Snplus1)
end
return SynchronizedTrajectory(Sn, product, values, times, transitions)
@@ -286,7 +286,7 @@ function volatile_simulate(product::SynchronizedModel;
# If x0 is absorbing
if isabsorbing || isacceptedLHA
if !isacceptedLHA
- next_state!(Snplus1, A, xn, time_bound, nothing, Sn, xn; verbose = verbose)
+ next_state!(Snplus1, A, xn, time_bound, nothing, Sn, xn, p_sim; verbose = verbose)
copyto!(Sn, Snplus1)
end
return Sn
@@ -302,7 +302,7 @@ function volatile_simulate(product::SynchronizedModel;
isabsorbing = true
break
end
- next_state!(Snplus1, A, vec_x, l_t[1], l_tr[1], Sn, xn; verbose = verbose)
+ next_state!(Snplus1, A, vec_x, l_t[1], l_tr[1], Sn, xn, p_sim; verbose = verbose)
copyto!(xn, vec_x)
tn = l_t[1]
tr_n = l_tr[1]
@@ -311,7 +311,7 @@ function volatile_simulate(product::SynchronizedModel;
n += 1
end
if isabsorbing && !isacceptedLHA
- next_state!(Snplus1, A, xn, time_bound, nothing, Sn, xn; verbose = verbose)
+ next_state!(Snplus1, A, xn, time_bound, nothing, Sn, xn, p_sim; verbose = verbose)
copyto!(Sn, Snplus1)
end
return Sn
diff --git a/tests/run_unit.jl b/tests/run_unit.jl
index 06e4f43..55d5bf3 100644
--- a/tests/run_unit.jl
+++ b/tests/run_unit.jl
@@ -14,6 +14,7 @@ using Test
@test include("unit/density_pm.jl")
@test include("unit/dist_lp.jl")
@test include("unit/dist_lp_var.jl")
+ @test include("unit/distributed_simulation.jl")
@test include("unit/draw_pm.jl")
@test include("unit/getindex_access_trajectory.jl")
@@ -27,7 +28,6 @@ using Test
@test include("unit/long_sim_er.jl")
@test include("unit/macro_network_model.jl")
- @test include("unit/macro_network_model_distributed.jl")
@test include("unit/model_prior.jl")
@test include("unit/models_exps_er_1d.jl")
@test include("unit/models_exps_er_2d.jl")
diff --git a/tests/unit/macro_network_model_distributed.jl b/tests/unit/distributed_simulation.jl
similarity index 82%
rename from tests/unit/macro_network_model_distributed.jl
rename to tests/unit/distributed_simulation.jl
index d02d440..06db472 100644
--- a/tests/unit/macro_network_model_distributed.jl
+++ b/tests/unit/distributed_simulation.jl
@@ -23,6 +23,7 @@ set_param!(model_SIR, [0.012, 0.05])
@everywhere simulate($model_SIR)
sym_f! = Symbol(model_SIR.f!)
sym_isabs = Symbol(model_SIR.isabsorbing)
+# Check the creation of model has defined the necessary functions on all workers
test_all = test_all && fetch(@spawnat 2 isdefined(Main, sym_f!)) && fetch(@spawnat 2 isdefined(Main, sym_isabs))
test_all = test_all && fetch(@spawnat 3 isdefined(Main, sym_f!)) && fetch(@spawnat 3 isdefined(Main, sym_isabs))
# Check the model object is not defined on workers
@@ -55,6 +56,17 @@ test_all = test_all && fetch(@spawnat 3 isdefined(Main, sym_f!)) && fetch(@spawn
test_all = test_all && !fetch(@spawnat 2 isdefined(Main, :ER)) && !fetch(@spawnat 2 isdefined(Main, :ER))
test_all = test_all && !fetch(@spawnat 3 isdefined(Main, :ER)) && !fetch(@spawnat 3 isdefined(Main, :ER))
+# Synchronized model
+load_model("ER")
+observe_all!(ER)
+load_automaton("automaton_G")
+x1, x2, t1, t2 = 50.0, 100.0, 0.0, 0.8
+A_G_R5 = create_automaton_G(ER, x1, x2, t1, t2, :E)
+sync_ER = ER * A_G_R5
+@everywhere simulate($sync_ER)
+test_all = test_all && !fetch(@spawnat 2 isdefined(Main, :sync_ER)) && !fetch(@spawnat 2 isdefined(Main, :sync_ER))
+test_all = test_all && !fetch(@spawnat 3 isdefined(Main, :sync_ER)) && !fetch(@spawnat 3 isdefined(Main, :sync_ER))
+
rmprocs(2)
return test_all
--
GitLab