removed TNEP data set type with refrence dict

Author: ccoffrin

src/core/base.jl

@@ -4,16 +4,6 @@ export
     GenericPowerModel,
     setdata, setsolver, solve
 
-type TNEPDataSets
-    branches
-    arcs_from
-    arcs_to
-    arcs
-    bus_arcs
-    buspairs
-end
-
-
 abstract AbstractPowerModel
 abstract AbstractPowerFormulation
 abstract AbstractConicPowerFormulation <: AbstractPowerFormulation
@@ -34,39 +24,20 @@ type GenericPowerModel{T<:AbstractPowerFormulation} <: AbstractPowerModel
 end
 
 # default generic constructor
-function GenericPowerModel{T}(data::Dict{AbstractString,Any}, vars::T; setting = Dict{AbstractString,Any}(), solver = JuMP.UnsetSolver(), data_processor = process_raw_mp_data)
-    data, ref, ext = data_processor(data)
+function GenericPowerModel{T}(data::Dict{AbstractString,Any}, vars::T; setting = Dict{AbstractString,Any}(), solver = JuMP.UnsetSolver())
+
     pm = GenericPowerModel{T}(
         Model(solver = solver), # model
         data, # data
         setting, # setting
         Dict{AbstractString,Any}(), # solution
-        ref, # sets
-        ext # ext
+        build_ref(data), # refrence data
+        Dict{Symbol,Any}() # ext
     )
 
     return pm
 end
 
-function process_raw_mp_data(data::Dict{AbstractString,Any})
-    ref = build_ref(data)
-
-    ext = Dict{Symbol,Any}()
-
-    return data, ref, ext
-end
-
-function process_raw_mp_ne_data(data::Dict{AbstractString,Any})
-    ref = build_ref(data)
-    ne_sets = build_ne_sets(data)
-
-    ext = Dict{Symbol,Any}()
-    ext[:ne] = ne_sets
-
-    return data, ref, ext
-end
-
-
 #
 # Just seems too hard to maintain with the default constructor
 #
