Many changes : new orchestrator attempt, many more fixes. Multiple timesteps handled, but bad meshing with refvalue/refvectors cause overwrites if we use multiscale mappings, and unexplored issues if we avoid them. Also, many-node to many-node issues if multiscale mapping. Some TODO comments, structs, commented out code and notes are outdated. More exploration and cleanup required, but current state is much more interesting than the previous commit.

Author: Samuel-amap

src/Abstract_model_structs.jl

@@ -50,18 +50,16 @@ end
 
 """
     timestep_valid(tsr::TimestepRange)
-
-Checks whether a TimestepRange
 """
 timestep_valid(tsr::TimestepRange) = tsr.lower_bound <= tsr.upper_bound
 
-function model_timestep_range_compatible_with_timestep(tsr::TimestepRange, p::Period) 
+function is_timestep_in_range(tsr::TimestepRange, p::Period) 
     if !timestep_valid(tsr)
         return false
     end
 
     # 0 means any timestep is valid, no timestep constraints
-    if tsr.upper_bound == Seconds(0)
+    if tsr.upper_bound == Second(0)
         return true
     end
 

src/PlantSimEngine.jl

@@ -57,6 +57,9 @@ include("component_models/get_status.jl")
 # Transform into a dataframe:
 include("dataframe.jl")
 
+# Timesteps. : 
+include("timestep/timestep_mapping.jl")
+
 # Computing model dependencies:
 include("dependencies/soft_dependencies.jl")
 include("dependencies/hard_dependencies.jl")
@@ -66,9 +69,6 @@ include("dependencies/printing.jl")
 include("dependencies/dependencies.jl")
 include("dependencies/get_model_in_dependency_graph.jl")
 
-# Timesteps. : 
-include("timestep/timestep_mapping.jl")
-
 # MTG compatibility:
 include("mtg/GraphSimulation.jl")
 include("mtg/mapping/getters.jl")
@@ -107,7 +107,7 @@ include("examples_import.jl")
 export PreviousTimeStep
 export AbstractModel
 export ModelList, MultiScaleModel
-export Orchestrator
+export Orchestrator, Orchestrator2, TimestepRange, Var_to, Var_from, ModelTimestepMapping
 export RMSE, NRMSE, EF, dr
 export Status, TimeStepTable, status
 export init_status!

src/dependencies/dependencies.jl

@@ -100,16 +100,16 @@ function dep(m::NamedTuple, nsteps=1; verbose::Bool=true)
     dep(nsteps; verbose=verbose, m...)
 end
 
-function dep(mapping::Dict{String,T}; verbose::Bool=true) where {T}
+function dep(mapping::Dict{String,T}; verbose::Bool=true, orchestrator=Orchestrator2()) where {T}
     # First step, get the hard-dependency graph and create SoftDependencyNodes for each hard-dependency root. In other word, we want 
     # only the nodes that are not hard-dependency of other nodes. These nodes are taken as roots for the soft-dependency graph because they
     # are independant.
-    soft_dep_graphs_roots, hard_dep_dict = hard_dependencies(mapping; verbose=verbose)
+    soft_dep_graphs_roots, hard_dep_dict = hard_dependencies(mapping; verbose=verbose, orchestrator=Orchestrator2())
     # Second step, compute the soft-dependency graph between SoftDependencyNodes computed in the first step. To do so, we search the 
     # inputs of each process into the outputs of the other processes, at the same scale, but also between scales. Then we keep only the
     # nodes that have no soft-dependencies, and we set them as root nodes of the soft-dependency graph. The other nodes are set as children
     # of the nodes that they depend on.
-    dep_graph = soft_dependencies_multiscale(soft_dep_graphs_roots, mapping, hard_dep_dict)
+    dep_graph = soft_dependencies_multiscale(soft_dep_graphs_roots, mapping, hard_dep_dict, orchestrator=orchestrator)
     # During the building of the soft-dependency graph, we identified the inputs and outputs of each dependency node, 
     # and also defined **inputs** as MappedVar if they are multiscale, i.e. if they take their values from another scale.
     # What we are missing is that we need to also define **outputs** as multiscale if they are needed by another scale.

