Feature/v3/update

[FBumann]

Description

Several updates with clear separation to changes from InvestParameters

• Update Interface.transform_data() to take a name_prefix parameter
• Added docstring for Storage.relative_minimum_final_charge_stateand Storage.relative_maximum_final_charge_state parameters
• Changed Datatype from Scalar to NonTemporalDataUser in NonTemporalEffectsUser
• added FlowSystem .years_of_last_year parameter to construct FlowSystem years_per_year attribute
• change has_time_dim parameters infit_to_model_coords() to specify needed dims directly
• make modeling.consecutive_duration_tracking() dimension agnostic
• add new modeling.continuous_transition_bounds() method
• add new modeling.link_changes_to_level_with_binaries() method
• change computation pf FlowSystem.weights to use new years_per_year attribute

Testing

• I have tested my changes
• Existing tests still pass

Checklist

• My code follows the project style
• I have updated documentation if needed
• I have added tests for new functionality (if applicable)

[coderabbitai]

Actionable comments posted: 6

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (5)

CHANGELOG.md (2)

92-93: Typo: “acess” → “access”.

Small spelling fix in the bullet point.

Apply this diff:

-  * Submodel: The base class for all submodels. Each is a subset of the Model, for simpler acess and clearer code.
+  * Submodel: The base class for all submodels. Each is a subset of the Model, for simpler access and clearer code.

---

108-109: Typos in Known issues.

“Elemenets” → “Elements”; “arrises” → “arises”; “thats” → “that's”.

Apply this diff:

-* IO for single Interfaces/Elemenets to Datasets might not work properly if the Interface/Element is not part of a fully transformed and connected FlowSystem. This arrises from Numeric Data not being stored as xr.DataArray by the user. To avoid this, always use the `to_dataset()` on Elements inside a FlowSystem thats connected and transformed.
+* IO for single Interfaces/Elements to Datasets might not work properly if the Interface/Element is not part of a fully transformed and connected FlowSystem. This arises from Numeric Data not being stored as xr.DataArray by the user. To avoid this, always use the `to_dataset()` on Elements inside a FlowSystem that's connected and transformed.

flixopt/features.py (1)

257-261: Property returns wrong variable name.

You create on_hours_total but the property returns total_on_hours, causing a KeyError.

Apply this diff:

-    def total_on_hours(self) -> linopy.Variable | None:
-        """Total on hours variable"""
-        return self['total_on_hours']
+    def total_on_hours(self) -> linopy.Variable | None:
+        """Total on hours variable"""
+        return self.get('on_hours_total')

flixopt/flow_system.py (2)

205-244: Round-trip: include years_of_last_year in serialized reference

Without persisting, from_dataset can’t reproduce years_per_year when custom last-year duration was provided.

         reference_structure, all_extracted_arrays = super()._create_reference_structure()
 
         # Remove timesteps, as it's directly stored in dataset index
         reference_structure.pop('timesteps', None)
+        # Persist years_of_last_year to allow round-trip reconstruction
+        if getattr(self, 'years_of_last_year', None) is not None:
+            reference_structure['years_of_last_year'] = self.years_of_last_year

---

260-287: from_dataset: pass through years_of_last_year

Ensure reconstructed FlowSystem uses the original last-year duration.

         flow_system = cls(
             timesteps=ds.indexes['time'],
             years=ds.indexes.get('year'),
             scenarios=ds.indexes.get('scenario'),
+            years_of_last_year=reference_structure.get('years_of_last_year'),
             weights=cls._resolve_dataarray_reference(reference_structure['weights'], arrays_dict)
             if 'weights' in reference_structure
             else None,
             hours_of_last_timestep=reference_structure.get('hours_of_last_timestep'),
             hours_of_previous_timesteps=reference_structure.get('hours_of_previous_timesteps'),
         )

🧹 Nitpick comments (10)

flixopt/modeling.py (1)

629-631: Error message: wrong class name.

Raise from ModelingPrimitives, not BoundingPatterns.

Apply this diff:

-        if not isinstance(model, Submodel):
-            raise ValueError('BoundingPatterns.continuous_transition_bounds() can only be used with a Submodel')
+        if not isinstance(model, Submodel):
+            raise ValueError('ModelingPrimitives.continuous_transition_bounds() can only be used with a Submodel')

flixopt/effects.py (1)

177-216: Honor the new name_prefix in transform_data.

The new parameter isn’t used; propagate it into variable name prefixes for consistency with other modules.

