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 type options.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]

flow(i, o, t) \geq min(i, o, t) \cdot nominal\_value                 \cdot status(i, o, t), \\
\forall t \in \textrm{TIMESTEPS}, \\
\forall (i, o) \in \textrm{BINARY\_FLOWS}.

Maximum flow constraint om.BinaryFlow.max[i,o,t]

flow(i, o, t) \leq max(i, o, t) \cdot nominal\_value                 \cdot status(i, o, t), \\
\forall t \in \textrm{TIMESTEPS}, \\
\forall (i, o) \in \textrm{BINARY\_FLOWS}.

Startup constraint om.BinaryFlow.startup_constr[i,o,t]

startup(i, o, t) \geq                 status(i,o,t) - status(i, o, t-1) \\
\forall t \in \textrm{TIMESTEPS}, \\
\forall (i,o) \in \textrm{STARTUP\_FLOWS}.

Shutdown constraint om.BinaryFlow.shutdown_constr[i,o,t]

shutdown(i, o, t) \geq                 status(i, o, t-1) - status(i, o, t) \\
\forall t \in \textrm{TIMESTEPS}, \\
\forall (i, o) \in \textrm{SHUTDOWN\_FLOWS}.

The following parts of the objective function are created:

If binary.startup_costs is set by the user:

\sum_{i, o \in STARTUP\_FLOWS} \sum_t  startup(i, o, t)             \cdot startup\_costs(i, o)

If binary.shutdown_costs is set by the user:

\sum_{i, o \in SHUTDOWN\_FLOWS} \sum_t shutdown(i, o, t)                 \cdot shutdown\_costs(i, o)

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]

\sum_{i \in INPUTS(n)} flow(i, n, t) \cdot \tau =          \sum_{o \in OUTPUTS(n)} flow(n, o, t) \cdot \tau, \\
\forall n \in \textrm{BUSES},
\forall t \in \textrm{TIMESTEPS}.

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 type options.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]

\sum_t flow(i, o, t) \cdot \tau \leq summed\_max(i, o), \\
\forall (i, o) \in \textrm{SUMMED\_MAX\_FLOWS}.

Flow min sum om.Flow.summed_min[i, o]

\sum_t flow(i, o, t) \cdot \tau \geq summed\_min(i, o), \\
\forall (i, o) \in \textrm{SUMMED\_MIN\_FLOWS}.

Negative gradient constraint om.Flow.negative_gradient_constr[i, o]:

flow(i, o, t-1) - flow(i, o, t) \geq         negative\_flow\_gradient(i, o, t), \\
\forall (i, o) \in \textrm{NEGATIVE\_GRADIENT\_FLOWS}, \\
\forall t \in \textrm{TIMESTEPS}.

Positive gradient constraint om.Flow.positive_gradient_constr[i, o]:

flow(i, o, t) - flow(i, o, t-1) \geq             positive\_flow\_gradient(i, o, t), \\
\forall (i, o) \in \textrm{POSITIVE\_GRADIENT\_FLOWS}, \\
\forall t \in \textrm{TIMESTEPS}.

The following parts of the objective function are created:

If variable_costs are set by the user:

\sum_{(i,o)} \sum_t flow(i, o, t) \cdot variable\_costs(i, o, t)

Additionally, if fixed_costs are set by the user:

\sum_{(i, o)}  nominal\_value(i, o) \cdot fixed\_costs(i, o)

The expression can be accessed by om.Flow.fixed_costs and their value after optimization by om.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 type options.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]

flow(i, o, t) = actual\_value(i, o, t) \cdot invest(i, o), \\
\forall (i, o) \in \textrm{FIXED\_FLOWS}, \\
\forall t \in \textrm{TIMESTEPS}.

Lower bound (min) constraint for invest flows om.InvestmentFlow.min[i, o, t]

flow(i, o, t) \geq min(i, o, t) \cdot invest(i, o), \\
\forall (i, o) \in \textrm{MIN\_FLOWS}, \\
\forall t \in \textrm{TIMESTEPS}.

Upper bound (max) constraint for invest flows om.InvestmentFlow.max[i, o, t]

flow(i, o, t) \leq max(i, o, t) \cdot invest(i, o), \\
\forall (i, o) \in \textrm{FLOWS}, \\
\forall t \in \textrm{TIMESTEPS}.

Flow max sum for invest flow om.InvestmentFlow.summed_max[i, o]

\sum_t flow(i, o, t) \cdot \tau \leq summed\_max(i, o)             \cdot invest(i, o) \\
\forall (i, o) \in \textrm{SUMMED\_MAX\_FLOWS}.

Flow min sum for invest flow om.InvestmentFlow.summed_min[i, o]

\sum_t flow(i, o, t) \cdot \tau \geq summed\_min(i, o)             \cdot invest(i, o) \\
\forall (i, o) \in \textrm{SUMMED\_MIN\_FLOWS}.

The following parts of the objective function are created:

Equivalent periodical costs (epc) expression om.InvestmentFlow.investment_costs:

\sum_{i, o} invest(i, o) \cdot ep\_costs(i, o)

Additionally, if fixed_costs are set by the user:

\sum_{i, o} invest(i, o) \cdot fixed\_costs(i,o)

The expression can be accessed by om.InvestmentFlow.fixed_costs and their value after optimization by om.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

capacity(n, t) =  &capacity(n, t\_previous(t)) \cdot         (1 - capacity\_loss(n)) \\
&- (flow(n, target(n), t)) / (outflow\_conversion\_factor(n) \cdot            \tau) \\
&+ flow(source(n), n, t) \cdot inflow\_conversion\_factor(n) \cdot            \tau, \\
&\forall n \in \textrm{INVESTSTORAGES} \textrm{,} \\
&\forall t \in \textrm{TIMESTEPS}.

