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

flixopt/components.py

@@ -3,13 +3,14 @@ This module contains the basic components of the flixopt framework.
 """
 
 import logging
+import warnings
 from typing import TYPE_CHECKING, Dict, List, Literal, Optional, Set, Tuple, Union
 
 import linopy
 import numpy as np
 
 from . import utils
-from .core import PlausibilityError, Scalar, ScenarioData, TimeSeries, TimestepData
+from .core import NumericData, NumericDataTS, PlausibilityError, Scalar, TimeSeries
 from .elements import Component, ComponentModel, Flow
 from .features import InvestmentModel, OnOffModel, PiecewiseModel
 from .interface import InvestParameters, OnOffParameters, PiecewiseConversion
@@ -23,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__(
@@ -34,25 +145,10 @@ class LinearConverter(Component):
         inputs: List[Flow],
         outputs: List[Flow],
         on_off_parameters: OnOffParameters = None,
-        conversion_factors: List[Dict[str, TimestepData]] = None,
+        conversion_factors: List[Dict[str, NumericDataTS]] = None,
         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
@@ -86,9 +182,9 @@ class LinearConverter(Component):
         if self.piecewise_conversion:
             for flow in self.flows.values():
                 if isinstance(flow.size, InvestParameters) and flow.size.fixed_size is None:
-                    logger.warning(
-                        f'Using a FLow with a fixed size ({flow.label_full}) AND a piecewise_conversion '
-                        f'(in {self.label_full}) and variable size is uncommon. Please check if this is intended!'
+                    raise PlausibilityError(
+                        f'piecewise_conversion (in {self.label_full}) and variable size '
+                        f'(in flow {flow.label_full}) do not make sense together!'
                     )
 
     def transform_data(self, flow_system: 'FlowSystem'):
@@ -96,7 +192,6 @@ class LinearConverter(Component):
         if self.conversion_factors:
             self.conversion_factors = self._transform_conversion_factors(flow_system)
         if self.piecewise_conversion:
-            self.piecewise_conversion.has_time_dim = True
             self.piecewise_conversion.transform_data(flow_system, f'{self.label_full}|PiecewiseConversion')
 
     def _transform_conversion_factors(self, flow_system: 'FlowSystem') -> List[Dict[str, TimeSeries]]:
@@ -128,17 +223,16 @@ class Storage(Component):
         label: str,
         charging: Flow,
         discharging: Flow,
-        capacity_in_flow_hours: Union[ScenarioData, InvestParameters],
-        relative_minimum_charge_state: TimestepData = 0,
-        relative_maximum_charge_state: TimestepData = 1,
-        initial_charge_state: Union[ScenarioData, Literal['lastValueOfSim']] = 0,
-        minimal_final_charge_state: Optional[ScenarioData] = None,
-        maximal_final_charge_state: Optional[ScenarioData] = None,
-        eta_charge: TimestepData = 1,
-        eta_discharge: TimestepData = 1,
-        relative_loss_per_hour: TimestepData = 0,
+        capacity_in_flow_hours: Union[Scalar, InvestParameters],
+        relative_minimum_charge_state: NumericData = 0,
+        relative_maximum_charge_state: NumericData = 1,
+        initial_charge_state: Union[Scalar, Literal['lastValueOfSim']] = 0,
+        minimal_final_charge_state: Optional[Scalar] = None,
+        maximal_final_charge_state: Optional[Scalar] = None,
+        eta_charge: NumericData = 1,
+        eta_discharge: NumericData = 1,
+        relative_loss_per_hour: NumericData = 0,
         prevent_simultaneous_charge_and_discharge: bool = True,
-        balanced: bool = False,
         meta_data: Optional[Dict] = None,
     ):
         """
@@ -164,7 +258,6 @@ class Storage(Component):
             relative_loss_per_hour: loss per chargeState-Unit per hour. The default is 0.
             prevent_simultaneous_charge_and_discharge: If True, loading and unloading at the same time is not possible.
                 Increases the number of binary variables, but is recommended for easier evaluation. The default is True.
