E2ELRReserveScaler

Samples reserve requirements following the procedure below:

1. Sample a minimum reserve requirement MRR from a uniform distribution U(lb, ub) (mrr_dist).
2. Compute the upper bound of reserve requirements for each generator as rmax = α * (pmax - pmin).
3. Fix the lower bound of reserve requirement per generator to zero.
4. Fix the reserve cost of each generator to zero.

The parameter α is a scaling factor that determines each generator's maximum reserve capacity. It is the factor parameter times the ratio of the largest generator's capacity to the sum of all generators' dispatchable capacity.

Glocal{G,L}

A glocal distribution with global/local factors α::G and η::L.

This distribution represents a random variable of the form ϵ = α×η, where

• α is a scalar random variable, with distribution d_α::G
• η is a vector random variable, with distribution d_η::L
• α and η are independent random variables

LoadScaler{D}

Scales loads with multiplicative noise sampled from d::D.

The distribution d::D is a 2*L-dimensional distribution. The sampled active (resp reactive) demand for load $i$ is denoted by $\tilde{p}_{i}$ (resp. $\tilde{q}_{i}$) and has the form

\[\tilde{p}_{i} = \epsilon_{i} \bar{p}_{i}, \quad \tilde{q}_{i} = \epsilon_{i+L} \bar{q}_{i},\]

where $\bar{p}_{i}, \bar{q}_{i}$ are the reference active/reactive demand for load $i$, and $\epsilon \in \mathbb{R}^{2L}$ is multiplicative noise sampled from distribution d::D.

Nminus1StatusSampler

Samples a branch or generator to be inactive following the procedure below:

1. With probability 1/2, decide if a branch or generator is inactive in this instance.

If a branch is inactive:

1. Identify the set of branches which are not bridges. Removing a bridge results in a disconnected network.
2. Sample a branch to be inactive from the set of non-bridge branches.
3. Construct the status vector to be all ones except for zero at the sampled branch.

If a generator is inactive:

1. Sample a generator to be inactive.
2. Construct the status vector to be all ones except for zero at the sampled generator.

OPFData(network::Dict{String,Any}; compute_clique_decomposition::Bool=false)

Convert a PowerModels data dictionary to OPFData structure.

The PowerModels data dictionary must be in basic format.

ScaledLogNormal(l, u, σs)

Generate a Glocal distribution ϵ = α×η where α~U[l,u] and ηᵢ ~ LogNormal(-σᵢ²/2, σᵢ).

ScaledUniform(l, u, σs)

Generate a Glocal distribution ϵ = α×η where α ~ U[l,u] and ηᵢ ~ U[1-σᵢ, 1+σᵢ].

_dedupe_and_sort_h5!(D)

De-duplicated and sort dataset D in increasing order of random seeds.

Equivalent to _dedupe_h5!(D); _sort_h5!(D), but more efficient.

_dedupe_h5!(D)

De-duplicate points in h5 dataset D, according to their random seed.

_get_case_info(config)

Extract case file and name from input config.

To be valid, the input config should include:

• either a case_file or pglib_case entry
• if no case_file is provided, pglib_case should be a valid, unique PGLib case name.

The case name will be set to the generic "case" value if none is provided.

_get_clique_decomposition(network::Dict{String,Any})

Compute the clique decomposition of a PowerModels data dictionary. The output is a Vector{Vector{Int}} containing all the cliques in the chordal completion of network.

_get_overlapping_pairs(groups)

Get the indices of pairs of cliques in groups that overlap.

Refer to https://github.com/lanl-ansi/PowerModels.jl/blob/be6af59202a6868b20a41214cb341b883d62e5f0/src/form/wrm.jl#L273-L274

