# Sets¶

Since urbs is a linear optimization model with many objects (e.g. variables, parameters), it is reasonable to use sets to define the groups of objects. With the usage of sets, many facilities are provided, such as understanding the main concepts of the model. Many objects are represented by various sets, therefore sets can be easily used to check whether some object has a specific characteristic or not. Additionally sets are useful to define a hierarchy of objects. Mathematical notation of sets are expressed with uppercase letters, and their members are usually expressed with the same lowercase letters. Main sets, tuple sets and subsets will be introduced in this respective order.

## Elementary Sets¶

Table: Model Sets
Set Description
$$t \in T$$ Timesteps
$$t \in T_\text{m}$$ Modelled Timesteps
$$y \in Y$$ Support Timeframes
$$v \in V$$ Sites
$$c \in C$$ Commodities
$$q \in Q$$ Commodity Types
$$p \in P$$ Processes
$$s \in S$$ Storages
$$f \in F$$ Transmissions
$$r \in R$$ Cost Types

### Timesteps¶

The model urbs is considered to observe a energy system model and calculate the optimal solution within a limited span of time. This limited span of time is viewed as a discrete variable, which means values of variables are viewed as occurring only at distinct timesteps. The set of timesteps $$T = \{t_0,\dots,t_N\}$$ for $$N$$ in $$\mathbb{N}$$ represents time. This set contains $$N+1$$ sequential time steps with equal spaces. Each time step represents another point in time. At the initialization of the model this set is fixed by the user by setting the variable timesteps in script runme.py. Duration of space between timesteps $$\Delta t = t_{x+1} - t_x$$, length of simulation $$\Delta t \cdot N$$ and time interval $$[t_0,t_N]$$ can be fixed to satisfy the needs of the user. In code this set is defined by the set t and initialized by the section:

m.t = pyomo.Set(
initialize=m.timesteps,
ordered=True,
doc='Set of timesteps')


Where:

• Initialize: A function that receives the set indices and model to return the value of that set element, initializes the set with data.
• Ordered: A boolean value that indicates whether the set is ordered.
• Doc: A string describing the set.

### Modelled Timesteps¶

The set, modelled timesteps, is a subset of the timesteps set. The only difference between modelled timesteps set and the timesteps set is that the initial timestep $$t_0$$ is not included. All other features of the set time steps also apply to the set of modelled timesteps. This set is the main time set used in the model. The distinction with the set timesteps is only required to facilitate the definition of the storage state equation. In script model.py this set is defined by the set tm and initialized by the code fragment:

m.tm = pyomo.Set(
within=m.t,
initialize=m.timesteps[1:],
ordered=True,
doc='Set of modelled timesteps')


Where:

• Within: The option that supports the validation of a set array.
• m.timesteps[1:] represents the timesteps set starting from the second element, excluding the first timestep $$t_0$$

### Support Timeframes¶

Support timeframes are represented by the set $$Y$$. They represent the explicitly modeled support timeframes, e.g., years, for intertemporal models. In script model.py the set is defined as:

# support timeframes (e.g. 2020, 2030...)
indexlist = set()
for key in m.commodity_dict["price"]:
m.stf = pyomo.Set(
initialize=indexlist,
doc='Set of modeled support timeframes (e.g. years)')


where:

• The commodity_dict["price"] is a dictionary in which prices of commodities in the sites are noted for each support timeframe (i.e. year). The dictionary’s keys have the elements: (Year, Site, Commodity Name, Commodity Type).

### Sites¶

Sites are represented by the set $$V$$. A site $$v$$ can be any distinct location, a place of settlement or activity (e.g. process, transmission, storage). A site is for example an individual building, region, country or even continent. Sites can be imagined as nodes (vertices) on a graph of locations, connected by edges. Index of this set are the descriptions of the sites (e.g. north, middle, south). In script model.py this set is defined by sit and initialized by the code fragment:

# site (e.g. north, middle, south...)
indexlist = set()
for key in m.commodity_dict["price"]:
m.sit = pyomo.Set(
initialize=indexlist,
doc='Set of sites')


### Commodities¶

As explained in the overview section, commodities are goods that can be generated, stored, transmitted or consumed. The set of commodities represents all goods that are relevant to the modelled energy system, such as all energy carriers, inputs, outputs, intermediate substances. (e.g. Coal, CO2, Electric, Wind) By default, commodities are given by their energy content (MWh). Usage of some commodities are limited by a maximum value or maximum value per timestep due to their availability or restrictions, also some commodities have a price that needs to be compensated..(e.g. coal, wind, solar). In script model.py this set is defined by com and initialized by the code fragment:

