Library

calc_dual_residual!(data::Dict{String, <:Any}; central::Bool=false)

calculate the dual redidual as seen by the area. Set central=true if the algorithm uses the optimality condition of a central coordinator.

calculate the global mismatch based on local mismatch

calculate the global mismatch based on local mismatch

calc_mismatch!(data::Dict{String, <:Any}; central::Bool=false)

calculate the mismatch and return the area data dictionary with the mismatch as seen by the area. Set central=true if the algorithm uses the optimality condition of a central coordinator.

check flag convergance using mismatch and dual residual

initialize dopf parameters

print final solution status

print iteration information

print iteration information

save last solution in previous_solutions vector

solve_dopf(data::Dict{String, <:Any}, model_type::DataType, optimizer, dopf_method::Module; print_level::Int64=1, multiprocessors::Bool=false, mismatch_method::String="norm", tol::Float64=1e-4, max_iteration::Int64=1000, save_data::Vector{String}=[], kwargs...)

Solve OPF problem using fully distributed algorithm.

Arguments:

• data::Dict{String, <:Any} : dictionary contains case in PowerModel format
• model_type::DataType : power flow formulation (PowerModel type)
• optimizer : optimizer JuMP initiation object
• dopf_method::Module : module contains the distributed algorithm methods as follows:
  • initialize_method::Function : initialize the algorithm parameters and shared variables
  • update_method::Function : update the algorithm after each iteration
  • build_method::Function : problem formulation
• print_level::Int64=1 : 0 - no print, 1 - print mismatch after each iteration and result summary, 2 - print optimizer output
• multiprocessors::Bool=false : enable multiprocessors using available workers. Multiprocessors feature requires loading the PowerModelsADA and the optimizer packages on all the processors using @everywhere using <package_name>.
• mismatch_method::String="norm" : mismatch calculation method (norm, max)
• tol::Float64=1e-4 : mismatch tolerance
• max_iteration::Int64=1000 : maximum number of iteration
• savedata::Vector{String}=[] : vector contains the keys of the dictionaries to be saved at each iteration in "previoussolution". For example, savedata=["solution", "sharedvariable", "mismatch"]
• kwargs = includes algorithm-specific and initialization parameters

solve_dopf_coordinated(data::Dict{String, <:Any}, model_type::DataType, optimizer, dopf_method::Module; print_level::Int64=1, multiprocessors::Bool=false, mismatch_method::String="norm", tol::Float64=1e-4, max_iteration::Int64=1000, save_data::Vector{String}=[], kwargs...)

Solve OPF problem using distributed algorithm with central coordinator.

Arguments:

• data::Dict{String, <:Any} : dictionary contains case in PowerModel format
• model_type::DataType : power flow formulation (PowerModel type)
• optimizer : optimizer JuMP initiation object
• dopf_method::Module : module contains the distributed algorithm methods as follows:
  • initialize_method_local::Function : initialize the local algorithm parameters and shared variables
  • initialize_method_coordinator::Function : initialize the coordinator algorithm parameters and shared variables
  • update_method_local::Function : update the local data after each iteration
  • update_method_coordinator::Function : update the coordinator data after each iteration
  • build_method_local::Function : local problem formulation
  • build_method_coordinator::Function : coordinator problem formulation
• print_level::Int64=1 : 0 - no print, 1 - print mismatch after each iteration and result summary, 2 - print optimizer output
• multiprocessors::Bool=false : enable multiprocessors using available workers. Multiprocessors feature requires loading the PowerModelsADA and the optimizer packages on all the processors using @everywhere using <package_name>.
• mismatch_method::String="norm" : mismatch calculation method (norm, max)
• tol::Float64=1e-4 : mismatch tolerance
• max_iteration::Int64=1000 : maximum number of iteration
• savedata::Vector{String}=[] : vector contains the keys of the dictionaries to be saved at each iteration in "previous\solution". For example, savedata=["solution", "sharedvariable", "mismatch"]
• kwargs = includes algorithm-specific and initialization parameters

solve_dopf_coordinated_mp(data::Dict{String, <:Any}, model_type::DataType, optimizer, dopf_method::Module; print_level::Int64=1, multiprocessors::Bool=false, mismatch_method::String="norm", tol::Float64=1e-4, max_iteration::Int64=1000, save_data::Vector{String}=[], kwargs...)

