Fix minimum up-/ downtime

docs/whatsnew/v0-5-2.rst

@@ -11,6 +11,7 @@ New features
 
 * Allow for evaluating differences in the remaining vs. the original value
   for multi-period investments.
+* Allow to define minimum up- and down-time per time step
 
 Documentation
 #############
@@ -23,6 +24,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).
 * Fix duplicated discounting of fixed costs for multi-period investment
 
 Testing

src/oemof/solph/_options.py

@@ -13,7 +13,6 @@
 SPDX-License-Identifier: MIT
 
 """
-
 from oemof.solph._plumbing import sequence
 
 
@@ -184,11 +183,11 @@ class NonConvex:
         from the actual output.
     inactivity_costs : numeric (iterable or scalar)
         Costs associated with not operating the flow.
-    minimum_uptime : numeric (1 or positive integer)
+    minimum_uptime : numeric or list of numeric (1 or positive integer)
         Minimum number of time steps that a flow must be greater then its
         minimum flow after startup. Be aware that minimum up and downtimes
         can contradict each other and may lead to infeasible problems.
-    minimum_downtime : numeric (1 or positive integer)
+    minimum_downtime : numeric or list of numeric (1 or positive integer)
         Minimum number of time steps a flow is forced to zero after
         shutting down. Be aware that minimum up and downtimes can
         contradict each other and may to infeasible problems.
@@ -199,12 +198,12 @@ class NonConvex:
     initial_status : numeric (0 or 1)
         Integer value indicating the status of the flow in the first time step
         (0 = off, 1 = on). For minimum up and downtimes, the initial status
-        is set for the respective values in the edge regions e.g. if a
-        minimum uptime of four timesteps is defined, the initial status is
-        fixed for the four first and last timesteps of the optimization period.
-        If both, up and downtimes are defined, the initial status is set for
-        the maximum of both e.g. for six timesteps if a minimum downtime of
-        six timesteps is defined besides a four timestep minimum uptime.
+        is set for the respective values in the beginning e.g. if a
+        minimum uptime of four timesteps is defined and the initial status is
+        set to one, the initial status is fixed for the four first timesteps
+        of the optimization period. Otherwise if the initial status is set to
+        zero and the first timesteps are fixed for the number of minimum
+        downtime steps.
     negative_gradient_limit : numeric (iterable, scalar or None)
         the normed *upper bound* on the positive difference
         (`flow[t-1] < flow[t]`) of two consecutive flow values.
@@ -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],
+                            len(m.TIMESTEPS),
+                        ),
+                    )
                 )
                 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],
+                            len(m.TIMESTEPS),
+                        ),
+                    )
                 )
                 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

@@ -520,7 +520,7 @@ def test_storage_invest_1_fixed_losses(self):
             inflow_conversion_factor=0.97,
             outflow_conversion_factor=0.86,
             nominal_storage_capacity=solph.Investment(
-                ep_costs=145, maximum=234
+                ep_costs=145, minimum=1, maximum=234
             ),
         )
         self.energysystem.add(bel, storage)
@@ -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,13 +28,11 @@ 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
+= 10
 
 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)
--10 NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_1)
-= 0
+= 10
 
 c_e_NonConvexFlowBlock_status_nominal_constraint(cheap_plant_min_down_constraints_Bus_T_2)_:
 +1 NonConvexFlowBlock_status_nominal(cheap_plant_min_down_constraints_Bus_T_2)
@@ -73,61 +71,29 @@ 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
 
 c_u_NonConvexFlowBlock_startup_constr(cheap_plant_min_down_constraints_Bus_T_2)_:
 -1 NonConvexFlowBlock_startup(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
+<= 1
 
 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
 
 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)_:
-+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
-
-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_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_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
+<= -1
 
 bounds
    0 <= flow(cheap_plant_min_down_constraints_Bus_T_0_0) <= 10.0
@@ -140,9 +106,7 @@ 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
    0 <= NonConvexFlowBlock_status(cheap_plant_min_down_constraints_Bus_T_2) <= 1
 binary
@@ -152,7 +116,5 @@ 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