flixopt 2.0.0__py3-none-any.whl → 2.1.0__py3-none-any.whl

docs/release-notes/v2.0.1.md

@@ -0,0 +1,12 @@
+# Release v2.0.1
+
+**Release Date:** 2025-04-10
+
+## Improvements
+
+* Add logger warning if relative_minimum is used without on_off_parameters in Flow, as this prevents the flow_rate from switching "OFF"
+
+## Bug Fixes
+
+* Replace "|" with "__" in filenames when saving figures, as "|" can lead to issues on windows
+* Fixed a Bug that prevented the load factor from working without InvestmentParameters

docs/release-notes/v2.1.0.md

@@ -0,0 +1,31 @@
+# Release v2.1.0
+
+**Release Date:** 2025-04-11
+
+## Improvements
+
+* Add logger warning if relative_minimum is used without on_off_parameters in Flow, as this prevents the flow_rate from switching "OFF"
+* Python 3.13 support added
+* Greatly improved internal testing infrastructure by leveraging linopy's testing framework
+
+## Bug Fixes
+
+* Bugfixing the lower bound of `flow_rate` when using optional investments without OnOffParameters.
+* Fixes a Bug that prevented divest effects from working.
+* added lower bounds of 0 to two unbounded vars (only numerical better)
+
+## Breaking Changes
+
+* We restructured the modeling of the On/Off state of FLows or Components. This leads to slightly renaming of variables and constraints.
+
+### Variable renaming
+* "...|consecutive_on_hours" is now "...|ConsecutiveOn|hours"
+* "...|consecutive_off_hours" is now "...|ConsecutiveOff|hours"
+
+### Constraint renaming
+* "...|consecutive_on_hours_con1" is now "...|ConsecutiveOn|con1"
+* "...|consecutive_on_hours_con2a" is now "...|ConsecutiveOn|con2a"
+* "...|consecutive_on_hours_con2b" is now "...|ConsecutiveOn|con2b"
+* "...|consecutive_on_hours_initial" is now "...|ConsecutiveOn|initial"
+* "...|consecutive_on_hours_minimum_duration" is now "...|ConsecutiveOn|minimum"
+The same goes for "...|consecutive_off..." --> "...|ConsecutiveOff|..."

flixopt/components.py

@@ -60,6 +60,7 @@ class LinearConverter(Component):
         return self.model
 
     def _plausibility_checks(self) -> None:
+        super()._plausibility_checks()
         if not self.conversion_factors and not self.piecewise_conversion:
             raise PlausibilityError('Either conversion_factors or piecewise_conversion must be defined!')
         if self.conversion_factors and self.piecewise_conversion:
@@ -213,6 +214,7 @@ class Storage(Component):
         """
         Check for infeasible or uncommon combinations of parameters
         """
+        super()._plausibility_checks()
         if utils.is_number(self.initial_charge_state):
             if isinstance(self.capacity_in_flow_hours, InvestParameters):
                 if self.capacity_in_flow_hours.fixed_size is None:
@@ -301,6 +303,7 @@ class Transmission(Component):
         self.absolute_losses = absolute_losses
 
     def _plausibility_checks(self):
+        super()._plausibility_checks()
         # check buses:
         if self.in2 is not None:
             assert self.in2.bus == self.out1.bus, (
@@ -396,6 +399,7 @@ class LinearConverterModel(ComponentModel):
         super().__init__(model, element)
         self.element: LinearConverter = element
         self.on_off: Optional[OnOffModel] = None
+        self.piecewise_conversion: Optional[PiecewiseConversion] = None
 
     def do_modeling(self):
         super().do_modeling()
@@ -426,16 +430,16 @@ class LinearConverterModel(ComponentModel):
                 for flow, piecewise in self.element.piecewise_conversion.items()
             }
 
