Explicit demand response peak load

assume/common/forecasts.py

@@ -110,9 +110,13 @@
     def __init__(
         self,
         index: pd.Series,
-        powerplants_units: pd.DataFrame,
-        demand_units: pd.DataFrame,
-        market_configs: dict = {},
+        powerplants_units: dict[str, pd.Series] = {},
+        demand_units: dict[str, pd.Series] = {},
+        dsm_units: dict[str, pd.Series] = {},
+        buses: dict[str, pd.Series] = {},
+        lines: dict[str, pd.Series] = {},
+        demand_df: dict[str, pd.Series] = {},
+        market_configs: dict[str, pd.Series] = {},
         save_path: str = "",
         *args,
         **kwargs,
@@ -121,6 +125,10 @@
         self.logger = logging.getLogger(__name__)
         self.powerplants_units = powerplants_units
         self.demand_units = demand_units
+        self.dsm_units = dsm_units
+        self.buses = buses
+        self.lines = lines
+        self.demand_df = demand_df
         self.market_configs = market_configs
         self.forecasts = pd.DataFrame(index=index)
         self.save_path = save_path
@@ -217,6 +225,31 @@
                     self.calculate_residual_load_forecast(market_id=market_id)
                 )
 
+        # Calculate node-specific congestion signal
+        node_congestion_signal_df = self.calculate_node_specific_congestion_forecast()
+
+        for col in node_congestion_signal_df.columns:
+            if col not in self.forecasts.columns:
+                self.forecasts[col] = node_congestion_signal_df[col]
+
+        utilisation_columns = [
+            f"{node}_renewable_utilisation"
+            for node in self.demand_units["node"].unique()
+        ]
+        utilisation_columns.append("all_nodes_renewable_utilisation")
+
+        # If any of the utilisation columns are missing, calculate and add them
+        if not all(col in self.forecasts.columns for col in utilisation_columns):
+            # Calculate renewable utilisation forecast if any columns are missing
+            renewable_utilisation_forecast = (
+                self.calculate_renewable_utilisation_forecast()
+            )
+
+            # Add each column from the renewable utilisation forecast to self.forecasts
+            for col in renewable_utilisation_forecast.columns:
+                if col not in self.forecasts.columns:
+                    self.forecasts[col] = renewable_utilisation_forecast[col]
+
     def get_registered_market_participants(self, market_id):
         """
         Retrieves information about market participants to make accurate price forecasts.
@@ -375,6 +408,131 @@
 
         return marginal_cost
 
+    def calculate_node_specific_congestion_forecast(self) -> pd.DataFrame:
+        """
+        Calculates a collective node-specific congestion signal by aggregating the congestion severity of all
+        transmission lines connected to each node, taking into account powerplant load based on availability factors.
+
+        Returns:
+            pd.DataFrame: A DataFrame with columns for each node, where each column represents the collective
+                          congestion signal time series for that node.
+        """
+        # Step 1: Calculate powerplant load using availability factors
+        availability_factor_df = pd.DataFrame(
+            index=self.index, columns=self.powerplants_units.index, data=0.0
+        )
+
+        # Calculate load for each powerplant based on availability factor and max power
+        for pp, max_power in self.powerplants_units["max_power"].items():
+            availability_factor_df[pp] = (
+                self.forecasts[f"availability_{pp}"] * max_power
+            )
+
+        # Step 2: Calculate net load for each node (demand - generation)
+        net_load_by_node = {}
+
+        for node in self.demand_units["node"].unique():
+            # Calculate total demand for this node
+            node_demand_units = self.demand_units[
+                self.demand_units["node"] == node
+            ].index
+            node_demand = self.demand_df[node_demand_units].sum(axis=1)
+
+            # Calculate total generation for this node by summing powerplant loads
+            node_generation_units = self.powerplants_units[
+                self.powerplants_units["node"] == node
+            ].index
+            node_generation = availability_factor_df[node_generation_units].sum(axis=1)
+
+            # Calculate net load (demand - generation)
+            net_load_by_node[node] = node_demand - node_generation
+
+        # Step 3: Calculate line-specific congestion severity
+        line_congestion_severity = pd.DataFrame(index=self.index)
+
+        for line_id, line_data in self.lines.iterrows():
+            node1, node2 = line_data["bus0"], line_data["bus1"]
+            line_capacity = line_data["s_nom"]
+
+            # Calculate net load for the line as the sum of net loads from both connected nodes
+            line_net_load = net_load_by_node[node1] + net_load_by_node[node2]
+            congestion_severity = line_net_load / line_capacity
+
+            # Store the line-specific congestion severity in DataFrame
+            line_congestion_severity[f"{line_id}_congestion_severity"] = (
+                congestion_severity
+            )
+
+        # Step 4: Calculate node-specific congestion signal by aggregating connected lines
+        node_congestion_signal = pd.DataFrame(index=self.index)
+
+        for node in self.demand_units["node"].unique():
+            # Find all lines connected to this node
+            connected_lines = self.lines[
+                (self.lines["bus0"] == node) | (self.lines["bus1"] == node)
+            ].index
+
+            # Collect all relevant line congestion severities
+            relevant_lines = [
+                f"{line_id}_congestion_severity" for line_id in connected_lines
+            ]
+
+            # Ensure only existing columns are used to avoid KeyError
+            relevant_lines = [
+                line
+                for line in relevant_lines
+                if line in line_congestion_severity.columns
+            ]
+
+            # Aggregate congestion severities for this node (use max or mean)
+            if relevant_lines:
+                node_congestion_signal[f"{node}_congestion_severity"] = (
+                    line_congestion_severity[relevant_lines].max(axis=1)
+                )
+
+        return node_congestion_signal
+
+    def calculate_renewable_utilisation_forecast(self) -> pd.DataFrame:
+        """
+        Calculates the renewable utilisation forecast by summing the available renewable generation
+        for each node and an overall 'all_nodes' summary.
+
+        Returns:
+            pd.DataFrame: A DataFrame with columns for each node, where each column represents the renewable
+                        utilisation signal time series for that node and a column for total utilisation across all nodes.
+        """
+        # Initialize a DataFrame to store renewable utilisation for each node
+        renewable_utilisation = pd.DataFrame(index=self.index)
+
+        # Identify renewable power plants by filtering `powerplants_units` DataFrame
+        renewable_plants = self.powerplants_units[
+            self.powerplants_units["fuel_type"] == "renewable"
+        ]
+
+        # Calculate utilisation based on availability and max power for each renewable plant
+        for node in self.demand_units["node"].unique():
+            node_renewable_sum = pd.Series(0, index=self.index)
+
+            # Filter renewable plants in this specific node
+            node_renewable_plants = renewable_plants[renewable_plants["node"] == node]
+
+            for pp in node_renewable_plants.index:
+                max_power = node_renewable_plants.loc[pp, "max_power"]
+                availability_col = f"availability_{pp}"
+
+                # Calculate renewable power based on availability and max capacity
+                if availability_col in self.forecasts.columns:
+                    node_renewable_sum += self.forecasts[availability_col] * max_power
+
+            # Store the node-specific renewable utilisation
+            renewable_utilisation[f"{node}_renewable_utilisation"] = node_renewable_sum
+
+        # Calculate the total renewable utilisation across all nodes
+        all_nodes_sum = renewable_utilisation.sum(axis=1)
+        renewable_utilisation["all_nodes_renewable_utilisation"] = all_nodes_sum
+
+        return renewable_utilisation
+
     def save_forecasts(self, path=None):
         """
         Saves the forecasts to a csv file located at the specified path.

