| # UnitCommitment.jl: Optimization Package for Security-Constrained Unit Commitment |
| # Copyright (C) 2020, UChicago Argonne, LLC. All rights reserved. |
| # Released under the modified BSD license. See COPYING.md for more details. |
|
|
| using Printf |
|
|
| bin(x) = [xi > 0.5 for xi in x] |
|
|
| function validate(instance_filename::String, solution_filename::String) |
| instance = UnitCommitment.read(instance_filename) |
| solution = JSON.parse(open(solution_filename)) |
| return validate(instance, solution) |
| end |
|
|
| """ |
| validate(instance, solution)::Bool |
|
|
| Verifies that the given solution is feasible for the problem. If feasible, |
| silently returns true. In infeasible, returns false and prints the validation |
| errors to the screen. |
|
|
| This function is implemented independently from the optimization model in |
| `model.jl`, and therefore can be used to verify that the model is indeed |
| producing valid solutions. It can also be used to verify the solutions produced |
| by other optimization packages. |
| """ |
| function validate( |
| instance::UnitCommitmentInstance, |
| solution::Union{Dict,OrderedDict}, |
| )::Bool |
| "Thermal production (MW)" ∈ keys(solution) ? |
| solution = Dict("s1" => solution) : nothing |
| err_count = 0 |
| err_count += _validate_units(instance, solution) |
| err_count += _validate_reserve_and_demand(instance, solution) |
|
|
| if err_count > 0 |
| @error "Found $err_count validation errors" |
| return false |
| end |
|
|
| return true |
| end |
|
|
| function _validate_units(instance::UnitCommitmentInstance, solution; tol = 0.01) |
| err_count = 0 |
| for sc in instance.scenarios |
| for unit in sc.thermal_units |
| production = solution[sc.name]["Thermal production (MW)"][unit.name] |
| reserve = [0.0 for _ in 1:instance.time] |
| spinning_reserves = |
| [r for r in unit.reserves if r.type == "spinning"] |
| if !isempty(spinning_reserves) |
| reserve += sum( |
| solution[sc.name]["Spinning reserve (MW)"][r.name][unit.name] |
| for r in spinning_reserves |
| ) |
| end |
| actual_production_cost = |
| solution[sc.name]["Thermal production cost (\$)"][unit.name] |
| actual_startup_cost = |
| solution[sc.name]["Startup cost (\$)"][unit.name] |
| is_on = bin(solution[sc.name]["Is on"][unit.name]) |
|
|
| for t in 1:instance.time |
| # Auxiliary variables |
| if t == 1 |
| is_starting_up = (unit.initial_status < 0) && is_on[t] |
| is_shutting_down = (unit.initial_status > 0) && !is_on[t] |
| ramp_up = |
| max(0, production[t] + reserve[t] - unit.initial_power) |
| ramp_down = max(0, unit.initial_power - production[t]) |
| else |
| is_starting_up = !is_on[t-1] && is_on[t] |
| is_shutting_down = is_on[t-1] && !is_on[t] |
| ramp_up = |
| max(0, production[t] + reserve[t] - production[t-1]) |
| ramp_down = max(0, production[t-1] - production[t]) |
| end |
|
|
| # Compute production costs |
| production_cost, startup_cost = 0, 0 |
| if is_on[t] |
| production_cost += unit.min_power_cost[t] |
| residual = max(0, production[t] - unit.min_power[t]) |
| for s in unit.cost_segments |
| cleared = min(residual, s.mw[t]) |
| production_cost += cleared * s.cost[t] |
| residual = max(0, residual - s.mw[t]) |
| end |
| end |
|
|
| # Production should be non-negative |
| if production[t] < -tol |
| @error @sprintf( |
| "Unit %s produces negative amount of power at time %d (%.2f)", |
| unit.name, |
| t, |
| production[t] |
| ) |
| err_count += 1 |
| end |
|
|
| # Verify must-run |
| if !is_on[t] && unit.must_run[t] |
| @error @sprintf( |
| "Must-run unit %s is offline at time %d", |
| unit.name, |
| t |
| ) |
| err_count += 1 |
| end |
|
|
| # Verify reserve eligibility |
| for r in sc.reserves |
| if r.type == "spinning" |
| if unit ∉ r.thermal_units && ( |
| unit in keys( |
| solution[sc.name]["Spinning reserve (MW)"][r.name], |
| ) |
| ) |
| @error @sprintf( |
| "Unit %s is not eligible to provide reserve %s", |
| unit.name, |
| r.name, |
| ) |
| err_count += 1 |
| end |
| end |
| end |
|
|
| # If unit is on, must produce at least its minimum power |
| if is_on[t] && (production[t] < unit.min_power[t] - tol) |
| @error @sprintf( |
| "Unit %s produces below its minimum limit at time %d (%.2f < %.2f)", |
| unit.name, |
| t, |
| production[t], |
| unit.min_power[t] |
| ) |
| err_count += 1 |
| end |
|
|
| # If unit is on, must produce at most its maximum power |
| if is_on[t] && |
| (production[t] + reserve[t] > unit.max_power[t] + tol) |
| @error @sprintf( |
| "Unit %s produces above its maximum limit at time %d (%.2f + %.2f> %.2f)", |
| unit.name, |
| t, |
| production[t], |
| reserve[t], |
| unit.max_power[t] |
| ) |
| err_count += 1 |
| end |
|
|
| # If unit is off, must produce zero |
| if !is_on[t] && production[t] + reserve[t] > tol |
| @error @sprintf( |
| "Unit %s produces power at time %d while off (%.2f + %.2f > 0)", |
| unit.name, |
| t, |
| production[t], |
| reserve[t], |
| ) |
| err_count += 1 |
| end |
|
|
| # Startup limit |
| if is_starting_up && (ramp_up > unit.startup_limit + tol) |
| @error @sprintf( |
| "Unit %s exceeds startup limit at time %d (%.2f > %.2f)", |
| unit.name, |
| t, |
| ramp_up, |
| unit.startup_limit |
| ) |
| err_count += 1 |
| end |
|
|
| # Shutdown limit |
| if is_shutting_down && (ramp_down > unit.shutdown_limit + tol) |
| @error @sprintf( |
| "Unit %s exceeds shutdown limit at time %d (%.2f > %.2f)", |
| unit.name, |
| t, |
| ramp_down, |
| unit.shutdown_limit |
| ) |
| err_count += 1 |
| end |
|
|
| # Ramp-up limit |
| if !is_starting_up && |
| !is_shutting_down && |
| (ramp_up > unit.ramp_up_limit + tol) |
| @error @sprintf( |
| "Unit %s exceeds ramp up limit at time %d (%.2f > %.2f)", |
| unit.name, |
| t, |
| ramp_up, |
| unit.ramp_up_limit |
| ) |
| err_count += 1 |
| end |
|
|
| # Ramp-down limit |
| if !is_starting_up && |
| !is_shutting_down && |
| (ramp_down > unit.ramp_down_limit + tol) |
| @error @sprintf( |
| "Unit %s exceeds ramp down limit at time %d (%.2f > %.2f)", |
| unit.name, |
| t, |
| ramp_down, |
| unit.ramp_down_limit |
| ) |
| err_count += 1 |
| end |
|
|
| # Verify startup costs & minimum downtime |
| if is_starting_up |
|
|
| # Calculate how much time the unit has been offline |
| time_down = 0 |
| for k in 1:(t-1) |
| if !is_on[t-k] |
| time_down += 1 |
| else |
| break |
| end |
| end |
| if (t == time_down + 1) && (unit.initial_status < 0) |
| time_down -= unit.initial_status |
| end |
|
|
| # Calculate startup costs |
| for c in unit.startup_categories |
| if time_down >= c.delay |
| startup_cost = c.cost |
| end |
| end |
|
|
| # Check minimum downtime |
| if time_down < unit.min_downtime |
| @error @sprintf( |
| "Unit %s violates minimum downtime at time %d", |
| unit.name, |
| t |
| ) |
| err_count += 1 |
| end |
| end |
|
|
| # Verify minimum uptime |
| if is_shutting_down |
|
|
| # Calculate how much time the unit has been online |
| time_up = 0 |
| for k in 1:(t-1) |
| if is_on[t-k] |
| time_up += 1 |
| else |
| break |
| end |
| end |
| if (t == time_up + 1) && (unit.initial_status > 0) |
| time_up += unit.initial_status |
| end |
|
|
| # Check minimum uptime |
| if time_up < unit.min_uptime |
| @error @sprintf( |
| "Unit %s violates minimum uptime at time %d", |
| unit.name, |
| t |
| ) |
| err_count += 1 |
| end |
| end |
|
|
| # Verify production costs |
| if abs(actual_production_cost[t] - production_cost) > 1.00 |
| @error @sprintf( |
| "Unit %s has unexpected production cost at time %d (%.2f should be %.2f)", |
| unit.name, |
| t, |
| actual_production_cost[t], |
| production_cost |
| ) |
| err_count += 1 |
| end |
|
|
| # Verify startup costs |
| if abs(actual_startup_cost[t] - startup_cost) > 1.00 |
| @error @sprintf( |
| "Unit %s has unexpected startup cost at time %d (%.2f should be %.2f)", |
| unit.name, |
| t, |
| actual_startup_cost[t], |
| startup_cost |
| ) |
| err_count += 1 |
| end |
| end |
| end |
| for pu in sc.profiled_units |
| production = solution[sc.name]["Profiled production (MW)"][pu.name] |
|
|
| for t in 1:instance.time |
| # Unit must produce at least its minimum power |
| if production[t] < pu.min_power[t] - tol |
| @error @sprintf( |
| "Profiled unit %s produces below its minimum limit at time %d (%.2f < %.2f)", |
| pu.name, |
| t, |
| production[t], |
| pu.min_power[t] |
| ) |
| err_count += 1 |
| end |
|
|
| # Unit must produce at most its maximum power |
| if production[t] > pu.max_power[t] + tol |
| @error @sprintf( |
| "Profiled unit %s produces above its maximum limit at time %d (%.2f > %.2f)", |
| pu.name, |
| t, |
| production[t], |
| pu.max_power[t] |
| ) |
| err_count += 1 |
| end |
| end |
| end |
| for su in sc.storage_units |
| storage_level = solution[sc.name]["Storage level (MWh)"][su.name] |
| charge_rate = |
| solution[sc.name]["Storage charging rates (MW)"][su.name] |
| discharge_rate = |
| solution[sc.name]["Storage discharging rates (MW)"][su.name] |
| actual_charge_cost = |
| solution[sc.name]["Storage charging cost (\$)"][su.name] |
| actual_discharge_cost = |
| solution[sc.name]["Storage discharging cost (\$)"][su.name] |
| is_charging = bin(solution[sc.name]["Is charging"][su.name]) |
| is_discharging = bin(solution[sc.name]["Is discharging"][su.name]) |
| # time in hours |
| time_step = sc.time_step / 60 |
|
|
| for t in 1:instance.time |
| # Unit must store at least its minimum level |
| if storage_level[t] < su.min_level[t] - tol |
| @error @sprintf( |
| "Storage unit %s stores below its minimum level at time %d (%.2f < %.2f)", |
| su.name, |
| t, |
| storage_level[t], |
| su.min_level[t] |
| ) |
| err_count += 1 |
| end |
| # Unit must store at most its maximum level |
| if storage_level[t] > su.max_level[t] + tol |
| @error @sprintf( |
| "Storage unit %s stores above its maximum level at time %d (%.2f > %.2f)", |
| su.name, |
| t, |
| storage_level[t], |
| su.max_level[t] |
| ) |
| err_count += 1 |
| end |
|
|
| if t == instance.time |
| # Unit must store at least its minimum level at last time period |
| if storage_level[t] < su.min_ending_level - tol |
| @error @sprintf( |
| "Storage unit %s stores below its minimum ending level (%.2f < %.2f)", |
| su.name, |
| storage_level[t], |
| su.min_ending_level |
| ) |
| err_count += 1 |
| end |
| # Unit must store at most its maximum level at last time period |
| if storage_level[t] > su.max_ending_level + tol |
| @error @sprintf( |
| "Storage unit %s stores above its maximum ending level (%.2f > %.2f)", |
| su.name, |
| storage_level[t], |
| su.max_ending_level |
| ) |
| err_count += 1 |
| end |
| end |
|
|
| # Unit must follow the energy transition constraint |
| prev_level = t == 1 ? su.initial_level : storage_level[t-1] |
| current_level = |
| (1 - su.loss_factor[t]) * prev_level + |
| time_step * ( |
| charge_rate[t] * su.charge_efficiency[t] - |
| discharge_rate[t] / su.discharge_efficiency[t] |
| ) |
| if abs(storage_level[t] - current_level) > tol |
| @error @sprintf( |
| "Storage unit %s has unexpected level at time %d (%.2f should be %.2f)", |
| unit.name, |
| t, |
| storage_level[t], |
| current_level |
| ) |
| err_count += 1 |
| end |
|
|
| # Unit cannot simultaneous charge and discharge if it is not allowed |
| if !su.simultaneous_charge_and_discharge[t] && |
| is_charging[t] && |
| is_discharging[t] |
| @error @sprintf( |
| "Storage unit %s is charging and discharging simultaneous at time %d", |
| su.name, |
| t |
| ) |
| err_count += 1 |
| end |
|
|
| # Unit must charge at least its minimum rate |
| if is_charging[t] && |
| (charge_rate[t] < su.min_charge_rate[t] - tol) |
| @error @sprintf( |
| "Storage unit %s charges below its minimum limit at time %d (%.2f < %.2f)", |
| unit.name, |
| t, |
| charge_rate[t], |
| su.min_charge_rate[t] |
| ) |
| err_count += 1 |
| end |
| # Unit must charge at most its maximum rate |
| if is_charging[t] && |
| (charge_rate[t] > su.max_charge_rate[t] + tol) |
| @error @sprintf( |
| "Storage unit %s charges above its maximum limit at time %d (%.2f > %.2f)", |
| unit.name, |
| t, |
| charge_rate[t], |
| su.max_charge_rate[t] |
| ) |
| err_count += 1 |
| end |
| # Unit must have zero charge when it is not charging |
| if !is_charging[t] && (charge_rate[t] > tol) |
| @error @sprintf( |
| "Storage unit %s charges power at time %d while not charging (%.2f > 0)", |
| unit.name, |
| t, |
| charge_rate[t] |
| ) |
| err_count += 1 |
| end |
|
|
| # Unit must discharge at least its minimum rate |
| if is_discharging[t] && |
| (discharge_rate[t] < su.min_discharge_rate[t] - tol) |
| @error @sprintf( |
| "Storage unit %s discharges below its minimum limit at time %d (%.2f < %.2f)", |
| unit.name, |
| t, |
| discharge_rate[t], |
| su.min_discharge_rate[t] |
| ) |
| err_count += 1 |
| end |
| # Unit must discharge at most its maximum rate |
| if is_discharging[t] && |
| (discharge_rate[t] > su.max_discharge_rate[t] + tol) |
| @error @sprintf( |
| "Storage unit %s discharges above its maximum limit at time %d (%.2f > %.2f)", |
| unit.name, |
| t, |
| discharge_rate[t], |
| su.max_discharge_rate[t] |
| ) |
| err_count += 1 |
| end |
| # Unit must have zero discharge when it is not charging |
| if !is_discharging[t] && (discharge_rate[t] > tol) |
| @error @sprintf( |
| "Storage unit %s discharges power at time %d while not discharging (%.2f > 0)", |
| unit.name, |
| t, |
| discharge_rate[t] |
| ) |
| err_count += 1 |
| end |
|
|
| # Compute storage costs |
| charge_cost = su.charge_cost[t] * charge_rate[t] |
| discharge_cost = su.discharge_cost[t] * discharge_rate[t] |
| # Compare costs |
| if abs(actual_charge_cost[t] - charge_cost) > tol |
| @error @sprintf( |
| "Storage unit %s has unexpected charge cost at time %d (%.2f should be %.2f)", |
| unit.name, |
| t, |
| actual_charge_cost[t], |
| charge_cost |
| ) |
| err_count += 1 |
| end |
| if abs(actual_discharge_cost[t] - discharge_cost) > tol |
| @error @sprintf( |
| "Storage unit %s has unexpected discharge cost at time %d (%.2f should be %.2f)", |
| unit.name, |
| t, |
| actual_discharge_cost[t], |
| discharge_cost |
| ) |
| err_count += 1 |
| end |
| end |
| end |
| end |
| return err_count |
| end |
|
|
| function _validate_reserve_and_demand(instance, solution, tol = 0.01) |
| err_count = 0 |
| for sc in instance.scenarios |
| for t in 1:instance.time |
| load_curtail = 0 |
| fixed_load = sum(b.load[t] for b in sc.buses) |
| ps_load = 0 |
| production = 0 |
| storage_charge = 0 |
| storage_discharge = 0 |
| if length(sc.price_sensitive_loads) > 0 |
| ps_load = sum( |
| solution[sc.name]["Price-sensitive loads (MW)"][ps.name][t] |
| for ps in sc.price_sensitive_loads |
| ) |
| end |
| if length(sc.thermal_units) > 0 |
| production = sum( |
| solution[sc.name]["Thermal production (MW)"][g.name][t] |
| for g in sc.thermal_units |
| ) |
| end |
| if length(sc.profiled_units) > 0 |
| production += sum( |
| solution[sc.name]["Profiled production (MW)"][pu.name][t] |
| for pu in sc.profiled_units |
| ) |
| end |
| if length(sc.storage_units) > 0 |
| storage_charge += sum( |
| solution[sc.name]["Storage charging rates (MW)"][su.name][t] |
| for su in sc.storage_units |
| ) |
| storage_discharge += sum( |
| solution[sc.name]["Storage discharging rates (MW)"][su.name][t] |
| for su in sc.storage_units |
| ) |
| end |
| if "Load curtail (MW)" in keys(solution) |
| load_curtail = sum( |
| solution[sc.name]["Load curtail (MW)"][b.name][t] for |
| b in sc.buses |
| ) |
| end |
| balance = |
| fixed_load - load_curtail - production + |
| ps_load + |
| storage_charge - storage_discharge |
|
|
| # Verify that production equals demand |
| if abs(balance) > tol |
| @error @sprintf( |
| "Non-zero power balance at time %d (%.2f + %.2f - %.2f - %.2f + %.2f - %.2f != 0)", |
| t, |
| fixed_load, |
| ps_load, |
| load_curtail, |
| production, |
| storage_charge, |
| storage_discharge, |
| ) |
| err_count += 1 |
| end |
|
|
| # Verify reserves |
| for r in sc.reserves |
| if r.type == "spinning" |
| provided = sum( |
| solution[sc.name]["Spinning reserve (MW)"][r.name][g.name][t] |
| for g in r.thermal_units |
| ) |
| shortfall = |
| solution[sc.name]["Spinning reserve shortfall (MW)"][r.name][t] |
| required = r.amount[t] |
|
|
| if provided + shortfall < required - tol |
| @error @sprintf( |
| "Insufficient reserve %s at time %d (%.2f + %.2f < %.2f)", |
| r.name, |
| t, |
| provided, |
| shortfall, |
| required, |
| ) |
| end |
| elseif r.type == "flexiramp" |
| upflexiramp = sum( |
| solution[sc.name]["Up-flexiramp (MW)"][r.name][g.name][t] |
| for g in r.thermal_units |
| ) |
| upflexiramp_shortfall = |
| solution[sc.name]["Up-flexiramp shortfall (MW)"][r.name][t] |
|
|
| if upflexiramp + upflexiramp_shortfall < r.amount[t] - tol |
| @error @sprintf( |
| "Insufficient up-flexiramp at time %d (%.2f + %.2f < %.2f)", |
| t, |
| upflexiramp, |
| upflexiramp_shortfall, |
| r.amount[t], |
| ) |
| err_count += 1 |
| end |
|
|
| dwflexiramp = sum( |
| solution[sc.name]["Down-flexiramp (MW)"][r.name][g.name][t] |
| for g in r.thermal_units |
| ) |
| dwflexiramp_shortfall = |
| solution[sc.name]["Down-flexiramp shortfall (MW)"][r.name][t] |
|
|
| if dwflexiramp + dwflexiramp_shortfall < r.amount[t] - tol |
| @error @sprintf( |
| "Insufficient down-flexiramp at time %d (%.2f + %.2f < %.2f)", |
| t, |
| dwflexiramp, |
| dwflexiramp_shortfall, |
| r.amount[t], |
| ) |
| err_count += 1 |
| end |
| else |
| error("Unknown reserve type: $(r.type)") |
| end |
| end |
| end |
| end |
|
|
| return err_count |
| end |
|
|
