oemof.solph package¶
Submodules¶
oemof.solph.blocks module¶
Creating sets, variables, constraints and parts of the objective function for the specified groups.

class
oemof.solph.blocks.
BinaryFlow
(*args, **kwargs)[source]¶ Bases:
pyomo.core.base.block.SimpleBlock
The following sets are created: (> see basic sets at
OperationalModel
) BINARY_FLOWS
 A set of flows with the attribute
binary
of typeoptions.Binary
.  MIN_FLOWS
 A subset of set BINARY_FLOWS with the attribute
min
greater than zero for at least one timestep in the simulation horizon.  STARTUP_FLOWS
 A subset of set BINARY_FLOWS with the attribute
startup_costs
being not None.  SHUTDOWN_FLOWS
 A subset of set BINARY_FLOWS with the attribute
shutdown_costs
being not None.
The following variable are created:
 Status variable (binary)
om.BinaryFLow.status
:  Variable indicating if flow is >= 0 indexed by FLOWS
 Startup variable (binary)
om.BinaryFlow.startup
:  Variable indicating startup of flow (component) indexed by STARTUP_FLOWS
 Shutdown variable (binary)
om.BinaryFlow.shutdown
:  Variable indicating shutdown of flow (component) indexed by SHUTDOWN_FLOWS
The following constraints are created:
 Minimum flow constraint
om.BinaryFlow.min[i,o,t]
 Maximum flow constraint
om.BinaryFlow.max[i,o,t]
 Startup constraint
om.BinaryFlow.startup_constr[i,o,t]
 Shutdown constraint
om.BinaryFlow.shutdown_constr[i,o,t]
The following parts of the objective function are created:
 If
binary.startup_costs
is set by the user:  If
binary.shutdown_costs
is set by the user:

class
oemof.solph.blocks.
Bus
(*args, **kwargs)[source]¶ Bases:
pyomo.core.base.block.SimpleBlock
Block for all balanced buses.
The following constraints are build:
 Bus balance
om.Bus.balance[i, o, t]
 Bus balance

class
oemof.solph.blocks.
DiscreteFlow
(*args, **kwargs)[source]¶ Bases:
pyomo.core.base.block.SimpleBlock
The following sets are created: (> see basic sets at
OperationalModel
) DISCRETE_FLOWS
 A set of flows with the attribute
discrete
of typeoptions.Discrete
.

class
oemof.solph.blocks.
Flow
(*args, **kwargs)[source]¶ Bases:
pyomo.core.base.block.SimpleBlock
Flow block with definitions for standard flows.
The following sets are created: (> see basic sets at
OperationalModel
) SUMMED_MAX_FLOWS
 A set of flows with the attribute
summed_max
being not None.  SUMMED_MIN_FLOWS
 A set of flows with the attribute
summed_min
being not None.  NEGATIVE_GRADIENT_FLOWS
 A set of flows with the attribute
negative_gradient
being not None.  POSITIVE_GRADIENT_FLOWS
 A set of flows with the attribute
positive_gradient
being not None
The following constraints are build:
 Flow max sum
om.Flow.summed_max[i, o]
 Flow min sum
om.Flow.summed_min[i, o]
 Negative gradient constraint
om.Flow.negative_gradient_constr[i, o]
:  Positive gradient constraint
om.Flow.positive_gradient_constr[i, o]
:
The following parts of the objective function are created:
 If
variable_costs
are set by the user:  Additionally, if
fixed_costs
are set by the user:
The expression can be accessed by
om.Flow.fixed_costs
and their value after optimization byom.Flow.fixed_costs()
. This works similar for variable costs with*.variable_costs
.

class
oemof.solph.blocks.
InvestmentFlow
(*args, **kwargs)[source]¶ Bases:
pyomo.core.base.block.SimpleBlock
Block for all flows with
investment
being not None.The following sets are created: (> see basic sets at
OperationalModel
) FLOWS
 A set of flows with the attribute
invest
of typeoptions.Investment
.  FIXED_FLOWS
 A set of flow with the attribute
fixed
set to True  SUMMED_MAX_FLOWS
 A subset of set FLOWS with flows with the attribute
summed_max
being not None.  SUMMED_MIN_FLOWS
 A subset of set FLOWS with flows with the attribute
