protazeni exportniho okna az do rana pred vyrobu FVE (prichazeli sme o prilezitosti mezi pulnoci a ranem)

backend/services/planning_engine.py

@@ -68,11 +68,15 @@ NEG_BUY_CHARGE_SHORTFALL_PENALTY_CZK_KWH = 100.0
 PRE_NEG_CHARGE_PENALTY_CZK_KWH = 400.0
 PRE_NEG_BATT_EXPORT_SHORTFALL_PENALTY_CZK_KWH = 80.0
 PRE_NEG_BATT_EXPORT_MIN_SELL_CZK_KWH = 1.0
-PLANNER_BUILD_TAG = "2026-05-28-pv-positive-sell-solver-v29"
+PLANNER_BUILD_TAG = "2026-05-28-night-export-window-midnight-v30"
 POS_SELL_PRE_NEG_SOC_SHORTFALL_PENALTY_CZK_PER_WH = 0.30
 PRE_NEG_BUY_SOC_CEILING_SLACK_PENALTY_CZK_PER_WH = 0.25
 PRE_NEG_BUY_EMPTY_EXPORT_SHORTFALL_PENALTY_CZK_KWH = 80.0
 EVENING_PEAK_SELL_EPS_CZK_KWH = 0.05
+# Noční výprodej baterie: večer (≥17h) + ráno do východu FVE (0–5h Prague), jedna špička přes půlnoc.
+NIGHT_EXPORT_EVENING_START_HOUR = 17
+NIGHT_EXPORT_MORNING_END_HOUR = 5
+NIGHT_EXPORT_PV_SUNRISE_SURPLUS_W = 500.0
 # Převáží terminal SoC shadow price při krátkém večerním horizontu (home-01).
 EVENING_PUSH_Z_EXPORT_BONUS_CZK = 2500.0
 # buy<0: preferovat import před PV A→bat (měkké; tvrdé bc_pv=0 láme bilanci s polem B).
