9180492083

Committed 21 May 2024 07:39PM UTC coverage: 96.581% (+0.1%) from 96.458%

Build # 9180492083

Build Type

Pull #1049

github

Committed by

web-flow

Commit Message

Merge f4d26cbca into 87be0adf7

Pull Request Pull Request #1049: Replace the specification of frequency for hours in pandas data_range

Run Details

1464 of 1540 branches covered (95.06%)

Branch coverage included in aggregate %.

4 of 4 new or added lines in 4 files covered. (100.0%)

10 existing lines in 2 files now uncovered.

2632 of 2701 relevant lines covered (97.45%)

0.97 hits per line

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

94.21

/src/oemof/solph/components/_offset_converter.py

# -*- coding: utf-8 -

"""
OffsetConverter and associated individual constraints (blocks) and groupings.

SPDX-FileCopyrightText: Uwe Krien <krien@uni-bremen.de>
SPDX-FileCopyrightText: Simon Hilpert
SPDX-FileCopyrightText: Cord Kaldemeyer
SPDX-FileCopyrightText: Patrik Schönfeldt
SPDX-FileCopyrightText: FranziPl
SPDX-FileCopyrightText: jnnr
SPDX-FileCopyrightText: Stephan Günther
SPDX-FileCopyrightText: FabianTU
SPDX-FileCopyrightText: Johannes Röder
SPDX-FileCopyrightText: Saeed Sayadi
SPDX-FileCopyrightText: Johannes Kochems

SPDX-License-Identifier: MIT

"""

from warnings import warn

from oemof.network import Node
from pyomo.core import BuildAction
from pyomo.core.base.block import ScalarBlock
from pyomo.environ import Constraint
from pyomo.environ import Set

from oemof.solph._plumbing import sequence


class OffsetConverter(Node):
    """An object with one input and multiple outputs and two coefficients
    per output to model part load behaviour.
    The output must contain a NonConvex object.

    Parameters
    ----------
    coefficients : dict of tuples, (:math:`C_0(t)`, :math:`C_1(t)`)
        Dict of tuples containing the respective output bus as key and
        as value a tuple with the parameters :math:`C_0(t)` and :math:`C_1(t)`.
        Here, :math:`C_1(t)` represents the slope of a linear equation and
        :math:`C_0(t)` is the y-intercept devided by the `nominal_value` of the
        output flow (this is for internal purposes).

        The tuple values can either be a scalar or a sequence with length
        of time horizon for simulation.

    Notes
    -----
    **C_1 and C_0 can be calculated as follows:**

    .. _OffsetConverterCoefficients-equations:

    .. math::

        C_1 = (l_{max}-l_{min})/(l_{max}/\\eta_{max}-l_{min}/\\eta_{min})

        C_0 = l_{min} \\cdot (1-C_1/\\eta_{min})

    Where :math:`l_{max}` and :math:`l_{min}` are the maximum and minimum
    partload share (e.g. 1.0 and 0.3) and :math:`\\eta_{max}` and
    :math:`\\eta_{min}` are the efficiencies/conversion factors at these
    partloads.

    The sets, variables, constraints and objective parts are created
     * :py:class:`~oemof.solph.components._offset_converter.OffsetConverterBlock`

    Examples
    --------
    >>> from oemof import solph
    >>> bel = solph.buses.Bus(label='bel')
    >>> bth = solph.buses.Bus(label='bth')
    >>> l_max = 1
    >>> l_min = 0.5
    >>> eta_max = 0.5
    >>> eta_min = 0.3
    >>> c1 = (l_max-l_min)/(l_max/eta_max-l_min/eta_min)
    >>> c0 = l_min*(1-c1/eta_min)
    >>> ostf = solph.components.OffsetConverter(
    ...    label='ostf',
    ...    inputs={bel: solph.flows.Flow()},
    ...    outputs={bth: solph.flows.Flow(
    ...         nominal_value=60, min=l_min, max=l_max,
    ...         nonconvex=solph.NonConvex())},
    ...    coefficients={bth: (c0, c1)}
    ... )
    >>> type(ostf)
    <class 'oemof.solph.components._offset_converter.OffsetConverter'>
    """  # noqa: E501

    def __init__(
        self,
        inputs,
        outputs,
        label=None,
        coefficients=None,
        custom_attributes=None,
    ):
        if custom_attributes is None:
            custom_attributes = {}
        super().__init__(
            inputs=inputs,
            outputs=outputs,
            label=label,
            custom_properties=custom_attributes,
        )

        if coefficients is not None:
            self.coefficients = dict()
            if isinstance(coefficients, tuple):
                # TODO: add the correct version in the message
                msg = (
                    "Passing a tuple to the keyword `coefficients` will be"
                    " deprecated in a later version. Please use a dict to"
                    " specify the corresponding output flow. The first output"
                    " flow will be assumed as target by default."
                )
                warn(msg, DeprecationWarning)
                if len(coefficients) != 2:
                    raise ValueError(
                        "Two coefficients or coefficient series have to be"
                        " given."
                    )
                self.coefficients.update(
                    {
                        [k for k in self.outputs.keys()][0]: tuple(
                            [sequence(i) for i in coefficients]
                        )
                    }
                )
            elif isinstance(coefficients, dict):
                for k, v in coefficients.items():
                    if len(v) != 2:
                        raise ValueError(
                            "Two coefficients or coefficient series have to be"
                            " given."
                        )
                    self.coefficients.update(
                        {k: (sequence(v[0]), sequence(v[1]))}
                    )
            else:
                raise TypeError(
                    "`coefficiencts` needs to be either dict or tuple"
                    " (deprecated)."
                )

        # `OffsetConverter` always needs the `NonConvex` attribute, but the
        # `Investment` attribute is optional. If it is used, the
        # `InvestNonConvexFlow` will be used in the definition of constraints,
        # otherwise, the `NonConvexFlow` will be used.
        if len(self.outputs):
            for v in self.outputs.values():
                if not v.nonconvex:
                    raise TypeError(
                        "Output flow must have the `NonConvex` attribute!"
                    )

        # `Investment` and `NonConvex` attributes cannot be defined for the
        # input flow.
        if len(self.inputs):
            for v in self.inputs.values():
                if v.investment:
                    raise TypeError(
                        "`Investment` attribute must be defined only for the "
                        + "output flow!"
                    )
                if v.nonconvex:
                    raise TypeError(
                        "`NonConvex` attribute must be defined only for the "
                        + "output flow!"
                    )

        if len(self.inputs) > 1:
            raise ValueError(
                "Component `OffsetConverter` must not have more than 1 input!"
            )

    def constraint_group(self):
        return OffsetConverterBlock