Apply this diff:

-    def transform_data(self, flow_system: FlowSystem, name_prefix: str = '') -> None:
+    def transform_data(self, flow_system: FlowSystem, name_prefix: str = '') -> None:
         self.minimum_operation_per_hour = flow_system.fit_to_model_coords(
-            f'{self.label_full}|minimum_operation_per_hour', self.minimum_operation_per_hour
+            f'{name_prefix}{self.label_full}|minimum_operation_per_hour', self.minimum_operation_per_hour
         )
 
         self.maximum_operation_per_hour = flow_system.fit_to_model_coords(
-            f'{self.label_full}|maximum_operation_per_hour', self.maximum_operation_per_hour
+            f'{name_prefix}{self.label_full}|maximum_operation_per_hour', self.maximum_operation_per_hour
         )
 
         self.specific_share_to_other_effects_operation = flow_system.fit_effects_to_model_coords(
-            f'{self.label_full}|operation->', self.specific_share_to_other_effects_operation, 'operation'
+            f'{name_prefix}{self.label_full}|operation->', self.specific_share_to_other_effects_operation, 'operation'
         )
 
         self.minimum_operation = flow_system.fit_to_model_coords(
-            f'{self.label_full}|minimum_operation', self.minimum_operation, dims=['year', 'scenario']
+            f'{name_prefix}{self.label_full}|minimum_operation', self.minimum_operation, dims=['year', 'scenario']
         )
         self.maximum_operation = flow_system.fit_to_model_coords(
-            f'{self.label_full}|maximum_operation', self.maximum_operation, dims=['year', 'scenario']
+            f'{name_prefix}{self.label_full}|maximum_operation', self.maximum_operation, dims=['year', 'scenario']
         )
         self.minimum_invest = flow_system.fit_to_model_coords(
-            f'{self.label_full}|minimum_invest', self.minimum_invest, dims=['year', 'scenario']
+            f'{name_prefix}{self.label_full}|minimum_invest', self.minimum_invest, dims=['year', 'scenario']
         )
         self.maximum_invest = flow_system.fit_to_model_coords(
-            f'{self.label_full}|maximum_invest', self.maximum_invest, dims=['year', 'scenario']
+            f'{name_prefix}{self.label_full}|maximum_invest', self.maximum_invest, dims=['year', 'scenario']
         )
         self.minimum_total = flow_system.fit_to_model_coords(
-            f'{self.label_full}|minimum_total',
+            f'{name_prefix}{self.label_full}|minimum_total',
             self.minimum_total,
             dims=['year', 'scenario'],
         )
         self.maximum_total = flow_system.fit_to_model_coords(
-            f'{self.label_full}|maximum_total', self.maximum_total, dims=['year', 'scenario']
+            f'{name_prefix}{self.label_full}|maximum_total', self.maximum_total, dims=['year', 'scenario']
         )
         self.specific_share_to_other_effects_invest = flow_system.fit_effects_to_model_coords(
-            f'{self.label_full}|invest->',
+            f'{name_prefix}{self.label_full}|invest->',
             self.specific_share_to_other_effects_invest,
             'invest',
             dims=['year', 'scenario'],
         )

flixopt/structure.py (1)

225-235: Add explicit return annotation for transform_data.

Public API shows a standardized signature returning None across modules.

Apply this diff:

-    def transform_data(self, flow_system: FlowSystem, name_prefix: str = ''):
+    def transform_data(self, flow_system: FlowSystem, name_prefix: str = '') -> None:

flixopt/elements.py (3)

100-106: Propagate name_prefix and use it in nested transforms

Honor the new API by threading name_prefix through and using it to build labels.

-    def transform_data(self, flow_system: FlowSystem, name_prefix: str = '') -> None:
-        if self.on_off_parameters is not None:
-            self.on_off_parameters.transform_data(flow_system, self.label_full)
-
-        for flow in self.inputs + self.outputs:
-            flow.transform_data(flow_system)
+    def transform_data(self, flow_system: FlowSystem, name_prefix: str = '') -> None:
+        if self.on_off_parameters is not None:
+            prefix = '|'.join(filter(None, [name_prefix, self.label_full]))
+            self.on_off_parameters.transform_data(flow_system, prefix)
+
+        for flow in self.inputs + self.outputs:
+            flow.transform_data(flow_system, name_prefix)

---

192-196: Use name_prefix when naming Bus transform data

