InfrastructureSystems API Reference

Delimiter to use when constructing qualified names like component_type__component_name.

Evaluate the PiecewiseLinearData or PiecewiseStepData at a given x-coordinate

Supertype for recorder events

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.

A data structure that acts like a container of components. The ComponentContainer interface consists of:

• get_components
• get_component
• get_available_components
• get_available_component

Notable subtypes include Components, SystemData, and PowerSystems.System.

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.

A simple container for components and time series data.

CompressionSettings(enabled, type, level, shuffle)

Provides customization of HDF5 compression settings.

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

• type::InfrastructureSystems.CompressionTypesModule.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,
)

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

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

• power_units::InfrastructureSystems.UnitSystemModule.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.

Thrown upon detection of user data that is not supported.

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

Deterministic(
    name::AbstractString,
    input_data::AbstractDict{Dates.DateTime, <:TimeSeries.TimeArray};
    resolution,
    interval,
    normalization_factor,
    scaling_factor_multiplier
) -> InfrastructureSystems.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.

Deterministic(
    name::AbstractString,
    filename::AbstractString,
    component::InfrastructureSystems.InfrastructureSystemsComponent,
    resolution::Dates.Period;
    interval,
    normalization_factor,
    scaling_factor_multiplier
) -> InfrastructureSystems.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.

Deterministic(
    name::AbstractString,
    series_data::InfrastructureSystems.RawTimeSeries,
    resolution::Dates.Period;
    interval,
    normalization_factor,
    scaling_factor_multiplier
) -> InfrastructureSystems.Deterministic

Construct Deterministic from RawTimeSeries.

Deterministic(
    src::InfrastructureSystems.Deterministic,
    name::AbstractString;
    scaling_factor_multiplier
) -> InfrastructureSystems.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)

Deterministic(
    forecast::InfrastructureSystems.Deterministic,
    data
) -> InfrastructureSystems.Deterministic

Construct a new Deterministic from an existing instance and a subset of data.

mutable struct DeterministicMetadata <: ForecastMetadata
    name::String
    resolution::Dates.Period
    initial_timestamp::Dates.DateTime
    interval::Dates.Period
    count::Int
    time_series_uuid::UUIDs.UUID
    horizon::Dates.Period
    time_series_type::Type{<:AbstractDeterministic}
    scaling_factor_multiplier::Union{Nothing, Function}
    features::Dict{String, Union{Bool, Int, String}}
    internal::InfrastructureSystemsInternal
end

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

Arguments

• name::String: user-defined name
• resolution::Dates.Period:
• initial_timestamp::Dates.DateTime: time series availability time
• interval::Dates.Period: time step between forecast windows
• count::Int: number of forecast windows
• time_series_uuid::UUIDs.UUID: reference to time series data
• horizon::Dates.Period: length of this time series
• time_series_type::Type{<:AbstractDeterministic}: Type of the time series data associated with this metadata.
• scaling_factor_multiplier::Union{Nothing, Function}: (default: nothing) Applicable when the time series data are scaling factors. Called on the associated component to convert the values.
• features::Dict{String, Union{Bool, Int, String}}: (default: Dict{String, Any}()) User-defined tags that differentiate multiple time series arrays that represent the same component attribute, such as different arrays for different scenarios or years.
• internal::InfrastructureSystemsInternal:

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

Base type for auxillary structs. These should not be stored in a system.

PluralComponentSelectors whose grouping is determined by a groupby field. The semantics of this field are described at make_selector.

Specializes the behavior of SimpleLogger by adding timestamps and process and thread IDs.

ComponentSelector represented by a filter function and a type of component. Contains all the components of that type that satisfy the filter function, grouped by the groupby field (see make_selector).

Wrapper around Iterators.Flatten to provide total length.

Supertype for forecast time series Current concrete subtypes are:

• Deterministic
• DeterministicSingleTimeSeries
• Scenarios
• Probabilistic

Subtypes of Forecast must implement:

• get_horizon_count
• get_initial_times
• get_initial_timestamp
• get_name
• get_scaling_factor_multiplier
• get_window
• iterate_windows

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

A unique key to identify and retrieve a Forecast

See: get_time_series_keys and get_time_series(::TimeSeriesOwners, ::TimeSeriesKey).

struct FuelCurve{T<:InfrastructureSystems.ValueCurve} <: InfrastructureSystems.ProductionVariableCostCurve{T<:InfrastructureSystems.ValueCurve}

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

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

• fuel_cost::Union{Float64, InfrastructureSystems.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.

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

GeographicInfo(
;
    geo_json,
    internal
) -> InfrastructureSystems.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)

Stores all time series data in an HDF5 file.

The file used is assumed to be temporary and will be automatically deleted when there are no more references to the storage object.

Hdf5TimeSeriesStorage(
    create_file::Bool;
    filename,
    directory,
    compression
) -> InfrastructureSystems.Hdf5TimeSeriesStorage

Constructs Hdf5TimeSeriesStorage.

Arguments

• create_file::Bool: create new file
• filename=nothing: if nothing, create a temp file, else use this name.
• directory=nothing: if set and filename is nothing, create a temp file in this directory. If it is not set, use the environment variable SIENNA_TIME_SERIES_DIRECTORY. If that is not set, use tempdir(). This should be set if the time series data is larger than the tmp filesystem can hold.

Hdf5TimeSeriesStorage(

) -> InfrastructureSystems.Hdf5TimeSeriesStorage

Constructs Hdf5TimeSeriesStorage by creating a temp file.

Stores all time series data in memory.

InMemoryTimeSeriesStorage(
    hdf5_storage::InfrastructureSystems.Hdf5TimeSeriesStorage
) -> InfrastructureSystems.InMemoryTimeSeriesStorage

Constructs InMemoryTimeSeriesStorage from an instance of Hdf5TimeSeriesStorage.

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.

Base type for structs that are stored in a system.

Required interface functions for subtypes:

Note: InfrastructureSystems provides default implementations for these methods that depend on the struct field names name and internal. If subtypes have different field names, they must implement these methods.

• get_name()
• setnameinternal!()
• get_internal()

Warning: Subtypes should not implement the function setname!(::InfrastructureSystemsComponent, name). InfrastructureSystems uses the component name in internal data structures, so it is not safe to change the name of a component after it has been added to a system. InfrastructureSystems provides setname!(data::SystemData, component, name) for this purpose.

Optional interface functions:

The default function returns true because some get_components functions need to return all "available" and all components that don't explicitly have that attribute should be returned.

• get_available()

The default function is a no-op.

• set_available!()

Subtypes may contain time series and be associated with supplemental attributes. Those behaviors can be modified with these methods:

• supportssupplementalattributes()
• supportstimeseries()

Internal storage common to InfrastructureSystems types.

InfrastructureSystemsInternal(
    u::Base.UUID
) -> InfrastructureSystems.InfrastructureSystemsInternal

Creates InfrastructureSystemsInternal with an existing UUID.

InfrastructureSystemsInternal(
;
    uuid,
    shared_system_references,
    units_info,
    ext
) -> InfrastructureSystems.InfrastructureSystemsInternal

Creates InfrastructureSystemsInternal with a new UUID.

Base type for any struct in the Sienna packages. All structs must implement a kwarg-only constructor to allow deserializing from a Dict.

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.

Evaluate the InputOutputCurve at a given input value x.

LazyDictFromIterator creates a dictionary from an iterator, but only increments the iterator and adds items to the dictionary as it needs them. In the worst case it is identical to creating a dictionary by iterating over the entire list. Each V should have a K member.

Arguments

• K: type of the dictionary keys
• V: type of the dictionary values
• iter: any object implementing the Iterator interface
• getter::Function: method to call on V to get its K

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

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

Evaluate the LinearFunctionData at a given x-coordinate

ComponentSelector represented by a list of other ComponentSelectors. Those selectors form the groups.

Contains information describing a log event.

LogEventTracker() -> InfrastructureSystems.LogEventTracker
LogEventTracker(
    levels
) -> InfrastructureSystems.LogEventTracker

Tracks counts of all log events by level.

Examples

LogEventTracker()
LogEventTracker((Logging.Info, Logging.Warn, Logging.Error))

Redirects log events to multiple loggers. The primary use case is to allow logging to both a file and the console. Secondarily, it can track the counts of all log messages.

Example

MultiLogger([TerminalLogger(stderr), SimpleLogger(stream)], LogEventTracker())

MultiLogger(
    loggers::Array{T<:Base.CoreLogging.AbstractLogger}
) -> InfrastructureSystems.MultiLogger

Creates a MultiLogger with no event tracking.

Example

MultiLogger([TerminalLogger(stderr), SimpleLogger(stream)])

ComponentSelector that refers by type and name to at most a single component. Has a single group that contains that component if it exists or contains no components if it doesn't.

Indicate that the feature at hand happens to not be implemented for the given data even though it could be. If it is a category mistake to imagine this feature defined on that data, use another exception, like TypeError or ArgumentError.

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

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

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

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

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

ComponentSelector subtype that may refer to multiple components.

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

Probabilistic(
    name::AbstractString,
    input_data::AbstractDict{Dates.DateTime, <:TimeSeries.TimeArray},
    percentiles::Vector{Float64};
    resolution,
    interval,
    normalization_factor,
    scaling_factor_multiplier
) -> InfrastructureSystems.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.

Probabilistic(
    name::AbstractString,
    data::DataStructures.SortedDict{Dates.DateTime, Matrix{Float64}},
    percentiles::Vector,
    resolution::Dates.Period;
    interval,
    normalization_factor,
    scaling_factor_multiplier
) -> InfrastructureSystems.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.

Probabilistic(
    name::AbstractString,
    series_data::InfrastructureSystems.RawTimeSeries,
    percentiles::Vector,
    resolution::Dates.Period;
    interval,
    normalization_factor,
    scaling_factor_multiplier
)

Construct Deterministic from RawTimeSeries.

Probabilistic(
    src::InfrastructureSystems.Probabilistic,
    name::AbstractString;
    scaling_factor_multiplier
) -> InfrastructureSystems.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.

mutable struct ProbabilisticMetadata <: ForecastMetadata
    name::String
    initial_timestamp::Dates.DateTime
    resolution::Dates.Period
    interval::Dates.Period
    count::Int
    percentiles::Vector{Float64}
    time_series_uuid::UUIDs.UUID
    horizon::Dates.Period
    scaling_factor_multiplier::Union{Nothing, Function}
    features::Dict{String, Union{Bool, Int, String}}
    internal::InfrastructureSystemsInternal
end

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

Arguments

• name::String: user-defined name
• initial_timestamp::Dates.DateTime: time series availability time
• resolution::Dates.Period:
• interval::Dates.Period: time step between forecast windows
• count::Int: number of forecast windows
• percentiles::Vector{Float64}: Percentiles for the probabilistic forecast
• time_series_uuid::UUIDs.UUID: reference to time series data
• horizon::Dates.Period: length of this time series
• scaling_factor_multiplier::Union{Nothing, Function}: (default: nothing) Applicable when the time series data are scaling factors. Called on the associated component to convert the values.
• features::Dict{String, Union{Bool, Int, String}}: (default: Dict{String, Any}()) User-defined tags that differentiate multiple time series arrays that represent the same component attribute, such as different arrays for different scenarios or years.
• internal::InfrastructureSystemsInternal:

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

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

QuadraticFunctionData(
    data::InfrastructureSystems.LinearFunctionData
) -> InfrastructureSystems.QuadraticFunctionData

Losslessly convert LinearFunctionData to QuadraticFunctionData

Evaluate the QuadraticFunctionData at a given x-coordinate

Wraps the data read from the text files with time series

Records user-defined events in JSON format.

Recorder(
    name::Symbol;
    io,
    mode,
    directory
) -> InfrastructureSystems.Recorder

Construct a Recorder.

Arguments

• name::Symbol: name of recorder
• io::Union{Nothing, IO}: If nothing, record events in a file using name.
• mode = "w": Only used when io is nothing.
• directory = ".": Only used when io is nothing.

ComponentSelector that wraps another ComponentSelector and applies dynamic grouping. Components are the same as those of the wrapped selector, grouping is by the groupby field (see make_selector)

To implement a sub-type of this you need to implement the methods below.

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

Scenarios(
    name::AbstractString,
    input_data::AbstractDict{Dates.DateTime, <:TimeSeries.TimeArray};
    resolution,
    interval,
    normalization_factor,
    scaling_factor_multiplier
) -> InfrastructureSystems.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.

Scenarios(
    name::AbstractString,
    data::DataStructures.SortedDict{Dates.DateTime, Matrix{Float64}},
    resolution::Dates.Period;
    interval,
    normalization_factor,
    scaling_factor_multiplier
) -> InfrastructureSystems.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.

Scenarios(
    src::InfrastructureSystems.Scenarios,
    name::AbstractString;
    scaling_factor_multiplier
) -> InfrastructureSystems.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.

mutable struct ScenariosMetadata <: ForecastMetadata
    name::String
    resolution::Dates.Period
    initial_timestamp::Dates.DateTime
    interval::Dates.Period
    scenario_count::Int64
    count::Int
    time_series_uuid::UUIDs.UUID
    horizon::Dates.Period
    scaling_factor_multiplier::Union{Nothing, Function}
    features::Dict{String, Union{Bool, Int, String}}
    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:
• initial_timestamp::Dates.DateTime: time series availability time
• interval::Dates.Period: time step between forecast windows
• scenario_count::Int64: Number of scenarios
• count::Int: number of forecast windows
• time_series_uuid::UUIDs.UUID: reference to time series data
• horizon::Dates.Period: length of this time series
• scaling_factor_multiplier::Union{Nothing, Function}: (default: nothing) Applicable when the time series data are scaling factors. Called on the associated component to convert the values.
• features::Dict{String, Union{Bool, Int, String}}: (default: Dict{String, Any}()) User-defined tags that differentiate multiple time series arrays that represent the same component attribute, such as different arrays for different scenarios or years.
• internal::InfrastructureSystemsInternal:

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

SingleTimeSeries(
    name::AbstractString,
    filename::AbstractString,
    component::InfrastructureSystems.InfrastructureSystemsComponent,
    resolution::Dates.Period;
    normalization_factor,
    scaling_factor_multiplier
) -> InfrastructureSystems.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.

SingleTimeSeries(
    name::AbstractString,
    data::Union{DataFrames.DataFrame, TimeSeries.TimeArray};
    normalization_factor,
    scaling_factor_multiplier,
    timestamp,
    resolution
) -> InfrastructureSystems.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.

SingleTimeSeries(
    src::InfrastructureSystems.SingleTimeSeries,
    name::AbstractString;
    scaling_factor_multiplier
) -> InfrastructureSystems.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.

SingleTimeSeries(
    time_series::InfrastructureSystems.SingleTimeSeries,
    data::TimeSeries.TimeArray
) -> Any

Creates a new SingleTimeSeries from an existing instance and a subset of data.

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

Construct SingleTimeSeries after constructing a TimeArray from initial_time and time_steps.

mutable struct SingleTimeSeriesMetadata <: StaticTimeSeriesMetadata
    name::String
    resolution::Dates.Period
    initial_timestamp::Dates.DateTime
    time_series_uuid::UUIDs.UUID
    length::Int
    scaling_factor_multiplier::Union{Nothing, Function}
    features::Dict{String, Union{Bool, Int, String}}
    internal::InfrastructureSystemsInternal
end

A TimeSeries Data object in contigous form.

Arguments

• name::String: user-defined name
• resolution::Dates.Period:
• initial_timestamp::Dates.DateTime: time series availability time
• time_series_uuid::UUIDs.UUID: reference to time series data
• length::Int: length of this time series
• scaling_factor_multiplier::Union{Nothing, Function}: (default: nothing) Applicable when the time series data are scaling factors. Called on the associated component to convert the values.
• features::Dict{String, Union{Bool, Int, String}}: (default: Dict{String, Any}()) User-defined tags that differentiate multiple time series arrays that represent the same component attribute, such as different arrays for different scenarios or years.
• internal::InfrastructureSystemsInternal:

ComponentSelector subtype that can only refer to zero or one components. get_components will always return zero or one components; get_component will return the component directly if there is one and return nothing if there is not.

Supertype for static time series, which has one value per time point

Current concrete subtypes are:

• SingleTimeSeries

See also: Forecast

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

A unique key to identify and retrieve a StaticTimeSeries

See: get_time_series_keys and get_time_series(::TimeSeriesOwners, ::TimeSeriesKey).

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.

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.

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.

SupplementalAttributeAssociations(
;
    create_indexes
) -> InfrastructureSystems.SupplementalAttributeAssociations

Construct a new SupplementalAttributeAssociations with an in-memory database.

mutable struct SystemData <: ComponentContainer
    components::Components
    "Masked components are attached to the system for overall management purposes but
    are not exposed in the standard library calls like [`get_components`](@ref).
    Examples are components in a subsystem."
    masked_components::Components
    validation_descriptors::Vector
    internal::InfrastructureSystemsInternal
end

Container for system components and time series data

SystemData(
;
    validation_descriptor_file,
    time_series_in_memory,
    time_series_directory,
    compression
) -> InfrastructureSystems.SystemData

Construct SystemData to store components and time series data.

Arguments

• validation_descriptor_file = nothing: Optionally, a file defining component validation descriptors.
• time_series_in_memory = false: Controls whether time series data is stored in memory or in a file.
• time_series_directory = nothing: Controls what directory time series data is stored in. Default is the environment variable SIENNA_TIME_SERIES_DIRECTORY or tempdir() if that isn't set.
• compression = CompressionSettings(): Controls compression of time series data.

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

Provides counts of time series including attachments to components and supplemental attributes.

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.

Describes how to construct time_series from raw time series data files.

Supertype for keys that can be used to access a desired time series dataset

Concrete subtypes:

• StaticTimeSeriesKey
• ForecastKey

Required methods:

• get_name
• get_resolution
• get_time_series_type

The default methods rely on the field names name and time_series_type.

Abstract type for time_series that are stored in a system. Users never create them or get access to them. Stores references to TimeSeriesData.

TimeSeriesMetadataStore(
    filename::AbstractString
) -> InfrastructureSystems.TimeSeriesMetadataStore

Load a TimeSeriesMetadataStore from a saved database into an in-memory database.

TimeSeriesMetadataStore(

) -> InfrastructureSystems.TimeSeriesMetadataStore

Construct a new TimeSeriesMetadataStore with an in-memory database.

Abstract type for time series storage implementations.

All subtypes must implement:

• clear_time_series!
• deserialize_time_series
• get_compression_settings
• get_num_time_series
• remove_time_series!
• serialize_time_series!
• Base.isempty

ComponentSelector represented by a type of component. Contains all the components of that type, grouped by the groupby field (see make_selector).

Supertype that represents a unitless cost curve

Concrete subtypes are:

• LinearCurve
• QuadraticCurve
• PiecewisePointCurve
• PiecewiseIncrementalCurve
• PiecewiseAverageCurve

*(fd::InfrastructureSystems.FunctionData, c::Real) -> Any

Multiply the FunctionData by a scalar: (f * c)(x) = (c * f)(x) = c * f(x)

*(
    c::Real,
    fd::InfrastructureSystems.LinearFunctionData
) -> InfrastructureSystems.LinearFunctionData

Multiply the LinearFunctionData by a scalar: (c * f)(x) = c * f(x)

*(
    c::Real,
    fd::InfrastructureSystems.PiecewiseLinearData
) -> InfrastructureSystems.PiecewiseLinearData

Multiply the PiecewiseLinearData by a scalar: (c * f)(x) = c * f(x)

*(
    c::Real,
    fd::InfrastructureSystems.PiecewiseStepData
) -> InfrastructureSystems.PiecewiseStepData

Multiply the PiecewiseStepData by a scalar: (c * f)(x) = c * f(x)

*(
    c::Real,
    fd::InfrastructureSystems.QuadraticFunctionData
) -> InfrastructureSystems.QuadraticFunctionData

Multiply the QuadraticFunctionData by a scalar: (c * f)(x) = c * f(x)

+(
    f::InfrastructureSystems.LinearFunctionData,
    g::InfrastructureSystems.LinearFunctionData
) -> InfrastructureSystems.LinearFunctionData

Add two LinearFunctionDatas: (f + g)(x) = f(x) + g(x)

+(
    fd::InfrastructureSystems.LinearFunctionData,
    c::Real
) -> InfrastructureSystems.LinearFunctionData

Add a scalar to the LinearFunctionData: (f + c)(x) = f(x) + c

+(
    f::InfrastructureSystems.PiecewiseLinearData,
    g::InfrastructureSystems.PiecewiseLinearData
) -> InfrastructureSystems.PiecewiseLinearData

Add two PiecewiseLinearDatas: (f + g)(x) = f(x) + g(x). Errors if the x-coordinates are not the same.

+(
    fd::InfrastructureSystems.PiecewiseLinearData,
    c::Real
) -> InfrastructureSystems.PiecewiseLinearData

Add a scalar to the PiecewiseLinearData: (f + c)(x) = f(x) + c

+(
    f::InfrastructureSystems.PiecewiseStepData,
    g::InfrastructureSystems.PiecewiseStepData
) -> InfrastructureSystems.PiecewiseStepData

Add two PiecewiseStepDatas: (f + g)(x) = f(x) + g(x). Errors if the x-coordinates are not the same.

+(
    fd::InfrastructureSystems.PiecewiseStepData,
    c::Real
) -> InfrastructureSystems.PiecewiseStepData

Add a scalar to the PiecewiseStepData: (f + c)(x) = f(x) + c

+(
    f::InfrastructureSystems.QuadraticFunctionData,
    g::InfrastructureSystems.QuadraticFunctionData
) -> InfrastructureSystems.QuadraticFunctionData

Add two QuadraticFunctionDatas: (f + g)(x) = f(x) + g(x)

+(
    fd::InfrastructureSystems.QuadraticFunctionData,
    c::Real
) -> InfrastructureSystems.QuadraticFunctionData

Add a scalar to the QuadraticFunctionData: (f + c)(x) = f(x) + c

+(c::Real, fd::InfrastructureSystems.FunctionData) -> Any

Add a scalar to the FunctionData: (c + f)(x) = (f + c)(x) = f(x) + c

-(fd::InfrastructureSystems.FunctionData) -> Any

Negate the FunctionData: (-f)(x) = -f(x)

<<(fd::InfrastructureSystems.FunctionData, c::Real) -> Any

Left shift the FunctionData by a scalar: (f << c)(x) = (f >> -c)(x) = f(x + c)

>>(
    fd::InfrastructureSystems.LinearFunctionData,
    c::Real
) -> InfrastructureSystems.LinearFunctionData

Right shift the LinearFunctionData by a scalar: (f >> c)(x) = f(x - c)

>>(
    fd::InfrastructureSystems.PiecewiseLinearData,
    c::Real
) -> InfrastructureSystems.PiecewiseLinearData

Right shift the PiecewiseLinearData by a scalar: (f >> c)(x) = f(x - c)

>>(
    fd::InfrastructureSystems.PiecewiseStepData,
    c::Real
) -> InfrastructureSystems.PiecewiseStepData

Right shift the PiecewiseStepData by a scalar: (f >> c)(x) = f(x - c)

>>(
    fd::InfrastructureSystems.QuadraticFunctionData,
    c::Real
) -> InfrastructureSystems.QuadraticFunctionData

Right shift the QuadraticFunctionData by a scalar: (f >> c)(x) = f(x - c)

~(
    fd::InfrastructureSystems.LinearFunctionData
) -> InfrastructureSystems.LinearFunctionData

Flip the LinearFunctionData about the y-axis: (~f)(x) = f(-x)

~(
    fd::InfrastructureSystems.PiecewiseLinearData
) -> InfrastructureSystems.PiecewiseLinearData

Flip the PiecewiseLinearData about the y-axis: (~f)(x) = f(-x)

~(
    fd::InfrastructureSystems.PiecewiseStepData
) -> InfrastructureSystems.PiecewiseStepData

Flip the PiecewiseStepData about the y-axis: (~f)(x) = f(-x)

~(
    fd::InfrastructureSystems.QuadraticFunctionData
) -> InfrastructureSystems.QuadraticFunctionData

Flip the QuadraticFunctionData about the y-axis: (~f)(x) = f(-x)

close(logger::InfrastructureSystems.MultiLogger)

Ensures that any file streams are flushed and closed.

convert(
    _::Type{InfrastructureSystems.QuadraticFunctionData},
    data::InfrastructureSystems.LinearFunctionData
) -> InfrastructureSystems.QuadraticFunctionData

Losslessly convert LinearFunctionData to QuadraticFunctionData

flush(logger::InfrastructureSystems.MultiLogger)

Flush any file streams.

get(
    container::InfrastructureSystems.LazyDictFromIterator,
    key
) -> Any

Returns the item mapped to key. If the key is already stored then it will be returned with a dictionary lookup. If it has not been stored then iterate over the list until it is found.

Returns nothing if key is not found.

zero(
    fd::InfrastructureSystems.PiecewiseLinearData
) -> InfrastructureSystems.PiecewiseLinearData

Get a PiecewiseLinearData with the same x-coordinates as fd but y-coordinates equal to zero

zero(
    fd::InfrastructureSystems.PiecewiseStepData
) -> InfrastructureSystems.PiecewiseStepData

Get a PiecewiseStepData with the same x-coordinates as fd and y-coordinates equal to zero

zero(
    ::Type{InfrastructureSystems.PiecewiseLinearData};
    domain
) -> InfrastructureSystems.PiecewiseLinearData

Get a PiecewiseLinearData representing the function f(x) = 0; optionally specify domain tuple to set the x-coordinates of the endpoints

zero(
    ::Type{InfrastructureSystems.PiecewiseStepData};
    domain
) -> InfrastructureSystems.PiecewiseStepData

Get a PiecewiseStepData representing the function f(x) = 0; optionally specify domain tuple to set the x-coordinates of the endpoints

zero(
    _::Union{InfrastructureSystems.LinearFunctionData, Type{InfrastructureSystems.LinearFunctionData}}
) -> InfrastructureSystems.LinearFunctionData

Get a LinearFunctionData representing the function f(x) = 0

zero(
    _::Union{InfrastructureSystems.QuadraticFunctionData, Type{InfrastructureSystems.QuadraticFunctionData}}
) -> InfrastructureSystems.QuadraticFunctionData

Get a QuadraticFunctionData representing the function f(x) = 0

zero(
    _::Union{Type{InfrastructureSystems.AverageRateCurve}, InfrastructureSystems.AverageRateCurve}
) -> InfrastructureSystems.AverageRateCurve{InfrastructureSystems.LinearFunctionData}

Get an AverageRateCurve representing f(x)/x = 0 with zero initial_input

zero(
    _::Union{Type{InfrastructureSystems.CostCurve}, InfrastructureSystems.CostCurve}
) -> InfrastructureSystems.CostCurve{LinearCurve}

Get a CostCurve representing zero variable cost

zero(
    _::Union{Type{InfrastructureSystems.FuelCurve}, InfrastructureSystems.FuelCurve}
) -> InfrastructureSystems.FuelCurve{LinearCurve}

Get a FuelCurve representing zero fuel usage and zero fuel cost

zero(
    _::Union{Type{InfrastructureSystems.FunctionData}, InfrastructureSystems.FunctionData}
) -> InfrastructureSystems.PiecewiseLinearData

Get a FunctionData representing the function f(x) = 0

zero(
    _::Union{Type{InfrastructureSystems.IncrementalCurve}, InfrastructureSystems.IncrementalCurve}
) -> InfrastructureSystems.IncrementalCurve{InfrastructureSystems.LinearFunctionData}

Get an IncrementalCurve representing f'(x) = 0 with zero initial_input

zero(
    _::Union{Type{InfrastructureSystems.InputOutputCurve}, InfrastructureSystems.InputOutputCurve}
) -> LinearCurve

Get an InputOutputCurve representing f(x) = 0

zero(
    _::Union{Type{InfrastructureSystems.ValueCurve}, InfrastructureSystems.ValueCurve}
) -> LinearCurve

Get a ValueCurve representing zero variable cost

_check_transform_single_time_series(
    data::InfrastructureSystems.SystemData,
    _::Type{InfrastructureSystems.DeterministicSingleTimeSeries},
    horizon::Dates.Period,
    interval::Dates.Period,
    resolution::Union{Nothing, Dates.Period}
) -> Vector{Any}

Check that all existing SingleTimeSeries can be converted to DeterministicSingleTimeSeries with the given horizon and interval.

Throw ConflictingInputsError if any time series cannot be converted.

Return a Vector of NamedTuple of component, time series metadata, and forecast parameters for all matches.

_get_all_concrete_subtypes(
    _::Type{T},
    sub_types::Vector{DataType}
)

Recursively builds a vector of subtypes.

_make_group(
    all_components,
    partition_results,
    group_result,
    group_name
) -> Any

Make a ComponentSelector containing the components in all_components whose corresponding entry of partition_results matches group_result

_validate(
    data::InfrastructureSystems.SystemData,
    component::InfrastructureSystems.InfrastructureSystemsComponent
)

Checks that the component exists in data and is the same object.

add_association!(
    associations::InfrastructureSystems.SupplementalAttributeAssociations,
    component::InfrastructureSystems.InfrastructureSystemsComponent,
    attribute::InfrastructureSystems.SupplementalAttribute
)

Add a supplemental attribute association to the associations. The caller must check for duplicates.

add_component!(
    components::InfrastructureSystems.Components,
    component::InfrastructureSystems.InfrastructureSystemsComponent;
    kwargs...
)

Add a component.

Throws ArgumentError if the component's name is already stored for its concrete type.

Throws InvalidRange if any of the component's field values are outside of defined valid range.

add_component_to_subsystem!(
    data::InfrastructureSystems.SystemData,
    subsystem_name::AbstractString,
    component::InfrastructureSystems.InfrastructureSystemsComponent
)

Add a component to a subsystem.

add_metadata!(
    store::InfrastructureSystems.TimeSeriesMetadataStore,
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    metadata::InfrastructureSystems.TimeSeriesMetadata
)

Add metadata to the store. The caller must check if there are duplicates.

add_serialization_metadata!(data::Dict, _::Type{T})

Add type information to the dictionary that can be used to deserialize the value.

add_subsystem!(
    data::InfrastructureSystems.SystemData,
    subsystem_name::AbstractString
)

Add a new subsystem to the system.

add_time_series!(
    data::InfrastructureSystems.SystemData,
    components,
    time_series::InfrastructureSystems.TimeSeriesData;
    features...
) -> Union{InfrastructureSystems.ForecastKey, InfrastructureSystems.StaticTimeSeriesKey}

Add the same time series data to multiple components.

Arguments

• data::SystemData: SystemData
• components: iterable of components that will store the same time series reference
• time_series::TimeSeriesData: Any object of subtype TimeSeriesData

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.

add_time_series!(
    data::InfrastructureSystems.SystemData,
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    time_series::InfrastructureSystems.TimeSeriesData;
    features...
) -> Union{InfrastructureSystems.ForecastKey, InfrastructureSystems.StaticTimeSeriesKey}

Add time series data to a component or supplemental attribute.

Arguments

• data::SystemData: SystemData
• owner::InfrastructureSystemsComponent: will store the time series reference
• time_series::TimeSeriesData: Any object of subtype TimeSeriesData

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

add_time_series_from_file_metadata!(
    data::InfrastructureSystems.SystemData,
    component_type::Type{<:InfrastructureSystems.InfrastructureSystemsComponent},
    file_metadata::Vector{InfrastructureSystems.TimeSeriesFileMetadata};
    resolution
) -> Vector{InfrastructureSystems.TimeSeriesKey}

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

Arguments

• data::SystemData: system
• file_metadata::Vector{TimeSeriesFileMetadata}: metadata for time series
• resolution::DateTime.Period=nothing: skip time_series that don't match this resolution.

add_time_series_from_file_metadata!(
    data::InfrastructureSystems.SystemData,
    ::Type{T<:InfrastructureSystems.InfrastructureSystemsComponent},
    metadata_file::AbstractString;
    resolution
) -> Vector{InfrastructureSystems.TimeSeriesKey}

Adds time_series from a metadata file or metadata descriptors.

Arguments

• data::SystemData: system
• ::Type{T}: type of the component associated with time series data; may be abstract
• metadata_file::AbstractString: metadata file for time series that includes an array of TimeSeriesFileMetadata instances or a vector.
• resolution::DateTime.Period=nothing: skip time_series that don't match this resolution.

assign_new_uuid_internal!(
    component::InfrastructureSystems.InfrastructureSystemsComponent
)

Assign a new UUID to the component.

assign_new_uuid_internal!(
    obj::InfrastructureSystems.InfrastructureSystemsType
)

Assign a new UUID.

available_and_fn(
    fn::Union{Nothing, Function},
    sys
) -> Union{typeof(InfrastructureSystems.get_available), InfrastructureSystems.var"#optional_and_fns##0#optional_and_fns##1"{typeof(InfrastructureSystems.get_available), <:Function}}

Use optional_and_fns to return a function that computes the conjunction of get_available and the given function

backup_to_temp(
    store::InfrastructureSystems.TimeSeriesMetadataStore
) -> String

Backup the database to a file on the temporary filesystem and return that filename.

begin_supplemental_attributes_update(
    func::Function,
    mgr::InfrastructureSystems.SupplementalAttributeManager
) -> Any

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.

begin_time_series_update(
    func::Function,
    mgr::InfrastructureSystems.TimeSeriesManager
) -> 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.

check_consistency(
    store::InfrastructureSystems.TimeSeriesMetadataStore,
    _::Type{InfrastructureSystems.SingleTimeSeries}
) -> Tuple{Any, Any}

Throw InvalidValue if the SingleTimeSeries arrays have different initial times or lengths. Return the initial timestamp and length as a tuple.

check_resolution(timestamps, resolution::Dates.Period)

Check if the timestamps have a constant resolution. Handles constant periods like Second and Minute as well as irregular periods like Month and Year. Relies on the calendrical arithmetic of the Julia's Dates library. https://docs.julialang.org/en/v1/stdlib/Dates/#TimeType-Period-Arithmetic

Arguments

• timestamps: An indexable sequence of DateTime values
• resolution: a Dates.Period value

clear_components!(
    components::InfrastructureSystems.Components
)

Removes all components from the system.

clear_ext!(
    obj::InfrastructureSystems.InfrastructureSystemsInternal
)

Clear any value stored in ext.

clear_metadata!(
    store::InfrastructureSystems.TimeSeriesMetadataStore
) -> SQLite.Query

Clear all time series metadata from the store.

clear_supplemental_attributes!(
    mgr::InfrastructureSystems.SupplementalAttributeManager
)

Removes all supplemental_attributes from the system.

Ignores whether attributes are attached to components.

clear_supplemental_attributes!(
    data::InfrastructureSystems.SystemData
)

Remove all supplemental attributes.

compare_over_fields(cmp_op, reduce_op, init, a, b) -> Any

For a and b, instances of the same concrete type, iterate over all the fields, compare a's value to b's using cmp_op, and reduce to one value using reduce_op with an initialization value of init.

compare_values(
    match_fn::Union{Nothing, Function},
    x,
    y;
    compare_uuids,
    exclude
) -> Bool

Recursively compares struct values. Prints all mismatched values to stdout.

Arguments

• match_fn: optional, a function used to determine whether two values match in the base case of the recursion. If nothing or not specified, the default implementation uses IS.isequivalent.
• x::T: First value
• y::U: Second value
• compare_uuids::Bool = false: Compare any UUID in the object or composed objects.
• `exclude::Set{Symbol} = Set{Symbol}(): Fields to exclude from comparison. Passed on recursively and so applied per type.

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.

compute_periods_between(
    t1::Dates.DateTime,
    t2::Dates.DateTime,
    period::Dates.Period
) -> Int64

Given a series of timestamps that increment by period, return the number of periods between t1 and t2.

t2 must be greater than or equal to t1. There must be an even number of periods between t1 and t2. period can be regular (e.g., Hour) or irregular (e.g., Month).

Arguments

• t1: The initial timestamp.
• t2: The second timestamp.
• period: The period to use for the index.

Examples

julia> compute_periods_between(
    DateTime("2024-01-01T00:00:00"),
    DateTime("2024-01-01T05:00:00"),
    Hour(1),
)
5
julia> compute_period_index(
    DateTime("2024-02-01T00:00:00"),
    DateTime("2024-04-01T00:00:00"),
    Month(1),
)
2
julia> compute_period_index(
    DateTime("2024-01-01T00:00:00"),
    DateTime("2028-01-01T00:00:00"),
    Year(1),
)
4

compute_sha256(filename::AbstractString) -> String

Return the SHA 256 hash of a file.

compute_time_array_index(
    initial_time::Dates.DateTime,
    other_time::Dates.DateTime,
    resolution::Dates.Period
) -> Any

Given a series of timestamps that start with initial_time and increment by resolution, return the index of other time in the array of timestamps.

Examples

julia> compute_time_array_index(
    DateTime("2024-01-01T00:00:00"),
    DateTime("2024-01-01T05:00:00"),
    Hour(1),
)
6
julia> compute_time_array_index(
    DateTime("2024-01-01T00:00:00"),
    DateTime("2024-04-01T00:00:00"),
    Month(1),
)
4
julia> compute_time_array_index(
    DateTime("2024-01-01T00:00:00"),
    DateTime("2028-01-01T00:00:00"),
    Year(1),
)
5

configure_logging(
;
    console,
    console_stream,
    console_level,
    progress,
    file,
    filename,
    file_level,
    file_mode,
    tracker,
    set_global
) -> InfrastructureSystems.MultiLogger

Creates console and file loggers per caller specification and returns a MultiLogger.

Suppress noisy events by specifying per-event values of maxlog = X and _suppression_period = Y where X is the max number of events that can occur in Y seconds. After the period ends, messages will no longer be suppressed. Note that if you don't specify _suppression_period then maxlog applies for the for the duration of your process (standard Julia logging behavior).

Note: Use of log message suppression and the LogEventTracker are not thread-safe. Please contact the package developers if you need this functionality.

Note: If logging to a file users must call Base.close() on the returned MultiLogger to ensure that all events get flushed.

Arguments

• console::Bool=true: create console logger
• console_stream::IOStream=stderr: stream for console logger
• console_level::Logging.LogLevel=Logging.Error: level for console messages
• progress::Bool=true: enable progress logger
• file::Bool=true: create file logger
• filename::Union{Nothing, String}=log.txt: log file
• file_level::Logging.LogLevel=Logging.Info: level for file messages
• file_mode::String=w+: mode used when opening log file
• tracker::Union{LogEventTracker, Nothing}=LogEventTracker(): optionally track log events
• set_global::Bool=true: set the created logger as the global logger

Example

logger = configure_logging(filename="mylog.txt")
@info "hello world"
@info "hello world" maxlog = 5 _suppression_period = 10

convert_forecast_input_time_arrays(
    data::AbstractDict{Dates.DateTime, <:TimeSeries.TimeArray};
    resolution
) -> Tuple{DataStructures.SortedDict{Dates.DateTime, _A, Base.Order.ForwardOrdering} where _A, Any}

Convert a Dict of TimeSeries.TimeArray to a SortedDict of Arrays. Before converting, check that the resolution is consistent in all time arrays. Return the SortedDict and the resolution.

copy_h5_file(src::AbstractString, dst::AbstractString)

Copies an HDF5 file to a new file. This should be used instead of a system call to copy because it won't copy unused space that results from deleting datasets.

copy_time_series!(
    dst::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    src::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.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.

deserialize(
    _::Type{T<:InfrastructureSystems.InfrastructureSystemsType},
    data::Dict
) -> InfrastructureSystems.SystemData

Deserialize an object from standard types stored in non-Julia formats, such as JSON, into Julia types.

double_equals_from_fields(a, b) -> Any

Compute the conjunction of the == values of all the fields in a and b

empty_group_levels!(
    logger::InfrastructureSystems.MultiLogger
)

Empty the minimum log levels stored for each group.

execute(
    db::SQLite.DB,
    query::AbstractString,
    params::Union{Nothing, Tuple, Vector},
    log_group::Symbol
) -> SQLite.Query

Wrapper around SQLite.DBInterface.execute to provide caching of compiled statements as well as log messages.

execute_count(
    db::SQLite.DB,
    query::AbstractString,
    params::Union{Nothing, Tuple, Vector},
    log_group::Symbol
) -> Any

Run a query to find a count. The query must produce a column called count with one row.

fast_deepcopy_system(
    data::InfrastructureSystems.SystemData;
    skip_time_series,
    skip_supplemental_attributes
) -> InfrastructureSystems.SystemData

Make a deepcopy of a SystemData more quickly by skipping the copying of time series and/or supplemental attributes.

Arguments

• data::SystemData: the SystemData to copy
• skip_time_series::Bool = true: whether to skip copying time series
• skip_supplemental_attributes::Bool = true: whether to skip copying supplemental attributes

Note that setting both skip_time_series and skip_supplemental_attributes to false results in the same behavior as deepcopy with no performance improvement.

from(
    time_series::InfrastructureSystems.SingleTimeSeries,
    timestamp
) -> InfrastructureSystems.SingleTimeSeries

Return a time_series truncated starting with timestamp.

from_file(
    ::Type{InfrastructureSystems.Hdf5TimeSeriesStorage},
    filename::AbstractString;
    read_only,
    directory
) -> InfrastructureSystems.Hdf5TimeSeriesStorage

Constructs Hdf5TimeSeriesStorage from an existing file.

from_h5_file(
    _::Type{InfrastructureSystems.TimeSeriesMetadataStore},
    src::AbstractString,
    directory
) -> InfrastructureSystems.TimeSeriesMetadataStore

Load a TimeSeriesMetadataStore from an HDF5 file into an in-memory database.

from_json(
    _::Type{T<:InfrastructureSystems.InfrastructureSystemsType},
    filename::String
) -> Any

Deserializes a InfrastructureSystemsType from a JSON filename.

from_json(
    io::Union{IO, String},
    _::Type{T<:InfrastructureSystems.InfrastructureSystemsType}
) -> InfrastructureSystems.TestComponent

Deserializes a InfrastructureSystemsType from String or IO.

from_records(
    _::Type{InfrastructureSystems.SupplementalAttributeAssociations},
    records
) -> InfrastructureSystems.SupplementalAttributeAssociations

Add records to the database. Expects output from to_records.

generate_struct_file(
    definition::InfrastructureSystems.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

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

get_abstract_subtypes(_::Type{T}) -> Vector

Returns an array of abstract types that are direct subtypes of T.

get_all_concrete_subtypes(_::Type{T}) -> Any

Returns an array of all concrete subtypes of T. Caches the values for faster lookup on repeated calls.

Note that this does not find parameterized types. It will also not find types dynamically added after the first call of given type.

get_assigned_subsystems(
    data::InfrastructureSystems.SystemData,
    component::InfrastructureSystems.InfrastructureSystemsComponent
) -> Vector

Return a Vector of subsystem names that contain the component.

get_associated_components(
    data::InfrastructureSystems.SystemData,
    attribute::InfrastructureSystems.SupplementalAttribute;
    component_type
) -> Any

Return all components associated with the attribute that match component_type.

Arguments

• data::SystemData: the SystemData to search
• attribute::SupplementalAttribute: Only return components associated with this attribute.
• component_type::Union{Nothing, Type{<:InfrastructureSystemsComponent}}: Optional, type of the components to return. Can be concrete or abstract.

get_associated_supplemental_attributes(
    data::InfrastructureSystems.SystemData,
    component_type::Type{<:InfrastructureSystems.InfrastructureSystemsComponent};
    attribute_type
) -> Any

Return all supplemental attributes associated with the components of the given type, optionally filtered by attribute_type.

Arguments

• data::SystemData: the SystemData to search
• component_type::Type{<:InfrastructureSystemsComponent}: Only return attributes

associated with the components of this type.

• attribute_type::Union{Nothing, Type{<:SupplementalAttribute}}`: Optional, type of the attributes to return. Can be concrete or abstract.

get_attribute_counts_by_type(
    associations::InfrastructureSystems.SupplementalAttributeAssociations
) -> Vector

Return a Vector of OrderedDict of stored time series counts by type.

get_attribute_summary_table(
    associations::InfrastructureSystems.SupplementalAttributeAssociations
) -> DataFrames.DataFrame

Return a DataFrame with the number of supplemental attributes by type for components.

get_available(
    value::InfrastructureSystems.InfrastructureSystemsComponent
) -> Bool

Return true if the component is available.

Like get_component but only on components that are available.

get_available_component(
    selector::InfrastructureSystems.ComponentSelector,
    sys
) -> Union{Nothing, InfrastructureSystems.InfrastructureSystemsComponent}

Like get_component but only operates on components for which get_available is true.

get_available_component(
    scope_limiter::Union{Nothing, Function},
    selector::InfrastructureSystems.ComponentSelector,
    sys
) -> Union{Nothing, InfrastructureSystems.InfrastructureSystemsComponent}

Like get_component but only operates on components for which get_available is true.

Like get_components but only on components that are available.

get_available_components(
    selector::InfrastructureSystems.ComponentSelector,
    sys
) -> Any

Like get_components but only operates on components for which get_available is true.

get_available_components(
    scope_limiter::Union{Nothing, Function},
    selector::InfrastructureSystems.ComponentSelector,
    sys
) -> Any

Like get_components but only operates on components for which get_available is true.

get_available_groups(
    selector::InfrastructureSystems.ComponentSelector,
    sys
) -> Any

Like get_groups but only operates on components for which get_available is true.

get_available_groups(
    scope_limiter::Union{Nothing, Function},
    selector::InfrastructureSystems.ComponentSelector,
    sys
) -> Any

Like get_groups but only operates on components for which get_available is true.

get_average_rates(
    vc::PiecewiseAverageCurve
) -> Vector{Float64}

Get the average rates that define the PiecewiseAverageCurve

get_base_component_type(
    _::InfrastructureSystems.ComponentContainer
) -> Type{InfrastructureSystems.InfrastructureSystemsComponent}

Return the base type stored in the container.

Get the single component that matches the given specification from the ComponentContainer, or nothing if there is no match.

get_component(
    selector::InfrastructureSystems.SingularComponentSelector,
    sys
) -> Union{Nothing, InfrastructureSystems.InfrastructureSystemsComponent}

Get the single component that matches the SingularComponentSelector, or nothing if there is no match.

Arguments

• selector::SingularComponentSelector: the SingularComponentSelector that specifies which component to get
• sys: the ComponentContainer-like source of components to draw from

get_component(
    scope_limiter::Union{Nothing, Function},
    selector::InfrastructureSystems.NameComponentSelector,
    sys
) -> Union{Nothing, InfrastructureSystems.InfrastructureSystemsComponent}

Get the component to which the NameComponentSelector points, or nothing if such a component does not exist in sys.

Arguments

• scope_limiter::Union{Function, Nothing}: see ComponentSelector
• selector::NameComponentSelector: the NameComponentSelector whose component to get
• sys: the ComponentContainer-like source of components to draw from

get_component(
    _::Type{T<:InfrastructureSystems.InfrastructureSystemsComponent},
    components::InfrastructureSystems.Components,
    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

get_component_supplemental_attribute_pairs(
    ::Type{T<:InfrastructureSystems.InfrastructureSystemsComponent},
    ::Type{U<:InfrastructureSystems.SupplementalAttribute},
    data::InfrastructureSystems.SystemData;
    components,
    attributes
) -> Array{NamedTuple{(:component, :supplemental_attribute), var"#s177"}, 1} where var"#s177"<:Tuple{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.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.

Get an iterator of components of a certain specification from the ComponentContainer.

get_components(
    selector::InfrastructureSystems.ComponentSelector,
    sys
) -> Any

Given a ComponentContainer-like source of components, get those components that make up the ComponentSelector.

Arguments

• selector::ComponentSelector: the ComponentSelector that specifies which components to get
• sys: the ComponentContainer-like source of components to draw from

get_components(
    scope_limiter::Union{Nothing, Function},
    selector::InfrastructureSystems.FilterComponentSelector,
    sys
) -> InfrastructureSystems.FlattenIteratorWrapper{T, I} where {T<:InfrastructureSystems.InfrastructureSystemsComponent, I<:(Vector)}

Get the components to which the FilterComponentSelector points.

Arguments

• scope_limiter::Union{Function, Nothing}: see ComponentSelector
• selector::FilterComponentSelector: the FilterComponentSelector whose components to get
• sys: the ComponentContainer-like source of components to draw from

get_components(
    scope_limiter::Union{Nothing, Function},
    selector::InfrastructureSystems.ListComponentSelector,
    sys
) -> InfrastructureSystems.FlattenIteratorWrapper

Get the components to which the ListComponentSelector points.

Arguments

• scope_limiter::Union{Function, Nothing}: see ComponentSelector
• selector::ListComponentSelector: the ListComponentSelector whose components to get
• sys: the ComponentContainer-like source of components to draw from

get_components(
    scope_limiter::Union{Nothing, Function},
    selector::InfrastructureSystems.NameComponentSelector,
    sys
) -> InfrastructureSystems.FlattenIteratorWrapper{T, Vector{Base.ValueIterator}} where T<:InfrastructureSystems.InfrastructureSystemsComponent

Get the components to which the NameComponentSelector points.

Arguments

• scope_limiter::Union{Function, Nothing}: see ComponentSelector
• selector::NameComponentSelector: the NameComponentSelector whose components to get
• sys: the ComponentContainer-like source of components to draw from

get_components(
    scope_limiter::Union{Nothing, Function},
    selector::InfrastructureSystems.RegroupedComponentSelector,
    sys
) -> Any

Get the components to which the RegroupedComponentSelector points.

Arguments

• scope_limiter::Union{Function, Nothing}: see ComponentSelector
• selector::RegroupedComponentSelector: the RegroupedComponentSelector whose components to get
• sys: the ComponentContainer-like source of components to draw from

get_components(
    scope_limiter::Union{Nothing, Function},
    selector::InfrastructureSystems.TypeComponentSelector,
    sys
) -> InfrastructureSystems.FlattenIteratorWrapper{T, I} where {T<:InfrastructureSystems.InfrastructureSystemsComponent, I<:(Vector)}

Get the components to which the TypeComponentSelector points.

Arguments

• scope_limiter::Union{Function, Nothing}: see ComponentSelector
• selector::TypeComponentSelector: the TypeComponentSelector whose components to get
• sys: the ComponentContainer-like source of components to draw from

get_components(
    ::Type{T<:InfrastructureSystems.InfrastructureSystemsComponent},
    components::InfrastructureSystems.Components;
    component_uuids
) -> InfrastructureSystems.FlattenIteratorWrapper{T, I} where {T<:InfrastructureSystems.InfrastructureSystemsComponent, I<:(Vector)}

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

Arguments

• T: component type
• components::Components: Components of the system
• filter_func::Union{Nothing, Function} = nothing: Optional function that accepts a component of type T and returns a Bool. Apply this function to each component and only return components where the result is true.

See also: iterate_components

get_components_by_name(
    _::Type{T<:InfrastructureSystems.InfrastructureSystemsComponent},
    components::InfrastructureSystems.Components,
    name::AbstractString
) -> Vector{T} where T<:InfrastructureSystems.InfrastructureSystemsComponent

Get the components of abstract type T with name. Note that InfrastructureSystems 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.

get_concrete_subtypes(_::Type{T}) -> Vector

Returns an array of concrete types that are direct subtypes of T.

get_constant_term(vc::LinearCurve) -> Float64

Get the constant term (i.e., intercept) of the LinearCurve

get_constant_term(vc::QuadraticCurve) -> Float64

Get the constant term of the QuadraticCurve

get_count(
    value::InfrastructureSystems.DeterministicMetadata
) -> Int64

Get DeterministicMetadata count.

get_count(
    value::InfrastructureSystems.DeterministicSingleTimeSeries
) -> Int64

Get DeterministicSingleTimeSeries count.

get_count(
    value::InfrastructureSystems.ProbabilisticMetadata
) -> Int64

Get ProbabilisticMetadata count.

get_count(
    value::InfrastructureSystems.ScenariosMetadata
) -> Int64

Get ScenariosMetadata count.

get_data(
    value::InfrastructureSystems.Deterministic
) -> DataStructures.SortedDict

Get Deterministic data.

get_data(
    value::InfrastructureSystems.Probabilistic
) -> DataStructures.SortedDict

Get Probabilistic data.

get_data(
    value::InfrastructureSystems.Scenarios
) -> DataStructures.SortedDict

Get Scenarios data.

get_data(
    value::InfrastructureSystems.SingleTimeSeries
) -> TimeSeries.TimeArray

Get SingleTimeSeries data.

get_data_type(
    ts::InfrastructureSystems.TimeSeriesData
) -> Any

Return a String for the data type of the forecast data, this implementation avoids the use of eval on arbitrary code stored in HDF dataset.

get_domain(
    fd::InfrastructureSystems.PiecewiseLinearData
) -> Tuple{Float64, Float64}

Get the domain of the function represented by the PiecewiseLinearData.

get_domain(
    fd::InfrastructureSystems.PiecewiseStepData
) -> Tuple{Float64, Float64}

Get the domain of the function represented by the PiecewiseStepData.

get_domain(
    _::Union{InfrastructureSystems.LinearFunctionData, InfrastructureSystems.QuadraticFunctionData}
) -> Tuple{Float64, Float64}

Get the domain of the function represented by the LinearFunctionData or QuadraticFunctionData (always (-Inf, Inf) for these types).

get_ext(
    obj::InfrastructureSystems.InfrastructureSystemsInternal
) -> Union{Nothing, Dict{String, Any}}

Return a user-modifiable dictionary to store extra information.

get_features(
    value::InfrastructureSystems.DeterministicMetadata
) -> Dict{String, Union{Bool, Int64, String}}

Get DeterministicMetadata features.

get_features(
    value::InfrastructureSystems.ProbabilisticMetadata
) -> Dict{String, Union{Bool, Int64, String}}

Get ProbabilisticMetadata features.

get_features(
    value::InfrastructureSystems.ScenariosMetadata
) -> Dict{String, Union{Bool, Int64, String}}

Get ScenariosMetadata features.

get_features(
    value::InfrastructureSystems.SingleTimeSeriesMetadata
) -> Dict{String, Union{Bool, Int64, String}}

Get SingleTimeSeriesMetadata features.

get_forecast_summary_table(
    store::InfrastructureSystems.TimeSeriesMetadataStore
) -> DataFrames.DataFrame

Return a DataFrame with the number of forecasts for components and supplemental attributes.

get_fuel_cost(
    cost::InfrastructureSystems.FuelCurve
) -> Union{Float64, InfrastructureSystems.TimeSeriesKey}

Get the fuel cost or the name of the fuel cost time series

get_function_data(
    cost::InfrastructureSystems.ProductionVariableCostCurve
) -> Any

Get the FunctionData representation of this ProductionVariableCostCurve's ValueCurve

get_function_data(
    curve::InfrastructureSystems.ValueCurve
) -> Any

Get the underlying FunctionData representation of this ValueCurve

get_geo_json(
    geo::InfrastructureSystems.GeographicInfo
) -> Dict{String, Any}

get_geo_json(geo::GeographicInfo)

Get the GeoJSON dictionary from a GeographicInfo attribute.

Arguments

• geo::GeographicInfo: the GeographicInfo attribute

get_group_level(
    logger::InfrastructureSystems.MultiLogger,
    group::Symbol
) -> Union{Nothing, Base.CoreLogging.LogLevel}

Return the minimum logging level for a group or nothing if group is not stored.

get_group_levels(
    logger::InfrastructureSystems.MultiLogger
) -> Dict{Symbol, Base.CoreLogging.LogLevel}

Return the minimum logging levels for groups that have been stored.

get_groups(
    selector::InfrastructureSystems.ComponentSelector,
    sys
) -> Any

Given a ComponentContainer-like source of components, get the groups that make up the ComponentSelector.

Arguments

• selector::ComponentSelector: the ComponentSelector whose groups should be retrieved
• sys: the ComponentContainer-like source of components to draw from

get_groups(
    scope_limiter::Union{Nothing, Function},
    selector::InfrastructureSystems.DynamicallyGroupedComponentSelector,
    sys
) -> Any

Given a ComponentContainer-like source of components, use the groupby property (see make_selector) to get the groups that make up the DynamicallyGroupedComponentSelector.

Arguments

• scope_limiter::Union{Function, Nothing}: see ComponentSelector
• selector::DynamicallyGroupedComponentSelector: the DynamicallyGroupedComponentSelector whose groups should be retrieved
• sys: the ComponentContainer-like source of components to draw from

get_groups(
    scope_limiter::Union{Nothing, Function},
    selector::InfrastructureSystems.SingularComponentSelector,
    sys
) -> Vector{T} where T<:InfrastructureSystems.SingularComponentSelector

Get the single group that corresponds to the SingularComponentSelector, i.e., itself.

Arguments

• scope_limiter::Union{Function, Nothing}: see ComponentSelector (unused in this case)
• selector::SingularComponentSelector: the SingularComponentSelector whose group should be retrieved
• sys: the ComponentContainer-like source of components to draw from (unused in this case)

get_horizon(
    value::InfrastructureSystems.DeterministicMetadata
) -> Dates.Period

Get DeterministicMetadata horizon.

get_horizon(
    value::InfrastructureSystems.DeterministicSingleTimeSeries
) -> Dates.Period

Get DeterministicSingleTimeSeries horizon.

get_horizon(
    value::InfrastructureSystems.ProbabilisticMetadata
) -> Dates.Period

Get ProbabilisticMetadata horizon.

get_horizon(
    value::InfrastructureSystems.ScenariosMetadata
) -> Dates.Period

Get ScenariosMetadata horizon.

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

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

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

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

get_initial_times(
    f::InfrastructureSystems.Forecast
) -> 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})

Return the initial times in the forecast.

get_initial_timestamp(
    value::InfrastructureSystems.DeterministicMetadata
) -> Dates.DateTime

Get DeterministicMetadata initial_timestamp.

get_initial_timestamp(
    value::InfrastructureSystems.DeterministicSingleTimeSeries
) -> Dates.DateTime

Get DeterministicSingleTimeSeries initial_timestamp.

get_initial_timestamp(
    value::InfrastructureSystems.ProbabilisticMetadata
) -> Dates.DateTime

Get ProbabilisticMetadata initial_timestamp.

get_initial_timestamp(
    value::InfrastructureSystems.ScenariosMetadata
) -> Dates.DateTime

Get ScenariosMetadata initial_timestamp.

get_initial_timestamp(
    value::InfrastructureSystems.SingleTimeSeriesMetadata
) -> Dates.DateTime

Get SingleTimeSeriesMetadata initial_timestamp.

get_input_at_zero(
    curve::InfrastructureSystems.ValueCurve
) -> Any

Get the input_at_zero field of this ValueCurve

get_internal(
    value::InfrastructureSystems.DeterministicMetadata
) -> InfrastructureSystems.InfrastructureSystemsInternal

Get DeterministicMetadata internal.

get_internal(
    value::InfrastructureSystems.Deterministic
) -> InfrastructureSystems.InfrastructureSystemsInternal

Get Deterministic internal.

get_internal(
    geo::InfrastructureSystems.GeographicInfo
) -> InfrastructureSystems.InfrastructureSystemsInternal

get_internal(geo::GeographicInfo)

Get the internal infrastructure systems data from a GeographicInfo attribute.

Arguments

• geo::GeographicInfo: the GeographicInfo attribute

get_internal(
    value::InfrastructureSystems.ProbabilisticMetadata
) -> InfrastructureSystems.InfrastructureSystemsInternal

Get ProbabilisticMetadata internal.

get_internal(
    value::InfrastructureSystems.Probabilistic
) -> InfrastructureSystems.InfrastructureSystemsInternal

Get Probabilistic internal.

get_internal(
    value::InfrastructureSystems.ScenariosMetadata
) -> InfrastructureSystems.InfrastructureSystemsInternal

Get ScenariosMetadata internal.

get_internal(
    value::InfrastructureSystems.Scenarios
) -> InfrastructureSystems.InfrastructureSystemsInternal

Get Scenarios internal.

get_internal(
    value::InfrastructureSystems.SingleTimeSeriesMetadata
) -> InfrastructureSystems.InfrastructureSystemsInternal

Get SingleTimeSeriesMetadata internal.

get_internal(
    value::InfrastructureSystems.SingleTimeSeries
) -> InfrastructureSystems.InfrastructureSystemsInternal

Get SingleTimeSeries internal.

get_interval(
    value::InfrastructureSystems.DeterministicMetadata
) -> Dates.Period

Get DeterministicMetadata interval.

get_interval(
    value::InfrastructureSystems.DeterministicSingleTimeSeries
) -> Dates.Period

Get DeterministicSingleTimeSeries interval.

get_interval(
    value::InfrastructureSystems.Deterministic
) -> Dates.Period

Get Deterministic interval.

get_interval(
    value::InfrastructureSystems.ProbabilisticMetadata
) -> Dates.Period

Get ProbabilisticMetadata interval.

get_interval(
    value::InfrastructureSystems.Probabilistic
) -> Dates.Period

Get Probabilistic interval.

get_interval(
    value::InfrastructureSystems.ScenariosMetadata
) -> Dates.Period

Get ScenariosMetadata interval.

get_interval(
    value::InfrastructureSystems.Scenarios
) -> Dates.Period

Get Scenarios interval.

get_interval_from_initial_times(
    initial_times::Vector{Dates.DateTime}
) -> Union{Dates.Millisecond, Dates.Second}

Return the interval by subtracting the first two initial times.

get_length(
    value::InfrastructureSystems.SingleTimeSeriesMetadata
) -> Int64

Get SingleTimeSeriesMetadata length.

get_log_events(
    tracker::InfrastructureSystems.LogEventTracker,
    level::Base.CoreLogging.LogLevel
) -> Union{Base.ValueIterator{Dict{Symbol, InfrastructureSystems.LogEvent}}, Vector{Any}}

Returns an iterable of log events for a level.

get_metadata(
    store::InfrastructureSystems.TimeSeriesMetadataStore,
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    time_series_type::Type{<:InfrastructureSystems.TimeSeriesData},
    name::String;
    resolution,
    features...
) -> Any

Return the metadata matching the inputs. Throw an exception if there is more than one matching input.

get_name(
    selector::InfrastructureSystems.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"

get_name(
    value::InfrastructureSystems.DeterministicMetadata
) -> String

Get DeterministicMetadata name.

get_name(
    value::InfrastructureSystems.Deterministic
) -> String

Get Deterministic name.

get_name(
    value::InfrastructureSystems.InfrastructureSystemsComponent
) -> Any

Return the name of the component.

get_name(
    value::InfrastructureSystems.ProbabilisticMetadata
) -> String

Get ProbabilisticMetadata name.

get_name(
    value::InfrastructureSystems.Probabilistic
) -> String

Get Probabilistic name.

get_name(
    value::InfrastructureSystems.ScenariosMetadata
) -> String

Get ScenariosMetadata name.

get_name(value::InfrastructureSystems.Scenarios) -> String

Get Scenarios name.

get_name(
    value::InfrastructureSystems.SingleTimeSeriesMetadata
) -> String

Get SingleTimeSeriesMetadata name.

get_name(
    value::InfrastructureSystems.SingleTimeSeries
) -> String

Get SingleTimeSeries name.

get_next_time(
    cache::InfrastructureSystems.TimeSeriesCache
) -> Any

Return the timestamp for the next read with get_next_time_series_array!.

Return nothing if all data has been read.

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)

get_num_attributes(
    associations::InfrastructureSystems.SupplementalAttributeAssociations
) -> Any

Return the number of supplemental attributes.

get_num_components_with_attributes(
    associations::InfrastructureSystems.SupplementalAttributeAssociations
) -> Any

Return the number of components with supplemental attributes.

get_num_steps(
    _::Type{T<:InfrastructureSystems.TimeSeriesFileFormat},
    file::CSV.File,
    period::AbstractArray
) -> Any

