Scenarios/fixes (#255)

* Fix indexing issue with only one scenario

* Bugfix Cooling Tower

* Add option for balanced Storage Flows (equalize size of charging and discharging)

* Add option for balanced Storage Flows

* Change error to warning (non-fixed size with piecewise conversion AND fixed_flow_rate with OnOff)

* Bugfix in DataConverter

* BUGFIX: Typo (total_max/total_min in Effect)

* Bugfix in node_balance() (negating did not work when using flow_hours mode

Author: FBumann

flixopt/components.py

@@ -86,8 +86,8 @@ def _plausibility_checks(self) -> None:
         if self.piecewise_conversion:
             for flow in self.flows.values():
                 if isinstance(flow.size, InvestParameters) and flow.size.fixed_size is None:
-                    raise PlausibilityError(
-                        f'piecewise_conversion (in {self.label_full}) and variable size '
+                    logger.warning(
+                        f'Piecewise_conversion (in {self.label_full}) and variable size '
                         f'(in flow {flow.label_full}) do not make sense together!'
                     )
 
@@ -138,6 +138,7 @@ def __init__(
         eta_discharge: TimestepData = 1,
         relative_loss_per_hour: TimestepData = 0,
         prevent_simultaneous_charge_and_discharge: bool = True,
+        balanced: bool = False,
         meta_data: Optional[Dict] = None,
     ):
         """
@@ -163,6 +164,7 @@ def __init__(
             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
@@ -188,6 +190,7 @@ def __init__(
         self.eta_discharge: TimestepData = eta_discharge
         self.relative_loss_per_hour: TimestepData = 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()
@@ -261,6 +264,18 @@ def _plausibility_checks(self) -> None:
                 f'is below allowed minimum charge_state {minimum_inital_capacity}'
             )
 
+        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=}.')
+
 
 @register_class_for_io
 class Transmission(Component):
@@ -531,6 +546,15 @@ def do_modeling(self):
         # 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'

flixopt/core.py

@@ -251,8 +251,11 @@ def _broadcast_time_to_scenarios(
         if not np.array_equal(data.coords['time'].values, coords['time'].values):
             raise ConversionError("Source time coordinates don't match target time coordinates")
 
+        if len(coords['scenario']) <= 1:
+            return data.copy(deep=True)
+
         # Broadcast values
-        values = np.tile(data.values, (len(coords['scenario']), 1))
+        values = np.tile(data.values, (len(coords['scenario']), 1)).T  # Tile seems to be faster than repeat()
         return xr.DataArray(values.copy(), coords=coords, dims=dims)
 
     @staticmethod

flixopt/elements.py

@@ -292,10 +292,9 @@ def _plausibility_checks(self) -> None:
             )
 
         if self.fixed_relative_profile is not None and self.on_off_parameters is not None:
-            raise ValueError(
-                f'Flow {self.label} has both a fixed_relative_profile and an on_off_parameters. This is not supported. '
-                f'Use relative_minimum and relative_maximum instead, '
-                f'if you want to allow flows to be switched on and off.'
+            logger.warning(
+                f'Flow {self.label} has both a fixed_relative_profile and an on_off_parameters.'
+                f'This will allow the flow to be switched on and off, effectively differing from the fixed_flow_rate.'
             )
 
         if (self.relative_minimum > 0).any() and self.on_off_parameters is None:

flixopt/features.py

@@ -154,11 +154,6 @@ def _create_bounds_for_defining_variable(self):
                 ),
                 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)
@@ -988,7 +983,7 @@ def __init__(
         # Parameters
         self._has_time_dim = has_time_dim
         self._has_scenario_dim = has_scenario_dim
-        self._total_max = total_max if total_min is not None else np.inf
+        self._total_max = total_max if total_max 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

flixopt/linear_converters.py

@@ -165,7 +165,7 @@ def __init__(
             label,
             inputs=[P_el, Q_th],
             outputs=[],
-            conversion_factors=[{P_el.label: 1, Q_th.label: -specific_electricity_demand}],
+            conversion_factors=[{P_el.label: -1, Q_th.label: specific_electricity_demand}],
             on_off_parameters=on_off_parameters,
             meta_data=meta_data,
         )
@@ -177,12 +177,12 @@ def __init__(
 
     @property
     def specific_electricity_demand(self):
-        return -self.conversion_factors[0][self.Q_th.label]
+        return self.conversion_factors[0][self.Q_th.label]
 
     @specific_electricity_demand.setter
     def specific_electricity_demand(self, value):
         check_bounds(value, 'specific_electricity_demand', self.label_full, 0, 1)
-        self.conversion_factors[0][self.Q_th.label] = -value
+        self.conversion_factors[0][self.Q_th.label] = value
 
 
 @register_class_for_io

flixopt/results.py

@@ -631,11 +631,7 @@ def node_balance(
         """
         ds = self.solution[self.inputs + self.outputs]
 
-        if mode == 'flow_hours':
-            ds = ds * self._calculation_results.hours_per_timestep
-            ds = ds.rename_vars({var: var.replace('flow_rate', 'flow_hours') for var in ds.data_vars})
-
-        return sanitize_dataset(
+        ds = sanitize_dataset(
             ds=ds,
             threshold=threshold,
             timesteps=self._calculation_results.timesteps_extra if with_last_timestep else None,
@@ -651,6 +647,12 @@ def node_balance(
             drop_suffix='|' if drop_suffix else None,
         )
 
+        if mode == 'flow_hours':
+            ds = ds * self._calculation_results.hours_per_timestep
+            ds = ds.rename_vars({var: var.replace('flow_rate', 'flow_hours') for var in ds.data_vars})
+
+        return ds
+
 
 class BusResults(_NodeResults):
     """Results for a Bus"""