Internals

AbstractStorageParameters as supertype for individual parameters for Storage nodes.

Storage parameters are used to provide the user the flexibility to include or not include capacities and variable and fixed OPEX parameters for charging, the storage level, and discharging.

Declaration of the general type for formulation of links.

Node as supertype for all technologies.

StorageBehavior as supertype for individual storage behaviours.

Storage behaviour is used to identify how a storage node should behave within the individual TimeStructures of a strategic period.

check_case_data(case)

Checks the case dictionary is in the correct format.

Checks

• The dictionary requires the keys :T, :nodes, :links, and :products.
• The individual keys are of the correct type, that is
  • :T::TimeStructure,
  • :nodes::Vector{<:Node},
  • :links::Vector{<:Link}, and
  • :products::Vector{<:Resource}.

check_data(case, modeltype, check_timeprofiles::Bool)

Check if the case data is consistent. Use the @assert_or_log macro when testing. Currently only checking node data.

check_fixed_opex(n, 𝒯ᴵⁿᵛ, check_timeprofiles::Bool)

Checks that the fixed opex value follows the given TimeStructure. This check requires that a function opex_fixed(n) is defined for the input n which returns a TimeProfile.

Checks

• The opex_fixed time profile cannot have a finer granulation than StrategicProfile.

Conditional checks (if check_timeprofiles=true)

• The profiles in opex_fixed have to have the same length as the number of strategic periods.

check_model(case, modeltype::EnergyModel, check_timeprofiles::Bool)

Checks the modeltype .

Checks

• All ResourceEmits require a corresponding value in the field emission_limit.
• The emission_limit time profiles cannot have a finer granulation than StrategicProfile.
• The emission_price time profiles cannot have a finer granulation than StrategicProfile.

Conditional checks (if check_timeprofiles=true)

• The profiles in emission_limit have to have the same length as the number of strategic periods.
• The profiles in emission_price have to have the same length as the number of strategic

periods.

check_node(n::Availability, 𝒯, modeltype::EnergyModel)

This method checks that an Availability node is valid. By default, that does not include any checks.

check_node(n::Node, 𝒯, modeltype::EnergyModel)

Check that the fields of a Node corresponds to required structure.

check_node(n::NetworkNode, 𝒯, modeltype::EnergyModel)

This method checks that a NetworkNode node is valid.

These checks are always performed, if the user is not creating a new method. Hence, it is important that a new NetworkNode type includes at least the same fields as in the RefNetworkNode node or that a new NetworkNode type receives a new method for check_node.

Checks

• The field cap is required to be non-negative.
• The values of the dictionary input are required to be non-negative.
• The values of the dictionary output are required to be non-negative.
• The value of the field fixed_opex is required to be non-negative and accessible through a StrategicPeriod as outlined in the function check_fixed_opex(n, 𝒯ᴵⁿᵛ, check_timeprofiles).

check_node(n::Sink, 𝒯, modeltype::EnergyModel)

This method checks that a Sink node is valid.

These checks are always performed, if the user is not creating a new method. Hence, it is important that a new Sink type includes at least the same fields as in the RefSink node or that a new Source type receives a new method for check_node.

Checks

• The field cap is required to be non-negative.
• The values of the dictionary input are required to be non-negative.
• The dictionary penalty is required to have the keys :deficit and :surplus.
• The sum of the values :deficit and :surplus in the dictionary penalty has to be non-negative to avoid an infeasible model.

check_node(n::Source, 𝒯, modeltype::EnergyModel)

This method checks that a Source node is valid.

These checks are always performed, if the user is not creating a new method. Hence, it is important that a new Source type includes at least the same fields as in the RefSource node or that a new Source type receives a new method for check_node.

Checks

• The field cap is required to be non-negative.
• The values of the dictionary output are required to be non-negative.
• The value of the field fixed_opex is required to be non-negative and accessible through a StrategicPeriod as outlined in the function check_fixed_opex(n, 𝒯ᴵⁿᵛ, check_timeprofiles).

check_node(n::Storage, 𝒯, modeltype::EnergyModel)

This method checks that a Storage node is valid.

These checks are always performed, if the user is not creating a new method. Hence, it is important that a new Storage type includes at least the same fields as in the RefStorage node or that a new Storage type receives a new method for check_node.

Checks

