From faf948d75b74475219dfd2294339f85a3c18cf2a Mon Sep 17 00:00:00 2001 From: Dusan Vojacek Date: Wed, 22 Apr 2026 19:41:11 +0200 Subject: [PATCH] fix max grid kw --- backend/services/planning_engine.py | 22 ++++-- backend/tests/test_planning_dispatch_milp.py | 77 ++++++++++++++++---- 2 files changed, 80 insertions(+), 19 deletions(-) diff --git a/backend/services/planning_engine.py b/backend/services/planning_engine.py index 6f88a91..f7ac139 100644 --- a/backend/services/planning_engine.py +++ b/backend/services/planning_engine.py @@ -318,6 +318,11 @@ def solve_dispatch( prob = pulp.LpProblem("ems_dispatch", pulp.LpMinimize) + # Penalizace překročení breakeru (Kč/kWh importu nad max_import_power_w). + # Záměr: breaker je fyzický strop, ale kvůli chybám forecastu a krátkým „extrémním“ oknům + # (např. záporná nákupní cena) umožníme solveru nominálně jít nad breaker, ovšem pouze za cenu. + IMPORT_OVER_BREAKER_PENALTY_CZK_KWH = 10.0 + min_soc_wh = float(getattr(battery, "min_soc_wh", battery.reserve_soc_wh)) arb_base_wh = max( float(getattr(battery, "arb_floor_wh", battery.reserve_soc_wh)), @@ -331,14 +336,15 @@ def solve_dispatch( ) # --- Proměnné --- - # gi[t] horní mez: site breaker (max_import_power_w) je fyzický strop, ale o jeho dodržení - # se v reálném čase stará **Deye reg 128** (grid charge current) + firmware throttling — - # dynamicky sníží nabíjení baterie, když aktuální `load + bc` přesáhne breaker. Proto LP - # povolí nominálně import až **breaker + BMS max charge**, aby mohl plánovat `bc = BMS max` - # i v slotech s vyšší baseline zátěží (jinak tvrdý strop zbytečně osekává arbitráž v cenově - # nejlepších 15min oknech). Reálný hardware nikdy víc než breaker nenatáhne. + # gi[t] horní mez: site breaker (max_import_power_w) je fyzický strop. + # Pro robustnost (forecast PV/load nemusí sedět) používáme měkký cap: dovolíme gi nominálně + # až ~breaker + BMS max charge, ale překročení breakeru je penalizované (viz gi_over). gi_upper = float(grid.max_import_power_w) + float(battery.max_charge_power_w) gi = [pulp.LpVariable(f"gi_{t}", 0, gi_upper) for t in range(T)] + gi_over = [ + pulp.LpVariable(f"gi_over_{t}", 0, max(0.0, gi_upper - float(grid.max_import_power_w))) + for t in range(T) + ] ge = [pulp.LpVariable(f"ge_{t}", 0, grid.max_export_power_w) for t in range(T)] bc = [pulp.LpVariable(f"bc_{t}", 0, battery.max_charge_power_w) for t in range(T)] bd = [pulp.LpVariable(f"bd_{t}", 0, battery.max_discharge_power_w) for t in range(T)] @@ -381,6 +387,7 @@ def solve_dispatch( pulp.lpSum( gi[t] * slots[t].buy_price * INTERVAL_H / 1000 - ge[t] * slots[t].sell_price * INTERVAL_H / 1000 + + gi_over[t] * IMPORT_OVER_BREAKER_PENALTY_CZK_KWH * INTERVAL_H / 1000 + 0.5 * (bc[t] + bd[t]) * degradation_cost_effective * INTERVAL_H / 1000 + pulp.lpSum( ev_direct[e][t] * slots[t].buy_price * INTERVAL_H / 1000 @@ -412,6 +419,9 @@ def solve_dispatch( == s.load_baseline_w + ev_total_t + hp[t] + bc[t] + ge[t] ) + # Měkký breaker cap: gi_over[t] >= max(0, gi[t] - breaker). + prob += gi_over[t] >= gi[t] - float(grid.max_import_power_w) + # SoC kontinuita soc_prev = current_soc_wh if t == 0 else soc[t - 1] prob += soc[t] == ( diff --git a/backend/tests/test_planning_dispatch_milp.py b/backend/tests/test_planning_dispatch_milp.py index 3366de5..2d70ccf 100644 --- a/backend/tests/test_planning_dispatch_milp.py +++ b/backend/tests/test_planning_dispatch_milp.py @@ -255,16 +255,12 @@ class PlanningDispatchMilpTests(unittest.TestCase): ) - def test_grid_import_cap_allows_full_bms_charge_above_breaker(self) -> None: + def test_grid_import_soft_cap_penalizes_breaker_overdraw(self) -> None: """ - Cheap buy, load 3.7 kW, PV malé → breaker 17 kW limituje gi, ale bc musí moct být - plných BMS 18 kW (Deye reg 128 + firmware throttling chrání jistič fyzicky). + Soft cap: solver může nominálně překročit breaker, ale jen pokud se to vyplatí. + Při běžné (nezáporné) nákupní ceně by měl držet import <= breaker. """ - slots = [ - _slot(load=3700, buy=0.4, sell=-0.3, pv_a=0, pv_b=1500), - _slot(load=2000, buy=5.0, sell=4.5, pv_a=0, pv_b=0), - _slot(load=2000, buy=5.0, sell=4.5, pv_a=0, pv_b=0), - ] + slots = [_slot(load=3700, buy=0.4, sell=-0.3, pv_a=0, pv_b=1500)] battery = _battery(uc_wh=64_000.0, min_pct=12.0, arb_pct=20.0) battery.max_charge_power_w = 18_000 battery.max_discharge_power_w = 18_000 @@ -299,11 +295,66 @@ class PlanningDispatchMilpTests(unittest.TestCase): tuv_delta_stats=None, operating_mode="AUTO", ) - self.assertEqual(len(results), 3) - self.assertGreaterEqual( - results[0].battery_setpoint_w, - 17_500, - msg="LP must be able to target near-BMS-max charge even when gi would exceed breaker", + self.assertEqual(len(results), 1) + self.assertLessEqual( + results[0].grid_setpoint_w, + grid.max_import_power_w, + msg="soft cap: for normal buy price, planned grid import should not exceed breaker", + ) + + def test_grid_import_soft_cap_allows_overdraw_when_extremely_negative(self) -> None: + """ + Regrese: při extrémně záporné nákupní ceně může solver překročit breaker (za cenu penalizace), + aby stihl krátké okno nabíjení. Překročení nesmí být 'zadarmo' (kontrolujeme alespoň, že existuje). + """ + # Dvouslotový scénář: v 1. slotu extrémně záporná cena, ve 2. slotu drahá. + # Terminal SoC kotva pak nepenalizuje držení energie (průměrná buy je ~0) a solver má motivaci + # v 1. slotu nabít na max, i kdyby to znamenalo malé překročení breakeru. + s0 = _slot(load=0, buy=-20.0, sell=-0.3, pv_a=0, pv_b=0) + s1 = replace_slot(s0, load=0) + s1 = PlanningSlot( + interval_start=s0.interval_start + timedelta(minutes=15), + buy_price=20.0, + sell_price=-0.3, + pv_a_forecast_w=0, + pv_b_forecast_w=0, + load_baseline_w=0, + ev1_connected=False, + ev2_connected=False, + is_predicted_price=False, + ) + slots = [s0, s1] + battery = _battery(uc_wh=64_000.0, min_pct=12.0, arb_pct=20.0) + battery.max_charge_power_w = 18_000 + battery.max_discharge_power_w = 18_000 + 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=17_000, max_export_power_w=13_500) + 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), + ] + soc0 = 0.55 * battery.usable_capacity_wh + results, _ms = solve_dispatch( + slots, + battery, + hp, + grid, + [None, None], + vehicles, + soc0, + 50.0, + tuv_delta_stats=None, + operating_mode="AUTO", + ) + 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)", )