@@ -961,28 +965,71 @@ def _pre_neg_buy_discharge_indices(
     return out
 
 
+def _slot_pv_surplus_w(slot: PlanningSlot) -> float:
+    load_w = float(slot.load_baseline_w)
+    pv_w = float(slot.pv_a_forecast_w) + float(slot.pv_b_forecast_w)
+    return max(0.0, pv_w - load_w)
+
+
+def _in_night_battery_export_window(slot: PlanningSlot) -> bool:
+    """
+    Noční okno pro večerní push / peak sell: >=17h Prague, nebo 0–5h (přes půlnoc).
+    Končí prvním slotem s významným PV přebytkem (východ FVE), ne kalendářním dnem.
+    """
+    if _slot_pv_surplus_w(slot) > NIGHT_EXPORT_PV_SUNRISE_SURPLUS_W:
+        return False
+    h = _prague_hour(slot)
+    if h >= NIGHT_EXPORT_EVENING_START_HOUR:
+        return True
+    return h <= NIGHT_EXPORT_MORNING_END_HOUR
+
+
+def _night_export_window_segments(slots: list[PlanningSlot]) -> list[list[int]]:
+    """Souvislé úseky nočního okna v horizontu (oddělené denní pauzou / východem FVE)."""
+    segments: list[list[int]] = []
+    current: list[int] = []
+    for t, s in enumerate(slots):
+        if _in_night_battery_export_window(s):
+            current.append(t)
+        else:
+            if current:
+                segments.append(current)
+                current = []
+    if current:
+        segments.append(current)
+    return segments
+
+
+def _night_peak_sell_czk_kwh(slots: list[PlanningSlot], slot_index: int) -> float:
+    """Max sell v nočním úseku, do kterého slot patří (pro evening_early)."""
+    for seg in _night_export_window_segments(slots):
+        if slot_index in seg:
+            return max(float(slots[t].sell_price) for t in seg)
+    return 0.0
+
+
 def _evening_peak_export_indices(
     slots: list[PlanningSlot],
     *,
     degrad_czk_kwh: float,
     evening_start_hour: int = 17,
 ) -> list[int]:
-    """Večerní špičky per den (shodně s R__063, hour >= 17 Prague)."""
-    peak_by_day: dict = {}
-    for s in slots:
-        if _prague_hour(s) < evening_start_hour:
-            continue
-        d = _prague_calendar_date(s)
-        peak_by_day[d] = max(peak_by_day.get(d, 0.0), float(s.sell_price))
+    """
+    Noční špičky sell: jeden peak na souvislý úsek (17h → půlnoc → ráno do východu FVE),
+    ne per kalendářní den (oprava 23:30 vs 00:00).
+    """
+    _ = evening_start_hour  # kompatibilita volání; okno řídí NIGHT_EXPORT_* konstanty
     out: list[int] = []
-    for t, s in enumerate(slots):
-        if _prague_hour(s) < evening_start_hour:
+    for seg in _night_export_window_segments(slots):
+        if not seg:
             continue
-        d = _prague_calendar_date(s)
-        peak = peak_by_day.get(d, 0.0)
-        if peak > 0 and float(s.sell_price) >= peak - degrad_czk_kwh:
+        peak = max(float(slots[t].sell_price) for t in seg)
+        if peak <= 0.0:
+            continue
+        for t in seg:
+            if float(slots[t].sell_price) >= peak - degrad_czk_kwh:
                 out.append(t)
-    return out
+    return sorted(out)
 
 
 def _evening_push_discharge_budget_wh(
@@ -1017,11 +1064,10 @@ def _evening_battery_export_push_indices(
     evening_start_hour: int = 17,
 ) -> list[int]:
     """
-    Večerní push: plný ge_bat na top sell sloty (≥17h Prague).
+    Noční push: plný ge_bat na top sell sloty v nočním okně (≥17h + 0–5h do východu FVE).
 
-    Ne jeden slot — kolik slotů unese Wh rozpočet (v24), seřazených sell desc.
-    Kandidáti jen u denního večerního max − EVENING_PEAK_SELL_EPS (úzké pásmo),
-    ne celé široké peak−degrad. Ráno / odpoledne řeší jiné větve solveru.
+    Ne jeden slot — kolik slotů unese Wh rozpočet, seřazených sell desc.
+    Peak sell je max v celém nočním úseku (přes půlnoc), ne per kalendářní den.
     """
     if per_slot_discharge_wh <= 0.0:
         return []
@@ -1569,21 +1615,12 @@ def solve_dispatch(
                 discharge_slot_buffer=discharge_buf_pre,
             )
         )
-        max_evening_sell_by_day: dict[object, float] = {}
-        for t_ev, s_ev in enumerate(slots):
-            if _prague_hour(s_ev) < 17:
-                continue
-            d_ev = _prague_calendar_date(s_ev)
-            max_evening_sell_by_day[d_ev] = max(
-                max_evening_sell_by_day.get(d_ev, 0.0),
-                float(s_ev.sell_price),
-            )
         # Zákaz ge_bat jen *před* prvním push slotem (ne po něm — jinak terminal SoC + load
         # drží energii pro 19–21 h bez prodeje, home-01 téměř neexportuje).
         first_evening_push_t = min(evening_push_ts) if evening_push_ts else None
         if first_evening_push_t is not None:
             for t_ev, s_ev in enumerate(slots):
-                if _prague_hour(s_ev) < 17:
+                if not _in_night_battery_export_window(s_ev):
                     continue
                 if t_ev >= first_evening_push_t:
                     continue
@@ -1591,8 +1628,7 @@ def solve_dispatch(
                     continue
                 if t_ev in evening_push_ts:
                     continue
-                d_ev = _prague_calendar_date(s_ev)
-                peak_sell = max_evening_sell_by_day.get(d_ev, 0.0)
+                peak_sell = _night_peak_sell_czk_kwh(slots, t_ev)
                 if float(s_ev.sell_price) < peak_sell - EVENING_PEAK_SELL_EPS_CZK_KWH:
                     evening_early_export_penalty_ts.add(t_ev)
     last_pos_sell_pre_neg_buy = _last_non_negative_sell_before_neg_buy(

backend/tests/test_planning_dispatch_milp.py

@@ -13,7 +13,9 @@ from services.planning_engine import (
     _dynamic_arb_floor_wh_series,
     _dispatch_result_comparison,
     _evening_battery_export_push_indices,
+    _evening_peak_export_indices,
     _evening_push_discharge_budget_wh,
+    _in_night_battery_export_window,
     _pre_neg_buy_soc_ceiling_wh,
     _pre_neg_peak_sell_idx,
     _prague_hour,
@@ -166,6 +168,75 @@ class EveningPushBudgetTests(unittest.TestCase):
         )
         self.assertEqual(len(push_lo), 0)
 
+    def test_night_window_includes_midnight_excludes_pv_sunrise(self) -> None:
+        """23:30 a 00:00 jeden peak; po východu FVE (pv > load) už ne."""
+        prague = ZoneInfo("Europe/Prague")
+        slots = [
+            PlanningSlot(
+                interval_start=datetime(2026, 5, 25, 23, 15, tzinfo=prague),
+                buy_price=5.0,
+                sell_price=3.323,
+                pv_a_forecast_w=0,
+                pv_b_forecast_w=0,
+                load_baseline_w=1800,
+                ev1_connected=False,
+                ev2_connected=False,
+                allow_discharge_export=True,
+            ),
+            PlanningSlot(
+                interval_start=datetime(2026, 5, 25, 23, 30, tzinfo=prague),
+                buy_price=5.0,
+                sell_price=3.286,
+                pv_a_forecast_w=0,
+                pv_b_forecast_w=0,
+                load_baseline_w=1800,
+                ev1_connected=False,
+                ev2_connected=False,
+                allow_discharge_export=True,
+            ),
+            PlanningSlot(
+                interval_start=datetime(2026, 5, 26, 0, 0, tzinfo=prague),
+                buy_price=5.6,
+                sell_price=3.586,
+                pv_a_forecast_w=0,
+                pv_b_forecast_w=0,
+                load_baseline_w=1800,
+                ev1_connected=False,
+                ev2_connected=False,
+                allow_discharge_export=True,
+            ),
+            PlanningSlot(
+                interval_start=datetime(2026, 5, 26, 6, 0, tzinfo=prague),
+                buy_price=4.0,
+                sell_price=3.0,
+                pv_a_forecast_w=10_000,
+                pv_b_forecast_w=0,
+                load_baseline_w=1800,
+                ev1_connected=False,
+                ev2_connected=False,
+                allow_discharge_export=True,
+            ),
+        ]
+        self.assertTrue(_in_night_battery_export_window(slots[2]))
+        self.assertFalse(_in_night_battery_export_window(slots[3]))
+        peak_ts = _evening_peak_export_indices(slots, degrad_czk_kwh=0.15)
+        self.assertIn(2, peak_ts, "půlnoc musí být v nočním peak pásmu")
+        self.assertNotIn(3, peak_ts)
+        bat = _battery(uc_wh=64_000.0, min_pct=12.0, max_pct=95.0)
+        per_slot = 18_000 * 0.95 * 0.25
+        push = _evening_battery_export_push_indices(
+            slots,
+            profitable_export_ts={0, 1, 2, 3},
+            degrad_czk_kwh=0.15,
+            current_soc_wh=0.9 * bat.soc_max_wh,
+            min_soc_wh=bat.min_soc_wh,
+            soc_max_wh=bat.soc_max_wh,
+            per_slot_discharge_wh=per_slot,
+            discharge_slot_buffer=1.5,
+        )
+        self.assertIn(2, push, "nejvyšší sell 00:00 má být v push před 23:30")
+        self.assertEqual(push[0], 2)
+
     def test_evening_push_budget_matches_r063_formula(self) -> None:
         bat = _battery(uc_wh=64_000.0, min_pct=10.0, max_pct=95.0)
         soc = 0.85 * bat.soc_max_wh
@@ -1339,7 +1410,7 @@ class NegativeSellPvChargeTests(unittest.TestCase):
             50.0,
             operating_mode="AUTO",
         )
-        self.assertEqual(snap.get("planner_build_tag"), "2026-05-28-pv-positive-sell-solver-v29")
+        self.assertEqual(snap.get("planner_build_tag"), "2026-05-28-night-export-window-midnight-v30")
         self.assertGreater(
             results[0].battery_setpoint_w,
             2_500,
@@ -1489,7 +1560,7 @@ class NegativeSellPvChargeTests(unittest.TestCase):
             50.0,
             operating_mode="AUTO",
         )
-        self.assertEqual(snap.get("planner_build_tag"), "2026-05-28-pv-positive-sell-solver-v29")
+        self.assertEqual(snap.get("planner_build_tag"), "2026-05-28-night-export-window-midnight-v30")
         self.assertEqual(len(results), len(slots))
 
     def test_gen_cutoff_full_soc_neg_sell_with_pv_b_feasible(self) -> None:
@@ -1553,7 +1624,7 @@ class NegativeSellPvChargeTests(unittest.TestCase):
             55.0,
             operating_mode="AUTO",
         )
-        self.assertEqual(snap.get("planner_build_tag"), "2026-05-28-pv-positive-sell-solver-v29")
+        self.assertEqual(snap.get("planner_build_tag"), "2026-05-28-night-export-window-midnight-v30")
         self.assertEqual(len(results), len(slots))
 
     def test_fixed_tariff_neg_sell_no_grid_export(self) -> None:
@@ -2209,7 +2280,7 @@ class ChargeAcquisitionArbitrageTests(unittest.TestCase):
                 interval_start=base + timedelta(minutes=15 * i),
                 buy_price=0.8,
                 sell_price=sell,
-                pv_a_forecast_w=6000,
+                pv_a_forecast_w=0,
                 pv_b_forecast_w=0,
                 load_baseline_w=800,
                 ev1_connected=False,
@@ -2239,7 +2310,7 @@ class ChargeAcquisitionArbitrageTests(unittest.TestCase):
             50.0,
             operating_mode="AUTO",
         )