assume/scenario/loader_csv.py

@@ -163,6 +163,8 @@ def load_dsm_units(
         "unit_type",
         "node",
         "flexibility_measure",
+        "congestion_threshold",
+        "peak_load_cap",
     ]
     # Filter the common columns to only include those that exist in the DataFrame
     common_columns = [col for col in common_columns if col in dsm_units.columns]
@@ -444,6 +446,8 @@ def load_config_and_create_forecaster(
     )
 
     powerplant_units = load_file(path=path, config=config, file_name="powerplant_units")
+    buses = load_file(path=path, config=config, file_name="buses")
+    lines = load_file(path=path, config=config, file_name="lines")
     storage_units = load_file(path=path, config=config, file_name="storage_units")
     demand_units = load_file(path=path, config=config, file_name="demand_units")
 
@@ -501,6 +505,10 @@ def load_config_and_create_forecaster(
         index=index,
         powerplants_units=powerplant_units,
         demand_units=demand_units,
+        dsm_units=dsm_units,
+        buses=buses,
+        lines=lines,
+        demand_df=demand_df,
         market_configs=config["markets_config"],
     )
 
@@ -526,6 +534,8 @@ def load_config_and_create_forecaster(
         "storage_units": storage_units,
         "demand_units": demand_units,
         "dsm_units": dsm_units,
+        "buses": buses,
+        "lines": lines,
         "forecaster": forecaster,
     }
 

assume/strategies/naive_strategies.py

@@ -2,6 +2,7 @@
 #
 # SPDX-License-Identifier: AGPL-3.0-or-later
 
+
 from assume.common.base import BaseStrategy, SupportsMinMax
 from assume.common.market_objects import MarketConfig, Order, Orderbook, Product
 
@@ -151,7 +152,7 @@
         **kwargs,
     ) -> Orderbook:
         # calculate the optimal operation of the unit
-        unit.calculate_optimal_operation_if_needed()
+        unit.determine_optimal_operation_without_flex()
 
         bids = []
         for product in product_tuples:
@@ -173,6 +174,8 @@
                 }
             )
 
+            # Plot the power requirements after calculating bids
+
         return bids
 
 
@@ -185,7 +188,7 @@
         **kwargs,
     ) -> Orderbook:
         # calculate the optimal operation of the unit according to the objective function
-        unit.calculate_optimal_operation_if_needed()
+        unit.determine_optimal_operation_with_flex()
 
         bids = []
         for product in product_tuples: