InfrastructureSystems API Reference

InfrastructureSystems.AverageRateCurveType

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

source
InfrastructureSystems.CompressionSettingsType
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,
)
source
InfrastructureSystems.CostCurveType
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.

source
InfrastructureSystems.DeterministicType
mutable struct Deterministic <: AbstractDeterministic
    name::String
    data::SortedDict
    resolution::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
  • scaling_factor_multiplier::Union{Nothing, Function}: Applicable when the time series data are scaling factors. Called on the associated component to convert the values.
  • internal::InfrastructureSystemsInternal
source
InfrastructureSystems.DeterministicMethod
Deterministic(
    name::AbstractString,
    input_data::AbstractDict{Dates.DateTime, <:TimeSeries.TimeArray};
    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.
  • normalization_factor::NormalizationFactor = 1.0: optional normalization factor to apply to each data entry
  • scaling_factor_multiplier::Union{Nothing, Function} = nothing: If the data are scaling factors then this function will be called on the component and applied to the data when get_time_series_array is called.
  • timestamp = :timestamp: If the values are DataFrames is passed then this must be the column name that contains timestamps.
source
InfrastructureSystems.DeterministicMethod
Deterministic(
    name::AbstractString,
    filename::AbstractString,
    component::InfrastructureSystems.InfrastructureSystemsComponent,
    resolution::Dates.Period;
    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.
source
InfrastructureSystems.DeterministicMethod
Deterministic(
    name::AbstractString,
    series_data::InfrastructureSystems.RawTimeSeries,
    resolution::Dates.Period;
    normalization_factor,
    scaling_factor_multiplier
) -> InfrastructureSystems.Deterministic

Construct Deterministic from RawTimeSeries.

source
InfrastructureSystems.DeterministicMethod
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)
source
InfrastructureSystems.DeterministicMethod
Deterministic(
    forecast::InfrastructureSystems.Deterministic,
    data
) -> InfrastructureSystems.Deterministic

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

source
InfrastructureSystems.DeterministicMetadataType
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:
source
InfrastructureSystems.DeterministicSingleTimeSeriesType
mutable struct DeterministicSingleTimeSeries <: AbstractDeterministic
    single_time_series::SingleTimeSeries
    initial_timestamp::Dates.DateTime
    interval::Dates.Period
    count::Int
    horizon::Int
end

A deterministic forecast that wraps a SingleTimeSeries

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

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

Arguments

  • single_time_series::SingleTimeSeries: wrapped SingleTimeSeries object
  • initial_timestamp::Dates.DateTime: time series availability time
  • interval::Dates.Period: time step between forecast windows
  • count::Int: number of forecast windows
  • horizon::Int: length of this time series
source
InfrastructureSystems.ForecastCacheMethod

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
source
InfrastructureSystems.FuelCurveType
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

  • 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, vom_cost)
FuelCurve(value_curve, fuel_cost)
FuelCurve(value_curve, fuel_cost, vom_cost)
FuelCurve(value_curve, power_units, fuel_cost)
FuelCurve(; value_curve, power_units, fuel_cost, vom_cost)

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

source
InfrastructureSystems.Hdf5TimeSeriesStorageMethod
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 SIENNATIMESERIES_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.
source
InfrastructureSystems.InMemoryTimeSeriesStorageMethod
InMemoryTimeSeriesStorage(
    hdf5_storage::InfrastructureSystems.Hdf5TimeSeriesStorage
) -> InfrastructureSystems.InMemoryTimeSeriesStorage

Constructs InMemoryTimeSeriesStorage from an instance of Hdf5TimeSeriesStorage.

source
InfrastructureSystems.IncrementalCurveType

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

source
InfrastructureSystems.InputOutputCurveType

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

source
InfrastructureSystems.LazyDictFromIteratorMethod

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
source
InfrastructureSystems.LinearCurveType
LinearCurve(proportional_term::Float64)
LinearCurve(proportional_term::Float64, constant_term::Float64)

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

Arguments

  • proportional_term::Float64: marginal rate
  • constant_term::Float64: optional, cost at zero production, defaults to 0.0
source
InfrastructureSystems.LinearFunctionDataType

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

Arguments

  • proportional_term::Float64: the proportional term in the represented function
  • constant_term::Float64: the constant term in the represented function
source
InfrastructureSystems.LogEventTrackerType
LogEventTracker() -> InfrastructureSystems.LogEventTracker
LogEventTracker(
    levels
) -> InfrastructureSystems.LogEventTracker

Tracks counts of all log events by level.

Examples

