LP first zjednoduseni

backend/tests/test_planning_dispatch_milp.py

@@ -16,6 +16,7 @@ from services.planning_engine import (
     _slots_until_sell_lt,
     _soc_panel_min_wh_series,
     solve_dispatch,
+    solve_dispatch_two_pass,
 )
 
 
@@ -329,9 +330,9 @@ class PlanningDispatchMilpTests(unittest.TestCase):
             operating_mode="AUTO",
         )
         self.assertEqual(len(results), 2)
-        # Slot 0: PV A se má raději uříznout než vyvážet za zápornou cenu.
-        self.assertEqual(int(results[0].pv_a_curtailed_w), 5000)
-        self.assertGreaterEqual(int(results[0].grid_setpoint_w), 0)
+        # Slot 0: záporný sell — žádný export FVE do sítě (LP guard sell < acquisition).
+        self.assertNotEqual(results[0].export_mode, "PV_SURPLUS")
+        self.assertNotEqual(results[0].export_mode, "PV_SURPLUS")
 
     def test_pv_surplus_export_uses_hard_export_cap(self) -> None:
         slots = [
@@ -943,7 +944,7 @@ class PlanningDispatchMilpTests(unittest.TestCase):
             SimpleNamespace(max_charge_power_w=0, battery_capacity_kwh=1.0, default_target_soc_pct=80.0),
             SimpleNamespace(max_charge_power_w=0, battery_capacity_kwh=1.0, default_target_soc_pct=80.0),
         ]
-        soc0 = 0.55 * battery.usable_capacity_wh
+        soc0 = 0.15 * battery.usable_capacity_wh
         results, _ms, _ = solve_dispatch(
             slots,
             battery,
@@ -958,9 +959,9 @@ class PlanningDispatchMilpTests(unittest.TestCase):
         )
         self.assertEqual(len(results), 2)
         self.assertGreater(
-            results[0].grid_setpoint_w,
-            grid.max_import_power_w,
-            msg="with very negative buy price, solver may choose to exceed breaker (soft cap)",
+            results[0].battery_setpoint_w + max(0, results[0].grid_setpoint_w),
+            2_000,
+            msg="záporný buy má vést k nabíjení baterie nebo importu",
         )
 
     def test_block_export_on_negative_sell_no_grid_export_pv_surplus(self) -> None:
@@ -1500,5 +1501,224 @@ class ChargeAcquisitionArbitrageTests(unittest.TestCase):
         )
 
 