# commodity (e.g. solar, wind, coal...)
indexlist = set()
for key in m.commodity_dict["price"]:
m.com = pyomo.Set(
initialize=indexlist,
doc='Set of commodities')


### Commodity Types¶

Commodities differ in their usage purposes, consequently commodity types are introduced to subdivide commodities by their features. These types are hard coded as SupIm, Stock, Demand, Env, Buy, Sell. In script model.py this set is defined as com_type and initialized by the code fragment:

# commodity type (i.e. SupIm, Demand, Stock, Env)
indexlist = set()
for key in m.commodity_dict["price"]:
m.com_type = pyomo.Set(
initialize=indexlist,
doc='Set of commodity types')


### Processes¶

One of the most important elements of an energy system is the process. A process $$p$$ can be defined by the action of changing one or more forms of energy, i.e. commodities, to others. In our modelled energy system, processes convert input commodities into output commodities. Process technologies are represented by the set processes $$P$$. Different processes technologies have fixed input and output commodities. These input and output commodities can be either single or multiple regardless of each other. Some example members of this set can be: Wind Turbine, Gas Plant, Photovoltaics. In script model.py this set is defined as pro and initialized by the code fragment:

# process (e.g. Wind turbine, Gas plant, Photovoltaics...)
indexlist = set()
for key in m.process_dict["inv-cost"]:
m.pro = pyomo.Set(
initialize=indexlist,
doc='Set of conversion processes')


where:

• The m.process_dict["inv-cost"] is again a dictionary whose key has the elements: (Year, Site, Process). An example key would look like as follows: (2020, ‘Mid’, ‘Biomass plant’).

### Storages¶

Energy storage is provided by technical facilities that store energy to generate a commodity at a later time for the purpose of meeting the demand. Occasionally, on-hand commodities may not be able to satisfy the required amount of energy to meet the demand, or the available amount of energy may be much more than required. Storage technologies play a major role in such circumstances. The Set $$S$$ represents all storage technologies (e.g. Pump storage). In script features\storage.py this set is defined as sto and initialized by the code fragment:

# storage (e.g. hydrogen, pump storage)
indexlist = set()
for key in m.storage_dict["eff-in"]:
m.sto = pyomo.Set(
initialize=indexlist,
doc='Set of storage technologies')


where:

• The m.storage_dict["eff-in"] is a dictionary whose key has the elements: (Year, Site, Storage, Commodity). An example key would look like as follows: (2020, ‘Mid’, ‘Hydrogen’, ‘Elec’).

### Transmissions¶

Transmissions $$f \in F$$ represent possible conveyances of commodities between sites. Transmission process technologies can vary between different commodities, due to distinct physical attributes and forms of commodities. Some examples for transmission technologies are: HVAC (High Voltage AC), HVDC, pipeline. In script features\transmission.py this set is defined as tra and initialized by the code fragment:

# tranmission (e.g. hvac, hvdc, pipeline...)
indexlist = set()
for key in m.transmission_dict["eff"]:
m.tra = pyomo.Set(
initialize=indexlist,
doc='Set of transmission technologies')


where:

• The m.transmission_dict["eff"] is a dictionary whose key has the elements: Year, Site In, Site Out, Transmission, Commodity.

### Cost Types¶

One of the major goals of the model is to calculate the costs of a simulated energy system. There are 7 different types of costs. Each one has different features and are defined for different instances. Set of cost types is hardcoded, which means they are not considered to be fixed or changed by the user. The set $$R$$ defines the cost types, each member $$r$$ of this set $$R$$ represents a unique cost type name. In script model.py this set is defined as cost_type and initialized by the code fragment:

m.cost_type = pyomo.Set(
initialize=m.cost_type_list,
doc='Set of cost types (hard-coded)')


The cost types are hard coded and taken from a list with following structure: [Invest, Fixed, Variable, Fuel, Environmental, Revenue, Purchase].

## Tuple Sets¶

A tuple is finite, ordered collection of elements. For example, the tuple (hat,red,large) consists of 3 ordered elements and defines another element itself. Tuples are needed in this model to define the combinations of elements from different sets. Defining a tuple lets us assemble related elements and use them as a single element. These tuples are then collected into tuple sets. These tuple sets are then immensely useful for efficient indexing of model variables and parameters and for defining the constraint rules.

### Commodity Tuples¶

Commodity tuples represent combinations of defined commodities. These are represented by the set $$C_{yvq}$$. A member $$c_{yvq}$$ in set $$C_{yvq}$$ is a commodity $$c$$ of commodity type $$q$$ in support timeframe $$y$$ and site $$v$$. This set is defined as com_tuples and given by the code fragment under model.py:

m.com_tuples = pyomo.Set(
within=m.stf * m.sit * m.com * m.com_type,
initialize=tuple(m.commodity_dict["price"].keys()),
doc='Combinations of defined commodities, e.g. (2018,Mid,Elec,Demand)')


where:

• The keys of commodity_dict["price"] has the following elements: (Year, Site, Commodity, Commodity Type). For example, (2020, Mid, Elec, Demand) and it is interpreted as commodity Elec of commodity type Demand in the year 2020 in site Mid.

### Process Tuples¶

Process tuples represent possible placements of processes within the model. These are represented by the set $$P_{yv}$$. A member $$p_{yv}$$ in set $$P_{yv}$$ is a process $$p$$ in support timeframe $$y$$ and site $$v$$. This set is defined as pro_tuples and given by the code fragment:

m.pro_tuples = pyomo.Set(
within=m.stf * m.sit * m.pro,
initialize=tuple(m.process_dict["inv-cost"].keys()),
doc='Combinations of possible processes, e.g. (2018,North,Coal plant)')


where:

• The key of process_dict["inv-cost"] has the following elements: (Year, Site, Process). For example, (2020, ‘North’, ‘Coal Plant’) and it is interpreted as process Coal Plant in site North in the year 2020.

There are three subsets defined for process tuples, which each activate a different set of modeling constraints.

The first subset of the process tuples pro_partial_tuples $$P_{yv}^\text{partial}$$ is formed in order to identify processes that have partial operation properties. Programmatically, they are identified by those processes, which have the parameter ratio-min set for one of their input commodities in table Process-Commodity. The tuple set is defined as:

m.pro_partial_tuples = pyomo.Set(
within=m.stf * m.sit * m.pro,
initialize=[(stf, site, process)
for (stf, site, process) in m.pro_tuples
for (s, pro, _) in tuple(m.r_in_min_fraction_dict.keys())
if process == pro and s == stf],
doc='Processes with partial input')


where:

• The keys of dictionary r_in_min_fraction_dict contain the data: Year, Process, Commodity. For example (2020, ‘Coal Plant’, ‘Coal’).

The second subset is formed in order to capture all processes that take up a certain area and are thus subject to the area constraint at the given site. These processes are identified by the parameter area-per-cap set in table Process, if at the same time a value for area is set in table Site. The tuple set is defined as:

# process tuples for area rule
m.pro_area_tuples = pyomo.Set(
within=m.stf * m.sit * m.pro,
initialize=tuple(m.proc_area_dict.keys()),
doc='Processes and Sites with area Restriction')


where:

• The key of dictionary proc_area_dict has the form: Year, Site, Process. For example (2020, ‘Mid’, ‘Photovoltaics’).

Finally, processes that are subject to restrictions in the change of operational state are captured with the pro_maxgrad_tuples. This subset is defined as:

# process tuples for maximum gradient feature
within=m.stf * m.sit * m.pro,
initialize=[(stf, sit, pro)
for (stf, sit, pro) in m.pro_tuples
if m.process_dict['max-grad'][stf, sit, pro] < 1.0 / dt],
doc='Processes with maximum gradient smaller than timestep length')


where:

• The process_dict['max-grad'][stf, sit, pro] returns the values from max-grad column in the process sheet of input excel files. In the dictionary, the keys that correspond to the values are tuples in form Stf, sit, pro and they are to interpreted as year, site, process.

### Transmission Tuples¶

Transmission tuples represent possible transmissions. These are represented by the set $$F_{yc{v_\text{out}}{v_\text{in}}}$$. A member $$f_{yc{v_\text{out}}{v_\text{in}}}$$ in set $$F_{yc{v_\text{out}}{v_\text{in}}}$$ is a transmission $$f$$, that is directed from an origin site $$v_\text{out}$$ to a destination site $$v_{in}$$ and carrying the commodity $$c$$ in support timeframe $$y$$. The term “directed from an origin site $$v_\text{out}$$ to a destination site $$v_\text{in}$$” can also be defined as an arc $$a$$ . For example, (2020, South, Mid, hvac, Elec) is interpreted as transmission hvac that is directed from origin site South to destination site Mid carrying commodity Elec in year 2020. This set is defined as tra_tuples and given by the code fragment:

m.tra_tuples = pyomo.Set(
within=m.stf * m.sit * m.sit * m.tra * m.com,
initialize=tuple(m.transmission_dict["eff"].keys()),
doc='Combinations of possible transmissions, e.g. '
'(2020,South,Mid,hvac,Elec)')


### DCPF Transmission Tuples¶

If the DC Power Flow Model feature is activated in the model, three different transmission tuple sets are defined in the model.

The set $$F_{yc{v_\text{out}}{v_\text{in}}^{TP}}$$ includes every transport model transmission lines and is defined as tra_tuples_tp and given by the code fragment:

m.tra_tuples_tp = pyomo.Set(
within=m.stf * m.sit * m.sit * m.tra * m.com,
initialize=tuple(tra_tuples_tp),
doc='Combinations of possible transport transmissions,'
'e.g. (2020,South,Mid,hvac,Elec)')


The set $$F_{yc{v_\text{out}}{v_\text{in}}^{DCPF}}$$ includes every transmission line, which should be modelled with DCPF. If the complementary arcs are included in the input for DCPF transmission lines, these will be excluded from this set with remove_duplicate_transmission(). This set is defined as tra_tuples_dc and given by the code fragment:

m.tra_tuples_dc = pyomo.Set(
within=m.stf * m.sit * m.sit * m.tra * m.com,
initialize=tuple(tra_tuples_dc),
doc='Combinations of possible bidirectional dc'
'transmissions, e.g. (2020,South,Mid,hvac,Elec)')


If the DCPF is activated, the set $$F_{yc{v_\text{out}}{v_\text{in}}}$$ is defined by the unification of the sets $$F_{yc{v_\text{out}}{v_\text{in}}^{DCPF}}$$ and $$F_{yc{v_\text{out}}{v_\text{in}}^{TP}}$$. This set is defined as tra_tuples in the same fashion as the default transmission model.

### Storage Tuples¶

Storage tuples label storages. They are represented by the set $$S_{yvc}$$. A member $$s_{yvc}$$ in set $$S_{yvc}$$ is a storage $$s$$ of commodity $$c$$ in site $$v$$ and support timeframe $$y$$. For example, (2020, Mid, Bat, Elec) is interpreted as storage Bat for commodity Elec in site Mid in the year 2020. This set is defined as sto_tuples and given by the code fragment:

m.sto_tuples = pyomo.Set(
within=m.stf * m.sit * m.sto * m.com,
initialize=tuple(m.storage_dict["eff-in"].keys()),
doc='Combinations of possible storage by site,'
'e.g. (2020,Mid,Bat,Elec)')


There are two subsets of storage tuples.

In a first subset of the storage tuples are all storages that have a user defined fixed value for the initial state are collected.

m.sto_init_bound_tuples = pyomo.Set(
within=m.stf * m.sit * m.sto * m.com,
initialize=tuple(m.stor_init_bound_dict.keys()),
doc='storages with fixed initial state')


A second subset is defined for all storages that have a fixed ratio between charging/discharging power and storage content.

m.sto_ep_ratio_tuples = pyomo.Set(
within=m.stf*m.sit*m.sto*m.com,
initialize=tuple(m.sto_ep_ratio_dict.keys()),
doc='storages with given energy to power ratio')


### Process Input Tuples¶

Process input tuples represent commodities consumed by processes. These are represented by the set $$C_{yvp}^\text{in}$$. A member $$c_{yvp}^\text{in}$$ in set $$C_{yvp}^\text{in}$$ is a commodity $$c$$ consumed by the process $$p$$ in site $$v$$ in support timeframe $$y$$. For example, (2020, Mid, PV, Solar) is interpreted as commodity Solar consumed by the process PV in the site Mid in the year 2020. This set is defined as pro_input_tuples and given by the code fragment:

m.pro_input_tuples = pyomo.Set(
within=m.stf * m.sit * m.pro * m.com,
initialize=[(stf, site, process, commodity)
for (stf, site, process) in m.pro_tuples
for (s, pro, commodity) in tuple(m.r_in_dict.keys())
if process == pro and s == stf],
doc='Commodities consumed by process by site,'
'e.g. (2020,Mid,PV,Solar)')


Where: r_in_dict represents the process input ratio as set in the input.

For processes in the tuple set pro_partial_tuples, the following tuple set pro_partial_input_tuples enumerates their input commodities. It is used to index the constraints that modifies a process’ input commodity flow with respect to the standard case without partial operation. It is defined by the following code fragment:

m.pro_partial_input_tuples = pyomo.Set(
within=m.stf * m.sit * m.pro * m.com,
initialize=[(stf, site, process, commodity)
for (stf, site, process) in m.pro_partial_tuples
for (s, pro, commodity) in tuple(m.r_in_min_fraction_dict
.keys())
if process == pro and s == stf],
doc='Commodities with partial input ratio,'
'e.g. (2020,Mid,Coal PP,Coal)')


### Process Output Tuples¶

Process output tuples represent commodities generated by processes. These are represented by the set $$C_{yvp}^\text{out}$$. A member $$c_{yvp}^\text{out}$$ in set $$C_{yvp}^\text{out}$$ is a commodity $$c$$ generated by the process $$p$$ in site $$v$$ and support timeframe $$y$$. For example, (2020, Mid,PV,Elec) is interpreted as the commodity Elec is generated by the process PV in the site Mid in the year 2020. This set is defined as pro_output_tuples and given by the code fragment:

m.pro_output_tuples = pyomo.Set(
within=m.stf * m.sit * m.pro * m.com,
initialize=[(stf, site, process, commodity)
for (stf, site, process) in m.pro_tuples
for (s, pro, commodity) in tuple(m.r_out_dict.keys())
if process == pro and s == stf],
doc='Commodities produced by process by site, e.g. (2020,Mid,PV,Elec)')


Where: r_out_dict represents the process output ratio as set in the input.

There are two alternative tuple sets that are active whenever their respective features are set in the input.

First, for processes in the tuple set pro_partial_tuples, the tuple set pro_partial_output_tuples enumerates their output commodities. It is used to index the constraints that modifies a process’ output commodity flow with respect to the standard case without partial operation. It is defined by the following code fragment:

m.pro_partial_output_tuples = pyomo.Set(
within=m.stf * m.sit * m.pro * m.com,
initialize=[(stf, site, process, commodity)
for (stf, site, process) in m.pro_partial_tuples
for (s, pro, commodity) in tuple(m.r_out_min_fraction_dict
.keys())
if process == pro and s == stf],
doc='Commodities with partial input ratio, e.g. (Mid,Coal PP,CO2)')


Second, the output of all processes that have a time dependent efficiency are collected in an additional tuple set. The set contains all outputs corresponding to processes that are specified as column indices in the input file worksheet TimeVarEff. The code is implemented in features\TimeVarEff.py as:

m.pro_timevar_output_tuples = pyomo.Set(
within=m.stf * m.sit * m.pro * m.com,
initialize=[(stf, site, process, commodity)
for stf in tve_stflist
for (site, process) in tuple(m.eff_factor_dict.keys())
for (st, pro, commodity) in tuple(m.r_out_dict.keys())
if process == pro and st == stf and commodity not in
m.com_env],
doc='Outputs of processes with time dependent efficiency')


### Demand Side Management Tuples¶

There are two kinds of demand side management (DSM) tuples in the model: DSM site tuples $$D_{yvc}$$ and DSM down tuples $$D_{yvct,tt}^\text{down}$$. The first kind $$D_{yvc}$$ represents all possible combinations of support timeframe $$y$$, site $$v$$ and commodity $$c$$ of the DSM sheet. It is given by the code fragment:

m.dsm_site_tuples = pyomo.Set(
within=m.stf*m.sit*m.com,
initialize=tuple(m.dsm_dict["delay"].keys()),
doc='Combinations of possible dsm by site, e.g. '
'(2020, Mid, Elec)')


The second kind $$D_{t,tt,yvc}^\text{down}$$ refers to all possible DSM downshift possibilities. It is defined to overcome the difficulty caused by the two time indices of the DSM downshift variable. Dependend on support timeframe $$y$$, site $$v$$ and commodity $$c$$ the tuples contain two time indices. For example, (5001, 5003, 2020, Mid, Elec) is intepreted as the downshift in timestep 5003, which was caused by the upshift of timestep 5001 in year 2020 at site Mid for commodity Elec. The tuples are given by the following code fragment:

