Release v0.6.8

Author: Bryn Pickering

.azure-pipelines.yml

@@ -50,10 +50,11 @@ steps:
       conda info -a
     displayName: Configure and update conda
 
-  - bash: |
+  - bash: |  # cbc -quit may be required to make sure that cbc is 'reset' such that its timeout time fits within pyomo's strict limit (see: https://github.com/Pyomo/pyomo/issues/2102)
       python utils/conda_create.py requirements.yml --python_version=$(PYTHON_VERSION) --channels conda-forge defaults --run
       source activate calliope
       conda install -y -c conda-forge coincbc
+      cbc -quit
       pip install --no-cache-dir --verbose -e .
       py.test -n 2 --junitxml=junit/test-results.xml --cov=calliope --cov-report=term-missing --cov-report=xml -W ignore::FutureWarning
     displayName: Set up environment and run tests (UNIX)

calliope/_version.py

@@ -1 +1 @@
-__version__ = "0.6.7"
+__version__ = "0.6.8"

calliope/backend/checks.py

@@ -50,7 +50,7 @@ def _get_param(loc_tech, var):
         if _is_in(loc_tech, var) and not model_data[var].loc[loc_tech].isnull().any():
             param = model_data[var].loc[loc_tech].values
         else:
-            param = defaults[var]
+            param = defaults.get(var, None)
         return param
 
     def _is_in(loc_tech, set_or_var):
@@ -208,7 +208,7 @@ def _set_inf_and_warn(loc_tech, var, warnings, warning_text):
         if _is_in(loc_tech, "loc_techs_store"):
             storage_cap = model_data.storage_cap.loc[loc_tech].item()
             if not pd.isnull(storage_cap) and not pd.isnull(energy_cap):
-                if _get_param(loc_tech, "charge_rate") is not False:
+                if _get_param(loc_tech, "charge_rate") is not None:
                     charge_rate = model_data["charge_rate"].loc[loc_tech].item()
                     if storage_cap * charge_rate < energy_cap:
                         errors.append(
@@ -217,7 +217,7 @@ def _set_inf_and_warn(loc_tech, var, warnings, warning_text):
                                 loc_tech
                             )
                         )
-                if _get_param(loc_tech, "energy_cap_per_storage_cap_max") is not False:
+                if not np.isinf(_get_param(loc_tech, "energy_cap_per_storage_cap_max")):
                     energy_cap_per_storage_cap_max = (
                         model_data["energy_cap_per_storage_cap_max"]
                         .loc[loc_tech]
@@ -230,7 +230,7 @@ def _set_inf_and_warn(loc_tech, var, warnings, warning_text):
                                 loc_tech
                             )
                         )
