feat(hydro): lower bound for power output of hydro units

Author: MPavicevic

src/pownet/builder/hydro.py

@@ -58,6 +58,7 @@ def __init__(self, model: gp.Model, inputs: SystemInput):
 
         # Constraints
         self.c_hourly_hydro_ub = gp.tupledict()
+        self.c_hourly_hydro_lb = gp.tupledict()
         self.c_hydro_limit_daily = gp.tupledict()
         self.c_hydro_limit_weekly = gp.tupledict()
 
@@ -83,7 +84,11 @@ def add_variables(self, step_k: int) -> None:
         self.daily_phydro = self.model.addVars(
             self.inputs.daily_hydro_unit_node.keys(),
             self.timesteps,
-            lb=0,
+            lb={
+                (unit, t): self.inputs.hydro_contracted_capacity_min[unit]
+                for unit in self.inputs.daily_hydro_unit_node.keys()
+                for t in self.timesteps
+            },
             ub={
                 (unit, t): self.inputs.hydro_contracted_capacity[unit]
                 for unit in self.inputs.daily_hydro_unit_node.keys()
@@ -96,7 +101,11 @@ def add_variables(self, step_k: int) -> None:
         self.weekly_phydro = self.model.addVars(
             self.inputs.weekly_hydro_unit_node.keys(),
             self.timesteps,
-            lb=0,
+            lb={
+                (unit, t): self.inputs.hydro_contracted_capacity_min[unit]
+                for unit in self.inputs.weekly_hydro_unit_node.keys()
+                for t in self.timesteps
+            },
             ub={
                 (unit, t): self.inputs.hydro_contracted_capacity[unit]
                 for unit in self.inputs.weekly_hydro_unit_node.keys()
@@ -158,6 +167,15 @@ def add_constraints(self, step_k: int, init_conds: dict, **kwargs) -> None:
             contracted_capacity_dict=self.inputs.hydro_contracted_capacity,
         )
 
+        self.c_hourly_hydro_lb = nondispatch_constr.add_c_hourly_unit_lb(
+            model=self.model,
+            pdispatch=self.hourly_phydro,
+            unit_type="hydro",
+            timesteps=self.timesteps,
+            units=self.inputs.hydro_unit_node.keys(),
+            contracted_capacity_min_dict=self.inputs.hydro_contracted_capacity_min,
+        )
+
         # Daily upper bound
         self.c_hydro_limit_daily = nondispatch_constr.add_c_hydro_limit_daily(
             model=self.model,

src/pownet/input.py

@@ -160,6 +160,7 @@ def __init__(
 
         # Hydropower (hourly and daily timeseries)
         self.hydro_contracted_capacity: dict[str, float] = {}
+        self.hydro_contracted_capacity_min: dict[str, float] = {}
         self.hydro_capacity: pd.DataFrame = pd.DataFrame()
         self.hydro_min_capacity: pd.DataFrame = pd.DataFrame()
         self.hydro_max_capacity: dict[str, float] = {}
@@ -611,11 +612,13 @@ def _load_contracted_capacity(self) -> None:
         if nondispatch_df.empty:
             return
         # Replace -1 in the contracted_capacity column to GRB.INFINITY
-        nondispatch_df["contracted_capacity"] = (
-            nondispatch_df["contracted_capacity"]
-            .astype(float)
-            .replace(-1, GRB.INFINITY)
-        )
+        for col in ["contracted_capacity", "contracted_capacity_min"]:
+            nondispatch_df[col] = (
+                nondispatch_df[col]
+                .astype(float)
+                .replace(-1, GRB.INFINITY)
+                .fillna(0)
+            )
 
         unit_types = {
             "hydro": self.hydro_unit_node,
@@ -646,6 +649,20 @@ def _load_contracted_capacity(self) -> None:
             .to_dict()
         )
 
+        # Add daily hydro units to the contracted capacity under "hydro"
+        self.hydro_contracted_capacity_min.update(
+            nondispatch_df.loc[nondispatch_df["name"].isin(self.daily_hydro_unit_node)]
+            .set_index("name")["contracted_capacity_min"]
+            .to_dict()
+        )
+
+        # Add daily hydro units to the contracted capacity under "hydro"
+        self.hydro_contracted_capacity_min.update(
+            nondispatch_df.loc[nondispatch_df["name"].isin(self.weekly_hydro_unit_node)]
+            .set_index("name")["contracted_capacity_min"]
+            .to_dict()
+        )
+
     def load_data(self):
         """Load the input data for the power system model.
         Timeseries are loaded as dataframes with the index starting at 1.

src/pownet/optim_model/constraints/nondispatch_constr.py

@@ -36,6 +36,38 @@ def add_c_hourly_unit_ub(
         name=f"hourly_{unit_type}_ub",
     )
 
+def add_c_hourly_unit_lb(
+    model: gp.Model,
+    pdispatch: gp.tupledict,
+    unit_type: str,
+    timesteps: range,
+    units: list,
+    contracted_capacity_min_dict: dict[str, float],
+) -> gp.tupledict:
+    """
+    Add constraints to define the hourly availability of non-dispatchable units. This is limited by the
+    contracted_capacity
+
+    Args:
+        model (gp.Model): The optimization model.
+        pdispatch (gp.tupledict): The dispatch variable.
+        unit_type (str): The type of unit ("wind", "solar", "hydro", "import").
+        timesteps (range): The range of timesteps.
+        units (list): The list of units.
+        contracted_capacity_min_dict (dict[str, float]): The contracted minimum capacity of the unit.
+
+    Returns:
+        gp.tupledict: The constraints linking the dispatch variable and the unit status variable.
+    """
+    return model.addConstrs(
+        (
+            pdispatch[unit, t] >= contracted_capacity_min_dict[unit]
+            for unit in units
+            for t in timesteps
+        ),
+        name=f"hourly_{unit_type}_lb",
+    )
+
 
 def add_c_link_unit_pu(
     model: gp.Model,
@@ -45,6 +77,7 @@ def add_c_link_unit_pu(
     timesteps: range,
     units: list,
     contracted_capacity_dict: dict[str, float],
+    contracted_capacity_min_dict: dict[str, float],
 ) -> gp.tupledict:
     """
     Add constraints to link the dispatch variable and the unit status variable.
@@ -183,7 +216,6 @@ def add_c_hydro_limit_weekly(
     sim_horizon: int,
     hydro_units: list,
     hydro_capacity: pd.DataFrame,
-    # hydro_capacity_min: pd.DataFrame,
 ) -> gp.tupledict:
     """
     Defines the weekly limit (lower and upper bounds) of hydro generation.
@@ -218,7 +250,6 @@ def add_c_hydro_limit_weekly(
     for week in range(step_k, step_k + max_week):
         for hydro_unit in hydro_units:
             cname = f"hydro_limit_weekly_ub[{hydro_unit},{week}]"
-            cname_min = f"hydro_limit_weekly_lb[{hydro_unit},{week}]"
             current_week = week - step_k + 1
 
             # Upper bound constraint
@@ -240,12 +271,11 @@ def add_c_hydro_limit_weekly_lb(
     step_k: int,
     sim_horizon: int,
     hydro_units: list,
-    # hydro_capacity: pd.DataFrame,
     hydro_capacity_min: pd.DataFrame,
 ) -> gp.tupledict:
     """
     Defines the weekly limit (lower and upper bounds) of hydro generation.
-    Assumes that a certain amount of water is available for hydropower generation each day.
+    Assumes that a certain amount of water is available for hydropower generation each week.
 
     Args:
         model (gp.Model): The optimization model
@@ -275,7 +305,6 @@ def add_c_hydro_limit_weekly_lb(
     max_week = sim_horizon // 168
     for week in range(step_k, step_k + max_week):
         for hydro_unit in hydro_units:
-            # cname = f"hydro_limit_weekly_ub[{hydro_unit},{week}]"
             cname_min = f"hydro_limit_weekly_lb[{hydro_unit},{week}]"
             current_week = week - step_k + 1