11190623206

Committed 29 Aug 2024 12:18PM UTC coverage: 88.755%. Remained the same

Build # 11190623206

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1120 from oemof/revision/include_v0-5_fixes

Merge revision/include v0 5 fixes

Run Details

1201 of 1393 branches covered (86.22%)

Branch coverage included in aggregate %.

51 of 53 new or added lines in 6 files covered. (96.23%)

122 existing lines in 4 files now uncovered.

2493 of 2769 relevant lines covered (90.03%)

2.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.63

/src/oemof/solph/flows/_simple_flow_block.py

# -*- coding: utf-8 -*-

"""Creating sets, variables, constraints and parts of the objective function
for Flow objects with neither nonconvex nor investment options.

SPDX-FileCopyrightText: Uwe Krien <krien@uni-bremen.de>
SPDX-FileCopyrightText: Simon Hilpert
SPDX-FileCopyrightText: Cord Kaldemeyer
SPDX-FileCopyrightText: Stephan Günther
SPDX-FileCopyrightText: Birgit Schachler
SPDX-FileCopyrightText: jnnr
SPDX-FileCopyrightText: jmloenneberga
SPDX-FileCopyrightText: Pierre-François Duc
SPDX-FileCopyrightText: Saeed Sayadi
SPDX-FileCopyrightText: Johannes Kochems

SPDX-License-Identifier: MIT

"""
from pyomo.core import BuildAction
from pyomo.core import Constraint
from pyomo.core import Expression
from pyomo.core import NonNegativeIntegers
from pyomo.core import NonNegativeReals
from pyomo.core import Set
from pyomo.core import Var
from pyomo.core.base.block import ScalarBlock

from oemof.solph._plumbing import valid_sequence


