PowerModelsDistribution.jl Library

Collection of Unbalanced Branch Flow Models

Collection of Second Order Cone Models

items that are mapped one-to-one from engineering to math models

different acceptable delimiters for arrays

field names that should become multi-conductor matrix not arrays

field names that should not be multi-conductor values

lists of scaling factors and what they apply to

two number operators for reverse polish notation

dss to pmd load model

all objects that define controls

all data holding objects

all edge types that can help define buses

all objects that provide montoring

all node types that can help define buses

Returns a Dict{String,Type} for the desired component comp, giving all of the expected data types

components currently supported for automatic data type parsing

Regexes for determining data types

list of edge type elements in the engineering model

data check functions for the engineering data model

Data types of accepted fields in the engineering data model

required fields in the engineering data model

list of nodal type elements in the engineering model

properties that should be excluded from being overwritten during the application of like

list of edge type elements in the engineering model

list of nodal type elements in the engineering model

list of multinetwork keys that belong at the root level

single number operators in reverse polish notation

Base Abstract Conic Unbalanced Branch Flow Model

Abstract form for linear unbalanced power flow models

Base Abstract NLP Unbalanced Branch Flow Model

Configurations

Generator, Solar, Storage, Wind Control Modes

Supported data model types

Dispatchable

Collection of Semidefinite Models

LinDist3Flow per Arnold et al. (2016), using vector variables for power, voltage and current

D. B. Arnold, M. Sankur, R. Dobbe, K. Brady, D. S. Callaway and A. Von Meier, "Optimal dispatch of reactive power for voltage regulation and balancing in unbalanced distribution systems," 2016 IEEE Power and Energy Society General Meeting (PESGM), Boston, MA, 2016, pp. 1-5, doi: 10.1109/PESGM.2016.7741261.

default LP unbalanced DistFlow constructor

Load Models

SDP BFM with KCL as matrix equation, Geth 2020 (under review)

default SDP unbalanced DistFlow with matrix KCL constructor

SDP BFM per Gan and Low 2014, PSCC

default SDP unbalanced DistFlow constructor

SOC relaxation of SDPUBFModel per Kim, Kojima, & Yamashita 2003, cast as a SOC

default SOC unbalanced DistFlow constructor

SOC relaxation of SDPUBFModel per Kim, Kojima, & Yamashita 2003, cast as an QCP

default SOC unbalanced DistFlow constructor

Shunt Models

Status

Switch States

custom handling for enums output to json

custom handling for enums output to json

turns a matrix into a serializable structure

overwrites PowerModels buspairs ref by conductor

Instantiates a PowerModelsDistribution data model

Adds a component of type obj_type_name with properties given by object to the existing data_dss structure. If a component of the same type has already been added to data_dss, the new component is appeneded to the existing array of components of that type, otherwise a new array is created.

add engineering data object to engineering data model

convert cost model names

Adds a property to an existing component properties dictionary object given the key and value of the property. If a property of the same name already exists inside object, the original value is converted to an array, and the new value is appended to the end.

adds kwargs that were specified but unused by the required defaults to the component

Filters out values of a vector or matrix for certain properties (transformer winding variant)

Filters out values of a vector or matrix for certain properties

applies like to component

applies a linecode to a line in preparation for converting to mathematical model

apply properties in the order that they are given

applies a xfmrcode to a transformer in preparation for converting to mathematical model

Assigns a property with name property_name and value property_value to the component of type obj_type named obj_name in data_dss.

Combines transformers with 'bank' keyword into a single transformer

shifts a vector by shift spots to the left

Builds a Multinetwork

loss model builder for transformer decomposition

Constructor for Optimal Power Balance

constructor for OSW in current-voltage variable space

Constructor for Optimal Switching

constructor for branch flow osw

Constructor for Optimal Switching

constructor for mixed-integer branch flow osw

helper function to properly reference time series variables from opendss

Returns a total (shunt+series) current magnitude bound for the from and to side of a branch. The total power rating also implies a current bound through the lower bound on the voltage magnitude of the connected buses.

Returns a total (shunt+series) current magnitude bound for the from and to side of a branch. The total power rating also implies a current bound through the lower bound on the voltage magnitude of the connected buses.

Returns a total (shunt+series) power magnitude bound for the from and to side of a branch. The total current rating also implies a current bound through the upper bound on the voltage magnitude of the connected buses.

Returns a total (shunt+series) power magnitude bound for the from and to side of a branch. The total current rating also implies a current bound through the upper bound on the voltage magnitude of the connected buses.

Returns a valid series current magnitude bound for a branch.

Returns bounds in line-to-line bounds on the voltage magnitude. If these are not part of the problem specification, then a valid upper bound is implied by the line-to-neutral bounds, but a lower bound (greater than zero) is not. Therefore, a default lower bound is then used, specified by the keyword argument vdmin_eps. The returned bounds are for the pairs 1->2, 2->3, 3->1

