Merge pull request #149 from VirtualPlantLab/add-dependency-graph-into-ModelList

Add dependency graph into model list

Author: VEZY

src/PlantSimEngine.jl

@@ -43,6 +43,9 @@ include("component_models/RefVector.jl")
 # Simulation table (time-step table, from PlantMeteo):
 include("component_models/TimeStepTable.jl")
 
+# Declaring the dependency graph
+include("dependencies/dependency_graph.jl")
+
 # List of models:
 include("component_models/ModelList.jl")
 include("mtg/MultiScaleModel.jl")
@@ -53,8 +56,7 @@ include("component_models/get_status.jl")
 # Transform into a dataframe:
 include("dataframe.jl")
 
-# Model dependencies:
-include("dependencies/dependency_graph.jl")
+# Computing model dependencies:
 include("dependencies/soft_dependencies.jl")
 include("dependencies/hard_dependencies.jl")
 include("dependencies/traversal.jl")

src/component_models/ModelList.jl

@@ -147,7 +147,8 @@ julia> [typeof(models[i][1]) for i in keys(status(models))]
 struct ModelList{M<:NamedTuple,S}
     models::M
     status::S
-    type_promotion::Union{Nothing, Dict}
+    type_promotion::Union{Nothing,Dict}
+    dependency_graph::DependencyGraph
 end
 
 #=function ModelList(models::M, status::Status) where {M<:NamedTuple{names,T} where {names,T<:NTuple{N,<:AbstractModel} where {N}}}
@@ -160,7 +161,6 @@ function ModelList(
     status=nothing,
     type_promotion::Union{Nothing,Dict}=nothing,
     variables_check::Bool=true,
-    nsteps=nothing,
     kwargs...
 )
 