# --- BEGIN: To be removed for versions >= v0.6 ---
class OffsetTransformer(OffsetConverter):
    def __init__(
        self,
        inputs,
        outputs,
        label=None,
        coefficients=None,
        custom_attributes=None,
    ):
        super().__init__(
            label=label,
            inputs=inputs,
            outputs=outputs,
            coefficients=coefficients,
            custom_attributes=custom_attributes,
        )
        warn(
            "solph.components.OffsetTransformer has been renamed to"
            " solph.components.OffsetConverter. The transitional wrapper"
            " will be deleted in the future.",
            FutureWarning,
        )


# --- END ---


class OffsetConverterBlock(ScalarBlock):
    r"""Block for the relation of nodes with type
    :class:`~oemof.solph.components._offset_converter.OffsetConverter`

    **The following constraints are created:**

    .. _OffsetConverter-equations:

    .. math::
        &
        P_{out}(p, t) = P_{in}(p, t) \cdot C_1(t) + P_nom(p) \cdot Y(t) \cdot C_0(t) \\


    The symbols used are defined as follows (with Variables (V) and Parameters (P)):

    +--------------------+---------------------------+------+--------------------------------------------------+
    | symbol             | attribute                 | type | explanation                                      |
    +====================+===========================+======+==================================================+
    | :math:`P_{out}(t)` | `flow[n,o,p,t]`           | V    | Outflow of converter                             |
    +--------------------+---------------------------+------+--------------------------------------------------+
    | :math:`P_{in}(t)`  | `flow[i,n,p,t]`           | V    | Inflow of converter                              |
    +--------------------+---------------------------+------+--------------------------------------------------+
    | :math:`Y(t)`       |                           | V    | Binary status variable of nonconvex outflow      |
    +--------------------+---------------------------+------+--------------------------------------------------+
    | :math:`P_{nom}(t)` |                           | V    | Nominal value (max. capacity) of the outflow     |
    +--------------------+---------------------------+------+--------------------------------------------------+
    | :math:`C_1(t)`     | `coefficients[o][1][n,t]` | P    | Linear coefficient 1 (slope)                     |
    +--------------------+---------------------------+------+--------------------------------------------------+
    | :math:`C_0(t)`     | `coefficients[o][0][n,t]` | P    | Linear coefficient 0 (y-intersection)/P_{nom}(t) |
    +--------------------+---------------------------+------+--------------------------------------------------+

    Note that :math:`P_{nom}(t) \cdot Y(t)` is merged into one variable,
    called `status_nominal[n, o, p, t]`.
    """  # noqa: E501

    CONSTRAINT_GROUP = True

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

    def _create(self, group=None):
        """Creates the relation for the class:`OffsetConverter`.

        Parameters
        ----------
        group : list
            List of oemof.solph.experimental.OffsetConverter objects for
            which the relation of inputs and outputs is created
            e.g. group = [ostf1, ostf2, ostf3, ...]. The components inside
            the list need to hold an attribute `coefficients` of type dict
            containing the conversion factors for all inputs to outputs.
        """
        if group is None:
            return None

        m = self.parent_block()

        self.OFFSETCONVERTERS = Set(initialize=[n for n in group])

        in_flows = {n: [i for i in n.inputs.keys()] for n in group}
        out_flows = {n: [o for o in n.outputs.keys()] for n in group}

        self.relation = Constraint(
            [
                (n, i, o, p, t)
                for p, t in m.TIMEINDEX
                for n in group
                for o in out_flows[n]
                for i in in_flows[n]
            ],
            noruleinit=True,
        )

        def _relation_rule(block):
            """Link binary input and output flow to component outflow."""
            for p, t in m.TIMEINDEX:
                for n in group:
                    for o in out_flows[n]:
                        for i in in_flows[n]:
                            expr = 0
                            expr += -m.flow[n, o, p, t]
                            expr += (
                                m.flow[i, n, p, t] * n.coefficients[o][1][t]
                            )
                            # `Y(t)` in the last term of the constraint
                            # (":math:`C_0(t) \cdot Y(t)`") is different for
                            # different cases. If both `Investment` and
                            # `NonConvex` attributes are used for the
                            # `OffsetConverter`, `Y(t)` would represent the
                            # `status_nominal[n,o,t]` in the
                            # `InvestNonConvexFlow`. But if only the
                            # `NonConvex` attribute is defined for the
                            # `OffsetConverter`, `Y(t)` would correspond to
                            # the `status_nominal[n,o,t]` in the
                            # `NonConvexFlow`.
                            try:
                                expr += (
                                    m.InvestNonConvexFlowBlock.status_nominal[
                                        n, o, t
                                    ]
                                    * n.coefficients[o][0][t]
                                )
                            # `KeyError` occurs when more than one
                            # `OffsetConverter` is defined, and in some of
                            # them only the `NonConvex` attribute is
                            # considered, while in others both `NonConvex`
                            # and `Investment` attributes are defined.
                            # `AttributeError` only occurs when the
                            # `OffsetConverter` has only the `NonConvex`
                            # attribute, and therefore,
                            # `m.InvestNonConvexFlowBlock.status_nominal`
                            # (inside the `try` block) does not exist.
                            except (KeyError, AttributeError):
                                expr += (
                                    m.NonConvexFlowBlock.status_nominal[
                                        n, o, t
                                    ]
                                    * n.coefficients[o][0][t]
                                )
                            block.relation.add((n, i, o, p, t), (expr == 0))

        self.relation_build = BuildAction(rule=_relation_rule)

