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
PowerSystems.EX4VSA — Type
mutable struct EX4VSA <: AVR
    Iflim::Float64
    d::Float64
    f::Float64
    Spar::Float64
    K1::Float64
    K2::Float64
    Oel_lim::MinMax
    G::Float64
    Ta::Float64
    Tb::Float64
    Te::Float64
    E_lim::MinMax
    V_ref::Float64
    ext::Dict{String, Any}
    states::Vector{Symbol}
    n_states::Int
    internal::InfrastructureSystemsInternal
end

IEEE Excitation System for Voltage Security Assesment

Arguments

  • Iflim::Float64: OEL Field current limit, validation range: (0, nothing)
  • d::Float64: OEL parameter d, validation range: (0, nothing)
  • f::Float64: OEL parameter f, validation range: (0, nothing)
  • Spar::Float64: OEL parameter Spar, validation range: (0, nothing)
  • K1::Float64: OEL delay time constant, validation range: (0, nothing)
  • K2::Float64: OEL parameter K2, validation range: (0, nothing)
  • Oel_lim::MinMax: Oel integrator limits (Oelmin, Oelmax)
  • G::Float64: AVR Exciter Gain, validation range: (0, nothing)
  • Ta::Float64: Numerator lead-lag (lag) time constant in s, validation range: (0, nothing)
  • Tb::Float64: Denominator lead-lag (lag) time constant in s, validation range: (0, nothing)
  • Te::Float64: Exciter Time Constant in s, validation range: (0, nothing)
  • E_lim::MinMax: Voltage regulator limits (regulator output) (Emin, Emax)
  • V_ref::Float64: (default: 1.0) Reference Voltage Set-point (pu), validation range: (0, nothing)
  • ext::Dict{String, Any}: (default: Dict{String, Any}()) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.
  • states::Vector{Symbol}: (Do not modify.) The states are:
Vll: Lead-lag internal state,
Vex: Exciter Output, 
oel: OEL integrator state
  • n_states::Int: (Do not modify.) The EX4VSA has 3 states
  • internal::InfrastructureSystemsInternal: (Do not modify.) PowerSystems.jl internal reference
source
PowerSystems.EXST1 — Type
mutable struct EXST1 <: AVR
    Tr::Float64
    Vi_lim::MinMax
    Tc::Float64
    Tb::Float64
    Ka::Float64
    Ta::Float64
    Vr_lim::MinMax
    Kc::Float64
    Kf::Float64
    Tf::Float64
    V_ref::Float64
    ext::Dict{String, Any}
    states::Vector{Symbol}
    n_states::Int
    internal::InfrastructureSystemsInternal
end

IEEE Type ST1 Excitation System (PTI version)

Arguments

  • Tr::Float64: Voltage Measurement Time Constant in s, validation range: (0, nothing)
  • Vi_lim::MinMax: Voltage input limits (Vimin, Vimax)
  • Tc::Float64: Numerator lead-lag (lead) time constant in s, validation range: (0, nothing)
  • Tb::Float64: Denominator lead-lag (lag) time constant in s, validation range: (0, nothing)
  • Ka::Float64: Amplifier Gain, validation range: (0, nothing)
  • Ta::Float64: Amplifier Time Constant in s, validation range: (0, nothing)
  • Vr_lim::MinMax: Voltage regulator limits (regulator output) (Vrmin, Vrmax)
  • Kc::Float64: Current field constant limiter multiplier, validation range: (0, nothing)
  • Kf::Float64: Excitation control system stabilizer gain, validation range: (eps(), 0.3)
  • Tf::Float64: Excitation control system stabilizer time constant, validation range: (eps(), nothing)
  • V_ref::Float64: (default: 1.0) Reference Voltage Set-point (pu), validation range: (0, nothing)
  • ext::Dict{String, Any}: (default: Dict{String, Any}()) An extra dictionary for users to add metadata that are not used in simulation, such as latitude and longitude.
  • states::Vector{Symbol}: (Do not modify.) The states are:
Vm: Sensed Terminal Voltage,
Vrll: Lead-Lag state,
Vr: Regulator Output, 
Vfb: Feedback state
  • n_states::Int: (Do not modify.) The EXST1 has 4 states
  • internal::InfrastructureSystemsInternal: (Do not modify.) PowerSystems.jl internal reference
source
PowerSystems.PowerFlowDataNetwork — Method
PowerFlowDataNetwork(
    file::Union{IO, String};
    kwargs...
) -> PowerSystems.PowerFlowDataNetwork

Constructs PowerFlowDataNetwork from a raw file. Currently Supports PSSE data files v30, v32 and v33

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

Convert Tuple to Min Max Named Tuple

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

Convert Tuple to Up Down Named Tuple

source
PowerSystems._convert_argument_types! — Method
_convert_argument_types!(
    str::AbstractString,
    struct_args::Vector
) -> Any

Convert specific parameters to types that are not Float64 for specific inverter components

source
PowerSystems._create_starbus_from_transformer — Method
_create_starbus_from_transformer(
    pm_data::Dict,
    transformer::Dict,
    starbus_id::Int64
) -> 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._float2string — Method
_float2string(
    v::AbstractFloat,
    float_precision::Int64
) -> Union{String, WeakRefStrings.PosLenString}

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::Int64,
    field::String,
    pm_data::Dict{String, Any}
) -> 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{T} where T<:SubString, 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_comps! — Method
_import_remaining_comps!(
    data_out::Dict,
    data_in::Dict;
    exclude
)

Imports remaining top level component lists from data_in into data_out, excluding keys in exclude

source
PowerSystems._import_remaining_keys! — Method
_import_remaining_keys!(
    comp_dest::Dict,
    comp_src::Dict;
    exclude
)

Imports remaining keys from a source component into detestation component, excluding keys in exclude

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

_init_bus!(bus, id)

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

source
PowerSystems._make_market_bid_curve — Method
_make_market_bid_curve(
    data::PiecewiseStepData;
    initial_input,
    power_units,
    input_at_zero
) -> CostCurve{PiecewiseIncrementalCurve}

Auxiliary make market bid curve for timeseries with nothing inputs.

source
PowerSystems._merge_cost_data! — Method
_merge_cost_data!(
    data::Dict{String, Any}
) -> Union{Nothing, Dict{String, Any}}

merges generator cost functions into generator data, if costs exist

source
PowerSystems._parse_dera1! — Method
_parse_dera1!(
    bus_dict,
    componentID,
    componentValues,
    param_map::Dict,
    bus_num::Int64
)

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

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 and dynamic inverter components (indexed via its id).

For Generators, each dictionary indexed by id contains a vector with 5 of its components:

  • Machine
  • Shaft
  • AVR
  • TurbineGov
  • PSS

For Inverters, each dictionary indexed by id contains a vector with 7 of its components:

  • Converter
  • ActivePowerControl
  • ReactivePowerControl
  • InnerControl
  • DCSource
  • FrequencyEstimator
  • Filter
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.

Comments in .dyr files are not supported (beginning of lines with //).

source
PowerSystems._parse_dyr_generator_components! — Method
_parse_dyr_generator_components!(
    bus_dict::Dict,
    componentID,
    componentValues,
    gen_map::Dict,
    param_map::Dict
)

Parse dictionary 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 indexed by its id.

source
PowerSystems._parse_dyr_inverter_components! — Method
_parse_dyr_inverter_components!(
    bus_dict::Dict,
    inv_dict::Dict,
    componentID::Tuple{String, String},
    inv_map::Dict
)

Parse dictionary 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 inverter indexed by its 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}}

_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::Vector, val) -> Vector{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._process_get_cost — Method
_process_get_cost(
    _::Type{T},
    _,
    cost,
    transform_fn,
    start_time::Union{Nothing, Dates.DateTime},
    len::Union{Nothing, Int64}
) -> TimeSeries.TimeArray

Helper function for cost getters.

Arguments

  • T: type/eltype we expect
  • component::Component: the component
  • cost: the data: either a single element of type T or a TimeSeriesKey
  • transform_fn: a function to apply to the elements of the time series
  • start_time: as in get_time_series
  • len: as in get_time_series
source
PowerSystems._process_set_cost — Method
_process_set_cost(_, _, _, _, _::Nothing)

Helper function for cost setters.

Arguments

  • T1: type we expect if it's not a time series
  • T2: eltype we expect if it is a time series
  • sys::System: the system
  • component::Component: the component
  • cost: the data: either a single element of type T1 or a IS.TimeSeriesData of eltype T2
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
) -> Union{Nothing, Vector{Dict{String, Any}}}

