9384060297

Committed 05 Jun 2024 12:27PM UTC coverage: 96.257% (-0.2%) from 96.447%

Build # 9384060297

Build Type

Pull #1068

github

Committed by

web-flow

Commit Message

Merge 5d50d2123 into a848e7bd3

Pull Request Pull Request #1068: Enforce nonconvex for OffsetConverter on a single flow instead of outputs

Run Details

1331 of 1412 branches covered (94.26%)

Branch coverage included in aggregate %.

90 of 94 new or added lines in 1 file covered. (95.74%)

3 existing lines in 2 files now uncovered.

2655 of 2729 relevant lines covered (97.29%)

1.95 hits per line

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

92.89

/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
    ----------
    conversion_factors : dict, (:math:`C_1(t)`)
        Dict containing the respective bus as key and as value the parameter
        :math:`C_1(t)`. It represents the slope of a linear equation with
        respect to the `NonConvex` flow. The value can either be a scalar or a
        sequence with length of time horizon for simulation.

    normed_offsets : dict, (:math:`C_0(t)`)
        Dict containing the respective bus as key and as value the parameter
        :math:`C_0(t)`. It represents the y-intercept with respect to the
        `NonConvex` flow divided by the `nominal_value` of the `NonConvex` flow
        (this is for internal purposes). The value 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 = \\frac{(l_{max}/\\eta_{max}-l_{min}/\\eta_{min}}{l_{max}-l_{min}}

        C_0 = \\frac{1}{\\eta_{max}} - C_1

    Where :math:`l_{max}` and :math:`l_{min}` are the maximum and minimum
    partload share (e.g. 1.0 and 0.5) with reference to the `NonConvex` flow
    and :math:`\\eta_{max}` and :math:`\\eta_{min}` are the respective
    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_nominal = 60
    >>> l_max = 1
    >>> l_min = 0.5
    >>> eta_max = 0.5
    >>> eta_min = 0.3
    >>> c1 = (l_max / eta_max - l_min / eta_min) / (l_max - l_min)
    >>> c0 = 1 / eta_max - c1
    >>> ostf = solph.components.OffsetConverter(
    ...    label='ostf',
    ...    inputs={bel: solph.flows.Flow()},
    ...    outputs={bth: solph.flows.Flow(
    ...         nominal_value=l_nominal, min=l_min, max=l_max,
    ...         nonconvex=solph.NonConvex())},
    ...    conversion_factors={bel: c1},
    ...    normed_offsets={bel: c0},
    ... )
    >>> type(ostf)
    <class 'oemof.solph.components._offset_converter.OffsetConverter'>

    The input required to operate at minimum load, can be computed from the
    slope and offset:

    >>> input_at_min = ostf.conversion_factors[bel][0] * l_min + ostf.normed_offsets[bel][0] * l_max
    >>> input_at_min * l_nominal
    100.0

    The same can be done for the input at nominal load:

    >>> input_at_max = l_max * (ostf.conversion_factors[bel][0] + ostf.normed_offsets[bel][0])
    >>> input_at_max * l_nominal
    120.0

    """  # noqa: E501

    def __init__(
        self,
        inputs,
        outputs,
        label=None,
        conversion_factors=None,
        normed_offsets=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,
        )

        # this part is used for the transition phase from the old OffsetConverter
        # API to the new one. It calcualtes the conversion_factors and normed_offsets
        # from the coefficients and the outputs information on min and max.
        if coefficients is not None and conversion_factors is None and normed_offsets is None:
            normed_offsets, conversion_factors = self.get_normed_offset_and_conversion_factors_from_old_style_coefficients(coefficients)

        elif coefficients is not None and (conversion_factors is not None or normed_offsets is not None):
            msg = ""
            raise TypeError(msg)

        _reference_flow = [v for v in self.inputs.values() if v.nonconvex]
        _reference_flow += [v for v in self.outputs.values() if v.nonconvex]
        if len(_reference_flow) != 1:
            raise ValueError(
                "Exactly one flow of the `OffsetConverter` must have the "
                "`NonConvex` attribute."
            )

        if _reference_flow[0] in self.inputs.values():
            self._reference_node_at_input = True
            self._reference_node = _reference_flow[0].input
        else:
            self._reference_node_at_input = False
            self._reference_node = _reference_flow[0].output

        _investment_node = [
            v.input for v in self.inputs.values() if v.investment
        ]
        _investment_node += [
            v.output for v in self.outputs.values() if v.investment
        ]

        if len(_investment_node) > 0:
            if (
                len(_investment_node) > 1
                or self._reference_node != _investment_node[0]
            ):
                raise TypeError(
                    "`Investment` attribute must be defined only for the "
                    "NonConvex flow!"
                )

        if conversion_factors is None:
            conversion_factors = {}

        if self._reference_node in conversion_factors:
            raise ValueError(
                "Conversion factors cannot be specified for the `NonConvex` "
                "flow."
            )

        self.conversion_factors = {
            k: sequence(v) for k, v in conversion_factors.items()
        }

        missing_conversion_factor_keys = (
            set(self.outputs) | set(self.inputs)
        ) - set(self.conversion_factors)

        for cf in missing_conversion_factor_keys:
            self.conversion_factors[cf] = sequence(1)

        if normed_offsets is None:
            normed_offsets = {}

        if self._reference_node in normed_offsets:
            raise ValueError(
                "Normed offsets cannot be specified for the `NonConvex` flow."
            )

        self.normed_offsets = {
            k: sequence(v) for k, v in normed_offsets.items()
        }

        missing_normed_offsets_keys = (
            set(self.outputs) | set(self.inputs)
        ) - set(self.normed_offsets)

        for cf in missing_normed_offsets_keys:
            self.normed_offsets[cf] = sequence(0)

    def constraint_group(self):
        return OffsetConverterBlock

    def get_normed_offset_and_conversion_factors_from_old_style_coefficients(self, coefficients):

        coefficients = tuple([sequence(i) for i in coefficients])
        if len(coefficients) != 2:
            raise ValueError(
                "Two coefficients or coefficient series have to be given."
            )

        input_bus = list(self.inputs.values())[0].input
        for flow in self.outputs.values():

            max_len = max(len(flow.max), len(flow.min), len(coefficients[0]), len(coefficients[1]))
            flow.max[max_len - 1]
            flow.min[max_len - 1]
            coefficients[0][max_len - 1]
            coefficients[1][max_len - 1]

            # this could by vectorized, but since it is an API compatibility fix
            # I will not do this here
            eta_at_max = sequence(0)
            eta_at_min = sequence(0)
            slope = []
            offset = []
            for i in range(max_len):
                eta_at_max = flow.max[i] * coefficients[1][i] / (flow.max[i] - coefficients[0][i])
                eta_at_min = flow.min[i] * coefficients[1][i] / (flow.min[i] - coefficients[0][i])

                c0, c1 = calculate_slope_and_offset_with_reference_to_output(flow.max[i], flow.min[i], eta_at_max, eta_at_min)
                slope += [c0]
                offset += [c1]

            # apparently, when coefficients are given as a list, it is assumed,
            # that the list identical in length to the timeindex
            # There should be a general check, if lenghts match then!
            if max_len == 1:
                slope = sequence(slope[0])
                offset = sequence(offset[0])

            conversion_factors = {input_bus: slope}
            normed_offsets = {input_bus: offset}
            msg = ""

        return normed_offsets, conversion_factors


# --- BEGIN: To be removed for versions >= v0.6 ---
class OffsetTransformer(OffsetConverter):
    def __init__(
        self,
        inputs,
        outputs,
        label=None,
        conversion_factors=None,
        normed_offsets=None,
        custom_attributes=None,
    ):
        super().__init__(
            label=label,
            inputs=inputs,
            outputs=outputs,
            conversion_factors=conversion_factors,
            normed_offsets=normed_offsets,
            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])

        reference_node = {n: n._reference_node for n in group}
        reference_node_at_input = {
            n: n._reference_node_at_input for n in group
        }
        in_flows = {
            n: [i for i in n.inputs.keys() if i != n._reference_node]
            for n in group
        }
        out_flows = {
            n: [o for o in n.outputs.keys() if o != n._reference_node]
            for n in group
        }

        self.relation = Constraint(
            [
                (n, reference_node[n], f, p, t)
                for p, t in m.TIMEINDEX
                for n in group
                for f in in_flows[n] + out_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:

                    if reference_node_at_input[n]:
                        ref_flow = m.flow[reference_node[n], n, p, t]
                        status_nominal_idx = reference_node[n], n, t
                    else:
                        ref_flow = m.flow[n, reference_node[n], p, t]
                        status_nominal_idx = n, reference_node[n], t

                    if hasattr(m.NonConvexFlowBlock, "status_nominal"):
                        status_nominal = m.NonConvexFlowBlock.status_nominal

                    if hasattr(m, "InvestNonConvexFlowBlock"):
                        if hasattr(
                            m.InvestNonConvexFlowBlock, "status_nominal"
                        ):
                            if (
                                status_nominal_idx
                                in m.InvestNonConvexFlowBlock.status_nominal
                            ):
                                status_nominal = (
                                    m.InvestNonConvexFlowBlock.status_nominal
                                )

                    ref_status_nominal = status_nominal[status_nominal_idx]

                    for f in in_flows[n] + out_flows[n]:
                        rhs = 0
                        if f in in_flows[n]:
                            rhs += m.flow[f, n, p, t]
                        else:
                            rhs += m.flow[n, f, p, t]

                        lhs = 0
                        lhs += ref_flow * n.conversion_factors[f][t]
                        lhs += ref_status_nominal * n.normed_offsets[f][t]
                        block.relation.add(
                            (n, reference_node[n], f, p, t), (lhs == rhs)
                        )

        self.relation_build = BuildAction(rule=_relation_rule)


def calculate_slope_and_offset_with_reference_to_input(
    max, min, eta_max, eta_min
):
    slope = (max * eta_max - min * eta_min) / (max - min)
    offset = eta_max - slope
    return slope, offset


def calculate_slope_and_offset_with_reference_to_output(
    max, min, eta_max, eta_min
):
    slope = (max / eta_max - min / eta_min) / (max - min)
    offset = 1 / eta_max - slope
    return slope, offset

1	# -*- coding: utf-8 -
2
3	"""
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	2✔
23
24	from oemof.network import Node	2✔
25	from pyomo.core import BuildAction	2✔
26	from pyomo.core.base.block import ScalarBlock	2✔
27	from pyomo.environ import Constraint	2✔
28	from pyomo.environ import Set	2✔
29
30	from oemof.solph._plumbing import sequence	2✔
31
32
33	class OffsetConverter(Node):	2✔
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	conversion_factors : dict, (:math:`C_1(t)`)
41	Dict containing the respective bus as key and as value the parameter
42	:math:`C_1(t)`. It represents the slope of a linear equation with
43	respect to the `NonConvex` flow. The value can either be a scalar or a
44	sequence with length of time horizon for simulation.
45
46	normed_offsets : dict, (:math:`C_0(t)`)
47	Dict containing the respective bus as key and as value the parameter
48	:math:`C_0(t)`. It represents the y-intercept with respect to the
49	`NonConvex` flow divided by the `nominal_value` of the `NonConvex` flow
50	(this is for internal purposes). The value can either be a scalar or a
51	sequence with length of time horizon for simulation.
52	Notes
53	-----
54	C_1 and C_0 can be calculated as follows:
55
56	.. _OffsetConverterCoefficients-equations:
57
58	.. math::
59
60	C_1 = \\frac{(l_{max}/\\eta_{max}-l_{min}/\\eta_{min}}{l_{max}-l_{min}}
61
62	C_0 = \\frac{1}{\\eta_{max}} - C_1
63
64	Where :math:`l_{max}` and :math:`l_{min}` are the maximum and minimum
65	partload share (e.g. 1.0 and 0.5) with reference to the `NonConvex` flow
66	and :math:`\\eta_{max}` and :math:`\\eta_{min}` are the respective
67	efficiencies/conversion factors at these partloads.
68
69	The sets, variables, constraints and objective parts are created
70	* :py:class:`~oemof.solph.components._offset_converter.OffsetConverterBlock`
71
72	Examples
73	--------
74	>>> from oemof import solph
75	>>> bel = solph.buses.Bus(label='bel')
76	>>> bth = solph.buses.Bus(label='bth')
77	>>> l_nominal = 60
78	>>> l_max = 1
79	>>> l_min = 0.5
80	>>> eta_max = 0.5
81	>>> eta_min = 0.3
82	>>> c1 = (l_max / eta_max - l_min / eta_min) / (l_max - l_min)
83	>>> c0 = 1 / eta_max - c1
84	>>> ostf = solph.components.OffsetConverter(
85	... label='ostf',
86	... inputs={bel: solph.flows.Flow()},
87	... outputs={bth: solph.flows.Flow(
88	... nominal_value=l_nominal, min=l_min, max=l_max,
89	... nonconvex=solph.NonConvex())},
90	... conversion_factors={bel: c1},
91	... normed_offsets={bel: c0},
92	... )
93	>>> type(ostf)
94	<class 'oemof.solph.components._offset_converter.OffsetConverter'>
95
96	The input required to operate at minimum load, can be computed from the
97	slope and offset:
98
99	>>> input_at_min = ostf.conversion_factors[bel][0] * l_min + ostf.normed_offsets[bel][0] * l_max
100	>>> input_at_min * l_nominal
101	100.0
102
103	The same can be done for the input at nominal load:
104
105	>>> input_at_max = l_max * (ostf.conversion_factors[bel][0] + ostf.normed_offsets[bel][0])
106	>>> input_at_max * l_nominal
107	120.0
108
109	""" # noqa: E501
110
111	def __init__(	2✔
112	self,
113	inputs,
114	outputs,
115	label=None,
116	conversion_factors=None,
117	normed_offsets=None,
118	coefficients=None,
119	custom_attributes=None,
120	):
121	if custom_attributes is None:	2!
122	custom_attributes = {}	2✔
123
124	super().__init__(	2✔
125	inputs=inputs,
126	outputs=outputs,
127	label=label,
128	custom_properties=custom_attributes,
129	)
130
131	# this part is used for the transition phase from the old OffsetConverter
132	# API to the new one. It calcualtes the conversion_factors and normed_offsets
133	# from the coefficients and the outputs information on min and max.
134	if coefficients is not None and conversion_factors is None and normed_offsets is None:	2✔
135	normed_offsets, conversion_factors = self.get_normed_offset_and_conversion_factors_from_old_style_coefficients(coefficients)	2✔
136
137	elif coefficients is not None and (conversion_factors is not None or normed_offsets is not None):	2!
NEW 138	msg = ""	×
NEW 139	raise TypeError(msg)	×
140
141	_reference_flow = [v for v in self.inputs.values() if v.nonconvex]	2✔
142	_reference_flow += [v for v in self.outputs.values() if v.nonconvex]	2✔
143	if len(_reference_flow) != 1:	2✔
144	raise ValueError(	2✔
145	"Exactly one flow of the `OffsetConverter` must have the "
146	"`NonConvex` attribute."
147	)
148
149	if _reference_flow[0] in self.inputs.values():	2✔
150	self._reference_node_at_input = True	2✔
151	self._reference_node = _reference_flow[0].input	2✔
152	else:
153	self._reference_node_at_input = False	2✔
154	self._reference_node = _reference_flow[0].output	2✔
155
156	_investment_node = [	2✔
157	v.input for v in self.inputs.values() if v.investment
158	]
159	_investment_node += [	2✔
160	v.output for v in self.outputs.values() if v.investment
161	]
162
163	if len(_investment_node) > 0:	2✔
164	if (	2✔
165	len(_investment_node) > 1
166	or self._reference_node != _investment_node[0]
167	):
168	raise TypeError(	2✔
169	"`Investment` attribute must be defined only for the "
170	"NonConvex flow!"
171	)
172
173	if conversion_factors is None:	2✔
174	conversion_factors = {}	2✔
175
176	if self._reference_node in conversion_factors:	2!
NEW 177	raise ValueError(	×
178	"Conversion factors cannot be specified for the `NonConvex` "
179	"flow."
180	)
181
182	self.conversion_factors = {	2✔
183	k: sequence(v) for k, v in conversion_factors.items()
184	}
185
186	missing_conversion_factor_keys = (	2✔
187	set(self.outputs) \| set(self.inputs)
188	) - set(self.conversion_factors)
189
190	for cf in missing_conversion_factor_keys:	2✔
191	self.conversion_factors[cf] = sequence(1)	2✔
192
193	if normed_offsets is None:	2✔
194	normed_offsets = {}	2✔
195
196	if self._reference_node in normed_offsets:	2!
UNCOV 197	raise ValueError(	×
198	"Normed offsets cannot be specified for the `NonConvex` flow."
199	)
200
201	self.normed_offsets = {	2✔
202	k: sequence(v) for k, v in normed_offsets.items()
203	}
204
205	missing_normed_offsets_keys = (	2✔
206	set(self.outputs) \| set(self.inputs)
207	) - set(self.normed_offsets)
208
209	for cf in missing_normed_offsets_keys:	2✔
210	self.normed_offsets[cf] = sequence(0)	2✔
211
212	def constraint_group(self):	2✔
213	return OffsetConverterBlock	2✔
214
215	def get_normed_offset_and_conversion_factors_from_old_style_coefficients(self, coefficients):	2✔
216
217	coefficients = tuple([sequence(i) for i in coefficients])	2✔
218	if len(coefficients) != 2:	2!
NEW 219	raise ValueError(	×
220	"Two coefficients or coefficient series have to be given."
221	)
222
223	input_bus = list(self.inputs.values())[0].input	2✔
224	for flow in self.outputs.values():	2✔
225
226	max_len = max(len(flow.max), len(flow.min), len(coefficients[0]), len(coefficients[1]))	2✔
227	flow.max[max_len - 1]	2✔
228	flow.min[max_len - 1]	2✔
229	coefficients[0][max_len - 1]	2✔
230	coefficients[1][max_len - 1]	2✔
231
232	# this could by vectorized, but since it is an API compatibility fix
233	# I will not do this here
234	eta_at_max = sequence(0)	2✔
235	eta_at_min = sequence(0)	2✔
236	slope = []	2✔
237	offset = []	2✔
238	for i in range(max_len):	2✔
239	eta_at_max = flow.max[i] * coefficients[1][i] / (flow.max[i] - coefficients[0][i])	2✔
240	eta_at_min = flow.min[i] * coefficients[1][i] / (flow.min[i] - coefficients[0][i])	2✔
241
242	c0, c1 = calculate_slope_and_offset_with_reference_to_output(flow.max[i], flow.min[i], eta_at_max, eta_at_min)	2✔
243	slope += [c0]	2✔
244	offset += [c1]	2✔
245
246	# apparently, when coefficients are given as a list, it is assumed,
247	# that the list identical in length to the timeindex
248	# There should be a general check, if lenghts match then!
249	if max_len == 1:	2!
250	slope = sequence(slope[0])	2✔
251	offset = sequence(offset[0])	2✔
252
253	conversion_factors = {input_bus: slope}	2✔
254	normed_offsets = {input_bus: offset}	2✔
255	msg = ""	2✔
256
257	return normed_offsets, conversion_factors	2✔
258
259
260	# --- BEGIN: To be removed for versions >= v0.6 ---
261	class OffsetTransformer(OffsetConverter):	2✔
262	def __init__(	2✔
263	self,
264	inputs,
265	outputs,
266	label=None,
267	conversion_factors=None,
268	normed_offsets=None,
269	custom_attributes=None,
270	):
271	super().__init__(	2✔
272	label=label,
273	inputs=inputs,
274	outputs=outputs,
275	conversion_factors=conversion_factors,
276	normed_offsets=normed_offsets,
277	custom_attributes=custom_attributes,
278	)
279	warn(	2✔
280	"solph.components.OffsetTransformer has been renamed to"
281	" solph.components.OffsetConverter. The transitional wrapper"
282	" will be deleted in the future.",
283	FutureWarning,
284	)
285
286
287	# --- END ---
288
289
290	class OffsetConverterBlock(ScalarBlock):	2✔
291	r"""Block for the relation of nodes with type
292	:class:`~oemof.solph.components._offset_converter.OffsetConverter`
293
294	The following constraints are created:
295
296	.. _OffsetConverter-equations:
297
298	.. math::
299	&
300	P_{out}(p, t) = P_{in}(p, t) \cdot C_1(t) + P_nom(p) \cdot Y(t) \cdot C_0(t) \\
301
302
303	The symbols used are defined as follows (with Variables (V) and Parameters (P)):
304
305	+--------------------+---------------------------+------+--------------------------------------------------+
306	\| symbol \| attribute \| type \| explanation \|
307	+====================+===========================+======+==================================================+
308	\| :math:`P_{out}(t)` \| `flow[n,o,p,t]` \| V \| Outflow of converter \|
309	+--------------------+---------------------------+------+--------------------------------------------------+
310	\| :math:`P_{in}(t)` \| `flow[i,n,p,t]` \| V \| Inflow of converter \|
311	+--------------------+---------------------------+------+--------------------------------------------------+
312	\| :math:`Y(t)` \| \| V \| Binary status variable of nonconvex outflow \|
313	+--------------------+---------------------------+------+--------------------------------------------------+
314	\| :math:`P_{nom}(t)` \| \| V \| Nominal value (max. capacity) of the outflow \|
315	+--------------------+---------------------------+------+--------------------------------------------------+
316	\| :math:`C_1(t)` \| `coefficients[o][1][n,t]` \| P \| Linear coefficient 1 (slope) \|
317	+--------------------+---------------------------+------+--------------------------------------------------+
318	\| :math:`C_0(t)` \| `coefficients[o][0][n,t]` \| P \| Linear coefficient 0 (y-intersection)/P_{nom}(t) \|
319	+--------------------+---------------------------+------+--------------------------------------------------+
320
321	Note that :math:`P_{nom}(t) \cdot Y(t)` is merged into one variable,
322	called `status_nominal[n, o, p, t]`.
323	""" # noqa: E501
324
325	CONSTRAINT_GROUP = True	2✔
326
327	def __init__(self, args, *kwargs):	2✔
328	super().__init__(args, *kwargs)	2✔
329
330	def _create(self, group=None):	2✔
331	"""Creates the relation for the class:`OffsetConverter`.
332
333	Parameters
334	----------
335	group : list
336	List of oemof.solph.experimental.OffsetConverter objects for
337	which the relation of inputs and outputs is created
338	e.g. group = [ostf1, ostf2, ostf3, ...]. The components inside
339	the list need to hold an attribute `coefficients` of type dict
340	containing the conversion factors for all inputs to outputs.
341	"""
342	if group is None:	2!
343	return None	×
344
345	m = self.parent_block()	2✔
346
347	self.OFFSETCONVERTERS = Set(initialize=[n for n in group])	2✔
348
349	reference_node = {n: n._reference_node for n in group}	2✔
350	reference_node_at_input = {	2✔
351	n: n._reference_node_at_input for n in group
352	}
353	in_flows = {	2✔
354	n: [i for i in n.inputs.keys() if i != n._reference_node]
355	for n in group
356	}
357	out_flows = {	2✔
358	n: [o for o in n.outputs.keys() if o != n._reference_node]
359	for n in group
360	}
361
362	self.relation = Constraint(	2✔
363	[
364	(n, reference_node[n], f, p, t)
365	for p, t in m.TIMEINDEX
366	for n in group
367	for f in in_flows[n] + out_flows[n]
368	],
369	noruleinit=True,
370	)
371
372	def _relation_rule(block):	2✔
373	"""Link binary input and output flow to component outflow."""
374	for p, t in m.TIMEINDEX:	2✔
375	for n in group:	2✔
376
377	if reference_node_at_input[n]:	2✔
378	ref_flow = m.flow[reference_node[n], n, p, t]	2✔
379	status_nominal_idx = reference_node[n], n, t	2✔
380	else:
381	ref_flow = m.flow[n, reference_node[n], p, t]	2✔
382	status_nominal_idx = n, reference_node[n], t	2✔
383
384	if hasattr(m.NonConvexFlowBlock, "status_nominal"):	2✔
385	status_nominal = m.NonConvexFlowBlock.status_nominal	2✔
386
387	if hasattr(m, "InvestNonConvexFlowBlock"):	2!
388	if hasattr(	2✔
389	m.InvestNonConvexFlowBlock, "status_nominal"
390	):
391	if (	2!
392	status_nominal_idx
393	in m.InvestNonConvexFlowBlock.status_nominal
394	):
395	status_nominal = (	2✔
396	m.InvestNonConvexFlowBlock.status_nominal
397	)
398
399	ref_status_nominal = status_nominal[status_nominal_idx]	2✔
400
401	for f in in_flows[n] + out_flows[n]:	2✔
402	rhs = 0	2✔
403	if f in in_flows[n]:	2✔
404	rhs += m.flow[f, n, p, t]	2✔
405	else:
406	rhs += m.flow[n, f, p, t]	2✔
407
408	lhs = 0	2✔
409	lhs += ref_flow * n.conversion_factors[f][t]	2✔
410	lhs += ref_status_nominal * n.normed_offsets[f][t]	2✔
411	block.relation.add(	2✔
412	(n, reference_node[n], f, p, t), (lhs == rhs)
413	)
414
415	self.relation_build = BuildAction(rule=_relation_rule)	2✔
416
417
418	def calculate_slope_and_offset_with_reference_to_input(	2✔
419	max, min, eta_max, eta_min
420	):
421	slope = (max * eta_max - min * eta_min) / (max - min)	2✔
422	offset = eta_max - slope	2✔
423	return slope, offset	2✔
424
425
426	def calculate_slope_and_offset_with_reference_to_output(	2✔
427	max, min, eta_max, eta_min
428	):
429	slope = (max / eta_max - min / eta_min) / (max - min)	2✔
430	offset = 1 / eta_max - slope	2✔
431	return slope, offset	2✔

oemof / oemof-solph / 9384060297

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