Solve OPF problem using distributed algorithm with central coordinator on multiprocessors. Multiprocessors feature requires loading the PowerModelsADA and the optimizer packages on all the processors using @everywhere using <package_name>.

Arguments:

• data::Dict{String, <:Any} : dictionary contains case in PowerModel format
• model_type::DataType : power flow formulation (PowerModel type)
• optimizer : optimizer JuMP initiation object
• dopf_method::Module : module contains the distributed algorithm methods as follows:
  • initialize_method_local::Function : initialize the local algorithm parameters and shared variables
  • initialize_method_coordinator::Function : initialize the coordinator algorithm parameters and shared variables
  • update_method_local::Function : update the local data after each iteration
  • update_method_coordinator::Function : update the coordinator data after each iteration
  • build_method_local::Function : local problem formulation
  • build_method_coordinator::Function : coordinator problem formulation
• print_level::Int64=1 : 0 - no print, 1 - print mismatch after each iteration and result summary, 2 - print optimizer output
• mismatch_method::String="norm" : mismatch calculation method (norm, max)
• tol::Float64=1e-4 : mismatch tolerance
• max_iteration::Int64=1000 : maximum number of iteration
• savedata::Vector{String}=[] : vector contains the keys of the dictionaries to be saved at each iteration in "previous\solution". For example, savedata=["solution", "sharedvariable", "mismatch"]
• kwargs = includes algorithm-specific and initialization parameters

solve_dopf_coordinated_sp(data::Dict{String, <:Any}, model_type::DataType, optimizer, dopf_method::Module; print_level::Int64=1, multiprocessors::Bool=false, mismatch_method::String="norm", tol::Float64=1e-4, max_iteration::Int64=1000, save_data::Vector{String}=[], kwargs...)

Solve OPF problem using distributed algorithm with central coordinator on single-processors.

Arguments:

• data::Dict{String, <:Any} : dictionary contains case in PowerModel format
• model_type::DataType : power flow formulation (PowerModel type)
• optimizer : optimizer JuMP initiation object
• dopf_method::Module : module contains the distributed algorithm methods as follows:
  • initialize_method_local::Function : initialize the local algorithm parameters and shared variables
  • initialize_method_coordinator::Function : initialize the coordinator algorithm parameters and shared variables
  • update_method_local::Function : update the local data after each iteration
  • update_method_coordinator::Function : update the coordinator data after each iteration
  • build_method_local::Function : local problem formulation
  • build_method_coordinator::Function : coordinator problem formulation
• print_level::Int64=1 : 0 - no print, 1 - print mismatch after each iteration and result summary, 2 - print optimizer output
• mismatch_method::String="norm" : mismatch calculation method (norm, max)
• tol::Float64=1e-4 : mismatch tolerance
• max_iteration::Int64=1000 : maximum number of iteration
• savedata::Vector{String}=[] : vector contains the keys of the dictionaries to be saved at each iteration in "previous\solution". For example, savedata=["solution", "sharedvariable", "mismatch"]
• kwargs = includes algorithm-specific and initialization parameters

solve_dopf_mp(data::Dict{String, <:Any}, model_type::DataType, optimizer, dopf_method::Module; print_level::Int64=1, mismatch_method::String="norm", tol::Float64=1e-4, max_iteration::Int64=1000, save_data::Vector{String}=[], kwargs...)

Solve OPF problem using fully distributed algorithm on multiprocessors. Multiprocessors feature requires loading the PowerModelsADA and the optimizer packages on all the processors using @everywhere using <package_name>.

Arguments:

• data::Dict{Int64, <:Any} : dictionary contains area data in PowerModel format
• model_type::DataType : power flow formulation (PowerModel type)
• optimizer : optimizer JuMP initiation object
• dopf_method::Module : module contains the distributed algorithm methods as follows:
  • initialize_method::Function : initialize the algorithm parameters and shared variables
  • update_method::Function : update the algorithm after each iteration
  • build_method::Function : problem formulation
• print_level::Int64=1 : 0 - no print, 1 - print mismatch after each iteration and result summary, 2 - print optimizer output
• mismatch_method::String="norm" : mismatch calculation method (norm, max)
• tol::Float64=1e-4 : mismatch tolerance
• max_iteration::Int64=1000 : maximum number of iteration
• savedata::Vector{String}=[] : vector contains the keys of the dictionaries to be saved at each iteration in "previoussolution". For example, savedata=["solution", "sharedvariable", "mismatch"]
• kwargs = includes algorithm-specific and initialization parameters

solve_dopf_sp(data::Dict{String, <:Any}, model_type::DataType, optimizer, dopf_method::Module; print_level::Int64=1, mismatch_method::String="norm", tol::Float64=1e-4, max_iteration::Int64=1000, save_data::Vector{String}=[], kwargs...)

Solve OPF problem using fully distributed algorithm on single-processor.

Arguments:

• data::Dict{Int64, <:Any} : dictionary contains area data in PowerModel format
• model_type::DataType : power flow formulation (PowerModel type)
• optimizer : optimizer JuMP initiation object
• dopf_method::Module : module contains the distributed algorithm methods as follows:
  • initialize_method::Function : initialize the algorithm parameters and shared variables
  • update_method::Function : update the algorithm after each iteration
  • build_method::Function : problem formulation
• print_level::Int64=1 : 0 - no print, 1 - print mismatch after each iteration and result summary, 2 - print optimizer output
• mismatch_method::String="norm" : mismatch calculation method (norm, max)
• tol::Float64=1e-4 : mismatch tolerance
• max_iteration::Int64=1000 : maximum number of iteration
• savedata::Vector{String}=[] : vector contains the keys of the dictionaries to be saved at each iteration in "previoussolution". For example, savedata=["solution", "sharedvariable", "mismatch"]
• kwargs = includes algorithm-specific and initialization parameters

check the shared variables of a local area are within tol

check the flag convergence for all areas and return a global variables

update iteration

update primal variables after obtaining a solution at each iteraton

update the area data solution dictionary

add virtual generators at the neighboring buses of an area

arrange area ID from 1 to number of areas. This step is necessary when having area number 0 and using central coordinator

assign area to the system data using a matrix with [bus, area] columnsor rows

assign area to the system data using a CVS file with buses and area ID

assign area to the system data using a vector with (bus => area) pairs

assign area to the system data using a dictionary with (bus => area) integers pairs

obtain system coordinator data

decompose_system(data::Dict{String, <:Any})

decompose a system into areas defined by bus area.

obtain an area decomposition with area ID

helper function to get the area ID

helper function to get the area ID

helper functions to all areas buses in a dicrionary

helper functions to all areas buses in a dicrionary

helper function to get all areas IDs

helper function to get all areas IDs

helper function to get all areas IDs

helper functions to get the area's local buses

helper functions to get the area's local buses

helper functions to get the area's neighbor buses

helper functions to get the area's neighbor buses

helper functions to get the area's neighbor buses

helper functions to get the area's neighbor buses

get the shared buses and branches between defined area and all other areas

get the shared buses and branches between defined area and all other areas

get the shared buses and branches between defined area and all other areas

get the shared buses and branches between an area and all other areas

prepare the shared data with or without serialization

store received data in the local data dictionary

deserialize and store the received data in the local data dictionary

define OPF problem constraints

no objective function case

define objective function using PowerModels and algorithm-specific objective

define OPF problem variable

calculate distributed solution operation cost

compare the distributed algorithm solution with PowerModels centralized solution

get the communication network diameter

return JuMP variable object from PowerModel object

initial_value(variable::String, initialization_method::String="flat", value::Float64=0.0)

assign initial value based on initialization method

Arguments:

• variable::String : variable names
• initializationmethod::String="flat" : ("flat", "previoussolution", "constant")
• value::Float64=0.0 : return value if initialization_method = "constant"

initialize_all_variable(data::Dict{String, <:Any}, model_type::DataType, dics_name::String="solution", initialization_method::String="flat")

return a dictionary contains all the problem variables. can be used to store the solutions.

Arguments:

• data::Dict{String, <:Any} : area data
• model_type::DataType : power flow formulation (PowerModel type)
• dics_name::String="solution" : location of existing dicrionary to be used to worm start the output
• initialization_method::String="flat" : "flat" or "worm" initialization

initialize shared variable dictionary

identifyall the variables names

identifythe shared bus and branch variables names