9270993638

Committed 28 May 2024 02:14PM UTC coverage: 96.407% (-0.04%) from 96.447%

Build # 9270993638

Build Type

Pull #1068

github

Committed by

web-flow

Commit Message

Merge 08bd06b75 into b35efad9e

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

Run Details

1321 of 1399 branches covered (94.42%)

Branch coverage included in aggregate %.

60 of 61 new or added lines in 1 file covered. (98.36%)

1 existing line in 1 file now uncovered.

2623 of 2692 relevant lines covered (97.44%)

2.92 hits per line

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

94.51

/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,
        custom_attributes=None,
    ):
        if custom_attributes is None:
            custom_attributes = {}

        super().__init__(
            inputs=inputs,
            outputs=outputs,
            label=label,
            custom_properties=custom_attributes,
        )

        _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


# --- 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	3✔
23
24	from oemof.network import Node	3✔
25	from pyomo.core import BuildAction	3✔
26	from pyomo.core.base.block import ScalarBlock	3✔
27	from pyomo.environ import Constraint	3✔
28	from pyomo.environ import Set	3✔
29
30	from oemof.solph._plumbing import sequence	3✔
31
32
33	class OffsetConverter(Node):	3✔
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__(	3✔
112	self,
113	inputs,
114	outputs,
115	label=None,
116	conversion_factors=None,
117	normed_offsets=None,
118	custom_attributes=None,
119	):
120	if custom_attributes is None:	3!
121	custom_attributes = {}	3✔
122
123	super().__init__(	3✔
124	inputs=inputs,
125	outputs=outputs,
126	label=label,
127	custom_properties=custom_attributes,
128	)
129
130	_reference_flow = [v for v in self.inputs.values() if v.nonconvex]	3✔
131	_reference_flow += [v for v in self.outputs.values() if v.nonconvex]	3✔
132	if len(_reference_flow) != 1:	3✔
133	raise ValueError(	3✔
134	"Exactly one flow of the `OffsetConverter` must have the "
135	"`NonConvex` attribute."
136	)
137
138	if _reference_flow[0] in self.inputs.values():	3✔
139	self._reference_node_at_input = True	3✔
140	self._reference_node = _reference_flow[0].input	3✔
141	else:
142	self._reference_node_at_input = False	3✔
143	self._reference_node = _reference_flow[0].output	3✔
144
145	_investment_node = [	3✔
146	v.input for v in self.inputs.values() if v.investment
147	]
148	_investment_node += [	3✔
149	v.output for v in self.outputs.values() if v.investment
150	]
151
152	if len(_investment_node) > 0:	3✔
153	if (	3✔
154	len(_investment_node) > 1
155	or self._reference_node != _investment_node[0]
156	):
157	raise TypeError(	3✔
158	"`Investment` attribute must be defined only for the "
159	"NonConvex flow!"
160	)
161
162	if conversion_factors is None:	3✔
163	conversion_factors = {}	3✔
164
165	if self._reference_node in conversion_factors:	3!
NEW 166	raise ValueError(	×
167	"Conversion factors cannot be specified for the `NonConvex` "
168	"flow."
169	)
170
171	self.conversion_factors = {	3✔
172	k: sequence(v) for k, v in conversion_factors.items()
173	}
174
175	missing_conversion_factor_keys = (	3✔
176	set(self.outputs) \| set(self.inputs)
177	) - set(self.conversion_factors)
178
179	for cf in missing_conversion_factor_keys:	3✔
180	self.conversion_factors[cf] = sequence(1)	3✔
181
182	if normed_offsets is None:	3✔
183	normed_offsets = {}	3✔
184
185	if self._reference_node in normed_offsets:	3!
UNCOV 186	raise ValueError(	×
187	"Normed offsets cannot be specified for the `NonConvex` flow."
188	)
189
190	self.normed_offsets = {	3✔
191	k: sequence(v) for k, v in normed_offsets.items()
192	}
193
194	missing_normed_offsets_keys = (	3✔
195	set(self.outputs) \| set(self.inputs)
196	) - set(self.normed_offsets)
197
198	for cf in missing_normed_offsets_keys:	3✔
199	self.normed_offsets[cf] = sequence(0)	3✔
200
201	def constraint_group(self):	3✔
202	return OffsetConverterBlock	3✔
203
204
205	# --- BEGIN: To be removed for versions >= v0.6 ---
206	class OffsetTransformer(OffsetConverter):	3✔
207	def __init__(	3✔
208	self,
209	inputs,
210	outputs,
211	label=None,
212	conversion_factors=None,
213	normed_offsets=None,
214	custom_attributes=None,
215	):
216	super().__init__(	3✔
217	label=label,
218	inputs=inputs,
219	outputs=outputs,
220	conversion_factors=conversion_factors,
221	normed_offsets=normed_offsets,
222	custom_attributes=custom_attributes,
223	)
224	warn(	3✔
225	"solph.components.OffsetTransformer has been renamed to"
226	" solph.components.OffsetConverter. The transitional wrapper"
227	" will be deleted in the future.",
228	FutureWarning,
229	)
230
231
232	# --- END ---
233
234
235	class OffsetConverterBlock(ScalarBlock):	3✔
236	r"""Block for the relation of nodes with type
237	:class:`~oemof.solph.components._offset_converter.OffsetConverter`
238
239	The following constraints are created:
240
241	.. _OffsetConverter-equations:
242
243	.. math::
244	&
245	P_{out}(p, t) = P_{in}(p, t) \cdot C_1(t) + P_nom(p) \cdot Y(t) \cdot C_0(t) \\
246
247
248	The symbols used are defined as follows (with Variables (V) and Parameters (P)):
249
250	+--------------------+---------------------------+------+--------------------------------------------------+
251	\| symbol \| attribute \| type \| explanation \|
252	+====================+===========================+======+==================================================+
253	\| :math:`P_{out}(t)` \| `flow[n,o,p,t]` \| V \| Outflow of converter \|
254	+--------------------+---------------------------+------+--------------------------------------------------+
255	\| :math:`P_{in}(t)` \| `flow[i,n,p,t]` \| V \| Inflow of converter \|
256	+--------------------+---------------------------+------+--------------------------------------------------+
257	\| :math:`Y(t)` \| \| V \| Binary status variable of nonconvex outflow \|
258	+--------------------+---------------------------+------+--------------------------------------------------+
259	\| :math:`P_{nom}(t)` \| \| V \| Nominal value (max. capacity) of the outflow \|
260	+--------------------+---------------------------+------+--------------------------------------------------+
261	\| :math:`C_1(t)` \| `coefficients[o][1][n,t]` \| P \| Linear coefficient 1 (slope) \|
262	+--------------------+---------------------------+------+--------------------------------------------------+
263	\| :math:`C_0(t)` \| `coefficients[o][0][n,t]` \| P \| Linear coefficient 0 (y-intersection)/P_{nom}(t) \|
264	+--------------------+---------------------------+------+--------------------------------------------------+
265
266	Note that :math:`P_{nom}(t) \cdot Y(t)` is merged into one variable,
267	called `status_nominal[n, o, p, t]`.
268	""" # noqa: E501
269
270	CONSTRAINT_GROUP = True	3✔
271
272	def __init__(self, args, *kwargs):	3✔
273	super().__init__(args, *kwargs)	3✔
274
275	def _create(self, group=None):	3✔
276	"""Creates the relation for the class:`OffsetConverter`.
277
278	Parameters
279	----------
280	group : list
281	List of oemof.solph.experimental.OffsetConverter objects for
282	which the relation of inputs and outputs is created
283	e.g. group = [ostf1, ostf2, ostf3, ...]. The components inside
284	the list need to hold an attribute `coefficients` of type dict
285	containing the conversion factors for all inputs to outputs.
286	"""
287	if group is None:	3!
288	return None	×
289
290	m = self.parent_block()	3✔
291
292	self.OFFSETCONVERTERS = Set(initialize=[n for n in group])	3✔
293
294	reference_node = {n: n._reference_node for n in group}	3✔
295	reference_node_at_input = {	3✔
296	n: n._reference_node_at_input for n in group
297	}
298	in_flows = {	3✔
299	n: [i for i in n.inputs.keys() if i != n._reference_node]
300	for n in group
301	}
302	out_flows = {	3✔
303	n: [o for o in n.outputs.keys() if o != n._reference_node]
304	for n in group
305	}
306
307	self.relation = Constraint(	3✔
308	[
309	(n, reference_node[n], f, p, t)
310	for p, t in m.TIMEINDEX
311	for n in group
312	for f in in_flows[n] + out_flows[n]
313	],
314	noruleinit=True,
315	)
316
317	def _relation_rule(block):	3✔
318	"""Link binary input and output flow to component outflow."""
319	for p, t in m.TIMEINDEX:	3✔
320	for n in group:	3✔
321
322	if reference_node_at_input[n]:	3✔
323	ref_flow = m.flow[reference_node[n], n, p, t]	3✔
324	status_nominal_idx = reference_node[n], n, t	3✔
325	else:
326	ref_flow = m.flow[n, reference_node[n], p, t]	3✔
327	status_nominal_idx = n, reference_node[n], t	3✔
328
329	if hasattr(m.NonConvexFlowBlock, "status_nominal"):	3✔
330	status_nominal = m.NonConvexFlowBlock.status_nominal	3✔
331
332	if hasattr(m, "InvestNonConvexFlowBlock"):	3!
333	if hasattr(	3✔
334	m.InvestNonConvexFlowBlock, "status_nominal"
335	):
336	if (	3!
337	status_nominal_idx
338	in m.InvestNonConvexFlowBlock.status_nominal
339	):
340	status_nominal = (	3✔
341	m.InvestNonConvexFlowBlock.status_nominal
342	)
343
344	ref_status_nominal = status_nominal[status_nominal_idx]	3✔
345
346	for f in in_flows[n] + out_flows[n]:	3✔
347	rhs = 0	3✔
348	if f in in_flows[n]:	3✔
349	rhs += m.flow[f, n, p, t]	3✔
350	else:
351	rhs += m.flow[n, f, p, t]	3✔
352
353	lhs = 0	3✔
354	lhs += ref_flow * n.conversion_factors[f][t]	3✔
355	lhs += ref_status_nominal * n.normed_offsets[f][t]	3✔
356	block.relation.add(	3✔
357	(n, reference_node[n], f, p, t), (lhs == rhs)
358	)
359
360	self.relation_build = BuildAction(rule=_relation_rule)	3✔
361
362
363	def calculate_slope_and_offset_with_reference_to_input(	3✔
364	max, min, eta_max, eta_min
365	):
366	slope = (max * eta_max - min * eta_min) / (max - min)	3✔
367	offset = eta_max - slope	3✔
368	return slope, offset	3✔
369
370
371	def calculate_slope_and_offset_with_reference_to_output(	3✔
372	max, min, eta_max, eta_min
373	):
374	slope = (max / eta_max - min / eta_min) / (max - min)	3✔
375	offset = 1 / eta_max - slope	3✔
376	return slope, offset	3✔

oemof / oemof-solph / 9270993638

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