9384374946

Committed 05 Jun 2024 12:47PM UTC coverage: 96.403% (-0.04%) from 96.447%

Build # 9384374946

Build Type

Pull #1068

github

Committed by

web-flow

Commit Message

Merge 9efbd5cb6 into a848e7bd3

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

Run Details

1498 of 1579 branches covered (94.87%)

Branch coverage included in aggregate %.

91 of 95 new or added lines in 1 file covered. (95.79%)

3 existing lines in 2 files now uncovered.

2656 of 2730 relevant lines covered (97.29%)

0.97 hits per line

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

92.92

/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):
        """
        Calculate slope and offset for new API from the old API coefficients.

        Parameters
        ----------
        coefficients : tuple
            tuple holding the coefficients (offset, slope) for the old style
            OffsetConverter.

        Returns
        -------
        tuple
            A tuple holding the slope and the offset for the new OffsetConverter
            API.
        """
        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 = (
                "The usage of coefficients is depricated, use "
                "conversion_factors and normed_offsets instead."
            )
            warn(msg, DeprecationWarning)

        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_at_max, eta_at_min
):
    """Calculate the slope and the offset with max and min given for input

    The reference is the input flow here. That means, the `NonConvex` flow
    is specified at one of the input flows. Therefore the `max` and the `min`
    both reference that flow. `eta_at_max` and `eta_at_min` are the efficiency
    values at the referenced point.

    .. math::

        \text{slope} =
        \frac{
            \text{max} \cdot \eta_\text{at max}
            - \text{min} \cdot \eta_\text{at min}
        }{\text{max} - \text{min}}\\

        \text{offset} = \eta_\text{at,max} - \text{slope}

    Parameters
    ----------
    max : float
        Maximum load value, e.g. 1
    min : float
        Minimum load value, e.g. 0.5
    eta_at_max : float
        Efficiency at maximum load.
    eta_at_min : float
        Efficiency at minimum load.

    Returns
    -------
    tuple
        slope and offset
    """
    slope = (max * eta_at_max - min * eta_at_min) / (max - min)
    offset = eta_at_max - slope
    return slope, offset