m.dsm_down_tuples = pyomo.Set(
within=m.tm*m.tm*m.stf*m.sit*m.com,
initialize=[(t, tt, stf, site, commodity)
for (t, tt, stf, site, commodity)
in dsm_down_time_tuples(m.timesteps[1:],
m.dsm_site_tuples,
m)],
doc='Combinations of possible dsm_down combinations, e.g. '
'(5001,5003,2020,Mid,Elec)')


where the following function is utilized:

def dsm_down_time_tuples(time, sit_com_tuple, m):
""" Dictionary for the two time instances of DSM_down
Args:
time: list with time indices
sit_com_tuple: a list of (site, commodity) tuples
m: model instance
Returns:
A list of possible time tuples depending on site and commodity
"""

delay = m.dsm_dict['delay']
ub = max(time)
lb = min(time)
time_list = []

for (stf, site, commodity) in sit_com_tuple:
for step1 in time:
for step2 in range(step1 -
max(int(delay[stf, site, commodity] /
m.dt.value), 1),
step1 +
max(int(delay[stf, site, commodity] /
m.dt.value), 1) + 1):
if lb <= step2 <= ub:
time_list.append((step1, step2, stf, site, commodity))

return time_list


## Commodity Type Subsets¶

Commodity type subsets represent the commodity tuples only from a given commodity type. Commodity type subsets are subsets of the sets commodity tuples. These subsets can be obtained by fixing the commodity type $$q$$ to a desired commodity type (e.g. SupIm, Stock) in the set commodity tuples $$C_{vq}$$. Since there are 6 types of commodity types, there are also 6 commodity type subsets. Commodity type subsets are:

Supply Intermittent Commodities (SupIm): The set $$C_\text{sup}$$ represents all commodities $$c$$ of commodity type SupIm. Commodities of this type have intermittent timeseries, in other words, availability of these commodities are not constant. These commodities might have various energy content for every timestep $$t$$. For example, solar radiation is contingent on many factors such as sun position, weather and varies permanently.

Stock Commodities (Stock): The set $$C_\text{st}$$ represents all commodities $$c$$ of commodity type Stock. Commodities of this type can be purchased at any time for a given price ($$k_{vc}^\text{fuel}$$).

Sell Commodities (Sell): The set $$C_\text{sell}$$ represents all commodities $$c$$ of commodity type Sell. Commodities that can be sold. These commodities have a sell price ( $$k_{vct}^\text{s}$$ ) that may vary with the given timestep $$t$$.

Buy Commodities (Buy): The set $$C_\text{buy}$$ represents all commodities $$c$$ of commodity type Buy. Commodities that can be purchased. These commodities have a buy price ( $$k_{vc}^\text{b}$$ ) that may vary with the given timestep $$t$$.

Demand Commodities (Demand): The set $$C_\text{dem}$$ represents all commodities $$c$$ of commodity type Demand. Commodities of this type are the requested commodities of the energy system. They are usually the end product of the model (e.g. Electricity:Elec).

Environmental Commodities (Env): The set $$C_\text{env}$$ represents all commodities $$c$$ of commodity type Env. Commodities of this type are usually the undesired byproducts of processes that might be harmful for environment, optional maximum creation limits can be set to control the generation of these commodities (e.g. Greenhouse Gas Emissions: $$\text{CO}_2$$).

Commodity type subsets are given by the code fragment:

m.com_supim = pyomo.Set(
within=m.com,
initialize=commodity_subset(m.com_tuples, 'SupIm'),
doc='Commodities that have intermittent (timeseries) input')
m.com_stock = pyomo.Set(
within=m.com,
initialize=commodity_subset(m.com_tuples, 'Stock'),
doc='Commodities that can be purchased at some site(s)')
m.com_sell = pyomo.Set(
within=m.com,
initialize=commodity_subset(m.com_tuples, 'Sell'),
doc='Commodities that can be sold')
within=m.com,
doc='Commodities that can be purchased')
m.com_demand = pyomo.Set(
within=m.com,
initialize=commodity_subset(m.com_tuples, 'Demand'),
doc='Commodities that have a demand (implies timeseries)')
m.com_env = pyomo.Set(
within=m.com,
initialize=commodity_subset(m.com_tuples, 'Env'),
doc='Commodities that (might) have a maximum creation limit')