1	# -*- coding: utf-8 -
2
3	"""	1✔
4	OffsetConverter and associated individual constraints (blocks) and groupings.
5
6	SPDX-FileCopyrightText: Uwe Krien <krien@uni-bremen.de>
7	SPDX-FileCopyrightText: Simon Hilpert
8	SPDX-FileCopyrightText: Cord Kaldemeyer
9	SPDX-FileCopyrightText: Patrik Schönfeldt
10	SPDX-FileCopyrightText: FranziPl
11	SPDX-FileCopyrightText: jnnr
12	SPDX-FileCopyrightText: Stephan Günther
13	SPDX-FileCopyrightText: FabianTU
14	SPDX-FileCopyrightText: Johannes Röder
15	SPDX-FileCopyrightText: Saeed Sayadi
16	SPDX-FileCopyrightText: Johannes Kochems
17
18	SPDX-License-Identifier: MIT
19
20	"""
21
22	from warnings import warn	1✔
23
24	from oemof.network import Node	1✔
25	from pyomo.core import BuildAction	1✔
26	from pyomo.core.base.block import ScalarBlock	1✔
27	from pyomo.environ import Constraint	1✔
28	from pyomo.environ import Set	1✔
29
30	from oemof.solph._plumbing import sequence	1✔
31
32
33	class OffsetConverter(Node):	1✔
34	"""An object with one input and multiple outputs and two coefficients
35	per output to model part load behaviour.
36	The output must contain a NonConvex object.
37
38	Parameters
39	----------
40	coefficients : dict of tuples, (:math:`C_0(t)`, :math:`C_1(t)`)
41	Dict of tuples containing the respective output bus as key and
42	as value a tuple with the parameters :math:`C_0(t)` and :math:`C_1(t)`.
43	Here, :math:`C_1(t)` represents the slope of a linear equation and
44	:math:`C_0(t)` is the y-intercept devided by the `nominal_value` of the
45	output flow (this is for internal purposes).
46
47	The tuple values can either be a scalar or a sequence with length
48	of time horizon for simulation.
49
50	Notes
51	-----
52	C_1 and C_0 can be calculated as follows:
53
54	.. _OffsetConverterCoefficients-equations:
55
56	.. math::
57
58	C_1 = (l_{max}-l_{min})/(l_{max}/\\eta_{max}-l_{min}/\\eta_{min})
59
60	C_0 = l_{min} \\cdot (1-C_1/\\eta_{min})
61
62	Where :math:`l_{max}` and :math:`l_{min}` are the maximum and minimum
63	partload share (e.g. 1.0 and 0.3) and :math:`\\eta_{max}` and
64	:math:`\\eta_{min}` are the efficiencies/conversion factors at these
65	partloads.
66
67	The sets, variables, constraints and objective parts are created
68	* :py:class:`~oemof.solph.components._offset_converter.OffsetConverterBlock`
69
70	Examples
71	--------
72	>>> from oemof import solph
73	>>> bel = solph.buses.Bus(label='bel')
74	>>> bth = solph.buses.Bus(label='bth')
75	>>> l_max = 1
76	>>> l_min = 0.5
77	>>> eta_max = 0.5
78	>>> eta_min = 0.3
79	>>> c1 = (l_max-l_min)/(l_max/eta_max-l_min/eta_min)
80	>>> c0 = l_min*(1-c1/eta_min)
81	>>> ostf = solph.components.OffsetConverter(
82	... label='ostf',
83	... inputs={bel: solph.flows.Flow()},
84	... outputs={bth: solph.flows.Flow(
85	... nominal_value=60, min=l_min, max=l_max,
86	... nonconvex=solph.NonConvex())},
87	... coefficients={bth: (c0, c1)}
88	... )
89	>>> type(ostf)
90	<class 'oemof.solph.components._offset_converter.OffsetConverter'>
91	""" # noqa: E501
92
93	def __init__(	1✔
94	self,
95	inputs,
96	outputs,
97	label=None,
98	coefficients=None,
99	custom_attributes=None,
100	):
101	if custom_attributes is None:	1!
102	custom_attributes = {}	1✔
103	super().__init__(	1✔
104	inputs=inputs,
105	outputs=outputs,
106	label=label,
107	custom_properties=custom_attributes,
108	)
109
110	if coefficients is not None:	1✔
111	self.coefficients = dict()	1✔
112	if isinstance(coefficients, tuple):	1✔
113	# TODO: add the correct version in the message
114	msg = (	1✔
115	"Passing a tuple to the keyword `coefficients` will be"
116	" deprecated in a later version. Please use a dict to"
117	" specify the corresponding output flow. The first output"
118	" flow will be assumed as target by default."
119	)
120	warn(msg, DeprecationWarning)	1✔
121	if len(coefficients) != 2:	1!
UNCOV 122	raise ValueError(	×
123	"Two coefficients or coefficient series have to be"
124	" given."
125	)
126	self.coefficients.update(	1✔
127	{
128	[k for k in self.outputs.keys()][0]: tuple(
129	[sequence(i) for i in coefficients]
130	)
131	}
132	)
133	elif isinstance(coefficients, dict):	1!
134	for k, v in coefficients.items():	1✔
135	if len(v) != 2:	1✔
136	raise ValueError(	1✔
137	"Two coefficients or coefficient series have to be"
138	" given."
139	)
140	self.coefficients.update(	1✔
141	{k: (sequence(v[0]), sequence(v[1]))}
142	)
143	else:
UNCOV 144	raise TypeError(	×
145	"`coefficiencts` needs to be either dict or tuple"
146	" (deprecated)."
147	)
148
149	# `OffsetConverter` always needs the `NonConvex` attribute, but the
150	# `Investment` attribute is optional. If it is used, the
151	# `InvestNonConvexFlow` will be used in the definition of constraints,
152	# otherwise, the `NonConvexFlow` will be used.
153	if len(self.outputs):	1✔
154	for v in self.outputs.values():	1✔
155	if not v.nonconvex:	1✔
156	raise TypeError(	1✔
157	"Output flow must have the `NonConvex` attribute!"
158	)
159
160	# `Investment` and `NonConvex` attributes cannot be defined for the
161	# input flow.
162	if len(self.inputs):	1✔
163	for v in self.inputs.values():	1✔
164	if v.investment:	1✔
165	raise TypeError(	1✔
166	"`Investment` attribute must be defined only for the "
167	+ "output flow!"
168	)
169	if v.nonconvex:	1✔
170	raise TypeError(	1✔
171	"`NonConvex` attribute must be defined only for the "
172	+ "output flow!"
173	)
174
175	if len(self.inputs) > 1:	1✔
176	raise ValueError(	1✔
177	"Component `OffsetConverter` must not have more than 1 input!"
178	)
179
180	def constraint_group(self):	1✔
181	return OffsetConverterBlock	1✔
182
183
184	# --- BEGIN: To be removed for versions >= v0.6 ---
185	class OffsetTransformer(OffsetConverter):	1✔
186	def __init__(	1✔
187	self,
188	inputs,
189	outputs,
190	label=None,
191	coefficients=None,
192	custom_attributes=None,
193	):
194	super().__init__(	1✔
195	label=label,
196	inputs=inputs,
197	outputs=outputs,
198	coefficients=coefficients,
199	custom_attributes=custom_attributes,
200	)
201	warn(	1✔
202	"solph.components.OffsetTransformer has been renamed to"
203	" solph.components.OffsetConverter. The transitional wrapper"
204	" will be deleted in the future.",
205	FutureWarning,
206	)
207
208
209	# --- END ---
210
211
212	class OffsetConverterBlock(ScalarBlock):	1✔
213	r"""Block for the relation of nodes with type
214	:class:`~oemof.solph.components._offset_converter.OffsetConverter`
215
216	The following constraints are created:
217
218	.. _OffsetConverter-equations:
219
220	.. math::
221	&
222	P_{out}(p, t) = P_{in}(p, t) \cdot C_1(t) + P_nom(p) \cdot Y(t) \cdot C_0(t) \\
223
224
225	The symbols used are defined as follows (with Variables (V) and Parameters (P)):
226
227	+--------------------+---------------------------+------+--------------------------------------------------+
228	\| symbol \| attribute \| type \| explanation \|
229	+====================+===========================+======+==================================================+
230	\| :math:`P_{out}(t)` \| `flow[n,o,p,t]` \| V \| Outflow of converter \|
231	+--------------------+---------------------------+------+--------------------------------------------------+
232	\| :math:`P_{in}(t)` \| `flow[i,n,p,t]` \| V \| Inflow of converter \|
233	+--------------------+---------------------------+------+--------------------------------------------------+
234	\| :math:`Y(t)` \| \| V \| Binary status variable of nonconvex outflow \|
235	+--------------------+---------------------------+------+--------------------------------------------------+
236	\| :math:`P_{nom}(t)` \| \| V \| Nominal value (max. capacity) of the outflow \|
237	+--------------------+---------------------------+------+--------------------------------------------------+
238	\| :math:`C_1(t)` \| `coefficients[o][1][n,t]` \| P \| Linear coefficient 1 (slope) \|
239	+--------------------+---------------------------+------+--------------------------------------------------+
240	\| :math:`C_0(t)` \| `coefficients[o][0][n,t]` \| P \| Linear coefficient 0 (y-intersection)/P_{nom}(t) \|
241	+--------------------+---------------------------+------+--------------------------------------------------+
242
243	Note that :math:`P_{nom}(t) \cdot Y(t)` is merged into one variable,
244	called `status_nominal[n, o, p, t]`.
245	""" # noqa: E501
246
247	CONSTRAINT_GROUP = True	1✔
248
249	def __init__(self, args, *kwargs):	1✔
250	super().__init__(args, *kwargs)	1✔
251
252	def _create(self, group=None):	1✔
253	"""Creates the relation for the class:`OffsetConverter`.
254
255	Parameters
256	----------
257	group : list
258	List of oemof.solph.experimental.OffsetConverter objects for
259	which the relation of inputs and outputs is created
260	e.g. group = [ostf1, ostf2, ostf3, ...]. The components inside
261	the list need to hold an attribute `coefficients` of type dict
262	containing the conversion factors for all inputs to outputs.
263	"""
264	if group is None:	1!
UNCOV 265	return None	×
266
267	m = self.parent_block()	1✔
268
269	self.OFFSETCONVERTERS = Set(initialize=[n for n in group])	1✔
270
271	in_flows = {n: [i for i in n.inputs.keys()] for n in group}	1✔
272	out_flows = {n: [o for o in n.outputs.keys()] for n in group}	1✔
273
274	self.relation = Constraint(	1✔
275	[
276	(n, i, o, p, t)
277	for p, t in m.TIMEINDEX
278	for n in group
279	for o in out_flows[n]
280	for i in in_flows[n]
281	],
282	noruleinit=True,
283	)
284
285	def _relation_rule(block):	1✔
286	"""Link binary input and output flow to component outflow."""
287	for p, t in m.TIMEINDEX:	1✔
288	for n in group:	1✔
289	for o in out_flows[n]:	1✔
290	for i in in_flows[n]:	1✔
291	expr = 0	1✔
292	expr += -m.flow[n, o, p, t]	1✔
293	expr += (	1✔
294	m.flow[i, n, p, t] * n.coefficients[o][1][t]
295	)
296	# `Y(t)` in the last term of the constraint
297	# (":math:`C_0(t) \cdot Y(t)`") is different for
298	# different cases. If both `Investment` and
299	# `NonConvex` attributes are used for the
300	# `OffsetConverter`, `Y(t)` would represent the
301	# `status_nominal[n,o,t]` in the
302	# `InvestNonConvexFlow`. But if only the
303	# `NonConvex` attribute is defined for the
304	# `OffsetConverter`, `Y(t)` would correspond to
305	# the `status_nominal[n,o,t]` in the
306	# `NonConvexFlow`.
307	try:	1✔
308	expr += (	1✔
309	m.InvestNonConvexFlowBlock.status_nominal[
310	n, o, t
311	]
312	* n.coefficients[o][0][t]
313	)
314	# `KeyError` occurs when more than one
315	# `OffsetConverter` is defined, and in some of
316	# them only the `NonConvex` attribute is
317	# considered, while in others both `NonConvex`
318	# and `Investment` attributes are defined.
319	# `AttributeError` only occurs when the
320	# `OffsetConverter` has only the `NonConvex`
321	# attribute, and therefore,
322	# `m.InvestNonConvexFlowBlock.status_nominal`
323	# (inside the `try` block) does not exist.
324	except (KeyError, AttributeError):	1✔
325	expr += (	1✔
326	m.NonConvexFlowBlock.status_nominal[
327	n, o, t
328	]
329	* n.coefficients[o][0][t]
330	)
331	block.relation.add((n, i, o, p, t), (expr == 0))	1✔
332
333	self.relation_build = BuildAction(rule=_relation_rule)	1✔

oemof / oemof-solph / 9180492083

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