def calculate_slope_and_offset_with_reference_to_output(
    max, min, eta_at_max, eta_at_min
):
    r"""Calculate the slope and the offset with max and min given for output.

    The reference is the output flow here. That means, the `NonConvex` flow
    is specified at one of the output flows. Therefore the `max` and the `min`
    both reference that flow. `eta_at_max` and `eta_at_min` are the efficiency
    values at the referenced point.

    .. math::

        \text{slope} =
        \frac{
            \frac{\text{max}}{\eta_\text{at max}}
            - \frac{\text{min}}{\eta_\text{at min}}
        }{\text{max} - \text{min}}\\

        \text{offset} = \frac{1}{\eta_\text{at,max}} - \text{slope}

    Parameters
    ----------
    max : float
        Maximum load value, e.g. 1
    min : float
        Minimum load value, e.g. 0.5
    eta_at_max : float
        Efficiency at maximum load.
    eta_at_min : float
        Efficiency at minimum load.

    Returns
    -------
    tuple
        slope and offset
    """
    slope = (max / eta_at_max - min / eta_at_min) / (max - min)
    offset = 1 / eta_at_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	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	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__(	1✔
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:	1!
122	custom_attributes = {}	1✔
123
124	super().__init__(	1✔
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:	1✔
135	normed_offsets, conversion_factors = self.get_normed_offset_and_conversion_factors_from_old_style_coefficients(coefficients)	1✔
136
137	elif coefficients is not None and (conversion_factors is not None or normed_offsets is not None):	1!
NEW 138	msg = ""	×
NEW 139	raise TypeError(msg)	×
140
141	_reference_flow = [v for v in self.inputs.values() if v.nonconvex]	1✔
142	_reference_flow += [v for v in self.outputs.values() if v.nonconvex]	1✔
143	if len(_reference_flow) != 1:	1✔
144	raise ValueError(	1✔
145	"Exactly one flow of the `OffsetConverter` must have the "
146	"`NonConvex` attribute."
147	)
148
149	if _reference_flow[0] in self.inputs.values():	1✔
150	self._reference_node_at_input = True	1✔
151	self._reference_node = _reference_flow[0].input	1✔
152	else:
153	self._reference_node_at_input = False	1✔
154	self._reference_node = _reference_flow[0].output	1✔
155
156	_investment_node = [	1✔
157	v.input for v in self.inputs.values() if v.investment
158	]
159	_investment_node += [	1✔
160	v.output for v in self.outputs.values() if v.investment
161	]
162
163	if len(_investment_node) > 0:	1✔
164	if (	1✔
165	len(_investment_node) > 1
166	or self._reference_node != _investment_node[0]
167	):
168	raise TypeError(	1✔
169	"`Investment` attribute must be defined only for the "
170	"NonConvex flow!"
171	)
172
173	if conversion_factors is None:	1✔
174	conversion_factors = {}	1✔
175
176	if self._reference_node in conversion_factors:	1!
NEW 177	raise ValueError(	×
178	"Conversion factors cannot be specified for the `NonConvex` "
179	"flow."
180	)
181
182	self.conversion_factors = {	1✔
183	k: sequence(v) for k, v in conversion_factors.items()
184	}
185
186	missing_conversion_factor_keys = (	1✔
187	set(self.outputs) \| set(self.inputs)
188	) - set(self.conversion_factors)
189
190	for cf in missing_conversion_factor_keys:	1✔
191	self.conversion_factors[cf] = sequence(1)	1✔
192
193	if normed_offsets is None:	1✔
194	normed_offsets = {}	1✔
195
196	if self._reference_node in normed_offsets:	1!
UNCOV 197	raise ValueError(	×
198	"Normed offsets cannot be specified for the `NonConvex` flow."
199	)
200
201	self.normed_offsets = {	1✔
202	k: sequence(v) for k, v in normed_offsets.items()
203	}
204
205	missing_normed_offsets_keys = (	1✔
206	set(self.outputs) \| set(self.inputs)
207	) - set(self.normed_offsets)
208
209	for cf in missing_normed_offsets_keys:	1✔
210	self.normed_offsets[cf] = sequence(0)	1✔
211
212	def constraint_group(self):	1✔
213	return OffsetConverterBlock	1✔
214
215	def get_normed_offset_and_conversion_factors_from_old_style_coefficients(self, coefficients):	1✔
216	"""
217	Calculate slope and offset for new API from the old API coefficients.
218
219	Parameters
220	----------
221	coefficients : tuple
222	tuple holding the coefficients (offset, slope) for the old style
223	OffsetConverter.
224
225	Returns
226	-------
227	tuple
228	A tuple holding the slope and the offset for the new OffsetConverter
229	API.
230	"""
231	coefficients = tuple([sequence(i) for i in coefficients])	1✔
232	if len(coefficients) != 2:	1!
NEW 233	raise ValueError(	×
234	"Two coefficients or coefficient series have to be given."
235	)
236
237	input_bus = list(self.inputs.values())[0].input	1✔
238	for flow in self.outputs.values():	1✔
239
240	max_len = max(len(flow.max), len(flow.min), len(coefficients[0]), len(coefficients[1]))	1✔
241	flow.max[max_len - 1]	1✔
242	flow.min[max_len - 1]	1✔
243	coefficients[0][max_len - 1]	1✔
244	coefficients[1][max_len - 1]	1✔
245
246	# this could by vectorized, but since it is an API compatibility fix
247	# I will not do this here
248	eta_at_max = sequence(0)	1✔
249	eta_at_min = sequence(0)	1✔
250	slope = []	1✔
251	offset = []	1✔
252	for i in range(max_len):	1✔
253	eta_at_max = flow.max[i] * coefficients[1][i] / (flow.max[i] - coefficients[0][i])	1✔
254	eta_at_min = flow.min[i] * coefficients[1][i] / (flow.min[i] - coefficients[0][i])	1✔
255
256	c0, c1 = calculate_slope_and_offset_with_reference_to_output(flow.max[i], flow.min[i], eta_at_max, eta_at_min)	1✔
257	slope += [c0]	1✔
258	offset += [c1]	1✔
259
260	# apparently, when coefficients are given as a list, it is assumed,
261	# that the list identical in length to the timeindex
262	# There should be a general check, if lenghts match then!
263	if max_len == 1:	1!
264	slope = sequence(slope[0])	1✔
265	offset = sequence(offset[0])	1✔
266
267	conversion_factors = {input_bus: slope}	1✔
268	normed_offsets = {input_bus: offset}	1✔
269	msg = (	1✔
270	"The usage of coefficients is depricated, use "
271	"conversion_factors and normed_offsets instead."
272	)
273	warn(msg, DeprecationWarning)	1✔
274
275	return normed_offsets, conversion_factors	1✔
276
277
278	# --- BEGIN: To be removed for versions >= v0.6 ---
279	class OffsetTransformer(OffsetConverter):	1✔
280	def __init__(	1✔
281	self,
282	inputs,
283	outputs,
284	label=None,
285	conversion_factors=None,
286	normed_offsets=None,
287	custom_attributes=None,
288	):
289	super().__init__(	1✔
290	label=label,
291	inputs=inputs,
292	outputs=outputs,
293	conversion_factors=conversion_factors,
294	normed_offsets=normed_offsets,
295	custom_attributes=custom_attributes,
296	)
297	warn(	1✔
298	"solph.components.OffsetTransformer has been renamed to"
299	" solph.components.OffsetConverter. The transitional wrapper"
300	" will be deleted in the future.",
301	FutureWarning,
302	)
303
304
305	# --- END ---
306
307
308	class OffsetConverterBlock(ScalarBlock):	1✔
309	r"""Block for the relation of nodes with type
310	:class:`~oemof.solph.components._offset_converter.OffsetConverter`
311
312	The following constraints are created:
313
314	.. _OffsetConverter-equations:
315
316	.. math::
317	&
318	P_{out}(p, t) = P_{in}(p, t) \cdot C_1(t) + P_nom(p) \cdot Y(t) \cdot C_0(t) \\
319
320
321	The symbols used are defined as follows (with Variables (V) and Parameters (P)):
322
323	+--------------------+---------------------------+------+--------------------------------------------------+
324	\| symbol \| attribute \| type \| explanation \|
325	+====================+===========================+======+==================================================+
326	\| :math:`P_{out}(t)` \| `flow[n,o,p,t]` \| V \| Outflow of converter \|
327	+--------------------+---------------------------+------+--------------------------------------------------+
328	\| :math:`P_{in}(t)` \| `flow[i,n,p,t]` \| V \| Inflow of converter \|
329	+--------------------+---------------------------+------+--------------------------------------------------+
330	\| :math:`Y(t)` \| \| V \| Binary status variable of nonconvex outflow \|
331	+--------------------+---------------------------+------+--------------------------------------------------+
332	\| :math:`P_{nom}(t)` \| \| V \| Nominal value (max. capacity) of the outflow \|
333	+--------------------+---------------------------+------+--------------------------------------------------+
334	\| :math:`C_1(t)` \| `coefficients[o][1][n,t]` \| P \| Linear coefficient 1 (slope) \|
335	+--------------------+---------------------------+------+--------------------------------------------------+
336	\| :math:`C_0(t)` \| `coefficients[o][0][n,t]` \| P \| Linear coefficient 0 (y-intersection)/P_{nom}(t) \|
337	+--------------------+---------------------------+------+--------------------------------------------------+
338
339	Note that :math:`P_{nom}(t) \cdot Y(t)` is merged into one variable,
340	called `status_nominal[n, o, p, t]`.
341	""" # noqa: E501
342
343	CONSTRAINT_GROUP = True	1✔
344
345	def __init__(self, args, *kwargs):	1✔
346	super().__init__(args, *kwargs)	1✔
347
348	def _create(self, group=None):	1✔
349	"""Creates the relation for the class:`OffsetConverter`.
350
351	Parameters
352	----------
353	group : list
354	List of oemof.solph.experimental.OffsetConverter objects for
355	which the relation of inputs and outputs is created
356	e.g. group = [ostf1, ostf2, ostf3, ...]. The components inside
357	the list need to hold an attribute `coefficients` of type dict
358	containing the conversion factors for all inputs to outputs.
359	"""
360	if group is None:	1!
361	return None	×
362
363	m = self.parent_block()	1✔
364
365	self.OFFSETCONVERTERS = Set(initialize=[n for n in group])	1✔
366
367	reference_node = {n: n._reference_node for n in group}	1✔
368	reference_node_at_input = {	1✔
369	n: n._reference_node_at_input for n in group
370	}
371	in_flows = {	1✔
372	n: [i for i in n.inputs.keys() if i != n._reference_node]
373	for n in group
374	}
375	out_flows = {	1✔
376	n: [o for o in n.outputs.keys() if o != n._reference_node]
377	for n in group
378	}
379
380	self.relation = Constraint(	1✔
381	[
382	(n, reference_node[n], f, p, t)
383	for p, t in m.TIMEINDEX
384	for n in group
385	for f in in_flows[n] + out_flows[n]
386	],
387	noruleinit=True,
388	)
389
390	def _relation_rule(block):	1✔
391	"""Link binary input and output flow to component outflow."""
392	for p, t in m.TIMEINDEX:	1✔
393	for n in group:	1✔
394
395	if reference_node_at_input[n]:	1✔
396	ref_flow = m.flow[reference_node[n], n, p, t]	1✔
397	status_nominal_idx = reference_node[n], n, t	1✔
398	else:
399	ref_flow = m.flow[n, reference_node[n], p, t]	1✔
400	status_nominal_idx = n, reference_node[n], t	1✔
401
402	if hasattr(m.NonConvexFlowBlock, "status_nominal"):	1✔
403	status_nominal = m.NonConvexFlowBlock.status_nominal	1✔
404
405	if hasattr(m, "InvestNonConvexFlowBlock"):	1!
406	if hasattr(	1✔
407	m.InvestNonConvexFlowBlock, "status_nominal"
408	):
409	if (	1!
410	status_nominal_idx
411	in m.InvestNonConvexFlowBlock.status_nominal
412	):
413	status_nominal = (	1✔
414	m.InvestNonConvexFlowBlock.status_nominal
415	)
416
417	ref_status_nominal = status_nominal[status_nominal_idx]	1✔
418
419	for f in in_flows[n] + out_flows[n]:	1✔
420	rhs = 0	1✔
421	if f in in_flows[n]:	1✔
422	rhs += m.flow[f, n, p, t]	1✔
423	else:
424	rhs += m.flow[n, f, p, t]	1✔
425
426	lhs = 0	1✔
427	lhs += ref_flow * n.conversion_factors[f][t]	1✔
428	lhs += ref_status_nominal * n.normed_offsets[f][t]	1✔
429	block.relation.add(	1✔
430	(n, reference_node[n], f, p, t), (lhs == rhs)
431	)
432
433	self.relation_build = BuildAction(rule=_relation_rule)	1✔
434
435
436	def calculate_slope_and_offset_with_reference_to_input(	1✔
437	max, min, eta_at_max, eta_at_min
438	):
439	"""Calculate the slope and the offset with max and min given for input
440
441	The reference is the input flow here. That means, the `NonConvex` flow
442	is specified at one of the input flows. Therefore the `max` and the `min`
443	both reference that flow. `eta_at_max` and `eta_at_min` are the efficiency
444	values at the referenced point.
445
446	.. math::
447
448	\text{slope} =
449	\frac{
450	\text{max} \cdot \eta_\text{at max}
451	- \text{min} \cdot \eta_\text{at min}
452	}{\text{max} - \text{min}}\\
453
454	\text{offset} = \eta_\text{at,max} - \text{slope}
455
456	Parameters
457	----------
458	max : float
459	Maximum load value, e.g. 1
460	min : float
461	Minimum load value, e.g. 0.5
462	eta_at_max : float
463	Efficiency at maximum load.
464	eta_at_min : float
465	Efficiency at minimum load.
466
467	Returns
468	-------
469	tuple
470	slope and offset
471	"""
472	slope = (max * eta_at_max - min * eta_at_min) / (max - min)	1✔
473	offset = eta_at_max - slope	1✔
474	return slope, offset	1✔
475
476
477	def calculate_slope_and_offset_with_reference_to_output(	1✔
478	max, min, eta_at_max, eta_at_min
479	):
480	r"""Calculate the slope and the offset with max and min given for output.
481
482	The reference is the output flow here. That means, the `NonConvex` flow
483	is specified at one of the output flows. Therefore the `max` and the `min`
484	both reference that flow. `eta_at_max` and `eta_at_min` are the efficiency
485	values at the referenced point.
486
487	.. math::
488
489	\text{slope} =
490	\frac{
491	\frac{\text{max}}{\eta_\text{at max}}
492	- \frac{\text{min}}{\eta_\text{at min}}
493	}{\text{max} - \text{min}}\\
494
495	\text{offset} = \frac{1}{\eta_\text{at,max}} - \text{slope}
496
497	Parameters
498	----------
499	max : float
500	Maximum load value, e.g. 1
501	min : float
502	Minimum load value, e.g. 0.5
503	eta_at_max : float
504	Efficiency at maximum load.
505	eta_at_min : float
506	Efficiency at minimum load.
507
508	Returns
509	-------
510	tuple
511	slope and offset
512	"""
513	slope = (max / eta_at_max - min / eta_at_min) / (max - min)	1✔
514	offset = 1 / eta_at_max - slope	1✔
515	return slope, offset	1✔

oemof / oemof-solph / 9384374946

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