src/dependencies/dependency_graph.jl

@@ -12,6 +12,16 @@ mutable struct HardDependencyNode{T} <: AbstractDependencyNode
     children::Vector{HardDependencyNode}
 end
 
+mutable struct TimestepMapping
+    variable_from::Symbol
+    variable_to::Symbol
+    node_to # SoftDependencyNode causes a circular reference # TODO could it be a harddependencynode... ?
+    mapping_function::Function
+    mapping_data_template
+    mapping_data::Dict{Int, Any} # TODO Any's type is the variable's type, also, is Int good here ? Prob not
+end
+
+# can hard dependency nodes also handle timestep mapped variables... ?
 mutable struct SoftDependencyNode{T} <: AbstractDependencyNode
     value::T
     process::Symbol
@@ -23,6 +33,8 @@ mutable struct SoftDependencyNode{T} <: AbstractDependencyNode
     parent_vars::Union{Nothing,NamedTuple}
     children::Vector{SoftDependencyNode}
     simulation_id::Vector{Int} # id of the simulation
+    timestep::Period
+    timestep_mapping_data::Union{Nothing, Vector{TimestepMapping}} # TODO : this approach might not play too well with parallelisation over MTG nodes
 end
 
 # Add methods to check if a node is parallelizable:

src/dependencies/hard_dependencies.jl

@@ -112,7 +112,7 @@ end
 
 
 # When we use a mapping (multiscale), we return the set of soft-dependencies (we put the hard-dependencies as their children):
-function hard_dependencies(mapping::Dict{String,T}; verbose::Bool=true) where {T}
+function hard_dependencies(mapping::Dict{String,T}; verbose::Bool=true, orchestrator::Orchestrator2=Orchestrator2()) where {T}
     full_vars_mapping = Dict(first(mod) => Dict(get_mapped_variables(last(mod))) for mod in mapping)
     soft_dep_graphs = Dict{String,Any}()
     not_found = Dict{Symbol,DataType}()
