def balance_conversion_plus_tiers_constraint_rule(backend_model, tier,
loc_tech, timestep):
"""
Force all carrier_in_2/carrier_in_3 and carrier_out_2/carrier_out_3 to follow
carrier_in and carrier_out (respectively).
If `tier` in ['out_2', 'out_3']:
.. container:: scrolling-wrapper
.. math::
\\sum_{loc::tech::carrier \\in loc::tech::carriers_{out}} (
\\frac{\\boldsymbol{carrier_{prod}}(loc::tech::carrier, timestep)}{
carrier\\_ratio(loc::tech::carrier, `out')} =
\\sum_{loc::tech::carrier \\in loc::tech::carriers_{tier}} (
\\frac{\\boldsymbol{carrier_{prod}}(loc::tech::carrier, timestep)}{
carrier\\_ratio(loc::tech::carrier, tier)}
\\quad \\forall \\text { tier } \\in [`out_2', `out_3'], \\forall loc::tech
\\in loc::techs_{conversion^{+}}, \\forall timestep \\in timesteps
If `tier` in ['in_2', 'in_3']:
.. container:: scrolling-wrapper
.. math::
\\sum_{loc::tech::carrier \\in loc::tech::carriers_{in}}
\\frac{\\boldsymbol{carrier_{con}}(loc::tech::carrier, timestep)}{
carrier\\_ratio(loc::tech::carrier, `in')} =
\\sum_{loc::tech::carrier \\in loc::tech::carriers_{tier}}
\\frac{\\boldsymbol{carrier_{prod}}(loc::tech::carrier, timestep)}{
carrier\\_ratio(loc::tech::carrier, tier)}
\\quad \\forall \\text{ tier } \\in [`in_2', `in_3'], \\forall loc::tech
\\in loc::techs_{conversion^{+}}, \\forall timestep \\in timesteps
"""
primary_tier, decision_variable = get_conversion_plus_io(
backend_model, tier)
model_data_dict = backend_model.__calliope_model_data['data']
loc_tech_carriers_1 = split_comma_list(
model_data_dict['lookup_loc_techs_conversion_plus'][primary_tier,
loc_tech])
loc_tech_carriers_2 = split_comma_list(
model_data_dict['lookup_loc_techs_conversion_plus'][tier, loc_tech])
c_1 = sum(decision_variable[loc_tech_carrier, timestep] /
get_param(backend_model, 'carrier_ratios', (primary_tier,
loc_tech_carrier))
for loc_tech_carrier in loc_tech_carriers_1)
c_2 = sum(
decision_variable[loc_tech_carrier, timestep] /
get_param(backend_model, 'carrier_ratios', (tier, loc_tech_carrier))
for loc_tech_carrier in loc_tech_carriers_2)
return c_1 == c_2
def balance_conversion_plus_tiers_constraint_rule(backend_model, tier, loc_tech, timestep):
"""
Force all carrier_in_2/carrier_in_3 and carrier_out_2/carrier_out_3 to follow
carrier_in and carrier_out (respectively).
If `tier` in ['out_2', 'out_3']:
.. container:: scrolling-wrapper
.. math::
\\sum_{loc::tech::carrier \\in loc::tech::carriers_{out}} (
\\frac{\\boldsymbol{carrier_{prod}}(loc::tech::carrier, timestep)}{
carrier\\_ratio(loc::tech::carrier, `out')} =
\\sum_{loc::tech::carrier \\in loc::tech::carriers_{tier}} (
\\frac{\\boldsymbol{carrier_{prod}}(loc::tech::carrier, timestep)}{
carrier\\_ratio(loc::tech::carrier, tier)}
\\quad \\forall \\text { tier } \\in [`out_2', `out_3'], \\forall loc::tech
\\in loc::techs_{conversion^{+}}, \\forall timestep \\in timesteps
If `tier` in ['in_2', 'in_3']:
.. container:: scrolling-wrapper
.. math::
\\sum_{loc::tech::carrier \\in loc::tech::carriers_{in}}
\\frac{\\boldsymbol{carrier_{con}}(loc::tech::carrier, timestep)}{
carrier\\_ratio(loc::tech::carrier, `in')} =
\\sum_{loc::tech::carrier \\in loc::tech::carriers_{tier}}
\\frac{\\boldsymbol{carrier_{prod}}(loc::tech::carrier, timestep)}{
carrier\\_ratio(loc::tech::carrier, tier)}
\\quad \\forall \\text{ tier } \\in [`in_2', `in_3'], \\forall loc::tech
\\in loc::techs_{conversion^{+}}, \\forall timestep \\in timesteps
"""
primary_tier, decision_variable = get_conversion_plus_io(backend_model, tier)
model_data_dict = backend_model.__calliope_model_data__['data']
loc_tech_carriers_1 = split_comma_list(
model_data_dict['lookup_loc_techs_conversion_plus'][primary_tier, loc_tech]
)
loc_tech_carriers_2 = split_comma_list(
model_data_dict['lookup_loc_techs_conversion_plus'][tier, loc_tech]
)
c_1 = sum(decision_variable[loc_tech_carrier, timestep]
/ get_param(backend_model, 'carrier_ratios', (primary_tier, loc_tech_carrier))
for loc_tech_carrier in loc_tech_carriers_1)
c_2 = sum(decision_variable[loc_tech_carrier, timestep]
/ get_param(backend_model, 'carrier_ratios', (tier, loc_tech_carrier))
for loc_tech_carrier in loc_tech_carriers_2)
return c_1 == c_2
def carrier_production_min_conversion_plus_milp_constraint_rule(
backend_model, loc_tech, timestep):
"""
Set minimum carrier production of conversion_plus MILP techs
.. container:: scrolling-wrapper
.. math::
\sum_{loc::tech::carrier \\in loc::tech::carriers_{out}}
\\boldsymbol{carrier_{prod}}(loc::tech::carrier, timestep)
\\geq energy_{cap, per unit}(loc::tech) \\times timestep\_resolution(timestep)
\\times \\boldsymbol{operating\_units}(loc::tech, timestep)
\\times energy_{cap, min use}(loc::tech)
\\quad \\forall loc::tech \\in loc::techs_{milp, conversion^{+}},
\\forall timestep \\in timesteps
"""
model_data_dict = backend_model.__calliope_model_data__['data']
timestep_resolution = backend_model.timestep_resolution[timestep]
energy_cap = get_param(backend_model, 'energy_cap_per_unit', loc_tech)
min_use = get_param(backend_model, 'energy_cap_min_use',
(loc_tech, timestep))
loc_tech_carriers_out = (split_comma_list(
model_data_dict['lookup_loc_techs_conversion_plus']['out', loc_tech]))
carrier_prod = sum(backend_model.carrier_prod[loc_tech_carrier, timestep]
for loc_tech_carrier in loc_tech_carriers_out)
return carrier_prod >= (backend_model.operating_units[loc_tech, timestep] *
timestep_resolution * energy_cap * min_use)
def carrier_production_min_conversion_plus_milp_constraint_rule(backend_model, loc_tech, timestep):
"""
Set minimum carrier production of conversion_plus MILP techs
.. container:: scrolling-wrapper
.. math::
\\sum_{loc::tech::carrier \\in loc::tech::carriers_{out}}
\\boldsymbol{carrier_{prod}}(loc::tech::carrier, timestep)
\\geq energy_{cap, per unit}(loc::tech) \\times timestep\\_resolution(timestep)
\\times \\boldsymbol{operating\\_units}(loc::tech, timestep)
\\times energy_{cap, min use}(loc::tech)
\\quad \\forall loc::tech \\in loc::techs_{milp, conversion^{+}},
\\forall timestep \\in timesteps
"""
model_data_dict = backend_model.__calliope_model_data__['data']
timestep_resolution = backend_model.timestep_resolution[timestep]
energy_cap = get_param(backend_model, 'energy_cap_per_unit', loc_tech)
min_use = get_param(backend_model, 'energy_cap_min_use', (loc_tech, timestep))
loc_tech_carriers_out = (
split_comma_list(model_data_dict['lookup_loc_techs_conversion_plus']['out', loc_tech])
)
carrier_prod = sum(backend_model.carrier_prod[loc_tech_carrier, timestep]
for loc_tech_carrier in loc_tech_carriers_out)
return carrier_prod >= (
backend_model.operating_units[loc_tech, timestep] *
timestep_resolution * energy_cap * min_use
)
def carrier_production_min_conversion_plus_constraint_rule(
backend_model, loc_tech, timestep):
"""
Set minimum conversion_plus carrier production.
.. container:: scrolling-wrapper
.. math::
\\sum_{loc::tech::carrier \\in loc::tech::carriers_{out}}
\\boldsymbol{carrier_{prod}}(loc::tech::carrier, timestep)
\\leq \\boldsymbol{energy_{cap}}(loc::tech) \\times timestep\\_resolution(timestep)
\\times energy_{cap, min use}(loc::tech)
\\quad \\forall loc::tech \\in loc::techs_{conversion^{+}},
\\forall timestep \\in timesteps
"""
model_data_dict = backend_model.__calliope_model_data["data"]
timestep_resolution = backend_model.timestep_resolution[timestep]
min_use = get_param(backend_model, "energy_cap_min_use",
(loc_tech, timestep))
loc_tech_carriers_out = split_comma_list(
model_data_dict["lookup_loc_techs_conversion_plus"]["out", loc_tech])
carrier_prod = sum(backend_model.carrier_prod[loc_tech_carrier, timestep]
for loc_tech_carrier in loc_tech_carriers_out)
return carrier_prod >= (timestep_resolution *
backend_model.energy_cap[loc_tech] * min_use)
def carrier_production_max_conversion_plus_constraint_rule(
backend_model, loc_tech, timestep):
"""
Set maximum conversion_plus carrier production.
.. container:: scrolling-wrapper
.. math::
\\sum_{loc::tech::carrier \\in loc::tech::carriers_{out}}
\\boldsymbol{carrier_{prod}}(loc::tech::carrier, timestep)
\\leq \\boldsymbol{energy_{cap}}(loc::tech) \\times timestep\\_resolution(timestep)
\\quad \\forall loc::tech \\in loc::techs_{conversion^{+}},
\\forall timestep \\in timesteps
"""
model_data_dict = backend_model.__calliope_model_data['data']
timestep_resolution = backend_model.timestep_resolution[timestep]
loc_tech_carriers_out = split_comma_list(
model_data_dict['lookup_loc_techs_conversion_plus']['out', loc_tech])
carrier_prod = sum(backend_model.carrier_prod[loc_tech_carrier, timestep]
for loc_tech_carrier in loc_tech_carriers_out)
return carrier_prod <= timestep_resolution * backend_model.energy_cap[
loc_tech]
def carrier_production_min_conversion_plus_constraint_rule(backend_model, loc_tech, timestep):
"""
Set minimum conversion_plus carrier production.
.. container:: scrolling-wrapper
.. math::
\\sum_{loc::tech::carrier \\in loc::tech::carriers_{out}}
\\boldsymbol{carrier_{prod}}(loc::tech::carrier, timestep)
\\leq \\boldsymbol{energy_{cap}}(loc::tech) \\times timestep\\_resolution(timestep)
\\times energy_{cap, min use}(loc::tech)
\\quad \\forall loc::tech \\in loc::techs_{conversion^{+}},
\\forall timestep \\in timesteps
"""
model_data_dict = backend_model.__calliope_model_data__['data']
timestep_resolution = backend_model.timestep_resolution[timestep]
min_use = get_param(backend_model, 'energy_cap_min_use', (loc_tech, timestep))
loc_tech_carriers_out = split_comma_list(
model_data_dict['lookup_loc_techs_conversion_plus']['out', loc_tech]
)
carrier_prod = sum(backend_model.carrier_prod[loc_tech_carrier, timestep]
for loc_tech_carrier in loc_tech_carriers_out)
return carrier_prod >= (
timestep_resolution * backend_model.energy_cap[loc_tech] * min_use
)
def carrier_production_max_conversion_plus_milp_constraint_rule(
backend_model, loc_tech, timestep
):
"""
Set maximum carrier production of conversion_plus MILP techs
.. container:: scrolling-wrapper
.. math::
\\sum_{loc::tech::carrier \\in loc::tech::carriers_{out}}
\\boldsymbol{carrier_{prod}}(loc::tech::carrier, timestep)
\\leq energy_{cap, per unit}(loc::tech) \\times timestep\\_resolution(timestep)
\\times \\boldsymbol{operating\\_units}(loc::tech, timestep)
\\times \\eta_{parasitic}(loc::tech, timestep)
\\quad \\forall loc::tech \\in loc::techs_{milp, conversion^{+}}, \\forall timestep \\in timesteps
"""
model_data_dict = backend_model.__calliope_model_data["data"]
timestep_resolution = backend_model.timestep_resolution[timestep]
energy_cap = get_param(backend_model, "energy_cap_per_unit", loc_tech)
loc_tech_carriers_out = split_comma_list(
model_data_dict["lookup_loc_techs_conversion_plus"]["out", loc_tech]
)
carrier_prod = sum(
backend_model.carrier_prod[loc_tech_carrier, timestep]
for loc_tech_carrier in loc_tech_carriers_out
)
return carrier_prod <= (
backend_model.operating_units[loc_tech, timestep]
* timestep_resolution
* energy_cap
)
def balance_conversion_plus_primary_constraint_rule(backend_model, loc_tech, timestep):
"""
Balance energy carrier consumption and production for carrier_in and carrier_out
.. container:: scrolling-wrapper
.. math::
\\sum_{loc::tech::carrier \\in loc::tech::carriers_{out}}
\\frac{\\boldsymbol{carrier_{prod}}(loc::tech::carrier, timestep)}{
carrier\\_ratio(loc::tech::carrier, `out')} =
-1 * \\sum_{loc::tech::carrier \\in loc::tech::carriers_{in}} (
\\boldsymbol{carrier_{con}}(loc::tech::carrier, timestep)
* carrier\\_ratio(loc::tech::carrier, `in') * \\eta_{energy}(loc::tech, timestep))
\\quad \\forall loc::tech \\in loc::techs_{conversion^{+}}, \\forall timestep \\in timesteps
"""
model_data_dict = backend_model.__calliope_model_data['data']
loc_tech_carriers_out = split_comma_list(
model_data_dict['lookup_loc_techs_conversion_plus']['out', loc_tech]
)
loc_tech_carriers_in = split_comma_list(
model_data_dict['lookup_loc_techs_conversion_plus']['in', loc_tech]
)
energy_eff = get_param(backend_model, 'energy_eff', (loc_tech, timestep))
carrier_prod = []
for loc_tech_carrier in loc_tech_carriers_out:
carrier_ratio = get_param(
backend_model, 'carrier_ratios', ('out', loc_tech_carrier, timestep)
)
if po.value(carrier_ratio) != 0:
carrier_prod.append(
backend_model.carrier_prod[loc_tech_carrier, timestep] / carrier_ratio
)
carrier_con = sum(
backend_model.carrier_con[loc_tech_carrier, timestep] *
get_param(backend_model, 'carrier_ratios', ('in', loc_tech_carrier, timestep))
for loc_tech_carrier in loc_tech_carriers_in
)
return sum(carrier_prod) == -1 * carrier_con * energy_eff
def balance_conversion_plus_primary_constraint_rule(backend_model, loc_tech, timestep):
"""
Balance energy carrier consumption and production for carrier_in and carrier_out
.. container:: scrolling-wrapper
.. math::
\\sum_{loc::tech::carrier \\in loc::tech::carriers_{out}}
\\frac{\\boldsymbol{carrier_{prod}}(loc::tech::carrier, timestep)}{
carrier\\_ratio(loc::tech::carrier, `out')} =
-1 * \\sum_{loc::tech::carrier \\in loc::tech::carriers_{in}} (
\\boldsymbol{carrier_{con}}(loc::tech::carrier, timestep)
* carrier\\_ratio(loc::tech::carrier, `in') * \\eta_{energy}(loc::tech, timestep))
\\quad \\forall loc::tech \\in loc::techs_{conversion^{+}}, \\forall timestep \\in timesteps
"""
model_data_dict = backend_model.__calliope_model_data__['data']
loc_tech_carriers_out = split_comma_list(
model_data_dict['lookup_loc_techs_conversion_plus']['out', loc_tech]
)
loc_tech_carriers_in = split_comma_list(
model_data_dict['lookup_loc_techs_conversion_plus']['in', loc_tech]
)
energy_eff = get_param(backend_model, 'energy_eff', (loc_tech, timestep))
carrier_prod = sum(
backend_model.carrier_prod[loc_tech_carrier, timestep] /
get_param(backend_model, 'carrier_ratios', ('out', loc_tech_carrier))
for loc_tech_carrier in loc_tech_carriers_out
)
carrier_con = sum(
backend_model.carrier_con[loc_tech_carrier, timestep] *
get_param(backend_model, 'carrier_ratios', ('in', loc_tech_carrier))
for loc_tech_carrier in loc_tech_carriers_in
)
return carrier_prod == -1 * carrier_con * energy_eff
def resource_area_capacity_per_loc_constraint_rule(backend_model, loc):
"""
Set upper bound on use of area for all locations which have `available_area`
constraint set. Does not consider resource_area applied to demand technologies
.. container:: scrolling-wrapper
.. math::
\\sum_{tech} \\boldsymbol{resource_{area}}(loc::tech) \\leq available\_area
\\quad \\forall loc \in locs \\text{ if } available\_area(loc)
"""
model_data_dict = backend_model.__calliope_model_data__['data']
available_area = model_data_dict['available_area'][loc]
loc_techs = split_comma_list(model_data_dict['lookup_loc_techs_area'][loc])
return (sum(backend_model.resource_area[loc_tech]
for loc_tech in loc_techs) <= available_area)
def resource_area_capacity_per_loc_constraint_rule(backend_model, loc):
"""
Set upper bound on use of area for all locations which have `available_area`
constraint set. Does not consider resource_area applied to demand technologies
.. container:: scrolling-wrapper
.. math::
\\sum_{tech} \\boldsymbol{resource_{area}}(loc::tech) \\leq available\\_area
\\quad \\forall loc \\in locs \\text{ if } available\\_area(loc)
"""
model_data_dict = backend_model.__calliope_model_data__['data']
available_area = model_data_dict['available_area'][loc]
loc_techs = split_comma_list(model_data_dict['lookup_loc_techs_area'][loc])
return (
sum(backend_model.resource_area[loc_tech] for loc_tech in loc_techs)
<= available_area
)
def balance_conversion_plus_tiers_constraint_rule(backend_model, tier,
loc_tech, timestep):
"""
Force all carrier_in_2/carrier_in_3 and carrier_out_2/carrier_out_3 to follow
carrier_in and carrier_out (respectively).
If `tier` in ['out_2', 'out_3']:
.. container:: scrolling-wrapper
.. math::
\\sum_{loc::tech::carrier \\in loc::tech::carriers_{out}} (
\\frac{\\boldsymbol{carrier_{prod}}(loc::tech::carrier, timestep)}{
carrier\\_ratio(loc::tech::carrier, `out')} =
\\sum_{loc::tech::carrier \\in loc::tech::carriers_{tier}} (
\\frac{\\boldsymbol{carrier_{prod}}(loc::tech::carrier, timestep)}{
carrier\\_ratio(loc::tech::carrier, tier)}
\\quad \\forall \\text { tier } \\in [`out_2', `out_3'], \\forall loc::tech
\\in loc::techs_{conversion^{+}}, \\forall timestep \\in timesteps
If `tier` in ['in_2', 'in_3']:
.. container:: scrolling-wrapper
.. math::
\\sum_{loc::tech::carrier \\in loc::tech::carriers_{in}}
\\frac{\\boldsymbol{carrier_{con}}(loc::tech::carrier, timestep)}{
carrier\\_ratio(loc::tech::carrier, `in')} =
\\sum_{loc::tech::carrier \\in loc::tech::carriers_{tier}}
\\frac{\\boldsymbol{carrier_{prod}}(loc::tech::carrier, timestep)}{
carrier\\_ratio(loc::tech::carrier, tier)}
\\quad \\forall \\text{ tier } \\in [`in_2', `in_3'], \\forall loc::tech
\\in loc::techs_{conversion^{+}}, \\forall timestep \\in timesteps
"""
primary_tier, decision_variable = get_conversion_plus_io(
backend_model, tier)
model_data_dict = backend_model.__calliope_model_data["data"]
loc_tech_carriers_1 = split_comma_list(
model_data_dict["lookup_loc_techs_conversion_plus"][primary_tier,
loc_tech])
loc_tech_carriers_2 = split_comma_list(
model_data_dict["lookup_loc_techs_conversion_plus"][tier, loc_tech])
c_1 = []
c_2 = []
for loc_tech_carrier in loc_tech_carriers_1:
carrier_ratio_1 = get_param(backend_model, "carrier_ratios",
(primary_tier, loc_tech_carrier, timestep))
if po.value(carrier_ratio_1) != 0:
c_1.append(decision_variable[loc_tech_carrier, timestep] /
carrier_ratio_1)
for loc_tech_carrier in loc_tech_carriers_2:
carrier_ratio_2 = get_param(backend_model, "carrier_ratios",
(tier, loc_tech_carrier, timestep))
if po.value(carrier_ratio_2) != 0:
c_2.append(decision_variable[loc_tech_carrier, timestep] /
carrier_ratio_2)
if len(c_2) == 0:
return po.Constraint.Skip
else:
return sum(c_1) == sum(c_2)