LogEventTracker()
LogEventTracker((Logging.Info, Logging.Warn, Logging.Error))
source
InfrastructureSystems.MultiLoggerType

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())
source
InfrastructureSystems.MultiLoggerMethod
MultiLogger(
    loggers::Array{T<:Base.CoreLogging.AbstractLogger}
) -> InfrastructureSystems.MultiLogger

Creates a MultiLogger with no event tracking.

Example

MultiLogger([TerminalLogger(stderr), SimpleLogger(stream)])
source
InfrastructureSystems.NotImplementedErrorType

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.

source
InfrastructureSystems.PiecewiseAverageCurveType
PiecewiseAverageCurve(initial_input::Union{Float64, Nothing}, x_coords::Vector{Float64}, slopes::Vector{Float64})

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

Arguments

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

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

Arguments

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

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

Arguments

  • points::Vector{@NamedTuple{x::Float64, y::Float64}}: the points that define the function
source
InfrastructureSystems.PiecewisePointCurveType
PiecewisePointCurve(points::Vector{Tuple{Float64, Float64}})

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

Arguments

  • points::Vector{Tuple{Float64, Float64}} or similar: vector of (production, cost) pairs
source
InfrastructureSystems.PiecewiseStepDataType

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

Arguments

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

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

  • c::Union{Nothing, Float64}: optional, the value to use for the integral from 0 to x_coords[1] of this function
source
InfrastructureSystems.ProbabilisticType
mutable struct Probabilistic <: Forecast
    name::String
    resolution::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
  • percentiles::Vector{Float64}: Percentiles for the probabilistic forecast
  • data::SortedDict: timestamp - scalingfactor
  • scaling_factor_multiplier::Union{Nothing, Function}: Applicable when the time series data are scaling factors. Called on the associated component to convert the values.
  • internal::InfrastructureSystemsInternal
source
InfrastructureSystems.ProbabilisticMethod
Probabilistic(
    name::AbstractString,
    input_data::AbstractDict,
    percentiles::Vector,
    resolution::Dates.Period;
    normalization_factor,
    scaling_factor_multiplier
) -> InfrastructureSystems.Probabilistic

Construct Probabilistic from a SortedDict of Arrays.

Arguments

  • name::AbstractString: user-defined name
  • input_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`
  • normalization_factor::NormalizationFactor = 1.0: optional normalization factor to apply to each data entry
  • scaling_factor_multiplier::Union{Nothing, Function} = nothing: If the data are scaling factors then this function will be called on the component and applied to the data when get_time_series_array is called.
source
InfrastructureSystems.ProbabilisticMethod
Probabilistic(
    name::AbstractString,
    input_data::AbstractDict{Dates.DateTime, <:TimeSeries.TimeArray},
    percentiles::Vector{Float64};
    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
  • normalization_factor::NormalizationFactor = 1.0: optional normalization factor to apply to each data entry
  • scaling_factor_multiplier::Union{Nothing, Function} = nothing: If the data are scaling factors then this function will be called on the component and applied to the data when get_time_series_array is called.
  • timestamp = :timestamp: If the values are DataFrames is passed then this must be the column name that contains timestamps.
source
InfrastructureSystems.ProbabilisticMethod
Probabilistic(
    name::AbstractString,
    series_data::InfrastructureSystems.RawTimeSeries,
    percentiles::Vector,
    resolution::Dates.Period;
    normalization_factor,
    scaling_factor_multiplier
) -> InfrastructureSystems.Probabilistic

Construct Deterministic from RawTimeSeries.

source
InfrastructureSystems.ProbabilisticMethod
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.

source
InfrastructureSystems.ProbabilisticMetadataType
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:
source
InfrastructureSystems.QuadraticCurveType
QuadraticCurve(quadratic_term::Float64, proportional_term::Float64, constant_term::Float64)

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

Arguments

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

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

Arguments

  • quadratic_term::Float64: the quadratic term in the represented function
  • proportional_term::Float64: the proportional term in the represented function
  • constant_term::Float64: the constant term in the represented function
source
InfrastructureSystems.RecorderMethod
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.
source
InfrastructureSystems.ScenariosType
mutable struct Scenarios <: Forecast
    name::String
    resolution::Dates.Period
    scenario_count::Int64
    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
  • scenario_count::Int64: Number of scenarios
  • data::SortedDict: timestamp - scalingfactor
  • scaling_factor_multiplier::Union{Nothing, Function}: Applicable when the time series data are scaling factors. Called on the associated component to convert the values.
  • internal::InfrastructureSystemsInternal
source
InfrastructureSystems.ScenariosMethod
Scenarios(
    name::AbstractString,
    input_data::AbstractDict,
    resolution::Dates.Period;
    normalization_factor,
    scaling_factor_multiplier
) -> InfrastructureSystems.Scenarios

Construct Scenarios from a SortedDict of Arrays.

Arguments

  • name::AbstractString: user-defined name
  • input_data::AbstractDict{Dates.DateTime, Matrix{Float64}}: time series data.
  • resolution::Dates.Period: The resolution of the forecast in Dates.Period`
  • normalization_factor::NormalizationFactor = 1.0: optional normalization factor to apply to each data entry
  • scaling_factor_multiplier::Union{Nothing, Function} = nothing: If the data are scaling factors then this function will be called on the component and applied to the data when get_time_series_array is called.
