From 25c864db613b2a066759d9fc459fa1f2ac49ec90 Mon Sep 17 00:00:00 2001 From: Dusan Vojacek Date: Tue, 26 May 2026 00:00:06 +0200 Subject: [PATCH] protazeni exportniho okna az do rana pred vyrobu FVE (prichazeli sme o prilezitosti mezi pulnoci a ranem) --- backend/services/planning_engine.py | 98 ++++++++---- backend/tests/test_planning_dispatch_milp.py | 151 ++++++++++++++++++- docs/04-modules/planning.md | 15 +- docs/planning-changelog.md | 8 + 4 files changed, 228 insertions(+), 44 deletions(-) diff --git a/backend/services/planning_engine.py b/backend/services/planning_engine.py index 59d233d..56bb4bf 100644 --- a/backend/services/planning_engine.py +++ b/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: - out.append(t) - return out + 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 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( diff --git a/backend/tests/test_planning_dispatch_milp.py b/backend/tests/test_planning_dispatch_milp.py index 971fa4b..48238fe 100644 --- a/backend/tests/test_planning_dispatch_milp.py +++ b/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) diff --git a/docs/04-modules/planning.md b/docs/04-modules/planning.md index 18666c8..ec46f8a 100644 --- a/docs/04-modules/planning.md +++ b/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`): diff --git a/docs/planning-changelog.md b/docs/planning-changelog.md index d73905d..9f9b726 100644 --- a/docs/planning-changelog.md +++ b/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.