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

flixopt/features.py

@@ -9,9 +9,10 @@ from typing import Dict, List, Optional, Tuple, Union
 import linopy
 import numpy as np
 
+from . import utils
 from .config import CONFIG
-from .core import Scalar, ScenarioData, TimeSeries, TimestepData, extract_data
-from .interface import InvestParameters, OnOffParameters, Piecewise
+from .core import NumericData, Scalar, TimeSeries
+from .interface import InvestParameters, OnOffParameters, Piece, Piecewise
 from .structure import Model, SystemModel
 
 logger = logging.getLogger('flixopt')
@@ -26,14 +27,13 @@ class InvestmentModel(Model):
         label_of_element: str,
         parameters: InvestParameters,
         defining_variable: [linopy.Variable],
-        relative_bounds_of_defining_variable: Tuple[TimestepData, TimestepData],
+        relative_bounds_of_defining_variable: Tuple[NumericData, NumericData],
         label: Optional[str] = None,
         on_variable: Optional[linopy.Variable] = None,
     ):
         super().__init__(model, label_of_element, label)
         self.size: Optional[Union[Scalar, linopy.Variable]] = None
         self.is_invested: Optional[linopy.Variable] = None
-        self.scenario_of_investment: Optional[linopy.Variable] = None
 
         self.piecewise_effects: Optional[PiecewiseEffectsModel] = None
 
@@ -43,32 +43,31 @@ class InvestmentModel(Model):
         self.parameters = parameters
 
     def do_modeling(self):
-        self.size = self.add(
-            self._model.add_variables(
-                lower=0 if self.parameters.optional else extract_data(self.parameters.minimum_size),
-                upper=extract_data(self.parameters.maximum_size),
-                name=f'{self.label_full}|size',
-                coords=self._model.get_coords(time_dim=False),
-            ),
-            'size',
-        )
+        if self.parameters.fixed_size and not self.parameters.optional:
+            self.size = self.add(
+                self._model.add_variables(
+                    lower=self.parameters.fixed_size, upper=self.parameters.fixed_size, name=f'{self.label_full}|size'
+                ),
+                'size',
+            )
+        else:
+            self.size = self.add(
+                self._model.add_variables(
+                    lower=0 if self.parameters.optional else self.parameters.minimum_size,
+                    upper=self.parameters.maximum_size,
+                    name=f'{self.label_full}|size',
+                ),
+                'size',
+            )
 
         # Optional
         if self.parameters.optional:
             self.is_invested = self.add(
-                self._model.add_variables(
-                    binary=True,
-                    name=f'{self.label_full}|is_invested',
-                    coords=self._model.get_coords(time_dim=False),
-                ),
-                'is_invested',
+                self._model.add_variables(binary=True, name=f'{self.label_full}|is_invested'), 'is_invested'
             )
 
             self._create_bounds_for_optional_investment()
 
-        if self._model.time_series_collection.scenarios is not None:
-            self._create_bounds_for_scenarios()
-
         # Bounds for defining variable
         self._create_bounds_for_defining_variable()
 
@@ -91,7 +90,10 @@ class InvestmentModel(Model):
             # share: divest_effects - isInvested * divest_effects
             self._model.effects.add_share_to_effects(
                 name=self.label_of_element,
-                expressions={effect: -self.is_invested * factor + factor for effect, factor in self.parameters.divest_effects.items()},
+                expressions={
+                    effect: -self.is_invested * factor + factor
+                    for effect, factor in self.parameters.divest_effects.items()
+                },
                 target='invest',
             )
 
@@ -154,6 +156,11 @@ class InvestmentModel(Model):
                 ),
                 f'fix_{variable.name}',
             )
+            if self._on_variable is not None:
+                raise ValueError(
+                    f'Flow {self.label_full} has a fixed relative flow rate and an on_variable.'
+                    f'This combination is currently not supported.'
+                )
             return
 
         # eq: defining_variable(t)  <= size * upper_bound(t)
@@ -178,7 +185,7 @@ class InvestmentModel(Model):
             #     ... mit mega = relative_maximum * maximum_size
             # äquivalent zu:.
             # eq: - defining_variable(t) + mega * On(t) + size * relative_minimum(t) <= + mega
