flixopt 2.2.0b0__py3-none-any.whl → 2.2.0rc2__py3-none-any.whl

flixopt/elements.py

@@ -10,10 +10,10 @@ import linopy
 import numpy as np
 
 from .config import CONFIG
-from .core import PlausibilityError, Scalar, ScenarioData, TimestepData, extract_data
-from .effects import EffectValuesUserTimestep
-from .features import InvestmentModel, OnOffModel, PreventSimultaneousUsageModel
-from .interface import InvestParameters, OnOffParameters
+from .core import NumericData, NumericDataTS, PlausibilityError, Scalar, TimeSeriesCollection
+from .effects import EffectValuesUser
+from .features import InvestmentModel, OnOffModel, PiecewiseEffectsPerFlowHourModel, PreventSimultaneousUsageModel
+from .interface import InvestParameters, OnOffParameters, PiecewiseEffectsPerFlowHour
 from .structure import Element, ElementModel, SystemModel, register_class_for_io
 
 if TYPE_CHECKING:
@@ -96,7 +96,7 @@ class Bus(Element):
     """
 
     def __init__(
-        self, label: str, excess_penalty_per_flow_hour: Optional[TimestepData] = 1e5, meta_data: Optional[Dict] = None
+        self, label: str, excess_penalty_per_flow_hour: Optional[NumericDataTS] = 1e5, meta_data: Optional[Dict] = None
     ):
         """
         Args:
@@ -154,17 +154,18 @@ class Flow(Element):
         self,
         label: str,
         bus: str,
-        size: Union[ScenarioData, InvestParameters] = None,
-        fixed_relative_profile: Optional[TimestepData] = None,
-        relative_minimum: TimestepData = 0,
-        relative_maximum: TimestepData = 1,
-        effects_per_flow_hour: Optional[EffectValuesUserTimestep] = None,
+        size: Union[Scalar, InvestParameters] = None,
+        fixed_relative_profile: Optional[NumericDataTS] = None,
+        relative_minimum: NumericDataTS = 0,
+        relative_maximum: NumericDataTS = 1,
+        effects_per_flow_hour: Optional[EffectValuesUser] = None,
+        piecewise_effects_per_flow_hour: Optional[PiecewiseEffectsPerFlowHour] = None,
         on_off_parameters: Optional[OnOffParameters] = None,
-        flow_hours_total_max: Optional[ScenarioData] = None,
-        flow_hours_total_min: Optional[ScenarioData] = None,
-        load_factor_min: Optional[ScenarioData] = None,
-        load_factor_max: Optional[ScenarioData] = None,
-        previous_flow_rate: Optional[ScenarioData] = None,
+        flow_hours_total_max: Optional[Scalar] = None,
+        flow_hours_total_min: Optional[Scalar] = None,
+        load_factor_min: Optional[Scalar] = None,
+        load_factor_max: Optional[Scalar] = None,
+        previous_flow_rate: Optional[NumericData] = None,
         meta_data: Optional[Dict] = None,
     ):
         r"""
@@ -180,6 +181,7 @@ class Flow(Element):
                  def: :math:`load\_factor:= sumFlowHours/ (nominal\_val \cdot \Delta t_{tot})`
             load_factor_max: maximal load factor (see minimal load factor)
             effects_per_flow_hour: operational costs, costs per flow-"work"
+            piecewise_effects_per_flow_hour: piecewise relation between flow hours and effects
             on_off_parameters: If present, flow can be "off", i.e. be zero (only relevant if relative_minimum > 0)
                 Therefore a binary var "on" is used. Further, several other restrictions and effects can be modeled
                 through this On/Off State (See OnOffParameters)
@@ -207,6 +209,7 @@ class Flow(Element):
         self.load_factor_max = load_factor_max
         # self.positive_gradient = TimeSeries('positive_gradient', positive_gradient, self)
         self.effects_per_flow_hour = effects_per_flow_hour if effects_per_flow_hour is not None else {}
+        self.piecewise_effects_per_flow_hour = piecewise_effects_per_flow_hour
         self.flow_hours_total_max = flow_hours_total_max
         self.flow_hours_total_min = flow_hours_total_min
         self.on_off_parameters = on_off_parameters
@@ -248,25 +251,12 @@ class Flow(Element):
         self.effects_per_flow_hour = flow_system.create_effect_time_series(
             self.label_full, self.effects_per_flow_hour, 'per_flow_hour'
         )
-        self.flow_hours_total_max = flow_system.create_time_series(
-            f'{self.label_full}|flow_hours_total_max', self.flow_hours_total_max, has_time_dim=False
-        )
-        self.flow_hours_total_min = flow_system.create_time_series(
-            f'{self.label_full}|flow_hours_total_min', self.flow_hours_total_min, has_time_dim=False
-        )
-        self.load_factor_max = flow_system.create_time_series(
-            f'{self.label_full}|load_factor_max', self.load_factor_max, has_time_dim=False
-        )
-        self.load_factor_min = flow_system.create_time_series(
-            f'{self.label_full}|load_factor_min', self.load_factor_min, has_time_dim=False
-        )
-
+        if self.piecewise_effects_per_flow_hour is not None:
+            self.piecewise_effects_per_flow_hour.transform_data(flow_system, self.label_full)
         if self.on_off_parameters is not None:
             self.on_off_parameters.transform_data(flow_system, self.label_full)
         if isinstance(self.size, InvestParameters):
-            self.size.transform_data(flow_system, self.label_full)
-        else:
-            self.size = flow_system.create_time_series(f'{self.label_full}|size', self.size, has_time_dim=False)
+            self.size.transform_data(flow_system)
 
     def infos(self, use_numpy: bool = True, use_element_label: bool = False) -> Dict:
         infos = super().infos(use_numpy, use_element_label)
@@ -284,8 +274,8 @@ class Flow(Element):
         if np.any(self.relative_minimum > self.relative_maximum):
             raise PlausibilityError(self.label_full + ': Take care, that relative_minimum <= relative_maximum!')
 
-        if not isinstance(self.size, InvestParameters) and (
-                np.any(self.size == CONFIG.modeling.BIG) and self.fixed_relative_profile is not None
+        if (
+            self.size == CONFIG.modeling.BIG and self.fixed_relative_profile is not None
         ):  # Default Size --> Most likely by accident
             logger.warning(
                 f'Flow "{self.label}" has no size assigned, but a "fixed_relative_profile". '
@@ -294,14 +284,15 @@ class Flow(Element):
             )
 
         if self.fixed_relative_profile is not None and self.on_off_parameters is not None:
-            logger.warning(
-                f'Flow {self.label} has both a fixed_relative_profile and an on_off_parameters.'
-                f'This will allow the flow to be switched on and off, effectively differing from the fixed_flow_rate.'
+            raise ValueError(
+                f'Flow {self.label} has both a fixed_relative_profile and an on_off_parameters. This is not supported. '
+                f'Use relative_minimum and relative_maximum instead, '
+                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.selected_data} and no on_off_parameters. '
+                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.'
             )
@@ -337,7 +328,7 @@ class FlowModel(ElementModel):
             self._model.add_variables(
                 lower=self.flow_rate_lower_bound,
                 upper=self.flow_rate_upper_bound,
-                coords=self._model.get_coords(),
+                coords=self._model.coords,
                 name=f'{self.label_full}|flow_rate',
             ),
             'flow_rate',
@@ -366,8 +357,10 @@ 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.flow_rate_lower_bound_relative,
-                                                          self.flow_rate_upper_bound_relative),
+                    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',
@@ -376,9 +369,9 @@ class FlowModel(ElementModel):
 
         self.total_flow_hours = self.add(
             self._model.add_variables(
-                lower=extract_data(self.element.flow_hours_total_min, 0),
-                upper=extract_data(self.element.flow_hours_total_max, np.inf),
-                coords=self._model.get_coords(time_dim=False),
+                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',
             ),
             'total_flow_hours',
@@ -386,7 +379,7 @@ class FlowModel(ElementModel):
 
         self.add(
             self._model.add_constraints(
-                self.total_flow_hours == (self.flow_rate * self._model.hours_per_step).sum('time'),
+                self.total_flow_hours == (self.flow_rate * self._model.hours_per_step).sum(),
                 name=f'{self.label_full}|total_flow_hours',
             ),
             'total_flow_hours',
@@ -398,33 +391,40 @@ class FlowModel(ElementModel):
         # Shares
         self._create_shares()
 
-    def results_structure(self):
-        return {
-            **super().results_structure(),
-            'start': self.element.bus if self.element.is_input_in_component else self.element.component,
-            'end': self.element.component if self.element.is_input_in_component else self.element.bus,
-            'component': self.element.component,
-        }
-
     def _create_shares(self):
         # Arbeitskosten:
         if self.element.effects_per_flow_hour != {}:
             self._model.effects.add_share_to_effects(
                 name=self.label_full,  # Use the full label of the element
                 expressions={
-                    effect: self.flow_rate * self._model.hours_per_step * factor.selected_data
+                    effect: self.flow_rate * self._model.hours_per_step * factor.active_data
                     for effect, factor in self.element.effects_per_flow_hour.items()
                 },
                 target='operation',
             )
 
+        if self.element.piecewise_effects_per_flow_hour is not None:
+            self.piecewise_effects = self.add(
+                PiecewiseEffectsPerFlowHourModel(
+                    model=self._model,
+                    label_of_element=self.label_of_element,
+                    piecewise_origin=(
+                        self.flow_rate.name,
+                        self.element.piecewise_effects_per_flow_hour.piecewise_flow_rate,
+                    ),
+                    piecewise_shares=self.element.piecewise_effects_per_flow_hour.piecewise_shares,
+                    zero_point=self.on_off.on if self.on_off is not None else False,
+                ),
+            )
+            self.piecewise_effects.do_modeling()
+
     def _create_bounds_for_load_factor(self):
         # TODO: Add Variable load_factor for better evaluation?
 
         # eq: var_sumFlowHours <= size * dt_tot * load_factor_max
         if self.element.load_factor_max is not None:
             name_short = 'load_factor_max'
-            flow_hours_per_size_max = self._model.hours_per_step.sum('time') * self.element.load_factor_max
+            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
 
             self.add(
@@ -438,7 +438,7 @@ class FlowModel(ElementModel):
         #  eq: size * sum(dt)* load_factor_min <= var_sumFlowHours
         if self.element.load_factor_min is not None:
             name_short = 'load_factor_min'
-            flow_hours_per_size_min = self._model.hours_per_step.sum('time') * self.element.load_factor_min
+            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
 
             self.add(
@@ -450,36 +450,34 @@ class FlowModel(ElementModel):
             )
 
     @property
-    def flow_rate_bounds_on(self) -> Tuple[TimestepData, TimestepData]:
+    def flow_rate_bounds_on(self) -> Tuple[NumericData, NumericData]:
         """Returns absolute flow rate bounds. Important for OnOffModel"""
         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 * extract_data(size), relative_maximum * extract_data(size)
+            return relative_minimum * size, relative_maximum * size
         if size.fixed_size is not None:
-            return (relative_minimum * extract_data(size.fixed_size),
-                    relative_maximum * extract_data(size.fixed_size))
-        return (relative_minimum * extract_data(size.minimum_size),
-                relative_maximum * extract_data(size.maximum_size))
+            return relative_minimum * size.fixed_size, relative_maximum * size.fixed_size
+        return relative_minimum * size.minimum_size, relative_maximum * size.maximum_size
 
     @property
-    def flow_rate_lower_bound_relative(self) -> TimestepData:
+    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 extract_data(self.element.relative_minimum)
-        return extract_data(fixed_profile)
+            return self.element.relative_minimum.active_data
+        return fixed_profile.active_data
 
     @property
-    def flow_rate_upper_bound_relative(self) -> TimestepData:
-        """ Returns the upper bound of the flow_rate relative to its size"""
+    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 extract_data(self.element.relative_maximum)
-        return extract_data(fixed_profile)
+            return self.element.relative_maximum.active_data
+        return fixed_profile.active_data
 
     @property
-    def flow_rate_lower_bound(self) -> TimestepData:
+    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
@@ -489,18 +487,18 @@ class FlowModel(ElementModel):
         if isinstance(self.element.size, InvestParameters):
             if self.element.size.optional:
                 return 0
-            return self.flow_rate_lower_bound_relative * extract_data(self.element.size.minimum_size)
-        return self.flow_rate_lower_bound_relative * extract_data(self.element.size)
+            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) -> TimestepData:
+    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 * extract_data(self.element.size.maximum_size)
-        return self.flow_rate_upper_bound_relative * extract_data(self.element.size)
+            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):
@@ -521,18 +519,14 @@ class BusModel(ElementModel):
         # Fehlerplus/-minus:
         if self.element.with_excess:
             excess_penalty = np.multiply(
-                self._model.hours_per_step, self.element.excess_penalty_per_flow_hour.selected_data
+                self._model.hours_per_step, self.element.excess_penalty_per_flow_hour.active_data
             )
             self.excess_input = self.add(
-                self._model.add_variables(
-                    lower=0, coords=self._model.get_coords(), name=f'{self.label_full}|excess_input'
-                ),
+                self._model.add_variables(lower=0, coords=self._model.coords, name=f'{self.label_full}|excess_input'),
                 'excess_input',
             )
             self.excess_output = self.add(
-                self._model.add_variables(
-                    lower=0, coords=self._model.get_coords(), name=f'{self.label_full}|excess_output'
-                ),
+                self._model.add_variables(lower=0, coords=self._model.coords, name=f'{self.label_full}|excess_output'),
                 'excess_output',
             )
             eq_bus_balance.lhs -= -self.excess_input + self.excess_output
@@ -547,8 +541,7 @@ class BusModel(ElementModel):
             inputs.append(self.excess_input.name)
         if self.excess_output is not None:
             outputs.append(self.excess_output.name)
-        return {**super().results_structure(), 'inputs': inputs, 'outputs': outputs,
-                'flows': [flow.label_full for flow in self.element.inputs + self.element.outputs]}
+        return {**super().results_structure(), 'inputs': inputs, 'outputs': outputs}
 
 
 class ComponentModel(ElementModel):
@@ -601,5 +594,4 @@ class ComponentModel(ElementModel):
             **super().results_structure(),
             'inputs': [flow.model.flow_rate.name for flow in self.element.inputs],
             'outputs': [flow.model.flow_rate.name for flow in self.element.outputs],
-            'flows': [flow.label_full for flow in self.element.inputs + self.element.outputs],
         }