flixopt 1.0.12__py3-none-any.whl → 2.0.1__py3-none-any.whl

flixOpt/core.py

@@ -1,182 +0,0 @@
-"""
-This module contains the core functionality of the flixOpt framework.
-It provides Datatypes, logging functionality, and some functions to transform data structures.
-"""
-
-import inspect
-import logging
-from typing import Any, Dict, List, Optional, Union
-
-import numpy as np
-
-from . import utils
-
-logger = logging.getLogger('flixOpt')
-
-Skalar = Union[int, float]  # Datatype
-Numeric = Union[int, float, np.ndarray]  # Datatype
-
-
-class TimeSeriesData:
-    # TODO: Move to Interface.py
-    def __init__(self, data: Numeric, agg_group: Optional[str] = None, agg_weight: Optional[float] = None):
-        """
-        timeseries class for transmit timeseries AND special characteristics of timeseries,
-        i.g. to define weights needed in calculation_type 'aggregated'
-            EXAMPLE solar:
-            you have several solar timeseries. These should not be overweighted
-            compared to the remaining timeseries (i.g. heat load, price)!
-            fixed_relative_profile_solar1 = TimeSeriesData(sol_array_1, type = 'solar')
-            fixed_relative_profile_solar2 = TimeSeriesData(sol_array_2, type = 'solar')
-            fixed_relative_profile_solar3 = TimeSeriesData(sol_array_3, type = 'solar')
-            --> this 3 series of same type share one weight, i.e. internally assigned each weight = 1/3
-            (instead of standard weight = 1)
-
-        Parameters
-        ----------
-        data : Union[int, float, np.ndarray]
-            The timeseries data, which can be a scalar, array, or numpy array.
-        agg_group : str, optional
-            The group this TimeSeriesData is a part of. agg_weight is split between members of a group. Default is None.
-        agg_weight : float, optional
-            The weight for calculation_type 'aggregated', should be between 0 and 1. Default is None.
-
-        Raises
-        ------
-        Exception
-            If both agg_group and agg_weight are set, an exception is raised.
-        """
-        self.data = data
-        self.agg_group = agg_group
-        self.agg_weight = agg_weight
-        if (agg_group is not None) and (agg_weight is not None):
-            raise Exception('Either <agg_group> or explicit <agg_weigth> can be used. Not both!')
-        self.label: Optional[str] = None
-
-    def __repr__(self):
-        # Get the constructor arguments and their current values
-        init_signature = inspect.signature(self.__init__)
-        init_args = init_signature.parameters
-
-        # Create a dictionary with argument names and their values
-        args_str = ', '.join(f'{name}={repr(getattr(self, name, None))}' for name in init_args if name != 'self')
-        return f'{self.__class__.__name__}({args_str})'
-
-    def __str__(self):
-        return str(self.data)
-
-
-Numeric_TS = Union[
-    Skalar, np.ndarray, TimeSeriesData
-]  # TODO: This is not really correct throughozt the codebase. Sometimes its used for TimeSeries aswell?
-
-
-class TimeSeries:
-    """
-    Class for data that applies to time series, stored as vector (np.ndarray) or scalar.
-
-    This class represents a vector or scalar value that makes the handling of time series easier.
-    It supports various operations such as activation of specific time indices, setting explicit active data, and
-    aggregation weight management.
-
-    Attributes
-    ----------
-    label : str
-        The label for the time series.
-    data : Optional[Numeric]
-        The actual data for the time series. Can be None.
-    aggregated_data : Optional[Numeric]
-        aggregated_data to use instead of data if provided.
-    active_indices : Optional[np.ndarray]
-        Indices of the time steps to activate.
-    aggregation_weight : float
-        Weight for aggregation method, between 0 and 1, normally 1.
-    aggregation_group : str
-        Group for calculating the aggregation weigth for aggregation method.
-    """
-
-    def __init__(self, label: str, data: Optional[Numeric_TS]):
-        self.label: str = label
-        if isinstance(data, TimeSeriesData):
-            self.data = self.make_scalar_if_possible(data.data)
-            self.aggregation_weight, self.aggregation_group = data.agg_weight, data.agg_group
-            data.label = self.label  # Connecting User_time_series to real Time_series
-        else:
-            self.data = self.make_scalar_if_possible(data)
-            self.aggregation_weight, self.aggregation_group = None, None
-
-        self.active_indices: Optional[Union[range, List[int]]] = None
-        self.aggregated_data: Optional[Numeric] = None
-
-    def activate_indices(self, indices: Optional[Union[range, List[int]]], aggregated_data: Optional[Numeric] = None):
-        self.active_indices = indices
-
-        if aggregated_data is not None:
-            assert len(aggregated_data) == len(self.active_indices) or len(aggregated_data) == 1, (
-                f'The aggregated_data has the wrong length for TimeSeries {self.label}. '
-                f'Length should be: {len(self.active_indices)} or 1, but is {len(aggregated_data)}'
-            )
-            self.aggregated_data = self.make_scalar_if_possible(aggregated_data)
-
-    def clear_indices_and_aggregated_data(self):
-        self.active_indices = None
-        self.aggregated_data = None
-
-    @property
-    def active_data(self) -> Numeric:
-        if self.aggregated_data is not None:  # Aggregated data is always active, if present
-            return self.aggregated_data
-
-        indices_not_applicable = np.isscalar(self.data) or (self.data is None) or (self.active_indices is None)
-        if indices_not_applicable:
-            return self.data
-        else:
-            return self.data[self.active_indices]
-
-    @property
-    def active_data_vector(self) -> np.ndarray:
-        # Always returns the active data as a vector.
-        return utils.as_vector(self.active_data, len(self.active_indices))
-
-    @property
-    def is_scalar(self) -> bool:
-        return np.isscalar(self.data)
-
-    @property
-    def is_array(self) -> bool:
-        return not self.is_scalar and self.data is not None
-
-    def __repr__(self):
-        # Retrieve all attributes and their values
-        attrs = vars(self)
-        # Format each attribute as 'key=value'
-        attrs_str = ', '.join(f'{key}={value!r}' for key, value in attrs.items())
-        # Format the output as 'ClassName(attr1=value1, attr2=value2, ...)'
-        return f'{self.__class__.__name__}({attrs_str})'
-
-    def __str__(self):
-        return str(self.active_data)
-
-    @staticmethod
-    def make_scalar_if_possible(data: Optional[Numeric]) -> Optional[Numeric]:
-        """
-        Convert an array to a scalar if all values are equal, or return the array as-is.
-        Can Return None if the passed data is None
-
-        Parameters
-        ----------
-        data : Numeric, None
-            The data to process.
-
-        Returns
-        -------
-        Numeric
-            A scalar if all values in the array are equal, otherwise the array itself. None, if the passed value is None
-        """
-        # TODO: Should this really return None Values?
-        if np.isscalar(data) or data is None:
-            return data
-        data = np.array(data)
-        if np.all(data == data[0]):
-            return data[0]
-        return data

flixOpt/effects.py

@@ -1,410 +0,0 @@
-"""
-This module contains the effects of the flixOpt framework.
-Furthermore, it contains the EffectCollection, which is used to collect all effects of a system.
-Different Datatypes are used to represent the effects with assigned values by the user,
-which are then transformed into the internal data structure.
-"""
-
-import logging
-from typing import Dict, Literal, Optional, Union
-
-import numpy as np
-
-from .core import Numeric, Numeric_TS, Skalar, TimeSeries
-from .features import ShareAllocationModel
-from .math_modeling import Equation, Variable
-from .structure import Element, ElementModel, SystemModel, _create_time_series
-
-logger = logging.getLogger('flixOpt')
-
-
-class Effect(Element):
-    """
-    Effect, i.g. costs, CO2 emissions, area, ...
-    Components, FLows, and so on can contribute to an Effect. One Effect is chosen as the Objective of the Optimization
-    """
-
-    def __init__(
-        self,
-        label: str,
-        unit: str,
-        description: str,
-        meta_data: Optional[Dict] = None,
-        is_standard: bool = False,
-        is_objective: bool = False,
-        specific_share_to_other_effects_operation: 'EffectValues' = None,
-        specific_share_to_other_effects_invest: 'EffectValuesInvest' = None,
-        minimum_operation: Optional[Skalar] = None,
-        maximum_operation: Optional[Skalar] = None,
-        minimum_invest: Optional[Skalar] = None,
-        maximum_invest: Optional[Skalar] = None,
-        minimum_operation_per_hour: Optional[Numeric_TS] = None,
-        maximum_operation_per_hour: Optional[Numeric_TS] = None,
-        minimum_total: Optional[Skalar] = None,
-        maximum_total: Optional[Skalar] = None,
-    ):
-        """
-        Parameters
-        ----------
-        label : str
-            name
-        unit : str
-            unit of effect, i.g. €, kg_CO2, kWh_primaryEnergy
-        description : str
-            long name
-        meta_data : Optional[Dict]
-            used to store more information about the element. Is not used internally, but saved in the results
-        is_standard : boolean, optional
-            true, if Standard-Effect (for direct input of value without effect (alternatively to dict)) , else false
-        is_objective : boolean, optional
-            true, if optimization target
-        specific_share_to_other_effects_operation : {effectType: TS, ...}, i.g. 180 €/t_CO2, input as {costs: 180}, optional
-            share to other effects (only operation)
-        specific_share_to_other_effects_invest : {effectType: TS, ...}, i.g. 180 €/t_CO2, input as {costs: 180}, optional
-            share to other effects (only invest).
-        minimum_operation : scalar, optional
-            minimal sum (only operation) of the effect
-        maximum_operation : scalar, optional
-            maximal sum (nur operation) of the effect.
-        minimum_operation_per_hour : scalar or TS
-            maximum value per hour (only operation) of effect (=sum of all effect-shares) for each timestep!
-        maximum_operation_per_hour : scalar or TS
-            minimum value per hour (only operation) of effect (=sum of all effect-shares) for each timestep!
-        minimum_invest : scalar, optional
-            minimal sum (only invest) of the effect
-        maximum_invest : scalar, optional
-            maximal sum (only invest) of the effect
-        minimum_total : sclalar, optional
-            min sum of effect (invest+operation).
-        maximum_total : scalar, optional
-            max sum of effect (invest+operation).
-        **kwargs : TYPE
-            DESCRIPTION.
-
-        Returns
-        -------
-        None.
-
-        """
-        super().__init__(label, meta_data=meta_data)
-        self.label = label
-        self.unit = unit
-        self.description = description
-        self.is_standard = is_standard
-        self.is_objective = is_objective
-        self.specific_share_to_other_effects_operation: Union[EffectValues, EffectTimeSeries] = (
-            specific_share_to_other_effects_operation or {}
-        )
-        self.specific_share_to_other_effects_invest: Union[EffectValuesInvest, EffectDictInvest] = (
-            specific_share_to_other_effects_invest or {}
-        )
-        self.minimum_operation = minimum_operation
-        self.maximum_operation = maximum_operation
-        self.minimum_operation_per_hour: Numeric_TS = minimum_operation_per_hour
-        self.maximum_operation_per_hour: Numeric_TS = maximum_operation_per_hour
-        self.minimum_invest = minimum_invest
-        self.maximum_invest = maximum_invest
-        self.minimum_total = minimum_total
-        self.maximum_total = maximum_total
-
-        self._plausibility_checks()
-
-    def _plausibility_checks(self) -> None:
-        # Check circular loops in effects: (Effekte fügen sich gegenseitig Shares hinzu):
-        # TODO: Improve checks!! Only most basic case covered...
-
-        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}'
-            )
-
-        # Effekt darf nicht selber als Share in seinen ShareEffekten auftauchen:
-        # operation:
-        for target_effect in self.specific_share_to_other_effects_operation.keys():
-            assert self not in 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 self.specific_share_to_other_effects_invest.keys():
-            assert self not in target_effect.specific_share_to_other_effects_invest.keys(), (
-                f'Error: circular invest-shares \n{error_str(target_effect.label, target_effect.label)}'
-            )
-
-    def transform_data(self):
-        self.minimum_operation_per_hour = _create_time_series(
-            'minimum_operation_per_hour', self.minimum_operation_per_hour, self
-        )
-        self.maximum_operation_per_hour = _create_time_series(
-            'maximum_operation_per_hour', self.maximum_operation_per_hour, self
-        )
-
-        self.specific_share_to_other_effects_operation = effect_values_to_time_series(
-            'specific_share_to_other_effects_operation', self.specific_share_to_other_effects_operation, self
-        )
-
-    def create_model(self) -> 'EffectModel':
-        self.model = EffectModel(self)
-        return self.model
-
-
-class EffectModel(ElementModel):
-    def __init__(self, element: Effect):
-        super().__init__(element)
-        self.element: Effect
-        self.invest = ShareAllocationModel(
-            self.element, 'invest', False, total_max=self.element.maximum_invest, total_min=self.element.minimum_invest
-        )
-        self.operation = ShareAllocationModel(
-            self.element,
-            'operation',
-            True,
-            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,
-        )
-        self.all = ShareAllocationModel(
-            self.element, 'all', False, total_max=self.element.maximum_total, total_min=self.element.minimum_total
-        )
-        self.sub_models.extend([self.invest, self.operation, self.all])
-
-    def do_modeling(self, system_model: SystemModel):
-        for model in self.sub_models:
-            model.do_modeling(system_model)
-
-        self.all.add_share(system_model, 'operation', self.operation.sum, 1)
-        self.all.add_share(system_model, 'invest', self.invest.sum, 1)
-
-
-EffectDict = Dict[Optional['Effect'], Numeric]
-EffectDictInvest = Dict[Optional['Effect'], Skalar]
-
-EffectValues = Optional[Union[Numeric_TS, EffectDict]]  # Datatype for User Input
-EffectValuesInvest = Optional[Union[Skalar, EffectDictInvest]]  # Datatype for User Input
-
-EffectTimeSeries = Dict[Optional['Effect'], TimeSeries]  # Final Internal Data Structure
-ElementTimeSeries = Dict[Optional[Element], TimeSeries]  # Final Internal Data Structure
-
-
-def nested_values_to_time_series(
-    nested_values: Dict[Element, Numeric_TS], label_suffix: str, parent_element: Element
-) -> ElementTimeSeries:
-    """
-    Creates TimeSeries from nested values, which are a Dict of Elements to values.
-    The resulting label of the TimeSeries is the label of the parent_element, followed by the label of the element in
-    the nested_values and the label_suffix.
-    """
-    return {
-        element: _create_time_series(f'{element.label}_{label_suffix}', value, parent_element)
-        for element, value in nested_values.items()
-        if element is not None
-    }
-
-
-def effect_values_to_time_series(
-    label_suffix: str, nested_values: EffectValues, parent_element: Element
-) -> Optional[EffectTimeSeries]:
-    """
-    Creates TimeSeries from EffectValues. The resulting label of the TimeSeries is the label of the parent_element,
-    followed by the label of the Effect in the nested_values and the label_suffix.
-    If the key in the EffectValues is None, the alias 'Standart_Effect' is used
-    """
-    nested_values = as_effect_dict(nested_values)
-    if nested_values is None:
-        return None
-    else:
-        standard_value = nested_values.pop(None, None)
-        transformed_values = nested_values_to_time_series(nested_values, label_suffix, parent_element)
-        if standard_value is not None:
-            transformed_values[None] = _create_time_series(
-                f'Standard_Effect_{label_suffix}', standard_value, parent_element
-            )
-        return transformed_values
-
-
-def as_effect_dict(effect_values: EffectValues) -> Optional[EffectDict]:
-    """
-    Converts effect values into a dictionary. If a scalar is provided, it is associated with a default effect type.
-
-    Examples
-    --------
-    costs = 20                        -> {None: 20}
-    costs = None                      -> None
-    costs = {effect1: 20, effect2: 0.3} -> {effect1: 20, effect2: 0.3}
-
-    Parameters
-    ----------
-    effect_values : None, int, float, TimeSeries, or dict
-        The effect values to convert, either a scalar, TimeSeries, or a dictionary.
-
-    Returns
-    -------
-    dict or None
-        A dictionary with None or Effect as the key, or None if input is None.
-    """
-    return (
-        effect_values
-        if isinstance(effect_values, dict)
-        else {None: effect_values}
-        if effect_values is not None
-        else None
-    )
-
-
-def effect_values_from_effect_time_series(effect_time_series: EffectTimeSeries) -> Dict[Optional[Effect], Numeric]:
-    return {effect: time_series.active_data for effect, time_series in effect_time_series.items()}
-
-
-class EffectCollection:
-    """
-    Handling all Effects
-    """
-
-    def __init__(self, label: str):
-        self.label = label
-        self.model: Optional[EffectCollectionModel] = None
-        self.effects: Dict[str, Effect] = {}
-
-    def create_model(self, system_model: SystemModel) -> 'EffectCollectionModel':
-        self.model = EffectCollectionModel(self, system_model)
-        return self.model
-
-    def add_effect(self, effect: 'Effect') -> None:
-        if effect.is_standard and self.standard_effect is not None:
-            raise Exception(f'A standard-effect already exists! ({self.standard_effect.label=})')
-        if effect.is_objective and self.objective_effect is not None:
-            raise Exception(f'A objective-effect already exists! ({self.objective_effect.label=})')
-        if effect in self.effects.values():
-            raise Exception(f'Effect already added! ({effect.label=})')
-        if effect.label in self.effects:
-            raise Exception(f'Effect with label "{effect.label=}" already added!')
-        self.effects[effect.label] = effect
-
-    @property
-    def standard_effect(self) -> Optional[Effect]:
-        for effect in self.effects.values():
-            if effect.is_standard:
-                return effect
-
-    @property
-    def objective_effect(self) -> Optional[Effect]:
-        for effect in self.effects.values():
-            if effect.is_objective:
-                return effect
-
-    @property
-    def label_full(self):
-        return self.label
-
-
-class EffectCollectionModel(ElementModel):
-    # TODO: Maybe all EffectModels should be sub_models of this Model? Including Objective and Penalty?
-    def __init__(self, element: EffectCollection, system_model: SystemModel):
-        super().__init__(element)
-        self.element = element
-        self._system_model = system_model
-        self._effect_models: Dict[Effect, EffectModel] = {}
-        self.penalty: Optional[ShareAllocationModel] = None
-        self.objective: Optional[Equation] = None
-
-    def do_modeling(self, system_model: SystemModel):
-        self._effect_models = {effect: effect.create_model() for effect in self.element.effects.values()}
-        self.penalty = ShareAllocationModel(self.element, 'penalty', False)
-        self.sub_models.extend(list(self._effect_models.values()) + [self.penalty])
-        for model in self.sub_models:
-            model.do_modeling(system_model)
-
-        self.add_share_between_effects()
-
-        self.objective = Equation('OBJECTIVE', 'OBJECTIVE', is_objective=True)
-        self.objective.add_summand(self._objective_effect_model.operation.sum, 1)
-        self.objective.add_summand(self._objective_effect_model.invest.sum, 1)
-        self.objective.add_summand(self.penalty.sum, 1)
-
-    @property
-    def _objective_effect_model(self) -> EffectModel:
-        return self._effect_models[self.element.objective_effect]
-
-    def _add_share_to_effects(
-        self,
-        name: str,
-        element: Element,
-        target: Literal['operation', 'invest'],
-        effect_values: EffectDict,
-        factor: Numeric,
-        variable: Optional[Variable] = None,
-    ) -> None:
-        # an alle Effects, die einen Wert haben, anhängen:
-        for effect, value in effect_values.items():
-            if effect is None:  # Falls None, dann Standard-effekt nutzen:
-                effect = self.element.standard_effect
-            assert effect in self.element.effects.values(), f'Effect {effect.label} was used but not added to model!'
-
-            if target == 'operation':
-                model = self._effect_models[effect].operation
-            elif target == 'invest':
-                model = self._effect_models[effect].invest
-            else:
-                raise ValueError(f'Target {target} not supported!')
-
-            name_of_share = f'{element.label_full}__{name}'
-            total_factor = np.multiply(value, factor)
-            model.add_share(self._system_model, name_of_share, variable, total_factor)
-
-    def add_share_to_invest(
-        self,
-        name: str,
-        element: Element,
-        effect_values: EffectDictInvest,
-        factor: Numeric,
-        variable: Optional[Variable] = None,
-    ) -> None:
-        # TODO: Add checks
-        self._add_share_to_effects(name, element, 'invest', effect_values, factor, variable)
-
-    def add_share_to_operation(
-        self,
-        name: str,
-        element: Element,
-        effect_values: EffectTimeSeries,
-        factor: Numeric,
-        variable: Optional[Variable] = None,
-    ) -> None:
-        # TODO: Add checks
-        self._add_share_to_effects(
-            name, element, 'operation', effect_values_from_effect_time_series(effect_values), factor, variable
-        )
-
-    def add_share_to_penalty(
-        self,
-        name: Optional[str],
-        variable: Variable,
-        factor: Numeric,
-    ) -> None:
-        assert variable is not None, 'A Variable must be passed to add a share to penalty! Else its a constant Penalty!'
-        self.penalty.add_share(self._system_model, name, variable, factor, True)
-
-    def add_share_between_effects(self):
-        for origin_effect in self.element.effects.values():
-            # 1. operation: -> hier sind es Zeitreihen (share_TS)
-            for target_effect, time_series in origin_effect.specific_share_to_other_effects_operation.items():
-                target_model = self._effect_models[target_effect].operation
-                origin_model = self._effect_models[origin_effect].operation
-                target_model.add_share(
-                    self._system_model,
-                    f'{origin_effect.label_full}_operation',
-                    origin_model.sum_TS,
-                    time_series.active_data,
-                )
-            # 2. invest:    -> hier ist es Skalar (share)
-            for target_effect, factor in origin_effect.specific_share_to_other_effects_invest.items():
-                target_model = self._effect_models[target_effect].invest
-                origin_model = self._effect_models[origin_effect].invest
-                target_model.add_share(
-                    self._system_model, f'{origin_effect.label_full}_invest', origin_model.sum, factor
-                )