ClusterStructure.plot() now works for all cases using fxplot:

  | Case             | Layout                                                                  |
  |------------------|-------------------------------------------------------------------------|
  | Simple (no dims) | Single heatmap                                                          |
  | Periods only     | Vertical stack (1 column)                                               |
  | Scenarios only   | Horizontal layout                                                       |
  | Both             | Grid (periods as rows, scenarios as columns via facet_cols=n_scenarios) |

  | File                                            | Issue                                                     | Fix                                                 |
  |-------------------------------------------------|-----------------------------------------------------------|-----------------------------------------------------|
  | docs/notebooks/03-investment-optimization.ipynb | Division by zero when solar_size = 0                      | Added guard: if solar_size > 0 else float('nan')    |
  | flixopt/clustering/base.py:181-235              | ClusterStructure.plot() crashes for multi-period/scenario | Added NotImplementedError with helpful message      |
  | flixopt/components.py:1256-1265                 | Obsolete linopy LP writer bug workaround                  | Removed + 0.0 workaround (fixed in linopy >= 0.5.1) |
  | flixopt/dataset_plot_accessor.py:742-780        | to_duration_curve crashes on variables without time dim   | Added guard to skip non-time variables              |
  | flixopt/features.py:234-236                     | Critical: Startup count ignores cluster weighting         | Now multiplies by cluster_weight before summing     |
  | flixopt/structure.py:268-281                    | scenario_weights docstring misleading                     | Updated docstring to accurately describe behavior   |

  Nitpick Fixes

  | File                                               | Fix                                                                                       |
  |----------------------------------------------------|-------------------------------------------------------------------------------------------|
  | docs/notebooks/data/generate_example_systems.py    | Fixed type hint pd.DataFrame → pd.Series for _elec_prices, added timezone guard           |
  | flixopt/statistics_accessor.py:2103-2132           | Added detailed comment explaining secondary y-axis offset strategy                        |
  | tests/test_cluster_reduce_expand.py                | Moved import xarray as xr to top of file                                                  |
  | docs/notebooks/data/generate_realistic_profiles.py | Clarified warnings.resetwarnings() comment                                                |
  | flixopt/transform_accessor.py                      | Removed unused cluster_coords and time_coords params from _combine_slices_to_dataarray_2d |
  | flixopt/comparison.py                              | Added error handling to _concat_property for FlowSystems lacking optimization data        |

Author: FBumann

docs/notebooks/03-investment-optimization.ipynb

@@ -234,7 +234,7 @@
     "    {\n",
     "        'Solar [kW]': solar_size,\n",
     "        'Tank [kWh]': tank_size,\n",
-    "        'Ratio [kWh/kW]': tank_size / solar_size,\n",
+    "        'Ratio [kWh/kW]': tank_size / solar_size if solar_size > 0 else float('nan'),\n",
     "    },\n",
     "    index=['Optimal Size'],\n",
     ").T"

docs/notebooks/data/generate_example_systems.py

@@ -55,7 +55,7 @@
 
 # Lazy-loaded shared data with error handling
 _weather: pd.DataFrame | None = None
-_elec_prices: pd.DataFrame | None = None
+_elec_prices: pd.Series | None = None
 
 
 def _get_weather() -> pd.DataFrame:
@@ -71,13 +71,15 @@ def _get_weather() -> pd.DataFrame:
     return _weather
 
 
-def _get_elec_prices() -> pd.DataFrame:
+def _get_elec_prices() -> pd.Series:
     """Get electricity prices, loading lazily on first access."""
     global _elec_prices
     if _elec_prices is None:
         try:
             _elec_prices = load_electricity_prices()
-            _elec_prices.index = _elec_prices.index.tz_localize(None)  # Remove timezone
+            # Remove timezone if present (guard against both tz-aware and tz-naive indices)
+            if _elec_prices.index.tz is not None:
+                _elec_prices.index = _elec_prices.index.tz_localize(None)
         except FileNotFoundError as e:
             raise FileNotFoundError(
                 f'Electricity price data not found. Ensure price data exists in {DATA_DIR}. Original error: {e}'

docs/notebooks/data/generate_realistic_profiles.py

@@ -25,7 +25,10 @@
 import pvlib
 from demandlib import bdew
 
-warnings.resetwarnings()  # Reset to default behavior due to weird dependency behaviour
+# Reset warnings to default after imports. Some dependencies (demandlib, pvlib)
+# may configure warnings during import. This ensures consistent warning behavior
+# when this module is used in different contexts (scripts, notebooks, tests).
+warnings.resetwarnings()
 
 # Data directory
 DATA_DIR = Path(__file__).parent / 'raw'

flixopt/clustering/base.py

@@ -182,7 +182,8 @@ def plot(self, colors: str | list[str] | None = None, show: bool | None = None)
         """Plot cluster assignment visualization.
 
         Shows which cluster each original period belongs to, and the
-        number of occurrences per cluster.
+        number of occurrences per cluster. For multi-period/scenario structures,
+        creates a faceted grid plot.
 
         Args:
             colors: Colorscale name (str) or list of colors.
@@ -198,34 +199,42 @@ def plot(self, colors: str | list[str] | None = None, show: bool | None = None)
         n_clusters = (
             int(self.n_clusters) if isinstance(self.n_clusters, (int, np.integer)) else int(self.n_clusters.values)
         )
+        colorscale = colors or CONFIG.Plotting.default_sequential_colorscale
 
-        cluster_order = self.get_cluster_order_for_slice()
-
-        # Build DataArray for fxplot heatmap
-        cluster_da = xr.DataArray(
-            cluster_order.reshape(1, -1),
-            dims=['y', 'original_cluster'],
-            coords={'y': ['Cluster'], 'original_cluster': range(1, len(cluster_order) + 1)},
-            name='cluster_assignment',
+        # Build DataArray with 1-based original_cluster coords
+        cluster_da = self.cluster_order.assign_coords(
+            original_cluster=np.arange(1, self.cluster_order.sizes['original_cluster'] + 1)
         )
 
-        # Use fxplot.heatmap for smart defaults
-        colorscale = colors or CONFIG.Plotting.default_sequential_colorscale
-        fig = cluster_da.fxplot.heatmap(
+        has_period = 'period' in cluster_da.dims
+        has_scenario = 'scenario' in cluster_da.dims
+
+        # Transpose for heatmap: first dim = y-axis, second dim = x-axis
+        if has_period:
+            cluster_da = cluster_da.transpose('period', 'original_cluster', ...)
+        elif has_scenario:
+            cluster_da = cluster_da.transpose('scenario', 'original_cluster', ...)
+
+        # Data to return (without dummy dims)
+        ds = xr.Dataset({'cluster_order': cluster_da})
+
+        # For plotting: add dummy y-dim if needed (heatmap requires 2D)
+        if not has_period and not has_scenario:
+            plot_da = cluster_da.expand_dims(y=['']).transpose('y', 'original_cluster')
+            plot_ds = xr.Dataset({'cluster_order': plot_da})
+        else:
+            plot_ds = ds
+
+        fig = plot_ds.fxplot.heatmap(
             colors=colorscale,
-            title=f'Cluster Assignment ({self.n_original_clusters} periods → {n_clusters} clusters)',
+            title=f'Cluster Assignment ({self.n_original_clusters} → {n_clusters} clusters)',
         )
-        fig.update_yaxes(showticklabels=False)
+
         fig.update_coloraxes(colorbar_title='Cluster')
+        if not has_period and not has_scenario:
+            fig.update_yaxes(showticklabels=False)
 
-        # Build data for PlotResult
-        data = xr.Dataset(
-            {
-                'cluster_order': self.cluster_order,
-                'cluster_occurrences': self.cluster_occurrences,
-            }
-        )
-        plot_result = PlotResult(data=data, figure=fig)
+        plot_result = PlotResult(data=ds, figure=fig)
 
         if show is None:
             show = CONFIG.Plotting.default_show

flixopt/comparison.py

@@ -223,8 +223,14 @@ def _concat_property(self, prop_name: str) -> xr.Dataset:
         """Concatenate a statistics property across all cases."""
         datasets = []
         for fs, name in zip(self._comp._systems, self._comp._names, strict=True):
-            ds = getattr(fs.statistics, prop_name)
-            datasets.append(ds.expand_dims(case=[name]))
+            try:
+                ds = getattr(fs.statistics, prop_name)
+                datasets.append(ds.expand_dims(case=[name]))
+            except RuntimeError as e:
+                warnings.warn(f"Skipping case '{name}': {e}", stacklevel=3)
+                continue
+        if not datasets:
+            return xr.Dataset()
         return xr.concat(datasets, dim='case', join='outer', fill_value=float('nan'))
 
     def _merge_dict_property(self, prop_name: str) -> dict[str, str]:

flixopt/dataset_plot_accessor.py

@@ -761,6 +761,9 @@ def to_duration_curve(self, *, normalize: bool = True) -> xr.Dataset:
         sorted_ds = self._ds.copy()
         for var in sorted_ds.data_vars:
             da = sorted_ds[var]
+            if 'time' not in da.dims:
+                # Skip variables without time dimension (e.g., scalar metadata)
+                continue
             time_axis = da.dims.index('time')
             # Sort along time axis (descending) - use flip for correct axis
             sorted_values = np.flip(np.sort(da.values, axis=time_axis), axis=time_axis)

flixopt/features.py

@@ -231,9 +231,12 @@ def _do_modeling(self):
                     coords=self._model.get_coords(('period', 'scenario')),
                     short_name='startup_count',
                 )
+                # Apply cluster_weight to count startups correctly in clustered systems.
+                # A startup in a cluster with weight 10 represents 10 actual startups.
                 # Sum over all temporal dimensions (time, and cluster if present)
                 startup_temporal_dims = [d for d in self.startup.dims if d not in ('period', 'scenario')]
-                self.add_constraints(count == self.startup.sum(startup_temporal_dims), short_name='startup_count')
+                weighted_startup = self.startup * self._model.weights.get('cluster', 1.0)
+                self.add_constraints(count == weighted_startup.sum(startup_temporal_dims), short_name='startup_count')
 
         # 5. Consecutive active duration (uptime) using existing pattern
         if self.parameters.use_uptime_tracking:

flixopt/statistics_accessor.py

@@ -2103,8 +2103,12 @@ def storage(
             # Get the primary y-axes from the bar figure to create matching secondary axes
             primary_yaxes = [key for key in fig.layout if key.startswith('yaxis')]
 
-            # For each primary y-axis, create a secondary y-axis
-            # Use +100 offset to ensure secondary axes don't conflict with plotly's auto-generated axis numbers
+            # For each primary y-axis, create a secondary y-axis.
+            # Secondary axis numbering strategy:
+            # - Primary axes are named 'yaxis', 'yaxis2', 'yaxis3', etc. (plotly auto-generates these for facets)
+            # - We use +100 offset (yaxis101, yaxis102, ...) to avoid conflicts with plotly's auto-numbering
+            # - Each secondary axis 'overlays' its corresponding primary axis and anchors to the same x-axis
+            # - This allows charge_state lines to share the subplot with power bars but use independent scales
             for i, primary_key in enumerate(sorted(primary_yaxes, key=lambda x: int(x[5:]) if x[5:] else 0)):
                 primary_num = primary_key[5:] if primary_key[5:] else '1'
                 secondary_num = int(primary_num) + 100

flixopt/structure.py

@@ -266,10 +266,12 @@ def sum_temporal(self, data: xr.DataArray) -> xr.DataArray:
 
     @property
     def scenario_weights(self) -> xr.DataArray:
-        """
-        Scenario weights of model (always normalized, via FlowSystem).
+        """Scenario weights of model.
 
-        Returns unit weights if no scenarios defined or no explicit weights set.
+        Returns:
+            - Scalar 1 if no scenarios defined
+            - Unit weights (all 1.0) if scenarios exist but no explicit weights set
+            - Normalized explicit weights if set via FlowSystem.scenario_weights
         """
         if self.flow_system.scenarios is None:
             return xr.DataArray(1)

flixopt/transform_accessor.py

@@ -925,8 +925,6 @@ def _build_cluster_weight_for_key(key: tuple) -> xr.DataArray:
                 da = self._combine_slices_to_dataarray_2d(
                     slices=typical_das[name],
                     original_da=original_da,
-                    cluster_coords=cluster_coords,
-                    time_coords=time_coords,
                     periods=periods,
                     scenarios=scenarios,
                 )
@@ -1160,8 +1158,6 @@ def _combine_slices_to_dataarray_generic(
     def _combine_slices_to_dataarray_2d(
         slices: dict[tuple, xr.DataArray],
         original_da: xr.DataArray,
-        cluster_coords: np.ndarray,
-        time_coords: np.ndarray,
         periods: list,
         scenarios: list,
     ) -> xr.DataArray:
@@ -1170,8 +1166,6 @@ def _combine_slices_to_dataarray_2d(
         Args:
             slices: Dict mapping (period, scenario) tuples to DataArrays with (cluster, time) dims.
             original_da: Original DataArray to get attrs from.
-            cluster_coords: Cluster coordinate values.
-            time_coords: Within-cluster time coordinate values.
             periods: List of period labels ([None] if no periods dimension).
             scenarios: List of scenario labels ([None] if no scenarios dimension).