Edit on GitHub

Internal API

PowerSystems._pti_dtypes — Constant

lookup array of data types for PTI file sections given by field_name, as enumerated by PSS/e Program Operation Manual.

source
Base.convert — Method
convert(_::Type{NamedTuple{(:min, :max), Tuple{Float64, Float64}}}, input::Tuple{Float64, Float64}) -> NamedTuple{(:min, :max), Tuple{Float64, Float64}}

Convert Tuple to Min Max Named Tuple

source
Base.convert — Method
convert(_::Type{NamedTuple{(:up, :down), Tuple{Float64, Float64}}}, input::Tuple{Float64, Float64}) -> NamedTuple{(:up, :down), Tuple{Float64, Float64}}

Convert Tuple to Up Down Named Tuple

source
PowerSystems._calc_comp_lines — Method
_calc_comp_lines(component::Dict{String, var"#s1778"} where var"#s1778") -> Vector{Any}

compute lines in m and b from from pwl cost models

source
PowerSystems._create_starbus_from_transformer — Method
_create_starbus_from_transformer(pm_data::Dict, transformer::Dict) -> Dict{String, Any}

create_starbus(pm_data, transformer)

Creates a starbus from a given three-winding transformer. "sourceid" is given by `["busi", "name", "I", "J", "K", "CKT"]` where "bus_i" and "name" are the modified names for the starbus, and "I", "J", "K" and "CKT" come from the originating transformer, in the PSS(R)E transformer specification.

source
PowerSystems._export_extra_data — Function
_export_extra_data(io::IO, data::Dict{String, var"#s220"} where var"#s220", component)
_export_extra_data(io::IO, data::Dict{String, var"#s219"} where var"#s219", component, excluded_fields; postfix)

Export fields of a component type

source
PowerSystems._float2string — Method
_float2string(v::AbstractFloat, float_precision::Int64) -> String

converts a float value into a string of fixed precision

sprintf would do the job but this work around is needed because sprintf cannot take format strings during runtime

source
PowerSystems._get_bus_value — Method
_get_bus_value(bus_i, field, pm_data) -> Any

_get_bus_value(bus_i, field, pm_data)

Returns the value of field of bus_i from the PowerModels data. Requires "bus" Dict to already be populated.

source
PowerSystems._get_line_elements — Method
_get_line_elements(line::AbstractString) -> Tuple{Vector{_A} where _A, Union{String, SubString}}

_get_line_elements(line)

Internal function. Uses regular expressions to extract all separate data elements from a line of a PTI file and populate them into an Array{String}. Comments, typically indicated at the end of a line with a '/' character, are also extracted separately, and Array{Array{String}, String} is returned.

source
PowerSystems._grey — Method
_grey(s::String) -> String

Makes a string grey in the terminal, does not seem to work well on Windows terminals more info can be found at https://en.wikipedia.org/wiki/ANSIescapecode

source
PowerSystems._import_remaining! — Method
_import_remaining!(data_out::Dict, data_in::Dict, import_all::Bool; exclude)

Imports remaining keys from data_in into data_out, excluding keys in exclude

source
PowerSystems._init_bus! — Method
_init_bus!(bus::Dict{String, Any}, id::Int64) -> Int64

_init_bus!(bus, id)

Initializes a bus of id id with default values given in the PSS(R)E specification.

source
PowerSystems._matpower_to_powermodels! — Method
_matpower_to_powermodels!(mp_data::Dict{String, var"#s222"} where var"#s222") -> Dict{String, var"#s222"} where var"#s222"

Converts a Matpower dict into a PowerModels dict

source
PowerSystems._parse_dyr_components — Method
_parse_dyr_components(dyr_file::AbstractString) -> Dict{Int64, Any}

Parse a .dyr file directly from its name by constructing its dictionary of dictionaries.

source
PowerSystems._parse_dyr_components — Method
_parse_dyr_components(data::Dict) -> Dict{Int64, Any}

Parse dictionary of dictionaries of data (from _parse_dyr_file) into a dictionary of struct components. The function receives the parsed dictionary and constructs a dictionary indexed by bus, that contains a dictionary with each dynamic generator components (indexed via its id).

Each dictionary indexed by id contains a vector with 5 of its components:

  • Machine
  • Shaft
  • AVR
  • TurbineGov
  • PSS
source
PowerSystems._parse_dyr_file — Method
_parse_dyr_file(file::AbstractString) -> Dict{Int64, Dict}