-            mega = self.parameters.maximum_size * lb_relative
+            mega = lb_relative * self.parameters.maximum_size
             on = self._on_variable
             self.add(
                 self._model.add_constraints(
@@ -188,50 +195,6 @@ class InvestmentModel(Model):
             )
             # anmerkung: Glg bei Spezialfall relative_minimum = 0 redundant zu OnOff ??
 
-    def _create_bounds_for_scenarios(self):
-        if isinstance(self.parameters.investment_scenarios, str):
-            if self.parameters.investment_scenarios == 'individual':
-                return
-            raise ValueError(f'Invalid value for investment_scenarios: {self.parameters.investment_scenarios}')
-
-        if self.parameters.investment_scenarios is None:
-            self.add(
-                self._model.add_constraints(
-                    self.size.isel(scenario=slice(None, -1)) == self.size.isel(scenario=slice(1, None)),
-                    name=f'{self.label_full}|equalize_size_per_scenario',
-                ),
-                'equalize_size_per_scenario',
-            )
-            return
-        if not isinstance(self.parameters.investment_scenarios, list):
-            raise ValueError(f'Invalid value for investment_scenarios: {self.parameters.investment_scenarios}')
-        if not all(scenario in self._model.time_series_collection.scenarios for scenario in self.parameters.investment_scenarios):
-            raise ValueError(f'Some scenarios in investment_scenarios are not present in the time_series_collection: '
-                             f'{self.parameters.investment_scenarios}. This might be due to selecting a subset of '
-                             f'all scenarios, which is not yet supported.')
-
-        investment_scenarios = self._model.time_series_collection.scenarios.intersection(self.parameters.investment_scenarios)
-        no_investment_scenarios = self._model.time_series_collection.scenarios.difference(self.parameters.investment_scenarios)
-
-        # eq: size(s) = size(s')    for s, s' in investment_scenarios
-        if len(investment_scenarios) > 1:
-            self.add(
-                self._model.add_constraints(
-                    self.size.sel(scenario=investment_scenarios[:-1]) == self.size.sel(scenario=investment_scenarios[1:]),
-                    name=f'{self.label_full}|investment_scenarios',
-                    ),
-                'investment_scenarios',
-            )
-
-        if len(no_investment_scenarios) >= 1:
-            self.add(
-                self._model.add_constraints(
-                    self.size.sel(scenario=no_investment_scenarios) == 0,
-                    name=f'{self.label_full}|no_investment_scenarios',
-                    ),
-                'no_investment_scenarios',
-            )
-
 
 class StateModel(Model):
     """
@@ -243,12 +206,12 @@ class StateModel(Model):
         model: SystemModel,
         label_of_element: str,
         defining_variables: List[linopy.Variable],
-        defining_bounds: List[Tuple[TimestepData, TimestepData]],
-        previous_values: List[Optional[TimestepData]] = None,
+        defining_bounds: List[Tuple[NumericData, NumericData]],
+        previous_values: List[Optional[NumericData]] = None,
         use_off: bool = True,
-        on_hours_total_min: Optional[ScenarioData] = 0,
-        on_hours_total_max: Optional[ScenarioData] = None,
-        effects_per_running_hour: Dict[str, TimestepData] = None,
+        on_hours_total_min: Optional[NumericData] = 0,
+        on_hours_total_max: Optional[NumericData] = None,
+        effects_per_running_hour: Dict[str, NumericData] = None,
         label: Optional[str] = None,
     ):
         """
@@ -285,16 +248,16 @@ class StateModel(Model):
             self._model.add_variables(
                 name=f'{self.label_full}|on',
                 binary=True,
-                coords=self._model.get_coords(),
+                coords=self._model.coords,
             ),
             'on',
         )
 
         self.total_on_hours = self.add(
             self._model.add_variables(
-                lower=extract_data(self._on_hours_total_min),
-                upper=extract_data(self._on_hours_total_max),
-                coords=self._model.get_coords(time_dim=False),
+                lower=self._on_hours_total_min,
+                upper=self._on_hours_total_max,
+                coords=None,
                 name=f'{self.label_full}|on_hours_total',
             ),
             'on_hours_total',
@@ -302,7 +265,7 @@ class StateModel(Model):
 
         self.add(
             self._model.add_constraints(
-                self.total_on_hours == (self.on * self._model.hours_per_step).sum('time'),
+                self.total_on_hours == (self.on * self._model.hours_per_step).sum(),
                 name=f'{self.label_full}|on_hours_total',
             ),
             'on_hours_total',
@@ -316,7 +279,7 @@ class StateModel(Model):
                 self._model.add_variables(
                     name=f'{self.label_full}|off',
                     binary=True,
-                    coords=self._model.get_coords(),
+                    coords=self._model.coords,
                 ),
                 'off',
             )
@@ -344,13 +307,11 @@ class StateModel(Model):
             )
 
             # Constraint: on * upper_bound >= def_var
