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

docs/release-notes/v2.0.1.md

@@ -1,6 +1,6 @@
 # Release v2.0.1
 
-**Release Date:** 2025-04-20
+**Release Date:** 2025-04-10
 
 ## Improvements
 

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/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
@@ -313,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',
             ),
@@ -329,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',
@@ -344,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',
@@ -353,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',
@@ -419,9 +427,9 @@ class FlowModel(ElementModel):
             )
 
     @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
@@ -430,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, self.element.relative_maximum.active_data
-        return fixed_profile.active_data, fixed_profile.active_data
+            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_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):
@@ -513,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],
                 )
             )