parent
4e8426beba
commit
483c793d49
@ -0,0 +1,28 @@
|
||||
# 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.
|
||||
|
||||
function _add_bus!(model::JuMP.Model, b::Bus)::Nothing
|
||||
net_injection = _get(model, :expr_net_injection)
|
||||
reserve = _get(model, :expr_reserve)
|
||||
curtail = _get(model, :curtail)
|
||||
for t in 1:model[:instance].time
|
||||
# Fixed load
|
||||
net_injection[b.name, t] = AffExpr(-b.load[t])
|
||||
|
||||
# Reserves
|
||||
reserve[b.name, t] = AffExpr()
|
||||
|
||||
# Load curtailment
|
||||
curtail[b.name, t] =
|
||||
@variable(model, lower_bound = 0, upper_bound = b.load[t])
|
||||
|
||||
add_to_expression!(net_injection[b.name, t], curtail[b.name, t], 1.0)
|
||||
add_to_expression!(
|
||||
model[:obj],
|
||||
curtail[b.name, t],
|
||||
model[:instance].power_balance_penalty[t],
|
||||
)
|
||||
end
|
||||
return
|
||||
end
|
||||
@ -0,0 +1,12 @@
|
||||
# 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.
|
||||
|
||||
function _add_transmission_line!(model, lm)::Nothing
|
||||
overflow = _get(model, :overflow)
|
||||
for t in 1:model[:instance].time
|
||||
v = overflow[lm.name, t] = @variable(model, lower_bound = 0)
|
||||
add_to_expression!(model[:obj], v, lm.flow_limit_penalty[t])
|
||||
end
|
||||
return
|
||||
end
|
||||
@ -0,0 +1,27 @@
|
||||
# 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.
|
||||
|
||||
function _add_price_sensitive_load!(
|
||||
model::JuMP.Model,
|
||||
ps::PriceSensitiveLoad,
|
||||
)::Nothing
|
||||
loads = _get(model, :loads)
|
||||
net_injection = _get(model, :expr_net_injection)
|
||||
for t in 1:model[:instance].time
|
||||
# Decision variable
|
||||
loads[ps.name, t] =
|
||||
@variable(model, lower_bound = 0, upper_bound = ps.demand[t])
|
||||
|
||||
# Objective function terms
|
||||
add_to_expression!(model[:obj], loads[ps.name, t], -ps.revenue[t])
|
||||
|
||||
# Net injection
|
||||
add_to_expression!(
|
||||
net_injection[ps.bus.name, t],
|
||||
loads[ps.name, t],
|
||||
-1.0,
|
||||
)
|
||||
end
|
||||
return
|
||||
end
|
||||
@ -0,0 +1,41 @@
|
||||
# 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.
|
||||
|
||||
function _add_system_wide_eqs!(model::JuMP.Model)::Nothing
|
||||
_add_net_injection_eqs!(model)
|
||||
_add_reserve_eqs!(model)
|
||||
return
|
||||
end
|
||||
|
||||
function _add_net_injection_eqs!(model::JuMP.Model)::Nothing
|
||||
T = model[:instance].time
|
||||
net_injection = _get(model, :net_injection)
|
||||
eq_net_injection_def = _get(model, :eq_net_injection_def)
|
||||
eq_power_balance = _get(model, :eq_power_balance)
|
||||
for t in 1:T, b in model[:instance].buses
|
||||
n = net_injection[b.name, t] = @variable(model)
|
||||
eq_net_injection_def[t, b.name] =
|
||||
@constraint(model, n == model[:expr_net_injection][b.name, t])
|
||||
end
|
||||
for t in 1:T
|
||||
eq_power_balance[t] = @constraint(
|
||||
model,
|
||||
sum(net_injection[b.name, t] for b in model[:instance].buses) == 0
|
||||
)
|
||||
end
|
||||
return
|
||||
end
|
||||
|
||||
function _add_reserve_eqs!(model::JuMP.Model)::Nothing
|
||||
eq_min_reserve = _get(model, :eq_min_reserve)
|
||||
for t in 1:model[:instance].time
|
||||
eq_min_reserve[t] = @constraint(
|
||||
model,
|
||||
sum(
|
||||
model[:expr_reserve][b.name, t] for b in model[:instance].buses
|
||||
) >= model[:instance].reserves.spinning[t]
|
||||
)
|
||||
end
|
||||
return
|
||||
end
|
||||
@ -0,0 +1,349 @@
|
||||
# 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.
|
||||
|
||||
function _add_unit!(model::JuMP.Model, g::Unit)
|
||||
if !all(g.must_run) && any(g.must_run)
|
||||
error("Partially must-run units are not currently supported")
|
||||
end
|
||||
if g.initial_power === nothing || g.initial_status === nothing
|
||||
error("Initial conditions for $(g.name) must be provided")
|
||||
end
|
||||
|
||||
# Variables
|
||||
_add_production_vars!(model, g)
|
||||
_add_reserve_vars!(model, g)
|
||||
_add_startup_shutdown_vars!(model, g)
|
||||
_add_status_vars!(model, g)
|
||||
|
||||
# Constraints and objective function
|
||||
_add_min_uptime_downtime_eqs!(model, g)
|
||||
_add_net_injection_eqs!(model, g)
|
||||
_add_production_eqs!(model, g)
|
||||
_add_ramp_eqs!(model, g)
|
||||
_add_startup_shutdown_costs_eqs!(model, g)
|
||||
_add_startup_shutdown_limit_eqs!(model, g)
|
||||
return _add_status_eqs!(model, g)
|
||||
end
|
||||
|
||||
_is_initially_on(g::Unit)::Float64 = (g.initial_status > 0 ? 1.0 : 0.0)
|
||||
|
||||
function _add_production_vars!(model::JuMP.Model, g::Unit)::Nothing
|
||||
prod_above = _get(model, :prod_above)
|
||||
segprod = _get(model, :segprod)
|
||||
for t in 1:model[:instance].time
|
||||
for k in 1:length(g.cost_segments)
|
||||
segprod[g.name, t, k] = @variable(model, lower_bound = 0)
|
||||
end
|
||||
prod_above[g.name, t] = @variable(model, lower_bound = 0)
|
||||
end
|
||||
return
|
||||
end
|
||||
|
||||
function _add_production_eqs!(model::JuMP.Model, g::Unit)::Nothing
|
||||
eq_prod_above_def = _get(model, :eq_prod_above_def)
|
||||
eq_prod_limit = _get(model, :eq_prod_limit)
|
||||
eq_segprod_limit = _get(model, :eq_segprod_limit)
|
||||
is_on = model[:is_on]
|
||||
K = length(g.cost_segments)
|
||||
prod_above = model[:prod_above]
|
||||
reserve = model[:reserve]
|
||||
segprod = model[:segprod]
|
||||
for t in 1:model[:instance].time
|
||||
# Objective function terms for production costs
|
||||
add_to_expression!(model[:obj], is_on[g.name, t], g.min_power_cost[t])
|
||||
for k in 1:K
|
||||
add_to_expression!(
|
||||
model[:obj],
|
||||
segprod[g.name, t, k],
|
||||
g.cost_segments[k].cost[t],
|
||||
)
|
||||
end
|
||||
# Production limits (piecewise-linear segments)
|
||||
for k in 1:K
|
||||
eq_segprod_limit[g.name, t, k] = @constraint(
|
||||
model,
|
||||
segprod[g.name, t, k] <=
|
||||
g.cost_segments[k].mw[t] * is_on[g.name, t]
|
||||
)
|
||||
end
|
||||
# Definition of production
|
||||
eq_prod_above_def[g.name, t] = @constraint(
|
||||
model,
|
||||
prod_above[g.name, t] == sum(segprod[g.name, t, k] for k in 1:K)
|
||||
)
|
||||
# Production limit
|
||||
eq_prod_limit[g.name, t] = @constraint(
|
||||
model,
|
||||
prod_above[g.name, t] + reserve[g.name, t] <=
|
||||
(g.max_power[t] - g.min_power[t]) * is_on[g.name, t]
|
||||
)
|
||||
end
|
||||
return
|
||||
end
|
||||
|
||||
function _add_reserve_vars!(model::JuMP.Model, g::Unit)::Nothing
|
||||
reserve = _get(model, :reserve)
|
||||
for t in 1:model[:instance].time
|
||||
if g.provides_spinning_reserves[t]
|
||||
reserve[g.name, t] = @variable(model, lower_bound = 0)
|
||||
else
|
||||
reserve[g.name, t] = 0.0
|
||||
end
|
||||
end
|
||||
return
|
||||
end
|
||||
|
||||
function _add_reserve_eqs!(model::JuMP.Model, g::Unit)::Nothing
|
||||
reserve = model[:reserve]
|
||||
for t in 1:model[:instance].time
|
||||
add_to_expression!(expr_reserve[g.bus.name, t], reserve[g.name, t], 1.0)
|
||||
end
|
||||
return
|
||||
end
|
||||
|
||||
function _add_startup_shutdown_vars!(model::JuMP.Model, g::Unit)::Nothing
|
||||
startup = _get(model, :startup)
|
||||
for t in 1:model[:instance].time
|
||||
for s in 1:length(g.startup_categories)
|
||||
startup[g.name, t, s] = @variable(model, binary = true)
|
||||
end
|
||||
end
|
||||
return
|
||||
end
|
||||
|
||||
function _add_startup_shutdown_limit_eqs!(model::JuMP.Model, g::Unit)::Nothing
|
||||
eq_shutdown_limit = _get(model, :eq_shutdown_limit)
|
||||
eq_startup_limit = _get(model, :eq_startup_limit)
|
||||
is_on = model[:is_on]
|
||||
prod_above = model[:prod_above]
|
||||
reserve = model[:reserve]
|
||||
switch_off = model[:switch_off]
|
||||
switch_on = model[:switch_on]
|
||||
T = model[:instance].time
|
||||
for t in 1:T
|
||||
# Startup limit
|
||||
eq_startup_limit[g.name, t] = @constraint(
|
||||
model,
|
||||
prod_above[g.name, t] + reserve[g.name, t] <=
|
||||
(g.max_power[t] - g.min_power[t]) * is_on[g.name, t] -
|
||||
max(0, g.max_power[t] - g.startup_limit) * switch_on[g.name, t]
|
||||
)
|
||||
# Shutdown limit
|
||||
if g.initial_power > g.shutdown_limit
|
||||
eq_shutdown_limit[g.name, 0] =
|
||||
@constraint(model, switch_off[g.name, 1] <= 0)
|
||||
end
|
||||
if t < T
|
||||
eq_shutdown_limit[g.name, t] = @constraint(
|
||||
model,
|
||||
prod_above[g.name, t] <=
|
||||
(g.max_power[t] - g.min_power[t]) * is_on[g.name, t] -
|
||||
max(0, g.max_power[t] - g.shutdown_limit) *
|
||||
switch_off[g.name, t+1]
|
||||
)
|
||||
end
|
||||
end
|
||||
return
|
||||
end
|
||||
|
||||
function _add_startup_shutdown_costs_eqs!(model::JuMP.Model, g::Unit)::Nothing
|
||||
eq_startup_choose = _get(model, :eq_startup_choose)
|
||||
eq_startup_restrict = _get(model, :eq_startup_restrict)
|
||||
S = length(g.startup_categories)
|
||||
startup = model[:startup]
|
||||
for t in 1:model[:instance].time
|
||||
for s in 1:S
|
||||
# If unit is switching on, we must choose a startup category
|
||||
eq_startup_choose[g.name, t, s] = @constraint(
|
||||
model,
|
||||
model[:switch_on][g.name, t] ==
|
||||
sum(startup[g.name, t, s] for s in 1:S)
|
||||
)
|
||||
|
||||
# If unit has not switched off in the last `delay` time periods, startup category is forbidden.
|
||||
# The last startup category is always allowed.
|
||||
if s < S
|
||||
range_start = t - g.startup_categories[s+1].delay + 1
|
||||
range_end = t - g.startup_categories[s].delay
|
||||
range = (range_start:range_end)
|
||||
initial_sum = (
|
||||
g.initial_status < 0 && (g.initial_status + 1 in range) ? 1.0 : 0.0
|
||||
)
|
||||
eq_startup_restrict[g.name, t, s] = @constraint(
|
||||
model,
|
||||
startup[g.name, t, s] <=
|
||||
initial_sum + sum(
|
||||
model[:switch_off][g.name, i] for i in range if i >= 1
|
||||
)
|
||||
)
|
||||
end
|
||||
|
||||
# Objective function terms for start-up costs
|
||||
add_to_expression!(
|
||||
model[:obj],
|
||||
startup[g.name, t, s],
|
||||
g.startup_categories[s].cost,
|
||||
)
|
||||
end
|
||||
end
|
||||
return
|
||||
end
|
||||
|
||||
function _add_status_vars!(model::JuMP.Model, g::Unit)::Nothing
|
||||
is_on = _get(model, :is_on)
|
||||
switch_on = _get(model, :switch_on)
|
||||
switch_off = _get(model, :switch_off)
|
||||
for t in 1:model[:instance].time
|
||||
if g.must_run[t]
|
||||
is_on[g.name, t] = 1.0
|
||||
switch_on[g.name, t] = (t == 1 ? 1.0 - _is_initially_on(g) : 0.0)
|
||||
switch_off[g.name, t] = 0.0
|
||||
else
|
||||
is_on[g.name, t] = @variable(model, binary = true)
|
||||
switch_on[g.name, t] = @variable(model, binary = true)
|
||||
switch_off[g.name, t] = @variable(model, binary = true)
|
||||
end
|
||||
end
|
||||
return
|
||||
end
|
||||
|
||||
function _add_status_eqs!(model::JuMP.Model, g::Unit)::Nothing
|
||||
eq_binary_link = _get(model, :eq_binary_link)
|
||||
eq_switch_on_off = _get(model, :eq_switch_on_off)
|
||||
is_on = model[:is_on]
|
||||
switch_off = model[:switch_off]
|
||||
switch_on = model[:switch_on]
|
||||
for t in 1:model[:instance].time
|
||||
if !g.must_run[t]
|
||||
# Link binary variables
|
||||
if t == 1
|
||||
eq_binary_link[g.name, t] = @constraint(
|
||||
model,
|
||||
is_on[g.name, t] - _is_initially_on(g) ==
|
||||
switch_on[g.name, t] - switch_off[g.name, t]
|
||||
)
|
||||
else
|
||||
eq_binary_link[g.name, t] = @constraint(
|
||||
model,
|
||||
is_on[g.name, t] - is_on[g.name, t-1] ==
|
||||
switch_on[g.name, t] - switch_off[g.name, t]
|
||||
)
|
||||
end
|
||||
# Cannot switch on and off at the same time
|
||||
eq_switch_on_off[g.name, t] = @constraint(
|
||||
model,
|
||||
switch_on[g.name, t] + switch_off[g.name, t] <= 1
|
||||
)
|
||||
end
|
||||
end
|
||||
return
|
||||
end
|
||||
|
||||
function _add_ramp_eqs!(model::JuMP.Model, g::Unit)::Nothing
|
||||
prod_above = model[:prod_above]
|
||||
reserve = model[:reserve]
|
||||
eq_ramp_up = _get(model, :eq_ramp_up)
|
||||
eq_ramp_down = _get(model, :eq_ramp_down)
|
||||
for t in 1:model[:instance].time
|
||||
# Ramp up limit
|
||||
if t == 1
|
||||
if _is_initially_on(g) == 1
|
||||
eq_ramp_up[g.name, t] = @constraint(
|
||||
model,
|
||||
prod_above[g.name, t] + reserve[g.name, t] <=
|
||||
(g.initial_power - g.min_power[t]) + g.ramp_up_limit
|
||||
)
|
||||
end
|
||||
else
|
||||
eq_ramp_up[g.name, t] = @constraint(
|
||||
model,
|
||||
prod_above[g.name, t] + reserve[g.name, t] <=
|
||||
prod_above[g.name, t-1] + g.ramp_up_limit
|
||||
)
|
||||
end
|
||||
|
||||
# Ramp down limit
|
||||
if t == 1
|
||||
if _is_initially_on(g) == 1
|
||||
eq_ramp_down[g.name, t] = @constraint(
|
||||
model,
|
||||
prod_above[g.name, t] >=
|
||||
(g.initial_power - g.min_power[t]) - g.ramp_down_limit
|
||||
)
|
||||
end
|
||||
else
|
||||
eq_ramp_down[g.name, t] = @constraint(
|
||||
model,
|
||||
prod_above[g.name, t] >=
|
||||
prod_above[g.name, t-1] - g.ramp_down_limit
|
||||
)
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function _add_min_uptime_downtime_eqs!(model::JuMP.Model, g::Unit)::Nothing
|
||||
is_on = model[:is_on]
|
||||
switch_off = model[:switch_off]
|
||||
switch_on = model[:switch_on]
|
||||
eq_min_uptime = _get(model, :eq_min_uptime)
|
||||
eq_min_downtime = _get(model, :eq_min_downtime)
|
||||
T = model[:instance].time
|
||||
for t in 1:T
|
||||
# Minimum up-time
|
||||
eq_min_uptime[g.name, t] = @constraint(
|
||||
model,
|
||||
sum(switch_on[g.name, i] for i in (t-g.min_uptime+1):t if i >= 1) <= is_on[g.name, t]
|
||||
)
|
||||
# Minimum down-time
|
||||
eq_min_downtime[g.name, t] = @constraint(
|
||||
model,
|
||||
sum(
|
||||
switch_off[g.name, i] for i in (t-g.min_downtime+1):t if i >= 1
|
||||
) <= 1 - is_on[g.name, t]
|
||||
)
|
||||
# Minimum up/down-time for initial periods
|
||||
if t == 1
|
||||
if g.initial_status > 0
|
||||
eq_min_uptime[g.name, 0] = @constraint(
|
||||
model,
|
||||
sum(
|
||||
switch_off[g.name, i] for
|
||||
i in 1:(g.min_uptime-g.initial_status) if i <= T
|
||||
) == 0
|
||||
)
|
||||
else
|
||||
eq_min_downtime[g.name, 0] = @constraint(
|
||||
model,
|
||||
sum(
|
||||
switch_on[g.name, i] for
|
||||
i in 1:(g.min_downtime+g.initial_status) if i <= T
|
||||
) == 0
|
||||
)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
function _add_net_injection_eqs!(model::JuMP.Model, g::Unit)::Nothing
|
||||
expr_net_injection = model[:expr_net_injection]
|
||||
expr_reserve = model[:expr_reserve]
|
||||
is_on = model[:is_on]
|
||||
prod_above = model[:prod_above]
|
||||
reserve = model[:reserve]
|
||||
for t in 1:model[:instance].time
|
||||
# Add to net injection expression
|
||||
add_to_expression!(
|
||||
expr_net_injection[g.bus.name, t],
|
||||
prod_above[g.name, t],
|
||||
1.0,
|
||||
)
|
||||
add_to_expression!(
|
||||
expr_net_injection[g.bus.name, t],
|
||||
is_on[g.name, t],
|
||||
g.min_power[t],
|
||||
)
|
||||
# Add to reserves expression
|
||||
add_to_expression!(expr_reserve[g.bus.name, t], reserve[g.name, t], 1.0)
|
||||
end
|
||||
end
|
||||
@ -1,3 +1,5 @@
|
||||
# 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.
|
||||
|
||||
abstract type Formulation end
|
||||
Loading…
Reference in new issue