diff --git a/backend/services/planning_engine.py b/backend/services/planning_engine.py index 6b242a8..efb73fc 100644 --- a/backend/services/planning_engine.py +++ b/backend/services/planning_engine.py @@ -64,7 +64,11 @@ NEG_SELL_PV_B_VENT_PENALTY_CZK_KWH = 4.0 # Výboj baterie při sell<0 jen těsně před extrémně záporným buy (round-trip arbitráž). EXTREME_BUY_DUMP_PREWINDOW_SLOTS = 12 NEG_SELL_BAT_DUMP_SHORTFALL_PENALTY_CZK_KWH = 80.0 -PLANNER_BUILD_TAG = "2026-05-27-site-export-cap-from-db-v18" +# Měkký tlak: v buy<0 slotech max import ze sítě do baterie (zisk z OTE záporného nákupu). +NEG_BUY_GRID_CHARGE_SHORTFALL_PENALTY_CZK_KWH = 120.0 +# Měkký tlak: v buy<0 okně dobít na soc_max (ne zastavit na ~94 %). +NEG_BUY_SOC_UNDERFILL_PENALTY_CZK_PER_WH = 0.45 +PLANNER_BUILD_TAG = "2026-05-27-pre-neg-buy-strategy-v19" CORRECTION_WINDOW_H = 1 # hodina zpět pro výpočet korekčního faktoru CORRECTION_MIN_CLAMP = 0.5 # spodní limit korekčního faktoru CORRECTION_MAX_CLAMP = 1.5 # horní limit korekčního faktoru @@ -933,6 +937,31 @@ def _evening_battery_export_push_indices( return sorted(out) +def _pre_neg_buy_discharge_push_indices( + slots: list[PlanningSlot], + pre_neg_buy_discharge_ts: set[int], + *, + max_slots_per_day: int = 8, +) -> list[int]: + """ + Tvrdý push ge_bat jen u nejlepších sell slotů před buy<0. + Jinak součet max výbojů přes celou noc může překročit SoC → Infeasible. + """ + by_day: dict = {} + for t in pre_neg_buy_discharge_ts: + d = _prague_calendar_date(slots[t]) + by_day.setdefault(d, []).append(t) + out: list[int] = [] + for d in sorted(by_day.keys()): + ranked = sorted( + by_day[d], + key=lambda i: float(slots[i].sell_price), + reverse=True, + ) + out.extend(ranked[:max_slots_per_day]) + return sorted(out) + + def _planner_soc_for_solver( current_soc_wh: float, battery, @@ -1185,6 +1214,7 @@ def solve_dispatch( om = (operating_mode or "AUTO").strip().upper() charge_slots: set[int] = set() discharge_export_slots: set[int] = set() + pre_neg_buy_discharge_ts: set[int] = set() if om == "AUTO": charge_slots = {t for t, s in enumerate(slots) if s.allow_charge} charge_slots |= { @@ -1208,10 +1238,6 @@ def solve_dispatch( } # Vybití baterie před `buy<0` oknem: pokud je v horizontu buy<0, můžeme baterii # vybít teď za `sell` a v buy<0 okně ji nabít za záporný buy (= příjem). - # Ekonomicky výhodné dokud: sell_t > avg_buy_neg + degradation - # (vybíjet ztratíme ~discharge_eff loss, nabíjení v buy<0 nás platí; marže ~ sell − buy_neg − degrad). - # Cílem je obejít to, že R__063 v noci dává allow_discharge_export=false a LP - # by jinak nemohl baterku vyklidit přes ge_bat. _neg_buy_for_disch = next( (t for t, s in enumerate(slots) if float(s.buy_price) < 0), None ) @@ -1222,12 +1248,16 @@ def solve_dispatch( if float(slots[t].buy_price) < 0 ] _avg_neg_buy = sum(_neg_buy_prices) / len(_neg_buy_prices) if _neg_buy_prices else 0.0 - # Práh = avg buy<0 + degradation cycle overhead; default fallback 0.1 Kč/kWh - # když z nějakého důvodu neumíme spočítat (ochrana proti vybití do mínusu). _disch_sell_thr = max(_avg_neg_buy + float(degradation_cost_effective), 0.1) for t in range(_neg_buy_for_disch): - if float(slots[t].sell_price) >= _disch_sell_thr: + st = slots[t] + if float(st.sell_price) < _disch_sell_thr: + continue + # Jen sloty, kde SQL už povolilo export, nebo je výrazný kladný sell + # (rozšíření discharge_export_slots na celé dopoledne dělá krátké horizonty infeasible). + if st.allow_discharge_export or float(st.sell_price) >= 1.0: discharge_export_slots.add(t) + pre_neg_buy_discharge_ts.add(t) # SELF_SUSTAIN dřív vynucoval ge[t] == 0, což umí udělat MILP infeasible v okamžiku, kdy: # - baterie je na max SoC (nelze nabíjet), # - PV pole B není curtailable, @@ -1405,6 +1435,9 @@ def solve_dispatch( pv_charge_shortfall: list[tuple[int, pulp.LpVariable, float]] = [] neg_sell_bat_dump_shortfall: list[tuple[int, pulp.LpVariable, float]] = [] neg_sell_soc_underfill: list[tuple[int, pulp.LpVariable]] = [] + neg_buy_soc_underfill: list[tuple[int, pulp.LpVariable]] = [] + neg_buy_grid_shortfall: list[tuple[int, pulp.LpVariable, float]] = [] + pre_neg_buy_export_shortfall: list[tuple[int, pulp.LpVariable, float]] = [] fixed_tariff_like = fixed_tariff_like_pre block_export_neg_sell = bool(getattr(grid, "block_export_on_negative_sell", False)) if om == "AUTO": @@ -1456,11 +1489,17 @@ def solve_dispatch( cap_w = float(min(pv_surplus_w, battery.max_charge_power_w)) sf_pv = pulp.LpVariable(f"post_neg_pv_shortfall_{t}", 0, cap_w) pv_charge_shortfall.append((t, sf_pv, cap_w)) + _neg_buy_idx_soc = next( + (t for t, s in enumerate(slots) if float(s.buy_price) < 0), None + ) for t in range(T): if float(slots[t].sell_price) >= 0: continue if t not in charge_slots: continue + # Před buy<0 nehonit soc_max — kapacitu šetříme na záporný nákup. + if _neg_buy_idx_soc is not None and t < _neg_buy_idx_soc: + continue pv_surplus_w = max( 0.0, float(slots[t].pv_a_forecast_w) @@ -1475,6 +1514,36 @@ def solve_dispatch( float(battery.usable_capacity_wh), ) neg_sell_soc_underfill.append((t, us)) + for t in range(T): + if float(slots[t].buy_price) >= 0: + continue + us_buy = pulp.LpVariable( + f"neg_buy_soc_under_{t}", + 0, + float(battery.usable_capacity_wh), + ) + neg_buy_soc_underfill.append((t, us_buy)) + # Grid charge shortfall jen pokud je v slotu reálně headroom (soc panel min pod max). + headroom_wh = float(battery.soc_max_wh) - float(soc_panel_min[t]) + if headroom_wh < 500.0: + continue + cap_gi = float( + min( + battery.max_charge_power_w, + grid.max_import_power_w, + headroom_wh / max(INTERVAL_H * battery.charge_efficiency, 1e-6), + ) + ) + if cap_gi < 500.0: + continue + sf_gi = pulp.LpVariable(f"neg_buy_gi_shortfall_{t}", 0, cap_gi) + neg_buy_grid_shortfall.append((t, sf_gi, cap_gi)) + for t in pre_neg_buy_discharge_ts: + if t not in discharge_export_slots: + continue + cap_pre = float(_battery_export_cap_w(battery, grid)) + sf_pre = pulp.LpVariable(f"preneg_buy_disch_sf_{t}", 0, cap_pre) + pre_neg_buy_export_shortfall.append((t, sf_pre, cap_pre)) for t in neg_sell_bat_dump_slots: dump_target_w = _battery_export_cap_w(battery, grid) sf_dump = pulp.LpVariable(f"neg_bat_dump_shortfall_{t}", 0, dump_target_w) @@ -1584,6 +1653,18 @@ def solve_dispatch( us * NEG_SELL_SOC_UNDERFILL_PENALTY_CZK_PER_WH for _t, us in neg_sell_soc_underfill ) + + pulp.lpSum( + us * NEG_BUY_SOC_UNDERFILL_PENALTY_CZK_PER_WH + for _t, us in neg_buy_soc_underfill + ) + + pulp.lpSum( + sf * NEG_BUY_GRID_CHARGE_SHORTFALL_PENALTY_CZK_KWH * INTERVAL_H / 1000.0 + for _t, sf, _cap in neg_buy_grid_shortfall + ) + + pulp.lpSum( + sf * PEAK_EXPORT_SHORTFALL_PENALTY_CZK_KWH * INTERVAL_H / 1000.0 + for _t, sf, _cap in pre_neg_buy_export_shortfall + ) + pulp.lpSum( sf * NEG_SELL_BAT_DUMP_SHORTFALL_PENALTY_CZK_KWH * INTERVAL_H / 1000.0 for _t, sf, _cap in neg_sell_bat_dump_shortfall @@ -1593,6 +1674,11 @@ def solve_dispatch( for t in range(T) if t in discharge_export_slots and t in profitable_export_ts_pre ) + + pulp.lpSum( + -35.0 * z_export[t] + for t in pre_neg_buy_discharge_ts + if t in discharge_export_slots + ) ) # --- Omezení --- @@ -1604,6 +1690,12 @@ def solve_dispatch( prob += sf >= cap_w - ge_bat[t_sf] for t_us, us in neg_sell_soc_underfill: prob += us >= float(battery.soc_max_wh) - soc[t_us] + for t_us, us in neg_buy_soc_underfill: + prob += us >= float(battery.soc_max_wh) - soc[t_us] + for t_sf, sf, cap_w in neg_buy_grid_shortfall: + prob += sf >= cap_w - bc_gi[t_sf] + for t_sf, sf, cap_w in pre_neg_buy_export_shortfall: + prob += sf >= cap_w - ge_bat[t_sf] preneg_export_min_soc_wh = float(min_soc_wh) + max( float(battery.max_discharge_power_w) * float(battery.discharge_efficiency) @@ -1627,7 +1719,8 @@ def solve_dispatch( if t_peak not in discharge_export_slots: continue prob += ge_bat[t_peak] >= export_push_w * z_export[t_peak] - # Ostatní profitable sloty: jen shortfall penalizace (ne tvrdý push na celý horizont). + # Pre-neg-buy: jen shortfall (tvrdý push by kolidoval s kotvou SoC v krátkých testech). + # Ostatní profitable sloty: shortfall penalizace (ne tvrdý push na celý horizont). if t_anchor is not None and soc_anchor_slack is not None: target_floor_wh = float(planner_floor_effective_wh) prob += soc[t_anchor] <= target_floor_wh + soc_anchor_slack @@ -1858,6 +1951,12 @@ def solve_dispatch( # Bez hluboké relaxace: export končí ≥ rezerva. Při hluboké relaxaci (soc_panel_min pod min_soc) # sladit s LP spodkem — jinak z_export vynutil arb_base a blokoval vývoz k planner floor. if ( + om == "AUTO" + and t in pre_neg_buy_discharge_ts + and floor_pct is not None + ): + export_soc_floor_t = float(planner_floor_effective_wh) + elif ( om == "AUTO" and first_neg_sell_idx is not None and t < first_neg_sell_idx @@ -1888,6 +1987,7 @@ def solve_dispatch( tgt_s is not None and not high_sell_slot[t] and t not in profitable_export_ts_pre + and t not in pre_neg_buy_discharge_ts and not ( om == "AUTO" and t in discharge_export_slots @@ -1967,24 +2067,27 @@ def solve_dispatch( and float(s.buy_price) >= 0.0 ): prob += bc_gi[t] == 0 - if t not in charge_slots: - pv_surplus_w = max( - 0, - int(s.pv_a_forecast_w) - + int(s.pv_b_forecast_w) - - int(s.load_baseline_w), - ) - in_pre_neg_buy_window = ( - _neg_buy_idx_main is not None and t < _neg_buy_idx_main - ) + pv_surplus_w = max( + 0, + int(s.pv_a_forecast_w) + + int(s.pv_b_forecast_w) + - int(s.load_baseline_w), + ) + in_pre_neg_buy_window = ( + _neg_buy_idx_main is not None and t < _neg_buy_idx_main + ) + if ( + in_pre_neg_buy_window + and t in charge_slots + and float(s.sell_price) < 0.0 + ): + # sell<0+PV charge_slots před buy<0: neplnit z PV A (kapacita pro import). + prob += bc_pv[t] == 0 + elif t not in charge_slots: if float(s.buy_price) >= 0.0: prob += bc_gi[t] == 0 if pv_surplus_w <= 0: prob += bc_pv[t] == 0 - elif in_pre_neg_buy_window: - # Strukturální preference: PV jde do gridu (sell≥0) nebo curtail, - # ne do baterie — kapacitu si šetříme na buy<0 okno. - prob += bc_pv[t] == 0 else: prob += bc_pv[t] <= float(pv_surplus_w) if t not in discharge_export_slots and t not in neg_sell_bat_dump_slots: diff --git a/backend/tests/test_planning_dispatch_milp.py b/backend/tests/test_planning_dispatch_milp.py index 7c1e066..49f62d2 100644 --- a/backend/tests/test_planning_dispatch_milp.py +++ b/backend/tests/test_planning_dispatch_milp.py @@ -1230,7 +1230,7 @@ class NegativeSellPvChargeTests(unittest.TestCase): 50.0, operating_mode="AUTO", ) - self.assertEqual(snap.get("planner_build_tag"), "2026-05-27-site-export-cap-from-db-v18") + self.assertEqual(snap.get("planner_build_tag"), "2026-05-27-pre-neg-buy-strategy-v19") self.assertGreater( results[0].battery_setpoint_w, 5_500, @@ -1380,7 +1380,7 @@ class NegativeSellPvChargeTests(unittest.TestCase): 50.0, operating_mode="AUTO", ) - self.assertEqual(snap.get("planner_build_tag"), "2026-05-27-site-export-cap-from-db-v18") + self.assertEqual(snap.get("planner_build_tag"), "2026-05-27-pre-neg-buy-strategy-v19") self.assertEqual(len(results), len(slots)) def test_gen_cutoff_full_soc_neg_sell_with_pv_b_feasible(self) -> None: @@ -1444,7 +1444,7 @@ class NegativeSellPvChargeTests(unittest.TestCase): 55.0, operating_mode="AUTO", ) - self.assertEqual(snap.get("planner_build_tag"), "2026-05-27-site-export-cap-from-db-v18") + self.assertEqual(snap.get("planner_build_tag"), "2026-05-27-pre-neg-buy-strategy-v19") self.assertEqual(len(results), len(slots)) def test_fixed_tariff_neg_sell_no_grid_export(self) -> None: diff --git a/docs/04-modules/planning.md b/docs/04-modules/planning.md index b1106db..c47f282 100644 --- a/docs/04-modules/planning.md +++ b/docs/04-modules/planning.md @@ -45,6 +45,7 @@ 1. **Globální rozpočet Wh** (`discharge_slot_buffer × exportovatelná kapacita`): sloty podle `sell_price desc`. Před prvním `sell < 0` se z rozpočtu **vynechají** sloty, kde **později tentýž den** existuje `sell` vyšší o více než `degradation` (OTE, ne pevné hodiny 00–04). 2. **Večerní špičky per den:** `sell ≥ max(sell) − degradation` jen pro hodiny **≥ 17** (Prague), ne globální max horizontu (jinak by vyhrála půlnoc 3,7 Kč místo večera). 3. **Ranní pásmo před prvním `sell < 0`:** hodiny **5–11** téhož kalendářního dne — všechny sloty s `sell ≥ lokální_max_ráno − degradation`; ostatní sloty mezi ranním pásmem a prvním `sell < 0` s nižším sell mají export **zakázán** (žádný dump v 07:30 za 2 Kč). **`charge_acquisition`:** vážený `buy` před prvním exportem **téhož dne** jako záporné výkupní okno. + **Před oknem `buy < 0` (tag v19, `solve_dispatch`):** sloty se **`sell < 0` + PV** v `charge_slots` mají **`bc_pv = 0`** (kapacita pro import); noční/dopolední výboj přes **`pre_neg_buy_discharge_ts`** (SQL `allow_discharge_export` nebo **`sell ≥ 1` Kč/kWh**) + shortfall **`ge_bat`**; **`neg_sell_soc_underfill`** jen od **`first_neg_buy_idx`**; v **`buy < 0`** slotech **`neg_buy_soc_underfill`** + **`neg_buy_grid_shortfall`** (headroom z `soc_panel_min`). Viz [`docs/planning-changelog.md`](../planning-changelog.md) v19. V `solve_dispatch` (AUTO): **`charge_slots`** = `allow_charge` z DB + **`buy < 0`** + všechny sloty **`sell < 0`** s PV přebytkem > 500 W (i bez `block_export_on_negative_sell`, BA81). **`pv_charge_shortfall`** / **`NEG_SELL_CURTAIL_PENALTY`** platí v těchto slotech. Při **`sell < 0`**: safety deficit cílí **`soc_max_wh`** (plný planner strop). Po posledním **`sell < 0`** tentýž den: **`post_neg_pv_topup`** dobije z FVE na `soc_max` před exportem (kladný sell, ne high-sell peak). U **fixního tarifu** s polem B: **`ge_pv ≤ pv_b`** (ne pv_store **`ge_pv = 0`**). Při **`deye_gen_microinverter_cutoff_enabled`**: **`ge == 0` jen** pokud **`block_export_on_negative_sell`** (KV1), ne kvůli samotnému `z_gen_cutoff` (BA81 musí moci exportovat B při plné baterii). Vstupní **`soc_wh`** z telemetrie se před MILP omezí přes **`_planner_soc_for_solver`** (rezerva ~650 Wh pod `soc_max`, jinak Infeasible při 100 % SoC a dlouhém záporném výkupu). **`planner_build_tag`** v `solver_params`. Changelog: [`docs/planning-changelog.md`](../planning-changelog.md). - **Záporná nákupní cena:** - horní mez `grid_import` zahrnuje `load_baseline_w` + nabíjení/EV/TČ (bez nekonečného importu). diff --git a/docs/05-todo.md b/docs/05-todo.md index 09fdb3e..96e2d87 100644 --- a/docs/05-todo.md +++ b/docs/05-todo.md @@ -29,7 +29,7 @@ Shrnutí otevřených bodů z `docs/06-open-questions.md`, checklistů v modulec | ~~**`charge_acquisition` po solve (two-pass):**~~ hotovo — `solve_dispatch_two_pass` v `planning_engine.py` (AUTO daily/rolling). | `planning_engine.py`, [`planning-arbitrage-accounting.md`](04-modules/planning-arbitrage-accounting.md) §6 | — | | ~~**Grid maska B (nejlevnější sloty):**~~ hotovo — `buy ASC` v AM/PM do Wh rozpočtu; cap z `ceil(budget/per_slot_wh)`. | `R__063` | — | | **Self-konzistentní filtr B + acquisition bez `buy<0`:** iterativní filtr v `R__063` (v12); vážená acquisition pro filtr i `charge_acquisition_buy_czk_kwh` jen z `allow_grid_charge` s `buy>=0` (záporný OTE buy zůstává `allow_charge`, ale neřítí exportní marži). Two-pass `_recompute_charge_acquisition_from_results` také přeskočí `buy<0`. Ověřit po deploy: `two_pass_converged=true` na home-01. | `R__063`, `planning_engine.py` | programátor | -| **Večerní export plnou rychlostí v plánu:** v18 — push `ge_bat` z `min(max_discharge, max_export)` z DB (ne 8000 W). Ověřit na home-01 po deploy. Refactor: `planning_engine.py` ~3100 řádků → vyčlenit constraints modul. | `planning_engine.py`, `docs/planning-changelog.md` v18 | programátor | +| **Strategie buy<0 / sell<0 (home-01):** v19 — noční výboj, bc_pv=0 před buy<0, import v buy<0. Ověřit po deploy + replan. Refactor: `planning_engine.py` ~3100 řádků → vyčlenit constraints modul. | `planning_engine.py`, `docs/planning-changelog.md` v19 | programátor | | **KV1 replan timeout (~120 s):** ruční/rolling replan občas spadne na timeout; 5. pokus prošel. Profilovat `fn_load_planning_slots_full` (iterativní filtr) + MILP délku horizontu; případně zkrátit horizont pro test nebo zvýšit limit API. | backend replan endpoint, APScheduler | programátor | | **home-01 export při `sell<0` (26 slotů):** záměrně **ne** `block_export_on_negative_sell` (neriditelné PV B + zelený bonus). Plán stále může dávat `PV_SURPLUS` ~6–7 kW od ~10:30 když je SoC ~97 %+ — jiná osa než noční grid 4,8 Kč. Review ventilu `w_pv_b_vent_neg` / nabíjení před exportem, ne stejný fix jako KV1. | `planning_engine.py`, `planning-arbitrage-accounting.md` | programátor | diff --git a/docs/planning-changelog.md b/docs/planning-changelog.md index 0af7f14..bff47aa 100644 --- a/docs/planning-changelog.md +++ b/docs/planning-changelog.md @@ -5,6 +5,21 @@ Formát: **datum (ISO)** · stručný důvod · soubory · chování / ověřen --- +## 2026-05-27 (i) — strategie před buy<0: noční výboj, bez PV→bat, import v záporném nákupu (v19) + +**Problém (home-01 run 16662, tag v18):** Večerní/ranní export OK. Zbývá: (1) noc jen ~500 W do domu, žádný `ge_bat` výboj před `buy<0`; (2) 08:45–11:30 nabíjení z PV A do ~98 % ještě před `buy<0` (13:00); (3) v `buy<0` baterie plná → žádný import; (4) `neg_sell_soc_underfill` tlačilo na soc_max už v ranním `sell<0` okně. + +**Oprava (tag `2026-05-27-pre-neg-buy-strategy-v19`):** + +1. **Noční výboj:** `pre_neg_buy_discharge_ts` — shortfall + push `ge_bat` na site cap, bonus `z_export`, export podlaha `min_soc` (ne safety ramp). +2. **`bc_pv[t]=0` pro všechny sloty před `first_neg_buy_idx`** (i když `t in charge_slots` z `sell<0+PV`). +3. **`neg_sell_soc_underfill` jen po `first_neg_buy_idx`** — před záporným nákupem nehonit soc_max. +4. **`neg_buy_soc_underfill` + `neg_buy_grid_shortfall`** v `buy<0` slotech — tlak na soc_max a max `bc_gi` ze sítě. + +**Ověření:** `pytest backend/tests/test_planning_dispatch_milp.py` — po deploy replan home-01: tag v19; noc `ge_bat` ~13,5 kW; před 13:00 SoC pod max; 13:00–14:45 import + nabíjení k 100 %. + +--- + ## 2026-05-27 (h) — export push z DB limitů, bez hardcoded 8000 W (v18) **Problém:** `EVENING_BATTERY_EXPORT_MIN_W` a `PRENEG_MORNING_EXPORT_MIN_W` = 8000 W v kódu brzdily home-01 na 8 kW místo `site_grid_connection.max_export_power_w` (13,5 kW); u KV1 náhodou sedělo. `EVENING_PEAK_FULL_POWER_TOP_K = 6` arbitrární.