-        self.assertEqual(snap["planner_build_tag"], "2026-05-28-pv-positive-sell-solver-v29")
+        self.assertEqual(snap["planner_build_tag"], "2026-05-28-night-export-window-midnight-v30")
         peak_idx = sells.index(4.04)
         peak = results[peak_idx]
         self.assertIn(peak.export_mode, ("BATTERY_SELL", "PV_SURPLUS"))
@@ -2254,6 +2325,74 @@ class ChargeAcquisitionArbitrageTests(unittest.TestCase):
                 msg=f"slot {i} sell={sells[i]} must not battery-export before first push",
             )
 
+    def test_midnight_higher_sell_gets_battery_export(self) -> None:
+        """home-01 archetyp: export v 00:00 (vyšší sell), ne jen 23:30."""
+        prague = ZoneInfo("Europe/Prague")
+        slots = [
+            PlanningSlot(
+                interval_start=datetime(2026, 5, 25, 23, 15, tzinfo=prague),
+                buy_price=5.28,
+                sell_price=3.323,
+                pv_a_forecast_w=0,
+                pv_b_forecast_w=0,
+                load_baseline_w=1800,
+                ev1_connected=False,
+                ev2_connected=False,
+                allow_charge=False,
+                allow_discharge_export=True,
+                charge_acquisition_buy_czk_kwh=0.8,
+            ),
+            PlanningSlot(
+                interval_start=datetime(2026, 5, 25, 23, 30, tzinfo=prague),
+                buy_price=5.23,
+                sell_price=3.286,
+                pv_a_forecast_w=0,
+                pv_b_forecast_w=0,
+                load_baseline_w=1800,
+                ev1_connected=False,
+                ev2_connected=False,
+                allow_charge=False,
+                allow_discharge_export=True,
+                charge_acquisition_buy_czk_kwh=0.8,
+            ),
+            PlanningSlot(
+                interval_start=datetime(2026, 5, 26, 0, 0, tzinfo=prague),
+                buy_price=5.63,
+                sell_price=3.586,
+                pv_a_forecast_w=0,
+                pv_b_forecast_w=0,
+                load_baseline_w=1800,
+                ev1_connected=False,
+                ev2_connected=False,
+                allow_charge=False,
+                allow_discharge_export=True,
+                charge_acquisition_buy_czk_kwh=0.8,
+            ),
+        ]
+        battery = _battery(uc_wh=64_000.0, terminal_soc_value_factor=0.0)
+        battery.max_discharge_power_w = 18_000
+        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=17_000, max_export_power_w=13_500)
+        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),
+        ]
+        results, _, snap = solve_dispatch(
+            slots,
+            battery,
+            hp,
+            grid,
+            [None, None],
+            vehicles,
+            0.9 * battery.soc_max_wh,
+            50.0,
+            operating_mode="AUTO",
+        )
+        self.assertEqual(snap["planner_build_tag"], "2026-05-28-night-export-window-midnight-v30")
+        r_midnight = results[2]
+        self.assertEqual(r_midnight.export_mode, "BATTERY_SELL")
+        self.assertGreaterEqual(abs(r_midnight.grid_setpoint_w), 12_500)
+
     def test_evening_push_export_near_site_cap_home01(self) -> None:
         """home-01 večer: export ≈ min(13.5 kW, 18 kW − load), ne (max−load)/2."""
         prague = ZoneInfo("Europe/Prague")
