Feature/v3/several improvements

examples/03_Calculation_types/example_calculation_types.py

@@ -46,7 +46,7 @@
     # TimeSeriesData objects
     TS_heat_demand = fx.TimeSeriesData(heat_demand)
     TS_electricity_demand = fx.TimeSeriesData(electricity_demand, aggregation_weight=0.7)
-    TS_electricity_price_sell = fx.TimeSeriesData(-(electricity_demand - 0.5), aggregation_group='p_el')
+    TS_electricity_price_sell = fx.TimeSeriesData(-(electricity_price - 0.5), aggregation_group='p_el')
     TS_electricity_price_buy = fx.TimeSeriesData(electricity_price + 0.5, aggregation_group='p_el')
 
     flow_system = fx.FlowSystem(timesteps)

examples/05_Two-stage-optimization/two_stage_optimization.py

@@ -118,6 +118,7 @@
     calculation_sizing.solve(fx.solvers.HighsSolver(0.1 / 100, 600))
     timer_sizing = timeit.default_timer() - start
 
+    start = timeit.default_timer()
     calculation_dispatch = fx.FullCalculation('Sizing', flow_system)
     calculation_dispatch.do_modeling()
     calculation_dispatch.fix_sizes(calculation_sizing.results.solution)

flixopt/calculation.py

@@ -556,7 +556,7 @@ def _create_sub_calculations(self):
         for i, (segment_name, timesteps_of_segment) in enumerate(
             zip(self.segment_names, self._timesteps_per_segment, strict=True)
         ):
-            calc = FullCalculation(f'{self.name}-{segment_name}', self.flow_system.sel(timesteps_of_segment))
+            calc = FullCalculation(f'{self.name}-{segment_name}', self.flow_system.sel(time=timesteps_of_segment))
             calc.flow_system._connect_network()  # Connect to have Correct names of Flows!
 
             self.sub_calculations.append(calc)

flixopt/components.py

