Datasets:
File size: 2,784 Bytes
43c68a3 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 | # 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 JuMP
"""
generate_initial_conditions!(instance, optimizer)
Generates feasible initial conditions for the given instance, by constructing
and solving a single-period mixed-integer optimization problem, using the given
optimizer. The instance is modified in-place.
"""
function generate_initial_conditions!(
instance::UnitCommitmentInstance,
optimizer,
)::Nothing
# Process first scenario
_generate_initial_conditions!(instance.scenarios[1], optimizer)
# Copy initial conditions to remaining scenarios
for (si, sc) in enumerate(instance.scenarios)
si > 1 || continue
for (gi, g) in sc.thermal_units
g_ref = instance.scenarios[1].thermal_units[gi]
g.initial_power = g_ref.initial_power
g.initial_status = g_ref.initial_status
end
end
end
function _generate_initial_conditions!(
sc::UnitCommitmentScenario,
optimizer,
)::Nothing
G = sc.thermal_units
B = sc.buses
PU = sc.profiled_units
t = 1
mip = JuMP.Model(optimizer)
# Decision variables
@variable(mip, x[G], Bin)
@variable(mip, p[G] >= 0)
@variable(mip, pu[PU])
# Constraint: Minimum power
@constraint(mip, min_power[g in G], p[g] >= g.min_power[t] * x[g])
@constraint(mip, pu_min_power[k in PU], pu[k] >= k.min_power[t])
# Constraint: Maximum power
@constraint(mip, max_power[g in G], p[g] <= g.max_power[t] * x[g])
@constraint(mip, pu_max_power[k in PU], pu[k] <= k.max_power[t])
# Constraint: Production equals demand
@constraint(
mip,
power_balance,
sum(b.load[t] for b in B) ==
sum(p[g] for g in G) + sum(pu[k] for k in PU)
)
# Constraint: Must run
for g in G
if g.must_run[t]
@constraint(mip, x[g] == 1)
end
end
# Objective function
function cost_slope(g)
mw = g.min_power[t]
c = g.min_power_cost[t]
for k in g.cost_segments
mw += k.mw[t]
c += k.mw[t] * k.cost[t]
end
if mw < 1e-3
return 0.0
else
return c / mw
end
end
@objective(
mip,
Min,
sum(p[g] * cost_slope(g) for g in G) +
sum(pu[k] * k.cost[t] for k in PU)
)
JuMP.optimize!(mip)
for g in G
if JuMP.value(x[g]) > 0
g.initial_power = JuMP.value(p[g])
g.initial_status = 24
else
g.initial_power = 0
g.initial_status = -24
end
end
return
end
|