@@ -2292,7 +2431,7 @@ class ChargeAcquisitionArbitrageTests(unittest.TestCase):
             50.0,
             operating_mode="AUTO",
         )
-        self.assertEqual(snap["planner_build_tag"], "2026-05-28-pv-positive-sell-solver-v29")
+        self.assertEqual(snap["planner_build_tag"], "2026-05-28-night-export-window-midnight-v30")
         r = results[0]
         self.assertEqual(r.export_mode, "BATTERY_SELL")
         self.assertGreaterEqual(abs(r.grid_setpoint_w), 12_500)

docs/04-modules/planning.md

@@ -64,9 +64,9 @@ Solver optimalizuje celý horizont (typicky do konce známých OTE dat, strop z
 - pohled dopředu (ráno ví že přes poledne bude záporná cena → prodává z baterie)
 - kompromisy mezi prodejem, nabíjením, TČ a EV v globálním optimu
 
-### Večerní export z baterie (v24–v27) — co plánovač dělá a co ne
+### Večerní / noční export z baterie (v24–v30) — co plánovač dělá a co ne
 
-Cíl zůstává **maximální ekonomický užitek v celém horizontu**: prodat (a nabít) v časech, kdy to dává smysl podle cen a kapacity baterie. Večerní logika **neřeší ráno před FVE** a **nevnucuje jediný slot**.
+Cíl zůstává **maximální ekonomický užitek v celém horizontu**: prodat (a nabít) v časech, kdy to dává smysl podle cen a kapacity baterie. **v30:** noční okno **přes půlnoc** (17:00 → 0–5:00 Prague), konec při **východu FVE** (`pv_a+pv_b > load + 500 W`); **tvrdý push baterie** jen v tmavých slotech, ne po východu slunce.
 
 #### Co se řeší jinde (není „večerní v26“)
 
@@ -74,14 +74,15 @@ Cíl zůstává **maximální ekonomický užitek v celém horizontu**: prodat (
 |---------------|------------------|---------|
 | Ráno **5–11** před prvním `sell < 0` | R__063 ranní pásmo + LP `morning_pre_neg_export_ts` | Export před záporným výkupním oknem, ne „před FVE“ jako takové |
 | Odpoledne / noc, obecně profitable | `allow_discharge_export` z rozpočtu Wh + LP `peak_export_shortfall` | Kdekoliv v horizontu, pokud marže sedí |
-| **≥ 17:00** večer | v24 Wh push + **v26** doplnění níže | Špička OTE večer |
+| **≥ 17:00** večer + **0–5:00** (v30) | v24 Wh push + v26/v28 + **noční peak přes půlnoc** | OTE špička i kolem půlnoci |
+| Po východu FVE | konec nočního okna | push / peak jen `pv` pod prahem |
 
-#### Tři vrstvy večerního chování (od 17:00 Prague)
+#### Tři vrstvy nočního chování (v30: 17:00 → půlnoc → do východu FVE)
 
 ```mermaid
 flowchart TD
   A[LP: globální optimum v horizontu] --> B{slot >= 17h a profitable export?}
-  B -->|sell pod dennim vecer. max - 0.05| C[ge_bat = 0: baterie ne pred spickou]
+  B -->|sell pod nocnim max - 0.05| C[ge_bat = 0: baterie ne pred spickou]
   B -->|sell v top pasme max - 0.05| D[evening_push kandidat]
   D --> E[Seradit sell desc, pridat sloty az do Wh rozpoctu]
   E --> F[ge_bat >= plny vykon na cap v kazdem push slotu]
@@ -92,8 +93,8 @@ flowchart TD
 1. **SQL masky (R__063, vrstva 2)** — které večerní sloty *smí* export z baterie vůbec (`allow_discharge_export`): mimo jiné sloty v pásmu „denní večerní max − degrad“ (SQL), plus globální Wh rozpočet (vrstva 1).
 
 2. **v27 — zákaz předčasného večerního vývozu** (`evening_early_export_penalty_ts` → tvrdé `ge_bat[t] = 0`):
-   - jen **hodiny ≥ 17** a **časově před** prvním slotem v `evening_push_ts` (ne po něm — v26 blokovalo i 19–21 h);
-   - jen pokud `sell < max_večer − 0,05` Kč/kWh;
+   - jen v **nočním okně** (`_in_night_battery_export_window`) a **časově před** prvním slotem v `evening_push_ts`;
+   - jen pokud `sell < max_sell_v_nočním_úseku − 0,05` (v30: max přes půlnoc, ne per kalendářní den);
    - **nezakazuje** přebytek FVE do sítě (`ge_pv`).
 
 3. **v24 + v27 — plný výkon v top večerních slotech** (`evening_push_ts`):

docs/planning-changelog.md

@@ -5,6 +5,14 @@ Formát: **datum (ISO)** · stručný důvod · soubory · chování / ověřen
 
 ---
 
+## 2026-05-28 — Noční export přes půlnoc, konec při východu FVE (v30)
+
+**Problém (home-01 run 17388):** Večerní peak **per kalendářní den** → export v **23:30** (3,29 Kč), slot **00:00** (3,59 Kč) bez `BATTERY_SELL` (nový den, hour < 17).
+
+**Změna (tag `2026-05-28-night-export-window-midnight-v30`):** `_night_export_window_segments` — okno **≥17h** + **0–5h** Prague, konec při `pv_a+pv_b > load + 500 W`. `_evening_peak_export_indices` / push / `evening_early` používají **jeden max sell v nočním úseku** (přes půlnoc). Po východu FVE žádný tvrdý push baterie.
+
+**Ověření:** `pytest … -k night_window_includes_midnight or midnight_higher_sell` · `planner_build_tag` **v30**.
+
 ## 2026-05-28 — FVE při kladném sell: solver místo pv_store curtail (v29)
 
 **Problém (home-01 odpoledne):** `ge_pv = 0` když `sell < max(future_sell)` (např. 3 Kč vs. večerních 6 Kč) při plné baterii → **curtail** celého pole A. Záměr „držet na večerní peak“ měl platit pro **baterii** (`ge_bat`), ne blokovat export FVE.