stochastic extension w/ scenarios

src/solution/methods/XavQiuWanThi2019/enforce.jl

@@ -5,13 +5,15 @@
 function _enforce_transmission(
     model::JuMP.Model,
     violations::Vector{_Violation},
+    sc::UnitCommitmentScenario
 )::Nothing
     for v in violations
         _enforce_transmission(
             model = model,
+            sc = sc,
             violation = v,
-            isf = model[:isf],
-            lodf = model[:lodf],
+            isf = sc.isf,
+            lodf = sc.lodf,
         )
     end
     return
@@ -19,6 +21,7 @@ end
 
 function _enforce_transmission(;
     model::JuMP.Model,
+    sc::UnitCommitmentScenario,
     violation::_Violation,
     isf::Matrix{Float64},
     lodf::Matrix{Float64},
@@ -51,7 +54,7 @@ function _enforce_transmission(;
     t = violation.time
     flow = @variable(model, base_name = "flow[$fm,$t]")
 
-    v = overflow[violation.monitored_line.name, violation.time]
+    v = overflow[sc.name, violation.monitored_line.name, violation.time]
     @constraint(model, flow <= limit + v)
     @constraint(model, -flow <= limit + v)
 
@@ -59,23 +62,23 @@ function _enforce_transmission(;
         @constraint(
             model,
             flow == sum(
-                net_injection[b.name, violation.time] *
+                net_injection[sc.name, b.name, violation.time] *
                 isf[violation.monitored_line.offset, b.offset] for
-                b in instance.buses if b.offset > 0
+                b in sc.buses if b.offset > 0
             )
         )
     else
         @constraint(
             model,
             flow == sum(
-                net_injection[b.name, violation.time] * (
+                net_injection[sc.name, 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
+                ) for b in sc.buses if b.offset > 0
             )
         )
     end

src/solution/methods/XavQiuWanThi2019/find.jl

@@ -5,32 +5,34 @@
 import Base.Threads: @threads
 
 function _find_violations(
-    model::JuMP.Model;
+    model::JuMP.Model,
+    sc::UnitCommitmentScenario;
     max_per_line::Int,
     max_per_period::Int,
 )
     instance = model[:instance]
     net_injection = model[:net_injection]
     overflow = model[:overflow]
-    length(instance.buses) > 1 || return []
+    length(sc.buses) > 1 || return []
     violations = []
     @info "Verifying transmission limits..."
     time_screening = @elapsed begin
-        non_slack_buses = [b for b in instance.buses if b.offset > 0]
+        non_slack_buses = [b for b in sc.buses if b.offset > 0]
         net_injection_values = [
-            value(net_injection[b.name, t]) for b in non_slack_buses,
+            value(net_injection[sc.name, b.name, t]) for b in non_slack_buses,
             t in 1:instance.time
         ]
         overflow_values = [
-            value(overflow[lm.name, t]) for lm in instance.lines,
+            value(overflow[sc.name, lm.name, t]) for lm in sc.lines,
             t in 1:instance.time
         ]
         violations = UnitCommitment._find_violations(
             instance = instance,
+            sc = sc,
             net_injections = net_injection_values,
             overflow = overflow_values,
-            isf = model[:isf],
-            lodf = model[:lodf],
+            isf = sc.isf,
+            lodf = sc.lodf,
             max_per_line = max_per_line,
             max_per_period = max_per_period,
         )
@@ -64,15 +66,16 @@ matrix, where L is the number of transmission lines.
 """
 function _find_violations(;
     instance::UnitCommitmentInstance,
+    sc::UnitCommitmentScenario,
     net_injections::Array{Float64,2},
     overflow::Array{Float64,2},
     isf::Array{Float64,2},
     lodf::Array{Float64,2},
     max_per_line::Int,
-    max_per_period::Int,
+    max_per_period::Int
 )::Array{_Violation,1}
-    B = length(instance.buses) - 1
-    L = length(instance.lines)
+    B = length(sc.buses) - 1
+    L = length(sc.lines)
     T = instance.time
     K = nthreads()
 
@@ -94,16 +97,16 @@ function _find_violations(;
 
     normal_limits::Array{Float64,2} = [
         l.normal_flow_limit[t] + overflow[l.offset, t] for
-        l in instance.lines, t in 1:T
+        l in sc.lines, t in 1:T
     ]
 
     emergency_limits::Array{Float64,2} = [
         l.emergency_flow_limit[t] + overflow[l.offset, t] for
-        l in instance.lines, t in 1:T
+        l in sc.lines, t in 1:T
     ]
 
     is_vulnerable::Array{Bool} = zeros(Bool, L)
-    for c in instance.contingencies
+    for c in sc.contingencies
         is_vulnerable[c.lines[1].offset] = true
     end
 
@@ -111,7 +114,7 @@ function _find_violations(;
         k = threadid()
 
         # Pre-contingency flows
-        pre_flow[:, k] = isf * net_injections[:, t]
+        pre_flow[:, k] = isf * net_injections[ :, t]
 
         # Post-contingency flows
         for lc in 1:L, lm in 1:L
@@ -144,7 +147,7 @@ function _find_violations(;
                     filters[t],
                     _Violation(
                         time = t,
-                        monitored_line = instance.lines[lm],
+                        monitored_line = sc.lines[lm],
                         outage_line = nothing,
                         amount = pre_v[lm, k],
                     ),
@@ -159,8 +162,8 @@ function _find_violations(;
                     filters[t],
                     _Violation(
                         time = t,
-                        monitored_line = instance.lines[lm],
-                        outage_line = instance.lines[lc],
+                        monitored_line = sc.lines[lm],
+                        outage_line = sc.lines[lc],
                         amount = post_v[lm, lc, k],
                     ),
                 )

src/solution/methods/XavQiuWanThi2019/optimize.jl

@@ -10,43 +10,47 @@ function optimize!(model::JuMP.Model, method::XavQiuWanThi2019.Method)::Nothing
         JuMP.set_optimizer_attribute(model, "MIPGap", gap)
         @info @sprintf("MIP gap tolerance set to %f", gap)
     end
-    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
-    end
-    while true
-        time_elapsed = time() - initial_time
-        time_remaining = method.time_limit - time_elapsed
-        if time_remaining < 0
-            @info "Time limit exceeded"
-            break
+    for scenario in model[:instance].scenarios
+        large_gap = false
+        has_transmission = (length(scenario.isf) > 0)
+        if has_transmission && method.two_phase_gap
+            set_gap(1e-2)
+            large_gap = true
         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
+        while true
+            initial_time = time()
+            time_elapsed = time() - initial_time
+            time_remaining = method.time_limit - time_elapsed
+            if time_remaining < 0
+                @info "Time limit exceeded"
                 break
             end
-        else
-            _enforce_transmission(model, violations)
+            @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,
+                scenario,
+                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, scenario)
+            end
         end
     end
     return