_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,
    correct_branch_rating
) -> 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 unique, 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},
    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}
) -> Vector

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

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},
    bus_data::Dict{String}
) -> Dict

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},
    bus_data::Dict{String}
) -> Dict

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},
    bus_data::Dict{String}
) -> Dict

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},
    bus_data::Dict{String}
) -> Dict

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}) -> 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}) -> 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(
    pm_data::Dict{String};
    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_power_balance — Method
calc_power_balance(data::Dict{String}) -> Dict{String, Any}

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

source
PowerSystems.calculate_saturation_coefficients — Method
calculate_saturation_coefficients(
    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/E2 and uses the negative solution of the quadratic equation

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_status — Method
check_status(data::Dict{String})

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.correct_network_data! — Method
correct_network_data!(
    data::Dict{String};
    correct_branch_rating
) -> 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_transformer_parameters! — Method
correct_transformer_parameters!(
    data::Dict{String}
) -> 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}
) -> Set{Int64}
correct_voltage_angle_differences!(
    data::Dict{String},
    default_pad
) -> Set{Int64}

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

source
PowerSystems.deactivate_isolated_components! — Method
deactivate_isolated_components!(data::Dict{String}) -> Bool

removes buses with single branch connections and without any other attached components. Also removes connected components without suffuceint generation or loads.

also deactivates 0 valued loads and shunts.

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/x for Se(1.2) = B(1.2 - A)^2/1.2 and Se(1.0) = B(1.0 - A)^2/1.0 as: Se(1.0) = (Se(1.2) * 1.2) /(1.2 - A)^2 * (1.0 - A)^2/1.0 that yields (1.2 - A)^2 Se(1.0) = Se(1.2) * 1.2 * (1.0 - A)^2 or expanding: (1.2 * Se(1.2) - Se(1.0)) A^2 + (2.4 Se(1.0) - 2 * 1.2 * Se(1.2)) A + (1.2 * 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.handle_deserialization_special_cases! — Method
handle_deserialization_special_cases!(
    component::Dict,
    _::Type{<:Component}
)

Allow types to implement handling of special cases during deserialization.

Arguments

  • component::Dict: The component serialized as a dictionary.
  • ::Type: The type of the component.
source
PowerSystems.im_replicate — Method
im_replicate(
    sn_data::Dict{String},
    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::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.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}) -> ACBus

Creates a PowerSystems.ACBus from a PowerSystems bus dictionary

source
PowerSystems.make_generator — Method
make_generator(
    data::PowerSystemTableData,
    gen,
    cost_colnames,
    bus,
    gen_storage
) -> Any

Creates a generator of any type.

source
PowerSystems.make_thermal_gen — Method
make_thermal_gen(
    gen_name::Union{SubString{String}, String},
    d::Dict,
    bus::ACBus,
    sys_mbase::Float64
) -> 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_psse — Method
parse_psse(io::IO; kwargs...) -> Dict{String, Any}

function parse_psse(io::IO; kwargs...)::Dict

Parses directly from iostream

source
PowerSystems.parse_psse — Method
parse_psse(filename::String; kwargs...) -> Dict{String, Any}

parse_psse(filename::String; kwargs...)::Dict

Parses directly from file

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

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}}

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}
) -> Union{Nothing, Bool}

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_and_convert_ts — Function
read_and_convert_ts(
    ts::TimeSeriesData,
    component::Component
) -> TimeSeries.TimeArray
read_and_convert_ts(
    ts::TimeSeriesData,
    component::Component,
    start_time::Union{Nothing, Dates.DateTime}
) -> TimeSeries.TimeArray
read_and_convert_ts(
    ts::TimeSeriesData,
    component::Component,
    start_time::Union{Nothing, Dates.DateTime},
    len::Union{Nothing, Int64}
) -> TimeSeries.TimeArray
read_and_convert_ts(
    ts::TimeSeriesData,
    component::Component,
    start_time::Union{Nothing, Dates.DateTime},
    len::Union{Nothing, Int64},
    transform_fn
) -> TimeSeries.TimeArray

Call gettimeseriesarray on the given time series and return a TimeArray of the results, values mapped by `transformfn` if it is not nothing

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

Transfer generators to ps_dict according to their classification

source
PowerSystems.replicate — Method
replicate(
    sn_data::Dict{String},
    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.resolve_swithces! — Method
resolve_swithces!(data::Dict{String})

given a network data dict merges buses that are connected by closed switches converting the dataset into a pure bus-branch model.

source
PowerSystems.simplify_network! — Method
simplify_network!(data::Dict{String}) -> Bool

attempts to deactive components that are not needed in the network by repeated calls to propagate_topology_status! and deactivate_isolated_components!

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

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_bus_ids! — Method
update_bus_ids!(
    data::Dict{String},
    bus_id_map::Dict{Int64, Int64};
    injective
)

given a network data dict and a mapping of current-bus-ids to new-bus-ids modifies the data dict to reflect the proposed new bus ids.

source
PowerSystems.update_data! — Method
update_data!(data::Dict{String}, new_data::Dict{String})

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