flixopt 2.1.1__py3-none-any.whl → 2.2.0b0__py3-none-any.whl

flixopt/flow_system.py

@@ -16,10 +16,17 @@ from rich.console import Console
 from rich.pretty import Pretty
 
 from . import io as fx_io
-from .core import NumericData, NumericDataTS, TimeSeries, TimeSeriesCollection, TimeSeriesData
-from .effects import Effect, EffectCollection, EffectTimeSeries, EffectValuesDict, EffectValuesUser
+from .core import Scalar, ScenarioData, TimeSeries, TimeSeriesCollection, TimeSeriesData, TimestepData
+from .effects import (
+    Effect,
+    EffectCollection,
+    EffectTimeSeries,
+    EffectValuesDict,
+    EffectValuesUserScenario,
+    EffectValuesUserTimestep,
+)
 from .elements import Bus, Component, Flow
-from .structure import CLASS_REGISTRY, Element, SystemModel, get_compact_representation, get_str_representation
+from .structure import CLASS_REGISTRY, Element, SystemModel
 
 if TYPE_CHECKING:
     import pyvis
@@ -35,23 +42,31 @@ class FlowSystem:
     def __init__(
         self,
         timesteps: pd.DatetimeIndex,
+        scenarios: Optional[pd.Index] = None,
         hours_of_last_timestep: Optional[float] = None,
         hours_of_previous_timesteps: Optional[Union[int, float, np.ndarray]] = None,
+        scenario_weights: Optional[ScenarioData] = None,
     ):
         """
         Args:
             timesteps: The timesteps of the model.
+            scenarios: The scenarios of the model.
             hours_of_last_timestep: The duration of the last time step. Uses the last time interval if not specified
             hours_of_previous_timesteps: The duration of previous timesteps.
                 If None, the first time increment of time_series is used.
                 This is needed to calculate previous durations (for example consecutive_on_hours).
                 If you use an array, take care that its long enough to cover all previous values!
+            scenario_weights: The weights of the scenarios. If None, all scenarios have the same weight. All weights are normalized to 1.
         """
         self.time_series_collection = TimeSeriesCollection(
             timesteps=timesteps,
+            scenarios=scenarios,
             hours_of_last_timestep=hours_of_last_timestep,
             hours_of_previous_timesteps=hours_of_previous_timesteps,
         )
+        self.scenario_weights = self.create_time_series(
+            'scenario_weights', scenario_weights, has_time_dim=False, has_scenario_dim=True
+        )
 
         # defaults:
         self.components: Dict[str, Component] = {}
@@ -66,10 +81,15 @@ class FlowSystem:
         timesteps_extra = pd.DatetimeIndex(ds.attrs['timesteps_extra'], name='time')
         hours_of_last_timestep = TimeSeriesCollection.calculate_hours_per_timestep(timesteps_extra).isel(time=-1).item()
 
+        scenarios = pd.Index(ds.attrs['scenarios'], name='scenario') if ds.attrs.get('scenarios') is not None else None
+        scenario_weights = fx_io.insert_dataarray(ds.attrs['scenario_weights'], ds)
+
         flow_system = FlowSystem(
             timesteps=timesteps_extra[:-1],
             hours_of_last_timestep=hours_of_last_timestep,
             hours_of_previous_timesteps=ds.attrs['hours_of_previous_timesteps'],
+            scenarios=scenarios,
+            scenario_weights=scenario_weights,
         )
 
         structure = fx_io.insert_dataarray({key: ds.attrs[key] for key in ['components', 'buses', 'effects']}, ds)