Return the number of steps specified by the period in the file.

get_num_steps(
    _::Type{T<:InfrastructureSystems.TimeSeriesFormatPeriodAsHeader},
    file::CSV.File,
    period::AbstractArray
) -> Any

Return the number of steps specified by the period in the file.

get_num_steps(
    _::Type{T<:Union{InfrastructureSystems.TimeSeriesFormatDateTimeAsColumn, InfrastructureSystems.TimeSeriesFormatPeriodAsColumn}},
    file::CSV.File,
    period::AbstractArray
) -> Any

Return the number of steps specified by the period in the file.

get_num_subsystems(
    data::InfrastructureSystems.SystemData
) -> Int64

Return the number of subsystems in the system.

get_num_time_series(
    store::InfrastructureSystems.TimeSeriesMetadataStore
) -> Any

Return the number of unique time series arrays.

get_percentiles(
    value::InfrastructureSystems.ProbabilisticMetadata
) -> Vector{Float64}

Get ProbabilisticMetadata percentiles.

get_percentiles(
    value::InfrastructureSystems.Probabilistic
) -> Vector{Float64}

Get Probabilistic percentiles.

get_period_columns(
    _::Type{InfrastructureSystems.TimeSeriesFormatPeriodAsColumn},
    file::CSV.File
) -> Vector{Symbol}

Return the column names that specify the Period.

get_points(
    data::InfrastructureSystems.PiecewiseLinearData
) -> Vector{@NamedTuple{x::Float64, y::Float64}}

Get the points that define the piecewise data

get_points(
    vc::PiecewisePointCurve
) -> Vector{@NamedTuple{x::Float64, y::Float64}}

Get the points that define the PiecewisePointCurve

get_power_units(
    cost::InfrastructureSystems.ProductionVariableCostCurve
) -> Any

Get the units for the x-axis of the curve

get_proportional_term(vc::LinearCurve) -> Float64

Get the proportional term (i.e., slope) of the LinearCurve

get_proportional_term(vc::QuadraticCurve) -> Float64

Get the proportional (i.e., linear) term of the QuadraticCurve

get_quadratic_term(vc::QuadraticCurve) -> Float64

Get the quadratic term of the QuadraticCurve

Get from a subtype or instance of FunctionData the type of data its get_raw_data method returns

get_resolution(
    value::InfrastructureSystems.DeterministicMetadata
) -> Dates.Period

Get DeterministicMetadata resolution.

get_resolution(
    value::InfrastructureSystems.Deterministic
) -> Dates.Period

Get Deterministic resolution.

get_resolution(
    value::InfrastructureSystems.ProbabilisticMetadata
) -> Dates.Period

Get ProbabilisticMetadata resolution.

get_resolution(
    value::InfrastructureSystems.Probabilistic
) -> Dates.Period

Get Probabilistic resolution.

get_resolution(
    value::InfrastructureSystems.ScenariosMetadata
) -> Dates.Period

Get ScenariosMetadata resolution.

get_resolution(
    value::InfrastructureSystems.Scenarios
) -> Dates.Period

Get Scenarios resolution.

get_resolution(
    value::InfrastructureSystems.SingleTimeSeriesMetadata
) -> Dates.Period

Get SingleTimeSeriesMetadata resolution.

get_resolution(
    value::InfrastructureSystems.SingleTimeSeries
) -> Dates.Period

Get SingleTimeSeries resolution.

get_resolution(ts::TimeSeries.TimeArray) -> Any

Return the resolution from a TimeArray by subtracting the first two timestamps.

get_scaling_factor_multiplier(
    value::InfrastructureSystems.DeterministicMetadata
) -> Union{Nothing, Function}

Get DeterministicMetadata scaling_factor_multiplier.

get_scaling_factor_multiplier(
    value::InfrastructureSystems.Deterministic
) -> Union{Nothing, Function}

Get Deterministic scaling_factor_multiplier.

get_scaling_factor_multiplier(
    value::InfrastructureSystems.ProbabilisticMetadata
) -> Union{Nothing, Function}

Get ProbabilisticMetadata scaling_factor_multiplier.

get_scaling_factor_multiplier(
    value::InfrastructureSystems.Probabilistic
) -> Union{Nothing, Function}

Get Probabilistic scaling_factor_multiplier.

get_scaling_factor_multiplier(
    value::InfrastructureSystems.ScenariosMetadata
) -> Union{Nothing, Function}

Get ScenariosMetadata scaling_factor_multiplier.

get_scaling_factor_multiplier(
    value::InfrastructureSystems.Scenarios
) -> Union{Nothing, Function}

Get Scenarios scaling_factor_multiplier.

get_scaling_factor_multiplier(
    value::InfrastructureSystems.SingleTimeSeriesMetadata
) -> Union{Nothing, Function}

Get SingleTimeSeriesMetadata scaling_factor_multiplier.

get_scaling_factor_multiplier(
    value::InfrastructureSystems.SingleTimeSeries
) -> Union{Nothing, Function}

Get SingleTimeSeries scaling_factor_multiplier.

get_scenario_count(
    value::InfrastructureSystems.ScenariosMetadata
) -> Int64

Get ScenariosMetadata scenario_count.

get_scenario_count(
    value::InfrastructureSystems.Scenarios
) -> Int64

Get Scenarios scenario_count.

get_serialization_metadata(data::Dict) -> Any

Return the type information for the serialized struct.

get_single_time_series(
    value::InfrastructureSystems.DeterministicSingleTimeSeries
) -> InfrastructureSystems.SingleTimeSeries

Get DeterministicSingleTimeSeries single_time_series.

get_slopes(
    pwl::InfrastructureSystems.PiecewiseLinearData
) -> Vector{Float64}

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

get_slopes(vc::PiecewiseIncrementalCurve) -> Vector{Float64}

Fetch the slopes that define the PiecewiseIncrementalCurve

get_slopes(vc::PiecewisePointCurve) -> Vector{Float64}

Calculate the slopes of the line segments defined by the PiecewisePointCurve

get_startup_fuel_offtake(
    cost::InfrastructureSystems.FuelCurve
) -> LinearCurve

Get the function for the fuel consumption at startup

get_static_time_series_summary_table(
    store::InfrastructureSystems.TimeSeriesMetadataStore
) -> DataFrames.DataFrame

Return a DataFrame with the number of static time series for components and supplemental attributes.

get_subsystem_components(
    data::InfrastructureSystems.SystemData,
    subsystem_name::AbstractString
) -> Base.Generator{Set{Base.UUID}, InfrastructureSystems.var"#get_subsystem_components##0#get_subsystem_components##1"{InfrastructureSystems.SystemData}}

Return a Generator of all components in the subsystem.

Throws ArgumentError if the subsystem name is not stored.

get_subsystems(
    data::InfrastructureSystems.SystemData
) -> Base.KeySet{String, Dict{String, Set{Base.UUID}}}

Return an iterator of all subsystem names in the system.

