src/core cleanup (#23)

* remove extra spaces, blank lines; shorten comment lines
* fix typo
* change println to warning

Author: kersulis

src/core/base.jl

@@ -1,10 +1,9 @@
 # stuff that is universal to all power models
 
-export 
+export
     GenericPowerModel,
     setdata, setsolver, solve
 
-
 type PowerDataSets
     ref_bus
     buses
@@ -26,8 +25,6 @@ abstract AbstractPowerModel
 abstract AbstractPowerFormulation
 abstract AbstractConicPowerFormulation <: AbstractPowerFormulation
 
-
-
 type GenericPowerModel{T<:AbstractPowerFormulation} <: AbstractPowerModel
     model::Model
     data::Dict{AbstractString,Any}
@@ -36,7 +33,6 @@ type GenericPowerModel{T<:AbstractPowerFormulation} <: AbstractPowerModel
     solution::Dict{AbstractString,Any}
 end
 
-
 # default generic constructor
 function GenericPowerModel{T}(data::Dict{AbstractString,Any}, vars::T; setting = Dict{AbstractString,Any}(), solver = JuMP.UnsetSolver())
     data, sets = process_raw_data(data)
@@ -52,7 +48,6 @@ function GenericPowerModel{T}(data::Dict{AbstractString,Any}, vars::T; setting =
     return pm
 end
 
-
 function process_raw_data(data::Dict{AbstractString,Any})
     make_per_unit(data)
     unify_transformer_taps(data)
@@ -64,8 +59,6 @@ function process_raw_data(data::Dict{AbstractString,Any})
     return data, sets
 end
 
-
-
 #
 # Just seems too hard to maintain with the default constructor
 #
@@ -79,7 +72,6 @@ end
 
 #end
 
-
 # TODO Ask Miles, why do we need to put JuMP. here?  using at top level should bring it in
 function JuMP.setsolver(pm::GenericPowerModel, solver::MathProgBase.AbstractMathProgSolver)
     setsolver(pm.model, solver)
@@ -97,7 +89,6 @@ function JuMP.solve(pm::GenericPowerModel)
     return status, solve_time
 end
 
-
 function run_generic_model(file, model_constructor, solver, post_method; solution_builder = get_solution, kwargs...)
     data = PowerModels.parse_file(file)
 
@@ -110,8 +101,7 @@ function run_generic_model(file, model_constructor, solver, post_method; solutio
     return build_solution(pm, status, solve_time; solution_builder = solution_builder)
 end
 
-
-function build_sets(data :: Dict{AbstractString,Any})
+function build_sets(data::Dict{AbstractString,Any})
     bus_lookup = [ Int(bus["index"]) => bus for bus in data["bus"] ]
     gen_lookup = [ Int(gen["index"]) => gen for gen in data["gen"] ]
     for gencost in data["gencost"]
@@ -120,15 +110,14 @@ function build_sets(data :: Dict{AbstractString,Any})
     end
     branch_lookup = [ Int(branch["index"]) => branch for branch in data["branch"] ]
 
-    # filter turned off stuff 
+    # filter turned off stuff
     bus_lookup = filter((i, bus) -> bus["bus_type"] != 4, bus_lookup)
     gen_lookup = filter((i, gen) -> gen["gen_status"] == 1 && gen["gen_bus"] in keys(bus_lookup), gen_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] 
+    arcs = [arcs_from; arcs_to]
 
     bus_gens = [i => [] for (i,bus) in bus_lookup]
     for (i,gen) in gen_lookup
@@ -156,16 +145,15 @@ function build_sets(data :: Dict{AbstractString,Any})
 
 
     buspair_indexes = collect(Set([(i,j) for (l,i,j) in arcs_from]))
-    buspairs = buspair_parameters(buspair_indexes, branch_lookup, bus_lookup)  
+    buspairs = buspair_parameters(buspair_indexes, branch_lookup, bus_lookup)
 
     return PowerDataSets(ref_bus, bus_lookup, bus_idxs, gen_lookup, gen_idxs, branch_lookup, branch_idxs, bus_gens, arcs_from, arcs_to, arcs, bus_branches, buspairs, buspair_indexes)
 end
 
-
 # compute bus pair level structures
 function buspair_parameters(buspair_indexes, branches, buses)
-    bp_angmin = [bp => -Inf for bp in buspair_indexes] 
-    bp_angmax = [bp =>  Inf for bp in buspair_indexes] 
+    bp_angmin = [bp => -Inf for bp in buspair_indexes]
+    bp_angmax = [bp =>  Inf for bp in buspair_indexes]
     bp_line = [bp => Inf for bp in buspair_indexes]
 
     for (l,branch) in branches
@@ -178,8 +166,8 @@ function buspair_parameters(buspair_indexes, branches, buses)
     end
 
     buspairs = [(i,j) => Dict(
-        "line"=>bp_line[(i,j)], 
-        "angmin"=>bp_angmin[(i,j)], 
+        "line"=>bp_line[(i,j)],
+        "angmin"=>bp_angmin[(i,j)],
         "angmax"=>bp_angmax[(i,j)],
         "rate_a"=>branches[bp_line[(i,j)]]["rate_a"],
         "tap"=>branches[bp_line[(i,j)]]["tap"],
@@ -191,9 +179,6 @@ function buspair_parameters(buspair_indexes, branches, buses)
     return buspairs
 end
 
-
-
-
 not_pu = Set(["rate_a","rate_b","rate_c","bs","gs","pd","qd","pg","qg","pmax","pmin","qmax","qmin"])
 not_rad = Set(["angmax","angmin","shift","va"])
 
@@ -209,7 +194,7 @@ function make_per_unit(mva_base::Number, data::Dict{AbstractString,Any})
         if k == "gencost"
             for cost_model in data[k]
                 if cost_model["model"] != 2
-                    println("WARNING: Skipping generator cost model of tpye other than 2")
+                    warn("Skipping generator cost model of type other than 2")
                     continue
                 end
                 degree = length(cost_model["cost"])
@@ -255,10 +240,8 @@ function unify_transformer_taps(data::Dict{AbstractString,Any})
     end
 end
 
-
-
 # NOTE, this function assumes all values are p.u. and angles are in radians
-function add_branch_parameters(data :: Dict{AbstractString,Any})
+function add_branch_parameters(data::Dict{AbstractString,Any})
     min_theta_delta = calc_min_phase_angle(data)
     max_theta_delta = calc_max_phase_angle(data)
 
@@ -278,7 +261,7 @@ function add_branch_parameters(data :: Dict{AbstractString,Any})
     end
 end
 
-function standardize_cost_order(data :: Dict{AbstractString,Any})
+function standardize_cost_order(data::Dict{AbstractString,Any})
     for gencost in data["gencost"]
         if gencost["model"] == 2 && length(gencost["cost"]) < 3
             println("std gen cost: ",gencost["cost"])
@@ -289,26 +272,18 @@ function standardize_cost_order(data :: Dict{AbstractString,Any})
     end
 end
 
-
-function calc_max_phase_angle(data :: Dict{AbstractString,Any})
+function calc_max_phase_angle(data::Dict{AbstractString,Any})
     bus_count = length(data["bus"])
     angle_max = [branch["angmax"] for branch in data["branch"]]
     sort!(angle_max, rev=true)
 
     return sum(angle_max[1:bus_count-1])
 end
 
-function calc_min_phase_angle(data :: Dict{AbstractString,Any})
+function calc_min_phase_angle(data::Dict{AbstractString,Any})
     bus_count = length(data["bus"])
     angle_min = [branch["angmin"] for branch in data["branch"]]
     sort!(angle_min)
 
     return sum(angle_min[1:bus_count-1])
 end
-
-
-
-
-
-
-

src/core/constraint.jl

@@ -1,8 +1,7 @@
-##########################################################################################################
-# The purpose of this file is to define commonly used and created constraints used in power flow models
+################################################################################
+# This file defines commonly used and created constraints for power flow models
 # This will hopefully make everything more compositional
-##########################################################################################################
-
+################################################################################
 
 # Generic thermal limit constraint
 function constraint_thermal_limit_from{T}(pm::GenericPowerModel{T}, branch; scale = 1.0)
@@ -86,7 +85,6 @@ function constraint_thermal_limit_to_on_off{T}(pm::GenericPowerModel{T}, branch;
     return Set([c])
 end
 
-
 function constraint_active_gen_setpoint{T}(pm::GenericPowerModel{T}, gen)
     i = gen["index"]
     pg = getvariable(pm.model, :pg)[gen["index"]]
@@ -102,7 +100,6 @@ function constraint_reactive_gen_setpoint{T}(pm::GenericPowerModel{T}, gen)
     return Set([c])
 end
 
-
 function constraint_active_loss_lb{T}(pm::GenericPowerModel{T}, branch)
     @assert branch["br_r"] >= 0
 
@@ -137,5 +134,3 @@ function constraint_reactive_loss_lb{T}(pm::GenericPowerModel{T}, branch)
     c = @constraint(m, q_fr + q_to >= -branch["br_b"]/2*(v_fr^2/branch["tap"]^2 + v_to^2))
     return Set([c])
 end
-
-

src/core/objective.jl

@@ -1,27 +1,23 @@
-##########################################################################################################
-# The purpose of this file is to define commonly used and created constraints used in power flow models
+################################################################################
+# This file is to defines commonly used constraints for power flow models
 # This will hopefully make everything more compositional
-##########################################################################################################
-
+################################################################################
 
 function objective_min_fuel_cost{T}(pm::GenericPowerModel{T})
     pg = getvariable(pm.model, :pg)
     cost = (i) -> pm.set.gens[i]["cost"]
     return @objective(pm.model, Min, sum{ cost(i)[1]*pg[i]^2 + cost(i)[2]*pg[i] + cost(i)[3], i in pm.set.gen_indexes} )
 end
 
-
 function objective_min_fuel_cost{T <: AbstractConicPowerFormulation}(pm::GenericPowerModel{T})
     @variable(pm.model, pm.set.gens[i]["pmin"]^2 <= pg_sqr[i in pm.set.gen_indexes] <= pm.set.gens[i]["pmax"]^2)
 
     pg = getvariable(pm.model, :pg)
 
     for (i, gen) in pm.set.gens
-    @constraint(pm.model, norm([2*pg[i], pg_sqr[i]-1]) <= pg_sqr[i]+1)
+        @constraint(pm.model, norm([2*pg[i], pg_sqr[i]-1]) <= pg_sqr[i]+1)
     end
 
     cost = (i) -> pm.set.gens[i]["cost"]
     return @objective(pm.model, Min, sum{ cost(i)[1]*pg_sqr[i] + cost(i)[2]*pg[i] + cost(i)[3], i in pm.set.gen_indexes} )
 end
-
-

src/core/relaxation_scheme.jl

@@ -1,17 +1,14 @@
-
-
 function relaxation_complex_product(m, a, b, c, d)
-    # TODO add LNC cuts to this 
+    # TODO add LNC cuts to this
     c = @constraint(m, c^2 + d^2 <= a*b)
     return Set([c])
 end
 
-
 function relaxation_complex_product_on_off(m, a, b, c, d, z)
-    # TODO add LNC cuts to this 
+    # TODO add LNC cuts to this
     @assert getlowerbound(c) <= 0 && getupperbound(c) >= 0
     @assert getlowerbound(d) <= 0 && getupperbound(d) >= 0
-    # assume c and d are already linked to z in other constraints 
+    # assume c and d are already linked to z in other constraints
     # and will be forced to 0 when z is 0
 
     a_ub = getupperbound(a)
@@ -24,7 +21,6 @@ function relaxation_complex_product_on_off(m, a, b, c, d, z)
     return Set([c1, c2, c3])
 end
 
-
 function relaxation_equality_on_off(m, x, y, z)
     # assumes 0 is in the domain of y when z is 0
 
@@ -37,23 +33,21 @@ function relaxation_equality_on_off(m, x, y, z)
     return Set([c1, c2])
 end
 
-
 # general relaxation of a square term
 function relaxation_sqr(m, x, y)
     c1 = @constraint(m, y >= x^2)
     c2 = @constraint(m, y <= (getupperbound(x)+getlowerbound(x))*x - getupperbound(x)*getlowerbound(x))
     return Set([c1, c2])
 end
 
-
 # general relaxation of a sin term
 function relaxation_sin(m, x, y)
     ub = getupperbound(x)
     lb = getlowerbound(x)
     @assert lb >= -pi/2 && ub <= pi/2
 
     max_ad = max(abs(lb),abs(ub))
-    
+
     if lb < 0 && ub > 0
         c1 = @constraint(m, y <= cos(max_ad/2)*(x - max_ad/2) + sin(max_ad/2))
         c2 = @constraint(m, y >= cos(max_ad/2)*(x + max_ad/2) - sin(max_ad/2))
@@ -69,21 +63,19 @@ function relaxation_sin(m, x, y)
     return Set([c1, c2])
 end
 
-
 # general relaxation of a cosine term
 function relaxation_cos(m, x, y)
     ub = getupperbound(x)
     lb = getlowerbound(x)
     @assert lb >= -pi/2 && ub <= pi/2
 
     max_ad = max(abs(lb),abs(ub))
-    
+
     c1 = @constraint(m, y <= 1 - (1-cos(max_ad))/(max_ad*max_ad)*(x^2))
     c2 = @constraint(m, y >= (cos(lb) - cos(ub))/(lb-ub)*(x - lb) + cos(lb))
     return Set([c1, c2])
 end
 
-
 # general relaxation of binlinear term (McCormick)
 function relaxation_product(m, x, y, z)
     x_ub = getupperbound(x)
@@ -98,5 +90,3 @@ function relaxation_product(m, x, y, z)
 
     return Set([c1, c2, c3, c4])
 end
-
-

src/core/solution.jl

@@ -1,4 +1,3 @@
-
 function build_solution{T}(pm::GenericPowerModel{T}, status, solve_time; objective = NaN, solution_builder = get_solution)
     # TODO assert that the model is solved
 
@@ -8,9 +7,9 @@ function build_solution{T}(pm::GenericPowerModel{T}, status, solve_time; objecti
     end
 
     solution = Dict{AbstractString,Any}(
-        "solver" => string(typeof(pm.model.solver)), 
-        "status" => status, 
-        "objective" => objective, 
+        "solver" => string(typeof(pm.model.solver)),
+        "status" => status,
+        "objective" => objective,
         "objective_lb" => guard_getobjbound(pm.model),
         "solve_time" => solve_time,
         "solution" => solution_builder(pm),
@@ -100,8 +99,6 @@ function add_setpoint{T}(sol, pm::GenericPowerModel{T}, dict_name, index_name, p
     end
 end
 
-
-
 solver_status_lookup = Dict{Any, Dict{Symbol, Symbol}}()
 
 solver_status_lookup[:Ipopt] = Dict(:Optimal => :LocalOptimal, :Infeasible => :LocalInfeasible)
@@ -110,7 +107,6 @@ solver_status_lookup[:ConicNonlinearBridge] = Dict(:Optimal => :LocalOptimal, :I
 # note that AmplNLWriter.AmplNLSolver is the solver type of bonmin
 solver_status_lookup[:AmplNLWriter] = Dict(:Optimal => :LocalOptimal, :Infeasible => :LocalInfeasible)
 
-
 # translates solver status codes to our status codes
 function solver_status_dict(solver_module_symbol, status)
     for (st, solver_stat_dict) in solver_status_lookup
@@ -132,6 +128,3 @@ function guard_getobjbound(model)
         -Inf
     end
 end
-
-
-