@@ -90,11 +110,15 @@ class FlowSystem:
         """
         timesteps_extra = pd.DatetimeIndex(data['timesteps_extra'], name='time')
         hours_of_last_timestep = TimeSeriesCollection.calculate_hours_per_timestep(timesteps_extra).isel(time=-1).item()
+        scenarios = pd.Index(data['scenarios'], name='scenario') if data.get('scenarios') is not None else None
+        scenario_weights = data.get('scenario_weights').selected_data if data.get('scenario_weights') is not None else None
 
         flow_system = FlowSystem(
             timesteps=timesteps_extra[:-1],
             hours_of_last_timestep=hours_of_last_timestep,
             hours_of_previous_timesteps=data['hours_of_previous_timesteps'],
+            scenarios=scenarios,
+            scenario_weights=scenario_weights,
         )
 
         flow_system.add_elements(*[Bus.from_dict(bus) for bus in data['buses'].values()])
@@ -170,6 +194,8 @@ class FlowSystem:
             },
             'timesteps_extra': [date.isoformat() for date in self.time_series_collection.timesteps_extra],
             'hours_of_previous_timesteps': self.time_series_collection.hours_of_previous_timesteps,
+            'scenarios': self.time_series_collection.scenarios.tolist() if self.time_series_collection.scenarios is not None else None,
+            'scenario_weights': self.scenario_weights,
         }
         if data_mode == 'data':
             return fx_io.replace_timeseries(data, 'data')
@@ -184,7 +210,7 @@ class FlowSystem:
         Args:
             constants_in_dataset: If True, constants are included as Dataset variables.
         """
-        ds = self.time_series_collection.to_dataset(include_constants=constants_in_dataset)
+        ds = self.time_series_collection.as_dataset()
         ds.attrs = self.as_dict(data_mode='name')
         return ds
 
@@ -268,41 +294,80 @@ class FlowSystem:
     def transform_data(self):
         if not self._connected:
             self._connect_network()
+        self.scenario_weights = self.create_time_series(
+            'scenario_weights', self.scenario_weights, has_time_dim=False, has_scenario_dim=True
+        )
         for element in self.all_elements.values():
             element.transform_data(self)
 
     def create_time_series(
         self,
         name: str,
-        data: Optional[Union[NumericData, TimeSeriesData, TimeSeries]],
-        needs_extra_timestep: bool = False,
-    ) -> Optional[TimeSeries]:
+        data: Optional[Union[TimestepData, TimeSeriesData, TimeSeries]],
+        has_time_dim: bool = True,
+        has_scenario_dim: bool = True,
+        has_extra_timestep: bool = False,
+    ) -> Optional[Union[Scalar, TimeSeries]]:
         """
-        Tries to create a TimeSeries from NumericData Data and adds it to the time_series_collection
+        Tries to create a TimeSeries from TimestepData and adds it to the time_series_collection
         If the data already is a TimeSeries, nothing happens and the TimeSeries gets reset and returned
         If the data is a TimeSeriesData, it is converted to a TimeSeries, and the aggregation weights are applied.
         If the data is None, nothing happens.
+
+        Args:
+            name: The name of the TimeSeries
+            data: The data to create a TimeSeries from
+            has_time_dim: Whether the data has a time dimension
+            has_scenario_dim: Whether the data has a scenario dimension
+            has_extra_timestep: Whether the data has an extra timestep
         """
+        if not has_time_dim and not has_scenario_dim:
+            raise ValueError('At least one of the dimensions must be present')
 
         if data is None:
             return None
-        elif isinstance(data, TimeSeries):
+
+        if not has_time_dim and self.time_series_collection.scenarios is None:
+            return data
+
+        if isinstance(data, TimeSeries):
             data.restore_data()
             if data in self.time_series_collection:
                 return data