-            piecewise_conversion = PiecewiseModel(
-                model=self._model,
-                label_of_element=self.label_of_element,
-                label=self.label_full,
-                piecewise_variables=piecewise_conversion,
-                zero_point=self.on_off.on if self.on_off is not None else False,
-                as_time_series=True,
+            self.piecewise_conversion = self.add(
+                PiecewiseModel(
+                    model=self._model,
+                    label_of_element=self.label_of_element,
+                    piecewise_variables=piecewise_conversion,
+                    zero_point=self.on_off.on if self.on_off is not None else False,
+                    as_time_series=True,
+                )
             )
-            piecewise_conversion.do_modeling()
-            self.sub_models.append(piecewise_conversion)
+            self.piecewise_conversion.do_modeling()
 
 
 class StorageModel(ComponentModel):

flixopt/core.py

@@ -426,8 +426,64 @@ class TimeSeries:
             True if all values in this TimeSeries are greater than other
         """
         if isinstance(other, TimeSeries):
-            return (self.active_data > other.active_data).all().item()
-        return NotImplemented
+            return self.active_data > other.active_data
+        return self.active_data > other
+
+    def __ge__(self, other):
+        """
+        Compare if this TimeSeries is greater than or equal to another.
+
+        Args:
+            other: Another TimeSeries to compare with
+
+        Returns:
+            True if all values in this TimeSeries are greater than or equal to other
+        """
+        if isinstance(other, TimeSeries):
+            return self.active_data >= other.active_data
+        return self.active_data >= other
+
+    def __lt__(self, other):
+        """
+        Compare if this TimeSeries is less than another.
+
+        Args:
+            other: Another TimeSeries to compare with
+
+        Returns:
+            True if all values in this TimeSeries are less than other
+        """
+        if isinstance(other, TimeSeries):
+            return self.active_data < other.active_data
+        return self.active_data < other
+
+    def __le__(self, other):
+        """
+        Compare if this TimeSeries is less than or equal to another.
+
+        Args:
+            other: Another TimeSeries to compare with
+
+        Returns:
+            True if all values in this TimeSeries are less than or equal to other
+        """
+        if isinstance(other, TimeSeries):
+            return self.active_data <= other.active_data
+        return self.active_data <= other
+
+    def __eq__(self, other):
+        """
+        Compare if this TimeSeries is equal to another.
+
+        Args:
+            other: Another TimeSeries to compare with
+
+        Returns:
+            True if all values in this TimeSeries are equal to other
+        """
+        if isinstance(other, TimeSeries):
+            return self.active_data == other.active_data
+        return self.active_data == other
 
     def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
         """
@@ -843,7 +899,7 @@ class TimeSeriesCollection:
         if isinstance(item, str):
             return item in self.time_series_data
         elif isinstance(item, TimeSeries):
-            return item in self.time_series_data.values()
+            return any([item is ts for ts in self.time_series_data.values()])
         return False
 
     @property

flixopt/elements.py

@@ -57,6 +57,7 @@ class Component(Element):
         super().__init__(label, meta_data=meta_data)
         self.inputs: List['Flow'] = inputs or []
         self.outputs: List['Flow'] = outputs or []
+        self._check_unique_flow_labels()
         self.on_off_parameters = on_off_parameters
         self.prevent_simultaneous_flows: List['Flow'] = prevent_simultaneous_flows or []
 
@@ -77,9 +78,15 @@ class Component(Element):
         infos['outputs'] = [flow.infos(use_numpy, use_element_label) for flow in self.outputs]
         return infos
 
+    def _check_unique_flow_labels(self):
+        all_flow_labels = [flow.label for flow in self.inputs + self.outputs]
+
+        if len(set(all_flow_labels)) != len(all_flow_labels):
+            duplicates = {label for label in all_flow_labels if all_flow_labels.count(label) > 1}
+            raise ValueError(f'Flow names must be unique! "{self.label_full}" got 2 or more of: {duplicates}')
+
     def _plausibility_checks(self) -> None:
-        # TODO: Check for plausibility
-        pass
+        self._check_unique_flow_labels()
 
 
 @register_class_for_io
@@ -115,7 +122,7 @@ class Bus(Element):
         )
 
     def _plausibility_checks(self) -> None:
-        if self.excess_penalty_per_flow_hour == 0:
+        if self.excess_penalty_per_flow_hour is not None and (self.excess_penalty_per_flow_hour == 0).all():
             logger.warning(f'In Bus {self.label}, the excess_penalty_per_flow_hour is 0. Use "None" or a value > 0.')
 
     @property
@@ -277,6 +284,13 @@ class Flow(Element):
                 f'if you want to allow flows to be switched on and off.'
             )
 
+        if (self.relative_minimum > 0).any() and self.on_off_parameters is None:
+            logger.warning(
+                f'Flow {self.label} has a relative_minimum of {self.relative_minimum.active_data} and no on_off_parameters. '
+                f'This prevents the flow_rate from switching off (flow_rate = 0). '
+                f'Consider using on_off_parameters to allow the flow to be switched on and off.'
+            )
+
     @property
     def label_full(self) -> str:
         return f'{self.component}({self.label})'
@@ -306,8 +320,8 @@ class FlowModel(ElementModel):
         # eq relative_minimum(t) * size <= flow_rate(t) <= relative_maximum(t) * size
         self.flow_rate: linopy.Variable = self.add(
             self._model.add_variables(
-                lower=self.absolute_flow_rate_bounds[0] if self.element.on_off_parameters is None else 0,
-                upper=self.absolute_flow_rate_bounds[1],
+                lower=self.flow_rate_lower_bound,
+                upper=self.flow_rate_upper_bound,
                 coords=self._model.coords,
                 name=f'{self.label_full}|flow_rate',
             ),
@@ -322,7 +336,7 @@ class FlowModel(ElementModel):
                     label_of_element=self.label_of_element,
                     on_off_parameters=self.element.on_off_parameters,
                     defining_variables=[self.flow_rate],
-                    defining_bounds=[self.absolute_flow_rate_bounds],
+                    defining_bounds=[self.flow_rate_bounds_on],
                     previous_values=[self.element.previous_flow_rate],
                 ),
                 'on_off',
@@ -337,7 +351,8 @@ class FlowModel(ElementModel):
                     label_of_element=self.label_of_element,
                     parameters=self.element.size,
                     defining_variable=self.flow_rate,
-                    relative_bounds_of_defining_variable=self.relative_flow_rate_bounds,
+                    relative_bounds_of_defining_variable=(self.flow_rate_lower_bound_relative,
+                                                          self.flow_rate_upper_bound_relative),
                     on_variable=self.on_off.on if self.on_off is not None else None,
                 ),
                 'investment',
