Simple single-variable hacky ad hoc connector test ; as a model it's awkward

Author: Samuel-amap

src/Abstract_model_structs.jl

@@ -25,4 +25,47 @@ model_(m::AbstractModel) = m
 get_models(m::AbstractModel) = [model_(m)] # Get the models of an AbstractModel
 # Note: it is returning a vector of models, because in this case the user provided a single model instead of a vector of.
 get_status(m::AbstractModel) = nothing
-get_mapped_variables(m::AbstractModel) = Pair{Symbol,String}[]
+get_mapped_variables(m::AbstractModel) = Pair{Symbol,String}[]
+
+
+#using Dates
+struct TimestepRange 
+    lower_bound::Period
+    upper_bound::Period
+end
+
+# Default, no specified range, meaning the model either doesn't depend on time or uses the simulation's default (eg smallest) timestep
+TimestepRange() = TimestepRange(Second(0), Second(0))
+# Only a single timestep type possible
+TimestepRange(p::Period) = TimestepRange(p, p)
+
+"""
+    timestep_range_(tsr::TimestepRange)
+
+Return the model's valid range for timesteps (which corresponds to the simulation base timestep in the default case).
+"""
+function timestep_range_(model::AbstractModel)
+    return TimestepRange()
+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) 
+    if !timestep_valid(tsr)
+        return false
+    end
+
+    # 0 means any timestep is valid, no timestep constraints
+    if tsr.upper_bound == Seconds(0)
+        return true
+    end
+
+    return p >= tsr.lower_bound && p <= tsr.lower_bound
+end
+
+# TODO should i set all timestep ranges to default and hope the modeler gets it right or should i force them to write something ?

src/mtg/GraphSimulation.jl

