fix max grid kw

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] == (

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)",
         )