@@ -120,6 +91,7 @@ function run_generic_model(data::Dict{AbstractString,Any}, model_constructor, so
     return build_solution(pm, status, solve_time; solution_builder = solution_builder)
 end
 
+
 function build_ref(data::Dict{AbstractString,Any})
     ref = Dict{Symbol,Any}()
     for (key, item) in data
@@ -167,30 +139,23 @@ function build_ref(data::Dict{AbstractString,Any})
 
     ref[:buspairs] = buspair_parameters(ref[:arcs_from], ref[:branch], ref[:bus])
 
-    return ref
-end
+    if haskey(ref, :ne_branch)
+        ref[:ne_branch] = filter((i, branch) -> branch["br_status"] == 1 && branch["f_bus"] in keys(ref[:bus]) && branch["t_bus"] in keys(ref[:bus]), ref[:ne_branch])
 
-function build_ne_sets(data::Dict{AbstractString,Any})    
-    bus_lookup = Dict([(Int(bus["index"]), bus) for bus in data["bus"]])
-    branch_lookup = Dict([(Int(branch["index"]), branch) for branch in data["ne_branch"]])
+        ref[:ne_arcs_from] = [(i,branch["f_bus"],branch["t_bus"]) for (i,branch) in ref[:ne_branch]]
+        ref[:ne_arcs_to]   = [(i,branch["t_bus"],branch["f_bus"]) for (i,branch) in ref[:ne_branch]]
+        ref[:ne_arcs] = [ref[:ne_arcs_from]; ref[:ne_arcs_to]]
 
-    # filter turned off stuff
-    bus_lookup = filter((i, bus) -> bus["bus_type"] != 4, bus_lookup)
-    branch_lookup = filter((i, branch) -> branch["br_status"] == 1 && branch["f_bus"] in keys(bus_lookup) && branch["t_bus"] in keys(bus_lookup), branch_lookup)
-
-    arcs_from = [(i,branch["f_bus"],branch["t_bus"]) for (i,branch) in branch_lookup]
-    arcs_to   = [(i,branch["t_bus"],branch["f_bus"]) for (i,branch) in branch_lookup]
-    arcs = [arcs_from; arcs_to]
+        ne_bus_arcs = Dict([(i, []) for (i,bus) in ref[:bus]])
+        for (l,i,j) in ref[:ne_arcs]
+            push!(ne_bus_arcs[i], (l,i,j))
+        end
+        ref[:ne_bus_arcs] = ne_bus_arcs
 
-    bus_arcs = Dict([(i, []) for (i,bus) in bus_lookup])
-    for (l,i,j) in arcs_from
-        push!(bus_arcs[i], (l,i,j))
-        push!(bus_arcs[j], (l,j,i))
+        ref[:ne_buspairs] = buspair_parameters(ref[:ne_arcs_from], ref[:ne_branch], ref[:bus])
     end
 
-    buspairs = buspair_parameters(arcs_from, branch_lookup, bus_lookup)
-
-    return TNEPDataSets(branch_lookup, arcs_from, arcs_to, arcs, bus_arcs, buspairs)
+    return ref
 end
 
 

src/core/objective.jl

@@ -23,6 +23,6 @@ end
 ### Cost of building lines
 function objective_tnep_cost{T}(pm::GenericPowerModel{T})
     line_ne = getvariable(pm.model, :line_ne)
-    branches = pm.ext[:ne].branches
+    branches = pm.ref[:ne_branch]
     return @objective(pm.model, Min, sum( branches[i]["construction_cost"]*line_ne[i] for (i,branch) in branches) )
 end

src/core/variable.jl

@@ -81,7 +81,7 @@ function variable_active_line_flow{T}(pm::GenericPowerModel{T}; bounded = true)
 end
 
 function variable_active_line_flow_ne{T}(pm::GenericPowerModel{T})
-    @variable(pm.model, -pm.ext[:ne].branches[l]["rate_a"] <= p_ne[(l,i,j) in pm.ext[:ne].arcs] <= pm.ext[:ne].branches[l]["rate_a"], start = getstart(pm.ext[:ne].branches, l, "p_start"))
+    @variable(pm.model, -pm.ref[:ne_branch][l]["rate_a"] <= p_ne[(l,i,j) in pm.ref[:ne_arcs]] <= pm.ref[:ne_branch][l]["rate_a"], start = getstart(pm.ref[:ne_branch], l, "p_start"))
     return p_ne
 end
 
@@ -96,7 +96,7 @@ function variable_reactive_line_flow{T}(pm::GenericPowerModel{T}; bounded = true
 end
 
 function variable_reactive_line_flow_ne{T}(pm::GenericPowerModel{T})
-    @variable(pm.model, -pm.ext[:ne].branches[l]["rate_a"] <= q_ne[(l,i,j) in pm.ext[:ne].arcs] <= pm.ext[:ne].branches[l]["rate_a"], start = getstart(pm.ext[:ne].branches, l, "q_start"))
+    @variable(pm.model, -pm.ref[:ne_branch][l]["rate_a"] <= q_ne[(l,i,j) in pm.ref[:ne_arcs]] <= pm.ref[:ne_branch][l]["rate_a"], start = getstart(pm.ref[:ne_branch], l, "q_start"))
     return q_ne
 end
 
@@ -254,8 +254,8 @@ function variable_line_indicator{T}(pm::GenericPowerModel{T})
 end
 
 function variable_line_ne{T}(pm::GenericPowerModel{T})
-    branches = pm.ext[:ne].branches
-    @variable(pm.model, 0 <= line_ne[l in keys(pm.ext[:ne].branches)] <= 1, Int, start = getstart(branches, l, "line_tnep_start", 1.0))
+    branches = pm.ref[:ne_branch]
+    @variable(pm.model, 0 <= line_ne[l in keys(branches)] <= 1, Int, start = getstart(branches, l, "line_tnep_start", 1.0))
     return line_ne
 end
 

src/form/acp.jl

@@ -68,7 +68,7 @@ end
 function constraint_active_kcl_shunt_ne{T <: AbstractACPForm}(pm::GenericPowerModel{T}, bus)
     i = bus["index"]
     bus_arcs = pm.ref[:bus_arcs][i]
-    bus_arcs_ne = pm.ext[:ne].bus_arcs[i]
+    bus_arcs_ne = pm.ref[:ne_bus_arcs][i]
     bus_gens = pm.ref[:bus_gens][i]
 
     v = getvariable(pm.model, :v)
@@ -97,7 +97,7 @@ end
 function constraint_reactive_kcl_shunt_ne{T <: AbstractACPForm}(pm::GenericPowerModel{T}, bus)
     i = bus["index"]
     bus_arcs = pm.ref[:bus_arcs][i]
-    bus_arcs_ne = pm.ext[:ne].bus_arcs[i]
+    bus_arcs_ne = pm.ref[:ne_bus_arcs][i]
     bus_gens = pm.ref[:bus_gens][i]
 
     v = getvariable(pm.model, :v)

src/form/dcp.jl

@@ -47,10 +47,10 @@ function variable_active_line_flow{T <: StandardDCPForm}(pm::GenericPowerModel{T
 end
 
 function variable_active_line_flow_ne{T <: StandardDCPForm}(pm::GenericPowerModel{T})
-    @variable(pm.model, -pm.ext[:ne].branches[l]["rate_a"] <= p_ne[(l,i,j) in pm.ext[:ne].arcs_from] <= pm.ext[:ne].branches[l]["rate_a"], start = getstart(pm.ext[:ne].branches, l, "p_start"))
+    @variable(pm.model, -pm.ref[:ne_branch][l]["rate_a"] <= p_ne[(l,i,j) in pm.ref[:ne_arcs_from]] <= pm.ref[:ne_branch][l]["rate_a"], start = getstart(pm.ref[:ne_branch], l, "p_start"))
 
-    p_ne_expr = Dict([((l,i,j), 1.0*p_ne[(l,i,j)]) for (l,i,j) in pm.ext[:ne].arcs_from])
-    p_ne_expr = merge(p_ne_expr, Dict([((l,j,i), -1.0*p_ne[(l,i,j)]) for (l,i,j) in pm.ext[:ne].arcs_from]))
+    p_ne_expr = Dict([((l,i,j), 1.0*p_ne[(l,i,j)]) for (l,i,j) in pm.ref[:ne_arcs_from]])
+    p_ne_expr = merge(p_ne_expr, Dict([((l,j,i), -1.0*p_ne[(l,i,j)]) for (l,i,j) in pm.ref[:ne_arcs_from]]))
 
     pm.model.ext[:p_ne_expr] = p_ne_expr
 end
@@ -95,7 +95,7 @@ end
 function constraint_active_kcl_shunt_ne{T <: AbstractDCPForm}(pm::GenericPowerModel{T}, bus)
     i = bus["index"]
     bus_arcs = pm.ref[:bus_arcs][i]
-    bus_arcs_ne = pm.ext[:ne].bus_arcs[i]
+    bus_arcs_ne = pm.ref[:ne_bus_arcs][i]
     bus_gens = pm.ref[:bus_gens][i]
 
     pg = getvariable(pm.model, :pg)
@@ -365,7 +365,7 @@ end
 function constraint_active_kcl_shunt_ne{T <: AbstractDCPLLForm}(pm::GenericPowerModel{T}, bus)
     i = bus["index"]
     bus_arcs = pm.ref[:bus_arcs][i]
-    bus_arcs_ne = pm.ext[:ne].bus_arcs[i]
+    bus_arcs_ne = pm.ref[:ne_bus_arcs][i]
     bus_gens = pm.ref[:bus_gens][i]
 
     p = getvariable(pm.model, :p)

src/form/wr.jl

@@ -63,7 +63,7 @@ end
 function constraint_active_kcl_shunt_ne{T <: AbstractWRForm}(pm::GenericPowerModel{T}, bus)
     i = bus["index"]
     bus_arcs = pm.ref[:bus_arcs][i]
-    bus_arcs_ne = pm.ext[:ne].bus_arcs[i]
+    bus_arcs_ne = pm.ref[:ne_bus_arcs][i]
     bus_gens = pm.ref[:bus_gens][i]
 
     w = getvariable(pm.model, :w)
@@ -91,7 +91,7 @@ end
 function constraint_reactive_kcl_shunt_ne{T <: AbstractWRForm}(pm::GenericPowerModel{T}, bus)
     i = bus["index"]
     bus_arcs = pm.ref[:bus_arcs][i]
-    bus_arcs_ne = pm.ext[:ne].bus_arcs[i]
+    bus_arcs_ne = pm.ref[:ne_bus_arcs][i]
     bus_gens = pm.ref[:bus_gens][i]
 
     w = getvariable(pm.model, :w)
@@ -277,9 +277,9 @@ end
 
 function constraint_complex_voltage_ne{T <: AbstractWRForm}(pm::GenericPowerModel{T})
     buses = pm.ref[:bus]
-    branches = pm.ext[:ne].branches
+    branches = pm.ref[:ne_branch]
 
-    wr_min, wr_max, wi_min, wi_max = compute_voltage_product_bounds(pm.ext[:ne].buspairs)
+    wr_min, wr_max, wi_min, wi_max = compute_voltage_product_bounds(pm.ref[:ne_buspairs])
     bi_bp = Dict([(i, (b["f_bus"], b["t_bus"])) for (i,b) in branches])
 
     w = getvariable(pm.model, :w)
@@ -291,7 +291,7 @@ function constraint_complex_voltage_ne{T <: AbstractWRForm}(pm::GenericPowerMode
     w_to = getvariable(pm.model, :w_to_ne)
 
     cs = Set()
-    for (l,i,j) in pm.ext[:ne].arcs_from
+    for (l,i,j) in pm.ref[:ne_arcs_from]
         c1 = @constraint(pm.model, w_from[l] <= z[l]*buses[branches[l]["f_bus"]]["vmax"]^2)
         c2 = @constraint(pm.model, w_from[l] >= z[l]*buses[branches[l]["f_bus"]]["vmin"]^2)
 
@@ -454,23 +454,23 @@ end
 
 function variable_voltage_magnitude_sqr_from_ne{T <: AbstractWRForm}(pm::GenericPowerModel{T})
     buses = pm.ref[:bus]
-    branches = pm.ext[:ne].branches
-    @variable(pm.model, 0 <= w_from_ne[i in keys(pm.ext[:ne].branches)] <= buses[branches[i]["f_bus"]]["vmax"]^2, start = getstart(pm.ref[:bus], i, "w_from_start", 1.001))
+    branches = pm.ref[:ne_branch]
+    @variable(pm.model, 0 <= w_from_ne[i in keys(pm.ref[:ne_branch])] <= buses[branches[i]["f_bus"]]["vmax"]^2, start = getstart(pm.ref[:bus], i, "w_from_start", 1.001))
     return w_from_ne
 end
 
 function variable_voltage_magnitude_sqr_to_ne{T <: AbstractWRForm}(pm::GenericPowerModel{T})
     buses = pm.ref[:bus]
-    branches = pm.ext[:ne].branches
-    @variable(pm.model, 0 <= w_to_ne[i in keys(pm.ext[:ne].branches)] <= buses[branches[i]["t_bus"]]["vmax"]^2, start = getstart(pm.ref[:bus], i, "w_to", 1.001))
+    branches = pm.ref[:ne_branch]
+    @variable(pm.model, 0 <= w_to_ne[i in keys(pm.ref[:ne_branch])] <= buses[branches[i]["t_bus"]]["vmax"]^2, start = getstart(pm.ref[:bus], i, "w_to", 1.001))
     return w_to_ne
 end
 
 function variable_complex_voltage_product_ne{T <: AbstractWRForm}(pm::GenericPowerModel{T})
-    wr_min, wr_max, wi_min, wi_max = compute_voltage_product_bounds(pm.ext[:ne].buspairs)
-    bi_bp = Dict([(i, (b["f_bus"], b["t_bus"])) for (i,b) in pm.ext[:ne].branches])
-    @variable(pm.model, min(0, wr_min[bi_bp[b]]) <= wr_ne[b in keys(pm.ext[:ne].branches)] <= max(0, wr_max[bi_bp[b]]), start = getstart(pm.ext[:ne].buspairs, bi_bp[b], "wr_start", 1.0))
-    @variable(pm.model, min(0, wi_min[bi_bp[b]]) <= wi_ne[b in keys(pm.ext[:ne].branches)] <= max(0, wi_max[bi_bp[b]]), start = getstart(pm.ext[:ne].buspairs, bi_bp[b], "wi_start"))
+    wr_min, wr_max, wi_min, wi_max = compute_voltage_product_bounds(pm.ref[:ne_buspairs])
+    bi_bp = Dict([(i, (b["f_bus"], b["t_bus"])) for (i,b) in pm.ref[:ne_branch]])
+    @variable(pm.model, min(0, wr_min[bi_bp[b]]) <= wr_ne[b in keys(pm.ref[:ne_branch])] <= max(0, wr_max[bi_bp[b]]), start = getstart(pm.ref[:ne_buspairs], bi_bp[b], "wr_start", 1.0))
+    @variable(pm.model, min(0, wi_min[bi_bp[b]]) <= wi_ne[b in keys(pm.ref[:ne_branch])] <= max(0, wi_max[bi_bp[b]]), start = getstart(pm.ref[:ne_buspairs], bi_bp[b], "wi_start"))
     return wr_ne, wi_ne
 end
 

src/prob/tnep.jl

@@ -5,7 +5,7 @@
 export run_tnep
 
 function run_tnep(file, model_constructor, solver; kwargs...)
-    return run_generic_model(file, model_constructor, solver, post_tnep; data_processor = process_raw_mp_ne_data, solution_builder = get_tnep_solution, kwargs...) 
+    return run_generic_model(file, model_constructor, solver, post_tnep; solution_builder = get_tnep_solution, kwargs...) 
 end
 
 # the general form of the tnep optimization model
@@ -35,7 +35,7 @@ function post_tnep{T}(pm::GenericPowerModel{T})
         constraint_reactive_kcl_shunt_ne(pm, bus)
     end
 
-    for (i,branch) in pm.ext[:ne].branches
+    for (i,branch) in pm.ref[:ne_branch]
         constraint_active_ohms_yt_ne(pm, branch)
         constraint_reactive_ohms_yt_ne(pm, branch)