10522218155

Committed 23 Aug 2024 08:07AM UTC coverage: 88.556% (-0.07%) from 88.63%

Build # 10522218155

Build Type

Pull #1111

github

Committed by

web-flow

Commit Message

Merge 996bd6fe6 into abb1be98b

Pull Request Pull Request #1111: Remove internal discounting functionality

Run Details

1170 of 1363 branches covered (85.84%)

Branch coverage included in aggregate %.

8 of 9 new or added lines in 3 files covered. (88.89%)

34 existing lines in 4 files now uncovered.

2467 of 2744 relevant lines covered (89.91%)

2.7 hits per line

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

95.07

/src/oemof/solph/_models.py

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

"""Solph Optimization Models.

SPDX-FileCopyrightText: Uwe Krien <krien@uni-bremen.de>
SPDX-FileCopyrightText: Simon Hilpert
SPDX-FileCopyrightText: Cord Kaldemeyer
SPDX-FileCopyrightText: gplssm
SPDX-FileCopyrightText: Patrik Schönfeldt
SPDX-FileCopyrightText: Saeed Sayadi
SPDX-FileCopyrightText: Johannes Kochems
SPDX-FileCopyrightText: Lennart Schürmann

SPDX-License-Identifier: MIT

"""
import logging
import warnings
from logging import getLogger

from oemof.tools import debugging
from pyomo import environ as po
from pyomo.core.plugins.transform.relax_integrality import RelaxIntegrality
from pyomo.opt import SolverFactory

from oemof.solph import processing
from oemof.solph.buses._bus import BusBlock
from oemof.solph.components._converter import ConverterBlock
from oemof.solph.flows._invest_non_convex_flow_block import (
    InvestNonConvexFlowBlock,
)
from oemof.solph.flows._investment_flow_block import InvestmentFlowBlock
from oemof.solph.flows._non_convex_flow_block import NonConvexFlowBlock
from oemof.solph.flows._simple_flow_block import SimpleFlowBlock


class LoggingError(BaseException):
    """Raised when the wrong logging level is used."""

    pass