class SimpleFlowBlock(ScalarBlock):
    r"""Flow block with definitions for standard flows.

    See :class:`~oemof.solph.flows._flow.Flow` class for all parameters of the
    *Flow*.

    .. automethod:: _create_constraints
    .. automethod:: _create_variables
    .. automethod:: _create_sets

    .. automethod:: _objective_expression

    Note
    ----
    See the :class:`~oemof.solph.flows._flow.Flow` class for the definition of
    all parameters from the "List of Parameters above.

    """  # noqa: E501

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

    def _create(self, group=None):
        r"""Creates sets, variables and constraints for all standard flows.

        Parameters
        ----------
        group : list
            List containing tuples containing flow (f) objects and the
            associated source (s) and target (t)
            of flow e.g. groups=[(s1, t1, f1), (s2, t2, f2),..]
        """
        if group is None:
            return None

        self._create_sets(group)
        self._create_variables(group)
        self._create_constraints()

    def _create_sets(self, group):
        """
        Creates all sets for standard flows.
        """
        self.FULL_LOAD_TIME_MAX_FLOWS = Set(
            initialize=[
                (g[0], g[1])
                for g in group
                if g[2].full_load_time_max is not None
                and g[2].nominal_value is not None
            ]
        )

        self.FULL_LOAD_TIME_MIN_FLOWS = Set(
            initialize=[
                (g[0], g[1])
                for g in group
                if g[2].full_load_time_min is not None
                and g[2].nominal_value is not None
            ]
        )

        self.NEGATIVE_GRADIENT_FLOWS = Set(
            initialize=[
                (g[0], g[1])
                for g in group
                if g[2].negative_gradient_limit[0] is not None
            ]
        )

        self.POSITIVE_GRADIENT_FLOWS = Set(
            initialize=[
                (g[0], g[1])
                for g in group
                if g[2].positive_gradient_limit[0] is not None
            ]
        )

        self.INTEGER_FLOWS = Set(
            initialize=[(g[0], g[1]) for g in group if g[2].integer]
        )

        self.LIFETIME_FLOWS = Set(
            initialize=[
                (g[0], g[1])
                for g in group
                if g[2].lifetime is not None and g[2].age is None
            ]
        )

        self.LIFETIME_AGE_FLOWS = Set(
            initialize=[
                (g[0], g[1])
                for g in group
                if g[2].lifetime is not None and g[2].age is not None
            ]
        )

    def _create_variables(self, group):
        r"""Creates all variables for standard flows.

        All *Flow* objects are indexed by a starting and ending node
        :math:`(i, o)`, which is omitted in the following for the sake of
        convenience. The creation of some variables depend on the values of
        *Flow* attributes. The following variables are created:

        * :math:`P(p, t)`
            Actual flow value (created in :class:`~oemof.solph._models.Model`).
            The variable is bound to:
            :math:`f_\mathrm{min}(t) \cdot P_\mathrm{nom}
            \le P(p, t)
            \le f_\mathrm{max}(t) \cdot P_\mathrm{nom}`.

            If `Flow.fix` is not None the variable is bound to
            :math:`P(p, t) = f_\mathrm{fix}(t) \cdot P_\mathrm{nom}`.

        * :math:`ve_n` (`Flow.negative_gradient` is not `None`)
            Difference of a flow in consecutive timesteps if flow is reduced.
            The variable is bound to: :math:`0 \ge ve_n \ge ve_n^{max}`.

        * :math:`ve_p` (`Flow.positive_gradient` is not `None`)
            Difference of a flow in consecutive timesteps if flow is increased.
            The variable is bound to: :math:`0 \ge ve_p \ge ve_p^{max}`.

        The following variable is build for Flows with the attribute
        `integer_flows` being not None.

        * :math:`i` (`Flow.integer` is `True`)
            All flow values are integers. Variable is bound to non-negative
            integers.
        """
        m = self.parent_block()

        self.positive_gradient = Var(
            self.POSITIVE_GRADIENT_FLOWS, m.TIMESTEPS, within=NonNegativeReals
        )

        self.negative_gradient = Var(
            self.NEGATIVE_GRADIENT_FLOWS, m.TIMESTEPS, within=NonNegativeReals
        )

        self.integer_flow = Var(
            self.INTEGER_FLOWS, m.TIMESTEPS, within=NonNegativeIntegers
        )
        # set upper bound of gradient variable
        for i, o, f in group:
            if valid_sequence(
                m.flows[i, o].positive_gradient_limit, len(m.TIMESTEPS)
            ):
                for t in m.TIMESTEPS:
                    self.positive_gradient[i, o, t].setub(
                        f.positive_gradient_limit[t] * f.nominal_value
                    )
            if valid_sequence(
                m.flows[i, o].negative_gradient_limit, len(m.TIMESTEPS)
            ):
                for t in m.TIMESTEPS:
                    self.negative_gradient[i, o, t].setub(
                        f.negative_gradient_limit[t] * f.nominal_value
                    )

    def _create_constraints(self):
        r"""Creates all constraints for standard flows.

        The following constraints are created, if the appropriate attribute of
        the *Flow* (see :class:`~oemof.solph.flows._flow.Flow`) object is set:

        * `Flow.full_load_time_max` is not `None` (full_load_time_max_constr):
            .. math::
                \sum_t P(t) \cdot \tau \leq F_{max} \cdot P_{nom}

        * `Flow.full_load_time_min` is not `None` (full_load_time_min_constr):
            .. math::
                \sum_t P(t) \cdot \tau \geq F_{min} \cdot P_{nom}

        * `Flow.negative_gradient` is not `None` (negative_gradient_constr):
            .. math::
              P(t-1) - P(t) \geq ve_n(t)

        * `Flow.positive_gradient` is not `None` (positive_gradient_constr):
            .. math::
              P(t) - P(t-1) \geq ve_p(t)

        * `Flow.integer` is `True`
            .. math::
              P(t) = i(t)
        """
        m = self.parent_block()

        def _flow_full_load_time_max_rule(model):
            """Rule definition for build action of max. sum flow constraint."""
            for inp, out in self.FULL_LOAD_TIME_MAX_FLOWS:
                lhs = sum(
                    m.flow[inp, out, ts] * m.timeincrement[ts]
                    for ts in m.TIMESTEPS
                )
                rhs = (
                    m.flows[inp, out].full_load_time_max
                    * m.flows[inp, out].nominal_value
                )
                self.full_load_time_max_constr.add((inp, out), lhs <= rhs)

        self.full_load_time_max_constr = Constraint(
            self.FULL_LOAD_TIME_MAX_FLOWS, noruleinit=True
        )
        self.full_load_time_max_build = BuildAction(
            rule=_flow_full_load_time_max_rule
        )

        def _flow_full_load_time_min_rule(_):
            """Rule definition for build action of min. sum flow constraint."""
            for inp, out in self.FULL_LOAD_TIME_MIN_FLOWS:
                lhs = sum(
                    m.flow[inp, out, ts] * m.timeincrement[ts]
                    for ts in m.TIMESTEPS
                )
                rhs = (
                    m.flows[inp, out].full_load_time_min
                    * m.flows[inp, out].nominal_value
                )
                self.full_load_time_min_constr.add((inp, out), lhs >= rhs)

        self.full_load_time_min_constr = Constraint(
            self.FULL_LOAD_TIME_MIN_FLOWS, noruleinit=True
        )
        self.full_load_time_min_build = BuildAction(
            rule=_flow_full_load_time_min_rule
        )

        def _positive_gradient_flow_rule(_):
            """Rule definition for positive gradient constraint."""
            for inp, out in self.POSITIVE_GRADIENT_FLOWS:
                for index in range(1, len(m.TIMESTEPS) + 1):
                    if m.TIMESTEPS.at(index) > 0:
                        lhs = (
                            m.flow[
                                inp,
                                out,
                                m.TIMESTEPS.at(index),
                            ]
                            - m.flow[
                                inp,
                                out,
                                m.TIMESTEPS.at(index - 1),
                            ]
                        )
                        rhs = self.positive_gradient[
                            inp, out, m.TIMESTEPS.at(index)
                        ]
                        self.positive_gradient_constr.add(
                            (inp, out, m.TIMESTEPS.at(index)),
                            lhs <= rhs,
                        )
                    else:
                        lhs = self.positive_gradient[inp, out, 0]
                        rhs = 0
                        self.positive_gradient_constr.add(
                            (inp, out, m.TIMESTEPS.at(index)),
                            lhs == rhs,
                        )

        self.positive_gradient_constr = Constraint(
            self.POSITIVE_GRADIENT_FLOWS, m.TIMESTEPS, noruleinit=True
        )
        self.positive_gradient_build = BuildAction(
            rule=_positive_gradient_flow_rule
        )

        def _negative_gradient_flow_rule(model):
            """Rule definition for negative gradient constraint."""
            for inp, out in self.NEGATIVE_GRADIENT_FLOWS:
                for index in range(1, len(m.TIMESTEPS) + 1):
                    if m.TIMESTEPS.at(index) > 0:
                        lhs = (
                            m.flow[inp, out, m.TIMESTEPS.at(index - 1)]
                            - m.flow[inp, out, m.TIMESTEPS.at(index)]
                        )
                        rhs = self.negative_gradient[
                            inp, out, m.TIMESTEPS.at(index)
                        ]
                        self.negative_gradient_constr.add(
                            (inp, out, m.TIMESTEPS.at(index)),
                            lhs <= rhs,
                        )
                    else:
                        lhs = self.negative_gradient[inp, out, 0]
                        rhs = 0
                        self.negative_gradient_constr.add(
                            (inp, out, m.TIMESTEPS.at(index)),
                            lhs == rhs,
                        )

        self.negative_gradient_constr = Constraint(
            self.NEGATIVE_GRADIENT_FLOWS, m.TIMESTEPS, noruleinit=True
        )
        self.negative_gradient_build = BuildAction(
            rule=_negative_gradient_flow_rule
        )

        def _integer_flow_rule(_, ii, oi, ti):
            """Force flow variable to NonNegativeInteger values."""
            return self.integer_flow[ii, oi, ti] == m.flow[ii, oi, ti]

        self.integer_flow_constr = Constraint(
            self.INTEGER_FLOWS, m.TIMESTEPS, rule=_integer_flow_rule
        )

        if m.es.periods is not None:

            def _lifetime_output_rule(_):
                """Force flow value to zero when lifetime is reached"""
                for inp, out in self.LIFETIME_FLOWS:
                    for p, ts in m.TIMEINDEX:
                        if m.flows[inp, out].lifetime <= m.es.periods_years[p]:
                            lhs = m.flow[inp, out, ts]
                            rhs = 0
                            self.lifetime_output.add(
                                (inp, out, p, ts), (lhs == rhs)
                            )

            self.lifetime_output = Constraint(
                self.LIFETIME_FLOWS, m.TIMEINDEX, noruleinit=True
            )
            self.lifetime_output_build = BuildAction(
                rule=_lifetime_output_rule
            )

            def _lifetime_age_output_rule(block):
                """Force flow value to zero when lifetime is reached
                considering initial age
                """
                for inp, out in self.LIFETIME_AGE_FLOWS:
                    for p, ts in m.TIMEINDEX:
                        if (
                            m.flows[inp, out].lifetime - m.flows[inp, out].age
                            <= m.es.periods_years[p]
                        ):
                            lhs = m.flow[inp, out, ts]
                            rhs = 0
                            self.lifetime_age_output.add(
                                (inp, out, p, ts), (lhs == rhs)
                            )

            self.lifetime_age_output = Constraint(
                self.LIFETIME_AGE_FLOWS, m.TIMEINDEX, noruleinit=True
            )
            self.lifetime_age_output_build = BuildAction(
                rule=_lifetime_age_output_rule
            )

    def _objective_expression(self):
        r"""Objective expression for all standard flows with fixed costs
        and variable costs.

        Depending on the attributes of the `Flow` object the following parts of
        the objective function are created for a standard model:

        * `Flow.variable_costs` is not `None`:
            .. math::
              \sum_{(i,o)} \sum_t P(t) \cdot w(t) \cdot c_{var}(i, o, t)

        where :math:`w(t)` is the objective weighting.

        In a multi-period model, in contrast, the following parts of
        the objective function are created:

        * `Flow.variable_costs` is not `None`:
            .. math::
              \sum_{(i,o)} \sum_{p, t} P(p, t) \cdot w(t)
              \cdot c_{var}(i, o, t)

        * `Flow.fixed_costs` is not `None` and flow has no lifetime limit
            .. math::
              \sum_{(i,o)} \displaystyle \sum_{pp=0}^{year_{max}}
              P_{nominal} \cdot c_{fixed}(i, o, pp) \cdot DF^{-pp}

        * `Flow.fixed_costs` is not `None` and flow has a lifetime limit,
           but not an initial age
            .. math::
              \sum_{(i,o)} \displaystyle \sum_{pp=0}^{limit_{exo}}
              P_{nominal} \cdot c_{fixed}(i, o, pp) \cdot DF^{-pp}

        * `Flow.fixed_costs` is not `None` and flow has a lifetime limit,
           and an initial age
            .. math::
              \sum_{(i,o)} \displaystyle \sum_{pp=0}^{limit_{exo}} P_{nominal}
              \cdot c_{fixed}(i, o, pp) \cdot DF^{-pp}

        Hereby

        * :math:`DF(p) = (1 + dr)` is the discount factor for period :math:`p`
          and :math:`dr` is the discount rate.
        * :math:`n` is the unit lifetime and :math:`a` is the initial age.
        * :math:`year_{max}` denotes the last year of the optimization
          horizon, i.e. at the end of the last period.
        * :math:`limit_{exo}=min\{year_{max}, n - a\}` is used as an
          upper bound to ensure fixed costs for existing capacities to occur
          within the optimization horizon. :math:`a` is the initial age
          of an asset (or 0 if not specified).
        """
        m = self.parent_block()

        variable_costs = 0
        fixed_costs = 0

        if m.es.periods is None:
            for i, o in m.FLOWS:
                if valid_sequence(
                    m.flows[i, o].variable_costs, len(m.TIMESTEPS)
                ):
                    for t in m.TIMESTEPS:
                        variable_costs += (
                            m.flow[i, o, t]
                            * m.objective_weighting[t]
                            * m.flows[i, o].variable_costs[t]
                        )

        else:
            for i, o in m.FLOWS:
                if valid_sequence(
                    m.flows[i, o].variable_costs, len(m.TIMESTEPS)
                ):
                    for p, t in m.TIMEINDEX:
                        variable_costs += (
                            m.flow[i, o, t]
                            * m.objective_weighting[t]
                            * m.flows[i, o].variable_costs[t]
                            * ((1 + m.discount_rate) ** -m.es.periods_years[p])
                        )

                # Fixed costs for units with no lifetime limit
                if (
                    m.flows[i, o].fixed_costs[0] is not None
                    and m.flows[i, o].nominal_value is not None
                    and (i, o) not in self.LIFETIME_FLOWS
                    and (i, o) not in self.LIFETIME_AGE_FLOWS
                ):
                    fixed_costs += sum(
                        m.flows[i, o].nominal_value
                        * m.flows[i, o].fixed_costs[pp]
                        * ((1 + m.discount_rate) ** (-pp))
                        for pp in range(m.es.end_year_of_optimization)
                    )

            # Fixed costs for units with limited lifetime
            for i, o in self.LIFETIME_FLOWS:
                if valid_sequence(m.flows[i, o].fixed_costs, len(m.TIMESTEPS)):
                    range_limit = min(
                        m.es.end_year_of_optimization,
                        m.flows[i, o].lifetime,
                    )
                    fixed_costs += sum(
                        m.flows[i, o].nominal_value
                        * m.flows[i, o].fixed_costs[pp]
                        * ((1 + m.discount_rate) ** (-pp))
                        for pp in range(range_limit)
                    )

            for i, o in self.LIFETIME_AGE_FLOWS:
                if valid_sequence(m.flows[i, o].fixed_costs, len(m.TIMESTEPS)):
                    range_limit = min(
                        m.es.end_year_of_optimization,
                        m.flows[i, o].lifetime - m.flows[i, o].age,
                    )
                    fixed_costs += sum(
                        m.flows[i, o].nominal_value
                        * m.flows[i, o].fixed_costs[pp]
                        * ((1 + m.discount_rate) ** (-pp))
                        for pp in range(range_limit)
                    )

        self.variable_costs = Expression(expr=variable_costs)
        self.fixed_costs = Expression(expr=fixed_costs)
        self.costs = Expression(expr=variable_costs + fixed_costs)

        return self.costs