summed_min
being not None.  MIN_FLOWS
 A subset of FLOWS with flows having set a least minimum value for at least one timestep in the optimization model.
The following variables are created:
 invest
om.InvestmentFlow.invest[i, o]
 Value of the investment variable (i.e. equivalent to the nominal value of the flows after optimization (indexed by FLOWS)
The following constraints are build:
 Actual value constraint for fixed invest flows
om.InvestmentFlow.fixed[i, o, t]
 Lower bound (min) constraint for invest flows
om.InvestmentFlow.min[i, o, t]
 Upper bound (max) constraint for invest flows
om.InvestmentFlow.max[i, o, t]
 Flow max sum for invest flow
om.InvestmentFlow.summed_max[i, o]
 Flow min sum for invest flow
om.InvestmentFlow.summed_min[i, o]
The following parts of the objective function are created:
 Equivalent periodical costs (epc) expression
om.InvestmentFlow.investment_costs
:  Additionally, if
fixed_costs
are set by the user:
The expression can be accessed by
om.InvestmentFlow.fixed_costs
and their value after optimization byom.InvestmentFlow.fixed_costs()
. This works similar for variable costs with*.variable_costs
etc.

class
oemof.solph.blocks.
InvestmentStorage
(*args, **kwargs)[source]¶ Bases:
pyomo.core.base.block.SimpleBlock
Storage with an
Investment
object.The following sets are created: (> see basic sets at
OperationalModel
) INVESTSTORAGES
 A set with all storages containing an Investment object.
 INITIAL_CAPACITY
 A subset of the set INVESTSTORAGES where elements of the set have an initial_capacity attribute.
 MIN_INVESTSTORAGES
 A subset of INVESTSTORAGES where elements of the set have an capacity_min attribute greater than zero for at least one time step.
The following variables are created:
 capacity
om.InvestmentStorage.capacity[n, t]
 Level of the storage (indexed by STORAGES and TIMESTEPS)
 invest
om.InvestmentStorage.invest[n, t]
 Nominal capacity of the storage (indexed by STORAGES)
The following constraints are build:
 Storage balance
 Initial capacity of
network.Storage
 Connect the invest variables of the storage and the input flow.
 Connect the invest variables of the storage and the output flow.
 Maximal capacity
om.InvestmentStorage.max_capacity[n, t]
 Minimal capacity
om.InvestmentStorage.min_capacity[n, t]
The following parts of the objective function are created:
 Equivalent periodical costs (investment costs):
 Additionally, if fixed costs are set by the user:
The expression can be accessed by
om.InvestStorages.fixed_costs
and their value after optimization byom.InvestStorages.fixed_costs()
. This works similar for investment costs with*.investment_costs
.

class
oemof.solph.blocks.
LinearN1Transformer
(*args, **kwargs)[source]¶ Bases:
pyomo.core.base.block.SimpleBlock
Block for the linear relation of nodes with type class:.LinearN1Transformer
The following constraints are created:
 Linear relation
om.LinearN1Transformer.relation[i,o,t]
 Linear relation

class
oemof.solph.blocks.
LinearTransformer
(*args, **kwargs)[source]¶ Bases:
pyomo.core.base.block.SimpleBlock
Block for the linear relation of nodes with type class:.LinearTransformer
The following sets are created: (> see basic sets at
OperationalModel
) LINEAR_TRANSFORMERS
 A set with all
LinearTransformer
objects.
The following constraints are created:
 Linear relation
om.LinearTransformer.relation[i,o,t]

class
oemof.solph.blocks.
Storage
(*args, **kwargs)[source]¶ Bases:
pyomo.core.base.block.SimpleBlock
Storages (no investment)
The following sets are created: (> see basic sets at
OperationalModel
) STORAGES
 A set with all
Storage
objects (and no attr:investement of typeInvestment
)
The following variables are created:
 capacity
 Capacity (level) for every storage and timestep. The value for the capacity at the beginning is set by the parameter initial_capacity or not set if initial_capacity is None. The variable of storage s and timestep t can be accessed by: om.Storage.capacity[s, t]
The following constraints are created:
 Storage balance
om.Storage.balance[n, t]
The following parts of the objective function are created:
 If
fixed_costs
is set by the user:
The fixed costs expression can be accessed by om.Storage.fixed_costs and their value after optimization by: om.Storage.fixed_costs().

class
oemof.solph.blocks.
VariableFractionTransformer
(*args, **kwargs)[source]¶ Bases:
pyomo.core.base.block.SimpleBlock
Block for the linear relation of nodes with type
VariableFractionTransformer
The following sets are created: (> see basic sets at
OperationalModel
) VARIABLE_FRACTION_TRANSFORMERS
 A set with all
VariableFractionTransformer
objects.
The following constraints are created:
 Variable i/o relation
om.VariableFractionTransformer.relation[i,o,t]
 Out flow relation
om.VariableFractionTransformer.relation[i,o,t]
oemof.solph.groupings module¶
list: Groupings needed on an energy system for it to work with solph.
 TODO: Maybe move this to the module docstring? It should be somewhere prominent
 so solph user’s immediately see that they need to use
GROUPINGS
when they want to create an energy system for use with solph.
If you want to use solph on an energy system, you need to create it with these groupings specified like this:
from oemof.network import EnergySystem import solph
energy_system = EnergySystem(groupings=solph.GROUPINGS)

oemof.solph.groupings.
constraint_grouping
(node)[source]¶ Grouping function for constraints.
This function can be passed in a list to
groupings
ofoemof.solph.network.EnergySystem
.
oemof.solph.models module¶

class
oemof.solph.models.
ExpansionModel
[source]¶ Bases:
pyomo.core.base.PyomoModel.ConcreteModel
An energy system model for optimized capacity expansion.

class
oemof.solph.models.
OperationalModel
(es, **kwargs)[source]¶ Bases:
pyomo.core.base.PyomoModel.ConcreteModel
An energy system model for operational simulation with optimized dispatch.
Parameters:  es (EnergySystem object) – Object that holds the nodes of an oemof energy system graph
 constraint_groups (list) – Solph looks for these groups in the given energy system and uses them
to create the constraints of the optimization problem.
Defaults to
OperationalModel.CONSTRAINTS
 timeindex (pandas DatetimeIndex) – The time index will be used to calculate the timesteps and the time increment for the optimization model.
 timesteps (sequence (optional)) – Timesteps used in the optimization model. If provided as list or pandas.DatetimeIndex the sequence will be used to index the time dependent variables, constraints etc. If not provided we will try to compute this sequence from attr:timeindex.
 timeincrement (float or list of floats (optional)) – Time increment used in constraints and objective expressions. If type is ‘float’, will be converted internally to solph.plumbing.Sequence() object for time dependent time increment. If a list is provided this list will be taken. Default is calculated from timeindex if provided.
 following sets are created (**The) –
 NODES – A set with all nodes of the given energy system.
 TIMESTEPS – A set with all timesteps of the given time horizon.
 FLOWS – A 2 dimensional set with all flows. Index: (source, target)
 NEGATIVE_GRADIENT_FLOWS – A subset of set FLOWS with all flows where attribute negative_gradient is set.
 POSITIVE_GRADIENT_FLOWS – A subset of set FLOWS with all flows where attribute positive_gradient is set.
 following variables are created (**The) –
 flow – Flow from source to target indexed by FLOWS, TIMESTEPS. Note: Bounds of this variable are set depending on attributes of the corresponding flow object.
 negative_flow_gradient – Difference of a flow in consecutive timesteps if flow is reduced indexed by NEGATIVE_GRADIENT_FLOWS, TIMESTEPS.
 positive_flow_gradient – Difference of a flow in consecutive timesteps if flow is increased indexed by NEGATIVE_GRADIENT_FLOWS, TIMESTEPS.

CONSTRAINT_GROUPS
= [<class 'oemof.solph.blocks.Bus'>, <class 'oemof.solph.blocks.LinearTransformer'>, <class 'oemof.solph.blocks.LinearN1Transformer'>, <class 'oemof.solph.blocks.VariableFractionTransformer'>, <class 'oemof.solph.blocks.Storage'>, <class 'oemof.solph.blocks.InvestmentFlow'>, <class 'oemof.solph.blocks.InvestmentStorage'>, <class 'oemof.solph.blocks.Flow'>, <class 'oemof.solph.blocks.BinaryFlow'>, <class 'oemof.solph.blocks.DiscreteFlow'>]¶

receive_duals
()[source]¶ Method sets solver suffix to extract information about dual variables from solver. Shadow prices (duals) and reduced costs (rc) are set as attributes of the model.

results
()[source]¶ Returns a nested dictionary of the results of this optimization model.
The dictionary is keyed by the
Entities
of the optimization model, that isom.results()[s][t]
holds the time series representing values attached to the edge (i.e. the flow) from s to t, where s and t are instances ofEntity
.Time series belonging only to one object, like e.g. shadow prices of commodities on a certain
Bus
, dispatch values of aDispatchSource
or storage values of aStorage
are treated as belonging to an edge looping from the object to itself. This means they can be accessed viaom.results()[object][object]
.Other result from the optimization model can be accessed like attributes of the flow, e.g. the invest variable for capacity of the storage ‘stor’ can be accessed like:
om.results()[stor][stor].invest
attributeFor the investment flow of a ‘transformer’ trsf to the bus ‘bel’ this can be accessed with:
om.results()[trsf][bel].invest
attributeThe value of the objective function is stored under the
om.results().objective
attribute.Note that the optimization model has to be solved prior to invoking this method.

solve
(solver='glpk', solver_io='lp', **kwargs)[source]¶ Takes care of communication with solver to solve the model.
Parameters:  solver (string) – solver to be used e.g. “glpk”,”gurobi”,”cplex”
 solver_io (string) – pyomo solver interface file format: “lp”,”python”,”nl”, etc.
 **kwargs (keyword arguments) – Possible keys can be set see below:
Other Parameters:  solve_kwargs (dict) – Other arguments for the pyomo.opt.SolverFactory.solve() method Example : {“tee”:True}
 cmdline_options (dict) – Dictionary with command line options for solver e.g. {“mipgap”:”0.01”} results in “–mipgap 0.01” {“interior”:” “} results in “–interior” Gurobi solver takes numeric parameter values such as {“method”: 2}
oemof.solph.network module¶

class
oemof.solph.network.
Bus
(*args, **kwargs)[source]¶ Bases:
oemof.network.Bus
A balance object. Every node has to be connected to Bus.
Notes
 The following sets, variables, constraints and objective parts are created

class
oemof.solph.network.
EnergySystem
(**kwargs)[source]¶ Bases:
oemof.energy_system.EnergySystem
A variant of
EnergySystem
specially tailored to solph.In order to work in tandem with solph, instances of this class always use
solph.GROUPINGS
. If custom groupings are supplied via the groupings keyword argument,solph.GROUPINGS
is prepended to those.If you know what you are doing and want to use solph without
solph.GROUPINGS
, you can just usecore's EnergySystem
directly.

class
oemof.solph.network.
Flow
(**kwargs)[source]¶ Bases:
object
Define a flow between two nodes. Note: Some attributes can only take numeric scalar as some may either take scalar or sequences (arraylike). If for latter a scalar is passed, this will be internally converted to a sequence.
Parameters:  nominal_value (numeric) – The nominal value of the flow. If this value is set the corresponding optimization variable of the flow object will be bounded by this value multiplied with min(lower bound)/max(upper bound).
 min (numeric (sequence or scalar)) – Normed minimum value of the flow. The flow absolute maximum will be
calculated by multiplying
nominal_value
withmin
 max (numeric (sequence or scalar)) – Nominal maximum value of the flow. (see.
min
)  actual_value (numeric (sequence or scalar)) – Specific value for the flow variable. Will be multiplied with the
nominal_value to get the absolute value. If fixed attr is set to True
the flow variable will be fixed to actual_value *
nominal_value
, I.e. this value is set exogenous.  positive_gradient (numeric (sequence or scalar)) – The normed maximal positive difference (flow[t1] < flow[t]) of two consecutive flow values.
 negative_gradient (numeric (sequence or scalar)) – The normed maximum negative difference (from[t1] > flow[t]) of two consecutive timesteps.
 summed_max (numeric) – Specific maximum value summed over all timesteps. Will be multiplied with the nominal_value to get the absolute limit.
 summed_min (numeric) – see above
 variable_costs (numeric (sequence or scalar)) – The costs associated with one unit of the flow. If this is set the costs will be added to the objective expression of the optimization problem.
 fixed_costs (numeric) – The costs of the whole period associated with the absolute nominal_value of the flow.
 fixed (boolean) – Boolean value indicating if a flow is fixed during the optimization
problem to its exante set value. Used in combination with the
actual_value
.  investment (
oemof.solph.options.Investment
object) – Object indicating if a nominal_value of the flow is determined by the optimization problem. Note: This will refer all attributes to an investment variable instead of to the nominal_value. The nominal_value should not be set (or set to None) if an investment object is used.  binary (
oemof.solph.options.BinaryFlow
object) – If an binary flow object is added here, the flow constraints will be altered significantly as the mathematical model for the flow will be different, i.e. constraint etc fromoemof.solph.blocks.BinaryFlow
will be used instead ofoemof.solph.blocks.Flow
. Note: this does not work in combination with the investment attribute set at the moment.
Notes
 The following sets, variables, constraints and objective parts are created
Flow
InvestmentFlow
(additionally if Investment object is present)BinaryFlow
(If binary object is present, CAUTION: replaces
Flow
class)
Examples
Creating a fixed flow object:
>>> f = Flow(actual_value=[10, 4, 4], fixed=True, variable_costs=5) >>> f.variable_costs[2] 5 >>> f.actual_value[2] 4
Creating a flow object with timedepended lower and upper bounds:
>>> f1 = Flow(min=[0.2, 0.3], max=0.99, nominal_value=100) >>> f1.max[1] 0.99

class
oemof.solph.network.
LinearN1Transformer
(*args, **kwargs)[source]¶ Bases:
oemof.network.Transformer
A Linear N:1 Transformer object.
Parameters: conversion_factors (dict) – Dictionary containing conversion factors for conversion of inflow(s) to specified outflow. Keys are output bus objects. The dictionary values can either be a scalar or a sequence with length of time horizon for simulation. Examples
Defining an linear transformer:
>>> gas = Bus() >>> biomass = Bus() >>> trsf = LinearN1Transformer(conversion_factors={gas: 0.4, ... biomass: [1, 2, 3]}) >>> trsf.conversion_factors[gas][3] 0.4
Notes
 The following sets, variables, constraints and objective parts are created

class
oemof.solph.network.
LinearTransformer
(*args, **kwargs)[source]¶ Bases:
oemof.network.Transformer
A Linear Transformer object.
Parameters: conversion_factors (dict) – Dictionary containing conversion factors for conversion of inflow to specified outflow. Keys are output bus objects. The dictionary values can either be a scalar or a sequence with length of time horizon for simulation. Examples
Defining an linear transformer:
>>> bel = Bus() >>> bth = Bus() >>> bng = Bus() >>> trsf = LinearTransformer(conversion_factors={bel: 0.4, ... bth: [1, 2, 3]}, ... inputs={bng: Flow()}) >>> trsf.conversion_factors[bel][3] 0.4
Notes
 The following sets, variables, constraints and objective parts are created

class
oemof.solph.network.
Sink
(*args, **kwargs)[source]¶ Bases:
oemof.network.Sink
An object with one input flow.

class
oemof.solph.network.
Source
(*args, **kwargs)[source]¶ Bases:
oemof.network.Source
An object with one output flow.

class
oemof.solph.network.
Storage
(*args, **kwargs)[source]¶ Bases:
oemof.network.Transformer
Parameters:  nominal_capacity (numeric) – Absolute nominal capacity of the storage
 nominal_input_capacity_ratio (numeric) – Ratio between the nominal inflow of the storage and its capacity.
 nominal_output_capacity_ratio (numeric) – Ratio between the nominal outflow of the storage and its capacity. Note: This ratio is used to create the Flow object for the outflow and set its nominal value of the storage in the constructor.
 nominal_input_capacity_ratio – see: nominal_output_capacity_ratio
 initial_capacity (numeric) – The capacity of the storage in the first (and last) time step of optimization.
 capacity_loss (numeric (sequence or scalar)) – The relative loss of the storage capacity from between two consecutive timesteps.
 inflow_conversion_factor (numeric (sequence or scalar)) – The relative conversion factor, i.e. efficiency associated with the inflow of the storage.
 outflow_conversion_factor (numeric (sequence or scalar)) – see: inflow_conversion_factor
 capacity_min (numeric (sequence or scalar)) – The nominal minimum capacity of the storage as fraction of the nominal capacity (between 0 and 1, default: 0). To set different values in every time step use a sequence.
 capacity_max (numeric (sequence or scalar)) – see: capacity_min
 investment (
oemof.solph.options.Investment
object) – Object indicating if a nominal_value of the flow is determined by the optimization problem. Note: This will refer all attributes to an investment variable instead of to the nominal_capacity. The nominal_capacity should not be set (or set to None) if an investment object is used.
Notes
 The following sets, variables, constraints and objective parts are created
Storage
(if no Investment object present)InvestmentStorage
(if Investment object present)

class
oemof.solph.network.
VariableFractionTransformer
(conversion_factor_single_flow, *args, **kwargs)[source]¶ Bases:
oemof.solph.network.LinearTransformer
A linear transformer with more than one output, where the fraction of the output flows is variable. By now it is restricted to two output flows.
One main output flow has to be defined and is tapped by the remaining flow. Thus, the main output will be reduced if the tapped output increases. Therefore a loss index has to be defined. Furthermore a maximum efficiency has to be specified if the whole flow is led to the main output (tapped_output = 0). The state with the maximum tapped_output is described through conversion factors equivalent to the LinearTransformer.
Parameters:  conversion_factors (dict) – Dictionary containing conversion factors for conversion of inflow to specified outflow. Keys are output bus objects. The dictionary values can either be a scalar or a sequence with length of time horizon for simulation.
 conversion_factor_single_flow (dict) – The efficiency of the main flow if there is no tapped flow. Only one key is allowed. Use one of the keys of the conversion factors. The key indicates the main flow. The other output flow is the tapped flow.
Examples
>>> bel = Bus(label='electricityBus') >>> bth = Bus(label='heatBus') >>> bgas = Bus(label='commodityBus') >>> vft = VariableFractionTransformer( ... label='variable_chp_gas', ... inputs={bgas: Flow(nominal_value=10e10)}, ... outputs={bel: Flow(), bth: Flow()}, ... conversion_factors={bel: 0.3, bth: 0.5}, ... conversion_factor_single_flow={bel: 0.5})
Notes
 The following sets, variables, constraints and objective parts are created
oemof.solph.options module¶
Optional classes to be added to a network class.

class
oemof.solph.options.
BinaryFlow
(**kwargs)[source]¶ Bases:
object
Parameters:  startup_costs (numeric) – Costs associated with a start of the flow (representing a unit).
 shutdown_costs (numeric) – Costs associated with the shutdown of the flow (representing a until).
 minimum_uptime (numeric) – Minimum time that a flow must be greater then its minimum flow after startup.
 minimum_downtime (numeric) – Minimum time a flow is forced to zero after shutting down.
 initial_status (numeric (0 or 1)) – Integer value indicating the status of the flow in the first time step (0 = off, 1 = on).

class
oemof.solph.options.
DiscreteFlow
(**kwargs)[source]¶ Bases:
object
Parameters: integers (boolean) – Specify domain of flow variable: If True, flow is forced to integer values.

class
oemof.solph.options.
Investment
(maximum=inf, minimum=0, ep_costs=0)[source]¶ Bases:
object
Parameters:  maximum (float) – Maximum of the additional invested capacity
 minimum (float) – Minimum of the addtional invested capacity
 ep_costs (float) – Equivalent periodical costs for the investment, if period is one year these costs are equal to the equivalent annual costs.
oemof.solph.plumbing module¶

oemof.solph.plumbing.
sequence
(sequence_or_scalar)[source]¶ Tests if an object is sequence (except string) or scalar and returns a the original sequence if object is a sequence and a ‘emulated’ sequence object of class _Sequence if object is a scalar or string.
Parameters: sequence_or_scalar (arraylike, None, int, float) – Examples
>>> sequence([1,2]) [1, 2]
>>> x = sequence(10) >>> x[0] 10
>>> x[10] 10 >>> print(x) [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]