GitHub

Public API Reference

Modeling

PowerSystems.Component — Type

Supertype for all PowerSystems components. All subtypes must include a InfrastructureSystemsInternal member. Subtypes should call InfrastructureSystemsInternal() by default, but also must provide a constructor that allows existing values to be deserialized.

source
PowerSystems.get_base_power — Method
get_base_power(c::Component) -> Float64

Default behavior of a component. If there is no base_power field, assume is in the system's base power.

source
PowerSystems.set_dynamic_injector! — Method
set_dynamic_injector!(
    static_injector::StaticInjection,
    dynamic_injector::Union{Nothing, DynamicInjection}
)

Set the dynamic injector for a static injection device.

Passes nothing to remove an existing dynamic injector from the device. Throws ArgumentError if the device already has a dynamic injector and a non-nothing value is provided.

Arguments

  • static_injector::StaticInjection: The static injection device.
  • dynamic_injector::Union{Nothing,DynamicInjection}: The dynamic injector to set, or nothing to remove it.

See also: get_dynamic_injector

source
PowerSystems.has_service — Method
has_service(device::Device, _::Type{T<:Service}) -> Bool

Return true if a service of type T is attached to the device.

Returns false immediately if the device does not support services.

Arguments

  • device::Device: The device.
  • T::Type{<:Service}: The service type to check for.

See also: has_service by instance

source
PowerSystems.ACBus — Method
ACBus(
    number,
    name,
    available,
    bustype::String,
    angle,
    voltage,
    voltage_limits,
    base_voltage,
    area,
    load_zone;
    ext
) -> ACBus

Construct an ACBus with bustype specified as a String for legacy compatibility.

The string is converted to the corresponding ACBusTypes enum value.

source
PowerSystems.DiscreteControlledACBranch — Type
DiscreteControlledACBranch(
    name,
    available,
    arc,
    active_power_flow,
    reactive_power_flow,
    r,
    x,
    rating,
    discrete_branch_type::String,
    branch_status::String
) -> DiscreteControlledACBranch
DiscreteControlledACBranch(
    name,
    available,
    arc,
    active_power_flow,
    reactive_power_flow,
    r,
    x,
    rating,
    discrete_branch_type::String,
    branch_status::String,
    ext
) -> DiscreteControlledACBranch
DiscreteControlledACBranch(
    name,
    available,
    arc,
    active_power_flow,
    reactive_power_flow,
    r,
    x,
    rating,
    discrete_branch_type::String,
    branch_status::String,
    ext,
    internal
) -> DiscreteControlledACBranch

Construct a DiscreteControlledACBranch with enum types specified as strings for legacy compatibility.

The discrete_branch_type and branch_status strings are converted to the corresponding DiscreteControlledBranchType and DiscreteControlledBranchStatus enum values.

source
PowerSystems.EnergyReservoirStorage — Type
EnergyReservoirStorage(
    name::AbstractString,
    available::Bool,
    bus,
    prime_mover_type,
    storage_technology_type,
    storage_capacity,
    storage_level_limits,
    initial_storage_capacity_level,
    rating,
    active_power,
    input_active_power_limits,
    output_active_power_limits,
    efficiency,
    reactive_power,
    reactive_power_limits,
    base_power,
    ::Nothing
)
EnergyReservoirStorage(
    name::AbstractString,
    available::Bool,
    bus,
    prime_mover_type,
    storage_technology_type,
    storage_capacity,
    storage_level_limits,
    initial_storage_capacity_level,
    rating,
    active_power,
    input_active_power_limits,
    output_active_power_limits,
    efficiency,
    reactive_power,
    reactive_power_limits,
    base_power,
    ::Nothing,
    services
)
EnergyReservoirStorage(
    name::AbstractString,
    available::Bool,
    bus,
    prime_mover_type,
    storage_technology_type,
    storage_capacity,
    storage_level_limits,
    initial_storage_capacity_level,
    rating,
    active_power,
    input_active_power_limits,
    output_active_power_limits,
    efficiency,
    reactive_power,
    reactive_power_limits,
    base_power,
    ::Nothing,
    services,
    dynamic_injector
)
EnergyReservoirStorage(
    name::AbstractString,
    available::Bool,
    bus,
    prime_mover_type,
    storage_technology_type,
    storage_capacity,
    storage_level_limits,
    initial_storage_capacity_level,
    rating,
    active_power,
    input_active_power_limits,
    output_active_power_limits,
    efficiency,
    reactive_power,
    reactive_power_limits,
    base_power,
    ::Nothing,
    services,
    dynamic_injector,
    ext
)
EnergyReservoirStorage(
    name::AbstractString,
    available::Bool,
    bus,
    prime_mover_type,
    storage_technology_type,
    storage_capacity,
    storage_level_limits,
    initial_storage_capacity_level,
    rating,
    active_power,
    input_active_power_limits,
    output_active_power_limits,
    efficiency,
    reactive_power,
    reactive_power_limits,
    base_power,
    ::Nothing,
    services,
    dynamic_injector,
    ext,
    internal
)

Construct an EnergyReservoirStorage without an explicit operational cost.

Uses a default StorageCost when operation_cost is nothing.

source
PowerSystems.FACTSControlDevice — Type
FACTSControlDevice(
    name,
    available,
    bus,
    control_mode::String,
    voltage_setpoint,
    max_shunt_current,
    reactive_power_required
) -> FACTSControlDevice
FACTSControlDevice(
    name,
    available,
    bus,
    control_mode::String,
    voltage_setpoint,
    max_shunt_current,
    reactive_power_required,
    services
) -> FACTSControlDevice
FACTSControlDevice(
    name,
    available,
    bus,
    control_mode::String,
    voltage_setpoint,
    max_shunt_current,
    reactive_power_required,
    services,
    dynamic_injector
) -> FACTSControlDevice
FACTSControlDevice(
    name,
    available,
    bus,
    control_mode::String,
    voltage_setpoint,
    max_shunt_current,
    reactive_power_required,
    services,
    dynamic_injector,
    ext
) -> FACTSControlDevice
FACTSControlDevice(
    name,
    available,
    bus,
    control_mode::String,
    voltage_setpoint,
    max_shunt_current,
    reactive_power_required,
    services,
    dynamic_injector,
    ext,
    internal
) -> FACTSControlDevice

Construct a FACTSControlDevice with control_mode specified as a string.

The string is converted to the corresponding FACTSOperationModes enum value.

source
PowerSystems.Line — Method
Line(
    name,
    available::Bool,
    active_power_flow::Float64,
    reactive_power_flow::Float64,
    arc::Arc,
    r,
    x,
    b,
    rating,
    angle_limits::Float64
) -> Line

Construct a Line accepting angle_limits as a Float64, converting it to a symmetric (min = -angle_limits, max = angle_limits) named tuple.

source
PowerSystems.RenewableGen — Type

Supertype for all renewable generation technologies

Requires the implementation of get_ratingand get_power_factor methods

source
PowerSystems.get_max_active_power — Method
get_max_active_power(d::RenewableGen) -> Float64

Return the max active power for the Renewable Generation calculated as the rating * power_factor

source
PowerSystems.get_max_reactive_power — Method
get_max_reactive_power(d::RenewableGen) -> Float64

Return the max reactive power for the Renewable Generation calculated as the rating * sin(acos(power_factor))

source
PowerSystems.Service — Type

Abstract supertype for all system services (ancillary services).

Services represent additional requirements and support to ensure reliable electricity delivery. Examples include reserve products for responding to unexpected disturbances (such as the sudden loss of a generator or transmission line), automatic generation control, and transmission interface limits.

Subtypes: AbstractReserve, AGC, ConstantReserveGroup, TransmissionInterface

source
PowerSystems.get_dynamic_components — Method
get_dynamic_components(
    device::DynamicInjection
) -> Base.Generator{I, F} where {I<:(Base.Iterators.Filter{PowerSystems.var"#get_dynamic_components##2#get_dynamic_components##3", I} where I<:(Base.Iterators.Zip{Is} where Is<:Tuple{Any, Tuple})), F<:(PowerSystems.var"#get_dynamic_components##0#get_dynamic_components##1"{<:DynamicInjection})}

Return an iterator of all DynamicComponent fields of a DynamicInjection device.

source
PowerSystems.get_states_types — Method
get_states_types(d::DynamicComponent) -> Vector{StateTypes}

Return the StateTypes for each state of a DynamicComponent.

The default implementation returns StateTypes.Differential for all states. Subtypes may override this method to specify different state types.

source
PowerSystems.add_subsystem! — Method
add_subsystem!(sys::System, subsystem_name::AbstractString)

Add a new subsystem to the system.

Subsystems are named groupings of components within a System, useful for representing e.g., regional partitions or study areas. Components must be added separately via add_component_to_subsystem!.

Throws InfrastructureSystems.InvalidValue if the number of subsystems would exceed the number of buses in the system.

See also: remove_subsystem!, get_subsystems

source
PowerSystems.get_subsystem_components — Method
get_subsystem_components(
    sys::System,
    subsystem_name::AbstractString
) -> Base.Generator{Set{Base.UUID}, InfrastructureSystems.var"#get_subsystem_components##0#get_subsystem_components##1"{InfrastructureSystems.SystemData}}

Return an iterator of all components in the subsystem.

Throws ArgumentError if the subsystem name is not stored.

See also: add_component_to_subsystem!, get_subsystems

source
InfrastructureSystems.get_fuel_cost — Method
get_fuel_cost(
    component::HybridSystem;
    start_time,
    len
) -> Union{Float64, TimeSeries.TimeArray}

Get the fuel cost of a HybridSystem's thermal subunit.

HybridSystem is a StaticInjectionSubsystem that aggregates subunits; fuel cost for thermal power comes from the ThermalGen subcomponent, not the hybrid's top-level MarketBidCost. This method delegates to get_fuel_cost on the thermal subunit when present.

Arguments

  • component::HybridSystem: The hybrid system
  • start_time: Optional start time for time series lookup
  • len: Optional length for time series lookup

Returns

The fuel cost from the thermal subunit (scalar or time series per get_fuel_cost).

Throws

  • ArgumentError if the hybrid has no thermal unit (get_thermal_unit(component) === nothing).
source
PowerSystems.get_decremental_initial_input — Method
get_decremental_initial_input(
    device::StaticInjection,
    cost::MarketBidCost;
    start_time,
    len
) -> Union{Nothing, TimeSeries.TimeArray}

Retrieve the decremental_initial_input for a StaticInjection device with a MarketBidCost. If this field is a time series, the user may specify start_time and len and the function returns a TimeArray of Float64s; if the field is not a time series, the function returns a single Float64 or nothing.

source
PowerSystems.get_decremental_offer_curves — Method
get_decremental_offer_curves(
    device::StaticInjection,
    cost::MarketBidCost;
    start_time,
    len
) -> Union{Nothing, CostCurve{PiecewiseIncrementalCurve}, TimeSeries.TimeArray}

Retrieve the decremental_offer_curves for a StaticInjection device with a MarketBidCost. If this field is a time series, the user may specify start_time and len and the function returns a TimeArray of PiecewiseStepDatas; if the field is not a time series, the function returns a single CostCurve{PiecewiseIncrementalCurve} or nothing.

source
PowerSystems.get_decremental_variable_cost — Method
get_decremental_variable_cost(
    device::StaticInjection,
    cost::MarketBidCost;
    start_time,
    len
) -> Union{Nothing, CostCurve{PiecewiseIncrementalCurve}, TimeSeriesKey, TimeSeries.TimeArray}

Retrieve the decremental variable cost bid for a StaticInjection device with a MarketBidCost. If any of the relevant fields (decremental_offer_curves, decremental_initial_input, no_load_cost) are time series, the user may specify start_time and len and the function returns a TimeArray of CostCurve{PiecewiseIncrementalCurve}s; if the field is not a time series, the function returns a single CostCurve{PiecewiseIncrementalCurve} or nothing.

source
PowerSystems.get_export_offer_curves — Method
get_export_offer_curves(
    device::StaticInjection,
    cost::ImportExportCost;
    start_time,
    len
) -> Union{CostCurve{PiecewiseIncrementalCurve}, TimeSeries.TimeArray}

Retrieve the export_offer_curves for a StaticInjection device with a ImportExportCost. If this field is a time series, the user may specify start_time and len and the function returns a TimeArray of PiecewiseStepDatas; if the field is not a time series, the function returns a single CostCurve{PiecewiseIncrementalCurve} or nothing.

source
PowerSystems.get_export_variable_cost — Method
get_export_variable_cost(
    device::StaticInjection,
    cost::ImportExportCost;
    start_time,
    len
) -> Union{Nothing, CostCurve{PiecewiseIncrementalCurve}, TimeSeriesKey, TimeSeries.TimeArray}

Retrieve the export variable cost bid for a StaticInjection device with an ImportExportCost. If export_offer_curves is a time series, the user may specify start_time and len and the function returns a TimeArray of CostCurve{PiecewiseIncrementalCurve}s; if the field is not a time series, the function returns a single CostCurve{PiecewiseIncrementalCurve} or nothing.

source
PowerSystems.get_import_offer_curves — Method
get_import_offer_curves(
    device::StaticInjection,
    cost::ImportExportCost;
    start_time,
    len
) -> Union{CostCurve{PiecewiseIncrementalCurve}, TimeSeries.TimeArray}

Retrieve the import_offer_curves for a StaticInjection device with a ImportExportCost. If this field is a time series, the user may specify start_time and len and the function returns a TimeArray of PiecewiseStepDatas; if the field is not a time series, the function returns a single CostCurve{PiecewiseIncrementalCurve} or nothing.

source
PowerSystems.get_import_variable_cost — Method
get_import_variable_cost(
    device::StaticInjection,
    cost::ImportExportCost;
    start_time,
    len
) -> Union{Nothing, CostCurve{PiecewiseIncrementalCurve}, TimeSeriesKey, TimeSeries.TimeArray}

Retrieve the import variable cost bid for a StaticInjection device with an ImportExportCost. If import_offer_curves is a time series, the user may specify start_time and len and the function returns a TimeArray of CostCurve{PiecewiseIncrementalCurve}s; if the field is not a time series, the function returns a single CostCurve{PiecewiseIncrementalCurve} or nothing.

source
PowerSystems.get_incremental_initial_input — Method
get_incremental_initial_input(
    device::StaticInjection,
    cost::MarketBidCost;
    start_time,
    len
) -> Union{Nothing, TimeSeries.TimeArray}

Retrieve the incremental_initial_input for a StaticInjection device with a MarketBidCost. If this field is a time series, the user may specify start_time and len and the function returns a TimeArray of Float64s; if the field is not a time series, the function returns a single Float64 or nothing.

source
PowerSystems.get_incremental_offer_curves — Method
get_incremental_offer_curves(
    device::StaticInjection,
    cost::MarketBidCost;
    start_time,
    len
) -> Union{Nothing, CostCurve{PiecewiseIncrementalCurve}, TimeSeries.TimeArray}

Retrieve the incremental_offer_curves for a StaticInjection device with a MarketBidCost. If this field is a time series, the user may specify start_time and len and the function returns a TimeArray of PiecewiseStepDatas; if the field is not a time series, the function returns a single CostCurve{PiecewiseIncrementalCurve} or nothing.

source
PowerSystems.get_incremental_variable_cost — Method
get_incremental_variable_cost(
    device::StaticInjection,
    cost::MarketBidCost;
    start_time,
    len
) -> Union{Nothing, CostCurve{PiecewiseIncrementalCurve}, TimeSeriesKey, TimeSeries.TimeArray}

Retrieve the incremental variable cost bid for a StaticInjection device with a MarketBidCost. If any of the relevant fields (incremental_offer_curves, incremental_initial_input, no_load_cost) are time series, the user may specify start_time and len and the function returns a TimeArray of CostCurve{PiecewiseIncrementalCurve}s; if the field is not a time series, the function returns a single CostCurve{PiecewiseIncrementalCurve}.

source
PowerSystems.get_no_load_cost — Method
get_no_load_cost(
    device::StaticInjection,
    cost::MarketBidCost;
    start_time,
    len
) -> Union{Nothing, Float64, TimeSeries.TimeArray}

Retrieve the no-load cost data for a StaticInjection device with a MarketBidCost. If this field is a time series, the user may specify start_time and len and the function returns a TimeArray of Float64s; if the field is not a time series, the function returns a single Float64 or nothing.

source
PowerSystems.get_shut_down — Method
get_shut_down(
    device::StaticInjection,
    cost::MarketBidCost;
    start_time,
    len
) -> Union{Float64, TimeSeries.TimeArray}

Retrieve the shutdown cost data for a StaticInjection device with a MarketBidCost. If this field is a time series, the user may specify start_time and len and the function returns a TimeArray of Float64s; if the field is not a time series, the function returns a single Float64.

source
PowerSystems.get_start_up — Method
get_start_up(
    device::StaticInjection,
    cost::MarketBidCost;
    start_time,
    len
) -> Union{@NamedTuple{hot::Float64, warm::Float64, cold::Float64}, TimeSeries.TimeArray}

Retrieve the startup cost data for a StaticInjection device with a MarketBidCost. If this field is a time series, the user may specify start_time and len and the function returns a TimeArray of StartUpStagess; if the field is not a time series, the function returns a single StartUpStages.

source
PowerSystems.get_variable_cost — Method
get_variable_cost(
    service::ReserveDemandCurve;
    start_time,
    len
) -> Union{CostCurve{PiecewiseIncrementalCurve}, TimeSeries.TimeArray}

Retrieve the variable cost data for a ReserveDemandCurve. The user may specify start_time and len and the function returns a TimeArray of CostCurves.

source
PowerSystems.get_variable_cost — Method
get_variable_cost(
    device::StaticInjection,
    cost::MarketBidCost;
    start_time,
    len
) -> Union{Nothing, CostCurve{PiecewiseIncrementalCurve}, TimeSeriesKey, TimeSeries.TimeArray}

Retrieve the variable cost bid for a StaticInjection device with a MarketBidCost. If any of the relevant fields (incremental_offer_curves, incremental_initial_input, no_load_cost) are time series, the user may specify start_time and len and the function returns a TimeArray of CostCurve{PiecewiseIncrementalCurve}s; if the field is not a time series, the function returns a single CostCurve{PiecewiseIncrementalCurve}.

source
PowerSystems.set_decremental_initial_input! — Method
set_decremental_initial_input!(
    sys::System,
    component::StaticInjection,
    data::Union{Float64, TimeSeriesData}
) -> Union{ForecastKey, StaticTimeSeriesKey}

Set the decremental_initial_input for a StaticInjection device with a MarketBidCost to either a scalar or a time series.

Arguments

  • sys::System: PowerSystem System
  • component::StaticInjection: Static injection device
  • time_series_data::Union{Float64, IS.TimeSeriesData}: the data. If a time series, must be of eltype Float64.
source
PowerSystems.set_decremental_variable_cost! — Method
set_decremental_variable_cost!(
    sys::System,
    component::StaticInjection,
    data::Union{Nothing, CostCurve{PiecewiseIncrementalCurve}, TimeSeriesData},
    power_units::UnitSystem
)

Set the decremental variable cost bid for a StaticInjection device with a MarketBidCost.

Arguments

source
PowerSystems.set_export_variable_cost! — Method
set_export_variable_cost!(
    sys::System,
    component::StaticInjection,
    data::Union{Nothing, CostCurve{PiecewiseIncrementalCurve}, TimeSeriesData},
    power_units::UnitSystem
)

Set the export variable cost bid for a StaticInjection device with an ImportExportCost.

Arguments

source
PowerSystems.set_fuel_cost! — Method
set_fuel_cost!(
    sys::System,
    component::StaticInjection,
    data::Union{Float64, TimeSeriesData}
) -> Any

Set the fuel cost of the component's variable cost, which must be a FuelCurve.

source
PowerSystems.set_import_variable_cost! — Method
set_import_variable_cost!(
    sys::System,
    component::StaticInjection,
    data::Union{Nothing, CostCurve{PiecewiseIncrementalCurve}, TimeSeriesData},
    power_units::UnitSystem
)

Set the import variable cost bid for a StaticInjection device with an ImportExportCost.

Arguments

source
PowerSystems.set_incremental_initial_input! — Method
set_incremental_initial_input!(
    sys::System,
    component::StaticInjection,
    data::Union{Float64, TimeSeriesData}
) -> Union{ForecastKey, StaticTimeSeriesKey}

Set the incremental_initial_input for a StaticInjection device with a MarketBidCost to either a scalar or a time series.

Arguments

  • sys::System: PowerSystem System
  • component::StaticInjection: Static injection device
  • time_series_data::Union{Float64, IS.TimeSeriesData}: the data. If a time series, must be of eltype Float64.
source
PowerSystems.set_incremental_variable_cost! — Method
set_incremental_variable_cost!(
    sys::System,
    component::StaticInjection,
    data::Union{Nothing, CostCurve{PiecewiseIncrementalCurve}, TimeSeriesData},
    power_units::UnitSystem
)

Set the incremental variable cost bid for a StaticInjection device with a MarketBidCost.

Arguments

source
PowerSystems.set_no_load_cost! — Method
set_no_load_cost!(
    sys::System,
    component::StaticInjection,
    data::Union{Float64, TimeSeriesData}
) -> Union{Float64, ForecastKey, StaticTimeSeriesKey}

Set the no-load cost for a StaticInjection device with a MarketBidCost to either a scalar or a time series.

Arguments

  • sys::System: PowerSystem System
  • component::StaticInjection: Static injection device
  • time_series_data::Union{Float64, IS.TimeSeriesData}: the data. If a time series, must be of eltype Float64.
source
PowerSystems.set_service_bid! — Method
set_service_bid!(
    sys::System,
    component::StaticInjection,
    service::Service,
    time_series_data::TimeSeriesData,
    power_units::UnitSystem
)

Adds service bids time-series data to the MarketBidCost.

Arguments

  • sys::System: PowerSystem System
  • component::StaticInjection: Static injection device
  • service::Service: Service for which the device is eligible to contribute
  • time_series_data::IS.TimeSeriesData: TimeSeriesData
source
PowerSystems.set_shut_down! — Method
set_shut_down!(
    sys::System,
    component::StaticInjection,
    data::Union{Float64, TimeSeriesData}
) -> Union{Float64, ForecastKey, StaticTimeSeriesKey}

Set the shutdown cost for a StaticInjection device with a MarketBidCost to either a single number or a time series.

Arguments

  • sys::System: PowerSystem System
  • component::StaticInjection: Static injection device
  • data::Union{Float64, IS.TimeSeriesData}: the data. If a time series, must be of eltype Float64.
source
PowerSystems.set_start_up! — Method
set_start_up!(
    sys::System,
    component::StaticInjection,
    data::Union{Float64, @NamedTuple{hot::Float64, warm::Float64, cold::Float64}, TimeSeriesData}
) -> Union{Float64, @NamedTuple{hot::Float64, warm::Float64, cold::Float64}, ForecastKey, StaticTimeSeriesKey}

Set the startup cost for a StaticInjection device with a MarketBidCost to either a single number, a single StartUpStages, or a time series.

Arguments

  • sys::System: PowerSystem System
  • component::StaticInjection: Static injection device
  • data::Union{Float64,StartUpStages,TimeSeriesData}: the data. If a time series, must be of eltype NTuple{3, Float64} – to represent a single value in a time series, use (value, 0.0, 0.0).
source
PowerSystems.set_variable_cost! — Method
set_variable_cost!(
    sys::System,
    component::StaticInjection,
    data::Union{Nothing, CostCurve{PiecewiseIncrementalCurve}, TimeSeriesData},
    power_units::UnitSystem
)

Set the incremental variable cost bid for a StaticInjection device with a MarketBidCost.

Arguments

source
PowerSystems.ACBusTypesModule.ACBusTypes — Type

Enumeration of AC power system bus types (MATPOWER Table B-1). Each variant corresponds to a standard bus classification used in power flow and steady-state network models. Set on an ACBus via the bustype field.

ValueDescription
ISOLATEDDisconnected from network
PQActive and reactive power defined (load bus)
PVActive power and voltage magnitude defined (generator bus)
REFReference bus (θ = 0)
SLACKSlack bus

Notes

  • Numeric values follow the MATPOWER convention for bus type codes.
  • Use the enum members (e.g., ACBusTypes.PQ, ACBusTypes.SLACK) when constructing or interpreting network data to ensure compatibility with MATPOWER-based data conventions.

References

source
PowerSystems.AngleUnitsModule.AngleUnits — Type

AngleUnits

Enumeration of angular measurement units used throughout PowerSystems.jl.

ValueDescription
DEGREESAngles expressed in degrees
RADIANSAngles expressed in radians

Notes

When performing trigonometric calculations with Julia's built-in functions (sin, cos, etc.), convert degrees to radians first (e.g., θ * π/180) if the unit is DEGREES.

source
PowerSystems.CombinedCycleConfigurationModule.CombinedCycleConfiguration — Type

Enumeration describing the physical layout of a combined cycle power plant.

ValueDescription
SingleShaftCombustionSteamSingle combustion turbine on a common shaft with one steam turbine
SeparateShaftCombustionSteamOne combustion turbine and one steam turbine on separate shafts
DoubleCombustionOneSteamTwo combustion turbines exhausting into one steam turbine
TripleCombustionOneSteamThree combustion turbines exhausting into one steam turbine
OtherAny other combined cycle configuration not covered by the above values

See Also

source
PowerSystems.DiscreteControlledBranchStatusModule.DiscreteControlledBranchStatus — Type

DiscreteControlledBranchStatus

Enumeration describing the controlled (commanded) status of a branch device such as a breaker or switch. Used with DiscreteControlledACBranch.

ValueDescription
OPENThe device is open (non-conducting)
CLOSEDThe device is closed (conducting)

Notes

Represents the intended or commanded state used by control and protection logic; it may differ from the actual measured/telemetry state during faults or failures.

source
PowerSystems.DiscreteControlledBranchTypeModule.DiscreteControlledBranchType — Type

DiscreteControlledBranchType

Enumeration of discrete controlled branch device types.

ValueDescription
SWITCHSwitching device that can be opened or closed to connect or isolate a circuit segment
BREAKERCircuit breaker capable of interrupting fault current
OTHEROther discrete branch device not covered by the above categories

See Also

source
PowerSystems.FACTSOperationModesModule.FACTSOperationModes — Type

Enumeration of operational modes for FACTS (Flexible AC Transmission System) devices, as defined in the PSS/E POM v33 Manual.

ValueDescription
OOSOut-Of-Service (i.e., Series and Shunt links open)
NMLNormal mode of operation, where Series and Shunt links are operating
BYPSeries link is bypassed (i.e., like a zero impedance line) and Shunt link operates as a STATCOM

References

  • PSS/E Power Operations Manual v33, FACTS device specification.
source
PowerSystems.HydroTurbineTypeModule.HydroTurbineType — Type

HydroTurbineType

Enumeration of hydroelectric turbine designs, used to classify hydro generating units by operating head range and flow characteristics.

ValueDescription
UNKNOWNTurbine type is not specified
PELTONImpulse turbine for high-head, low-flow sites
FRANCISReaction turbine, widely used for medium-head applications
KAPLANAdjustable-blade propeller turbine for low-head, high-flow sites
TURGOImpulse turbine similar to Pelton but suitable for higher flow rates
CROSSFLOWBanki-Michell (crossflow) impulse turbine, robust for small hydro
BULBCompact Kaplan variant for low-head run-of-river plants
DERIAZDiagonal flow reaction turbine with variable pitch blades
PROPELLERFixed-blade propeller turbine
OTHERPlaceholder for less common or custom turbine designs

See Also

  • HydroTurbine: Hydro generator component using this enumeration.
source
PowerSystems.ImpedanceCorrectionTransformerControlModeModule.ImpedanceCorrectionTransformerControlMode — Type

ImpedanceCorrectionTransformerControlMode

Enumeration of control modes for impedance correction in transformers, as defined in the PSS/E transformer control specifications.

ValueDescription
PHASE_SHIFT_ANGLEImpedance correction as a function of phase shift angle (phase-shifting transformers)
TAP_RATIOImpedance correction as a function of tap ratio (tap-changing transformers)

See Also

source
PowerSystems.LoadConformityModule.LoadConformity — Type

WECC-defined enumeration for load conformity classification used in dynamic modeling.

Load conformity indicates whether a load follows system voltage and frequency variations according to WECC modeling standards:

ValueDescription
NON_CONFORMINGNon-conforming load
CONFORMINGConforming load
UNDEFINEDUndefined or unknown whether load is conforming or non-conforming

See Also

source
PowerSystems.PollutantTypeModule.PollutantType — Type

Enumeration of pollutant types for emissions tracking.

ValueDescription
CO2Carbon dioxide
CO2ECarbon dioxide equivalent
CH4Methane
N2ONitrous oxide
NOXNitrogen oxides
SO2Sulfur dioxide
PM25Particulate matter (2.5 μm)
PM10Particulate matter (10 μm)
HGMercury
HAPHazardous air pollutants
CUSTOMUser-defined pollutant
source
PowerSystems.PrimeMoversModule.PrimeMovers — Type

Enumeration of prime mover types used in electric power generation, as defined by the U.S. Energy Information Administration (EIA) Form 923 instructions.

Prime movers are the engines, turbines, water wheels, or similar machines that drive electric generators or provide mechanical energy for other purposes.

Notes

PVe is used for photovoltaic systems, renamed from the EIA code PV to avoid a naming conflict with ACBusTypes PV.

ValueDescription
BAEnergy Storage, Battery
BTTurbines Used in a Binary Cycle (including those used for geothermal applications)
CACombined-Cycle – Steam Part
CCCombined-Cycle - Aggregated Plant *augmentation of EIA
CEEnergy Storage, Compressed Air
CPEnergy Storage, Concentrated Solar Power
CSCombined-Cycle Single-Shaft Combustion turbine and steam turbine share a single generator
CTCombined-Cycle Combustion Turbine Part
ESEnergy Storage, Other
FCFuel Cell
FWEnergy Storage, Flywheel
GTCombustion (Gas) Turbine (including jet engine design)
HAHydrokinetic, Axial Flow Turbine
HBHydrokinetic, Wave Buoy
HKHydrokinetic, Other
HYHydraulic Turbine (including turbines associated with delivery of water by pipeline)
ICInternal Combustion (diesel, piston, reciprocating) Engine
PSEnergy Storage, Reversible Hydraulic Turbine (Pumped Storage)
OTOther
STSteam Turbine (including nuclear, geothermal and solar steam; does not include combined-cycle turbine)
PVePhotovoltaic (Note: renamed from EIA PV to avoid conflict with ACBusTypes.PV)
WTWind Turbine, Onshore
WSWind Turbine, Offshore

References

See Also

source
PowerSystems.ReservoirDataTypeModule.ReservoirDataType — Type

Enumeration of the quantity type used to represent the state of a HydroReservoir.

ValueUnitsDescription
USABLE_VOLUMEm^3The volume of water that can be stored for levels between the penstock intake and the top reservoir level
TOTAL_VOLUMEm^3The total volume of the reservoir considering a total depletion of the water levels. This unit system usually requires the specification of a valid minimum volume level
HEADmThe difference in elevations between the top water levels. It requires a valid conversion constant to go from head to potential energy stored.
ENERGYMWhUses energy units in MWh to approximate the water storage as a generic energy reservoir.

See Also

source
PowerSystems.StateTypesModule.StateTypes — Type

StateTypes

Categorization of state variable types for dynamic components.

ValueDescription
DifferentialState governed by a differential equation (evolves continuously in time)
AlgebraicState determined by an algebraic constraint (no time derivative)
HybridState that can behave as differential or algebraic depending on operating conditions

See Also

  • DynamicComponent: Abstract base type whose states are classified by this enumeration.
source
PowerSystems.StorageTechModule.StorageTech — Type

Enumeration of energy storage technologies used in power system modeling.

ValueDescription
PTESPumped thermal energy storage
LIBLiON Battery
LABLead Acid Battery
FLWBRedox Flow Battery
SIBSodium Ion Battery
ZIBZinc Ion Battery
HGSHydrogen Gas Storage
LAESLiquid Air Storage
OTHER_CHEMOther Chemical Storage
OTHER_MECHOther Mechanical Storage
OTHER_THERMOther Thermal Storage

See Also

source
PowerSystems.ThermalFuelsModule.ThermalFuels — Type

Enumeration of thermal fuel types, using EIA Form 923 fuel codes for standardized reporting of fuel consumption in electric power generation.

Categories include: coal and coal-derived fuels, petroleum products, natural gas, nuclear, biomass and waste-derived fuels, geothermal, and other thermal energy sources.

ValueEIA Fuel CodeDescription
ANTHRACITE_COALANTAnthracite Coal
BITUMINOUS_COALBITBituminous Coal
LIGNITE_COALLIGLignite Coal
SUBBITUMINOUS_COALSUBSubbituminous Coal
WASTE_COALWCWaste/Other Coal (including anthracite culm, bituminous gob, fine coal, lignite waste, waste coal)
REFINED_COALRCRefined Coal (A coal product that improves heat content and reduces emissions. Excludes coal processed by coal preparation plants.)
SYNTHESIS_GAS_COALSGCCoal-Derived Synthesis Gas
DISTILLATE_FUEL_OILDFODistillate Fuel Oil (including diesel, No. 1, No. 2, and No. 4 fuel oils)
JET_FUELJFJet Fuel
KEROSENEKERKerosene
PETROLEUM_COKEPCPetroleum Coke
RESIDUAL_FUEL_OILRFOResidual Fuel Oil (including No. 5 and No. 6 fuel oils, and bunker C fuel oil)
PROPANEPGPropane, gaseous
SYNTHESIS_GAS_PETROLEUM_COKESGPPetroleum Coke Derived Synthesis Gas
WASTE_OILWOWaste/Other Oil (including crude oil, liquid butane, liquid propane, naphtha, oil waste, re-refined motor oil, sludge oil, tar oil)
BLASTE_FURNACE_GASBFGBlast Furnace Gas
NATURAL_GASNGNatural Gas
OTHER_GASOGOther Gas
AG_BYPRODUCTABAgricultural By-products
MUNICIPAL_WASTEMSWMunicipal Solid Waste
OTHER_BIOMASS_SOLIDSOBSOther Biomass Solids
WOOD_WASTE_SOLIDSWDSWood/Wood Waste Solids (including paper, pellets, railroad ties, utility poles, wood chips, bark, and wood waste solids)
OTHER_BIOMASS_LIQUIDSOBLOther Biomass Liquids
SLUDGE_WASTESLWSludge Waste
BLACK_LIQUORBLQBlack Liquor
WOOD_WASTE_LIQUIDSWDLWood Waste Liquids excluding Black Liquor (includes red liquor, sludge wood, spent sulfite liquor, and other wood-based liquids)
LANDFILL_GASLFGLandfill Gas
OTHEHR_BIOMASS_GASOBGOther Biomass Gas (includes digester gas, methane, and other biomass gasses)
NUCLEARNUCNuclear Uranium, Plutonium, Thorium
WASTE_HEATWHWaste heat not directly attributed to a fuel source
TIREDERIVED_FUELTDFTire-derived Fuels
COAL*N/AGeneral Coal Fuels
GEOTHERMAL*GEOGeothermal Fuels
OTHEROTHOther type of fuel

*Asterisk denotes fuel codes not directly from the current EIA 923 form but kept for compatibility with older versions of the form.

Notes

COAL (general coal) and GEOTHERMAL codes are not directly from the current EIA 923 form but are retained for compatibility with older data.

References

See Also

source
PowerSystems.WindingCategoryModule.WindingCategory — Type

WindingCategory

Enumeration of transformer winding roles used to interpret a ImpedanceCorrectionData (Transformer Impedance Correction Table) association.

ValueDescription
TR2W_WINDINGWinding of a two-winding transformer connected to ImpedanceCorrectionData
PRIMARY_WINDINGPrimary winding of a three-winding transformer connected to ImpedanceCorrectionData
SECONDARY_WINDINGSecondary winding of a three-winding transformer connected to ImpedanceCorrectionData
TERTIARY_WINDINGTertiary winding of a three-winding transformer connected to ImpedanceCorrectionData

See Also

source
PowerSystems.WindingGroupNumberModule.WindingGroupNumber — Type

WindingGroupNumber

Enumeration of transformer winding group numbers representing the phase displacement between primary and secondary windings of three-phase transformers, per IEC 60076-1.

ValueDescription
UNDEFINEDWinding group not specified
GROUP_00° phase displacement (e.g., Yy0, Dd0, Dz0)
GROUP_1−30° phase displacement (e.g., Dy1, Yd1, Yz1)
GROUP_5−150° phase displacement (e.g., Dy5, Yd5, Yz5)
GROUP_6180° phase displacement (e.g., Yy6, Dd6, Dz6)
GROUP_7150° phase displacement (e.g., Dy7, Yd7, Yz7)
GROUP_1130° phase displacement (e.g., Dy11, Yd11, Yz11)

Notes

  • Phase displacement is measured from primary to secondary winding; positive angles lead and negative angles lag.
  • Clock notation: each clock hour represents 30°.

References

  • IEC 60076-1: Power transformers — General.
source

Supplemental Attributes

InfrastructureSystems.SupplementalAttribute — Type

Base type for structs that store supplemental attributes

Required interface functions for subtypes:

  • get_internal()

Optional interface functions:

  • get_uuid()

Subtypes may contain time series. Which requires

  • supports_time_series(::SupplementalAttribute)

All subtypes must include an instance of ComponentUUIDs in order to track components attached to each attribute.

source
PowerSystems.FixedForcedOutage — Type
struct FixedForcedOutage <: UnplannedOutage
    outage_status::Float64
    monitored_components::Set{Base.UUID}
    internal::InfrastructureSystemsInternal
end

Supplemental attribute for forced outages with a deterministic (fixed) outage status. The status value can be derived from stochastic process simulations or historical data, and may vary over time via attached time series data.

Arguments

  • outage_status::Float64: Forced outage status of the component: 1.0 indicates outaged (unavailable), 0.0 indicates available.
  • monitored_components::Set{Base.UUID}: UUIDs of devices whose post-contingency state should be modeled when this outage occurs. Empty by default; semantics of an empty set are decided by the downstream consumer.
  • internal::InfrastructureSystems.InfrastructureSystemsInternal: (Do not modify.) PowerSystems.jl internal reference.

See Also

source
PowerSystems.FixedForcedOutage — Method
FixedForcedOutage(
;
    outage_status,
    monitored_components,
    internal
)

FixedForcedOutage(; outage_status, monitored_components, internal)

Construct a FixedForcedOutage.

Arguments

  • outage_status::Float64: Forced outage status of the component: 1.0 indicates outaged (unavailable), 0.0 indicates available.
  • monitored_components: (default: Base.UUID[]) Any iterable of Base.UUID or Device. Devices are converted to their UUIDs internally; duplicates are collapsed.
  • internal::InfrastructureSystems.InfrastructureSystemsInternal: (default: InfrastructureSystemsInternal()) (Do not modify.) PowerSystems.jl internal reference.
source
PowerSystems.GeometricDistributionForcedOutage — Type
struct GeometricDistributionForcedOutage <: UnplannedOutage
    mean_time_to_recovery::Float64
    outage_transition_probability::Float64
    monitored_components::Set{Base.UUID}
    internal::InfrastructureSystemsInternal
end

Supplemental attribute for unplanned forced outages with transition probabilities modeled by geometric distributions. Both the outage probability and the recovery probability can vary over time and be attached as time series data.

Arguments

  • mean_time_to_recovery::Float64: Expected time elapsed to recovery after a failure, in milliseconds.
  • outage_transition_probability::Float64: Per-timestep probability of failure; parameterizes the geometric distribution as (1 - p).
  • monitored_components::Set{Base.UUID}: UUIDs of devices whose post-contingency state should be modeled when this outage occurs. Empty by default; semantics of an empty set are decided by the downstream consumer.
  • internal::InfrastructureSystems.InfrastructureSystemsInternal: (Do not modify.) PowerSystems.jl internal reference.

See Also

source
PowerSystems.GeometricDistributionForcedOutage — Method
GeometricDistributionForcedOutage(
;
    mean_time_to_recovery,
    outage_transition_probability,
    monitored_components,
    internal
) -> GeometricDistributionForcedOutage

GeometricDistributionForcedOutage(; mean_time_to_recovery, outage_transition_probability, monitored_components, internal)

Construct a GeometricDistributionForcedOutage.

Arguments

  • mean_time_to_recovery::Float64: (default: 0.0) Expected time elapsed to recovery after a failure, in milliseconds.
  • outage_transition_probability::Float64: (default: 0.0) Per-timestep probability of failure; parameterizes the geometric distribution as (1 - p).
  • monitored_components: (default: Base.UUID[]) Any iterable of Base.UUID or Device. Devices are converted to their UUIDs internally; duplicates are collapsed.
  • internal::InfrastructureSystems.InfrastructureSystemsInternal: (default: InfrastructureSystemsInternal()) (Do not modify.) PowerSystems.jl internal reference.
source
PowerSystems.Outage — Type

Supertype for outage contingencies representing planned or unplanned equipment outages.

Concrete subtypes include GeometricDistributionForcedOutage, PlannedOutage, and FixedForcedOutage.

Interface for custom subtypes

Subtypes are expected to provide the following fields, or override the matching accessors via multiple dispatch:

The default supports_time_series returns true; override for custom outage types that do not support time series.

source
PowerSystems.PlannedOutage — Type
struct PlannedOutage <: Outage
    outage_schedule::String
    monitored_components::Set{Base.UUID}
    internal::InfrastructureSystemsInternal
end

Supplemental attribute for planned (scheduled) outages. The outage schedule is stored as a time series identified by the outage_schedule name string.

Arguments

  • outage_schedule::String: Name of the time series containing the outage schedule.
  • monitored_components::Set{Base.UUID}: UUIDs of devices whose post-contingency state should be modeled when this outage occurs. Empty by default; semantics of an empty set are decided by the downstream consumer.
  • internal::InfrastructureSystems.InfrastructureSystemsInternal: (Do not modify.) PowerSystems.jl internal reference.

See Also

source
PowerSystems.PlannedOutage — Method
PlannedOutage(
;
    outage_schedule,
    monitored_components,
    internal
)

PlannedOutage(; outage_schedule, monitored_components, internal)

Construct a PlannedOutage.

Arguments

  • outage_schedule::String: Name of the time series containing the outage schedule.
  • monitored_components: (default: Base.UUID[]) Any iterable of Base.UUID or Device. Devices are converted to their UUIDs internally; duplicates are collapsed.
  • internal::InfrastructureSystems.InfrastructureSystemsInternal: (default: InfrastructureSystemsInternal()) (Do not modify.) PowerSystems.jl internal reference.
source
PowerSystems.get_monitored_components — Method
get_monitored_components(value::Outage) -> Any

Get the set of Device UUIDs whose post-contingency state should be modeled when this outage occurs. PowerSystems does not assign meaning to an empty set; downstream consumers (e.g., PowerSimulations) decide whether empty means "monitor nothing" or "monitor everything".

source
PowerSystems.Contingency — Type

Supertype for contingency events that can be attached to components as supplemental attributes.

Concrete subtypes include Outage and its descendants.

source
PowerSystems.ImpedanceCorrectionData — Type
struct ImpedanceCorrectionData <: SupplementalAttribute
    table_number::Int64
    impedance_correction_curve::PiecewiseLinearData
    transformer_winding::WindingCategory
    transformer_control_mode::ImpedanceCorrectionTransformerControlMode
    internal::InfrastructureSystemsInternal
end

Supplemental attribute representing a single row of a Transformer Impedance Correction Table (TICT). Adjusts transformer impedance as a piecewise-linear function of tap ratio or phase shift angle.

Arguments

  • table_number::Int64: Row number of the TICT, used to link this correction entry to a specific transformer component.
  • impedance_correction_curve::PiecewiseLinearData: Piecewise-linear function defining impedance correction intervals as a function of tap ratio or phase shift angle.
  • transformer_winding::WindingCategory: Winding of the transformer this correction entry is associated with.
  • transformer_control_mode::ImpedanceCorrectionTransformerControlMode: Control mode determining whether correction is applied based on tap ratio or phase shift angle.
  • internal::InfrastructureSystemsInternal: (Do not modify.) PowerSystems.jl internal reference.

See Also

source
PowerSystems.ImpedanceCorrectionData — Method
ImpedanceCorrectionData(
;
    table_number,
    impedance_correction_curve,
    transformer_winding,
    transformer_control_mode,
    internal
)

ImpedanceCorrectionData(; table_number, impedance_correction_curve, transformer_winding, transformer_control_mode, internal)

Construct an ImpedanceCorrectionData.

Arguments

  • table_number::Int64: Row number of the TICT, used to link this correction entry to a specific transformer component.
  • impedance_correction_curve::PiecewiseLinearData: Piecewise-linear function defining impedance correction intervals as a function of tap ratio or phase shift angle.
  • transformer_winding::WindingCategory: Winding of the transformer this correction entry is associated with.
  • transformer_control_mode::ImpedanceCorrectionTransformerControlMode: Control mode determining whether correction is applied based on tap ratio or phase shift angle.
  • internal::InfrastructureSystemsInternal: (default: InfrastructureSystemsInternal()) (Do not modify.) PowerSystems.jl internal reference.
source
PowerSystems.CombinedCycleBlock — Type
struct CombinedCycleBlock <: PowerPlant
    name::String
    configuration::CombinedCycleConfiguration
    heat_recovery_to_steam_factor::Float64
    hrsg_ct_map::Dict{Int, Vector{Base.UUID}}
    hrsg_ca_map::Dict{Int, Vector{Base.UUID}}
    ct_hrsg_map::Dict{Base.UUID, Vector{Int}}
    ca_hrsg_map::Dict{Base.UUID, Vector{Int}}
    internal::InfrastructureSystemsInternal
end

Supplemental attribute representing a combined cycle plant modeled at the block level, where combustion turbines (CTs) feed heat recovery steam generators (HRSGs) that drive combined-cycle steam turbines (CAs). The internal maps capture the CT→HRSG→CA topology.

Arguments

  • name::String: Name of the combined cycle block.
  • configuration::CombinedCycleConfiguration: Configuration type of the combined cycle plant.
  • heat_recovery_to_steam_factor::Float64: Fraction of CT exhaust heat recovered by the HRSG for steam generation.
  • hrsg_ct_map::Dict{Int, Vector{Base.UUID}}: Mapping from HRSG index to the UUIDs of CTs feeding that HRSG.
  • hrsg_ca_map::Dict{Int, Vector{Base.UUID}}: Mapping from HRSG index to the UUIDs of CAs driven by that HRSG.
  • ct_hrsg_map::Dict{Base.UUID, Vector{Int}}: Reverse mapping from a CT's UUID to the indices of HRSGs it feeds (a CT can feed multiple HRSGs).
  • ca_hrsg_map::Dict{Base.UUID, Vector{Int}}: Reverse mapping from a CA's UUID to the indices of HRSGs that supply it (a CA can receive from multiple HRSGs).
  • internal::InfrastructureSystemsInternal: (Do not modify.) PowerSystems.jl internal reference.

See Also

source
PowerSystems.CombinedCycleBlock — Method
CombinedCycleBlock(
;
    name,
    configuration,
    heat_recovery_to_steam_factor,
    hrsg_ct_map,
    hrsg_ca_map,
    ct_hrsg_map,
    ca_hrsg_map,
    internal
)

CombinedCycleBlock(; name, configuration, heat_recovery_to_steam_factor, hrsg_ct_map, hrsg_ca_map, ct_hrsg_map, ca_hrsg_map, internal)

Construct a CombinedCycleBlock.

Arguments

  • name::String: Name of the combined cycle block
  • configuration::CombinedCycleConfiguration: Configuration type of the combined cycle
  • heat_recovery_to_steam_factor::Float64: (default: 0.0) Factor for heat recovery to steam conversion
  • hrsg_ct_map::AbstractDict: (default: empty dict) Mapping of HRSG numbers to CT unit UUIDs (CTs as HRSG inputs)
  • hrsg_ca_map::AbstractDict: (default: empty dict) Mapping of HRSG numbers to CA unit UUIDs (CAs as HRSG outputs)
  • ct_hrsg_map::AbstractDict: (default: empty dict) Reverse mapping from CT unit UUID to HRSG numbers
  • ca_hrsg_map::AbstractDict: (default: empty dict) Reverse mapping from CA unit UUID to HRSG numbers
  • internal::InfrastructureSystemsInternal: (default: InfrastructureSystemsInternal()) (Do not modify.) PowerSystems.jl internal reference.
source
PowerSystems.CombinedCycleFractional — Type
struct CombinedCycleFractional <: PowerPlant
    name::String
    configuration::CombinedCycleConfiguration
    operation_exclusion_map::Dict{Int, Vector{Base.UUID}}
    inverse_operation_exclusion_map::Dict{Base.UUID, Int}
    internal::InfrastructureSystemsInternal
end

Supplemental attribute representing a combined cycle plant modeled at the aggregate (fractional) level, where each generator unit represents a specific plant configuration with an aggregate heat rate. Mutually exclusive operating groups are tracked via the operation exclusion maps.

Arguments

  • name::String: Name of the combined cycle fractional plant.
  • configuration::CombinedCycleConfiguration: Configuration type of the combined cycle plant.
  • operation_exclusion_map::Dict{Int, Vector{Base.UUID}}: Mapping from exclusion group index to the UUIDs of units in that group; only one unit per group may operate simultaneously.
  • inverse_operation_exclusion_map::Dict{Base.UUID, Int}: Reverse mapping from a unit's UUID to its exclusion group index.
  • internal::InfrastructureSystemsInternal: (Do not modify.) PowerSystems.jl internal reference.

See Also

source
PowerSystems.CombinedCycleFractional — Method
CombinedCycleFractional(
;
    name,
    configuration,
    operation_exclusion_map,
    inverse_operation_exclusion_map,
    internal
)

CombinedCycleFractional(; name, configuration, operation_exclusion_map, inverse_operation_exclusion_map, internal)

Construct a CombinedCycleFractional.

Arguments

  • name::String: Name of the combined cycle fractional plant
  • configuration::CombinedCycleConfiguration: Configuration type of the combined cycle
  • operation_exclusion_map::AbstractDict: (default: empty dict) Mapping of operation exclusion group numbers to unit UUIDs
  • inverse_operation_exclusion_map::AbstractDict: (default: empty dict) Reverse mapping from unit UUID to exclusion group number
  • internal::InfrastructureSystemsInternal: (default: InfrastructureSystemsInternal()) (Do not modify.) PowerSystems.jl internal reference.
source
PowerSystems.HydroPowerPlant — Type
struct HydroPowerPlant <: PowerPlant
    name::String
    penstock_map::Dict{Int, Vector{Base.UUID}}
    reverse_penstock_map::Dict{Base.UUID, Int}
    internal::InfrastructureSystemsInternal
end

Supplemental attribute representing a HydroGen power plant where multiple generating units share penstocks. The penstock maps capture the unit ↔ penstock topology for hydraulic coupling constraints.

Arguments

  • name::String: Name of the hydro power plant.
  • penstock_map::Dict{Int, Vector{Base.UUID}}: Mapping from penstock index to the UUIDs of units connected to that penstock (multiple units may share one penstock).
  • reverse_penstock_map::Dict{Base.UUID, Int}: Reverse mapping from a unit's UUID to the index of its penstock.
  • internal::InfrastructureSystemsInternal: (Do not modify.) PowerSystems.jl internal reference.

See Also

  • HydroGen: Abstract type for hydroelectric generating units.
source
PowerSystems.HydroPowerPlant — Method
HydroPowerPlant(
;
    name,
    penstock_map,
    reverse_penstock_map,
    internal
)

HydroPowerPlant(; name, penstock_map, reverse_penstock_map, internal)

Construct a HydroPowerPlant.

Arguments

  • name::String: Name of the hydro power plant.
  • penstock_map::Dict{Int, Vector{Base.UUID}}: (default: empty dict) Mapping from penstock index to the UUIDs of units connected to that penstock.
  • reverse_penstock_map::Dict{Base.UUID, Int}: (default: empty dict) Reverse mapping from a unit's UUID to its penstock index.
  • internal::InfrastructureSystemsInternal: (default: InfrastructureSystemsInternal()) (Do not modify.) PowerSystems.jl internal reference.
source
PowerSystems.RenewablePowerPlant — Type
struct RenewablePowerPlant <: PowerPlant
    name::String
    pcc_map::Dict{Int, Vector{Base.UUID}}
    reverse_pcc_map::Dict{Base.UUID, Int}
    internal::InfrastructureSystemsInternal
end

Supplemental attribute representing a RenewableGen power plant where multiple generating units share a point of common coupling (PCC). The PCC maps capture the unit ↔ PCC topology for grid connection constraints.

Arguments

  • name::String: Name of the renewable power plant.
  • pcc_map::Dict{Int, Vector{Base.UUID}}: Mapping from PCC index to the UUIDs of units connected to that PCC (multiple units may share one PCC).
  • reverse_pcc_map::Dict{Base.UUID, Int}: Reverse mapping from a unit's UUID to the index of its PCC.
  • internal::InfrastructureSystemsInternal: (Do not modify.) PowerSystems.jl internal reference.

See Also

source
PowerSystems.RenewablePowerPlant — Method
RenewablePowerPlant(
;
    name,
    pcc_map,
    reverse_pcc_map,
    internal
)

RenewablePowerPlant(; name, pcc_map, reverse_pcc_map, internal)

Construct a RenewablePowerPlant.

Arguments

  • name::String: Name of the renewable power plant.
  • pcc_map::Dict{Int, Vector{Base.UUID}}: (default: empty dict) Mapping from PCC index to the UUIDs of units connected to that PCC.
  • reverse_pcc_map::Dict{Base.UUID, Int}: (default: empty dict) Reverse mapping from a unit's UUID to its PCC index.
  • internal::InfrastructureSystemsInternal: (default: InfrastructureSystemsInternal()) (Do not modify.) PowerSystems.jl internal reference.
source
PowerSystems.ThermalPowerPlant — Type
struct ThermalPowerPlant <: PowerPlant
    name::String
    shaft_map::Dict{Int, Vector{Base.UUID}}
    reverse_shaft_map::Dict{Base.UUID, Int}
    internal::InfrastructureSystemsInternal
end

Supplemental attribute representing a ThermalGen power plant where multiple generator units share mechanical shafts. The shaft maps capture the unit ↔ shaft topology for multi-shaft dispatch and synchronous condensing configurations.

Arguments

  • name::String: Name of the power plant.
  • shaft_map::Dict{Int, Vector{Base.UUID}}: Mapping from shaft index to the UUIDs of units connected to that shaft (multiple units may share one shaft).
  • reverse_shaft_map::Dict{Base.UUID, Int}: Reverse mapping from a unit's UUID to the index of its shaft.
  • internal::InfrastructureSystemsInternal: (Do not modify.) PowerSystems.jl internal reference.

See Also

source
PowerSystems.ThermalPowerPlant — Method
ThermalPowerPlant(
;
    name,
    shaft_map,
    reverse_shaft_map,
    internal
)

ThermalPowerPlant(; name, shaft_map, reverse_shaft_map, internal)

Construct a ThermalPowerPlant.

Arguments

  • name::String: Name of the power plant.
  • shaft_map::Dict{Int, Vector{Base.UUID}}: (default: empty dict) Mapping from shaft index to the UUIDs of units connected to that shaft.
  • reverse_shaft_map::Dict{Base.UUID, Int}: (default: empty dict) Reverse mapping from a unit's UUID to its shaft index.
  • internal::InfrastructureSystemsInternal: (default: InfrastructureSystemsInternal()) (Do not modify.) PowerSystems.jl internal reference.
source
PowerSystems.add_supplemental_attribute! — Method
add_supplemental_attribute!(
    sys::System,
    component::ThermalGen,
    attribute::CombinedCycleBlock;
    hrsg_number
)

add_supplemental_attribute!(sys::System, component::ThermalGen, attribute::CombinedCycleBlock; hrsg_number::Int)

Add a thermal generator to a CombinedCycleBlock by associating it with an HRSG number. Only generators with CT (combustion turbine as HRSG input) or CA (combined cycle steam part as HRSG output) prime mover types can be added.

Arguments

  • sys::System: The system containing the generator.
  • component::ThermalGen: The thermal generator to add to the block.
  • attribute::CombinedCycleBlock: The combined cycle block.
  • hrsg_number::Int: The HRSG number to associate with the generator.

Throws

  • ArgumentError: if the generator is already associated with this block.
  • ArgumentError: if the generator's prime mover type is not CT or CA.

See also: remove_supplemental_attribute!, begin_supplemental_attributes_update

source
PowerSystems.add_supplemental_attribute! — Method
add_supplemental_attribute!(
    sys::System,
    component::ThermalGen,
    attribute::CombinedCycleFractional;
    exclusion_group
)

add_supplemental_attribute!(sys::System, component::ThermalGen, attribute::CombinedCycleFractional; exclusion_group::Int)

Add a thermal generator to a CombinedCycleFractional by associating it with an exclusion group number. Only generators with CC (combined cycle) prime mover type can be added.

Arguments

  • sys::System: The system containing the generator.
  • component::ThermalGen: The thermal generator to add to the plant.
  • attribute::CombinedCycleFractional: The combined cycle fractional plant.
  • exclusion_group::Int: The exclusion group number to associate with the generator.

Throws

  • ArgumentError: if the generator is already associated with this plant.
  • ArgumentError: if the generator's prime mover type is not CC.

See also: remove_supplemental_attribute!, begin_supplemental_attributes_update

source
PowerSystems.add_supplemental_attribute! — Method
add_supplemental_attribute!(
    sys::System,
    component::ThermalGen,
    attribute::ThermalPowerPlant;
    shaft_number
)

add_supplemental_attribute!(sys::System, component::ThermalGen, attribute::ThermalPowerPlant; shaft_number::Int)

Add a thermal generator to a ThermalPowerPlant by associating it with a shaft number. This attaches the plant as a supplemental attribute to the generator and records the generator's UUID in the plant's shaft map.

Arguments

  • sys::System: The system containing the generator.
  • component::ThermalGen: The thermal generator to add to the plant.
  • attribute::ThermalPowerPlant: The thermal power plant.
  • shaft_number::Int: The shaft number to associate with the generator.

Throws

  • ArgumentError: if the generator is already associated with this plant.

See also: remove_supplemental_attribute!, begin_supplemental_attributes_update

source
PowerSystems.add_supplemental_attribute! — Method
add_supplemental_attribute!(
    sys::System,
    component::Union{EnergyReservoirStorage, RenewableGen},
    attribute::RenewablePowerPlant,
    pcc_number::Int64
)

add_supplemental_attribute!(sys::System, component::Union{RenewableGen, EnergyReservoirStorage}, attribute::RenewablePowerPlant, pcc_number::Int)

Add a renewable generator or storage to a RenewablePowerPlant by associating it with a PCC number. This attaches the plant as a supplemental attribute to the generator and records the generator's UUID in the plant's PCC map.

Note

pcc_number is a positional argument, unlike the keyword shaft_number in the ThermalPowerPlant overload. This inconsistency is a known API issue.

Arguments

  • sys::System: The system containing the generator.
  • component::Union{RenewableGen, EnergyReservoirStorage}: The renewable generator or storage to add to the plant.
  • attribute::RenewablePowerPlant: The renewable power plant.
  • pcc_number::Int: The PCC (point of common coupling) number to associate with the generator.

Throws

  • ArgumentError: if the component is already associated with this plant.

See also: remove_supplemental_attribute!, begin_supplemental_attributes_update

source
PowerSystems.add_supplemental_attribute! — Method
add_supplemental_attribute!(
    sys::System,
    component::Union{HydroPumpTurbine, HydroTurbine},
    attribute::HydroPowerPlant,
    penstock_number::Int64
)

add_supplemental_attribute!(sys::System, component::Union{HydroPumpTurbine, HydroTurbine}, attribute::HydroPowerPlant, penstock_number::Int)

Add a hydro generator to a HydroPowerPlant by associating it with a penstock number. This attaches the plant as a supplemental attribute to the generator and records the generator's UUID in the plant's penstock map.

Note

penstock_number is a positional argument, unlike the keyword shaft_number in the ThermalPowerPlant overload. This inconsistency is a known API issue.

Arguments

  • sys::System: The system containing the generator.
  • component::Union{HydroPumpTurbine, HydroTurbine}: The hydro generator to add to the plant.
  • attribute::HydroPowerPlant: The hydro power plant.
  • penstock_number::Int: The penstock number to associate with the generator.

Throws

  • ArgumentError: if the generator is already associated with this plant.
  • ArgumentError: if component is a HydroDispatch — use HydroTurbine instead.

See also: remove_supplemental_attribute!, begin_supplemental_attributes_update

source
PowerSystems.get_ca_hrsg_map — Method
get_ca_hrsg_map(
    value::CombinedCycleBlock
) -> Dict{Base.UUID, Vector{Int64}}

Return the ca_hrsg_map field of CombinedCycleBlock: reverse mapping from a combined-cycle steam turbine's (CA) UUID to the indices of HRSGs that supply it.

source
PowerSystems.get_components_in_exclusion_group — Method
get_components_in_exclusion_group(
    sys::System,
    plant::CombinedCycleFractional,
    exclusion_group::Int64
) -> Any

get_components_in_exclusion_group(sys::System, plant::CombinedCycleFractional, exclusion_group::Int)

Return all thermal generators in exclusion group exclusion_group of a CombinedCycleFractional. Only one generator per exclusion group may operate simultaneously.

Arguments

  • sys::System: The system containing the components.
  • plant::CombinedCycleFractional: The combined cycle fractional plant.
  • exclusion_group::Int: The exclusion group number to query.

Throws

  • ArgumentError: if exclusion_group does not exist in the plant.

See also: add_supplemental_attribute!, get_operation_exclusion_map

source
PowerSystems.get_components_in_pcc — Method
get_components_in_pcc(
    sys::System,
    plant::RenewablePowerPlant,
    pcc_number::Int64
) -> Any

get_components_in_pcc(sys::System, plant::RenewablePowerPlant, pcc_number::Int)

Return all renewable generators and storage devices connected to PCC pcc_number (point of common coupling) in a RenewablePowerPlant.

Arguments

  • sys::System: The system containing the components.
  • plant::RenewablePowerPlant: The renewable power plant.
  • pcc_number::Int: The PCC number to query.

Throws

  • ArgumentError: if pcc_number does not exist in the plant.

See also: add_supplemental_attribute!, get_pcc_map

source
PowerSystems.get_components_in_penstock — Method
get_components_in_penstock(
    sys::System,
    plant::HydroPowerPlant,
    penstock_number::Int64
) -> Any

get_components_in_penstock(sys::System, plant::HydroPowerPlant, penstock_number::Int)

Return all hydro generators connected to penstock penstock_number in a HydroPowerPlant.

Arguments

  • sys::System: The system containing the components.
  • plant::HydroPowerPlant: The hydro power plant.
  • penstock_number::Int: The penstock number to query.

Throws

  • ArgumentError: if penstock_number does not exist in the plant.

See also: add_supplemental_attribute!, get_penstock_map

source
PowerSystems.get_components_in_shaft — Method
get_components_in_shaft(
    sys::System,
    plant::ThermalPowerPlant,
    shaft_number::Int64
) -> Any

get_components_in_shaft(sys::System, plant::ThermalPowerPlant, shaft_number::Int)

Return all thermal generators connected to shaft shaft_number in a ThermalPowerPlant.

Arguments

  • sys::System: The system containing the components.
  • plant::ThermalPowerPlant: The thermal power plant.
  • shaft_number::Int: The shaft number to query.

Throws

  • ArgumentError: if shaft_number does not exist in the plant.

See also: add_supplemental_attribute!, get_shaft_map

source
PowerSystems.get_ct_hrsg_map — Method
get_ct_hrsg_map(
    value::CombinedCycleBlock
) -> Dict{Base.UUID, Vector{Int64}}

Return the ct_hrsg_map field of CombinedCycleBlock: reverse mapping from a combustion turbine's (CT) UUID to the indices of HRSGs it feeds.

source
PowerSystems.get_hrsg_ca_map — Method
get_hrsg_ca_map(
    value::CombinedCycleBlock
) -> Dict{Int64, Vector{Base.UUID}}

Return the hrsg_ca_map field of CombinedCycleBlock: mapping from HRSG index to the UUIDs of combined-cycle steam turbines (CA) driven by that HRSG.

source
PowerSystems.get_operation_exclusion_map — Method
get_operation_exclusion_map(
    value::CombinedCycleFractional
) -> Dict{Int64, Vector{Base.UUID}}

Return the operation_exclusion_map field of CombinedCycleFractional: mapping from exclusion group index to the UUIDs of units in that group; only one unit per group may operate simultaneously.

source
PowerSystems.get_pcc_map — Method
get_pcc_map(
    value::RenewablePowerPlant
) -> Dict{Int64, Vector{Base.UUID}}

Return the pcc_map field of RenewablePowerPlant: mapping from PCC (point of common coupling) index to the UUIDs of generators and storage devices connected to that PCC.

source
PowerSystems.get_penstock_map — Method
get_penstock_map(
    value::HydroPowerPlant
) -> Dict{Int64, Vector{Base.UUID}}

Return the penstock_map field of HydroPowerPlant: mapping from penstock index to the UUIDs of generators connected to that penstock.

source
PowerSystems.remove_supplemental_attribute! — Method
remove_supplemental_attribute!(
    sys::System,
    component::ThermalGen,
    attribute::CombinedCycleBlock
)

remove_supplemental_attribute!(sys::System, component::ThermalGen, attribute::CombinedCycleBlock)

Remove a thermal generator from a CombinedCycleBlock. The generator is removed from whichever HRSG map corresponds to its prime mover type (CT or CA).

Arguments

  • sys::System: The system containing the generator.
  • component::ThermalGen: The thermal generator to remove from the block.
  • attribute::CombinedCycleBlock: The combined cycle block.

Throws

  • ArgumentError: if the generator is not associated with this block.

See also: add_supplemental_attribute!, begin_supplemental_attributes_update

source
PowerSystems.remove_supplemental_attribute! — Method
remove_supplemental_attribute!(
    sys::System,
    component::ThermalGen,
    attribute::CombinedCycleFractional
)

remove_supplemental_attribute!(sys::System, component::ThermalGen, attribute::CombinedCycleFractional)

Remove a thermal generator from a CombinedCycleFractional.

Arguments

  • sys::System: The system containing the generator.
  • component::ThermalGen: The thermal generator to remove from the plant.
  • attribute::CombinedCycleFractional: The combined cycle fractional plant.

Throws

  • ArgumentError: if the generator is not associated with this plant.

See also: add_supplemental_attribute!, begin_supplemental_attributes_update

source
PowerSystems.remove_supplemental_attribute! — Method
remove_supplemental_attribute!(
    sys::System,
    component::ThermalGen,
    attribute::ThermalPowerPlant
)

remove_supplemental_attribute!(sys::System, component::ThermalGen, attribute::ThermalPowerPlant)

Remove a thermal generator from a ThermalPowerPlant.

Arguments

  • sys::System: The system containing the generator.
  • component::ThermalGen: The thermal generator to remove from the plant.
  • attribute::ThermalPowerPlant: The thermal power plant.

Throws

  • ArgumentError: if the generator is not associated with this plant.

See also: add_supplemental_attribute!, begin_supplemental_attributes_update

source
PowerSystems.remove_supplemental_attribute! — Method
remove_supplemental_attribute!(
    sys::System,
    component::Union{EnergyReservoirStorage, RenewableGen},
    attribute::RenewablePowerPlant
)

remove_supplemental_attribute!(sys::System, component::Union{RenewableGen, EnergyReservoirStorage}, attribute::RenewablePowerPlant)

Remove a renewable generator or storage device from a RenewablePowerPlant.

Arguments

  • sys::System: The system containing the component.
  • component::Union{RenewableGen, EnergyReservoirStorage}: The renewable generator or storage device to remove from the plant.
  • attribute::RenewablePowerPlant: The renewable power plant.

Throws

  • ArgumentError: if the component is not associated with this plant.

See also: add_supplemental_attribute!, begin_supplemental_attributes_update

source
PowerSystems.remove_supplemental_attribute! — Method
remove_supplemental_attribute!(
    sys::System,
    component::Union{HydroPumpTurbine, HydroTurbine},
    attribute::HydroPowerPlant
)

remove_supplemental_attribute!(sys::System, component::Union{HydroPumpTurbine, HydroTurbine}, attribute::HydroPowerPlant)

Remove a hydro generator from a HydroPowerPlant.

Arguments

  • sys::System: The system containing the generator.
  • component::Union{HydroPumpTurbine, HydroTurbine}: The hydro generator to remove from the plant.
  • attribute::HydroPowerPlant: The hydro power plant.

Throws

  • ArgumentError: if the generator is not associated with this plant.

See also: add_supplemental_attribute!, begin_supplemental_attributes_update

source
PowerSystems.EmissionsData — Type
EmissionsData(; name, pollutant, emission_rate, basis, energy_unit, ...)

A SupplementalAttribute describing the emission of a single pollutant from a host component. Combines pollutant identity (CO2, NOx, etc.) with an emission rate expressed as a ValueCurve (supporting constant, linear, or piecewise relationships between fuel consumption / power output and emissions). One EmissionsData instance can be attached to one or many components via add_supplemental_attribute!.

Arguments

  • name::String: Identifier for this emissions attribute.
  • pollutant::PollutantType: Scoped enum (CO2, CO2E, CH4, N2O, NOX, SO2, PM25, PM10, HG, HAP, CUSTOM).
  • emission_rate::ValueCurve: Emission rate as a ValueCurve, typically an IncrementalCurve. A convenience constructor accepts a Real scalar, which is wrapped in an IncrementalCurve with constant rate.
  • basis::EmissionBasis: FUEL_INPUT (mass per unit of heat input) or POWER_OUTPUT (mass per unit of electrical output).
  • energy_unit::EnergyUnit: Energy unit for the rate denominator (MMBTU, GJ, or MWH). Must be consistent with basis.
  • start_up_adder::Float64: (default: 0.0) Per-start emission pulse, in mass_unit.
  • mass_unit::MassUnit: (default: MassUnit.KG) KG, LB, SHORT_TON, METRIC_TON.
  • gwp::Float64: (default: 1.0) GWP100 multiplier for CO2-equivalent reporting.
  • available::Bool: (default: true) Whether this attribute is active.
  • ext::Dict{String, Any}: (default: Dict{String, Any}()) Extra metadata dictionary.
  • internal::InfrastructureSystemsInternal: (Do not modify.) PowerSystems internal reference.