-                if _get_param(loc_tech, "energy_cap_per_storage_cap_min") is not False:
+                if _get_param(loc_tech, "energy_cap_per_storage_cap_min") != 0:
                     energy_cap_per_storage_cap_min = (
                         model_data["energy_cap_per_storage_cap_min"]
                         .loc[loc_tech]

calliope/backend/pyomo/constraints/capacity.py

@@ -12,7 +12,12 @@
 import pyomo.core as po  # pylint: disable=import-error
 import numpy as np
 
-from calliope.backend.pyomo.util import get_param, split_comma_list
+from calliope.backend.pyomo.util import (
+    apply_equals,
+    get_param,
+    split_comma_list,
+    invalid,
+)
 from calliope import exceptions
 
 ORDER = 10  # order in which to invoke constraints relative to other constraint files
@@ -103,28 +108,21 @@ def get_capacity_constraint(
 
     decision_variable = getattr(backend_model, parameter)
 
-    if not _equals:
+    if _equals is None:
         _equals = get_param(backend_model, parameter + "_equals", loc_tech)
-    if not _max:
+    if _max is None:
         _max = get_param(backend_model, parameter + "_max", loc_tech)
-    if not _min:
+    if _min is None:
         _min = get_param(backend_model, parameter + "_min", loc_tech)
-    if po.value(_equals) is not False and po.value(_equals) is not None:
-        if np.isinf(po.value(_equals)):
-            e = exceptions.ModelError
-            raise e(
-                "Cannot use inf for {}_equals for loc:tech `{}`".format(
-                    parameter, loc_tech
-                )
-            )
-        if scale:
+    if apply_equals(_equals):
+        if scale is not None:
             _equals *= scale
         return decision_variable[loc_tech] == _equals
     else:
         if po.value(_min) == 0 and np.isinf(po.value(_max)):
             return po.Constraint.NoConstraint
         else:
-            if scale:
+            if scale is not None:
                 _max *= scale
                 _min *= scale
             return (_min, decision_variable[loc_tech], _max)
@@ -236,10 +234,15 @@ def energy_capacity_storage_equals_constraint_rule(backend_model, loc_tech):
             \\forall loc::tech \\in loc::techs_{store}
 
     """
-    return backend_model.energy_cap[loc_tech] == (
-        backend_model.storage_cap[loc_tech]
-        * get_param(backend_model, "energy_cap_per_storage_cap_equals", loc_tech)
+    energy_cap_per_storage_cap = get_param(
+        backend_model, "energy_cap_per_storage_cap_equals", loc_tech
     )
+    if apply_equals(energy_cap_per_storage_cap):
+        return backend_model.energy_cap[loc_tech] == (
+            backend_model.storage_cap[loc_tech] * energy_cap_per_storage_cap
+        )
+    else:
+        return po.Constraint.Skip
 
 
 def resource_capacity_constraint_rule(backend_model, loc_tech):
@@ -321,7 +324,7 @@ def resource_area_constraint_rule(backend_model, loc_tech):
         backend_model, "resource_area_per_energy_cap", loc_tech
     )
 
-    if po.value(energy_cap_max) == 0 and not po.value(area_per_energy_cap):
+    if po.value(energy_cap_max) == 0 and invalid(area_per_energy_cap):
         # If a technology has no energy_cap here, we force resource_area to zero,
         # so as not to accrue spurious costs
         return backend_model.resource_area[loc_tech] == 0
@@ -443,16 +446,12 @@ def energy_capacity_systemwide_constraint_rule(backend_model, tech):
     max_systemwide = get_param(backend_model, "energy_cap_max_systemwide", tech)
     equals_systemwide = get_param(backend_model, "energy_cap_equals_systemwide", tech)
 
-    if np.isinf(po.value(max_systemwide)) and not equals_systemwide:
+    if np.isinf(po.value(max_systemwide)) and not apply_equals(equals_systemwide):
         return po.Constraint.NoConstraint
-    elif equals_systemwide and np.isinf(po.value(equals_systemwide)):
-        raise exceptions.ModelError(
-            "Cannot use inf for energy_cap_equals_systemwide for tech `{}`".format(tech)
-        )
 
     sum_expr = sum(backend_model.energy_cap[loc_tech] for loc_tech in all_loc_techs)
 
-    if equals_systemwide:
+    if not invalid(equals_systemwide):
         return sum_expr == equals_systemwide * multiplier
     else:
         return sum_expr <= max_systemwide * multiplier

calliope/backend/pyomo/constraints/conversion.py

@@ -96,7 +96,7 @@ def cost_var_conversion_constraint_rule(backend_model, cost, loc_tech, timestep)
 
     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))
-    if po.value(cost_om_prod):
+    if po.value(cost_om_prod) != 0:
         cost_prod = (
             cost_om_prod
             * weight
@@ -105,7 +105,7 @@ def cost_var_conversion_constraint_rule(backend_model, cost, loc_tech, timestep)
     else:
         cost_prod = 0
 
-    if po.value(cost_om_con):
+    if po.value(cost_om_con) != 0:
         cost_con = (
             cost_om_con
             * weight

calliope/backend/pyomo/constraints/conversion_plus.py

@@ -15,6 +15,7 @@
     get_param,
     split_comma_list,
     get_conversion_plus_io,
+    invalid,
 )
 
 ORDER = 20  # order in which to invoke constraints relative to other constraint files
@@ -237,7 +238,7 @@ def cost_var_conversion_plus_constraint_rule(backend_model, cost, loc_tech, time
         cost_om_prod = get_param(
             backend_model, "cost_om_prod", (cost, loc_tech, timestep)
         )
-        if cost_om_prod:
+        if not invalid(cost_om_prod):
             var_cost += (
                 cost_om_prod
                 * weight
@@ -248,7 +249,7 @@ def cost_var_conversion_plus_constraint_rule(backend_model, cost, loc_tech, time
         cost_om_con = get_param(
             backend_model, "cost_om_con", (cost, loc_tech, timestep)
         )
-        if cost_om_con:
+        if not invalid(cost_om_con):
             var_cost += (
                 cost_om_con
                 * weight

calliope/backend/pyomo/constraints/energy_balance.py

@@ -211,7 +211,8 @@ def balance_supply_constraint_rule(backend_model, loc_tech, timestep):
     else:
         available_resource = resource * resource_scale
 
-    if po.value(force_resource):
+    # NOTE: this is a boolean comparison, generalised to account for possible floatification of the input data
+    if po.value(force_resource) == 1:
         return carrier_prod == available_resource
     elif min_use:
         return min_use * available_resource <= carrier_prod <= available_resource
@@ -286,7 +287,8 @@ def balance_demand_constraint_rule(backend_model, loc_tech, timestep):
     # e.g. in the group constraints
     backend_model.required_resource[loc_tech, timestep] = required_resource
 
-    if po.value(force_resource):
+    # NOTE: this is a boolean comparison, generalised to account for possible floatification of the input data
+    if po.value(force_resource) == 1:
         return carrier_con == backend_model.required_resource[loc_tech, timestep]
     else:
         return carrier_con >= backend_model.required_resource[loc_tech, timestep]
@@ -351,8 +353,8 @@ def resource_availability_supply_plus_constraint_rule(
         )
     else:
         available_resource = resource * resource_scale
-
-    if po.value(force_resource):
+    # NOTE: this is a boolean comparison, generalised to account for possible floatification of the input data
+    if po.value(force_resource) == 1:
         return backend_model.resource_con[loc_tech, timestep] == available_resource
     else:
         return backend_model.resource_con[loc_tech, timestep] <= available_resource
@@ -474,7 +476,7 @@ def balance_supply_plus_constraint_rule(backend_model, loc_tech, timestep):
                     timestep
                 ]
             elif current_timestep == 0 and run_config["cyclic_storage"]:
-                previous_step = backend_model.timesteps[-1]
+                previous_step = backend_model.timesteps.at(-1)
             else:
                 previous_step = get_previous_timestep(backend_model.timesteps, timestep)
             storage_loss = get_param(backend_model, "storage_loss", loc_tech)
@@ -540,7 +542,7 @@ def balance_storage_constraint_rule(backend_model, loc_tech, timestep):
         ):
             previous_step = model_data_dict["lookup_cluster_last_timestep"][timestep]
         elif current_timestep == 0 and run_config["cyclic_storage"]:
-            previous_step = backend_model.timesteps[-1]
+            previous_step = backend_model.timesteps.at(-1)
         else:
             previous_step = get_previous_timestep(backend_model.timesteps, timestep)
         storage_loss = get_param(backend_model, "storage_loss", loc_tech)
@@ -641,7 +643,7 @@ def storage_initial_rule(backend_model, loc_tech):
         time_resolution = 24
     else:
         storage = backend_model.storage
-        final_step = backend_model.timesteps[-1]
+        final_step = backend_model.timesteps.at(-1)
         time_resolution = backend_model.timestep_resolution[final_step]
 
     return (

calliope/backend/pyomo/constraints/group.py

@@ -59,6 +59,17 @@ def load_constraints(backend_model):
                 ),
             )
 
+        if "group_storage_cap_{}".format(sense) in model_data_dict:
+            setattr(
+                backend_model,
+                "group_storage_cap_{}_constraint".format(sense),
+                po.Constraint(
+                    getattr(backend_model, "group_names_storage_cap_{}".format(sense)),
+                    [sense],
+                    rule=storage_cap_constraint_rule,
+                ),
+            )
+
         if "group_resource_area_{}".format(sense) in model_data_dict:
             setattr(
                 backend_model,
@@ -198,14 +209,27 @@ def load_constraints(backend_model):
             )
 
     if "group_demand_share_per_timestep_decision" in model_data_dict:
-        backend_model.group_demand_share_per_timestep_decision_main_constraint = (
-            po.Constraint(
-                backend_model.group_names_demand_share_per_timestep_decision,
-                backend_model.loc_tech_carriers_demand_share_per_timestep_lhs,
-                backend_model.timesteps,
-                rule=demand_share_per_timestep_decision_main_constraint_rule,
+        relaxation = backend_model.__calliope_run_config["relax_constraint"][
+            "demand_share_per_timestep_decision_main_constraint"
+        ]
+        if relaxation == 0:
+            sense_scale = [("equals", 1)]
+        else:
+            sense_scale = [("min", 1 - relaxation), ("max", 1 + relaxation)]
+        for group_name in backend_model.group_names_demand_share_per_timestep_decision:
+            setattr(
+                backend_model,
+                f"group_demand_share_per_timestep_decision_{group_name}_constraint",
+                po.Constraint(
+                    [group_name],
+                    get_group_lhs_and_rhs_loc_tech_carriers(backend_model, group_name)[
+                        0
+                    ],
+                    backend_model.timesteps,
+                    sense_scale,
+                    rule=demand_share_per_timestep_decision_main_constraint_rule,
+                ),
             )
-        )
         backend_model.group_demand_share_per_timestep_decision_sum_constraint = (
             po.Constraint(
                 backend_model.group_names_demand_share_per_timestep_decision,
@@ -334,7 +358,7 @@ def demand_share_per_timestep_constraint_rule(
 
 
 def demand_share_per_timestep_decision_main_constraint_rule(
-    backend_model, group_name, loc_tech_carrier, timestep
+    backend_model, group_name, loc_tech_carrier, timestep, sense, scale
 ):
     """
     Allows the model to decide on how a fraction demand for a carrier is met
@@ -368,6 +392,7 @@ def demand_share_per_timestep_decision_main_constraint_rule(
     lhs = backend_model.carrier_prod[loc_tech_carrier, timestep]
     rhs = (
         -1
+        * scale
         * sum(
             backend_model.required_resource[
                 rhs_loc_tech_carrier.rsplit("::", 1)[0], timestep
@@ -377,7 +402,7 @@ def demand_share_per_timestep_decision_main_constraint_rule(
         * backend_model.demand_share_per_timestep_decision[loc_tech_carrier]
     )
 
-    return equalizer(lhs, rhs, "min")
+    return equalizer(lhs, rhs, sense)
 
 
 def demand_share_per_timestep_decision_sum_constraint_rule(backend_model, group_name):
@@ -686,8 +711,7 @@ def energy_cap_constraint_rule(backend_model, constraint_group, what):
 
 def storage_cap_constraint_rule(backend_model, constraint_group, what):
     """
-    Enforce upper and lower bounds for storage_cap of storage_cap
-    for groups of technologies and locations.
+    Enforce upper and lower bounds of storage_cap for groups of technologies and locations.
 
     .. container:: scrolling-wrapper
 

calliope/backend/pyomo/constraints/milp.py

@@ -18,6 +18,7 @@
     get_loc_tech,
     split_comma_list,
     loc_tech_is_in,
+    apply_equals,
 )
 
 from calliope.backend.pyomo.constraints.capacity import get_capacity_constraint
@@ -447,7 +448,7 @@ def energy_capacity_max_purchase_milp_constraint_rule(backend_model, loc_tech):
     energy_cap_equals = get_param(backend_model, "energy_cap_equals", loc_tech)
     energy_cap_scale = get_param(backend_model, "energy_cap_scale", loc_tech)
 
-    if po.value(energy_cap_equals):
+    if apply_equals(energy_cap_equals):
         return backend_model.energy_cap[loc_tech] == (
             energy_cap_equals * energy_cap_scale * backend_model.purchased[loc_tech]
         )
@@ -505,7 +506,7 @@ def storage_capacity_max_purchase_milp_constraint_rule(backend_model, loc_tech):
     storage_cap_max = get_param(backend_model, "storage_cap_max", loc_tech)
     storage_cap_equals = get_param(backend_model, "storage_cap_equals", loc_tech)
 
-    if po.value(storage_cap_equals):
+    if apply_equals(storage_cap_equals):
         return backend_model.storage_cap[loc_tech] == (
             storage_cap_equals * backend_model.purchased[loc_tech]
         )
@@ -648,12 +649,8 @@ def unit_capacity_systemwide_milp_constraint_rule(backend_model, tech):
     max_systemwide = get_param(backend_model, "units_max_systemwide", tech)
     equals_systemwide = get_param(backend_model, "units_equals_systemwide", tech)
 
-    if np.isinf(po.value(max_systemwide)) and not equals_systemwide:
+    if np.isinf(po.value(max_systemwide)) and not apply_equals(equals_systemwide):
         return po.Constraint.NoConstraint
-    elif equals_systemwide and np.isinf(po.value(equals_systemwide)):
-        raise ValueError(
-            "Cannot use inf for energy_cap_equals_systemwide for tech `{}`".format(tech)
-        )
 
     sum_expr_units = sum(
         backend_model.units[loc_tech]
@@ -666,7 +663,7 @@ def unit_capacity_systemwide_milp_constraint_rule(backend_model, tech):
         if loc_tech_is_in(backend_model, loc_tech, "loc_techs_purchase")
     )
 
-    if equals_systemwide:
+    if apply_equals(equals_systemwide):
         return sum_expr_units + sum_expr_purchase == equals_systemwide * multiplier
     else:
         return sum_expr_units + sum_expr_purchase <= max_systemwide * multiplier