Feature/result dict wrapper

docs/whatsnew/v0-6-1.rst

@@ -3,11 +3,12 @@ v0.6.1
 
 API changes
 ###########
-* GenericStorage requires explicitly set `Investment` objects if the `invest_relation` 
-  keywords are used. Automatic creation of the `Investment` objects is removed.
+
 
 New features
 ############
+* GenericStorage requires explicitly set `Investment` objects if the `invest_relation` 
+  keywords are used. Automatic creation of the `Investment` objects is removed.
 * Two new keys added to `Results` class (experimental) to calculate variable costs and 
   investment costs via `results["variable_costs"]` and `results["investment_costs"]`.
 
@@ -22,10 +23,19 @@ Bug fixes
 Other changes
 #############
 
+* Implement a backward-compatibility module for processing.results that uses
+  the new solph.Results object.
 * Experimental component `SinkDSM` (unmaintained) has been removed
 * Unmaintained, non-working functionality for three-phase electricity has been
   removed.
 
+Known issues
+############
+
+* Backward-compatibile result extraction (processing.results)
+  of mutli-period-models fails.
+* Results of TSAM-models do not have original time axis reconstructed.
+
 Contributors
 ############
 

examples/check_examples.py

@@ -1,8 +1,8 @@
+import importlib
 import os
 import subprocess
 import tempfile
 import warnings
-import importlib
 from datetime import datetime
 
 import matplotlib

examples/result_object/result_object.py

@@ -69,12 +69,12 @@
 
 from oemof.solph import EnergySystem
 from oemof.solph import Model
+from oemof.solph import Results
 from oemof.solph import buses
 from oemof.solph import components
 from oemof.solph import create_time_index
 from oemof.solph import flows
 from oemof.solph import processing
-from oemof.solph import Results
 from oemof.solph import views
 
 

src/oemof/solph/_processing.py

@@ -0,0 +1,135 @@
+# -*- coding: utf-8 -*-
+
+"""Compatibility wrapper of solph.Results for providing solph results in the
+structure of the output of old processing.results(model).
+
+SPDX-FileCopyrightText: Patrik Schönfeldt <patrik.schoenfeldt@dlr.de>
+
+SPDX-License-Identifier: MIT
+"""
+
+import warnings
+from itertools import groupby
+
+import pandas as pd
+from oemof.tools import debugging
+
+from ._models import Model
+from ._results import Results
+
+
+def results(
+    model: Model,
+    remove_last_time_point: bool = False,
+    scalar_data: list[str] | None = None,
+):
+    """Create a nested result dictionary from the result DataFrame
+
+    The results from Pyomo from the Results object are
+    transferred into a nested dictionary of pandas objects.
+    The first level key of that dictionary is a node
+    (denoting the respective flow or component).
+
+    The second level keys are "sequences" and "scalars":
+
+    * A pd.DataFrame holds all results that are time-dependent, i.e. given as
+      a sequence and can be indexed with the energy system's timeindex.
+    * A pd.Series holds all scalar values which are applicable for timestep 0
+      (i.e. investments).
+
+    Models with more than one time for investments are not supported.
+    In these models, investments are sequential data,
+    but with a second time imdex. As this is a compatibility layer,
+    we did not add support for this new feature.
+    Instead, use of the Results object is advised.
+
+    Parameters
+    ----------
+    model : oemof.solph.Model
+        A solved oemof.solph model.
+    remove_last_time_point : bool
+        The last time point of all TIMEPOINT variables is removed to get the
+        same length as the TIMESTEP (interval) variables without getting
+        nan-values. By default, the last time point is removed if it has not
+        been defined by the user in the EnergySystem but inferred. If all
+        time points have been defined explicitly by the user the last time
+        point will not be removed by default. In that case all interval
+        variables will get one row with nan-values to have the same index
+        for all variables.
+    scalar_data :  list[str]
+        List of variables to be treated as scalar data (see above).
+    sequence_data: list[str]
+        List of variables to be treated as sequential data (see above).
+    """
+
+    meta_result_keys = ["Solution", "Problem", "Solver"]
+
+    if scalar_data is None:
+        scalar_data = ["invest", "total"]
+
+    result_dict = {}
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore", category=debugging.ExperimentalFeatureWarning
+        )
+        result_object = Results(model)
+
+    timeindex = model.es.timeindex
+
+    if remove_last_time_point:
+        timeindex = timeindex[:-1]
+
+    def _handle_scalar(data):
+        return data.iloc[0]
+
+    def _handle_sequence(data):
+        return data
+
+    for result_key in result_object.keys():
+        if result_key not in meta_result_keys:
+            if result_key in scalar_data:
+                result_type = "scalars"
+                data_handler = _handle_scalar
+            else:
+                result_type = "sequences"
+                data_handler = _handle_sequence
+
+            index = result_object[result_key].columns
+            for item in index:
+                if isinstance(index, pd.MultiIndex):
+                    node_tuple = item
+                else:
+                    node_tuple = (item, None)
+                if node_tuple not in result_dict:
+                    result_dict[node_tuple] = {
+                        "scalars": pd.Series(),
+                        "sequences": pd.DataFrame(index=timeindex),
+                    }
+
+                data = result_object[result_key][item]
+                result_dict[node_tuple][result_type][result_key] = (
+                    data_handler(data)
+                )
+
+    if model.dual is not None:
+        grouped = groupby(
+            sorted(model.BusBlock.balance.iterkeys()), lambda t: t[0]
+        )
+        for bus, timestep in grouped:
+            duals = [
+                model.dual[model.BusBlock.balance[bus, t]] for _, t in timestep
+            ]
+            if model.es.periods is None:
+                df = pd.DataFrame({"duals": duals}, index=timeindex[:-1])
+            # TODO: Align with standard model
+            else:
+                df = pd.DataFrame({"duals": duals}, index=timeindex)
+            if (bus, None) not in result_dict.keys():
+                result_dict[(bus, None)] = {
+                    "sequences": df,
+                    "scalars": pd.Series(dtype=float),
+                }
+            else:
+                result_dict[(bus, None)]["sequences"]["duals"] = duals
+
+    return result_dict