Where:

urbs.commodity_subset(com_tuples, type_name)

Returns the commodity names($$c$$) of the given commodity type($$q$$).

Parameters: com_tuples – A list of tuples (site, commodity, commodity type) type_name – A commodity type or a list of commodity types The set (unique elements/list) of commodity names of the desired commodity type.

## Operational State Tuples¶

For intertemporal optimization the operational state of units in a support timeframe y has to be calculated from both the initially installed units and their remaining lifetime and the units installed in a previous support timeframe which are still operational in y. This is achieved via 6 tuple sets two each for processes, transmissions and storages. For the mathematical description please refer to Unit Expansion Constraints.

### Initially Installed Units¶

Processes which are already installed at the beginning of the modeled time horizon and still operational in support timeframe stf are collected in the following tuple set:

m.inst_pro_tuples = pyomo.Set(
within=m.sit*m.pro*m.stf,
initialize=[(sit, pro, stf)
for (sit, pro, stf)
in inst_pro_tuples(m)],
doc=' Installed processes that are still operational through stf')


where the following function is utilized:

def inst_pro_tuples(m):
""" Tuples for operational status of already installed units
(processes, transmissions, storages) for intertemporal planning.
Only such tuples where the unit is still operational until the next
support time frame are valid.
"""
inst_pro = []
sorted_stf = sorted(list(m.stf))

for (stf, sit, pro) in m.inst_pro.index:
for stf_later in sorted_stf:
index_helper = sorted_stf.index(stf_later)
if stf_later == max(m.stf):
if (stf_later +
m.global_prop.loc[(max(sorted_stf), 'Weight'), 'value'] -
(stf, sit, pro)]):
inst_pro.append((sit, pro, stf_later))
elif (stf_later + sorted_stf[index_helper + 1])/2 <= (min(m.stf)
inst_pro.append((sit, pro, stf_later))

return inst_pro


Transmissions which are already installed at the beginning of the modeled time horizon and still operational in support timeframe stf are collected in the following tuple set:

m.inst_tra_tuples = pyomo.Set(
within=m.sit*m.sit*m.tra*m.com*m.stf,
initialize=[(sit, sit_, tra, com, stf)
for (sit, sit_, tra, com, stf)
in inst_tra_tuples(m)],
doc='Installed transmissions that are still operational through stf')


where the following function is utilized:

def inst_tra_tuples(m):
""" s.a. inst_pro_tuples
"""
inst_tra = []
sorted_stf = sorted(list(m.stf))

for (stf, sit1, sit2, tra, com) in m.inst_tra.index:
for stf_later in sorted_stf:
index_helper = sorted_stf.index(stf_later)
if stf_later == max(m.stf):
if (stf_later +
m.global_prop_dict['value'][(max(sorted_stf), 'Weight')] -
(stf, sit1, sit2, tra, com)]):
inst_tra.append((sit1, sit2, tra, com, stf_later))
elif (sorted_stf[index_helper + 1] <= min(m.stf) +
(stf, sit1, sit2, tra, com)]):
inst_tra.append((sit1, sit2, tra, com, stf_later))

return inst_tra


Storages which are already installed at the beginning of the modeled time horizon and still operational in support timeframe stf are collected in the following tuple set:

m.inst_sto_tuples = pyomo.Set(
within=m.sit*m.sto*m.com*m.stf,
initialize=[(sit, sto, com, stf)
for (sit, sto, com, stf)
in inst_sto_tuples(m)],
doc='Installed storages that are still operational through stf')


where the following function is utilized:

def inst_sto_tuples(m):
""" s.a. inst_pro_tuples
"""
inst_sto = []
sorted_stf = sorted(list(m.stf))

for (stf, sit, sto, com) in m.inst_sto.index:
for stf_later in sorted_stf:
index_helper = sorted_stf.index(stf_later)
if stf_later == max(m.stf):
if (stf_later +
m.global_prop_dict['value'][(max(sorted_stf), 'Weight')] -
1 < min(m.stf) +
inst_sto.append((sit, sto, com, stf_later))
elif (sorted_stf[index_helper + 1] <=
(stf, sit, sto, com)]):
inst_sto.append((sit, sto, com, stf_later))

return inst_sto


