From 4beb8cf99fd5f3003a819f3ab1e6754408bb3814 Mon Sep 17 00:00:00 2001 From: Dusan Vojacek Date: Mon, 25 May 2026 02:13:41 +0200 Subject: [PATCH] uz sem zaoufalej --- backend/services/planning_engine.py | 203 +------------------ backend/tests/test_planning_dispatch_milp.py | 6 +- docs/04-modules/planning.md | 2 +- docs/05-todo.md | 2 +- docs/planning-changelog.md | 16 ++ scripts/diagnose_home01_infeasible.py | 121 +++++++++++ scripts/home01_run16674_slots.json | 1 + 7 files changed, 153 insertions(+), 198 deletions(-) create mode 100644 scripts/diagnose_home01_infeasible.py create mode 100644 scripts/home01_run16674_slots.json diff --git a/backend/services/planning_engine.py b/backend/services/planning_engine.py index cce2f07..c6ff198 100644 --- a/backend/services/planning_engine.py +++ b/backend/services/planning_engine.py @@ -64,11 +64,7 @@ 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 -# 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-v19c" +PLANNER_BUILD_TAG = "2026-05-28-revert-v19-hard-v20" 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 @@ -937,41 +933,6 @@ def _evening_battery_export_push_indices( return sorted(out) -def _negative_buy_slot_indices(slots: list[PlanningSlot]) -> list[int]: - return [t for t, s in enumerate(slots) if float(s.buy_price) < 0.0] - - -def _neg_buy_soc_pressure_slots(slots: list[PlanningSlot]) -> list[int]: - """Tlak na soc_max jen na konci buy<0 okna (ne každý 15min slot zvlášť).""" - neg = _negative_buy_slot_indices(slots) - return [neg[-1]] if neg else [] - - -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, @@ -1098,13 +1059,11 @@ def solve_dispatch( charge_commitment_prev_w: Optional[list[Optional[float]]] = None, planner_version: str | None = None, relaxed_expensive_import: bool = False, - relaxed_neg_buy_pressure: bool = False, ) -> tuple[list[DispatchResult], int, dict[str, Any]]: """ LP solver pro dispatch optimalizaci. Vrátí (výsledky, solver_duration_ms, solver_debug_snapshot). relaxed_expensive_import: nouzový režim po Infeasible — síť smí krmit baseload v drahých slotech. - relaxed_neg_buy_pressure: vypne měkké v19 shortfall (pre-neg export, neg-buy soc/grid). """ T = len(slots) if T < 1: @@ -1226,7 +1185,6 @@ 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 |= { @@ -1248,26 +1206,6 @@ def solve_dispatch( discharge_export_slots = { t for t, s in enumerate(slots) if s.allow_discharge_export } - # 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). - _neg_buy_for_disch = next( - (t for t, s in enumerate(slots) if float(s.buy_price) < 0), None - ) - if _neg_buy_for_disch is not None and _neg_buy_for_disch > 0: - _neg_buy_prices = [ - float(slots[t].buy_price) - for t in range(_neg_buy_for_disch, T) - 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 - _disch_sell_thr = max(_avg_neg_buy + float(degradation_cost_effective), 0.1) - for t in range(_neg_buy_for_disch): - st = slots[t] - if float(st.sell_price) < _disch_sell_thr: - continue - # Jen kladný sell (sell<0 + z_export by vynutilo ge_bat≥1 zároveň s ge_bat=0). - if float(st.sell_price) >= 1.0: - 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, @@ -1445,9 +1383,6 @@ 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": @@ -1499,17 +1434,11 @@ 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) @@ -1524,35 +1453,6 @@ def solve_dispatch( float(battery.usable_capacity_wh), ) neg_sell_soc_underfill.append((t, us)) - if not relaxed_neg_buy_pressure: - for t in _neg_buy_soc_pressure_slots(slots): - us_buy = pulp.LpVariable( - f"neg_buy_soc_under_{t}", - 0, - float(battery.usable_capacity_wh), - ) - neg_buy_soc_underfill.append((t, us_buy)) - for t in range(T): - if float(slots[t].buy_price) >= 0: - continue - 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: - 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) @@ -1662,18 +1562,6 @@ 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 @@ -1683,10 +1571,6 @@ 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 - ) ) # --- Omezení --- @@ -1698,12 +1582,6 @@ 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) @@ -1727,7 +1605,6 @@ def solve_dispatch( if t_peak not in discharge_export_slots: continue prob += ge_bat[t_peak] >= export_push_w * z_export[t_peak] - # 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) @@ -1853,7 +1730,7 @@ def solve_dispatch( block_neg_sell_export_t = bool( getattr(grid, "block_export_on_negative_sell", False) ) - if t not in neg_sell_bat_dump_slots and t not in pre_neg_buy_discharge_ts: + if t not in neg_sell_bat_dump_slots: prob += ge_bat[t] == 0 ev_cap_neg = sum( float(vehicles[e].max_charge_power_w) @@ -1959,12 +1836,6 @@ 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 @@ -1995,7 +1866,6 @@ 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 @@ -2042,16 +1912,6 @@ def solve_dispatch( prob += bd[t] == 0 # Slot pre-selection (z DB fn_load_planning_slots_full → allow_*) - # PŘED prvním buy<0 slotem v horizontu (= rezervační okno): - # - sell ≥ 0 → bc_pv = 0 (PV poteče do gridu / curtail, baterka se nenabíjí z PV - # protože v buy<0 okně bude akvizice levnější — záporná). - # - sell < 0 → slot je v charge_slots (R__063), bc_pv ≤ pv_surplus (= nemůžeme - # pole A vyhodit do mínusu, raději nabít baterii). - # JINDY (po buy<0 okně, nebo žádné buy<0 v horizontu): původní permissive - # bc_pv ≤ pv_surplus aby nedošlo k regresi normálních dnů. - _neg_buy_idx_main = next( - (t for t, s in enumerate(slots) if float(s.buy_price) < 0), None - ) if om == "AUTO": for t in range(T): s = slots[t] @@ -2062,12 +1922,6 @@ def solve_dispatch( + int(s.pv_b_forecast_w) - int(s.load_baseline_w), ) - # Grid→bat (bc_gi): R__063 dává allow_charge=true ze dvou různých důvodů: - # (a) ekonomicky výhodný grid charge slot (nízký buy, výhodná arbitráž), - # (b) sell<0 + pv_surplus (= "povolit PV nabíjení aby pole A nešlo do mínusu"). - # V druhém případě bc_gi NESMÍ být povoleno (home-01 run 16652: 09:15–09:45 - # nabíjelo 18 kW ze sítě za buy 1,1–1,2 Kč jen proto, že sell=−0,2). - # Druhý případ poznáme přes `sell<0 + pv_surplus>0`. if ( t in charge_slots and sell_t_pre < 0 @@ -2075,34 +1929,20 @@ def solve_dispatch( and float(s.buy_price) >= 0.0 ): prob += bc_gi[t] == 0 - 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 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), + ) if float(s.buy_price) >= 0.0: prob += bc_gi[t] == 0 if pv_surplus_w <= 0: 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 - and t not in pre_neg_buy_discharge_ts - ): + if t not in discharge_export_slots and t not in neg_sell_bat_dump_slots: prob += ge_bat[t] == 0 prob += z_export[t] == 0 @@ -2285,28 +2125,6 @@ def solve_dispatch( charge_commitment_prev_w=charge_commitment_prev_w, planner_version=planner_version, relaxed_expensive_import=True, - relaxed_neg_buy_pressure=relaxed_neg_buy_pressure, - ) - if not relaxed_neg_buy_pressure: - logger.warning( - "solve_dispatch Infeasible, retry with relaxed_neg_buy_pressure " - "(skip v19 soft shortfalls)" - ) - return solve_dispatch( - slots, - battery, - heat_pump, - grid, - ev_sessions, - vehicles, - current_soc_wh, - current_tuv_temp_c, - tuv_delta_stats=tuv_delta_stats, - operating_mode=operating_mode, - charge_commitment_prev_w=charge_commitment_prev_w, - planner_version=planner_version, - relaxed_expensive_import=True, - relaxed_neg_buy_pressure=True, ) raise RuntimeError(f"Solver: {pulp.LpStatus[status]}") @@ -2538,7 +2356,6 @@ def solve_dispatch( }, "load_first_enabled": om == "AUTO", "relaxed_expensive_import": relaxed_expensive_import, - "relaxed_neg_buy_pressure": relaxed_neg_buy_pressure, "charge_acquisition_buy_czk_kwh": charge_acquisition_czk_kwh, "charge_acquisition_cutoff_at": ( slots[0].charge_acquisition_cutoff_at.isoformat() diff --git a/backend/tests/test_planning_dispatch_milp.py b/backend/tests/test_planning_dispatch_milp.py index a423e65..96b5cba 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-pre-neg-buy-strategy-v19c") + self.assertEqual(snap.get("planner_build_tag"), "2026-05-28-revert-v19-hard-v20") 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-pre-neg-buy-strategy-v19c") + self.assertEqual(snap.get("planner_build_tag"), "2026-05-28-revert-v19-hard-v20") 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-pre-neg-buy-strategy-v19c") + self.assertEqual(snap.get("planner_build_tag"), "2026-05-28-revert-v19-hard-v20") 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 661e821..b5fefd6 100644 --- a/docs/04-modules/planning.md +++ b/docs/04-modules/planning.md @@ -45,7 +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 v19c, `solve_dispatch`):** sloty se **`sell < 0` + PV** v `charge_slots` mají **`bc_pv = 0`** (kapacita pro import); noční výboj přes **`pre_neg_buy_discharge_ts`** (`sell ≥ 1` nebo SQL `allow_discharge_export`) + shortfall **`ge_bat`** — **bez** přidání do **`discharge_export_slots`** (jinak Infeasible: `bd` k loadu). **`neg_sell_soc_underfill`** jen od **`first_neg_buy_idx`**; v **`buy < 0`** **`neg_buy_soc_underfill`** + **`neg_buy_grid_shortfall`**. Viz changelog v19/v19b. + **Planner tag v20:** revert experimentálních v19 Python constraintů (opakované Infeasible na home-01). Aktivní **v17** (`bc_gi=0` při sell<0+PV+buy≥0, `ge_pv≤pv_b`) a **v18** (export push z DB limitů). Strategie před `buy<0` / noční výboj patří do **`R__063`** (`allow_*` masky), ne tvrdých LP — viz changelog v20. 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 b8d1768..716885a 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 | -| **Strategie buy<0 / sell<0 (home-01):** v19c — Infeasible fix (soc jen poslední buy<0 slot). Deploy + replan, tag `…-v19c`. | `planning_engine.py`, `docs/planning-changelog.md` v19c | programátor | +| **Strategie buy<0 (home-01):** v20 revert v19 hard constraintů; další krok = SQL `R__063` + ověření MCP před Python LP. | `R__063`, `planning_engine.py` v20 | 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 7136c77..0978780 100644 --- a/docs/planning-changelog.md +++ b/docs/planning-changelog.md @@ -5,6 +5,22 @@ Formát: **datum (ISO)** · stručný důvod · soubory · chování / ověřen --- +## 2026-05-28 — revert tvrdých v19 constraintů (v20) + +**Problém:** v19–v19c opakovaně **Solver: Infeasible** na home-01 (ověřeno proti MCP run 16674 — `buy<0` od 11:00, ne 13:00). Vrstvené Python patch bez reprodukce na živých slotech. + +**Rozhodnutí:** **Revert** celé v19 Python vrstvy (pre-neg discharge, `bc_pv=0` před buy<0, neg-buy shortfall). Zůstává stabilní základ: +- **v17:** `bc_gi=0` při sell<0+PV+buy≥0; `ge_pv ≤ pv_b` při sell<0 +- **v18:** večerní export push z DB `min(discharge, export)` W + +Strategie před buy<0 / import v buy<0 patří do **SQL `R__063`** (masky `allow_*`), ne dalších tvrdých LP constraintů — až po feasibilitě na MCP datech. + +**Tag:** `2026-05-28-revert-v19-hard-v20` + +**Diagnostika:** `scripts/diagnose_home01_infeasible.py` + fixture z MCP `planning_interval` run 16674. + +--- + ## 2026-05-27 (k) — Infeasible: soc na každém buy<0 slotu + sell<0 v pre-neg (v19c) **Problém:** (1) **`neg_buy_soc_underfill`** na **každém** `buy<0` slotu vyžadoval `soc = soc_max` každých 15 min — při startu pod max fyzicky nemožné. (2) **`pre_neg_buy_discharge_ts`** mohlo zahrnout `sell<0` + `allow_discharge_export` → **`ge_bat=0`** (sell<0) vs **`z_export` → ge_bat≥1** → Infeasible. diff --git a/scripts/diagnose_home01_infeasible.py b/scripts/diagnose_home01_infeasible.py new file mode 100644 index 0000000..7de9583 --- /dev/null +++ b/scripts/diagnose_home01_infeasible.py @@ -0,0 +1,121 @@ +#!/usr/bin/env python3 +"""Bisect Infeasible na reálných slotech home-01 (MCP run 16674). PYTHONPATH=backend.""" +from __future__ import annotations + +import json +import sys +from datetime import datetime, timezone +from pathlib import Path +from types import SimpleNamespace + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "backend")) + +from services.planning_engine import PlanningSlot, solve_dispatch, solve_dispatch_two_pass, PLANNER_BUILD_TAG + +# Export z MCP: planning_interval run_id=16674 + fn_planning_site_context(2) +SLOTS_JSON = Path(__file__).with_name("home01_run16674_slots.json") +SOC_WH = 37120.0 + + +def _ctx() -> tuple[SimpleNamespace, SimpleNamespace, SimpleNamespace, list]: + battery = SimpleNamespace( + usable_capacity_wh=64000.0, + min_soc_wh=6400.0, + arb_floor_wh=12800.0, + reserve_soc_wh=12800.0, + soc_max_wh=64000.0, + charge_efficiency=0.95, + discharge_efficiency=0.95, + degradation_cost_czk_kwh=0.15, + max_charge_power_w=18000, + max_discharge_power_w=18000, + charge_slot_buffer=1.3, + discharge_slot_buffer=1.5, + planner_terminal_soc_value_factor=0.9, + planner_discharge_floor_percent=5.0, + planner_extreme_buy_threshold_czk_kwh=-2.0, + planner_daytime_charge_target_enabled=True, + planner_charge_commitment_penalty_czk_kwh=0.2, + planner_night_baseload_buffer_percent=20, + ) + grid = SimpleNamespace( + max_import_power_w=17000, + max_export_power_w=13500, + block_export_on_negative_sell=False, + deye_gen_microinverter_cutoff_enabled=False, + ) + hp = SimpleNamespace(rated_heating_power_w=0, tuv_min_temp_c=45.0, tuv_target_temp_c=55.0) + vehicles = [ + SimpleNamespace(max_charge_power_w=11000, battery_capacity_kwh=75.0, default_target_soc_pct=80.0), + SimpleNamespace(max_charge_power_w=7400, battery_capacity_kwh=52.0, default_target_soc_pct=90.0), + ] + return battery, hp, grid, vehicles + + +def load_slots(*, permissive_masks: bool) -> list[PlanningSlot]: + rows = json.loads(SLOTS_JSON.read_text()) + out: list[PlanningSlot] = [] + for r in rows: + ts = datetime.fromisoformat(r["interval_start"].replace("Z", "+00:00")) + pv_surplus = max(0, int(r["pv_a"]) + int(r["pv_b"]) - int(r["load"])) + out.append( + PlanningSlot( + interval_start=ts, + buy_price=float(r["buy"]), + sell_price=float(r["sell"]), + pv_a_forecast_w=int(r["pv_a"]), + pv_b_forecast_w=int(r["pv_b"]), + load_baseline_w=int(r["load"]), + ev1_connected=False, + ev2_connected=False, + allow_charge=True if permissive_masks else (float(r["buy"]) < 0 or (float(r["sell"]) < 0 and pv_surplus > 500)), + allow_discharge_export=permissive_masks, + ) + ) + return out + + +def try_solve(label: str, slots: list[PlanningSlot], **kwargs) -> str: + battery, hp, grid, vehicles = _ctx() + try: + if kwargs.pop("two_pass", False): + solve_dispatch_two_pass( + slots, battery, hp, grid, [None, None], vehicles, SOC_WH, 55.0, + operating_mode="AUTO", **kwargs, + ) + else: + solve_dispatch( + slots, battery, hp, grid, [None, None], vehicles, SOC_WH, 55.0, + operating_mode="AUTO", **kwargs, + ) + return f"OK {label}" + except Exception as e: + return f"FAIL {label}: {e}" + + +def main() -> None: + if not SLOTS_JSON.exists(): + print(f"Chybí {SLOTS_JSON} — spusť export z MCP (run 16674).", file=sys.stderr) + sys.exit(1) + + print("tag", PLANNER_BUILD_TAG) + print("slots", len(json.loads(SLOTS_JSON.read_text()))) + neg_buy = [r for r in json.loads(SLOTS_JSON.read_text()) if r["buy"] < 0] + print("neg_buy slots", len(neg_buy), "first", neg_buy[0]["interval_start"] if neg_buy else None) + + cases = [ + ("permissive masks, 1-pass", dict(permissive_masks=True, two_pass=False)), + ("permissive masks, 2-pass", dict(permissive_masks=True, two_pass=True)), + ("realistic masks, 1-pass", dict(permissive_masks=False, two_pass=False)), + ("realistic masks, 2-pass", dict(permissive_masks=False, two_pass=True)), + ("realistic + relaxed_expensive", dict(permissive_masks=False, two_pass=False, relaxed_expensive_import=True)), + ("realistic + both relaxed", dict(permissive_masks=False, two_pass=False, relaxed_expensive_import=True, relaxed_neg_buy_pressure=True)), + ] + for label, kw in cases: + masks = kw.pop("permissive_masks") + slots = load_slots(permissive_masks=masks) + print(try_solve(label, slots, **kw)) + + +if __name__ == "__main__": + main() diff --git a/scripts/home01_run16674_slots.json b/scripts/home01_run16674_slots.json new file mode 100644 index 0000000..4a7b882 --- /dev/null +++ b/scripts/home01_run16674_slots.json @@ -0,0 +1 @@ +[{"interval_start":"2026-05-24T23:45:00.000Z","buy":4.766958,"sell":2.9315,"load":579,"pv_a":0,"pv_b":0},{"interval_start":"2026-05-25T11:00:00.000Z","buy":-0.070392,"sell":-0.8225,"load":858,"pv_a":6306,"pv_b":7397},{"interval_start":"2026-05-25T12:00:00.000Z","buy":-0.337409,"sell":-1.065,"load":6267,"pv_a":5870,"pv_b":6971}] \ No newline at end of file