From a17c22d4751b759fb3248327d6e60390dcafaab2 Mon Sep 17 00:00:00 2001 From: Dusan Vojacek Date: Sat, 16 May 2026 15:52:14 +0200 Subject: [PATCH] dalsi fix - chtel drzet baterii prakticky porad a neprodat ani nejeet passive mode --- .../test_planning_charge_slot_selection.py | 113 ++++++++++++++++-- .../R__063_fn_load_planning_slots_full.sql | 14 ++- docs/04-modules/planning.md | 2 +- 3 files changed, 115 insertions(+), 14 deletions(-) diff --git a/backend/tests/test_planning_charge_slot_selection.py b/backend/tests/test_planning_charge_slot_selection.py index a987af3..d1799d2 100644 --- a/backend/tests/test_planning_charge_slot_selection.py +++ b/backend/tests/test_planning_charge_slot_selection.py @@ -1,15 +1,14 @@ -"""Pre-selection nabíjecích slotů (anti-micro-cycling) – referenční Python. +"""Pre-selection nabíjecích a exportních slotů – referenční Python. -Logika je v DB: ems.fn_load_planning_slots_full. Tento soubor drží kopii algoritmu -pro rychlé unit testy bez PostgreSQL. +Logika je v DB: ems.fn_load_planning_slots_full. Kopie algoritmu pro unit testy bez PG. -Algoritmus (aktuální): - A) PV-surplus sloty (pv_surplus > 0): ranking dle sell_price ASC, - vyberou se nejlevnější, dokud kumulativní PV surplus nepokryje - charge target (energy_to_fill × charge_buf). Zbylé → PV do sítě. - B) Non-PV sloty (pv_surplus <= 0): AM/PM rozpočet 50/50, - OTE-first priorita (is_predicted_price=false před true), - poté seřazené dle buy_price ASC. +Charge mask: + A) PV-surplus: sell_price ASC, dokud PV nepokryje charge target. + B) Non-PV: AM/PM 50/50, OTE-first, buy_price ASC. + +Discharge-export mask: + ref_buy = min(buy) mezi allow_charge sloty (arbitráž mezi sloty, ne sell vs buy ve stejném). + Top sloty dle sell_price desc kde sell > ref_buy + degradation. """ from __future__ import annotations @@ -108,6 +107,54 @@ def _select_charge_slots( return selected +def _select_discharge_export_slots( + slots: list[PlanningSlot], + battery: SimpleNamespace, + current_soc_wh: float, + charge_slots: set[int] | None = None, +) -> set[int]: + """Kopie logiky z ems.fn_load_planning_slots_full (discharge-export mask).""" + discharge_buf = float(getattr(battery, "discharge_slot_buffer", 0) or 0) + if discharge_buf <= 0: + return set(range(len(slots))) + + min_soc_wh = float(getattr(battery, "min_soc_wh", 0) or 0) + soc_max_wh = float(battery.soc_max_wh) + exportable_wh = soc_max_wh - min_soc_wh + if exportable_wh <= 0: + return set() + + degrad = float(getattr(battery, "degradation_cost_czk_kwh", 0.15) or 0.15) + eta = float(getattr(battery, "discharge_efficiency", 1.0) or 1.0) + max_p_w = float(getattr(battery, "max_discharge_power_w", 0.0) or 0.0) + per_slot_wh = max_p_w * eta * INTERVAL_H + discharge_target_wh = exportable_wh * discharge_buf + + if charge_slots is None: + charge_slots = _select_charge_slots(slots, battery, current_soc_wh) + + ref_buy = min( + (float(slots[t].buy_price) for t in charge_slots), + default=min(float(s.buy_price) for s in slots), + ) + + candidates = [ + (t, float(slots[t].sell_price)) + for t in range(len(slots)) + if float(slots[t].sell_price) > ref_buy + degrad + ] + candidates.sort(key=lambda x: (-x[1], -x[0])) + + selected: set[int] = set() + cum = 0.0 + for t, _sell in candidates: + if cum >= discharge_target_wh or per_slot_wh <= 0: + break + selected.add(t) + cum += per_slot_wh + return selected + + def _prague_hour(s: PlanningSlot) -> int: dt = s.interval_start if dt.tzinfo is None: @@ -140,17 +187,28 @@ def _slot( def _battery( *, charge_buf: float = 1.3, + discharge_buf: float = 1.5, uc_wh: float = 64_000.0, soc_max_pct: float = 95.0, + min_soc_pct: float = 10.0, max_charge_w: float = 18_000.0, + max_discharge_w: float = 18_000.0, charge_eff: float = 0.95, + discharge_eff: float = 0.95, + degrad: float = 0.15, ) -> SimpleNamespace: + uc = uc_wh return SimpleNamespace( - usable_capacity_wh=uc_wh, - soc_max_wh=soc_max_pct / 100.0 * uc_wh, + usable_capacity_wh=uc, + min_soc_wh=min_soc_pct / 100.0 * uc, + soc_max_wh=soc_max_pct / 100.0 * uc, max_charge_power_w=max_charge_w, + max_discharge_power_w=max_discharge_w, charge_efficiency=charge_eff, + discharge_efficiency=discharge_eff, charge_slot_buffer=charge_buf, + discharge_slot_buffer=discharge_buf, + degradation_cost_czk_kwh=degrad, ) @@ -241,5 +299,36 @@ class SelectChargeSlotsTests(unittest.TestCase): ) +class SelectDischargeExportSlotsTests(unittest.TestCase): + def test_evening_sell_allowed_when_cheaper_than_ref_charge_buy(self) -> None: + """Regrese home-01: večer sell 3.3 > ref_buy 0.5 + degrad i když buy ve slotu je 5.6.""" + slots = [ + _slot(buy=0.50, sell=-0.30, hour_utc=6), + _slot(buy=0.51, sell=-0.29, hour_utc=7), + _slot(buy=5.60, sell=3.30, hour_utc=16), + _slot(buy=5.98, sell=3.37, hour_utc=17), + ] + battery = _battery(uc_wh=64_000.0) + charge = _select_charge_slots(slots, battery, current_soc_wh=0.2 * battery.usable_capacity_wh) + discharge = _select_discharge_export_slots( + slots, battery, current_soc_wh=0.2 * battery.usable_capacity_wh, charge_slots=charge + ) + self.assertIn(0, charge) + self.assertIn(2, discharge, "Evening sell must qualify vs ref buy, not same-slot buy") + self.assertIn(3, discharge) + + def test_export_excluded_when_sell_below_ref_buy_plus_degradation(self) -> None: + slots = [ + _slot(buy=0.40, sell=0.10, hour_utc=8), + _slot(buy=4.00, sell=0.50, hour_utc=18), + ] + battery = _battery(uc_wh=10_000.0, discharge_buf=2.0) + charge = _select_charge_slots(slots, battery, current_soc_wh=0.0) + discharge = _select_discharge_export_slots( + slots, battery, current_soc_wh=0.0, charge_slots=charge + ) + self.assertNotIn(1, discharge, "sell 0.5 < ref 0.4 + 0.15") + + 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 8d81d39..c788ab3 100644 --- a/db/routines/R__063_fn_load_planning_slots_full.sql +++ b/db/routines/R__063_fn_load_planning_slots_full.sql @@ -61,6 +61,7 @@ declare v_daytime_en boolean; v_night_buf_pct numeric; v_degrad_czk_kwh numeric; + v_ref_buy_czk_kwh numeric; begin drop table if exists _ems_plan_slot_wk; create temp table _ems_plan_slot_wk on commit drop as @@ -323,6 +324,17 @@ begin end loop; end if; + -- Referenční nákup pro arbitráž exportu: nejlevnější buy mezi sloty, kde lze nabíjet + -- (ne buy ve stejném slotu — střídač nekupuje a neprodává současně). + select coalesce( + min(wk.buy_price) filter (where wk.allow_charge), + min(wk.buy_price) + ) + into v_ref_buy_czk_kwh + from _ems_plan_slot_wk wk; + + v_ref_buy_czk_kwh := coalesce(v_ref_buy_czk_kwh, 0); + -- discharge-export mask if v_discharge_buf <= 0 then update _ems_plan_slot_wk wk set allow_discharge_export = true; @@ -334,7 +346,7 @@ begin for r_slot in select wk.slot_ord from _ems_plan_slot_wk wk - where wk.sell_price > wk.buy_price + v_degrad_czk_kwh + where wk.sell_price > v_ref_buy_czk_kwh + v_degrad_czk_kwh order by wk.sell_price desc, wk.slot_ord desc loop exit when v_cum >= v_discharge_target_wh; diff --git a/docs/04-modules/planning.md b/docs/04-modules/planning.md index 279a868..e977e30 100644 --- a/docs/04-modules/planning.md +++ b/docs/04-modules/planning.md @@ -30,7 +30,7 @@ - měkký cíl na konci 24h přes `_soc_security_profile` + tvrdé dvouúrovňové pravidlo výše. - **Dynamická ekonomická podlaha (fáze 2):** - `_dynamic_arb_floor_wh_series`: podle součtu FVE výkonu v dalších ~8 h (`ARB_LOOKAHEAD_SLOTS`) se `arb_floor_wh[t]` posouvá mezi `min_soc_wh` a rezervou z DB – silné očekávané slunce ji sníží (ráno / po obloze); vynutit konstantní chování lze `battery.disable_dynamic_arb_floor=True` jen pro testy / ladění. -- **Výběr exportních slotů (`allow_discharge_export`):** `ems.fn_load_planning_slots_full` označí jen sloty, kde smí solver **úmyslně** vybíjet baterii do sítě (SELL). Výběr je **globálně** podle `sell_price desc` (ne AM/PM 50/50) a jen kde `sell_price > buy_price + degradation_cost_czk_kwh` (žádný export se ztrátou). V `solve_dispatch` (AUTO): mimo tyto sloty platí **`bd[t] = 0`** a **`w_arb[t] = 0`** — EMS **neplánuje** vybíjení do predikovaného `load_baseline`; skutečnou zátěž v těch slotech pokrývá střídač v režimu **PASSIVE** (`deye_physical_mode`). **CHARGE** jen v `allow_charge` slotech s importem+nabíjením; **SELL** jen v `allow_discharge_export` s exportem+vybíjením. +- **Výběr exportních slotů (`allow_discharge_export`):** `ems.fn_load_planning_slots_full` označí jen sloty, kde smí solver **úmyslně** vybíjet baterii do sítě (SELL). Výběr je **globálně** podle `sell_price desc` (ne AM/PM 50/50). Ekonomická podmínka je **arbitráž mezi sloty**: `sell_price > ref_buy + degradation_cost_czk_kwh`, kde `ref_buy` = `min(buy_price)` mezi sloty s `allow_charge=true` (fallback `min` v celém horizontu) — **ne** porovnání sell vs buy ve stejném intervalu. V `solve_dispatch` (AUTO): mimo tyto sloty platí **`bd[t] = 0`** a **`w_arb[t] = 0`** — EMS **neplánuje** vybíjení do predikovaného `load_baseline`; skutečnou zátěž pokrývá střídač v **PASSIVE**. **CHARGE** jen v `allow_charge` slotech; **SELL** jen v `allow_discharge_export`. - **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í —