124 lines
4.8 KiB
Python
124 lines
4.8 KiB
Python
#!/usr/bin/env python3
|
|
"""Bisect Infeasible na reálných slotech home-01 (MCP run 16674). PYTHONPATH=backend."""
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import sys
|
|
from datetime import datetime, timezone
|
|
from pathlib import Path
|
|
from types import SimpleNamespace
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "backend"))
|
|
|
|
from services.planning_engine import PlanningSlot, solve_dispatch, solve_dispatch_two_pass, PLANNER_BUILD_TAG
|
|
|
|
# Export z MCP: planning_interval run_id=16674 + fn_planning_site_context(2)
|
|
SLOTS_JSON = Path(__file__).with_name("home01_run16706_slots.json")
|
|
if not SLOTS_JSON.exists():
|
|
SLOTS_JSON = Path(__file__).with_name("home01_run16674_slots.json")
|
|
SOC_WH = 37120.0
|
|
|
|
|
|
def _ctx() -> tuple[SimpleNamespace, SimpleNamespace, SimpleNamespace, list]:
|
|
battery = SimpleNamespace(
|
|
usable_capacity_wh=64000.0,
|
|
min_soc_wh=6400.0,
|
|
arb_floor_wh=12800.0,
|
|
reserve_soc_wh=12800.0,
|
|
soc_max_wh=64000.0,
|
|
charge_efficiency=0.95,
|
|
discharge_efficiency=0.95,
|
|
degradation_cost_czk_kwh=0.15,
|
|
max_charge_power_w=18000,
|
|
max_discharge_power_w=18000,
|
|
charge_slot_buffer=1.3,
|
|
discharge_slot_buffer=1.5,
|
|
planner_terminal_soc_value_factor=0.9,
|
|
planner_discharge_floor_percent=5.0,
|
|
planner_extreme_buy_threshold_czk_kwh=-2.0,
|
|
planner_daytime_charge_target_enabled=True,
|
|
planner_charge_commitment_penalty_czk_kwh=0.2,
|
|
planner_night_baseload_buffer_percent=20,
|
|
)
|
|
grid = SimpleNamespace(
|
|
max_import_power_w=17000,
|
|
max_export_power_w=13500,
|
|
block_export_on_negative_sell=False,
|
|
deye_gen_microinverter_cutoff_enabled=False,
|
|
)
|
|
hp = SimpleNamespace(rated_heating_power_w=0, tuv_min_temp_c=45.0, tuv_target_temp_c=55.0)
|
|
vehicles = [
|
|
SimpleNamespace(max_charge_power_w=11000, battery_capacity_kwh=75.0, default_target_soc_pct=80.0),
|
|
SimpleNamespace(max_charge_power_w=7400, battery_capacity_kwh=52.0, default_target_soc_pct=90.0),
|
|
]
|
|
return battery, hp, grid, vehicles
|
|
|
|
|
|
def load_slots(*, permissive_masks: bool) -> list[PlanningSlot]:
|
|
rows = json.loads(SLOTS_JSON.read_text())
|
|
out: list[PlanningSlot] = []
|
|
for r in rows:
|
|
ts = datetime.fromisoformat(r["interval_start"].replace("Z", "+00:00"))
|
|
pv_surplus = max(0, int(r["pv_a"]) + int(r["pv_b"]) - int(r["load"]))
|
|
out.append(
|
|
PlanningSlot(
|
|
interval_start=ts,
|
|
buy_price=float(r["buy"]),
|
|
sell_price=float(r["sell"]),
|
|
pv_a_forecast_w=int(r["pv_a"]),
|
|
pv_b_forecast_w=int(r["pv_b"]),
|
|
load_baseline_w=int(r["load"]),
|
|
ev1_connected=False,
|
|
ev2_connected=False,
|
|
allow_charge=True if permissive_masks else (float(r["buy"]) < 0 or (float(r["sell"]) < 0 and pv_surplus > 500)),
|
|
allow_discharge_export=permissive_masks,
|
|
)
|
|
)
|
|
return out
|
|
|
|
|
|
def try_solve(label: str, slots: list[PlanningSlot], **kwargs) -> str:
|
|
battery, hp, grid, vehicles = _ctx()
|
|
try:
|
|
if kwargs.pop("two_pass", False):
|
|
solve_dispatch_two_pass(
|
|
slots, battery, hp, grid, [None, None], vehicles, SOC_WH, 55.0,
|
|
operating_mode="AUTO", **kwargs,
|
|
)
|
|
else:
|
|
solve_dispatch(
|
|
slots, battery, hp, grid, [None, None], vehicles, SOC_WH, 55.0,
|
|
operating_mode="AUTO", **kwargs,
|
|
)
|
|
return f"OK {label}"
|
|
except Exception as e:
|
|
return f"FAIL {label}: {e}"
|
|
|
|
|
|
def main() -> None:
|
|
if not SLOTS_JSON.exists():
|
|
print(f"Chybí {SLOTS_JSON} — spusť export z MCP (run 16674).", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
print("tag", PLANNER_BUILD_TAG)
|
|
print("slots", len(json.loads(SLOTS_JSON.read_text())))
|
|
neg_buy = [r for r in json.loads(SLOTS_JSON.read_text()) if r["buy"] < 0]
|
|
print("neg_buy slots", len(neg_buy), "first", neg_buy[0]["interval_start"] if neg_buy else None)
|
|
|
|
cases = [
|
|
("permissive masks, 1-pass", dict(permissive_masks=True, two_pass=False)),
|
|
("permissive masks, 2-pass", dict(permissive_masks=True, two_pass=True)),
|
|
("realistic masks, 1-pass", dict(permissive_masks=False, two_pass=False)),
|
|
("realistic masks, 2-pass", dict(permissive_masks=False, two_pass=True)),
|
|
("realistic + relaxed_expensive", dict(permissive_masks=False, two_pass=False, relaxed_expensive_import=True)),
|
|
("realistic + both relaxed", dict(permissive_masks=False, two_pass=False, relaxed_expensive_import=True, relaxed_neg_buy_pressure=True)),
|
|
]
|
|
for label, kw in cases:
|
|
masks = kw.pop("permissive_masks")
|
|
slots = load_slots(permissive_masks=masks)
|
|
print(try_solve(label, slots, **kw))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|