@@ -16,7 +16,7 @@ A type that holds all information for a simulation over a graph.
 - `models`: a dictionary of models
 - `outputs`: a dictionary of outputs
 """
-struct GraphSimulation{T,S,U,O,V}
+struct GraphSimulation{T,S,U,O,V,W}
     graph::T
     statuses::S
     status_templates::Dict{String,Dict{Symbol,Any}}
@@ -26,10 +26,12 @@ struct GraphSimulation{T,S,U,O,V}
     models::Dict{String,U}
     outputs::Dict{String,O}
     outputs_index::Dict{String, Int}
+    default_timestep::Int # TODO make it a period ?
+    model_timesteps::Dict{W, Int} #where {W <: AbstractModel}
 end
 
-function GraphSimulation(graph, mapping; nsteps=1, outputs=nothing, type_promotion=nothing, check=true, verbose=false)
-    GraphSimulation(init_simulation(graph, mapping; nsteps=nsteps, outputs=outputs, type_promotion=type_promotion, check=check, verbose=verbose)...)
+function GraphSimulation(graph, mapping; nsteps=1, outputs=nothing, type_promotion=nothing, check=true, verbose=false, default_timestep=1, model_timesteps=Dict{String, Int}())
+    GraphSimulation(init_simulation(graph, mapping; nsteps=nsteps, outputs=outputs, type_promotion=type_promotion, check=check, verbose=verbose)..., default_timestep, model_timesteps)
 end
 
 dep(g::GraphSimulation) = g.dependency_graph

src/run.jl

@@ -365,17 +365,21 @@ function run!(
     meteo=nothing,
     constants=PlantMeteo.Constants(),
     extra=nothing;
+    orchestrator::Orchestrator=nothing,
     nsteps=nothing,
     tracked_outputs=nothing,
     check=true,
-    executor=ThreadedEx()
+    executor=ThreadedEx(),
+    default_timestep::Int,
+    model_timesteps::Dict{T, Int} where {T}
+  
 )
     isnothing(nsteps) && (nsteps = get_nsteps(meteo))
     meteo_adjusted = adjust_weather_timesteps_to_given_length(nsteps, meteo)
 
     # NOTE : replace_mapping_status_vectors_with_generated_models is assumed to have already run if used
     # otherwise there might be vector length conflicts with timesteps
-    sim = GraphSimulation(object, mapping, nsteps=nsteps, check=check, outputs=tracked_outputs)
+    sim = GraphSimulation(object, mapping, nsteps=nsteps, check=check, outputs=tracked_outputs, default_timestep=default_timestep, model_timesteps=model_timesteps)
     run!(
         sim,
         meteo_adjusted,
@@ -455,6 +459,18 @@ function run_node_multiscale!(
         return nothing
     end
 
+    model_timestep = object.model_timesteps[typeof(node.value)]
+
+    if model_timestep != object.default_timestep
+        # do accumulation
+        
+
+        # run if necessary
+        if i % model_timestep != 0
+            return nothing
+        end
+    end
+
     node_statuses = status(object)[node.scale] # Get the status of the nodes at the current scale
     models_at_scale = models[node.scale]
 

test/test-simulation.jl

@@ -292,4 +292,153 @@ end;
             end
         end
     end
-end
+end
+
+
+
+
+using PlantSimEngine
+# Include the example dummy processes:
+using PlantSimEngine.Examples
+using Test, Aqua
+using Tables, DataFrames, CSV
+using MultiScaleTreeGraph
+using PlantMeteo, Statistics
+using Documenter # for doctests
+
+using PlantMeteo.Dates
+include("helper-functions.jl")
+
+
+
+# These models might be worth exposing in the future ?
+PlantSimEngine.@process "basic_current_timestep" verbose = false
+
+struct HelperCurrentTimestepModel <: AbstractBasic_Current_TimestepModel
+end
+
+PlantSimEngine.inputs_(::HelperCurrentTimestepModel) = (next_timestep=1,)
+PlantSimEngine.outputs_(m::HelperCurrentTimestepModel) = (current_timestep=1,)
+
+function PlantSimEngine.run!(m::HelperCurrentTimestepModel, models, status, meteo, constants=nothing, extra=nothing)
+    status.current_timestep = status.next_timestep
+ end 
+
+ PlantSimEngine.ObjectDependencyTrait(::Type{<:HelperCurrentTimestepModel}) = PlantSimEngine.IsObjectDependent()
+ PlantSimEngine.TimeStepDependencyTrait(::Type{<:HelperCurrentTimestepModel}) = PlantSimEngine.IsTimeStepDependent()
+
+PlantSimEngine.timestep_range_(m::HelperCurrentTimestepModel) = Day(1)
+
+
+ PlantSimEngine.@process "basic_next_timestep" verbose = false
+ struct HelperNextTimestepModel <: AbstractBasic_Next_TimestepModel
+ end
+ 
+ PlantSimEngine.inputs_(::HelperNextTimestepModel) = (current_timestep=1,)
+ PlantSimEngine.outputs_(m::HelperNextTimestepModel) = (next_timestep=1,)
+ 
+ function PlantSimEngine.run!(m::HelperNextTimestepModel, models, status, meteo, constants=nothing, extra=nothing)
+     status.next_timestep = status.current_timestep + 1
+  end 
+
+PlantSimEngine.timestep_range_(m::HelperNextTimestepModel) = Day(1)
+
+
+
+
+
+PlantSimEngine.@process "ToyDay" verbose = false
+
+struct MyToyDayModel <: AbstractToydayModel end
+
+PlantSimEngine.inputs_(m::MyToyDayModel) = (a=1,)
+PlantSimEngine.outputs_(m::MyToyDayModel) = (daily_temperature=-Inf,)
+
+function PlantSimEngine.run!(m::MyToyDayModel, models, status, meteo, constants=nothing, extra=nothing)
+    status.daily_temperature = meteo.T
+end
+
+PlantSimEngine.@process "ToyWeek" verbose = false
+
+struct MyToyWeekModel <: AbstractToyweekModel
+    temperature_threshold::Float64
+end
+
+MyToyWeekModel() = MyToyWeekModel(30.0)
+function PlantSimEngine.inputs_(::MyToyWeekModel)
+     (weekly_max_temperature=-Inf,)
+end
+PlantSimEngine.outputs_(m::MyToyWeekModel) = (hot = false,)
+
+function PlantSimEngine.run!(m::MyToyWeekModel, models, status, meteo, constants=nothing, extra=nothing)
+    status.hot = status.weekly_max_temperature > m.temperature_threshold
+end
+
+PlantSimEngine.timestep_range_(m::MyToyWeekModel) = Week(1)
+
+
+
+PlantSimEngine.@process "DWConnector" verbose = false
+
+struct MyDwconnectorModel <: AbstractDwconnectorModel
+    T_daily::Array{Float64}
+end
+
+MyDwconnectorModel() = MyDwconnectorModel(Array{Float64}(undef, 7))
+
+function PlantSimEngine.inputs_(::MyDwconnectorModel)
+     (daily_temperature=-Inf, current_timestep=1,)
+end
+PlantSimEngine.outputs_(m::MyDwconnectorModel) = (weekly_max_temperature = 0.0,)
+
+function PlantSimEngine.run!(m::MyDwconnectorModel, models, status, meteo, constants=nothing, extra=nothing)
+    m.T_daily[1 + (status.current_timestep % 7)] = status.daily_temperature 
+    
+    if(status.current_timestep % 7 == 1)
+        status.weekly_max_temperature = sum(m.T_daily)/7.0
+    else
+        status.weekly_max_temperature = 0
+    end
+end
+
+    PlantSimEngine.timestep_range_(m::MyDwconnectorModel) = Day(1)
+
+
+
+
+
+meteo_day = read_weather(joinpath(pkgdir(PlantSimEngine), "examples/meteo_day.csv"), duration=Day)
+
+m = Dict("Default" => (
+    MyToyDayModel(), 
+    MyToyWeekModel(),
+    MyDwconnectorModel(), 
+    HelperNextTimestepModel(),
+    MultiScaleModel(
+                    model=HelperCurrentTimestepModel(),
+                    mapped_variables=[PreviousTimeStep(:next_timestep),],
+                    ),
+    Status(a=1,)))
+
+to_initialize(m)
+
+models_timestep = Dict(MyToyDayModel=>1, MyDwconnectorModel => 1, MyToyWeekModel =>7, HelperNextTimestepModel => 1, HelperCurrentTimestepModel => 1)
+
+mtg = Node(MultiScaleTreeGraph.NodeMTG("/", "Default", 1, 1))
+ 
+out = run!(mtg, m, meteo_day, default_timestep=1, model_timesteps=models_timestep)
+
+@testset "Test varying timestep" begin
+    
+    
+    @test
+    @test
+    
+end
+
+
+    # NOTE : replace_mapping_status_vectors_with_generated_models is assumed to have already run if used
+    # otherwise there might be vector length conflicts with timesteps
+    sim = @enter PlantSimEngine.GraphSimulation(mtg, m, nsteps=nothing, check=true, outputs=nothing, default_timestep=1, model_timesteps=models_timestep)
+
+using PlantSimEngine