fix prodeje za malo z pole b

backend/services/planning_engine.py

@@ -619,6 +619,39 @@ def _slots_with_charge_acquisition(
     ]
 
 
+def _pv_store_value_czk_kwh(
+    slot: PlanningSlot,
+    charge_acquisition_czk_kwh: float,
+    min_spread: float,
+) -> float:
+    """
+    Minimální efektivní sell [Kč/kWh], pod kterým je FVE→síť horší než uložení
+    (večerní peak / náklad zásoby z levného nákupu).
+    """
+    future = float(
+        slot.future_sell_opportunity_czk_kwh
+        if slot.future_sell_opportunity_czk_kwh is not None
+        else slot.sell_price
+    )
+    return max(future, float(charge_acquisition_czk_kwh)) - min_spread
+
+
+def _pv_forced_vent_export_allowed(
+    t: int,
+    *,
+    current_soc_wh: float,
+    battery,
+    soc_headroom_wh: float,
+    pv_surplus_w: float,
+) -> bool:
+    """Přebytek FVE do sítě jen když baterie na konci předchozího slotu nemá kapacitu."""
+    if pv_surplus_w <= 0:
+        return False
+    if t == 0:
+        return current_soc_wh >= float(battery.soc_max_wh) - soc_headroom_wh
+    return False
+
+
 def solve_dispatch_two_pass(
     slots: list[PlanningSlot],
     battery,
@@ -880,6 +913,7 @@ def solve_dispatch(
         if charge_acq_raw is not None
         else min(float(s.buy_price) for s in slots)
     )
+    soc_headroom_wh = max(2000.0, 0.05 * float(battery.soc_max_wh))
 
     # Kotva: poslední slot před prvním sell<0 by měl končit u planner floor (pokud relaxace existuje).
     # Slack penalizujeme v objective; samotné omezení přidáme až po definici soc.
@@ -1109,9 +1143,31 @@ def solve_dispatch(
         if s.sell_price < 0:
             prob += w_arb[t] == 0
             prob += bd[t] <= pulp.lpSum(ev_via_bat[e][t] for e in range(EV))
-            # Tvrdý zákaz vývozu při záporné prodejní ceně, pokud:
-            # - site má GEN/MI cutoff model (binárky z_gen_cutoff — BA81), nebo
-            # - explicitně site_grid_connection.block_export_on_negative_sell (např. fixní nákup, bez pole B).
+            prob += ge_bat[t] == 0
+            ev_cap_neg = sum(
+                float(vehicles[e].max_charge_power_w)
+                for e in range(EV)
+                if (e == 0 and s.ev1_connected) or (e == 1 and s.ev2_connected)
+            )
+            load_neg = (
+                float(s.load_baseline_w)
+                + ev_cap_neg
+                + float(heat_pump.rated_heating_power_w)
+            )
+            pv_surplus_neg_w = max(
+                0.0,
+                float(s.pv_a_forecast_w) + float(s.pv_b_forecast_w) - load_neg,
+            )
+            # FVE→síť při záporném výkupu jen nucený vent (plná baterie); jinak bc_pv / load-first.
+            if not _pv_forced_vent_export_allowed(
+                t,
+                current_soc_wh=current_soc_wh,
+                battery=battery,
+                soc_headroom_wh=soc_headroom_wh,
+                pv_surplus_w=pv_surplus_neg_w,
+            ):
+                prob += ge_pv[t] == 0
+            # Tvrdý zákaz celého vývozu (GEN / fixní nákup bez pole B).
             block_neg_sell_export = bool(
                 getattr(grid, "block_export_on_negative_sell", False)
             )
@@ -1241,9 +1297,6 @@ def solve_dispatch(
         ref_buy_horizon = min(float(s.buy_price) for s in slots)
         min_spread = float(degradation_cost_effective)
         hp_rated_w = float(heat_pump.rated_heating_power_w)
-        soc_headroom_wh = max(
-            2000.0, 0.05 * float(battery.soc_max_wh)
-        )
         for t in range(T):
             s = slots[t]
             buy_t = float(s.buy_price)
@@ -1258,15 +1311,18 @@ def solve_dispatch(
                 0.0,
                 float(s.pv_a_forecast_w) + float(s.pv_b_forecast_w) - load_t,
             )
-            # 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 block_loss_pv_export:
-                    prob += ge_pv[t] == 0
+            # FVE export jen pokud sell ≥ hodnota uložení (večerní peak / acquisition − degradace).
+            pv_store_val = _pv_store_value_czk_kwh(
+                s, charge_acquisition_czk_kwh, min_spread
+            )
+            if sell_t < pv_store_val and not _pv_forced_vent_export_allowed(
+                t,
+                current_soc_wh=current_soc_wh,
+                battery=battery,
+                soc_headroom_wh=soc_headroom_wh,
+                pv_surplus_w=pv_surplus_w,
+            ):
+                prob += ge_pv[t] == 0
             # Drahý nákup oproti horizontu: import jen na load + EV + TČ, ne na grid-nabíjení.
             if buy_t >= 0 and buy_t > ref_buy_horizon + min_spread:
                 prob += gi[t] <= load_t + ev_cap_t + hp_rated_w

backend/tests/test_planning_dispatch_milp.py

@@ -1782,6 +1782,75 @@ class LoadFirstDispatchTests(unittest.TestCase):
         self.assertEqual(r.export_mode, "PV_SURPLUS")
 
 
+class Home01PvStoreValueTests(unittest.TestCase):
+    """FVE (zejména pole B) nesmí jít do sítě pod hodnotou uložení / večerní peak."""
+
+    def test_pv_b_low_sell_charges_not_exports(self) -> None:
+        """08:30 archetyp: sell ~0,09, večer ~5,5 → bc, ne ge_pv."""
+        slots = [
+            PlanningSlot(
+                interval_start=datetime(2026, 5, 22, 6, 30, tzinfo=timezone.utc),
+                buy_price=1.017,
+                sell_price=0.088,
+                pv_a_forecast_w=0,
+                pv_b_forecast_w=5313,
+                load_baseline_w=1961,
+                ev1_connected=False,
+                ev2_connected=False,
+                allow_charge=True,
+                allow_discharge_export=False,
+                charge_acquisition_buy_czk_kwh=0.526,
+                future_sell_opportunity_czk_kwh=5.5,
+            )
+        ]
+        battery = _battery(uc_wh=64_000.0, min_pct=12.0, arb_pct=20.0)
+        battery.max_charge_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.45 * battery.usable_capacity_wh
+        results, _, _ = solve_dispatch(
+            slots, battery, hp, grid, [None, None], vehicles, soc0, 50.0, operating_mode="AUTO"
+        )
+        r = results[0]
+        self.assertGreaterEqual(r.grid_setpoint_w, 0, "nízký sell: žádný export FVE")
+        self.assertGreater(r.battery_setpoint_w, 500, "přebytek PV do baterie")
+
+    def test_negative_sell_no_pv_export_when_battery_has_room(self) -> None:
+        slots = [
+            PlanningSlot(
+                interval_start=datetime(2026, 5, 22, 7, 45, tzinfo=timezone.utc),
+                buy_price=0.55,
+                sell_price=-0.266,
+                pv_a_forecast_w=0,
+                pv_b_forecast_w=5474,
+                load_baseline_w=1961,
+                ev1_connected=False,
+                ev2_connected=False,
+                allow_charge=True,
+                allow_discharge_export=False,
+                charge_acquisition_buy_czk_kwh=0.526,
+                future_sell_opportunity_czk_kwh=5.5,
+            )
+        ]
+        battery = _battery(uc_wh=64_000.0)
+        battery.max_charge_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.5 * battery.usable_capacity_wh
+        results, _, _ = solve_dispatch(
+            slots, battery, hp, grid, [None, None], vehicles, soc0, 50.0, operating_mode="AUTO"
+        )
+        self.assertGreaterEqual(results[0].grid_setpoint_w, 0)
+
+
 class SitePowerCapTests(unittest.TestCase):
     """Tvrdé limity site import a součtu nabíjení baterie."""