-            return self.time_series_collection.create_time_series(
-                data=data.active_data, name=name, needs_extra_timestep=needs_extra_timestep
+            return self.time_series_collection.add_time_series(
+                data=data.selected_data,
+                name=name,
+                has_time_dim=has_time_dim,
+                has_scenario_dim=has_scenario_dim,
+                has_extra_timestep=has_extra_timestep,
             )
-        return self.time_series_collection.create_time_series(
-            data=data, name=name, needs_extra_timestep=needs_extra_timestep
+        elif isinstance(data, TimeSeriesData):
+            data.label = name
+            return self.time_series_collection.add_time_series(
+                data=data.data,
+                name=name,
+                has_time_dim=has_time_dim,
+                has_scenario_dim=has_scenario_dim,
+                has_extra_timestep=has_extra_timestep,
+                aggregation_weight=data.agg_weight,
+                aggregation_group=data.agg_group,
+            )
+        return self.time_series_collection.add_time_series(
+            data=data,
+            name=name,
+            has_time_dim=has_time_dim,
+            has_scenario_dim=has_scenario_dim,
+            has_extra_timestep=has_extra_timestep,
         )
 
     def create_effect_time_series(
         self,
         label_prefix: Optional[str],
-        effect_values: EffectValuesUser,
+        effect_values: Union[EffectValuesUserScenario, EffectValuesUserTimestep],
         label_suffix: Optional[str] = None,
-    ) -> Optional[EffectTimeSeries]:
+        has_time_dim: bool = True,
+        has_scenario_dim: bool = True,
+    ) -> Optional[Union[EffectTimeSeries, EffectValuesDict]]:
         """
         Transform EffectValues to EffectTimeSeries.
         Creates a TimeSeries for each key in the nested_values dictionary, using the value as the data.
@@ -310,13 +375,31 @@ class FlowSystem:
         The resulting label of the TimeSeries is the label of the parent_element,
         followed by the label of the Effect in the nested_values and the label_suffix.
         If the key in the EffectValues is None, the alias 'Standard_Effect' is used
+
+        Args:
+            label_prefix: Prefix for the TimeSeries name
+            effect_values: Dictionary of EffectValues
+            label_suffix: Suffix for the TimeSeries name
+            has_time_dim: Whether the data has a time dimension
+            has_scenario_dim: Whether the data has a scenario dimension
         """
+        if not has_time_dim and not has_scenario_dim:
+            raise ValueError('At least one of the dimensions must be present')
+
         effect_values: Optional[EffectValuesDict] = self.effects.create_effect_values_dict(effect_values)
         if effect_values is None:
             return None
 
+        if not has_time_dim and self.time_series_collection.scenarios is None:
+            return effect_values
+
         return {
-            effect: self.create_time_series('|'.join(filter(None, [label_prefix, effect, label_suffix])), value)
+            effect: self.create_time_series(
+                name='|'.join(filter(None, [label_prefix, effect, label_suffix])),
+                data=value,
+                has_time_dim=has_time_dim,
+                has_scenario_dim=has_scenario_dim,
+            )
             for effect, value in effect_values.items()
         }
 

flixopt/interface.py

@@ -4,14 +4,14 @@ These are tightly connected to features.py
 """
 
 import logging
-from typing import TYPE_CHECKING, Dict, Iterator, List, Optional, Union
+from typing import TYPE_CHECKING, Dict, Iterator, List, Literal, Optional, Union
 
 from .config import CONFIG
-from .core import NumericData, NumericDataTS, Scalar
+from .core import NumericDataTS, Scalar, ScenarioData, TimestepData
 from .structure import Interface, register_class_for_io
 
 if TYPE_CHECKING:  # for type checking and preventing circular imports
-    from .effects import EffectValuesUser, EffectValuesUserScalar
+    from .effects import EffectValuesUserScenario, EffectValuesUserTimestep
     from .flow_system import FlowSystem
 
 
@@ -20,7 +20,7 @@ logger = logging.getLogger('flixopt')
 
 @register_class_for_io
 class Piece(Interface):
-    def __init__(self, start: NumericData, end: NumericData):
+    def __init__(self, start: TimestepData, end: TimestepData):
         """
         Define a Piece, which is part of a Piecewise object.
 
@@ -30,10 +30,15 @@ class Piece(Interface):
         """
         self.start = start
         self.end = end
+        self.has_time_dim = False
 
     def transform_data(self, flow_system: 'FlowSystem', name_prefix: str):
-        self.start = flow_system.create_time_series(f'{name_prefix}|start', self.start)
-        self.end = flow_system.create_time_series(f'{name_prefix}|end', self.end)
+        self.start = flow_system.create_time_series(
+            name=f'{name_prefix}|start', data=self.start, has_time_dim=self.has_time_dim, has_scenario_dim=True
+        )
+        self.end = flow_system.create_time_series(
+            name=f'{name_prefix}|end', data=self.end, has_time_dim=self.has_time_dim, has_scenario_dim=True
+        )
 
 
 @register_class_for_io
@@ -46,6 +51,17 @@ class Piecewise(Interface):
             pieces: The pieces of the piecewise.
         """
         self.pieces = pieces
+        self._has_time_dim = False
+
+    @property
+    def has_time_dim(self):
+        return self._has_time_dim
+
+    @has_time_dim.setter
+    def has_time_dim(self, value):
+        self._has_time_dim = value
+        for piece in self.pieces:
+            piece.has_time_dim = value
 
     def __len__(self):
         return len(self.pieces)
@@ -73,6 +89,18 @@ class PiecewiseConversion(Interface):
             piecewises: Dict of Piecewises defining the conversion factors. flow labels as keys, piecewise as values
         """
         self.piecewises = piecewises
+        self._has_time_dim = True
+        self.has_time_dim = True  # Inital propagation
+
+    @property
+    def has_time_dim(self):
+        return self._has_time_dim
+
+    @has_time_dim.setter
+    def has_time_dim(self, value):
+        self._has_time_dim = value
+        for piecewise in self.piecewises.values():
+            piecewise.has_time_dim = value
 
     def items(self):
         return self.piecewises.items()
@@ -94,12 +122,24 @@ class PiecewiseEffects(Interface):
         """
         self.piecewise_origin = piecewise_origin
         self.piecewise_shares = piecewise_shares
+        self._has_time_dim = False
+        self.has_time_dim = False  # Inital propagation
+
+    @property
+    def has_time_dim(self):
+        return self._has_time_dim
+
+    @has_time_dim.setter
+    def has_time_dim(self, value):
+        self._has_time_dim = value
+        self.piecewise_origin.has_time_dim = value
+        for piecewise in self.piecewise_shares.values():
+            piecewise.has_time_dim = value
 
     def transform_data(self, flow_system: 'FlowSystem', name_prefix: str):
-        raise NotImplementedError('PiecewiseEffects is not yet implemented for non scalar shares')
-        # self.piecewise_origin.transform_data(flow_system, f'{name_prefix}|PiecewiseEffects|origin')
-        # for name, piecewise in self.piecewise_shares.items():
-        #    piecewise.transform_data(flow_system, f'{name_prefix}|PiecewiseEffects|{name}')
+        self.piecewise_origin.transform_data(flow_system, f'{name_prefix}|PiecewiseEffects|origin')
+        for effect, piecewise in self.piecewise_shares.items():
+            piecewise.transform_data(flow_system, f'{name_prefix}|PiecewiseEffects|{effect}')
 
 
 @register_class_for_io
@@ -110,14 +150,15 @@ class InvestParameters(Interface):
 
     def __init__(
         self,
-        fixed_size: Optional[Union[int, float]] = None,
-        minimum_size: Optional[Union[int, float]] = None,
-        maximum_size: Optional[Union[int, float]] = None,
+        fixed_size: Optional[ScenarioData] = None,
+        minimum_size: Optional[ScenarioData] = None,
+        maximum_size: Optional[ScenarioData] = None,
         optional: bool = True,  # Investition ist weglassbar
-        fix_effects: Optional['EffectValuesUserScalar'] = None,
-        specific_effects: Optional['EffectValuesUserScalar'] = None,  # costs per Flow-Unit/Storage-Size/...
+        fix_effects: Optional['EffectValuesUserScenario'] = None,
+        specific_effects: Optional['EffectValuesUserScenario'] = None,  # costs per Flow-Unit/Storage-Size/...
         piecewise_effects: Optional[PiecewiseEffects] = None,
-        divest_effects: Optional['EffectValuesUserScalar'] = None,
+        divest_effects: Optional['EffectValuesUserScenario'] = None,
+        investment_scenarios: Optional[Union[Literal['individual'], List[Union[int, str]]]] = None,
     ):
         """
         Args:
@@ -128,58 +169,99 @@ class InvestParameters(Interface):
             specific_effects: Specific costs, e.g., in €/kW_nominal or €/m²_nominal.
                 Example: {costs: 3, CO2: 0.3} with costs and CO2 representing an Object of class Effect
                 (Attention: Annualize costs to chosen period!)
-            piecewise_effects: Linear piecewise relation [invest_pieces, cost_pieces].
-                Example 1:
-                    [           [5, 25, 25, 100],       # size in kW
-                     {costs:    [50,250,250,800],       # €
-                      PE:       [5, 25, 25, 100]        # kWh_PrimaryEnergy
-                      }
-                    ]
-                Example 2 (if only standard-effect):
-                    [   [5, 25, 25, 100],  # kW # size in kW
-                        [50,250,250,800]        # value for standart effect, typically €
-                     ]  # €
-                (Attention: Annualize costs to chosen period!)
-                (Args 'specific_effects' and 'fix_effects' can be used in parallel to Investsizepieces)
-            minimum_size: Min nominal value (only if: size_is_fixed = False). Defaults to CONFIG.modeling.EPSILON.
-            maximum_size: Max nominal value (only if: size_is_fixed = False). Defaults to CONFIG.modeling.BIG.
+            piecewise_effects: Define the effects of the investment as a piecewise function of the size of the investment.
+            minimum_size: Minimum possible size of the investment.
+            maximum_size: Maximum possible size of the investment.
+            investment_scenarios: For which scenarios to optimize the size for.
+                - 'individual': Optimize the size of each scenario individually
+                - List of scenario names: Optimize the size for the passed scenario names (equal size in all). All other scenarios will have the size 0.
+                - None: Equals to a list of all scenarios (default)
         """
-        self.fix_effects: EffectValuesUser = fix_effects or {}
-        self.divest_effects: EffectValuesUser = divest_effects or {}
+        self.fix_effects: EffectValuesUserScenario = fix_effects if fix_effects is not None else {}
+        self.divest_effects: EffectValuesUserScenario = divest_effects if divest_effects is not None else {}
         self.fixed_size = fixed_size
         self.optional = optional
-        self.specific_effects: EffectValuesUser = specific_effects or {}
+        self.specific_effects: EffectValuesUserScenario = specific_effects if specific_effects is not None else {}
         self.piecewise_effects = piecewise_effects
         self._minimum_size = minimum_size if minimum_size is not None else CONFIG.modeling.EPSILON
         self._maximum_size = maximum_size if maximum_size is not None else CONFIG.modeling.BIG  # default maximum
+        self.investment_scenarios = investment_scenarios
 
-    def transform_data(self, flow_system: 'FlowSystem'):
-        self.fix_effects = flow_system.effects.create_effect_values_dict(self.fix_effects)
-        self.divest_effects = flow_system.effects.create_effect_values_dict(self.divest_effects)
-        self.specific_effects = flow_system.effects.create_effect_values_dict(self.specific_effects)
+    def transform_data(self, flow_system: 'FlowSystem', name_prefix: str):
+        self._plausibility_checks(flow_system)
+        self.fix_effects = flow_system.create_effect_time_series(
+            label_prefix=name_prefix,
+            effect_values=self.fix_effects,
+            label_suffix='fix_effects',
+            has_time_dim=False,
+            has_scenario_dim=True,
+        )
+        self.divest_effects = flow_system.create_effect_time_series(
+            label_prefix=name_prefix,
+            effect_values=self.divest_effects,
+            label_suffix='divest_effects',
+            has_time_dim=False,
+            has_scenario_dim=True,
+        )
+        self.specific_effects = flow_system.create_effect_time_series(
+            label_prefix=name_prefix,
+            effect_values=self.specific_effects,
+            label_suffix='specific_effects',
+            has_time_dim=False,
+            has_scenario_dim=True,
+        )
+        if self.piecewise_effects is not None:
+            self.piecewise_effects.has_time_dim = False
+            self.piecewise_effects.transform_data(flow_system, f'{name_prefix}|PiecewiseEffects')
+
+        self._minimum_size = flow_system.create_time_series(
+            f'{name_prefix}|minimum_size', self.minimum_size, has_time_dim=False, has_scenario_dim=True
+        )
+        self._maximum_size = flow_system.create_time_series(
+            f'{name_prefix}|maximum_size', self.maximum_size, has_time_dim=False, has_scenario_dim=True
+        )
+        if self.fixed_size is not None:
+            self.fixed_size = flow_system.create_time_series(
+                f'{name_prefix}|fixed_size', self.fixed_size, has_time_dim=False, has_scenario_dim=True
+            )
+
+    def _plausibility_checks(self, flow_system):
+        if isinstance(self.investment_scenarios, list):
+            if not set(self.investment_scenarios).issubset(flow_system.time_series_collection.scenarios):
+                raise ValueError(
+                    f'Some scenarios in investment_scenarios are not present in the time_series_collection: '
+                    f'{set(self.investment_scenarios) - set(flow_system.time_series_collection.scenarios)}'
+                )
+        if self.investment_scenarios is not None:
+            if not self.optional:
+                if self.minimum_size is not None or self.fixed_size is not None:
+                    logger.warning(
+                        'When using investment_scenarios, minimum_size and fixed_size should only ne used if optional is True.'
+                        'Otherwise the investment cannot be 0 incertain scenarios while being non-zero in others.'
+                    )
 
     @property
     def minimum_size(self):
-        return self.fixed_size or self._minimum_size
+        return self.fixed_size if self.fixed_size is not None else self._minimum_size
 
     @property
     def maximum_size(self):
-        return self.fixed_size or self._maximum_size
+        return self.fixed_size if self.fixed_size is not None else self._maximum_size
 
 
 @register_class_for_io
 class OnOffParameters(Interface):
     def __init__(
         self,
-        effects_per_switch_on: Optional['EffectValuesUser'] = None,
-        effects_per_running_hour: Optional['EffectValuesUser'] = None,
-        on_hours_total_min: Optional[int] = None,
-        on_hours_total_max: Optional[int] = None,
-        consecutive_on_hours_min: Optional[NumericData] = None,
-        consecutive_on_hours_max: Optional[NumericData] = None,
-        consecutive_off_hours_min: Optional[NumericData] = None,
-        consecutive_off_hours_max: Optional[NumericData] = None,
-        switch_on_total_max: Optional[int] = None,
+        effects_per_switch_on: Optional['EffectValuesUserTimestep'] = None,
+        effects_per_running_hour: Optional['EffectValuesUserTimestep'] = None,
+        on_hours_total_min: Optional[ScenarioData] = None,
+        on_hours_total_max: Optional[ScenarioData] = None,
+        consecutive_on_hours_min: Optional[TimestepData] = None,
+        consecutive_on_hours_max: Optional[TimestepData] = None,
+        consecutive_off_hours_min: Optional[TimestepData] = None,
+        consecutive_off_hours_max: Optional[TimestepData] = None,
+        switch_on_total_max: Optional[ScenarioData] = None,
         force_switch_on: bool = False,
     ):
         """
@@ -202,8 +284,8 @@ class OnOffParameters(Interface):
             switch_on_total_max: max nr of switchOn operations
             force_switch_on: force creation of switch on variable, even if there is no switch_on_total_max
         """
-        self.effects_per_switch_on: EffectValuesUser = effects_per_switch_on or {}
-        self.effects_per_running_hour: EffectValuesUser = effects_per_running_hour or {}
+        self.effects_per_switch_on: EffectValuesUserTimestep = effects_per_switch_on or {}
+        self.effects_per_running_hour: EffectValuesUserTimestep = effects_per_running_hour or {}
         self.on_hours_total_min: Scalar = on_hours_total_min
         self.on_hours_total_max: Scalar = on_hours_total_max
         self.consecutive_on_hours_min: NumericDataTS = consecutive_on_hours_min
@@ -232,6 +314,15 @@ class OnOffParameters(Interface):
         self.consecutive_off_hours_max = flow_system.create_time_series(
             f'{name_prefix}|consecutive_off_hours_max', self.consecutive_off_hours_max
         )
+        self.on_hours_total_max = flow_system.create_time_series(
+            f'{name_prefix}|on_hours_total_max', self.on_hours_total_max, has_time_dim=False
+        )
+        self.on_hours_total_min = flow_system.create_time_series(
+            f'{name_prefix}|on_hours_total_min', self.on_hours_total_min, has_time_dim=False
+        )
+        self.switch_on_total_max = flow_system.create_time_series(
+            f'{name_prefix}|switch_on_total_max', self.switch_on_total_max, has_time_dim=False
+        )
 
     @property
     def use_off(self) -> bool:

flixopt/io.py

@@ -23,7 +23,7 @@ def replace_timeseries(obj, mode: Literal['name', 'stats', 'data'] = 'name'):
         return [replace_timeseries(v, mode) for v in obj]
     elif isinstance(obj, TimeSeries):  # Adjust this based on the actual class
         if obj.all_equal:
-            return obj.active_data.values[0].item()
+            return obj.selected_data.values.max().item()
         elif mode == 'name':
             return f'::::{obj.name}'
         elif mode == 'stats':
@@ -44,7 +44,7 @@ def insert_dataarray(obj, ds: xr.Dataset):
         return [insert_dataarray(v, ds) for v in obj]
     elif isinstance(obj, str) and obj.startswith('::::'):
         da = ds[obj[4:]]
-        if da.isel(time=-1).isnull():
+        if 'time' in da.dims and da.isel(time=-1).isnull().any().item():
             return da.isel(time=slice(0, -1))
         return da
     else:
@@ -79,15 +79,17 @@ def _save_to_yaml(data, output_file='formatted_output.yaml'):
         output_file (str): Path to output YAML file
     """
     # Process strings to normalize all newlines and handle special patterns
-    processed_data = _process_complex_strings(data)
+    processed_data = _normalize_complex_data(data)
 
     # Define a custom representer for strings
     def represent_str(dumper, data):
-        # Use literal block style (|) for any string with newlines
+        # Use literal block style (|) for multi-line strings
         if '\n' in data:
+            # Clean up formatting for literal block style
+            data = data.strip()  # Remove leading/trailing whitespace
             return dumper.represent_scalar('tag:yaml.org,2002:str', data, style='|')
 
-        # Use quoted style for strings with special characters to ensure proper parsing
+        # Use quoted style for strings with special characters
         elif any(char in data for char in ':`{}[]#,&*!|>%@'):
             return dumper.represent_scalar('tag:yaml.org,2002:str', data, style='"')
 
@@ -97,53 +99,80 @@ def _save_to_yaml(data, output_file='formatted_output.yaml'):
     # Add the string representer to SafeDumper
     yaml.add_representer(str, represent_str, Dumper=yaml.SafeDumper)
 
+    # Configure dumper options for better formatting
+    class CustomDumper(yaml.SafeDumper):
+        def increase_indent(self, flow=False, indentless=False):
+            return super(CustomDumper, self).increase_indent(flow, False)
+
     # Write to file with settings that ensure proper formatting
     with open(output_file, 'w', encoding='utf-8') as file:
         yaml.dump(
             processed_data,
             file,
-            Dumper=yaml.SafeDumper,
+            Dumper=CustomDumper,
             sort_keys=False,  # Preserve dictionary order
             default_flow_style=False,  # Use block style for mappings
-            width=float('inf'),  # Don't wrap long lines
+            width=1000,  # Set a reasonable line width
             allow_unicode=True,  # Support Unicode characters
+            indent=2,  # Set consistent indentation
         )
 
 
-def _process_complex_strings(data):
+def _normalize_complex_data(data):
     """
-    Process dictionary data recursively with comprehensive string normalization.
-    Handles various types of strings and special formatting.
+    Recursively normalize strings in complex data structures.
+
+    Handles dictionaries, lists, and strings, applying various text normalization
+    rules while preserving important formatting elements.
 
     Args:
-        data: The data to process (dict, list, str, or other)
+        data: Any data type (dict, list, str, or primitive)
 
     Returns:
-        Processed data with normalized strings
+        Data with all strings normalized according to defined rules
     """
     if isinstance(data, dict):
-        return {k: _process_complex_strings(v) for k, v in data.items()}
+        return {key: _normalize_complex_data(value) for key, value in data.items()}
+
     elif isinstance(data, list):
-        return [_process_complex_strings(item) for item in data]
+        return [_normalize_complex_data(item) for item in data]
+
     elif isinstance(data, str):
-        # Step 1: Normalize line endings to \n
-        normalized = data.replace('\r\n', '\n').replace('\r', '\n')
+        return _normalize_string_content(data)
 
-        # Step 2: Handle escaped newlines with robust regex
-        normalized = re.sub(r'(?<!\\)\\n', '\n', normalized)
+    else:
+        return data
 
-        # Step 3: Handle unnecessary double backslashes
-        normalized = re.sub(r'\\\\(n)', r'\\\1', normalized)
 
-        # Step 4: Ensure proper formatting of "[time: N]:\n---------"
-        normalized = re.sub(r'(\[time: \d+\]):\s*\\?n', r'\1:\n', normalized)
+def _normalize_string_content(text):
+    """
+    Apply comprehensive string normalization rules.
 
-        # Step 5: Ensure "Constraint `...`" patterns are properly formatted
-        normalized = re.sub(r'Constraint `([^`]+)`\\?n', r'Constraint `\1`\n', normalized)
+    Args:
+        text: The string to normalize
 
-        return normalized
-    else:
-        return data
+    Returns:
+        Normalized string with standardized formatting
+    """
+    # Standardize line endings
+    text = text.replace('\r\n', '\n').replace('\r', '\n')
+
+    # Convert escaped newlines to actual newlines (avoiding double-backslashes)
+    text = re.sub(r'(?<!\\)\\n', '\n', text)
+
+    # Normalize double backslashes before specific escape sequences
+    text = re.sub(r'\\\\([rtn])', r'\\\1', text)
+
+    # Standardize constraint headers format
+    text = re.sub(r'Constraint\s*`([^`]+)`\s*(?:\\n|[\s\n]*)', r'Constraint `\1`\n', text)
+
+    # Clean up ellipsis patterns
+    text = re.sub(r'[\t ]*(\.\.\.)', r'\1', text)
+
+    # Limit consecutive newlines (max 2)
+    text = re.sub(r'\n{3,}', '\n\n', text)
+
+    return text.strip()
 
 
 def document_linopy_model(model: linopy.Model, path: pathlib.Path = None) -> Dict[str, str]: