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

flixopt/effects.py

@@ -7,13 +7,13 @@ which are then transformed into the internal data structure.
 
 import logging
 import warnings
-from typing import TYPE_CHECKING, Dict, Iterator, List, Literal, Optional, Union
+from typing import TYPE_CHECKING, Dict, Iterator, List, Literal, Optional, Set, Tuple, Union
 
 import linopy
 import numpy as np
-import pandas as pd
+import xarray as xr
 
-from .core import NumericData, NumericDataTS, Scalar, TimeSeries, TimeSeriesCollection
+from .core import NumericDataTS, ScenarioData, TimeSeries, TimeSeriesCollection, TimestepData, extract_data
 from .features import ShareAllocationModel
 from .structure import Element, ElementModel, Interface, Model, SystemModel, register_class_for_io
 
@@ -38,16 +38,16 @@ class Effect(Element):
         meta_data: Optional[Dict] = None,
         is_standard: bool = False,
         is_objective: bool = False,
-        specific_share_to_other_effects_operation: Optional['EffectValuesUser'] = None,
-        specific_share_to_other_effects_invest: Optional['EffectValuesUser'] = None,
-        minimum_operation: Optional[Scalar] = None,
-        maximum_operation: Optional[Scalar] = None,
-        minimum_invest: Optional[Scalar] = None,
-        maximum_invest: Optional[Scalar] = None,
+        specific_share_to_other_effects_operation: Optional['EffectValuesUserTimestep'] = None,
+        specific_share_to_other_effects_invest: Optional['EffectValuesUserScenario'] = None,
+        minimum_operation: Optional[ScenarioData] = None,
+        maximum_operation: Optional[ScenarioData] = None,
+        minimum_invest: Optional[ScenarioData] = None,
+        maximum_invest: Optional[ScenarioData] = None,
         minimum_operation_per_hour: Optional[NumericDataTS] = None,
         maximum_operation_per_hour: Optional[NumericDataTS] = None,
