Thermal heuristics for clusters with reserve - Leo's internship

src/andromede/simulation/optimization.py

@@ -836,12 +836,13 @@ def build_problem(
     *,
     problem_name: str = "optimization_problem",
     border_management: BlockBorderManagement = BlockBorderManagement.CYCLE,
-    solver_id: str = "SCIP",
+    solver_id: str = "XPRESS_LP",
     problem_strategy: ModelSelectionStrategy = MergedProblemStrategy(),
 ) -> OptimizationProblem:
     """
     Entry point to build the optimization problem for a time period.
     """
+
     solver: lp.Solver = lp.Solver.CreateSolver(solver_id)
 
     database.requirements_consistency(network)

src/andromede/thermal_heuristic/model.py

@@ -152,7 +152,11 @@ def __init__(self, initial_model: Model) -> None:
 class HeuristicAccurateModelBuilder(ModelEditor):
     def __init__(self, initial_model: Model) -> None:
         super().__init__(initial_model)
-        generation_variable = ["generation"]
+        generation_variable = ["energy_generation","generation_reserve_up_primary_on","generation_reserve_up_primary_off",
+                     "generation_reserve_down_primary","generation_reserve_up_secondary_on","generation_reserve_up_secondary_off",
+                     "generation_reserve_down_secondary","generation_reserve_up_tertiary1_on","generation_reserve_up_tertiary1_off",
+                     "generation_reserve_down_tertiary1","generation_reserve_up_tertiary2_on","generation_reserve_up_tertiary2_off",
+                     "generation_reserve_down_tertiary2","nb_off_primary","nb_off_secondary","nb_off_tertiary1","nb_off_tertiary2"]
 
         THERMAL_CLUSTER_MODEL_ACCURATE_HEURISTIC = model(
             id=self.initial_model.id,

src/andromede/thermal_heuristic/problem.py

@@ -71,45 +71,83 @@ def update_database_heuristic(
         output: OutputValues,
         index: BlockScenarioIndex,
         list_cluster_id: List[str],
-        param_to_update: str,
-        var_to_read: str,
+        param_to_update: List[List[str]],
+        var_to_read: List[str],
         fn_to_apply: Callable,
         param_needed_to_compute: Optional[List[str]] = None,
+        param_node_needed_to_compute : Optional[List[str]] = None,
+        version: Optional[str] = None,
+        option: Optional[str] = None,
+        bonus: Optional[str] = None,
     ) -> None:
         for cluster in list_cluster_id:
-            if (
-                ComponentParameterIndex(cluster, param_to_update)
-                not in self.database.__dict__.keys()
-            ):
-                self.database.add_data(cluster, param_to_update, ConstantData(0))
-            self.database.convert_to_time_scenario_series_data(
-                ComponentParameterIndex(cluster, param_to_update),
-                self.time_scenario_hour_parameter.hour
-                * self.time_scenario_hour_parameter.week,
-                self.time_scenario_hour_parameter.scenario,
-            )
-
-            sol = output.component(cluster).var(var_to_read).value[0]  # type:ignore
+            for list_param_update in param_to_update:
+                for param_update in list_param_update:
+                    if (
+                        ComponentParameterIndex(cluster, param_update)
+                        not in self.database.__dict__.keys()
+                    ):
+                        self.database.add_data(cluster, param_update, ConstantData(0))
+                    self.database.convert_to_time_scenario_series_data(
+                        ComponentParameterIndex(cluster, param_update),
+                        self.time_scenario_hour_parameter.hour
+                        * self.time_scenario_hour_parameter.week,
+                        self.time_scenario_hour_parameter.scenario,
+                    )
+            sol = {}
+            for variable in var_to_read:
+                sol[variable] = output.component(cluster).var(variable).value[0] # type:ignore
 
             param = {}
             if param_needed_to_compute is not None:
                 for p in param_needed_to_compute:
-                    param[p] = [
+                    sol[p] = [
                         self.database.get_value(
                             ComponentParameterIndex(cluster, p),
                             t,
                             index.scenario,
                         )
                         for t in timesteps(index, self.time_scenario_hour_parameter)
                     ]
+            if param_node_needed_to_compute is not None:
+                list_connections = self.network._connections
+                print(list_connections)
+                node = None
+                for connection in list_connections:
+                    if connection.port1.component.id == cluster:
+                        node = connection.port2.component.id
+                    if connection.port2.component.id == cluster:
+                        node = connection.port1.component.id
+                for p in param_node_needed_to_compute:
+                    sol[p] = [self.database.get_data(node,p).value
+                                for t in timesteps(index, self.time_scenario_hour_parameter)]   
+
+            if version is not None:
+                if option is not None:
+                    result_heuristic = fn_to_apply([i for i, t in enumerate(timesteps(index, self.time_scenario_hour_parameter))],
+                                            sol,version,option,bonus)            
+                else:
+                    result_heuristic = fn_to_apply([i for i, t in enumerate(timesteps(index, self.time_scenario_hour_parameter))],
+                                            sol,version)            
+            elif option is not None:
+                result_heuristic = fn_to_apply([i for i, t in enumerate(timesteps(index, self.time_scenario_hour_parameter))],
+                                            sol,option,bonus)            
+            else:
+                result_heuristic = fn_to_apply( [i for i, t in enumerate(timesteps(index, self.time_scenario_hour_parameter))],
+                                            sol)            
 
             for i, t in enumerate(timesteps(index, self.time_scenario_hour_parameter)):
-                self.database.set_value(
-                    ComponentParameterIndex(cluster, param_to_update),
-                    fn_to_apply(sol[i], *[p[i] for p in param.values()]),  # type:ignore
-                    t,
-                    index.scenario,
-                )
+                results_heuristic = result_heuristic[i]
+                for p,list_param_update in enumerate(param_to_update):
+                    for param_update in list_param_update:
+                        self.database.set_value(
+                            ComponentParameterIndex(cluster, param_update),
+                            results_heuristic[p],  # type:ignore
+                            t,
+                            index.scenario,
+                        )
+
+
 
     def heuristic_resolution_step(
         self,