Fix minimum up-/ downtime

docs/whatsnew/v0-5-2.rst

@@ -23,6 +23,7 @@ Bug fixes
   bias towards investments happening earlier in the optimization horizon.
 * Fix bugs in multi-period documentation.
 * Fix y intersect of OffsetConverter
+* Fix minimum uptime being relevant for initial downtime (and vice versa).
 
 Testing
 #######

src/oemof/solph/_options.py

@@ -13,7 +13,6 @@
 SPDX-License-Identifier: MIT
 
 """
-
 from oemof.solph._plumbing import sequence
 
 
@@ -232,8 +231,8 @@ def __init__(
             custom_attributes = {}
 
         self.initial_status = initial_status
-        self.minimum_uptime = minimum_uptime
-        self.minimum_downtime = minimum_downtime
+        self.minimum_uptime = sequence(minimum_uptime)
+        self.minimum_downtime = sequence(minimum_downtime)
         self.maximum_startups = maximum_startups
         self.maximum_shutdowns = maximum_shutdowns
 
@@ -247,11 +246,7 @@ def __init__(
         for attribute, value in custom_attributes.items():
             setattr(self, attribute, value)
 
-    @property
-    def max_up_down(self):
-        """Return maximum of minimum_uptime and minimum_downtime.
-
-        The maximum of both is used to set the initial status for this
-        number of time steps within the edge regions.
-        """
-        return max(self.minimum_uptime, self.minimum_downtime)
+        if initial_status == 0:
+            self.first_flexible_timestep = self.minimum_downtime[0]
+        else:
+            self.first_flexible_timestep = self.minimum_uptime[0]

src/oemof/solph/_plumbing.py

@@ -61,7 +61,7 @@ class _Sequence(UserList):
     --------
     >>> s = _Sequence(default=42)
     >>> len(s)
-    0
+    1
     >>> s[1]
     42
     >>> s[2]
@@ -79,7 +79,7 @@ class _Sequence(UserList):
     def __init__(self, *args, **kwargs):
         self.default = kwargs["default"]
         self.default_changed = False
-        self.highest_index = -1
+        self.highest_index = 0
         super().__init__(*args)
 
     def __getitem__(self, key):

src/oemof/solph/flows/_non_convex_flow_block.py

@@ -85,6 +85,15 @@ def _create_variables(self):
         """
         m = self.parent_block()
         self.status = Var(self.NONCONVEX_FLOWS, m.TIMESTEPS, within=Binary)
+        for o, i in self.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
+                ):
+                    self.status[o, i, t] = m.flows[
+                        o, i
+                    ].nonconvex.initial_status
+                    self.status[o, i, t].fix()
 
         # `status_nominal` is a parameter which represents the
         # multiplication of a binary variable (`status`)
@@ -173,10 +182,10 @@ def _sets_for_non_convex_flows(self, group):
             `maximum_shutdowns` being not None.
         MINUPTIMEFLOWS
             A subset of set NONCONVEX_FLOWS with the attribute
-            `minimum_uptime` being not None.
+            `minimum_uptime` being > 0.
         MINDOWNTIMEFLOWS
             A subset of set NONCONVEX_FLOWS with the attribute
-            `minimum_downtime` being not None.
+            `minimum_downtime` being > 0.
         POSITIVE_GRADIENT_FLOWS
             A subset of set NONCONVEX_FLOWS with the attribute
             `positive_gradient` being not None.