-        minimum_total: Optional[Scalar] = None,
-        maximum_total: Optional[Scalar] = None,
+        minimum_total: Optional[ScenarioData] = None,
+        maximum_total: Optional[ScenarioData] = None,
     ):
         """
         Args:
@@ -76,10 +76,12 @@ class Effect(Element):
         self.description = description
         self.is_standard = is_standard
         self.is_objective = is_objective
-        self.specific_share_to_other_effects_operation: EffectValuesUser = (
+        self.specific_share_to_other_effects_operation: EffectValuesUserTimestep = (
             specific_share_to_other_effects_operation or {}
         )
-        self.specific_share_to_other_effects_invest: EffectValuesUser = specific_share_to_other_effects_invest or {}
+        self.specific_share_to_other_effects_invest: EffectValuesUserTimestep = (
+            specific_share_to_other_effects_invest or {}
+        )
         self.minimum_operation = minimum_operation
         self.maximum_operation = maximum_operation
         self.minimum_operation_per_hour: NumericDataTS = minimum_operation_per_hour
@@ -96,11 +98,33 @@ class Effect(Element):
         self.maximum_operation_per_hour = flow_system.create_time_series(
             f'{self.label_full}|maximum_operation_per_hour', self.maximum_operation_per_hour, flow_system
         )
-
         self.specific_share_to_other_effects_operation = flow_system.create_effect_time_series(
             f'{self.label_full}|operation->', self.specific_share_to_other_effects_operation, 'operation'
         )
 
+        self.minimum_operation = flow_system.create_time_series(
+            f'{self.label_full}|minimum_operation', self.minimum_operation, has_time_dim=False
+        )
+        self.maximum_operation = flow_system.create_time_series(
+            f'{self.label_full}|maximum_operation', self.maximum_operation, has_time_dim=False
+        )
+        self.minimum_invest = flow_system.create_time_series(
+            f'{self.label_full}|minimum_invest', self.minimum_invest, has_time_dim=False
+        )
+        self.maximum_invest = flow_system.create_time_series(
+            f'{self.label_full}|maximum_invest', self.maximum_invest, has_time_dim=False
+        )
+        self.minimum_total = flow_system.create_time_series(
+            f'{self.label_full}|minimum_total', self.minimum_total, has_time_dim=False,
+        )
+        self.maximum_total = flow_system.create_time_series(
+            f'{self.label_full}|maximum_total', self.maximum_total, has_time_dim=False
+        )
+        self.specific_share_to_other_effects_invest = flow_system.create_effect_time_series(
+            f'{self.label_full}|invest->', self.specific_share_to_other_effects_invest, 'invest',
+            has_time_dim=False
+        )
+
     def create_model(self, model: SystemModel) -> 'EffectModel':
         self._plausibility_checks()
         self.model = EffectModel(model, self)
@@ -118,31 +142,29 @@ class EffectModel(ElementModel):
         self.total: Optional[linopy.Variable] = None
         self.invest: ShareAllocationModel = self.add(
             ShareAllocationModel(
-                self._model,
-                False,
-                self.label_of_element,
-                'invest',
+                model=self._model,
+                has_time_dim=False,
+                has_scenario_dim=True,
+                label_of_element=self.label_of_element,
+                label='invest',
                 label_full=f'{self.label_full}(invest)',
-                total_max=self.element.maximum_invest,
-                total_min=self.element.minimum_invest,
+                total_max=extract_data(self.element.maximum_invest),
+                total_min=extract_data(self.element.minimum_invest),
             )
         )
 
         self.operation: ShareAllocationModel = self.add(
             ShareAllocationModel(
-                self._model,
-                True,
-                self.label_of_element,
-                'operation',
+                model=self._model,
+                has_time_dim=True,
+                has_scenario_dim=True,
+                label_of_element=self.label_of_element,
+                label='operation',
                 label_full=f'{self.label_full}(operation)',
-                total_max=self.element.maximum_operation,
-                total_min=self.element.minimum_operation,
-                min_per_hour=self.element.minimum_operation_per_hour.active_data
-                if self.element.minimum_operation_per_hour is not None
-                else None,
-                max_per_hour=self.element.maximum_operation_per_hour.active_data
-                if self.element.maximum_operation_per_hour is not None
-                else None,
+                total_max=extract_data(self.element.maximum_operation),
+                total_min=extract_data(self.element.minimum_operation),
+                min_per_hour=extract_data(self.element.minimum_operation_per_hour),
+                max_per_hour=extract_data(self.element.maximum_operation_per_hour),
             )
         )
 
@@ -152,9 +174,9 @@ class EffectModel(ElementModel):
 
         self.total = self.add(
             self._model.add_variables(
-                lower=self.element.minimum_total if self.element.minimum_total is not None else -np.inf,
-                upper=self.element.maximum_total if self.element.maximum_total is not None else np.inf,
-                coords=None,
+                lower=extract_data(self.element.minimum_total, if_none=-np.inf),
+                upper=extract_data(self.element.maximum_total, if_none=np.inf),
+                coords=self._model.get_coords(time_dim=False),
                 name=f'{self.label_full}|total',
             ),
             'total',
@@ -162,7 +184,7 @@ class EffectModel(ElementModel):
 
         self.add(
             self._model.add_constraints(
-                self.total == self.operation.total.sum() + self.invest.total.sum(), name=f'{self.label_full}|total'
+                self.total == self.operation.total + self.invest.total, name=f'{self.label_full}|total'
             ),
             'total',
         )
@@ -171,11 +193,12 @@ class EffectModel(ElementModel):
 EffectValuesExpr = Dict[str, linopy.LinearExpression]  # Used to create Shares
 EffectTimeSeries = Dict[str, TimeSeries]  # Used internally to index values
 EffectValuesDict = Dict[str, NumericDataTS]  # How effect values are stored
-EffectValuesUser = Union[NumericDataTS, Dict[str, NumericDataTS]]  # User-specified Shares to Effects
-""" This datatype is used to define the share to an effect by a certain attribute. """
 
-EffectValuesUserScalar = Union[Scalar, Dict[str, Scalar]]  # User-specified Shares to Effects
-""" This datatype is used to define the share to an effect by a certain attribute. Only scalars are allowed. """
+EffectValuesUserScenario = Union[ScenarioData, Dict[str, ScenarioData]]
+""" This datatype is used to define the share to an effect for every scenario. """
+
+EffectValuesUserTimestep = Union[TimestepData, Dict[str, TimestepData]]
+""" This datatype is used to define the share to an effect for every timestep. """
 
 
 class EffectCollection:
@@ -207,7 +230,9 @@ class EffectCollection:
             self._effects[effect.label] = effect
             logger.info(f'Registered new Effect: {effect.label}')
 
-    def create_effect_values_dict(self, effect_values_user: EffectValuesUser) -> Optional[EffectValuesDict]:
+    def create_effect_values_dict(
+        self, effect_values_user: Union[EffectValuesUserScenario, EffectValuesUserTimestep]
+    ) -> Optional[EffectValuesDict]:
         """
         Converts effect values into a dictionary. If a scalar is provided, it is associated with a default effect type.
 
@@ -244,26 +269,18 @@ class EffectCollection:
 
     def _plausibility_checks(self) -> None:
         # Check circular loops in effects:
-        # TODO: Improve checks!! Only most basic case covered...
+        operation, invest = self.calculate_effect_share_factors()
 
-        def error_str(effect_label: str, share_ffect_label: str):
-            return (
-                f'  {effect_label} -> has share in: {share_ffect_label}\n'
-                f'  {share_ffect_label} -> has share in: {effect_label}'
-            )
+        operation_cycles = detect_cycles(tuples_to_adjacency_list([key for key in operation]))
+        invest_cycles = detect_cycles(tuples_to_adjacency_list([key for key in invest]))
 
-        for effect in self.effects.values():
-            # Effekt darf nicht selber als Share in seinen ShareEffekten auftauchen:
-            # operation:
-            for target_effect in effect.specific_share_to_other_effects_operation.keys():
-                assert effect not in self[target_effect].specific_share_to_other_effects_operation.keys(), (
-                    f'Error: circular operation-shares \n{error_str(target_effect.label, target_effect.label)}'
-                )
-            # invest:
-            for target_effect in effect.specific_share_to_other_effects_invest.keys():
-                assert effect not in self[target_effect].specific_share_to_other_effects_invest.keys(), (
-                    f'Error: circular invest-shares \n{error_str(target_effect.label, target_effect.label)}'
-                )
+        if operation_cycles:
+            cycle_str = "\n".join([" -> ".join(cycle) for cycle in operation_cycles])
+            raise ValueError(f'Error: circular operation-shares detected:\n{cycle_str}')
+
+        if invest_cycles:
+            cycle_str = "\n".join([" -> ".join(cycle) for cycle in invest_cycles])
+            raise ValueError(f'Error: circular invest-shares detected:\n{cycle_str}')
 
     def __getitem__(self, effect: Union[str, Effect]) -> 'Effect':
         """
@@ -327,6 +344,30 @@ class EffectCollection:
             raise ValueError(f'An objective-effect already exists! ({self._objective_effect.label=})')
         self._objective_effect = value
 
+    def calculate_effect_share_factors(self) -> Tuple[
+        Dict[Tuple[str, str], xr.DataArray],
+        Dict[Tuple[str, str], xr.DataArray],
+    ]:
+        shares_invest = {}
+        for name, effect in self.effects.items():
+            if effect.specific_share_to_other_effects_invest:
+                shares_invest[name] = {
+                    target: extract_data(data)
+                    for target, data in effect.specific_share_to_other_effects_invest.items()
+                }
+        shares_invest = calculate_all_conversion_paths(shares_invest)
+
+        shares_operation = {}
+        for name, effect in self.effects.items():
+            if effect.specific_share_to_other_effects_operation:
+                shares_operation[name] = {
+                    target: extract_data(data)
+                    for target, data in effect.specific_share_to_other_effects_operation.items()
+                }
+        shares_operation = calculate_all_conversion_paths(shares_operation)
+
+        return shares_operation, shares_invest
+
 
 class EffectCollectionModel(Model):
     """
@@ -346,29 +387,42 @@ class EffectCollectionModel(Model):
     ) -> None:
         for effect, expression in expressions.items():
             if target == 'operation':
-                self.effects[effect].model.operation.add_share(name, expression)
+                self.effects[effect].model.operation.add_share(
+                    name,
+                    expression,
+                    has_time_dim=True,
+                    has_scenario_dim=True,
+                )
             elif target == 'invest':
-                self.effects[effect].model.invest.add_share(name, expression)
+                self.effects[effect].model.invest.add_share(
+                    name,
+                    expression,
+                    has_time_dim=False,
+                    has_scenario_dim=True,
+                )
             else:
                 raise ValueError(f'Target {target} not supported!')
 
     def add_share_to_penalty(self, name: str, expression: linopy.LinearExpression) -> None:
         if expression.ndim != 0:
             raise TypeError(f'Penalty shares must be scalar expressions! ({expression.ndim=})')
-        self.penalty.add_share(name, expression)
+        self.penalty.add_share(name, expression, has_time_dim=False, has_scenario_dim=False)
 
     def do_modeling(self):
         for effect in self.effects:
             effect.create_model(self._model)
         self.penalty = self.add(
-            ShareAllocationModel(self._model, shares_are_time_series=False, label_of_element='Penalty')
+            ShareAllocationModel(self._model, has_time_dim=False, has_scenario_dim=False, label_of_element='Penalty')
         )
         for model in [effect.model for effect in self.effects] + [self.penalty]:
             model.do_modeling()
 
         self._add_share_between_effects()
 
-        self._model.add_objective(self.effects.objective_effect.model.total + self.penalty.total)
+        self._model.add_objective(
+            (self.effects.objective_effect.model.total * self._model.scenario_weights).sum()
+            + self.penalty.total.sum()
+        )
 
     def _add_share_between_effects(self):
         for origin_effect in self.effects:
@@ -376,11 +430,161 @@ class EffectCollectionModel(Model):
             for target_effect, time_series in origin_effect.specific_share_to_other_effects_operation.items():
                 self.effects[target_effect].model.operation.add_share(
                     origin_effect.model.operation.label_full,
-                    origin_effect.model.operation.total_per_timestep * time_series.active_data,
+                    origin_effect.model.operation.total_per_timestep * time_series.selected_data,
+                    has_time_dim=True,
+                    has_scenario_dim=True,
                 )
             # 2. invest:    -> hier ist es Scalar (share)
             for target_effect, factor in origin_effect.specific_share_to_other_effects_invest.items():
                 self.effects[target_effect].model.invest.add_share(
                     origin_effect.model.invest.label_full,
                     origin_effect.model.invest.total * factor,
+                    has_time_dim=False,
+                    has_scenario_dim=True,
                 )
+
+
+def calculate_all_conversion_paths(
+        conversion_dict: Dict[str, Dict[str, xr.DataArray]],
+) -> Dict[Tuple[str, str], xr.DataArray]:
+    """
+    Calculates all possible direct and indirect conversion factors between units/domains.
+    This function uses Breadth-First Search (BFS) to find all possible conversion paths
+    between different units or domains in a conversion graph. It computes both direct
+    conversions (explicitly provided in the input) and indirect conversions (derived
+    through intermediate units).
+    Args:
+        conversion_dict: A nested dictionary where:
+            - Outer keys represent origin units/domains
+            - Inner dictionaries map target units/domains to their conversion factors
+            - Conversion factors can be integers, floats, or numpy arrays
+    Returns:
+        A dictionary mapping (origin, target) tuples to their respective conversion factors.
+        Each key is a tuple of strings representing the origin and target units/domains.
+        Each value is the conversion factor (int, float, or numpy array) from origin to target.
+    """
+    # Initialize the result dictionary to accumulate all paths
+    result = {}
+
+    # Add direct connections to the result first
+    for origin, targets in conversion_dict.items():
+        for target, factor in targets.items():
+            result[(origin, target)] = factor
+
+    # Track all paths by keeping path history to avoid cycles
+    # Iterate over each domain in the dictionary
+    for origin in conversion_dict:
+        # Keep track of visited paths to avoid repeating calculations
+        processed_paths = set()
+        # Use a queue with (current_domain, factor, path_history)
+        queue = [(origin, 1, [origin])]
+
+        while queue:
+            current_domain, factor, path = queue.pop(0)
+
+            # Skip if we've processed this exact path before
+            path_key = tuple(path)
+            if path_key in processed_paths:
+                continue
+            processed_paths.add(path_key)
+
+            # Iterate over the neighbors of the current domain
+            for target, conversion_factor in conversion_dict.get(current_domain, {}).items():
+                # Skip if target would create a cycle
+                if target in path:
+                    continue
+
+                # Calculate the indirect conversion factor
+                indirect_factor = factor * conversion_factor
+                new_path = path + [target]
+
+                # Only consider paths starting at origin and ending at some target
+                if len(new_path) > 2 and new_path[0] == origin:
+                    # Update the result dictionary - accumulate factors from different paths
+                    if (origin, target) in result:
+                        result[(origin, target)] = result[(origin, target)] + indirect_factor
+                    else:
+                        result[(origin, target)] = indirect_factor
+
+                # Add new path to queue for further exploration
+                queue.append((target, indirect_factor, new_path))
+
+    # Convert all values to DataArrays
+    result = {key: value if isinstance(value, xr.DataArray) else xr.DataArray(value)
+              for key, value in result.items()}
+
+    return result
+
+
+def detect_cycles(graph: Dict[str, List[str]]) -> List[List[str]]:
+    """
+    Detects cycles in a directed graph using DFS.
+
+    Args:
+        graph: Adjacency list representation of the graph
+
+    Returns:
+        List of cycles found, where each cycle is a list of nodes
+    """
+    # Track nodes in current recursion stack
+    visiting = set()
+    # Track nodes that have been fully explored
+    visited = set()
+    # Store all found cycles
+    cycles = []
+
+    def dfs_find_cycles(node, path=None):
+        if path is None:
+            path = []
+
+        # Current path to this node
+        current_path = path + [node]
+        # Add node to current recursion stack
+        visiting.add(node)
+
+        # Check all neighbors
+        for neighbor in graph.get(node, []):
+            # If neighbor is in current path, we found a cycle
+            if neighbor in visiting:
+                # Get the cycle by extracting the relevant portion of the path
+                cycle_start = current_path.index(neighbor)
+                cycle = current_path[cycle_start:] + [neighbor]
+                cycles.append(cycle)
+            # If neighbor hasn't been fully explored, check it
+            elif neighbor not in visited:
+                dfs_find_cycles(neighbor, current_path)
+
+        # Remove node from current path and mark as fully explored
+        visiting.remove(node)
+        visited.add(node)
+
+    # Check each unvisited node
+    for node in graph:
+        if node not in visited:
+            dfs_find_cycles(node)
+
+    return cycles
+
+
+def tuples_to_adjacency_list(edges: List[Tuple[str, str]]) -> Dict[str, List[str]]:
+    """
+    Converts a list of edge tuples (source, target) to an adjacency list representation.
+
+    Args:
+        edges: List of (source, target) tuples representing directed edges
+
+    Returns:
+        Dictionary mapping each source node to a list of its target nodes
+    """
+    graph = {}
+
+    for source, target in edges:
+        if source not in graph:
+            graph[source] = []
+        graph[source].append(target)
+
+        # Ensure target nodes with no outgoing edges are in the graph
+        if target not in graph:
+            graph[target] = []
+
+    return graph