def location_specific_to_dataset(model_run): """ Extract location specific information from the processed dictionary (model.model_run) and return an xarray Dataset with DataArray variables describing distance, coordinate and available area information. Parameters ---------- model_run : AttrDict processed Calliope model_run dict Returns ------- data_dict : dict conforming to xarray conventions """ # for every transmission technology, we extract distance information, if it # is available data_dict = dict() data_dict['distance'] = dict( dims='loc_techs_transmission', data=[ model_run.get_key( 'locations.{loc_from}.links.{loc_to}.techs.{tech}.distance'. format(**split_loc_techs_transmission(loc_tech)), np.nan) for loc_tech in model_run.sets['loc_techs_transmission'] ]) data_dict['lookup_remotes'] = dict( dims='loc_techs_transmission', data=concat_iterable( [(k['loc_to'], k['tech'], k['loc_from']) for k in [ split_loc_techs_transmission(loc_tech) for loc_tech in model_run.sets['loc_techs_transmission'] ]], ['::', ':'])) data_dict['available_area'] = dict(dims='locs', data=[ model_run.locations[loc].get( 'available_area', np.nan) for loc in model_run.sets['locs'] ]) # remove this dictionary element if nothing is defined in it if set(data_dict['available_area']['data']) == {np.nan}: del data_dict['available_area'] # Coordinates are defined per location, but may not be defined at all for # the model if 'coordinates' in model_run.sets: data_dict['loc_coordinates'] = dict(dims=['locs', 'coordinates'], data=[]) for loc in model_run.sets['locs']: data_dict['loc_coordinates']['data'].append([ model_run.locations[loc].coordinates[coordinate] for coordinate in model_run.sets.coordinates ]) return data_dict
def generate_loc_tech_sets(model_run, simple_sets): """ Generate loc-tech sets for a given pre-processed ``model_run`` Parameters ---------- model_run : AttrDict simple_sets : AttrDict Simple sets returned by ``generate_simple_sets(model_run)``. """ sets = AttrDict() ## # First deal with transmission techs, which can show up only in # loc_techs_transmission, loc_techs_milp, and loc_techs_purchase ## # All `tech:loc` expanded transmission technologies sets.loc_techs_transmission = set( concat_iterable( [ (i, u, j) for i, j, u in product( # (loc, loc, tech) product simple_sets.locs, simple_sets.locs, simple_sets.techs_transmission_names) if model_run.get_key( 'locations.{}.links.{}.techs.{}'.format(i, j, u), None) ], ['::', ':'])) # A dict of transmission tech config objects # to make parsing for set membership easier loc_techs_transmission_config = { k: model_run.get_key( 'locations.{loc_from}.links.{loc_to}.techs.{tech}'.format( **split_loc_techs_transmission(k))) for k in sets.loc_techs_transmission } ## # Now deal with the rest of the techs and other sets ## # Only loc-tech combinations that actually exist sets.loc_techs_non_transmission = set( concat_iterable( [(l, t) for l, t in product(simple_sets.locs, simple_sets.techs_non_transmission) if model_run.get_key('locations.{}.techs.{}'.format(l, t), None)], ['::'])) sets.loc_techs = sets.loc_techs_non_transmission | sets.loc_techs_transmission # A dict of non-transmission tech config objects # to make parsing for set membership easier loc_techs_config = { k: model_run.get_key('locations.{}.techs.{}'.format(*k.split('::'))) for k in sets.loc_techs_non_transmission } loc_techs_all_config = { **loc_techs_config, **loc_techs_transmission_config } ## # Sets based on membership in abstract base technology groups ## for group in [ 'storage', 'demand', 'supply', 'supply_plus', 'conversion', 'conversion_plus' ]: tech_set = set( k for k in sets.loc_techs_non_transmission if model_run.techs[k.split('::')[1]].inheritance[-1] == group) sets['loc_techs_{}'.format(group)] = tech_set sets.loc_techs_non_conversion = set( k for k in sets.loc_techs_non_transmission if k not in sets.loc_techs_conversion and k not in sets.loc_techs_conversion_plus) | sets.loc_techs_transmission # Techs that introduce energy into the system sets.loc_techs_supply_all = (sets.loc_techs_supply | sets.loc_techs_supply_plus | sets.loc_techs_conversion | sets.loc_techs_conversion_plus) ## # Sets based on specific constraints being active ## # Technologies that specify resource_area constraints sets.loc_techs_area = set( k for k in sets.loc_techs_non_transmission if (any( 'resource_area' in i for i in loc_techs_config[k].keys_nested()) or loc_techs_config[k]. constraints.get('resource_unit', 'energy') == 'energy_per_area')) # Technologies that define storage, which can include `supply_plus` # and `storage` groups. sets.loc_techs_store = set(k for k in sets.loc_techs_supply_plus if any( 'storage_' in i for i in loc_techs_config[k].constraints.keys_nested()) ) | sets.loc_techs_storage # technologies that specify a finite resource sets.loc_techs_finite_resource = set( k for k in sets.loc_techs_non_transmission if loc_techs_config[k].constraints.get('resource') and not ( loc_techs_config[k].constraints.get('resource') in ['inf', np.inf]) ) # `supply` technologies that specify a finite resource sets.loc_techs_finite_resource_supply = ( sets.loc_techs_finite_resource.intersection(sets.loc_techs_supply)) # `demand` technologies that specify a finite resource sets.loc_techs_finite_resource_demand = ( sets.loc_techs_finite_resource.intersection(sets.loc_techs_demand)) # `supply_plus` technologies that specify a finite resource sets.loc_techs_finite_resource_supply_plus = ( sets.loc_techs_finite_resource.intersection( sets.loc_techs_supply_plus)) # Technologies that define ramping constraints sets.loc_techs_ramping = set( k for k in sets.loc_techs_non_transmission if 'energy_ramping' in loc_techs_config[k].constraints) # Technologies that allow export sets.loc_techs_export = set( k for k in sets.loc_techs_non_transmission if 'export_carrier' in loc_techs_config[k].constraints) # Technologies that allow purchasing discrete units # NB: includes transmission techs! loc_techs_purchase = set(k for k in sets.loc_techs_non_transmission if any( '.purchase' in i for i in loc_techs_config[k].get('costs', AttrDict()).keys_nested( )) and not any('units_' in i for i in loc_techs_config[k].get( 'constraints', AttrDict()).keys_nested())) transmission_purchase = set( k for k in sets.loc_techs_transmission if any('.purchase' in i for i in loc_techs_transmission_config[k].get( 'costs', AttrDict()).keys_nested()) and not any( 'units_' in i for i in loc_techs_transmission_config[k].get( 'constraints', AttrDict()).keys_nested())) sets.loc_techs_purchase = loc_techs_purchase | transmission_purchase # Technologies with MILP constraints loc_techs_milp = set(k for k in sets.loc_techs_non_transmission if any( 'units_' in i for i in loc_techs_config[k].constraints.keys_nested())) transmission_milp = set(k for k in sets.loc_techs_transmission if any( 'units_' in i for i in loc_techs_transmission_config[k].constraints.keys_nested())) sets.loc_techs_milp = loc_techs_milp | transmission_milp ## # Sets based on specific costs being active # NB includes transmission techs ## loc_techs_costs = set(k for k in sets.loc_techs_non_transmission if any( 'costs' in i for i in loc_techs_config[k].keys())) loc_techs_transmission_costs = set( k for k in sets.loc_techs_transmission if any('costs' in i for i in loc_techs_transmission_config[k].keys())) # Any capacity or fixed annual costs loc_techs_investment_costs = set(k for k in loc_techs_costs if any( '_cap' in i or '.purchase' in i or '_area' in i for i in loc_techs_config[k].costs.keys_nested())) loc_techs_transmission_investment_costs = set( k for k in loc_techs_transmission_costs if any('_cap' in i or '.purchase' in i or '_area' in i for i in loc_techs_transmission_config[k].costs.keys_nested())) # Any operation and maintenance loc_techs_om_costs = set(k for k in loc_techs_costs if any( 'om_' in i or 'export' in i for i in loc_techs_config[k].costs.keys_nested())) loc_techs_transmission_om_costs = set( k for k in loc_techs_transmission_costs if any('om_' in i for i in loc_techs_transmission_config[k].costs.keys_nested())) # Any export costs sets.loc_techs_costs_export = set(k for k in loc_techs_costs if any( 'export' in i for i in loc_techs_config[k].costs.keys_nested())) sets.loc_techs_cost = loc_techs_costs | loc_techs_transmission_costs sets.loc_techs_investment_cost = (loc_techs_investment_costs | loc_techs_transmission_investment_costs) sets.loc_techs_om_cost = loc_techs_om_costs | loc_techs_transmission_om_costs ## # Subsets of costs for different abstract base technologies ## sets.loc_techs_om_cost_conversion = loc_techs_om_costs.intersection( sets.loc_techs_conversion) sets.loc_techs_om_cost_conversion_plus = loc_techs_om_costs.intersection( sets.loc_techs_conversion_plus) sets.loc_techs_om_cost_supply = loc_techs_om_costs.intersection( sets.loc_techs_supply) sets.loc_techs_om_cost_supply_plus = loc_techs_om_costs.intersection( sets.loc_techs_supply_plus) ## # Subsets of `conversion_plus` technologies ## # `conversion_plus` technologies with secondary carrier(s) out sets.loc_techs_out_2 = set(k for k in sets.loc_techs_conversion_plus if 'carrier_out_2' in model_run.techs[k.split( '::')[1].split(':')[0]].essentials) # `conversion_plus` technologies with tertiary carrier(s) out sets.loc_techs_out_3 = set(k for k in sets.loc_techs_conversion_plus if 'carrier_out_3' in model_run.techs[k.split( '::')[1].split(':')[0]].essentials) # `conversion_plus` technologies with secondary carrier(s) in sets.loc_techs_in_2 = set(k for k in sets.loc_techs_conversion_plus if 'carrier_in_2' in model_run.techs[k.split( '::')[1].split(':')[0]].essentials) # `conversion_plus` technologies with tertiary carrier(s) in sets.loc_techs_in_3 = set(k for k in sets.loc_techs_conversion_plus if 'carrier_in_3' in model_run.techs[k.split( '::')[1].split(':')[0]].essentials) ## # `loc_tech_carrier` sets ## # loc_tech_carriers for all technologies that have energy_prod=True sets.loc_tech_carriers_prod = set( '{}::{}'.format(k, carrier) for k in sets.loc_techs if loc_techs_all_config[k].constraints.get_key('energy_prod', False) for carrier in get_all_carriers(model_run.techs[k.split('::')[1].split( ':')[0]].essentials, direction='out')) # loc_tech_carriers for all technologies that have energy_con=True sets.loc_tech_carriers_con = set( '{}::{}'.format(k, carrier) for k in sets.loc_techs if loc_techs_all_config[k].constraints.get_key('energy_con', False) for carrier in get_all_carriers(model_run.techs[k.split('::')[1].split( ':')[0]].essentials, direction='in')) # loc_tech_carriers for all supply technologies sets.loc_tech_carriers_supply_all = set( '{}::{}'.format(k, carrier) for k in sets.loc_techs_supply_all for carrier in get_all_carriers(model_run.techs[k.split('::')[1].split( ':')[0]].essentials, direction='out')) # loc_tech_carriers for all demand technologies sets.loc_tech_carriers_demand = set( '{}::{}'.format(k, carrier) for k in sets.loc_techs_demand for carrier in get_all_carriers(model_run.techs[k.split('::')[1].split( ':')[0]].essentials, direction='in')) # loc_tech_carriers for all technologies that have export sets.loc_tech_carriers_export = set( '{}::{}'.format(k, loc_techs_all_config[k].constraints.export_carrier) for k in sets.loc_techs if loc_techs_all_config[k].constraints.get_key( 'export_carrier', False)) # loc_tech_carriers for `conversion_plus` technologies sets.loc_tech_carriers_conversion_plus = set( k for k in sets.loc_tech_carriers_con | sets.loc_tech_carriers_prod if k.rsplit('::', 1)[0] in sets.loc_techs_conversion_plus) # loc_carrier combinations that exist with either a con or prod tech sets.loc_carriers = set('{0}::{2}'.format(*k.split('::')) for k in sets.loc_tech_carriers_prod | sets.loc_tech_carriers_con) return sets
def generate_constraint_sets(model_run): """ Generate loc-tech sets for a given pre-processed ``model_run`` Parameters ---------- model_run : AttrDict """ sets = model_run.sets ## From here on, everything is a `key=value` pair within a dictionary constraint_sets = dict() # energy_balance.py constraint_sets['loc_carriers_system_balance_constraint'] = sets.loc_carriers constraint_sets['loc_techs_balance_supply_constraint'] = sets.loc_techs_finite_resource_supply constraint_sets['loc_techs_balance_demand_constraint'] = sets.loc_techs_finite_resource_demand constraint_sets['loc_techs_resource_availability_supply_plus_constraint'] = sets.loc_techs_finite_resource_supply_plus constraint_sets['loc_techs_balance_transmission_constraint'] = sets.loc_techs_transmission constraint_sets['loc_techs_balance_supply_plus_constraint'] = sets.loc_techs_supply_plus constraint_sets['loc_techs_balance_storage_constraint'] = sets.loc_techs_storage if model_run.run.cyclic_storage is True: constraint_sets['loc_techs_storage_initial_constraint'] = [ i for i in sets.loc_techs_store if constraint_exists(model_run, i, 'constraints.storage_initial') is not None ] constraint_sets['carriers_reserve_margin_constraint'] = [ i for i in sets.carriers if i in model_run.model.get_key('reserve_margin', {}).keys() ] # clustering-specific balance constraints if (model_run.model.get_key('time.function', None) == 'apply_clustering' and model_run.model.get_key('time.function_options.storage_inter_cluster', True)): set_name = 'loc_techs_balance_storage_inter_cluster_constraint' constraint_sets[set_name] = sets.loc_techs_store # costs.py constraint_sets['loc_techs_cost_constraint'] = sets.loc_techs_cost constraint_sets['loc_techs_cost_investment_constraint'] = sets.loc_techs_investment_cost constraint_sets['loc_techs_cost_var_constraint'] = [ i for i in sets.loc_techs_om_cost if i not in sets.loc_techs_conversion_plus + sets.loc_techs_conversion ] # export.py constraint_sets['loc_carriers_update_system_balance_constraint'] = [ i for i in sets.loc_carriers if sets.loc_techs_export and any(['{0}::{2}'.format(*j.split('::')) == i for j in sets.loc_tech_carriers_export]) ] constraint_sets['loc_tech_carriers_export_balance_constraint'] = ( sets.loc_tech_carriers_export ) constraint_sets['loc_techs_update_costs_var_constraint'] = [ i for i in sets.loc_techs_om_cost if i in sets.loc_techs_export ] constraint_sets['loc_tech_carriers_export_max_constraint'] = [ i for i in sets.loc_tech_carriers_export if constraint_exists( model_run, i.rsplit('::', 1)[0], 'constraints.export_cap' ) is not None ] # capacity.py constraint_sets['loc_techs_storage_capacity_constraint'] = [ i for i in sets.loc_techs_store if i not in sets.loc_techs_milp ] constraint_sets['loc_techs_energy_capacity_storage_constraint_old'] = [ i for i in sets.loc_techs_store if constraint_exists(model_run, i, 'constraints.charge_rate') ] constraint_sets['loc_techs_energy_capacity_storage_equals_constraint'] = [ i for i in sets.loc_techs_store if constraint_exists(model_run, i, 'constraints.energy_cap_per_storage_cap_equals') ] constraint_sets['loc_techs_energy_capacity_storage_min_constraint'] = [ i for i in sets.loc_techs_store if constraint_exists(model_run, i, 'constraints.energy_cap_per_storage_cap_min') and not constraint_exists(model_run, i, 'constraints.energy_cap_per_storage_cap_equals') ] constraint_sets['loc_techs_energy_capacity_storage_max_constraint'] = [ i for i in sets.loc_techs_store if constraint_exists(model_run, i, 'constraints.energy_cap_per_storage_cap_max') and not constraint_exists(model_run, i, 'constraints.energy_cap_per_storage_cap_equals') ] constraint_sets['loc_techs_resource_capacity_constraint'] = [ i for i in sets.loc_techs_finite_resource_supply_plus if any([ constraint_exists(model_run, i, 'constraints.resource_cap_equals'), constraint_exists(model_run, i, 'constraints.resource_cap_max'), constraint_exists(model_run, i, 'constraints.resource_cap_min') ]) ] constraint_sets['loc_techs_resource_capacity_equals_energy_capacity_constraint'] = [ i for i in sets.loc_techs_finite_resource_supply_plus if constraint_exists(model_run, i, 'constraints.resource_cap_equals_energy_cap') ] constraint_sets['loc_techs_resource_area_constraint'] = sets.loc_techs_area constraint_sets['loc_techs_resource_area_per_energy_capacity_constraint'] = [ i for i in sets.loc_techs_area if constraint_exists(model_run, i, 'constraints.resource_area_per_energy_cap') is not None ] constraint_sets['locs_resource_area_capacity_per_loc_constraint'] = [ i for i in sets.locs if model_run.locations[i].get_key('available_area', None) is not None and sets.loc_techs_area ] constraint_sets['loc_techs_energy_capacity_constraint'] = [ i for i in sets.loc_techs if i not in sets.loc_techs_milp + sets.loc_techs_purchase ] constraint_sets['techs_energy_capacity_systemwide_constraint'] = [ i for i in sets.techs if model_run.get_key('techs.{}.constraints.energy_cap_max_systemwide'.format(i), None) or model_run.get_key('techs.{}.constraints.energy_cap_equals_systemwide'.format(i), None) ] # dispatch.py constraint_sets['loc_tech_carriers_carrier_production_max_constraint'] = [ i for i in sets.loc_tech_carriers_prod if i not in sets.loc_tech_carriers_conversion_plus and i.rsplit('::', 1)[0] not in sets.loc_techs_milp ] constraint_sets['loc_tech_carriers_carrier_production_min_constraint'] = [ i for i in sets.loc_tech_carriers_prod if i not in sets.loc_tech_carriers_conversion_plus and constraint_exists(model_run, i.rsplit('::', 1)[0], 'constraints.energy_cap_min_use') and i.rsplit('::', 1)[0] not in sets.loc_techs_milp ] constraint_sets['loc_tech_carriers_carrier_consumption_max_constraint'] = [ i for i in sets.loc_tech_carriers_con if i.rsplit('::', 1)[0] in sets.loc_techs_demand + sets.loc_techs_storage + sets.loc_techs_transmission and i.rsplit('::', 1)[0] not in sets.loc_techs_milp ] constraint_sets['loc_techs_resource_max_constraint'] = sets.loc_techs_supply_plus constraint_sets['loc_tech_carriers_ramping_constraint'] = [ i for i in sets.loc_tech_carriers_prod if i.rsplit('::', 1)[0] in sets.loc_techs_ramping ] # clustering-specific dispatch constraints if (model_run.model.get_key('time.function', None) == 'apply_clustering' and model_run.model.get_key('time.function_options.storage_inter_cluster', True)): constraint_sets['loc_techs_storage_intra_max_constraint'] = sets.loc_techs_store constraint_sets['loc_techs_storage_intra_min_constraint'] = sets.loc_techs_store constraint_sets['loc_techs_storage_inter_max_constraint'] = sets.loc_techs_store constraint_sets['loc_techs_storage_inter_min_constraint'] = sets.loc_techs_store else: constraint_sets['loc_techs_storage_max_constraint'] = sets.loc_techs_store # milp.py constraint_sets['loc_techs_unit_commitment_milp_constraint'] = sets.loc_techs_milp constraint_sets['loc_techs_unit_capacity_milp_constraint'] = sets.loc_techs_milp constraint_sets['loc_tech_carriers_carrier_production_max_milp_constraint'] = [ i for i in sets.loc_tech_carriers_prod if i not in sets.loc_tech_carriers_conversion_plus and i.rsplit('::', 1)[0] in sets.loc_techs_milp ] constraint_sets['loc_techs_carrier_production_max_conversion_plus_milp_constraint'] = [ i for i in sets.loc_techs_conversion_plus if i in sets.loc_techs_milp ] constraint_sets['loc_tech_carriers_carrier_production_min_milp_constraint'] = [ i for i in sets.loc_tech_carriers_prod if i not in sets.loc_tech_carriers_conversion_plus and constraint_exists(model_run, i.rsplit('::', 1)[0], 'constraints.energy_cap_min_use') and i.rsplit('::', 1)[0] in sets.loc_techs_milp ] constraint_sets['loc_techs_carrier_production_min_conversion_plus_milp_constraint'] = [ i for i in sets.loc_techs_conversion_plus if constraint_exists(model_run, i, 'constraints.energy_cap_min_use') and i in sets.loc_techs_milp ] constraint_sets['loc_tech_carriers_carrier_consumption_max_milp_constraint'] = [ i for i in sets.loc_tech_carriers_con if i.rsplit('::', 1)[0] in sets.loc_techs_demand + sets.loc_techs_storage + sets.loc_techs_transmission and i.rsplit('::', 1)[0] in sets.loc_techs_milp ] constraint_sets['loc_techs_energy_capacity_units_milp_constraint'] = [ i for i in sets.loc_techs_milp if constraint_exists(model_run, i, 'constraints.energy_cap_per_unit') is not None ] constraint_sets['loc_techs_storage_capacity_units_milp_constraint'] = [ i for i in sets.loc_techs_milp if i in sets.loc_techs_store ] constraint_sets['loc_techs_energy_capacity_max_purchase_milp_constraint'] = [ i for i in sets.loc_techs_purchase if (constraint_exists(model_run, i, 'constraints.energy_cap_equals') is not None or (constraint_exists(model_run, i, 'constraints.energy_cap_max') is not None and constraint_exists(model_run, i, 'constraints.energy_cap_max') != np.inf)) ] constraint_sets['loc_techs_energy_capacity_min_purchase_milp_constraint'] = [ i for i in sets.loc_techs_purchase if (not constraint_exists(model_run, i, 'constraints.energy_cap_equals') and constraint_exists(model_run, i, 'constraints.energy_cap_min')) ] constraint_sets['loc_techs_storage_capacity_max_purchase_milp_constraint'] = [ i for i in set(sets.loc_techs_purchase).intersection(sets.loc_techs_store) if (constraint_exists(model_run, i, 'constraints.storage_cap_equals') is not None or (constraint_exists(model_run, i, 'constraints.storage_cap_max') is not None and constraint_exists(model_run, i, 'constraints.storage_cap_max') != np.inf)) ] constraint_sets['loc_techs_storage_capacity_min_purchase_milp_constraint'] = [ i for i in set(sets.loc_techs_purchase).intersection(sets.loc_techs_store) if (not constraint_exists(model_run, i, 'constraints.storage_cap_equals') and constraint_exists(model_run, i, 'constraints.storage_cap_min')) ] constraint_sets['loc_techs_update_costs_investment_units_milp_constraint'] = [ i for i in sets.loc_techs_milp if i in sets.loc_techs_investment_cost and any(constraint_exists(model_run, i, 'costs.{}.purchase'.format(j)) for j in model_run.sets.costs) ] # loc_techs_purchase technologies only exist because they have defined a purchase cost constraint_sets['loc_techs_update_costs_investment_purchase_milp_constraint'] = sets.loc_techs_purchase constraint_sets['techs_unit_capacity_systemwide_milp_constraint'] = [ i for i in sets.techs if model_run.get_key('techs.{}.constraints.units_max_systemwide'.format(i), None) or model_run.get_key('techs.{}.constraints.units_equals_systemwide'.format(i), None) ] constraint_sets['loc_techs_asynchronous_prod_con_milp_constraint'] = sets.loc_techs_asynchronous_prod_con # conversion.py constraint_sets['loc_techs_balance_conversion_constraint'] = sets.loc_techs_conversion constraint_sets['loc_techs_cost_var_conversion_constraint'] = sets.loc_techs_om_cost_conversion # conversion_plus.py constraint_sets['loc_techs_balance_conversion_plus_primary_constraint'] = sets.loc_techs_conversion_plus constraint_sets['loc_techs_carrier_production_max_conversion_plus_constraint'] = [ i for i in sets.loc_techs_conversion_plus if i not in sets.loc_techs_milp ] constraint_sets['loc_techs_carrier_production_min_conversion_plus_constraint'] = [ i for i in sets.loc_techs_conversion_plus if constraint_exists(model_run, i, 'constraints.energy_cap_min_use') and i not in sets.loc_techs_milp ] constraint_sets['loc_techs_cost_var_conversion_plus_constraint'] = sets.loc_techs_om_cost_conversion_plus constraint_sets['loc_techs_balance_conversion_plus_in_2_constraint'] = sets.loc_techs_in_2 constraint_sets['loc_techs_balance_conversion_plus_in_3_constraint'] = sets.loc_techs_in_3 constraint_sets['loc_techs_balance_conversion_plus_out_2_constraint'] = sets.loc_techs_out_2 constraint_sets['loc_techs_balance_conversion_plus_out_3_constraint'] = sets.loc_techs_out_3 # network.py constraint_sets['loc_techs_symmetric_transmission_constraint'] = sets.loc_techs_transmission # policy.py constraint_sets['techlists_group_share_energy_cap_min_constraint'] = [ i for i in sets.techlists if 'energy_cap_min' in model_run.model.get_key('group_share.{}'.format(i), {}).keys() ] constraint_sets['techlists_group_share_energy_cap_max_constraint'] = [ i for i in sets.techlists if 'energy_cap_max' in model_run.model.get_key('group_share.{}'.format(i), {}).keys() ] constraint_sets['techlists_group_share_energy_cap_equals_constraint'] = [ i for i in sets.techlists if 'energy_cap_equals' in model_run.model.get_key('group_share.{}'.format(i), {}).keys() ] constraint_sets['techlists_carrier_group_share_carrier_prod_min_constraint'] = [ i + '::' + carrier for i in sets.techlists if 'carrier_prod_min' in model_run.model.get_key('group_share.{}'.format(i), {}).keys() for carrier in sets.carriers if carrier in model_run.model.get_key('group_share.{}.carrier_prod_min'.format(i), {}).keys() ] constraint_sets['techlists_carrier_group_share_carrier_prod_max_constraint'] = [ i + '::' + carrier for i in sets.techlists if 'carrier_prod_max' in model_run.model.get_key('group_share.{}'.format(i), {}).keys() for carrier in sets.carriers if carrier in model_run.model.get_key('group_share.{}.carrier_prod_max'.format(i), {}).keys() ] constraint_sets['techlists_carrier_group_share_carrier_prod_equals_constraint'] = [ i + '::' + carrier for i in sets.techlists if 'carrier_prod_equals' in model_run.model.get_key('group_share.{}'.format(i), {}).keys() for carrier in sets.carriers if carrier in model_run.model.get_key('group_share.{}.carrier_prod_equals'.format(i), {}).keys() ] # group.py group_constraints = { name: data for name, data in model_run['group_constraints'].items() if data.get("exists", True) } constraint_sets['constraint_groups'] = list(group_constraints.keys()) for group_constraint_name, group_constraint in group_constraints.items(): tech_groups = [ [k for k, v in checks.DEFAULTS.tech_groups.items() if i in v['allowed_group_constraints']] for i in group_constraint.keys() if i not in ['techs', 'locs', 'exists'] ] allowed_tech_groups = set(tech_groups[0]).intersection(*tech_groups) allowed_techs = sum([sets['techs_{}'.format(i)] for i in allowed_tech_groups], []) # If the group constraint defines its own techs, remove those that are # not allowed (there is a warning for this in checks.py) techs = list(set(group_constraint.get('techs', allowed_techs)).intersection(allowed_techs)) locs = group_constraint.get('locs', sets['locs']) # If there are transmission techs, keep only those that link to allowed locations techs = [i for i in techs if ':' not in techs or i.split(':')[-1] in locs] trans_techs = set(techs).intersection(sets['techs_transmission_names']) for i in trans_techs: techs += [i + ':' + j for j in locs] techs.remove(i) # All possible loc_techs for this constraint loc_techs_all = list(set(concat_iterable( [(l, t) for l, t in product(locs, techs)], ['::'] ))) # Some loc_techs may not actually exist in the actual model, # so we must filter with actually exising loc_techs loc_techs = [i for i in loc_techs_all if i in sets.loc_techs] constraint_sets['group_constraint_loc_techs_{}'.format(group_constraint_name)] = loc_techs return constraint_sets
def location_specific_to_dataset(model_run): """ Extract location specific information from the processed dictionary (model.model_run) and return an xarray Dataset with DataArray variables describing distance, coordinate and available area information. Parameters ---------- model_run : AttrDict processed Calliope model_run dict Returns ------- data_dict : dict conforming to xarray conventions """ # for every transmission technology, we extract distance information, if it # is available data_dict = dict() data_dict['distance'] = dict(dims='loc_techs_transmission', data=[ model_run.get_key( 'locations.{loc_from}.links.{loc_to}.techs.{tech}.distance' .format(**split_loc_techs_transmission(loc_tech)), np.nan) for loc_tech in model_run.sets['loc_techs_transmission'] ]) # If there is no distance information stored, distance array is deleted if data_dict['distance']['data'].count(np.nan) == len(data_dict['distance']['data']): del data_dict['distance'] data_dict['lookup_remotes'] = dict( dims='loc_techs_transmission', data=concat_iterable([ (k['loc_to'], k['tech'], k['loc_from']) for k in [ split_loc_techs_transmission(loc_tech) for loc_tech in model_run.sets['loc_techs_transmission'] ] ], ['::', ':']) ) # If there are no remote locations stored, lookup_remotes array is deleted if data_dict['lookup_remotes']['data'].count(np.nan) == len(data_dict['lookup_remotes']['data']): del data_dict['lookup_remotes'] data_dict['available_area'] = dict(dims='locs', data=[ model_run.locations[loc].get('available_area', np.nan) for loc in model_run.sets['locs'] ]) # remove this dictionary element if nothing is defined in it if set(data_dict['available_area']['data']) == {np.nan}: del data_dict['available_area'] # Coordinates are defined per location, but may not be defined at all for # the model if 'coordinates' in model_run.sets: data_dict['loc_coordinates'] = dict(dims=['locs', 'coordinates'], data=[]) for loc in model_run.sets['locs']: data_dict['loc_coordinates']['data'].append([ model_run.locations[loc].coordinates[coordinate] for coordinate in model_run.sets.coordinates]) return data_dict
def generate_loc_tech_sets(model_run, simple_sets): """ Generate loc-tech sets for a given pre-processed ``model_run`` Parameters ---------- model_run : AttrDict simple_sets : AttrDict Simple sets returned by ``generate_simple_sets(model_run)``. """ sets = AttrDict() ## # First deal with transmission techs, which can show up only in # loc_techs_transmission, loc_techs_milp, and loc_techs_purchase ## # All `tech:loc` expanded transmission technologies sets.loc_techs_transmission = set(concat_iterable([ (i, u, j) for i, j, u in product( # (loc, loc, tech) product simple_sets.locs, simple_sets.locs, simple_sets.techs_transmission_names) if model_run.get_key( 'locations.{}.links.{}.techs.{}'.format(i, j, u), None ) ], ['::', ':'])) # A dict of transmission tech config objects # to make parsing for set membership easier loc_techs_transmission_config = { k: model_run.get_key( 'locations.{loc_from}.links.{loc_to}.techs.{tech}' .format(**split_loc_techs_transmission(k)) ) for k in sets.loc_techs_transmission } ## # Now deal with the rest of the techs and other sets ## # Only loc-tech combinations that actually exist sets.loc_techs_non_transmission = set(concat_iterable([ (l, t) for l, t in product( simple_sets.locs, simple_sets.techs_non_transmission) if model_run.get_key('locations.{}.techs.{}'.format(l, t), None) ], ['::'])) sets.loc_techs = sets.loc_techs_non_transmission | sets.loc_techs_transmission # A dict of non-transmission tech config objects # to make parsing for set membership easier loc_techs_config = { k: model_run.get_key( 'locations.{}.techs.{}'.format(*k.split('::')) ) for k in sets.loc_techs_non_transmission } loc_techs_all_config = {**loc_techs_config, **loc_techs_transmission_config} ## # Sets based on membership in abstract base technology groups ## for group in [ 'storage', 'demand', 'supply', 'supply_plus', 'conversion', 'conversion_plus']: tech_set = set( k for k in sets.loc_techs_non_transmission if model_run.techs[k.split('::')[1]].inheritance[-1] == group ) sets['loc_techs_{}'.format(group)] = tech_set sets.loc_techs_non_conversion = set( k for k in sets.loc_techs_non_transmission if k not in sets.loc_techs_conversion and k not in sets.loc_techs_conversion_plus ) | sets.loc_techs_transmission # Techs that introduce energy into the system sets.loc_techs_supply_all = ( sets.loc_techs_supply | sets.loc_techs_supply_plus | sets.loc_techs_conversion | sets.loc_techs_conversion_plus ) ## # Sets based on specific constraints being active ## # Technologies that specify resource_area constraints sets.loc_techs_area = set( k for k in sets.loc_techs_non_transmission if ( any('resource_area' in i for i in loc_techs_config[k].keys_nested()) or loc_techs_config[k].constraints.get('resource_unit', 'energy') == 'energy_per_area' ) ) # Technologies that define storage, which can include `supply_plus` # and `storage` groups. sets.loc_techs_store = set( k for k in sets.loc_techs_supply_plus if any('storage_' in i for i in loc_techs_config[k].constraints.keys_nested()) ) | sets.loc_techs_storage # technologies that specify a finite resource sets.loc_techs_finite_resource = set( k for k in sets.loc_techs_non_transmission if loc_techs_config[k].constraints.get('resource') and not (loc_techs_config[k].constraints.get('resource') in ['inf', np.inf]) ) # `supply` technologies that specify a finite resource sets.loc_techs_finite_resource_supply = ( sets.loc_techs_finite_resource.intersection(sets.loc_techs_supply) ) # `demand` technologies that specify a finite resource sets.loc_techs_finite_resource_demand = ( sets.loc_techs_finite_resource.intersection(sets.loc_techs_demand) ) # `supply_plus` technologies that specify a finite resource sets.loc_techs_finite_resource_supply_plus = ( sets.loc_techs_finite_resource.intersection(sets.loc_techs_supply_plus) ) # Technologies that define ramping constraints sets.loc_techs_ramping = set( k for k in sets.loc_techs_non_transmission if 'energy_ramping' in loc_techs_config[k].constraints ) # Technologies that allow export sets.loc_techs_export = set( k for k in sets.loc_techs_non_transmission if 'export_carrier' in loc_techs_config[k].constraints ) # Technologies that allow purchasing discrete units # NB: includes transmission techs! loc_techs_purchase = set( k for k in sets.loc_techs_non_transmission if any('.purchase' in i for i in loc_techs_config[k].get( 'costs', AttrDict()).keys_nested()) and not any('units_' in i for i in loc_techs_config[k].get( 'constraints', AttrDict()).keys_nested()) ) transmission_purchase = set( k for k in sets.loc_techs_transmission if any('.purchase' in i for i in loc_techs_transmission_config[k].get( 'costs', AttrDict()).keys_nested()) and not any('units_' in i for i in loc_techs_transmission_config[k].get( 'constraints', AttrDict()).keys_nested()) ) sets.loc_techs_purchase = loc_techs_purchase | transmission_purchase # Technologies with MILP constraints loc_techs_milp = set( k for k in sets.loc_techs_non_transmission if any('units_' in i for i in loc_techs_config[k].constraints.keys_nested()) ) transmission_milp = set( k for k in sets.loc_techs_transmission if any('units_' in i for i in loc_techs_transmission_config[k].constraints.keys_nested()) ) sets.loc_techs_milp = loc_techs_milp | transmission_milp ## # Sets based on specific costs being active # NB includes transmission techs ## loc_techs_costs = set( k for k in sets.loc_techs_non_transmission if any('costs' in i for i in loc_techs_config[k].keys()) ) loc_techs_transmission_costs = set( k for k in sets.loc_techs_transmission if any('costs' in i for i in loc_techs_transmission_config[k].keys()) ) # Any capacity or fixed annual costs loc_techs_investment_costs = set( k for k in loc_techs_costs if any('_cap' in i or '.purchase' in i or '_area' in i for i in loc_techs_config[k].costs.keys_nested()) ) loc_techs_transmission_investment_costs = set( k for k in loc_techs_transmission_costs if any('_cap' in i or '.purchase' in i or '_area' in i for i in loc_techs_transmission_config[k].costs.keys_nested()) ) # Any operation and maintenance loc_techs_om_costs = set( k for k in loc_techs_costs if any('om_' in i or 'export' in i for i in loc_techs_config[k].costs.keys_nested()) ) loc_techs_transmission_om_costs = set( k for k in loc_techs_transmission_costs if any('om_' in i for i in loc_techs_transmission_config[k].costs.keys_nested()) ) # Any export costs sets.loc_techs_costs_export = set( k for k in loc_techs_costs if any('export' in i for i in loc_techs_config[k].costs.keys_nested()) ) sets.loc_techs_cost = loc_techs_costs | loc_techs_transmission_costs sets.loc_techs_investment_cost = ( loc_techs_investment_costs | loc_techs_transmission_investment_costs) sets.loc_techs_om_cost = loc_techs_om_costs | loc_techs_transmission_om_costs ## # Subsets of costs for different abstract base technologies ## sets.loc_techs_om_cost_conversion = loc_techs_om_costs.intersection(sets.loc_techs_conversion) sets.loc_techs_om_cost_conversion_plus = loc_techs_om_costs.intersection(sets.loc_techs_conversion_plus) sets.loc_techs_om_cost_supply = loc_techs_om_costs.intersection(sets.loc_techs_supply) sets.loc_techs_om_cost_supply_plus = loc_techs_om_costs.intersection(sets.loc_techs_supply_plus) ## # Subsets of `conversion_plus` technologies ## # `conversion_plus` technologies with secondary carrier(s) out sets.loc_techs_out_2 = set( k for k in sets.loc_techs_conversion_plus if 'carrier_out_2' in model_run.techs[k.split('::')[1].split(':')[0]].essentials ) # `conversion_plus` technologies with tertiary carrier(s) out sets.loc_techs_out_3 = set( k for k in sets.loc_techs_conversion_plus if 'carrier_out_3' in model_run.techs[k.split('::')[1].split(':')[0]].essentials ) # `conversion_plus` technologies with secondary carrier(s) in sets.loc_techs_in_2 = set( k for k in sets.loc_techs_conversion_plus if 'carrier_in_2' in model_run.techs[k.split('::')[1].split(':')[0]].essentials ) # `conversion_plus` technologies with tertiary carrier(s) in sets.loc_techs_in_3 = set( k for k in sets.loc_techs_conversion_plus if 'carrier_in_3' in model_run.techs[k.split('::')[1].split(':')[0]].essentials ) ## # `loc_tech_carrier` sets ## # loc_tech_carriers for all technologies that have energy_prod=True sets.loc_tech_carriers_prod = set( '{}::{}'.format(k, carrier) for k in sets.loc_techs if loc_techs_all_config[k].constraints.get_key('energy_prod', False) for carrier in get_all_carriers(model_run.techs[k.split('::')[1].split(':')[0]].essentials, direction='out') ) # loc_tech_carriers for all technologies that have energy_con=True sets.loc_tech_carriers_con = set( '{}::{}'.format(k, carrier) for k in sets.loc_techs if loc_techs_all_config[k].constraints.get_key('energy_con', False) for carrier in get_all_carriers(model_run.techs[k.split('::')[1].split(':')[0]].essentials, direction='in') ) # loc_tech_carriers for all supply technologies sets.loc_tech_carriers_supply_all = set( '{}::{}'.format(k, carrier) for k in sets.loc_techs_supply_all for carrier in get_all_carriers(model_run.techs[k.split('::')[1].split(':')[0]].essentials, direction='out') ) # loc_tech_carriers for all demand technologies sets.loc_tech_carriers_demand = set( '{}::{}'.format(k, carrier) for k in sets.loc_techs_demand for carrier in get_all_carriers(model_run.techs[k.split('::')[1].split(':')[0]].essentials, direction='in') ) # loc_tech_carriers for all technologies that have export sets.loc_tech_carriers_export = set( '{}::{}'.format(k, loc_techs_all_config[k].constraints.export_carrier) for k in sets.loc_techs if loc_techs_all_config[k].constraints.get_key('export_carrier', False) ) # loc_tech_carriers for `conversion_plus` technologies sets.loc_tech_carriers_conversion_plus = set( k for k in sets.loc_tech_carriers_con | sets.loc_tech_carriers_prod if k.rsplit('::', 1)[0] in sets.loc_techs_conversion_plus ) # loc_carrier combinations that exist with either a con or prod tech sets.loc_carriers = set( '{0}::{2}'.format(*k.split('::')) for k in sets.loc_tech_carriers_prod | sets.loc_tech_carriers_con ) return sets