Variables

function variable_mc_branch_current(
	pm::AbstractExplicitNeutralIVRModel;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

For IVR models with explicit neutrals, creates total current variables :cr and :ci, series current variables :csr and :csi, and placeholder dictionaries for the terminal current flows :cr_bus and :ci_bus

function variable_mc_branch_current(
	pm::ReducedExplicitNeutralIVRModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

For branch-reduced IVR models with explicit neutrals, creates series current variables :csr and :csi, placeholder dictionaries for the total current :cr and :ci, and placeholder dictionaries for the terminal current flows :cr_bus and :ci_bus

variable: ci[l,i,j] for (l,i,j) in arcs

function variable_mc_branch_current_imaginary(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

Creates branch imaginary current variables :ci for models with explicit neutrals

variable: cr[l,i,j] for (l,i,j) in arcs

function variable_mc_branch_current_real(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

Creates branch real current variables :cr for models with explicit neutrals

variable: csi[l] for l in branch

function variable_mc_branch_current_series_imaginary(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

Creates branch imaginary series current variables :csi for models with explicit neutrals

variable: csr[l] for l in branch

function variable_mc_branch_current_series_real(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

Creates branch real series current variables :csr for models with explicit neutrals

apo models ignore reactive power flows

function variable_mc_branch_power(
	pm::AbstractExplicitNeutralACRModel;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true,
)

For ACR models with explicit neutrals, creates branch power variables :p and :q and placeholder dictionaries for the terminal power flows :p_bus and :q_bus.

branch flow variables, delegated back to PowerModels

variable_mc_branch_power(pm::FBSUBFPowerModel; nw::Int=nw_id_default, bounded::Bool=true, report::Bool=true)

Branch flow variables similar to LPUBFDiagModel

apo models ignore reactive power flows

variable: q[l,i,j] for (l,i,j) in arcs

function variable_mc_branch_power_imaginary(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

Creates branch reactive power variables :q for models with explicit neutrals

variable: p[l,i,j] for (l,i,j) in arcs

function variable_mc_branch_power_real(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

Creates branch active power variables :p for models with explicit neutrals

nothing to do, these models do not have complex voltage variables

variable_mc_bus_voltage(pm::FBSUBFPowerModel; nw::Int=nw_id_default, bounded::Bool=true, report::Bool=true)

Voltage variables are defined in rectangular coordinates similar to ACRUPowerModel. An initial operating point is specified for linearization.

variable_mc_bus_voltage(pm::FOTPUPowerModel; nw::Int=nw_id_default, bounded::Bool=true, report::Bool=true)

Voltage variables are defined in polar coordinates similar to ACPUPowerModel. An initial operating point is specified for linearization.

variable_mc_bus_voltage(pm::FOTRUPowerModel; nw::Int=nw_id_default, bounded::Bool=true, report::Bool=true)

Voltage variables are defined in rectangular coordinates similar to ACRUPowerModel. An initial operating point is specified for linearization similar to FBSUBFPowerModel.

function variable_mc_bus_voltage(
	pm::RectangularVoltageExplicitNeutralModels;
	nw=nw_id_default,
	bounded::Bool=true,
)

Creates rectangular voltage variables :vr and :vi for models with explicit neutrals

function variable_mc_bus_voltage_imaginary(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

Creates imaginary voltage variables :vr for models with explicit neutrals

Create variables for bus status

on/off voltage magnitude variable

variable: w[i] >= 0 for i in `buses

voltage variable magnitude squared (relaxed form)

Create voltage variables for branch flow model

function variable_mc_bus_voltage_real(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

Creates real voltage variables :vr for models with explicit neutrals

variable_mc_capacitor_reactive_power(pm::AbstractUnbalancedPowerModel; nw::Int=nw_id_default)

Capacitor (with capcontrol) relaxed power variables for AbstractLPUBFModel (using McCormick envelopes)

variable_mc_capacitor_switch_state(pm::AbstractUnbalancedPowerModel, relax::Bool; nw::Int=nw_id_default, report::Bool=true)

Capacitor (with capcontrol) switch state (open/close) variables

variable_mc_capcontrol(pm::AbstractLPUBFModel; nw::Int=nw_id_default, relax::Bool=false, report::Bool=true)

Capacitor switching and relaxed power variables.

nothing to do, these models do not have complex voltage variables

variable_mc_capcontrol(pm::AbstractUnbalancedPowerModel; nw::Int=nw_id_default, relax::Bool=false, report::Bool=true)

Capacitor switching variables.

Create variables for generator status

For the matrix KCL formulation, the generator needs an explicit current variable.

variable_mc_generator_current(pm::SOCUBFModels, gen_ids::Vector{Int}; nw::Int=nw_id_default, bounded::Bool=true, report::Bool=true)

For the SOC branch-flow formulation, the delta-generator needs an explicit current variable.

variable: cig[j] for j in gen

function variable_mc_generator_current_imaginary(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

Creates generator imaginary current variables :cig for models with explicit neutrals

variable: crg[j] for j in gen

function variable_mc_generator_current_real(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

Creates generator real current variables :crg for models with explicit neutrals

function variable_mc_generator_power(
	pm::AbstractExplicitNeutralACRModel;
	nw::Int=nw_id_default,
)

For ACR models with explicit neutrals, creates generator power variables :pg and :qg, and placeholder dictionaries for terminal power flows :pg_bus and :qg_bus,

function variable_mc_generator_power(
	pm::AbstractNLExplicitNeutralIVRModel; nw::Int=nw_id_default, bounded::Bool=true, report::Bool=true
)

For IVR models with explicit neutrals, no power variables are required

function variable_mc_generator_power(
	pm::AbstractQuadraticExplicitNeutralIVRModel; nw::Int=nw_id_default, bounded::Bool=true, report::Bool=true
)

For quadratic IVR models with explicit neutrals, creates generator power variables :pg and :qg

variable_mc_generator_power(pm::AbstractUBFModels; nw::Int=nw_id_default, bounded::Bool=true, report::Bool=true)

The variable creation for generators in branch flow model. Delta generators always need an auxilary power variable (X) similar to delta loads. Wye generators however, don't need any variables.

create variables for generators, delegate to PowerModels

For the matrix KCL formulation, the generator needs an explicit current and power variable.

variable_mc_generator_power(pm::SOCUBFModels; nw::Int=nw_id_default, bounded::Bool=true, report::Bool=true)

The variable creation for generators in SOC branch flow model. Delta generators always need an auxilary power variable (X) and current squared variable (CC) similar to delta loads. Wye generators however, don't need any variables.

variable_mc_generator_power_delta_aux(pm::AbstractUBFModels, gen_ids::Vector{Int}; nw::Int=nw_id_default, eps::Real=0.1, bounded::Bool=true, report::Bool=true)

Creates power matrix variable X for delta-connected generators similar to delta loads.

apo models ignore reactive power flows

function variable_mc_generator_power_imaginary(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

Creates generator reactive power variables :qg for models with explicit neutrals

apo models ignore reactive power flows

For the matrix KCL formulation, the generator needs an explicit power variable.

function variable_mc_generator_power_real(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

Creates generator active power variables :pg for models with explicit neutrals

function variable_mc_load_current(
	pm::AbstractExplicitNeutralIVRModel;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

For IVR models with explicit neutrals, creates placeholder dictionaries for the load current :crd and :cid, and for the terminal current flows :crd_bus and :cid_bus

function variable_mc_load_current(
	pm::AbstractQuadraticExplicitNeutralIVRModel; nw::Int=nw_id_default, bounded::Bool=true, report::Bool=true
)

For quadratic IVR models with explicit neutrals, creates load current variables :crd and :cid, and placeholder dictionaries for the terminal current flows :crd_bus and :cid_bus

All loads need a current variable; for wye loads, this variable will be in the wye reference frame whilst for delta currents it will be in the delta reference frame.

variable_mc_load_current(pm::FBSUBFPowerModel, load_ids::Vector{Int}; nw::Int=nw_id_default, bounded::Bool=true, report::Bool=true)

No loads require a current variable. Delta loads are zero-order approximations and wye loads are first-order approximations around the initial operating point.

function variable_mc_load_current_imaginary(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

Creates load imaginary current variables :cid for models with explicit neutrals

function variable_mc_load_current_real(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

Creates load real current variables :crd for models with explicit neutrals

Create variables for demand status

function variable_mc_load_power(
	pm::AbstractExplicitNeutralACRModel;
	nw=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

For ACR models with explicit neutrals, creates placeholder dictionaries for load power expressions :pd and :qd

function variable_mc_load_power(
	pm::AbstractNLExplicitNeutralIVRModel;
	nw=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

For non-linear IVR models with explicit neutrals, creates placeholder dictionaries for the load power :pd and :qd, and for the terminal power flows :pd_bus and :qd_bus

function variable_mc_load_power(
	pm::AbstractQuadraticExplicitNeutralIVRModel; nw::Int=nw_id_default, bounded::Bool=true, report::Bool=true
)

For quadratic IVR models with explicit neutrals, creates load power variables :pd and :qd

These variables reflect the power consumed by the load, NOT the power injected into the bus nodes; these variables only coincide for wye-connected loads with a grounded neutral.

The variable creation for the loads is rather complicated because Expressions are used wherever possible instead of explicit variables. Delta loads always need a current variable and auxilary power variable (X), and all other load model variables are then linear transformations of these (linear Expressions). Wye loads however, don't need any variables when the load is modelled as constant power or constant impedance. In all other cases (e.g. when a cone is used to constrain the power), variables need to be created.

Create a dictionary with values of type Any for the load. Depending on the load model, this can be a parameter or a NLexpression. These will be inserted into KCL.

Create a dictionary with values of type Any for the load. Depending on the load model, this can be a parameter or a NLexpression. These will be inserted into KCL.

The variable creation for the loads is rather complicated because Expressions are used wherever possible instead of explicit variables. All loads need a current variable; for wye loads, this variable will be in the wye reference frame whilst for delta currents it will be in the delta reference frame. All loads need variables for the off-diagonals of the nodal power variables. In some cases, the diagonals elements can be created as Expressions. Delta loads only need a current variable and auxilary power variable (X), and all other load model variables are then linear transformations of these (linear Expressions).

function variable_mc_load_power_active(
	pm::AbstractQuadraticExplicitNeutralIVRModel;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

Creates load active power variables :pd for models with explicit neutrals

The bus qualifier denotes that this is the power withdrawn at the bus; Only for grounded wye-connected loads, this is the same as the power consumed by the multi-phase load. The off-diagonals only need to be created for the matrix KCL formulation.

Creates power matrix variable X for delta windings; this defines both the wye-side power Sy and the delta-side power Sd through the lin. transformations Sy = X.Td, Sd = Td.X with Td=[1 -1 0; 0 1 -1; -1 0 1]

See the paper by Zhao et al. for the first convex relaxation of delta transformations. @INPROCEEDINGS{zhaooptimal2017, author={C. Zhao, E. Dall'Anese and S. Low}, booktitle={IREP 2017 Bulk Power Systems Dynamics and Control Symposium}, title={{Optimal Power Flow in Multiphase Radial Networks with Delta Connections}}, year={2017}, month={}, url={https://www.nrel.gov/docs/fy18osti/67852.pdf} }

See upcoming paper for discussion of bounds. [reference added when accepted]

variable_mc_load_power_delta_aux(pm::FBSUBFPowerModel, load_ids::Vector{Int}; nw::Int=nw_id_default, eps::Real=0.1, bounded::Bool=true, report::Bool=true)

Auxiliary variables are not required since delta loads are zero-order approximations calculated using the initial operating point.

function variable_mc_load_power_reactive(
	pm::AbstractQuadraticExplicitNeutralIVRModel;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

Creates load reactive power variables :qd for models with explicit neutrals

no voltage variables

Create tap variables.

Create variables for shunt status

generates variables for both active and reactive slack at each bus

do nothing by default but some formulations require this

do nothing by default but some formulations require this

Create variables for storage status

variables for modeling storage units, includes grid injection and internal variables

apo models ignore reactive power flows

a reactive power slack variable that enables the storage device to inject or consume reactive power at its connecting bus, subject to the injection limits of the device.

a reactive power slack variable that enables the storage device to inject or consume reactive power at its connecting bus, subject to the injection limits of the device.

apo models ignore reactive power flows

apo models ignore reactive power flows

Create variables for reactive storage injection

variable_mc_storage_power_mi(pm::AbstractUnbalancedPowerModel; nw::Int=nw_id_default, relax::Bool=false, bounded::Bool=true, report::Bool=true)

Variables for storage power (mixed-integer if relax==false)

Create variables for active and reactive storage injection

Create variables for active storage injection

function variable_mc_switch_current(
	pm::AbstractExplicitNeutralIVRModel;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true,
)

For IVR models with explicit neutrals, creates switch current variables :crs and :cis, and placeholder dictionaries for the terminal current flows :crsw_bus and :cisw_bus

function variable_mc_switch_current_imaginary(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

For models with explicit neutrals, creates switch imaginary current variables :cisw for models with explicit neutrals.

function variable_mc_switch_current_real(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

For models with explicit neutrals, creates switch real current variables :crsw for models with explicit neutrals.

function variable_mc_switch_power(
	pm::AbstractExplicitNeutralACRModel;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true,
)

For ACR models with explicit neutrals, creates switch power variables :p and :q and placeholder dictionaries for the terminal power flows :ps_bus and :qs_bus.

matrix power variables for switches

variable_mc_switch_power(pm::LPUBFDiagModel; nw::Int=nw_id_default, bounded::Bool=true, report::Bool=true)

Switch power variables.

apo models ignore reactive power flows

function variable_mc_switch_power_imaginary(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

For models with explicit neutrals, creates switch reactive power variables :qsw for models with explicit neutrals. This is defined per arc, i.e. with a variable for the from-side and to-side power.

function variable_mc_switch_power_real(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

For models with explicit neutrals, creates switch active power variables :psw for models with explicit neutrals. This is defined per arc, i.e. with a variable for the from-side and to-side power.

switch state (open/close) variables

function variable_mc_transformer_current(
	pm::AbstractExplicitNeutralIVRModel;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true,
)

For IVR models with explicit neutrals, create transformer current variables :crt and :cit, and placeholder dictionaries for the terminal current flows :crt_bus and :cit_bus

variable: ci[l,i,j] for (l,i,j) in arcs

function variable_mc_transformer_current_imaginary(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

Creates transformer imaginary current variables :cit for models with explicit neutrals

variable: cr[l,i,j] for (l,i,j) in arcs

function variable_mc_transformer_current_real(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

Creates transformer real current variables :crt for models with explicit neutrals

function variable_mc_transformer_power(
	pm::AbstractExplicitNeutralACRModel;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true,
)

For ACR models with explicit neutrals, creates transfomer power variables :pt and :qt, and placeholder dictionaries for transformer terminal power flows :pt_bus and :qt_bus

function variable_mc_transformer_power(
	pm::AbstractNLExplicitNeutralIVRModel;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true,
)

For non-linear IVR models with explicit neutrals, no power variables are required.

function variable_mc_transformer_power(
	pm::AbstractQuadraticExplicitNeutralIVRModel;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true,
)

For quadratic IVR models with explicit neutrals, creates transformer power variables :pt and :qt

defines matrix transformer power variables for the unbalanced branch flow models

Creates variables for both active and reactive power flow at each transformer.

Creates variables for both active and reactive power flow at each transformer.

Creates variables for both active and reactive power flow at each transformer.

apo models ignore reactive power flows

Create variables for the reactive power flowing into all transformer windings.

function variable_mc_transformer_power_imaginary(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

Creates transformer reactive power variables :qt for models with explicit neutrals

Create variables for the active power flowing into all transformer windings.

function variable_mc_transformer_power_real(
	pm::ExplicitNeutralModels;
	nw::Int=nw_id_default,
	bounded::Bool=true,
	report::Bool=true
)

Creates transformer active power variables :pt for models with explicit neutrals

variable_mx_complex(
    model::JuMP.Model,
    indices::Array{T,1},
    N::Dict{T,Vector{Int}},
    M::Dict{T,Vector{Int}};
    upper_bound::Union{Missing, Dict{T,<:Matrix{<:Real}}}=missing,
    lower_bound::Union{Missing, Dict{T,<:Matrix{<:Real}}}=missing,
    symm_bound::Union{Missing, Dict{T,<:Matrix{<:Real}}}=missing,
    name::Union{String, Tuple{String,String}}="",
    prefix::String=""
)::Tuple where T

Shorthand to create two real matrix variables, where the first is the real part and the second the imaginary part.

If the name argument is a String, it will be suffixed with 're' and 'im'. It is possible to specify the names of the real and imaginary part directly as a Tuple as well (to achieve P and Q instead of Sre and Sim for example).

variable_mx_complex_with_diag(
    model::JuMP.Model,
    indices::Array{T,1},
    N::Dict{T,Vector{Int}};
    upper_bound::Union{Missing, Dict{T,<:Matrix{<:Real}}}=missing,
    lower_bound::Union{Missing, Dict{T,<:Matrix{<:Real}}}=missing,
    symm_bound::Union{Missing, Dict{T,<:Matrix{<:Real}}}=missing,
    diag_re::Dict{T,<:Vector{<:Any}}=Dict([(i, zeros(length(N[i]))) for i in indices]),
    diag_im::Dict{T,<:Vector{<:Any}}=Dict([(i, zeros(length(N[i]))) for i in indices]),
    name::Union{String, Tuple{String,String}}="",
    prefix::String=""
)::Tuple where T

Same as variable_mx_complex, but square and the diagonal of the matrix variables consists of the constants passed as the diagre and diagim argument. The diag argument is a dictionary of (index, 1d-array) pairs.

Useful for power matrices with specified diagonals (constant power wye loads).

variable_mx_hermitian(
    model::JuMP.Model,
    indices::Array{T,1},
    N::Dict{T,Vector{Int}};
    upper_bound::Union{Missing, Dict{T,<:Matrix{<:Real}}}=missing,
    lower_bound::Union{Missing, Dict{T,<:Matrix{<:Real}}}=missing,
    symm_bound::Union{Missing, Dict{T,<:Matrix{<:Real}}}=missing,
    sqrt_upper_bound::Union{Missing, Dict{T,<:Vector{<:Real}}}=missing,
    sqrt_lower_bound::Union{Missing, Dict{T,<:Vector{<:Real}}}=missing,
    set_lower_bound_diag_to_zero::Bool=false,
    imag_set_diag_to_zero::Bool=true,
    name::Union{String,Tuple{String,String}}="",
    prefix::String=""
)::Tuple where T

Returns a pair of symmetric and skew-symmetric matrix variables.

variable_mx_real(
    model::JuMP.Model,
    indices::Array{T,1},
    N::Dict{T,Vector{Int}},
    M::Dict{T,Vector{Int}};
    upper_bound::Union{Missing, Dict{T,<:Matrix{<:Real}}}=missing,
    lower_bound::Union{Missing, Dict{T,<:Matrix{<:Real}}}=missing,
    name::String="",
    prefix::String=""
) where T

This function creates a set of real matrix variables of size NxM, indexed over the elements of the indices argument. The upper and lower bounds have to be specified, and are dictionaries with the indices as keys and the matrix bounds as values. The name and prefix arguments will be combined into the base_name argument for JuMP; the prefix will typically be the network number nw. Instead of sequentially creating the matrix variables, the elements of the matrices are created sequentially for all matrices at once. I.e., we loop over the elements, and not over the indices. This is needed so that the variable names printed by JuMP are in line with the current design.

Returns a dictionary of (index, matrix variable) pairs

variable_mx_real_skewsymmetric(
    model::JuMP.Model,
    indices::Array{T,1},
    N::Dict{T,Vector{Int}};
    upper_bound::Union{Missing, Dict{T,<:Matrix{<:Real}}}=missing,
    lower_bound::Union{Missing, Dict{T,<:Matrix{<:Real}}}=missing,
    set_diag_to_zero::Bool=true,
    name::String="",
    prefix::String=""
)::Dict where T

Same as variable_mx_real, but adds skew-symmetry structure.

variable_mx_real_symmetric(
    model::JuMP.Model,
    indices::Array{T,1},
    N::Dict{T,Vector{Int}};
    upper_bound::Union{Missing, Dict{T,<:Matrix{<:Real}}}=missing,
    lower_bound::Union{Missing, Dict{T,<:Matrix{<:Real}}}=missing,
    name::String="",
    prefix::String=""
)::Dict where T

Same as variable_mx_real, but adds symmetry structure

variable_mx_real_with_diag(
    model::JuMP.Model,
    indices::Array{T,1},
    N::Dict{T,Vector{Int}};
    upper_bound::Union{Missing, Dict{T,<:Matrix{<:Real}}}=missing,
    lower_bound::Union{Missing, Dict{T,<:Matrix{<:Real}}}=missing,
    diag::Dict{T,<:Vector{<:Any}}=Dict([(i, fill(0, length(N[i]))) for i in indices]),
    name::String="",
    prefix::String=""
) where T

Same as variable_mx_real, but has to be square and the diagonal of the matrix variables consists of the elements passed as the diag argument. The diag argument is a dictionary of (index, 1d-array) pairs. Useful for power matrices with specified diagonals (constant power wye loads). If not specified, the diagonal elements are set to zero.