import json import math import os import numpy as np import pytest from scipy.optimize import Bounds, LinearConstraint, milp from scipy.sparse import coo_matrix OUTPUT_FILE = "/root/report.json" CASE_FILE = "/root/network.json" TOL_POWER_BALANCE_MW = 1e-2 TOL_RESERVE_MW = 1e-2 TOL_GENERATOR_MW = 1e-3 TOL_RAMP_MW = 1e-3 TOL_BINARY = 1e-5 TOL_COST_REL = 1e-4 TOL_COST_ABS = 1e-2 TOL_OPTIMALITY_GAP_REL = 0.10 ACCEPTED_STATUSES = { "optimal", "feasible", "time_limit_feasible", "suboptimal_feasible", "heuristic_feasible", } REQUIRED_CONSTRAINT_CHECKS = { "demand_balance", "spinning_reserve", "reserve_deliverability", "generator_limits", "must_run", "ramping", "minimum_up_down", "startup_shutdown_logic", "initial_conditions", "renewable_limits", "cost_consistency", } def _load_json(path: str) -> dict: with open(path, "r", encoding="utf-8") as f: data = json.load(f) assert isinstance(data, dict), f"{path} must contain a JSON object" return data def _require_keys(obj: dict, keys: set[str], label: str) -> None: missing = keys - set(obj) assert not missing, f"{label} missing keys: {sorted(missing)}" def _numeric_array(values, length: int, label: str) -> np.ndarray: arr = np.asarray(values, dtype=float) assert arr.shape == (length,), f"{label} must have length {length}, got shape {arr.shape}" assert np.all(np.isfinite(arr)), f"{label} contains non-finite values" return arr def _parse_pglib_uc_case(case: dict) -> dict: _require_keys(case, {"time_periods", "demand", "reserves", "thermal_generators", "renewable_generators"}, "case") time_periods = int(case["time_periods"]) assert time_periods > 0, "time_periods must be positive" demand = _numeric_array(case["demand"], time_periods, "case demand") reserves = _numeric_array(case["reserves"], time_periods, "case reserves") assert np.all(demand >= 0), "case demand contains negative values" assert np.all(reserves >= 0), "case reserves contains negative values" thermal_items = list(case["thermal_generators"].items()) renewable_items = list(case["renewable_generators"].items()) assert thermal_items, "case must contain thermal generators" thermal = [] thermal_names = [] for key, gen in thermal_items: _require_keys( gen, { "power_output_minimum", "power_output_maximum", "ramp_up_limit", "ramp_down_limit", "ramp_startup_limit", "ramp_shutdown_limit", "time_up_minimum", "time_down_minimum", "power_output_t0", "unit_on_t0", "time_down_t0", "time_up_t0", "startup", "piecewise_production", }, f"thermal generator {key}", ) name = str(gen.get("name", key)) thermal_names.append(name) pmin = float(gen["power_output_minimum"]) pmax = float(gen["power_output_maximum"]) assert pmax >= pmin >= 0, f"{name} has invalid output range" curve = sorted( [(float(point["mw"]), float(point["cost"])) for point in gen["piecewise_production"]], key=lambda x: x[0], ) assert len(curve) >= 2, f"{name} must have at least two piecewise cost points" assert abs(curve[0][0] - pmin) <= TOL_GENERATOR_MW, ( f"{name} first piecewise MW {curve[0][0]} does not match Pmin {pmin}" ) assert abs(curve[-1][0] - pmax) <= TOL_GENERATOR_MW, ( f"{name} last piecewise MW {curve[-1][0]} does not match Pmax {pmax}" ) assert all(curve[i + 1][0] > curve[i][0] for i in range(len(curve) - 1)), ( f"{name} piecewise MW points must be strictly increasing" ) startups = sorted( [(int(item["lag"]), float(item["cost"])) for item in gen["startup"]], key=lambda x: x[0], ) assert startups, f"{name} must have at least one startup tier" assert all(lag > 0 for lag, _ in startups), f"{name} startup lags must be positive" thermal.append( { "name": name, "pmin": pmin, "pmax": pmax, "cap": pmax - pmin, "ru": float(gen["ramp_up_limit"]), "rd": float(gen["ramp_down_limit"]), "su": float(gen["ramp_startup_limit"]), "sd": float(gen["ramp_shutdown_limit"]), "min_up": int(gen["time_up_minimum"]), "min_down": int(gen["time_down_minimum"]), "p0": float(gen["power_output_t0"]), "u0": int(round(float(gen["unit_on_t0"]))), "time_down_t0": int(gen["time_down_t0"]), "time_up_t0": int(gen["time_up_t0"]), "must_run": int(gen.get("must_run", 0)), "startup": startups, "piecewise": curve, } ) assert len(set(thermal_names)) == len(thermal_names), "thermal generator names are not unique" renewable = [] renewable_names = [] for key, gen in renewable_items: _require_keys(gen, {"power_output_minimum", "power_output_maximum"}, f"renewable generator {key}") name = str(gen.get("name", key)) renewable_names.append(name) pmin = _numeric_array(gen["power_output_minimum"], time_periods, f"{name} renewable minimum") pmax = _numeric_array(gen["power_output_maximum"], time_periods, f"{name} renewable maximum") assert np.all(pmax + TOL_GENERATOR_MW >= pmin), f"{name} renewable max below min" renewable.append({"name": name, "pmin": pmin, "pmax": pmax}) assert len(set(renewable_names)) == len(renewable_names), "renewable generator names are not unique" return { "T": time_periods, "demand": demand, "reserves": reserves, "thermal": thermal, "renewable": renewable, "thermal_names": thermal_names, "renewable_names": renewable_names, } def _as_binary_array(values, length: int, label: str) -> np.ndarray: arr = _numeric_array(values, length, label) rounded = np.rint(arr).astype(int) assert np.all(np.abs(arr - rounded) <= TOL_BINARY), f"{label} must be binary within tolerance" assert np.all((rounded == 0) | (rounded == 1)), f"{label} contains values other than 0/1" return rounded def _extract_report_arrays(report: dict, parsed_case: dict) -> dict: T = parsed_case["T"] _require_keys( report, {"case_name", "summary", "thermal_generators", "renewable_generators", "hourly_summary", "constraint_check"}, "report", ) assert isinstance(report["summary"], dict), "summary must be an object" assert isinstance(report["thermal_generators"], list), "thermal_generators must be a list" assert isinstance(report["renewable_generators"], list), "renewable_generators must be a list" assert isinstance(report["hourly_summary"], list), "hourly_summary must be a list" assert isinstance(report["constraint_check"], dict), "constraint_check must be an object" thermal_entries = {} for entry in report["thermal_generators"]: assert isinstance(entry, dict), "each thermal_generators entry must be an object" name = entry.get("name") assert isinstance(name, str), "thermal generator entry missing string name" assert name not in thermal_entries, f"duplicate thermal generator {name}" thermal_entries[name] = entry assert set(thermal_entries) == set(parsed_case["thermal_names"]), ( "thermal generator names do not match case data" ) renewable_entries = {} for entry in report["renewable_generators"]: assert isinstance(entry, dict), "each renewable_generators entry must be an object" name = entry.get("name") assert isinstance(name, str), "renewable generator entry missing string name" assert name not in renewable_entries, f"duplicate renewable generator {name}" renewable_entries[name] = entry assert set(renewable_entries) == set(parsed_case["renewable_names"]), ( "renewable generator names do not match case data" ) G = len(parsed_case["thermal"]) R = len(parsed_case["renewable"]) commitment = np.zeros((G, T), dtype=int) startup = np.zeros((G, T), dtype=int) shutdown = np.zeros((G, T), dtype=int) production = np.zeros((G, T), dtype=float) reserve = np.zeros((G, T), dtype=float) for g, gen in enumerate(parsed_case["thermal"]): entry = thermal_entries[gen["name"]] _require_keys(entry, {"commitment", "production_MW", "reserve_MW", "startup", "shutdown"}, gen["name"]) commitment[g] = _as_binary_array(entry["commitment"], T, f"{gen['name']} commitment") startup[g] = _as_binary_array(entry["startup"], T, f"{gen['name']} startup") shutdown[g] = _as_binary_array(entry["shutdown"], T, f"{gen['name']} shutdown") production[g] = _numeric_array(entry["production_MW"], T, f"{gen['name']} production_MW") reserve[g] = _numeric_array(entry["reserve_MW"], T, f"{gen['name']} reserve_MW") renewable_production = np.zeros((R, T), dtype=float) for r, gen in enumerate(parsed_case["renewable"]): entry = renewable_entries[gen["name"]] _require_keys(entry, {"production_MW"}, gen["name"]) renewable_production[r] = _numeric_array(entry["production_MW"], T, f"{gen['name']} production_MW") assert len(report["hourly_summary"]) == T, f"hourly_summary must have {T} records" for t, row in enumerate(report["hourly_summary"]): assert isinstance(row, dict), f"hourly_summary[{t}] must be an object" _require_keys( row, { "hour", "demand_MW", "thermal_generation_MW", "renewable_generation_MW", "reserve_requirement_MW", "scheduled_spinning_reserve_MW", }, f"hourly_summary[{t}]", ) assert int(row["hour"]) == t + 1, f"hourly_summary[{t}] hour must be {t + 1}" return { "commitment": commitment, "startup": startup, "shutdown": shutdown, "thermal_production": production, "thermal_reserve": reserve, "renewable_production": renewable_production, } def _recompute_transition_indicators(arrays: dict, parsed_case: dict) -> tuple[np.ndarray, np.ndarray]: u = arrays["commitment"] G, T = u.shape expected_startup = np.zeros_like(u) expected_shutdown = np.zeros_like(u) for g, gen in enumerate(parsed_case["thermal"]): prev = gen["u0"] for t in range(T): expected_startup[g, t] = max(u[g, t] - prev, 0) expected_shutdown[g, t] = max(prev - u[g, t], 0) prev = u[g, t] return expected_startup, expected_shutdown def _recompute_hourly_summary(arrays: dict, parsed_case: dict) -> dict: thermal_generation = arrays["thermal_production"].sum(axis=0) renewable_generation = arrays["renewable_production"].sum(axis=0) scheduled_reserve = arrays["thermal_reserve"].sum(axis=0) demand_balance_violation = np.abs(thermal_generation + renewable_generation - parsed_case["demand"]) reserve_shortfall = np.maximum(parsed_case["reserves"] - scheduled_reserve, 0.0) return { "thermal_generation_MW": thermal_generation, "renewable_generation_MW": renewable_generation, "scheduled_spinning_reserve_MW": scheduled_reserve, "max_demand_balance_violation_MW": float(np.max(demand_balance_violation)), "max_reserve_shortfall_MW": float(np.max(reserve_shortfall)), } def _startup_cost_for_duration(generator: dict, offline_duration: int) -> float: chosen_cost = generator["startup"][0][1] for lag, cost in generator["startup"]: if lag <= offline_duration: chosen_cost = cost else: break return chosen_cost def _piecewise_total_cost_at_output(generator: dict, production_mw: float) -> float: curve = generator["piecewise"] assert production_mw >= curve[0][0] - TOL_GENERATOR_MW, ( f"{generator['name']} production below first cost point" ) assert production_mw <= curve[-1][0] + TOL_GENERATOR_MW, ( f"{generator['name']} production above last cost point" ) if production_mw <= curve[0][0]: return curve[0][1] for (mw0, cost0), (mw1, cost1) in zip(curve, curve[1:]): if production_mw <= mw1 + TOL_GENERATOR_MW: if production_mw >= mw1: return cost1 slope = (cost1 - cost0) / (mw1 - mw0) return cost0 + slope * (production_mw - mw0) return curve[-1][1] def _recompute_total_cost(arrays: dict, parsed_case: dict) -> float: u = arrays["commitment"] v = arrays["startup"] production = arrays["thermal_production"] total_cost = 0.0 for g, gen in enumerate(parsed_case["thermal"]): offline_duration = gen["time_down_t0"] if gen["u0"] == 0 else 0 for t in range(parsed_case["T"]): if v[g, t] == 1: total_cost += _startup_cost_for_duration(gen, offline_duration) if u[g, t] == 1: total_cost += _piecewise_total_cost_at_output(gen, production[g, t]) offline_duration = 0 else: offline_duration += 1 return float(total_cost) def _solve_uc_benchmark_cost(case: dict) -> float: parsed = _parse_pglib_uc_case(case) T = parsed["T"] G = len(parsed["thermal"]) R = len(parsed["renewable"]) lb = [] ub = [] integrality = [] objective = [] def add_var(lower: float, upper: float, integer: bool, cost: float = 0.0) -> int: idx = len(lb) lb.append(float(lower)) ub.append(float(upper)) integrality.append(1 if integer else 0) objective.append(float(cost)) return idx u = np.empty((G, T), dtype=int) v = np.empty((G, T), dtype=int) w = np.empty((G, T), dtype=int) p = np.empty((G, T), dtype=int) r = np.empty((G, T), dtype=int) y: list[list[list[int]]] = [[[] for _ in range(T)] for _ in range(G)] q = np.empty((R, T), dtype=int) for g, gen in enumerate(parsed["thermal"]): first_cost = gen["piecewise"][0][1] force_online_until = 0 force_offline_until = 0 if gen["u0"] == 1 and gen["time_up_t0"] < gen["min_up"]: force_online_until = gen["min_up"] - gen["time_up_t0"] if gen["u0"] == 0 and gen["time_down_t0"] < gen["min_down"]: force_offline_until = gen["min_down"] - gen["time_down_t0"] for t in range(T): lower, upper = 0.0, 1.0 if gen["must_run"] == 1 or t < force_online_until: lower = upper = 1.0 if t < force_offline_until: lower = upper = 0.0 u[g, t] = add_var(lower, upper, True, first_cost) startup_cost = min(cost for _, cost in gen["startup"]) v[g, t] = add_var(0.0, 1.0, True, startup_cost) w[g, t] = add_var(0.0, 1.0, True, 0.0) p[g, t] = add_var(0.0, gen["cap"], False, 0.0) r[g, t] = add_var(0.0, gen["cap"], False, 0.0) for (mw0, cost0), (mw1, cost1) in zip(gen["piecewise"], gen["piecewise"][1:]): width = mw1 - mw0 slope = (cost1 - cost0) / width y[g][t].append(add_var(0.0, width, False, slope)) for i, gen in enumerate(parsed["renewable"]): for t in range(T): q[i, t] = add_var(gen["pmin"][t], gen["pmax"][t], False, 0.0) row_idx = [] col_idx = [] data = [] cons_lb = [] cons_ub = [] def add_constraint(entries: list[tuple[int, float]], lower: float, upper: float) -> None: row = len(cons_lb) for col, val in entries: if abs(val) > 0: row_idx.append(row) col_idx.append(col) data.append(float(val)) cons_lb.append(float(lower)) cons_ub.append(float(upper)) for g, gen in enumerate(parsed["thermal"]): cap = gen["cap"] startup_reduction = max(gen["pmax"] - gen["su"], 0.0) shutdown_reduction = max(gen["pmax"] - gen["sd"], 0.0) p0_above_min = gen["u0"] * (gen["p0"] - gen["pmin"]) for t in range(T): prev_u = gen["u0"] if t == 0 else u[g, t - 1] entries = [(u[g, t], 1.0), (v[g, t], -1.0), (w[g, t], 1.0)] rhs = float(prev_u) if t == 0 else 0.0 if t > 0: entries.append((u[g, t - 1], -1.0)) add_constraint(entries, rhs, rhs) add_constraint([(v[g, t], 1.0), (w[g, t], 1.0)], -math.inf, 1.0) add_constraint([(p[g, t], 1.0)] + [(seg, -1.0) for seg in y[g][t]], 0.0, 0.0) for seg_idx, seg in enumerate(y[g][t]): width = gen["piecewise"][seg_idx + 1][0] - gen["piecewise"][seg_idx][0] add_constraint([(seg, 1.0), (u[g, t], -width)], -math.inf, 0.0) add_constraint( [(p[g, t], 1.0), (r[g, t], 1.0), (u[g, t], -cap), (v[g, t], startup_reduction)], -math.inf, 0.0, ) if t < T - 1: add_constraint( [(p[g, t], 1.0), (r[g, t], 1.0), (u[g, t], -cap), (w[g, t + 1], shutdown_reduction)], -math.inf, 0.0, ) if t == 0: add_constraint([(p[g, t], 1.0), (r[g, t], 1.0)], -math.inf, gen["ru"] + p0_above_min) add_constraint([(p[g, t], -1.0)], -math.inf, gen["rd"] - p0_above_min) else: add_constraint( [(p[g, t], 1.0), (r[g, t], 1.0), (p[g, t - 1], -1.0)], -math.inf, gen["ru"], ) add_constraint([(p[g, t - 1], 1.0), (p[g, t], -1.0)], -math.inf, gen["rd"]) up_span = min(gen["min_up"], T - t) if up_span > 0: add_constraint([(u[g, k], -1.0) for k in range(t, t + up_span)] + [(v[g, t], up_span)], -math.inf, 0.0) down_span = min(gen["min_down"], T - t) if down_span > 0: add_constraint([(u[g, k], 1.0) for k in range(t, t + down_span)] + [(w[g, t], down_span)], -math.inf, down_span) for t in range(T): entries = [] for g, gen in enumerate(parsed["thermal"]): entries.append((p[g, t], 1.0)) entries.append((u[g, t], gen["pmin"])) for i in range(R): entries.append((q[i, t], 1.0)) add_constraint(entries, parsed["demand"][t], parsed["demand"][t]) add_constraint([(r[g, t], 1.0) for g in range(G)], parsed["reserves"][t], math.inf) matrix = coo_matrix((data, (row_idx, col_idx)), shape=(len(cons_lb), len(lb))).tocsr() result = milp( c=np.asarray(objective, dtype=float), integrality=np.asarray(integrality, dtype=int), bounds=Bounds(np.asarray(lb), np.asarray(ub)), constraints=LinearConstraint(matrix, np.asarray(cons_lb), np.asarray(cons_ub)), options={"time_limit": 240.0, "mip_rel_gap": 0.05, "disp": False}, ) assert result.x is not None, f"benchmark MILP did not return a feasible incumbent: {result.message}" x = result.x bench_arrays = { "commitment": np.rint(x[u]).astype(int), "startup": np.rint(x[v]).astype(int), "shutdown": np.rint(x[w]).astype(int), "thermal_production": x[p] + np.array([[gen["pmin"] for _ in range(T)] for gen in parsed["thermal"]]) * np.rint(x[u]), "thermal_reserve": np.maximum(x[r], 0.0), "renewable_production": x[q], } return _recompute_total_cost(bench_arrays, parsed) @pytest.fixture(scope="module") def report(): assert os.path.exists(OUTPUT_FILE), f"Output file {OUTPUT_FILE} does not exist" return _load_json(OUTPUT_FILE) @pytest.fixture(scope="module") def case_data(): return _load_json(CASE_FILE) @pytest.fixture(scope="module") def parsed_case(case_data): return _parse_pglib_uc_case(case_data) @pytest.fixture(scope="module") def arrays(report, parsed_case): return _extract_report_arrays(report, parsed_case) @pytest.fixture(scope="module") def recomputed_cost(arrays, parsed_case): return _recompute_total_cost(arrays, parsed_case) class TestSchema: def test_required_schema(self, report, parsed_case): summary = report["summary"] _require_keys( summary, { "solver_status", "objective_cost", "reported_mip_gap", "time_periods", "num_thermal_generators", "num_renewable_generators", "total_startups", "total_shutdowns", "max_demand_balance_violation_MW", "max_reserve_shortfall_MW", }, "summary", ) assert summary["solver_status"] in ACCEPTED_STATUSES, ( f"solver_status must be one of {sorted(ACCEPTED_STATUSES)}" ) gap = summary["reported_mip_gap"] if gap is not None: gap = float(gap) assert math.isfinite(gap) and gap >= 0.0, "reported_mip_gap must be null or finite nonnegative" assert int(summary["time_periods"]) == parsed_case["T"], "summary time_periods does not match case" assert int(summary["num_thermal_generators"]) == len(parsed_case["thermal"]), ( "summary num_thermal_generators does not match case" ) assert int(summary["num_renewable_generators"]) == len(parsed_case["renewable"]), ( "summary num_renewable_generators does not match case" ) _require_keys(report["constraint_check"], REQUIRED_CONSTRAINT_CHECKS, "constraint_check") for key in REQUIRED_CONSTRAINT_CHECKS: assert report["constraint_check"][key] == "pass", f"constraint_check.{key} must be 'pass'" def test_arrays_align_with_case(self, arrays, parsed_case): T = parsed_case["T"] assert arrays["commitment"].shape == (len(parsed_case["thermal"]), T) assert arrays["startup"].shape == (len(parsed_case["thermal"]), T) assert arrays["shutdown"].shape == (len(parsed_case["thermal"]), T) assert arrays["thermal_production"].shape == (len(parsed_case["thermal"]), T) assert arrays["thermal_reserve"].shape == (len(parsed_case["thermal"]), T) assert arrays["renewable_production"].shape == (len(parsed_case["renewable"]), T) class TestBinaryLogic: def test_startup_shutdown_match_commitment(self, arrays, parsed_case): expected_startup, expected_shutdown = _recompute_transition_indicators(arrays, parsed_case) np.testing.assert_array_equal(arrays["startup"], expected_startup) np.testing.assert_array_equal(arrays["shutdown"], expected_shutdown) def test_no_simultaneous_startup_shutdown(self, arrays): assert np.all(arrays["startup"] + arrays["shutdown"] <= 1), "unit starts and shuts down in same hour" def test_reported_transition_counts(self, report, arrays): summary = report["summary"] assert int(summary["total_startups"]) == int(arrays["startup"].sum()), "total_startups mismatch" assert int(summary["total_shutdowns"]) == int(arrays["shutdown"].sum()), "total_shutdowns mismatch" class TestThermalFeasibility: def test_must_run_units_online(self, arrays, parsed_case): for g, gen in enumerate(parsed_case["thermal"]): if gen["must_run"] == 1: assert np.all(arrays["commitment"][g] == 1), f"{gen['name']} is must-run but not always online" def test_output_limits_and_offline_zeroes(self, arrays, parsed_case): u = arrays["commitment"] production = arrays["thermal_production"] reserve = arrays["thermal_reserve"] for g, gen in enumerate(parsed_case["thermal"]): assert np.all(reserve[g] >= -TOL_GENERATOR_MW), f"{gen['name']} has negative reserve" offline = u[g] == 0 assert np.all(np.abs(production[g, offline]) <= TOL_GENERATOR_MW), ( f"{gen['name']} has production while offline" ) assert np.all(np.abs(reserve[g, offline]) <= TOL_GENERATOR_MW), ( f"{gen['name']} has reserve while offline" ) assert np.all(production[g] + TOL_GENERATOR_MW >= gen["pmin"] * u[g]), ( f"{gen['name']} below minimum output" ) assert np.all(production[g] <= gen["pmax"] * u[g] + TOL_GENERATOR_MW), ( f"{gen['name']} above maximum output" ) def test_deliverable_reserve_and_ramping(self, arrays, parsed_case): u = arrays["commitment"] v = arrays["startup"] w = arrays["shutdown"] production = arrays["thermal_production"] reserve = arrays["thermal_reserve"] T = parsed_case["T"] for g, gen in enumerate(parsed_case["thermal"]): p_above_min = production[g] - gen["pmin"] * u[g] p0 = gen["u0"] * (gen["p0"] - gen["pmin"]) cap = gen["cap"] startup_reduction = max(gen["pmax"] - gen["su"], 0.0) shutdown_reduction = max(gen["pmax"] - gen["sd"], 0.0) assert np.all(p_above_min >= -TOL_GENERATOR_MW), f"{gen['name']} production above-min is negative" for t in range(T): lhs = p_above_min[t] + reserve[g, t] cap_rhs = cap * u[g, t] - startup_reduction * v[g, t] assert lhs <= cap_rhs + TOL_GENERATOR_MW, f"{gen['name']} violates startup capacity at hour {t + 1}" if t < T - 1: shut_rhs = cap * u[g, t] - shutdown_reduction * w[g, t + 1] assert lhs <= shut_rhs + TOL_GENERATOR_MW, ( f"{gen['name']} violates pre-shutdown capacity at hour {t + 1}" ) previous = p0 if t == 0 else p_above_min[t - 1] assert lhs - previous <= gen["ru"] + TOL_RAMP_MW, ( f"{gen['name']} violates ramp-up reserve deliverability at hour {t + 1}" ) assert previous - p_above_min[t] <= gen["rd"] + TOL_RAMP_MW, ( f"{gen['name']} violates ramp-down limit at hour {t + 1}" ) class TestSystemFeasibility: def test_demand_and_reserve(self, arrays, parsed_case): thermal = arrays["thermal_production"].sum(axis=0) renewable = arrays["renewable_production"].sum(axis=0) reserve = arrays["thermal_reserve"].sum(axis=0) assert np.max(np.abs(thermal + renewable - parsed_case["demand"])) <= TOL_POWER_BALANCE_MW, ( "thermal plus renewable generation does not match demand" ) assert np.min(reserve - parsed_case["reserves"]) >= -TOL_RESERVE_MW, "spinning reserve shortfall" def test_renewable_limits(self, arrays, parsed_case): production = arrays["renewable_production"] for i, gen in enumerate(parsed_case["renewable"]): assert np.all(production[i] + TOL_GENERATOR_MW >= gen["pmin"]), ( f"{gen['name']} renewable production below minimum" ) assert np.all(production[i] <= gen["pmax"] + TOL_GENERATOR_MW), ( f"{gen['name']} renewable production above maximum" ) fixed = np.abs(gen["pmax"] - gen["pmin"]) <= TOL_GENERATOR_MW assert np.all(np.abs(production[i, fixed] - gen["pmin"][fixed]) <= TOL_GENERATOR_MW), ( f"{gen['name']} fixed renewable output not respected" ) def test_hourly_summary_matches_schedule(self, report, arrays, parsed_case): recomputed = _recompute_hourly_summary(arrays, parsed_case) for t, row in enumerate(report["hourly_summary"]): assert abs(float(row["demand_MW"]) - parsed_case["demand"][t]) <= TOL_POWER_BALANCE_MW assert abs(float(row["reserve_requirement_MW"]) - parsed_case["reserves"][t]) <= TOL_RESERVE_MW assert abs(float(row["thermal_generation_MW"]) - recomputed["thermal_generation_MW"][t]) <= TOL_POWER_BALANCE_MW assert abs(float(row["renewable_generation_MW"]) - recomputed["renewable_generation_MW"][t]) <= TOL_POWER_BALANCE_MW assert ( abs(float(row["scheduled_spinning_reserve_MW"]) - recomputed["scheduled_spinning_reserve_MW"][t]) <= TOL_RESERVE_MW ) summary = report["summary"] assert ( abs(float(summary["max_demand_balance_violation_MW"]) - recomputed["max_demand_balance_violation_MW"]) <= TOL_POWER_BALANCE_MW ) assert ( abs(float(summary["max_reserve_shortfall_MW"]) - recomputed["max_reserve_shortfall_MW"]) <= TOL_RESERVE_MW ) class TestMinimumUpDown: def test_initial_and_in_horizon_obligations(self, arrays, parsed_case): u = arrays["commitment"] v = arrays["startup"] w = arrays["shutdown"] T = parsed_case["T"] for g, gen in enumerate(parsed_case["thermal"]): if gen["u0"] == 1 and gen["time_up_t0"] < gen["min_up"]: remaining = min(T, gen["min_up"] - gen["time_up_t0"]) assert np.all(u[g, :remaining] == 1), f"{gen['name']} violates initial min-up obligation" if gen["u0"] == 0 and gen["time_down_t0"] < gen["min_down"]: remaining = min(T, gen["min_down"] - gen["time_down_t0"]) assert np.all(u[g, :remaining] == 0), f"{gen['name']} violates initial min-down obligation" for t in range(T): if v[g, t] == 1: end = min(T, t + gen["min_up"]) assert np.all(u[g, t:end] == 1), f"{gen['name']} violates min-up after hour {t + 1}" if w[g, t] == 1: end = min(T, t + gen["min_down"]) assert np.all(u[g, t:end] == 0), f"{gen['name']} violates min-down after hour {t + 1}" class TestCostAndQuality: def test_reported_cost_matches_schedule(self, report, recomputed_cost): reported_cost = float(report["summary"]["objective_cost"]) assert math.isfinite(reported_cost) and reported_cost > 0, "reported objective_cost must be positive finite" assert abs(reported_cost - recomputed_cost) <= max( TOL_COST_ABS, TOL_COST_REL * max(1.0, abs(recomputed_cost)), ), f"reported objective {reported_cost} does not match recomputed cost {recomputed_cost}" def test_cost_within_benchmark_gap(self, case_data, recomputed_cost): benchmark_cost = _solve_uc_benchmark_cost(case_data) assert recomputed_cost <= benchmark_cost * (1.0 + TOL_OPTIMALITY_GAP_REL) + TOL_COST_ABS, ( f"recomputed cost {recomputed_cost} exceeds benchmark {benchmark_cost} by more than " f"{TOL_OPTIMALITY_GAP_REL:.0%}" )