Thermal heuristic

src/andromede/simulation/optimization.py

@@ -18,7 +18,7 @@
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from enum import Enum
-from typing import Dict, Iterable, List, Optional, Type
+from typing import Dict, Iterable, List, Optional, Type, Union
 
 import ortools.linear_solver.pywraplp as lp
 
@@ -68,8 +68,9 @@ def _get_parameter_value(
     name: str,
 ) -> float:
     data = context.database.get_data(component_id, name)
+    absolute_scenario = context.scenario_to_absolute_scenario(scenario)
     absolute_timestep = context.block_timestep_to_absolute_timestep(block_timestep)
-    return data.get_value(absolute_timestep, scenario)
+    return data.get_value(absolute_timestep, absolute_scenario)
 
 
 # TODO: Maybe add the notion of constant parameter in the model
@@ -303,7 +304,7 @@ def __init__(
         network: Network,
         database: DataBase,
         block: TimeBlock,
-        scenarios: int,
+        scenarios: Union[List[int], int],
         border_management: BlockBorderManagement,
     ):
         self._network = network
@@ -322,9 +323,16 @@ def network(self) -> Network:
         return self._network
 
     @property
-    def scenarios(self) -> int:
+    def scenarios(self) -> Union[List[int], int]:
         return self._scenarios
 
+    def scenario_length(self) -> int:
+        if type(self.scenarios) is int:
+            return self.scenarios
+        elif type(self.scenarios) is List:
+            return len(self.scenarios)
+        return 1
+
     def block_length(self) -> int:
         return len(self._block.timesteps)
 
