flixopt 2.1.7__py3-none-any.whl → 2.2.0rc2__py3-none-any.whl

flixopt/__init__.py

@@ -22,6 +22,7 @@ from .commons import (
     Piecewise,
     PiecewiseConversion,
     PiecewiseEffects,
+    PiecewiseEffectsPerFlowHour,
     SegmentedCalculation,
     Sink,
     Source,

flixopt/commons.py

@@ -18,7 +18,15 @@ from .core import TimeSeriesData
 from .effects import Effect
 from .elements import Bus, Flow
 from .flow_system import FlowSystem
-from .interface import InvestParameters, OnOffParameters, Piece, Piecewise, PiecewiseConversion, PiecewiseEffects
+from .interface import (
+    InvestParameters,
+    OnOffParameters,
+    Piece,
+    Piecewise,
+    PiecewiseConversion,
+    PiecewiseEffects,
+    PiecewiseEffectsPerFlowHour,
+)
 
 __all__ = [
     'TimeSeriesData',
@@ -48,4 +56,5 @@ __all__ = [
     'results',
     'linear_converters',
     'solvers',
+    'PiecewiseEffectsPerFlowHour',
 ]

flixopt/components.py

@@ -24,9 +24,119 @@ logger = logging.getLogger('flixopt')
 
 @register_class_for_io
 class LinearConverter(Component):
-    """
-    Converts input-Flows into output-Flows via linear conversion factors
+    """Convert input flows into output flows using linear or piecewise linear conversion factors.
+
+    This component models conversion equipment where input flows are transformed
+    into output flows with fixed or variable conversion ratios, such as:
+
+    - Heat pumps and chillers with variable efficiency
+    - Power plants with fuel-to-electricity conversion
+    - Chemical processes with multiple inputs/outputs
+    - Pumps and compressors
+    - Combined heat and power (CHP) plants
+
+    Args:
+        label: Unique identifier for the component in the FlowSystem.
+        inputs: List of input Flow objects that feed into the converter.
+        outputs: List of output Flow objects produced by the converter.
+        on_off_parameters: Controls binary on/off behavior of the converter.
+            When specified, the component can be completely turned on or off, affecting
+            all connected flows. This creates binary variables in the optimization.
+            For better performance, consider using OnOffParameters on individual flows instead.
+        conversion_factors: Linear conversion ratios between flows as time series data.
+            List of dictionaries mapping flow labels to their conversion factors.
+            Mutually exclusive with piecewise_conversion.
+        piecewise_conversion: Piecewise linear conversion relationships between flows.
+            Enables modeling of variable efficiency or discrete operating modes.
+            Mutually exclusive with conversion_factors.
+        meta_data: Additional information stored with the component.
+            Saved in results but not used internally. Use only Python native types.
+
+    Warning:
+        When using `piecewise_conversion` without `on_off_parameters`, flow rates cannot
+        reach zero unless explicitly defined with zero-valued pieces (e.g., `fx.Piece(0, 0)`).
+        This prevents unintended zero flows and maintains mathematical consistency.
+
+        To allow zero flow rates:
+
+        - Add `on_off_parameters` to enable complete shutdown, or
+        - Include explicit zero pieces in your `piecewise_conversion` definition
+
+        This behavior was clarified in v2.1.7 to prevent optimization edge cases.
+
+    Examples:
+        Simple heat pump with fixed COP:
+
+        ```python
+        heat_pump = fx.LinearConverter(
+            label='heat_pump',
+            inputs=[electricity_flow],
+            outputs=[heat_flow],
+            conversion_factors=[
+                {
+                    'electricity_flow': 1.0,  # 1 kW electricity input
+                    'heat_flow': 3.5,  # 3.5 kW heat output (COP=3.5)
+                }
+            ],
+        )
+        ```
+
+        Variable efficiency heat pump:
+
+        ```python
+        heat_pump = fx.LinearConverter(
+            label='variable_heat_pump',
+            inputs=[electricity_flow],
+            outputs=[heat_flow],
+            piecewise_conversion=fx.PiecewiseConversion(
+                {
+                    'electricity_flow': fx.Piecewise(
+                        [
+                            fx.Piece(0, 10),  # Allow zero to 10 kW input
+                            fx.Piece(10, 25),  # Higher load operation
+                        ]
+                    ),
+                    'heat_flow': fx.Piecewise(
+                        [
+                            fx.Piece(0, 35),  # COP=3.5 at low loads
+                            fx.Piece(35, 75),  # COP=3.0 at high loads
+                        ]
+                    ),
+                }
+            ),
+        )
+        ```
+
+        Combined heat and power plant:
+
+        ```python
+        chp_plant = fx.LinearConverter(
+            label='chp_plant',
+            inputs=[natural_gas_flow],
+            outputs=[electricity_flow, heat_flow],
+            conversion_factors=[
+                {
+                    'natural_gas_flow': 1.0,  # 1 MW fuel input
+                    'electricity_flow': 0.4,  # 40% electrical efficiency
+                    'heat_flow': 0.45,  # 45% thermal efficiency
+                }
+            ],
+            on_off_parameters=fx.OnOffParameters(
+                min_on_hours=4,  # Minimum 4-hour operation
+                min_off_hours=2,  # Minimum 2-hour downtime
+            ),
+        )
+        ```
+
+    Note:
+        Either `conversion_factors` or `piecewise_conversion` must be specified, but not both.
+        The component automatically handles the mathematical relationships between all
+        connected flows according to the specified conversion ratios.
 
+    See Also:
+        PiecewiseConversion: For variable efficiency modeling
+        OnOffParameters: For binary on/off control
+        Flow: Input and output flow definitions
     """
 
     def __init__(
@@ -39,21 +149,6 @@ class LinearConverter(Component):
         piecewise_conversion: Optional[PiecewiseConversion] = None,
         meta_data: Optional[Dict] = None,
     ):
-        """
-        Args:
-            label: The label of the Element. Used to identify it in the FlowSystem
-            inputs: The input Flows
-            outputs: The output Flows
-            on_off_parameters: Information about on and off state of LinearConverter.
-                Component is On/Off, if all connected Flows are On/Off. This induces an On-Variable (binary) in all Flows!
-                If possible, use OnOffParameters in a single Flow instead to keep the number of binary variables low.
-                See class OnOffParameters.
-            conversion_factors: linear relation between flows.
-                Either 'conversion_factors' or 'piecewise_conversion' can be used!
-            piecewise_conversion: Define a piecewise linear relation between flow rates of different flows.
-                Either 'conversion_factors' or 'piecewise_conversion' can be used!
-            meta_data: used to store more information about the Element. Is not used internally, but saved in the results. Only use python native types.
-        """
         super().__init__(label, inputs, outputs, on_off_parameters, meta_data=meta_data)
         self.conversion_factors = conversion_factors or []
         self.piecewise_conversion = piecewise_conversion

flixopt/elements.py

@@ -12,8 +12,8 @@ import numpy as np
 from .config import CONFIG
 from .core import NumericData, NumericDataTS, PlausibilityError, Scalar, TimeSeriesCollection
 from .effects import EffectValuesUser
-from .features import InvestmentModel, OnOffModel, PreventSimultaneousUsageModel
-from .interface import InvestParameters, OnOffParameters
+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:
@@ -159,6 +159,7 @@ class Flow(Element):
         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[Scalar] = None,
         flow_hours_total_min: Optional[Scalar] = None,
@@ -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,6 +251,8 @@ 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'
         )
+        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):
@@ -398,6 +403,21 @@ class FlowModel(ElementModel):
                 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?
 

flixopt/features.py

@@ -12,7 +12,7 @@ import numpy as np
 from . import utils
 from .config import CONFIG
 from .core import NumericData, Scalar, TimeSeries
-from .interface import InvestParameters, OnOffParameters, Piecewise
+from .interface import InvestParameters, OnOffParameters, Piece, Piecewise
 from .structure import Model, SystemModel
 
 logger = logging.getLogger('flixopt')
@@ -841,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).
 
@@ -850,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)
@@ -896,7 +898,7 @@ 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(
@@ -904,13 +906,15 @@ class PiecewiseModel(Model):
                     ),
                     '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',
@@ -1079,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

flixopt/interface.py

@@ -63,15 +63,168 @@ class Piecewise(Interface):
 
 @register_class_for_io
 class PiecewiseConversion(Interface):
-    def __init__(self, piecewises: Dict[str, Piecewise]):
-        """
-        Define a piecewise conversion between multiple Flows.
-        --> "gaps" can be expressed by a piece not starting at the end of the prior piece: [(1,3), (4,5)]
-        --> "points" can expressed as piece with same begin and end: [(3,3), (4,4)]
+    """Define piecewise linear conversion relationships between multiple flows.
+
+    This class models complex conversion processes where the relationship between
+    input and output flows changes at different operating points, such as:
+
+    - Variable efficiency equipment (heat pumps, engines, turbines)
+    - Multi-stage chemical processes with different conversion rates
+    - Equipment with discrete operating modes
+    - Systems with capacity constraints and thresholds
+
+    Args:
+        piecewises: Dictionary mapping flow labels to their Piecewise conversion functions.
+            Keys are flow names (e.g., 'electricity_in', 'heat_out', 'fuel_consumed').
+            Values are Piecewise objects defining conversion factors at different operating points.
+            All Piecewise objects must have the same number of pieces and compatible domains
+            to ensure consistent conversion relationships across operating ranges.
+
+    Note:
+        Special modeling features:
+
+        - **Gaps**: Express forbidden operating ranges by creating non-contiguous pieces.
+          Example: `[(0,50), (100,200)]` - cannot operate between 50-100 units
+        - **Points**: Express discrete operating points using pieces with identical start/end.
+          Example: `[(50,50), (100,100)]` - can only operate at exactly 50 or 100 units
+
+    Examples:
+        Heat pump with variable COP (Coefficient of Performance):
+
+        ```python
+        PiecewiseConversion(
+            {
+                'electricity_in': Piecewise(
+                    [
+                        Piece(0, 10),  # Low load: 0-10 kW electricity
+                        Piece(10, 25),  # High load: 10-25 kW electricity
+                    ]
+                ),
+                'heat_out': Piecewise(
+                    [
+                        Piece(0, 35),  # Low load COP=3.5: 0-35 kW heat output
+                        Piece(35, 75),  # High load COP=3.0: 35-75 kW heat output
+                    ]
+                ),
+            }
+        )
+        # At 15 kW electricity input → 52.5 kW heat output (interpolated)
+        ```
+
+        Engine with fuel consumption and emissions:
+
+        ```python
+        PiecewiseConversion(
+            {
+                'fuel_input': Piecewise(
+                    [
+                        Piece(5, 15),  # Part load: 5-15 L/h fuel
+                        Piece(15, 30),  # Full load: 15-30 L/h fuel
+                    ]
+                ),
+                'power_output': Piecewise(
+                    [
+                        Piece(10, 25),  # Part load: 10-25 kW output
+                        Piece(25, 45),  # Full load: 25-45 kW output
+                    ]
+                ),
+                'co2_emissions': Piecewise(
+                    [
+                        Piece(12, 35),  # Part load: 12-35 kg/h CO2
+                        Piece(35, 78),  # Full load: 35-78 kg/h CO2
+                    ]
+                ),
+            }
+        )
+        ```
 
-        Args:
-            piecewises: Dict of Piecewises defining the conversion factors. flow labels as keys, piecewise as values
-        """
+        Discrete operating modes (on/off equipment):
+
+        ```python
+        PiecewiseConversion(
+            {
+                'electricity_in': Piecewise(
+                    [
+                        Piece(0, 0),  # Off mode: no consumption
+                        Piece(20, 20),  # On mode: fixed 20 kW consumption
+                    ]
+                ),
+                'cooling_out': Piecewise(
+                    [
+                        Piece(0, 0),  # Off mode: no cooling
+                        Piece(60, 60),  # On mode: fixed 60 kW cooling
+                    ]
+                ),
+            }
+        )
+        ```
+
+        Equipment with forbidden operating range:
+
+        ```python
+        PiecewiseConversion(
+            {
+                'steam_input': Piecewise(
+                    [
+                        Piece(0, 100),  # Low pressure operation
+                        Piece(200, 500),  # High pressure (gap: 100-200)
+                    ]
+                ),
+                'power_output': Piecewise(
+                    [
+                        Piece(0, 80),  # Low efficiency at low pressure
+                        Piece(180, 400),  # High efficiency at high pressure
+                    ]
+                ),
+            }
+        )
+        ```
+
+        Multi-product chemical reactor:
+
+        ```python
+        fx.PiecewiseConversion(
+            {
+                'feedstock': fx.Piecewise(
+                    [
+                        fx.Piece(10, 50),  # Small batch: 10-50 kg/h
+                        fx.Piece(50, 200),  # Large batch: 50-200 kg/h
+                    ]
+                ),
+                'product_A': fx.Piecewise(
+                    [
+                        fx.Piece(7, 32),  # Small batch yield: 70%
+                        fx.Piece(32, 140),  # Large batch yield: 70%
+                    ]
+                ),
+                'product_B': fx.Piecewise(
+                    [
+                        fx.Piece(2, 12),  # Small batch: 20% to product B
+                        fx.Piece(12, 45),  # Large batch: better selectivity
+                    ]
+                ),
+                'waste': fx.Piecewise(
+                    [
+                        fx.Piece(1, 6),  # Small batch waste: 10%
+                        fx.Piece(6, 15),  # Large batch waste: 7.5%
+                    ]
+                ),
+            }
+        )
+        ```
+
+    Common Use Cases:
+        - Heat pumps/chillers: COP varies with load and ambient conditions
+        - Power plants: Heat rate curves showing fuel efficiency vs output
+        - Chemical reactors: Conversion rates and selectivity vs throughput
+        - Compressors/pumps: Power consumption vs flow rate
+        - Multi-stage processes: Different conversion rates per stage
+        - Equipment with minimum loads: Cannot operate below threshold
+        - Batch processes: Discrete production campaigns
+
+    """
+
+    def __init__(self, piecewises: Dict[str, Piecewise]):
         self.piecewises = piecewises
 
     def items(self):
@@ -102,6 +255,112 @@ class PiecewiseEffects(Interface):
         #    piecewise.transform_data(flow_system, f'{name_prefix}|PiecewiseEffects|{name}')
 
 
+@register_class_for_io
+class PiecewiseEffectsPerFlowHour(Interface):
+    """
+    Define piecewise linear relationships between flow rate and various effects (costs, emissions, etc.).
+
+    This class models situations where the relationship between flow rate and effects changes at
+    different flow rate levels, such as:
+    - Pump efficiency curves across operating ranges
+    - Emission factors that vary with operating levels
+    - Capacity-dependent transportation costs
+    - Decision between different operating modes or suppliers
+    - Optional equipment activation with minimum flow requirements
+
+    Args:
+        piecewise_flow_rate: `Piecewise` defining the valid flow rate segments.
+            Each Piece represents a linear segment with (min_flow, max_flow) bounds.
+
+        piecewise_shares: Dictionary mapping effect names to their `Piecewise`.
+            Keys are effect names (e.g., 'Costs', 'CO2', 'Maintenance').
+            Values are `Piecewise` objects defining the absolute effect values (not rates/prices).
+
+            ⚠️  IMPORTANT: Values represent total effect amounts, not unit rates.
+            For a flow rate of X, the effect value is interpolated from the `Piecewise`.
+            This is NOT flow_rate × unit_price (which would be non-linear).
+
+    Behavior:
+        - If the first piece doesn't start at zero, flow rate is automatically bounded
+          by piecewise_flow_rate (when OnOffParameters are not used)
+        - Each segment represents a linear relationship within that flow rate range
+        - Effects are interpolated linearly within each piece
+        - All `Piece`s of the different `Piecewise`s at index i are active at the same time
+        - A decision whether to utilize the effect can be modeled by defining multiple Pieces for the same flow rate range
+
+    Examples:
+        # Tiered cost structure with increasing rates
+        PiecewiseEffectsPerFlowHour(
+            piecewise_flow_rate=Piecewise([
+                Piece(0, 50),    # Low flow segment: 0-50 units
+                Piece(50, 200)   # High flow segment: 50-200 units
+            ]),
+            piecewise_shares={
+                'Costs': Piecewise([
+                    Piece(0, 500),     # At flow=0: cost=0, at flow=50: cost=500
+                    Piece(500, 2000)   # At flow=50: cost=500, at flow=200: cost=2000
+                ]),
+                'CO2': Piecewise([
+                    Piece(0, 100),     # At flow=0: CO2=0, at flow=50: CO2=100
+                    Piece(100, 800)    # At flow=50: CO2=100, at flow=200: CO2=800
+                ])
+            }
+        )
+
+        # Decision between two suppliers with overlapping flow ranges
+        PiecewiseEffectsPerFlowHour(
+            piecewise_flow_rate=Piecewise([
+                Piece(0, 100),     # Supplier A: 0-100 units
+                Piece(50, 150)     # Supplier B: 50-150 units (overlaps with A)
+            ]),
+            piecewise_shares={
+                'Costs': Piecewise([
+                    Piece(0, 800),     # Supplier A: cheaper for low volumes
+                    Piece(400, 1200)   # Supplier B: better rates for high volumes
+                ])
+            }
+        )
+        # Flow range 50-100: Optimizer chooses between suppliers based on cost
+
+        # Optional equipment with minimum activation threshold
+        PiecewiseEffectsPerFlowHour(
+            piecewise_flow_rate=Piecewise([
+                Piece(0, 0),       # Equipment off: no flow
+                Piece(20, 100)     # Equipment on: minimum 20 units required
+            ]),
+            piecewise_shares={
+                'Costs': Piecewise([
+                    Piece(0, 0),       # No cost when off
+                    Piece(200, 800)    # Fixed startup cost + variable cost
+                ]),
+                'CO2': Piecewise([
+                    Piece(0, 0),       # No CO2 when off
+                    Piece(50, 300)     # Decreasing CO2 per fuel burn with higher power
+                ])
+            }
+        )
+        # Decision: Either flow=0 (off) or flow≥20 (on with minimum threshold)
+
+        # Equipment efficiency curve (although this might be better modeled as a Flow rather than an effect)
+        PiecewiseEffectsPerFlowHour(
+            piecewise_flow_rate=Piecewise([Piece(10, 100)]),  # Min 10, max 100 units
+            piecewise_shares={
+                'PowerConsumption': Piecewise([Piece(50, 800)])  # Non-linear efficiency
+            }
+        )
+
+    """
+
+    def __init__(self, piecewise_flow_rate: Piecewise, piecewise_shares: Dict[str, Piecewise]):
+        self.piecewise_flow_rate = piecewise_flow_rate
+        self.piecewise_shares = piecewise_shares
+
+    def transform_data(self, flow_system: 'FlowSystem', name_prefix: str):
+        self.piecewise_flow_rate.transform_data(flow_system, f'{name_prefix}|PiecewiseEffectsPerFlowHour|origin')
+        for name, piecewise in self.piecewise_shares.items():
+            piecewise.transform_data(flow_system, f'{name_prefix}|PiecewiseEffectsPerFlowHour|{name}')
+
+
 @register_class_for_io
 class InvestParameters(Interface):
     """

{flixopt-2.1.7.dist-info → flixopt-2.2.0rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flixopt
-Version: 2.1.7
+Version: 2.2.0rc2
 Summary: Vector based energy and material flow optimization framework in Python.
 Author-email: "Chair of Building Energy Systems and Heat Supply, TU Dresden" <peter.stange@tu-dresden.de>, Felix Bumann <felixbumann387@gmail.com>, Felix Panitz <baumbude@googlemail.com>, Peter Stange <peter.stange@tu-dresden.de>
 Maintainer-email: Felix Bumann <felixbumann387@gmail.com>, Peter Stange <peter.stange@tu-dresden.de>

{flixopt-2.1.7.dist-info → flixopt-2.2.0rc2.dist-info}/RECORD

@@ -18,19 +18,19 @@ docs/user-guide/Mathematical Notation/Piecewise.md,sha256=GgTQ7dVTTb0lq14GFuuZeG
 docs/user-guide/Mathematical Notation/Storage.md,sha256=Zk5Irnr4bxIqI2KL2wcbAg8PdFDGTxhDFlRrnvjK6Bk,2200
 docs/user-guide/Mathematical Notation/index.md,sha256=2d6k4zbKET1kg7zBt1fEdKsG8jM5j2IIe6yclMTUlDw,1254
 docs/user-guide/Mathematical Notation/others.md,sha256=z6LOzcnvfI-1qQx0Fg7Q6wSK9tAzH2d34KbW4lYNyCE,48
-flixopt/__init__.py,sha256=xTxHXC-_lWa65roGUM3J3HXfiYcMCJHoQsuL5mS0Xkg,688
+flixopt/__init__.py,sha256=yW3zslmBnNDYoYTGUq1XkBL7UqpP9O1iDV1d3V00iyM,721
 flixopt/aggregation.py,sha256=xgQu2U5YEbtdDAEMjWiuP9uo_KjhzC95VNmY4ZcSX3I,16939
 flixopt/calculation.py,sha256=pj8nvAG3Vv6NHNyvhU3YbrMDogClFni5CfuJk4631Fw,19914
-flixopt/commons.py,sha256=ZNlUN1z-h9OGHPo-s-n5OLlJaoPZKVGcAdRyGKpMk4M,1256
-flixopt/components.py,sha256=o9H4yfwuI_Y31BuYZH_NkVYm_Du4aoAiVTtHO_KhMUg,33297
+flixopt/commons.py,sha256=6exWKBgcWCUjcqolw1kG6Aee4bm_6DF1kTrSUzZbs1M,1353
+flixopt/components.py,sha256=N5_xmhFtOjCJnNl-o_V12lvUxp5tUyuGQRgkUVaNnuk,36868
 flixopt/config.py,sha256=Kt8QYk7hX5qHcQUtfgjM862C6SQr4K2lDvtk_LLER8Y,9085
 flixopt/config.yaml,sha256=imzAnnhcJhIfKNTTXFB5Td7Pvk5ARn5j720k-oGGRug,392
 flixopt/core.py,sha256=vaIBRQE0w9Ro5Xe_jWHKXMLRenSS2P1Tpy9-geTuWcE,38103
 flixopt/effects.py,sha256=7kwZwfv3oRmkzc30kdjeOyB4qnyA9zxsPun1ysQdDxM,16662
-flixopt/elements.py,sha256=MDOQb17FkUGN1bgdbAMoavBuBmVtN6evDbLT7ExL4pI,26944
-flixopt/features.py,sha256=JgvwIK5o8GKJBUnicfMe7sfXbzojFQGfAkCpGVwzKww,43983
+flixopt/elements.py,sha256=S89IykQmXxKTtfNn8HW6fWLdb64UePaY0vaittCAJ2M,28153
+flixopt/features.py,sha256=AI3pW8UbyYLZFDIiPtexmNRkLT7UU-ckmcse9lWRPgw,46263
 flixopt/flow_system.py,sha256=Gowg5k7LWlF6VYRHtrIbKVCKWKMrzlZQtBCfdeEq4jQ,19607
-flixopt/interface.py,sha256=uXf6Z29OfHpIRsS1-oZZ6SSuy8FLe13FjtqzHPqzzQE,12088
+flixopt/interface.py,sha256=Be3IWcYCLATDCoTliiv6Ky1V_srn1KiCHY3tBriVd_U,22631
 flixopt/io.py,sha256=2QKdtu2-mkzSGBIqHtUcF9UaG32nq9qcIRxZghf1hLw,11284
 flixopt/linear_converters.py,sha256=ej5V_ML_3m1k9HbDnuey6pHEpQtguYkxBXHxWyE9sq0,10936
 flixopt/network_app.py,sha256=oVdARrTDV43H5ZAypJP3dmIL4A9x-Y3ec0zZC5gS8rA,28019
@@ -39,7 +39,7 @@ flixopt/results.py,sha256=GKSZmz0GCuJwspTC8Ot6MOKinvy_mhnDXCafb_f7uVY,35161
 flixopt/solvers.py,sha256=k1bSoiXec3asWED70-erXkgtpn2C8KRBfSZj0FLviSM,2436
 flixopt/structure.py,sha256=CZIz_8UVF56BT4tiDQYzfH4WCR-yaiZHW0--u6olHx4,26281
 flixopt/utils.py,sha256=f-_vFDvvG27-c_VMpzkv3lb79Yny4rvoSmemushbzhU,1687
-flixopt-2.1.7.dist-info/licenses/LICENSE,sha256=HKsZnbrM_3Rvnr_u9cWSG90cBsj5_slaqI_z_qcxnGI,1118
+flixopt-2.2.0rc2.dist-info/licenses/LICENSE,sha256=HKsZnbrM_3Rvnr_u9cWSG90cBsj5_slaqI_z_qcxnGI,1118
 pics/architecture_flixOpt-pre2.0.0.png,sha256=9RWSA3vys588aadr2437zor-_-xBTQNQ0bAf8xGcu5g,70605
 pics/architecture_flixOpt.png,sha256=KjN1bJwESbkHmTW7UsJ7dZyiKZlTO7Dx20dg8KlR1HU,260219
 pics/flixOpt_plotting.jpg,sha256=zn7ZPAtXm5eRTxtOj86e4-PPhHpCar1jqGh7vMBgQGY,518862
@@ -48,7 +48,7 @@ pics/pics.pptx,sha256=ImWeGGvjtWJ6BGruipsnZYmWtHj5sWdbw1NSFePbkC8,683344
 scripts/extract_release_notes.py,sha256=3UUE4hWhdd2t2m2x0ZpchGP-A0MvfqO2Wc5EdNN-fgE,1249
 scripts/gen_ref_pages.py,sha256=AYRtXyz78x5I_Hn0oRtGVbTxgLLj2QNyRX6vWRefPjc,1960
 tests/ressources/Zeitreihen2020.csv,sha256=kbsDTKZS0iUsNZAS7m3DohzZI_OHHWe44s3GwLvcTLw,1918412
-flixopt-2.1.7.dist-info/METADATA,sha256=_cFPusrwdee_4dJRFbKQWGhTWZOHTrWsT4PdBVhLhJA,8229
-flixopt-2.1.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-flixopt-2.1.7.dist-info/top_level.txt,sha256=DEuo4R1z7GmEp5R3pjbQEJbaPRjKHFvNX2ceiBnVOL0,32
-flixopt-2.1.7.dist-info/RECORD,,
+flixopt-2.2.0rc2.dist-info/METADATA,sha256=OVQsScG4XvEoQVhF3m3qde_FmII3gGFHVRhcwjHklc0,8232
+flixopt-2.2.0rc2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+flixopt-2.2.0rc2.dist-info/top_level.txt,sha256=DEuo4R1z7GmEp5R3pjbQEJbaPRjKHFvNX2ceiBnVOL0,32
+flixopt-2.2.0rc2.dist-info/RECORD,,