-            self.add(
-                self._model.add_constraints(self.on * ub >= def_var, name=f'{self.label_full}|on_con2'), 'on_con2'
-            )
+            self.add(self._model.add_constraints(self.on * ub >= def_var, name=f'{self.label_full}|on_con2'), 'on_con2')
         else:
             # Case for multiple defining variables
             ub = sum(bound[1] for bound in self._defining_bounds) / nr_of_def_vars
-            lb = CONFIG.modeling.EPSILON  #TODO: Can this be a bigger value? (maybe the smallest bound?)
+            lb = CONFIG.modeling.EPSILON  # TODO: Can this be a bigger value? (maybe the smallest bound?)
 
             # Constraint: on * epsilon <= sum(all_defining_variables)
             self.add(
@@ -384,7 +345,7 @@ class StateModel(Model):
         return 1 - self.previous_states
 
     @staticmethod
-    def compute_previous_states(previous_values: List[TimestepData], epsilon: float = 1e-5) -> np.ndarray:
+    def compute_previous_states(previous_values: List[NumericData], epsilon: float = 1e-5) -> np.ndarray:
         """Computes the previous states {0, 1} of defining variables as a binary array from their previous values."""
         if not previous_values or all([val is None for val in previous_values]):
             return np.array([0])
@@ -425,19 +386,19 @@ class SwitchStateModel(Model):
 
         # Create switch variables
         self.switch_on = self.add(
-            self._model.add_variables(binary=True, name=f'{self.label_full}|switch_on', coords=self._model.get_coords()),
+            self._model.add_variables(binary=True, name=f'{self.label_full}|switch_on', coords=self._model.coords),
             'switch_on',
         )
 
         self.switch_off = self.add(
-            self._model.add_variables(binary=True, name=f'{self.label_full}|switch_off', coords=self._model.get_coords()),
+            self._model.add_variables(binary=True, name=f'{self.label_full}|switch_off', coords=self._model.coords),
             'switch_off',
         )
 
         # Create count variable for number of switches
         self.switch_on_nr = self.add(
             self._model.add_variables(
-                upper=extract_data(self._switch_on_max),
+                upper=self._switch_on_max,
                 lower=0,
                 name=f'{self.label_full}|switch_on_nr',
             ),
@@ -466,7 +427,9 @@ class SwitchStateModel(Model):
 
         # Mutual exclusivity constraint
         self.add(
-            self._model.add_constraints(self.switch_on + self.switch_off <= 1.1, name=f'{self.label_full}|switch_on_or_off'),
+            self._model.add_constraints(
+                self.switch_on + self.switch_off <= 1.1, name=f'{self.label_full}|switch_on_or_off'
+            ),
             'switch_on_or_off',
         )
 
@@ -491,9 +454,9 @@ class ConsecutiveStateModel(Model):
         model: SystemModel,
         label_of_element: str,
         state_variable: linopy.Variable,
-        minimum_duration: Optional[TimestepData] = None,
-        maximum_duration: Optional[TimestepData] = None,
-        previous_states: Optional[TimestepData] = None,
+        minimum_duration: Optional[NumericData] = None,
+        maximum_duration: Optional[NumericData] = None,
+        previous_states: Optional[NumericData] = None,
         label: Optional[str] = None,
     ):
         """
@@ -515,9 +478,9 @@ class ConsecutiveStateModel(Model):
         self._maximum_duration = maximum_duration
 
         if isinstance(self._minimum_duration, TimeSeries):
-            self._minimum_duration = self._minimum_duration.selected_data
+            self._minimum_duration = self._minimum_duration.active_data
         if isinstance(self._maximum_duration, TimeSeries):
-            self._maximum_duration = self._maximum_duration.selected_data
+            self._maximum_duration = self._maximum_duration.active_data
 
         self.duration = None
 
@@ -531,8 +494,8 @@ class ConsecutiveStateModel(Model):
         self.duration = self.add(
             self._model.add_variables(
                 lower=0,
-                upper=extract_data(self._maximum_duration, mega),
-                coords=self._model.get_coords(),
+                upper=self._maximum_duration if self._maximum_duration is not None else mega,
+                coords=self._model.coords,
                 name=f'{self.label_full}|hours',
             ),
             'hours',
@@ -542,9 +505,7 @@ class ConsecutiveStateModel(Model):
 
         # Upper bound constraint
         self.add(
-            self._model.add_constraints(
-                self.duration <= self._state_variable * mega, name=f'{self.label_full}|con1'
-            ),
+            self._model.add_constraints(self.duration <= self._state_variable * mega, name=f'{self.label_full}|con1'),
             'con1',
         )
 
@@ -585,7 +546,7 @@ class ConsecutiveStateModel(Model):
             )
 
             # Handle initial condition
-            if 0 < self.previous_duration < self._minimum_duration.isel(time=0).max():
+            if 0 < self.previous_duration < self._minimum_duration.isel(time=0):
                 self.add(
                     self._model.add_constraints(
                         self._state_variable.isel(time=0) == 1, name=f'{self.label_full}|initial_minimum'
@@ -596,8 +557,8 @@ class ConsecutiveStateModel(Model):
         # Set initial value
         self.add(
             self._model.add_constraints(
-                self.duration.isel(time=0) ==
-                (hours_per_step.isel(time=0) + self.previous_duration) * self._state_variable.isel(time=0),
+                self.duration.isel(time=0)
+                == (hours_per_step.isel(time=0) + self.previous_duration) * self._state_variable.isel(time=0),
                 name=f'{self.label_full}|initial',
             ),
             'initial',
@@ -608,14 +569,14 @@ class ConsecutiveStateModel(Model):
     @property
     def previous_duration(self) -> Scalar:
         """Computes the previous duration of the state variable"""
-        #TODO: Allow for other/dynamic timestep resolutions
+        # TODO: Allow for other/dynamic timestep resolutions
         return ConsecutiveStateModel.compute_consecutive_hours_in_state(
-            self._previous_states, self._model.hours_per_step.isel(time=0).values.flatten()[0]
+            self._previous_states, self._model.hours_per_step.isel(time=0).item()
         )
 
     @staticmethod
     def compute_consecutive_hours_in_state(
-        binary_values: TimestepData, hours_per_timestep: Union[int, float, np.ndarray]
+        binary_values: NumericData, hours_per_timestep: Union[int, float, np.ndarray]
     ) -> Scalar:
         """
         Computes the final consecutive duration in state 'on' (=1) in hours, from a binary array.
@@ -659,7 +620,10 @@ class ConsecutiveStateModel(Model):
                 f'as {binary_values=}'
             )
 
