flixopt 2.2.0b0__py3-none-any.whl → 2.2.0rc2__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, Set, Tuple, Union
+from typing import TYPE_CHECKING, Dict, Iterator, List, Literal, Optional, Union
 
 import linopy
 import numpy as np
-import xarray as xr
+import pandas as pd
 
-from .core import NumericDataTS, ScenarioData, TimeSeries, TimeSeriesCollection, TimestepData, extract_data
+from .core import NumericData, NumericDataTS, Scalar, TimeSeries, TimeSeriesCollection
 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['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,
+        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,
         minimum_operation_per_hour: Optional[NumericDataTS] = None,
         maximum_operation_per_hour: Optional[NumericDataTS] = None,
-        minimum_total: Optional[ScenarioData] = None,
-        maximum_total: Optional[ScenarioData] = None,
+        minimum_total: Optional[Scalar] = None,
+        maximum_total: Optional[Scalar] = None,
     ):
         """
         Args:
@@ -76,12 +76,10 @@ class Effect(Element):
         self.description = description
         self.is_standard = is_standard
         self.is_objective = is_objective
-        self.specific_share_to_other_effects_operation: EffectValuesUserTimestep = (
+        self.specific_share_to_other_effects_operation: EffectValuesUser = (
             specific_share_to_other_effects_operation or {}
         )
-        self.specific_share_to_other_effects_invest: EffectValuesUserTimestep = (
-            specific_share_to_other_effects_invest or {}
-        )
+        self.specific_share_to_other_effects_invest: EffectValuesUser = 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,35 +94,14 @@ class Effect(Element):
             f'{self.label_full}|minimum_operation_per_hour', self.minimum_operation_per_hour
         )
         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
+            f'{self.label_full}|maximum_operation_per_hour',
+            self.maximum_operation_per_hour,
         )
+
         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)
@@ -142,29 +119,31 @@ class EffectModel(ElementModel):
         self.total: Optional[linopy.Variable] = None
         self.invest: ShareAllocationModel = self.add(
             ShareAllocationModel(
-                model=self._model,
-                has_time_dim=False,
-                has_scenario_dim=True,
-                label_of_element=self.label_of_element,
-                label='invest',
+                self._model,
+                False,
+                self.label_of_element,
+                'invest',
                 label_full=f'{self.label_full}(invest)',
-                total_max=extract_data(self.element.maximum_invest),
-                total_min=extract_data(self.element.minimum_invest),
+                total_max=self.element.maximum_invest,
+                total_min=self.element.minimum_invest,
             )
         )
 
         self.operation: ShareAllocationModel = self.add(
             ShareAllocationModel(
-                model=self._model,
-                has_time_dim=True,
-                has_scenario_dim=True,
-                label_of_element=self.label_of_element,
-                label='operation',
+                self._model,
+                True,
+                self.label_of_element,
+                'operation',
                 label_full=f'{self.label_full}(operation)',
-                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),
+                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,
             )
         )
 
@@ -174,9 +153,9 @@ class EffectModel(ElementModel):
 
         self.total = self.add(
             self._model.add_variables(
-                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),
+                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,
                 name=f'{self.label_full}|total',
             ),
             'total',
@@ -184,7 +163,7 @@ class EffectModel(ElementModel):
 
         self.add(
             self._model.add_constraints(
-                self.total == self.operation.total + self.invest.total, name=f'{self.label_full}|total'
+                self.total == self.operation.total.sum() + self.invest.total.sum(), name=f'{self.label_full}|total'
             ),
             'total',
         )
@@ -193,12 +172,11 @@ 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. """
 
-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. """
+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. """
 
 
 class EffectCollection:
@@ -230,9 +208,7 @@ class EffectCollection:
             self._effects[effect.label] = effect
             logger.info(f'Registered new Effect: {effect.label}')
 
-    def create_effect_values_dict(
-        self, effect_values_user: Union[EffectValuesUserScenario, EffectValuesUserTimestep]
-    ) -> Optional[EffectValuesDict]:
+    def create_effect_values_dict(self, effect_values_user: EffectValuesUser) -> Optional[EffectValuesDict]:
         """
         Converts effect values into a dictionary. If a scalar is provided, it is associated with a default effect type.
 
@@ -269,18 +245,26 @@ class EffectCollection:
 
     def _plausibility_checks(self) -> None:
         # Check circular loops in effects:
-        operation, invest = self.calculate_effect_share_factors()
+        # TODO: Improve checks!! Only most basic case covered...
 
-        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]))
-
-        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}')
+        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}'
+            )
 
-        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}')
+        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)}'
+                )
 
     def __getitem__(self, effect: Union[str, Effect]) -> 'Effect':
         """
@@ -344,30 +328,6 @@ 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):
     """
@@ -387,42 +347,29 @@ class EffectCollectionModel(Model):
     ) -> None:
         for effect, expression in expressions.items():
             if target == 'operation':
-                self.effects[effect].model.operation.add_share(
-                    name,
-                    expression,
-                    has_time_dim=True,
-                    has_scenario_dim=True,
-                )
+                self.effects[effect].model.operation.add_share(name, expression)
             elif target == 'invest':
-                self.effects[effect].model.invest.add_share(
-                    name,
-                    expression,
-                    has_time_dim=False,
-                    has_scenario_dim=True,
-                )
+                self.effects[effect].model.invest.add_share(name, expression)
             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, has_time_dim=False, has_scenario_dim=False)
+        self.penalty.add_share(name, expression)
 
     def do_modeling(self):
         for effect in self.effects:
             effect.create_model(self._model)
         self.penalty = self.add(
-            ShareAllocationModel(self._model, has_time_dim=False, has_scenario_dim=False, label_of_element='Penalty')
+            ShareAllocationModel(self._model, shares_are_time_series=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._model.scenario_weights).sum()
-            + self.penalty.total.sum()
-        )
+        self._model.add_objective(self.effects.objective_effect.model.total + self.penalty.total)
 
     def _add_share_between_effects(self):
         for origin_effect in self.effects:
@@ -430,161 +377,11 @@ 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.selected_data,
-                    has_time_dim=True,
-                    has_scenario_dim=True,
+                    origin_effect.model.operation.total_per_timestep * time_series.active_data,
                 )
             # 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