Parse .dyr file into a dictionary indexed by bus number. Each bus number key has a dictionary indexed by component type and id.

source
PowerSystems._parse_elements — Method
_parse_elements(elements::Array, dtypes::Array, defaults::Dict, section::AbstractString) -> Dict{String, Any}

This is an experimental method for parsing elements and setting defaults at the same time. It is not currently working but would reduce memory allocations if implemented correctly.

source
PowerSystems._parse_line_element! — Method
_parse_line_element!(data::Dict, elements::Array, section::AbstractString)

_parse_line_element!(data, elements, section)

Internal function. Parses a single "line" of data elements from a PTI file, as given by elements which is an array of the line, typically split at ,. Elements are parsed into data types given by section and saved into data::Dict.

source
PowerSystems._parse_pti_data — Method
_parse_pti_data(data_io::IO) -> Dict{String, Array{Dict, N} where N}

_parse_pti_data(data_string, sections)

Internal function. Parse a PTI raw file into a Dict, given the data_string of the file and a list of the sections in the PTI file (typically given by default by get_pti_sections().

source
PowerSystems._populate_args — Method
_populate_args(param_map, val) -> Any

Populate arguments in a vector for each dynamic component (except Shafts). Returns a vector with the parameter values of the argument of each component.

source
PowerSystems._psse2pm_branch! — Method
_psse2pm_branch!(pm_data::Dict, pti_data::Dict, import_all::Bool)

_psse2pm_branch!(pm_data, pti_data)

Parses PSS(R)E-style Branch data into a PowerModels-style Dict. "source_id" is given by ["I", "J", "CKT"] in PSS(R)E Branch specification.

source
PowerSystems._psse2pm_bus! — Method
_psse2pm_bus!(pm_data::Dict, pti_data::Dict, import_all::Bool)

_psse2pm_bus!(pm_data, pti_data)

Parses PSS(R)E-style Bus data into a PowerModels-style Dict. "source_id" is given by ["I", "NAME"] in PSS(R)E Bus specification.

source
PowerSystems._psse2pm_dcline! — Method
_psse2pm_dcline!(pm_data::Dict, pti_data::Dict, import_all::Bool)

_psse2pm_dcline!(pm_data, pti_data)

Parses PSS(R)E-style Two-Terminal and VSC DC Lines data into a PowerModels compatible Dict structure by first converting them to a simple DC Line Model. For Two-Terminal DC lines, "sourceid" is given by ["IPR", "IPI", "NAME"] in the PSS(R)E Two-Terminal DC specification. For Voltage Source Converters, "sourceid" is given by ["IBUS1", "IBUS2", "NAME"], where "IBUS1" is "IBUS" of the first converter bus, and "IBUS2" is the "IBUS" of the second converter bus, in the PSS(R)E Voltage Source Converter specification.

source
PowerSystems._psse2pm_generator! — Method
_psse2pm_generator!(pm_data::Dict, pti_data::Dict, import_all::Bool)

_psse2pm_generator!(pm_data, pti_data)

Parses PSS(R)E-style Generator data in a PowerModels-style Dict. "source_id" is given by ["I", "ID"] in PSS(R)E Generator specification.

source
PowerSystems._psse2pm_load! — Method
_psse2pm_load!(pm_data::Dict, pti_data::Dict, import_all::Bool)

_psse2pm_load!(pm_data, pti_data)

Parses PSS(R)E-style Load data into a PowerModels-style Dict. "source_id" is given by ["I", "ID"] in the PSS(R)E Load specification.

source
PowerSystems._psse2pm_shunt! — Method
_psse2pm_shunt!(pm_data::Dict, pti_data::Dict, import_all::Bool)

_psse2pm_shunt!(pm_data, pti_data)

Parses PSS(R)E-style Fixed and Switched Shunt data into a PowerModels-style Dict. "source_id" is given by ["I", "ID"] for Fixed Shunts, and ["I", "SWREM"] for Switched Shunts, as given by the PSS(R)E Fixed and Switched Shunts specifications.

source
PowerSystems._psse2pm_transformer! — Method
_psse2pm_transformer!(pm_data::Dict, pti_data::Dict, import_all::Bool)

_psse2pm_transformer!(pm_data, pti_data)

Parses PSS(R)E-style Transformer data into a PowerModels-style Dict. "source_id" is given by ["I", "J", "K", "CKT", "winding"], where "winding" is 0 if transformer is two-winding, and 1, 2, or 3 for three-winding, and the remaining keys are defined in the PSS(R)E Transformer specification.

source
PowerSystems._pti_to_powermodels! — Method
_pti_to_powermodels!(pti_data::Dict; import_all, validate) -> Dict{String, Any}

_pti_to_powermodels!(pti_data)

Converts PSS(R)E-style data parsed from a PTI raw file, passed by pti_data into a format suitable for use internally in PowerModels. Imports all remaining data from the PTI file if import_all is true (Default: false).

source
PowerSystems._read_data_row — Method
_read_data_row(data::PowerSystemTableData, row, field_infos; na_to_nothing) -> NamedTuple

Reads values from dataframe row and performs necessary conversions.

source
PowerSystems._remove_pwl_cost_duplicates! — Function
_remove_pwl_cost_duplicates!(id, comp, type_name) -> Bool
_remove_pwl_cost_duplicates!(id, comp, type_name, tolerance) -> Bool

checks that each point in the a pwl function is unqiue, simplifies the function if duplicates appear

source
PowerSystems._simplify_pwl_cost! — Function
_simplify_pwl_cost!(id, comp, type_name) -> Bool
_simplify_pwl_cost!(id, comp, type_name, tolerance) -> Bool

checks the slope of each segment in a pwl function, simplifies the function if the slope changes is below a tolerance

source
PowerSystems._split_loads_shunts! — Method
_split_loads_shunts!(data::Dict{String, Any})

_split_loads_shunts!(data)

Seperates Loads and Shunts in data under separate "load" and "shunt" keys in the PowerModels data format. Includes references to originating bus via "loadbus" and "shuntbus" keys, respectively.

source
PowerSystems._standardize_cost_terms! — Method
_standardize_cost_terms!(components::Dict{String, var"#s1777"} where var"#s1777", comp_order::Int64, cost_comp_name::String) -> Set{Int64}

ensures all polynomial costs functions have at exactly comp_order terms

source
PowerSystems._type_array — Method
_type_array(string_array::Array{T<:AbstractString, 1}) -> Any

Attempts to determine the type of an array of strings extracted from a matlab file

source
PowerSystems._type_value — Method
_type_value(value_string::AbstractString) -> Any

Attempts to determine the type of a string extracted from a matlab file

source
PowerSystems._update_data! — Method
_update_data!(data::Dict{String, var"#s1777"} where var"#s1777", new_data::Dict{String, var"#s1776"} where var"#s1776")

recursive call of updatedata

source
PowerSystems._write_results — Method
_write_results(sys::System, nl_result) -> Dict{String, DataFrames.DataFrame}

Return power flow results in dictionary of dataframes.

source
PowerSystems.add_service_internal! — Method
add_service_internal!(device::Device, service::Service)

This function add a service to the component without checking if the component and the service are attached to the same system

source
PowerSystems.adequacy_check — Method
adequacy_check(sys::System) -> Union{Nothing, Bool}

adequacy_check(sys::System)

Checks the system for sum(generator ratings) >= sum(load ratings).

Arguments

  • sys::System: system
source
PowerSystems.bus_gen_lookup — Method
bus_gen_lookup(gen_data::Dict{String, var"#s1775"} where var"#s1775", bus_data::Dict{String, var"#s1774"} where var"#s1774") -> Dict{_A, _B} where {_A, _B}

builds a lookup list of what generators are connected to a given bus

source
PowerSystems.bus_load_lookup — Method
bus_load_lookup(load_data::Dict{String, var"#s1775"} where var"#s1775", bus_data::Dict{String, var"#s1774"} where var"#s1774") -> Dict{_A, _B} where {_A, _B}

builds a lookup list of what loads are connected to a given bus

source
PowerSystems.bus_shunt_lookup — Method
bus_shunt_lookup(shunt_data::Dict{String, var"#s1775"} where var"#s1775", bus_data::Dict{String, var"#s1774"} where var"#s1774") -> Dict{_A, _B} where {_A, _B}

builds a lookup list of what shunts are connected to a given bus

source
PowerSystems.bus_storage_lookup — Method
bus_storage_lookup(storage_data::Dict{String, var"#s1775"} where var"#s1775", bus_data::Dict{String, var"#s1774"} where var"#s1774") -> Dict{_A, _B} where {_A, _B}

builds a lookup list of what storage is connected to a given bus

source
PowerSystems.calc_branch_flow_ac — Method
calc_branch_flow_ac(data::Dict{String, var"#s1778"} where var"#s1778") -> Dict{String, Any}

assumes a vaild ac solution is included in the data and computes the branch flow values

source
PowerSystems.calc_branch_flow_dc — Method
calc_branch_flow_dc(data::Dict{String, var"#s1778"} where var"#s1778") -> Dict{String, Any}

assumes a vaild dc solution is included in the data and computes the branch flow values

source
PowerSystems.calc_connected_components — Method
calc_connected_components(data::Dict{String, var"#s1772"} where var"#s1772"; edges) -> Set{Set{Int64}}

computes the connected components of the network graph returns a set of sets of bus ids, each set is a connected component

source
PowerSystems.calc_cost_pwl_lines — Method
calc_cost_pwl_lines(comp_dict::Dict) -> Dict{Any, Any}

compute lines in m and b from from pwl cost models data is a list of components.

Can be run on data or ref data structures

source
PowerSystems.calc_gen_cost — Method
calc_gen_cost(data::Dict{String, var"#s1776"} where var"#s1776") -> Any

computes the generator cost from given network data

source
PowerSystems.calc_power_balance — Method
calc_power_balance(data::Dict{String, var"#s1778"} where var"#s1778") -> Dict{String, Any}

assumes a vaild solution is included in the data and computes the power balance at each bus

source
PowerSystems.check_component_addition — Method
check_component_addition(sys::System, component::Component; kwargs...)

Throws ArgumentError if a PowerSystems rule blocks addition to the system.

This method is tied with handlecomponentaddition!. If the methods are re-implemented for a subtype then whatever is added in handlecomponentaddition! must be checked here.

source
PowerSystems.check_connectivity — Method
check_connectivity(data::Dict{String, var"#s218"} where var"#s218")

checks that all buses are unique and other components link to valid buses

source
PowerSystems.check_status — Method
check_status(data::Dict{String, var"#s218"} where var"#s218")

checks that active components are not connected to inactive buses, otherwise prints warnings

source
PowerSystems.check_type — Method
check_type(typ, value) -> Any

Checks if the given value is of a given type, if not tries to make it that type

source
PowerSystems.check_voltage_setpoints — Method
check_voltage_setpoints(data::Dict{String, var"#s1775"} where var"#s1775")

throws warnings if generator and dc line voltage setpoints are not consistent with the bus voltage setpoint

source
PowerSystems.correct_bus_types! — Method
correct_bus_types!(data::Dict{String, var"#s1774"} where var"#s1774") -> Set{Int64}

checks bus types are consistent with generator connections, if not, fixes them

source
PowerSystems.correct_current_limits! — Method
correct_current_limits!(data::Dict{String, var"#s1778"} where var"#s1778") -> Set{Int64}

checks that each branch has a reasonable current rating-a, if not computes one

source
PowerSystems.correct_network_data! — Method
correct_network_data!(data::Dict{String, var"#s1779"} where var"#s1779") -> Dict{String, Dict{Symbol, Set{Int64}}}

Runs various data quality checks on a PowerModels data dictionary. Applies modifications in some cases. Reports modified component ids.

source
PowerSystems.correct_thermal_limits! — Method
correct_thermal_limits!(data::Dict{String, var"#s1778"} where var"#s1778") -> Set{Int64}

checks that each branch has a reasonable thermal rating-a, if not computes one

source
PowerSystems.correct_transformer_parameters! — Method
correct_transformer_parameters!(data::Dict{String, var"#s1777"} where var"#s1777") -> Set{Int64}

checks that each branch has a reasonable transformer parameters

this is important because setting tap == 0.0 leads to NaN computations, which are hard to debug

source
PowerSystems.correct_voltage_angle_differences! — Function
correct_voltage_angle_differences!(data::Dict{String, var"#s1776"} where var"#s1776") -> Set{Int64}
correct_voltage_angle_differences!(data::Dict{String, var"#s1775"} where var"#s1775", default_pad) -> Set{Int64}

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

source
PowerSystems.flow_func — Method
flow_func(b::ACBranch, V_from::ComplexF64, V_to::ComplexF64) -> Tuple{Float64, Float64}

Calculates the From - To complex power flow using external data of voltages of branch of type Line

source
PowerSystems.flow_func — Method
flow_func(b::TapTransformer, V_from::ComplexF64, V_to::ComplexF64) -> Tuple{Float64, Float64}

Calculates the From - To complex power flow using external data of voltages of branch of type TapTransformer

source
PowerSystems.flow_func — Method
flow_func(b::Transformer2W, V_from::ComplexF64, V_to::ComplexF64) -> Tuple{Float64, Float64}

Calculates the From - To complex power flow using external data of voltages of branch of type Transformer2W

source
PowerSystems.flow_val — Method
flow_val(b::ACBranch) -> Union{Float64, ComplexF64}

Calculates the From - To complex power flow (Flow injected at the bus) of branch of type Line

source
PowerSystems.flow_val — Method
flow_val(b::TapTransformer) -> Union{Float64, ComplexF64}

Calculates the From - To complex power flow (Flow injected at the bus) of branch of type TapTransformer

source
PowerSystems.flow_val — Method
flow_val(b::Transformer2W) -> Union{Float64, ComplexF64}

Calculates the From - To complex power flow (Flow injected at the bus) of branch of type Transformer2W

source
PowerSystems.get_avr_saturation — Method
get_avr_saturation(E::Tuple{Float64, Float64}, Se::Tuple{Float64, Float64}) -> Tuple{Float64, Float64}

Obtain coefficients (A, B) of the function Se(x) = B(x - A)^2/x for Se(E1) = B(E1 - A)^2/E1 and Se(E2) = B(E2 - A)^2/2 and uses the negative solution of the quadratic equation

source
PowerSystems.get_dataframe — Method
get_dataframe(data::PowerSystemTableData, category::PowerSystems.InputCategoryModule.InputCategory) -> DataFrames.DataFrame

Return the dataframe for the category.

source
PowerSystems.get_exponential_saturation — Method
get_exponential_saturation(Se::Tuple{Float64, Float64}) -> Tuple{Float64, Float64}

Obtain coefficients (A, B) of the function Se = Bx^A for Se(1.2) = B(1.2)^A and Se(1.0) = B(1.0)^A as: B = Se(1.0) and hence (1.2)^A = Se(1.2)/B -> A = log(Se(1.2)/B) / log(1.2)

source
PowerSystems.get_generator_mapping — Function
get_generator_mapping() -> Dict{NamedTuple, DataType}
get_generator_mapping(filename) -> Dict{NamedTuple, DataType}

Return a dict where keys are a tuple of input parameters (fuel, unit_type) and values are generator types.

source
PowerSystems.get_generator_type — Method
get_generator_type(fuel, unit_type, mappings::Dict{NamedTuple, DataType}) -> Union{Nothing, DataType}

Return the PowerSystems generator type for this fuel and unit_type.

source
PowerSystems.get_quadratic_saturation — Method
get_quadratic_saturation(Se::Tuple{Float64, Float64}) -> Tuple{Float64, Float64}

Obtain coefficients (A, B) of the function Se = B(x - A)^2 for Se(1.2) = B(1.2 - A)^2 and Se(1.0) = B(1.0 - A)^2 as: Se(1.0) = Se(1.2)/(1.2 - A)^2 * (1.0 - A)^2 that yields (1.2 - A)^2 Se(1.0) = Se(1.2) * (1.0 - A)^2 or expanding: (Se(1.2) - Se(1.0)) A^2 + (2.4 Se(1.0) - 2 Se(1.2)) A + (Se(1.2) - 1.44 Se(1.0)) = 0 and uses the negative solution of the quadratic equation

source
PowerSystems.get_series_susceptance — Method
get_series_susceptance(b::Union{PhaseShiftingTransformer, TapTransformer}) -> Float64

Returns the series susceptance of a controllable transformer following the convention in power systems to define susceptance as the inverse of the imaginary part of the impedance. In the case of phase shifter transformers the angle is ignored.

source
PowerSystems.get_user_field — Method
get_user_field(data::PowerSystemTableData, category::PowerSystems.InputCategoryModule.InputCategory, field::AbstractString) -> Any

Return the custom name stored in the user descriptor file.

Throws DataFormatError if a required value is not found in the file.

source
PowerSystems.get_user_fields — Method
get_user_fields(data::PowerSystemTableData, category::PowerSystems.InputCategoryModule.InputCategory) -> Any

Return a vector of user-defined fields for the category.

source
PowerSystems.im_replicate — Method
im_replicate(sn_data::Dict{String, var"#s1778"} where var"#s1778", count::Int64, global_keys::Set{String}) -> Dict{String, Any}

Transforms a single network into a multinetwork with several deepcopies of the original network

source
PowerSystems.is_attached — Method
is_attached(component::T<:Component, sys::System) -> Bool

Return true if the component is attached to the system.

source
PowerSystems.isafield — Method
isafield(component::Component, field::Symbol) -> Any

Checks if a PowerSystemDevice has a field or subfield name.

source
PowerSystems.ismultinetwork — Method
ismultinetwork(data::Dict{String, var"#s1780"} where var"#s1780") -> Any

checks if a given network data is a multinetwork

source
PowerSystems.iterate_rows — Method
iterate_rows(data::PowerSystemTableData, category; na_to_nothing) -> Channel{Any}

Return a NamedTuple of parameters from the descriptor file for each row of a dataframe, making type conversions as necessary.

Refer to the PowerSystems descriptor file for field names that will be created.

source
PowerSystems.load_csv_parser! — Method
load_csv_parser!(sys::System, data::PowerSystemTableData)

load_csv_parser!(sys::System, data::PowerSystemTableData)

Add loads to the System from the raw load data.

source
PowerSystems.loadzone_csv_parser! — Method
loadzone_csv_parser!(sys::System, data::PowerSystemTableData)

loadzone_csv_parser!(sys::System, data::PowerSystemTableData)

Add branches to the System from the raw data.

source
PowerSystems.make_bus — Method
make_bus(bus_dict::Dict{String, Any}) -> Bus

Creates a PowerSystems.Bus from a PowerSystems bus dictionary

source
PowerSystems.make_thermal_gen — Method
make_thermal_gen(gen_name::AbstractString, d::Dict, bus::Bus, sys_mbase::Number) -> ThermalStandard

The polynomial term follows the convention that for an n-degree polynomial, at least n + 1 components are needed. c(p) = cn*p^n+...+c1p+c0 co is stored in the field in of the Econ Struct

source
PowerSystems.parse_pti — Method
parse_pti(io::IO) -> Dict{String, Array{Dict, N} where N}

parse_pti(io::IO)

Reads PTI data in io::IO, returning a Dict of the data parsed into the proper types.

source
PowerSystems.parse_pti — Method
parse_pti(filename::String) -> Dict{String, Array{Dict, N} where N}

parse_pti(filename::String)

Open PTI raw file given by filename, returning a Dict of the data parsed into the proper types.

source
PowerSystems.propagate_topology_status! — Method
propagate_topology_status!(data::Dict{String, var"#s1778"} where var"#s1778")

finds active network buses and branches that are not necessary for the computation and sets their status to off.

Works on a PowerModels data dict, so that a it can be used without a GenericPowerModel object

Warning: this implementation has quadratic complexity, in the worst case

source
PowerSystems.read_gen! — Method
read_gen!(sys::System, data, bus_number_to_bus::Dict{Int64, Bus}; kwargs...)

Transfer generators to ps_dict according to their classification

source
PowerSystems.replicate — Method
replicate(sn_data::Dict{String, var"#s1777"} where var"#s1777", count::Int64; global_keys) -> Dict{String, Any}

Turns in given single network data in multinetwork data with a count replicate of the given network. Note that this function performs a deepcopy of the network data. Significant multinetwork space savings can often be achieved by building application specific methods of building multinetwork with minimal data replication.

source
PowerSystems.simplify_cost_terms! — Method
simplify_cost_terms!(data::Dict{String, var"#s1772"} where var"#s1772") -> Tuple{Set{Int64}, Set{Int64}}

trims zeros from higher order cost terms

source
PowerSystems.total_load_rating — Method
total_load_rating(sys::System) -> Any

total_load_rating(sys::System)

Checks the system for sum(generator ratings) >= sum(load ratings).

Arguments

  • sys::System: system
source
PowerSystems.update_data! — Method
update_data!(data::Dict{String, var"#s1779"} where var"#s1779", new_data::Dict{String, var"#s1778"} where var"#s1778")

recursively applies new_data to data, overwriting information

source
PowerSystems.verify_device_eligibility — Method
verify_device_eligibility(sys::System, component::StaticInjection, service::Service)

Validates if a device is eligible to contribute to a service.

Arguments

  • sys::System: PowerSystem System
  • component::StaticInjection: Static injection device
  • service::Service,: Service for which the device is eligible to contribute
source