flixopt 3.2.1__py3-none-any.whl → 3.4.0__py3-none-any.whl

flixopt/calculation.py

@@ -13,13 +13,14 @@ from __future__ import annotations
 import logging
 import math
 import pathlib
+import sys
 import timeit
 import warnings
 from collections import Counter
 from typing import TYPE_CHECKING, Annotated, Any
 
 import numpy as np
-import yaml
+from tqdm import tqdm
 
 from . import io as fx_io
 from .aggregation import Aggregation, AggregationModel, AggregationParameters
@@ -53,6 +54,8 @@ class Calculation:
         active_timesteps: Deprecated. Use FlowSystem.sel(time=...) or FlowSystem.isel(time=...) instead.
     """
 
+    model: FlowSystemModel | None
+
     def __init__(
         self,
         name: str,
@@ -87,7 +90,7 @@ class Calculation:
         flow_system._used_in_calculation = True
 
         self.flow_system = flow_system
-        self.model: FlowSystemModel | None = None
+        self.model = None
 
         self.durations = {'modeling': 0.0, 'solving': 0.0, 'saving': 0.0}
         self.folder = pathlib.Path.cwd() / 'results' if folder is None else pathlib.Path(folder)
@@ -112,7 +115,7 @@ class Calculation:
                     'periodic': effect.submodel.periodic.total.solution.values,
                     'total': effect.submodel.total.solution.values,
                 }
-                for effect in self.flow_system.effects
+                for effect in sorted(self.flow_system.effects.values(), key=lambda e: e.label_full.upper())
             },
             'Invest-Decisions': {
                 'Invested': {
@@ -225,7 +228,7 @@ class FullCalculation(Calculation):
         return self
 
     def solve(
-        self, solver: _Solver, log_file: pathlib.Path | None = None, log_main_results: bool = True
+        self, solver: _Solver, log_file: pathlib.Path | None = None, log_main_results: bool | None = None
     ) -> FullCalculation:
         t_start = timeit.default_timer()
 
@@ -235,6 +238,8 @@ class FullCalculation(Calculation):
             **solver.options,
         )
         self.durations['solving'] = round(timeit.default_timer() - t_start, 2)
+        logger.info(f'Model solved with {solver.name} in {self.durations["solving"]:.2f} seconds.')
+        logger.info(f'Model status after solve: {self.model.status}')
 
         if self.model.status == 'warning':
             # Save the model and the flow_system to file in case of infeasibility
@@ -248,15 +253,13 @@ class FullCalculation(Calculation):
             )
 
         # Log the formatted output
-        if log_main_results:
+        should_log = log_main_results if log_main_results is not None else CONFIG.Solving.log_main_results
+        if should_log:
             logger.info(
                 f'{" Main Results ":#^80}\n'
-                + yaml.dump(
+                + fx_io.format_yaml_string(
                     self.main_results,
-                    default_flow_style=False,
-                    sort_keys=False,
-                    allow_unicode=True,
-                    indent=4,
+                    compact_numeric_lists=True,
                 )
             )
 
@@ -366,7 +369,7 @@ class AggregatedCalculation(FullCalculation):
         )
 
         self.aggregation.cluster()
-        self.aggregation.plot(show=True, save=self.folder / 'aggregation.html')
+        self.aggregation.plot(show=CONFIG.Plotting.default_show, save=self.folder / 'aggregation.html')
         if self.aggregation_parameters.aggregate_data_and_fix_non_binary_vars:
             ds = self.flow_system.to_dataset()
             for name, series in self.aggregation.aggregated_data.items():
@@ -567,48 +570,111 @@ class SegmentedCalculation(Calculation):
                 f'({timesteps_of_segment[0]} -> {timesteps_of_segment[-1]}):'
             )
 
+    def _solve_single_segment(
+        self,
+        i: int,
+        calculation: FullCalculation,
+        solver: _Solver,
+        log_file: pathlib.Path | None,
+        log_main_results: bool,
+        suppress_output: bool,
+    ) -> None:
+        """Solve a single segment calculation."""
+        if i > 0 and self.nr_of_previous_values > 0:
+            self._transfer_start_values(i)
+
+        calculation.do_modeling()
+
+        # Warn about Investments, but only in first run
+        if i == 0:
+            invest_elements = [
+                model.label_full
+                for component in calculation.flow_system.components.values()
+                for model in component.submodel.all_submodels
+                if isinstance(model, InvestmentModel)
+            ]
+            if invest_elements:
+                logger.critical(
+                    f'Investments are not supported in Segmented Calculation! '
+                    f'Following InvestmentModels were found: {invest_elements}'
+                )
+
+        log_path = pathlib.Path(log_file) if log_file is not None else self.folder / f'{self.name}.log'
+
+        if suppress_output:
+            with fx_io.suppress_output():
+                calculation.solve(solver, log_file=log_path, log_main_results=log_main_results)
+        else:
+            calculation.solve(solver, log_file=log_path, log_main_results=log_main_results)
+
     def do_modeling_and_solve(
-        self, solver: _Solver, log_file: pathlib.Path | None = None, log_main_results: bool = False
+        self,
+        solver: _Solver,
+        log_file: pathlib.Path | None = None,
+        log_main_results: bool = False,
+        show_individual_solves: bool = False,
     ) -> SegmentedCalculation:
+        """Model and solve all segments of the segmented calculation.
+
+        This method creates sub-calculations for each time segment, then iteratively
+        models and solves each segment. It supports two output modes: a progress bar
+        for compact output, or detailed individual solve information.
+
+        Args:
+            solver: The solver instance to use for optimization (e.g., Gurobi, HiGHS).
+            log_file: Optional path to the solver log file. If None, defaults to
+                folder/name.log.
+            log_main_results: Whether to log main results (objective, effects, etc.)
+                after each segment solve. Defaults to False.
+            show_individual_solves: If True, shows detailed output for each segment
+                solve with logger messages. If False (default), shows a compact progress
+                bar with suppressed solver output for cleaner display.
+
+        Returns:
+            Self, for method chaining.
+
+        Note:
+            The method automatically transfers all start values between segments to ensure
+            continuity of storage states and flow rates across segment boundaries.
+        """
         logger.info(f'{"":#^80}')
         logger.info(f'{" Segmented Solving ":#^80}')
         self._create_sub_calculations()
 
-        for i, calculation in enumerate(self.sub_calculations):
-            logger.info(
-                f'{self.segment_names[i]} [{i + 1:>2}/{len(self.segment_names):<2}] '
-                f'({calculation.flow_system.timesteps[0]} -> {calculation.flow_system.timesteps[-1]}):'
+        if show_individual_solves:
+            # Path 1: Show individual solves with detailed output
+            for i, calculation in enumerate(self.sub_calculations):
+                logger.info(
+                    f'Solving segment {i + 1}/{len(self.sub_calculations)}: '
+                    f'{calculation.flow_system.timesteps[0]} -> {calculation.flow_system.timesteps[-1]}'
+                )
+                self._solve_single_segment(i, calculation, solver, log_file, log_main_results, suppress_output=False)
+        else:
+            # Path 2: Show only progress bar with suppressed output
+            progress_bar = tqdm(
+                enumerate(self.sub_calculations),
+                total=len(self.sub_calculations),
+                desc='Solving segments',
+                unit='segment',
+                file=sys.stdout,
+                disable=not CONFIG.Solving.log_to_console,
             )
 
-            if i > 0 and self.nr_of_previous_values > 0:
-                self._transfer_start_values(i)
-
-            calculation.do_modeling()
-
-            # Warn about Investments, but only in fist run
-            if i == 0:
-                invest_elements = [
-                    model.label_full
-                    for component in calculation.flow_system.components.values()
-                    for model in component.submodel.all_submodels
-                    if isinstance(model, InvestmentModel)
-                ]
-                if invest_elements:
-                    logger.critical(
-                        f'Investments are not supported in Segmented Calculation! '
-                        f'Following InvestmentModels were found: {invest_elements}'
+            try:
+                for i, calculation in progress_bar:
+                    progress_bar.set_description(
+                        f'Solving ({calculation.flow_system.timesteps[0]} -> {calculation.flow_system.timesteps[-1]})'
                     )
-
-            calculation.solve(
-                solver,
-                log_file=pathlib.Path(log_file) if log_file is not None else self.folder / f'{self.name}.log',
-                log_main_results=log_main_results,
-            )
+                    self._solve_single_segment(i, calculation, solver, log_file, log_main_results, suppress_output=True)
+            finally:
+                progress_bar.close()
 
         for calc in self.sub_calculations:
             for key, value in calc.durations.items():
                 self.durations[key] += value
 
+        logger.info(f'Model solved with {solver.name} in {self.durations["solving"]:.2f} seconds.')
+
         self.results = SegmentedCalculationResults.from_calculation(self)
 
         return self

flixopt/components.py

@@ -11,6 +11,7 @@ from typing import TYPE_CHECKING, Literal
 import numpy as np
 import xarray as xr
 
+from . import io as fx_io
 from .core import PeriodicDataUser, PlausibilityError, TemporalData, TemporalDataUser
 from .elements import Component, ComponentModel, Flow
 from .features import InvestmentModel, PiecewiseModel
@@ -160,6 +161,8 @@ class LinearConverter(Component):
 
     """
 
+    submodel: LinearConverterModel | None
+
     def __init__(
         self,
         label: str,
@@ -376,6 +379,8 @@ class Storage(Component):
         With flow rates in m3/h, the charge state is therefore in m3.
     """
 
+    submodel: StorageModel | None
+
     def __init__(
         self,
         label: str,
@@ -528,6 +533,15 @@ class Storage(Component):
                     f'{self.discharging.size.minimum_size=}, {self.discharging.size.maximum_size=}.'
                 )
 
+    def __repr__(self) -> str:
+        """Return string representation."""
+        # Use build_repr_from_init directly to exclude charging and discharging
+        return fx_io.build_repr_from_init(
+            self,
+            excluded_params={'self', 'label', 'charging', 'discharging', 'kwargs'},
+            skip_default_size=True,
+        ) + fx_io.format_flow_details(self)
+
 
 @register_class_for_io
 class Transmission(Component):
@@ -640,6 +654,8 @@ class Transmission(Component):
 
     """
 
+    submodel: TransmissionModel | None
+
     def __init__(
         self,
         label: str,

flixopt/config.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import os
 import sys
 import warnings
 from logging.handlers import RotatingFileHandler
@@ -63,6 +64,14 @@ _DEFAULTS = MappingProxyType(
                 'default_qualitative_colorscale': 'plotly',
             }
         ),
+        'solving': MappingProxyType(
+            {
+                'mip_gap': 0.01,
+                'time_limit_seconds': 300,
+                'log_to_console': True,
+                'log_main_results': True,
+            }
+        ),
     }
 )
 
@@ -75,6 +84,8 @@ class CONFIG:
     Attributes:
         Logging: Logging configuration.
         Modeling: Optimization modeling parameters.
+        Solving: Solver configuration and default parameters.
+        Plotting: Plotting configuration.
         config_name: Configuration name.
 
     Examples:
@@ -91,6 +102,9 @@ class CONFIG:
           level: DEBUG
           console: true
           file: app.log
+        solving:
+          mip_gap: 0.001
+          time_limit_seconds: 600
         ```
     """
 
@@ -194,6 +208,30 @@ class CONFIG:
         epsilon: float = _DEFAULTS['modeling']['epsilon']
         big_binary_bound: int = _DEFAULTS['modeling']['big_binary_bound']
 
+    class Solving:
+        """Solver configuration and default parameters.
+
+        Attributes:
+            mip_gap: Default MIP gap tolerance for solver convergence.
+            time_limit_seconds: Default time limit in seconds for solver runs.
+            log_to_console: Whether solver should output to console.
+            log_main_results: Whether to log main results after solving.
+
+        Examples:
+            ```python
+            # Set tighter convergence and longer timeout
+            CONFIG.Solving.mip_gap = 0.001
+            CONFIG.Solving.time_limit_seconds = 600
+            CONFIG.Solving.log_to_console = False
+            CONFIG.apply()
+            ```
+        """
+
+        mip_gap: float = _DEFAULTS['solving']['mip_gap']
+        time_limit_seconds: int = _DEFAULTS['solving']['time_limit_seconds']
+        log_to_console: bool = _DEFAULTS['solving']['log_to_console']
+        log_main_results: bool = _DEFAULTS['solving']['log_main_results']
+
     class Plotting:
         """Plotting configuration.
 
@@ -246,6 +284,12 @@ class CONFIG:
         for key, value in _DEFAULTS['modeling'].items():
             setattr(cls.Modeling, key, value)
 
+        for key, value in _DEFAULTS['solving'].items():
+            setattr(cls.Solving, key, value)
+
+        for key, value in _DEFAULTS['plotting'].items():
+            setattr(cls.Plotting, key, value)
+
         cls.config_name = _DEFAULTS['config_name']
         cls.apply()
 
@@ -329,6 +373,12 @@ class CONFIG:
             elif key == 'modeling' and isinstance(value, dict):
                 for nested_key, nested_value in value.items():
                     setattr(cls.Modeling, nested_key, nested_value)
+            elif key == 'solving' and isinstance(value, dict):
+                for nested_key, nested_value in value.items():
+                    setattr(cls.Solving, nested_key, nested_value)
+            elif key == 'plotting' and isinstance(value, dict):
+                for nested_key, nested_value in value.items():
+                    setattr(cls.Plotting, nested_key, nested_value)
             elif hasattr(cls, key):
                 setattr(cls, key, value)
 
@@ -366,6 +416,12 @@ class CONFIG:
                 'epsilon': cls.Modeling.epsilon,
                 'big_binary_bound': cls.Modeling.big_binary_bound,
             },
+            'solving': {
+                'mip_gap': cls.Solving.mip_gap,
+                'time_limit_seconds': cls.Solving.time_limit_seconds,
+                'log_to_console': cls.Solving.log_to_console,
+                'log_main_results': cls.Solving.log_main_results,
+            },
             'plotting': {
                 'default_show': cls.Plotting.default_show,
                 'default_engine': cls.Plotting.default_engine,
@@ -376,6 +432,70 @@ class CONFIG:
             },
         }
 
+    @classmethod
+    def silent(cls) -> type[CONFIG]:
+        """Configure for silent operation.
+
+        Disables console logging, solver output, and result logging
+        for clean production runs. Does not show plots. Automatically calls apply().
+        """
+        cls.Logging.console = False
+        cls.Plotting.default_show = False
+        cls.Logging.file = None
+        cls.Solving.log_to_console = False
+        cls.Solving.log_main_results = False
+        cls.apply()
+        return cls
+
+    @classmethod
+    def debug(cls) -> type[CONFIG]:
+        """Configure for debug mode with verbose output.
+
+        Enables console logging at DEBUG level and all solver output for
+        troubleshooting. Automatically calls apply().
+        """
+        cls.Logging.console = True
+        cls.Logging.level = 'DEBUG'
+        cls.Solving.log_to_console = True
+        cls.Solving.log_main_results = True
+        cls.apply()
+        return cls
+
+    @classmethod
+    def exploring(cls) -> type[CONFIG]:
+        """Configure for exploring flixopt
+
+        Enables console logging at INFO level and all solver output.
+        Also enables browser plotting for plotly with showing plots per default
+        """
+        cls.Logging.console = True
+        cls.Logging.level = 'INFO'
+        cls.Solving.log_to_console = True
+        cls.Solving.log_main_results = True
+        cls.browser_plotting()
+        cls.apply()
+        return cls
+
+    @classmethod
+    def browser_plotting(cls) -> type[CONFIG]:
+        """Configure for interactive usage with plotly to open plots in browser.
+
+        Sets plotly.io.renderers.default = 'browser'. Useful for running examples
+        and viewing interactive plots. Does NOT modify CONFIG.Plotting settings.
+
+        Respects FLIXOPT_CI environment variable if set.
+        """
+        cls.Plotting.default_show = True
+        cls.apply()
+
+        # Only set to True if environment variable hasn't overridden it
+        if 'FLIXOPT_CI' not in os.environ:
+            import plotly.io as pio
+
+            pio.renderers.default = 'browser'
+
+        return cls
+
 
 class MultilineFormatter(logging.Formatter):
     """Formatter that handles multi-line messages with consistent prefixes.

flixopt/effects.py

@@ -16,9 +16,10 @@ import linopy
 import numpy as np
 import xarray as xr
 
+from . import io as fx_io
 from .core import PeriodicDataUser, Scalar, TemporalData, TemporalDataUser
 from .features import ShareAllocationModel
-from .structure import Element, ElementModel, FlowSystemModel, Submodel, register_class_for_io
+from .structure import Element, ElementContainer, ElementModel, FlowSystemModel, Submodel, register_class_for_io
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
@@ -159,6 +160,8 @@ class Effect(Element):
 
     """
 
+    submodel: EffectModel | None
+
     def __init__(
         self,
         label: str,
@@ -448,17 +451,19 @@ PeriodicEffects = dict[str, Scalar]
 EffectExpr = dict[str, linopy.LinearExpression]  # Used to create Shares
 
 
-class EffectCollection:
+class EffectCollection(ElementContainer[Effect]):
     """
     Handling all Effects
     """
 
+    submodel: EffectCollectionModel | None
+
     def __init__(self, *effects: Effect):
-        self._effects = {}
+        super().__init__(element_type_name='effects')
         self._standard_effect: Effect | None = None
         self._objective_effect: Effect | None = None
 
-        self.submodel: EffectCollectionModel | None = None
+        self.submodel = None
         self.add_effects(*effects)
 
     def create_model(self, model: FlowSystemModel) -> EffectCollectionModel:
@@ -474,7 +479,7 @@ class EffectCollection:
                 self.standard_effect = effect
             if effect.is_objective:
                 self.objective_effect = effect
-            self._effects[effect.label] = effect
+            self.add(effect)  # Use the inherited add() method from ElementContainer
             logger.info(f'Registered new Effect: {effect.label}')
 
     def create_effect_values_dict(
@@ -520,10 +525,13 @@ class EffectCollection:
         # Check circular loops in effects:
         temporal, periodic = self.calculate_effect_share_factors()
 
-        # Validate all referenced sources exist
-        unknown = {src for src, _ in list(temporal.keys()) + list(periodic.keys()) if src not in self.effects}
+        # Validate all referenced effects (both sources and targets) exist
+        edges = list(temporal.keys()) + list(periodic.keys())
+        unknown_sources = {src for src, _ in edges if src not in self}
+        unknown_targets = {tgt for _, tgt in edges if tgt not in self}
+        unknown = unknown_sources | unknown_targets
         if unknown:
-            raise KeyError(f'Unknown effects used in in effect share mappings: {sorted(unknown)}')
+            raise KeyError(f'Unknown effects used in effect share mappings: {sorted(unknown)}')
 
         temporal_cycles = detect_cycles(tuples_to_adjacency_list([key for key in temporal]))
         periodic_cycles = detect_cycles(tuples_to_adjacency_list([key for key in periodic]))
@@ -552,31 +560,23 @@ class EffectCollection:
             else:
                 raise KeyError(f'Effect {effect} not found!')
         try:
-            return self.effects[effect]
+            return super().__getitem__(effect)  # Leverage ContainerMixin suggestions
         except KeyError as e:
-            raise KeyError(f'Effect "{effect}" not found! Add it to the FlowSystem first!') from e
-
-    def __iter__(self) -> Iterator[Effect]:
-        return iter(self._effects.values())
+            # Extract the original message and append context for cleaner output
+            original_msg = str(e).strip('\'"')
+            raise KeyError(f'{original_msg} Add the effect to the FlowSystem first.') from None
 
-    def __len__(self) -> int:
-        return len(self._effects)
+    def __iter__(self) -> Iterator[str]:
+        return iter(self.keys())  # Iterate over keys like a normal dict
 
     def __contains__(self, item: str | Effect) -> bool:
         """Check if the effect exists. Checks for label or object"""
         if isinstance(item, str):
-            return item in self.effects  # Check if the label exists
+            return super().__contains__(item)  # Check if the label exists
         elif isinstance(item, Effect):
-            if item.label_full in self.effects:
-                return True
-            if item in self.effects.values():  # Check if the object exists
-                return True
+            return item.label_full in self and self[item.label_full] is item
         return False
 
-    @property
-    def effects(self) -> dict[str, Effect]:
-        return self._effects
-
     @property
     def standard_effect(self) -> Effect:
         if self._standard_effect is None:
@@ -611,7 +611,7 @@ class EffectCollection:
         dict[tuple[str, str], xr.DataArray],
     ]:
         shares_periodic = {}
-        for name, effect in self.effects.items():
+        for name, effect in self.items():
             if effect.share_from_periodic:
                 for source, data in effect.share_from_periodic.items():
                     if source not in shares_periodic:
@@ -620,7 +620,7 @@ class EffectCollection:
         shares_periodic = calculate_all_conversion_paths(shares_periodic)
 
         shares_temporal = {}
-        for name, effect in self.effects.items():
+        for name, effect in self.items():
             if effect.share_from_temporal:
                 for source, data in effect.share_from_temporal.items():
                     if source not in shares_temporal:
@@ -670,7 +670,7 @@ class EffectCollectionModel(Submodel):
 
     def _do_modeling(self):
         super()._do_modeling()
-        for effect in self.effects:
+        for effect in self.effects.values():
             effect.create_model(self._model)
         self.penalty = self.add_submodels(
             ShareAllocationModel(self._model, dims=(), label_of_element='Penalty'),
@@ -684,7 +684,7 @@ class EffectCollectionModel(Submodel):
         )
 
     def _add_share_between_effects(self):
-        for target_effect in self.effects:
+        for target_effect in self.effects.values():
             # 1. temporal: <- receiving temporal shares from other effects
             for source_effect, time_series in target_effect.share_from_temporal.items():
                 target_effect.submodel.temporal.add_share(