-        return np.sum(binary_values[-nr_of_indexes_with_consecutive_ones:] * hours_per_timestep[-nr_of_indexes_with_consecutive_ones:])
+        return np.sum(
+            binary_values[-nr_of_indexes_with_consecutive_ones:]
+            * hours_per_timestep[-nr_of_indexes_with_consecutive_ones:]
+        )
 
 
 class OnOffModel(Model):
@@ -674,8 +638,8 @@ class OnOffModel(Model):
         on_off_parameters: OnOffParameters,
         label_of_element: str,
         defining_variables: List[linopy.Variable],
-        defining_bounds: List[Tuple[TimestepData, TimestepData]],
-        previous_values: List[Optional[TimestepData]],
+        defining_bounds: List[Tuple[NumericData, NumericData]],
+        previous_values: List[Optional[NumericData]],
         label: Optional[str] = None,
     ):
         """
@@ -712,8 +676,8 @@ class OnOffModel(Model):
             defining_bounds=self._defining_bounds,
             previous_values=self._previous_values,
             use_off=self.parameters.use_off,
-            on_hours_total_min=extract_data(self.parameters.on_hours_total_min),
-            on_hours_total_max=extract_data(self.parameters.on_hours_total_max),
+            on_hours_total_min=self.parameters.on_hours_total_min,
+            on_hours_total_max=self.parameters.on_hours_total_max,
             effects_per_running_hour=self.parameters.effects_per_running_hour,
         )
         self.add(self.state_model)
@@ -832,7 +796,7 @@ class PieceModel(Model):
             self._model.add_variables(
                 binary=True,
                 name=f'{self.label_full}|inside_piece',
-                coords=self._model.get_coords(time_dim=self._as_time_series),
+                coords=self._model.coords if self._as_time_series else None,
             ),
             'inside_piece',
         )
@@ -842,7 +806,7 @@ class PieceModel(Model):
                 lower=0,
                 upper=1,
                 name=f'{self.label_full}|lambda0',
-                coords=self._model.get_coords(time_dim=self._as_time_series),
+                coords=self._model.coords if self._as_time_series else None,
             ),
             'lambda0',
         )
@@ -852,7 +816,7 @@ class PieceModel(Model):
                 lower=0,
                 upper=1,
                 name=f'{self.label_full}|lambda1',
-                coords=self._model.get_coords(time_dim=self._as_time_series),
+                coords=self._model.coords if self._as_time_series else None,
             ),
             'lambda1',
         )
@@ -877,7 +841,7 @@ class PiecewiseModel(Model):
         label: str = '',
     ):
         """
