feat: gate early overhang charging by price proximity

Co-authored-by: MaStr <1036501+MaStr@users.noreply.github.com>

Author: Copilot

src/batcontrol/logic/default.py

@@ -423,13 +423,18 @@ def __get_required_recharge_energy(self, calc_input: CalculationInput ,
             if self.enable_precharge_overhang:
                 recharge_energy = self.__get_recharge_overhang_energy(
                     recharge_energy,
-                    turning_point_hour
+                    turning_point_hour,
+                    current_price,
+                    prices,
+                    min_price_difference
                 )
 
         self.calculation_output.required_recharge_energy = recharge_energy
         return recharge_energy
 
-    def __get_recharge_overhang_energy(self, recharge_energy: float, turning_point_hour: Optional[int]) -> float:
+    def __get_recharge_overhang_energy(self, recharge_energy: float, turning_point_hour: Optional[int],
+                                       current_price: float, prices: dict,
+                                       min_price_difference: float) -> float:
         """ Return recharge overhang if more than one charging slot is needed """
         if turning_point_hour is None or turning_point_hour < 1:
             return recharge_energy
@@ -447,6 +452,17 @@ def __get_recharge_overhang_energy(self, recharge_energy: float, turning_point_h
         if required_slots <= 1:
             return recharge_energy
 
+        next_lowest_price = min(prices[h] for h in range(1, len(prices)))
+        allowed_price_distance = min_price_difference / 2
+        if abs(current_price - next_lowest_price) > allowed_price_distance:
+            logger.debug(
+                "[Rule] Skip recharge overhang before turning point. Current price %.4f is not within %.4f of next lowest price %.4f.",
+                current_price,
+                allowed_price_distance,
+                next_lowest_price
+            )
+            return recharge_energy
+
         overhang_energy = recharge_energy - usable_charge_per_slot
         logger.debug(
             "[Rule] Recharge overhang detected (%0.1f Wh, %d slots). Charging overhang before turning point in hour %d.",

tests/batcontrol/logic/test_default.py

@@ -349,7 +349,7 @@ def test_recharge_overhang_is_charged_before_turning_point(self):
         calc_input = CalculationInput(
             consumption=np.array([100, 3500, 100]),
             production=np.array([0, 0, 0]),
-            prices={0: 0.20, 1: 0.40, 2: 0.10},
+            prices={0: 0.12, 1: 0.40, 2: 0.10},
             stored_energy=stored_energy,
             stored_usable_energy=stored_usable_energy,
             free_capacity=free_capacity,
@@ -366,6 +366,46 @@ def test_recharge_overhang_is_charged_before_turning_point(self):
             msg="Expected to charge only the overhang before the turning point"
         )
 
+    def test_recharge_overhang_is_skipped_when_current_price_too_high(self):
+        """Test that overhang precharge is skipped if current price is too far from next low."""
+        self.logic.enable_precharge_overhang = True
+        self.logic.max_charge_loss_factor = 0.1
+        self.logic.set_calculation_parameters(
+            CalculationParameters(
+                max_charging_from_grid_limit=0.79,
+                min_price_difference=0.05,
+                min_price_difference_rel=0.2,
+                max_capacity=self.max_capacity,
+                max_grid_charge_rate=2000
+            )
+        )
+
+        stored_energy = 1000
+        stored_usable_energy, free_capacity = self._calculate_battery_values(
+            stored_energy,
+            self.max_capacity
+        )
+
+        calc_input = CalculationInput(
+            consumption=np.array([100, 3500, 100]),
+            production=np.array([0, 0, 0]),
+            prices={0: 0.20, 1: 0.40, 2: 0.10},
+            stored_energy=stored_energy,
+            stored_usable_energy=stored_usable_energy,
+            free_capacity=free_capacity,
+        )
+
+        calc_timestamp = datetime.datetime(2025, 6, 20, 12, 0, 0, tzinfo=datetime.timezone.utc)
+        self.assertTrue(self.logic.calculate(calc_input, calc_timestamp))
+        calc_output = self.logic.get_calculation_output()
+
+        self.assertAlmostEqual(
+            calc_output.required_recharge_energy,
+            3100.0,
+            delta=0.1,
+            msg="Expected full recharge amount when current price is still too expensive"
+        )
+
     def test_recharge_overhang_feature_flag_disables_behavior(self):
         """Test that disabling the feature flag keeps full recharge amount."""
         self.logic.enable_precharge_overhang = False