source
PowerSystems.set_basis_and_energy_unit! — Method
set_basis_and_energy_unit!(
    value::EmissionsData,
    basis::EmissionBasis,
    energy_unit::EnergyUnit
)

Set EmissionsData basis (EmissionBasis) and energy_unit (EnergyUnit) together, validating the combination. This is the supported way to retarget an attribute between FUEL_INPUT and POWER_OUTPUT, since neither field can be changed individually without transiently violating the basis/energy_unit invariant.

source
InfrastructureSystems.GeographicInfo — Type
GeographicInfo <: SupplementalAttribute

Supplemental attribute to store geographic information about system components in GeoJSON format.

Arguments

  • geo_json::Dict{String, Any}: dictionary containing GeoJSON data representing the geographic information of the component
  • internal::InfrastructureSystemsInternal: internal infrastructure systems data for managing metadata and UUID tracking
source
InfrastructureSystems.GeographicInfo — Method
GeographicInfo(; geo_json, internal) -> GeographicInfo

GeographicInfo(; geo_json, internal)

Construct a GeographicInfo supplemental attribute.

Arguments

  • geo_json::Dict{String, Any}: dictionary containing GeoJSON data. Defaults to an empty dictionary if not provided
  • internal::InfrastructureSystemsInternal: internal infrastructure systems data. Defaults to a new InfrastructureSystemsInternal instance if not provided

Example

# Create with default empty geo_json
geo_info = GeographicInfo()

# Create with specific geo_json data
geo_data = Dict("type" => "Point", "coordinates" => [1.0, 2.0])
geo_info = GeographicInfo(geo_json = geo_data)
source

Operating Costs

InfrastructureSystems.CostCurve — Type
struct CostCurve{T<:ValueCurve} <: ProductionVariableCostCurve{T<:ValueCurve}

  • value_curve::ValueCurve: The underlying ValueCurve representation of this ProductionVariableCostCurve

  • power_units::UnitSystem: (default: natural units (MW)) The units for the x-axis of the curve

  • vom_cost::LinearCurve: (default of 0) Additional proportional Variable Operation and Maintenance Cost in /(power_unit h), represented as a LinearCurve

CostCurve(value_curve, power_units, vom_cost)
CostCurve(; value_curve, power_units, vom_cost)

Direct representation of the variable operation cost of a power plant in currency. Composed of a ValueCurve that may represent input-output, incremental, or average rate data. The default units for the x-axis are MW and can be specified with power_units.

source
InfrastructureSystems.FuelCurve — Type
struct FuelCurve{T<:ValueCurve} <: ProductionVariableCostCurve{T<:ValueCurve}

  • value_curve::ValueCurve: The underlying ValueCurve representation of this ProductionVariableCostCurve

  • power_units::UnitSystem: (default: natural units (MW)) The units for the x-axis of the curve

  • fuel_cost::Union{Float64, TimeSeriesKey}: Either a fixed value for fuel cost or the TimeSeriesKey to a fuel cost time series

  • startup_fuel_offtake::LinearCurve: (default of 0) Fuel consumption at the unit startup proceedure. Additional cost to the startup costs and related only to the initial fuel required to start the unit. represented as a LinearCurve

  • vom_cost::LinearCurve: (default of 0) Additional proportional Variable Operation and Maintenance Cost in /(power_unit h) represented as a LinearCurve

FuelCurve(value_curve, power_units, fuel_cost, startup_fuel_offtake, vom_cost)
FuelCurve(value_curve, fuel_cost)
FuelCurve(value_curve, fuel_cost, startup_fuel_offtake, vom_cost)
FuelCurve(value_curve, power_units, fuel_cost)
FuelCurve(; value_curve, power_units, fuel_cost, startup_fuel_offtake, vom_cost)

Representation of the variable operation cost of a power plant in terms of fuel (MBTU, liters, m^3, etc.), coupled with a conversion factor between fuel and currency. Composed of a ValueCurve that may represent input-output, incremental, or average rate data. The default units for the x-axis are MW and can be specified with power_units.

source
InfrastructureSystems.get_initial_input — Method
get_initial_input(
    cost::ProductionVariableCostCurve
) -> Union{Nothing, Float64}

Get the initial_input field of this ProductionVariableCostCurve's ValueCurve (not defined for input-output data)

source
InfrastructureSystems.LinearCurve — Type
LinearCurve(proportional_term::Float64)
LinearCurve(proportional_term::Float64, constant_term::Float64)

A linear input-output curve, representing a constant marginal rate. May have zero no-load cost (i.e., constant average rate) or not.

Arguments

  • proportional_term::Float64: marginal rate
  • constant_term::Float64: optional, cost at zero production, defaults to 0.0
source
InfrastructureSystems.PiecewiseAverageCurve — Type
PiecewiseAverageCurve(initial_input::Union{Float64, Nothing}, x_coords::Vector{Float64}, slopes::Vector{Float64})

A piecewise linear curve specified by average rates between production points. May have nonzero initial value.

Arguments

  • initial_input::Union{Float64, Nothing}: cost at minimum production point first(x_coords) (NOT at zero production), defines the start of the curve
  • x_coords::Vector{Float64}: vector of n production points
  • slopes::Vector{Float64}: vector of n-1 average rates/slopes of the curve segments between the points
source
InfrastructureSystems.PiecewiseIncrementalCurve — Type
PiecewiseIncrementalCurve(initial_input::Union{Float64, Nothing}, x_coords::Vector{Float64}, slopes::Vector{Float64})
PiecewiseIncrementalCurve(input_at_zero::Union{Nothing, Float64}, initial_input::Union{Float64, Nothing}, x_coords::Vector{Float64}, slopes::Vector{Float64})

A piecewise linear curve specified by marginal rates (slopes) between production points. May have nonzero initial value.

Arguments

  • input_at_zero::Union{Nothing, Float64}: (optional, defaults to nothing) cost at zero production, does NOT represent a part of the curve
  • initial_input::Union{Float64, Nothing}: cost at minimum production point first(x_coords) (NOT at zero production), defines the start of the curve
  • x_coords::Vector{Float64}: vector of n production points
  • slopes::Vector{Float64}: vector of n-1 marginal rates/slopes of the curve segments between the points
source
InfrastructureSystems.PiecewisePointCurve — Type
PiecewisePointCurve(points::Vector{Tuple{Float64, Float64}})

A piecewise linear curve specified by cost values at production points.

Arguments

  • points::Vector{Tuple{Float64, Float64}} or similar: vector of (production, cost) pairs
source
InfrastructureSystems.QuadraticCurve — Type
QuadraticCurve(quadratic_term::Float64, proportional_term::Float64, constant_term::Float64)

A quadratic input-output curve, may have nonzero no-load cost.

Arguments

  • quadratic_term::Float64: quadratic term of the curve
  • proportional_term::Float64: proportional term of the curve
  • constant_term::Float64: constant term of the curve
source
InfrastructureSystems.AverageRateCurve — Type

An average rate curve, relating the production quantity to the average cost rate from the origin: y = f(x)/x. Can be used, for instance, in the representation of a CostCurve where x is MW and y is currency/MWh, or in the representation of a FuelCurve where x is MW and y is fuel/MWh. Typically calculated by dividing absolute values of cost rate or fuel input rate by absolute values of electric power.

source
InfrastructureSystems.IncrementalCurve — Type

An incremental (or 'marginal') curve, relating the production quantity to the derivative of cost: y = f'(x). Can be used, for instance, in the representation of a CostCurve where x is MW and y is currency/MWh, or in the representation of a FuelCurve where x is MW and y is fuel/MWh.

source
InfrastructureSystems.InputOutputCurve — Type

An input-output curve, directly relating the production quantity to the cost: y = f(x). Can be used, for instance, in the representation of a CostCurve where x is MW and y is currency/hr, or in the representation of a FuelCurve where x is MW and y is fuel/hr.

source
InfrastructureSystems.get_initial_input — Method
get_initial_input(
    curve::Union{AverageRateCurve, IncrementalCurve}
) -> Union{Nothing, Float64}

Get the initial_input field of this ValueCurve (not defined for InputOutputCurve)

source
InfrastructureSystems.LinearFunctionData — Type

Structure to represent the underlying data of linear functions. Principally used for the representation of cost functions f(x) = proportional_term*x + constant_term.

Arguments

  • proportional_term::Float64: the proportional term in the represented function
  • constant_term::Float64: the constant term in the represented function
source
InfrastructureSystems.PiecewiseLinearData — Type

Structure to represent piecewise linear data as a series of points: two points define one segment, three points define two segments, etc. The curve starts at the first point given, not the origin. Principally used for the representation of cost functions where the points store quantities (x, y), such as (MW, /h).

Arguments

  • points::Vector{@NamedTuple{x::Float64, y::Float64}}: the points that define the function
source
InfrastructureSystems.PiecewiseStepData — Type

Structure to represent a step function as a series of endpoint x-coordinates and segment y-coordinates: two x-coordinates and one y-coordinate defines a single segment, three x-coordinates and two y-coordinates define two segments, etc. This can be useful to represent the derivative of a PiecewiseLinearData, where the y-coordinates of this step function represent the slopes of that piecewise linear function, so there is also an optional field c that can be used to store the initial y-value of that piecewise linear function. Principally used for the representation of cost functions where the points store quantities (x, dy/dx), such as (MW, /MWh).

Arguments

  • x_coords::Vector{Float64}: the x-coordinates of the endpoints of the segments
  • y_coords::Vector{Float64}: the y-coordinates of the segments: y_coords[1] is the y-value between

x_coords[1] and x_coords[2], etc. Must have one fewer elements than x_coords.

  • c::Union{Nothing, Float64}: optional, the value to use for the integral from 0 to x_coords[1] of this function
source
InfrastructureSystems.QuadraticFunctionData — Type

Structure to represent the underlying data of quadratic functions. Principally used for the representation of cost functions f(x) = quadratic_term*x^2 + proportional_term*x + constant_term.

Arguments

  • quadratic_term::Float64: the quadratic term in the represented function
  • proportional_term::Float64: the proportional term in the represented function
  • constant_term::Float64: the constant term in the represented function
source
InfrastructureSystems.get_slopes — Method
get_slopes(pwl::PiecewiseLinearData) -> Vector{Float64}

Calculates the slopes of the line segments defined by the PiecewiseLinearData, returning one fewer slope than the number of underlying points.

source

Time Series

InfrastructureSystems.TimeSeriesData — Type

Abstract type for time series stored in the system. Components store references to these through TimeSeriesMetadata values so that data can reside on storage media instead of memory.

source
InfrastructureSystems.Deterministic — Type
mutable struct Deterministic <: AbstractDeterministic
    name::String
    data::SortedDict
    resolution::Dates.Period
    interval::Dates.Period
    scaling_factor_multiplier::Union{Nothing, Function}
    internal::InfrastructureSystemsInternal
end

A deterministic forecast for a particular data field in a Component.

Arguments

  • name::String: user-defined name
  • data::SortedDict: timestamp - scalingfactor
  • resolution::Dates.Period: forecast resolution
  • interval::Dates.Period: forecast interval
  • scaling_factor_multiplier::Union{Nothing, Function}: Applicable when the time series data are scaling factors. Called on the associated component to convert the values.
  • internal::InfrastructureSystemsInternal
source
InfrastructureSystems.Deterministic — Method
Deterministic(
    name::AbstractString,
    input_data::AbstractDict{Dates.DateTime, <:TimeSeries.TimeArray};
    resolution,
    interval,
    normalization_factor,
    scaling_factor_multiplier
) -> Deterministic

Construct Deterministic from a Dict of TimeArrays.

Arguments

  • name::AbstractString: user-defined name
  • input_data::AbstractDict{Dates.DateTime, TimeSeries.TimeArray}: time series data.
  • resolution::Union{Nothing, Dates.Period} = nothing: If nothing, infer resolution from the data. Otherwise, it must be the difference between each consecutive timestamps. Resolution is required if the resolution is irregular, such as with Dates.Month or Dates.Year.
  • interval::Union{Nothing, Dates.Period} = nothing: If nothing, infer interval from the data. Otherwise, it must be the difference in time between the start of each window. Interval is required if the interval is irregular, such as with Dates.Month or Dates.Year.
  • normalization_factor::NormalizationFactor = 1.0: optional normalization factor to apply to each data entry
  • scaling_factor_multiplier::Union{Nothing, Function} = nothing: If the data are scaling factors then this function will be called on the component and applied to the data when get_time_series_array is called.
  • timestamp = :timestamp: If the values are DataFrames is passed then this must be the column name that contains timestamps.
source
InfrastructureSystems.Deterministic — Method
Deterministic(
    name::AbstractString,
    filename::AbstractString,
    component::InfrastructureSystems.InfrastructureSystemsComponent,
    resolution::Dates.Period;
    interval,
    normalization_factor,
    scaling_factor_multiplier
) -> Deterministic

Construct Deterministic from a CSV file. The first column must be a timestamp in DateTime format and the columns the values in the forecast window.

Arguments

  • name::AbstractString: user-defined name
  • filename::AbstractString: name of CSV file containing data
  • component::InfrastructureSystemsComponent: component associated with the data
  • normalization_factor::NormalizationFactor = 1.0: optional normalization factor to apply to each data entry
  • scaling_factor_multiplier::Union{Nothing, Function} = nothing: If the data are scaling factors then this function will be called on the component and applied to the data when get_time_series_array is called.
source
InfrastructureSystems.Deterministic — Method
Deterministic(
    name::AbstractString,
    series_data::InfrastructureSystems.RawTimeSeries,
    resolution::Dates.Period;
    interval,
    normalization_factor,
    scaling_factor_multiplier
) -> Deterministic

Construct Deterministic from RawTimeSeries.

source
InfrastructureSystems.Deterministic — Method
Deterministic(
    src::Deterministic,
    name::AbstractString;
    scaling_factor_multiplier
) -> Deterministic

Construct Deterministic that shares the data from an existing instance.

This is useful in cases where you want a component to use the same time series data for two different attributes.

Examples

resolution = Dates.Hour(1)
data = Dict(
    DateTime("2020-01-01T00:00:00") => ones(24),
    DateTime("2020-01-01T01:00:00") => ones(24),
)
# Define a Deterministic for the first attribute
forecast_max_active_power = Deterministic(
    "max_active_power",
    data,
    resolution,
    scaling_factor_multiplier = get_max_active_power,
)
add_time_series!(sys, generator, forecast_max_active_power)
# Reuse time series for second attribute
forecast_max_reactive_power = Deterministic(
    forecast_max_active_power,
    "max_reactive_power"
    scaling_factor_multiplier = get_max_reactive_power,
)
add_time_series!(sys, generator, forecast_max_reactive_power)
source
InfrastructureSystems.iterate_windows — Method
iterate_windows(
    forecast::Deterministic
) -> Base.Generator{I, InfrastructureSystems.var"#iterate_windows_common##0#iterate_windows_common##1"{Deterministic}} where I<:(DataStructures.IterableObject{C, DataStructures.EntireContainer, DataStructures.KeysIter, DataStructures.NoTokens, DataStructures.ForwardIter} where C<:(DataStructures.SortedDict{K, D, Ord} where {Ord<:Base.Order.Ordering, D, K}))

Iterate over the windows in a forecast

Examples

for window in iterate_windows(forecast)
    @show values(maximum(window))
end
source
InfrastructureSystems.DeterministicSingleTimeSeries — Type
mutable struct DeterministicSingleTimeSeries <: AbstractDeterministic
    single_time_series::SingleTimeSeries
    initial_timestamp::Dates.DateTime
    interval::Dates.Period
    count::Int
    horizon::Int
end

A deterministic forecast that wraps a SingleTimeSeries

DeterministicSingleTimeSeries behaves exactly like a Deterministic, but instead of storing windows at each initial time it provides a view into the existing SingleTimeSeries at incrementing offsets. This avoids large data duplications when there are the overlapping windows between forecasts.

Can be used as a perfect forecast based on historical data when real forecast data is unavailable.

Arguments

  • single_time_series::SingleTimeSeries: wrapped SingleTimeSeries object
  • initial_timestamp::Dates.DateTime: time series availability time
  • interval::Dates.Period: time step between forecast windows
  • count::Int: number of forecast windows
  • horizon::Int: length of this time series
source
InfrastructureSystems.iterate_windows — Method
iterate_windows(
    forecast::DeterministicSingleTimeSeries
) -> Union{Tuple{Any}, Base.Generator{I, InfrastructureSystems.var"#iterate_windows##0#iterate_windows##1"{DeterministicSingleTimeSeries}} where I<:(StepRangeLen{T, R, S, Int64} where {T, R>:Dates.DateTime, S})}

Iterate over the windows in a forecast

Examples

for window in iterate_windows(forecast)
    @show values(maximum(window))
end
source
InfrastructureSystems.Probabilistic — Type
mutable struct Probabilistic <: Forecast
    name::String
    resolution::Dates.Period
    interval::Dates.Period
    percentiles::Vector{Float64}
    data::SortedDict
    scaling_factor_multiplier::Union{Nothing, Function}
    internal::InfrastructureSystemsInternal
end

A Probabilistic forecast for a particular data field in a Component.

Arguments

  • name::String: user-defined name
  • resolution::Dates.Period: forecast resolution
  • interval::Dates.Period: forecast interval
  • percentiles::Vector{Float64}: Percentiles for the probabilistic forecast
  • data::SortedDict: timestamp - scalingfactor
  • scaling_factor_multiplier::Union{Nothing, Function}: Applicable when the time series data are scaling factors. Called on the associated component to convert the values.
  • internal::InfrastructureSystemsInternal
source
InfrastructureSystems.Probabilistic — Method
Probabilistic(
    name::AbstractString,
    input_data::AbstractDict{Dates.DateTime, <:TimeSeries.TimeArray},
    percentiles::Vector{Float64};
    resolution,
    interval,
    normalization_factor,
    scaling_factor_multiplier
) -> Probabilistic

Construct Probabilistic from a Dict of TimeArrays.

Arguments

  • name::AbstractString: user-defined name
  • input_data::AbstractDict{Dates.DateTime, TimeSeries.TimeArray}: time series data.
  • percentiles: Percentiles represented in the probabilistic forecast
  • resolution::Union{Nothing, Dates.Period} = nothing: If nothing, infer resolution from the data. Otherwise, this must be the difference between each consecutive timestamps. This is required if the resolution is irregular, such as Dates.Month or Dates.Year.
  • interval::Union{Nothing, Dates.Period} = nothing: If nothing, infer interval from the data. Otherwise, it must be the difference in time between the start of each window. Interval is required if the type is irregular, such as with Dates.Month or Dates.Year.
  • normalization_factor::NormalizationFactor = 1.0: optional normalization factor to apply to each data entry
  • scaling_factor_multiplier::Union{Nothing, Function} = nothing: If the data are scaling factors then this function will be called on the component and applied to the data when get_time_series_array is called.
  • timestamp = :timestamp: If the values are DataFrames is passed then this must be the column name that contains timestamps.
source
InfrastructureSystems.Probabilistic — Method
Probabilistic(
    name::AbstractString,
    data::DataStructures.SortedDict{Dates.DateTime, Matrix{Float64}},
    percentiles::Vector,
    resolution::Dates.Period;
    interval,
    normalization_factor,
    scaling_factor_multiplier
) -> Probabilistic

Construct Probabilistic from a SortedDict of Arrays.