class Model(po.ConcreteModel):
    """An energy system model for operational and/or investment
    optimization.

    Parameters
    ----------
    energysystem : EnergySystem object
        Object that holds the nodes of an oemof energy system graph.
    constraint_groups : list
        Solph looks for these groups in the given energy system and uses them
        to create the constraints of the optimization problem.
        Defaults to `Model.CONSTRAINT_GROUPS`
    discount_rate : float or None
        The rate used for discounting in a multi-period model.
        A 2% discount rate needs to be defined as 0.02.
    objective_weighting : array like (optional)
        Weights used for temporal objective function
        expressions. If nothing is passed, `timeincrement` will be used which
        is calculated from the freq length of the energy system timeindex or
        can be directly passed as a sequence.
    auto_construct : boolean
        If this value is true, the set, variables, constraints, etc. are added,
        automatically when instantiating the model. For sequential model
        building process set this value to False
        and use methods `_add_parent_block_sets`,
        `_add_parent_block_variables`, `_add_blocks`, `_add_objective`

    Attributes
    ----------
    timeincrement : sequence
        Time increments
    flows : dict
        Flows of the model
    name : str
        Name of the model
    es : solph.EnergySystem
        Energy system of the model
    meta : `pyomo.opt.results.results_.SolverResults` or None
        Solver results
    dual : `pyomo.core.base.suffix.Suffix` or None
        Store the dual variables of the model if pyomo suffix is set to IMPORT
    rc : `pyomo.core.base.suffix.Suffix` or None
        Store the reduced costs of the model if pyomo suffix is set to IMPORT

    Note
    ----

    * The discount rate is only applicable for a multi-period model.
    * If you want to work with costs data in nominal terms,
      you should specify a discount rate.
    * By default, there is a discount rate of 2% in a multi-period model.
    * If you want to provide your costs data in real terms,
      just specify `discount_rate = 0`, i.e. effectively there will be
      no discounting.


    **The following basic sets are created**:

    NODES
        A set with all nodes of the given energy system.

    TIMESTEPS
        A set with all timesteps of the given time horizon.

    PERIODS
        A set with all investment periods of the given time horizon.

    TIMEINDEX
        A set with all time indices of the given time horizon, whereby
        time indices are defined as a tuple consisting of the period and the
        timestep. E.g. (2, 10) would be timestep 10 (which is exactly the same
        as in the TIMESTEPS set) and which is in period 2.

    FLOWS
        A 2 dimensional set with all flows. Index: `(source, target)`

    **The following basic variables are created**:

    flow
        Flow from source to target indexed by FLOWS, TIMEINDEX.
        Note: Bounds of this variable are set depending on attributes of
        the corresponding flow object.

    """

    CONSTRAINT_GROUPS = [
        BusBlock,
        ConverterBlock,
        InvestmentFlowBlock,
        SimpleFlowBlock,
        NonConvexFlowBlock,
        InvestNonConvexFlowBlock,
    ]

    def __init__(self, energysystem, discount_rate=None, **kwargs):
        super().__init__()

        # Check root logger. Due to a problem with pyomo the building of the
        # model will take up to a 100 times longer if the root logger is set
        # to DEBUG

        if getLogger().level <= 10 and kwargs.get("debug", False) is False:
            msg = (
                "The root logger level is 'DEBUG'.\nDue to a communication "
                "problem between solph and the pyomo package,\nusing the "
                "DEBUG level will slow down the modelling process by the "
                "factor ~100.\nIf you need the debug-logging you can "
                "initialise the Model with 'debug=True`\nYou should only do "
                "this for small models. To avoid the slow-down use the "
                "logger\nfunction of oemof.tools (read docstring) or "
                "change the level of the root logger:\n\nimport logging\n"
                "logging.getLogger().setLevel(logging.INFO)"
            )
            raise LoggingError(msg)

        # ########################  Arguments #################################

        self.name = kwargs.get("name", type(self).__name__)

        self.es = energysystem

        if kwargs.get("timeincrement"):
            msg = "Resetting timeincrement from EnergySystem in Model."
            warnings.warn(msg, debugging.SuspiciousUsageWarning)

            self.timeincrement = kwargs.get("timeincrement")
        else:
            self.timeincrement = self.es.timeincrement

        self.objective_weighting = kwargs.get(
            "objective_weighting", self.timeincrement
        )

        self._constraint_groups = type(self).CONSTRAINT_GROUPS + kwargs.get(
            "constraint_groups", []
        )

        self._constraint_groups += [
            i
            for i in self.es.groups
            if hasattr(i, "CONSTRAINT_GROUP")
            and i not in self._constraint_groups
        ]

        self.flows = self.es.flows()

        self.solver_results = None
        self.dual = None
        self.rc = None

        if discount_rate is not None:
            self.discount_rate = discount_rate
        elif energysystem.periods is not None:
            self._set_discount_rate_with_warning()
        else:
            pass

        if kwargs.get("auto_construct", True):
            self._construct()

    def _construct(self):
        """Construct a Model by adding parent block sets and variables
        as well as child blocks and variables to it.
        """
        self._add_parent_block_sets()
        self._add_parent_block_variables()
        self._add_child_blocks()
        self._add_objective()

    def _set_discount_rate_with_warning(self):
        """
        Sets the discount rate to the standard value and raises a warning.
        """
        self.discount_rate = 0.02
        msg = (
            f"By default, a discount_rate of {self.discount_rate} "
            f"is used for a multi-period model. "
            f"If you want to use another value, "
            f"you have to specify the `discount_rate` attribute."
        )
        warnings.warn(msg, debugging.SuspiciousUsageWarning)

    def _add_parent_block_sets(self):
        """Add all basic sets to the model, i.e. NODES, TIMESTEPS and FLOWS.
        Also create sets PERIODS and TIMEINDEX used for multi-period models.
        """
        self.nodes = list(self.es.nodes)

        # create set with all nodes
        self.NODES = po.Set(initialize=[n for n in self.nodes])

        if self.es.timeincrement is None:
            msg = (
                "The EnergySystem needs to have a valid 'timeincrement' "
                "attribute to build a model."
            )
            raise AttributeError(msg)

        # pyomo set for timesteps of optimization problem
        self.TIMESTEPS = po.Set(
            initialize=range(len(self.es.timeincrement)), ordered=True
        )
        self.TIMEPOINTS = po.Set(
            initialize=range(len(self.es.timeincrement) + 1), ordered=True
        )

        if self.es.periods is None:
            self.TIMEINDEX = po.Set(
                initialize=list(
                    zip(
                        [0] * len(self.es.timeincrement),
                        range(len(self.es.timeincrement)),
                    )
                ),
                ordered=True,
            )
            self.PERIODS = po.Set(initialize=[0])
        else:
            nested_list = [
                [k] * len(self.es.periods[k])
                for k in range(len(self.es.periods))
            ]
            flattened_list = [
                item for sublist in nested_list for item in sublist
            ]
            self.TIMEINDEX = po.Set(
                initialize=list(
                    zip(flattened_list, range(len(self.es.timeincrement)))
                ),
                ordered=True,
            )
            self.PERIODS = po.Set(
                initialize=sorted(list(set(range(len(self.es.periods)))))
            )

        # (Re-)Map timesteps to periods
        timesteps_in_period = {p: [] for p in self.PERIODS}
        for p, t in self.TIMEINDEX:
            timesteps_in_period[p].append(t)
        self.TIMESTEPS_IN_PERIOD = timesteps_in_period

        # previous timesteps
        previous_timesteps = [x - 1 for x in self.TIMESTEPS]
        previous_timesteps[0] = self.TIMESTEPS.last()

        self.previous_timesteps = dict(zip(self.TIMESTEPS, previous_timesteps))

        # pyomo set for all flows in the energy system graph
        self.FLOWS = po.Set(
            initialize=self.flows.keys(), ordered=True, dimen=2
        )

        self.BIDIRECTIONAL_FLOWS = po.Set(
            initialize=[k for (k, v) in self.flows.items() if v.bidirectional],
            ordered=True,
            dimen=2,
            within=self.FLOWS,
        )

        self.UNIDIRECTIONAL_FLOWS = po.Set(
            initialize=[
                k for (k, v) in self.flows.items() if not v.bidirectional
            ],
            ordered=True,
            dimen=2,
            within=self.FLOWS,
        )

    def _add_parent_block_variables(self):
        """Add the parent block variables, which is the `flow` variable,
        indexed by FLOWS and TIMEINDEX."""
        self.flow = po.Var(self.FLOWS, self.TIMESTEPS, within=po.Reals)

        for o, i in self.FLOWS:
            if self.flows[o, i].nominal_value is not None:
                if self.flows[o, i].fix[self.TIMESTEPS.at(1)] is not None:
                    for t in self.TIMESTEPS:
                        self.flow[o, i, t].value = (
                            self.flows[o, i].fix[t]
                            * self.flows[o, i].nominal_value
                        )
                        self.flow[o, i, t].fix()
                else:
                    for t in self.TIMESTEPS:
                        self.flow[o, i, t].setub(
                            self.flows[o, i].max[t]
                            * self.flows[o, i].nominal_value
                        )
                    if not self.flows[o, i].nonconvex:
                        for t in self.TIMESTEPS:
                            self.flow[o, i, t].setlb(
                                self.flows[o, i].min[t]
                                * self.flows[o, i].nominal_value
                            )
                    elif (o, i) in self.UNIDIRECTIONAL_FLOWS:
                        for t in self.TIMESTEPS:
                            self.flow[o, i, t].setlb(0)
            else:
                if (o, i) in self.UNIDIRECTIONAL_FLOWS:
                    for t in self.TIMESTEPS:
                        self.flow[o, i, t].setlb(0)

    def _add_child_blocks(self):
        """Method to add the defined child blocks for components that have
        been grouped in the defined constraint groups. This collects all the
        constraints from the buses, components and flows blocks
        and adds them to the model.
        """
        for group in self._constraint_groups:
            block = group()
            self.add_component(str(block), block)

            # create constraints etc. related with block for all nodes
            # in the group
            block._create(group=self.es.groups.get(group))

    def _add_objective(self, sense=po.minimize, update=False):
        """Method to sum up all objective expressions from the child blocks
        that have been created. This method looks for `_objective_expression`
        attribute in the block definition and will call this method to add
        their return value to the objective function.
        """
        if update:
            self.del_component("objective")

        expr = 0

        for block in self.component_data_objects():
            if hasattr(block, "_objective_expression"):
                expr += block._objective_expression()

        self.objective = po.Objective(sense=sense, expr=expr)

    def receive_duals(self):
        """Method sets solver suffix to extract information about dual
        variables from solver. Shadow prices (duals) and reduced costs (rc) are
        set as attributes of the model.
        """
        # shadow prices
        self.dual = po.Suffix(direction=po.Suffix.IMPORT)
        # reduced costs
        self.rc = po.Suffix(direction=po.Suffix.IMPORT)

    def results(self):
        """Returns a nested dictionary of the results of this optimization.
        See the processing module for more information on results extraction.
        """
        return processing.results(self)

    def solve(self, solver="cbc", solver_io="lp", **kwargs):
        r"""Takes care of communication with solver to solve the model.

        Parameters
        ----------
        solver : string
            solver to be used e.g. "cbc", "glpk", "gurobi", "cplex"
        solver_io : string
            pyomo solver interface file format: "lp", "python", "nl", etc.
        \**kwargs : keyword arguments
            Possible keys can be set see below:

        Other Parameters
        ----------------
        solve_kwargs : dict
            Other arguments for the pyomo.opt.SolverFactory.solve() method
            Example : {"tee":True}
        cmdline_options : dict
            Dictionary with command line options for solver e.g.
            {"mipgap":"0.01"} results in "--mipgap 0.01"
            \{"interior":" "} results in "--interior"
            \Gurobi solver takes numeric parameter values such as
            {"method": 2}
        """
        solve_kwargs = kwargs.get("solve_kwargs", {})
        solver_cmdline_options = kwargs.get("cmdline_options", {})

        opt = SolverFactory(solver, solver_io=solver_io)
        # set command line options
        options = opt.options
        for k in solver_cmdline_options:
            options[k] = solver_cmdline_options[k]

        solver_results = opt.solve(self, **solve_kwargs)

        status = solver_results["Solver"][0]["Status"]
        termination_condition = solver_results["Solver"][0][
            "Termination condition"
        ]

        if status == "ok" and termination_condition == "optimal":
            logging.info("Optimization successful...")
        else:
            msg = (
                "Optimization ended with status {0} and termination "
                "condition {1}"
            )
            warnings.warn(
                msg.format(status, termination_condition), UserWarning
            )
        self.es.results = solver_results
        self.solver_results = solver_results

        return solver_results

    def relax_problem(self):
        """Relaxes integer variables to reals of optimization model self."""
        relaxer = RelaxIntegrality()
        relaxer._apply_to(self)

        return self