@@ -346,7 +361,7 @@ class FlowModel(ElementModel):
 
         self.total_flow_hours = self.add(
             self._model.add_variables(
-                lower=self.element.flow_hours_total_min if self.element.flow_hours_total_min is not None else -np.inf,
+                lower=self.element.flow_hours_total_min if self.element.flow_hours_total_min is not None else 0,
                 upper=self.element.flow_hours_total_max if self.element.flow_hours_total_max is not None else np.inf,
                 coords=None,
                 name=f'{self.label_full}|total_flow_hours',
@@ -389,14 +404,13 @@ class FlowModel(ElementModel):
             flow_hours_per_size_max = self._model.hours_per_step.sum() * self.element.load_factor_max
             size = self.element.size if self._investment is None else self._investment.size
 
-            if self._investment is not None:
-                self.add(
-                    self._model.add_constraints(
-                        self.total_flow_hours <= size * flow_hours_per_size_max,
-                        name=f'{self.label_full}|{name_short}',
-                    ),
-                    name_short,
-                )
+            self.add(
+                self._model.add_constraints(
+                    self.total_flow_hours <= size * flow_hours_per_size_max,
+                    name=f'{self.label_full}|{name_short}',
+                ),
+                name_short,
+            )
 
         #  eq: size * sum(dt)* load_factor_min <= var_sumFlowHours
         if self.element.load_factor_min is not None:
@@ -404,19 +418,18 @@ class FlowModel(ElementModel):
             flow_hours_per_size_min = self._model.hours_per_step.sum() * self.element.load_factor_min
             size = self.element.size if self._investment is None else self._investment.size
 
-            if self._investment is not None:
-                self.add(
-                    self._model.add_constraints(
-                        self.total_flow_hours >= size * flow_hours_per_size_min,
-                        name=f'{self.label_full}|{name_short}',
-                    ),
-                    name_short,
-                )
+            self.add(
+                self._model.add_constraints(
+                    self.total_flow_hours >= size * flow_hours_per_size_min,
+                    name=f'{self.label_full}|{name_short}',
+                ),
+                name_short,
+            )
 
     @property
-    def absolute_flow_rate_bounds(self) -> Tuple[NumericData, NumericData]:
+    def flow_rate_bounds_on(self) -> Tuple[NumericData, NumericData]:
         """Returns absolute flow rate bounds. Important for OnOffModel"""
-        relative_minimum, relative_maximum = self.relative_flow_rate_bounds
+        relative_minimum, relative_maximum = self.flow_rate_lower_bound_relative, self.flow_rate_upper_bound_relative
         size = self.element.size
         if not isinstance(size, InvestParameters):
             return relative_minimum * size, relative_maximum * size
@@ -425,12 +438,44 @@ class FlowModel(ElementModel):
         return relative_minimum * size.minimum_size, relative_maximum * size.maximum_size
 
     @property
-    def relative_flow_rate_bounds(self) -> Tuple[NumericData, NumericData]:
-        """Returns relative flow rate bounds."""
+    def flow_rate_lower_bound_relative(self) -> NumericData:
+        """Returns the lower bound of the flow_rate relative to its size"""
+        fixed_profile = self.element.fixed_relative_profile
+        if fixed_profile is None:
+            return self.element.relative_minimum.active_data
+        return fixed_profile.active_data
+
+    @property
+    def flow_rate_upper_bound_relative(self) -> NumericData:
+        """ Returns the upper bound of the flow_rate relative to its size"""
         fixed_profile = self.element.fixed_relative_profile
         if fixed_profile is None:
-            return self.element.relative_minimum.active_data, self.element.relative_maximum.active_data
-        return fixed_profile.active_data, fixed_profile.active_data
+            return self.element.relative_maximum.active_data
+        return fixed_profile.active_data
+
+    @property
+    def flow_rate_lower_bound(self) -> NumericData:
+        """
+        Returns the minimum bound the flow_rate can reach.
+        Further constraining might be done in OnOffModel and InvestmentModel
+        """
+        if self.element.on_off_parameters is not None:
+            return 0
+        if isinstance(self.element.size, InvestParameters):
+            if self.element.size.optional:
+                return 0
+            return self.flow_rate_lower_bound_relative * self.element.size.minimum_size
+        return self.flow_rate_lower_bound_relative * self.element.size
+
+    @property
+    def flow_rate_upper_bound(self) -> NumericData:
+        """
+        Returns the maximum bound the flow_rate can reach.
+        Further constraining might be done in OnOffModel and InvestmentModel
+        """
+        if isinstance(self.element.size, InvestParameters):
+            return self.flow_rate_upper_bound_relative * self.element.size.maximum_size
+        return self.flow_rate_upper_bound_relative * self.element.size
 
 
 class BusModel(ElementModel):
@@ -508,7 +553,7 @@ class ComponentModel(ElementModel):
                     self.element.on_off_parameters,
                     self.label_of_element,
                     defining_variables=[flow.model.flow_rate for flow in all_flows],
-                    defining_bounds=[flow.model.absolute_flow_rate_bounds for flow in all_flows],
+                    defining_bounds=[flow.model.flow_rate_bounds_on for flow in all_flows],
                     previous_values=[flow.previous_flow_rate for flow in all_flows],
                 )
             )