-        Modeling a Piecewise relation between miultiple variables.
+        Modeling a Piecewise relation between multiple variables.
         The relation is defined by a list of Pieces, which are assigned to the variables.
         Each Piece is a tuple of (start, end).
 
@@ -886,7 +850,9 @@ class PiecewiseModel(Model):
             label_of_element: The label of the parent (Element). Used to construct the full label of the model.
             label: The label of the model. Used to construct the full label of the model.
             piecewise_variables: The variables to which the Pieces are assigned.
-            zero_point: A variable that can be used to define a zero point for the Piecewise relation. If None or False, no zero point is defined.
+            zero_point: A variable that can be used to define a zero point for the Piecewise relation.
+                If None or False, no zero point is defined. THis leads to 0 not being possible,
+                unless its its contained in a Piece.
             as_time_series: Whether the Piecewise relation is defined for a TimeSeries or a single variable.
         """
         super().__init__(model, label_of_element, label)
@@ -932,21 +898,23 @@ class PiecewiseModel(Model):
             # b) eq: -On(t) + Segment1.onSeg(t) + Segment2.onSeg(t) + ... = 0       zusätzlich kann alles auch Null sein
             if isinstance(self._zero_point, linopy.Variable):
                 self.zero_point = self._zero_point
-                rhs = self.zero_point
+                sign, rhs = '<=', self.zero_point
             elif self._zero_point is True:
                 self.zero_point = self.add(
                     self._model.add_variables(
-                        coords=self._model.get_coords(), binary=True, name=f'{self.label_full}|zero_point'
+                        coords=self._model.coords, binary=True, name=f'{self.label_full}|zero_point'
                     ),
                     'zero_point',
                 )
-                rhs = self.zero_point
+                sign, rhs = '<=', self.zero_point
             else:
-                rhs = 1
+                sign, rhs = '=', 1
 
             self.add(
                 self._model.add_constraints(
-                    sum([piece.inside_piece for piece in self.pieces]) <= rhs,
+                    sum([piece.inside_piece for piece in self.pieces]),
+                    sign,
+                    rhs,
                     name=f'{self.label_full}|{variable.name}|single_segment',
                 ),
                 f'{var_name}|single_segment',
@@ -957,20 +925,19 @@ class ShareAllocationModel(Model):
     def __init__(
         self,
         model: SystemModel,
-        has_time_dim: bool,
-        has_scenario_dim: bool,
+        shares_are_time_series: bool,
         label_of_element: Optional[str] = None,
         label: Optional[str] = None,
         label_full: Optional[str] = None,
-        total_max: Optional[ScenarioData] = None,
-        total_min: Optional[ScenarioData] = None,
-        max_per_hour: Optional[TimestepData] = None,
-        min_per_hour: Optional[TimestepData] = None,
+        total_max: Optional[Scalar] = None,
+        total_min: Optional[Scalar] = None,
+        max_per_hour: Optional[NumericData] = None,
+        min_per_hour: Optional[NumericData] = None,
     ):
         super().__init__(model, label_of_element=label_of_element, label=label, label_full=label_full)
-        if not has_time_dim:  # If the condition is True
+        if not shares_are_time_series:  # If the condition is True
             assert max_per_hour is None and min_per_hour is None, (
-                'Both max_per_hour and min_per_hour cannot be used when has_time_dim is False'
+                'Both max_per_hour and min_per_hour cannot be used when shares_are_time_series is False'
             )
         self.total_per_timestep: Optional[linopy.Variable] = None
         self.total: Optional[linopy.Variable] = None
@@ -981,9 +948,8 @@ class ShareAllocationModel(Model):
         self._eq_total: Optional[linopy.Constraint] = None
 
         # Parameters
-        self._has_time_dim = has_time_dim
-        self._has_scenario_dim = has_scenario_dim
-        self._total_max = total_max if total_max is not None else np.inf
+        self._shares_are_time_series = shares_are_time_series
+        self._total_max = total_max if total_min is not None else np.inf
         self._total_min = total_min if total_min is not None else -np.inf
         self._max_per_hour = max_per_hour if max_per_hour is not None else np.inf
         self._min_per_hour = min_per_hour if min_per_hour is not None else -np.inf
@@ -991,10 +957,7 @@ class ShareAllocationModel(Model):
     def do_modeling(self):
         self.total = self.add(
             self._model.add_variables(
-                lower=self._total_min,
-                upper=self._total_max,
-                coords=self._model.get_coords(time_dim=False, scenario_dim=self._has_scenario_dim),
-                name=f'{self.label_full}|total',
+                lower=self._total_min, upper=self._total_max, coords=None, name=f'{self.label_full}|total'
             ),
             'total',
         )
@@ -1003,12 +966,16 @@ class ShareAllocationModel(Model):
             self._model.add_constraints(self.total == 0, name=f'{self.label_full}|total'), 'total'
         )
 
-        if self._has_time_dim:
+        if self._shares_are_time_series:
             self.total_per_timestep = self.add(
                 self._model.add_variables(
-                    lower=-np.inf if (self._min_per_hour is None) else extract_data(self._min_per_hour) * self._model.hours_per_step,
-                    upper=np.inf if (self._max_per_hour is None) else extract_data(self._max_per_hour) * self._model.hours_per_step,
-                    coords=self._model.get_coords(time_dim=True, scenario_dim=self._has_scenario_dim),
+                    lower=-np.inf
+                    if (self._min_per_hour is None)
+                    else np.multiply(self._min_per_hour, self._model.hours_per_step),
+                    upper=np.inf
+                    if (self._max_per_hour is None)
+                    else np.multiply(self._max_per_hour, self._model.hours_per_step),
+                    coords=self._model.coords,
                     name=f'{self.label_full}|total_per_timestep',
                 ),
                 'total_per_timestep',
@@ -1020,14 +987,12 @@ class ShareAllocationModel(Model):
             )
 
             # Add it to the total
-            self._eq_total.lhs -= self.total_per_timestep.sum(dim='time')
+            self._eq_total.lhs -= self.total_per_timestep.sum()
 
     def add_share(
         self,
         name: str,
         expression: linopy.LinearExpression,
-        has_time_dim: bool,
-        has_scenario_dim: bool,
     ):
         """
         Add a share to the share allocation model. If the share already exists, the expression is added to the existing share.
@@ -1039,17 +1004,16 @@ class ShareAllocationModel(Model):
             name: The name of the share.
             expression: The expression of the share. Added to the right hand side of the constraint.
         """
-        if has_time_dim and not self._has_time_dim:
-            raise ValueError('Cannot add share with time_dim=True to a model without time_dim')
-        if has_scenario_dim and not self._has_scenario_dim:
-            raise ValueError('Cannot add share with scenario_dim=True to a model without scenario_dim')
-
         if name in self.shares:
             self.share_constraints[name].lhs -= expression
         else:
             self.shares[name] = self.add(
                 self._model.add_variables(
-                    coords=self._model.get_coords(time_dim=has_time_dim, scenario_dim=has_scenario_dim),
+                    coords=None
+                    if isinstance(expression, linopy.LinearExpression)
+                    and expression.ndim == 0
+                    or not isinstance(expression, linopy.LinearExpression)
+                    else self._model.coords,
                     name=f'{name}->{self.label_full}',
                 ),
                 name,
@@ -1057,7 +1021,7 @@ class ShareAllocationModel(Model):
             self.share_constraints[name] = self.add(
                 self._model.add_constraints(self.shares[name] == expression, name=f'{name}->{self.label_full}'), name
             )
-            if not has_time_dim:
+            if self.shares[name].ndim == 0:
                 self._eq_total.lhs -= self.shares[name]
             else:
                 self._eq_total_per_timestep.lhs -= self.shares[name]
@@ -1086,12 +1050,7 @@ class PiecewiseEffectsModel(Model):
 
     def do_modeling(self):
         self.shares = {
-            effect: self.add(
-                self._model.add_variables(
-                    coords=self._model.get_coords(time_dim=False), name=f'{self.label_full}|{effect}'
-                ),
-                f'{effect}',
-            )
+            effect: self.add(self._model.add_variables(coords=None, name=f'{self.label_full}|{effect}'), f'{effect}')
             for effect in self._piecewise_shares
         }
 
@@ -1124,6 +1083,65 @@ class PiecewiseEffectsModel(Model):
         )
 
 
+class PiecewiseEffectsPerFlowHourModel(Model):
+    def __init__(
+        self,
+        model: SystemModel,
+        label_of_element: str,
+        piecewise_origin: Tuple[str, Piecewise],
+        piecewise_shares: Dict[str, Piecewise],
+        zero_point: Optional[Union[bool, linopy.Variable]],
+        label: str = 'PiecewiseEffectsPerFlowHour',
+    ):
+        super().__init__(model, label_of_element, label)
+        assert len(piecewise_origin[1]) == len(list(piecewise_shares.values())[0]), (
+            'Piece length of variable_segments and share_segments must be equal'
+        )
+        self._zero_point = zero_point
+        self._piecewise_origin = piecewise_origin
+        self._piecewise_shares = piecewise_shares
+
+        self.shares: Dict[str, linopy.Variable] = {}
+
+        self.piecewise_model: Optional[PiecewiseModel] = None
+
+    def do_modeling(self):
+        self.shares = {
+            effect: self.add(
+                self._model.add_variables(coords=self._model.coords, name=f'{self.label_full}|{effect}'), f'{effect}'
+            )
+            for effect in self._piecewise_shares
+        }
+
+        piecewise_variables = {
+            self._piecewise_origin[0]: self._piecewise_origin[1],
+            **{
+                self.shares[effect_label].name: self._piecewise_shares[effect_label]
+                for effect_label in self._piecewise_shares
+            },
+        }
+
+        self.piecewise_model = self.add(
+            PiecewiseModel(
+                model=self._model,
+                label_of_element=self.label_of_element,
+                piecewise_variables=piecewise_variables,
+                zero_point=self._zero_point,
+                as_time_series=True,
+                label='PiecewiseEffectsPerFlowHour',
+            )
+        )
+
+        self.piecewise_model.do_modeling()
+
+        # Shares
+        self._model.effects.add_share_to_effects(
+            name=self.label_of_element,
+            expressions={effect: variable * self._model.hours_per_step for effect, variable in self.shares.items()},
+            target='operation',
+        )
+
+
 class PreventSimultaneousUsageModel(Model):
     """
     Prevents multiple Multiple Binary variables from being 1 at the same time