Initial capacity of network.Storage

capacity(n, t_{last}) = invest(n) \cdot
initial\_capacity(n), \\
\forall n \in \textrm{INITIAL\_CAPACITY,} \\
\forall t \in \textrm{TIMESTEPS}.

Connect the invest variables of the storage and the input flow.

InvestmentFlow.invest(source(n), n) =
invest(n) * nominal\_input\_capacity\_ratio(n) \\
\forall n \in \textrm{INVESTSTORAGES}

Connect the invest variables of the storage and the output flow.

InvestmentFlow.invest(n, target(n)) ==
invest(n) * nominal_output_capacity_ratio(n) \\
\forall n \in \textrm{INVESTSTORAGES}

Maximal capacity om.InvestmentStorage.max_capacity[n, t]

capacity(n, t) \leq invest(n) \cdot capacity\_min(n, t), \\
\forall n \in \textrm{MAX\_INVESTSTORAGES,} \\
\forall t \in \textrm{TIMESTEPS}.

Minimal capacity om.InvestmentStorage.min_capacity[n, t]

capacity(n, t) \geq invest(n) \cdot capacity\_min(n, t), \\
\forall n \in \textrm{MIN\_INVESTSTORAGES,} \\
\forall t \in \textrm{TIMESTEPS}.

The following parts of the objective function are created:

Equivalent periodical costs (investment costs):

\sum_n invest(n) \cdot ep\_costs(n)

Additionally, if fixed costs are set by the user:

\sum_n invest(n) \cdot fixed\_costs(n)

The expression can be accessed by om.InvestStorages.fixed_costs and their value after optimization by om.InvestStorages.fixed_costs() . This works similar for investment costs with *.investment_costs.

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 constraints are created:

Linear relation om.LinearTransformer.relation[i,o,t]

flow(i, n, t) \cdot conversion_factor(n, o, t) =             flow(n, o, t), \\
\forall t \in \textrm{TIMESTEPS}, \\
\forall n \in \textrm{LINEAR\_TRANSFORMERS}, \\
\forall o \in \textrm{OUTPUTS(n)}.

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 type Investment)

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]

capacity(n, t) = capacity(n, previous(t)) \cdot              (1 - capacity\_loss_n(t)))             - \frac{flow(n, o, t)}{\eta(n, o, t)} \cdot \tau             + flow(i, n, t) \cdot \eta(i, n, t) \cdot \tau

The following parts of the objective function are created:

If fixed_costs is set by the user:

\sum_n nominal\_capacity(n, t) \cdot fixed\_costs(n)

The fixed costs expression can be accessed by om.Storage.fixed_costs and their value after optimization by: om.Storage.fixed_costs().

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 of oemof.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.

The following sets are created:

NODES
A set with all nodes of the given energy system.
TIMESTEPS
A set with all time steps of the given time horizon.
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 timeindex will be used to calculate the timesteps the timeincrement 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)) – Timeincrement used in constraints and objective expressions. If type is ‘float’, internally will be converted to solph.plumbing.Sequence() object for time dependent timeincrement. 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 oemof nodes.
  • TIMESTEPS – A set with all timesteps for the optimization problem.
  • 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.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'>]
objective_function(sense=1, update=False)[source]
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.

relax_problem()[source]

Relaxes integer variables to reals of optimization model self

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 is om.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 of Entity.

Time series belonging only to one object, like e.g. shadow prices of commodities on a certain Bus, dispatch values of a DispatchSource or storage values of a Storage are treated as belonging to an edge looping from the object to itself. This means they can be accessed via om.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 attribute

For the investment flow of a ‘transformer’ trsf to the bus ‘bel’ this can be accessed with:

om.results()[trsf][bel].invest attribute

The 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(*args, **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 use core'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 (array-like). 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.
  • min (numeric (sequence or scalar)) – Normed minimum value of the flow. The flow absolute maximum will be calculated by multiplying nominal_value with min
  • 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 is True the flow variable will be fixed to actual_value * nominal_value.
  • positive_gradient (numeric (sequence or scalar)) – The normed maximal positive difference (flow[t-1] < flow[t]) of two consecutive flow values.
  • negative_gradient (numeric (sequence or scalar)) – The normed maximum negative difference (from[t-1] > 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.
  • fixed_costs (numeric (sequence or scalar)) – The costs 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 ex-ante 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.

Notes

The following sets, variables, constraints and objective parts are created

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 time-depended 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.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()
>>> trsf = LinearTransformer(conversion_factors={bel: 0.4,
...                                              bth: [1, 2, 3]})
>>> 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) timestep 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 timestep 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
oemof.solph.network.storage_nominal_value_warning(flow)[source]

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 force to integer values.
class oemof.solph.options.Investment(maximum=inf, ep_costs=0)[source]

Bases: object

Parameters:
  • maximum (float) – Maximum of the additional 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.NodesFromCSV(file_nodes_flows, file_nodes_flows_sequences, delimiter=', ', additional_classes={}, additional_seq_attributes=[])[source]

Creates nodes with their respective flows and sequences from a pre-defined CSV structure. An example has been provided in the development examples

Parameters:
  • file_nodes_flows (string with name of CSV file of nodes and flows) –
  • file_nodes_flows_sequences (string with name of CSV file of sequences) –
  • delimiter (delimiter of CSV file) –
  • additional_classes (dictionary with additional classes to be used in csv) – of type {‘MyClass1’: MyClass1, ...}
  • additional_seq_attributes (list of strings with attributes that have to be) – of type ‘solph sequence’
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 (array-like or scalar (None, int, etc.)) –

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]

Module contents