oemof.tabular package

Submodules

oemof.tabular.facades module

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

More specifically, the Facade`s 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

SPDX-License-Identifier: BSD-3-Clause

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
>>> from oemof.tabular import facades
>>> 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
>>> from oemof.tabular import facades
>>> 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
>>> from oemof.tabular import facades
>>> 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
>>> from oemof.tabular import facades
>>> 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
>>> from oemof.tabular import facades
>>> 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.tabular.facades.Dispatchable

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
>>> from oemof.tabular import facades
>>> my_elec_bus_1 = solph.Bus('my_elec_bus_1')
>>> my_elec_bus_2 = solph.Bus('my_elec_bus_2')
>>> my_loadink = Link(
...     label='link',
...     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

Load object with one input

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
>>> from oemof.tabular import facades
>>> my_bus = solph.Bus('my_bus')
>>> my_load = Load(
...     label='load',
...     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
>>> from oemof.tabular import facades
>>> 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]

Bases: oemof.tabular.facades.Dispatchable

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'))
>>> es.add(my_bus)
>>> es.add(
...    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
>>> from oemof.tabular import facades
>>> my_bus = solph.Bus('my_bus')
>>> my_volatile = Volatile(
...     label='wind',
...     bus=my_bus,
...     carrier='wind',
...     tech='onshore',
...     capacity_cost=150,
...     profile=[0.25, 0.1, 0.3])
build_solph_components()[source]
oemof.tabular.facades.add_subnodes(n, **kwargs)[source]