Returns a current magnitude bound for the generators.

Given a set of terminals 'cnds' with associated shunt addmittance 'Y', this method will calculate the reduced addmittance matrix if terminal 'ground' is grounded.

Returns magnitude bounds for the current going through the load.

Returns a magnitude bound for the current going through the load.

Calculates lower and upper bounds for the loads themselves (not the power withdrawn at the bus).

Returns the voltage magnitude bounds for the individual load elements in a multiphase load. These are inferred from vmin/vmax for wye loads and from calcbusvmll_bounds for delta loads.

Given a set of addmittances 'y' connected from the conductors 'fcnds' to the conductors 'tcnds', this method will return a list of conductors 'cnd' and a matrix 'Y', which will satisfy I[cnds] = Y*V[cnds].

Returns a current magnitude bound for the from and to side of a transformer. The total power rating also implies a current bound through the lower bound on the voltage magnitude of the connected buses.

Returns a power magnitude bound for the from and to side of a transformer. The total current rating also implies a current bound through the upper bound on the voltage magnitude of the connected buses.

bus data checks

checks bus_name exists and has terminals

checks the connection configuration and infers the dimensions of the connection (number of connected terminals)

checks connectivity of object

checks that an engineering model component has the correct data types

checks if data structures are equivalent, and if not, will enumerate the differences

generator data checks

checks that a component has fields

check that fields has size data_size

line data checks

linecode data checks

load data checks

Returns a Bool, indicating whether the convex hull of the voltage-dependent relationship needs a cone inclusion constraint.

check that all data in fields have the same size

shunt data checks

shunt capacitor data checks

Transformer, n-windings three-phase lossy data checks

voltage source data checks

cleans up array properties back into strings for later conversion

lossy grounding to perfect grounding and shunts

Creates a Dict{String,Any} containing all of the expected properties for a Capacitor. If bus2 is not specified, the capacitor will be treated as a shunt. See OpenDSS documentation for valid fields and ways to specify the different properties.

alias createcircuit to createvsource

Creates a Dict{String,Any} containing all of the expected properties for a Generator. See OpenDSS documentation for valid fields and ways to specify the different properties.

Creates a Dict{String,Any} containing all of the properties for a Line. See OpenDSS documentation for valid fields and ways to specify the different properties.

Creates a Dict{String,Any} containing all of the properties of a Linecode. See OpenDSS documentation for valid fields and ways to specify the different properties.

Creates a Dict{String,Any} containing all of the expected properties for a Load. See OpenDSS documentation for valid fields and ways to specify the different properties.

Creates a Dict{String,Any} containing all expected properties for a LoadShape element. See OpenDSS documentation for valid fields and ways to specify different properties.

Creates a Dict{String,Any} containing all of the expected properties for a PVSystem. See OpenDSS document https://github.com/tshort/OpenDSS/blob/master/Doc/OpenDSS%20PVSystem%20Model.doc for valid fields and ways to specify the different properties.

Creates a Dict{String,Any} containing all of the expected properties for a Reactor. If bus2 is not specified Reactor is treated like a shunt. See OpenDSS documentation for valid fields and ways to specify the different properties.

Creates a Dict{String,Any} containing all expected properties for a Spectrum object. See OpenDSS documentation for valid fields and ways to specify different properties.

Creates a Dict{String,Any} containing all expected properties for a storage element. See OpenDSS documentation for valid fields and ways to specify the different properties.

Creates a Dict{String,Any} containing all of the expected properties for a Transformer. See OpenDSS documentation for valid fields and ways to specify the different properties.

Creates a Dict{String,Any} containing all of the expected properties for a Voltage Source. If bus2 is not specified, VSource will be treated like a generator. Mostly used as source which represents the circuit. See OpenDSS documentation for valid fields and ways to specify the different properties.

Transformer codes contain all of the same properties as a transformer except bus, buses, bank, xfmrcode

Creates a Dict{String,Any} containing all expected properties for a XYCurve object. See OpenDSS documentation for valid fields and ways to specify different properties.

Discovers all of the buses (not separately defined in OpenDSS), from "lines"

discovers all phases and neutrals in the network

discovers all terminals in the network

Adds nodes as buses to data_eng from data_dss

Parses buscoords lon,lat into their respective buses

Adds capacitors to data_eng from data_dss

Adds generators to data_eng from data_dss

Adds lines to data_eng from data_dss

Adds lines to data_eng from data_dss

Adds loads to data_eng from data_dss

Constant can still be scaled by other settings, fixed cannot Note that in the current feature set, fixed therefore equals constant

1: Constant P and Q, default 2: Constant Z 3: Constant P and quadratic Q 4: Exponential 5: Constant I 6: Constant P and fixed Q

7: Constant P and quadratic Q (i.e., fixed reactance)

8: ZIP

Adds loadshapes to data_eng from data_dss

Adds pvsystems to data_eng from data_dss

Adds shunt reactors to data_eng from data_dss

Adds storage to data_eng from data_dss

Adds transformers to data_eng from data_dss

Adds vsources to data_eng from data_dss

Adds transformers to data_eng from data_dss

Discovers all neutrals in the network

finds maximal set of ungrounded phases

Returns an ordered list of defined conductors. If ground=false, will omit any 0

creates a delta transformation matrix

gets the grounding information for a bus

get a grounded terminal from a bus; if not present, create one

Given a vector and a list of elements to find, this method will return a list of the positions of the elements in that vector.

get locations of terminal in connections list

returns component from the mathematical data model

getground helper function

guesses the data type of a value using regex, returning Float64, Int, ComplexF64, or String (if number type cannot be determined)

creates a dss dict inside object that imports all items in prop_order from dss_obj

initializes the base components that are expected by powermodelsdistribution in the mathematical model

Initializes the lookup table

initializes the base math object of any type, and copies any one-to-one mappings

initializes a time_series data structure in the InfrastructureModels style

initialization actions for unmapping

checks to see if property1 is after property2 in the prop_order

checks to see if a property is after linecode

checks to see if a property is after xfmrcode

checks if loadshape has both pmult and qmult

checks if data is an opendss-style array string

checks is a string is a connection by checking the values

checks if data is an opendss-style matrix string

detects if expr is Reverse Polish Notation expression

converts julia Version into serializable structure

performs kron reduction on branch

performs kron reduction on branch - helper function

transformations might have introduced buses with four-terminals; crop here

Returns the exponential load model parameters for a load. For an exponential load it simply returns certain data model properties, whilst for constantpower, constantcurrent and constant_impedance it returns the equivalent exponential model parameters.

converts to per unit from SI

Sometimes we want to bound only a subset of the elements of a matrix variable. For example, an unbounded Hermitian variable usually still has a lower bound of zero on the real diagonal elements. When there is a mix of bounded and unbounded elements, the unboundedness is encoded as 'Inf' and '-Inf' in the bound parameters. This cannot be passed directlty to JuMP, because it would lead to an error in Mosek for example. Instead, this method checks whether all bounds for an element (n,m) are Inf, and if so, does not pass a bound to JuMP.

base function for converting engineering model to mathematical model

converts engineering bus components into mathematical bus components

converts engineering generators into mathematical generators

converts engineering lines into mathematical branches

converts engineering load components into mathematical load components

converts a engineering multinetwork to a math multinetwork

converts engineering generic shunt components into mathematical shunt components

converts engineering solar components into mathematical generators

converts engineering storage into mathematical storage

converts engineering switches into mathematical switches and (if neeed) impedance branches to represent loss model

converts engineering n-winding transformers into mathematical ideal 2-winding lossless transformer branches and impedance branches to represent the loss model

converts engineering voltage sources into mathematical generators and (if needed) impedance branches to represent the loss model

Merges two (partially) parsed OpenDSS files to the same dictionary dss_prime. Used in cases where files are referenced via the "compile" or "redirect" OpenDSS commands inside the originating file.

Multiconductor adaptation of min fuel cost polynomial linquad objective

gen connections adaptation of min fuel cost polynomial linquad objective

Multiconductor adaptation of min fuel cost polynomial linquad objective

gen connections adaptation of min fuel cost polynomial linquad objective

adds conductors to connections during padding process, transformer winding variant

adds conductors to connections during padding process

pads properties to have the total number of conductors for the whole system (transformer winding variant)

pads properties to have the total number of conductors for the whole system

pads properties to have the total number of conductors for the whole system - delta connection variant

pads properties to have the total number of conductors for the whole system - delta connection variant

Parses a OpenDSS style array string data into a one dimensional array of type dtype. Array strings are capped by either brackets, single quotes, or double quotes, and elements are separated by spaces.

parses sng and dbl precision loadshape binary files

Parses busnames as defined in OpenDSS, e.g. "primary.1.2.3.0"

Parses a Bus Coordinate file, in either "dat" or "csv" formats, where in "dat", columns are separated by spaces, and in "csv" by commas. File expected to contain "bus,x,y" on each line.

Parses a component with properties into a object. If object is not defined, an empty dictionary will be used. Assumes that unnamed properties are given in order, but named properties can be given anywhere.

parses connection "conn" specification reducing to wye or delta

parses single column load profile files

parses csv or binary loadshape files

converts dss load model to supported PowerModelsDistribution LoadModel enum

Parses the data in keys defined by to_parse in data_dss using types given by the default properties from the get_prop_default function.

parses the raw dss values into their expected data types

parses enums from json

