# oemof.tabular package¶

## Submodules¶

Facade’s are classes providing a simplified view on more complex classes.

More specifically, the Facades in this module act as simplified, energy specific wrappers around oemof’s and oemof.solph’s more abstract and complex classes. The idea is to be able to instantiate a Facade using keyword arguments, whose value are derived from simple, tabular data sources. Under the hood the Facade then uses these arguments to construct an oemof or oemof.solph component and sets it up to be easily used in an EnergySystem.

Note The mathematical notation is as follows:

• Optimization variables (endogenous variables) are denoted by $$x$$
• Optimization parameters (exogenous variables) are denoted by $$c$$
• The set of timesteps $$T$$ describes all timesteps of the optimization problem

class oemof.tabular.facades.BackpressureTurbine(*args, **kwargs)[source]

Bases: oemof.solph.network.Transformer, oemof.tabular.facades.Facade

Combined Heat and Power (backpressure) unit with one input and two outputs.

Parameters: electricity_bus (oemof.solph.Bus) – An oemof bus instance where the chp unit is connected to with its electrical output heat_bus (oemof.solph.Bus) – An oemof bus instance where the chp unit is connected to with its thermal output fuel_bus (oemof.solph.Bus) – An oemof bus instance where the chp unit is connected to with its input carrier_cost (numeric) – Input carrier cost of the backpressure unit, Default: 0 capacity (numeric) – The electrical capacity of the chp unit (e.g. in MW). electric_efficiency – Electrical efficiency of the chp unit thermal_efficiency – Thermal efficiency of the chp unit marginal_cost (numeric) – Marginal cost for one unit of produced electrical output E.g. for a powerplant: marginal cost =fuel cost + operational cost + co2 cost (in Euro / MWh) if timestep length is one hour. Default: 0 expandable (boolean) – True, if capacity can be expanded within optimization. Default: False. capacity_cost (numeric) – Investment costs per unit of electrical capacity (e.g. Euro / MW) . If capacity is not set, this value will be used for optimizing the chp capacity.

Backpressure turbine power plants are modelled with a constant relation between heat and electrical output (power to heat coefficient).

$x^{flow, carrier}(t) = \frac{x^{flow, electricity}(t) + x^{flow, heat}(t)}\ {c^{thermal\:efficiency}(t) + c^{electrical\:efficiency}(t)} \qquad \forall t \in T$
$\frac{x^{flow, electricity}(t)}{x_{flow, thermal}(t)} = \frac{c^{electrical\:efficiency}(t)}{c^{thermal\:efficiency}(t)} \qquad \forall t \in T$

Ojective expression for operation includes marginal cost and/or carrier costs:

$x^{opex} = \sum_t (x^{flow, out}(t) \cdot c^{marginal\_cost}(t) + x^{flow, carrier}(t) \cdot c^{carrier\_cost}(t))$

Examples

>>> from oemof import solph
>>> my_elec_bus = solph.Bus('my_elec_bus')
>>> my_fuel_bus = solph.Bus('my_fuel_bus')
>>> my_heat_bus = solph.Bus('my_heat_bus')
>>> my_backpressure = BackpressureTurbine(
...     label='backpressure',
...     carrier='gas',
...     tech='bp',
...     fuel_bus=my_fuel_bus,
...     heat_bus=my_heat_bus,
...     electricity_bus=my_elec_bus,
...     capacity_cost=50,
...     carrier_cost=0.6,
...     electric_efficiency=0.4,
...     thermal_efficiency=0.35)

build_solph_components()[source]
class oemof.tabular.facades.Commodity(*args, **kwargs)[source]

Bases: oemof.solph.network.Source, oemof.tabular.facades.Facade

Commodity element with one output for example a biomass commodity

Parameters: bus (oemof.solph.Bus) – An oemof bus instance where the unit is connected to with its output amount (numeric) – Total available amount to be used within the complete timehorzion of the problem marginal_cost (numeric) – Marginal cost for one unit used commodity output_paramerters (dict (optional)) – Parameters to set on the output edge of the component (see. oemof.solph Edge/Flow class for possible arguments)
$\sum_{t} x^{flow}(t) \leq c^{amount}$

For constraints set through output_parameters see oemof.solph.Flow class.

Examples

>>> from oemof import solph
>>> my_bus = solph.Bus('my_bus')
>>> my_commodity = Commodity(
...     label='biomass-commodity',
...     bus=my_bus,
...     carrier='biomass',
...     amount=1000,
...     marginal_cost=10,
...     output_parameters={
...         'max': [0.9, 0.5, 0.4]})