@@ -187,10 +187,13 @@ function ModelList(
     ts_kwargs = homogeneous_ts_kwargs(status)
     ts_kwargs = add_model_vars(ts_kwargs, mods, type_promotion)
 
+
+
     model_list = ModelList(
         mods,
         ts_kwargs,
-        type_promotion
+        type_promotion,
+        dep(; verbose=true, mods...)
     )
     variables_check && !is_initialized(model_list)
 
@@ -219,8 +222,8 @@ function add_model_vars(x, models, type_promotion)
 
     # If the user gave a status, we check if all the variables are already initialized:
     vars_in_x = status_keys(x)
-    status_x = 
-    all([k in vars_in_x for k in keys(ref_vars)]) && return isa(x, Status) ? x : Status(x)  # If so, we return the input
+    status_x =
+        all([k in vars_in_x for k in keys(ref_vars)]) && return isa(x, Status) ? x : Status(x)  # If so, we return the input
 
     # Else, we add the variables by making a new object (carefull, this is a copy so it takes more time):
 
@@ -229,15 +232,15 @@ function add_model_vars(x, models, type_promotion)
 
     # If the user gave an empty status, we initialize all variables to their default values:
     if x === nothing
-       return Status(ref_vars)
+        return Status(ref_vars)
     end
-    
+
     if Tables.istable(x)
         # This situation only occurs if the user provided a table instead of a status
         # Meaning we have a status of vector values, all initialized up to a certain point
         # Unsure this is desirable, as that means run! does nothing or overwrites everything
         # Anyway, we wish to create a NamedTuple() of Vectors here
-        x_full = (;zip(propertynames(x), Tables.columns(x))...)
+        x_full = (; zip(propertynames(x), Tables.columns(x))...)
         x_full = merge(ref_vars, x_full)
 
     else
@@ -286,7 +289,7 @@ PlantSimEngine.homogeneous_ts_kwargs((Tₗ=[25.0, 26.0], aPPFD=1000.0))
 function homogeneous_ts_kwargs(kwargs::NamedTuple{N,T}) where {N,T}
     length(kwargs) == 0 && return kwargs
     vars_vals = collect(Any, values(kwargs))
- 
+
     vars_array = NamedTuple{keys(kwargs)}(j for j in vars_vals)
 
     return vars_array
@@ -325,15 +328,17 @@ function Base.copy(m::T) where {T<:ModelList}
     ModelList(
         m.models,
         deepcopy(m.status),
-        deepcopy(m.type_promotion)
+        deepcopy(m.type_promotion),
+        deepcopy(m.dependency_graph)
     )
 end
 
 function Base.copy(m::T, status) where {T<:ModelList}
     ModelList(
         m.models,
         status,
-        deepcopy(m.type_promotion)
+        deepcopy(m.type_promotion),
+        deepcopy(m.dependency_graph)
     )
 end
 
@@ -465,7 +470,7 @@ function convert_vars!(mapped_vars::Dict{String,Dict{Symbol,Any}}, type_promotio
 end
 
 function Base.show(io::IO, ::MIME"text/plain", t::ModelList)
-    print(io, dep(t, verbose=false))
+    print(io, dep(t))
     print(io, status(t))
 end
 

src/dependencies/dependencies.jl

@@ -1,8 +1,9 @@
 dep(::T, nsteps=1) where {T<:AbstractModel} = NamedTuple()
 
 """
-    dep(m::ModelList, nsteps=1; verbose::Bool=true)
+    dep(m::ModelList)
     dep(mapping::Dict{String,T}; verbose=true)
+    dep!(m::ModelList, nsteps=1)
 
 Get the model dependency graph given a ModelList or a multiscale model mapping. If one graph is returned, 
 then all models are coupled. If several graphs are returned, then only the models inside each graph are coupled, and
@@ -34,7 +35,12 @@ to other scales if needed. Then we transform all these nodes into soft dependenc
 Then we traverse all these and we set nodes that need outputs from other nodes as inputs as children/parents.
 If a node has no dependency, it is set as a root node and pushed into a new Dict (independant_process_root). This Dict is the returned dependency graph. And 
 it presents root nodes as independent starting points for the sub-graphs, which are the models that are coupled together. We can then traverse each of 
-these graphs independently to retrieve the models that are coupled together, in the right order of execution.
+these graphs independently to r
+
+# Notes
+
+The difference between `dep(m::ModelList)` and `dep!(m::ModelList, nsteps)` is that the first one returns the dependency graph found in the model list, while the 
+second one returns the dependency graph with the specified number of steps, modifying the simulation IDs of each node in the graph (`simulation_id=fill(0, nsteps)`).
 
 # Examples
 
@@ -75,8 +81,18 @@ function dep(nsteps=1; verbose::Bool=true, vars...)
     return deps
 end
 
-function dep(m::ModelList, nsteps=1; verbose::Bool=true)
-    dep(nsteps; verbose=verbose, m.models...)
+function dep(m::ModelList)
+    m.dependency_graph
+end
+
+function dep!(m::ModelList, nsteps=1)
+    traverse_dependency_graph!(m.dependency_graph; visit_hard_dep=false) do node
+        if length(node.simulation_id) != nsteps
+            node.simulation_id = fill(0, nsteps)
+        end
+    end
+
+    return m.dependency_graph
 end
 
 

src/processes/model_initialisation.jl

@@ -65,8 +65,8 @@ mapping = Dict(
 to_initialize(mapping)
 ```
 """
-function to_initialize(m::ModelList; verbose::Bool=true)
-    needed_variables = to_initialize(dep(m; verbose=verbose))
+function to_initialize(m::ModelList)
+    needed_variables = to_initialize(dep(m))
     to_init = Dict{Symbol,Tuple}()
     for (process, vars) in needed_variables
         # default_values = needed_variables[:process1]
@@ -245,7 +245,7 @@ function init_variables(model::T; verbose::Bool=true) where {T<:AbstractModel}
 end
 
 function init_variables(m::ModelList; verbose::Bool=true)
-    init_variables(dep(m; verbose=verbose))
+    init_variables(dep(m))
 end
 
 function init_variables(m::DependencyGraph)
@@ -300,7 +300,7 @@ is_initialized(models)
 ```
 """
 function is_initialized(m::T; verbose=true) where {T<:ModelList}
-    var_names = to_initialize(m; verbose=verbose)
+    var_names = to_initialize(m)
 
     if any([length(to_init) > 0 for (process, to_init) in pairs(var_names)])
         verbose && @info "Some variables must be initialized before simulation: $var_names (see `to_initialize()`)" maxlog = 1

src/run.jl

@@ -187,7 +187,7 @@ function run!(
     meteo_adjusted = adjust_weather_timesteps_to_given_length(get_status_vector_max_length(object.status), meteo)
     nsteps = get_nsteps(meteo_adjusted)
 
-    dep_graph = dep(object, nsteps)
+    dep_graph = dep!(object, nsteps)
 
     if check
         # Check if the meteo data and the status have the same length (or length 1)

test/test-ModelList.jl

@@ -18,7 +18,6 @@
     leaf = ModelList(
         process1=Process1Model(1.0),
         process2=Process2Model(),
-        nsteps=3
     )
 
     @test length(status(leaf)) == 5
@@ -81,7 +80,6 @@ end;
         process1=Process1Model(1.0),
         process2=Process2Model(),
         status=(var1=15.0,),
-        nsteps=3
     )
 
     @test length(status(leaf)) == 5
@@ -123,8 +121,7 @@ end;
     inits = init_variables(leaf)
     sorted_vars = sort([keys(inits.process3)...])
 
-    @test [getfield(inits.process3, i) for i in sorted_vars] ==
-          fill(-Inf, 3)
+    @test [getfield(inits.process3, i) for i in sorted_vars] == fill(-Inf, 3)
 end;
 
 @testset "Copy a ModelList" begin