Merge pull request #68 from FBumann/feature/fixed-profile

Feature/fixed profile

Author: FBumann

examples/Ex00_minmal/minimal_example.py

@@ -33,8 +33,7 @@
 
     # Heat load component with a fixed thermal demand profile
     heat_load = fx.Sink('Heat Demand',
-        sink=fx.Flow(label='Thermal Load', bus=heat_bus, size=1, relative_maximum=max(thermal_load_profile),
-                     fixed_relative_value=thermal_load_profile))
+        sink=fx.Flow(label='Thermal Load', bus=heat_bus, size=1, fixed_relative_profile=thermal_load_profile))
 
     # Gas source component with cost-effect per flow hour
     gas_source = fx.Source('Natural Gas Tariff',

examples/Ex01_simple/simple_example.py

@@ -60,8 +60,7 @@
     # Heat Demand Sink: Represents a fixed heat demand profile
     heat_sink = fx.Sink(label='Heat Demand',
                         sink=fx.Flow(label='Q_th_Last', bus=Fernwaerme, size=1,
-                                     relative_maximum=max(heat_demand_per_h),
-                                     fixed_relative_value=heat_demand_per_h))
+                                     fixed_relative_profile=heat_demand_per_h))
 
     # Gas Source: Gas tariff source with associated costs and CO2 emissions
     gas_source = fx.Source(label='Gastarif',

examples/Ex02_complex/complex_example.py

@@ -109,7 +109,8 @@
     # 5.a) Heat demand profile
     Waermelast = fx.Sink('Wärmelast', sink=fx.Flow('Q_th_Last',  # Heat sink
                                                    bus=Fernwaerme,  # Linked bus
-                                                   size=1, relative_maximum=max(heat_demand), fixed_relative_value=heat_demand))  # Fixed demand profile
+                                                   size=1,
+                                                   fixed_relative_profile=heat_demand))  # Fixed demand profile
 
     # 5.b) Gas tariff
     Gasbezug = fx.Source('Gastarif', source=fx.Flow('Q_Gas', bus=Gas,  # Gas source

examples/Ex03_calculation_types/example_calculation_types.py

@@ -92,14 +92,11 @@
     # 4. Sinks and Sources
     # Heat Load Profile
     a_waermelast = fx.Sink('Wärmelast',
-                           sink=fx.Flow('Q_th_Last', bus=Fernwaerme, size=1,
-                                        relative_maximum=max(TS_heat_demand.data), fixed_relative_value=TS_heat_demand))
+                           sink=fx.Flow('Q_th_Last', bus=Fernwaerme, size=1,fixed_relative_profile=TS_heat_demand))
 
     # Electricity Feed-in
     a_strom_last = fx.Sink('Stromlast',
-                           sink=fx.Flow('P_el_Last', bus=Strom, size=1,
-                                        relative_maximum=max(TS_electricity_demand.data),
-                                        fixed_relative_value=TS_electricity_demand))
+                           sink=fx.Flow('P_el_Last', bus=Strom, size=1, fixed_relative_profile=TS_electricity_demand))
 
     # Gas Tariff
     a_gas_tarif = fx.Source('Gastarif',

flixOpt/components.py

@@ -269,7 +269,7 @@ def __init__(self, element: Storage):
     def do_modeling(self, system_model):
         super().do_modeling(system_model)
 
-        lb, ub = self.charge_state_bounds
+        lb, ub = self.absolute_charge_state_bounds
         self.charge_state = create_variable('charge_state', self, system_model.nr_of_time_steps + 1, lower_bound=lb,
                                             upper_bound=ub)
 
@@ -303,10 +303,8 @@ def do_modeling(self, system_model):
                                     1 / self.element.eta_discharge.active_data * system_model.dt_in_hours)
 
         if isinstance(self.element.capacity_in_flow_hours, InvestParameters):
-            self._investment = InvestmentModel(
-                self.element, self.element.capacity_in_flow_hours, self.charge_state,
-                (self.element.relative_minimum_charge_state.active_data,
-                 self.element.relative_maximum_charge_state.active_data))
+            self._investment = InvestmentModel(self.element, self.element.capacity_in_flow_hours, self.charge_state,
+                                               self.relative_charge_state_bounds)
             self.sub_models.append(self._investment)
             self._investment.do_modeling(system_model)
 