Arguments

  • name::AbstractString: user-defined name
  • data::AbstractDict{Dates.DateTime, Matrix{Float64}}: time series data.
  • percentiles: Percentiles represented in the probabilistic forecast
  • resolution::Dates.Period: The resolution of the forecast in Dates.Period`
  • interval::Union{Nothing, Dates.Period}: If nothing, infer interval from the data. Otherwise, it must be the difference in time between the start of each window. Interval is required if the type is irregular, such as with Dates.Month or Dates.Year.
  • normalization_factor::NormalizationFactor = 1.0: optional normalization factor to apply to each data entry
  • scaling_factor_multiplier::Union{Nothing, Function} = nothing: If the data are scaling factors then this function will be called on the component and applied to the data when get_time_series_array is called.
source
InfrastructureSystems.Probabilistic — Method
Probabilistic(
    name::AbstractString,
    series_data::InfrastructureSystems.RawTimeSeries,
    percentiles::Vector,
    resolution::Dates.Period;
    interval,
    normalization_factor,
    scaling_factor_multiplier
)

Construct Deterministic from RawTimeSeries.

source
InfrastructureSystems.Probabilistic — Method
Probabilistic(
    src::Probabilistic,
    name::AbstractString;
    scaling_factor_multiplier
) -> Probabilistic

Construct a Probabilistic that shares the data from an existing instance.

This is useful in cases where you want a component to use the same time series data for two different attributes.

source
InfrastructureSystems.iterate_windows — Method
iterate_windows(
    forecast::Probabilistic
) -> Base.Generator{I, InfrastructureSystems.var"#iterate_windows_common##0#iterate_windows_common##1"{Probabilistic}} where I<:(DataStructures.IterableObject{C, DataStructures.EntireContainer, DataStructures.KeysIter, DataStructures.NoTokens, DataStructures.ForwardIter} where C<:(DataStructures.SortedDict{K, D, Ord} where {Ord<:Base.Order.Ordering, D, K}))

Iterate over the windows in a forecast

Examples

for window in iterate_windows(forecast)
    @show values(maximum(window))
end
source
InfrastructureSystems.Scenarios — Type
mutable struct Scenarios <: Forecast
    name::String
    resolution::Dates.Period
    interval::Dates.Period
    scenario_count::Int
    data::SortedDict
    scaling_factor_multiplier::Union{Nothing, Function}
    internal::InfrastructureSystemsInternal
end

A Discrete Scenario Based time series for a particular data field in a Component.

Arguments

  • name::String: user-defined name
  • resolution::Dates.Period: forecast resolution
  • interval::Dates.Period: forecast interval
  • scenario_count::Int: Number of scenarios
  • data::SortedDict: timestamp - scalingfactor
  • scaling_factor_multiplier::Union{Nothing, Function}: Applicable when the time series data are scaling factors. Called on the associated component to convert the values.
  • internal::InfrastructureSystemsInternal
source
InfrastructureSystems.Scenarios — Method
Scenarios(
    name::AbstractString,
    input_data::AbstractDict{Dates.DateTime, <:TimeSeries.TimeArray};
    resolution,
    interval,
    normalization_factor,
    scaling_factor_multiplier
) -> Scenarios

Construct Scenarios from a Dict of TimeArrays.

Arguments

  • name::AbstractString: user-defined name
  • input_data::AbstractDict{Dates.DateTime, TimeSeries.TimeArray}: time series data.
  • resolution::Union{Nothing, Dates.Period} = nothing: If nothing, infer resolution from the data. Otherwise, it must be the difference between each consecutive timestamps. Resolution is required if the type is irregular, such as with Dates.Month or Dates.Year.
  • interval::Union{Nothing, Dates.Period} = nothing: If nothing, infer interval from the data. Otherwise, it must be the difference in time between the start of each window. Interval is required if the type is irregular, such as with Dates.Month or Dates.Year.
  • normalization_factor::NormalizationFactor = 1.0: optional normalization factor to apply to each data entry
  • scaling_factor_multiplier::Union{Nothing, Function} = nothing: If the data are scaling factors then this function will be called on the component and applied to the data when get_time_series_array is called.
  • timestamp = :timestamp: If the values are DataFrames is passed then this must be the column name that contains timestamps.
source
InfrastructureSystems.Scenarios — Method
Scenarios(
    name::AbstractString,
    data::DataStructures.SortedDict{Dates.DateTime, Matrix{Float64}},
    resolution::Dates.Period;
    interval,
    normalization_factor,
    scaling_factor_multiplier
) -> Scenarios

Construct Scenarios from a SortedDict of Arrays.

Arguments

  • name::AbstractString: user-defined name
  • input_data::SortedDict{Dates.DateTime, Matrix{Float64}}: time series data.
  • resolution::Dates.Period: The resolution of the forecast in Dates.Period
  • interval::Union{Nothing, Dates.Period}: If nothing, infer interval from the data. Otherwise, this must be the difference in time between the start of each window. Interval is required if the type is irregular, such as with Dates.Month or Dates.Year.
  • normalization_factor::NormalizationFactor = 1.0: optional normalization factor to apply to each data entry
  • scaling_factor_multiplier::Union{Nothing, Function} = nothing: If the data are scaling factors then this function will be called on the component and applied to the data when get_time_series_array is called.
source
InfrastructureSystems.Scenarios — Method
Scenarios(
    src::Scenarios,
    name::AbstractString;
    scaling_factor_multiplier
) -> Scenarios

Construct Scenarios that shares the data from an existing instance.

This is useful in cases where you want a component to use the same time series data for two different attributes.

source
InfrastructureSystems.iterate_windows — Method
iterate_windows(
    forecast::Scenarios
) -> Base.Generator{I, InfrastructureSystems.var"#iterate_windows_common##0#iterate_windows_common##1"{Scenarios}} where I<:(DataStructures.IterableObject{C, DataStructures.EntireContainer, DataStructures.KeysIter, DataStructures.NoTokens, DataStructures.ForwardIter} where C<:(DataStructures.SortedDict{K, D, Ord} where {Ord<:Base.Order.Ordering, D, K}))

Iterate over the windows in a forecast

Examples

for window in iterate_windows(forecast)
    @show values(maximum(window))
end
source
InfrastructureSystems.SingleTimeSeries — Type
mutable struct SingleTimeSeries <: StaticTimeSeries
    name::String
    data::TimeSeries.TimeArray
    scaling_factor_multiplier::Union{Nothing, Function}
    internal::InfrastructureSystemsInternal
end

A single column of time series data for a particular data field in a Component.

In contrast with a forecast, this can represent one continual time series, such as a series of historical measurements or realizations or a single scenario (e.g. a weather year or different input assumptions).

Arguments

  • name::String: user-defined name
  • data::TimeSeries.TimeArray: timestamp - scalingfactor
  • resolution::Dates.Period: Time duration between steps in the time series. The resolution must be the same throughout the time series
  • scaling_factor_multiplier::Union{Nothing, Function}: Applicable when the time series data are scaling factors. Called on the associated component to convert the values.
  • internal::InfrastructureSystemsInternal
source
InfrastructureSystems.SingleTimeSeries — Method
SingleTimeSeries(
    name::AbstractString,
    filename::AbstractString,
    component::InfrastructureSystems.InfrastructureSystemsComponent,
    resolution::Dates.Period;
    normalization_factor,
    scaling_factor_multiplier
) -> SingleTimeSeries

Construct SingleTimeSeries from a CSV file. The file must have a column that is the name of the component.

Arguments

  • name::AbstractString: user-defined name
  • filename::AbstractString: name of CSV file containing data
  • component::InfrastructureSystemsComponent: component associated with the data
  • resolution::Dates.Period: resolution of the time series
  • normalization_factor::NormalizationFactor = 1.0: optional normalization factor to apply to each data entry
  • scaling_factor_multiplier::Union{Nothing, Function} = nothing: If the data are scaling factors then this function will be called on the component and applied to the data when get_time_series_array is called.
source
InfrastructureSystems.SingleTimeSeries — Method
SingleTimeSeries(
    name::AbstractString,
    data::Union{DataFrame, TimeSeries.TimeArray};
    normalization_factor,
    scaling_factor_multiplier,
    timestamp,
    resolution
) -> SingleTimeSeries

Construct SingleTimeSeries from a TimeArray or DataFrame.

Arguments

  • name::AbstractString: user-defined name
  • data::Union{TimeSeries.TimeArray, DataFrames.DataFrame}: time series data
  • normalization_factor::NormalizationFactor = 1.0: optional normalization factor to apply to each data entry
  • scaling_factor_multiplier::Union{Nothing, Function} = nothing: If the data are scaling factors then this function will be called on the component and applied to the data when get_time_series_array is called.
  • timestamp::Symbol = :timestamp: If a DataFrame is passed then this must be the column name that contains timestamps.
  • resolution::Union{Nothing, Dates.Period} = nothing: If nothing, infer resolution from the data. Otherwise, it must be the difference between each consecutive timestamps. Resolution is required if the resolution is irregular, such as with Dates.Month or Dates.Year.
source
InfrastructureSystems.SingleTimeSeries — Method
SingleTimeSeries(
    src::SingleTimeSeries,
    name::AbstractString;
    scaling_factor_multiplier
) -> SingleTimeSeries

Construct SingleTimeSeries that shares the data from an existing instance.

This is useful in cases where you want a component to use the same time series data for two different attribtues.

source
InfrastructureSystems.SingleTimeSeries — Method
SingleTimeSeries(
    name::String,
    resolution::Dates.Period,
    initial_time::Dates.DateTime,
    time_steps::Int64
) -> SingleTimeSeries

Construct SingleTimeSeries after constructing a TimeArray from initial_time and time_steps.

source
InfrastructureSystems.ForecastCache — Method

Construct ForecastCache to automatically control caching of forecast data. Maintains some count of forecast windows in memory based on cache_size_bytes.

Call Base.iterate or get_next_time_series_array! to retrieve data. Each iteration will return a TimeSeries.TimeArray covering one forecast window of length horizon_count.

Arguments

  • ::Type{T}: subtype of Forecast
  • component::InfrastructureSystemsComponent: component
  • name::AbstractString: forecast name
  • start_time::Union{Nothing, Dates.DateTime} = nothing: forecast start time
  • horizon_count::Union{Nothing, Int} = nothing: forecast horizon count
  • cache_size_bytes = TIME_SERIES_CACHE_SIZE_BYTES: maximum size of data to keep in memory
  • ignore_scaling_factors = false: controls whether to ignore scaling_factor_multiplier in the time series instance
  • interval::Union{Nothing, Dates.Period} = nothing: select among multiple forecasts that share (type, name) but differ in interval.
  • resolution::Union{Nothing, Dates.Period} = nothing: select among multiple forecasts that share (type, name) but differ in resolution.
source
InfrastructureSystems.StaticTimeSeriesCache — Method

Construct StaticTimeSeriesCache to automatically control caching of time series data. Maintains rows of data in memory based on cache_size_bytes.

Call Base.iterate or get_time_series_array to retrieve data. Each iteration will return a TimeSeries.TimeArray of size 1.

Arguments

  • ::Type{T}: subtype of StaticTimeSeries
  • component::InfrastructureSystemsComponent: component
  • name::AbstractString: time series name
  • cache_size_bytes = TIME_SERIES_CACHE_SIZE_BYTES: maximum size of data to keep in memory
  • ignore_scaling_factors = false: controls whether to ignore scaling_factor_multiplier in the time series instance
  • resolution::Union{Nothing, Dates.Period} = nothing: select among multiple SingleTimeSeries that share (type, name) but differ in resolution.
source
InfrastructureSystems.get_next_time_series_array! — Method
get_next_time_series_array!(
    cache::InfrastructureSystems.TimeSeriesCache
) -> Any

Return the next TimeSeries.TimeArray.

Returns nothing when all data has been read. Call reset! to restart. Call get_next_time to check the start time.

Reads from storage if the data is not already in cache.

Arguments

  • cache::StaticTimeSeriesCache: cached instance

Examples

cache = ForecastCache(Deterministic, component, "max_active_power")
window1 = get_next_time_series_array!(cache)
window2 = get_next_time_series_array!(cache)
source
InfrastructureSystems.copy_time_series! — Method
copy_time_series!(
    dst::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute},
    src::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute};
    name_mapping,
    scaling_factor_multiplier_mapping
)

Efficiently add all time_series in one component to another by copying the underlying references.

Arguments

  • dst::TimeSeriesOwners: Destination owner
  • src::TimeSeriesOwners: Source owner
  • name_mapping::Dict = nothing: Optionally map src names to different dst names. If provided and src has a time_series with a name not present in name_mapping, that time_series will not copied. If name_mapping is nothing then all time_series will be copied with src's names.
  • scaling_factor_multiplier_mapping::Dict = nothing: Optionally map src multipliers to different dst multipliers. If provided and src has a time_series with a multiplier not present in scaling_factor_multiplier_mapping, that time_series will not copied. If scaling_factor_multiplier_mapping is nothing then all time_series will be copied with src's multipliers.
source
InfrastructureSystems.get_time_series — Method
get_time_series(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute},
    key::TimeSeriesKey;
    start_time,
    len,
    count
) -> Any

Return the exact stored data in a time series, using a time series key.

This will load all forecast windows into memory by default. Be aware of how much data is stored.

Specify start_time and len if you only need a subset of data.

Does not apply a scaling factor multiplier.

Arguments

  • owner::TimeSeriesOwners: Component or attribute containing the time series
  • key::TimeSeriesKey: the time series' key
  • start_time::Union{Nothing, Dates.DateTime} = nothing: If nothing, use the initial_timestamp of the time series. If the time series is a subtype of Forecast then start_time must be the first timestamp of a window.
  • len::Union{Nothing, Int} = nothing: Length in the time dimension. If nothing, use the entire length.
  • count::Union{Nothing, Int} = nothing: Only applicable to subtypes of Forecast. Number of forecast windows starting at start_time to return. Defaults to all available.
  • features...: User-defined tags that differentiate multiple time series arrays for the same component attribute, such as different arrays for different scenarios or years

See also: get_time_series by name

source
InfrastructureSystems.get_time_series — Method
get_time_series(
    ::Type{T<:TimeSeriesData},
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute},
    name::AbstractString;
    start_time,
    len,
    count,
    resolution,
    interval,
    features...
) -> Any

Return the exact stored data in a time series

This will load all forecast windows into memory by default. Be aware of how much data is stored.

Specify start_time and len if you only need a subset of data.

Does not apply a scaling factor multiplier.

Arguments

  • ::Type{T}: Concrete subtype of TimeSeriesData to return
  • owner::TimeSeriesOwners: Component or attribute containing the time series
  • name::AbstractString: name of time series
  • resolution::Union{Nothing, Dates.Period} = nothing: Required if resolution is needed to uniquely identify the time series.
  • interval::Union{Nothing, Dates.Period} = nothing: Required if multiple forecasts share the same resolution but differ by interval. Throws an error if omitted and ambiguous.
  • start_time::Union{Nothing, Dates.DateTime} = nothing: If nothing, use the initial_timestamp of the time series. If T is a subtype of Forecast then start_time must be the first timestamp of a window.
  • len::Union{Nothing, Int} = nothing: Length in the time dimension. If nothing, use the entire length.
  • count::Union{Nothing, Int} = nothing: Only applicable to subtypes of Forecast. Number of forecast windows starting at start_time to return. Defaults to all available.
  • features...: User-defined tags that differentiate multiple time series arrays for the same component attribute, such as different arrays for different scenarios or years

See also: get_time_series_array, get_time_series_values, get_time_series by key

source
InfrastructureSystems.get_time_series_array — Method
get_time_series_array(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute},
    forecast::Forecast;
    start_time,
    len,
    ignore_scaling_factors
) -> Any

Return a TimeSeries.TimeArray for one forecast window from a cached Forecast instance

If the time series data are scaling factors, the returned data will be scaled by the scaling factor multiplier by default.

Arguments

  • owner::TimeSeriesOwners: Component or attribute containing the time series
  • forecast::Forecast: a concrete subtype of Forecast
  • start_time::Union{Nothing, Dates.DateTime} = nothing: the first timestamp of one of the forecast windows
  • len::Union{Nothing, Int} = nothing: Length of time-series to retrieve (i.e. number of timestamps). If nothing, use the entire length.
  • ignore_scaling_factors = false: If true, the time-series data will not be multiplied by the result of calling the stored scaling_factor_multiplier function on the owner

See also get_time_series_values, get_time_series_timestamps, ForecastCache, get_time_series_array by name from storage, get_time_series_array from a StaticTimeSeriesCache

source
InfrastructureSystems.get_time_series_array — Method
get_time_series_array(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute},
    time_series::StaticTimeSeries;
    start_time,
    len,
    ignore_scaling_factors
) -> Any

Return a TimeSeries.TimeArray from a cached StaticTimeSeries instance.

If the time series data are scaling factors, the returned data will be scaled by the scaling factor multiplier by default.

Arguments

  • owner::TimeSeriesOwners: Component or attribute containing the time series
  • time_series::StaticTimeSeries: subtype of StaticTimeSeries (e.g., SingleTimeSeries)
  • start_time::Union{Nothing, Dates.DateTime} = nothing: the first timestamp to retrieve. If nothing, use the initial_timestamp of the time series.
  • len::Union{Nothing, Int} = nothing: Length of time-series to retrieve (i.e. number of timestamps). If nothing, use the entire length
  • ignore_scaling_factors = false: If true, the time-series data will not be multiplied by the result of calling the stored scaling_factor_multiplier function on the owner

See also: get_time_series_values, get_time_series_timestamps, StaticTimeSeriesCache, get_time_series_array by name from storage, get_time_series_array from a ForecastCache

source
InfrastructureSystems.get_time_series_array — Method
get_time_series_array(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute},
    key::TimeSeriesKey;
    start_time,
    len,
    ignore_scaling_factors
) -> Any

Return a TimeSeries.TimeArray from storage, using a time series key.

If the time series data are scaling factors, the returned data will be scaled by the scaling factor multiplier by default.

Arguments

  • owner::TimeSeriesOwners: Component or attribute containing the time series
  • key::TimeSeriesKey: the time series key
  • start_time::Union{Nothing, Dates.DateTime} = nothing: If nothing, use the initial_timestamp of the time series. If the time series is a subtype of Forecast then start_time must be the first timestamp of a window.
  • len::Union{Nothing, Int} = nothing: Length of time-series to retrieve (i.e. number of timestamps). If nothing, use the entire length.
  • ignore_scaling_factors = false: If true, the time-series data will not be multiplied by the result of calling the stored scaling_factor_multiplier function on the owner

See also: get_time_series_array by name, get_time_series_values, get_time_series_timestamps

source
InfrastructureSystems.get_time_series_array — Method
get_time_series_array(
    ::Type{T<:TimeSeriesData},
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute},
    name::AbstractString;
    resolution,
    interval,
    start_time,
    len,
    ignore_scaling_factors,
    features...
) -> Any

Return a TimeSeries.TimeArray from storage for the given time series parameters.

If the time series data are scaling factors, the returned data will be scaled by the scaling factor multiplier by default.

This will load all forecast windows into memory by default. Be aware of how much data is stored.

Specify start_time and len if you only need a subset of data.

Arguments

  • ::Type{T}: the type of time series (a concrete subtype of TimeSeriesData)
  • owner::TimeSeriesOwners: Component or attribute containing the time series
  • name::AbstractString: name of time series
  • resolution::Union{Nothing, Dates.Period} = nothing: Required if resolution is needed to uniquely identify the time series.
  • interval::Union{Nothing, Dates.Period} = nothing: Required if multiple forecasts share the same resolution but differ by interval. Throws an error if omitted and ambiguous.
  • start_time::Union{Nothing, Dates.DateTime} = nothing: If nothing, use the initial_timestamp of the time series. If T is a subtype of Forecast then start_time must be the first timestamp of a window.
  • len::Union{Nothing, Int} = nothing: Length of time-series to retrieve (i.e. number of timestamps). If nothing, use the entire length.
  • ignore_scaling_factors = false: If true, the time-series data will not be multiplied by the result of calling the stored scaling_factor_multiplier function on the owner
  • features...: User-defined tags that differentiate multiple time series arrays for the same component attribute, such as different arrays for different scenarios or years

See also: get_time_series_values, get_time_series_timestamps, get_time_series_array from a StaticTimeSeriesCache, get_time_series_array from a ForecastCache

source
InfrastructureSystems.get_time_series_multiple — Function
get_time_series_multiple(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute};
    ...
) -> Union{Tuple{}, Channel{Any}}
get_time_series_multiple(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute},
    filter_func;
    type,
    name,
    resolution,
    interval
) -> Union{Tuple{}, Channel{Any}}

Returns an iterator of TimeSeriesData instances attached to the component or attribute.

Note that passing a filter function can be much slower than the other filtering parameters because it reads time series data from media.

Call collect on the result to get an array.

Arguments

  • owner::TimeSeriesOwners: component or attribute from which to get time_series
  • filter_func = nothing: Only return time_series for which this returns true.
  • type::Union{Nothing, ::Type{<:TimeSeriesData}} = nothing: Only return time_series with this type.
  • name::Union{Nothing, AbstractString} = nothing: Only return time_series matching this value.
  • resolution::Union{Nothing, Dates.Period} = nothing: Only return time_series matching this value.

See also: get_time_series_multiple from a System

source
InfrastructureSystems.get_time_series_timestamps — Method
get_time_series_timestamps(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute},
    forecast::Forecast;
    start_time,
    len
) -> Vector{D} where D<:Dates.TimeType

Return a vector of timestamps from a cached Forecast instance.

Arguments

  • owner::TimeSeriesOwners: Component or attribute containing the time series
  • forecast::Forecast: a concrete subtype of Forecast
  • start_time::Union{Nothing, Dates.DateTime} = nothing: the first timestamp of one of the forecast windows
  • len::Union{Nothing, Int} = nothing: Length of time-series to retrieve (i.e. number of timestamps). If nothing, use the entire length.

See also: get_time_series_array, get_time_series_values, ForecastCache, get_time_series_timestamps by name from storage, get_time_series_timestamps from a StaticTimeSeriesCache

source
InfrastructureSystems.get_time_series_timestamps — Method
get_time_series_timestamps(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute},
    time_series::StaticTimeSeries;
    start_time,
    len
) -> Vector{D} where D<:Dates.TimeType

Return a vector of timestamps from a cached StaticTimeSeries instance.

Arguments

  • owner::TimeSeriesOwners: Component or attribute containing the time series
  • time_series::StaticTimeSeries: subtype of StaticTimeSeries (e.g., SingleTimeSeries)
  • start_time::Union{Nothing, Dates.DateTime} = nothing: the first timestamp to retrieve. If nothing, use the initial_timestamp of the time series.
  • len::Union{Nothing, Int} = nothing: Length of time-series to retrieve (i.e. number of timestamps). If nothing, use the entire length

See also: get_time_series_array, get_time_series_values, StaticTimeSeriesCache, get_time_series_timestamps by name from storage, get_time_series_timestamps from a ForecastCache

source
InfrastructureSystems.get_time_series_timestamps — Method
get_time_series_timestamps(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute},
    key::TimeSeriesKey;
    start_time,
    len
) -> Vector{D} where D<:Dates.TimeType

Return a vector of timestamps from storage, using a time series key.

Arguments

  • owner::TimeSeriesOwners: Component or attribute containing the time series
  • key::TimeSeriesKey: the time series key
  • start_time::Union{Nothing, Dates.DateTime} = nothing: If nothing, use the initial_timestamp of the time series. If the time series is a subtype of Forecast then start_time must be the first timestamp of a window.
  • len::Union{Nothing, Int} = nothing: Length of time-series to retrieve (i.e. number of timestamps). If nothing, use the entire length.

See also: get_time_series_timestamps by name, get_time_series_array, get_time_series_values

source
InfrastructureSystems.get_time_series_timestamps — Method
get_time_series_timestamps(
    ::Type{T<:TimeSeriesData},
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute},
    name::AbstractString;
    resolution,
    interval,
    start_time,
    len,
    features...
) -> Vector{D} where D<:Dates.TimeType

Return a vector of timestamps from storage for the given time series parameters.

Arguments

  • ::Type{T}: the type of time series (a concrete subtype of TimeSeriesData)
  • owner::TimeSeriesOwners: Component or attribute containing the time series
  • name::AbstractString: name of time series
  • resolution::Union{Nothing, Dates.Period} = nothing: Required if resolution is needed to uniquely identify the time series.
  • interval::Union{Nothing, Dates.Period} = nothing: Required if multiple forecasts share the same resolution but differ by interval. Throws an error if omitted and ambiguous.
  • start_time::Union{Nothing, Dates.DateTime} = nothing: If nothing, use the initial_timestamp of the time series. If T is a subtype of Forecast then start_time must be the first timestamp of a window.
  • len::Union{Nothing, Int} = nothing: Length of time-series to retrieve (i.e. number of timestamps). If nothing, use the entire length.
  • features...: User-defined tags that differentiate multiple time series arrays for the same component attribute, such as different arrays for different scenarios or years

See also: get_time_series_array, get_time_series_values, get_time_series_timestamps from a StaticTimeSeriesCache, get_time_series_timestamps from a ForecastCache

source
InfrastructureSystems.get_time_series_values — Method
get_time_series_values(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute},
    forecast::Forecast;
    start_time,
    len,
    ignore_scaling_factors
) -> Any

Return an vector of timeseries data without timestamps for one forecast window from a cached Forecast instance.

Arguments

  • owner::TimeSeriesOwners: Component or attribute containing the time series
  • forecast::Forecast: a concrete subtype of Forecast
  • start_time::Union{Nothing, Dates.DateTime} = nothing: the first timestamp of one of the forecast windows
  • len::Union{Nothing, Int} = nothing: Length of time-series to retrieve (i.e. number of timestamps). If nothing, use the entire length.
  • ignore_scaling_factors = false: If true, the time-series data will not be multiplied by the result of calling the stored scaling_factor_multiplier function on the owner

See also: get_time_series_array, get_time_series_timestamps, ForecastCache, get_time_series_values by name from storage, get_time_series_values from a StaticTimeSeriesCache

source
InfrastructureSystems.get_time_series_values — Method
get_time_series_values(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute},
    time_series::StaticTimeSeries;
    start_time,
    len,
    ignore_scaling_factors
) -> Any

Return an vector of timeseries data without timestamps from a cached StaticTimeSeries instance

Arguments

  • owner::TimeSeriesOwners: Component or attribute containing the time series
  • time_series::StaticTimeSeries: subtype of StaticTimeSeries (e.g., SingleTimeSeries)
  • start_time::Union{Nothing, Dates.DateTime} = nothing: the first timestamp to retrieve. If nothing, use the initial_timestamp of the time series.
  • len::Union{Nothing, Int} = nothing: Length of time-series to retrieve (i.e. number of timestamps). If nothing, use the entire length
  • ignore_scaling_factors = false: If true, the time-series data will not be multiplied by the result of calling the stored scaling_factor_multiplier function on the owner

See also: get_time_series_array, get_time_series_timestamps, StaticTimeSeriesCache, get_time_series_values by name from storage, get_time_series_values from a ForecastCache

source
InfrastructureSystems.get_time_series_values — Method
get_time_series_values(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute},
    key::TimeSeriesKey;
    start_time,
    len,
    ignore_scaling_factors
) -> Any

Return a vector of time series data without timestamps from storage, using a time series key.

Arguments

  • owner::TimeSeriesOwners: Component or attribute containing the time series
  • key::TimeSeriesKey: the time series key
  • start_time::Union{Nothing, Dates.DateTime} = nothing: If nothing, use the initial_timestamp of the time series. If the time series is a subtype of Forecast then start_time must be the first timestamp of a window.
  • len::Union{Nothing, Int} = nothing: Length of time-series to retrieve (i.e. number of timestamps). If nothing, use the entire length.
  • ignore_scaling_factors = false: If true, the time-series data will not be multiplied by the result of calling the stored scaling_factor_multiplier function on the owner

See also: get_time_series_values by name, get_time_series_array, get_time_series_timestamps

source
InfrastructureSystems.get_time_series_values — Method
get_time_series_values(
    ::Type{T<:TimeSeriesData},
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute},
    name::AbstractString;
    resolution,
    interval,
    start_time,
    len,
    ignore_scaling_factors,
    features...
) -> Any

Return an vector of timeseries data without timestamps from storage

If the data size is small and this will be called many times, consider using the version that accepts a cached TimeSeriesData instance.

Arguments

  • ::Type{T}: type of the time series (a concrete subtype of TimeSeriesData)
  • owner::TimeSeriesOwners: Component or attribute containing the time series
  • name::AbstractString: name of time series
  • resolution::Union{Nothing, Dates.Period} = nothing: Required if resolution is needed to uniquely identify the time series.
  • interval::Union{Nothing, Dates.Period} = nothing: Required if multiple forecasts share the same resolution but differ by interval. Throws an error if omitted and ambiguous.
  • start_time::Union{Nothing, Dates.DateTime} = nothing: If nothing, use the initial_timestamp of the time series. If T is a subtype of Forecast then start_time must be the first timestamp of a window.
  • len::Union{Nothing, Int} = nothing: Length of time-series to retrieve (i.e. number of timestamps). If nothing, use the entire length.
  • ignore_scaling_factors = false: If true, the time-series data will not be multiplied by the result of calling the stored scaling_factor_multiplier function on the owner
  • features...: User-defined tags that differentiate multiple time series arrays for the same component attribute, such as different arrays for different scenarios or years

See also: get_time_series_array, get_time_series_timestamps, get_time_series, get_time_series_values from a StaticTimeSeriesCache, get_time_series_values from a ForecastCache

source
InfrastructureSystems.has_time_series — Method
has_time_series(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute};
    kwargs...
) -> Bool

Return true if the component or supplemental attribute has time series data.

source
InfrastructureSystems.has_time_series — Method
has_time_series(
    val::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute},
    _::Type{T<:TimeSeriesData}
) -> Bool

Return true if the component or supplemental attribute has time series data of type T.

source
InfrastructureSystems.TimeSeriesAssociation — Type

Defines an association between a time series owner (component or supplemental attribute) and the time series metadata.

Examples

association1 = TimeSeriesAssociation(component, time_series)
association2 = TimeSeriesAssociation(component, time_series, scenario = "high")
source
InfrastructureSystems.CompressionSettings — Type
CompressionSettings(enabled, type, level, shuffle)

Provides customization of HDF5 compression settings.

  • enabled::Bool: Controls whether compression is enabled.

  • type::CompressionTypes: Specifies the type of compression to use.

  • level::Int64: Supported values are 0-9. Higher values deliver better compression ratios but take longer.

  • shuffle::Bool: Controls whether to enable the shuffle filter. Used with DEFLATE.

Refer to the HDF5.jl and HDF5 documentation for more details on the options.

Example

settings = CompressionSettings(
    enabled = true,
    type = CompressionTypes.DEFLATE,  # BLOSC is also supported
    level = 3,
    shuffle = true,
)
source
InfrastructureSystems.show_time_series — Method
show_time_series(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, SupplementalAttribute}
)

Show a table with time series data attached to the component.

source

System

PowerSystems.System — Type

A power system

System is the main data container in PowerSystems.jl, including basic metadata (base power, frequency), components (network topology, loads, generators, and services), and time series data.

System(base_power)
System(base_power, buses, components...)
System(base_power, buses, generators, loads, branches, storage, services; kwargs...)
System(base_power, buses, generators, loads; kwargs...)
System(file; kwargs...)
System(; buses, generators, loads, branches, storage, base_power, services, kwargs...)
System(; kwargs...)

Arguments

  • base_power::Float64: the base power value for the system
  • buses::Vector{ACBus}: an array of buses
  • components...: Each element (e.g., buses, generators, ...) must be an iterable containing subtypes of Component.
  • file::AbstractString: Path to a Matpower, PSSE, or JSON file ending with .m, .raw, or .json

Keyword arguments

  • name::String: System name.
  • description::String: System description.
  • frequency::Float64: (default = 60.0) Operating frequency (Hz).
  • runchecks::Bool: Run available checks on input fields and when add_component! is called. Throws InvalidValue if an error is found.
  • generator_mapping: A dictionary mapping generator names to their corresponding topologies. This is used to associate generators with their respective buses when parsing from CSV.
  • time_series_in_memory::Bool=false: Store time series data in memory instead of HDF5.
  • time_series_directory::Union{Nothing, String}: Directory for the time series HDF5 file. Defaults to the tmp file system.
  • timeseries_metadata_file: Path to a file containing time series metadata descriptors. This is used to add time series data to the system from files.
  • time_series_read_only::Bool=false: Open the time series store in read-only mode. This is useful for reading time series data without modifying it.
  • enable_compression::Bool=false: Enable compression of time series data in HDF5.
  • compression::CompressionSettings: Allows customization of HDF5 compression settings.
  • config_path::String: specify path to validation config file
  • unit_system::String: (Default = "SYSTEM_BASE") Set the unit system for per-unitization while getting and setting data ("SYSTEM_BASE", "DEVICE_BASE", or "NATURAL_UNITS")
  • bus_name_formatter: A function that takes a Dict of bus data (with keys like "name" and "index") and returns a String to use as the bus name when parsing PSSe or Matpower files.
  • load_name_formatter: A function that takes a Dict of load data (with key "source_id") and returns a String to use as the load name when parsing PSSe or Matpower files.
  • loadzone_name_formatter: A function that takes a load zone identifier (typically an Int) and returns a String to use as the load zone name when parsing PSSe or Matpower files.
  • gen_name_formatter: A function that takes a Dict of generator data and returns a String to use as the generator name when parsing PSSe or Matpower files.
  • shunt_name_formatter: A function that takes a Dict of shunt data and returns a String to use as the FixedAdmittance name when parsing PSSe or Matpower files.
  • branch_name_formatter: A function that takes a Dict of branch data, a from-bus (ACBus), and a to-bus (ACBus), and returns a String to use as the branch name when parsing PSSe or Matpower files.
  • pm_data_corrections::Bool: A function that applies the correction to the data from PowerModels.jl.
  • import_all::Bool: A boolean flag to indicate whether to import all available data when parsing PSSe or Matpower files. The additional data will be stored in the ext dictionary and can be retrieved using get_ext
  • internal::InfrastructureSystems.InfrastructureSystemsInternal: Internal structure for InfrastructureSystems.jl. This is used only during JSON de-seralization, do not pass it when building a System manually.

By default, time series data is stored in an HDF5 file in the tmp file system to prevent large datasets from overwhelming system memory (see Data Storage). If the system's time series data will be larger than the amount of tmp space available, use the time_series_directory parameter to change its location. You can also override the location by setting the environment variable SIENNA_TIME_SERIES_DIRECTORY to another directory.

HDF5 compression is not enabled by default, but you can enable it with enable_compression to get significant storage savings at the cost of CPU time. CompressionSettings can be used to customize the HDF5 compression.

If you know that your dataset will fit in your computer's memory, then you can increase performance by storing it in memory with time_series_in_memory.

Examples

sys = System(100.0; name = "My Power System")
sys = System(100.0; name = "My Power System", description = "System corresponds to scenario A")
sys= System(path_to_my_psse_raw_file; # PSSE file bus names are not unique
    bus_name_formatter = x -> strip(string(x["name"])) * "-" * string(x["index"]),
)
sys = System(100.0; enable_compression = true)
sys = System(100.0; compression = CompressionSettings(
    enabled = true,
    type = CompressionTypes.DEFLATE,  # BLOSC is also supported
    level = 3,
    shuffle = true)
)
sys = System(100.0; time_series_in_memory = true)
source
PowerSystems.System — Method
System(
    sys_file::AbstractString,
    dyr_file::AbstractString;
    kwargs...
) -> Any

Parse static and dynamic data directly from PSS/e text files. Automatically generates all the relationships between the available dynamic injection models and the static counterpart

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

  • Machine
  • Shaft
  • AVR
  • TurbineGov
  • PSS

Files must be parsed from a .raw file (PTI data format) and a .dyr file.

Examples:

raw_file = "Example.raw"
dyr_file = "Example.dyr"
sys = System(raw_file, dyr_file)
source
PowerSystems.System — Method
System(
    file_path::AbstractString;
    assign_new_uuids,
    try_reimport,
    kwargs...
) -> Any

Constructs a System from a file path ending with .m, .raw, or .json

If the file is JSON, then assign_new_uuids = true will generate new UUIDs for the system and all components. If the file is .raw, then try_reimport = false will skip searching for a <name>_export_metadata.json file in the same directory.

source
PowerSystems.System — Method
System(
    data,
    base_power::Number;
    internal,
    kwargs...
) -> System

Construct a System from InfrastructureSystems.SystemData

source
PowerSystems.System — Method
System(
    base_power::Float64,
    buses::Vector{ACBus},
    components...;
    kwargs...
) -> System

System constructor when components are constructed externally.

source
PowerSystems.System — Method
System(
    ::Nothing;
    buses,
    generators,
    loads,
    branches,
    storage,
    base_power,
    services,
    kwargs...
) -> System

Constructs a non-functional System for demo purposes.

source
PowerSystems.System — Method
System(base_power::Number; kwargs...) -> System

Construct an empty System. Useful for building a System while parsing raw data.

source
PowerSystems.get_associated_components — Method
get_associated_components(
    sys::System,
    attribute::SupplementalAttribute;
    component_type
) -> Any

get_associated_components(sys::System, attribute::SupplementalAttribute; component_type)

Return a vector of components attached to the given supplemental attribute.

Arguments

  • sys::System: The system to search.
  • attribute::SupplementalAttribute: The supplemental attribute whose associated components are returned.
  • component_type::Union{Nothing, Type{<:Component}}: (default: nothing) If provided, only return Components of this type. Can be concrete or abstract.

See also: get_associated_components(sys, attribute_type), add_supplemental_attribute!

source
PowerSystems.get_associated_components — Method
get_associated_components(
    sys::System,
    attribute_type::Type{<:SupplementalAttribute};
    component_type
) -> Any

get_associated_components(sys::System, attribute_type::Type{<:SupplementalAttribute}; component_type)

Return a vector of components that have at least one supplemental attribute of attribute_type attached.

Arguments

  • sys::System: The system to search.
  • attribute_type::Type{<:SupplementalAttribute}: The SupplementalAttribute type to filter by. Can be concrete or abstract.
  • component_type::Union{Nothing, Type{<:Component}}: (default: nothing) If provided, only return Components of this type. Can be concrete or abstract.

See also: get_associated_components(sys, attribute), add_supplemental_attribute!

source
PowerSystems.get_available_component — Method
get_available_component(
    sys::System,
    uuid::Base.UUID
) -> Union{Nothing, InfrastructureSystems.InfrastructureSystemsComponent}

get_available_component(sys::System, uuid::Union{Base.UUID, String})

Return the component with the given UUID if it is available, or nothing if the component exists but is unavailable. Throws ArgumentError if no component with that UUID exists. A component is available when get_available returns true.

Arguments

  • sys::System: The system to search.
  • uuid::Union{Base.UUID, String}: The UUID of the component to retrieve.

See also: get_component(sys, uuid), get_available

source
PowerSystems.get_available_component — Method
get_available_component(
    ::Type{T<:Component},
    sys::System,
    args...;
    kwargs...
) -> Union{Nothing, InfrastructureSystems.InfrastructureSystemsComponent}

get_available_component(::Type{T}, sys::System, name::AbstractString) where {T <: Component}

Return the component of type T with the given name if it is available, otherwise return nothing. A component is available when get_available returns true.

If T is an abstract type, names must be unique across all subtypes.

Arguments

  • T: The Component type to retrieve. Can be concrete or abstract.
  • sys::System: The system to search.
  • name::AbstractString: The name of the component.

See also: get_component, get_available

source
PowerSystems.get_available_components — Method
get_available_components(
    sys::System,
    attribute::SupplementalAttribute
)

get_available_components(sys::System, attribute::SupplementalAttribute)

Return an iterator of available components attached to a given supplemental attribute. A component is available when get_available returns true.

Arguments

  • sys::System: The system to search.
  • attribute::SupplementalAttribute: The supplemental attribute whose available associated components are returned.

See also: get_associated_components, get_available

source
PowerSystems.get_available_components — Method
get_available_components(
    filter_func::Function,
    ::Type{T<:Component},
    sys::System;
    subsystem_name
) -> InfrastructureSystems.FlattenIteratorWrapper{var"#s236", I} where {var"#s236"<:Component, I<:(Vector)}

get_available_components(filter_func::Function, ::Type{T}, sys::System; subsystem_name) where {T <: Component}

Return an iterator of available components of type T that also satisfy filter_func. A component is available when get_available returns true.

T can be a concrete or abstract Component type from the Type Tree. Call collect on the result if an array is desired.

Arguments

  • filter_func::Function: A single-argument function returning true for components to include.
  • T: The Component type to retrieve. Can be concrete or abstract.
  • sys::System: The system to search.
  • subsystem_name::Union{Nothing, String}: (default: nothing) If provided, restrict results to the named subsystem.

Examples

gens = get_available_components(x -> get_fuel(x) == ThermalFuels.COAL, ThermalStandard, sys)

See also: get_components, get_available

source
PowerSystems.get_available_components — Method
get_available_components(
    ::Type{T<:Component},
    sys::System;
    subsystem_name
) -> InfrastructureSystems.FlattenIteratorWrapper{var"#s236", I} where {var"#s236"<:Component, I<:(Vector)}

get_available_components(::Type{T}, sys::System; subsystem_name) where {T <: Component}

Return an iterator of available components of type T from a System. A component is available when get_available returns true. Equivalent to get_components with a filter on availability.

T can be a concrete or abstract Component type from the Type Tree. Call collect on the result if an array is desired.

Arguments

  • T: The Component type to retrieve. Can be concrete or abstract.
  • sys::System: The system to search.
  • subsystem_name::Union{Nothing, String}: (default: nothing) If provided, restrict results to the named subsystem.

Examples

gens = get_available_components(ThermalStandard, sys)
gens = get_available_components(Generator, sys)

See also: get_components, get_available

source
PowerSystems.get_component — Method
get_component(
    sys::System,
    uuid::Base.UUID
) -> InfrastructureSystems.InfrastructureSystemsComponent

get_component(sys::System, uuid::Union{Base.UUID, String})

Return the component with the given UUID. Throws ArgumentError if no component with that UUID exists.

Arguments

  • sys::System: The system to search.
  • uuid::Union{Base.UUID, String}: The UUID of the component.

See also: get_component(T, sys, name)

source
PowerSystems.get_component — Method
get_component(
    _::Type{T<:Component},
    sys::System,
    name::AbstractString
) -> Union{Nothing, InfrastructureSystems.InfrastructureSystemsComponent}

get_component(::Type{T}, sys::System, name::AbstractString) where {T <: Component}

Return the component of type T with the given name, or nothing if no match is found.

If T is an abstract type, names must be unique across all subtypes. Use get_components_by_name when names are not unique across subtypes.

Arguments

  • T: The Component type to retrieve. Can be concrete or abstract.
  • sys::System: The system to search.
  • name::AbstractString: The name of the component.

Throws

  • ArgumentError: if T is abstract and more than one component with the given name exists across subtypes.

See also: get_component(sys, uuid), get_components_by_name

source
PowerSystems.get_components — Method
get_components(
    filter_func::Function,
    ::Type{T<:Component},
    sys::System;
    subsystem_name
) -> InfrastructureSystems.FlattenIteratorWrapper{var"#s236", I} where {var"#s236"<:Component, I<:(Vector)}

get_components(filter_func::Function, ::Type{T}, sys::System; subsystem_name) where {T <: Component}

Return an iterator of components of type T from a System that satisfy filter_func.

T can be a concrete or abstract Component type from the Type Tree. Call collect on the result if an array is desired.

Arguments

  • filter_func::Function: A single-argument function returning true for components to include.
  • T: The Component type to retrieve. Can be concrete or abstract.
  • sys::System: The system to search.
  • subsystem_name::Union{Nothing, String}: (default: nothing) If provided, restrict results to the named subsystem.

Examples

iter_coal = get_components(x -> get_fuel(x) == ThermalFuels.COAL, Generator, sys)
pv_gens =
    collect(get_components(x -> get_prime_mover_type(x) == PrimeMovers.PVe, Generator, sys))

See also: get_components, get_available_components, get_buses

source
PowerSystems.get_components — Method
get_components(
    ::Type{T<:Component},
    sys::System;
    subsystem_name
) -> InfrastructureSystems.FlattenIteratorWrapper{var"#s236", I} where {var"#s236"<:Component, I<:(Vector)}

get_components(::Type{T}, sys::System; subsystem_name) where {T <: Component}

Return an iterator of components of type T from a System.

T can be a concrete or abstract Component type from the Type Tree. Call collect on the result if an array is desired.

Arguments

  • T: The Component type to retrieve. Can be concrete or abstract.
  • sys::System: The system to search.
  • subsystem_name::Union{Nothing, String}: (default: nothing) If provided, restrict results to the named subsystem.

Examples

iter = get_components(ThermalStandard, sys)
iter = get_components(Generator, sys)
generators = collect(get_components(Generator, sys))

See also: iterate_components, get_components with a filter, get_available_components, get_buses

source
InfrastructureSystems.from_json — Method
from_json(
    io::Union{IO, String},
    ::Type{System};
    runchecks,
    assign_new_uuids,
    kwargs...
) -> System

If assignnewuuids = true, generate new UUIDs for the system and all components.

Warning: time series data is not restored by this method. If that is needed, use the normal process to construct the system from a serialized JSON file instead, such as with System("sys.json").

source
InfrastructureSystems.get_component — Method
get_component(
    _::Type{T<:Component},
    sys::System,
    name::AbstractString
) -> Union{Nothing, InfrastructureSystems.InfrastructureSystemsComponent}

Get the component of type T with name. Returns nothing if no component matches. If T is an abstract type then the names of components across all subtypes of T must be unique.

See get_components_by_name for abstract types with non-unique names across subtypes.

Throws ArgumentError if T is not a concrete type and there is more than one component with requested name

source
InfrastructureSystems.get_components — Method
get_components(
    ::Type{T<:Component},
    sys::System;
    subsystem_name
) -> InfrastructureSystems.FlattenIteratorWrapper{var"#s236", I} where {var"#s236"<:Component, I<:(Vector)}

Return an iterator of components of a given Type from a System.

T can be a concrete or abstract Component type from the Type Tree. Call collect on the result if an array is desired.

Examples

iter = get_components(ThermalStandard, sys)
iter = get_components(Generator, sys)
generators = collect(get_components(Generator, sys))

See also: iterate_components, get_components with a filter, get_available_components, get_buses

source
InfrastructureSystems.get_supplemental_attributes — Method
get_supplemental_attributes(
    filter_func::Function,
    _::Type{T<:SupplementalAttribute},
    sys::System
) -> InfrastructureSystems.FlattenIteratorWrapper{T, I} where {T<:SupplementalAttribute, I<:(Vector)}

Returns an iterator of supplemental attributes. T can be concrete or abstract. Call collect on the result if an array is desired.

Examples

iter = get_supplemental_attributes(GeometricDistributionForcedOutage, sys)
iter = get_supplemental_attributes(Outage, sys)
iter = get_supplemental_attributes(x -> get_mean_time_to_recovery(x) ==  >= 0.5, GeometricDistributionForcedOutage, sys)
outages = get_supplemental_attributes(GeometricDistributionForcedOutage, sys) do outage
    get_mean_time_to_recovery(x) ==  >= 0.5
end
outages = collect(get_supplemental_attributes(GeometricDistributionForcedOutage, sys))

See also: iterate_supplemental_attributes

source
InfrastructureSystems.get_time_series_multiple — Function
get_time_series_multiple(
    sys::System;
    ...
) -> Channel{TimeSeriesData}
get_time_series_multiple(
    sys::System,
    filter_func;
    type,
    name,
    resolution,
    interval
) -> Channel{TimeSeriesData}

Return an iterator of time series attached to components in the system.

Note that passing a filter function can be much slower than the other filtering parameters because it reads time series data from media.

Call collect on the result to get an array.

Arguments

  • sys::System: system
  • filter_func = nothing: Only return time series for which this returns true.
  • type = nothing: Only return time series with this TimeSeriesData type.
  • name = nothing: Only return time series matching this value.
  • resolution = nothing: Only return time series matching this resolution.
  • interval = nothing: Only return time series matching this interval.

Examples

for time_series in get_time_series_multiple(sys)
    @show time_series
end

ts = collect(get_time_series_multiple(sys; type = SingleTimeSeries))
source
InfrastructureSystems.serialize — Method
serialize(sys::System) -> Dict{String, Any}

Serialize a System instance. Returns a Dict{String, Any} of the form Dict("data_format_version" => "1.0", "field1" => serialize(sys.field1), ...), which can then be written to a JSON3 file.

source
InfrastructureSystems.set_name! — Method
set_name!(
    component::Component,
    name::AbstractString
) -> AbstractString

Set the name of a component.

Throws an exception if the component is attached to a system.

source
InfrastructureSystems.to_json — Method
to_json(
    sys::System,
    filename::AbstractString;
    user_data,
    pretty,
    force,
    runchecks
)

Serializes a system to a JSON file and saves time series to an HDF5 file.

Arguments

  • sys::System: system
  • filename::AbstractString: filename to write

Keyword arguments

  • user_data::Union{Nothing, Dict} = nothing: optional metadata to record
  • pretty::Bool = false: whether to pretty-print the JSON
  • force::Bool = false: whether to overwrite existing files
  • check::Bool = false: whether to run system validation checks

Refer to check_component for exceptions thrown if check = true.

source
PowerSystems.add_component! — Method
add_component!(
    sys::System,
    dyn_injector::DynamicInjection,
    static_injector::StaticInjection;
    kwargs...
)

Add a dynamic injector to the system.

A component cannot be added to more than one System. Throws ArgumentError if the name does not match the static_injector name. Throws ArgumentError if the static_injector is not attached to the system.

All rules for the generic add_component! method also apply.

source
PowerSystems.add_component! — Method
add_component!(
    sys::System,
    component::Component;
    skip_validation,
    kwargs...
)

Add a component to the system.

A component cannot be added to more than one System. Throws ArgumentError if the component's name is already stored for its concrete type. Throws ArgumentError if any Component-specific rule is violated. Throws InvalidValue if any of the component's field values are outside of defined valid range.

Examples

sys = System(100.0)

# Add a single component.
add_component!(sys, bus)

# Add many at once.
buses = [bus1, bus2, bus3]
generators = [gen1, gen2, gen3]
foreach(x -> add_component!(sys, x), Iterators.flatten((buses, generators)))

See also add_components!.

source
PowerSystems.add_components! — Method
add_components!(sys::System, components)

Add many components to the system at once.

A component cannot be added to more than one System. Throws ArgumentError if the component's name is already stored for its concrete type. Throws ArgumentError if any Component-specific rule is violated. Throws InvalidValue if any of the component's field values are outside of defined valid range.

Examples

sys = System(100.0)

buses = [bus1, bus2, bus3]
generators = [gen1, gen2, gen3]
add_components!(sys, Iterators.flatten((buses, generators))
source
PowerSystems.add_service! — Method
add_service!(device::Device, service::Service, sys::System)

Similar to add_service! but for Service and Device already stored in the system. Performs validation checks on the device and the system

Arguments

source
PowerSystems.add_supplemental_attribute! — Method
add_supplemental_attribute!(
    sys::System,
    component::Component,
    attribute::SupplementalAttribute
)

Add a supplemental attribute to the component. The attribute may already be attached to a different component.

source
PowerSystems.add_time_series! — Method
add_time_series!(
    sys::System,
    metadata_file::AbstractString;
    resolution
) -> Vector{TimeSeriesKey}

Add time series data from a metadata file or metadata descriptors.

Arguments

  • sys::System: system
  • metadata_file::AbstractString: metadata file for timeseries that includes an array of InfrastructureSystems.TimeSeriesFileMetadata instances or a vector.
  • resolution::DateTime.Period=nothing: skip time series that don't match this resolution.
source
PowerSystems.add_time_series! — Method
add_time_series!(
    sys::System,
    components,
    time_series::TimeSeriesData;
    features...
) -> Union{ForecastKey, StaticTimeSeriesKey}

Add the same time series data to multiple components.

This function stores a single copy of the data. Each component will store a reference to that data. This is significantly more efficent than calling add_time_series! for each component individually with the same data because in this case, only one time series array is stored.

Throws ArgumentError if a component is not stored in the system.

source
PowerSystems.add_time_series! — Method
add_time_series!(
    sys::System,
    component::Component,
    time_series::TimeSeriesData;
    features...
) -> Union{ForecastKey, StaticTimeSeriesKey}

Add time series data to a component. Assign optional features to differentiate time series of the same type with the same name but with different data.

Returns a key that can later be used to retrieve the time series data.

Throws ArgumentError if the component is not stored in the system.

Examples

ts1 = Deterministic(
    name = "max_active_power",
    data = deterministic_data,
    resolution = Dates.Hour(1),
)
ts2 = SingleTimeSeries(
    name = "max_active_power",
    data = time_array_1,
)
ts3 = SingleTimeSeries(
    name = "max_active_power",
    data = time_array_2,
)
key1 = add_time_series!(system, component, ts1)
key2 = add_time_series!(system, component, ts2, scenario = "high")
key3 = add_time_series!(system, component, ts3, scenario = "low")
ts1_b = get_time_series(component, key1)
ts2_b = get_time_series(component, key2)
ts3_b = get_time_series(component, key3)
source
PowerSystems.add_time_series! — Method
add_time_series!(
    sys::System,
    file_metadata::Vector{InfrastructureSystems.TimeSeriesFileMetadata};
    resolution
) -> Vector{TimeSeriesKey}

Add time series data from a metadata file or metadata descriptors.

Arguments

source
PowerSystems.begin_supplemental_attributes_update — Method
begin_supplemental_attributes_update(
    func::Function,
    sys::System
)

Begin an update of supplemental attributes. Use this function when adding or removing many supplemental attributes in order to improve performance.

If an error occurs during the update, changes will be reverted.

Examples

begin_supplemental_attributes_update(sys) do
    add_supplemental_attribute!(sys, component1, attribute1)
    add_supplemental_attribute!(sys, component2, attribute2)
end
source
PowerSystems.begin_time_series_update — Method
begin_time_series_update(func::Function, sys::System) -> Any

Begin an update of time series. Use this function when adding many time series arrays in order to improve performance.

If an error occurs during the update, changes will be reverted.

Using this function to remove time series is currently not supported.

Examples

begin_time_series_update(sys) do
    add_time_series!(sys, component1, time_series1)
    add_time_series!(sys, component2, time_series2)
end
source
PowerSystems.bulk_add_time_series! — Method
bulk_add_time_series!(
    sys::System,
    associations;
    batch_size
) -> Vector{TimeSeriesKey}

Add time series in bulk.

Prefer use of begin_time_series_update.

Examples

# Assumes `read_time_series` will return data appropriate for Deterministic forecasts
# based on the generator name and the filenames match the component and time series names.
resolution = Dates.Hour(1)
associations = (
    IS.TimeSeriesAssociation(
        gen,
        Deterministic(
            data = read_time_series(get_name(gen) * ".csv"),
            name = "get_max_active_power",
            resolution=resolution),
    )
    for gen in get_components(ThermalStandard, sys)
)
bulk_add_time_series!(sys, associations)
source
PowerSystems.check_component — Method
check_component(sys::System, component::Component)

Check the values of a component.

Throws InvalidValue if any of the component's field values are outside of defined valid range or if the custom validate method for the type fails its check.

source
PowerSystems.check_time_series_consistency — Method
check_time_series_consistency(
    sys::System,
    _::Type{T<:TimeSeriesData}
) -> Union{Nothing, Tuple{Any, Any}}

Checks time series in the system for inconsistencies.

For SingleTimeSeries, returns a Tuple of initial_timestamp and length.

This is a no-op for subtypes of Forecast because those are already guaranteed to be consistent.

Throws InfrastructureSystems.InvalidValue if any time series is inconsistent.

source
PowerSystems.convert_component! — Method
convert_component!(
    sys::System,
    line::Line,
    linetype::Type{MonitoredLine};
    kwargs...
)

Converts a Line component to a MonitoredLine component and replaces the original in the system

source
PowerSystems.convert_component! — Method
convert_component!(
    sys::System,
    line::MonitoredLine,
    linetype::Type{Line};
    kwargs...
)

Converts a MonitoredLine component to a Line component and replaces the original in the system.

source
PowerSystems.convert_component! — Method
convert_component!(
    sys::System,
    old_load::PowerLoad,
    new_type::Type{StandardLoad};
    kwargs...
)

Converts a PowerLoad component to a StandardLoad component and replaces the original in the system. Does not set any fields in StandardLoad that lack a PowerLoad equivalent.

source
PowerSystems.from_subsystem — Method
from_subsystem(
    sys::System,
    subsystem::AbstractString;
    runchecks
) -> System

Construct a System from a subsystem of an existing system.

Arguments

  • sys::System: the base system from which the subsystems are derived
  • subsystem::String: the name of the subsystem to extract from the original system

Keyword arguments

  • runchecks::Bool: (default = true) whether to run system validation checks.
source
PowerSystems.get_associated_supplemental_attributes — Method
get_associated_supplemental_attributes(
    sys::System,
    ::Type{T<:InfrastructureSystems.InfrastructureSystemsComponent};
    attribute_type
) -> Any

get_associated_supplemental_attributes(sys::System, ::Type{T}; attribute_type = nothing)

Return the supplemental attributes associated with components of type T.

Arguments

  • sys::System: System containing the components.
  • ::Type{T}: Component type to filter by.
  • attribute_type::Union{Nothing, Type{<:SupplementalAttribute}}: (default: nothing) Optionally restrict the result to a single supplemental attribute type.

Examples

attrs = get_associated_supplemental_attributes(
    sys,
    ThermalStandard;
    attribute_type = GeometricDistributionForcedOutage,
)
for attr in attrs
    @show summary(attr)
end
source
PowerSystems.get_bus — Method
get_bus(
    sys::System,
    name::AbstractString
) -> Union{Nothing, InfrastructureSystems.InfrastructureSystemsComponent}

Return ACBus with name.

source
PowerSystems.get_buses — Method
get_buses(
    sys::System,
    aggregator::AggregationTopology
) -> Vector{ACBus}

Return a vector of buses contained within an AggregationTopology.

Examples

area = get_component(Area, system, "my_area"); # Get an Area named my_area
area_buses = get_buses(system, area)
source
PowerSystems.get_buses — Method
get_buses(
    sys::System,
    bus_numbers::Set{Int64}
) -> Vector{ACBus}

Return ACBuses from a set of identification numbers

Examples

# View all the bus ID numbers in the System
get_number.(get_components(ACBus, system))
# Select a subset
buses_by_ID = get_buses(system, Set(101:110))
source
PowerSystems.get_component_supplemental_attribute_pairs — Method
get_component_supplemental_attribute_pairs(
    ::Type{T<:Component},
    ::Type{U<:SupplementalAttribute},
    sys::System;
    components,
    attributes
) -> Array{NamedTuple{(:component, :supplemental_attribute), var"#s177"}, 1} where var"#s177"<:Tuple{Component, SupplementalAttribute}

Return a vector of NamedTuples with pairs of components and supplemental attributes that are associated with each other. Limit by components and attributes if provided.

The return type is NamedTuple{(:component, :supplemental_attribute), Tuple{T, U}}[] where T is the component type and U is the supplemental attribute type.

Arguments

  • sys::System: System containing the components and attributes.
  • ::Type{T}: Type of the Component to filter by. Can be concrete or abstract.
  • ::Type{U}: Type of the SupplementalAttribute to filter by. Can be concrete or abstract.
  • components: Optional iterable. If set, filter pairs where the component is in this iterable.
  • attributes: Optional iterable. If set, filter pairs where the supplemental attribute is in this iterable.

Examples

gen_attr_pairs = get_component_supplemental_attribute_pairs(
    GeometricDistributionForcedOutage,
    ThermalStandard,
    sys,
)
for (gen, attr) in gen_attr_pairs
    @show summary(gen) summary(attr)
end

my_generators = [gen1, gen2, gen3]
gen_attr_pairs_limited = get_component_supplemental_attribute_pairs(
    GeometricDistributionForcedOutage,
    ThermalStandard,
    sys,
    components = my_generators,
)
for (gen, attr) in gen_attr_pairs_limited
    @show summary(gen) summary(attr)
end
source
PowerSystems.get_components_by_name — Method
get_components_by_name(
    _::Type{T<:Component},
    sys::System,
    name::AbstractString
) -> Vector{T} where T<:InfrastructureSystems.InfrastructureSystemsComponent

Get the components of abstract type T with name. Note that PowerSystems enforces unique names on each concrete type but not across concrete types.

See get_component if the concrete type is known.

Throws ArgumentError if T is not an abstract type.

source
PowerSystems.get_connected_head_reservoirs — Method
get_connected_head_reservoirs(
    sys::System,
    turbine::HydroUnit
) -> Vector

Return a vector of connected head reservoirs to the turbine. Reservoirs that have the turbine in their downstream_turbines field are head reservoirs of such turbine.

source
PowerSystems.get_connected_tail_reservoirs — Method
get_connected_tail_reservoirs(
    sys::System,
    turbine::HydroUnit
) -> Vector

Return a vector of connected tail reservoirs to the turbine. Reservoirs that have the turbine in their upstream_turbines field are tail reservoirs of such turbine.

source
PowerSystems.get_ext — Method
get_ext(sys::System) -> Union{Nothing, Dict{String, Any}}

Return a user-modifiable dictionary to store extra information.

source
PowerSystems.get_forecast_horizon — Method
get_forecast_horizon(
    sys::System;
    kwargs...
) -> Union{Nothing, Dates.Period}

Return the horizon for all forecasts. Use resolution and/or interval keyword arguments to filter when multiple forecast groups exist.

source
PowerSystems.get_forecast_initial_times — Method
get_forecast_initial_times(
    sys::System;
    kwargs...
) -> Union{Vector{Any}, Vector{Dates.DateTime}, StepRangeLen{T, R, S, Int64} where {T, R>:Dates.DateTime, S}}

Return the initial times for all forecasts. Use resolution and/or interval keyword arguments to filter when multiple forecast groups exist.

source
PowerSystems.get_forecast_initial_timestamp — Method
get_forecast_initial_timestamp(
    sys::System;
    kwargs...
) -> Union{Nothing, Dates.DateTime}

Return the initial timestamp for all forecasts. Use resolution and/or interval keyword arguments to filter when multiple forecast groups exist.

source
PowerSystems.get_forecast_interval — Method
get_forecast_interval(
    sys::System;
    kwargs...
) -> Union{Nothing, Dates.Period}

Return the forecast interval. Use resolution and/or interval keyword arguments to select which forecast group to query when multiple exist.

source
PowerSystems.get_forecast_window_count — Method
get_forecast_window_count(
    sys::System;
    kwargs...
) -> Union{Nothing, Int64}

Return the window count for all forecasts. Use resolution and/or interval keyword arguments to filter when multiple forecast groups exist.

source
PowerSystems.has_component — Method
has_component(
    sys::System,
    T::Type{<:Component},
    name::AbstractString
) -> Bool

Check to see if the component of type T with name exists.

source
PowerSystems.iterate_components — Method
iterate_components(
    sys::System
) -> InfrastructureSystems.FlattenIteratorWrapper{InfrastructureSystems.InfrastructureSystemsComponent, I} where I<:(Vector)

Iterates over all components.

Examples

for component in iterate_components(sys)
    @show component
end

See also: get_components

source
PowerSystems.iterate_supplemental_attributes — Method
iterate_supplemental_attributes(
    sys::System
) -> Base.Iterators.Flatten{Base.Generator{Base.ValueIterator{Dict{DataType, Dict{Base.UUID, <:SupplementalAttribute}}}, InfrastructureSystems.var"#iterate_container##0#iterate_container##1"}}

Iterates over all supplemental_attributes.

Examples

for supplemental_attribute in iterate_supplemental_attributes(sys)
    @show supplemental_attribute
end

See also: get_supplemental_attributes

source
PowerSystems.open_time_series_store! — Function
open_time_series_store!(
    func::Function,
    sys::System;
    ...
) -> Any
open_time_series_store!(
    func::Function,
    sys::System,
    mode,
    args...;
    kwargs...
) -> Any

Open the time series store for bulk additions or reads

This is recommended before calling add_time_series! many times because of the overhead associated with opening and closing an HDF5 file.

This is not necessary for an in-memory time series store.

Examples

# Assume there is a system with an array of Components and SingleTimeSeries
# stored in the variables components and single_time_series, respectively
open_time_series_store!(sys, "r+") do
    for (component, ts) in zip(components, single_time_series)
        add_time_series!(sys, component, ts)
    end
end

You can also use this function to make reads faster. Change the mode from "r+" to "r" to open the file read-only.

See also: begin_time_series_update

source
PowerSystems.remove_component! — Method
remove_component!(sys::System, component::Component)

Remove a component from the system by its value.

Throws ArgumentError if the component is not stored.

source
PowerSystems.remove_component! — Method
remove_component!(
    _::Type{T<:Component},
    sys::System,
    name::AbstractString
)

Remove a component from the system by its name.

Throws ArgumentError if the component is not stored.

source
PowerSystems.remove_components! — Method
remove_components!(
    filter_func::Function,
    sys::System,
    _::Type{T<:Component}
) -> Vector{T} where T<:Component

Remove all components of type T that match filter_func from the system.

source
PowerSystems.remove_components! — Method
remove_components!(
    sys::System,
    _::Type{T<:Component}
) -> Base.ValueIterator{T} where T<:(Dict{String, <:InfrastructureSystems.InfrastructureSystemsComponent})

Remove all components of type T from the system.

Throws ArgumentError if the type is not stored.

source
PowerSystems.remove_supplemental_attribute! — Method
remove_supplemental_attribute!(
    sys::System,
    component::Component,
    attribute::SupplementalAttribute
)

Remove the supplemental attribute from the component. The attribute will be removed from the system if it is not attached to any other component.

source
PowerSystems.remove_supplemental_attributes! — Method
remove_supplemental_attributes!(
    _::Type{T<:SupplementalAttribute},
    sys::System
) -> Base.ValueIterator{T} where T<:(Dict{Base.UUID, <:SupplementalAttribute})

Remove all supplemental attributes with the given type from the system.

source
PowerSystems.remove_time_series! — Method
remove_time_series!(
    sys::System,
    ::Type{T<:TimeSeriesData},
    owner::Union{SupplementalAttribute, Component},
    name::String;
    resolution,
    interval,
    features...
)

Remove the time series data for a component or supplemental attribute and time series type.

Use resolution, interval, and features keyword arguments to disambiguate when multiple time series of the same type and name exist with different resolutions, intervals, or user-defined feature tags.

source
PowerSystems.remove_time_series! — Method
remove_time_series!(
    sys::System,
    ::Type{T<:TimeSeriesData};
    resolution,
    interval
)

Remove all the time series data for a time series type.

See also: clear_time_series!

If you are storing time series data in an HDF5 file, remove_time_series! does not actually free up file space (HDF5 behavior). If you want to remove all or most time series instances then consider using clear_time_series!. It will delete the HDF5 file and create a new one. PowerSystems has plans to automate this type of workflow.

source
PowerSystems.replace_dynamic_injector! — Method
replace_dynamic_injector!(
    sys::System,
    static_injector::StaticInjection,
    new_dynamic_injector::DynamicInjection
)

Replace the dynamic injector in a static component.

Safely removes the old dynamic injector from the system if no other component references it. If another component references the old dynamic injector, it is kept in the system and an info message is logged.

Throws ArgumentError if the static injector is not attached to the system. Throws ArgumentError if the static injector does not have a dynamic injector. Throws ArgumentError if the new dynamic injector name does not match the static injector name.

source
PowerSystems.set_runchecks! — Method
set_runchecks!(sys::System, value::Bool)

Enable or disable system checks. Applies to component addition as well as overall system consistency.

source
PowerSystems.set_units_base_system! — Method
set_units_base_system!(
    system::System,
    units::Union{UnitSystem, String}
)

Sets the units base for the getter functions on the devices. It modifies the behavior of all getter functions

Examples

set_units_base_system!(sys, "NATURAL_UNITS")
set_units_base_system!(sys, UnitSystem.SYSTEM_BASE)
source
PowerSystems.transform_single_time_series! — Method
transform_single_time_series!(
    sys::System,
    horizon::Dates.Period,
    interval::Dates.Period;
    resolution,
    delete_existing
)

Transform all instances of SingleTimeSeries in a System to DeterministicSingleTimeSeries

This can be used to generate a perfect forecast from historical measurements or realizations when actual forecasts are unavailable, without unnecessarily duplicating data.

If all SingleTimeSeries instances cannot be transformed then none will be.

By default, any existing DeterministicSingleTimeSeries forecasts will be deleted before the transform (delete_existing = true). Set delete_existing = false to preserve existing DeterministicSingleTimeSeries; entries with matching name, resolution, features, horizon, and interval are skipped, allowing multiple calls with different resolutions to coexist.

Arguments

  • sys::System: System containing the components.
  • horizon::Dates.Period: desired horizon of each forecast window
  • interval::Dates.Period: desired interval between forecast windows
  • resolution::Union{Nothing, Dates.Period} = nothing: If set, only transform time series with this resolution.
  • delete_existing::Bool = true: If true, delete all existing DeterministicSingleTimeSeries before transforming.
source
PowerSystems.with_units_base — Method
with_units_base(
    f::Function,
    c::Component,
    units::Union{UnitSystem, String}
) -> Any

A "context manager" that sets the Component's units base to the given value, executes the function, then sets the units base back.

Examples

active_power_mw = with_units_base(component, UnitSystem.NATURAL_UNITS) do
    get_active_power(component)
end
# now active_power_mw is in natural units no matter what units base the system is in
source
PowerSystems.with_units_base — Method
with_units_base(
    f::Function,
    sys::System,
    units::Union{UnitSystem, String}
) -> Any

A "context manager" that sets the System's units base to the given value, executes the function, then sets the units base back.

Examples

active_power_mw = with_units_base(sys, UnitSystem.NATURAL_UNITS) do
    get_active_power(gen)
end
# now active_power_mw is in natural units no matter what units base the system is in
source
PowerSystems.show_components — Function
show_components(
    sys::System,
    component_type::Type{<:Component};
    ...
)
show_components(
    sys::System,
    component_type::Type{<:Component},
    additional_columns::Union{Dict, Vector};
    kwargs...
)

Show all components of the given type in a table.

Arguments

  • sys::System: System containing the components.
  • component_type::Type{<:Component}: Type to display. Must be a concrete type.
  • additional_columns::Union{Dict, Vector}: Additional columns to display. The Dict option is a mapping of column name to function. The function must accept a component. The Vector option is an array of field names for the component_type.

Extra keyword arguments are forwarded to PrettyTables.pretty_table.

Examples

show_components(sys, ThermalStandard)
show_components(sys, ThermalStandard, Dict("has_time_series" => x -> has_time_series(x)))
show_components(sys, ThermalStandard, [:active_power, :reactive_power])
source
PowerSystems.generate_struct_file — Method
generate_struct_file(
    definition::StructDefinition;
    filename,
    output_directory
)

Generate a Julia source code file for one struct from a StructDefinition.

Refer to StructDefinition and StructField for descriptions of the available fields.

Arguments

  • definition::StructDefinition: Defines the struct and all fields.
  • filename::AbstractString: Add the struct definition to this JSON file. Defaults to src/descriptors/power_system_structs.json
  • output_directory::AbstractString: Generate the files in this directory. Defaults to src/models/generated
source
PowerSystems.generate_struct_files — Method
generate_struct_files(
    definitions;
    filename,
    output_directory
)

Generate Julia source code files for multiple structs from a iterable of StructDefinition instances.

Refer to StructDefinition and StructField for descriptions of the available fields.

Arguments

  • definitions: Defines the structs and all fields.
  • filename::AbstractString: Add the struct definition to this JSON file. Defaults to src/descriptors/power_system_structs.json
  • output_directory::AbstractString: Generate the files in this directory. Defaults to src/models/generated
source
InfrastructureSystems.StructDefinition — Method
StructDefinition(
;
    struct_name,
    fields,
    supertype,
    docstring,
    is_component
)

Construct a StructDefinition for code auto-generation purposes.

Arguments

  • struct_name::AbstractString: Struct name
  • fields::Vector{StructField}: Struct fields. Refer to StructField.
  • docstring::AbstractString: Struct docstring. Defaults to an empty string.
  • supertype::Union{String, DataType}: Struct supertype. Defaults to no supertype.
  • is_component::Bool: Set to true for component types that will be attached to a system. Do not set to Default to true.
source
InfrastructureSystems.StructField — Method
StructField(
;
    name,
    data_type,
    default,
    comment,
    needs_conversion,
    exclude_setter,
    valid_range,
    validation_action,
    null_value,
    internal_default
)

Construct a StructField for code auto-generation purposes.

Arguments

  • name::String: Field name
  • data_type::Union{DataType, String}: Field type
  • default::Any: The generated constructors will define this as a default value.
  • comment::String: Include this comment above the field name. Defaults to empty string.
  • needs_conversion::Bool: Set to true if the getter and setter functions need to apply unit conversion. The type must implement get_value(::Component, ::Type) and set_value(::Component, ::Type) for this combination of component type and field type.
  • exclude_setter::Bool: Do not generate a setter function for this field. Defaults to false.
  • valid_range::Union{Nothing, String, Dict}: Enables range validation when the component is added to a system. Define this as a Dict with "min" and "max" or as a String with the field name in the struct that defines this field's valid range and InfrastructureSystems will validate any value against that range. Use nothing if one doesn't apply, such as if there is no max limit.
  • validation_action: Define this as "error" or "warn". If it is "error" then InfrastructureSystems will throw an exception if the validation code detects a problem. Otherwise, it will log a warning.
  • null_value::Any: Value to indicate the field is zero or empty, such as 0.0 for Float64. If all members in the struct define this field then a "demo" constructor will be generated. This allows entering val = MyType(nothing) in the REPL to see the layout of a struct without worrying about valid values.
  • internal_default: Set to true for non-user-facing fields like InfrastructureSystemsInternal that have default values.
source
InfrastructureSystems.generate_struct_file — Method
generate_struct_file(
    definition::StructDefinition;
    filename,
    output_directory
)

Generate a Julia source code file for one struct from a StructDefinition.

Refer to StructDefinition and StructField for descriptions of the available fields.

Arguments

  • definition::StructDefinition: Defines the struct and all fields.
  • filename::AbstractString: Add the struct definition to this JSON file. Defaults to src/descriptors/structs.json
  • output_directory::AbstractString: Generate the files in this directory. Defaults to src/generated
source
InfrastructureSystems.generate_struct_files — Method
generate_struct_files(
    definitions;
    filename,
    output_directory
)

Generate Julia source code files for multiple structs from a iterable of StructDefinition instances.

Refer to StructDefinition and StructField for descriptions of the available fields.

Arguments

  • definitions: Defines the structs and all fields.
  • filename::AbstractString: Add the struct definition to this JSON file. Defaults to src/descriptors/power_system_structs.json
  • output_directory::AbstractString: Generate the files in this directory. Defaults to src/generated
source

Advanced Component Selection

The primary way to retrieve components in PowerSystems.jl is with the get_components and similar get_* methods above. The following ComponentSelector interface offers advanced, repeatable component selection primarily for multi-scenario post-processing analytics. See PowerAnalytics.jl.

InfrastructureSystems.ComponentSelector — Type

Given some ComponentContainer-like source of components to draw from, such as a PowerSystems.System, a ComponentSelector picks out a certain subset of them based on some user-defined selection criteria. A ComponentSelector can also be used to name that subset of components or to split it up into groups. The same ComponentSelector can be used to apply the same set of selection criteria to multiple sources of components. The primary use case for ComponentSelector is to support repeatable multi-scenario post-processing analytics (see e.g. PowerAnalytics.jl).

Formally, instances of ComponentSelector represent lazy, partitioned, named, source-independent collections of InfrastructureSystemsComponents.

Core Interface

  • make_selector: factory function to handle ComponentSelector creation; end users should use this rather than calling the constructors directly.
  • get_groups: get the groups that make up a ComponentSelector, which will themselves be represented as ComponentSelectors.
  • get_components: get all the components that make up a ComponentSelector, ignoring how they are grouped. A component should appear in the get_components of a given selector if and only if it appears in the get_components of at least one of that selector's groups.
  • get_name: get the name of the ComponentSelector. All ComponentSelectors have a name, whether it is specified by the user or created automatically.
  • rebuild_selector: create a new ComponentSelector from an existing one with some details (e.g., the name or the grouping behavior) tweaked.

Availability Filtering

Besides the core interface, also provided are get_component for ComponentSelector subtypes that can only refer to at most one component; and get_available_component, get_available_components, and get_available_groups, which work the same as the corresponding functions without available except they only consider components for which get_available is true.

scope_limiter Filtering

The ComponentSelector methods of get_component, get_components, and get_groups, and the corresponding _available_ variants, take an optional first argument scope_limiter::Union{Function, Nothing}. If a function is passed in here, it will be used as a filter function to limit the components under consideration before the ComponentSelector's criteria are evaluated.

source
InfrastructureSystems.get_name — Method
get_name(selector::ComponentSelector) -> Any

Get the name of the ComponentSelector. This is either a user-specified name passed in at creation or a name automatically generated from the selector's specification.

Examples

sel = make_selector(RenewableDispatch)
get_name(sel)  # "RenewableDispatch"
source
InfrastructureSystems.make_selector — Function

Factory function to create the appropriate subtype of ComponentSelector given the arguments. Users should call this rather than manually constructing ComponentSelectors.

Arguments

Several methods of this function have a parameter groupby::Union{Symbol, Function}, which specifies how the selector is grouped for the purposes of get_groups. The groupby argument has the following semantics:

  • groupby = :each (default): each component that makes up the selector forms its own group. The number of groups from get_groups will be equal to the number of components from get_components.
  • groupby = :all: all components that make up the selector are put into the same group. get_groups will yield one group.
  • groupby = partition_function: if the argument is a user-supplied function, the function will be applied to each component; all components with the same result under the function will be grouped together, with the name of the group specified by the function's output.

Other arguments are documented on a per-method basis.

Examples

See the methods.

source
InfrastructureSystems.make_selector — Method
make_selector(
    filter_func::Function,
    component_type::Type{<:InfrastructureSystems.InfrastructureSystemsComponent};
    name,
    groupby
) -> InfrastructureSystems.FilterComponentSelector

Make a ComponentSelector from a filter function and a type of component. The filter function must accept instances of component_type as a sole argument and return a Bool. Optionally provide a grouping behavior and/or name for the selector. Selectors constructed this way point to all the components of the given type that satisfy the filter function, grouped by the groupby argument (see the base make_selector documentation).

Arguments

  • filter_func::Function: the filter function to apply to components
  • component_type::Type{<:InfrastructureSystemsComponent}: the type of component to select
  • groupby::Union{Symbol, Function} = :each: the grouping behavior (see the base make_selector documentation)
  • name::Union{String, Nothing} = nothing: the name of the selector; if not provided, one will be constructed automatically

Examples

sel1 = make_selector(RenewableDispatch, x -> get_prime_mover_type(x) == PrimeMovers.PVe)
sel2 = make_selector(RenewableDispatch, x -> get_prime_mover_type(x) == PrimeMovers.PVe; groupby = :all)
sel3 = make_selector(RenewableDispatch, x -> get_prime_mover_type(x) == PrimeMovers.PVe; name = "my_selector")

See also: make_selector unified function documentation

source
InfrastructureSystems.make_selector — Method
make_selector(
    component::InfrastructureSystems.InfrastructureSystemsComponent;
    name
) -> InfrastructureSystems.NameComponentSelector

Make a ComponentSelector from a component, pointing to a single component with the same type and name as the one given. Optionally provide a name for the selector. Selectors constructed this way contain exactly one group, which contains one component if the target component exists and zero if it doesn't.

Arguments

  • component::InfrastructureSystemsComponent: the component whose type and name specify the target of this selector
  • name::Union{String, Nothing} = nothing: the name of the selector; if not provided, one will be constructed automatically

Examples

sel1 = make_selector(my_component)
sel2 = make_selector(my_component; name = "my_selector")

See also: make_selector unified function documentation

source
InfrastructureSystems.make_selector — Method
make_selector(
    component_type::Type{<:InfrastructureSystems.InfrastructureSystemsComponent},
    component_name::AbstractString;
    name
) -> InfrastructureSystems.NameComponentSelector

Make a ComponentSelector pointing to a single component with the given type and name. Optionally provide a name for the selector. Selectors constructed this way contain exactly one group, which contains one component if the target component exists and zero if it doesn't.

Arguments

  • component_type::Type{<:InfrastructureSystemsComponent}: the type of the target component
  • component_name::AbstractString: the name of the target component
  • name::Union{String, Nothing} = nothing: the name of the selector; if not provided, one will be constructed automatically

Examples

sel1 = make_selector(ThermalStandard, "322_CT_6")
sel2 = make_selector(ThermalStandard, "322_CT_6"; name = "my_selector")

See also: make_selector unified function documentation

source
InfrastructureSystems.make_selector — Method
make_selector(
    component_type::Type{<:InfrastructureSystems.InfrastructureSystemsComponent};
    groupby,
    name
) -> InfrastructureSystems.TypeComponentSelector

Make a ComponentSelector from a type of component. Optionally provide a grouping behavior and/or name for the selector. Selectors constructed this way point to all the components of the given type, grouped by the groupby argument (see the base make_selector documentation).

Arguments

  • component_type::Type{<:InfrastructureSystemsComponent}: the type of component to select
  • groupby::Union{Symbol, Function} = :each: the grouping behavior (see the base make_selector documentation)
  • name::Union{String, Nothing} = nothing: the name of the selector; if not provided, one will be constructed automatically

Examples

sel1 = make_selector(RenewableDispatch)
sel2 = make_selector(RenewableDispatch; groupby = :all)
sel3 = make_selector(RenewableDispatch; name = "my_selector")

See also: make_selector unified function documentation

source
InfrastructureSystems.make_selector — Method
make_selector(
    content::ComponentSelector...;
    name
) -> InfrastructureSystems.ListComponentSelector

Make a ComponentSelector from several existing ComponentSelectors. Optionally provide a name for the selector. Selectors constructed this way contain one group for each of the selectors they were constructed with.

Arguments

  • content::ComponentSelector...: the list of selectors that should form the groups
  • name::Union{String, Nothing} = nothing: the name of the selector; if not provided, one will be constructed automatically

Examples

sel1 = make_selector(make_selector(ThermalStandard), make_selector(RenewableDispatch))
sel2 = make_selector(make_selector(ThermalStandard), make_selector(RenewableDispatch); name = "my_selector")

See also: make_selector unified function documentation

source
InfrastructureSystems.rebuild_selector — Method
rebuild_selector(
    selector::InfrastructureSystems.ListComponentSelector;
    name,
    groupby
) -> InfrastructureSystems.ListComponentSelector

Returns a ComponentSelector functionally identical to the input selector except with the changes to its fields specified in the keyword arguments. It is not guaranteed that the result will have the same concrete type.

Examples

Suppose you have a selector with manual groups and you want to group by :each:

sel = make_selector(make_selector(ThermalStandard), make_selector(RenewableDispatch))
sel_each = rebuild_selector(sel; groupby = :each)  # will be a RegroupedComponentSelector
source
InfrastructureSystems.rebuild_selector — Method
rebuild_selector(
    selector::ComponentSelector;
    name
) -> InfrastructureSystems.ListComponentSelector

Returns a ComponentSelector functionally identical to the input selector except with the changes to its fields specified in the keyword arguments.

Examples

Suppose you have a selector with name = "my_name. If you instead wanted name = "your_name:

sel = make_selector(ThermalStandard, "322_CT_6"; name = "my_name")
sel_yours = rebuild_selector(sel; name = "your_name")
source
InfrastructureSystems.rebuild_selector — Method
rebuild_selector(
    selector::DynamicallyGroupedComponentSelector;
    name,
    groupby
) -> Any

Returns a ComponentSelector functionally identical to the input selector except with the changes to its fields specified in the keyword arguments.

Examples

Suppose you have a selector with groupby = :all. If you instead wanted groupby = :each:

sel = make_selector(ThermalStandard; groupby = :all)
sel_each = rebuild_selector(sel; groupby = :each)
source
PowerSystems.get_component — Method
get_component(
    scope_limiter::Union{Nothing, Function},
    selector::SingularComponentSelector,
    sys::System
) -> Union{Nothing, InfrastructureSystems.InfrastructureSystemsComponent}

Return the component of the System that makes up the SingularComponentSelector; nothing if there is none. Optionally specify a filter function scope_limiter as the first argument to limit the components that should be considered.

Arguments

source
PowerSystems.get_components — Method
get_components(
    scope_limiter::Union{Nothing, Function},
    selector::ComponentSelector,
    sys::System
) -> Any

Return the components of the System that make up the ComponentSelector. Optionally specify a filter function scope_limiter as the first argument to limit the components that should be considered.

Arguments

source
PowerSystems.get_groups — Method
get_groups(
    scope_limiter::Union{Nothing, Function},
    selector::ComponentSelector,
    sys::System
) -> Any

Return the groups that make up the ComponentSelector. Optionally specify a filter function scope_limiter as the first argument to limit the components that should be considered.

Arguments

source
InfrastructureSystems.component_to_qualified_string — Method
component_to_qualified_string(
    component_type::Type{<:InfrastructureSystems.InfrastructureSystemsComponent},
    component_name::AbstractString
) -> Any

Canonical way to turn an InfrastructureSystemsComponent specification/instance into a unique-per-system string.

source
InfrastructureSystems.subtype_to_string — Method
subtype_to_string(
    subtype::Type{<:InfrastructureSystems.InfrastructureSystemsComponent}
) -> Any

Canonical way to turn an InfrastructureSystemsComponent subtype into a unique string.

source

Additional Component Methods

PowerSystems.get_base_voltage — Method
get_base_voltage(
    line::Union{Line, MonitoredLine}
) -> Union{Nothing, Float64}

Return the base voltage (kV) of a Line or MonitoredLine by reading the base_voltage from both endpoints of the line's Arc.

If the two bus voltages are identical, that value is returned directly. If they differ but are within BRANCH_BUS_VOLTAGE_DIFFERENCE_TOL (percent), the value with fewer significant figures is returned (i.e., the rounder number). If the difference exceeds the tolerance, an error is thrown.

Arguments

  • line::Union{Line, MonitoredLine}: The transmission line.
source
PowerSystems.get_power_factor — Method
get_power_factor(_::Device) -> Float64

Generic fallback — throws ArgumentError for devices that do not implement get_power_factor.

source
PowerSystems.get_rating — Method
get_rating(_::Device) -> Float64

Generic fallback — throws ArgumentError for devices that do not implement get_rating.

source

Deprecated Methods

PowerSystems.TwoTerminalHVDCLine — Function
TwoTerminalHVDCLine(
    name,
    available,
    active_power_flow,
    arc,
    active_power_limits_from,
    active_power_limits_to,
    reactive_power_limits_from,
    reactive_power_limits_to
) -> TwoTerminalGenericHVDCLine
TwoTerminalHVDCLine(
    name,
    available,
    active_power_flow,
    arc,
    active_power_limits_from,
    active_power_limits_to,
    reactive_power_limits_from,
    reactive_power_limits_to,
    loss
) -> TwoTerminalGenericHVDCLine
TwoTerminalHVDCLine(
    name,
    available,
    active_power_flow,
    arc,
    active_power_limits_from,
    active_power_limits_to,
    reactive_power_limits_from,
    reactive_power_limits_to,
    loss,
    services
) -> TwoTerminalGenericHVDCLine
TwoTerminalHVDCLine(
    name,
    available,
    active_power_flow,
    arc,
    active_power_limits_from,
    active_power_limits_to,
    reactive_power_limits_from,
    reactive_power_limits_to,
    loss,
    services,
    ext
) -> TwoTerminalGenericHVDCLine

Deprecated method for the old TwoTerminalHVDCLine that returns the new TwoTerminalGenericHVDCLine. This constructor is used for some backward compatibility and will be removed in a future version.

source
PowerSystems.TwoTerminalHVDCLine — Function
TwoTerminalHVDCLine(
    name,
    available,
    active_power_flow,
    arc,
    active_power_limits_from,
    active_power_limits_to,
    reactive_power_limits_from,
    reactive_power_limits_to,
    loss::@NamedTuple{l0::Float64, l1::Float64}
) -> TwoTerminalGenericHVDCLine
TwoTerminalHVDCLine(
    name,
    available,
    active_power_flow,
    arc,
    active_power_limits_from,
    active_power_limits_to,
    reactive_power_limits_from,
    reactive_power_limits_to,
    loss::@NamedTuple{l0::Float64, l1::Float64},
    services
) -> TwoTerminalGenericHVDCLine
TwoTerminalHVDCLine(
    name,
    available,
    active_power_flow,
    arc,
    active_power_limits_from,
    active_power_limits_to,
    reactive_power_limits_from,
    reactive_power_limits_to,
    loss::@NamedTuple{l0::Float64, l1::Float64},
    services,
    ext
) -> TwoTerminalGenericHVDCLine

Deprecated method for the old TwoTerminalHVDCLine that returns the new TwoTerminalGenericHVDCLine. This constructor is used for some backward compatibility and will be removed in a future version.

source
PowerSystems.TwoTerminalHVDCLine — Function
TwoTerminalHVDCLine(
    name,
    available,
    active_power_flow,
    arc,
    active_power_limits_from,
    active_power_limits_to,
    reactive_power_limits_from,
    reactive_power_limits_to,
    loss::Union{LinearCurve, PiecewiseIncrementalCurve}
) -> TwoTerminalGenericHVDCLine
TwoTerminalHVDCLine(
    name,
    available,
    active_power_flow,
    arc,
    active_power_limits_from,
    active_power_limits_to,
    reactive_power_limits_from,
    reactive_power_limits_to,
    loss::Union{LinearCurve, PiecewiseIncrementalCurve},
    services
) -> TwoTerminalGenericHVDCLine
TwoTerminalHVDCLine(
    name,
    available,
    active_power_flow,
    arc,
    active_power_limits_from,
    active_power_limits_to,
    reactive_power_limits_from,
    reactive_power_limits_to,
    loss::Union{LinearCurve, PiecewiseIncrementalCurve},
    services,
    ext
) -> TwoTerminalGenericHVDCLine

Deprecated method for the old TwoTerminalHVDCLine that returns the new TwoTerminalGenericHVDCLine. This constructor is used for some backward compatibility and will be removed in a future version.

source
PowerSystems.TwoTerminalHVDCLine — Method
TwoTerminalHVDCLine(
    name,
    available,
    active_power_flow,
    arc,
    active_power_limits_from,
    active_power_limits_to,
    reactive_power_limits_from,
    reactive_power_limits_to,
    loss::@NamedTuple{l0::Float64, l1::Float64},
    services,
    ext,
    internal
) -> TwoTerminalGenericHVDCLine

Deprecated method for the old TwoTerminalHVDCLine that returns the new TwoTerminalGenericHVDCLine. This constructor is used for some backward compatibility and will be removed in a future version.

source
PowerSystems.TwoTerminalHVDCLine — Method
TwoTerminalHVDCLine(
;
    name,
    available,
    active_power_flow,
    arc,
    active_power_limits_from,
    active_power_limits_to,
    reactive_power_limits_from,
    reactive_power_limits_to,
    loss,
    services,
    ext,
    internal
)

Deprecated method for the old TwoTerminalHVDCLine that returns the new TwoTerminalGenericHVDCLine. This constructor is used for some backward compatibility and will be removed in a future version.

source

Parsing

PowerSystems.PowerSystemTableData — Method
PowerSystemTableData(
    directory::AbstractString,
    base_power::Float64,
    user_descriptor_file::AbstractString;
    descriptor_file,
    generator_mapping_file,
    timeseries_metadata_file
) -> PowerSystemTableData

Reads in all the data stored in csv files in a directory

Warning

This parser is planned for deprecation. PowerSystems.jl will be moving to a database solution for handling data. There are plans to eventually include utility functions to translate from .csv files to the database, but there will probably be a gap in support. Users are recommended to write their own custom Julia code to import data from their unique data formats, rather than relying on this parsing code. See How-to Build a System from CSV Files for an example.

Arguments

  • directory::AbstractString: directory containing CSV files
  • base_power::Float64: base power for the constructed System
  • user_descriptor_file::AbstractString: customized input descriptor file. Example
  • descriptor_file=POWER_SYSTEM_DESCRIPTOR_FILE: PowerSystems.jl descriptor file. Default
  • generator_mapping_file=GENERATOR_MAPPING_FILE_CDM: generator mapping configuration file. Default
  • timeseries_metadata_file = joinpath(directory, "timeseries_pointers"): Time series pointers .json file. Example

The general format for data in the directory is:

  • bus.csv (required)
    • columns specifying area and zone will create a corresponding set of Area and LoadZone objects.
    • columns specifying max_active_power or max_reactive_power will create PowerLoad objects when nonzero values are encountered and will contribute to the peak_active_power and peak_reactive_power values for the corresponding LoadZone object.
  • branch.csv
  • dc_branch.csv
  • gen.csv
  • load.csv
  • reserves.csv
  • storage.csv

Custom construction of generators

Each generator will be defined as a concrete subtype of Generator, based on the fuel and type columns in gen.csv and the generator_mapping_file. The default mapping file is src/parsers/generator_mapping.yaml. You can override this behavior by specifying your own file.

Custom Column names

PowerSystems provides am input mapping capability that allows you to keep your own column names. For example, when parsing raw data for a generator the code expects a column called name. If the raw data instead defines that column as GEN UID then you can change the custom_name field under the generator category to GEN UID in your YAML file.

To enable the parsing of a custom set of csv files, you can generate a configuration file (such as user_descriptors.yaml) from the defaults, which are stored in src/descriptors/power_system_inputs.json.

python ./bin/generate_config_file.py ./user_descriptors.yaml

Next, edit this file with your customizations.

Note that the user-specific customizations are stored in YAML rather than JSON to allow for easier editing. The next few sections describe changes you can make to this YAML file. Do not edit the default JSON file.

Per-unit conversion

PowerSystems defines whether it expects a column value to be per-unit system base, per-unit device base, or natural units in power_system_inputs.json. If it expects a per-unit convention that differs from your values then you can set the unit_system in user_descriptors.yaml and PowerSystems will automatically convert the values. For example, if you have a max_active_power value stored in natural units (MW), but power_system_inputs.json specifies unit_system: device_base, you can enter unit_system: natural_units in user_descriptors.yaml and PowerSystems will divide the value by the value of the corresponding entry in the column identified by the base_reference field in power_system_inputs.json. You can also override the base_reference setting by adding base_reference: My Column to make device base per-unit conversion by dividing the value by the entry in My Column. System base per-unit conversions always divide the value by the system base_power value instantiated when constructing a System.

PowerSystems provides a limited set of unit conversions. For example, if power_system_inputs.json indicates that a value's unit is degrees but your values are in radians then you can set unit: radian in your YAML file. Other valid unit entries include GW, GWh, MW, MWh, kW, and kWh.

Examples

data_dir = "/data/my-data-dir"
base_power = 100.0
descriptors = "./user_descriptors.yaml"
timeseries_metadata_file = "./timeseries_pointers.json"
generator_mapping_file = "./generator_mapping.yaml"
data = PowerSystemTableData(
    data_dir,
    base_power,
    descriptors;
    timeseries_metadata_file = timeseries_metadata_file,
    generator_mapping_file = generator_mapping_file,
)
sys = System(data; time_series_in_memory = true)
source
PowerSystems.create_poly_cost — Method
create_poly_cost(
    gen,
    cost_colnames
) -> Union{Tuple{LinearCurve, Float64}, Tuple{QuadraticCurve, Float64}}

create_poly_cost(gen, cost_colnames)

Return a Polynomial function cost based on the coeffiecients provided on gen.

Three supported cases,

  1. If three values are passed then we have data looking like: a2 * x^2 + a1 * x + a0,
  2. If a1 and a0 are passed then we have data looking like: a1 * x + a0,
  3. If only a1 is passed then we have data looking like: a1 * x.
source
PowerSystems.PowerModelsData — Method
PowerModelsData(
    file::Union{IO, String};
    kwargs...
) -> PowerModelsData

Constructs PowerModelsData from a raw file. Currently Supports MATPOWER and PSSE data files parsed by PowerModels.

source
PowerSystems.add_dyn_injectors! — Method
add_dyn_injectors!(sys::System, dyr_file::AbstractString)

Add to a system already created the dynamic components. The system should already be parsed from a .raw file.

Examples:

dyr_file = "Example.dyr"
add_dyn_injectors!(sys, dyr_file)
source
PowerSystems.parse_file — Method
parse_file(
    io::IO;
    import_all,
    validate,
    correct_branch_rating,
    filetype
) -> Any

Parses the iostream from a file

source
PowerSystems.parse_file — Method
parse_file(
    file::String;
    import_all,
    validate,
    correct_branch_rating
) -> Any

parse_file(
    file;
    import_all = false,
    validate = true,
    correct_branch_rating = true,
)

Parses a Matpower .m file or PTI (PSS(R)E-v33) .raw file into a PowerModels data structure. All fields from PTI files will be imported if import_all is true (Default: false).

source
PowerSystems.parse_matlab_file — Method
parse_matlab_file(
    file_string::String;
    kwargs...
) -> Union{Dict{String, Any}, Tuple{Dict{String, Any}, Union{Nothing, SubString}, Dict{String, Any}}}

Parse a MATLAB .m file into a Dict.

source
PowerSystems.parse_matlab_string — Method
parse_matlab_string(
    data_string::String;
    extended
) -> Union{Dict{String, Any}, Tuple{Dict{String, Any}, Union{Nothing, SubString}, Dict{String, Any}}}

Parse a MATLAB data string into a Dict, extracting function definitions and matrix assignments.

source

Logging

PowerSystems.configure_logging — Method
configure_logging(
;
    console_level,
    file_level,
    filename
) -> MultiLogger

Creates console and file loggers.

Note: Log messages may not be written to the file until flush() or close() is called on the returned logger.

Arguments

  • console_level = Logging.Error: level for console messages
  • file_level = Logging.Info: level for file messages
  • filename::Union{Nothing, AbstractString} = "power-systems.log": log file; pass nothing to disable file logging

Example

logger = configure_logging(console_level = Logging.Info)
@info "log message"
close(logger)
source