diff --git a/backend/services/planning_engine.py b/backend/services/planning_engine.py index cf3ad67..9de2664 100644 --- a/backend/services/planning_engine.py +++ b/backend/services/planning_engine.py @@ -38,6 +38,8 @@ SOLVER_TIME_LIMIT = 10 # sekund # (rezerva z DB). Při relaxaci spodku před extrémně záporným buy je podlaha soc_panel_min[t] # (planner floor), jinak by šlo jen do zátěže a nešlo by „vypustit do sítě“ před levným nákupem. GE_MIN_EXPORT_W = 1.0 +# Dvouprůchodové solve: stop když acquisition z pass1 vs pass2 se liší méně než (Kč/kWh). +ACQUISITION_TWO_PASS_EPS_KWH = 0.05 # Dokud je kotva pro hluboký dump (první sell < 0 v horizontu, jinak první extrémní buy) dál než # tento počet 15min slotů, držíme plánovací spodek na rezervě (arb_base_wh) místo planner floor — # priorita: beze „ztráty na prodeji“ (sell >= 0) držet buffer, hluboký vývoz až těsně před záporným prodejem. @@ -579,6 +581,113 @@ def apply_forecast_correction( # LP Solver # ============================================================ +def _recompute_charge_acquisition_from_results( + slots: list[PlanningSlot], + results: list["DispatchResult"], + battery, +) -> float: + """Vážený buy z nabíjecích slotů (grid import + bat charge) z prvního solve.""" + wh_total = 0.0 + cost = 0.0 + for s, r in zip(slots, results): + if not s.allow_charge: + continue + gi_w = max(0, int(r.grid_setpoint_w or 0)) + bc_w = max(0, int(r.battery_setpoint_w or 0)) + wh = (gi_w + bc_w) * INTERVAL_H + if wh <= 0: + continue + wh_total += wh + cost += float(s.buy_price) * wh + if wh_total <= 0: + raw = getattr(slots[0], "charge_acquisition_buy_czk_kwh", None) + if raw is not None: + return float(raw) + return min(float(s.buy_price) for s in slots) + return cost / wh_total + + +def _slots_with_charge_acquisition( + slots: list[PlanningSlot], + acquisition_czk_kwh: float, +) -> list[PlanningSlot]: + return [ + replace(s, charge_acquisition_buy_czk_kwh=acquisition_czk_kwh) + for s in slots + ] + + +def solve_dispatch_two_pass( + slots: list[PlanningSlot], + battery, + heat_pump, + grid, + ev_sessions: list, + vehicles: list, + current_soc_wh: float, + current_tuv_temp_c: float, + *, + tuv_delta_stats: Optional[dict[tuple[int, int], float]] = None, + operating_mode: str = "AUTO", + charge_commitment_prev_w: Optional[list[Optional[float]]] = None, + planner_version: str | None = None, +) -> tuple[list["DispatchResult"], int, dict[str, Any]]: + """ + Dva průchody solve_dispatch: pass2 používá acquisition z váženého buy nabíjení v pass1. + """ + results1, ms1, snap1 = 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, + ) + acq1 = float( + snap1.get("inputs", {}).get("charge_acquisition_buy_czk_kwh") + or getattr(slots[0], "charge_acquisition_buy_czk_kwh", None) + or min(float(s.buy_price) for s in slots) + ) + acq2 = _recompute_charge_acquisition_from_results(slots, results1, battery) + converged = abs(acq2 - acq1) < ACQUISITION_TWO_PASS_EPS_KWH + if converged: + if isinstance(snap1.get("inputs"), dict): + snap1["inputs"]["acquisition_pass1_czk_kwh"] = round(acq1, 6) + snap1["inputs"]["acquisition_pass2_czk_kwh"] = round(acq2, 6) + snap1["inputs"]["two_pass_enabled"] = True + snap1["inputs"]["two_pass_converged"] = True + return results1, ms1, snap1 + + slots2 = _slots_with_charge_acquisition(slots, acq2) + results2, ms2, snap2 = solve_dispatch( + slots2, + 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, + ) + if isinstance(snap2.get("inputs"), dict): + snap2["inputs"]["acquisition_pass1_czk_kwh"] = round(acq1, 6) + snap2["inputs"]["acquisition_pass2_czk_kwh"] = round(acq2, 6) + snap2["inputs"]["two_pass_enabled"] = True + snap2["inputs"]["two_pass_converged"] = False + snap2["inputs"]["solver_duration_ms_pass1"] = ms1 + return results2, ms1 + ms2, snap2 + + def solve_dispatch( slots: list[PlanningSlot], battery, @@ -823,14 +932,15 @@ def solve_dispatch( commit_lp.append((t, cv, cap_prev)) # --- Účelová funkce (jen OTE sloty; terminal SoC shadow price na konci horizontu) --- - # Arbitráž baterie: ge_bat v exportních slotech + charge_acquisition (SQL, před 1. exportem). - # Viz docs/04-modules/planning-arbitrage-accounting.md — ne stejnoslotové buy/sell. + # Kanály: gi×buy, −ge_pv×sell, −ge_bat×sell, +ge_bat×acquisition (export bat. jen v discharge slotách). + # Viz docs/04-modules/planning-arbitrage-accounting.md — mezi-slotová arbitráž, ne sell vs buy v jednom slotu. prob += ( pulp.lpSum( gi[t] * slots[t].buy_price * INTERVAL_H / 1000 - - ge[t] * slots[t].sell_price * INTERVAL_H / 1000 + - ge_pv[t] * slots[t].sell_price * INTERVAL_H / 1000 + - ge_bat[t] * slots[t].sell_price * INTERVAL_H / 1000 + ( - ge[t] * SELF_SUSTAIN_EXPORT_PENALTY_CZK_KWH * INTERVAL_H / 1000 + ge_pv[t] * SELF_SUSTAIN_EXPORT_PENALTY_CZK_KWH * INTERVAL_H / 1000 if om == "SELF_SUSTAIN" else 0 ) @@ -1095,41 +1205,13 @@ def solve_dispatch( 0.0, float(s.pv_a_forecast_w) + float(s.pv_b_forecast_w) - load_t, ) - # Mezi-slotová FVE arbitráž: export jen když (prodat teď − levný nákup později) - # ≥ (večerní špička − acquisition). Jinak drž PV v baterii na peak sell. - fso_t = float( - s.future_sell_opportunity_czk_kwh - if s.future_sell_opportunity_czk_kwh is not None - else sell_t - ) - future_chg_buys = [ - float(slots[ts].buy_price) - for ts in range(t + 1, T) - if ts in charge_slots - ] - min_future_chg_buy = ( - min(future_chg_buys) - if future_chg_buys - else charge_acquisition_czk_kwh - ) - export_refill_net = sell_t - min_future_chg_buy - store_peak_net = fso_t - charge_acquisition_czk_kwh - cross_slot_pv_export = ( - t not in charge_slots - and pv_surplus_w > 0 - and future_chg_buys - and export_refill_net >= store_peak_net + min_spread - ) - # Ztrátový export FVE (sell ≪ buy): zakázat jen pokud jde energii do baterie. - # Výjimky: plná baterie (ventil), neriťitelné pv_b s přebytkem, cross-slot výše. - if sell_t < buy_t - min_spread: + # FVE export: zakázat jen okamžitě ztrátový výkup vs plánovaná zásoba (ne sell < buy ve slotu). + if sell_t < charge_acquisition_czk_kwh - min_spread: block_loss_pv_export = not ( float(s.pv_b_forecast_w) > 0 and pv_surplus_w > 0 ) if t == 0 and current_soc_wh >= float(battery.soc_max_wh) - soc_headroom_wh: block_loss_pv_export = False - if cross_slot_pv_export: - block_loss_pv_export = False if block_loss_pv_export: prob += ge_pv[t] == 0 # Drahý nákup oproti horizontu: import jen na load + EV + TČ, ne na grid-nabíjení. @@ -1411,12 +1493,21 @@ async def run_daily_plan( planner_version_resolved = _planner_engine_version(planner_version) slots = await _load_slots(site_id, horizon_from, horizon_to, db, soc_wh=soc_wh) - results, duration_ms, solver_snapshot = solve_dispatch( - slots, battery, hp, grid, ev_sessions, vehicles, soc_wh, tuv_temp, - tuv_delta_stats=tuv_stats, - operating_mode=operating_mode or "AUTO", - planner_version=planner_version_resolved, - ) + om = operating_mode or "AUTO" + if om == "AUTO": + results, duration_ms, solver_snapshot = solve_dispatch_two_pass( + slots, battery, hp, grid, ev_sessions, vehicles, soc_wh, tuv_temp, + tuv_delta_stats=tuv_stats, + operating_mode=om, + planner_version=planner_version_resolved, + ) + else: + results, duration_ms, solver_snapshot = solve_dispatch( + slots, battery, hp, grid, ev_sessions, vehicles, soc_wh, tuv_temp, + tuv_delta_stats=tuv_stats, + operating_mode=om, + planner_version=planner_version_resolved, + ) comparison_ctx = _maybe_add_planner_comparison( slots=slots, battery=battery, @@ -1426,7 +1517,7 @@ async def run_daily_plan( vehicles=vehicles, current_soc_wh=soc_wh, current_tuv_temp_c=tuv_temp, - operating_mode=operating_mode or "AUTO", + operating_mode=om, tuv_delta_stats=tuv_stats, active_version=planner_version_resolved, ) @@ -1600,13 +1691,23 @@ async def run_rolling_replan( commitment_prev = await _load_previous_plan_charge_commitment_prev_w(site_id, slots, db) - results, duration_ms, solver_snapshot = solve_dispatch( - slots, battery, hp, grid, ev_sessions, vehicles, soc_wh, tuv_temp, - tuv_delta_stats=tuv_stats, - operating_mode=operating_mode or "AUTO", - charge_commitment_prev_w=commitment_prev, - planner_version=planner_version_resolved, - ) + om = operating_mode or "AUTO" + if om == "AUTO": + results, duration_ms, solver_snapshot = solve_dispatch_two_pass( + slots, battery, hp, grid, ev_sessions, vehicles, soc_wh, tuv_temp, + tuv_delta_stats=tuv_stats, + operating_mode=om, + charge_commitment_prev_w=commitment_prev, + planner_version=planner_version_resolved, + ) + else: + results, duration_ms, solver_snapshot = solve_dispatch( + slots, battery, hp, grid, ev_sessions, vehicles, soc_wh, tuv_temp, + tuv_delta_stats=tuv_stats, + operating_mode=om, + charge_commitment_prev_w=commitment_prev, + planner_version=planner_version_resolved, + ) comparison_ctx = _maybe_add_planner_comparison( slots=slots, battery=battery, @@ -1616,7 +1717,7 @@ async def run_rolling_replan( vehicles=vehicles, current_soc_wh=soc_wh, current_tuv_temp_c=tuv_temp, - operating_mode=operating_mode or "AUTO", + operating_mode=om, tuv_delta_stats=tuv_stats, active_version=planner_version_resolved, charge_commitment_prev_w=commitment_prev, diff --git a/backend/tests/test_planning_charge_slot_selection.py b/backend/tests/test_planning_charge_slot_selection.py index 40264eb..e06c9f3 100644 --- a/backend/tests/test_planning_charge_slot_selection.py +++ b/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.""" diff --git a/backend/tests/test_planning_dispatch_milp.py b/backend/tests/test_planning_dispatch_milp.py index 0fedac2..e18c161 100644 --- a/backend/tests/test_planning_dispatch_milp.py +++ b/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() diff --git a/db/routines/R__063_fn_load_planning_slots_full.sql b/db/routines/R__063_fn_load_planning_slots_full.sql index 475b78a..27a6ab5 100644 --- a/db/routines/R__063_fn_load_planning_slots_full.sql +++ b/db/routines/R__063_fn_load_planning_slots_full.sql @@ -381,7 +381,7 @@ begin -- charge mask: grid arbitráž (B) před FVE (A); AM/PM rozpočet Wh zůstává 50/50. -- - -- B) Grid ze sítě: spot, buy v pásmu AM/PM ≤ min(buy v pásmu)+band, lookahead VT→NT; + -- B) Grid ze sítě: spot, nejlevnější sloty v AM/PM do Wh rozpočtu (den plánu → před exportním oknem → buy ASC); -- i při pv_surplus>0; cap slotů ∝ rozpočet Wh / per_slot_charge_wh. -- A) PV-surplus: store_score DESC, doplní jen zbytek do energy_to_fill po vrstvě B. if v_charge_buf <= 0 then @@ -400,11 +400,6 @@ begin select wk.slot_ord from _ems_plan_slot_wk wk where extract(hour from wk.interval_start at time zone 'Europe/Prague') < 12 - and wk.buy_price <= v_ref_buy_am_czk_kwh + v_buy_charge_band_czk_kwh - and ( - wk.buy_min_next_n is null - or wk.buy_price <= wk.buy_min_next_n + v_buy_lookahead_eps - ) order by case when (wk.interval_start at time zone 'Europe/Prague')::date = v_plan_day_prague @@ -439,11 +434,6 @@ begin select wk.slot_ord from _ems_plan_slot_wk wk where extract(hour from wk.interval_start at time zone 'Europe/Prague') >= 12 - and wk.buy_price <= v_ref_buy_pm_czk_kwh + v_buy_charge_band_czk_kwh - and ( - wk.buy_min_next_n is null - or wk.buy_price <= wk.buy_min_next_n + v_buy_lookahead_eps - ) order by case when (wk.interval_start at time zone 'Europe/Prague')::date = v_plan_day_prague @@ -480,6 +470,8 @@ begin from _ems_plan_slot_wk wk where wk.pv_surplus_w > 0 and wk.sell_price >= wk.buy_price - v_degrad_czk_kwh + -- Držet PV na večerní peak: ne nabíjet z FVE když sell výrazně pod budoucím výkupním oknem. + and wk.sell_price >= wk.future_sell_lookahead - v_degrad_czk_kwh order by wk.store_score desc nulls last, wk.slot_ord loop exit when v_cum >= v_pv_layer_cap_wh; @@ -671,7 +663,7 @@ $fn$; comment on function ems.fn_load_planning_slots_full is '15min sloty s cenami, forecastem, baseline a maskami proti mikro-cyklu (charge/discharge-export). ' 'Charge mask A: PV-surplus dle store_score DESC (future_sell−sell−max(0,buy−sell)); zbytek → PV export. ' - 'Charge mask B: non-PV jen spot, buy≤ref_buy+degrad, lookahead min buy v N slotech, cap 6 slotů AM/PM. ' + 'Charge mask B: spot, nejlevnější buy v AM/PM do Wh rozpočtu (priorita den plánu, před exportním oknem). ' 'ref_buy = min(buy) horizontu. Discharge-export: nejdražší sell kde sell>ref_buy+degrad (spot). ' 'Strop SoC pro výpočet energie k dobití: coalesce(planner_max_soc_percent, max_soc_percent). ' 'Denní safety vstupy: night_baseload_* (20:00–06:00 Europe/Prague), safety_soc_target_wh (6–19), ' diff --git a/docs/04-modules/planning-arbitrage-accounting.md b/docs/04-modules/planning-arbitrage-accounting.md index a0ecd20..af0ec2b 100644 --- a/docs/04-modules/planning-arbitrage-accounting.md +++ b/docs/04-modules/planning-arbitrage-accounting.md @@ -104,24 +104,20 @@ Pro **home-01** při nabíjení 11:00–14:00 za ~0,7–0,9 Kč a výprodeji 19: --- -## 6. Implementace (2026-05) a backlog +## 6. Implementace (LP-first přestavba, 2026-05) -### Hotovo (jednoduchá varianta před solve) +### Hotovo -1. **`ems.fn_load_planning_slots_full`** (`R__063`): sloupce - `charge_acquisition_buy_czk_kwh`, `charge_acquisition_cutoff_at`. -2. **Vážený průměr `buy`** v `allow_charge` slotech **před** prvním `allow_discharge_export` (`cutoff`): - `Σ(buy × per_slot_charge_wh) / Σ(per_slot_charge_wh)` — bez `future_sell` z odpolední FVE (jinak acquisition nafukovala večerní export). -3. **`solve_dispatch`:** v exportních slotech (`allow_discharge_export`) přičíst k objective - `+ ge_bat[t] × charge_acquisition × INTERVAL_H/1000` (náklad uložené energie), ponechat `−ge×sell`. Snapshot v `solver_params.inputs`. -4. **FVE opportunity:** varianta **B** — lookahead `future_sell_opportunity`, ne jen `sell[t]` v odhadu PV Wh. +1. **`ems.fn_load_planning_slots_full`** (`R__063`): grid **B** = nejlevnější sloty v AM/PM do Wh rozpočtu (bez `buy≤min+band` a lookahead gate na grid); **A** = PV jen pokud `sell ≥ future_sell_lookahead − degrad`. `charge_acquisition` z `allow_grid_charge` před 1. exportem. +2. **`solve_dispatch` (AUTO):** objective `gi×buy − ge_pv×sell − ge_bat×sell + ge_bat×acquisition` (export bat. jen v `allow_discharge_export`). Odstraněn cross-slot guard `ge_pv ≥ surplus` / `bc=0` dle `export_refill_net`. +3. **Guard FVE:** `ge_pv=0` jen při `sell < charge_acquisition − degrad` (ne `sell < buy` ve stejném slotu). +4. **`solve_dispatch_two_pass`:** pass 1 → vážený `buy` z `bc`+`gi` v `allow_charge` → pass 2; volá `run_daily_plan` / `run_rolling_replan` v AUTO. Snapshot: `acquisition_pass1_czk_kwh`, `acquisition_pass2_czk_kwh`, `two_pass_enabled`. +5. **Regrese:** `Home01RegressionTests` v `backend/tests/test_planning_dispatch_milp.py`; masky v `test_planning_charge_slot_selection.py`. -### Zbývá / vylepšit +### Co dál neřešit ad-hoc -1. **Iterace po solve:** přepočítat acquisition z plánovaných `bc`+`gi` / `pv` místo odhadu z masek — viz [`docs/05-todo.md`](../05-todo.md). -2. **Objective:** explicitní `ge_bat × (sell − acquisition − degrad)` vs současné `−ge×sell` + `+ge_bat×acquisition` (ekvivalentní jen pokud `ge_pv` v exportním slotu ≈ 0). -3. **Masky:** více charge slotů ∝ `energy_to_fill / per_slot_wh` — viz [`planning.md`](planning.md). -4. **Bilance / guardy:** zpřesnit, aby večerní export nebyl vázaný na falešný `gi×buy` v tomže slotu. +- Další Python `if sell < buy` guardy — ekonomiku drží LP + acquisition + masky rozpočtu slotů. +- Multi-period inventory model (větší projekt) — mimo tuto vlnu. --- @@ -148,4 +144,4 @@ Očekávání: SoC před večerem **70–90 %** po levném pásmu; večer **expo --- -*Poslední aktualizace: 2026-05 — charge_acquisition před 1. exportem + LP `ge_bat` náklad; iterace po solve v TODO.* +*Poslední aktualizace: 2026-05 — LP-first přestavba (masky B/A, two-pass acquisition, explicitní ge_pv/ge_bat objective). Po deployi: `solver_params.inputs.two_pass_enabled` na novém `planning_run`.* diff --git a/docs/04-modules/planning.md b/docs/04-modules/planning.md index e2e8254..6fe23ec 100644 --- a/docs/04-modules/planning.md +++ b/docs/04-modules/planning.md @@ -11,11 +11,12 @@ - **Terminal SoC shadow price:** v objective je člen `−(avg_buy_prvních_24h × planner_terminal_soc_value_factor / 1000) × soc[T−1]` (Kč), kde faktor je **`ems.asset_battery.planner_terminal_soc_value_factor`** přes **`ems.fn_planning_site_context`** (default v DB **0.9**); viz sekci *Tuning pro malé baterie* níže. Účel: konec horizontu nemusí končit zbytečně vyprázdněnou baterií (receding horizon). - **Masky `allow_charge` / `allow_discharge_export` (tenký anti-mikrocyklus):** generuje `ems.fn_load_planning_slots_full` (`R__063`). Ekonomiku primárně řídí LP podle efektivních cen; masky jen omezují počet slotů pro grid nabíjení / export baterie. - **PV-surplus (vrstva A):** ranking dle **`store_score DESC`** = `future_sell_opportunity − sell − max(0, buy−sell)`; jen sloty s `sell ≥ buy − degradation`. Kumulativní PV pokrývá `grid_target` (deficit SoC, nad `reserve_soc` bez násobení `charge_slot_buffer`). Zbytek → `allow_charge=false` (PV jen do sítě / `bc ≤ pv_surplus` v LP). - - **Grid ze sítě (vrstva B, před FVE):** spot, **AM/PM rozpočet Wh 50/50** z `grid_target`. Výběr: nejdřív **kalendářní den plánu** (`p_from` Prague), pak sloty před **výkupním oknem daného dne** (`sell > min(buy téhož dne)+degrad` — ne globální min zítra). Lookahead VT→NT jen před tímto oknem. **`charge_acquisition`:** vážený `buy` jen u `allow_grid_charge` (ne FVE vrstva A). - - **LP (AUTO):** FVE export při `sell < buy` jen pokud `(sell − min_buy_v_charge) ≥ (future_sell − acquisition) + degrad` — jinak PV do baterie na večerní peak. Viz [`planning-arbitrage-accounting.md`](planning-arbitrage-accounting.md) §2.2. + - **Grid ze sítě (vrstva B, před FVE):** spot, **AM/PM rozpočet Wh 50/50** z `grid_target`. Výběr: **nejlevnější `buy`** v pásmu (kalendářní den plánu → před výkupním oknem dne → `buy ASC`), bez pásma `min+0,40` a bez lookahead gate na grid B. **`charge_acquisition`:** vážený `buy` jen u `allow_grid_charge` před 1. exportem; po solve **dvouprůchodově** přepočet z `bc`+`gi` (`solve_dispatch_two_pass` v `planning_engine.py`). + - **PV vrstva A:** jen pokud `sell ≥ future_sell_opportunity − degradation` (držet FVE na večerní peak, ne „nabíjet z FVE“ při nízkém sell). + - **LP (AUTO):** objective explicitně `−ge_pv×sell − ge_bat×sell + ge_bat×acquisition` v exportních slotech; **bez** cross-slot vynucení `ge_pv ≥ surplus`. Guard FVE: `ge_pv=0` jen pokud `sell < charge_acquisition − degrad` (ne `sell < buy` ve slotu). Viz [`planning-arbitrage-accounting.md`](planning-arbitrage-accounting.md). - **`ref_buy_min` (brána exportu):** `min(buy_price)` horizontu — jen „existuje levný nákup?“, **ne** průměrná cena nabití přes hodiny. Export sloty: `sell > ref_buy_min + degradation` (spot). Viz [`planning-arbitrage-accounting.md`](planning-arbitrage-accounting.md). - Pokud `energy_to_fill <= 0` nebo `charge_slot_buffer = 0`: všechny sloty povoleny. -- **LP ekonomické guardy** (`solve_dispatch`, AUTO): pokud `sell < buy − degradation` → `ge_pv=0` (výjimka: plná baterie, přebytek **pv_b**). Pokud `buy > min(buy)+degradation` → `gi` jen na load+EV+TČ. Viz `planning_engine.py` sekce po slot pre-selection. +- **LP ekonomické guardy** (`solve_dispatch`, AUTO): `ge_pv=0` pokud `sell < charge_acquisition − degradation` (výjimka: plná baterie, přebytek **pv_b**). Pokud `buy > min(buy)+degradation` mimo charge masku → `gi` jen na load+EV+TČ. Viz `planning_engine.py` po slot pre-selection. - **Denní safety charge (měkké LP, ne maska):** `fn_load_planning_slots_full` (**V077+**) vrací navíc odhad nočního baseload Wh (20:00–06:00 Europe/Prague), buffer % z `asset_battery.planner_night_baseload_buffer_percent`, lookahead `future_*_czk_kwh`, volitelný `safety_soc_target_wh` (6–19) a flag `is_daytime_pv_surplus_slot`.\n+\n+ V solveru (`planning_engine.solve_dispatch()`):\n+ - `safety_soc_target_wh` se používá primárně jako **ochrana exportu z baterie**: v běžných slotech (mimo high‑sell špičky) se při aktivním exportu vynutí `soc[t] ≥ max(arb_base_wh, safety_soc_target_wh)`.\n+ - safety deficit penalizace v objective běží jen v `is_daytime_pv_surplus_slot` (a ne v high‑sell špičce), aby solver neměl motivaci dělat obecné „nabij co nejdřív“ chování.\n+ Tvrdé `allow_charge` se kvůli tomu nemění. - **Rolling charge commitment:** při `run_rolling_replan` se z aktivního plánu načtou sloty, kde dříve platilo `battery_setpoint_w > 500`, `pv_a+pv_b > load_baseline`, `grid_setpoint_w ≤ 0` a současně **není výrazný export** (`grid_setpoint_w ≥ −500`). To je záměr: commitment má kotvit „nabíjení z PV přebytku“, ne „charge while exporting“. Měkká penalizace proti snížení `bc[t]` oproti předchozímu plánu je řízená `planner_charge_commitment_penalty_czk_kwh` na `asset_battery`. Implementace: `_load_previous_plan_charge_commitment_prev_w`, volitelný argument `charge_commitment_prev_w` u `solve_dispatch()`. - **Debug snapshot:** každý běh ukládá JSON do `ems.planning_run.solver_params` (sekce `version`, `inputs`, `masks`, `soc_bounds`, `objective_terms`, `chosen_slots`) přes `fn_planning_run_commit` (`p_run_meta->'solver_params'`). Read-model: **`select ems.fn_planning_run_debug();`** (`R__087_fn_planning_run_debug.sql`). diff --git a/docs/05-todo.md b/docs/05-todo.md index 1fbc92c..bb7d5a7 100644 --- a/docs/05-todo.md +++ b/docs/05-todo.md @@ -26,8 +26,8 @@ Shrnutí otevřených bodů z `docs/06-open-questions.md`, checklistů v modulec | Popis | Kde | Kdo | |-------|-----|-----| -| **`charge_acquisition` po solve:** druhé kolo — vážený průměr z plánovaných `bc`+`gi` a PV nabíjení místo odhadu z masek před solve; případně jedna iterace solve. Cutoff před 1. exportem už je v SQL. | `R__063_fn_load_planning_slots_full.sql`, `planning_engine.py`; [`planning-arbitrage-accounting.md`](04-modules/planning-arbitrage-accounting.md) §6 | programátor | -| **Více levných charge slotů** v masce (N ∝ `energy_to_fill / per_slot_wh`, ne jen cap 6). | `R__063` | programátor | +| ~~**`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` | — | ---