-            balanced: Wether to equate the size of the charging and discharging flow. Only if not fixed.
             meta_data: used to store more information about the Element. Is not used internally, but saved in the results. Only use python native types.
         """
         # TODO: fixed_relative_chargeState implementieren
@@ -179,18 +272,17 @@ class Storage(Component):
         self.charging = charging
         self.discharging = discharging
         self.capacity_in_flow_hours = capacity_in_flow_hours
-        self.relative_minimum_charge_state: TimestepData = relative_minimum_charge_state
-        self.relative_maximum_charge_state: TimestepData = relative_maximum_charge_state
+        self.relative_minimum_charge_state: NumericDataTS = relative_minimum_charge_state
+        self.relative_maximum_charge_state: NumericDataTS = relative_maximum_charge_state
 
         self.initial_charge_state = initial_charge_state
         self.minimal_final_charge_state = minimal_final_charge_state
         self.maximal_final_charge_state = maximal_final_charge_state
 
-        self.eta_charge: TimestepData = eta_charge
-        self.eta_discharge: TimestepData = eta_discharge
-        self.relative_loss_per_hour: TimestepData = relative_loss_per_hour
+        self.eta_charge: NumericDataTS = eta_charge
+        self.eta_discharge: NumericDataTS = eta_discharge
+        self.relative_loss_per_hour: NumericDataTS = relative_loss_per_hour
         self.prevent_simultaneous_charge_and_discharge = prevent_simultaneous_charge_and_discharge
-        self.balanced = balanced
 
     def create_model(self, model: SystemModel) -> 'StorageModel':
         self._plausibility_checks()
@@ -202,83 +294,55 @@ class Storage(Component):
         self.relative_minimum_charge_state = flow_system.create_time_series(
             f'{self.label_full}|relative_minimum_charge_state',
             self.relative_minimum_charge_state,
-            has_extra_timestep=True,
+            needs_extra_timestep=True,
         )
         self.relative_maximum_charge_state = flow_system.create_time_series(
             f'{self.label_full}|relative_maximum_charge_state',
             self.relative_maximum_charge_state,
-            has_extra_timestep=True,
+            needs_extra_timestep=True,
         )
         self.eta_charge = flow_system.create_time_series(f'{self.label_full}|eta_charge', self.eta_charge)
         self.eta_discharge = flow_system.create_time_series(f'{self.label_full}|eta_discharge', self.eta_discharge)
         self.relative_loss_per_hour = flow_system.create_time_series(
             f'{self.label_full}|relative_loss_per_hour', self.relative_loss_per_hour
         )
-        if not isinstance(self.initial_charge_state, str):
-            self.initial_charge_state = flow_system.create_time_series(
-                f'{self.label_full}|initial_charge_state', self.initial_charge_state, has_time_dim=False
-            )
-        self.minimal_final_charge_state = flow_system.create_time_series(
-            f'{self.label_full}|minimal_final_charge_state', self.minimal_final_charge_state, has_time_dim=False
-        )
-        self.maximal_final_charge_state = flow_system.create_time_series(
-            f'{self.label_full}|maximal_final_charge_state', self.maximal_final_charge_state, has_time_dim=False
-        )
         if isinstance(self.capacity_in_flow_hours, InvestParameters):
-            self.capacity_in_flow_hours.transform_data(flow_system, f'{self.label_full}|InvestParameters')
-        else:
-            self.capacity_in_flow_hours = flow_system.create_time_series(
-                f'{self.label_full}|capacity_in_flow_hours', self.capacity_in_flow_hours, has_time_dim=False
-            )
+            self.capacity_in_flow_hours.transform_data(flow_system)
 
     def _plausibility_checks(self) -> None:
         """
         Check for infeasible or uncommon combinations of parameters
         """
         super()._plausibility_checks()
-        if isinstance(self.initial_charge_state, str):
-            if self.initial_charge_state != 'lastValueOfSim':
-                raise PlausibilityError(f'initial_charge_state has undefined value: {self.initial_charge_state}')
-            return
-        if isinstance(self.capacity_in_flow_hours, InvestParameters):
-            if self.capacity_in_flow_hours.fixed_size is None:
-                maximum_capacity = self.capacity_in_flow_hours.maximum_size
-                minimum_capacity = self.capacity_in_flow_hours.minimum_size
+        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:
+                    maximum_capacity = self.capacity_in_flow_hours.maximum_size
+                    minimum_capacity = self.capacity_in_flow_hours.minimum_size
+                else:
+                    maximum_capacity = self.capacity_in_flow_hours.fixed_size
+                    minimum_capacity = self.capacity_in_flow_hours.fixed_size
             else:
-                maximum_capacity = self.capacity_in_flow_hours.fixed_size
-                minimum_capacity = self.capacity_in_flow_hours.fixed_size
-        else:
-            maximum_capacity = self.capacity_in_flow_hours
-            minimum_capacity = self.capacity_in_flow_hours
-
-        # initial capacity >= allowed min for maximum_size:
-        minimum_inital_capacity = maximum_capacity * self.relative_minimum_charge_state.isel(time=0)
-        # initial capacity <= allowed max for minimum_size:
-        maximum_inital_capacity = minimum_capacity * self.relative_maximum_charge_state.isel(time=0)
-        # TODO: index=1 ??? I think index 0
-
-        if (self.initial_charge_state > maximum_inital_capacity).any():
-            raise ValueError(
-                f'{self.label_full}: {self.initial_charge_state=} '
-                f'is above allowed maximum charge_state {maximum_inital_capacity}'
-            )
-        if (self.initial_charge_state < minimum_inital_capacity).any():
-            raise ValueError(
-                f'{self.label_full}: {self.initial_charge_state=} '
-                f'is below allowed minimum charge_state {minimum_inital_capacity}'
-            )
+                maximum_capacity = self.capacity_in_flow_hours
+                minimum_capacity = self.capacity_in_flow_hours
 
-        if self.balanced:
-            if not isinstance(self.charging.size, InvestParameters) or not isinstance(self.discharging.size, InvestParameters):
-                raise PlausibilityError(
-                    f'Balancing charging and discharging Flows in {self.label_full} '
-                    f'is only possible with Investments.')
-            if (self.charging.size.minimum_size > self.discharging.size.maximum_size or
-                self.charging.size.maximum_size < self.discharging.size.minimum_size):
-                raise PlausibilityError(
-                    f'Balancing charging and discharging Flows in {self.label_full} need compatible minimum and maximum sizes.'
-                    f'Got: {self.charging.size.minimum_size=}, {self.charging.size.maximum_size=} and '
-                    f'{self.charging.size.minimum_size=}, {self.charging.size.maximum_size=}.')
+            # initial capacity >= allowed min for maximum_size:
+            minimum_inital_capacity = maximum_capacity * self.relative_minimum_charge_state.isel(time=1)
+            # initial capacity <= allowed max for minimum_size:
+            maximum_inital_capacity = minimum_capacity * self.relative_maximum_charge_state.isel(time=1)
+
+            if self.initial_charge_state > maximum_inital_capacity:
+                raise ValueError(
+                    f'{self.label_full}: {self.initial_charge_state=} '
+                    f'is above allowed maximum charge_state {maximum_inital_capacity}'
+                )
+            if self.initial_charge_state < minimum_inital_capacity:
+                raise ValueError(
+                    f'{self.label_full}: {self.initial_charge_state=} '
+                    f'is below allowed minimum charge_state {minimum_inital_capacity}'
+                )
+        elif self.initial_charge_state != 'lastValueOfSim':
+            raise ValueError(f'{self.label_full}: {self.initial_charge_state=} has an invalid value')
 
 
 @register_class_for_io
@@ -296,8 +360,8 @@ class Transmission(Component):
         out1: Flow,
         in2: Optional[Flow] = None,
         out2: Optional[Flow] = None,
-        relative_losses: Optional[TimestepData] = None,
-        absolute_losses: Optional[TimestepData] = None,
+        relative_losses: Optional[NumericDataTS] = None,
+        absolute_losses: Optional[NumericDataTS] = None,
         on_off_parameters: OnOffParameters = None,
         prevent_simultaneous_flows_in_both_directions: bool = True,
         meta_data: Optional[Dict] = None,
@@ -380,7 +444,7 @@ class TransmissionModel(ComponentModel):
     def do_modeling(self):
         """Initiates all FlowModels"""
         # Force On Variable if absolute losses are present
-        if (self.element.absolute_losses is not None) and np.any(self.element.absolute_losses.selected_data != 0):
+        if (self.element.absolute_losses is not None) and np.any(self.element.absolute_losses.active_data != 0):
             for flow in self.element.inputs + self.element.outputs:
                 if flow.on_off_parameters is None:
                     flow.on_off_parameters = OnOffParameters()
@@ -417,14 +481,14 @@ class TransmissionModel(ComponentModel):
         # eq: out(t) + on(t)*loss_abs(t) = in(t)*(1 - loss_rel(t))
         con_transmission = self.add(
             self._model.add_constraints(
-                out_flow.model.flow_rate == -in_flow.model.flow_rate * (self.element.relative_losses.selected_data - 1),
+                out_flow.model.flow_rate == -in_flow.model.flow_rate * (self.element.relative_losses.active_data - 1),
                 name=f'{self.label_full}|{name}',
             ),
             name,
         )
 
         if self.element.absolute_losses is not None:
-            con_transmission.lhs += in_flow.model.on_off.on * self.element.absolute_losses.selected_data
+            con_transmission.lhs += in_flow.model.on_off.on * self.element.absolute_losses.active_data
 
         return con_transmission
 
@@ -452,10 +516,8 @@ class LinearConverterModel(ComponentModel):
 
                 self.add(
                     self._model.add_constraints(
-                        sum([flow.model.flow_rate * conv_factors[flow.label].selected_data for flow in used_inputs])
-                        == sum(
-                            [flow.model.flow_rate * conv_factors[flow.label].selected_data for flow in used_outputs]
-                        ),
+                        sum([flow.model.flow_rate * conv_factors[flow.label].active_data for flow in used_inputs])
+                        == sum([flow.model.flow_rate * conv_factors[flow.label].active_data for flow in used_outputs]),
                         name=f'{self.label_full}|conversion_{i}',
                     )
                 )
@@ -495,15 +557,12 @@ class StorageModel(ComponentModel):
         lb, ub = self.absolute_charge_state_bounds
         self.charge_state = self.add(
             self._model.add_variables(
-                lower=lb,
-                upper=ub,
-                coords=self._model.get_coords(extra_timestep=True),
-                name=f'{self.label_full}|charge_state',
+                lower=lb, upper=ub, coords=self._model.coords_extra, name=f'{self.label_full}|charge_state'
             ),
             'charge_state',
         )
         self.netto_discharge = self.add(
-            self._model.add_variables(coords=self._model.get_coords(), name=f'{self.label_full}|netto_discharge'),
+            self._model.add_variables(coords=self._model.coords, name=f'{self.label_full}|netto_discharge'),
             'netto_discharge',
         )
         # netto_discharge:
@@ -518,17 +577,17 @@ class StorageModel(ComponentModel):
         )
 
         charge_state = self.charge_state
-        rel_loss = self.element.relative_loss_per_hour.selected_data
+        rel_loss = self.element.relative_loss_per_hour.active_data
         hours_per_step = self._model.hours_per_step
         charge_rate = self.element.charging.model.flow_rate
         discharge_rate = self.element.discharging.model.flow_rate
-        eff_charge = self.element.eta_charge.selected_data
-        eff_discharge = self.element.eta_discharge.selected_data
+        eff_charge = self.element.eta_charge.active_data
+        eff_discharge = self.element.eta_discharge.active_data
 
         self.add(
             self._model.add_constraints(
                 charge_state.isel(time=slice(1, None))
-                == charge_state.isel(time=slice(None, -1)) * (1 - rel_loss * hours_per_step)
+                == charge_state.isel(time=slice(None, -1)) * ((1 - rel_loss) ** hours_per_step)
                 + charge_rate * eff_charge * hours_per_step
                 - discharge_rate * eff_discharge * hours_per_step,
                 name=f'{self.label_full}|charge_state',
@@ -550,34 +609,29 @@ class StorageModel(ComponentModel):
         # Initial charge state
         self._initial_and_final_charge_state()
 
-        if self.element.balanced:
-            self.add(
-                self._model.add_constraints(
-                    self.element.charging.model._investment.size * 1 == self.element.discharging.model._investment.size * 1,
-                    name=f'{self.label_full}|balanced_sizes',
-                ),
-                'balanced_sizes'
-            )
-
     def _initial_and_final_charge_state(self):
         if self.element.initial_charge_state is not None:
             name_short = 'initial_charge_state'
             name = f'{self.label_full}|{name_short}'
 
-            if isinstance(self.element.initial_charge_state, str):
+            if utils.is_number(self.element.initial_charge_state):
                 self.add(
                     self._model.add_constraints(
-                        self.charge_state.isel(time=0) == self.charge_state.isel(time=-1), name=name
+                        self.charge_state.isel(time=0) == self.element.initial_charge_state, name=name
                     ),
                     name_short,
                 )
-            else:
+            elif self.element.initial_charge_state == 'lastValueOfSim':
                 self.add(
                     self._model.add_constraints(
-                        self.charge_state.isel(time=0) == self.element.initial_charge_state, name=name
+                        self.charge_state.isel(time=0) == self.charge_state.isel(time=-1), name=name
                     ),
                     name_short,
                 )
+            else:  # TODO: Validation in Storage Class, not in Model
+                raise PlausibilityError(
+                    f'initial_charge_state has undefined value: {self.element.initial_charge_state}'
+                )
 
         if self.element.maximal_final_charge_state is not None:
             self.add(
@@ -598,7 +652,7 @@ class StorageModel(ComponentModel):
             )
 
     @property
-    def absolute_charge_state_bounds(self) -> Tuple[TimestepData, TimestepData]:
+    def absolute_charge_state_bounds(self) -> Tuple[NumericData, NumericData]:
         relative_lower_bound, relative_upper_bound = self.relative_charge_state_bounds
         if not isinstance(self.element.capacity_in_flow_hours, InvestParameters):
             return (
@@ -612,10 +666,10 @@ class StorageModel(ComponentModel):
             )
 
     @property
-    def relative_charge_state_bounds(self) -> Tuple[TimestepData, TimestepData]:
+    def relative_charge_state_bounds(self) -> Tuple[NumericData, NumericData]:
         return (
-            self.element.relative_minimum_charge_state,
-            self.element.relative_maximum_charge_state,
+            self.element.relative_minimum_charge_state.active_data,
+            self.element.relative_maximum_charge_state.active_data,
         )
 
 
@@ -628,52 +682,170 @@ class SourceAndSink(Component):
     def __init__(
         self,
         label: str,
-        source: Flow,
-        sink: Flow,
-        prevent_simultaneous_sink_and_source: bool = True,
+        inputs: List[Flow] = None,
+        outputs: List[Flow] = None,
+        prevent_simultaneous_flow_rates: bool = True,
         meta_data: Optional[Dict] = None,
+        **kwargs,
     ):
         """
         Args:
             label: The label of the Element. Used to identify it in the FlowSystem