Build names with the optional name_prefix for consistency across the new API.

-    def transform_data(self, flow_system: FlowSystem, name_prefix: str = '') -> None:
-        self.excess_penalty_per_flow_hour = flow_system.fit_to_model_coords(
-            f'{self.label_full}|excess_penalty_per_flow_hour', self.excess_penalty_per_flow_hour
-        )
+    def transform_data(self, flow_system: FlowSystem, name_prefix: str = '') -> None:
+        base = '|'.join(filter(None, [name_prefix, self.label_full]))
+        self.excess_penalty_per_flow_hour = flow_system.fit_to_model_coords(
+            f'{base}|excess_penalty_per_flow_hour', self.excess_penalty_per_flow_hour
+        )

---

420-452: Honor name_prefix in Flow.transform_data and propagate to nested transforms

Leverage the provided name_prefix to construct labels and forward it to sub-transforms.

-    def transform_data(self, flow_system: FlowSystem, name_prefix: str = '') -> None:
-        self.relative_minimum = flow_system.fit_to_model_coords(
-            f'{self.label_full}|relative_minimum', self.relative_minimum
-        )
-        self.relative_maximum = flow_system.fit_to_model_coords(
-            f'{self.label_full}|relative_maximum', self.relative_maximum
-        )
-        self.fixed_relative_profile = flow_system.fit_to_model_coords(
-            f'{self.label_full}|fixed_relative_profile', self.fixed_relative_profile
-        )
-        self.effects_per_flow_hour = flow_system.fit_effects_to_model_coords(
-            self.label_full, self.effects_per_flow_hour, 'per_flow_hour'
-        )
-        self.flow_hours_total_max = flow_system.fit_to_model_coords(
-            f'{self.label_full}|flow_hours_total_max', self.flow_hours_total_max, dims=['year', 'scenario']
-        )
-        self.flow_hours_total_min = flow_system.fit_to_model_coords(
-            f'{self.label_full}|flow_hours_total_min', self.flow_hours_total_min, dims=['year', 'scenario']
-        )
-        self.load_factor_max = flow_system.fit_to_model_coords(
-            f'{self.label_full}|load_factor_max', self.load_factor_max, dims=['year', 'scenario']
-        )
-        self.load_factor_min = flow_system.fit_to_model_coords(
-            f'{self.label_full}|load_factor_min', self.load_factor_min, dims=['year', 'scenario']
-        )
-
-        if self.on_off_parameters is not None:
-            self.on_off_parameters.transform_data(flow_system, self.label_full)
-        if isinstance(self.size, InvestParameters):
-            self.size.transform_data(flow_system, self.label_full)
-        else:
-            self.size = flow_system.fit_to_model_coords(f'{self.label_full}|size', self.size, dims=['year', 'scenario'])
+    def transform_data(self, flow_system: FlowSystem, name_prefix: str = '') -> None:
+        base = '|'.join(filter(None, [name_prefix, self.label_full]))
+        self.relative_minimum = flow_system.fit_to_model_coords(
+            f'{base}|relative_minimum', self.relative_minimum
+        )
+        self.relative_maximum = flow_system.fit_to_model_coords(
+            f'{base}|relative_maximum', self.relative_maximum
+        )
+        self.fixed_relative_profile = flow_system.fit_to_model_coords(
+            f'{base}|fixed_relative_profile', self.fixed_relative_profile
+        )
+        self.effects_per_flow_hour = flow_system.fit_effects_to_model_coords(
+            base, self.effects_per_flow_hour, 'per_flow_hour'
+        )
+        self.flow_hours_total_max = flow_system.fit_to_model_coords(
+            f'{base}|flow_hours_total_max', self.flow_hours_total_max, dims=['year', 'scenario']
+        )
+        self.flow_hours_total_min = flow_system.fit_to_model_coords(
+            f'{base}|flow_hours_total_min', self.flow_hours_total_min, dims=['year', 'scenario']
+        )
+        self.load_factor_max = flow_system.fit_to_model_coords(
+            f'{base}|load_factor_max', self.load_factor_max, dims=['year', 'scenario']
+        )
+        self.load_factor_min = flow_system.fit_to_model_coords(
+            f'{base}|load_factor_min', self.load_factor_min, dims=['year', 'scenario']
+        )
+
+        if self.on_off_parameters is not None:
+            self.on_off_parameters.transform_data(flow_system, base)
+        if isinstance(self.size, InvestParameters):
+            self.size.transform_data(flow_system, base)
+        else:
+            self.size = flow_system.fit_to_model_coords(f'{base}|size', self.size, dims=['year', 'scenario'])

flixopt/components.py (3)

207-214: Thread name_prefix through and apply in piecewise label prefix

Keep the name_prefix consistent in super and PiecewiseConversion.

-    def transform_data(self, flow_system: FlowSystem, name_prefix: str = '') -> None:
-        super().transform_data(flow_system)
+    def transform_data(self, flow_system: FlowSystem, name_prefix: str = '') -> None:
+        super().transform_data(flow_system, name_prefix)
         if self.conversion_factors:
             self.conversion_factors = self._transform_conversion_factors(flow_system)
         if self.piecewise_conversion:
             self.piecewise_conversion.has_time_dim = True
-            self.piecewise_conversion.transform_data(flow_system, f'{self.label_full}|PiecewiseConversion')
+            prefix = '|'.join(filter(None, [name_prefix, self.label_full]))
+            self.piecewise_conversion.transform_data(flow_system, f'{prefix}|PiecewiseConversion')

---

425-466: Honor name_prefix in Storage.transform_data

Consistently prefix names; also pass name_prefix to super.

-    def transform_data(self, flow_system: FlowSystem, name_prefix: str = '') -> None:
-        super().transform_data(flow_system)
-        self.relative_minimum_charge_state = flow_system.fit_to_model_coords(
-            f'{self.label_full}|relative_minimum_charge_state',
+    def transform_data(self, flow_system: FlowSystem, name_prefix: str = '') -> None:
+        super().transform_data(flow_system, name_prefix)
+        base = '|'.join(filter(None, [name_prefix, self.label_full]))
+        self.relative_minimum_charge_state = flow_system.fit_to_model_coords(
+            f'{base}|relative_minimum_charge_state',
             self.relative_minimum_charge_state,
         )
-        self.relative_maximum_charge_state = flow_system.fit_to_model_coords(
-            f'{self.label_full}|relative_maximum_charge_state',
+        self.relative_maximum_charge_state = flow_system.fit_to_model_coords(
+            f'{base}|relative_maximum_charge_state',
             self.relative_maximum_charge_state,
         )
-        self.eta_charge = flow_system.fit_to_model_coords(f'{self.label_full}|eta_charge', self.eta_charge)
-        self.eta_discharge = flow_system.fit_to_model_coords(f'{self.label_full}|eta_discharge', self.eta_discharge)
+        self.eta_charge = flow_system.fit_to_model_coords(f'{base}|eta_charge', self.eta_charge)
+        self.eta_discharge = flow_system.fit_to_model_coords(f'{base}|eta_discharge', self.eta_discharge)
         self.relative_loss_per_hour = flow_system.fit_to_model_coords(
-            f'{self.label_full}|relative_loss_per_hour', self.relative_loss_per_hour
+            f'{base}|relative_loss_per_hour', self.relative_loss_per_hour
         )
         if not isinstance(self.initial_charge_state, str):
             self.initial_charge_state = flow_system.fit_to_model_coords(
-                f'{self.label_full}|initial_charge_state', self.initial_charge_state, dims=['year', 'scenario']
+                f'{base}|initial_charge_state', self.initial_charge_state, dims=['year', 'scenario']
             )
-        self.minimal_final_charge_state = flow_system.fit_to_model_coords(
-            f'{self.label_full}|minimal_final_charge_state', self.minimal_final_charge_state, dims=['year', 'scenario']
+        self.minimal_final_charge_state = flow_system.fit_to_model_coords(
+            f'{base}|minimal_final_charge_state', self.minimal_final_charge_state, dims=['year', 'scenario']
         )
-        self.maximal_final_charge_state = flow_system.fit_to_model_coords(
-            f'{self.label_full}|maximal_final_charge_state', self.maximal_final_charge_state, dims=['year', 'scenario']
+        self.maximal_final_charge_state = flow_system.fit_to_model_coords(
+            f'{base}|maximal_final_charge_state', self.maximal_final_charge_state, dims=['year', 'scenario']
         )
         self.relative_minimum_final_charge_state = flow_system.fit_to_model_coords(
-            f'{self.label_full}|relative_minimum_final_charge_state',
+            f'{base}|relative_minimum_final_charge_state',
             self.relative_minimum_final_charge_state,
             dims=['year', 'scenario'],
         )
         self.relative_maximum_final_charge_state = flow_system.fit_to_model_coords(
-            f'{self.label_full}|relative_maximum_final_charge_state',
+            f'{base}|relative_maximum_final_charge_state',
             self.relative_maximum_final_charge_state,
             dims=['year', 'scenario'],
         )
         if isinstance(self.capacity_in_flow_hours, InvestParameters):
-            self.capacity_in_flow_hours.transform_data(flow_system, f'{self.label_full}|InvestParameters')
+            self.capacity_in_flow_hours.transform_data(flow_system, f'{base}|InvestParameters')
         else:
             self.capacity_in_flow_hours = flow_system.fit_to_model_coords(
-                f'{self.label_full}|capacity_in_flow_hours', self.capacity_in_flow_hours, dims=['year', 'scenario']
+                f'{base}|capacity_in_flow_hours', self.capacity_in_flow_hours, dims=['year', 'scenario']
             )

---

696-703: Honor name_prefix in Transmission.transform_data

Pass name_prefix to super and use it for naming losses.

-    def transform_data(self, flow_system: FlowSystem, name_prefix: str = '') -> None:
-        super().transform_data(flow_system)
-        self.relative_losses = flow_system.fit_to_model_coords(
-            f'{self.label_full}|relative_losses', self.relative_losses
-        )
-        self.absolute_losses = flow_system.fit_to_model_coords(
-            f'{self.label_full}|absolute_losses', self.absolute_losses
-        )
+    def transform_data(self, flow_system: FlowSystem, name_prefix: str = '') -> None:
+        super().transform_data(flow_system, name_prefix)
+        base = '|'.join(filter(None, [name_prefix, self.label_full]))
+        self.relative_losses = flow_system.fit_to_model_coords(f'{base}|relative_losses', self.relative_losses)
+        self.absolute_losses = flow_system.fit_to_model_coords(f'{base}|absolute_losses', self.absolute_losses)

flixopt/flow_system.py (1)

69-90: Persist years_of_last_year on the instance

Store the constructor arg to enable serialization and round‑trip reconstruction.

     def __init__(
         self,
         timesteps: pd.DatetimeIndex,
         years: pd.Index | None = None,
         scenarios: pd.Index | None = None,
         hours_of_last_timestep: float | None = None,
         hours_of_previous_timesteps: int | float | np.ndarray | None = None,
         years_of_last_year: int | None = None,
         weights: NonTemporalDataUser | None = None,
     ):
         self.timesteps = self._validate_timesteps(timesteps)
         self.timesteps_extra = self._create_timesteps_with_extra(timesteps, hours_of_last_timestep)
         self.hours_of_previous_timesteps = self._calculate_hours_of_previous_timesteps(
             timesteps, hours_of_previous_timesteps
         )
 
+        self.years_of_last_year = years_of_last_year
         if years is None:
             self.years, self.years_per_year = None, None
         else:
             self.years = self._validate_years(years)
-            self.years_per_year = self.calculate_years_per_year(self.years, years_of_last_year)
+            self.years_per_year = self.calculate_years_per_year(self.years, years_of_last_year)

📜 Review details

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between af4a297 and a2985e3.

📒 Files selected for processing (10)

• CHANGELOG.md (2 hunks)
• flixopt/components.py (4 hunks)
• flixopt/effects.py (3 hunks)
• flixopt/elements.py (4 hunks)
• flixopt/features.py (3 hunks)
• flixopt/flow_system.py (8 hunks)
• flixopt/interface.py (6 hunks)
• flixopt/modeling.py (4 hunks)
• flixopt/structure.py (2 hunks)
• tests/todos.txt (0 hunks)

💤 Files with no reviewable changes (1)

• tests/todos.txt

🧰 Additional context used

🪛 markdownlint-cli2 (0.18.1)

CHANGELOG.md

38-38: Heading levels should only increment by one level at a time
Expected: h3; Actual: h4

(MD001, heading-increment)

🔇 Additional comments (16)

flixopt/modeling.py (1)

275-288: Forward/backward: rely on normalized duration_per_step.

With the normalization above, the slicing here is correct. Please ensure duration_per_step has the same coord along duration_dim as state_variable.

Run a quick assertion in tests ensuring duration_per_step.dims == (duration_dim,) and matching coords.

flixopt/features.py (1)

213-215: LGTM on duration-aware consecutive constraints.

Passing duration_per_step=self.hours_per_step and duration_dim='time' integrates correctly with the updated primitive.

Please confirm self.hours_per_step is 1‑D on time for all call sites.

Also applies to: 226-228

flixopt/effects.py (1)

19-19: Type alias update is consistent with core types.

Importing NonTemporalDataUser and updating NonTemporalEffectsUser improves API clarity.

Also applies to: 278-279

flixopt/structure.py (1)

174-181: Weights defaulting logic: normalization looks correct.

Using years_per_year as default base and normalizing by sum matches the new multi‑year semantics.

Please ensure years_per_year aligns on dims ['year','scenario'] (or broadcasts) for all FlowSystems lacking explicit weights.

flixopt/elements.py (1)

678-699: Lower-bound fix for optional investments looks correct; please confirm edge cases

The guard ensures optional investments don’t force a >0 lower bound when not investing. Good.

Please confirm behavior when:

• optional=True and relative_minimum>0: lb should remain 0.
• optional=False and relative_minimum>0: lb should be relative_minimum × minimum_or_fixed_size.

flixopt/components.py (1)

264-269: Docs additions LGTM

The new final charge state params are clearly described.

flixopt/flow_system.py (5)

52-63: Docs update LGTM

New years_of_last_year param is documented clearly.

---

382-386: Dims filtering in fit_to_model_coords: LGTM

The simplified dims handling via coord filtering is clean.

---

778-793: Use cached dataset for selection: LGTM

This reduces repeated to_dataset calls; matches intent.

---

815-830: isel selection refactor: LGTM

Symmetric optimization here is good.

---

426-443: Verify weights normalization across year/scenario

Non-1 sums now warn. Ensure downstream uses normalized weights. If not, consider normalizing internally to avoid scaling surprises.

flixopt/interface.py (5)

76-80: Piece.transform_data: LGTM

Adopts name_prefix and dims behavior consistently.

---

222-225: Piecewise.transform_data: LGTM

Propagates prefix per piece; consistent with API.

---

444-447: PiecewiseConversion.transform_data: LGTM

Prefix composition per flow is correct.

---

874-907: InvestParameters.transform_data: LGTM

Effects and bounds now respect name_prefix and dims=['year','scenario'].

---

1123-1151: OnOffParameters.transform_data: LGTM

Consistent prefixing and dims usage.

[coderabbitai]

🧹 Nitpick

Fix heading levels (MD001): use h3 under h2.

Change the three h4 section headers to h3 to avoid heading‑increment violations.

Apply this diff:

-#### Multi-year-investments
+### Multi-year-investments
...
-#### Stochastic modeling
+### Stochastic modeling
...
-#### Improved Data handling: IO, resampling and more through xarray
+### Improved Data handling: IO, resampling and more through xarray

Also applies to: 42-42, 55-55

🧰 Tools

🪛 markdownlint-cli2 (0.18.1)

38-38: Heading levels should only increment by one level at a time
Expected: h3; Actual: h4

(MD001, heading-increment)

🤖 Prompt for AI Agents

In CHANGELOG.md around lines 38, 42, and 55, the section headers currently use
h4 (####) which violates MD001; change each of those headers from h4 to h3 by
replacing the leading "####" with "###" so they are proper h3 headings under the
h2 parent; update all three instances (lines 38, 42, 55) consistently.

[coderabbitai]

🧹 Nitpick

Typo: “form” → “from”.

“…accessible directly form the results…” should be “…from the results…”.

Apply this diff:

-* FlowSystem Restoring: The used FlowSystem is now accessible directly form the results without manual restoring (lazily). All Parameters can be safely accessed anytime after the solve.
+* FlowSystem Restoring: The used FlowSystem is now accessible directly from the results without manual restoring (lazily). All Parameters can be safely accessed anytime after the solve.

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	* FlowSystem Restoring: The used FlowSystem is now accessible directly form the results without manual restoring (lazily). All Parameters can be safely accessed anytime after the solve.
	* FlowResults added as a new class to store the results of Flows. They can now be accessed directly.
	* FlowSystem Restoring: The used FlowSystem is now accessible directly from the results without manual restoring (lazily). All Parameters can be safely accessed anytime after the solve.
	* FlowResults added as a new class to store the results of Flows. They can now be accessed directly.

🤖 Prompt for AI Agents

In CHANGELOG.md around lines 72 to 73, there is a typo: the phrase "accessible
directly form the results" should read "accessible directly from the results";
update that word ("form" → "from") in the sentence and ensure the corrected
sentence reads "...accessible directly from the results without manual restoring
(lazily)."

[coderabbitai]

⚠️ Potential issue

Fix single-year edge case in calculate_years_per_year

np.diff(years) is empty for a single-year index → indexing [-1] crashes. Handle len(years)==1; also clarify the docstring.

-    def calculate_years_per_year(years: pd.Index, years_of_last_year: int | None = None) -> xr.DataArray:
-        """Calculate duration of each timestep as a 1D DataArray."""
-        years_per_year = np.diff(years)
-        return xr.DataArray(
-            np.append(years_per_year, years_of_last_year or years_per_year[-1]),
-            coords={'year': years},
-            dims='year',
-            name='years_per_year',
-        )
+    def calculate_years_per_year(years: pd.Index, years_of_last_year: int | None = None) -> xr.DataArray:
+        """Calculate the duration represented by each year index as a 1D DataArray."""
+        if len(years) == 1:
+            last = years_of_last_year if years_of_last_year is not None else 1
+            data = np.array([last], dtype=int)
+        else:
+            diffs = np.diff(years)
+            last = years_of_last_year if years_of_last_year is not None else diffs[-1]
+            data = np.append(diffs, last)
+        return xr.DataArray(data, coords={'year': years}, dims='year', name='years_per_year')

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	@staticmethod
	def calculate_years_per_year(years: pd.Index, years_of_last_year: int | None = None) -> xr.DataArray:
	"""Calculate duration of each timestep as a 1D DataArray."""
	years_per_year = np.diff(years)
	return xr.DataArray(
	np.append(years_per_year, years_of_last_year or years_per_year[-1]),
	coords={'year': years},
	dims='year',
	name='years_per_year',
	)
	@staticmethod
	def calculate_years_per_year(years: pd.Index, years_of_last_year: int | None = None) -> xr.DataArray:
	"""Calculate the duration represented by each year index as a 1D DataArray."""
	if len(years) == 1:
	last = years_of_last_year if years_of_last_year is not None else 1
	data = np.array([last], dtype=int)
	else:
	diffs = np.diff(years)
	last = years_of_last_year if years_of_last_year is not None else diffs[-1]
	data = np.append(diffs, last)
	return xr.DataArray(data, coords={'year': years}, dims='year', name='years_per_year')

🤖 Prompt for AI Agents

In flixopt/flow_system.py around lines 183 to 193, calculate_years_per_year
currently uses np.diff(years) and accesses years_per_year[-1], which crashes for
a single-year Index; update the function to handle len(years) == 1 by returning
a DataArray of [1.0] (or the provided years_of_last_year) for that single year,
and for general cases compute diffs and append the last interval safely using a
safe default when years_of_last_year is None; also update the docstring to state
that for a single-year index the duration defaults to 1 (or to
years_of_last_year if given) and that the function returns a 1D DataArray of
timestep durations indexed by year.

[coderabbitai]

⚠️ Potential issue

duration_per_step: handle scalars and validate inputs; fix Big‑M.

As written, duration_per_step.sum(duration_dim) fails for scalars; also no validation if duration_per_step is None or duration_dim missing in state. Normalize duration_per_step to a DataArray aligned to state_variable and compute mega robustly.

Apply this diff:

-        mega = duration_per_step.sum(duration_dim) + previous_duration  # Big-M value
+        # Validate inputs and normalize duration_per_step to a DataArray aligned on duration_dim
+        if duration_per_step is None:
+            raise ValueError('consecutive_duration_tracking: duration_per_step must be provided')
+        if duration_dim not in state_variable.dims:
+            raise ValueError(f'consecutive_duration_tracking: duration_dim "{duration_dim}" not in state_variable.dims')
+        if np.isscalar(duration_per_step):
+            duration_per_step = xr.DataArray(
+                duration_per_step,
+                dims=[duration_dim],
+                coords={duration_dim: state_variable.coords[duration_dim]},
+            )
+        mega = duration_per_step.sum(duration_dim) + previous_duration  # Big-M value

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	mega = duration_per_step.sum(duration_dim) + previous_duration # Big-M value
	# Duration variable
	duration = model.add_variables(
	lower=0,
	upper=maximum_duration if maximum_duration is not None else mega,
	coords=model.get_coords(),
	coords=state_variable.coords,
	name=name,
	# Validate inputs and normalize duration_per_step to a DataArray aligned on duration_dim
	if duration_per_step is None:
	raise ValueError('consecutive_duration_tracking: duration_per_step must be provided')
	if duration_dim not in state_variable.dims:
	raise ValueError(f'consecutive_duration_tracking: duration_dim "{duration_dim}" not in state_variable.dims')
	if np.isscalar(duration_per_step):
	duration_per_step = xr.DataArray(
	duration_per_step,
	dims=[duration_dim],
	coords={duration_dim: state_variable.coords[duration_dim]},
	)
	mega = duration_per_step.sum(duration_dim) + previous_duration # Big-M value
	# Duration variable
	duration = model.add_variables(
	lower=0,
	upper=maximum_duration if maximum_duration is not None else mega,
	coords=state_variable.coords,
	name=name,

[coderabbitai]

⚠️ Potential issue

Initial condition: guard scalar duration_per_step.

When duration_per_step is scalar, .isel(...) will raise. Use the normalized DataArray from above.

Apply this diff:

-        constraints['initial'] = model.add_constraints(
-            duration.isel({duration_dim: 0})
-            == (duration_per_step.isel({duration_dim: 0}) + previous_duration) * state_variable.isel({duration_dim: 0}),
-            name=f'{duration.name}|initial',
-        )
+        constraints['initial'] = model.add_constraints(
+            duration.isel({duration_dim: 0})
+            == (duration_per_step.isel({duration_dim: 0}) + previous_duration)
+            * state_variable.isel({duration_dim: 0}),
+            name=f'{duration.name}|initial',
+        )

Committable suggestion skipped: line range outside the PR's diff.

🤖 Prompt for AI Agents

In flixopt/modeling.py around lines 291 to 296, the initial-condition uses
duration_per_step.isel(...) which will raise when duration_per_step is a scalar;
replace uses of the raw duration_per_step.isel(...) with the normalized
DataArray created earlier (use the normalized duration_per_step variable defined
above) so that .isel is safe for both scalar and indexed inputs, i.e., reference
the normalized DataArray in the equality expression for the 'initial'
constraint.

[coderabbitai]

⚠️ Potential issue

Fix shape mismatch in minimum-duration constraint.

LHS currently uses full duration (length T) while RHS is length T‑1. Slice LHS to t>0 to match.

Apply this diff:

-            constraints['lb'] = model.add_constraints(
-                duration
-                >= (
-                    state_variable.isel({duration_dim: slice(None, -1)})
-                    - state_variable.isel({duration_dim: slice(1, None)})
-                )
-                * minimum_duration.isel({duration_dim: slice(None, -1)}),
-                name=f'{duration.name}|lb',
-            )
+            constraints['lb'] = model.add_constraints(
+                duration.isel({duration_dim: slice(1, None)})
+                >= (
+                    state_variable.isel({duration_dim: slice(None, -1)})
+                    - state_variable.isel({duration_dim: slice(1, None)})
+                )
+                * minimum_duration.isel({duration_dim: slice(None, -1)}),
+                name=f'{duration.name}|lb',
+            )

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	if minimum_duration is not None:
	constraints['lb'] = model.add_constraints(
	duration
	>= (state_variable.isel(time=slice(None, -1)) - state_variable.isel(time=slice(1, None)))
	* minimum_duration.isel(time=slice(None, -1)),
	>= (
	state_variable.isel({duration_dim: slice(None, -1)})
	- state_variable.isel({duration_dim: slice(1, None)})
	)
	* minimum_duration.isel({duration_dim: slice(None, -1)}),
	name=f'{duration.name}|lb',
	)
	if minimum_duration is not None:
	constraints['lb'] = model.add_constraints(
	duration.isel({duration_dim: slice(1, None)})
	>= (
	state_variable.isel({duration_dim: slice(None, -1)})
	- state_variable.isel({duration_dim: slice(1, None)})
	)
	* minimum_duration.isel({duration_dim: slice(None, -1)}),
	name=f'{duration.name}|lb',
	)

🤖 Prompt for AI Agents

In flixopt/modeling.py around lines 299 to 309, the minimum_duration constraint
uses full-duration on the LHS (length T) while the RHS is length T-1, causing a
shape mismatch; fix it by slicing the LHS to t>0 (e.g.
duration.isel({duration_dim: slice(1, None)})) so both sides align with the
state_variable slices and minimum_duration slice, and keep the existing
constraint name and call to model.add_constraints.