Source code for calliope.backend.pyomo.constraints.costs

"""
Copyright (C) 2013-2018 Calliope contributors listed in AUTHORS.
Licensed under the Apache 2.0 License (see LICENSE file).

costs.py
~~~~~~~~

Cost constraints.

"""

import pyomo.core as po  # pylint: disable=import-error

from calliope.backend.pyomo.util import \
    get_param, \
    get_timestep_weight, \
    loc_tech_is_in


def load_constraints(backend_model):
    sets = backend_model.__calliope_model_data__['sets']

    if 'loc_techs_cost_constraint' in sets:
        backend_model.cost_constraint = po.Constraint(
            backend_model.costs,
            backend_model.loc_techs_cost,
            rule=cost_constraint_rule
        )
    # FIXME: remove check for operate from constraint files, avoid investment costs more intelligently?
    if 'loc_techs_cost_investment_constraint' in sets and backend_model.mode != 'operate':
        # Right-hand side expression can be later updated by MILP investment costs
        backend_model.cost_investment_rhs = po.Expression(
            backend_model.costs,
            backend_model.loc_techs_cost_investment_constraint,
            initialize=0.0
        )

        backend_model.cost_investment_constraint = po.Constraint(
            backend_model.costs,
            backend_model.loc_techs_cost_investment_constraint,
            rule=cost_investment_constraint_rule
        )

    if 'loc_techs_om_cost' in sets:
        # Right-hand side expression can be later updated by export costs/revenue
        backend_model.cost_var_rhs = po.Expression(
            backend_model.costs,
            backend_model.loc_techs_om_cost,
            backend_model.timesteps,
            initialize=0.0
        )
    if 'loc_techs_cost_var_constraint' in sets:
        # Constraint is built over a different loc_techs set to expression, as
        # it is updated in conversion.py and conversion_plus.py constraints
        backend_model.cost_var_constraint = po.Constraint(
            backend_model.costs,
            backend_model.loc_techs_cost_var_constraint,
            backend_model.timesteps,
            rule=cost_var_constraint_rule
        )