@@ -221,14 +230,14 @@ def _sets_for_non_convex_flows(self, group):
             initialize=[
                 (g[0], g[1])
                 for g in group
-                if g[2].nonconvex.minimum_uptime > 0
+                if max(g[2].nonconvex.minimum_uptime) > 0
             ]
         )
         self.MINDOWNTIMEFLOWS = Set(
             initialize=[
                 (g[0], g[1])
                 for g in group
-                if g[2].nonconvex.minimum_downtime > 0
+                if max(g[2].nonconvex.minimum_downtime) > 0
             ]
         )
         self.NEGATIVE_GRADIENT_FLOWS = Set(
@@ -441,10 +450,6 @@ def _inactivity_costs(self):
 
         return inactivity_costs
 
-    @staticmethod
-    def _time_step_allows_flexibility(t, max_up_down, last_step):
-        return max_up_down <= t <= last_step - max_up_down
-
     def _min_downtime_constraint(self):
         r"""
         .. math::
@@ -469,24 +474,32 @@ def min_downtime_rule(_, i, o, t):
             """
             Rule definition for min-downtime constraints of non-convex flows.
             """
-            if self._time_step_allows_flexibility(
-                t, m.flows[i, o].nonconvex.max_up_down, m.TIMESTEPS.at(-1)
+            if (
+                m.flows[i, o].nonconvex.first_flexible_timestep
+                < t
+                < m.TIMESTEPS.at(-1)
             ):
+                # We have a 2D matrix of constraints,
+                # so testing is easier then just calling the rule for valid t.
+
                 expr = 0
                 expr += (
                     self.status[i, o, t - 1] - self.status[i, o, t]
-                ) * m.flows[i, o].nonconvex.minimum_downtime
-                expr += -m.flows[i, o].nonconvex.minimum_downtime
+                ) * m.flows[i, o].nonconvex.minimum_downtime[t]
+                expr += -m.flows[i, o].nonconvex.minimum_downtime[t]
                 expr += sum(
-                    self.status[i, o, t + d]
-                    for d in range(0, m.flows[i, o].nonconvex.minimum_downtime)
+                    self.status[i, o, d]
+                    for d in range(
+                        t,
+                        min(
+                            t + m.flows[i, o].nonconvex.minimum_downtime[t],
+                            m.TIMESTEPS.at(-1),
+                        ),
+                    )
                 )
                 return expr <= 0
             else:
-                expr = 0
-                expr += self.status[i, o, t]
-                expr += -m.flows[i, o].nonconvex.initial_status
-                return expr == 0
+                return Constraint.Skip
 
         return Constraint(
             self.MINDOWNTIMEFLOWS, m.TIMESTEPS, rule=min_downtime_rule
@@ -514,23 +527,30 @@ def _min_uptime_rule(_, i, o, t):
             """
             Rule definition for min-uptime constraints of non-convex flows.
             """
-            if self._time_step_allows_flexibility(
-                t, m.flows[i, o].nonconvex.max_up_down, m.TIMESTEPS.at(-1)
+            if (
+                m.flows[i, o].nonconvex.first_flexible_timestep
+                < t
+                < m.TIMESTEPS.at(-1)
             ):
+                # We have a 2D matrix of constraints,
+                # so testing is easier then just calling the rule for valid t.
                 expr = 0
                 expr += (
                     self.status[i, o, t] - self.status[i, o, t - 1]
-                ) * m.flows[i, o].nonconvex.minimum_uptime
+                ) * m.flows[i, o].nonconvex.minimum_uptime[t]
                 expr += -sum(
-                    self.status[i, o, t + u]
-                    for u in range(0, m.flows[i, o].nonconvex.minimum_uptime)
+                    self.status[i, o, u]
+                    for u in range(
+                        t,
+                        min(
+                            t + m.flows[i, o].nonconvex.minimum_uptime[t],
+                            m.TIMESTEPS.at(-1),
+                        ),
+                    )
                 )
                 return expr <= 0
             else:
-                expr = 0
-                expr += self.status[i, o, t]
-                expr += -m.flows[i, o].nonconvex.initial_status
-                return expr == 0
+                return Constraint.Skip
 
         return Constraint(
             self.MINUPTIMEFLOWS, m.TIMESTEPS, rule=_min_uptime_rule

tests/constraint_tests.py

@@ -1227,7 +1227,7 @@ def test_min_max_runtime(self):
                     nonconvex=solph.NonConvex(
                         minimum_downtime=4,
                         minimum_uptime=2,
-                        initial_status=2,
+                        initial_status=1,
                         startup_costs=5,
                         shutdown_costs=7,
                     ),

tests/lp_files/min_max_runtime.lp

@@ -28,8 +28,7 @@ c_e_BusBlock_balance(Bus_T_0_2)_:
 
 c_e_NonConvexFlowBlock_status_nominal_constraint(cheap_plant_min_down_constraints_Bus_T_0)_:
 +1 NonConvexFlowBlock_status_nominal(cheap_plant_min_down_constraints_Bus_T_0)
--10 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_0)
-= 0
+= 20
 
 c_e_NonConvexFlowBlock_status_nominal_constraint(cheap_plant_min_down_constraints_Bus_T_1)_:
 +1 NonConvexFlowBlock_status_nominal(cheap_plant_min_down_constraints_Bus_T_1)
@@ -73,14 +72,12 @@ c_u_NonConvexFlowBlock_max(cheap_plant_min_down_constraints_Bus_T_0_2)_:
 
 c_u_NonConvexFlowBlock_startup_constr(cheap_plant_min_down_constraints_Bus_T_0)_:
 -1 NonConvexFlowBlock_startup(cheap_plant_min_down_constraints_Bus_T_0)
-+1 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_0)
-<= 2
+<= 0
 
 c_u_NonConvexFlowBlock_startup_constr(cheap_plant_min_down_constraints_Bus_T_1)_:
 -1 NonConvexFlowBlock_startup(cheap_plant_min_down_constraints_Bus_T_1)
--1 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_0)
 +1 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_1)
-<= 0
+<= 2
 
 c_u_NonConvexFlowBlock_startup_constr(cheap_plant_min_down_constraints_Bus_T_2)_:
 -1 NonConvexFlowBlock_startup(cheap_plant_min_down_constraints_Bus_T_2)
@@ -90,44 +87,36 @@ c_u_NonConvexFlowBlock_startup_constr(cheap_plant_min_down_constraints_Bus_T_2)_
 
 c_u_NonConvexFlowBlock_shutdown_constr(cheap_plant_min_down_constraints_Bus_T_0)_:
 -1 NonConvexFlowBlock_shutdown(cheap_plant_min_down_constraints_Bus_T_0)
--1 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_0)
-<= -2
+<= 0
 
 c_u_NonConvexFlowBlock_shutdown_constr(cheap_plant_min_down_constraints_Bus_T_1)_:
 -1 NonConvexFlowBlock_shutdown(cheap_plant_min_down_constraints_Bus_T_1)
-+1 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_0)
 -1 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_1)
-<= 0
+<= -2
 
 c_u_NonConvexFlowBlock_shutdown_constr(cheap_plant_min_down_constraints_Bus_T_2)_:
 -1 NonConvexFlowBlock_shutdown(cheap_plant_min_down_constraints_Bus_T_2)
 +1 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_1)
 -1 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_2)
 <= 0
 
-c_e_NonConvexFlowBlock_min_uptime_constr(cheap_plant_min_down_constraints_Bus_T_0)_:
-+1 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_0)
-= 2
-
-c_e_NonConvexFlowBlock_min_uptime_constr(cheap_plant_min_down_constraints_Bus_T_1)_:
+c_u_NonConvexFlowBlock_min_uptime_constr(cheap_plant_min_down_constraints_Bus_T_0)_:
 +1 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_1)
-= 2
-
-c_e_NonConvexFlowBlock_min_uptime_constr(cheap_plant_min_down_constraints_Bus_T_2)_:
-+1 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_2)
-= 2
+<= 6
 
-c_e_NonConvexFlowBlock_min_downtime_constr(cheap_plant_min_down_constraints_Bus_T_0)_:
-+1 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_0)
-= 2
+c_u_NonConvexFlowBlock_min_uptime_constr(cheap_plant_min_down_constraints_Bus_T_1)_:
+-3 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_1)
++2 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_2)
+<= 0
 
-c_e_NonConvexFlowBlock_min_downtime_constr(cheap_plant_min_down_constraints_Bus_T_1)_:
-+1 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_1)
-= 2
+c_u_NonConvexFlowBlock_min_downtime_constr(cheap_plant_min_down_constraints_Bus_T_0)_:
+-3 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_1)
+<= -6
 
-c_e_NonConvexFlowBlock_min_downtime_constr(cheap_plant_min_down_constraints_Bus_T_2)_:
-+1 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_2)
-= 2
+c_u_NonConvexFlowBlock_min_downtime_constr(cheap_plant_min_down_constraints_Bus_T_1)_:
++5 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_1)
+-4 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_2)
+<= 4
 
 bounds
    0 <= flow(cheap_plant_min_down_constraints_Bus_T_0_0) <= 10.0
@@ -140,7 +129,6 @@ bounds
    0 <= NonConvexFlowBlock_shutdown(cheap_plant_min_down_constraints_Bus_T_1) <= 1
    0 <= NonConvexFlowBlock_shutdown(cheap_plant_min_down_constraints_Bus_T_2) <= 1
    0 <= NonConvexFlowBlock_status_nominal(cheap_plant_min_down_constraints_Bus_T_0) <= +inf
-   0 <= NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_0) <= 1
    0 <= NonConvexFlowBlock_status_nominal(cheap_plant_min_down_constraints_Bus_T_1) <= +inf
    0 <= NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_1) <= 1
    0 <= NonConvexFlowBlock_status_nominal(cheap_plant_min_down_constraints_Bus_T_2) <= +inf
@@ -152,7 +140,6 @@ binary
   NonConvexFlowBlock_shutdown(cheap_plant_min_down_constraints_Bus_T_0)
   NonConvexFlowBlock_shutdown(cheap_plant_min_down_constraints_Bus_T_1)
   NonConvexFlowBlock_shutdown(cheap_plant_min_down_constraints_Bus_T_2)
-  NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_0)
   NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_1)
   NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_2)
 end

tests/test_plumbing.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -
+
+"""Testing the class NonConvex.
+
+SPDX-FileCopyrightText: Patrik Schönfeldt
+
+SPDX-License-Identifier: MIT
+"""
+import pytest
+
+from oemof.solph._plumbing import sequence
+
+
+def test_sequence():
+    seq0 = sequence(0)
+    assert seq0[0] == 0
+    assert len(seq0) == 1
+
+    assert seq0[10] == 0
+    assert len(seq0) == 11
+
+    assert max(seq0) == 0
+
+    seq10 = sequence(10)
+    assert max(seq10) == 10
+
+    assert seq10[0] == 10
+    assert len(seq10) == 1
+
+    assert seq10[10] == 10
+    assert len(seq10) == 11
+
+    seq12 = sequence([1, 3])
+    assert max(seq12) == 3
+    assert seq12[0] == 1
+    assert seq12[1] == 3
+
+    with pytest.raises(IndexError):
+        seq12[2]

tests/test_scripts/test_solph/test_options/test_non_convex.py

@@ -22,24 +22,3 @@ def test_custom_attribute():
 
     assert non_convex_object.first_attribute is True
     assert non_convex_object.second_attribute == 5
-
-
-def test_max_up_down():
-    non_convex_object1 = NonConvex(
-        minimum_uptime=5,
-        minimum_downtime=4,
-    )
-    assert non_convex_object1.max_up_down == 5
-
-    non_convex_object1 = NonConvex(
-        minimum_downtime=4,
-    )
-    assert non_convex_object1.max_up_down == 4
-
-    non_convex_object1 = NonConvex(
-        minimum_uptime=5,
-    )
-    assert non_convex_object1.max_up_down == 5
-
-    non_convex_object1 = NonConvex()
-    assert non_convex_object1.max_up_down == 0