@@ -226,6 +226,42 @@ function hard_dependencies(mapping::Dict{String,T}; verbose::Bool=true) where {T
         end
     end
 
+#=
+ # TODO check whether this is a bit late in the game
+                # maybe the timestep mapping should be done before we enter this function
+                if length(orchestrator.non_default_timestep_data_per_scale) > 0
+                    if haskey(orchestrator.non_default_timestep_data_per_scale, symbol(node))
+                        tvm = orchestrator.non_default_timestep_data_per_scale[symbol(node)].timestep_variable_mapping
+                        if haskey(twm, var)
+
+                        end
+                    end
+                end
+                error("Variable `$(var)` is not computed by any model, not mapped from a different scale or timestep not initialised by the user in the status, and not found in the MTG at scale $(symbol(node)) (checked for MTG node $(node_id(node))).")
+=#
+
+
+    # Once multiscale mapping has been dealt with, check if any variable has a timestep mapping
+    # Which will add potential new dependencies
+    #=if !isempty(orchestrator.non_default_timestep_data_per_scale)
+        # TODO the user can get away with not declaring the model, only the scale if necessary
+        # a prepass that recomputes everything might simplify code here and make the simulation require less variable digging
+        for (scale, tsh) in non_default_timestep_data_per_scale
+            # TODO find which model the variable is pulled from
+            # TODO check the variable exists
+            for (model, timestep) in tsh.model_timesteps
+            # TODO check the timestep is within the model's accepted timestep range
+            # TODO recover the right variables
+            end
+
+            for (variable, tvm) in tsh.timestep_variable_mapping
+                # TODO check the variable isn't already mapped
+                # If it is, ensure there are no name conflicts 
+                # and the model of the variable it is taken from has the expected timestep
+                # If it isn't, create a new link
+            end
+        end
+    end=#
     for (organ, model) in mapping
         soft_dep_graph = Dict(
             process_ => SoftDependencyNode(
@@ -238,7 +274,9 @@ function hard_dependencies(mapping::Dict{String,T}; verbose::Bool=true) where {T
                 nothing,
                 nothing,
                 SoftDependencyNode[],
-                [0] # Vector of zeros of length = number of time-steps
+                [0], # Vector of zeros of length = number of time-steps
+                orchestrator.default_timestep,
+                nothing
             )
             for (process_, soft_dep_vars) in hard_deps[organ].roots # proc_ = :carbon_assimilation ; soft_dep_vars = hard_deps.roots[proc_]
         )

src/dependencies/soft_dependencies.jl

@@ -70,7 +70,9 @@ function soft_dependencies(d::DependencyGraph{Dict{Symbol,HardDependencyNode}},
             nothing,
             nothing,
             SoftDependencyNode[],
-            fill(0, nsteps)
+            fill(0, nsteps),
+            Day(1), # TODO
+            nothing
         )
         for (process_, soft_dep_vars) in d.roots
     )
@@ -138,8 +140,18 @@ function soft_dependencies(d::DependencyGraph{Dict{Symbol,HardDependencyNode}},
     return DependencyGraph(independant_process_root, d.not_found)
 end
 
+function timestep_mapped_variables(orchestrator)
+
+#=struct SimulationTimestepHandler#{W,V}
+    model_timesteps::Dict{Any, Period} # where {W <: AbstractModel} # if a model isn't in there, then it follows the default, todo check if the given timestep respects the model's range
+    timestep_variable_mapping::Dict{Any, TimestepMapper} #where {V}
+end
+    non_default_timestep_data_per_scale::Dict{String, SimulationTimestepHandler}
+=#
+end
+
 # For multiscale mapping:
-function soft_dependencies_multiscale(soft_dep_graphs_roots::DependencyGraph{Dict{String,Any}}, mapping::Dict{String,A}, hard_dep_dict::Dict{Pair{Symbol,String},HardDependencyNode}) where {A<:Any}
+function soft_dependencies_multiscale(soft_dep_graphs_roots::DependencyGraph{Dict{String,Any}}, mapping::Dict{String,A}, hard_dep_dict::Dict{Pair{Symbol,String},HardDependencyNode}; orchestrator::Orchestrator2=Orchestrator2()) where {A<:Any}
     mapped_vars = mapped_variables(mapping, soft_dep_graphs_roots, verbose=false)
     rev_mapping = reverse_mapping(mapped_vars, all=false)
 
@@ -324,10 +336,93 @@ function soft_dependencies_multiscale(soft_dep_graphs_roots::DependencyGraph{Dic
         end
     end
 
-    return DependencyGraph(independant_process_root, soft_dep_graphs_roots.not_found)
+    dep_graph = DependencyGraph(independant_process_root, soft_dep_graphs_roots.not_found)
+    traverse_dependency_graph!(x ->  set_non_default_timestep_in_node(x, orchestrator), dep_graph, visit_hard_dep=false)
+    traverse_dependency_graph!(x -> add_timestep_data_to_node(x, orchestrator), dep_graph, visit_hard_dep=false)
+
+    return dep_graph
+end
+
+# # set the timestep for everyone first, else we might not use the correct timestep when looking at the parents later
+function set_non_default_timestep_in_node(soft_dependency_node, orchestrator::Orchestrator2)
+    for mtsm in orchestrator.non_default_timestep_mapping
+        if mtsm.scale == soft_dependency_node.scale && (mtsm.model) == typeof(model_(soft_dependency_node.value))
+            soft_dependency_node.timestep = mtsm.timestep
+        end
+    end
+end
+
+function add_timestep_data_to_node(soft_dependency_node, orchestrator::Orchestrator2)
+
+    # now we can create the mapping
+    for mtsm in orchestrator.non_default_timestep_mapping
+        if mtsm.scale == soft_dependency_node.scale && (mtsm.model) == typeof(model_(soft_dependency_node.value))
+            for (var_to, var_from) in mtsm.var_to_var        
+                if !isnothing(soft_dependency_node.parent)
+                    parent = nothing
+                    variable_mapping = nothing
+                    for parent_node in soft_dependency_node.parent
+                        if typeof(parent_node.value) == var_from.model && parent_node.scale == var_from.scale
+                            parent = parent_node                                            
+                            variable_mapping = create_timestep_mapping(soft_dependency_node, parent, var_to, var_from)
+                            break
+                        end
+                    end
+                    if isnothing(parent)
+                        #error
+                    end
+                    if isnothing(parent.timestep_mapping_data)
+                        parent.timestep_mapping_data = Vector{TimestepMapping}()
+                    end
+                    push!(parent.timestep_mapping_data, variable_mapping)
+                else
+                    # Error
+                end
+            end                
+        end
+    end
 end
 
+# TODO this is incorrect, there may be multiple variables mapped between the two nodes
+function create_timestep_mapping(node::SoftDependencyNode, parent::SoftDependencyNode, var_to::Var_to, var_from::Var_from)
+    
+    @assert parent.timestep != 0 "Error : node timestep internally set to 0"
+
+    timestep_ratio = node.timestep / parent.timestep
+
+    # Keeping things simple for now, only integers allowed
+    @assert timestep_ratio == trunc(timestep_ratio) "Error : non-integer timestep ratio"
+
+    # TODO ensure type compatibility between var_to and var_from
+    # Simplification probably possible by doing the check earlier
+
+    # TODO test previoustimestep
+    var_type = DataType
+    
+    for (symbol, var_dump) in node.inputs
+        for var in var_dump
+            if isa(var, MappedVar)
+                # check the source variable, because the sink one might be a vector...?
+                # TODO multinode mapping
+                if var.source_variable  == var_from.name
+                    # This should be a fixed size array, ideally
+                    var_type = eltype(mapped_default(var))
+                    break
+                end
+            else
+                if var.symbol == var_from.name
+                    @assert "untested"
+                    var_type = eltype(mapped_default(var))
+                    break
+                end
+            end
+        end
+    end
 
+    mapping_data_template = Vector{var_type}(undef, convert(Int64, timestep_ratio))
+    # TODO : type shouldn't be Any but Vector{var_type}
+    return TimestepMapping(var_from.name, var_to.name, node, var_from.mapping_function, mapping_data_template, Dict{MultiScaleTreeGraph.NodeMTG, Any}())
+end
 """
     drop_process(proc_vars, process)
 

src/mtg/GraphSimulation.jl

@@ -25,12 +25,14 @@ struct GraphSimulation{T,S,U,O,V}
     var_need_init::Dict{String,V}
     dependency_graph::DependencyGraph
     models::Dict{String,U}
-    orchestrator::Orchestrator
     outputs::Dict{String,O}
+    outputs_index::Dict{String, Int}
+    orchestrator::Orchestrator2
+
 end
 
-function GraphSimulation(graph, mapping; nsteps=1, outputs=nothing, type_promotion=nothing, check=true, verbose=false, orchestrator=Orchestrator())
-    GraphSimulation(init_simulation(graph, mapping; nsteps=nsteps, outputs=outputs, type_promotion=type_promotion, check=check, verbose=verbose)..., orchestrator)
+function GraphSimulation(graph, mapping; nsteps=1, outputs=nothing, type_promotion=nothing, check=true, verbose=false, orchestrator=Orchestrator2())
+    GraphSimulation(init_simulation(graph, mapping; nsteps=nsteps, outputs=outputs, type_promotion=type_promotion, check=check, verbose=verbose, orchestrator=orchestrator)...)
 end
 
 dep(g::GraphSimulation) = g.dependency_graph

src/mtg/add_organ.jl

@@ -33,5 +33,10 @@ function add_organ!(node::MultiScaleTreeGraph.Node, sim_object, link, symbol, sc
     new_node = MultiScaleTreeGraph.Node(id, node, MultiScaleTreeGraph.NodeMTG(link, symbol, index, scale), attributes)
     st = init_node_status!(new_node, sim_object.statuses, sim_object.status_templates, sim_object.reverse_multiscale_mapping, sim_object.var_need_init, check=check)
 
+    # TODO add the node to the timestep mappings
+    # TODO initialise the MTG nodes in the timestep mappings
+    # NOTE : this isn't ideal, as it constrains the add_organ! function usage
+    init_timestep_mapping_data(new_node, sim_object.dependency_graph)
+
     return st
 end