build_solph_components()[source]
class oemof.tabular.facades.Conversion(*args, **kwargs)[source]

Bases: oemof.solph.network.Transformer, oemof.tabular.facades.Facade

Conversion unit with one input and one output.

Parameters: from_bus (oemof.solph.Bus) – An oemof bus instance where the conversion unit is connected to with its input. to_bus (oemof.solph.Bus) – An oemof bus instance where the conversion unit is connected to with its output. capacity (numeric) – The conversion capacity (output side) of the unit. efficiency (numeric) – Efficiency of the conversion unit (0 <= efficiency <= 1). Default: 1 marginal_cost (numeric) – Marginal cost for one unit of produced output. Default: 0 carrier_cost (numeric) – Carrier cost for one unit of used input. Default: 0 capacity_cost (numeric) – Investment costs per unit of output capacity. If capacity is not set, this value will be used for optimizing the conversion output capacity. expandable (boolean or numeric (binary)) – True, if capacity can be expanded within optimization. Default: False. capacity_potential (numeric) – Maximum invest capacity in unit of output capacity. input_parameters (dict (optional)) – Set parameters on the input edge of the conversion unit (see oemof.solph for more information on possible parameters) ouput_parameters (dict (optional)) – Set parameters on the output edge of the conversion unit (see oemof.solph for more information on possible parameters)
$x^{flow, from}(t) \cdot c^{efficiency}(t) = x^{flow, to}(t) \qquad \forall t \in T$

Ojective expression for operation includes marginal cost and/or carrier costs:

$x^{opex} = \sum_t (x^{flow, out}(t) \cdot c^{marginal\_cost}(t) + x^{flow, carrier}(t) \cdot c^{carrier\_cost}(t))$

Examples

>>> from oemof import solph
>>> my_biomass_bus = solph.Bus('my_biomass_bus')
>>> my_heat_bus = solph.Bus('my_heat_bus')
>>> my_conversion = Conversion(
...     label='biomass_plant',
...     carrier='biomass',
...     tech='st',
...     from_bus=my_biomass_bus,
...     to_bus=my_heat_bus,
...     capacity=100,
...     efficiency=0.4)

build_solph_components()[source]
class oemof.tabular.facades.Dispatchable(*args, **kwargs)[source]

Bases: oemof.solph.network.Source, oemof.tabular.facades.Facade

Dispatchable element with one output for example a gas-turbine

Parameters: bus (oemof.solph.Bus) – An oemof bus instance where the unit is connected to with its output capacity (numeric) – The installed power of the generator (e.g. in MW). If not set the capacity will be optimized (s. also capacity_cost argument) profile (array-like (optional)) – Profile of the output such that profile[t] * installed capacity yields the upper bound for timestep t marginal_cost (numeric) – Marginal cost for one unit of produced output, i.e. for a powerplant: mc = fuel_cost + co2_cost + … (in Euro / MWh) if timestep length is one hour. Default: 0 capacity_cost (numeric (optional)) – Investment costs per unit of capacity (e.g. Euro / MW) . If capacity is not set, this value will be used for optimizing the generators capacity. expandable (boolean) – True, if capacity can be expanded within optimization. Default: False. output_paramerters (dict (optional)) – Parameters to set on the output edge of the component (see. oemof.solph Edge/Flow class for possible arguments) capacity_potential (numeric) – Max install capacity if capacity is to be expanded

The mathematical representations for this components are dependent on the user defined attributes. If the capacity is fixed before (dispatch mode) the following equation holds:

$x^{flow}(t) \leq c^{capacity} \cdot c^{profile}(t) \ \qquad \forall t \in T$

Where $$x^{flow}$$ denotes the production (endogenous variable) of the dispatchable object to the bus.

If expandable is set to True (investment mode), the equation changes slightly:

$x^{flow}(t) \leq (x^{capacity} + c^{capacity}) \cdot c^{profile}(t) \qquad \forall t \in T$

Where the bounded endogenous variable of the volatile component is added:

$x^{capacity} \leq c^{capacity\_potential}$

Ojective expression for operation:

$x^{opex} = \sum_t x^{flow}(t) \cdot c^{marginal\_cost}(t)$

For constraints set through output_parameters see oemof.solph.Flow class.

Examples