-            source: output-flow of this component
-            sink: input-flow of this component
-            prevent_simultaneous_sink_and_source: If True, inflow and outflow can not be active simultaniously.
+            outputs: output-flows of this component
+            inputs: input-flows of this component
+            prevent_simultaneous_flow_rates: If True, inflow and outflow can not be active simultaniously.
             meta_data: used to store more information about the Element. Is not used internally, but saved in the results. Only use python native types.
         """
+        source = kwargs.pop('source', None)
+        sink = kwargs.pop('sink', None)
+        prevent_simultaneous_sink_and_source = kwargs.pop('prevent_simultaneous_sink_and_source', None)
+        if source is not None:
+            warnings.deprecated(
+                'The use of the source argument is deprecated. Use the outputs argument instead.',
+                stacklevel=2,
+            )
+            if outputs is not None:
+                raise ValueError('Either source or outputs can be specified, but not both.')
+            outputs = [source]
+
+        if sink is not None:
+            warnings.deprecated(
+                'The use of the sink argument is deprecated. Use the outputs argument instead.',
+                stacklevel=2,
+            )
+            if inputs is not None:
+                raise ValueError('Either sink or outputs can be specified, but not both.')
+            inputs = [sink]
+
+        if prevent_simultaneous_sink_and_source is not None:
+            warnings.deprecated(
+                'The use of the prevent_simultaneous_sink_and_source argument is deprecated. Use the prevent_simultaneous_flow_rates argument instead.',
+                stacklevel=2,
+            )
+            prevent_simultaneous_flow_rates = prevent_simultaneous_sink_and_source
+
         super().__init__(
             label,
-            inputs=[sink],
-            outputs=[source],
-            prevent_simultaneous_flows=[sink, source] if prevent_simultaneous_sink_and_source is True else None,
+            inputs=inputs,
+            outputs=outputs,
+            prevent_simultaneous_flows=inputs + outputs if prevent_simultaneous_flow_rates is True else None,
             meta_data=meta_data,
         )
-        self.source = source
-        self.sink = sink
-        self.prevent_simultaneous_sink_and_source = prevent_simultaneous_sink_and_source
+        self.prevent_simultaneous_flow_rates = prevent_simultaneous_flow_rates
+
+    @property
+    def source(self) -> Flow:
+        warnings.warn(
+            'The source property is deprecated. Use the outputs property instead.',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.outputs[0]
+
+    @property
+    def sink(self) -> Flow:
+        warnings.warn(
+            'The sink property is deprecated. Use the outputs property instead.',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.inputs[0]
+
+    @property
+    def prevent_simultaneous_sink_and_source(self) -> bool:
+        warnings.warn(
+            'The prevent_simultaneous_sink_and_source property is deprecated. Use the prevent_simultaneous_flow_rates property instead.',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.prevent_simultaneous_flow_rates
 
 
 @register_class_for_io
 class Source(Component):
-    def __init__(self, label: str, source: Flow, meta_data: Optional[Dict] = None):
+    def __init__(
+        self,
+        label: str,
+        outputs: List[Flow] = None,
+        meta_data: Optional[Dict] = None,
+        prevent_simultaneous_flow_rates: bool = False,
+        **kwargs,
+    ):
         """
         Args:
             label: The label of the Element. Used to identify it in the FlowSystem