_merge_h5(V::Vector{Array{T,N})

Concatenate a collection of N-dimensional arrays along their last dimension.

This function is semantically equivalent to cat(V...; dims=ndims(first(V))), but uses a more efficient, splatting-free, implementation. All elements of V must have the same size in the first N-1 dimensions.

idx_a, idx_b = _overlap_indices(A, B)

Given two arrays (sizes need not match) that share some values, return:

• linear index of shared values in A
• linear index of shared values in B

Thus, A[idxa] == B[idxb].

Refer to https://github.com/lanl-ansi/PowerModels.jl/blob/be6af59202a6868b20a41214cb341b883d62e5f0/src/form/wrm.jl#L469

_select_h5!(D, p)

Select data points in D as indicated by p.

D should be a dictionary in h5-compatible format, and p is either a vector of indices, or a logical vector of the same length as D["meta"]["seed"].

• If p is a vector of indices, then all values of p should be integers between 1 and the number of elements in D
• If p is a logical vector, then it should have the same length as D["meta"]["seed"]. Only datapoints i for which p[i] is true are selected.

_sort_h5!(D)

Sort dataset D in increasing order of random seeds.

The dictionary D should be in h5-compatible format. It is modified in-place.

The function expects D["meta"]["seed"] to exist and be a Vector{Int}. An error is thrown if such an entry is not found.

bridges(data)

Identify whether each branch is a bridge.

The input data must be in basic format.

A branch is a bridge if removing it renders the network disconnected. Returns a dictionary res::Dict{String,Bool} such that res[br] is true if branch br is a bridge, and false otherwise.

build_opf(ACOPF, data, optimizer)

Build an ACOPF model.

build_opf(DCOPF, data, optimizer)

Build a DCOPF model.

build_opf(SDPOPF, data, optimizer)

Build an SDPOPF model.

build_opf(SparseSDPOPF, data, optimizer)

Build an SparseSDPOPF model.

build_opf(SOCOPF, data, optimizer)

Build an SOCOPF model.

compute_flow!(pf, pg, Φ::FullPTDF)

Compute power flow pf = Φ*pg given PTDF matrix Φ and nodal injections pg.

compute_flow!(pf, pg, Φ::LazyPTDF)

Compute power flow pf = Φ*pg lazily, without forming the PTDF matrix.

Namely, pf is computed as pf = BA * (F \ pg), where F is an LDLᵀ factorization of AᵀBA.

compute_voltage_phasor_bounds(vfmin, vfmax, vtmin, vtmax, dvamin, dvamax)

Compute lower/upper bounds on wr/wi variables.

convert_float_data(D, F)

Convert all floating-point scalars and arrays to F.

Arguments

• D: Should be a JSON-serializable dictionary, which generally means that all keys are String and all values are JSON-compatible.
• F: Must be a subtype of AbstractFloat

Returns

• d::Dict{String,Any}: a dictionary with same nested structure as D, with all floating-point scalars and arrays converted to F.

load_h5

load_json(filename::AbstractString)

Load JSON data from file filename.

ptdf_row(Φ::FullPTDF, e::Int)

Return the e-th row of PTDF matrix Φ.

ptdf_row(Φ::LazyPTDF, e::Int)

Return the e-th row of (lazy) PTDF matrix Φ.

save_h5(filename, D; warn=true)

Saves dictionary D to HDF5 file filename.

Arguments

• filename::AbstractString: Path to the HDF5 file; must be a valid path.
• D: Dictionary to save to the file. All keys in D must be of String type, and it must be HDF5-compatible. Additional restrictions are enforced on the values of D, see below.
• warn::Bool=true: Whether to raise a warning when converting numerical data.

save_json(filename::AbstractString, data; indent)

Save data into JSON file filename. The following formats are supported:

• uncompressed JSON .json
• Gzip-compressed JSON .json.gz
• Bzip2-compressed JSON .json.bz2

If the file extension does not match one of the above, an error is thrown.

tensorize(V)

Concatenate elements of V into a higher-dimensional tensor.

Similar to Base.stack, with one major difference: if V is a vector of scalars, the result is a 2D array M whose last dimension is length(V), and such that M[:, i] == V[i].

This function is only defined for Vector{T} and Vector{Array{T,N}} inputs, to avoid any unexpected behavior of Base.stack.

rand!(rng::AbstractRNG, s::AbstractOPFSampler, data::OPFData)

Sample one new OPF instance and modify data in-place.

data must be the same network (i.e., same grid components with same indexing) as the one used to create s.