>>> from oemof import solph
>>> my_bus = solph.Bus('my_bus')
>>> my_dispatchable = Dispatchable(
...     label='ccgt',
...     bus=my_bus,
...     carrier='gas',
...     tech='ccgt',
...     capacity=1000,
...     marginal_cost=10,
...     output_parameters={
...         'min': 0.2})

build_solph_components()[source]
class oemof.tabular.facades.Excess(*args, **kwargs)[source]

Bases: oemof.solph.network.Sink, oemof.tabular.facades.Facade

class oemof.tabular.facades.ExtractionTurbine(*args, **kwargs)[source]

Bases: oemof.solph.components.ExtractionTurbineCHP, oemof.tabular.facades.Facade

Combined Heat and Power (extraction) unit with one input and two outputs.

Parameters: electricity_bus (oemof.solph.Bus) – An oemof bus instance where the chp unit is connected to with its electrical output heat_bus (oemof.solph.Bus) – An oemof bus instance where the chp unit is connected to with its thermal output fuel_bus (oemof.solph.Bus) – An oemof bus instance where the chp unit is connected to with its input carrier_cost (numeric) – Cost per unit of used input carrier capacity (numeric) – The electrical capacity of the chp unit (e.g. in MW) in full extraction mode. electric_efficiency – Electrical efficiency of the chp unit in full backpressure mode thermal_efficiency – Thermal efficiency of the chp unit in full backpressure mode condensing_efficiency – Electrical efficiency if turbine operates in full extraction mode marginal_cost (numeric) – Marginal cost for one unit of produced electrical output E.g. for a powerplant: marginal cost =fuel cost + operational cost + co2 cost (in Euro / MWh) if timestep length is one hour. capacity_cost (numeric) – Investment costs per unit of electrical capacity (e.g. Euro / MW) . If capacity is not set, this value will be used for optimizing the chp capacity. expandable (boolean) – True, if capacity can be expanded within optimization. Default: False.

The mathematical description is derived from the oemof base class ExtractionTurbineCHP :

$x^{flow, carrier}(t) = \frac{x^{flow, electricity}(t) + x^{flow, heat}(t) \ \cdot c^{beta}(t)}{c^{condensing\_efficiency}(t)} \qquad \forall t \in T$
$x^{flow, electricity}(t) \geq x^{flow, thermal}(t) \cdot \frac{c^{electrical\_efficiency}(t)}{c^{thermal\_efficiency}(t)} \qquad \forall t \in T$

where $$c^{beta}$$ is defined as:

$c^{beta}(t) = \frac{c^{condensing\_efficiency}(t) - c^{electrical\_efficiency(t)}}{c^{thermal\_efficiency}(t)} \qquad \forall t \in T$

Ojective expression for operation includes marginal cost and/or carrier costs:

$x^{opex} = \sum_t (x^{flow, out}(t) \cdot c^{marginal\_cost}(t) + x^{flow, carrier}(t) \cdot c^{carrier\_cost}(t))$

Examples

>>> from oemof import solph
>>> my_elec_bus = solph.Bus('my_elec_bus')
>>> my_fuel_bus = solph.Bus('my_fuel_bus')
>>> my_heat_bus = solph.Bus('my_heat_bus')
>>> my_extraction = ExtractionTurbine(
...     label='extraction',
...     carrier='gas',
...     tech='ext',
...     electricity_bus=my_elec_bus,
...     heat_bus=my_heat_bus,
...     fuel_bus=my_fuel_bus,
...     capacity=1000,
...     condensing_efficiency=[0.5, 0.51, 0.55],
...     electric_efficiency=0.4,
...     thermal_efficiency=0.35)

build_solph_components()[source]
class oemof.tabular.facades.Facade(*args, **kwargs)[source]

Bases: oemof.network.Node

Parameters: _facade_requires_ (list of str) – A list of required attributes. The constructor checks whether these are present as keywort arguments or whether they are already present on self (which means they have been set by constructors of subclasses) and raises an error if he doesn’t find them.
update()[source]
class oemof.tabular.facades.Generator(*args, **kwargs)[source]

Bases: oemof.solph.custom.Link, oemof.tabular.facades.Facade

Bi-direction link for two buses (e.g. to model transshipment)