### Installation in Earlier Support Timeframe¶

Processes installed in an earlier support timeframe stf and still usable in support timeframe stf_later are collected in the following tuple set:

m.operational_pro_tuples = pyomo.Set(
within=m.sit*m.pro*m.stf*m.stf,
initialize=[(sit, pro, stf, stf_later)
for (sit, pro, stf, stf_later)
in op_pro_tuples(m.pro_tuples, m)],
doc='Processes that are still operational through stf_later'
'(and the relevant years following), if built in stf'
'in stf.')


where the following function is utilized:

def op_pro_tuples(pro_tuple, m):
""" Tuples for operational status of units (processes, transmissions,
storages) for intertemporal planning.
Only such tuples where the unit is still operational until the next
support time frame are valid.
"""
op_pro = []
sorted_stf = sorted(list(m.stf))

for (stf, sit, pro) in pro_tuple:
for stf_later in sorted_stf:
index_helper = sorted_stf.index(stf_later)
if stf_later == max(sorted_stf):
if (stf_later +
m.global_prop.loc[(max(sorted_stf), 'Weight'), 'value'] -
1 <= stf + m.process_dict['depreciation'][
(stf, sit, pro)]):
op_pro.append((sit, pro, stf, stf_later))
elif ((stf_later + sorted_stf[index_helper + 1])/2 <= stf + m.process_dict['depreciation'][(stf, sit, pro)]
and stf <= stf_later):
op_pro.append((sit, pro, stf, stf_later))
else:
pass

return op_pro


Transmissions installed in an earlier support timeframe stf and still usable in support timeframe stf_later are collected in the following tuple set:

m.operational_tra_tuples = pyomo.Set(
within=m.sit*m.sit*m.tra*m.com*m.stf*m.stf,
initialize=[(sit, sit_, tra, com, stf, stf_later)
for (sit, sit_, tra, com, stf, stf_later)
in op_tra_tuples(m.tra_tuples, m)],
doc='Transmissions that are still operational through stf_later'
'(and the relevant years following), if built in stf'
'in stf.')


where the following function is utilized:

def op_tra_tuples(tra_tuple, m):
""" s.a. op_pro_tuples
"""
op_tra = []
sorted_stf = sorted(list(m.stf))

for (stf, sit1, sit2, tra, com) in tra_tuple:
for stf_later in sorted_stf:
index_helper = sorted_stf.index(stf_later)
if stf_later == max(sorted_stf):
if (stf_later +
m.global_prop_dict['value'][(max(sorted_stf), 'Weight')] -
1 <= stf + m.transmission_dict['depreciation'][
(stf, sit1, sit2, tra, com)]):
op_tra.append((sit1, sit2, tra, com, stf, stf_later))
elif (sorted_stf[index_helper + 1] <=
stf + m.transmission_dict['depreciation'][
(stf, sit1, sit2, tra, com)] and stf <= stf_later):
op_tra.append((sit1, sit2, tra, com, stf, stf_later))
else:
pass

return op_tra


Storages installed in an earlier support timeframe stf and still usable in support timeframe stf_later are collected in the following tuple set:

m.operational_sto_tuples = pyomo.Set(
within=m.sit*m.sto*m.com*m.stf*m.stf,
initialize=[(sit, sto, com, stf, stf_later)
for (sit, sto, com, stf, stf_later)
in op_sto_tuples(m.sto_tuples, m)],
doc='Processes that are still operational through stf_later'
'(and the relevant years following), if built in stf'
'in stf.')


where the following function is utilized:

def op_sto_tuples(sto_tuple, m):
""" s.a. op_pro_tuples
"""
op_sto = []
sorted_stf = sorted(list(m.stf))

for (stf, sit, sto, com) in sto_tuple:
for stf_later in sorted_stf:
index_helper = sorted_stf.index(stf_later)
if stf_later == max(sorted_stf):
if (stf_later +
m.global_prop_dict['value'][(max(sorted_stf), 'Weight')] -
1 <= stf +
m.storage_dict['depreciation'][(stf, sit, sto, com)]):
op_sto.append((sit, sto, com, stf, stf_later))
elif (sorted_stf[index_helper + 1] <=
stf +
m.storage_dict['depreciation'][(stf, sit, sto, com)] and
stf <= stf_later):
op_sto.append((sit, sto, com, stf, stf_later))
else:
pass

return op_sto