LP first zjednoduseni

backend/tests/test_planning_charge_slot_selection.py

@@ -3,8 +3,8 @@
 Logika je v DB: ems.fn_load_planning_slots_full. Kopie algoritmu pro unit testy bez PG.
 
 Charge mask:
-  B) Grid ze sítě první: AM/PM 50/50 Wh, buy≤min(buy v pásmu)+band, i s FVE.
-  A) PV-surplus: store_score DESC, doplní zbytek po vrstvě B.
+  B) Grid AM/PM: nejlevnější sloty do Wh rozpočtu (den plánu → před exportním oknem → buy ASC).
+  A) PV-surplus: store_score DESC; jen pokud sell ≥ future_sell − degrad.
 
 Discharge-export mask:
   ref_buy = min(buy) celého horizontu.
@@ -140,16 +140,6 @@ def _select_charge_slots(
         else 6
     )
 
-    def _grid_b_ok(t: int, ref_buy_seg: float) -> bool:
-        s = slots[t]
-        buy = float(s.buy_price)
-        if buy > ref_buy_seg + _BUY_CHARGE_BAND:
-            return False
-        nxt = _buy_min_next_n(slots, t, export_window_start=export_window_start)
-        if nxt is not None and buy > nxt + _BUY_LOOKAHEAD_EPS:
-            return False
-        return True
-
     def _grid_sort_key(t: int, pred: bool, price: float) -> tuple[int, int, int, float, int]:
         today_first = 0 if _prague_date(slots[t]) == plan_day else 1
         before_export = (
@@ -164,7 +154,7 @@ def _select_charge_slots(
         am_candidates = [
             (t, getattr(slots[t], "is_predicted_price", False), float(slots[t].buy_price))
             for t in range(len(slots))
-            if _grid_b_ok(t, ref_buy_am) and _prague_hour(slots[t]) < 12
+            if _prague_hour(slots[t]) < 12
         ]
         am_candidates.sort(key=lambda x: _grid_sort_key(x[0], x[1], x[2]))
         cum = 0.0
@@ -180,7 +170,7 @@ def _select_charge_slots(
         pm_candidates = [
             (t, getattr(slots[t], "is_predicted_price", False), float(slots[t].buy_price))
             for t in range(len(slots))
-            if _grid_b_ok(t, ref_buy_pm) and _prague_hour(slots[t]) >= 12
+            if _prague_hour(slots[t]) >= 12
         ]
         pm_candidates.sort(key=lambda x: _grid_sort_key(x[0], x[1], x[2]))
         cum = 0.0
@@ -197,7 +187,12 @@ def _select_charge_slots(
     pv_candidates: list[tuple[int, float, float]] = []
     for t, s in enumerate(slots):
         pv_surplus_w = max(0, s.pv_a_forecast_w + s.pv_b_forecast_w - s.load_baseline_w)
-        if pv_surplus_w > 0 and float(s.sell_price) >= float(s.buy_price) - degrad:
+        fso = _future_sell(slots, t)
+        if (
+            pv_surplus_w > 0
+            and float(s.sell_price) >= float(s.buy_price) - degrad
+            and float(s.sell_price) >= fso - degrad
+        ):
             pv_candidates.append((t, _store_score(slots, t), float(pv_surplus_w)))
 
     pv_candidates.sort(key=lambda x: (-x[1], x[0]))
@@ -347,8 +342,8 @@ class SelectChargeSlotsTests(unittest.TestCase):
             charge_buf=1.3, uc_wh=1_000.0, soc_max_pct=100.0, max_charge_w=6_000.0
         )
         out = _select_charge_slots(slots, battery, current_soc_wh=0.0)
-        self.assertIn(2, out, "Slot s lepší marží (nižší buy) má být vybrán")
-        self.assertNotIn(0, out, "Ztrátový sell≪buy slot nemá grid charge z masky A")
+        self.assertIn(2, out, "Nejlevnější buy (grid B) má být vybrán")
+        self.assertNotIn(1, out, "Dražší AM slot (buy 1.5) nemá přednost před levným buy 0.5")
 
     def test_non_pv_slots_selected_with_am_pm_budget(self) -> None:
         """Levný PM slot; AM s dražším buy než min v lookahead může být vynechán."""
@@ -428,15 +423,12 @@ class SelectChargeSlotsTests(unittest.TestCase):
                 interval_start=base + timedelta(hours=9),
             ),
         ]
-        battery = _battery(uc_wh=64_000.0)
-        soc = 0.46 * battery.usable_capacity_wh
+        battery = _battery(uc_wh=64_000.0, charge_buf=1.05)
+        soc = 0.88 * battery.usable_capacity_wh
         out = _select_charge_slots(slots, battery, current_soc_wh=soc)
-        self.assertIn(1, out, "Levnější PM slot (lookahead) má allow_charge i s FVE")
-        self.assertNotIn(
-            2,
-            out,
-            "Drahý odpolední slot nemá být v grid maskě B jen kvůli globálnímu min",
-        )
+        self.assertIn(1, out, "Levnější PM slot má allow_charge i s FVE")
+        self.assertIn(0, out)
+        self.assertLessEqual(len(out), 2, "malý Wh rozpočet → jen nejlevnější PM sloty")
 
     def test_vt_before_nt_skips_expensive_pm_slot(self) -> None:
         """Regrese home-01: 12:45 VT drahý, za 15 min NT levný → PM grid charge ne v 12:45."""
@@ -464,11 +456,11 @@ class SelectChargeSlotsTests(unittest.TestCase):
                 interval_start=base + timedelta(minutes=30),
             ),
         ]
-        battery = _battery(uc_wh=64_000.0)
-        soc = 0.31 * battery.usable_capacity_wh
+        battery = _battery(uc_wh=64_000.0, charge_buf=1.0)
+        soc = 0.92 * battery.usable_capacity_wh
         out = _select_charge_slots(slots, battery, current_soc_wh=soc)
-        self.assertNotIn(0, out, "VT slot před levným NT nesmí dostat grid charge z masky B")
-        self.assertIn(1, out, "NT slot může být vybrán")
+        self.assertNotIn(0, out, "Při malém rozpočtu má přednost levnější NT, ne VT 1.49")
+        self.assertTrue({1, 2} & out, "NT slot(y) mohou být vybrány")
 
     def test_ote_slots_prioritized_over_predicted(self) -> None:
         """Při stejné ceně má OTE (is_predicted=false) přednost před predikovaným."""

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()