-            source: output-flow of source
+            outputs: output-flows of source
             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, outputs=[source], meta_data=meta_data)
-        self.source = source
+        source = kwargs.pop('source', None)
+        if source is not None:
+            warnings.warn(
+                'The use of the source argument is deprecated. Use the outputs argument instead.',
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            if outputs is not None:
+                raise ValueError('Either source or outputs can be specified, but not both.')
+            outputs = [source]
+
+        self.prevent_simultaneous_flow_rates = prevent_simultaneous_flow_rates
+        super().__init__(
+            label,
+            outputs=outputs,
+            meta_data=meta_data,
+            prevent_simultaneous_flows=outputs if prevent_simultaneous_flow_rates else None,
+        )
+
+    @property
+    def source(self) -> Flow:
+        warnings.warn(
+            'The source property is deprecated. Use the outputs property instead.',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.outputs[0]
 
 
 @register_class_for_io
 class Sink(Component):
-    def __init__(self, label: str, sink: Flow, meta_data: Optional[Dict] = None):
+    def __init__(
+        self,
+        label: str,
+        inputs: List[Flow] = None,
+        meta_data: Optional[Dict] = None,
+        prevent_simultaneous_flow_rates: bool = False,
+        **kwargs,
+    ):
         """
         Args:
             label: The label of the Element. Used to identify it in the FlowSystem
-            meta_data: used to store more information about the element. Is not used internally, but saved in the results
-            sink: input-flow of sink
+            inputs: output-flows of source
+            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=[sink], meta_data=meta_data)
-        self.sink = sink
+        sink = kwargs.pop('sink', None)
+        if sink is not None:
+            warnings.warn(
+                'The use of the sink argument is deprecated. Use the outputs argument instead.',
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            if inputs is not None:
+                raise ValueError('Either sink or outputs can be specified, but not both.')
+            inputs = [sink]
+
+        self.prevent_simultaneous_flow_rates = prevent_simultaneous_flow_rates
+        super().__init__(
+            label,
+            inputs=inputs,
+            meta_data=meta_data,
+            prevent_simultaneous_flows=inputs if prevent_simultaneous_flow_rates else None,
+        )
+
+    @property
+    def sink(self) -> Flow:
+        warnings.warn(
+            'The sink property is deprecated. Use the outputs property instead.',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.inputs[0]