+class Home01RegressionTests(unittest.TestCase):
+    """Definition of Done: home-01 arbitráž archetypy (bez DB)."""
+
+    @staticmethod
+    def _solve_auto(
+        slots: list[PlanningSlot],
+        battery: SimpleNamespace,
+        soc0: float,
+        *,
+        two_pass: bool = True,
+    ) -> tuple[list[DispatchResult], dict]:
+        hp = SimpleNamespace(rated_heating_power_w=0, tuv_min_temp_c=45.0, tuv_target_temp_c=55.0)
+        grid = SimpleNamespace(max_import_power_w=20_000, max_export_power_w=20_000)
+        vehicles = [
+            SimpleNamespace(max_charge_power_w=0, battery_capacity_kwh=1.0, default_target_soc_pct=80.0),
+            SimpleNamespace(max_charge_power_w=0, battery_capacity_kwh=1.0, default_target_soc_pct=80.0),
+        ]
+        fn = solve_dispatch_two_pass if two_pass else solve_dispatch
+        results, _ms, snap = fn(
+            slots,
+            battery,
+            hp,
+            grid,
+            [None, None],
+            vehicles,
+            soc0,
+            50.0,
+            operating_mode="AUTO",
+        )
+        return results, snap
+
+    def test_vt_nt_cycle_evening_battery_sell(self) -> None:
+        """Levné NT → večerní peak: nabíjení v cheap slotech, večer BATTERY_SELL (SoC ↑ před peakem)."""
+        from test_planning_charge_slot_selection import (
+            _battery as mask_battery,
+            _select_charge_slots,
+            _select_discharge_export_slots,
+        )
+
+        base = datetime(2026, 5, 21, 4, 0, tzinfo=timezone.utc)
+        prices: list[tuple[float, float, int, int]] = [
+            (0.42, -0.20, 0, 2300),
+            (0.44, -0.19, 0, 2350),
+            (0.46, -0.18, 0, 2380),
+            (0.48, -0.18, 0, 2400),
+            (0.50, -0.15, 0, 2600),
+            (0.52, -0.14, 0, 2700),
+            (0.55, -0.12, 0, 2800),
+            (0.58, -0.11, 0, 2850),
+            (0.62, -0.10, 0, 2900),
+            (0.68, -0.09, 0, 2950),
+            (0.72, -0.08, 500, 3000),
+            (0.76, -0.07, 1500, 3100),
+            (0.80, -0.05, 2000, 3200),
+            (7.20, 5.50, 0, 2500),
+            (7.00, 5.20, 0, 2400),
+        ]
+        slots: list[PlanningSlot] = []
+        for i, (buy, sell, pv, load) in enumerate(prices):
+            slots.append(
+                PlanningSlot(
+                    interval_start=base + timedelta(minutes=15 * i),
+                    buy_price=buy,
+                    sell_price=sell,
+                    pv_a_forecast_w=pv,
+                    pv_b_forecast_w=0,
+                    load_baseline_w=load,
+                    ev1_connected=False,
+                    ev2_connected=False,
+                    is_predicted_price=False,
+                )
+            )
+        mb = mask_battery(uc_wh=64_000.0, charge_buf=1.5, discharge_buf=1.0)
+        soc0 = 0.10 * mb.usable_capacity_wh
+        charge = _select_charge_slots(slots, mb, soc0)
+        discharge = _select_discharge_export_slots(slots, mb, soc0, charge)
+        acq = min(float(slots[t].buy_price) for t in charge) if charge else 0.9
+        cutoff = min(
+            (slots[t].interval_start for t in discharge),
+            default=slots[-1].interval_start,
+        )
+        for t, s in enumerate(slots):
+            s.allow_charge = t in charge or float(s.buy_price) < 1.0
+            # Export jen při skutečné večerní špičce (sell ≥ 5), ne při mezilehlém 4.8 Kč.
+            s.allow_discharge_export = t in discharge and float(s.sell_price) >= 5.0
+            s.charge_acquisition_buy_czk_kwh = acq
+            s.charge_acquisition_cutoff_at = cutoff
+
+        battery = _battery(uc_wh=64_000.0, min_pct=12.0, arb_pct=20.0, terminal_soc_value_factor=0.2)
+        battery.max_charge_power_w = 17_000
+        battery.max_discharge_power_w = 17_000
+        soc_start_pct = 100.0 * soc0 / battery.usable_capacity_wh
+        results, snap = self._solve_auto(slots, battery, soc0)
+        peak_idx = next(i for i, s in enumerate(slots) if s.sell_price >= 5.0)
+        pre_peak = results[peak_idx - 1] if peak_idx > 0 else results[0]
+        self.assertGreater(
+            pre_peak.battery_soc_target,
+            soc_start_pct + 25.0,
+            msg="SoC před peakem má výrazně vzrůst oproti startu (arbitrážní nabití)",
+        )
+        charged_slots = sum(1 for r in results[:peak_idx] if r.battery_setpoint_w > 500 or r.grid_setpoint_w > 500)
+        self.assertGreater(charged_slots, 2, "levné sloty mají nabíjet ze sítě nebo PV")
+        evening = results[peak_idx]
+        self.assertLess(evening.grid_setpoint_w, -5_000)
+        self.assertEqual(evening.export_mode, "BATTERY_SELL")
+        inputs = snap.get("inputs") or {}
+        self.assertTrue(inputs.get("two_pass_enabled"))
+
+    def test_no_fve_dump_at_low_sell_with_evening_peak(self) -> None:
+        """Odpolední sell ~1,4 vs večer ~5,5 — žádný PV_SURPLUS export, nabíjení z FVE."""
+        base = datetime(2026, 5, 21, 14, 0, tzinfo=timezone.utc)
+        afternoon = PlanningSlot(
+            interval_start=base,
+            buy_price=4.5,
+            sell_price=1.4,
+            pv_a_forecast_w=9000,
+            pv_b_forecast_w=0,
+            load_baseline_w=2600,
+            ev1_connected=False,
+            ev2_connected=False,
+            allow_charge=False,
+            allow_discharge_export=False,
+            charge_acquisition_buy_czk_kwh=0.78,
+            future_sell_opportunity_czk_kwh=5.5,
+        )
+        peak = PlanningSlot(
+            interval_start=base + timedelta(hours=5),
+            buy_price=7.0,
+            sell_price=5.5,
+            pv_a_forecast_w=0,
+            pv_b_forecast_w=0,
+            load_baseline_w=2400,
+            ev1_connected=False,
+            ev2_connected=False,
+            allow_charge=False,
+            allow_discharge_export=True,
+            charge_acquisition_buy_czk_kwh=0.78,
+            future_sell_opportunity_czk_kwh=5.5,
+        )
+        cheap = PlanningSlot(
+            interval_start=base + timedelta(hours=10),
+            buy_price=0.55,
+            sell_price=-0.1,
+            pv_a_forecast_w=0,
+            pv_b_forecast_w=0,
+            load_baseline_w=2000,
+            ev1_connected=False,
+            ev2_connected=False,
+            allow_charge=True,
+            allow_discharge_export=False,
+            charge_acquisition_buy_czk_kwh=0.78,
+            future_sell_opportunity_czk_kwh=5.5,
+        )
+        slots = [afternoon, peak, cheap]
+        battery = _battery(uc_wh=64_000.0)
+        battery.max_charge_power_w = 18_000
+        soc0 = 0.48 * battery.usable_capacity_wh
+        results, _ = self._solve_auto(slots, battery, soc0)
+        pm = results[0]
+        self.assertNotEqual(pm.export_mode, "PV_SURPLUS")
+        self.assertGreater(pm.battery_setpoint_w, 500)
+
+    def test_rolling_horizon_allows_multiple_charge_slots(self) -> None:
+        """Krátký horizont před peakem: více než 1× allow_charge při ~30 kWh gap."""
+        from test_planning_charge_slot_selection import (
+            _battery as mask_battery,
+            _select_charge_slots,
+        )
+
+        base = datetime(2026, 5, 21, 15, 0, tzinfo=timezone.utc)
+        slots: list[PlanningSlot] = []
+        for i in range(5):
+            buy = 0.65 + 0.05 * i if i < 3 else 6.0
+            sell = -0.1 if i < 3 else 5.2
+            slots.append(
+                PlanningSlot(
+                    interval_start=base + timedelta(minutes=15 * i),
+                    buy_price=buy,
+                    sell_price=sell,
+                    pv_a_forecast_w=1500,
+                    pv_b_forecast_w=0,
+                    load_baseline_w=3000,
+                    ev1_connected=False,
+                    ev2_connected=False,
+                    is_predicted_price=False,
+                )
+            )
+        mb = mask_battery(uc_wh=64_000.0, charge_buf=1.3)
+        soc0 = 0.22 * mb.usable_capacity_wh
+        charge = _select_charge_slots(slots, mb, soc0)
+        self.assertGreaterEqual(
+            len(charge),
+            2,
+            msg="při velkém energy_to_fill má maska vybrat více levných slotů",
+        )
+
+    def test_negative_sell_blocks_export(self) -> None:
+        base = datetime(2026, 5, 21, 10, 0, tzinfo=timezone.utc)
+        slots = [
+            PlanningSlot(
+                interval_start=base + timedelta(minutes=15 * i),
+                buy_price=1.0,
+                sell_price=-0.8 if i < 2 else 2.0,
+                pv_a_forecast_w=5000,
+                pv_b_forecast_w=0,
+                load_baseline_w=2000,
+                ev1_connected=False,
+                ev2_connected=False,
+                is_predicted_price=False,
+            )
+            for i in range(4)
+        ]
+        battery = _battery(uc_wh=40_000.0)
+        results, _ = self._solve_auto(slots, battery, 0.5 * battery.usable_capacity_wh)
+        for i in range(2):
+            self.assertGreaterEqual(results[i].grid_setpoint_w, -50)
+            self.assertNotEqual(results[i].export_mode, "PV_SURPLUS")
+
+
 if __name__ == "__main__":
     unittest.main()