@@ -336,6 +344,11 @@ def connection_fields_expressions(self) -> Dict[PortFieldKey, List[ExpressionNod
     def block_timestep_to_absolute_timestep(self, block_timestep: int) -> int:
         return self._block.timesteps[block_timestep]
 
+    def scenario_to_absolute_scenario(self, scenario: int) -> int:
+        if type(self.scenarios) is List or type(self.scenarios) is list:
+            return self.scenarios[scenario]
+        return scenario
+
     @property
     def database(self) -> DataBase:
         return self._database
@@ -350,7 +363,7 @@ def get_time_indices(self, index_structure: IndexingStructure) -> Iterable[int]:
         return range(self.block_length()) if index_structure.time else range(1)
 
     def get_scenario_indices(self, index_structure: IndexingStructure) -> Iterable[int]:
-        return range(self.scenarios) if index_structure.scenario else range(1)
+        return range(self.scenario_length()) if index_structure.scenario else range(1)
 
     # TODO: API to improve, variable_structure guides which of the indices block_timestep and scenario should be used
     def get_component_variable(
@@ -508,8 +521,8 @@ def _create_objective(
     for term in linear_expr.terms.values():
         # TODO : How to handle the scenario operator in a general manner ?
         if isinstance(term.scenario_operator, Expectation):
-            weight = 1 / opt_context.scenarios
-            scenario_ids = range(opt_context.scenarios)
+            weight = 1 / opt_context.scenario_length()
+            scenario_ids = range(opt_context.scenario_length())
         else:
             weight = 1
             scenario_ids = range(1)
@@ -819,7 +832,7 @@ def build_problem(
     network: Network,
     database: DataBase,
     block: TimeBlock,
-    scenarios: int,
+    scenarios: Union[List[int], int],
     *,
     problem_name: str = "optimization_problem",
     border_management: BlockBorderManagement = BlockBorderManagement.CYCLE,

src/andromede/study/data.py

@@ -13,7 +13,7 @@
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Dict, List, Optional
 
 import pandas as pd
 
@@ -41,6 +41,12 @@ class AbstractDataStructure(ABC):
     def get_value(self, timestep: int, scenario: int) -> float:
         return NotImplemented
 
+    def set_value(self, value: float, timestep: int, scenario: int) -> None:
+        raise NotImplementedError
+
+    def get_max_value(self) -> float:
+        return NotImplemented
+
     @abstractmethod
     def check_requirement(self, time: bool, scenario: bool) -> bool:
         """
@@ -57,6 +63,9 @@ class ConstantData(AbstractDataStructure):
     def get_value(self, timestep: int, scenario: int) -> float:
         return self.value
 
+    def get_max_value(self) -> float:
+        return self.value
+
     # ConstantData can be used for time varying or constant models
     def check_requirement(self, time: bool, scenario: bool) -> bool:
         if not isinstance(self, ConstantData):
@@ -77,6 +86,12 @@ class TimeSeriesData(AbstractDataStructure):
     def get_value(self, timestep: int, scenario: int) -> float:
         return self.time_series[TimeIndex(timestep)]
 
+    def set_value(self, value: float, timestep: int, scenario: int) -> None:
+        self.time_series[TimeIndex(timestep)] = value
+
+    def get_max_value(self) -> float:
+        return max(self.time_series.values())
+
     def check_requirement(self, time: bool, scenario: bool) -> bool:
         if not isinstance(self, TimeSeriesData):
             raise ValueError("Invalid data type for TimeSeriesData")
@@ -97,6 +112,12 @@ class ScenarioSeriesData(AbstractDataStructure):
     def get_value(self, timestep: int, scenario: int) -> float:
         return self.scenario_series[ScenarioIndex(scenario)]
 
+    def set_value(self, value: float, timestep: int, scenario: int) -> None:
+        self.scenario_series[ScenarioIndex(scenario)] = value
+
+    def get_max_value(self) -> float:
+        return max(self.scenario_series.values())
+
     def check_requirement(self, time: bool, scenario: bool) -> bool:
         if not isinstance(self, ScenarioSeriesData):
             raise ValueError("Invalid data type for TimeSeriesData")
@@ -130,6 +151,12 @@ def get_value(self, timestep: int, scenario: int) -> float:
         value = str(self.time_scenario_series.iloc[timestep, scenario])
         return float(value)
 
+    def set_value(self, value: float, timestep: int, scenario: int) -> None:
+        self.time_scenario_series.iloc[timestep, scenario] = value
+
+    def get_max_value(self) -> float:
+        return self.time_scenario_series.values.max()
+
     def check_requirement(self, time: bool, scenario: bool) -> bool:
         if not isinstance(self, TimeScenarioSeriesData):
             raise ValueError("Invalid data type for TimeScenarioSeriesData")
@@ -172,6 +199,18 @@ def get_value(
         else:
             raise KeyError(f"Index {index} not found.")
 
+    def set_value(
+        self, index: ComponentParameterIndex, value: float, timestep: int, scenario: int
+    ) -> None:
+        self._data[index].set_value(value, timestep, scenario)
+
+    def convert_to_time_scenario_series_data(
+        self, index: ComponentParameterIndex, timesteps: int, scenarios: int
+    ) -> None:
+        self._data[index] = convert_to_time_scenario_series_data(
+            self._data[index], timesteps, scenarios
+        )
+
     def requirements_consistency(self, network: Network) -> None:
         for component in network.components:
             for param in component.model.parameters.values():
@@ -184,3 +223,17 @@ def requirements_consistency(self, network: Network) -> None:
                     raise ValueError(
                         f"Data inconsistency for component: {component.id}, parameter: {param.name}. Requirement not met."
                     )
+
+
+def convert_to_time_scenario_series_data(
+    initial_data: AbstractDataStructure, timesteps: int, scenarios: int
+) -> TimeScenarioSeriesData:
+    data = pd.DataFrame(
+        [
+            [initial_data.get_value(t, s) for s in range(scenarios)]
+            for t in range(timesteps)
+        ],
+        index=list(range(timesteps)),
+        columns=list(range(scenarios)),
+    )
+    return TimeScenarioSeriesData(data)

src/andromede/study/resolve_components.py

@@ -145,7 +145,7 @@ def build_data_base(
     input_comp: InputComponents, timeseries_dir: Optional[Path]
 ) -> DataBase:
     database = DataBase()
-    for comp in input_comp.components:
+    for comp in input_comp.components + input_comp.nodes:
         for param in comp.parameters or []:
             param_value = _evaluate_param_type(
                 param.type, param.value, param.timeseries, timeseries_dir