Matias bresciano branch

.github/workflows/ci.yml

@@ -6,15 +6,15 @@ on:
 
 jobs:
   ci:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v4
         with:
-          python-version: 3.11
+          python-version: 3.12
           cache: pip
           cache-dependency-path: |
             requirements.txt

requirements-dev.txt

@@ -2,3 +2,4 @@ black
 isort
 mypy
 pytest
+plotly

requirements.txt

@@ -1,4 +1,6 @@
-numpy
+numpy==1.26.4
+matplotlib
 scipy
 xpress
-ortools
+ortools
+tqdm

src/calculate_reward_and_bellman_values.py

@@ -75,17 +75,17 @@ def get_penalty(self, week: int, len_week: int) -> Callable:
             pen = interp1d(
                 [
                     0,
-                    self.reservoir.bottom_rule_curve[week],
-                    self.reservoir.upper_rule_curve[week],
+                    self.reservoir.weekly_lower_rule_curve[week],
+                    self.reservoir.weekly_upper_rule_curve[week],
                     self.reservoir.capacity,
                 ],
                 [
                     -self.penalty_bottom_rule_curve
-                    * (self.reservoir.bottom_rule_curve[week]),
+                    * (self.reservoir.weekly_lower_rule_curve[week]),
                     0,
                     0,
                     -self.penalty_upper_rule_curve
-                    * (self.reservoir.capacity - self.reservoir.upper_rule_curve[week]),
+                    * (self.reservoir.capacity - self.reservoir.weekly_upper_rule_curve[week]),
                 ],
             )
         return pen
@@ -287,13 +287,13 @@ def solve_weekly_problem_with_approximation(
         X = self.stock_discretization
 
         for i_fut in range(len(X)):
-            u = -X[i_fut] + level_i + stock.inflow[week, scenario]
-            if -stock.max_pumping[week] * stock.efficiency <= u:
+            u = -X[i_fut] + level_i + stock.weekly_inflow[week, scenario]
+            if -stock.max_weekly_pump[week] * stock.efficiency <= u:
                 if (
                     self.reservoir_management.overflow
-                    or u <= stock.max_generating[week]
+                    or u <= stock.max_weekly_turb[week]
                 ):
-                    u = min(u, stock.max_generating[week])
+                    u = min(u, stock.max_weekly_turb[week])
                     G = reward_fn(u)
                     penalty = pen(X[i_fut])
                     if (G + V_fut(X[i_fut]) + penalty) > Vu:
@@ -302,7 +302,7 @@ def solve_weekly_problem_with_approximation(
                         control = u
 
         for u in range(len(points)):
-            state_fut = level_i - points[u] + stock.inflow[week, scenario]
+            state_fut = level_i - points[u] + stock.weekly_inflow[week, scenario]
             if 0 <= state_fut <= stock.capacity:
                 penalty = pen(state_fut)
                 G = reward_fn(points[u])
@@ -311,35 +311,35 @@ def solve_weekly_problem_with_approximation(
                     xf = state_fut
                     control = points[u]
 
-        Umin = level_i + stock.inflow[week, scenario] - stock.bottom_rule_curve[week]
+        Umin = level_i + stock.weekly_inflow[week, scenario] - stock.weekly_lower_rule_curve[week]
         if (
-            -stock.max_pumping[week] * stock.efficiency
+            -stock.max_weekly_pump[week] * stock.efficiency
             <= Umin
-            <= stock.max_generating[week]
+            <= stock.max_weekly_turb[week]
         ):
-            state_fut = level_i - Umin + stock.inflow[week, scenario]
+            state_fut = level_i - Umin + stock.weekly_inflow[week, scenario]
             penalty = pen(state_fut)
             if (reward_fn(Umin) + V_fut(state_fut) + penalty) > Vu:
                 Vu = reward_fn(Umin) + V_fut(state_fut) + penalty
                 xf = state_fut
                 control = Umin
 
-        Umax = level_i + stock.inflow[week, scenario] - stock.upper_rule_curve[week]
+        Umax = level_i + stock.weekly_inflow[week, scenario] - stock.weekly_upper_rule_curve[week]
         if (
-            -stock.max_pumping[week] * stock.efficiency
+            -stock.max_weekly_pump[week] * stock.efficiency
             <= Umax
-            <= stock.max_generating[week]
+            <= stock.max_weekly_turb[week]
         ):
-            state_fut = level_i - Umax + stock.inflow[week, scenario]
+            state_fut = level_i - Umax + stock.weekly_inflow[week, scenario]
             penalty = pen(state_fut)
             if (reward_fn(Umax) + V_fut(state_fut) + penalty) > Vu:
                 Vu = reward_fn(Umax) + V_fut(state_fut) + penalty
                 xf = state_fut
                 control = Umax
 
         control = min(
-            -(xf - level_i - stock.inflow[week, scenario]),
-            stock.max_generating[week],
+            -(xf - level_i - stock.weekly_inflow[week, scenario]),
+            stock.max_weekly_turb[week],
         )
         return (Vu, xf, control)
 

src/functions_iterative.py

@@ -356,9 +356,9 @@ def init_iterative_calculation(
     for week in range(len_week):
         for scenario in range(len_scenario):
             r = RewardApproximation(
-                lb_control=-reservoir_management.reservoir.max_pumping[week]
+                lb_control=-reservoir_management.reservoir.max_weekly_pump[week]
                 * reservoir_management.reservoir.efficiency,
-                ub_control=reservoir_management.reservoir.max_generating[week],
+                ub_control=reservoir_management.reservoir.max_weekly_turb[week],
                 ub_reward=0,
             )
             G[TimeScenarioIndex(week, scenario)] = r

src/optimization.py

@@ -224,9 +224,9 @@ def create_weekly_problem_itr(
         )
 
         U = model.Var(
-            lb=-reservoir_management.reservoir.max_pumping[self.week]
+            lb=-reservoir_management.reservoir.max_weekly_pump[self.week]
             * reservoir_management.reservoir.efficiency,
-            ub=reservoir_management.reservoir.max_generating[self.week],
+            ub=reservoir_management.reservoir.max_weekly_turb[self.week],
             integer=False,
             name="u",
         )
@@ -236,15 +236,15 @@ def create_weekly_problem_itr(
                 x_s_1
                 <= x_s
                 - U
-                + reservoir_management.reservoir.inflow[self.week, self.scenario],
+                + reservoir_management.reservoir.weekly_inflow[self.week, self.scenario],
                 name=f"ReservoirConservation::area<{reservoir_management.reservoir.area}>::week<{self.week}>",
             )
         else:
             model.Add(
                 x_s_1
                 == x_s
                 - U
-                + reservoir_management.reservoir.inflow[self.week, self.scenario],
+                + reservoir_management.reservoir.weekly_inflow[self.week, self.scenario],
                 name=f"ReservoirConservation::area<{reservoir_management.reservoir.area}>::week<{self.week}>",
             )
 
@@ -256,13 +256,13 @@ def create_weekly_problem_itr(
             model.Add(
                 y
                 >= -reservoir_management.penalty_bottom_rule_curve
-                * (x_s_1 - reservoir_management.reservoir.bottom_rule_curve[self.week]),
+                * (x_s_1 - reservoir_management.reservoir.weekly_lower_rule_curve[self.week]),
                 name=f"PenaltyForViolatingBottomRuleCurve::area<{reservoir_management.reservoir.area}>::week<{self.week}>",
             )
             model.Add(
                 y
                 >= reservoir_management.penalty_upper_rule_curve
-                * (x_s_1 - reservoir_management.reservoir.upper_rule_curve[self.week]),
+                * (x_s_1 - reservoir_management.reservoir.weekly_upper_rule_curve[self.week]),
                 name=f"PenaltyForViolatingUpperRuleCurve::area<{reservoir_management.reservoir.area}>::week<{self.week}>",
             )
         else:
@@ -506,7 +506,7 @@ def solve_problem_with_bellman_values(
             -(
                 xf
                 - level_i
-                - bellman_value_calculation.reservoir_management.reservoir.inflow[
+                - bellman_value_calculation.reservoir_management.reservoir.weekly_inflow[
                     self.week, self.scenario
                 ]
             ),