Parameters: from_bus (oemof.solph.Bus) – An oemof bus instance where the link unit is connected to with its input. to_bus (oemof.solph.Bus) – An oemof bus instance where the link unit is connected to with its output. capacity (numeric) – The maximal capacity (output side each) of the unit. If not set, attr capacity_cost needs to be set. loss – Relative loss through the link (default: 0) capacity_cost (numeric) – Investment costs per unit of output capacity. If capacity is not set, this value will be used for optimizing the chp capacity. marginal_cost (numeric) – Cost per unit Transport in each timestep. Default: 0 expandable (boolean) – True, if capacity can be expanded within optimization. Default: False.

Note

Assigning a small value like 0.00001 to marginal_cost may force unique solution of optimization problem.

Examples

>>> from oemof import solph
>>> my_elec_bus_1 = solph.Bus('my_elec_bus_1')
>>> my_elec_bus_2 = solph.Bus('my_elec_bus_2')
...     carrier='electricity',
...     from_bus=my_elec_bus_1,
...     to_bus=my_elec_bus_2,
...     capacity=100,
...     loss=0.04)

build_solph_components()[source]
class oemof.tabular.facades.Load(*args, **kwargs)[source]

Bases: oemof.solph.network.Sink, oemof.tabular.facades.Facade

Parameters: bus (oemof.solph.Bus) – An oemof bus instance where the demand is connected to. amount (numeric) – The total amount for the timehorzion (e.g. in MWh) profile (array-like) – Load profile with normed values such that profile[t] * amount yields the load in timestep t (e.g. in MWh) marginal_utility (numeric) – Marginal utility in for example Euro / MWh fixed (boolean) – True, if demand should be inelastic (Default: True) input_parameters (dict (optional))
$x^{flow}(t) = c^{amount}(t) \cdot x^{flow}(t) \qquad \forall t \in T$

Examples

>>> from oemof import solph
>>> my_bus = solph.Bus('my_bus')
...     carrier='electricity',
...     bus=my_bus,
...     amount=100,
...     profile=[0.3, 0.2, 0.5])

build_solph_components()[source]
class oemof.tabular.facades.Reservoir(*args, **kwargs)[source]

Bases: oemof.solph.components.GenericStorage, oemof.tabular.facades.Facade

A Reservoir storage unit, that is initially half full.

Note that the investment option is not available for this facade at the current development state.

Parameters: bus (oemof.solph.Bus) – An oemof bus instance where the storage unit is connected to. storage_capacity (numeric) – The total storage capacity of the storage (e.g. in MWh) capacity (numeric) – Installed production capacity of the turbine installed at the reservoir efficiency (numeric) – Efficiency of the turbine converting inflow to electricity production, default: 1 profile (array-like) – Absolute inflow profile of inflow into the storage input_parameters (dict) – Dictionary to specifiy parameters on the input edge. You can use all keys that are available for the oemof.solph.network.Flow class. output_parameters (dict) – see: input_parameters

The reservoir is modelled as a storage with a constant inflow:

$x^{level}(t) = x^{level}(t-1) \cdot (1 - c^{loss\_rate}(t)) + x^{profile}(t) - \frac{x^{flow, out}(t)}{c^{efficiency}(t)} \qquad \forall t \in T$
$x^{level}(0) = 0.5 \cdot c^{capacity}$

The inflow is bounded by the exogenous inflow profile. Thus if the inflow exceeds the maximum capacity of the storage, spillage is possible by setting $$x^{profile}(t)$$ to lower values.

$0 \leq x^{profile}(t) \leq c^{profile}(t) \qquad \forall t \in T$

The spillage of the reservoir is therefore defined by: $$c^{profile}(t) - x^{profile}(t)$$.

Note

As the Reservoir is a sub-class of oemof.solph.GenericStorage you also pass all arguments of this class.

Examples

Basic usage examples of the GenericStorage with a random selection of attributes. See the Flow class for all Flow attributes.

>>> from oemof import solph
>>> my_bus = solph.Bus('my_bus')
>>> my_reservoir = Reservoir(
...     label='my_reservoir',
...     bus=my_bus,
...     carrier='water',
...     tech='reservoir',
...     storage_capacity=1000,
...     capacity=50,
...     profile=[1, 2, 6],
...     loss_rate=0.01,
...     initial_storage_level=0,
...     max_storage_level = 0.9,
...     efficiency=0.93)

build_solph_components()[source]
class oemof.tabular.facades.Shortage(*args, **kwargs)[source]
class oemof.tabular.facades.Storage(*args, **kwargs)[source]