1	# -- coding: utf-8 --
2
3	"""Creating sets, variables, constraints and parts of the objective function
4	for Flow objects with neither nonconvex nor investment options.
5
6	SPDX-FileCopyrightText: Uwe Krien <krien@uni-bremen.de>
7	SPDX-FileCopyrightText: Simon Hilpert
8	SPDX-FileCopyrightText: Cord Kaldemeyer
9	SPDX-FileCopyrightText: Stephan Günther
10	SPDX-FileCopyrightText: Birgit Schachler
11	SPDX-FileCopyrightText: jnnr
12	SPDX-FileCopyrightText: jmloenneberga
13	SPDX-FileCopyrightText: Pierre-François Duc
14	SPDX-FileCopyrightText: Saeed Sayadi
15	SPDX-FileCopyrightText: Johannes Kochems
16
17	SPDX-License-Identifier: MIT
18
19	"""
20	from pyomo.core import BuildAction	3✔
21	from pyomo.core import Constraint	3✔
22	from pyomo.core import Expression	3✔
23	from pyomo.core import NonNegativeIntegers	3✔
24	from pyomo.core import NonNegativeReals	3✔
25	from pyomo.core import Set	3✔
26	from pyomo.core import Var	3✔
27	from pyomo.core.base.block import ScalarBlock	3✔
28
29	from oemof.solph._plumbing import valid_sequence	3✔
30
31
32	class SimpleFlowBlock(ScalarBlock):	3✔
33	r"""Flow block with definitions for standard flows.
34
35	See :class:`~oemof.solph.flows._flow.Flow` class for all parameters of the
36	Flow.
37
38	.. automethod:: _create_constraints
39	.. automethod:: _create_variables
40	.. automethod:: _create_sets
41
42	.. automethod:: _objective_expression
43
44	Note
45	----
46	See the :class:`~oemof.solph.flows._flow.Flow` class for the definition of
47	all parameters from the "List of Parameters above.
48
49	""" # noqa: E501
50
51	def __init__(self, args, *kwargs):	3✔
52	super().__init__(args, *kwargs)	3✔
53
54	def _create(self, group=None):	3✔
55	r"""Creates sets, variables and constraints for all standard flows.
56
57	Parameters
58	----------
59	group : list
60	List containing tuples containing flow (f) objects and the
61	associated source (s) and target (t)
62	of flow e.g. groups=[(s1, t1, f1), (s2, t2, f2),..]
63	"""
64	if group is None:	3✔
65	return None	3✔
66
67	self._create_sets(group)	3✔
68	self._create_variables(group)	3✔
69	self._create_constraints()	3✔
70
71	def _create_sets(self, group):	3✔
72	"""
73	Creates all sets for standard flows.
74	"""
75	self.FULL_LOAD_TIME_MAX_FLOWS = Set(	3✔
76	initialize=[
77	(g[0], g[1])
78	for g in group
79	if g[2].full_load_time_max is not None
80	and g[2].nominal_value is not None
81	]
82	)
83
84	self.FULL_LOAD_TIME_MIN_FLOWS = Set(	3✔
85	initialize=[
86	(g[0], g[1])
87	for g in group
88	if g[2].full_load_time_min is not None
89	and g[2].nominal_value is not None
90	]
91	)
92
93	self.NEGATIVE_GRADIENT_FLOWS = Set(	3✔
94	initialize=[
95	(g[0], g[1])
96	for g in group
97	if g[2].negative_gradient_limit[0] is not None
98	]
99	)
100
101	self.POSITIVE_GRADIENT_FLOWS = Set(	3✔
102	initialize=[
103	(g[0], g[1])
104	for g in group
105	if g[2].positive_gradient_limit[0] is not None
106	]
107	)
108
109	self.INTEGER_FLOWS = Set(	3✔
110	initialize=[(g[0], g[1]) for g in group if g[2].integer]
111	)
112
113	self.LIFETIME_FLOWS = Set(	3✔
114	initialize=[
115	(g[0], g[1])
116	for g in group
117	if g[2].lifetime is not None and g[2].age is None
118	]
119	)
120
121	self.LIFETIME_AGE_FLOWS = Set(	3✔
122	initialize=[
123	(g[0], g[1])
124	for g in group
125	if g[2].lifetime is not None and g[2].age is not None
126	]
127	)
128
129	def _create_variables(self, group):	3✔
130	r"""Creates all variables for standard flows.
131
132	All Flow objects are indexed by a starting and ending node
133	:math:`(i, o)`, which is omitted in the following for the sake of
134	convenience. The creation of some variables depend on the values of
135	Flow attributes. The following variables are created:
136
137	* :math:`P(p, t)`
138	Actual flow value (created in :class:`~oemof.solph._models.Model`).
139	The variable is bound to:
140	:math:`f_\mathrm{min}(t) \cdot P_\mathrm{nom}
141	\le P(p, t)
142	\le f_\mathrm{max}(t) \cdot P_\mathrm{nom}`.
143
144	If `Flow.fix` is not None the variable is bound to
145	:math:`P(p, t) = f_\mathrm{fix}(t) \cdot P_\mathrm{nom}`.
146
147	* :math:`ve_n` (`Flow.negative_gradient` is not `None`)
148	Difference of a flow in consecutive timesteps if flow is reduced.
149	The variable is bound to: :math:`0 \ge ve_n \ge ve_n^{max}`.
150
151	* :math:`ve_p` (`Flow.positive_gradient` is not `None`)
152	Difference of a flow in consecutive timesteps if flow is increased.
153	The variable is bound to: :math:`0 \ge ve_p \ge ve_p^{max}`.
154
155	The following variable is build for Flows with the attribute
156	`integer_flows` being not None.
157
158	* :math:`i` (`Flow.integer` is `True`)
159	All flow values are integers. Variable is bound to non-negative
160	integers.
161	"""
162	m = self.parent_block()	3✔
163
164	self.positive_gradient = Var(	3✔
165	self.POSITIVE_GRADIENT_FLOWS, m.TIMESTEPS, within=NonNegativeReals
166	)
167
168	self.negative_gradient = Var(	3✔
169	self.NEGATIVE_GRADIENT_FLOWS, m.TIMESTEPS, within=NonNegativeReals
170	)
171
172	self.integer_flow = Var(	3✔
173	self.INTEGER_FLOWS, m.TIMESTEPS, within=NonNegativeIntegers
174	)
175	# set upper bound of gradient variable
176	for i, o, f in group:	3✔
177	if valid_sequence(	3✔
178	m.flows[i, o].positive_gradient_limit, len(m.TIMESTEPS)
179	):
180	for t in m.TIMESTEPS:	3✔
181	self.positive_gradient[i, o, t].setub(	3✔
182	f.positive_gradient_limit[t] * f.nominal_value
183	)
184	if valid_sequence(	3✔
185	m.flows[i, o].negative_gradient_limit, len(m.TIMESTEPS)
186	):
187	for t in m.TIMESTEPS:	3✔
188	self.negative_gradient[i, o, t].setub(	3✔
189	f.negative_gradient_limit[t] * f.nominal_value
190	)
191
192	def _create_constraints(self):	3✔
193	r"""Creates all constraints for standard flows.
194
195	The following constraints are created, if the appropriate attribute of
196	the Flow (see :class:`~oemof.solph.flows._flow.Flow`) object is set:
197
198	* `Flow.full_load_time_max` is not `None` (full_load_time_max_constr):
199	.. math::
200	\sum_t P(t) \cdot \tau \leq F_{max} \cdot P_{nom}
201
202	* `Flow.full_load_time_min` is not `None` (full_load_time_min_constr):
203	.. math::
204	\sum_t P(t) \cdot \tau \geq F_{min} \cdot P_{nom}
205
206	* `Flow.negative_gradient` is not `None` (negative_gradient_constr):
207	.. math::
208	P(t-1) - P(t) \geq ve_n(t)
209
210	* `Flow.positive_gradient` is not `None` (positive_gradient_constr):
211	.. math::
212	P(t) - P(t-1) \geq ve_p(t)
213
214	* `Flow.integer` is `True`
215	.. math::
216	P(t) = i(t)
217	"""
218	m = self.parent_block()	3✔
219
220	def _flow_full_load_time_max_rule(model):	3✔
221	"""Rule definition for build action of max. sum flow constraint."""
222	for inp, out in self.FULL_LOAD_TIME_MAX_FLOWS:	3✔
223	lhs = sum(	3✔
224	m.flow[inp, out, ts] * m.timeincrement[ts]
225	for ts in m.TIMESTEPS
226	)
227	rhs = (	3✔
228	m.flows[inp, out].full_load_time_max
229	* m.flows[inp, out].nominal_value
230	)
231	self.full_load_time_max_constr.add((inp, out), lhs <= rhs)	3✔
232
233	self.full_load_time_max_constr = Constraint(	3✔
234	self.FULL_LOAD_TIME_MAX_FLOWS, noruleinit=True
235	)
236	self.full_load_time_max_build = BuildAction(	3✔
237	rule=_flow_full_load_time_max_rule
238	)
239
240	def _flow_full_load_time_min_rule(_):	3✔
241	"""Rule definition for build action of min. sum flow constraint."""
242	for inp, out in self.FULL_LOAD_TIME_MIN_FLOWS:	3✔
243	lhs = sum(	3✔
244	m.flow[inp, out, ts] * m.timeincrement[ts]
245	for ts in m.TIMESTEPS
246	)
247	rhs = (	3✔
248	m.flows[inp, out].full_load_time_min
249	* m.flows[inp, out].nominal_value
250	)
251	self.full_load_time_min_constr.add((inp, out), lhs >= rhs)	3✔
252
253	self.full_load_time_min_constr = Constraint(	3✔
254	self.FULL_LOAD_TIME_MIN_FLOWS, noruleinit=True
255	)
256	self.full_load_time_min_build = BuildAction(	3✔
257	rule=_flow_full_load_time_min_rule
258	)
259
260	def _positive_gradient_flow_rule(_):	3✔
261	"""Rule definition for positive gradient constraint."""
262	for inp, out in self.POSITIVE_GRADIENT_FLOWS:	3✔
263	for index in range(1, len(m.TIMESTEPS) + 1):	3✔
264	if m.TIMESTEPS.at(index) > 0:	3✔
265	lhs = (	3✔
266	m.flow[
267	inp,
268	out,
269	m.TIMESTEPS.at(index),
270	]
271	- m.flow[
272	inp,
273	out,
274	m.TIMESTEPS.at(index - 1),
275	]
276	)
277	rhs = self.positive_gradient[	3✔
278	inp, out, m.TIMESTEPS.at(index)
279	]
280	self.positive_gradient_constr.add(	3✔
281	(inp, out, m.TIMESTEPS.at(index)),
282	lhs <= rhs,
283	)
284	else:
285	lhs = self.positive_gradient[inp, out, 0]	3✔
286	rhs = 0	3✔
287	self.positive_gradient_constr.add(	3✔
288	(inp, out, m.TIMESTEPS.at(index)),
289	lhs == rhs,
290	)
291
292	self.positive_gradient_constr = Constraint(	3✔
293	self.POSITIVE_GRADIENT_FLOWS, m.TIMESTEPS, noruleinit=True
294	)
295	self.positive_gradient_build = BuildAction(	3✔
296	rule=_positive_gradient_flow_rule
297	)
298
299	def _negative_gradient_flow_rule(model):	3✔
300	"""Rule definition for negative gradient constraint."""
301	for inp, out in self.NEGATIVE_GRADIENT_FLOWS:	3✔
302	for index in range(1, len(m.TIMESTEPS) + 1):	3✔
303	if m.TIMESTEPS.at(index) > 0:	3✔
304	lhs = (	3✔
305	m.flow[inp, out, m.TIMESTEPS.at(index - 1)]
306	- m.flow[inp, out, m.TIMESTEPS.at(index)]
307	)
308	rhs = self.negative_gradient[	3✔
309	inp, out, m.TIMESTEPS.at(index)
310	]
311	self.negative_gradient_constr.add(	3✔
312	(inp, out, m.TIMESTEPS.at(index)),
313	lhs <= rhs,
314	)
315	else:
316	lhs = self.negative_gradient[inp, out, 0]	3✔
317	rhs = 0	3✔
318	self.negative_gradient_constr.add(	3✔
319	(inp, out, m.TIMESTEPS.at(index)),
320	lhs == rhs,
321	)
322
323	self.negative_gradient_constr = Constraint(	3✔
324	self.NEGATIVE_GRADIENT_FLOWS, m.TIMESTEPS, noruleinit=True
325	)
326	self.negative_gradient_build = BuildAction(	3✔
327	rule=_negative_gradient_flow_rule
328	)
329
330	def _integer_flow_rule(_, ii, oi, ti):	3✔
331	"""Force flow variable to NonNegativeInteger values."""
UNCOV 332	return self.integer_flow[ii, oi, ti] == m.flow[ii, oi, ti]	×
333
334	self.integer_flow_constr = Constraint(	3✔
335	self.INTEGER_FLOWS, m.TIMESTEPS, rule=_integer_flow_rule
336	)
337
338	if m.es.periods is not None:	3✔
339
340	def _lifetime_output_rule(_):	3✔
341	"""Force flow value to zero when lifetime is reached"""
342	for inp, out in self.LIFETIME_FLOWS:	3!
UNCOV 343	for p, ts in m.TIMEINDEX:	×
UNCOV 344	if m.flows[inp, out].lifetime <= m.es.periods_years[p]:	×
UNCOV 345	lhs = m.flow[inp, out, ts]	×
UNCOV 346	rhs = 0	×
UNCOV 347	self.lifetime_output.add(	×
348	(inp, out, p, ts), (lhs == rhs)
349	)
350
351	self.lifetime_output = Constraint(	3✔
352	self.LIFETIME_FLOWS, m.TIMEINDEX, noruleinit=True
353	)
354	self.lifetime_output_build = BuildAction(	3✔
355	rule=_lifetime_output_rule
356	)
357
358	def _lifetime_age_output_rule(block):	3✔
359	"""Force flow value to zero when lifetime is reached
360	considering initial age
361	"""
362	for inp, out in self.LIFETIME_AGE_FLOWS:	3!
UNCOV 363	for p, ts in m.TIMEINDEX:	×
UNCOV 364	if (	×
365	m.flows[inp, out].lifetime - m.flows[inp, out].age
366	<= m.es.periods_years[p]
367	):
UNCOV 368	lhs = m.flow[inp, out, ts]	×
369	rhs = 0	×
370	self.lifetime_age_output.add(	×
371	(inp, out, p, ts), (lhs == rhs)
372	)
373
374	self.lifetime_age_output = Constraint(	3✔
375	self.LIFETIME_AGE_FLOWS, m.TIMEINDEX, noruleinit=True
376	)
377	self.lifetime_age_output_build = BuildAction(	3✔
378	rule=_lifetime_age_output_rule
379	)
380
381	def _objective_expression(self):	3✔
382	r"""Objective expression for all standard flows with fixed costs
383	and variable costs.
384
385	Depending on the attributes of the `Flow` object the following parts of
386	the objective function are created for a standard model:
387
388	* `Flow.variable_costs` is not `None`:
389	.. math::
390	\sum_{(i,o)} \sum_t P(t) \cdot w(t) \cdot c_{var}(i, o, t)
391
392	where :math:`w(t)` is the objective weighting.
393
394	In a multi-period model, in contrast, the following parts of
395	the objective function are created:
396
397	* `Flow.variable_costs` is not `None`:
398	.. math::
399	\sum_{(i,o)} \sum_{p, t} P(p, t) \cdot w(t)
400	\cdot c_{var}(i, o, t)
401
402	* `Flow.fixed_costs` is not `None` and flow has no lifetime limit
403	.. math::
404	\sum_{(i,o)} \displaystyle \sum_{pp=0}^{year_{max}}
405	P_{nominal} \cdot c_{fixed}(i, o, pp) \cdot DF^{-pp}
406
407	* `Flow.fixed_costs` is not `None` and flow has a lifetime limit,
408	but not an initial age
409	.. math::
410	\sum_{(i,o)} \displaystyle \sum_{pp=0}^{limit_{exo}}
411	P_{nominal} \cdot c_{fixed}(i, o, pp) \cdot DF^{-pp}
412
413	* `Flow.fixed_costs` is not `None` and flow has a lifetime limit,
414	and an initial age
415	.. math::
416	\sum_{(i,o)} \displaystyle \sum_{pp=0}^{limit_{exo}} P_{nominal}
417	\cdot c_{fixed}(i, o, pp) \cdot DF^{-pp}
418
419	Hereby
420
421	* :math:`DF(p) = (1 + dr)` is the discount factor for period :math:`p`
422	and :math:`dr` is the discount rate.
423	* :math:`n` is the unit lifetime and :math:`a` is the initial age.
424	* :math:`year_{max}` denotes the last year of the optimization
425	horizon, i.e. at the end of the last period.
426	* :math:`limit_{exo}=min\{year_{max}, n - a\}` is used as an
427	upper bound to ensure fixed costs for existing capacities to occur
428	within the optimization horizon. :math:`a` is the initial age
429	of an asset (or 0 if not specified).
430	"""
431	m = self.parent_block()	3✔
432
433	variable_costs = 0	3✔
434	fixed_costs = 0	3✔
435
436	if m.es.periods is None:	3✔
437	for i, o in m.FLOWS:	3✔
438	if valid_sequence(	3!
439	m.flows[i, o].variable_costs, len(m.TIMESTEPS)
440	):
441	for t in m.TIMESTEPS:	3✔
442	variable_costs += (	3✔
443	m.flow[i, o, t]
444	* m.objective_weighting[t]
445	* m.flows[i, o].variable_costs[t]
446	)
447
448	else:
449	for i, o in m.FLOWS:	3✔
450	if valid_sequence(	3!
451	m.flows[i, o].variable_costs, len(m.TIMESTEPS)
452	):
453	for p, t in m.TIMEINDEX:	3✔
454	variable_costs += (	3✔
455	m.flow[i, o, t]
456	* m.objective_weighting[t]
457	* m.flows[i, o].variable_costs[t]
458	* ((1 + m.discount_rate) ** -m.es.periods_years[p])
459	)
460
461	# Fixed costs for units with no lifetime limit
462	if (	3!
463	m.flows[i, o].fixed_costs[0] is not None
464	and m.flows[i, o].nominal_value is not None
465	and (i, o) not in self.LIFETIME_FLOWS
466	and (i, o) not in self.LIFETIME_AGE_FLOWS
467	):
UNCOV 468	fixed_costs += sum(	×
469	m.flows[i, o].nominal_value
470	* m.flows[i, o].fixed_costs[pp]
471	* ((1 + m.discount_rate) ** (-pp))
472	for pp in range(m.es.end_year_of_optimization)
473	)
474
475	# Fixed costs for units with limited lifetime
476	for i, o in self.LIFETIME_FLOWS:	3!
NEW 477	if valid_sequence(m.flows[i, o].fixed_costs, len(m.TIMESTEPS)):	×
478	range_limit = min(	×
479	m.es.end_year_of_optimization,
480	m.flows[i, o].lifetime,
481	)
UNCOV 482	fixed_costs += sum(	×
483	m.flows[i, o].nominal_value
484	* m.flows[i, o].fixed_costs[pp]
485	* ((1 + m.discount_rate) ** (-pp))
486	for pp in range(range_limit)
487	)
488
489	for i, o in self.LIFETIME_AGE_FLOWS:	3!
NEW 490	if valid_sequence(m.flows[i, o].fixed_costs, len(m.TIMESTEPS)):	×
UNCOV 491	range_limit = min(	×
492	m.es.end_year_of_optimization,
493	m.flows[i, o].lifetime - m.flows[i, o].age,
494	)
UNCOV 495	fixed_costs += sum(	×
496	m.flows[i, o].nominal_value
497	* m.flows[i, o].fixed_costs[pp]
498	* ((1 + m.discount_rate) ** (-pp))
499	for pp in range(range_limit)
500	)
501
502	self.variable_costs = Expression(expr=variable_costs)	3✔
503	self.fixed_costs = Expression(expr=fixed_costs)	3✔
504	self.costs = Expression(expr=variable_costs + fixed_costs)	3✔
505
506	return self.costs	3✔

oemof / oemof-solph / 11190623206

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous