Update _profile_aggregate to avoid defining over_clustered_years as Parameters

Author: abelsiqueira

src/TulipaEnergyModel.jl

@@ -26,10 +26,10 @@ using TimerOutputs: TimerOutput, @timeit
 const to = TimerOutput()
 
 # Definitions and auxiliary files
-include("utils.jl")
 include("run-scenario.jl")
 include("model-parameters.jl")
 include("structures.jl")
+include("utils.jl")
 
 # Data
 include("input-schemas.jl")

src/model-preparation.jl

@@ -599,19 +599,17 @@ function prepare_profiles_structure(connection)
     )
 
     over_clustered_year = Dict(
-        (row.profile_name, row.year) => ProfileWithRollingHorizon(
-            Float64[
-                row.value for row in DuckDB.query(
-                    connection,
-                    "SELECT profile.value
-                    FROM profiles_timeframe AS profile
-                    WHERE
-                        profile.profile_name = '$(row.profile_name)'
-                        AND profile.year = $(row.year)
-                    ",
-                )
-            ],
-        ) for row in DuckDB.query(
+        (row.profile_name, row.year) => Float64[
+            row.value for row in DuckDB.query(
+                connection,
+                "SELECT profile.value
+                FROM profiles_timeframe AS profile
+                WHERE
+                    profile.profile_name = '$(row.profile_name)'
+                    AND profile.year = $(row.year)
+                ",
+            )
+        ] for row in DuckDB.query(
             connection,
             "SELECT DISTINCT
                 profiles.profile_name,
@@ -621,7 +619,6 @@ function prepare_profiles_structure(connection)
         )
     )
 
-    # TODO: Decide where to put this (leave here?)
     # Creating over_clustered_year profiles of inflows using the inflows
     # profiles of rep_periods and asset_milestone.storage_inflows
     for row in DuckDB.query(
@@ -672,7 +669,7 @@ function prepare_profiles_structure(connection)
             )
         ]
         if length(values) > 0
-            over_clustered_year[(profile_name, year)] = ProfileWithRollingHorizon(values)
+            over_clustered_year[(profile_name, year)] = values
         end
     end
 

src/structures.jl

@@ -224,12 +224,12 @@ Structure to hold the dictionaries of profiles.
 """
 mutable struct ProfileLookup
     # The integers here are Int32 because they are obtained directly from DuckDB
-    #
+
     # rep_period[(asset, year, rep_period)]
     rep_period::Dict{Tuple{String,Int32,Int32},ProfileWithRollingHorizon}
 
     # over_clustered_year[(asset, year)]
-    over_clustered_year::Dict{Tuple{String,Int32},ProfileWithRollingHorizon}
+    over_clustered_year::Dict{Tuple{String,Int32},Vector{Float64}}
 end
 
 """

src/utils.jl

@@ -27,22 +27,36 @@ If `profiles[tuple_key]` exists, then this function computes the aggregation of
 over the range `time_block` using the aggregator `agg_function`, i.e., `agg_function(V[time_block])`.
 If it does not exist, then `V[time_block]` is substituted by a vector of the corresponding size and `default_value`.
 """
-function _profile_aggregate(profiles, tuple_key::Tuple, time_block, agg_function, default_value)
+function _profile_aggregate(
+    profiles::Dict, # either rep_period or over_clustered_year
+    tuple_key::Tuple,
+    time_block,
+    agg_function,
+    default_value,
+)
     if any(ismissing, tuple_key) || !haskey(profiles, tuple_key)
         return agg_function(Iterators.repeated(default_value, length(time_block)))
     end
     profile_object = profiles[tuple_key]
 
+    return _profile_aggregate(profile_object, time_block, agg_function)
+end
+
+function _profile_aggregate(profile_object::Vector{Float64}, time_block, agg_function)
+    return agg_function(skipmissing(profile_object[time_block]))
+end
+
+function _profile_aggregate(profile_object::ProfileWithRollingHorizon, time_block, agg_function)
     # Rolling horizon is inferred by the existence of rolling_horizon_variables
     is_rolling_horizon = length(profile_object.rolling_horizon_variables) > 0
 
-    if is_rolling_horizon
-        profile_value = profile_object.rolling_horizon_variables
-        return agg_function(skipmissing(profile_value[time_block]))
+    profile_value = if is_rolling_horizon
+        profile_object.rolling_horizon_variables
     else
-        profile_value = profile_object.values
-        return agg_function(skipmissing(profile_value[time_block]))
+        profile_object.values
     end
+
+    return agg_function(skipmissing(profile_value[time_block]))
 end
 
 """