Scenarios

flixopt/calculation.py

@@ -183,8 +183,8 @@ def solve(self, solver: _Solver, log_file: Optional[pathlib.Path] = None, log_ma
 
     def _activate_time_series(self):
         self.flow_system.transform_data()
-        self.flow_system.time_series_collection.activate_timesteps(
-            active_timesteps=self.active_timesteps,
+        self.flow_system.time_series_collection.set_selection(
+            timesteps=self.active_timesteps
         )
 
 
@@ -217,6 +217,8 @@ def __init__(
                 list with indices, which should be used for calculation. If None, then all timesteps are used.
             folder: folder where results should be saved. If None, then the current working directory is used.
         """
+        if flow_system.time_series_collection.scenarios is not None:
+            raise ValueError('Aggregation is not supported for scenarios yet. Please use FullCalculation instead.')
         super().__init__(name, flow_system, active_timesteps, folder=folder)
         self.aggregation_parameters = aggregation_parameters
         self.components_to_clusterize = components_to_clusterize
@@ -272,9 +274,9 @@ def _perform_aggregation(self):
 
         # Aggregation - creation of aggregated timeseries:
         self.aggregation = Aggregation(
-            original_data=self.flow_system.time_series_collection.to_dataframe(
-                include_extra_timestep=False
-            ),  # Exclude last row (NaN)
+            original_data=self.flow_system.time_series_collection.as_dataset(
+                with_extra_timestep=False, with_constants=False
+            ).to_dataframe(),
             hours_per_time_step=float(dt_min),
             hours_per_period=self.aggregation_parameters.hours_per_period,
             nr_of_periods=self.aggregation_parameters.nr_of_periods,
@@ -286,9 +288,11 @@ def _perform_aggregation(self):
         self.aggregation.cluster()
         self.aggregation.plot(show=True, save=self.folder / 'aggregation.html')
         if self.aggregation_parameters.aggregate_data_and_fix_non_binary_vars:
-            self.flow_system.time_series_collection.insert_new_data(
-                self.aggregation.aggregated_data, include_extra_timestep=False
-            )
+            for col in self.aggregation.aggregated_data.columns:
+                data = self.aggregation.aggregated_data[col].values
+                if col in self.flow_system.time_series_collection._has_extra_timestep:
+                    data = np.append(data, data[-1])
+                self.flow_system.time_series_collection.update_time_series(col, data)
         self.durations['aggregation'] = round(timeit.default_timer() - t_start_agg, 2)
 
 
@@ -327,8 +331,8 @@ def __init__(
         self.nr_of_previous_values = nr_of_previous_values
         self.sub_calculations: List[FullCalculation] = []
 
-        self.all_timesteps = self.flow_system.time_series_collection.all_timesteps
-        self.all_timesteps_extra = self.flow_system.time_series_collection.all_timesteps_extra
+        self.all_timesteps = self.flow_system.time_series_collection._full_timesteps
+        self.all_timesteps_extra = self.flow_system.time_series_collection._full_timesteps_extra
 
         self.segment_names = [
             f'Segment_{i + 1}' for i in range(math.ceil(len(self.all_timesteps) / self.timesteps_per_segment))

flixopt/components.py

@@ -194,12 +194,12 @@ def transform_data(self, flow_system: 'FlowSystem') -> None:
         self.relative_minimum_charge_state = flow_system.create_time_series(
             f'{self.label_full}|relative_minimum_charge_state',
             self.relative_minimum_charge_state,
-            needs_extra_timestep=True,
+            has_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,
-            needs_extra_timestep=True,
+            has_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)
@@ -342,7 +342,7 @@ def __init__(self, model: SystemModel, element: Transmission):
     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.active_data != 0):
+        if (self.element.absolute_losses is not None) and np.any(self.element.absolute_losses.selected_data != 0):
             for flow in self.element.inputs + self.element.outputs:
                 if flow.on_off_parameters is None:
                     flow.on_off_parameters = OnOffParameters()
@@ -379,14 +379,14 @@ def create_transmission_equation(self, name: str, in_flow: Flow, out_flow: Flow)
         # 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.active_data - 1),
+                out_flow.model.flow_rate == -in_flow.model.flow_rate * (self.element.relative_losses.selected_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.active_data
+            con_transmission.lhs += in_flow.model.on_off.on * self.element.absolute_losses.selected_data
 
         return con_transmission
 
@@ -413,8 +413,8 @@ def do_modeling(self):
 
                 self.add(
                     self._model.add_constraints(
-                        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]),
+                        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]),
                         name=f'{self.label_full}|conversion_{i}',
                     )
                 )
@@ -474,12 +474,12 @@ def do_modeling(self):
         )
 
         charge_state = self.charge_state
-        rel_loss = self.element.relative_loss_per_hour.active_data
+        rel_loss = self.element.relative_loss_per_hour.selected_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.active_data
-        eff_discharge = self.element.eta_discharge.active_data
+        eff_charge = self.element.eta_charge.selected_data
+        eff_discharge = self.element.eta_discharge.selected_data
 
         self.add(
             self._model.add_constraints(
@@ -565,8 +565,8 @@ def absolute_charge_state_bounds(self) -> Tuple[NumericData, NumericData]:
     @property
     def relative_charge_state_bounds(self) -> Tuple[NumericData, NumericData]:
         return (
-            self.element.relative_minimum_charge_state.active_data,
-            self.element.relative_maximum_charge_state.active_data,
+            self.element.relative_minimum_charge_state.selected_data,
+            self.element.relative_maximum_charge_state.selected_data,
         )