src/oemof/solph/constraints/flow_count_limit.py

@@ -130,9 +130,14 @@ def limit_active_flow_count_by_keyword(
     limit_active_flow_count
     """
     flows = []
-    for i, o in model.NonConvexFlowBlock.NONCONVEX_FLOWS:
-        if hasattr(model.flows[i, o], keyword):
-            flows.append((i, o))
+    if hasattr(model.NonConvexFlowBlock, "FIXED_CAPACITY_NONCONVEX_FLOWS"):
+        for i, o in model.NonConvexFlowBlock.FIXED_CAPACITY_NONCONVEX_FLOWS:
+            if hasattr(model.flows[i, o], keyword):
+                flows.append((i, o))
+    if hasattr(model.InvestNonConvexFlowBlock, "INVEST_NON_CONVEX_FLOWS"):
+        for i, o in model.InvestNonConvexFlowBlock.INVEST_NON_CONVEX_FLOWS:
+            if hasattr(model.flows[i, o], keyword):
+                flows.append((i, o))
 
     return limit_active_flow_count(
         model,

src/oemof/solph/flows/_non_convex_flow_block.py

@@ -71,7 +71,9 @@ def _create_sets(self, group):
 
         .. automethod:: _sets_for_non_convex_flows
         """
-        self.NONCONVEX_FLOWS = Set(initialize=[(g[0], g[1]) for g in group])
+        self.FIXED_CAPACITY_NONCONVEX_FLOWS = Set(
+            initialize=[(g[0], g[1]) for g in group]
+        )
 
         self._sets_for_non_convex_flows(group)
 
@@ -86,8 +88,10 @@ def _create_variables(self):
         .. automethod:: _variables_for_non_convex_flows
         """
         m = self.parent_block()
-        self.status = Var(self.NONCONVEX_FLOWS, m.TIMESTEPS, within=Binary)
-        for o, i in self.NONCONVEX_FLOWS:
+        self.status = Var(
+            self.FIXED_CAPACITY_NONCONVEX_FLOWS, m.TIMESTEPS, within=Binary
+        )
+        for o, i in self.FIXED_CAPACITY_NONCONVEX_FLOWS:
             if m.flows[o, i].nonconvex.initial_status is not None:
                 for t in range(
                     0, m.flows[o, i].nonconvex.first_flexible_timestep
@@ -101,7 +105,9 @@ def _create_variables(self):
         # multiplication of a binary variable (`status`)
         # and a continuous variable (`invest` or `nominal_capacity`)
         self.status_nominal = Var(
-            self.NONCONVEX_FLOWS, m.TIMESTEPS, within=NonNegativeReals
+            self.FIXED_CAPACITY_NONCONVEX_FLOWS,
+            m.TIMESTEPS,
+            within=NonNegativeReals,
         )
 
         self._variables_for_non_convex_flows()
@@ -132,7 +138,7 @@ def _objective_expression(self):
         .. automethod:: _activity_costs
         .. automethod:: _inactivity_costs
         """
-        if not hasattr(self, "NONCONVEX_FLOWS"):
+        if not hasattr(self, "FIXED_CAPACITY_NONCONVEX_FLOWS"):
             return 0
 
         startup_costs = self._startup_costs()
@@ -669,7 +675,9 @@ def _status_nominal_rule(_, i, o, t):
             return expr
 
         return Constraint(
-            self.NONCONVEX_FLOWS, m.TIMESTEPS, rule=_status_nominal_rule
+            self.FIXED_CAPACITY_NONCONVEX_FLOWS,
+            m.TIMESTEPS,
+            rule=_status_nominal_rule,
         )
 
     def _shared_constraints_for_non_convex_flows(self):