@@ -472,36 +472,39 @@ def _plausibility_checks(self) -> None:
         Check for infeasible or uncommon combinations of parameters
         """
         super()._plausibility_checks()
+
+        # Validate string values and set flag
+        initial_is_last = False
         if isinstance(self.initial_charge_state, str):
-            if self.initial_charge_state != 'lastValueOfSim':
+            if self.initial_charge_state == 'lastValueOfSim':
+                initial_is_last = True
+            else:
                 raise PlausibilityError(f'initial_charge_state has undefined value: {self.initial_charge_state}')
-            return
+
+        # Use new InvestParameters methods to get capacity bounds
         if isinstance(self.capacity_in_flow_hours, InvestParameters):
-            if self.capacity_in_flow_hours.fixed_size is None:
-                maximum_capacity = self.capacity_in_flow_hours.maximum_size
-                minimum_capacity = self.capacity_in_flow_hours.minimum_size
-            else:
-                maximum_capacity = self.capacity_in_flow_hours.fixed_size
-                minimum_capacity = self.capacity_in_flow_hours.fixed_size
+            minimum_capacity = self.capacity_in_flow_hours.minimum_or_fixed_size
+            maximum_capacity = self.capacity_in_flow_hours.maximum_or_fixed_size
         else:
             maximum_capacity = self.capacity_in_flow_hours
             minimum_capacity = self.capacity_in_flow_hours
 
-        # initial capacity >= allowed min for maximum_size:
+        # Initial capacity should not constraint investment decision
         minimum_initial_capacity = maximum_capacity * self.relative_minimum_charge_state.isel(time=0)
-        # initial capacity <= allowed max for minimum_size:
         maximum_initial_capacity = minimum_capacity * self.relative_maximum_charge_state.isel(time=0)
 
-        if (self.initial_charge_state > maximum_initial_capacity).any():
-            raise ValueError(
-                f'{self.label_full}: {self.initial_charge_state=} '
-                f'is above allowed maximum charge_state {maximum_initial_capacity}'
-            )
-        if (self.initial_charge_state < minimum_initial_capacity).any():
-            raise ValueError(
-                f'{self.label_full}: {self.initial_charge_state=} '
-                f'is below allowed minimum charge_state {minimum_initial_capacity}'
-            )
+        # Only perform numeric comparisons if not using 'lastValueOfSim'
+        if not initial_is_last:
+            if (self.initial_charge_state > maximum_initial_capacity).any():
+                raise PlausibilityError(
+                    f'{self.label_full}: {self.initial_charge_state=} '
+                    f'is constraining the investment decision. Chosse a value above {maximum_initial_capacity}'
+                )
+            if (self.initial_charge_state < minimum_initial_capacity).any():
+                raise PlausibilityError(
+                    f'{self.label_full}: {self.initial_charge_state=} '
+                    f'is constraining the investment decision. Chosse a value below {minimum_initial_capacity}'
+                )
 
         if self.balanced:
             if not isinstance(self.charging.size, InvestParameters) or not isinstance(
@@ -736,8 +739,9 @@ def _do_modeling(self):
     def create_transmission_equation(self, name: str, in_flow: Flow, out_flow: Flow) -> linopy.Constraint:
         """Creates an Equation for the Transmission efficiency and adds it to the model"""
         # eq: out(t) + on(t)*loss_abs(t) = in(t)*(1 - loss_rel(t))
+        rel_losses = 0 if self.element.relative_losses is None else self.element.relative_losses
         con_transmission = self.add_constraints(
-            out_flow.submodel.flow_rate == -in_flow.submodel.flow_rate * (self.element.relative_losses - 1),
+            out_flow.submodel.flow_rate == in_flow.submodel.flow_rate * (1 - rel_losses),
             short_name=name,
         )
 

flixopt/core.py

@@ -142,12 +142,12 @@ def __repr__(self):
     @property
     def agg_group(self):
         warnings.warn('agg_group is deprecated, use aggregation_group instead', DeprecationWarning, stacklevel=2)
-        return self._aggregation_group
+        return self.aggregation_group
 
     @property
     def agg_weight(self):
         warnings.warn('agg_weight is deprecated, use aggregation_weight instead', DeprecationWarning, stacklevel=2)
-        return self._aggregation_weight
+        return self.aggregation_weight
 
 
 TemporalDataUser = (
@@ -606,19 +606,36 @@ def get_dataarray_stats(arr: xr.DataArray) -> dict:
     return stats
 
 
-def drop_constant_arrays(ds: xr.Dataset, dim='time', drop_arrays_without_dim: bool = True):
-    """Drop variables with very low variance (near-constant)."""
+def drop_constant_arrays(ds: xr.Dataset, dim: str = 'time', drop_arrays_without_dim: bool = True) -> xr.Dataset:
+    """Drop variables with constant values along a dimension.
+
+    Args:
+        ds: Input dataset to filter.
+        dim: Dimension along which to check for constant values.
+        drop_arrays_without_dim: If True, also drop variables that don't have the specified dimension.
+
+    Returns:
+        Dataset with constant variables removed.
+    """
     drop_vars = []
 
     for name, da in ds.data_vars.items():
-        if dim in da.dims:
-            if da.max(dim) == da.min(dim):
+        # Skip variables without the dimension
+        if dim not in da.dims:
+            if drop_arrays_without_dim:
                 drop_vars.append(name)
             continue
-        elif drop_arrays_without_dim:
+
+        # Check if variable is constant along the dimension
+        if (da.max(dim, skipna=True) == da.min(dim, skipna=True)).all().item():
             drop_vars.append(name)
 
-    logger.debug(f'Dropping {len(drop_vars)} arrays with constant values')
+    if drop_vars:
+        drop_vars = sorted(drop_vars)
+        logger.debug(
+            f'Dropping {len(drop_vars)} constant/dimension-less arrays: {drop_vars[:5]}{"..." if len(drop_vars) > 5 else ""}'
+        )
+
     return ds.drop_vars(drop_vars)
 
 

flixopt/elements.py

@@ -13,9 +13,9 @@
 
 from .config import CONFIG
 from .core import PlausibilityError, Scalar, TemporalData, TemporalDataUser
-from .features import InvestmentModel, ModelingPrimitives, OnOffModel
+from .features import InvestmentModel, OnOffModel
 from .interface import InvestParameters, OnOffParameters
-from .modeling import BoundingPatterns, ModelingUtilitiesAbstract
+from .modeling import BoundingPatterns, ModelingPrimitives, ModelingUtilitiesAbstract
 from .structure import Element, ElementModel, FlowSystemModel, register_class_for_io
 
 if TYPE_CHECKING:

flixopt/modeling.py

@@ -53,49 +53,67 @@ def to_binary(
 
     @staticmethod
     def count_consecutive_states(
-        binary_values: xr.DataArray,
+        binary_values: xr.DataArray | np.ndarray | list[int, float],
         dim: str = 'time',
-        epsilon: float = None,
+        epsilon: float | None = None,
     ) -> float:
-        """
-        Counts the number of consecutive states in a binary time series.
+        """Count consecutive steps in the final active state of a binary time series.
+
+        This function counts how many consecutive time steps the series remains "on"
+        (non-zero) at the end of the time series. If the final state is "off", returns 0.
 
         Args:
-            binary_values: Binary DataArray
-            dim: Dimension to count consecutive states over
-            epsilon: Tolerance for zero detection (uses CONFIG.modeling.EPSILON if None)
+            binary_values: Binary DataArray with values close to 0 (off) or 1 (on).
+            dim: Dimension along which to count consecutive states.
+            epsilon: Tolerance for zero detection. Uses CONFIG.modeling.EPSILON if None.
 
         Returns:
-            The consecutive number of steps spent in the final state of the timeseries
-        """
-        if epsilon is None:
-            epsilon = CONFIG.modeling.EPSILON
+            Sum of values in the final consecutive "on" period. Returns 0.0 if the
+            final state is "off".
+
+        Examples:
+            >>> arr = xr.DataArray([0, 0, 1, 1, 1, 0, 1, 1], dims=['time'])
+            >>> ModelingUtilitiesAbstract.count_consecutive_states(arr)
+            2.0
 
-        binary_values = binary_values.any(dim=[d for d in binary_values.dims if d != dim])
+            >>> arr = [0, 0, 1, 0, 1, 1, 1, 1]
+            >>> ModelingUtilitiesAbstract.count_consecutive_states(arr)
+            4.0
+        """
+        epsilon = epsilon or CONFIG.modeling.EPSILON
+
+        if isinstance(binary_values, xr.DataArray):
+            # xarray path
+            other_dims = [d for d in binary_values.dims if d != dim]
+            if other_dims:
+                binary_values = binary_values.any(dim=other_dims)
+            arr = binary_values.values
+        else:
+            # numpy/array-like path
+            arr = np.asarray(binary_values)
 
-        # Handle scalar case
-        if binary_values.ndim == 0:
-            return float(binary_values.item())
+        # Flatten to 1D if needed
+        arr = arr.ravel() if arr.ndim > 1 else arr
 
-        # Check if final state is off
-        if np.isclose(binary_values.isel({dim: -1}), 0, atol=epsilon).all():
+        # Handle edge cases
+        if arr.size == 0:
             return 0.0
+        if arr.size == 1:
+            return float(arr[0]) if not np.isclose(arr[0], 0, atol=epsilon) else 0.0
 
-        # Find consecutive 'on' period from the end
-        is_zero = np.isclose(binary_values, 0, atol=epsilon)
+        # Return 0 if final state is off
+        if np.isclose(arr[-1], 0, atol=epsilon):
+            return 0.0
 
-        # Find the last zero, then sum everything after it
+        # Find the last zero position (treat NaNs as off)
+        arr = np.nan_to_num(arr, nan=0.0)
+        is_zero = np.isclose(arr, 0, atol=epsilon)
         zero_indices = np.where(is_zero)[0]
-        if len(zero_indices) == 0:
-            # All 'on' - sum everything
-            start_idx = 0
-        else:
-            # Start after last zero
-            start_idx = zero_indices[-1] + 1
 
-        consecutive_values = binary_values.isel({dim: slice(start_idx, None)})
+        # Calculate sum from last zero to end
+        start_idx = zero_indices[-1] + 1 if zero_indices.size > 0 else 0
 
-        return float(consecutive_values.sum().item())  # TODO: Som only over one dim?
+        return float(np.sum(arr[start_idx:]))
 
 
 class ModelingUtilities:
@@ -308,7 +326,13 @@ def consecutive_duration_tracking(
             )
 
             # Handle initial condition for minimum duration
-            if previous_duration > 0 and previous_duration < minimum_duration.isel({duration_dim: 0}).max():
+            prev = (
+                float(previous_duration)
+                if not isinstance(previous_duration, xr.DataArray)
+                else float(previous_duration.max().item())
+            )
+            min0 = float(minimum_duration.isel({duration_dim: 0}).max().item())
+            if prev > 0 and prev < min0:
                 constraints['initial_lb'] = model.add_constraints(
                     state_variable.isel({duration_dim: 0}) == 1, name=f'{duration.name}|initial_lb'
                 )
@@ -435,7 +459,7 @@ def bounds_with_state(
         lower_bound, upper_bound = bounds
         name = name or f'{variable.name}'
 
-        if np.all(lower_bound - upper_bound) < 1e-10:
+        if np.allclose(lower_bound, upper_bound, atol=1e-10, equal_nan=True):
             fix_constraint = model.add_constraints(variable == variable_state * upper_bound, name=f'{name}|fix')
             return [fix_constraint]
 
@@ -481,7 +505,7 @@ def scaled_bounds(
         rel_lower, rel_upper = relative_bounds
         name = name or f'{variable.name}'
 
-        if np.abs(rel_lower - rel_upper).all() < 10e-10:
+        if np.allclose(rel_lower, rel_upper, atol=1e-10, equal_nan=True):
             return [model.add_constraints(variable == scaling_variable * rel_lower, name=f'{name}|fixed')]
 
         upper_constraint = model.add_constraints(variable <= scaling_variable * rel_upper, name=f'{name}|ub')

flixopt/results.py

@@ -291,17 +291,18 @@ def flow_system(self) -> FlowSystem:
         """The restored flow_system that was used to create the calculation.
         Contains all input parameters."""
         if self._flow_system is None:
+            old_level = logger.level
+            logger.level = logging.CRITICAL
             try:
-                current_logger_level = logger.getEffectiveLevel()
-                logger.setLevel(logging.CRITICAL)
                 self._flow_system = FlowSystem.from_dataset(self.flow_system_data)
                 self._flow_system._connect_network()
-                logger.setLevel(current_logger_level)
             except Exception as e:
                 logger.critical(
                     f'Not able to restore FlowSystem from dataset. Some functionality is not availlable. {e}'
                 )
                 raise _FlowSystemRestorationError(f'Not able to restore FlowSystem from dataset. {e}') from e
+            finally:
+                logger.level = old_level
         return self._flow_system
 
     def filter_solution(

flixopt/structure.py

@@ -422,8 +422,9 @@ def _resolve_dataarray_reference(
 
         # Handle null values with warning
         if array.isnull().any():
-            logger.warning(f"DataArray '{array_name}' contains null values. Dropping them.")
-            array = array.dropna(dim='time', how='all')
+            logger.warning(f"DataArray '{array_name}' contains null values. Dropping all-null along present dims.")
+            if 'time' in array.dims:
+                array = array.dropna(dim='time', how='all')
 
         # Check if this should be restored as TimeSeriesData
         if TimeSeriesData.is_timeseries_data(array):

pyproject.toml

@@ -182,7 +182,7 @@ markers = [
     "slow: marks tests as slow",
     "examples: marks example tests (run only on releases)",
 ]
-addopts = "-m 'not examples'"  # Skip examples by default
+addopts = '-m "not examples"'  # Skip examples by default
 
 [tool.bandit]
 skips = ["B101", "B506"]  # assert_used and yaml_load