@@ -346,13 +344,19 @@ def _model_initial_and_final_charge_state(self, system_model):
             eq_min.add_constant(- self.element.minimal_final_charge_state)
 
     @property
-    def charge_state_bounds(self) -> Tuple[Numeric, Numeric]:
+    def absolute_charge_state_bounds(self) -> Tuple[Numeric, Numeric]:
+        relative_lower_bound, relative_upper_bound = self.relative_charge_state_bounds
         if not isinstance(self.element.capacity_in_flow_hours, InvestParameters):
-            return (self.element.relative_minimum_charge_state.active_data * self.element.capacity_in_flow_hours,
-                    self.element.relative_maximum_charge_state.active_data * self.element.capacity_in_flow_hours)
+            return (relative_lower_bound * self.element.capacity_in_flow_hours,
+                    relative_upper_bound * self.element.capacity_in_flow_hours)
         else:
-            return (self.element.relative_minimum_charge_state.active_data * self.element.capacity_in_flow_hours.minimum_size,
-                    self.element.relative_maximum_charge_state.active_data * self.element.capacity_in_flow_hours.maximum_size)
+            return (relative_lower_bound * self.element.capacity_in_flow_hours.minimum_size,
+                    relative_upper_bound * self.element.capacity_in_flow_hours.maximum_size)
+
+    @property
+    def relative_charge_state_bounds(self) -> Tuple[Numeric, Numeric]:
+        return (self.element.relative_minimum_charge_state.active_data,
+                self.element.relative_maximum_charge_state.active_data)
 
 
 class SourceAndSink(Component):

flixOpt/core.py