get_supplemental_attributes(
    filter_func::Function,
    _::Type{T<:InfrastructureSystems.SupplementalAttribute},
    mgr::InfrastructureSystems.SupplementalAttributeManager
) -> InfrastructureSystems.FlattenIteratorWrapper{T, I} where {T<:InfrastructureSystems.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.

Arguments

• T: supplemental_attribute type
• mgr::SupplementalAttributeManager: SupplementalAttributeManager in the system
• filter_func::Union{Nothing, Function} = nothing: Optional function that accepts a component of type T and returns a Bool. Apply this function to each component and only return components where the result is true.

get_supplemental_attributes(
    _::Type{T<:InfrastructureSystems.SupplementalAttribute},
    component::InfrastructureSystems.InfrastructureSystemsComponent
) -> Any

Return a Vector of supplemental_attributes. T can be concrete or abstract.

Arguments

• T: supplemental_attribute type
• supplemental_attributes::SupplementalAttributes: SupplementalAttributes in the system
• filter_func::Union{Nothing, Function} = nothing: Optional function that accepts a component of type T and returns a Bool. Apply this function to each component and only return components where the result is true.

get_time_series(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    key::InfrastructureSystems.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

get_time_series(
    ::Type{T<:InfrastructureSystems.TimeSeriesData},
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    name::AbstractString;
    start_time,
    len,
    count,
    resolution,
    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.
• 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

get_time_series_array!(
    cache::InfrastructureSystems.TimeSeriesCache,
    timestamp::Dates.DateTime
) -> Any

Return the TimeSeries.TimeArray starting at timestamp. Reads from storage if the data is not already in cache.

Timestamps must be read sequentially. Repeated reads are allowed. Random access may be added in the future.

Arguments

• cache::StaticTimeSeriesCache: cached instance
• timestamp::Dates.DateTime: starting timestamp for the time series array

get_time_series_array(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    forecast::InfrastructureSystems.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 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

get_time_series_array(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    time_series::InfrastructureSystems.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 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

get_time_series_array(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    key::InfrastructureSystems.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 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

get_time_series_array(
    ::Type{T<:InfrastructureSystems.TimeSeriesData},
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    name::AbstractString;
    resolution,
    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.
• 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 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

get_time_series_counts(
    store::InfrastructureSystems.TimeSeriesMetadataStore
) -> InfrastructureSystems.TimeSeriesCounts

Return an instance of TimeSeriesCounts.

get_time_series_counts_by_type(
    store::InfrastructureSystems.TimeSeriesMetadataStore
) -> Vector

Return a Vector of OrderedDict of stored time series counts by type.

get_time_series_format(file::CSV.File) -> Type

Return the time series format used in the CSV file.

get_time_series_keys(
    store::InfrastructureSystems.TimeSeriesMetadataStore,
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute}
) -> Vector

Return information about each time series array attached to the owner. This information can be used to call get_time_series.

get_time_series_keys(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute}
) -> Vector

Return information about each time series array attached to the owner. This information can be used to call get_time_series(::TimeSeriesOwners, ::TimeSeriesKey).

get_time_series_manager(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute}
) -> Any

Return the TimeSeriesManager or nothing if the component/attribute does not support time series.

get_time_series_multiple(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute};
    ...
) -> Union{Tuple{}, Channel{Any}}
get_time_series_multiple(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    filter_func;
    type,
    name,
    resolution
) -> 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

get_time_series_multiple(
    data::InfrastructureSystems.SystemData;
    ...
) -> Channel{Any}
get_time_series_multiple(
    data::InfrastructureSystems.SystemData,
    filter_func;
    type,
    name
) -> Channel{Any}

Returns an iterator of TimeSeriesData instances attached to 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

• data::SystemData: system
• filter_func = nothing: Only return time_series for which this returns true.
• type = nothing: Only return time_series with this type.
• name = nothing: Only return time_series matching this value.

See also: get_time_series_multiple from an individual component or attribute

get_time_series_resolutions(
    store::InfrastructureSystems.TimeSeriesMetadataStore;
    time_series_type
) -> Any

Return a sorted Vector of distinct resolutions for all time series of the given type (or all types).

get_time_series_timestamps(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    forecast::InfrastructureSystems.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

get_time_series_timestamps(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    time_series::InfrastructureSystems.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

get_time_series_timestamps(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    key::InfrastructureSystems.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

get_time_series_timestamps(
    ::Type{T<:InfrastructureSystems.TimeSeriesData},
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    name::AbstractString;
    resolution,
    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.
• 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

get_time_series_type(
    value::InfrastructureSystems.DeterministicMetadata
) -> Type{<:InfrastructureSystems.AbstractDeterministic}

Get DeterministicMetadata time_series_type.

get_time_series_uuid(
    value::InfrastructureSystems.DeterministicMetadata
) -> Base.UUID

Get DeterministicMetadata time_series_uuid.

get_time_series_uuid(
    value::InfrastructureSystems.ProbabilisticMetadata
) -> Base.UUID

Get ProbabilisticMetadata time_series_uuid.

get_time_series_uuid(
    value::InfrastructureSystems.ScenariosMetadata
) -> Base.UUID

Get ScenariosMetadata time_series_uuid.

get_time_series_uuid(
    value::InfrastructureSystems.SingleTimeSeriesMetadata
) -> Base.UUID

Get SingleTimeSeriesMetadata time_series_uuid.

get_time_series_values(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    forecast::InfrastructureSystems.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 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

get_time_series_values(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    time_series::InfrastructureSystems.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 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

get_time_series_values(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    key::InfrastructureSystems.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 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

get_time_series_values(
    ::Type{T<:InfrastructureSystems.TimeSeriesData},
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    name::AbstractString;
    resolution,
    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.
• 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 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

get_timestamp(
    _::Type{InfrastructureSystems.TimeSeriesFormatYMDPeriodAsColumn},
    file::CSV.File,
    row_index::Int64
) -> Any

Return a Dates.DateTime for the row in the CSV file.

get_total_period(f::InfrastructureSystems.Forecast) -> Any

Return the total period covered by the forecast.

get_unique_timestamps(
    _::Type{T<:InfrastructureSystems.TimeSeriesFileFormat},
    file::CSV.File
) -> Vector{Dict{String, Any}}

Return a vector of dicts of unique timestamps and their counts.

get_uuid(
    geo::InfrastructureSystems.GeographicInfo
) -> Base.UUID

get_uuid(geo::GeographicInfo)

Get the UUID from a GeographicInfo attribute.

Arguments

• geo::GeographicInfo: the GeographicInfo attribute

get_uuid(
    obj::InfrastructureSystems.InfrastructureSystemsType
) -> Base.UUID

Gets the UUID for any InfrastructureSystemsType.

get_value_columns(
    _::Type{InfrastructureSystems.TimeSeriesFormatComponentsAsColumnsNoTime},
    file::CSV.File
) -> Vector{Symbol}

Return the column names with values.

get_value_columns(
    _::Type{InfrastructureSystems.TimeSeriesFormatYMDPeriodAsColumn},
    file::CSV.File
) -> Vector{Symbol}

Return the column names with values (components).

get_value_curve(
    cost::InfrastructureSystems.ProductionVariableCostCurve
) -> Any

Get the underlying ValueCurve representation of this ProductionVariableCostCurve

get_vom_cost(
    cost::InfrastructureSystems.ProductionVariableCostCurve
) -> Any

Get the variable operation and maintenance cost in currency/(power_units h)

get_window(
    forecast::InfrastructureSystems.Forecast,
    index::Int64;
    len
) -> Any

Return the forecast window corresponsing to interval index.

get_x_coords(
    data::InfrastructureSystems.PiecewiseLinearData
) -> Vector{Float64}

Get the x-coordinates of the points that define the piecewise data

get_x_coords(
    data::InfrastructureSystems.PiecewiseStepData
) -> Vector{Float64}

Get the x-coordinates of the points that define the piecewise data

get_x_coords(vc::PiecewiseAverageCurve) -> Vector{Float64}

Get the x-coordinates that define the PiecewiseAverageCurve

get_x_coords(
    vc::PiecewiseIncrementalCurve
) -> Vector{Float64}

Get the x-coordinates that define the PiecewiseIncrementalCurve

get_x_coords(vc::PiecewisePointCurve) -> Vector{Float64}

Get the x-coordinates of the points that define the PiecewisePointCurve

get_x_lengths(
    pwl::Union{InfrastructureSystems.PiecewiseLinearData, InfrastructureSystems.PiecewiseStepData}
) -> Vector{Float64}

Calculates the x-length of each segment of a piecewise curve.

get_y_coords(
    data::InfrastructureSystems.PiecewiseLinearData
) -> Vector{Float64}

Get the y-coordinates of the points that define the PiecewiseLinearData

get_y_coords(
    data::InfrastructureSystems.PiecewiseStepData
) -> Vector{Float64}

Get the y-coordinates of the segments in the PiecewiseStepData

get_y_coords(vc::PiecewisePointCurve) -> Vector{Float64}

Get the y-coordinates of the points that define the PiecewisePointCurve

has_association(
    associations::InfrastructureSystems.SupplementalAttributeAssociations,
    attribute::InfrastructureSystems.SupplementalAttribute
) -> Bool

Return true if there is at least one association matching the inputs.

has_component(
    components::InfrastructureSystems.Components,
    T::Type{<:InfrastructureSystems.InfrastructureSystemsComponent},
    name::AbstractString
) -> Bool

Check to see if a component with name exists.

has_component(
    data::InfrastructureSystems.SystemData,
    subsystem_name::AbstractString,
    component::InfrastructureSystems.InfrastructureSystemsComponent
) -> Bool

Return true if the component is in the subsystem.

has_component(
    data::InfrastructureSystems.SystemData,
    T::Type{<:InfrastructureSystems.InfrastructureSystemsComponent},
    name::AbstractString
) -> Bool

Check to see if a component exists.

has_components(
    components::InfrastructureSystems.Components,
    T::Type{<:InfrastructureSystems.InfrastructureSystemsComponent}
) -> Bool

Check to see if a component if the given type exists.

has_metadata(
    store::InfrastructureSystems.TimeSeriesMetadataStore,
    time_series_uuid::Base.UUID
) -> Bool

Return True if there is time series matching the UUID.

has_supplemental_attributes(
    component::InfrastructureSystems.InfrastructureSystemsComponent
) -> Bool

Return true if the component has supplemental attributes.

has_supplemental_attributes(
    component::InfrastructureSystems.InfrastructureSystemsComponent,
    _::Type{T<:InfrastructureSystems.SupplementalAttribute}
) -> Bool

Return true if the component has supplemental attributes of the given type.

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

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

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

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

hash_from_fields(a) -> Any

Compute a hash of the instance a by combining hashes of all its fields

head(
    time_series::InfrastructureSystems.SingleTimeSeries
) -> Any

Return a time_series with only the first num values.

increment_count!(
    tracker::InfrastructureSystems.LogEventTracker,
    event::InfrastructureSystems.LogEvent,
    suppressed::Bool
) -> Union{Nothing, Int64, InfrastructureSystems.LogEvent}

Increments the count of a log event.

index_to_initial_time(
    forecast::InfrastructureSystems.Forecast,
    index::Int64
) -> Any

Return the Dates.DateTime corresponding to an interval index.

is_assigned_to_subsystem(
    data::InfrastructureSystems.SystemData,
    component::InfrastructureSystems.InfrastructureSystemsComponent,
    subsystem_name::AbstractString
) -> Bool

Return true if the component is assigned to the subsystem.

is_assigned_to_subsystem(
    data::InfrastructureSystems.SystemData,
    component::InfrastructureSystems.InfrastructureSystemsComponent
) -> Bool

Return true if the component is assigned to any subsystems.

is_concave(
    pwl::InfrastructureSystems.PiecewiseLinearData
) -> Bool

Returns True/False depending on the concavity of the underlying data. For piecewise linear data, it checks if the sequence of slopes is non-increasing.

is_concave(
    cost::InfrastructureSystems.ProductionVariableCostCurve
) -> Any

Calculate the concavity of the underlying data

is_concave(curve::InfrastructureSystems.ValueCurve) -> Bool

Calculate the concavity of the underlying data

is_convex(
    pwl::InfrastructureSystems.PiecewiseLinearData
) -> Bool

Returns True/False depending on the convexity of the underlying data

is_convex(
    cost::InfrastructureSystems.ProductionVariableCostCurve
) -> Any

Calculate the convexity of the underlying data

is_convex(curve::InfrastructureSystems.ValueCurve) -> Bool

Calculate the convexity of the underlying data

is_cost_alias(
    _::Union{Type{<:InfrastructureSystems.ValueCurve}, InfrastructureSystems.ValueCurve}
) -> Bool

Whether there is a cost alias for the instance or type under consideration

is_ext_valid_for_serialization(value) -> Bool

Perform a test to see if JSON3 can convert this value so that the code can give the user a a comprehensible corrective action.

is_transform_array_for_hdf_supported(
    _::Type{T<:Real}
) -> Bool

Check if the element type T is supported by transformarrayfor_hdf. Returns true if supported, false otherwise. Uses multiple dispatch for a more Julian approach.

isequal_from_fields(a, b) -> Any

Compute the conjunction of the isequal values of all the fields in a and b

isequivalent(x, y) -> Any

An equality predicate that is true for NaN, NaN (unlike ==) and for -0.0, 0.0 (unlike isequal)

iterate_components(
    components::InfrastructureSystems.Components
) -> InfrastructureSystems.FlattenIteratorWrapper{InfrastructureSystems.InfrastructureSystemsComponent, I} where I<:(Vector)

Iterates over all components.

Examples

for component in iterate_components(obj)
    @show component
end

See also: get_components

iterate_container(
    container::InfrastructureSystems.InfrastructureSystemsContainer
) -> InfrastructureSystems.FlattenIteratorWrapper{InfrastructureSystems.InfrastructureSystemsComponent, I} where I<:(Vector)

Iterates over all data in the container.

iterate_supplemental_attributes(
    mgr::InfrastructureSystems.SupplementalAttributeManager
) -> Base.Iterators.Flatten{Base.Generator{Base.ValueIterator{Dict{DataType, Dict{Base.UUID, <:InfrastructureSystems.SupplementalAttribute}}}, InfrastructureSystems.var"#iterate_container##0#iterate_container##1"}}

Iterates over all supplemental_attributes.

Examples

for supplemental_attribute in iterate_supplemental_attributes(obj)
    @show supplemental_attribute
end

iterate_windows(
    forecast::InfrastructureSystems.DeterministicSingleTimeSeries
) -> Union{Tuple{Any}, Base.Generator{I, InfrastructureSystems.var"#iterate_windows##0#iterate_windows##1"{InfrastructureSystems.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

iterate_windows(
    forecast::InfrastructureSystems.Deterministic
) -> Base.Generator{I, InfrastructureSystems.var"#iterate_windows_common##0#iterate_windows_common##1"{InfrastructureSystems.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

iterate_windows(
    forecast::InfrastructureSystems.Probabilistic
) -> Base.Generator{I, InfrastructureSystems.var"#iterate_windows_common##0#iterate_windows_common##1"{InfrastructureSystems.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

iterate_windows(
    forecast::InfrastructureSystems.Scenarios
) -> Base.Generator{I, InfrastructureSystems.var"#iterate_windows_common##0#iterate_windows_common##1"{InfrastructureSystems.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

list_associated_component_uuids(
    associations::InfrastructureSystems.SupplementalAttributeAssociations,
    attribute::InfrastructureSystems.SupplementalAttribute,
    _::Nothing
) -> Any

Return the distinct component UUIDs associated with the attribute.

list_associated_component_uuids(
    associations::InfrastructureSystems.SupplementalAttributeAssociations,
    attribute::InfrastructureSystems.SupplementalAttribute,
    component_type::Type{<:InfrastructureSystems.InfrastructureSystemsComponent}
) -> Any

Return the distinct component UUIDs associated with the attribute, filter by component type.

list_associated_component_uuids(
    associations::InfrastructureSystems.SupplementalAttributeAssociations,
    attribute_type::Type{<:InfrastructureSystems.SupplementalAttribute},
    _::Nothing
) -> Any

Return the distinct component UUIDs associated with the attribute type.

list_associated_component_uuids(
    associations::InfrastructureSystems.SupplementalAttributeAssociations,
    attribute_type::Type{<:InfrastructureSystems.SupplementalAttribute},
    component_type::Type{<:InfrastructureSystems.InfrastructureSystemsComponent}
) -> Any

Return the distinct component UUIDs associated with the attribute type, filter by component_type.

list_associated_pair_uuids(
    associations::InfrastructureSystems.SupplementalAttributeAssociations,
    attribute_type::Type{<:InfrastructureSystems.SupplementalAttribute},
    component_type::Type{<:InfrastructureSystems.InfrastructureSystemsComponent}
) -> Vector

Return the component and attribute UUIDs that are associated with the given types.

list_associated_supplemental_attribute_uuids(
    associations::InfrastructureSystems.SupplementalAttributeAssociations,
    component::InfrastructureSystems.InfrastructureSystemsComponent,
    _::Nothing
) -> Any

Return the distinct attribute UUIDs associated with the component.

list_associated_supplemental_attribute_uuids(
    associations::InfrastructureSystems.SupplementalAttributeAssociations,
    component::InfrastructureSystems.InfrastructureSystemsComponent,
    attribute_type::Type{<:InfrastructureSystems.SupplementalAttribute}
) -> Any

Return the distinct attribute UUIDs associated with the component, filter by attribute type.

list_associated_supplemental_attribute_uuids(
    associations::InfrastructureSystems.SupplementalAttributeAssociations,
    component_type::Type{<:InfrastructureSystems.InfrastructureSystemsComponent},
    _::Nothing
) -> Any

Return the distinct attribute UUIDs associated with the component type.

list_associated_supplemental_attribute_uuids(
    associations::InfrastructureSystems.SupplementalAttributeAssociations,
    component_type::Type{<:InfrastructureSystems.InfrastructureSystemsComponent},
    attribute_type::Type{<:InfrastructureSystems.SupplementalAttribute}
) -> Any

Return the distinct attribute UUIDs associated with the component type, filter by attribute_type.

list_existing_time_series_uuids(
    store::InfrastructureSystems.TimeSeriesMetadataStore,
    uuids
) -> Any

Return the time series UUIDs specified in the passed uuids that are already stored.

list_matching_time_series_uuids(
    store::InfrastructureSystems.TimeSeriesMetadataStore;
    time_series_type,
    name,
    resolution,
    features...
) -> Any

Return the time series UUIDs that match the inputs.

list_metadata_with_owner_uuid(
    store::InfrastructureSystems.TimeSeriesMetadataStore,
    owner_type::Type{<:Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute}};
    time_series_type,
    name,
    resolution,
    features...
) -> Vector

Return a Vector of NamedTuple of owner UUID and time series metadata matching the inputs.

list_recorder_events(
    ::Type{T<:InfrastructureSystems.AbstractRecorderEvent},
    filename::AbstractString
) -> Vector{T} where T<:InfrastructureSystems.AbstractRecorderEvent
list_recorder_events(
    ::Type{T<:InfrastructureSystems.AbstractRecorderEvent},
    filename::AbstractString,
    filter_func::Union{Nothing, Function}
) -> Vector{T} where T<:InfrastructureSystems.AbstractRecorderEvent

Return the events of type T in filename.

Arguments

• T: event type
• filename::AbstractString: filename containing recorder events
• filter_func::Union{Nothing, Function} = nothing: Optional function that accepts an event of type T and returns a Bool. Apply this function to each event and only return events where the result is true.

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.

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

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

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

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

make_selector(
    content::InfrastructureSystems.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

make_time_array(
    forecast::InfrastructureSystems.Forecast,
    start_time::Dates.DateTime;
    len
) -> Any

Return a TimeSeries.TimeArray for one forecast window.

make_time_series!(
    cache::InfrastructureSystems.TimeSeriesParsingCache,
    ts_file_metadata::InfrastructureSystems.TimeSeriesFileMetadata
) -> Any

Return a time series from TimeSeriesFileMetadata.

Arguments

• cache::TimeSeriesParsingCache: cached data
• ts_file_metadata::TimeSeriesFileMetadata: metadata
• resolution::{Nothing, Dates.Period}: skip any time_series that don't match this resolution

mask_component!(
    data::InfrastructureSystems.SystemData,
    component::InfrastructureSystems.InfrastructureSystemsComponent;
    remove_time_series,
    remove_supplemental_attributes
)

Removes the component from the main container and adds it to the masked container.

open_file_logger(func::Function, filename::String) -> Any
open_file_logger(
    func::Function,
    filename::String,
    level
) -> Any
open_file_logger(
    func::Function,
    filename::String,
    level,
    mode
) -> Any

Opens a file logger using Logging.SimpleLogger.

Arguments

• func::Function
• filename::String: logger filename
• level=Logging.Info: optional, to change the minimum logging level
• mode = "w+": Optional, to designate write mode

Example

open_file_logger("log.txt", Logging.Info) do logger
    global_logger(logger)
    @info "hello world"
end

optional_and_fns(
    fn1::Function,
    fn2::Function
) -> InfrastructureSystems.var"#optional_and_fns##0#optional_and_fns##1"{<:Function, <:Function}

Return a function that computes the conjunction of the two functions with short-circuit evaluation, where if either of the functions is nothing it is as if its result is true.

prepare_for_removal!(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute}
)

This function must be called when a component or attribute is removed from a system.

prepare_for_serialization_to_file!(
    data::InfrastructureSystems.SystemData,
    filename::AbstractString;
    force
)

Parent object should call this prior to serialization so that SystemData can store the appropriate path information for the time series data.

read_time_series(
    ::Type{T<:InfrastructureSystems.TimeSeriesData},
    data_file::AbstractString;
    ...
) -> InfrastructureSystems.RawTimeSeries
read_time_series(
    ::Type{T<:InfrastructureSystems.TimeSeriesData},
    data_file::AbstractString,
    component_name;
    kwargs...
) -> Any

Return a TimeArray from a CSV file.

Pass component_name when the file does not have the component name in a column header.

read_time_series(
    ::Type{T<:InfrastructureSystems.TimeSeriesFormatPeriodAsHeader},
    ::Type{<:InfrastructureSystems.StaticTimeSeries},
    file::CSV.File,
    component_name::AbstractString;
    kwargs...
) -> InfrastructureSystems.RawTimeSeries

This version of the function supports the format where there is no column header for a component, so the component_name must be passed in.

read_time_series(
    ::Type{T<:InfrastructureSystems.TimeSeriesFormatComponentsAsColumnsNoTime},
    ::Type{<:InfrastructureSystems.StaticTimeSeries},
    file::CSV.File;
    ...
) -> InfrastructureSystems.RawTimeSeries
read_time_series(
    ::Type{T<:InfrastructureSystems.TimeSeriesFormatComponentsAsColumnsNoTime},
    ::Type{<:InfrastructureSystems.StaticTimeSeries},
    file::CSV.File,
    component_name;
    kwargs...
) -> InfrastructureSystems.RawTimeSeries

This version of the function only has component_name to match the interface. It is unused.

Set start_datetime as a keyword argument for the starting timestamp, otherwise the current day is used.

read_time_series(
    ::Type{T<:Union{InfrastructureSystems.TimeSeriesFormatDateTimeAsColumn, InfrastructureSystems.TimeSeriesFormatPeriodAsColumn}},
    ::Type{<:InfrastructureSystems.StaticTimeSeries},
    file::CSV.File;
    ...
) -> InfrastructureSystems.RawTimeSeries
read_time_series(
    ::Type{T<:Union{InfrastructureSystems.TimeSeriesFormatDateTimeAsColumn, InfrastructureSystems.TimeSeriesFormatPeriodAsColumn}},
    ::Type{<:InfrastructureSystems.StaticTimeSeries},
    file::CSV.File,
    component_name;
    kwargs...
) -> InfrastructureSystems.RawTimeSeries

Return a TimeSeries.TimeArray representing the CSV file.

This version of the function only has component_name to match the interface. It is unused.

read_time_series(
    ::Type{T<:InfrastructureSystems.TimeSeriesFormatDateTimeAsColumn},
    ::Type{InfrastructureSystems.Deterministic},
    file::CSV.File;
    ...
) -> InfrastructureSystems.RawTimeSeries
read_time_series(
    ::Type{T<:InfrastructureSystems.TimeSeriesFormatDateTimeAsColumn},
    ::Type{InfrastructureSystems.Deterministic},
    file::CSV.File,
    component_name;
    kwargs...
) -> InfrastructureSystems.RawTimeSeries

Return a RawTimeSeries from a CSV file.

Pass component_name when the file does not have the component name in a column header.

read_time_series_file_metadata(
    file_path::AbstractString
) -> Any

Reads time_series metadata and fixes relative paths to the data files.

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

rebuild_selector(
    selector::InfrastructureSystems.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")

rebuild_selector(
    selector::InfrastructureSystems.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)

redirect_stdout_to_log(func::Function) -> Any

Redirect all data written to stdout by a function to log events.

register_recorder!(name::Symbol; io, mode, directory)

Register a recorder to log events. Afterwards, calls to @record name <event-type>() will record the event as JSON in <name>.log.

Callers should guarantee that unregister_recorder! is called to close the file handle.

Arguments

• name::Symbol: name of recorder
• io::Union{Nothing, IO}: If nothing, record events in a file using name.
• mode = "w": Only used when io is nothing.
• directory = ".": Only used when io is nothing.

remove_association!(
    associations::InfrastructureSystems.SupplementalAttributeAssociations,
    component::InfrastructureSystems.InfrastructureSystemsComponent,
    attribute::InfrastructureSystems.SupplementalAttribute
)

Remove the association between the attribute and component.

remove_associations!(
    associations::InfrastructureSystems.SupplementalAttributeAssociations,
    type::Type{<:InfrastructureSystems.SupplementalAttribute}
)

Remove all associations of the given type.

remove_component!(
    components::InfrastructureSystems.Components,
    component::InfrastructureSystems.InfrastructureSystemsComponent;
    remove_time_series,
    remove_supplemental_attributes
) -> InfrastructureSystems.InfrastructureSystemsComponent

Remove a component by its value.

Throws ArgumentError if the component is not stored.

remove_component!(
    ::Type{T<:InfrastructureSystems.InfrastructureSystemsComponent},
    components::InfrastructureSystems.Components,
    name::AbstractString;
    remove_time_series,
    remove_supplemental_attributes
) -> InfrastructureSystems.InfrastructureSystemsComponent

Remove a component by its name.

Throws ArgumentError if the component is not stored.

remove_component_from_subsystem!(
    data::InfrastructureSystems.SystemData,
    subsystem_name::AbstractString,
    component::InfrastructureSystems.InfrastructureSystemsComponent
)

Remove a component from a subsystem.

Throws ArgumentError if the subsystem name or component is not stored.

remove_components!(
    _::Type{T<:InfrastructureSystems.InfrastructureSystemsComponent},
    components::InfrastructureSystems.Components
) -> Base.ValueIterator{T} where T<:(Dict{String, <:InfrastructureSystems.InfrastructureSystemsComponent})

Remove all components of type T.

Throws ArgumentError if the type is not stored.

remove_metadata!(
    store::InfrastructureSystems.TimeSeriesMetadataStore,
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    metadata::InfrastructureSystems.TimeSeriesMetadata
) -> Union{Nothing, InfrastructureSystems.TimeSeriesMetadata}

Remove the matching metadata from the store.

remove_subsystem!(
    data::InfrastructureSystems.SystemData,
    subsystem_name::AbstractString
)

Remove a subsystem from the system.

Throws ArgumentError if the subsystem name is not stored.

remove_supplemental_attributes!(
    mgr::InfrastructureSystems.SupplementalAttributeManager,
    _::Type{T<:InfrastructureSystems.SupplementalAttribute}
) -> Base.ValueIterator{T} where T<:(Dict{Base.UUID, <:InfrastructureSystems.SupplementalAttribute})

Remove all supplemental_attributes of type T.

Ignores whether attributes are attached to components.

Throws ArgumentError if the type is not stored.

remove_time_series!(
    mgr::InfrastructureSystems.TimeSeriesManager,
    time_series_type::Type{<:InfrastructureSystems.TimeSeriesData},
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    name::String;
    resolution,
    features...
)

Remove the time series data for a component.

remove_time_series!(
    data::InfrastructureSystems.SystemData,
    ::Type{T<:InfrastructureSystems.TimeSeriesData},
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    name::String;
    resolution,
    features...
)

Remove the time series data for a component.

remove_time_series!(
    data::InfrastructureSystems.SystemData,
    ::Type{T<:InfrastructureSystems.TimeSeriesData};
    resolution
)

Removes all time series of a particular type from a System.

Arguments

• data::SystemData: system
• type::Type{<:TimeSeriesData}: Type of time series objects to remove.
• resolution::Union{Nothing, Dates.Period} = nothing: Only remove time series with this resolution.

replace_component_uuid!(
    associations::InfrastructureSystems.SupplementalAttributeAssociations,
    old_uuid::Base.UUID,
    new_uuid::Base.UUID
)

Replace the component UUID in the table.

replace_iterator(
    container::InfrastructureSystems.LazyDictFromIterator,
    iter
)

Replace the iterator, maintaining the cached dict.

report_log_summary(
    tracker::InfrastructureSystems.LogEventTracker
) -> String

Returns a summary of log event counts by level.

report_log_summary(
    logger::InfrastructureSystems.MultiLogger
) -> String

Returns a summary of log event counts by level.

reset!(cache::InfrastructureSystems.TimeSeriesCache)

Reset parameters in order to start reading data from the beginning with get_next_time_series_array!

reset_iterator(
    container::InfrastructureSystems.LazyDictFromIterator
)

Reset the iterator for cases where underlying arrays have changed.

serialize(
    val::InfrastructureSystems.InfrastructureSystemsType
) -> Dict{String, Any}

Serialize the Julia value into standard types that can be converted to non-Julia formats, such as JSON. In cases where val is an instance of a struct, return a Dict. In cases where val is a scalar value, return that value.

set_available!(
    value::InfrastructureSystems.InfrastructureSystemsComponent
) -> Bool

Set the availability of the component.

set_component!(
    metadata::InfrastructureSystems.TimeSeriesFileMetadata,
    data::InfrastructureSystems.SystemData,
    mod::Module
) -> Union{Nothing, InfrastructureSystems.InfrastructureSystemsComponent}

Set the component value in metadata by looking up the category in module. This requires that category be a string version of a component's abstract type. Modules can override for custom behavior.

set_count!(
    value::InfrastructureSystems.DeterministicMetadata,
    val
) -> Any

Set DeterministicMetadata count.

set_count!(
    value::InfrastructureSystems.DeterministicSingleTimeSeries,
    val
) -> Any

Set DeterministicSingleTimeSeries count.

set_count!(
    value::InfrastructureSystems.ProbabilisticMetadata,
    val
) -> Any

Set ProbabilisticMetadata count.

set_count!(
    value::InfrastructureSystems.ScenariosMetadata,
    val
) -> Any

Set ScenariosMetadata count.

set_data!(
    value::InfrastructureSystems.Deterministic,
    val
) -> Any

Set Deterministic data.

set_data!(
    value::InfrastructureSystems.Probabilistic,
    val
) -> Any

Set Probabilistic data.

set_data!(
    value::InfrastructureSystems.Scenarios,
    val
) -> Any

Set Scenarios data.

set_data!(
    value::InfrastructureSystems.SingleTimeSeries,
    val
) -> Any

Set SingleTimeSeries data.

set_features!(
    value::InfrastructureSystems.DeterministicMetadata,
    val
) -> Any

Set DeterministicMetadata features.