solph.flows._investment_flow_block.InvestmentFlowBlock._objective_expression()

Complexity

Conditions

18

Size

Total Lines	302
Code Lines	121

Duplication

Lines	25
Ratio	8.28 %

Importance

Changes

0

# -*- coding: utf-8 -*-
    def _objective_expression(self):
        r"""Objective expression for flows with investment attribute of type
        class:`.Investment`. The returned costs are fixed and
        investment costs. Variable costs are added from the standard flow
        objective expression.

        Objective terms for a standard model and a multi-period model differ
        quite strongly. Besides, the part of the objective function added by
        the *InvestmentFlowBlock* also depends on whether a convex
        or nonconvex *InvestmentFlowBlock* is selected.
        The following parts of the objective function are created:

        *Standard model*

            * :attr:`nonconvex = False`

                .. math::
                    P_{invest}(0) \cdot c_{invest,var}(0)

            * :attr:`nonconvex = True`

                .. math::
                    P_{invest}(0) \cdot c_{invest,var}(0)
                    + c_{invest,fix}(0) \cdot Y_{invest}(0) \\

        Where 0 denotes the 0th (investment) period since
        in a standard model, there is only this one period.

        *Multi-period model*

            * :attr:`nonconvex = False`

                .. math::
                    &
                    P_{invest}(p) \cdot A(c_{invest,var}(p), l, ir)
                    \cdot \frac {1}{ANF(d, ir)} \cdot DF^{-p}\\
                    &\\
                    &
                    \forall p \in \textrm{PERIODS}

            In case, the remaining lifetime of an asset is greater than 0 and
            attribute `use_remaining_value` of the energy system is True,
            the difference in value for the investment period compared to the
            last period of the optimization horizon is accounted for
            as an adder to the investment costs:

                .. math::
                    &
                    P_{invest}(p) \cdot (A(c_{invest,var}(p), l_{r}, ir) -
                    A(c_{invest,var}(|P|), l_{r}, ir)\\
                    & \cdot \frac {1}{ANF(l_{r}, ir)} \cdot DF^{-|P|}\\
                    &\\
                    &
                    \forall p \in \textrm{PERIODS}

            * :attr:`nonconvex = True`

                .. math::
                    &
                    (P_{invest}(p) \cdot A(c_{invest,var}(p), l, ir)
                    \cdot \frac {1}{ANF(d, ir)}\\
                    &
                    +  c_{invest,fix}(p) \cdot b_{invest}(p)) \cdot DF^{-p}\\
                    &\\
                    &
                    \forall p \in \textrm{PERIODS}

            In case, the remaining lifetime of an asset is greater than 0 and
            attribute `use_remaining_value` of the energy system is True,
            the difference in value for the investment period compared to the
            last period of the optimization horizon is accounted for
            as an adder to the investment costs:

                .. math::
                    &
                    (P_{invest}(p) \cdot (A(c_{invest,var}(p), l_{r}, ir) -
                    A(c_{invest,var}(|P|), l_{r}, ir)\\
                    & \cdot \frac {1}{ANF(l_{r}, ir)} \cdot DF^{-|P|}\\
                    &
                    +  (c_{invest,fix}(p) - c_{invest,fix}(|P|))
                    \cdot b_{invest}(p)) \cdot DF^{-p}\\
                    &\\
                    &
                    \forall p \in \textrm{PERIODS}

            * :attr:`fixed_costs` not None for investments

                .. math::
                    &
                    (\sum_{pp=year(p)}^{limit_{end}}
                    P_{invest}(p) \cdot c_{fixed}(pp) \cdot DF^{-pp})
                    \cdot DF^{-p}\\
                    &\\
                    &
                    \forall p \in \textrm{PERIODS}

            * :attr:`fixed_costs` not None for existing capacity

                .. math::
                    \sum_{pp=0}^{limit_{exo}} P_{exist} \cdot c_{fixed}(pp)
                    \cdot DF^{-pp}


        where:

        * :math:`A(c_{invest,var}(p), l, ir)` A is the annuity for
          investment expenses :math:`c_{invest,var}(p)`, lifetime :math:`l`
          and interest rate :math:`ir`.
        * :math:`l_{r}` is the remaining lifetime at the end of the
          optimization horizon (in case it is greater than 0 and
          smaller than the actual lifetime).
        * :math:`ANF(d, ir)` is the annuity factor for duration :math:`d`
          and interest rate :math:`ir`.
        * :math:`d=min\{year_{max} - year(p), l\}` defines the
          number of years within the optimization horizon that investment
          annuities are accounted for.
        * :math:`year(p)` denotes the start year of period :math:`p`.
        * :math:`year_{max}` denotes the last year of the optimization
          horizon, i.e. at the end of the last period.
        * :math:`limit_{end}=min\{year_{max}, year(p) + l\}` is used as an
          upper bound to ensure fixed costs for endogenous investments
          to occur within the optimization horizon.
        * :math:`limit_{exo}=min\{year_{max}, l - a\}` is used as an
          upper bound to ensure fixed costs for existing capacities to occur
          within the optimization horizon. :math:`a` is the initial age
          of an asset.
        * :math:`DF=(1+dr)` is the discount factor.

        The annuity / annuity factor hereby is:

            .. math::
                &
                A(c_{invest,var}(p), l, ir) = c_{invest,var}(p) \cdot
                    \frac {(1+ir)^l \cdot ir} {(1+ir)^l - 1}\\
                &\\
                &
                ANF(d, ir)=\frac {(1+ir)^d \cdot ir} {(1+ir)^d - 1}

        They are derived using the reciprocal of the oemof.tools.economics
        annuity function with a capex of 1.
        The interest rate :math:`ir` for the annuity is defined as weighted
        average costs of capital (wacc) and assumed constant over time.
        """
        if not hasattr(self, "INVESTFLOWS"):
            return 0

        m = self.parent_block()
        investment_costs = 0
        period_investment_costs = {p: 0 for p in m.PERIODS}
        fixed_costs = 0

        if m.es.periods is None:
            for i, o in self.CONVEX_INVESTFLOWS:
                for p in m.PERIODS:
                    investment_costs += (
                        self.invest[i, o, p]
                        * m.flows[i, o].investment.ep_costs[p]
                    )

            for i, o in self.NON_CONVEX_INVESTFLOWS:
                for p in m.PERIODS:
                    investment_costs += (
                        self.invest[i, o, p]
                        * m.flows[i, o].investment.ep_costs[p]
                        + self.invest_status[i, o, p]
                        * m.flows[i, o].investment.offset[p]
                    )

        else:
            msg = (
                "You did not specify an interest rate.\n"
                "It will be set equal to the discount_rate of {} "
                "of the model as a default.\nThis corresponds to a "
                "social planner point of view and does not reflect "
                "microeconomic interest requirements."
            )
            for i, o in self.CONVEX_INVESTFLOWS:
                lifetime = m.flows[i, o].investment.lifetime
                interest = 0
                if interest == 0:
                    warn(
                        msg.format(m.discount_rate),
                        debugging.SuspiciousUsageWarning,
                    )
                    interest = m.discount_rate
                for p in m.PERIODS:
                    annuity = economics.annuity(
                        capex=m.flows[i, o].investment.ep_costs[p],
                        n=lifetime,
                        wacc=interest,
                    )
                    duration = min(
                        m.es.end_year_of_optimization - m.es.periods_years[p],
                        lifetime,
                    )
                    present_value_factor_remaining = 1 / economics.annuity(
                        capex=1, n=duration, wacc=interest
                    )
                    investment_costs_increment = (
                        self.invest[i, o, p]
                        * annuity
                        * present_value_factor_remaining
                    )
                    remaining_value_difference = (
                        self._evaluate_remaining_value_difference(
                            m,
                            p,
                            i,
                            o,
                            m.es.end_year_of_optimization,
                            lifetime,
                            interest,
                        )
                    )
                    investment_costs += (
                        investment_costs_increment + remaining_value_difference
                    )
                    period_investment_costs[p] += investment_costs_increment

            for i, o in self.NON_CONVEX_INVESTFLOWS:
                lifetime = m.flows[i, o].investment.lifetime
                interest = 0
                if interest == 0:
                    warn(
                        msg.format(m.discount_rate),
                        debugging.SuspiciousUsageWarning,
                    )
                    interest = m.discount_rate
                for p in m.PERIODS:
                    annuity = economics.annuity(
                        capex=m.flows[i, o].investment.ep_costs[p],
                        n=lifetime,
                        wacc=interest,
                    )
                    duration = min(
                        m.es.end_year_of_optimization - m.es.periods_years[p],
                        lifetime,
                    )
                    present_value_factor_remaining = 1 / economics.annuity(
                        capex=1, n=duration, wacc=interest
                    )
                    investment_costs_increment = (
                        self.invest[i, o, p]
                        * annuity
                        * present_value_factor_remaining
                        + self.invest_status[i, o, p]
                        * m.flows[i, o].investment.offset[p]
                    )
                    remaining_value_difference = (
                        self._evaluate_remaining_value_difference(
                            m,
                            p,
                            i,
                            o,
                            m.es.end_year_of_optimization,
                            lifetime,
                            interest,
                            nonconvex=True,
                        )
                    )
                    investment_costs += (
                        investment_costs_increment + remaining_value_difference
                    )
                    period_investment_costs[p] += investment_costs_increment

            for i, o in self.INVESTFLOWS:
                if valid_sequence(

This code seems to be duplicated in your project.

                    m.flows[i, o].investment.fixed_costs, len(m.PERIODS)
                ):
                    lifetime = m.flows[i, o].investment.lifetime
                    for p in m.PERIODS:
                        range_limit = min(
                            m.es.end_year_of_optimization,
                            m.es.periods_years[p] + lifetime,
                        )
                        fixed_costs += sum(
                            self.invest[i, o, p]
                            * m.flows[i, o].investment.fixed_costs[pp]
                            for pp in range(m.es.periods_years[p], range_limit)
                        )

            for i, o in self.EXISTING_INVESTFLOWS:
                if valid_sequence(

This code seems to be duplicated in your project.

                    m.flows[i, o].investment.fixed_costs, len(m.PERIODS)
                ):
                    lifetime = m.flows[i, o].investment.lifetime
                    age = m.flows[i, o].investment.age
                    range_limit = min(
                        m.es.end_year_of_optimization, lifetime - age
                    )
                    fixed_costs += sum(
                        m.flows[i, o].investment.existing
                        * m.flows[i, o].investment.fixed_costs[pp]
                        for pp in range(range_limit)
                    )

        self.investment_costs = Expression(expr=investment_costs)
        self.period_investment_costs = period_investment_costs
        self.fixed_costs = Expression(expr=fixed_costs)
        self.costs = Expression(expr=investment_costs + fixed_costs)

        return self.costs