• The TimeProfile of the field capacity in the type in the field charge is required to be non-negative if the chosen composite type has the field capacity.
• The TimeProfile of the field capacity in the type in the field level is required to be non-negative`.
• The TimeProfile of the field capacity in the type in the field discharge is required to be non-negative if the chosen composite type has the field capacity.
• The TimeProfile of the field fixed_opex is required to be non-negative and accessible through a StrategicPeriod as outlined in the function check_fixed_opex(n, 𝒯ᴵⁿᵛ, check_timeprofiles) for the chosen composite type .
• The values of the dictionary input are required to be non-negative.
• The values of the dictionary output are required to be non-negative.

check_node_data(n::Node, data::Data, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)

Check that the included Data types of a Node corresponds to required structure. This function will always result in a multiple error message, if several instances of the same supertype is loaded.

check_node_data(n::Node, data::EmissionsData, 𝒯, modeltype::EnergyModel, check_timeprofiles::Bool)

Check that the included Data types of a Node corresponds to required structure. This function will always result in a multiple error message, if several instances of the same supertype is loaded.

Checks

• Each node can only have a single EmissionsData.
• Time profiles for process emissions, if present.
• The value of the field co2_capture is required to be in the range $[0, 1]$, if CaptureData is used.

check_profile(fieldname, value::TimeProfile, ts::TimeStructure, sp)

Check that an individual TimeProfile corresponds to the time structure ts in strategic period sp. The function flow is designed to provide errors in all situations in which the the TimeProfile does not correspond to the chosen TimeStructure through the application of the @assert_or_log macro.

Examples for inconsistent combinations:

ts = SimpleTimes(3, 1)

# A too long OperationalProfile resulting in omitting the last 2 values
value = OperationalProfile([1, 2, 3, 4, 5])

# A too short OperationalProfile resulting in repetition of the last value once
value = OperationalProfile([1, 2])

If you use a more detailed TimeProfile than the TimeStructure, it will you provide you with a warning, e.g., using RepresentativeProfile without RepresentativePeriods.

It currently does not include support for identifying OperationalProfiles.

check_profile(fieldname, value::TimeProfile, 𝒯)

Check that an individual TimeProfile corresponds to the time structure 𝒯. It currently does not include support for identifying OperationalScenarios.

check_representative_profile(time_profile::TimeProfile, message::String)

Function for checking that an individual TimeProfile does not include the wrong type for representative periods indexing

Input

• time_profile - The time profile that should be checked.
• message - A message that should be printed after the type of profile.

Checks

• TimeProfiles access in RepresentativePeriods cannot include OperationalProfile or ScenarioProfile as this is not allowed through indexing on the TimeProfile.

check_scenario_profile(time_profile::TimeProfile, message::String)

Function for checking that an individual TimeProfile does not include the wrong type for scenario indexing

Checks

• TimeProfiles access in RepresentativePeriods cannot include OperationalProfile or ScenarioProfile as this is not allowed through indexing on the TimeProfile.

check_strategic_profile(time_profile::TimeProfile, message::String)

Function for checking that an individual TimeProfile does not include the wrong type for strategic indexing

Checks

• TimeProfiles access in StrategicPeriods cannot include OperationalProfile, ScenarioProfile, or RepresentativeProfile as this is not allowed through indexing on the TimeProfile.

check_time_structure(n::Node, 𝒯)

Check that all fields of a Node that are of type TimeProfile correspond to the time structure 𝒯.

collect_types(types_list)

Return a Dict of all the give types_list and their supertypes. The keys in the dictionary are the types, and their corresponding value is the number in the type hierarchy.

E.g., Node is at the top and will thus have the value 1. Types just below Node will have value 2, and so on.

compile_logs(case, log_by_element)

Simple method for showing all log messages.

constraints_emissions(m, 𝒩, 𝒯, 𝒫, modeltype::EnergyModel)

Create constraints for the emissions accounting for both operational and strategic periods.

constraints_level_bounds(
    m,
    n::Storage,
    t::TS.TimePeriod,
    cyclic_pers::CyclicPeriods{<:TS.AbstractRepresentativePeriod},
    modeltype::EnergyModel,
)

When representative periods are used and the previous operational period is nothing, then bounds are incorporated to avoid that the initial level storage level is violating the maximum and minimum level.

constraints_level_bounds(
    m,
    n::Storage,
    t::TS.TimePeriod,
    prev_pers::TS.TimePeriod,
    modeltype::EnergyModel,
)

Provides bounds on the initial storage level in an operational period to account for the level being modelled at the end of the operational periods.

The default approach is to not provide bounds.

constraints_level_iterate(
    m,
    n::Storage,
    prev_pers::PreviousPeriods,
    per,
    ts::OperationalScenarios,
    modeltype::EnergyModel,
)

In the case of OperationalScenarios, this is achieved through calling the function constraints_level_scp. In the default case, no constraints are added.

constraints_level_iterate(
    m,
    n::Storage,
    prev_pers::PreviousPeriods,
    cyclic_pers::CyclicPeriods,
    per,
    ts::RepresentativePeriods,
    modeltype::EnergyModel,
)

Iterate through the individual time structures of a Storage node. This iteration function should in general allow for all necessary functionality for incorporating modifications.

In the case of RepresentativePeriods, this is achieved through calling the function constraints_level_rp to introduce, e.g., cyclic constraints as it is in the default case.

constraints_level_iterate(
    m,
    n::Storage,
    prev_pers::PreviousPeriods,
    per,
    ts::SimpleTimes,
    modeltype::EnergyModel,
)

In the case of SimpleTimes, the iterator function is at its lowest level. In this situation,the previous level is calculated using the function previous_level and used for the storage balance. The the approach for calculating the previous_level is depending on the types in the parameteric type PreviousPeriods.

In addition, additional bounds can be included on the initial level within an operational period.

constraints_level_rp(m, n::Storage, per, modeltype::EnergyModel)

Provides additional contraints for representative periods.

The default approach is to set the total change in all representative periods within a strategic period to 0. This implies that the Storage node cannot accumulate energy between individual strategic periods.

constraints_level_rp(m, n::Storage{<:Accumulating}, per, modeltype::EnergyModel)

When a Storage{<:Accumulating} is used, the cyclic constraint for restricting the level change within a strategic period to 0 (through setting the sum of :stor_level_Δ_rp within a strategic period to 0) is not implemented as accumulation within a strategic period is desirable.

This implies that Accumulating behaviours require the developer to introduce the function previous_level in the case of prev_pers = PreviousPeriods{<:NothingPeriod, Nothing, Nothing}.

constraints_level_rp(m, n::Storage{CyclicRepresentative}, per, modeltype::EnergyModel)

When a Storage{CyclicRepresentative} is used, the change in the representative period is constrained to 0.

constraints_level_scp(m, n::Storage, per, modeltype::EnergyModel)

Provides additional constraints for scenario periods.

The default approach is to not provide any constraints.

constraints_level_scp(m, n::Storage{CyclicRepresentative}, per, modeltype::EnergyModel)

When a Storage{CyclicRepresentative} is used, the final level in an operational scenario is constrained to be the same in all operational scenarios.

constraints_links(m, 𝒩, 𝒯, 𝒫, ℒ, modeltype::EnergyModel)

Call the function create_link for link formulation

constraints_node(m, 𝒩, 𝒯, 𝒫, ℒ, modeltype::EnergyModel)

Create link constraints for each n ∈ 𝒩 depending on its type and calling the function create_node(m, n, 𝒯, 𝒫) for the individual node constraints.

Create constraints for fixed OPEX.

create_link(m, 𝒯, 𝒫, l, formulation::Formulation)

Set the constraints for a simple Link (input = output). Can serve as fallback option for all unspecified subtypes of Link.

has_charge_OPEX_fixed(n::Storage)

Returns logic whether the node has a charge fixed OPEX contribution.

has_charge_OPEX_var(n::Storage)

Returns logic whether the node has a charge variable OPEX contribution.

has_charge_cap(n::Storage)

Returns logic whether the node has a charge capacity.

has_discharge_OPEX_fixed(n::Storage)

Returns logic whether the node has a discharge fixed OPEX contribution.

has_discharge_OPEX_var(n::Storage)

Returns logic whether the node has a discharge variable OPEX contribution.

has_discharge_cap(n::Storage)

Returns logic whether the node has a discharge capacity.

has_level_OPEX_fixed(n::Storage)

Returns logic whether the node has a level fixed OPEX contribution.

has_level_OPEX_var(n::Storage)

Returns logic whether the node has a level variable OPEX contribution.

is_network_node(n::Node)

Checks, whether node n is a NetworkNode node

is_resource_emit(p::Resource)

Checks whether the Resource p is of type ResourceEmit.

is_sink(n::Node)

Checks, whether node n is a Sink node

is_source(n::Node)

Checks, whether node n is a Source node

is_storage(n::Node)

Checks, whether node n is a Storage node

link_res(l::Link)

Return the resources transported for a given link l.

link_sub(ℒ::Vector{<:Link}, n::Node)

Return connected links from the vector ℒ for a given node n as array. The first subarray corresponds to the from field, while the second to the to field.

multiple(t_inv, t)

Provide a simplified function for returning the combination of the functions duration(t) * multiplestrat(tinv, t) * probability(t)

nodes_not_av(𝒩::Array{<:Node})

Returns nodes that are not Availability nodes for a given Array 𝒩::Array{<:Node}.

nodes_not_sub(𝒩::Array{<:Node}, sub)

Returns nodes that are not of type sub for a given Array 𝒩::Array{<:Node}.

nodes_sub(𝒩::Array{<:Node}, sub)

Returns nodes that are of type sub for a given Array 𝒩::Array{<:Node}.

objective(m, 𝒩, 𝒯, 𝒫, modeltype::EnergyModel)

Create the objective for the optimization problem for a given modeltype.

res_em(𝒫::Array{<:Resource})

Returns all emission resources for a

• a given array ::Array{<:Resource}.The output is in this case an Array{<:Resource}
• a given dictionary ::Dict.The output is in this case a dictionary Dict with the correct fields

res_not(𝒩::Array{<:Resource}, res_inst)

Return all resources that are not res_inst for

• a given array ::Array{<:Resource}.The output is in this case an Array{<:Resource}
• a given dictionary ::Dict.The output is in this case a dictionary Dict with the correct fields

res_sub(𝒫::Array{<:Resource}, sub = ResourceEmit)

Return resources that are of type sub for a given Array ::Array{Resource}.

sort_types(types_list::Dict)

Sort the result of collect_types and return a vector where a supertype comes before all its subtypes.

variables_capacity(m, 𝒩, 𝒯, modeltype::EnergyModel)

Declaration of different capacity variables for nodes 𝒩ⁿᵒᵗ that are neither Storage nor Availability nodes. These variables are:

• :cap_use - use of a technology node in each operational period and
• :cap_inst - installed capacity in each operational period in terms of either :flow_in or :flow_out (depending on node n ∈ 𝒩)

Declaration of different storage variables for Storage nodes 𝒩ˢᵗᵒʳ. These variables are:

• :stor_level - storage level at the end of each operational period.
• :stor_level_Δ_op - storage level change in each operational period.
• :stor_level_Δ_rp - storage level change in each representative period.
• :stor_level_inst - installed capacity for storage in each operational period, constrained in the operational case to the provided capacity in the storage parameters used in the field :level.
• :stor_charge_use - storage charging use in each operational period.
• :stor_charge_inst - installed charging capacity, e.g. power, in each operational period, constrained in the operational case to the provided capacity in the storage parameters used in the field :charge. This variable is only defined if the Storage node has a field charge.
• :stor_discharge_use - storage discharging use in each operational period.
• :stor_discharge_inst - installed charging capacity, e.g. power, in each operational period, constrained in the operational case to the provided capacity in the storage parameters used in the field :discharge. This variable is only defined if the Storage node has a field discharge.

variables_capex(m, 𝒩, 𝒯, 𝒫, modeltype::EnergyModel)

Declaration of the CAPEX variables of the model for each investment period 𝒯ᴵⁿᵛ ∈ 𝒯. Empty for operational models but required for multiple dispatch in investment model.

variables_emission(m, 𝒩, 𝒯, 𝒫, modeltype::EnergyModel)

Declaration of emission variables per technology node with emissions n ∈ 𝒩ᵉᵐ and emission resource 𝒫ᵉᵐ ∈ 𝒫.

The emission variables are differentiated in:

• :emissions_node - emissions of a node in an operational period,
• :emissions_total - total emissions in an operational period, and
• :emissions_strategic - total strategic emissions, constrained to an upper limit based on the field emission_limit of the EnergyModel.

variables_flow(m, 𝒩, 𝒯, 𝒫, ℒ, modeltype::EnergyModel)

Declaration of the individual input (:flow_in) and output (:flow_out) flowrates for each technological node n ∈ 𝒩 and link l ∈ ℒ (:link_in and :link_out).

variables_nodes(m, 𝒩, 𝒯, modeltype::EnergyModel)

Loop through all node types and create variables specific to each type. This is done by calling the method variables_node on all nodes of each type.

The node type representing the widest cathegory will be called first. That is, variables_node will be called on a Node before it is called on NetworkNode-nodes.

variables_opex(m, 𝒩, 𝒯, 𝒫, modeltype::EnergyModel)

Declaration of the OPEX variables (:opex_var and :opex_fixed) of the model for each period 𝒯ᴵⁿᵛ ∈ 𝒯. Variable OPEX can be non negative to account for revenue streams.