@@ -36,9 +36,9 @@ def __init__(self,
             EXAMPLE solar:
             you have several solar timeseries. These should not be overweighted
             compared to the remaining timeseries (i.g. heat load, price)!
-            fixed_relative_value_solar1 = TimeSeriesData(sol_array_1, type = 'solar')
-            fixed_relative_value_solar2 = TimeSeriesData(sol_array_2, type = 'solar')
-            fixed_relative_value_solar3 = TimeSeriesData(sol_array_3, type = 'solar')
+            fixed_relative_profile_solar1 = TimeSeriesData(sol_array_1, type = 'solar')
+            fixed_relative_profile_solar2 = TimeSeriesData(sol_array_2, type = 'solar')
+            fixed_relative_profile_solar3 = TimeSeriesData(sol_array_3, type = 'solar')
             --> this 3 series of same type share one weight, i.e. internally assigned each weight = 1/3
             (instead of standard weight = 1)
 

flixOpt/elements.py

@@ -139,14 +139,13 @@ class Flow(Element):
     flows are inputs and outputs of components
     '''
 
-    # static var:
     _default_size = 1e9  # Großer Gültigkeitsbereich als Standard
 
     def __init__(self,
                  label: str,
-                 bus: Bus = None,  # TODO: Is this for sure Optional?
+                 bus: Bus,
                  size: Union[Skalar, InvestParameters] = _default_size,
-                 fixed_relative_value: Optional[Numeric_TS] = None,  # TODO: Rename?
+                 fixed_relative_profile: Optional[Numeric_TS] = None,
                  relative_minimum: Numeric_TS = 0,
                  relative_maximum: Numeric_TS = 1,
                  effects_per_flow_hour: Optional[EffectValues] = None,
@@ -190,10 +189,10 @@ def __init__(self,
         flow_hours_total_min : TYPE, optional
             minimum flow-hours ("flow-work")
             (if size is not const, maybe load_factor_min fits better for you!)
-        fixed_relative_value : scalar, array, TimeSeriesData, optional
+        fixed_relative_profile : scalar, array, TimeSeriesData, optional
             fixed relative values for flow (if given).
-            val(t) := fixed_relative_value(t) * size(t)
-            With this value, the flow-value is no opt-variable anymore;
+            val(t) := fixed_relative_profile(t) * size(t)
+            With this value, the flow_rate is no opt-variable anymore;
             (relative_minimum u. relative_maximum are making sense anymore)
             used for fixed load profiles, i.g. heat demand, wind-power, solarthermal
             If the load-profile is just an upper limit, use relative_maximum instead.
@@ -204,7 +203,7 @@ def __init__(self,
         self.size = size
         self.relative_minimum = relative_minimum
         self.relative_maximum = relative_maximum
-        self.fixed_relative_value = fixed_relative_value
+        self.fixed_relative_profile = fixed_relative_profile
 
         self.load_factor_min = load_factor_min
         self.load_factor_max = load_factor_max
@@ -228,7 +227,7 @@ def create_model(self) -> 'FlowModel':
     def transform_data(self):
         self.relative_minimum = _create_time_series(f'relative_minimum', self.relative_minimum, self)
         self.relative_maximum = _create_time_series(f'relative_maximum', self.relative_maximum, self)
-        self.fixed_relative_value = _create_time_series(f'fixed_relative_value', self.fixed_relative_value, self)
+        self.fixed_relative_profile = _create_time_series(f'fixed_relative_profile', self.fixed_relative_profile, self)
         self.effects_per_flow_hour = effect_values_to_time_series(f'per_flow_hour', self.effects_per_flow_hour, self)
         if self.on_off_parameters is not None:
             self.on_off_parameters.transform_data(self)
@@ -245,9 +244,9 @@ def _plausibility_checks(self) -> None:
         if np.any(self.relative_minimum > self.relative_maximum):
             raise Exception(self.label_full + ': Take care, that relative_minimum <= relative_maximum!')
 
-        if self.size == Flow._default_size and self.fixed_relative_value is not None:  #Default Size --> Most likely by accident
-            raise Exception('Achtung: Wenn fixed_relative_value genutzt wird, muss zugehöriges size definiert werden, '
-                            'da: value = fixed_relative_value * size!')
+        if self.size == Flow._default_size and self.fixed_relative_profile is not None:  #Default Size --> Most likely by accident
+            raise Exception('Achtung: Wenn fixed_relative_profile genutzt wird, muss zugehöriges size definiert werden, '
+                            'da: value = fixed_relative_profile * size!')
 
     @property
     def label_full(self) -> str:
@@ -283,15 +282,16 @@ def __init__(self, element: Flow):
     def do_modeling(self, system_model: SystemModel):
         lower_bound, upper_bound, fixed_flow_rate = 0, None, None  # Standard configuration
         if not isinstance(self.element.size, InvestParameters):
-            if self.element.fixed_relative_value is not None:  # Size is fixed -> flow_rate can be fixed
-                fixed_flow_rate = self.element.fixed_relative_value.active_data * self.element.size
-            if self.element.on_off_parameters is None:  # Size is fixed and No On-Variable -> Bounds can be set
+            if self.element.fixed_relative_profile is not None:  # Size is fixed -> flow_rate can be fixed
+                lower_bound, upper_bound = None, None  # Ignoring bounds
+                fixed_flow_rate = self.element.fixed_relative_profile.active_data * self.element.size
+            elif self.element.on_off_parameters is None:  # Size is fixed, no profile and No On-Variable -> Bounds can be set
                 lower_bound = self.element.relative_minimum.active_data * self.element.size
                 upper_bound = self.element.relative_maximum.active_data * self.element.size
 
         # eq relative_minimum(t) * size <= flow_rate(t) <= relative_maximum(t) * size
-        self.flow_rate = create_variable('flow_rate', self, system_model.nr_of_time_steps, fixed_value=fixed_flow_rate,
-                                         lower_bound=lower_bound, upper_bound=upper_bound,
+        self.flow_rate = create_variable('flow_rate', self, system_model.nr_of_time_steps,
+                                         fixed_value=fixed_flow_rate, lower_bound=lower_bound, upper_bound=upper_bound,
                                          previous_values=self.element.previous_flow_rate)
 
         # OnOff
@@ -307,6 +307,7 @@ def do_modeling(self, system_model: SystemModel):
             self._investment = InvestmentModel(self.element, self.element.size,
                                                self.flow_rate,
                                                self.relative_flow_rate_bounds,
+                                               self.element.fixed_relative_profile,
                                                on_variable=self._on.on if self._on is not None else None)
             self._investment.do_modeling(system_model)
             self.sub_models.append(self._investment)
@@ -358,19 +359,21 @@ def _create_bounds_for_load_factor(self, system_model: SystemModel):
 
     @property
     def absolute_flow_rate_bounds(self) -> Tuple[Numeric, Numeric]:
+        relative_lower_bound, relative_upper_bound = self.relative_flow_rate_bounds
         if not isinstance(self.element.size, InvestParameters):
-            return (self.element.relative_minimum.active_data * self.element.size,
-                    self.element.relative_maximum.active_data * self.element.size)
+            return (relative_lower_bound * self.element.size,
+                    relative_upper_bound * self.element.size)
         else:
-            return (self.element.relative_minimum.active_data * self.element.size.minimum_size,
-                    self.element.relative_maximum.active_data * self.element.size.maximum_size)
+            return (relative_lower_bound * self.element.size.minimum_size,
+                    relative_upper_bound * self.element.size.maximum_size)
 
     @property
     def relative_flow_rate_bounds(self) -> Tuple[Numeric, Numeric]:
-        if self.element.fixed_relative_value is None:
+        if self.element.fixed_relative_profile is None:
             return self.element.relative_minimum.active_data, self.element.relative_maximum.active_data
         else:
-            return self.element.fixed_relative_value.active_data, self.element.fixed_relative_value.active_data
+            return (np.minimum(self.element.fixed_relative_profile.active_data, self.element.relative_minimum.active_data),
+                    np.maximum(self.element.fixed_relative_profile.active_data, self.element.relative_maximum.active_data))
 
 
 class BusModel(ElementModel):

flixOpt/features.py

@@ -30,10 +30,11 @@ def __init__(self, element: Union['Flow', 'Storage'],
                  invest_parameters: InvestParameters,
                  defining_variable: [VariableTS],
                  relative_bounds_of_defining_variable: Tuple[Numeric, Numeric],
+                 fixed_relative_profile: Optional[Numeric] = None,
                  label: str = 'Investment',
                  on_variable: Optional[VariableTS] = None):
         """
-        if relative_bounds are both equal, then its like a fixed relative value
+        If fixed relative profile is used, the relative bounds are ignored
         """
         super().__init__(element, label)
         self.element: Union['Flow', 'Storage'] = element
@@ -45,6 +46,7 @@ def __init__(self, element: Union['Flow', 'Storage'],
         self._on_variable = on_variable
         self._defining_variable = defining_variable
         self._relative_bounds_of_defining_variable = relative_bounds_of_defining_variable
+        self._fixed_relative_profile = fixed_relative_profile
         self._invest_parameters = invest_parameters
 
     def do_modeling(self, system_model: SystemModel):
@@ -121,14 +123,14 @@ def _create_bounds_for_optional_investment(self, system_model: SystemModel):
 
     def _create_bounds_for_defining_variable(self, system_model: SystemModel):
         label = self._defining_variable.label
-        relative_minimum, relative_maximum = self._relative_bounds_of_defining_variable
         # fixed relative value
-        if np.array_equal(relative_minimum, relative_maximum):
+        if self._fixed_relative_profile is not None:
             # TODO: Allow Off? Currently not...
             eq_fixed = create_equation(f'fixed_{label}', self)
             eq_fixed.add_summand(self._defining_variable, 1)
-            eq_fixed.add_summand(self.size, np.multiply(-1, relative_maximum))
+            eq_fixed.add_summand(self.size, np.multiply(-1, self._fixed_relative_profile))
         else:
+            relative_minimum, relative_maximum = self._relative_bounds_of_defining_variable
             eq_upper = create_equation(f'ub_{label}', self, 'ineq')
             # eq: defining_variable(t)  <= size * upper_bound(t)
             eq_upper.add_summand(self._defining_variable, 1)