1	# -- coding: utf-8 --
2
3	"""Solph Optimization Models.
4
5	SPDX-FileCopyrightText: Uwe Krien <krien@uni-bremen.de>
6	SPDX-FileCopyrightText: Simon Hilpert
7	SPDX-FileCopyrightText: Cord Kaldemeyer
8	SPDX-FileCopyrightText: gplssm
9	SPDX-FileCopyrightText: Patrik Schönfeldt
10	SPDX-FileCopyrightText: Saeed Sayadi
11	SPDX-FileCopyrightText: Johannes Kochems
12	SPDX-FileCopyrightText: Lennart Schürmann
13
14	SPDX-License-Identifier: MIT
15
16	"""
17	import logging	3✔
18	import warnings	3✔
19	from logging import getLogger	3✔
20
21	from oemof.tools import debugging	3✔
22	from pyomo import environ as po	3✔
23	from pyomo.core.plugins.transform.relax_integrality import RelaxIntegrality	3✔
24	from pyomo.opt import SolverFactory	3✔
25
26	from oemof.solph import processing	3✔
27	from oemof.solph.buses._bus import BusBlock	3✔
28	from oemof.solph.components._converter import ConverterBlock	3✔
29	from oemof.solph.flows._invest_non_convex_flow_block import (	3✔
30	InvestNonConvexFlowBlock,
31	)
32	from oemof.solph.flows._investment_flow_block import InvestmentFlowBlock	3✔
33	from oemof.solph.flows._non_convex_flow_block import NonConvexFlowBlock	3✔
34	from oemof.solph.flows._simple_flow_block import SimpleFlowBlock	3✔
35
36
37	class LoggingError(BaseException):	3✔
38	"""Raised when the wrong logging level is used."""
39
40	pass	3✔
41
42
43	class Model(po.ConcreteModel):	3✔
44	"""An energy system model for operational and/or investment
45	optimization.
46
47	Parameters
48	----------
49	energysystem : EnergySystem object
50	Object that holds the nodes of an oemof energy system graph.
51	constraint_groups : list
52	Solph looks for these groups in the given energy system and uses them
53	to create the constraints of the optimization problem.
54	Defaults to `Model.CONSTRAINT_GROUPS`
55	discount_rate : float or None
56	The rate used for discounting in a multi-period model.
57	A 2% discount rate needs to be defined as 0.02.
58	objective_weighting : array like (optional)
59	Weights used for temporal objective function
60	expressions. If nothing is passed, `timeincrement` will be used which
61	is calculated from the freq length of the energy system timeindex or
62	can be directly passed as a sequence.
63	auto_construct : boolean
64	If this value is true, the set, variables, constraints, etc. are added,
65	automatically when instantiating the model. For sequential model
66	building process set this value to False
67	and use methods `_add_parent_block_sets`,
68	`_add_parent_block_variables`, `_add_blocks`, `_add_objective`
69
70	Attributes
71	----------
72	timeincrement : sequence
73	Time increments
74	flows : dict
75	Flows of the model
76	name : str
77	Name of the model
78	es : solph.EnergySystem
79	Energy system of the model
80	meta : `pyomo.opt.results.results_.SolverResults` or None
81	Solver results
82	dual : `pyomo.core.base.suffix.Suffix` or None
83	Store the dual variables of the model if pyomo suffix is set to IMPORT
84	rc : `pyomo.core.base.suffix.Suffix` or None
85	Store the reduced costs of the model if pyomo suffix is set to IMPORT
86
87	Note
88	----
89
90	* The discount rate is only applicable for a multi-period model.
91	* If you want to work with costs data in nominal terms,
92	you should specify a discount rate.
93	* By default, there is a discount rate of 2% in a multi-period model.
94	* If you want to provide your costs data in real terms,
95	just specify `discount_rate = 0`, i.e. effectively there will be
96	no discounting.
97
98
99	The following basic sets are created:
100
101	NODES
102	A set with all nodes of the given energy system.
103
104	TIMESTEPS
105	A set with all timesteps of the given time horizon.
106
107	PERIODS
108	A set with all investment periods of the given time horizon.
109
110	TIMEINDEX
111	A set with all time indices of the given time horizon, whereby
112	time indices are defined as a tuple consisting of the period and the
113	timestep. E.g. (2, 10) would be timestep 10 (which is exactly the same
114	as in the TIMESTEPS set) and which is in period 2.
115
116	FLOWS
117	A 2 dimensional set with all flows. Index: `(source, target)`
118
119	The following basic variables are created:
120
121	flow
122	Flow from source to target indexed by FLOWS, TIMEINDEX.
123	Note: Bounds of this variable are set depending on attributes of
124	the corresponding flow object.
125
126	"""
127
128	CONSTRAINT_GROUPS = [	3✔
129	BusBlock,
130	ConverterBlock,
131	InvestmentFlowBlock,
132	SimpleFlowBlock,
133	NonConvexFlowBlock,
134	InvestNonConvexFlowBlock,
135	]
136
137	def __init__(self, energysystem, discount_rate=None, **kwargs):	3✔
138	super().__init__()	3✔
139
140	# Check root logger. Due to a problem with pyomo the building of the
141	# model will take up to a 100 times longer if the root logger is set
142	# to DEBUG
143
144	if getLogger().level <= 10 and kwargs.get("debug", False) is False:	3✔
145	msg = (	3✔
146	"The root logger level is 'DEBUG'.\nDue to a communication "
147	"problem between solph and the pyomo package,\nusing the "
148	"DEBUG level will slow down the modelling process by the "
149	"factor ~100.\nIf you need the debug-logging you can "
150	"initialise the Model with 'debug=True`\nYou should only do "
151	"this for small models. To avoid the slow-down use the "
152	"logger\nfunction of oemof.tools (read docstring) or "
153	"change the level of the root logger:\n\nimport logging\n"
154	"logging.getLogger().setLevel(logging.INFO)"
155	)
156	raise LoggingError(msg)	3✔
157
158	# ######################## Arguments #################################
159
160	self.name = kwargs.get("name", type(self).__name__)	3✔
161
162	self.es = energysystem	3✔
163
164	if kwargs.get("timeincrement"):	3✔
165	msg = "Resetting timeincrement from EnergySystem in Model."	3✔
166	warnings.warn(msg, debugging.SuspiciousUsageWarning)	3✔
167
168	self.timeincrement = kwargs.get("timeincrement")	3✔
169	else:
170	self.timeincrement = self.es.timeincrement	3✔
171
172	self.objective_weighting = kwargs.get(	3✔
173	"objective_weighting", self.timeincrement
174	)
175
176	self._constraint_groups = type(self).CONSTRAINT_GROUPS + kwargs.get(	3✔
177	"constraint_groups", []
178	)
179
180	self._constraint_groups += [	3✔
181	i
182	for i in self.es.groups
183	if hasattr(i, "CONSTRAINT_GROUP")
184	and i not in self._constraint_groups
185	]
186
187	self.flows = self.es.flows()	3✔
188
189	self.solver_results = None	3✔
190	self.dual = None	3✔
191	self.rc = None	3✔
192
193	if discount_rate is not None:	3✔
194	self.discount_rate = discount_rate	3✔
195	elif energysystem.periods is not None:	3✔
196	self._set_discount_rate_with_warning()	3✔
197	else:
198	pass	2✔
199
200	if kwargs.get("auto_construct", True):	3!
201	self._construct()	3✔
202
203	def _construct(self):	3✔
204	"""Construct a Model by adding parent block sets and variables
205	as well as child blocks and variables to it.
206	"""
207	self._add_parent_block_sets()	3✔
208	self._add_parent_block_variables()	3✔
209	self._add_child_blocks()	3✔
210	self._add_objective()	3✔
211
212	def _set_discount_rate_with_warning(self):	3✔
213	"""
214	Sets the discount rate to the standard value and raises a warning.
215	"""
216	self.discount_rate = 0.02	3✔
217	msg = (	3✔
218	f"By default, a discount_rate of {self.discount_rate} "
219	f"is used for a multi-period model. "
220	f"If you want to use another value, "
221	f"you have to specify the `discount_rate` attribute."
222	)
223	warnings.warn(msg, debugging.SuspiciousUsageWarning)	3✔
224
225	def _add_parent_block_sets(self):	3✔
226	"""Add all basic sets to the model, i.e. NODES, TIMESTEPS and FLOWS.
227	Also create sets PERIODS and TIMEINDEX used for multi-period models.
228	"""
229	self.nodes = list(self.es.nodes)	3✔
230
231	# create set with all nodes
232	self.NODES = po.Set(initialize=[n for n in self.nodes])	3✔
233
234	if self.es.timeincrement is None:	3✔
235	msg = (	3✔
236	"The EnergySystem needs to have a valid 'timeincrement' "
237	"attribute to build a model."
238	)
239	raise AttributeError(msg)	3✔
240
241	# pyomo set for timesteps of optimization problem
242	self.TIMESTEPS = po.Set(	3✔
243	initialize=range(len(self.es.timeincrement)), ordered=True
244	)
245	self.TIMEPOINTS = po.Set(	3✔
246	initialize=range(len(self.es.timeincrement) + 1), ordered=True
247	)
248
249	if self.es.periods is None:	3✔
250	self.TIMEINDEX = po.Set(	3✔
251	initialize=list(
252	zip(
253	[0] * len(self.es.timeincrement),
254	range(len(self.es.timeincrement)),
255	)
256	),
257	ordered=True,
258	)
259	self.PERIODS = po.Set(initialize=[0])	3✔
260	else:
261	nested_list = [	3✔
262	[k] * len(self.es.periods[k])
263	for k in range(len(self.es.periods))
264	]
265	flattened_list = [	3✔
266	item for sublist in nested_list for item in sublist
267	]
268	self.TIMEINDEX = po.Set(	3✔
269	initialize=list(
270	zip(flattened_list, range(len(self.es.timeincrement)))
271	),
272	ordered=True,
273	)
274	self.PERIODS = po.Set(	3✔
275	initialize=sorted(list(set(range(len(self.es.periods)))))
276	)
277
278	# (Re-)Map timesteps to periods
279	timesteps_in_period = {p: [] for p in self.PERIODS}	3✔
280	for p, t in self.TIMEINDEX:	3✔
281	timesteps_in_period[p].append(t)	3✔
282	self.TIMESTEPS_IN_PERIOD = timesteps_in_period	3✔
283
284	# previous timesteps
285	previous_timesteps = [x - 1 for x in self.TIMESTEPS]	3✔
286	previous_timesteps[0] = self.TIMESTEPS.last()	3✔
287
288	self.previous_timesteps = dict(zip(self.TIMESTEPS, previous_timesteps))	3✔
289
290	# pyomo set for all flows in the energy system graph
291	self.FLOWS = po.Set(	3✔
292	initialize=self.flows.keys(), ordered=True, dimen=2
293	)
294
295	self.BIDIRECTIONAL_FLOWS = po.Set(	3✔
296	initialize=[k for (k, v) in self.flows.items() if v.bidirectional],
297	ordered=True,
298	dimen=2,
299	within=self.FLOWS,
300	)
301
302	self.UNIDIRECTIONAL_FLOWS = po.Set(	3✔
303	initialize=[
304	k for (k, v) in self.flows.items() if not v.bidirectional
305	],
306	ordered=True,
307	dimen=2,
308	within=self.FLOWS,
309	)
310
311	def _add_parent_block_variables(self):	3✔
312	"""Add the parent block variables, which is the `flow` variable,
313	indexed by FLOWS and TIMEINDEX."""
314	self.flow = po.Var(self.FLOWS, self.TIMESTEPS, within=po.Reals)	3✔
315
316	for o, i in self.FLOWS:	3✔
317	if self.flows[o, i].nominal_value is not None:	3✔
318	if self.flows[o, i].fix[self.TIMESTEPS.at(1)] is not None:	3✔
319	for t in self.TIMESTEPS:	3✔
320	self.flow[o, i, t].value = (	3✔
321	self.flows[o, i].fix[t]
322	* self.flows[o, i].nominal_value
323	)
324	self.flow[o, i, t].fix()	3✔
325	else:
326	for t in self.TIMESTEPS:	3✔
327	self.flow[o, i, t].setub(	3✔
328	self.flows[o, i].max[t]
329	* self.flows[o, i].nominal_value
330	)
331	if not self.flows[o, i].nonconvex:	3✔
332	for t in self.TIMESTEPS:	3✔
333	self.flow[o, i, t].setlb(	3✔
334	self.flows[o, i].min[t]
335	* self.flows[o, i].nominal_value
336	)
337	elif (o, i) in self.UNIDIRECTIONAL_FLOWS:	3!
338	for t in self.TIMESTEPS:	3✔
339	self.flow[o, i, t].setlb(0)	3✔
340	else:
341	if (o, i) in self.UNIDIRECTIONAL_FLOWS:	3!
342	for t in self.TIMESTEPS:	3✔
343	self.flow[o, i, t].setlb(0)	3✔
344
345	def _add_child_blocks(self):	3✔
346	"""Method to add the defined child blocks for components that have
347	been grouped in the defined constraint groups. This collects all the
348	constraints from the buses, components and flows blocks
349	and adds them to the model.
350	"""
351	for group in self._constraint_groups:	3✔
352	block = group()	3✔
353	self.add_component(str(block), block)	3✔
354
355	# create constraints etc. related with block for all nodes
356	# in the group
357	block._create(group=self.es.groups.get(group))	3✔
358
359	def _add_objective(self, sense=po.minimize, update=False):	3✔
360	"""Method to sum up all objective expressions from the child blocks
361	that have been created. This method looks for `_objective_expression`
362	attribute in the block definition and will call this method to add
363	their return value to the objective function.
364	"""
365	if update:	3!
UNCOV 366	self.del_component("objective")	×
367
368	expr = 0	3✔
369
370	for block in self.component_data_objects():	3✔
371	if hasattr(block, "_objective_expression"):	3✔
372	expr += block._objective_expression()	3✔
373
374	self.objective = po.Objective(sense=sense, expr=expr)	3✔
375
376	def receive_duals(self):	3✔
377	"""Method sets solver suffix to extract information about dual
378	variables from solver. Shadow prices (duals) and reduced costs (rc) are
379	set as attributes of the model.
380	"""
381	# shadow prices
382	self.dual = po.Suffix(direction=po.Suffix.IMPORT)	3✔
383	# reduced costs
384	self.rc = po.Suffix(direction=po.Suffix.IMPORT)	3✔
385
386	def results(self):	3✔
387	"""Returns a nested dictionary of the results of this optimization.
388	See the processing module for more information on results extraction.
389	"""
390	return processing.results(self)	3✔
391
392	def solve(self, solver="cbc", solver_io="lp", **kwargs):	3✔
393	r"""Takes care of communication with solver to solve the model.
394
395	Parameters
396	----------
397	solver : string
398	solver to be used e.g. "cbc", "glpk", "gurobi", "cplex"
399	solver_io : string
400	pyomo solver interface file format: "lp", "python", "nl", etc.
401	\**kwargs : keyword arguments
402	Possible keys can be set see below:
403
404	Other Parameters
405	----------------
406	solve_kwargs : dict
407	Other arguments for the pyomo.opt.SolverFactory.solve() method
408	Example : {"tee":True}
409	cmdline_options : dict
410	Dictionary with command line options for solver e.g.
411	{"mipgap":"0.01"} results in "--mipgap 0.01"
412	\{"interior":" "} results in "--interior"
413	\Gurobi solver takes numeric parameter values such as
414	{"method": 2}
415	"""
416	solve_kwargs = kwargs.get("solve_kwargs", {})	3✔
417	solver_cmdline_options = kwargs.get("cmdline_options", {})	3✔
418
419	opt = SolverFactory(solver, solver_io=solver_io)	3✔
420	# set command line options
421	options = opt.options	3✔
422	for k in solver_cmdline_options:	3!
UNCOV 423	options[k] = solver_cmdline_options[k]	×
424
425	solver_results = opt.solve(self, **solve_kwargs)	3✔
426
427	status = solver_results["Solver"][0]["Status"]	3✔
428	termination_condition = solver_results["Solver"][0][	3✔
429	"Termination condition"
430	]
431
432	if status == "ok" and termination_condition == "optimal":	3✔
433	logging.info("Optimization successful...")	3✔
434	else:
435	msg = (	3✔
436	"Optimization ended with status {0} and termination "
437	"condition {1}"
438	)
439	warnings.warn(	3✔
440	msg.format(status, termination_condition), UserWarning
441	)
442	self.es.results = solver_results	3✔
443	self.solver_results = solver_results	3✔
444
445	return solver_results	3✔
446
447	def relax_problem(self):	3✔
448	"""Relaxes integer variables to reals of optimization model self."""
UNCOV 449	relaxer = RelaxIntegrality()	×
UNCOV 450	relaxer._apply_to(self)	×
451
UNCOV 452	return self	×

oemof / oemof-solph / 10522218155

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