Parses an already separated line given by elements (an array) of an OpenDSS file into current_obj. If not defined, current_obj is an empty dictionary.

parses loadshape component

Parses a OpenDSS style triangular matrix string data into a two dimensional array of type dtype. Matrix strings are capped by either parenthesis or brackets, rows are separated by "|", and columns are separated by spaces.

parses in a serialized matrix

parser function for serialized matrices

recursive helper function for parsing serialized matrices

parses pmult and qmult entries on loadshapes

parses data type of properties of objects

Parses a string of properties of a component type, character by character into an array with each element containing (if present) the property name, "=", and the property value.

parses Reverse Polish Notation expr

parses the setbusxy command

parse spectrum component

parse xycurve component

per-unit conversion for branches

per-unit conversion for buses

per-unit conversion for generators

per-unit conversion for loads

per-unit conversion for shunts

per-unit conversion for storage

per-unit conversion for switches

per-unit conversion for ideal 2-winding transformers

Replaces NaN values with zeros

rolls a 1d array left or right by idx

depreciation warning for runmcmnopb

depreciation warning for runmc_osw

depreciation warning for runmcoswmi

Converts a set of short-circuit tests to an equivalent reactance network. Reference: R. C. Dugan, “A perspective on transformer modeling for distribution system analysis,” in 2003 IEEE Power Engineering Society General Meeting (IEEE Cat. No.03CH37491), 2003, vol. 1, pp. 114-119 Vol. 1.

function for applying a scale to a paramter

helper function to apply a scale factor to given properties

slices branches based on connected terminals

Solve optimal switching problem

Solve mixed-integer optimal switching problem

solve test mn mc problem

Strips comments, defined by "!" from the ends of lines

strips lines that are either commented (block or single) or empty

converts Dict{String,Any} to Dict{Symbol,Any} for passing as kwargs

https://stackoverflow.com/questions/39039553/lower-triangular-matrix-in-julia

wraps angles in degrees to 180

wraps angles in radians to pi

Generic add function to add components to an engineering data model

Function to add default vbase for a bus

kron reduction

pad matrices to max number of conductors

phase projection for components where unprojected states are not yet supported

add voltage bounds

Load shedding problem including storage (snap-shot)

Load shedding problem for Branch Flow model

Load shedding problem for Branch Flow model

Standard unit commitment (!relaxed) load shedding problem

constructor for OPF in current-voltage variable space

Constructor for Optimal Power Flow

constructor for branch flow opf

constructor for on-load tap-changer OPF

OPF problem with slack power at every bus

Constructor for Power Flow in current-voltage variable space

Constructor for Power Flow Problem

Constructor for Branch Flow Power Flow

PF problem with slack power at every bus

Multinetwork load shedding problem including storage

Multinetwork load shedding problem for Branch Flow model

Multinetwork current-voltage optimal power flow problem

Multinetwork optimal power flow problem

Multinetwork branch flow optimal power flow problem

calculates voltage bases for each voltage zone

Calculates the tap scale factor for the non-dimensionalized equations.

checks the engineering data model for correct data types, required fields and applies default checks

For rectangular coordinates of a complex matrix M=Mre+im*Mim, this function applies constraints equivalent to requiring that M itself is PSD.

Take a multi-conductor voltage variable V and a current variable I. The associated power is then defined as S = VI^H Define the lifted variables as W and L as W = VV^H, L = I*I^H Then, it is equally valid that [W S; S^H L] ∈ PSDCone, rank([W S; S^H L])=1 This function adds this PSD constraint for the rectangular coordinates of S, W and L.

Impose all balance related constraints for which key present in data model of bus. For a discussion of sequence components and voltage unbalance factor (VUF), see @INPROCEEDINGS{girigoudarmolzahnroald-2019, author={K. Girigoudar and D. K. Molzahn and L. A. Roald}, booktitle={submitted}, title={{Analytical and Empirical Comparisons of Voltage Unbalance Definitions}}, year={2019}, month={}, url={https://molzahn.github.io/pubs/girigoudarmolzahnroald-2019.pdf} }

Defines voltage drop over a branch, linking from and to side complex voltage

a = exp(im2π/3) U+ = (1Ua + aUb a^2Uc)/3 U- = (1Ua + a^2Ub aUc)/3 vuf = |U-|/|U+| |U-| <= vufmax|U+| |U-|^2 <= vufmax^2*|U+|^2

on/off bus voltage magnitude constraint

on/off bus voltage magnitude constraint

on/off voltage magnitude constraint

a = exp(im2π/3) U+ = (1Ua + aUb a^2Uc)/3 U- = (1Ua + a^2Ub aUc)/3 vuf = |U-|/|U+| |U-| <= vufmax|U+| |U-|^2 <= vufmax^2*|U+|^2

on/off bus voltage magnitude squared constraint for relaxed formulations

on/off voltage magnitude squared constraint for relaxed formulations

a = exp(im2π/3) U+ = (1Ua + aUb a^2Uc)/3 U- = (1Ua + a^2Ub aUc)/3 vuf = |U-|/|U+| |U-| <= vufmax|U+| |U-|^2 <= vufmax^2*|U+|^2

a = exp(im2π/3) U+ = (1Ua + aUb a^2Uc)/3 U- = (1Ua + a^2Ub aUc)/3 vuf = |U-|/|U+| |U-| <= vufmax|U+| |U-|^2 <= vufmax^2*|U+|^2

bus voltage on/off constraint for load shed problem

bus voltage on/off constraint for load shed problem

on/off bus voltage constraint for DCP formulation, nothing to do

on/off constraint for bus voltages

on/off bus voltage constraint for relaxed forms

Kirchhoff's current law applied to buses sum(cr + im*ci) = 0

Defines how current distributes over series and shunt impedances of a pi-model branch

Bounds the current magnitude at both from and to side of a branch cr[f_idx]^2 + ci[f_idx]^2 <= c_rating_a^2 cr[t_idx]^2 + ci[t_idx]^2 <= c_rating_a^2

Defines how current distributes over series and shunt impedances of a pi-model branch

pmin <= Re(v*cg') <= pmax

defines limits on active power output of a generator where bounds can't be used

on/off constraint for generators

on/off constraint for generators

pg[i] == pg

generator active power setpoint constraint

qmin <= Im(v*cg') <= qmax

defines limits on reactive power output of a generator where bounds can't be used

Only support wye-connected generators.

DELTA When connected in delta, the load power gives the reference in the delta reference frame. This means sd1 = vab.conj(iab) = (va-vb).conj(iab) We can relate this to the per-phase power by sna = va.conj(ia) = va.conj(iab-ica) = va.conj(conj(sab/vab) - conj(sca/vca)) = va.(sab/(va-vb) - sca/(vc-va)) So for delta, sn is constrained indirectly.

Link the current and power withdrawn by a generator at the bus through a PSD constraint. The rank-1 constraint is dropped in this formulation.

delta connected generator setpoint constraint for IVR formulation

wye connected generator setpoint constraint for IVR formulation

We want to express sab = cp.|vab|+im.cq.|vab| iab = conj(sab/vab) = |vab|.(cq-im.cq)/conj(vab) = (1/|vab|).(cp-im.cq)*vab idem for ibc and ica And then sa = va.conj(ia) = va.conj(iab-ica) idem for sb and sc

Only support wye-connected, constant-power loads.

CONSTANT POWER Fixes the load power sd. sd = [sd1, sd2, sd3] What is actually fixed, depends on whether the load is connected in delta or wye. When connected in wye, the load power equals the per-phase power sn drawn at the bus to which the load is connected. sd1 = va.conj(ia) = sn_a

CONSTANT CURRENT Sets the active and reactive load power sd to be proportional to the the voltage magnitude. pd = cp.|vm| qd = cq.|vm| sd = cp.|vm| + j.cq.|vm|

CONSTANT IMPEDANCE Sets the active and reactive power drawn by the load to be proportional to the square of the voltage magnitude. pd = cp.|vm|^2 qd = cq.|vm|^2 sd = cp.|vm|^2 + j.cq.|vm|^2

DELTA When connected in delta, the load power gives the reference in the delta reference frame. This means sd1 = vab.conj(iab) = (va-vb).conj(iab) We can relate this to the per-phase power by sna = va.conj(ia) = va.conj(iab-ica) = va.conj(conj(sab/vab) - conj(sca/vca)) = va.(sab/(va-vb) - sca/(vc-va)) So for delta, sn is constrained indirectly.

Creates the constraints modelling the (relaxed) voltage-dependent loads for the matrix KCL formulation.

Creates the constraints modelling the (relaxed) voltage-dependent loads.

delta connected load setpoint constraint for IVR formulation

wye connected load setpoint constraint for IVR formulation

Defines relationship between branch (series) power flow, branch (series) current and node voltage magnitude

Defines relationship between branch (series) power flow, branch (series) current and node voltage magnitude

Defines relationship between branch (series) power flow, branch (series) current and node voltage magnitude

Defines relationship between branch (series) power flow, branch (series) current and node voltage magnitude

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

do nothing by default

Defines voltage drop over a branch, linking from and to side voltage

Defines voltage drop over a branch, linking from and to side voltage

ensures that power generation and demand are balanced

nothing to do, no voltage angle variables

Creates Ohms constraints (yt post fix indicates that Y and T values are in rectangular form)

p_fr ==     g[c,c] * vm_fr[c]^2 +
            sum( g[c,d]*vm_fr[c]*vm_fr[d]*cos(va_fr[c]-va_fr[d]) +
                 b[c,d]*vm_fr[c]*vm_fr[d]*sin(va_fr[c]-va_fr[d]) for d in conductor_ids(pm) if d != c) +
            sum(-g[c,d]*vm_fr[c]*vm_to[d]*cos(va_fr[c]-va_to[d]) +
                -b[c,d]*vm_fr[c]*vm_to[d]*sin(va_fr[c]-va_to[d]) for d in conductor_ids(pm))
            + g_fr[c,c] * vm_fr[c]^2 +
            sum( g_fr[c,d]*vm_fr[c]*vm_fr[d]*cos(va_fr[c]-va_fr[d]) +
                 b_fr[c,d]*vm_fr[c]*vm_fr[d]*sin(va_fr[c]-va_fr[d]) for d in conductor_ids(pm) if d != c)
            )
q_fr == -b[c,c] *vm_fr[c]^2 -
            sum( b[c,d]*vm_fr[c]*vm_fr[d]*cos(va_fr[c]-va_fr[d]) -
                 g[c,d]*vm_fr[c]*vm_fr[d]*sin(va_fr[c]-va_fr[d]) for d in conductor_ids(pm) if d != c) -
            sum(-b[c,d]*vm_fr[c]*vm_to[d]*cos(va_fr[c]-va_to[d]) +
                 g[c,d]*vm_fr[c]*vm_to[d]*sin(va_fr[c]-va_to[d]) for d in conductor_ids(pm))
            -b_fr[c,c] *vm_fr[c]^2 -
            sum( b_fr[c,d]*vm_fr[c]*vm_fr[d]*cos(va_fr[c]-va_fr[d]) -
                 g_fr[c,d]*vm_fr[c]*vm_fr[d]*sin(va_fr[c]-va_fr[d]) for d in conductor_ids(pm) if d != c)
            )

Creates Ohms constraints

sfr = vfr.conj(Y(vfr-vto)) sfr = (vrfr+imvi_fr).(G-imB)([vrfr-vrto]-im[vifr-vito]) sfr = (vrfr+imvifr).([Gvrfr-Gvr_to-Bvifr+B*vito]-im[Gvifr-G*vito+Bvr_fr-Bvr_to])

Creates Ohms constraints (yt post fix indicates that Y and T values are in rectangular form)

p[f_idx] == -b*(t[f_bus] - t[t_bus])

ohms constraint for branches on the from-side

delegate back to PowerModels

nothing to do, this model is symmetric

Creates Ohms constraints (yt post fix indicates that Y and T values are in rectangular form)

p[t_idx] ==  (g+g_to)*v[t_bus]^2 + (-g*tr-b*ti)/tm*(v[t_bus]*v[f_bus]*cos(t[t_bus]-t[f_bus])) + (-b*tr+g*ti)/tm*(v[t_bus]*v[f_bus]*sin(t[t_bus]-t[f_bus]))
q[t_idx] == -(b+b_to)*v[t_bus]^2 - (-b*tr+g*ti)/tm*(v[t_bus]*v[f_bus]*cos(t[f_bus]-t[t_bus])) + (-g*tr-b*ti)/tm*(v[t_bus]*v[f_bus]*sin(t[t_bus]-t[f_bus]))

Creates Ohms constraints (yt post fix indicates that Y and T values are in rectangular form)

p[t_idx] ==  (g+g_to)*v[t_bus]^2 + (-g*tr-b*ti)/tm*(v[t_bus]*v[f_bus]*cos(t[t_bus]-t[f_bus])) + (-b*tr+g*ti)/tm*(v[t_bus]*v[f_bus]*sin(t[t_bus]-t[f_bus]))
q[t_idx] == -(b+b_to)*v[t_bus]^2 - (-b*tr+g*ti)/tm*(v[t_bus]*v[f_bus]*cos(t[f_bus]-t[t_bus])) + (-g*tr-b*ti)/tm*(v[t_bus]*v[f_bus]*sin(t[t_bus]-t[f_bus]))

ohms constraint for branches on the to-side

delegate back to PowerModels

Do nothing, this model is symmetric

For a variable tap transformer, fix the tap variables which are fixed. For example, an OLTC where the third phase is fixed, will have tap variables for all phases, but the third tap variable should be fixed.

power balanace constraint with line shunts and transformers, active power only

KCL including transformer arcs and load variables.

Shunt handling in matrix form: I = Y.U S = U.I' = U.(Y.U)' = U.U'.Y' = W.Y' = (Wr+j.Wi)(G+jB)' = (Wr+j.Wi)(G'-j.B') = (Wr.G'+Wi.B')+j(-Wr.B'+Wi.G') P = Wr.G'+Wi.B' Q = -Wr.B'+Wi.G'

power balance constraint with line shunts and transformers for load shed problem, DCP formulation

KCL for load shed problem with transformers

KCL for load shed problem with transformers (AbstractWForms)

power balance constraint with line shunts and transformers for load shed problem, DCP formulation

KCL including transformer arcs

Defines branch flow model power flow equations

Defines branch flow model power flow equations

qq[i] == qq

storage loss constraints, delegate to PowerModels

Neglects the active and reactive loss terms associated with the squared current magnitude.

nothing to do

-rate_a <= p[f_idx] <= rate_a

p[f_idx]^2 + q[f_idx]^2 <= rate_a^2

Generic thermal limit constraint from-side

branch thermal constraints from

p[t_idx]^2 + q[t_idx]^2 <= rate_a^2

Generic thermal limit constraint to-side

branch thermal constraints to

balanced three-phase phasor

nothing to do, no voltage angle variables

Creates phase angle constraints at reference buses

reference angle constraints

Creates phase angle constraints at reference buses

do nothing, no way to represent this in these variables

nothing to do, this model is symmetric

Transformer constraints, considering winding type, conductor order, polarity and tap settings.

This function adds all constraints required to model a two-winding, delta-wye connected transformer.

delta-wye transformer power constraint for IVR formulation

Links to and from power and voltages in a wye-wye transformer, assumes tmfixed is true wfri=(politm_scaletmi)^2wto_i

This function adds all constraints required to model a two-winding, wye-wye connected transformer.

wye-wye transformer power constraint for IVR formulation

This is duplicated at PowerModelsDistribution level to correctly handle the indexing of the shunts.

Bounds the voltage angle difference between bus pairs

nothing to do, these models do not have angle difference constraints

This is duplicated at PowerModelsDistribution level to correctly handle the indexing of the shunts.

vmin <= vm[i] <= vmax

This constraint captures problem agnostic constraints that define limits for voltage magnitudes (where variable bounds cannot be used) Notable examples include IVRPowerModel and ACRPowerModel

vm[i] == vmref

vm[i] == vmref

nothing to do

voltage magnitude setpoint constraint

vm[i] == vmref

Add explicit PSD-ness of W for nodes where it is not implied

Add explicit PSD-ness of W for nodes where it is not implied

Add explicit PSD-ness of W for nodes where it is not implied

Creates the constraints modelling the (relaxed) voltage-dependency of the power consumed in each phase, s=p+jq. This is completely symmetrical for p and q, with appropriate substitutions of the variables and parameters: p->q, a->b, alpha->beta, pmin->qmin, pmax->qmax

checks that each branch has non-negative thermal ratings and removes zero thermal ratings

checks that voltage angle differences are within 90 deg., if not tightens

Counts active ungrounded connections on edge components

Counts active ungrounded terminals on buses

Counts number of nodes in network

creates a aysmmetric lossless 2-winding transformer object with some defaults

creates a bus object with some defaults

creates a generator object with some defaults

Create a line with some default values

creates a linecode with some defaults

creates a load object with some defaults

creates a generic shunt with some defaults

creates a solar generator with some defaults

creates energy storage object with some defaults

creates a switch object with some defaults

creates a n-winding transformer object with some defaults

creates a voltage source with some defaults

creates transformer code with some defaults

deletes a component from the engineering data model

finds voltage zones

multiconductor version of instantiate model from PowerModels

remove parameters from objects with loss models to make them lossless

Transforms single-conductor network data into multi-conductor data

converts data model between per-unit and SI units

generate a new, unique terminal

maximum loadability objective (continuous load shed) with storage

minimum load delta objective (continuous load shed) with storage

simplified minimum load delta objective (continuous load shed)

simplified minimum load delta objective (continuous load shed)

a quadratic penalty for bus power slack variables

adds pg_cost variables and constraints

adds pg_cost variables and constraints

Parses a OpenDSS file given by filename into a Dict{Array{Dict}}. Only supports components and options, but not commands, e.g. "plot" or "solve". Will also parse files defined inside of the originating DSS file via the "compile", "redirect" or "buscoords" commands.

parse_file(io)

Parses the IOStream of a file into a PowerModelsDistribution data structure.

Parses a JSON file into a PowerModelsDistribution data structure

Parses a JSON file into a PowerModelsDistribution data structure

Parses a Dict resulting from the parsing of a DSS file into a PowerModels usable format

Parses a DSS file into a PowerModels usable format

prints a PowerModelsDistribution data structure into a JSON file

prints a PowerModelsDistribution data structure into a JSON file

Adds arcs for PowerModelsDistribution transformers; for dclines and branches this is done in PowerModels

Adds arcs for PowerModelsDistribution transformers; for dclines and branches this is done in PowerModels

computes storage bounds

For debugging / exploration: real-valued SDP to SDP relaxation based on PSDness of principal minors, default is 3x3 SDP relaxation

See section 4.3 for complex to real PSD constraint transformation: @article{Fazel2001, author = {Fazel, M. and Hindi, H. and Boyd, S.P.}, title = {{A rank minimization heuristic with application to minimum order system approximation}}, doi = {10.1109/ACC.2001.945730}, journal = {Proc. American Control Conf.}, number = {2}, pages = {4734–4739}, url = {http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=945730}, volume = {6}, year = {2001} }

SDP to SOC relaxation of type 2, applied to complex-value matrix, as described in:

@article{Kim2003,
author = {Kim, S and Kojima, M and Yamashita, M},
title = {{Second order cone programming relaxation of a positive semidefinite constraint}},
doi = {10.1080/1055678031000148696},
journal = {Optimization Methods and Software},
number = {5},
pages = {535--541},
volume = {18},
year = {2003}
}

SDP to SOC relaxation of type 2, applied to complex-value matrix, as described in:

@article{Kim2003,
author = {Kim, S and Kojima, M and Yamashita, M},
title = {{Second order cone programming relaxation of a positive semidefinite constraint}},
doi = {10.1080/1055678031000148696},
journal = {Optimization Methods and Software},
number = {5},
pages = {535--541},
volume = {18},
year = {2003}
}

See section 4.3 for complex to real PSD constraint transformation: @article{Fazel2001, author = {Fazel, M. and Hindi, H. and Boyd, S.P.}, title = {{A rank minimization heuristic with application to minimum order system approximation}}, doi = {10.1109/ACC.2001.945730}, journal = {Proc. American Control Conf.}, number = {2}, pages = {4734–4739}, url = {http://ieeexplore.ieee.org/lpdocs/epic03/wrapper.htm?arnumber=945730}, volume = {6}, year = {2001} }

SDP to SOC relaxation of type 2, applied to real-value matrix, as described in:

@article{Kim2003,
author = {Kim, S and Kojima, M and Yamashita, M},
title = {{Second order cone programming relaxation of a positive semidefinite constraint}},
doi = {10.1080/1055678031000148696},
journal = {Optimization Methods and Software},
number = {5},
pages = {535--541},
volume = {18},
year = {2003}
}

SDP to SOC relaxation of type 2, applied to real-value matrix, as described in:

@article{Kim2003,
author = {Kim, S and Kojima, M and Yamashita, M},
title = {{Second order cone programming relaxation of a positive semidefinite constraint}},
doi = {10.1080/1055678031000148696},
journal = {Optimization Methods and Software},
number = {5},
pages = {535--541},
volume = {18},
year = {2003}
}

removes all fields ending in 'ub' or 'lb'

depreciation warning for runacmc_opf

depreciation warning for runacmcopfoltc

Power Flow problem with ACPPowerModel

depreciation warning for runmcmld

depreciation warning for runmcmld_bf

depreciation warning for runmcmld_uc

depreciation message for runmcmodel

depreciation warning for runmcopf

depreciation warning for runmcopf_oltc

depreciation message for runmcopf_pbs

Power Flow Problem

depreciation message for runmcopf_pbs

depreciation warning for runmnmcmldsimple

depreciation warning for runmnmc_opf

Local wrapper method for JuMP.setlowerbound, which skips NaN and infinite (-Inf only)

Local wrapper method for JuMP.setupperbound, which skips NaN and infinite (+Inf only)

converts the solution data into the data model's standard space, polar voltages and rectangular power

Solve load shedding problem with storage

Solve unit commitment load shedding problem (!relaxed)

alias to run_model in PowerModels with multiconductor=true, and transformer ref extensions added by default

alias to run_model in PowerModels with multiconductor=true, and transformer ref extensions added by default

Solve Optimal Power Flow

Solve on-load tap-changer OPF

Solve OPF problem with slack power at every bus

Power Flow Problem

Solve PF problem with slack power at every bus

Solve multinetwork load shedding problem with storage

Solve multinetwork optimal power flow problem

transforms model between engineering (high-level) and mathematical (low-level) models

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

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

variable: csi[l] for l in branch

variable: csr[l] for l in branch

apo models ignore reactive power flows

branch flow variables, delegated back to PowerModels

apo models ignore reactive power flows

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

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

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

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

Create variables for generator status

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

variable: cig[j] for j in gen

variable: crg[j] for j in gen

create variables for generators, delegate to PowerModels

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

apo models ignore reactive power flows

apo models ignore reactive power flows

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

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.

Create variables for demand status

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).

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.

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]

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

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

Create variables for active and reactive storage injection

Create variables for active storage injection

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

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

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.

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

Create variables for the active power flowing into all transformer windings

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).

Same as variablemxcomplex, 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).

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

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

Same as variablemxreal, but adds skew-symmetry structure.

Same as variablemxreal, but adds symmetry structure

Same as variablemxreal, 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.