parent
e594a68492
commit
4e8426beba
@ -0,0 +1,98 @@
|
|||||||
|
# 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.
|
||||||
|
|
||||||
|
mutable struct Bus
|
||||||
|
name::String
|
||||||
|
offset::Int
|
||||||
|
load::Vector{Float64}
|
||||||
|
units::Vector
|
||||||
|
price_sensitive_loads::Vector
|
||||||
|
end
|
||||||
|
|
||||||
|
mutable struct CostSegment
|
||||||
|
mw::Vector{Float64}
|
||||||
|
cost::Vector{Float64}
|
||||||
|
end
|
||||||
|
|
||||||
|
mutable struct StartupCategory
|
||||||
|
delay::Int
|
||||||
|
cost::Float64
|
||||||
|
end
|
||||||
|
|
||||||
|
mutable struct Unit
|
||||||
|
name::String
|
||||||
|
bus::Bus
|
||||||
|
max_power::Vector{Float64}
|
||||||
|
min_power::Vector{Float64}
|
||||||
|
must_run::Vector{Bool}
|
||||||
|
min_power_cost::Vector{Float64}
|
||||||
|
cost_segments::Vector{CostSegment}
|
||||||
|
min_uptime::Int
|
||||||
|
min_downtime::Int
|
||||||
|
ramp_up_limit::Float64
|
||||||
|
ramp_down_limit::Float64
|
||||||
|
startup_limit::Float64
|
||||||
|
shutdown_limit::Float64
|
||||||
|
initial_status::Union{Int,Nothing}
|
||||||
|
initial_power::Union{Float64,Nothing}
|
||||||
|
provides_spinning_reserves::Vector{Bool}
|
||||||
|
startup_categories::Vector{StartupCategory}
|
||||||
|
end
|
||||||
|
|
||||||
|
mutable struct TransmissionLine
|
||||||
|
name::String
|
||||||
|
offset::Int
|
||||||
|
source::Bus
|
||||||
|
target::Bus
|
||||||
|
reactance::Float64
|
||||||
|
susceptance::Float64
|
||||||
|
normal_flow_limit::Vector{Float64}
|
||||||
|
emergency_flow_limit::Vector{Float64}
|
||||||
|
flow_limit_penalty::Vector{Float64}
|
||||||
|
end
|
||||||
|
|
||||||
|
mutable struct Reserves
|
||||||
|
spinning::Vector{Float64}
|
||||||
|
end
|
||||||
|
|
||||||
|
mutable struct Contingency
|
||||||
|
name::String
|
||||||
|
lines::Vector{TransmissionLine}
|
||||||
|
units::Vector{Unit}
|
||||||
|
end
|
||||||
|
|
||||||
|
mutable struct PriceSensitiveLoad
|
||||||
|
name::String
|
||||||
|
bus::Bus
|
||||||
|
demand::Vector{Float64}
|
||||||
|
revenue::Vector{Float64}
|
||||||
|
end
|
||||||
|
|
||||||
|
mutable struct UnitCommitmentInstance
|
||||||
|
time::Int
|
||||||
|
power_balance_penalty::Vector{Float64}
|
||||||
|
units::Vector{Unit}
|
||||||
|
buses::Vector{Bus}
|
||||||
|
lines::Vector{TransmissionLine}
|
||||||
|
reserves::Reserves
|
||||||
|
contingencies::Vector{Contingency}
|
||||||
|
price_sensitive_loads::Vector{PriceSensitiveLoad}
|
||||||
|
end
|
||||||
|
|
||||||
|
function Base.show(io::IO, instance::UnitCommitmentInstance)
|
||||||
|
print(io, "UnitCommitmentInstance(")
|
||||||
|
print(io, "$(length(instance.units)) units, ")
|
||||||
|
print(io, "$(length(instance.buses)) buses, ")
|
||||||
|
print(io, "$(length(instance.lines)) lines, ")
|
||||||
|
print(io, "$(length(instance.contingencies)) contingencies, ")
|
||||||
|
print(
|
||||||
|
io,
|
||||||
|
"$(length(instance.price_sensitive_loads)) price sensitive loads, ",
|
||||||
|
)
|
||||||
|
print(io, "$(instance.time) time steps")
|
||||||
|
print(io, ")")
|
||||||
|
return
|
||||||
|
end
|
||||||
|
|
||||||
|
export UnitCommitmentInstance
|
||||||
@ -0,0 +1,20 @@
|
|||||||
|
# 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.
|
||||||
|
|
||||||
|
# This file extends some JuMP functions so that decision variables can be safely
|
||||||
|
# replaced by (constant) floating point numbers.
|
||||||
|
|
||||||
|
import JuMP: value, fix, set_name
|
||||||
|
|
||||||
|
function value(x::Float64)
|
||||||
|
return x
|
||||||
|
end
|
||||||
|
|
||||||
|
function fix(x::Float64, v::Float64; force)
|
||||||
|
return abs(x - v) < 1e-6 || error("Value mismatch: $x != $v")
|
||||||
|
end
|
||||||
|
|
||||||
|
function set_name(x::Float64, n::String)
|
||||||
|
# nop
|
||||||
|
end
|
||||||
@ -0,0 +1,33 @@
|
|||||||
|
# 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.
|
||||||
|
|
||||||
|
"""
|
||||||
|
fix!(model::JuMP.Model, solution::AbstractDict)::Nothing
|
||||||
|
|
||||||
|
Fix the value of all binary variables to the ones specified by the given
|
||||||
|
solution. Useful for computing LMPs.
|
||||||
|
"""
|
||||||
|
function fix!(model::JuMP.Model, solution::AbstractDict)::Nothing
|
||||||
|
instance, T = model[:instance], model[:instance].time
|
||||||
|
is_on = model[:is_on]
|
||||||
|
prod_above = model[:prod_above]
|
||||||
|
reserve = model[:reserve]
|
||||||
|
for g in instance.units
|
||||||
|
for t in 1:T
|
||||||
|
is_on_value = round(solution["Is on"][g.name][t])
|
||||||
|
production_value =
|
||||||
|
round(solution["Production (MW)"][g.name][t], digits = 5)
|
||||||
|
reserve_value =
|
||||||
|
round(solution["Reserve (MW)"][g.name][t], digits = 5)
|
||||||
|
JuMP.fix(is_on[g.name, t], is_on_value, force = true)
|
||||||
|
JuMP.fix(
|
||||||
|
prod_above[g.name, t],
|
||||||
|
production_value - is_on_value * g.min_power[t],
|
||||||
|
force = true,
|
||||||
|
)
|
||||||
|
JuMP.fix(reserve[g.name, t], reserve_value, force = true)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
return
|
||||||
|
end
|
||||||
@ -0,0 +1,83 @@
|
|||||||
|
# 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 _enforce_transmission(
|
||||||
|
model::JuMP.Model,
|
||||||
|
violations::Vector{_Violation},
|
||||||
|
)::Nothing
|
||||||
|
for v in violations
|
||||||
|
_enforce_transmission(
|
||||||
|
model = model,
|
||||||
|
violation = v,
|
||||||
|
isf = model[:isf],
|
||||||
|
lodf = model[:lodf],
|
||||||
|
)
|
||||||
|
end
|
||||||
|
return
|
||||||
|
end
|
||||||
|
|
||||||
|
function _enforce_transmission(;
|
||||||
|
model::JuMP.Model,
|
||||||
|
violation::_Violation,
|
||||||
|
isf::Matrix{Float64},
|
||||||
|
lodf::Matrix{Float64},
|
||||||
|
)::Nothing
|
||||||
|
instance = model[:instance]
|
||||||
|
limit::Float64 = 0.0
|
||||||
|
overflow = model[:overflow]
|
||||||
|
net_injection = model[:net_injection]
|
||||||
|
|
||||||
|
if violation.outage_line === nothing
|
||||||
|
limit = violation.monitored_line.normal_flow_limit[violation.time]
|
||||||
|
@info @sprintf(
|
||||||
|
" %8.3f MW overflow in %-5s time %3d (pre-contingency)",
|
||||||
|
violation.amount,
|
||||||
|
violation.monitored_line.name,
|
||||||
|
violation.time,
|
||||||
|
)
|
||||||
|
else
|
||||||
|
limit = violation.monitored_line.emergency_flow_limit[violation.time]
|
||||||
|
@info @sprintf(
|
||||||
|
" %8.3f MW overflow in %-5s time %3d (outage: line %s)",
|
||||||
|
violation.amount,
|
||||||
|
violation.monitored_line.name,
|
||||||
|
violation.time,
|
||||||
|
violation.outage_line.name,
|
||||||
|
)
|
||||||
|
end
|
||||||
|
|
||||||
|
fm = violation.monitored_line.name
|
||||||
|
t = violation.time
|
||||||
|
flow = @variable(model, base_name = "flow[$fm,$t]")
|
||||||
|
|
||||||
|
v = overflow[violation.monitored_line.name, violation.time]
|
||||||
|
@constraint(model, flow <= limit + v)
|
||||||
|
@constraint(model, -flow <= limit + v)
|
||||||
|
|
||||||
|
if violation.outage_line === nothing
|
||||||
|
@constraint(
|
||||||
|
model,
|
||||||
|
flow == sum(
|
||||||
|
net_injection[b.name, violation.time] *
|
||||||
|
isf[violation.monitored_line.offset, b.offset] for
|
||||||
|
b in instance.buses if b.offset > 0
|
||||||
|
)
|
||||||
|
)
|
||||||
|
else
|
||||||
|
@constraint(
|
||||||
|
model,
|
||||||
|
flow == sum(
|
||||||
|
net_injection[b.name, violation.time] * (
|
||||||
|
isf[violation.monitored_line.offset, b.offset] + (
|
||||||
|
lodf[
|
||||||
|
violation.monitored_line.offset,
|
||||||
|
violation.outage_line.offset,
|
||||||
|
] * isf[violation.outage_line.offset, b.offset]
|
||||||
|
)
|
||||||
|
) for b in instance.buses if b.offset > 0
|
||||||
|
)
|
||||||
|
)
|
||||||
|
end
|
||||||
|
return nothing
|
||||||
|
end
|
||||||
@ -0,0 +1,44 @@
|
|||||||
|
# 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 _offer(filter::_ViolationFilter, v::_Violation)::Nothing
|
||||||
|
if v.monitored_line.offset ∉ keys(filter.queues)
|
||||||
|
filter.queues[v.monitored_line.offset] =
|
||||||
|
PriorityQueue{_Violation,Float64}()
|
||||||
|
end
|
||||||
|
q::PriorityQueue{_Violation,Float64} =
|
||||||
|
filter.queues[v.monitored_line.offset]
|
||||||
|
if length(q) < filter.max_per_line
|
||||||
|
enqueue!(q, v => v.amount)
|
||||||
|
else
|
||||||
|
if v.amount > peek(q)[1].amount
|
||||||
|
dequeue!(q)
|
||||||
|
enqueue!(q, v => v.amount)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
return nothing
|
||||||
|
end
|
||||||
|
|
||||||
|
function _query(filter::_ViolationFilter)::Array{_Violation,1}
|
||||||
|
violations = Array{_Violation,1}()
|
||||||
|
time_queue = PriorityQueue{_Violation,Float64}()
|
||||||
|
for l in keys(filter.queues)
|
||||||
|
line_queue = filter.queues[l]
|
||||||
|
while length(line_queue) > 0
|
||||||
|
v = dequeue!(line_queue)
|
||||||
|
if length(time_queue) < filter.max_total
|
||||||
|
enqueue!(time_queue, v => v.amount)
|
||||||
|
else
|
||||||
|
if v.amount > peek(time_queue)[1].amount
|
||||||
|
dequeue!(time_queue)
|
||||||
|
enqueue!(time_queue, v => v.amount)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
while length(time_queue) > 0
|
||||||
|
violations = [violations; dequeue!(time_queue)]
|
||||||
|
end
|
||||||
|
return violations
|
||||||
|
end
|
||||||
@ -0,0 +1,67 @@
|
|||||||
|
# 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.
|
||||||
|
|
||||||
|
"""
|
||||||
|
optimize!(model::JuMP.Model, method::_XaQiWaTh19)::Nothing
|
||||||
|
|
||||||
|
Solve the given unit commitment model, enforcing transmission and N-1
|
||||||
|
security constraints lazily, according to the algorithm described in:
|
||||||
|
|
||||||
|
Xavier, A. S., Qiu, F., Wang, F., & Thimmapuram, P. R. (2019). Transmission
|
||||||
|
constraint filtering in large-scale security-constrained unit commitment.
|
||||||
|
IEEE Transactions on Power Systems, 34(3), 2457-2460.
|
||||||
|
"""
|
||||||
|
function optimize!(model::JuMP.Model, method::_XaQiWaTh19)::Nothing
|
||||||
|
function set_gap(gap)
|
||||||
|
try
|
||||||
|
JuMP.set_optimizer_attribute(model, "MIPGap", gap)
|
||||||
|
@info @sprintf("MIP gap tolerance set to %f", gap)
|
||||||
|
catch
|
||||||
|
@warn "Could not change MIP gap tolerance"
|
||||||
|
end
|
||||||
|
end
|
||||||
|
instance = model[:instance]
|
||||||
|
initial_time = time()
|
||||||
|
large_gap = false
|
||||||
|
has_transmission = (length(model[:isf]) > 0)
|
||||||
|
if has_transmission && method.two_phase_gap
|
||||||
|
set_gap(1e-2)
|
||||||
|
large_gap = true
|
||||||
|
else
|
||||||
|
set_gap(method.gap_limit)
|
||||||
|
end
|
||||||
|
while true
|
||||||
|
time_elapsed = time() - initial_time
|
||||||
|
time_remaining = method.time_limit - time_elapsed
|
||||||
|
if time_remaining < 0
|
||||||
|
@info "Time limit exceeded"
|
||||||
|
break
|
||||||
|
end
|
||||||
|
@info @sprintf(
|
||||||
|
"Setting MILP time limit to %.2f seconds",
|
||||||
|
time_remaining
|
||||||
|
)
|
||||||
|
JuMP.set_time_limit_sec(model, time_remaining)
|
||||||
|
@info "Solving MILP..."
|
||||||
|
JuMP.optimize!(model)
|
||||||
|
has_transmission || break
|
||||||
|
violations = _find_violations(
|
||||||
|
model,
|
||||||
|
max_per_line = method.max_violations_per_line,
|
||||||
|
max_per_period = method.max_violations_per_period,
|
||||||
|
)
|
||||||
|
if isempty(violations)
|
||||||
|
@info "No violations found"
|
||||||
|
if large_gap
|
||||||
|
large_gap = false
|
||||||
|
set_gap(method.gap_limit)
|
||||||
|
else
|
||||||
|
break
|
||||||
|
end
|
||||||
|
else
|
||||||
|
_enforce_transmission(model, violations)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
return
|
||||||
|
end
|
||||||
@ -0,0 +1,78 @@
|
|||||||
|
# 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.
|
||||||
|
|
||||||
|
import DataStructures: PriorityQueue
|
||||||
|
|
||||||
|
"""
|
||||||
|
struct _XaQiWaTh19 <: SolutionMethod
|
||||||
|
time_limit::Float64
|
||||||
|
gap_limit::Float64
|
||||||
|
two_phase_gap::Bool
|
||||||
|
end
|
||||||
|
|
||||||
|
Lazy constraint solution method described in:
|
||||||
|
|
||||||
|
Xavier, A. S., Qiu, F., Wang, F., & Thimmapuram, P. R. (2019). Transmission
|
||||||
|
constraint filtering in large-scale security-constrained unit commitment.
|
||||||
|
IEEE Transactions on Power Systems, 34(3), 2457-2460.
|
||||||
|
|
||||||
|
Fields
|
||||||
|
=========
|
||||||
|
- `time_limit`:
|
||||||
|
the time limit over the entire optimization procedure.
|
||||||
|
- `gap_limit`:
|
||||||
|
the desired relative optimality gap.
|
||||||
|
- `two_phase_gap`:
|
||||||
|
if true, solve the problem with large gap tolerance first, then reduce
|
||||||
|
the gap tolerance when no further violated constraints are found.
|
||||||
|
"""
|
||||||
|
struct _XaQiWaTh19
|
||||||
|
time_limit::Float64
|
||||||
|
gap_limit::Float64
|
||||||
|
two_phase_gap::Bool
|
||||||
|
max_violations_per_line::Int
|
||||||
|
max_violations_per_period::Int
|
||||||
|
|
||||||
|
function _XaQiWaTh19(;
|
||||||
|
time_limit::Float64,
|
||||||
|
gap_limit::Float64,
|
||||||
|
two_phase_gap::Bool,
|
||||||
|
max_violations_per_line::Int,
|
||||||
|
max_violations_per_period::Int,
|
||||||
|
)
|
||||||
|
return new(
|
||||||
|
time_limit,
|
||||||
|
gap_limit,
|
||||||
|
two_phase_gap,
|
||||||
|
max_violations_per_line,
|
||||||
|
max_violations_per_period,
|
||||||
|
)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
struct _Violation
|
||||||
|
time::Int
|
||||||
|
monitored_line::TransmissionLine
|
||||||
|
outage_line::Union{TransmissionLine,Nothing}
|
||||||
|
amount::Float64
|
||||||
|
|
||||||
|
function _Violation(;
|
||||||
|
time::Int,
|
||||||
|
monitored_line::TransmissionLine,
|
||||||
|
outage_line::Union{TransmissionLine,Nothing},
|
||||||
|
amount::Float64,
|
||||||
|
)
|
||||||
|
return new(time, monitored_line, outage_line, amount)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
mutable struct _ViolationFilter
|
||||||
|
max_per_line::Int
|
||||||
|
max_total::Int
|
||||||
|
queues::Dict{Int,PriorityQueue{_Violation,Float64}}
|
||||||
|
|
||||||
|
function _ViolationFilter(; max_per_line::Int = 1, max_total::Int = 5)
|
||||||
|
return new(max_per_line, max_total, Dict())
|
||||||
|
end
|
||||||
|
end
|
||||||
@ -0,0 +1,23 @@
|
|||||||
|
# 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 optimize!(model::JuMP.Model)::Nothing
|
||||||
|
|
||||||
|
Solve the given unit commitment model. Unlike JuMP.optimize!, this uses more
|
||||||
|
advanced methods to accelerate the solution process and to enforce transmission
|
||||||
|
and N-1 security constraints.
|
||||||
|
"""
|
||||||
|
function optimize!(model::JuMP.Model)::Nothing
|
||||||
|
return UnitCommitment.optimize!(
|
||||||
|
model,
|
||||||
|
_XaQiWaTh19(
|
||||||
|
time_limit = 3600.0,
|
||||||
|
gap_limit = 1e-4,
|
||||||
|
two_phase_gap = true,
|
||||||
|
max_violations_per_line = 1,
|
||||||
|
max_violations_per_period = 5,
|
||||||
|
),
|
||||||
|
)
|
||||||
|
end
|
||||||
@ -0,0 +1,65 @@
|
|||||||
|
# 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 solution(model::JuMP.Model)::OrderedDict
|
||||||
|
instance, T = model[:instance], model[:instance].time
|
||||||
|
function timeseries(vars, collection)
|
||||||
|
return OrderedDict(
|
||||||
|
b.name => [round(value(vars[b.name, t]), digits = 5) for t in 1:T]
|
||||||
|
for b in collection
|
||||||
|
)
|
||||||
|
end
|
||||||
|
function production_cost(g)
|
||||||
|
return [
|
||||||
|
value(model[:is_on][g.name, t]) * g.min_power_cost[t] + sum(
|
||||||
|
Float64[
|
||||||
|
value(model[:segprod][g.name, t, k]) *
|
||||||
|
g.cost_segments[k].cost[t] for
|
||||||
|
k in 1:length(g.cost_segments)
|
||||||
|
],
|
||||||
|
) for t in 1:T
|
||||||
|
]
|
||||||
|
end
|
||||||
|
function production(g)
|
||||||
|
return [
|
||||||
|
value(model[:is_on][g.name, t]) * g.min_power[t] + sum(
|
||||||
|
Float64[
|
||||||
|
value(model[:segprod][g.name, t, k]) for
|
||||||
|
k in 1:length(g.cost_segments)
|
||||||
|
],
|
||||||
|
) for t in 1:T
|
||||||
|
]
|
||||||
|
end
|
||||||
|
function startup_cost(g)
|
||||||
|
S = length(g.startup_categories)
|
||||||
|
return [
|
||||||
|
sum(
|
||||||
|
g.startup_categories[s].cost *
|
||||||
|
value(model[:startup][g.name, t, s]) for s in 1:S
|
||||||
|
) for t in 1:T
|
||||||
|
]
|
||||||
|
end
|
||||||
|
sol = OrderedDict()
|
||||||
|
sol["Production (MW)"] =
|
||||||
|
OrderedDict(g.name => production(g) for g in instance.units)
|
||||||
|
sol["Production cost (\$)"] =
|
||||||
|
OrderedDict(g.name => production_cost(g) for g in instance.units)
|
||||||
|
sol["Startup cost (\$)"] =
|
||||||
|
OrderedDict(g.name => startup_cost(g) for g in instance.units)
|
||||||
|
sol["Is on"] = timeseries(model[:is_on], instance.units)
|
||||||
|
sol["Switch on"] = timeseries(model[:switch_on], instance.units)
|
||||||
|
sol["Switch off"] = timeseries(model[:switch_off], instance.units)
|
||||||
|
sol["Reserve (MW)"] = timeseries(model[:reserve], instance.units)
|
||||||
|
sol["Net injection (MW)"] =
|
||||||
|
timeseries(model[:net_injection], instance.buses)
|
||||||
|
sol["Load curtail (MW)"] = timeseries(model[:curtail], instance.buses)
|
||||||
|
if !isempty(instance.lines)
|
||||||
|
sol["Line overflow (MW)"] = timeseries(model[:overflow], instance.lines)
|
||||||
|
end
|
||||||
|
if !isempty(instance.price_sensitive_loads)
|
||||||
|
sol["Price-sensitive loads (MW)"] =
|
||||||
|
timeseries(model[:loads], instance.price_sensitive_loads)
|
||||||
|
end
|
||||||
|
return sol
|
||||||
|
end
|
||||||
@ -0,0 +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 SolutionMethod end
|
||||||
@ -0,0 +1,24 @@
|
|||||||
|
# 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 set_warm_start!(model::JuMP.Model, solution::AbstractDict)::Nothing
|
||||||
|
instance, T = model[:instance], model[:instance].time
|
||||||
|
is_on = model[:is_on]
|
||||||
|
prod_above = model[:prod_above]
|
||||||
|
reserve = model[:reserve]
|
||||||
|
for g in instance.units
|
||||||
|
for t in 1:T
|
||||||
|
JuMP.set_start_value(is_on[g.name, t], solution["Is on"][g.name][t])
|
||||||
|
JuMP.set_start_value(
|
||||||
|
switch_on[g.name, t],
|
||||||
|
solution["Switch on"][g.name][t],
|
||||||
|
)
|
||||||
|
JuMP.set_start_value(
|
||||||
|
switch_off[g.name, t],
|
||||||
|
solution["Switch off"][g.name][t],
|
||||||
|
)
|
||||||
|
end
|
||||||
|
end
|
||||||
|
return
|
||||||
|
end
|
||||||
@ -0,0 +1,10 @@
|
|||||||
|
# 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 write(filename::AbstractString, solution::AbstractDict)::Nothing
|
||||||
|
open(filename, "w") do file
|
||||||
|
return JSON.print(file, solution, 2)
|
||||||
|
end
|
||||||
|
return
|
||||||
|
end
|
||||||
@ -0,0 +1,52 @@
|
|||||||
|
# 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.
|
||||||
|
|
||||||
|
"""
|
||||||
|
slice(instance, range)
|
||||||
|
|
||||||
|
Creates a new instance, with only a subset of the time periods.
|
||||||
|
This function does not modify the provided instance. The initial
|
||||||
|
conditions are also not modified.
|
||||||
|
|
||||||
|
Example
|
||||||
|
-------
|
||||||
|
|
||||||
|
# Build a 2-hour UC instance
|
||||||
|
instance = UnitCommitment.read_benchmark("test/case14")
|
||||||
|
modified = UnitCommitment.slice(instance, 1:2)
|
||||||
|
|
||||||
|
"""
|
||||||
|
function slice(
|
||||||
|
instance::UnitCommitmentInstance,
|
||||||
|
range::UnitRange{Int},
|
||||||
|
)::UnitCommitmentInstance
|
||||||
|
modified = deepcopy(instance)
|
||||||
|
modified.time = length(range)
|
||||||
|
modified.power_balance_penalty = modified.power_balance_penalty[range]
|
||||||
|
modified.reserves.spinning = modified.reserves.spinning[range]
|
||||||
|
for u in modified.units
|
||||||
|
u.max_power = u.max_power[range]
|
||||||
|
u.min_power = u.min_power[range]
|
||||||
|
u.must_run = u.must_run[range]
|
||||||
|
u.min_power_cost = u.min_power_cost[range]
|
||||||
|
u.provides_spinning_reserves = u.provides_spinning_reserves[range]
|
||||||
|
for s in u.cost_segments
|
||||||
|
s.mw = s.mw[range]
|
||||||
|
s.cost = s.cost[range]
|
||||||
|
end
|
||||||
|
end
|
||||||
|
for b in modified.buses
|
||||||
|
b.load = b.load[range]
|
||||||
|
end
|
||||||
|
for l in modified.lines
|
||||||
|
l.normal_flow_limit = l.normal_flow_limit[range]
|
||||||
|
l.emergency_flow_limit = l.emergency_flow_limit[range]
|
||||||
|
l.flow_limit_penalty = l.flow_limit_penalty[range]
|
||||||
|
end
|
||||||
|
for ps in modified.price_sensitive_loads
|
||||||
|
ps.demand = ps.demand[range]
|
||||||
|
ps.revenue = ps.revenue[range]
|
||||||
|
end
|
||||||
|
return modified
|
||||||
|
end
|
||||||
@ -0,0 +1,3 @@
|
|||||||
|
# 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.
|
||||||
@ -0,0 +1,69 @@
|
|||||||
|
# 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.
|
||||||
|
|
||||||
|
"""
|
||||||
|
repair!(instance)
|
||||||
|
|
||||||
|
Verifies that the given unit commitment instance is valid and automatically
|
||||||
|
fixes some validation errors if possible, issuing a warning for each error
|
||||||
|
found. If a validation error cannot be automatically fixed, issues an
|
||||||
|
exception.
|
||||||
|
|
||||||
|
Returns the number of validation errors found.
|
||||||
|
"""
|
||||||
|
function repair!(instance::UnitCommitmentInstance)::Int
|
||||||
|
n_errors = 0
|
||||||
|
|
||||||
|
for g in instance.units
|
||||||
|
|
||||||
|
# Startup costs and delays must be increasing
|
||||||
|
for s in 2:length(g.startup_categories)
|
||||||
|
if g.startup_categories[s].delay <= g.startup_categories[s-1].delay
|
||||||
|
prev_value = g.startup_categories[s].delay
|
||||||
|
new_value = g.startup_categories[s-1].delay + 1
|
||||||
|
@warn "Generator $(g.name) has non-increasing startup delays (category $s). " *
|
||||||
|
"Changing delay: $prev_value → $new_value"
|
||||||
|
g.startup_categories[s].delay = new_value
|
||||||
|
n_errors += 1
|
||||||
|
end
|
||||||
|
|
||||||
|
if g.startup_categories[s].cost < g.startup_categories[s-1].cost
|
||||||
|
prev_value = g.startup_categories[s].cost
|
||||||
|
new_value = g.startup_categories[s-1].cost
|
||||||
|
@warn "Generator $(g.name) has decreasing startup cost (category $s). " *
|
||||||
|
"Changing cost: $prev_value → $new_value"
|
||||||
|
g.startup_categories[s].cost = new_value
|
||||||
|
n_errors += 1
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
for t in 1:instance.time
|
||||||
|
# Production cost curve should be convex
|
||||||
|
for k in 2:length(g.cost_segments)
|
||||||
|
cost = g.cost_segments[k].cost[t]
|
||||||
|
min_cost = g.cost_segments[k-1].cost[t]
|
||||||
|
if cost < min_cost - 1e-5
|
||||||
|
@warn "Generator $(g.name) has non-convex production cost curve " *
|
||||||
|
"(segment $k, time $t). Changing cost: $cost → $min_cost"
|
||||||
|
g.cost_segments[k].cost[t] = min_cost
|
||||||
|
n_errors += 1
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
# Startup limit must be greater than min_power
|
||||||
|
if g.startup_limit < g.min_power[t]
|
||||||
|
new_limit = g.min_power[t]
|
||||||
|
prev_limit = g.startup_limit
|
||||||
|
@warn "Generator $(g.name) has startup limit lower than minimum power. " *
|
||||||
|
"Changing startup limit: $prev_limit → $new_limit"
|
||||||
|
g.startup_limit = new_limit
|
||||||
|
n_errors += 1
|
||||||
|
end
|
||||||
|
end
|
||||||
|
end
|
||||||
|
|
||||||
|
return n_errors
|
||||||
|
end
|
||||||
|
|
||||||
|
export repair!
|
||||||
Loading…
Reference in new issue