source
InfrastructureSystems.ScenariosMethod
Scenarios(
    name::AbstractString,
    input_data::AbstractDict{Dates.DateTime, <:TimeSeries.TimeArray};
    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.
  • normalization_factor::NormalizationFactor = 1.0: optional normalization factor to apply to each data entry
  • scaling_factor_multiplier::Union{Nothing, Function} = nothing: If the data are scaling factors then this function will be called on the component and applied to the data when get_time_series_array is called.
  • timestamp = :timestamp: If the values are DataFrames is passed then this must be the column name that contains timestamps.
source
InfrastructureSystems.ScenariosMethod
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.

source
InfrastructureSystems.ScenariosMetadataType
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:
source
InfrastructureSystems.SingleTimeSeriesType
mutable struct SingleTimeSeries <: StaticTimeSeries
    name::String
    data::TimeSeries.TimeArray
    scaling_factor_multiplier::Union{Nothing, Function}
    internal::InfrastructureSystemsInternal
end

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

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

Arguments

  • name::String: user-defined name
  • data::TimeSeries.TimeArray: timestamp - scalingfactor
  • resolution::Dates.Period: Time duration between steps in the time series. The resolution must be the same throughout the time series
  • scaling_factor_multiplier::Union{Nothing, Function}: Applicable when the time series data are scaling factors. Called on the associated component to convert the values.
  • internal::InfrastructureSystemsInternal
source
InfrastructureSystems.SingleTimeSeriesMethod
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.
source
InfrastructureSystems.SingleTimeSeriesMethod
SingleTimeSeries(
    name::AbstractString,
    data::Union{DataFrames.DataFrame, TimeSeries.TimeArray};
    normalization_factor,
    scaling_factor_multiplier,
    timestamp
) -> 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 = :timestamp: If a DataFrame is passed then this must be the column name that contains timestamps.
source
InfrastructureSystems.SingleTimeSeriesMethod
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.

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

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

source
InfrastructureSystems.SingleTimeSeriesMethod
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.

source
InfrastructureSystems.SingleTimeSeriesMetadataType
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:
source
InfrastructureSystems.StaticTimeSeriesCacheMethod

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 scalingfactormultiplier in the time series instance
source
InfrastructureSystems.StructDefinitionMethod
StructDefinition(
;
    struct_name,
    fields,
    supertype,
    docstring,
    is_component
)

Construct a StructDefinition for code auto-generation purposes.

Arguments

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

Construct a StructField for code auto-generation purposes.

Arguments

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

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

  • supportstimeseries(::SupplementalAttribute)

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

source
InfrastructureSystems.SystemDataType
mutable struct SystemData <: InfrastructureSystemsType
    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

source
InfrastructureSystems.SystemDataMethod
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 SIENNATIMESERIES_DIRECTORY or tempdir() if that isn't set.
  • compression = CompressionSettings(): Controls compression of time series data.
source
InfrastructureSystems.TimeSeriesAssociationType

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

Examples

association1 = TimeSeriesAssociation(component, time_series)
association2 = TimeSeriesAssociation(component, time_series, scenario = "high")
source
InfrastructureSystems.TimeSeriesDataType

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

source
InfrastructureSystems.TimeSeriesStorageType

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
source
Base.closeMethod
close(logger::InfrastructureSystems.MultiLogger)

Ensures that any file streams are flushed and closed.

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

Losslessly convert LinearFunctionData to QuadraticFunctionData

source
Base.flushMethod
flush(logger::InfrastructureSystems.MultiLogger)

Flush any file streams.

source
Base.getMethod
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.

source
Base.zeroMethod
zero(
    _::Type{InfrastructureSystems.FunctionData}
) -> InfrastructureSystems.LinearFunctionData

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

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

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

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

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

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

Get a CostCurve representing zero variable cost

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

Get a FuelCurve representing zero fuel usage and zero fuel cost

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

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

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

Get an InputOutputCurve representing f(x) = 0

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

Get a ValueCurve representing zero variable cost

source
InfrastructureSystems._check_transform_single_time_seriesMethod
_check_transform_single_time_series(
    data::InfrastructureSystems.SystemData,
    _::Type{InfrastructureSystems.DeterministicSingleTimeSeries},
    horizon::Dates.Period,
    interval::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.

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

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

source
InfrastructureSystems.add_association!Method
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.

source
InfrastructureSystems.add_component!Method
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.

source
InfrastructureSystems.add_metadata!Method
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.

source
InfrastructureSystems.add_time_series!Method
add_time_series!(
    data::InfrastructureSystems.SystemData,
    components,
    time_series::InfrastructureSystems.TimeSeriesData;
    features...
) -> InfrastructureSystems.TimeSeriesKey

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.

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

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.

source
InfrastructureSystems.add_time_series_from_file_metadata!Method
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.
source
InfrastructureSystems.add_time_series_from_file_metadata!Method
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.
source
InfrastructureSystems.assign_new_uuid_internal!Method
assign_new_uuid_internal!(
    component::InfrastructureSystems.InfrastructureSystemsComponent
)

Return an instance of ForecastParameters for the given inputs.

Throws ConflictingInputsError if horizon and interval are incompatible with the metadata.

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

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

source
InfrastructureSystems.check_consistencyMethod
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.

source
InfrastructureSystems.compare_over_fieldsMethod
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.

source
InfrastructureSystems.compare_valuesMethod
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.
source
InfrastructureSystems.configure_loggingMethod
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
source
InfrastructureSystems.copy_h5_fileMethod
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.

source
InfrastructureSystems.copy_time_series!Method
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 timeseries with a name not present in namemapping, that timeseries will not copied. If namemapping 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 timeseries with a multiplier not present in scalingfactormultipliermapping, that timeseries will not copied. If scalingfactormultipliermapping is nothing then all time_series will be copied with src's multipliers.
source
InfrastructureSystems.deserializeMethod
deserialize(
    _::Type{T<:InfrastructureSystems.InfrastructureSystemsType},
    data::Dict
) -> InfrastructureSystems.ComponentUUIDs

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

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

Wrapper around SQLite.DBInterface.execute to provide log messages.

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

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

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

Return a time_series truncated starting with timestamp.

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

Constructs Hdf5TimeSeriesStorage from an existing file.

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

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

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

Deserializes a InfrastructureSystemsType from a JSON filename.

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

Deserializes a InfrastructureSystemsType from String or IO.

source
InfrastructureSystems.generate_struct_fileMethod
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
source
InfrastructureSystems.generate_struct_filesMethod
generate_struct_files(
    definitions;
    filename,
    output_directory
)

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

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

Arguments

  • definitions: Defines the structs and all fields.
  • filename::AbstractString: Add the struct definition to this JSON file. Defaults to src/descriptors/power_system_structs.json
  • output_directory::AbstractString: Generate the files in this directory. Defaults to src/generated
source
InfrastructureSystems.get_all_concrete_subtypesMethod
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.

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

Return a Vector of subsystem names that contain the component.

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

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

source
InfrastructureSystems.get_componentMethod
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

source
InfrastructureSystems.get_componentsMethod
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

source
InfrastructureSystems.get_components_by_nameMethod
get_components_by_name(
    _::Type{T<:InfrastructureSystems.InfrastructureSystemsComponent},
    components::InfrastructureSystems.Components,
    name::AbstractString
) -> Vector{<: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.

source
InfrastructureSystems.get_data_typeMethod
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.

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

Return a user-modifiable dictionary to store extra information.

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

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

source
InfrastructureSystems.get_group_levelMethod
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.

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

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

source
InfrastructureSystems.get_initial_inputMethod
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)

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

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

source
InfrastructureSystems.get_log_eventsMethod
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.

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

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

source
InfrastructureSystems.get_next_time_series_array!Method
get_next_time_series_array!(
    cache::InfrastructureSystems.TimeSeriesCache
) -> Any

Return the next TimeSeries.TimeArray.

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

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

Arguments

  • cache::StaticTimeSeriesCache: cached instance

Examples

cache = ForecastCache(Deterministic, component, "max_active_power")
window1 = get_next_time_series_array!(cache)
window2 = get_next_time_series_array!(cache)
source
InfrastructureSystems.get_num_stepsMethod
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.

source
InfrastructureSystems.get_num_stepsMethod
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.

source
InfrastructureSystems.get_num_stepsMethod
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.

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

Get the points that define the piecewise data

source
InfrastructureSystems.get_slopesMethod
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.

source
InfrastructureSystems.get_subsystem_componentsMethod
get_subsystem_components(
    data::InfrastructureSystems.SystemData,
    subsystem_name::AbstractString
) -> Base.Generator{Set{Base.UUID}, InfrastructureSystems.var"#419#420"{InfrastructureSystems.SystemData}}

Return a Generator of all components in the subsystem.

Throws ArgumentError if the subsystem name is not stored.

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

Return an iterator of all subsystem names in the system.

source
InfrastructureSystems.get_supplemental_attributesMethod
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.
source
InfrastructureSystems.get_supplemental_attributesMethod
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.
source
InfrastructureSystems.get_time_seriesFunction
get_time_series(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    key::InfrastructureSystems.TimeSeriesKey
) -> Any
get_time_series(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    key::InfrastructureSystems.TimeSeriesKey,
    start_time::Union{Nothing, Dates.DateTime}
) -> Any
get_time_series(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    key::InfrastructureSystems.TimeSeriesKey,
    start_time::Union{Nothing, Dates.DateTime},
    len::Union{Nothing, Int64}
) -> Any
get_time_series(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    key::InfrastructureSystems.TimeSeriesKey,
    start_time::Union{Nothing, Dates.DateTime},
    len::Union{Nothing, Int64},
    count::Union{Nothing, Int64}
) -> Any

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

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

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

Does not apply a scaling factor multiplier.

Arguments

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

See also: get_time_series by name

source
InfrastructureSystems.get_time_seriesMethod
get_time_series(
    ::Type{T<:InfrastructureSystems.TimeSeriesData},
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    name::AbstractString;
    start_time,
    len,
    count,
    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
  • start_time::Union{Nothing, Dates.DateTime} = nothing: If nothing, use the initial_timestamp of the time series. If T is a subtype of Forecast then start_time must be the first timestamp of a window.
  • len::Union{Nothing, Int} = nothing: Length in the time dimension. If nothing, use the entire length.
  • count::Union{Nothing, Int} = nothing: Only applicable to subtypes of Forecast. Number of forecast windows starting at start_time to return. Defaults to all available.
  • features...: User-defined tags that differentiate multiple time series arrays for the same component attribute, such as different arrays for different scenarios or years

See also: get_time_series_array, get_time_series_values, get_time_series by key

source
InfrastructureSystems.get_time_series_arrayFunction
get_time_series_array(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    time_series::InfrastructureSystems.StaticTimeSeries;
    ...
) -> Any
get_time_series_array(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    time_series::InfrastructureSystems.StaticTimeSeries,
    start_time::Union{Nothing, Dates.DateTime};
    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

source
InfrastructureSystems.get_time_series_array!Method
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
source
InfrastructureSystems.get_time_series_arrayMethod
get_time_series_array(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    forecast::InfrastructureSystems.Forecast,
    start_time::Dates.DateTime;
    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

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

source
InfrastructureSystems.get_time_series_keysMethod
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 gettimeseries.

source
InfrastructureSystems.get_time_series_managerMethod
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.

source
InfrastructureSystems.get_time_series_multipleFunction
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
) -> 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 = nothing: Only return time_series with this type.
  • name = nothing: Only return time_series matching this value.

See also: get_time_series_multiple from a System

source
InfrastructureSystems.get_time_series_multipleFunction
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

source
InfrastructureSystems.get_time_series_resolutionsMethod
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).

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

Return a vector of timestamps from a cached StaticTimeSeries instance.

Arguments

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

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

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

Return a vector of timestamps from a cached Forecast instance.

Arguments

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

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

source
InfrastructureSystems.get_time_series_timestampsMethod
get_time_series_timestamps(
    ::Type{T<:InfrastructureSystems.TimeSeriesData},
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    name::AbstractString;
    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
  • start_time::Union{Nothing, Dates.DateTime} = nothing: If nothing, use the initial_timestamp of the time series. If T is a subtype of Forecast then start_time must be the first timestamp of a window.
  • len::Union{Nothing, Int} = nothing: Length of time-series to retrieve (i.e. number of timestamps). If nothing, use the entire length.
  • features...: User-defined tags that differentiate multiple time series arrays for the same component attribute, such as different arrays for different scenarios or years

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

source
InfrastructureSystems.get_time_series_valuesFunction
get_time_series_values(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    time_series::InfrastructureSystems.StaticTimeSeries;
    ...
) -> Any
get_time_series_values(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    time_series::InfrastructureSystems.StaticTimeSeries,
    start_time::Union{Nothing, Dates.DateTime};
    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

source
InfrastructureSystems.get_time_series_valuesMethod
get_time_series_values(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    forecast::InfrastructureSystems.Forecast,
    start_time::Dates.DateTime;
    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

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

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

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

source
InfrastructureSystems.get_unique_timestampsMethod
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.

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

Return the column names with values (components).

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

Get the underlying ValueCurve representation of this ProductionVariableCostCurve

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

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

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

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

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

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

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

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

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

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

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

Check to see if a component with name exists.

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

Return true if the component is in the subsystem.

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

Check to see if a component exists.

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

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

source
InfrastructureSystems.has_metadataMethod
has_metadata(
    store::InfrastructureSystems.TimeSeriesMetadataStore,
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute},
    metadata::InfrastructureSystems.TimeSeriesMetadata
) -> Bool

Return True if there is time series metadata matching the inputs.

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

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

source
InfrastructureSystems.has_time_seriesMethod
has_time_series(
    store::InfrastructureSystems.TimeSeriesMetadataStore,
    time_series_uuid::Base.UUID
) -> Any

Return True if there is time series matching the UUID.

source
InfrastructureSystems.has_time_seriesMethod
has_time_series(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute}
) -> Any

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

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

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

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

Return a time_series with only the first num values.

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

Increments the count of a log event.

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

Return true if the component is assigned to the subsystem.

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

Return true if the component is assigned to any subsystems.

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

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

source
InfrastructureSystems.iterate_componentsMethod
iterate_components(
    components::InfrastructureSystems.Components
) -> Base.Iterators.Flatten{Base.Generator{Base.ValueIterator{Dict{DataType, Dict{String, <:InfrastructureSystems.InfrastructureSystemsComponent}}}, InfrastructureSystems.var"#110#111"}}

Iterates over all components.

Examples

for component in iterate_components(obj)
    @show component
end

See also: get_components

source
InfrastructureSystems.iterate_containerMethod
iterate_container(
    container::InfrastructureSystems.InfrastructureSystemsContainer
) -> Base.Iterators.Flatten{I} where I<:(Base.Generator{_A, InfrastructureSystems.var"#110#111"} where _A)

Iterates over all data in the container.

source
InfrastructureSystems.iterate_supplemental_attributesMethod
iterate_supplemental_attributes(
    mgr::InfrastructureSystems.SupplementalAttributeManager
) -> Base.Iterators.Flatten{Base.Generator{Base.ValueIterator{Dict{DataType, Dict{Base.UUID, <:InfrastructureSystems.SupplementalAttribute}}}, InfrastructureSystems.var"#110#111"}}

Iterates over all supplemental_attributes.

Examples

for supplemental_attribute in iterate_supplemental_attributes(obj)
    @show supplemental_attribute
end
source
InfrastructureSystems.iterate_windowsMethod
iterate_windows(
    forecast::InfrastructureSystems.DeterministicSingleTimeSeries
) -> Union{Tuple{Any}, Base.Generator{I, InfrastructureSystems.var"#134#135"{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
source
InfrastructureSystems.iterate_windowsMethod
iterate_windows(
    forecast::InfrastructureSystems.Deterministic
) -> Base.Generator{I, InfrastructureSystems.var"#105#106"{InfrastructureSystems.Deterministic}} where I<:(DataStructures.SDMKeyIteration{T} where T<:DataStructures.SortedDict)

Iterate over the windows in a forecast

Examples

for window in iterate_windows(forecast)
    @show values(maximum(window))
end
source
InfrastructureSystems.iterate_windowsMethod
iterate_windows(
    forecast::InfrastructureSystems.Probabilistic
) -> Base.Generator{I, InfrastructureSystems.var"#105#106"{InfrastructureSystems.Probabilistic}} where I<:(DataStructures.SDMKeyIteration{T} where T<:DataStructures.SortedDict)

Iterate over the windows in a forecast

Examples

for window in iterate_windows(forecast)
    @show values(maximum(window))
end
source
InfrastructureSystems.iterate_windowsMethod
iterate_windows(
    forecast::InfrastructureSystems.Scenarios
) -> Base.Generator{I, InfrastructureSystems.var"#105#106"{InfrastructureSystems.Scenarios}} where I<:(DataStructures.SDMKeyIteration{T} where T<:DataStructures.SortedDict)

Iterate over the windows in a forecast

Examples

for window in iterate_windows(forecast)
    @show values(maximum(window))
end
source
InfrastructureSystems.list_associated_component_uuidsMethod
list_associated_component_uuids(
    associations::InfrastructureSystems.SupplementalAttributeAssociations,
    attribute::InfrastructureSystems.SupplementalAttribute
) -> Any

Return the component UUIDs associated with the attribute.

source
InfrastructureSystems.list_associated_supplemental_attribute_uuidsMethod
list_associated_supplemental_attribute_uuids(
    associations::InfrastructureSystems.SupplementalAttributeAssociations,
    component::InfrastructureSystems.InfrastructureSystemsComponent;
    attribute_type
) -> Any

Return the supplemental attribute UUIDs associated with the component and attribute type.

source
InfrastructureSystems.list_existing_metadataMethod
list_existing_metadata(
    store::InfrastructureSystems.TimeSeriesMetadataStore,
    owners::Vector{Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute}},
    metadata::Vector{InfrastructureSystems.TimeSeriesMetadata}
) -> Vector

Return the metadata specified in the passed metadata vector that are already stored.

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

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

source
InfrastructureSystems.list_recorder_eventsMethod
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.
source
InfrastructureSystems.make_time_series!Method
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
source
InfrastructureSystems.mask_component!Method
mask_component!(
    data::InfrastructureSystems.SystemData,
    component::InfrastructureSystems.InfrastructureSystemsComponent;
    remove_time_series
)

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

source
InfrastructureSystems.open_file_loggerFunction
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
source
InfrastructureSystems.prepare_for_removal!Method
prepare_for_removal!(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute}
)

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

source
InfrastructureSystems.prepare_for_serialization_to_file!Method
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.

source
InfrastructureSystems.read_time_seriesMethod
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.

source
InfrastructureSystems.read_time_seriesMethod
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.

source
InfrastructureSystems.read_time_seriesMethod
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.

source
InfrastructureSystems.read_time_seriesMethod
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.

source
InfrastructureSystems.read_time_seriesMethod
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.

source
InfrastructureSystems.register_recorder!Method
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.
source
InfrastructureSystems.remove_association!Method
remove_association!(
    associations::InfrastructureSystems.SupplementalAttributeAssociations,
    component::InfrastructureSystems.InfrastructureSystemsComponent,
    attribute::InfrastructureSystems.SupplementalAttribute
)

Remove the association between the attribute and component.

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

Remove all associations of the given type.

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

Remove a component by its value.

Throws ArgumentError if the component is not stored.

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

Remove a component by its name.

Throws ArgumentError if the component is not stored.

source
InfrastructureSystems.remove_component_from_subsystem!Method
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.

source
InfrastructureSystems.remove_components!Method
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.

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

Remove the matching metadata from the store.

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

Remove a subsystem from the system.

Throws ArgumentError if the subsystem name is not stored.

source
InfrastructureSystems.remove_supplemental_attributes!Method
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.

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

Remove the time series data for a component.

source
InfrastructureSystems.remove_time_series!Method
remove_time_series!(
    data::InfrastructureSystems.SystemData,
    ::Type{T<:InfrastructureSystems.TimeSeriesData},
    component::InfrastructureSystems.InfrastructureSystemsComponent,
    name::String;
    features...
)

Remove the time series data for a component.

source
InfrastructureSystems.remove_time_series!Method
remove_time_series!(
    data::InfrastructureSystems.SystemData,
    _::Type{T<:InfrastructureSystems.TimeSeriesData}
)

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.
source
InfrastructureSystems.serializeMethod
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.

source
InfrastructureSystems.set_component!Method
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.

source
InfrastructureSystems.set_group_level!Method
set_group_level!(
    logger::InfrastructureSystems.MultiLogger,
    group::Symbol,
    level::Base.CoreLogging.LogLevel
)

Set the minimum log level for a group.

The group field of a log message defaults to its file's base name (no extension) as a symbol. It can be customized by setting _group = :a_group_name.

The minimum log level stored for a console or file logger supercede this setting.

source
InfrastructureSystems.show_recorder_eventsMethod
show_recorder_events(
    ::Type{T<:InfrastructureSystems.AbstractRecorderEvent},
    filename::AbstractString;
    ...
)
show_recorder_events(
    ::Type{T<:InfrastructureSystems.AbstractRecorderEvent},
    filename::AbstractString,
    filter_func::Union{Nothing, Function};
    kwargs...
)

Show the events of type T in filename in a table. Refer to PrettyTables.jl documentation for accepted kwargs.

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.
  • exclude_columns = Set{String}(): Column names to exclude from the table
  • kwargs: Passed to PrettyTables

Examples

show_recorder_events(TestEvent, test_recorder.log)
show_recorder_events(TestEvent, test_recorder.log, x -> x.val2 > 2)
source
InfrastructureSystems.show_time_seriesMethod
show_time_series(
    owner::Union{InfrastructureSystems.InfrastructureSystemsComponent, InfrastructureSystems.SupplementalAttribute}
)

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

source
InfrastructureSystems.sqlFunction
sql(
    associations::InfrastructureSystems.SupplementalAttributeAssociations,
    query::String
) -> DataFrames.DataFrame
sql(
    associations::InfrastructureSystems.SupplementalAttributeAssociations,
    query::String,
    params
) -> DataFrames.DataFrame

Run a query and return the results in a DataFrame.

source
InfrastructureSystems.sqlFunction
sql(
    store::InfrastructureSystems.TimeSeriesMetadataStore,
    query::String
) -> DataFrames.DataFrame
sql(
    store::InfrastructureSystems.TimeSeriesMetadataStore,
    query::String,
    params
) -> DataFrames.DataFrame

Run a query and return the results in a DataFrame.

source
InfrastructureSystems.strip_module_nameMethod
strip_module_name(name::String) -> String

Strips the module name off of a type. This can be useful to print types as strings and receive consistent results regardless of whether the user used import or using to load a package.

Unlike Base.nameof, this function preserves any parametric types.

Examples

julia> strip_module_name(PowerSystems.RegulationDevice{ThermalStandard})
"RegulationDevice{ThermalStandard}"
julia> string(nameof(PowerSystems.RegulationDevice{ThermalStandard}))
"RegulationDevice"
source
InfrastructureSystems.tailMethod
tail(
    time_series::InfrastructureSystems.SingleTimeSeries
) -> Any

Return a time_series with only the ending num values.

source
InfrastructureSystems.toMethod
to(
    time_series::InfrastructureSystems.SingleTimeSeries,
    timestamp
) -> InfrastructureSystems.SingleTimeSeries

Return a time_series truncated after timestamp.

source
InfrastructureSystems.to_jsonMethod
to_json(
    obj::InfrastructureSystems.InfrastructureSystemsType;
    pretty,
    indent
) -> Any

Serializes a InfrastructureSystemsType to a JSON string.

source
InfrastructureSystems.to_jsonMethod
to_json(
    obj::InfrastructureSystems.InfrastructureSystemsType;
    pretty,
    indent
) -> Any

Serializes a InfrastructureSystemsType to a JSON file.

source
InfrastructureSystems.transform_single_time_series!Method
transform_single_time_series!(
    data::InfrastructureSystems.SystemData,
    _::Type{<:InfrastructureSystems.DeterministicSingleTimeSeries},
    horizon::Dates.Period,
    interval::Dates.Period
)

Transform all instances of SingleTimeSeries to DeterministicSingleTimeSeries. If all SingleTimeSeries instances cannot be transformed then none will be.

Any existing DeterministicSingleTimeSeries forecasts will be deleted even if the inputs are invalid.

source
InfrastructureSystems.whenMethod
when(
    time_series::InfrastructureSystems.SingleTimeSeries,
    period::Function,
    t::Integer
) -> Any

Refer to TimeSeries.when(). Underlying data is copied.

source
InfrastructureSystems.@assert_opMacro

Throw an AssertionError if conditions like op(exp1, exp2) are false, where op is a conditional infix operator.

Examples

julia> a = 3; b = 4;
julia> @assert_op a == b
ERROR: AssertionError: 3 == 4

julia> @assert_op a + 3 > b + 4
ERROR: AssertionError: 6 > 8
source
InfrastructureSystems.@recordMacro

Record an event if the recorder with name is enabled.

Arguments

  • name::Symbol: name of recorder
  • event::AbstractRecorderEvent: event to record

Examples

@record simulation TestEvent("start", 1, 2.0)
source
InfrastructureSystems.@scoped_enumMacro

Macro to wrap Enum in a module to keep the top level scope clean.

Examples

julia> @scoped_enum Fruit APPLE = 1 ORANGE = 2

julia> value = Fruit.APPLE
Fruit.APPLE = 1

julia> value = Fruit(1)
Fruit.APPLE = 1

julia> @scoped_enum(Fruit,
    APPLE = 1,  # comment
    ORANGE = 2,  # comment
)
source