From b4e5fc5040c9d21035ab06aed8eeb209ff77cc88 Mon Sep 17 00:00:00 2001 From: Dusan Vojacek Date: Tue, 26 May 2026 08:29:05 +0200 Subject: [PATCH] uprava aby rano prodaval do site pred sell < 0 oknem --- backend/services/planning_engine.py | 178 +++++++++++++++++-- backend/tests/test_planning_dispatch_milp.py | 128 +++++++++++++ docs/04-modules/planning.md | 3 +- docs/planning-changelog.md | 8 + 4 files changed, 303 insertions(+), 14 deletions(-) diff --git a/backend/services/planning_engine.py b/backend/services/planning_engine.py index df4fd4f..992331a 100644 --- a/backend/services/planning_engine.py +++ b/backend/services/planning_engine.py @@ -71,7 +71,12 @@ 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-neg-sell-soc-phases-v32" +PLANNER_BUILD_TAG = "2026-05-28-pre-neg-pv-export-forecast-v33" +# Před prvním sell<0: export FVE jen pokud predikce v sell<0 okně pokryje dobítí na prep cíl. +PRE_NEG_PV_EXPORT_FORECAST_MARGIN = 1.15 +PRE_NEG_PV_EXPORT_MIN_NEEDED_WH = 2500.0 +PRE_NEG_PV_EXPORT_SHORTFALL_PENALTY_CZK_KWH = 55.0 +PRE_NEG_PV_BCPV_DISCOURAGE_CZK_KWH = 90.0 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 @@ -860,6 +865,90 @@ def _neg_sell_day_phases( return phases, soc_targets, shortfall_weights +def _neg_sell_day_pv_usable_wh( + slots: list[PlanningSlot], + first_neg_sell_idx: int | None, + *, + max_charge_power_w: float, + charge_efficiency: float, +) -> float: + """ + Odhad Wh nabitelné z FVE v sell<0 slotech téhož pražského dne (forecast surplus × cap nabíjení). + """ + if first_neg_sell_idx is None: + return 0.0 + neg_day = _prague_calendar_date(slots[first_neg_sell_idx]) + total_wh = 0.0 + for s in slots: + if _prague_calendar_date(s) != neg_day: + continue + if float(s.sell_price) >= 0.0: + continue + pv_surplus_w = max( + 0.0, + float(s.pv_a_forecast_w) + + float(s.pv_b_forecast_w) + - float(s.load_baseline_w), + ) + if pv_surplus_w <= 500.0: + continue + cap_w = min(pv_surplus_w, float(max_charge_power_w)) + total_wh += cap_w * INTERVAL_H * float(charge_efficiency) + return total_wh + + +def _pre_neg_pv_export_forecast_cushion_ok( + slots: list[PlanningSlot], + battery: Any, + current_soc_wh: float, + first_neg_sell_idx: int | None, + *, + neg_sell_phases_en: bool, +) -> bool: + """ + Export FVE před sell<0 jen pokud forecast v záporném okně pokryje dobítí na cíl (typ. 80 %). + Jinak raději nabíjet teď — riziko deště / podhodnocené FVE v sell<0. + """ + if first_neg_sell_idx is None or first_neg_sell_idx <= 0: + return False + prep_pct = float(getattr(battery, "planner_neg_sell_prep_soc_percent", 100.0)) + if neg_sell_phases_en and prep_pct < 100.0 - 1e-6: + target_wh = prep_pct / 100.0 * float(battery.soc_max_wh) + else: + target_wh = float(battery.soc_max_wh) + needed_wh = max(0.0, target_wh - float(current_soc_wh)) + if needed_wh < PRE_NEG_PV_EXPORT_MIN_NEEDED_WH: + return True + usable_wh = _neg_sell_day_pv_usable_wh( + slots, + first_neg_sell_idx, + max_charge_power_w=float(battery.max_charge_power_w), + charge_efficiency=float(battery.charge_efficiency), + ) + return usable_wh >= needed_wh * PRE_NEG_PV_EXPORT_FORECAST_MARGIN + + +def _pre_neg_pv_export_slot_indices( + slots: list[PlanningSlot], + first_neg_sell_idx: int | None, + pre_neg_export_last_t: int | None, + first_neg_buy_idx: int | None, +) -> set[int]: + """Sloty s kladným sell před prvním sell<0 (a před buy<0), PV přebytek).""" + if first_neg_sell_idx is None or pre_neg_export_last_t is None: + return set() + out: set[int] = set() + for t in range(pre_neg_export_last_t + 1): + if float(slots[t].sell_price) < 0.0: + continue + if first_neg_buy_idx is not None and t >= first_neg_buy_idx: + continue + if _slot_pv_surplus_w(slots[t]) <= NIGHT_EXPORT_PV_SUNRISE_SURPLUS_W: + continue + out.add(t) + return out + + MORNING_PRENEG_START_HOUR = 5 MORNING_PRENEG_END_HOUR = 11 @@ -1646,6 +1735,29 @@ def solve_dispatch( prep_hold_bcpv_shortfall: list[tuple[int, pulp.LpVariable, float]] = [] prep_hold_curtail_shortfall: list[tuple[int, pulp.LpVariable, float]] = [] prep_hold_met_binary: dict[int, pulp.LpVariable] = {} + pre_neg_pv_export_forecast_ok = bool( + om == "AUTO" + and not purchase_fixed_pre + and first_neg_sell_idx is not None + and pre_neg_export_last_t is not None + and _pre_neg_pv_export_forecast_cushion_ok( + slots, + battery, + current_soc_wh, + first_neg_sell_idx, + neg_sell_phases_en=neg_sell_phases_en, + ) + ) + pre_neg_pv_export_ts = ( + _pre_neg_pv_export_slot_indices( + slots, + first_neg_sell_idx, + pre_neg_export_last_t, + first_neg_buy_idx, + ) + if pre_neg_pv_export_forecast_ok + else set() + ) pre_neg_buy_discharge_ts: set[int] = set() if om == "AUTO" and first_neg_buy_idx is not None and first_neg_buy_idx > 0: pre_neg_buy_discharge_ts = _pre_neg_buy_discharge_indices( @@ -1815,6 +1927,7 @@ def solve_dispatch( peak_export_shortfall: list[tuple[int, pulp.LpVariable, float]] = [] pv_charge_shortfall: list[tuple[int, pulp.LpVariable, float]] = [] pre_neg_pv_charge_shortfall: list[tuple[int, pulp.LpVariable, float]] = [] + pre_neg_pv_export_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, float]] = [] neg_buy_charge_shortfall: list[tuple[int, pulp.LpVariable, float]] = [] @@ -1904,6 +2017,25 @@ def solve_dispatch( cap_ns = float(min(pv_surplus_ns, battery.max_charge_power_w)) sf_ns = pulp.LpVariable(f"neg_phase_pv_charge_{t_ns}", 0, cap_ns) pv_charge_shortfall.append((t_ns, sf_ns, cap_ns)) + if pre_neg_pv_export_forecast_ok: + for t_pe in sorted(pre_neg_pv_export_ts): + s_pe = slots[t_pe] + pv_surplus_pe = max( + 0.0, + float(s_pe.pv_a_forecast_w) + + float(s_pe.pv_b_forecast_w) + - float(s_pe.load_baseline_w), + ) + cap_pe = float( + min( + pv_surplus_pe, + float(grid.max_export_power_w), + ) + ) + if cap_pe <= 500.0: + continue + sf_pe = pulp.LpVariable(f"pre_neg_pv_export_sf_{t_pe}", 0, cap_pe) + pre_neg_pv_export_shortfall.append((t_pe, sf_pe, cap_pe)) for t in range(T): if not post_neg_pv_topup[t]: continue @@ -2122,6 +2254,17 @@ def solve_dispatch( sf * NEG_SELL_CURTAIL_PENALTY_CZK_KWH * INTERVAL_H / 1000.0 for _t, sf, _cap in prep_hold_curtail_shortfall ) + + pulp.lpSum( + sf * PRE_NEG_PV_EXPORT_SHORTFALL_PENALTY_CZK_KWH * INTERVAL_H / 1000.0 + for _t, sf, _cap in pre_neg_pv_export_shortfall + ) + + pulp.lpSum( + bc_pv[t] + * PRE_NEG_PV_BCPV_DISCOURAGE_CZK_KWH + * INTERVAL_H + / 1000.0 + for t in pre_neg_pv_export_ts + ) + 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 @@ -2211,6 +2354,8 @@ def solve_dispatch( prob += sf >= cap_w - ge_bat[t_sf] for t_sf, sf, cap_w in pre_neg_pv_charge_shortfall: prob += sf >= cap_w - bc_pv[t_sf] + for t_sf, sf, cap_w in pre_neg_pv_export_shortfall: + prob += sf >= cap_w - ge_pv[t_sf] preneg_export_min_soc_wh = float(min_soc_wh) + max( float(battery.max_discharge_power_w) * float(battery.discharge_efficiency) @@ -2662,6 +2807,9 @@ def solve_dispatch( ): prob += ge_bat[t] == 0 prob += z_export[t] == 0 + for t_pne in pre_neg_pv_export_ts: + # v33: při dostatečné FVE v sell<0 okně neukládat ranní PV do baterie — export. + prob += bc_pv[t_pne] == 0 # Ekonomické guardy: ceny v objective nestačí proti maskám / terminal SoC. # Referenční buy jen z ne-záporných slotů: jinak jeden buy<0 v horizontu označí @@ -2689,18 +2837,8 @@ def solve_dispatch( 0.0, float(s.pv_a_forecast_w) + float(s.pv_b_forecast_w) - load_t, ) - # FVE export: před prvním sell<0 smí jít přebytek do sítě (kladný sell), pak nabít - # v záporném okně z PV. Jinak držet energii na future_sell peak. - allow_pre_neg_pv_export = ( - first_neg_sell_idx is not None - and pre_neg_export_last_t is not None - and t <= pre_neg_export_last_t - and sell_t >= 0 - and ( - first_neg_buy_idx is None - or t < first_neg_buy_idx - ) - ) + # FVE export před sell<0 jen pokud forecast v sell<0 okně pokryje dobítí (v33). + allow_pre_neg_pv_export = t in pre_neg_pv_export_ts pv_store_val = _pv_store_value_czk_kwh(s, min_spread) skip_pv_store_block = ( float(s.pv_b_forecast_w) > 0 @@ -3124,6 +3262,20 @@ def solve_dispatch( ), }, "neg_sell_phases_enabled": bool(neg_sell_phases_en), + "pre_neg_pv_export_forecast_ok": bool(pre_neg_pv_export_forecast_ok), + "pre_neg_pv_export_slots": [ + slots[i].interval_start.isoformat() for i in sorted(pre_neg_pv_export_ts) + ], + "neg_sell_day_pv_usable_wh": ( + _neg_sell_day_pv_usable_wh( + slots, + first_neg_sell_idx, + max_charge_power_w=float(battery.max_charge_power_w), + charge_efficiency=float(battery.charge_efficiency), + ) + if first_neg_sell_idx is not None + else None + ), "load_first_enabled": om == "AUTO", "relaxed_expensive_import": relaxed_expensive_import, "charge_acquisition_buy_czk_kwh": charge_acquisition_czk_kwh, diff --git a/backend/tests/test_planning_dispatch_milp.py b/backend/tests/test_planning_dispatch_milp.py index 512d784..3429da2 100644 --- a/backend/tests/test_planning_dispatch_milp.py +++ b/backend/tests/test_planning_dispatch_milp.py @@ -21,6 +21,7 @@ from services.planning_engine import ( _neg_sell_phases_enabled, _pre_neg_buy_soc_ceiling_wh, _pre_neg_peak_sell_idx, + _pre_neg_pv_export_forecast_cushion_ok, _prague_hour, _prewindow_deferral_slots, _slots_until_buy_le_threshold, @@ -3845,5 +3846,132 @@ class NegSellSocPhaseTests(unittest.TestCase): self.assertLessEqual(max(0, -results[-1].grid_setpoint_w), 500) +class PreNegPvExportForecastTests(unittest.TestCase): + """v33: export FVE před sell<0 jen pokud forecast v sell<0 okně pokryje prep SoC.""" + + @staticmethod + def _slots_morning_then_neg(n: int = 22, *, neg_pv_scale: float = 1.0) -> list[PlanningSlot]: + base = datetime(2026, 6, 10, 6, 0, tzinfo=timezone.utc) + out: list[PlanningSlot] = [] + for i in range(n): + sell = -0.25 if i >= 6 else (2.8 if i < 4 else 1.2) + if i >= 6: + pv_a = (8000 + (i - 6) * 500) * neg_pv_scale + pv_b = 6000.0 * neg_pv_scale + else: + pv_a = 1500 + i * 400 + pv_b = 1500.0 + future_sell = 6.5 if sell >= 0 else None + out.append( + PlanningSlot( + interval_start=base + timedelta(minutes=15 * i), + buy_price=2.0, + sell_price=sell, + pv_a_forecast_w=pv_a, + pv_b_forecast_w=pv_b, + load_baseline_w=450, + ev1_connected=False, + ev2_connected=False, + allow_charge=True, + allow_discharge_export=False, + future_sell_opportunity_czk_kwh=future_sell, + ) + ) + return out + + def test_cushion_ok_when_neg_window_pv_large(self) -> None: + slots = self._slots_morning_then_neg() + bat = _battery(uc_wh=64_000.0, max_pct=95.0) + bat.planner_neg_sell_prep_soc_percent = 80.0 + bat.planner_neg_sell_full_soc_tail_slots = 4 + self.assertTrue( + _pre_neg_pv_export_forecast_cushion_ok( + slots, + bat, + 0.30 * bat.soc_max_wh, + 6, + neg_sell_phases_en=True, + ) + ) + + def test_cushion_fail_when_neg_window_pv_tiny(self) -> None: + slots = self._slots_morning_then_neg(neg_pv_scale=0.05) + bat = _battery(uc_wh=64_000.0, max_pct=95.0) + bat.planner_neg_sell_prep_soc_percent = 80.0 + bat.planner_neg_sell_full_soc_tail_slots = 4 + self.assertFalse( + _pre_neg_pv_export_forecast_cushion_ok( + slots, + bat, + 0.30 * bat.soc_max_wh, + 6, + neg_sell_phases_en=True, + ) + ) + + def test_morning_exports_pv_when_cushion_ok(self) -> None: + slots = self._slots_morning_then_neg() + bat = _battery(uc_wh=64_000.0, max_pct=95.0) + bat.planner_neg_sell_prep_soc_percent = 80.0 + bat.planner_neg_sell_full_soc_tail_slots = 4 + bat.planner_neg_sell_vent_min_sell_czk_kwh = -1.0 + 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=13_500, + block_export_on_negative_sell=False, + ) + 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, + bat, + hp, + grid, + [None, None], + vehicles, + 0.30 * bat.soc_max_wh, + 50.0, + operating_mode="AUTO", + ) + self.assertTrue(snap["inputs"].get("pre_neg_pv_export_forecast_ok")) + self.assertIn( + slots[2].interval_start.isoformat(), + snap["inputs"].get("pre_neg_pv_export_slots") or [], + ) + self.assertLess(results[2].grid_setpoint_w, -500) + + def test_morning_charges_when_cushion_fail(self) -> None: + slots = self._slots_morning_then_neg(neg_pv_scale=0.05) + bat = _battery(uc_wh=64_000.0, max_pct=95.0) + bat.planner_neg_sell_prep_soc_percent = 80.0 + bat.planner_neg_sell_full_soc_tail_slots = 4 + 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=13_500, + block_export_on_negative_sell=False, + ) + 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, + bat, + hp, + grid, + [None, None], + vehicles, + 0.30 * bat.soc_max_wh, + 50.0, + operating_mode="AUTO", + ) + self.assertFalse(snap["inputs"].get("pre_neg_pv_export_forecast_ok")) + self.assertGreater(results[2].battery_setpoint_w, 2000) + + if __name__ == "__main__": unittest.main() diff --git a/docs/04-modules/planning.md b/docs/04-modules/planning.md index 4e24808..2966844 100644 --- a/docs/04-modules/planning.md +++ b/docs/04-modules/planning.md @@ -50,7 +50,8 @@ **Planner tag v26:** v25 + upřesnění večerního exportu — viz sekce **Večerní export z baterie** níže a changelog v26. **Planner tag v23:** v22b + **výboj baterie do sítě** před `buy<0` (`_pre_neg_buy_discharge_indices`, sell≥1 Kč/kWh, push `ge_bat` z DB limitů). Viz changelog v23. 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`** (legacy): safety deficit cílí **`soc_max_wh`**; po posledním **`sell < 0`**: **`post_neg_pv_topup`**. **Planner tag v32:** fázované SoC — viz níže. -- **Záporný výkup — fázované SoC (v32, `2026-05-28-neg-sell-soc-phases-v32`):** Parametry na **`ems.asset_battery`**: `planner_neg_sell_prep_soc_percent` (default **80**), `planner_neg_sell_full_soc_tail_slots` (default **4** = 1 h), `planner_neg_sell_vent_min_sell_czk_kwh` (default **−1** u home-01; **NULL** = ventil B jen při plné baterii). **`_neg_sell_day_phases`** (kalendářní den Prague): **prep** = ASAP nabít na prep %; **tail** = poslední N slotů rampa na `soc_max` + volitelný `ge_pv ≤ pv_b` pokud `sell ≥` práh; měkký curtail A (`pv_a_curtailed_w`) při SoC ≥ prep. Realizace na Deye: **reg 340** = forecast − curtail; při plné baterii bez curtailu v plánu EMS 340 **nezapisuje** (solar sell off). Legacy: `prep_soc_percent ≥ 100` nebo `tail_slots = 0`. KV1: seed `prep=100`. Ověření: `NegSellSocPhaseTests`, `solver_params.masks[].neg_sell_phase`. 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ý výkup — fázované SoC (v32, `2026-05-28-neg-sell-soc-phases-v32`):** Parametry na **`ems.asset_battery`**: `planner_neg_sell_prep_soc_percent` (default **80**), `planner_neg_sell_full_soc_tail_slots` (default **4** = 1 h), `planner_neg_sell_vent_min_sell_czk_kwh` (default **−1** u home-01; **NULL** = ventil B jen při plné baterii). **`_neg_sell_day_phases`** (kalendářní den Prague): **prep** = ASAP nabít na prep %; **tail** = poslední N slotů rampa na `soc_max` + volitelný `ge_pv ≤ pv_b` pokud `sell ≥` práh; měkký curtail A (`pv_a_curtailed_w`) při SoC ≥ prep. Realizace na Deye: **reg 340** = forecast − curtail; při plné baterii bez curtailu v plánu EMS 340 **nezapisuje** (solar sell off). Legacy: `prep_soc_percent ≥ 100` nebo `tail_slots = 0`. KV1: seed `prep=100`. Ověření: `NegSellSocPhaseTests`, `solver_params.masks[].neg_sell_phase`. +- **Před sell<0 — export FVE s forecast pojistkou (v33):** `_pre_neg_pv_export_forecast_cushion_ok` — export FVE v kladných slotech před prvním `sell<0` jen pokud součet predikovaného PV přebytku v sell<0 okně (týž pražský den) pokryje dobítí na prep SoC (× **1,15**). Jinak LP raději nabíjí z FVE (riziko deště). Při splněné pojistce: `bc_pv=0` v `pre_neg_pv_export_ts`, shortfall na `ge_pv`, penalizace `bc_pv`. `solver_params.inputs.pre_neg_pv_export_forecast_ok`, `pre_neg_pv_export_slots`. Testy `PreNegPvExportForecastTests`. 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). - **Záporná prodejní cena → tvrdý zákaz vývozu (`ge = 0`)** (`planning_engine.solve_dispatch`): platí ve slotu kde `sell_price < 0`, pokud lokality zapne některou z opcí — diff --git a/docs/planning-changelog.md b/docs/planning-changelog.md index 53977b7..1108322 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 — Před sell<0: export FVE jen při dostatečné predikci v záporném okně (v33) + +**Problém:** Při kladném sell ráno LP nabíjel na večerní peak (~6,5 Kč) místo exportu (~3 Kč). Uživatel chce export teď, ale ne když forecast v sell<0 okně nestačí na dobítí (déšť). + +**Změna (tag `2026-05-28-pre-neg-pv-export-forecast-v33`):** `_pre_neg_pv_export_forecast_cushion_ok` — porovná potřebné Wh na prep SoC (80 %) s odhadem FVE v sell<0 slotech téhož dne (`_neg_sell_day_pv_usable_wh` × margin 1,15). Jen pak `pre_neg_pv_export_ts` + shortfall `ge_pv` + **`bc_pv=0`** (ranní FVE ne do baterie). Jinak staré chování (šetřit na večer / nabít z FVE). + +**Ověření:** `pytest … -k PreNegPvExportForecastTests` · `solver_params.inputs.pre_neg_pv_export_forecast_ok`. + ## 2026-05-28 — Záporný výkup: fázované SoC a curtail A (v32) **Problém:** V okně `sell < 0` LP tlačil `soc_max` až na konci; nepraktické pro EV/TČ/oblačnost; curtail A na FE málo viditelný.