Bases: oemof.solph.components.GenericStorage, oemof.tabular.facades.Facade

Storage unit

Parameters: bus (oemof.solph.Bus) – An oemof bus instance where the storage unit is connected to. storage_capacity (numeric) – The total capacity of the storage (e.g. in MWh) capacity (numeric) – Maximum production capacity (e.g. in MW) efficiency (numeric) – Efficiency of charging and discharging process: Default: 1 storage_capacity_cost (numeric) – Investment costs for the storage unit e.g in €/MWh-capacity expandable (boolean) – True, if capacity can be expanded within optimization. Default: False. storage_capacity_potential (numeric) – Potential of the investment for storage capacity in MWh capacity_potential (numeric) – Potential of the investment for capacity in MW input_parameters (dict (optional)) – Set parameters on the input edge of the storage (see oemof.solph for more information on possible parameters) ouput_parameters (dict (optional)) – Set parameters on the output edge of the storage (see oemof.solph for more information on possible parameters)

Intertemporal energy balance of the storage:

$x^{level}(t) = x^{level}(t-1) \cdot (1 - c^{loss\_rate}) + \sqrt{c^{efficiency}(t)} x^{flow, in}(t) - \frac{x^{flow, out}(t)}{\sqrt{c^{efficiency}(t)}} \qquad \forall t \in T$
$x^{level}(0) = 0.5 \cdot c^{capacity}$

The expression added to the cost minimizing objective funtion for the operation is given as:

$x^{opex} = \sum_t (x^{flow, out}(t) \cdot c^{marginal\_cost}(t))$

Examples

>>> import pandas as pd
>>> from oemof import solph
>>> from oemof.tabular import facades as fc
>>> my_bus = solph.Bus('my_bus')
>>> es = solph.EnergySystem(
...    timeindex=pd.date_range('2019', periods=3, freq='H'))
...    fc.Storage(
...        label="storage",
...        bus=my_bus,
...        carrier="lithium",
...        tech="battery",
...        storage_capacity_cost=10,
...        invest_relation_output_capacity=1/6, # oemof.solph
...        marginal_cost=5,
...        balanced=True, # oemof.solph argument
...        initial_storage_level=1, # oemof.solph argument
...        max_storage_level=[0.9, 0.95, 0.8])) # oemof.solph argument

build_solph_components()[source]
class oemof.tabular.facades.Volatile(*args, **kwargs)[source]

Bases: oemof.solph.network.Source, oemof.tabular.facades.Facade

Volatile element with one output. This class can be used to model PV oder Wind power plants.

Parameters: bus (oemof.solph.Bus) – An oemof bus instance where the generator is connected to capacity (numeric) – The installed power of the unit (e.g. in MW). profile (array-like) – Profile of the output such that profile[t] * capacity yields output for timestep t marginal_cost (numeric) – Marginal cost for one unit of produced output, i.e. for a powerplant: mc = fuel_cost + co2_cost + … (in Euro / MWh) if timestep length is one hour. capacity_cost (numeric (optional)) – Investment costs per unit of capacity (e.g. Euro / MW) . If capacity is not set, this value will be used for optimizing the generators capacity. output_paramerters (dict (optional)) – Parameters to set on the output edge of the component (see. oemof.solph Edge/Flow class for possible arguments) capacity_potential (numeric) – Max install capacity if investment expandable (boolean) – True, if capacity can be expanded within optimization. Default: False. fixed (boolean) – If False, the output may be curtailed when optimizing dispatch. Default: True

The mathematical representations for this components are dependent on the user defined attributes. If the capacity is fixed before (dispatch mode) the following equation holds:

$x^{flow}(t) = c^{capacity} \cdot c^{profile}(t) \qquad \forall t \in T$

Where $$x_{volatile}^{flow}$$ denotes the production (endogenous variable) of the volatile object to the bus.

If expandable is set to True (investment mode), the equation changes slightly:

$x^{flow}(t) = (x^{capacity} + c^{capacity}) \ \cdot c^{profile}(t) \qquad \forall t \in T$

Where the bounded endogenous variable of the volatile component is added:

$x_{volatile}^{capacity} \leq c_{volatile}^{capacity\_potential}$

Ojective expression for operation:

$x^{opex} = \sum_t (x^{flow}(t) \cdot c^{marginal\_cost}(t))$

Examples

>>> from oemof import solph

build_solph_components()[source]
oemof.tabular.facades.add_subnodes(n, **kwargs)[source]