Fix/specific timeincrement docs

src/oemof/solph/_options.py

@@ -185,13 +185,13 @@ class NonConvex:
     inactivity_costs : numeric (iterable or scalar)
         Costs associated with not operating the flow.
     minimum_uptime : numeric (1 or positive integer)
-        Minimum time 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 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 time 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.
+        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.
     maximum_startups : numeric (0 or positive integer)
         Maximum number of start-ups in the optimization timeframe.
     maximum_shutdowns : numeric (0 or positive integer)

src/oemof/solph/components/_generic_storage.py

@@ -80,7 +80,7 @@ class GenericStorage(Node):
         Couple storage level of first and last time step.
         (Total inflow and total outflow are balanced.)
     loss_rate : numeric (iterable or scalar)
-        The relative loss of the storage content per time unit (e.g. hour).
+        The relative loss of the storage content per hour.
     fixed_losses_relative : numeric (iterable or scalar), :math:`\gamma(t)`
         Losses per hour that are independent of the storage content but
         proportional to nominal storage capacity.
@@ -395,16 +395,12 @@ class GenericStorageBlock(ScalarBlock):
     :math:`c_{max}(t)`          maximum allowed storage `max_storage_level[t]`
     :math:`\beta(t)`            fraction of lost energy `loss_rate[t]`
                                 as share of
-                                :math:`E(t)`
-                                per time unit
-                                (e.g. hour)
+                                :math:`E(t)` per hour
     :math:`\gamma(t)`           fixed loss of energy    `fixed_losses_relative[t]`
-                                relative to
-                                :math:`E_{nom}` per
-                                time unit (e.g. hour)
+                                per hour relative to
+                                :math:`E_{nom}`
     :math:`\delta(t)`           absolute fixed loss     `fixed_losses_absolute[t]`
-                                of energy per
-                                time unit (e.g. hour)
+                                of energy per hour
     :math:`\dot{E}_i(t)`        energy flowing in       `inputs`
     :math:`\dot{E}_o(t)`        energy flowing out      `outputs`
     :math:`\eta_i(t)`           conversion factor       `inflow_conversion_factor[t]`
@@ -1079,11 +1075,11 @@ class GenericInvestmentStorageBlock(ScalarBlock):
         ":math:`r_{in,out}`", ":attr:`invest_relation_input_output`", "
         Relation of nominal in- and outflow"
         ":math:`\beta(t)`", "`loss_rate[t]`", "Fraction of lost energy
-        as share of :math:`E(t)` per time unit"
+        as share of :math:`E(t)` per hour"
         ":math:`\gamma(t)`", "`fixed_losses_relative[t]`", "Fixed loss
-        of energy relative to :math:`E_{invest} + E_{exist}` per time unit"
+        of energy relative to :math:`E_{invest} + E_{exist}` per hour"
         ":math:`\delta(t)`", "`fixed_losses_absolute[t]`", "Absolute
-        fixed loss of energy per time unit"
+        fixed loss of energy per hour"
         ":math:`\eta_i(t)`", "`inflow_conversion_factor[t]`", "
         Conversion factor (i.e. efficiency) when storing energy"
         ":math:`\eta_o(t)`", "`outflow_conversion_factor[t]`", "