solph.flows._flow.Flow.__init__()

Complexity

Conditions

35

Size

Total Lines	207
Code Lines	126

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=0,
        max=1,
        fix=None,
        positive_gradient_limit=None,
        negative_gradient_limit=None,
        full_load_time_max=None,
        full_load_time_min=None,
        integer=False,
        # --- BEGIN: To be removed for versions >= v0.7 ---
        bidirectional=False,
        # --- END
        nonconvex=None,
        lifetime=None,
        age=None,
        fixed_costs=None,
        custom_attributes=None,  # To be removed for versions >= v0.7
        custom_properties=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

        if custom_attributes is not None:
            msg = (
                "For backward compatibility,"
                + " the option custom_attributes overwrites the option"
                + " custom_properties."
                + " Both options cannot be set at the same time."
            )
            if custom_properties is not None:
                raise AttributeError(msg)
            else:
                warn(msg, FutureWarning)
            custom_properties = custom_attributes
        # --- END ---

        super().__init__(custom_properties=custom_properties)

        # --- BEGIN: The following code can be removed for versions >= v0.7 ---
        if custom_attributes is not None:
            for attribute, value in custom_attributes.items():
                setattr(self, attribute, value)
        # --- END ---

        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.variable_costs = sequence(variable_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
        # --- BEGIN: To be removed for versions >= v0.7 ---
        self.bidirectional = bidirectional
        # --- END
        self.lifetime = lifetime
        self.age = age

        # It is not allowed to define `min` or `max` if `fix` is defined.
        # HINT: This also allows `flow`s with `fix` to be bidirectional, if
        # negative values are used in `fix`, despite `min` and `max` having
        # the default values (0 and 1).
        # TODO: Is it intended to have bidirectional fixed flows?
        if fix is not None and (min != 0 or max != 1):
            msg = (
                "It is not allowed to define `min`/`max` if `fix` is defined."
            )
            raise AttributeError(msg)

        # --- BEGIN: The following code can be removed for versions >= v0.7 ---
        if self.bidirectional:
            msg = "The `bidirectional` keyword is deprecated and will be "
            "removed in a future version, as it sets the value of `min` to -1 "
            "without the users explicit intent. It is recommended to set a "
            "negative value for `min` explicitly instead."
            warn(msg, FutureWarning)
            if min == 0:
                min = -1
        # --- END

        if sequence(min).min() < 0:
            msg = (
                "Setting `min` to negative values allows for the flow to "
                "become bidirectional, which is an experimental feature."
            )
            warn(msg, debugging.ExperimentalFeatureWarning)

        self.fix = sequence(fix)
        self.max = sequence(max)
        self.min = sequence(min)

        need_nominal_capacity = [
            "fix",
            "full_load_time_max",
            "full_load_time_min",
            "min",
            "max",
        ]
        need_nominal_capacity_defaults = {
            "fix": None,
            "full_load_time_max": None,
            "full_load_time_min": None,
            # --- BEGIN: The following code can be removed for versions >= v0.7
            "min": -1 if self.bidirectional else 0,
            # --- END
            # "min": 0,
            "max": 1,
        }
        if self.investment is None and self.nominal_capacity is None:
            for attr in need_nominal_capacity:
                if isinstance(getattr(self, attr), Iterable):
                    the_attr = getattr(self, attr)[0]
                else:
                    the_attr = getattr(self, attr)
                if the_attr != need_nominal_capacity_defaults[attr]:
                    raise AttributeError(
                        f"If {attr} is set in a flow, "
                        "nominal_capacity must be set as well."
                    )

        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."
            )