Not resetting state of charge

src/policies/PolicyEvaluator.py

@@ -47,6 +47,7 @@ class PolicyEvaluator:
         charge_thresholds=np.arange(-1500, 1500, 50),
         discharge_thresholds=np.arange(-1500, 1500, 50),
         penalty: int = 0,
+        state_of_charge: float = 0.0,
     ):
         if date in self.cache:
             (reconstructed_imbalance_prices, real_imbalance_prices) = self.cache[date]
@@ -82,6 +83,7 @@ class PolicyEvaluator:
             penalty,
             charge_thresholds,
             discharge_thresholds,
+            state_of_charge=state_of_charge,
         )
 
     def optimize_penalty_for_target_charge_cycles(
@@ -135,6 +137,7 @@ class PolicyEvaluator:
         penalty: int,
         charge_thresholds,
         discharge_thresholds,
+        state_of_charge=0.0,
     ):
         """_summary_
 
@@ -155,6 +158,7 @@ class PolicyEvaluator:
                 charge_thresholds,
                 discharge_thresholds,
                 penalty,
+                battery_state_of_charge=state_of_charge,
             )
         )
 
@@ -162,16 +166,20 @@ class PolicyEvaluator:
         predicted_discharge_threshold = found_discharge_thresholds.mean(axis=0)
 
         ### Determine Profits and Charge Cycles ###
-        simulated_profit, simulated_charge_cycles = self.baseline_policy.simulate(
-            torch.tensor([[real_imbalance_prices]]),
-            torch.tensor([predicted_charge_threshold]),
-            torch.tensor([predicted_discharge_threshold]),
+        simulated_profit, simulated_charge_cycles, new_state_of_charge = (
+            self.baseline_policy.simulate(
+                torch.tensor([[real_imbalance_prices]]),
+                torch.tensor([predicted_charge_threshold]),
+                torch.tensor([predicted_discharge_threshold]),
+                battery_state_of_charge=torch.tensor([state_of_charge]),
+            )
         )
         return (
             simulated_profit[0][0].item(),
             simulated_charge_cycles[0][0].item(),
             predicted_charge_threshold.item(),
             predicted_discharge_threshold.item(),
+            new_state_of_charge.squeeze(0).item(),
         )
 
     def evaluate_test_set(self, idx_samples, test_loader):
@@ -213,12 +221,20 @@ class PolicyEvaluator:
     def evaluate_test_set_for_penalty(self, idx_samples, test_loader, penalty):
         total_profit = 0
         total_charge_cycles = 0
+        state_of_charge = 0.0
 
         for date in tqdm(self.dates):
             try:
-                profit, charge_cycles, _, _ = self.evaluate_for_date(
-                    date, idx_samples, test_loader, penalty=penalty
+                profit, charge_cycles, _, _, new_state_of_charge = (
+                    self.evaluate_for_date(
+                        date,
+                        idx_samples,
+                        test_loader,
+                        penalty=penalty,
+                        state_of_charge=state_of_charge,
+                    )
                 )
+                state_of_charge = new_state_of_charge
                 total_profit += profit
                 total_charge_cycles += charge_cycles
             except KeyboardInterrupt: