solph.flows._flow.Flow.__init__()

Complexity

Conditions

33

Size

Total Lines	165
Code Lines	104

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

# -*- coding: utf-8 -*-
    def __init__(
        self,
        nominal_capacity=None,
        # --- BEGIN: To be removed for versions >= v0.7 ---
        nominal_value=None,
        # --- END ---
        variable_costs=0,
        min=None,
        max=None,
        fix=None,
        positive_gradient_limit=None,
        negative_gradient_limit=None,
        full_load_time_max=None,
        full_load_time_min=None,
        integer=False,
        bidirectional=False,
        nonconvex=None,
        lifetime=None,
        age=None,
        fixed_costs=None,
        custom_attributes=None,
    ):
        # TODO: Check if we can inherit from pyomo.core.base.var _VarData
        # then we need to create the var object with
        # pyomo.core.base.IndexedVarWithDomain before any SimpleFlowBlock
        # is created. E.g. create the variable in the energy system and
        # populate with information afterwards when creating objects.

        # --- BEGIN: The following code can be removed for versions >= v0.7 ---
        if nominal_value is not None:
            msg = (
                "For backward compatibility,"
                + " the option nominal_value overwrites the option"
                + " nominal_capacity."
                + " Both options cannot be set at the same time."
            )
            if nominal_capacity is not None:
                raise AttributeError(msg)
            else:
                warn(msg, FutureWarning)
            nominal_capacity = nominal_value
        # --- END ---

        super().__init__()

        if custom_attributes is not None:
            for attribute, value in custom_attributes.items():
                setattr(self, attribute, value)

        self.nominal_capacity = None
        self.investment = None

        infinite_error_msg = (
            "{} must be a finite value. Passing an infinite "
            "value is not allowed."
        )
        if isinstance(nominal_capacity, numbers.Real):
            if not math.isfinite(nominal_capacity):
                raise ValueError(infinite_error_msg.format("nominal_capacity"))
            self.nominal_capacity = nominal_capacity
        elif isinstance(nominal_capacity, Investment):
            self.investment = nominal_capacity

        if fixed_costs is not None:
            msg = (
                "Be aware that the fixed costs attribute is only\n"
                "meant to be used for multi-period models to depict "
                "fixed costs that occur on a yearly basis.\n"
                "If you wish to set up a multi-period model, explicitly "
                "set the `periods` attribute of your energy system.\n"
                "It has been decided to remove the `fixed_costs` "
                "attribute with v0.2 for regular uses.\n"
                "If you specify `fixed_costs` for a regular model, "
                "this will simply be silently ignored."
            )
            warn(msg, debugging.SuspiciousUsageWarning)

        self.fixed_costs = sequence(fixed_costs)
        self.positive_gradient_limit = sequence(positive_gradient_limit)
        self.negative_gradient_limit = sequence(negative_gradient_limit)

        self.full_load_time_max = full_load_time_max
        self.full_load_time_min = full_load_time_min
        self.integer = integer
        self.nonconvex = nonconvex
        self.bidirectional = bidirectional
        self.lifetime = lifetime
        self.age = age

        # It is not allowed to define min or max if fix is defined.
        if fix is not None and (min is not None or max is not None):
            raise AttributeError(
                "It is not allowed to define `min`/`max` if `fix` is defined."
            )

        need_nominal_value = [
            "fix",
            "full_load_time_max",
            "full_load_time_min",
            "min",
            "max",
        ]
        sequences = ["fix", "variable_costs", "min", "max"]
        if self.investment is None and self.nominal_capacity is None:
            for attr in need_nominal_value:
                if isinstance(eval(attr), Iterable):
                    the_attr = eval(attr)[0]
                else:
                    the_attr = eval(attr)
                if the_attr is not None:
                    raise AttributeError(
                        f"If {attr} is set in a flow (except InvestmentFlow), "
                        "nominal_value must be set as well.\n"
                        "Otherwise, it won't have any effect."
                    )
        # minimum will be set even without nominal limit

        # maximum and minimum (absolute values) should be always set,
        # as nominal_value or invest might be defined later
        if max is None:
            max = 1
        if min is None:
            if bidirectional:
                min = -1
            else:
                min = 0

        for attr in sequences:
            setattr(self, attr, sequence(eval(attr)))

        if self.nominal_capacity is not None and not math.isfinite(
            self.max[0]
        ):
            raise ValueError(infinite_error_msg.format("max"))

        # Checking for impossible gradient combinations
        if self.nonconvex:
            if self.nonconvex.positive_gradient_limit[0] is not None and (
                self.positive_gradient_limit[0] is not None
                or self.negative_gradient_limit[0] is not None
            ):
                raise ValueError(
                    "You specified a positive gradient in your nonconvex "
                    "option. This cannot be combined with a positive or a "
                    "negative gradient for a standard flow!"
                )

            if self.nonconvex.negative_gradient_limit[0] is not None and (
                self.positive_gradient_limit[0] is not None
                or self.negative_gradient_limit[0] is not None
            ):
                raise ValueError(
                    "You specified a negative gradient in your nonconvex "
                    "option. This cannot be combined with a positive or a "
                    "negative gradient for a standard flow!"
                )

        if (
            self.investment
            and self.nonconvex
            and not np.isfinite(self.investment.maximum.max())
        ):
            raise AttributeError(
                "Investment into a non-convex flows needs a maximum "
                + "investment to be set."
            )