[docs]def cost_constraint_rule(backend_model, cost, loc_tech): """ Combine investment and time varying costs into one cost per technology .. container:: scrolling-wrapper .. math:: \\boldsymbol{cost}(cost, loc::tech) = \\boldsymbol{cost_{investment}}(cost, loc::tech) + \\sum_{timestep \\in timesteps} \\boldsymbol{cost_{var}}(cost, loc::tech, timestep) """ # FIXME: remove check for operate from constraint files, avoid investment costs more intelligently? if loc_tech_is_in(backend_model, loc_tech, 'loc_techs_investment_cost') and backend_model.mode != 'operate': cost_investment = backend_model.cost_investment[cost, loc_tech] else: cost_investment = 0 if loc_tech_is_in(backend_model, loc_tech, 'loc_techs_om_cost'): cost_var = sum(backend_model.cost_var[cost, loc_tech, timestep] for timestep in backend_model.timesteps) else: cost_var = 0 return ( backend_model.cost[cost, loc_tech] == cost_investment + cost_var )
[docs]def cost_investment_constraint_rule(backend_model, cost, loc_tech): """ Calculate costs from capacity decision variables. Transmission technologies "exist" at two locations, so their cost is divided by 2. .. container:: scrolling-wrapper .. math:: \\boldsymbol{cost_{investment}}(cost, loc::tech) = cost_{fractional\\_om}(cost, loc::tech) + cost_{fixed\\_om}(cost, loc::tech) + cost_{con}(cost, loc::tech) cost_{con}(cost, loc::tech) = depreciation\\_rate * ts\\_weight * (cost_{energy\\_cap}(cost, loc::tech) \\times \\boldsymbol{energy_{cap}}(loc::tech) + cost_{storage\\_cap}(cost, loc::tech) \\times \\boldsymbol{storage_{cap}}(loc::tech) + cost_{resource\\_cap}(cost, loc::tech) \\times \\boldsymbol{resource_{cap}}(loc::tech) + cost_{resource\\_area}(cost, loc::tech)) \\times \\boldsymbol{resource_{area}}(loc::tech) depreciation\\_rate = \\begin{cases} = 1 / plant\\_life,& \\text{if } interest\\_rate = 0\\\\ = \\frac{interest\\_rate \\times (1 + interest\\_rate)^{plant\\_life}}{(1 + interest\\_rate)^{plant\\_life} - 1},& \\text{if } interest\\_rate \\gt 0\\\\ \\end{cases} ts\\_weight = \\sum_{timestep \\in timesteps} (time\\_res(timestep) \\times weight(timestep)) \\times \\frac{1}{8760} """ model_data_dict = backend_model.__calliope_model_data__ def _get_investment_cost(capacity_decision_variable, calliope_set): """ Conditionally add investment costs, if the relevant set of technologies exists. Both inputs are strings. """ if loc_tech_is_in(backend_model, loc_tech, calliope_set): _cost = (getattr(backend_model, capacity_decision_variable)[loc_tech] * get_param(backend_model, 'cost_' + capacity_decision_variable, (cost, loc_tech))) return _cost else: return 0 cost_energy_cap = (backend_model.energy_cap[loc_tech] * get_param(backend_model, 'cost_energy_cap', (cost, loc_tech))) cost_storage_cap = _get_investment_cost('storage_cap', 'loc_techs_store') cost_resource_cap = _get_investment_cost('resource_cap', 'loc_techs_supply_plus') cost_resource_area = _get_investment_cost('resource_area', 'loc_techs_area') cost_om_annual_investment_fraction = get_param(backend_model, 'cost_om_annual_investment_fraction', (cost, loc_tech)) cost_om_annual = get_param(backend_model, 'cost_om_annual', (cost, loc_tech)) ts_weight = get_timestep_weight(backend_model) depreciation_rate = model_data_dict['data']['cost_depreciation_rate'].get((cost, loc_tech), 0) cost_con = ( depreciation_rate * ts_weight * (cost_energy_cap + cost_storage_cap + cost_resource_cap + cost_resource_area) ) # Transmission technologies exist at two locations, thus their cost is divided by 2 if loc_tech_is_in(backend_model, loc_tech, 'loc_techs_transmission'): cost_con = cost_con / 2 cost_fractional_om = cost_om_annual_investment_fraction * cost_con cost_fixed_om = cost_om_annual * backend_model.energy_cap[loc_tech] * ts_weight backend_model.cost_investment_rhs[cost, loc_tech].expr = ( cost_fractional_om + cost_fixed_om + cost_con ) return ( backend_model.cost_investment[cost, loc_tech] == backend_model.cost_investment_rhs[cost, loc_tech] )
[docs]def cost_var_constraint_rule(backend_model, cost, loc_tech, timestep): """ Calculate costs from time-varying decision variables .. container:: scrolling-wrapper .. math:: \\boldsymbol{cost_{var}}(cost, loc::tech, timestep) = cost_{prod}(cost, loc::tech, timestep) + cost_{con}(cost, loc::tech, timestep) cost_{prod}(cost, loc::tech, timestep) = cost_{om\\_prod}(cost, loc::tech, timestep) \\times weight(timestep) \\times \\boldsymbol{carrier_{prod}}(loc::tech::carrier, timestep) prod\\_con\\_eff = \\begin{cases} = \\boldsymbol{resource_{con}}(loc::tech, timestep),& \\text{if } loc::tech \\in loc\\_techs\\_supply\\_plus \\\\ = \\frac{\\boldsymbol{carrier_{prod}}(loc::tech::carrier, timestep)}{energy_eff(loc::tech, timestep)},& \\text{if } loc::tech \\in loc\\_techs\\_supply \\\\ \\end{cases} cost_{con}(cost, loc::tech, timestep) = cost_{om\\_con}(cost, loc::tech, timestep) \\times weight(timestep) \\times prod\\_con\\_eff """ model_data_dict = backend_model.__calliope_model_data__ cost_om_prod = get_param(backend_model, 'cost_om_prod', (cost, loc_tech, timestep)) cost_om_con = get_param(backend_model, 'cost_om_con', (cost, loc_tech, timestep)) weight = backend_model.timestep_weights[timestep] loc_tech_carrier = model_data_dict['data']['lookup_loc_techs'][loc_tech] if po.value(cost_om_prod): cost_prod = cost_om_prod * weight * backend_model.carrier_prod[loc_tech_carrier, timestep] else: cost_prod = 0 if loc_tech_is_in(backend_model, loc_tech, 'loc_techs_supply_plus') and cost_om_con: cost_con = cost_om_con * weight * backend_model.resource_con[loc_tech, timestep] elif loc_tech_is_in(backend_model, loc_tech, 'loc_techs_supply') and cost_om_con: energy_eff = get_param(backend_model, 'energy_eff', (loc_tech, timestep)) if po.value(energy_eff) > 0: # in case energy_eff is zero, to avoid an infinite value cost_con = cost_om_con * weight * (backend_model.carrier_prod[loc_tech_carrier, timestep] / energy_eff) else: cost_con = 0 else: cost_con = 0 backend_model.cost_var_rhs[cost, loc_tech, timestep].expr = cost_prod + cost_con return (backend_model.cost_var[cost, loc_tech, timestep] == backend_model.cost_var_rhs[cost, loc_tech, timestep])