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

docs/examples/00-Minimal Example.md

@@ -2,4 +2,4 @@
 
 ```python
 {! ../examples/00_Minmal/minimal_example.py !}
-```
+```

docs/examples/01-Basic Example.md

@@ -2,4 +2,4 @@
 
 ```python
 {! ../examples/01_Simple/simple_example.py !}
-```
+```

docs/examples/02-Complex Example.md

@@ -7,4 +7,4 @@ This saves the results of a calculation to file and reloads them to analyze the
 ## Load the Results from file
 ```python
 {! ../examples/02_Complex/complex_example_results.py !}
-```
+```

docs/examples/index.md

@@ -2,4 +2,4 @@
 
 Here you can find a collection of examples that demonstrate how to use FlixOpt.
 
-We work on improving this gallery. If you have something to share, please contact us!
+We work on improving this gallery. If you have something to share, please contact us!

docs/faq/contribute.md

@@ -4,17 +4,29 @@ We warmly welcome contributions from the community! This guide will help you get
 
 ## Development Setup
 1. Clone the repository `git clone https://github.com/flixOpt/flixopt.git`
-2. Install the development dependencies `pip install -editable .[dev, docs]`
-3. Run `pytest` and `ruff check .` to ensure your code passes all tests
-
-## Documentation
-FlixOpt uses [mkdocs](https://www.mkdocs.org/) to generate documentation. To preview the documentation locally, run `mkdocs serve` in the root directory.
-
-## Helpful Commands
-- `mkdocs serve` to preview the documentation locally. Navigate to `http://127.0.0.1:8000/` to view the documentation.
-- `pytest` to run the test suite (You can also run the provided python script `run_all_test.py`)
-- `ruff check .` to run the linter
-- `ruff check . --fix` to automatically fix linting issues
+2. Install the development dependencies `pip install -e ".[dev]"`
+3. Install pre-commit hooks `pre-commit install` (one-time setup)
+4. Run `pytest` to ensure your code passes all tests
+
+## Code Quality
+We use [Ruff](https://github.com/astral-sh/ruff) for linting and formatting. After the one-time setup above, **code quality checks run automatically on every commit**.
+
+To run manually:
+- `ruff check --fix .` to check and fix linting issues
+- `ruff format .` to format code
+
+## Documentation (Optional)
+FlixOpt uses [mkdocs](https://www.mkdocs.org/) to generate documentation.
+To work on documentation:
+```bash
+pip install -e ".[docs]"
+mkdocs serve
+```
+Then navigate to http://127.0.0.1:8000/
+
+## Testing
+- `pytest` to run the test suite
+- You can also run the provided python script `run_all_test.py`
 
 ---
 # Best practices
@@ -30,8 +42,8 @@ FlixOpt uses [mkdocs](https://www.mkdocs.org/) to generate documentation. To pre
 ## Branches
 As we start to think FlixOpt in **Releases**, we decided to introduce multiple **dev**-branches instead of only one:
 Following the **Semantic Versioning** guidelines, we introduced:
-- `next/patch`: This is where all pull requests for the next patch release (1.0.x) go.  
-- `next/minor`: This is where all pull requests for the next minor release (1.x.0) go.  
+- `next/patch`: This is where all pull requests for the next patch release (1.0.x) go.
+- `next/minor`: This is where all pull requests for the next minor release (1.x.0) go.
 - `next/major`: This is where all pull requests for the next major release (x.0.0) go.
 
 Everything else remains in `feature/...`-branches.
@@ -44,6 +56,6 @@ At some point, `next/minor` or `next/major` will get merged into `main` using a
 ## Releases
 As stated, we follow **Semantic Versioning**.
 Right after one of the 3 [release branches](#branches) is merged into main, a **Tag** should be added to the merge commit and pushed to the main branch. The tag has the form `v1.2.3`.
-With this tag,  a release with **Release Notes** must be created. 
+With this tag,  a release with **Release Notes** must be created.
 
 *This is our current best practice*

docs/faq/index.md

@@ -1,3 +1,3 @@
 # Frequently Asked Questions
 
-## Work in progress
+## Work in progress

docs/javascripts/mathjax.js

@@ -15,4 +15,4 @@ document$.subscribe(() => {
   MathJax.typesetClear()
   MathJax.texReset()
   MathJax.typesetPromise()
-})
+})

docs/user-guide/Mathematical Notation/Bus.md

@@ -30,4 +30,4 @@ With:
 - $\phi_\text{in}(\text{t}_i)$ and $\phi_\text{out}(\text{t}_i)$ being the missing or excess flow-rate at time $\text{t}_i$, respectively
 - $\text{t}_i$ being the time step
 - $s_{b \rightarrow \Phi}(\text{t}_i)$ being the penalty term
-- $\text a_{b \rightarrow \Phi}(\text{t}_i)$ being the penalty coefficient (`excess_penalty_per_flow_hour`)
+- $\text a_{b \rightarrow \Phi}(\text{t}_i)$ being the penalty coefficient (`excess_penalty_per_flow_hour`)

docs/user-guide/Mathematical Notation/Effects, Penalty & Objective.md

@@ -8,17 +8,17 @@ These arise from so called **Shares**, which originate from **Elements** like [F
 Assiziated effects could be:
 - costs - given in [€/kWh]...
 - ...or emissions - given in [kg/kWh].
-- 
+-
 Effects are allocated seperatly for investments and operation.
 
 ### Shares to Effects
 
 $$ \label{eq:Share_invest}
-s_{l \rightarrow e, \text{inv}} = \sum_{v \in \mathcal{V}_{l, \text{inv}}} v \cdot \text a_{v \rightarrow e} 
+s_{l \rightarrow e, \text{inv}} = \sum_{v \in \mathcal{V}_{l, \text{inv}}} v \cdot \text a_{v \rightarrow e}
 $$
 
 $$ \label{eq:Share_operation}
-s_{l \rightarrow e, \text{op}}(\text{t}_i) = \sum_{v \in \mathcal{V}_{l,\text{op}}} v(\text{t}_i) \cdot \text a_{v \rightarrow e}(\text{t}_i)           
+s_{l \rightarrow e, \text{op}}(\text{t}_i) = \sum_{v \in \mathcal{V}_{l,\text{op}}} v(\text{t}_i) \cdot \text a_{v \rightarrow e}(\text{t}_i)
 $$
 
 With:
@@ -36,26 +36,26 @@ With:
 
 ### Shares between different Effects
 
-Furthermore, the Effect $x$ can contribute a share to another Effect ${e} \in \mathcal{E}\backslash x$. 
-This share is defined by the factor $\text r_{x \rightarrow e}$. 
+Furthermore, the Effect $x$ can contribute a share to another Effect ${e} \in \mathcal{E}\backslash x$.
+This share is defined by the factor $\text r_{x \rightarrow e}$.
 
-For example, the Effect "CO$_2$ emissions" (unit: kg) 
-can cause an additional share to Effect "monetary costs" (unit: €). 
+For example, the Effect "CO$_2$ emissions" (unit: kg)
+can cause an additional share to Effect "monetary costs" (unit: €).
 In this case, the factor $\text a_{x \rightarrow e}$ is the specific CO$_2$ price in €/kg. However, circular references have to be avoided.
 
 The overall sum of investment shares of an Effect $e$ is given by $\eqref{Effect_invest}$
 
 $$ \label{eq:Effect_invest}
-E_{e, \text{inv}} = 
-\sum_{l \in \mathcal{L}} s_{l \rightarrow e,\text{inv}} + 
+E_{e, \text{inv}} =
+\sum_{l \in \mathcal{L}} s_{l \rightarrow e,\text{inv}} +
 \sum_{x \in \mathcal{E}\backslash e} E_{x, \text{inv}}  \cdot \text{r}_{x \rightarrow  e,\text{inv}}
 $$
 
 The overall sum of operation shares is given by $\eqref{eq:Effect_Operation}$
 
 $$ \label{eq:Effect_Operation}
-E_{e, \text{op}}(\text{t}_{i}) = 
-\sum_{l \in \mathcal{L}} s_{l \rightarrow e, \text{op}}(\text{t}_i) + 
+E_{e, \text{op}}(\text{t}_{i}) =
+\sum_{l \in \mathcal{L}} s_{l \rightarrow e, \text{op}}(\text{t}_i) +
 \sum_{x \in \mathcal{E}\backslash e} E_{x, \text{op}}(\text{t}_i) \cdot \text{r}_{x \rightarrow {e},\text{op}}(\text{t}_i)
 $$
 
@@ -100,7 +100,7 @@ $$
 
 Additionally to the user defined [Effects](#effects), a Penalty $\Phi$ is part of every FlixOpt Model.
 Its used to prevent unsolvable problems and simplify troubleshooting.
-Shares to the penalty can originate from every Element and are constructed similarly to 
+Shares to the penalty can originate from every Element and are constructed similarly to
 $\eqref{Share_invest}$ and  $\eqref{Share_operation}$.
 
 $$ \label{eq:Penalty}
@@ -129,4 +129,4 @@ With:
 
 This approach allows for a multi-criteria optimization using both...
  - ... the **Weigted Sum**Method, as the chosen **Objective Effect** can incorporate other Effects.
- - ... the ($\epsilon$-constraint method) by constraining effects.
+ - ... the ($\epsilon$-constraint method) by constraining effects.

docs/user-guide/Mathematical Notation/Flow.md

@@ -23,4 +23,4 @@ $$
 
 This mathematical Formulation can be extended or changed when using [OnOffParameters](#onoffparameters)
 to define the On/Off state of the Flow, or [InvestParameters](#investments),
-which changes the size of the Flow from a constant to an optimization variable.
+which changes the size of the Flow from a constant to an optimization variable.

docs/user-guide/Mathematical Notation/LinearConverter.md

@@ -10,7 +10,7 @@ With:
 - $p_{f_\text{in}}(\text{t}_i)$ and $p_{f_\text{out}}(\text{t}_i)$ being the flow-rate at time $\text{t}_i$ for flow $f_\text{in}$ and $f_\text{out}$, respectively
 - $\text a_{f_\text{in}}(\text{t}_i)$ and $\text b_{f_\text{out}}(\text{t}_i)$ being the ratio of the flow-rate at time $\text{t}_i$ for flow $f_\text{in}$ and $f_\text{out}$, respectively
 
-With one incoming **Flow** and one outgoing **Flow**, this can be simplified to: 
+With one incoming **Flow** and one outgoing **Flow**, this can be simplified to:
 
 $$ \label{eq:Linear-Transformer-Ratio-simple}
     \text a(\text{t}_i) \cdot p_{f_\text{in}}(\text{t}_i) = p_{f_\text{out}}(\text{t}_i)
@@ -18,4 +18,4 @@ $$
 
 where $\text a$ can be interpreted as the conversion efficiency of the **LinearTransformer**.
 #### Piecewise Concersion factors
-The conversion efficiency can be defined as a piecewise linear approximation. See [Piecewise](Piecewise.md) for more details.
+The conversion efficiency can be defined as a piecewise linear approximation. See [Piecewise](Piecewise.md) for more details.

docs/user-guide/Mathematical Notation/Piecewise.md

@@ -40,7 +40,7 @@ Which can also be described as $v \in \{0\} \cup [\text{v}_{\text{start_k}}, \te
 
 ## Combining multiple Piecewises
 
-Piecewise allows representing non-linear relationships. 
+Piecewise allows representing non-linear relationships.
 This is a powerful technique in linear optimization to model non-linear behaviors while maintaining the problem's linearity.
 
 Therefore, each Piecewise must have the same number of Pieces $k$.

docs/user-guide/Mathematical Notation/Storage.md

@@ -41,4 +41,4 @@ Where:
 - $p_{f_\text{in}}(\text{t}_i)$ is the input flow rate at time $\text{t}_i$
 - $\eta_\text{in}(\text{t}_i)$ is the charging efficiency at time $\text{t}_i$
 - $p_{f_\text{out}}(\text{t}_i)$ is the output flow rate at time $\text{t}_i$
-- $\eta_\text{out}(\text{t}_i)$ is the discharging efficiency at time $\text{t}_i$
+- $\eta_\text{out}(\text{t}_i)$ is the discharging efficiency at time $\text{t}_i$

docs/user-guide/Mathematical Notation/index.md

@@ -14,7 +14,7 @@ FlixOpt uses the following naming conventions:
 
 ## Timesteps
 Time steps are defined as a sequence of discrete time steps $\text{t}_i \in \mathcal{T} \quad \text{for} \quad i \in \{1, 2, \dots, \text{n}\}$ (left-aligned in its timespan).
-From this sequence, the corresponding time intervals $\Delta \text{t}_i \in \Delta \mathcal{T}$ are derived as 
+From this sequence, the corresponding time intervals $\Delta \text{t}_i \in \Delta \mathcal{T}$ are derived as
 
 $$\Delta \text{t}_i = \text{t}_{i+1} - \text{t}_i \quad \text{for} \quad i \in \{1, 2, \dots, \text{n}-1\}$$
 

docs/user-guide/Mathematical Notation/others.md

@@ -1,3 +1,3 @@
 # Work in Progress
 
-This is a work in progress.
+This is a work in progress.

docs/user-guide/index.md

@@ -6,7 +6,7 @@ FlixOpt is built around a set of core concepts that work together to represent a
 
 ### FlowSystem
 
-The [`FlowSystem`][flixopt.flow_system.FlowSystem] is the central organizing unit in FlixOpt. 
+The [`FlowSystem`][flixopt.flow_system.FlowSystem] is the central organizing unit in FlixOpt.
 Every FlixOpt model starts with creating a FlowSystem. It:
 
 - Defines the timesteps for the optimization
@@ -40,7 +40,7 @@ Examples:
 [`Bus`][flixopt.elements.Bus] objects represent nodes or connection points in a FlowSystem. They:
 
 - Balance incoming and outgoing flows
-- Can represent physical networks like heat, electricity, or gas 
+- Can represent physical networks like heat, electricity, or gas
 - Handle infeasible balances gently by allowing the balance to be closed in return for a big Penalty (optional)
 
 ### Components

flixopt/__init__.py

@@ -2,6 +2,10 @@
 This module bundles all common functionality of flixopt and sets up the logging
 """
 
+from importlib.metadata import version
+
+__version__ = version('flixopt')
+
 from .commons import (
     CONFIG,
     AggregatedCalculation,
@@ -18,6 +22,7 @@ from .commons import (
     Piecewise,
     PiecewiseConversion,
     PiecewiseEffects,
+    PiecewiseEffectsPerFlowHour,
     SegmentedCalculation,
     Sink,
     Source,

flixopt/aggregation.py

@@ -34,7 +34,6 @@ from .structure import (
 if TYPE_CHECKING:
     import plotly.graph_objects as go
 
-warnings.filterwarnings('ignore', category=DeprecationWarning)
 logger = logging.getLogger('flixopt')
 
 

flixopt/calculation.py

@@ -12,7 +12,6 @@ import logging
 import math
 import pathlib
 import timeit
-import warnings
 from typing import Any, Dict, List, Optional, Union
 
 import numpy as np
@@ -44,92 +43,74 @@ class Calculation:
         self,
         name: str,
         flow_system: FlowSystem,
-        selected_timesteps: Optional[pd.DatetimeIndex] = None,
-        selected_scenarios: Optional[pd.Index] = None,
-        folder: Optional[pathlib.Path] = None,
         active_timesteps: Optional[pd.DatetimeIndex] = None,
+        folder: Optional[pathlib.Path] = None,
     ):
         """
         Args:
             name: name of calculation
             flow_system: flow_system which should be calculated
-            selected_timesteps: timesteps which should be used for calculation. If None, then all timesteps are used.
-            selected_scenarios: scenarios which should be used for calculation. If None, then all scenarios are used.
+            active_timesteps: 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.
-            active_timesteps: Deprecated. Use selected_timesteps instead.
         """
-        if active_timesteps is not None:
-            warnings.warn(
-                'active_timesteps is deprecated. Use selected_timesteps instead.',
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            selected_timesteps = active_timesteps
         self.name = name
         self.flow_system = flow_system
         self.model: Optional[SystemModel] = None
-        self.selected_timesteps = selected_timesteps
-        self.selected_scenarios = selected_scenarios
+        self.active_timesteps = active_timesteps
 
         self.durations = {'modeling': 0.0, 'solving': 0.0, 'saving': 0.0}
         self.folder = pathlib.Path.cwd() / 'results' if folder is None else pathlib.Path(folder)
         self.results: Optional[CalculationResults] = None
 
-        if not self.folder.exists():
-            try:
-                self.folder.mkdir(parents=False)
-            except FileNotFoundError as e:
-                raise FileNotFoundError(
-                    f'Folder {self.folder} and its parent do not exist. Please create them first.'
-                ) from e
+        if self.folder.exists() and not self.folder.is_dir():
+            raise NotADirectoryError(f'Path {self.folder} exists and is not a directory.')
+        self.folder.mkdir(parents=False, exist_ok=True)
 
     @property
     def main_results(self) -> Dict[str, Union[Scalar, Dict]]:
         from flixopt.features import InvestmentModel
 
-        main_results = {
+        return {
             'Objective': self.model.objective.value,
-            'Penalty': self.model.effects.penalty.total.solution.values,
+            'Penalty': float(self.model.effects.penalty.total.solution.values),
             'Effects': {
                 f'{effect.label} [{effect.unit}]': {
-                    'operation': effect.model.operation.total.solution.values,
-                    'invest': effect.model.invest.total.solution.values,
-                    'total': effect.model.total.solution.values,
+                    'operation': float(effect.model.operation.total.solution.values),
+                    'invest': float(effect.model.invest.total.solution.values),
+                    'total': float(effect.model.total.solution.values),
                 }
                 for effect in self.flow_system.effects
             },
             'Invest-Decisions': {
                 'Invested': {
-                    model.label_of_element: model.size.solution
+                    model.label_of_element: float(model.size.solution)
                     for component in self.flow_system.components.values()
                     for model in component.model.all_sub_models
-                    if isinstance(model, InvestmentModel) and model.size.solution.max() >= CONFIG.modeling.EPSILON
+                    if isinstance(model, InvestmentModel) and float(model.size.solution) >= CONFIG.modeling.EPSILON
                 },
                 'Not invested': {
-                    model.label_of_element: model.size.solution
+                    model.label_of_element: float(model.size.solution)
                     for component in self.flow_system.components.values()
                     for model in component.model.all_sub_models
-                    if isinstance(model, InvestmentModel) and model.size.solution.max() < CONFIG.modeling.EPSILON
+                    if isinstance(model, InvestmentModel) and float(model.size.solution) < CONFIG.modeling.EPSILON
                 },
             },
             'Buses with excess': [
                 {
                     bus.label_full: {
-                        'input': bus.model.excess_input.solution.sum('time'),
-                        'output': bus.model.excess_output.solution.sum('time'),
+                        'input': float(np.sum(bus.model.excess_input.solution.values)),
+                        'output': float(np.sum(bus.model.excess_output.solution.values)),
                     }
                 }
                 for bus in self.flow_system.buses.values()
                 if bus.with_excess
                 and (
-                    bus.model.excess_input.solution.sum() > 1e-3
-                    or bus.model.excess_output.solution.sum() > 1e-3
+                    float(np.sum(bus.model.excess_input.solution.values)) > 1e-3
+                    or float(np.sum(bus.model.excess_output.solution.values)) > 1e-3
                 )
             ],
         }
 
-        return utils.round_floats(main_results)
-
     @property
     def summary(self):
         return {
@@ -143,15 +124,6 @@ class Calculation:
             'Config': CONFIG.to_dict(),
         }
 
-    @property
-    def active_timesteps(self) -> pd.DatetimeIndex:
-        warnings.warn(
-            'active_timesteps is deprecated. Use selected_timesteps instead.',
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return self.selected_timesteps
-
 
 class FullCalculation(Calculation):
     """
@@ -207,8 +179,8 @@ class FullCalculation(Calculation):
 
     def _activate_time_series(self):
         self.flow_system.transform_data()
-        self.flow_system.time_series_collection.set_selection(
-            timesteps=self.selected_timesteps, scenarios=self.selected_scenarios
+        self.flow_system.time_series_collection.activate_timesteps(
+            active_timesteps=self.active_timesteps,
         )
 
 
@@ -223,7 +195,7 @@ class AggregatedCalculation(FullCalculation):
         flow_system: FlowSystem,
         aggregation_parameters: AggregationParameters,
         components_to_clusterize: Optional[List[Component]] = None,
-        selected_timesteps: Optional[pd.DatetimeIndex] = None,
+        active_timesteps: Optional[pd.DatetimeIndex] = None,
         folder: Optional[pathlib.Path] = None,
     ):
         """
@@ -237,13 +209,11 @@ class AggregatedCalculation(FullCalculation):
             components_to_clusterize: List of Components to perform aggregation on. If None, then all components are aggregated.
                 This means, teh variables in the components are equalized to each other, according to the typical periods
                 computed in the DataAggregation
-            selected_timesteps: pd.DatetimeIndex or None
+            active_timesteps: pd.DatetimeIndex or None
                 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, selected_timesteps, folder=folder)
+        super().__init__(name, flow_system, active_timesteps, folder=folder)
         self.aggregation_parameters = aggregation_parameters
         self.components_to_clusterize = components_to_clusterize
         self.aggregation = None
@@ -298,9 +268,9 @@ class AggregatedCalculation(FullCalculation):
 
         # Aggregation - creation of aggregated timeseries:
         self.aggregation = Aggregation(
-            original_data=self.flow_system.time_series_collection.as_dataset(
-                with_extra_timestep=False, with_constants=False
-            ).to_dataframe(),
+            original_data=self.flow_system.time_series_collection.to_dataframe(
+                include_extra_timestep=False
+            ),  # Exclude last row (NaN)
             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,
@@ -312,11 +282,9 @@ class AggregatedCalculation(FullCalculation):
         self.aggregation.cluster()
         self.aggregation.plot(show=True, save=self.folder / 'aggregation.html')
         if self.aggregation_parameters.aggregate_data_and_fix_non_binary_vars:
-            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.flow_system.time_series_collection.insert_new_data(
+                self.aggregation.aggregated_data, include_extra_timestep=False
+            )
         self.durations['aggregation'] = round(timeit.default_timer() - t_start_agg, 2)
 
 
@@ -355,13 +323,13 @@ class SegmentedCalculation(Calculation):
         self.nr_of_previous_values = nr_of_previous_values
         self.sub_calculations: List[FullCalculation] = []
 
-        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.all_timesteps = self.flow_system.time_series_collection.all_timesteps
+        self.all_timesteps_extra = self.flow_system.time_series_collection.all_timesteps_extra
 
         self.segment_names = [
             f'Segment_{i + 1}' for i in range(math.ceil(len(self.all_timesteps) / self.timesteps_per_segment))
         ]
-        self.selected_timesteps_per_segment = self._calculate_timesteps_of_segment()
+        self.active_timesteps_per_segment = self._calculate_timesteps_of_segment()
 
         assert timesteps_per_segment > 2, 'The Segment length must be greater 2, due to unwanted internal side effects'
         assert self.timesteps_per_segment_with_overlap <= len(self.all_timesteps), (
@@ -387,7 +355,7 @@ class SegmentedCalculation(Calculation):
         logger.info(f'{" Segmented Solving ":#^80}')
 
         for i, (segment_name, timesteps_of_segment) in enumerate(
-            zip(self.segment_names, self.selected_timesteps_per_segment, strict=False)
+            zip(self.segment_names, self.active_timesteps_per_segment, strict=False)
         ):
             if self.sub_calculations:
                 self._transfer_start_values(i)
@@ -398,7 +366,7 @@ class SegmentedCalculation(Calculation):
             )
 
             calculation = FullCalculation(
-                f'{self.name}-{segment_name}', self.flow_system, selected_timesteps=timesteps_of_segment
+                f'{self.name}-{segment_name}', self.flow_system, active_timesteps=timesteps_of_segment
             )
             self.sub_calculations.append(calculation)
             calculation.do_modeling()
@@ -432,9 +400,9 @@ class SegmentedCalculation(Calculation):
         This function gets the last values of the previous solved segment and
         inserts them as start values for the next segment
         """
-        timesteps_of_prior_segment = self.selected_timesteps_per_segment[segment_index - 1]
+        timesteps_of_prior_segment = self.active_timesteps_per_segment[segment_index - 1]
 
-        start = self.selected_timesteps_per_segment[segment_index][0]
+        start = self.active_timesteps_per_segment[segment_index][0]
         start_previous_values = timesteps_of_prior_segment[self.timesteps_per_segment - self.nr_of_previous_values]
         end_previous_values = timesteps_of_prior_segment[self.timesteps_per_segment - 1]
 
@@ -463,12 +431,12 @@ class SegmentedCalculation(Calculation):
                 comp.initial_charge_state = self._original_start_values[comp.label_full]
 
     def _calculate_timesteps_of_segment(self) -> List[pd.DatetimeIndex]:
-        selected_timesteps_per_segment = []
+        active_timesteps_per_segment = []
         for i, _ in enumerate(self.segment_names):
             start = self.timesteps_per_segment * i
             end = min(start + self.timesteps_per_segment_with_overlap, len(self.all_timesteps))
-            selected_timesteps_per_segment.append(self.all_timesteps[start:end])
-        return selected_timesteps_per_segment
+            active_timesteps_per_segment.append(self.all_timesteps[start:end])
+        return active_timesteps_per_segment
 
     @property
     def timesteps_per_segment_with_overlap(self):

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',
 ]