def test_get_cdd_country():
"""testing
"""
regions = ['reg_A', 'reg_B']
temp_data = {
"reg_A": np.zeros((365, 24)) + 20,
"reg_B": np.zeros((365, 24)) + 20}
base_temp_diff_params = {}
base_temp_diff_params['sig_midpoint'] = 0
base_temp_diff_params['sig_steepness'] = 1
base_temp_diff_params['yr_until_changed'] = 2020
t_base_heating_base_yr = 15.5
result = hdd_cdd.get_cdd_country(
t_base_heating_base_yr,
regions,
temp_data)
expected = {
"reg_A": (20 - 15.5) * 8760 / 24,
"reg_B": (20 - 15.5) * 8760 / 24}
assert result['reg_A'] == expected['reg_A']
assert result['reg_B'] == expected['reg_B']
def test_get_cdd_country():
"""testing
"""
base_yr = 2015
curr_yr = 2020
weather_stations = {
"weater_station_A": {
'station_latitude': 55.8695,
'station_longitude': -4.4
}
}
regions = ['reg_A', 'reg_B']
temp_data = {"weater_station_A": np.zeros((365, 24)) + 20}
base_temp_diff_params = {}
base_temp_diff_params['sig_midpoint'] = 0
base_temp_diff_params['sig_steepness'] = 1
base_temp_diff_params['yr_until_changed'] = 2020
reg_coord = {
"reg_A": {
'latitude': 59.02999742,
'longitude': -3.4
},
"reg_B": {
'latitude': 57.02999742,
'longitude': -4.4
}
}
t_base_heating_base_yr = 15.5
t_base_heating_future_yr = 15.5
result = hdd_cdd.get_cdd_country(base_yr, curr_yr, regions, temp_data,
base_temp_diff_params,
t_base_heating_base_yr,
t_base_heating_future_yr, reg_coord,
weather_stations)
expected = {
"reg_A": (20 - 15.5) * 8760 / 24,
"reg_B": (20 - 15.5) * 8760 / 24
}
assert result['reg_A'] == expected['reg_A']
assert result['reg_B'] == expected['reg_B']
def ss_disaggregate(data, raw_fuel_sectors_enduses):
"""Disaggregate fuel for service submodel (per enduse and sector)
"""
print("... disaggregate service demand")
ss_fueldata_disagg = {}
# ---------------------------------------
# Calculate heating degree days for regions
# ---------------------------------------
ss_hdd_individ_region = hdd_cdd.get_hdd_country(data['lu_reg'], data,
'ss_t_base_heating')
ss_cdd_individ_region = hdd_cdd.get_cdd_country(data['lu_reg'], data,
'ss_t_base_cooling')
# ---------------------------------------
# Overall disaggregation factors per enduse and sector
# ---------------------------------------
# Total floor area for every enduse per sector
national_floorarea_by_sector = {}
for sector in data['ss_sectors']:
national_floorarea_by_sector[sector] = 0
for region in data['lu_reg']:
national_floorarea_by_sector[sector] += data[
'ss_sector_floor_area_by'][region][sector]
f_ss_catering = {}
f_ss_computing = {}
f_ss_cooling_ventilation = {}
f_ss_water_heating = {}
f_ss_space_heating = {}
f_ss_lighting = {}
f_ss_other_electricity = {}
f_ss_other_gas = {}
for sector in data['all_sectors']:
f_ss_catering[sector] = 0
f_ss_computing[sector] = 0
f_ss_cooling_ventilation[sector] = 0
f_ss_water_heating[sector] = 0
f_ss_space_heating[sector] = 0
f_ss_lighting[sector] = 0
f_ss_other_electricity[sector] = 0
f_ss_other_gas[sector] = 0
for region_name in data['lu_reg']:
# HDD
reg_hdd = ss_hdd_individ_region[region_name]
reg_cdd = ss_cdd_individ_region[region_name]
# Floor Area of sector
reg_floor_area = data['ss_sector_floor_area_by'][region_name][
sector]
# Population
reg_pop = data['population'][data['sim_param']
['base_yr']][region_name]
# National disaggregation factors
f_ss_catering[sector] += reg_pop
f_ss_computing[sector] += reg_pop
f_ss_cooling_ventilation[sector] += reg_pop * reg_cdd
f_ss_water_heating[sector] += reg_pop
f_ss_space_heating[sector] += reg_floor_area * reg_hdd
f_ss_lighting[sector] += reg_floor_area
f_ss_other_electricity[sector] += reg_pop
f_ss_other_gas[sector] += reg_pop
# ---------------------------------------
# Disaggregate according to enduse
# ---------------------------------------
for region_name in data['lu_reg']:
ss_fueldata_disagg[region_name] = {}
for sector in data['ss_sectors']:
ss_fueldata_disagg[region_name][sector] = {}
for enduse in data['ss_all_enduses']:
# HDD
reg_hdd = ss_hdd_individ_region[region_name]
reg_cdd = ss_cdd_individ_region[region_name]
# Floor Area of sector
reg_floor_area = data['ss_sector_floor_area_by'][region_name][
sector]
# Population
reg_pop = data['population'][data['sim_param']
['base_yr']][region_name]
if enduse == 'ss_catering':
reg_diasg_factor = reg_pop / f_ss_catering[sector]
elif enduse == 'ss_computing':
reg_diasg_factor = reg_pop / f_ss_computing[sector]
elif enduse == 'ss_cooling_ventilation':
reg_diasg_factor = (
reg_pop * reg_cdd) / f_ss_cooling_ventilation[sector]
elif enduse == 'ss_water_heating':
reg_diasg_factor = reg_pop / f_ss_water_heating[sector]
elif enduse == 'ss_space_heating':
reg_diasg_factor = (reg_floor_area *
reg_hdd) / f_ss_space_heating[sector]
elif enduse == 'ss_lighting':
reg_diasg_factor = reg_floor_area / f_ss_lighting[sector]
if enduse == 'ss_other_electricity':
reg_diasg_factor = reg_pop / f_ss_other_electricity[sector]
elif enduse == 'ss_other_gas':
reg_diasg_factor = reg_pop / f_ss_other_gas[sector]
# Disaggregate (fuel * factor)
ss_fueldata_disagg[region_name][sector][
enduse] = raw_fuel_sectors_enduses[sector][
enduse] * reg_diasg_factor
# TESTING Check if total fuel is the same before and after aggregation
control_sum1 = 0
control_sum2 = 0
for reg in ss_fueldata_disagg:
for sector in ss_fueldata_disagg[reg]:
for enduse in ss_fueldata_disagg[reg][sector]:
control_sum1 += np.sum(ss_fueldata_disagg[reg][sector][enduse])
for sector in data['ss_sectors']:
for enduse in data['ss_all_enduses']:
control_sum2 += np.sum(raw_fuel_sectors_enduses[sector][enduse])
#The loaded floor area must correspond to provided fuel sectors numers
np.testing.assert_almost_equal(control_sum1,
control_sum2,
decimal=2,
err_msg="")
return ss_fueldata_disagg
def ss_disaggregate(ss_national_fuel, assumptions, scenario_data, base_yr,
curr_yr, regions, reg_coord, temp_data, weather_stations,
enduses, sectors, all_sectors, crit_limited_disagg_pop_hdd,
crit_limited_disagg_pop, crit_full_disagg):
"""Disaggregate fuel for service submodel (per enduse and sector)
Outputs
-------
ss_fuel_disagg : dict
region, Enduse, Sectors
"""
logging.debug("... disaggregate service demand")
ss_fuel_disagg = {}
# ---------------------------------------
# Calculate heating degree days for regions
# ---------------------------------------
ss_hdd_individ_region = hdd_cdd.get_hdd_country(
base_yr, curr_yr, regions, temp_data,
assumptions.base_temp_diff_params,
assumptions.strategy_variables['ss_t_base_heating_future_yr']
['scenario_value'], assumptions.t_bases.ss_t_heating_by, reg_coord,
weather_stations)
ss_cdd_individ_region = hdd_cdd.get_cdd_country(
base_yr, curr_yr, regions, temp_data,
assumptions.base_temp_diff_params,
assumptions.strategy_variables['ss_t_base_cooling_future_yr']
['scenario_value'], assumptions.t_bases.ss_t_cooling_by, reg_coord,
weather_stations)
# ---------------------------------------------
# Get all regions with missing floor area data
# ---------------------------------------------
regions_without_floorarea = get_regions_missing_floor_area_sector(
regions, scenario_data['floor_area']['ss_floorarea'], base_yr)
regions_with_floorarea = list(regions)
for reg in regions_without_floorarea:
regions_with_floorarea.remove(reg)
# ---------------------------------------
# Overall disaggregation factors per enduse and sector
# ---------------------------------------
ss_fuel_disagg = ss_disaggr(all_regions=regions,
regions=regions_without_floorarea,
sectors=sectors,
enduses=enduses,
all_sectors=all_sectors,
base_yr=base_yr,
scenario_data=scenario_data,
ss_hdd_individ_region=ss_hdd_individ_region,
ss_cdd_individ_region=ss_cdd_individ_region,
ss_fuel_disagg=ss_fuel_disagg,
ss_national_fuel=ss_national_fuel,
crit_limited_disagg_pop=False,
crit_limited_disagg_pop_hdd=True,
crit_full_disagg=False)
# Substract from national fuel already disaggregated fuel
ss_national_fuel_remaining = copy.deepcopy(ss_national_fuel)
for enduse in ss_national_fuel:
for sector in ss_national_fuel[enduse]:
for reg in ss_fuel_disagg:
ss_national_fuel_remaining[enduse][sector] -= ss_fuel_disagg[
reg][enduse][sector]
# Disaggregate with floor area
ss_fuel_disagg = ss_disaggr(
all_regions=regions_with_floorarea,
regions=regions_with_floorarea,
sectors=sectors,
enduses=enduses,
all_sectors=all_sectors,
base_yr=base_yr,
scenario_data=scenario_data,
ss_hdd_individ_region=ss_hdd_individ_region,
ss_cdd_individ_region=ss_cdd_individ_region,
ss_fuel_disagg=ss_fuel_disagg,
ss_national_fuel=ss_national_fuel_remaining,
crit_limited_disagg_pop=crit_limited_disagg_pop,
crit_limited_disagg_pop_hdd=crit_limited_disagg_pop_hdd,
crit_full_disagg=crit_full_disagg)
# -----------------
# Check if total fuel is the
# same before and after aggregation
#------------------
testing_functions.control_disaggregation(ss_fuel_disagg, ss_national_fuel,
enduses, sectors)
logging.debug("... finished disaggregation ss")
return dict(ss_fuel_disagg)
def ss_disaggregate(
ss_national_fuel,
service_building_count,
assumptions,
scenario_data,
pop_for_disagg,
regions,
reg_coord,
temp_data,
weather_stations,
enduses,
sectors,
crit_limited_disagg_pop_hdd,
crit_limited_disagg_pop,
crit_full_disagg,
crit_temp_min_max=False
):
"""Disaggregate fuel for service submodel (per enduse and sector)
Outputs
-------
ss_fuel_disagg : dict
region, Enduse, Sectors
"""
logging.debug("... disaggregate service demand")
ss_fuel_disagg = {}
# ---------------------------------------
# Calculate heating degree days for regions
# ---------------------------------------
ss_hdd_individ_region = hdd_cdd.get_hdd_country(
t_base_heating=assumptions.t_bases.ss_t_heating,
regions=regions,
temp_data=temp_data,
reg_coord=reg_coord,
weather_stations=weather_stations,
crit_temp_min_max=crit_temp_min_max)
ss_cdd_individ_region = hdd_cdd.get_cdd_country(
t_base_cooling=assumptions.t_bases.ss_t_cooling,
regions=regions,
temp_data=temp_data,
reg_coord=reg_coord,
weather_stations=weather_stations,
crit_temp_min_max=crit_temp_min_max)
# ---------------------------------------------
# Get all regions with floor area data
# ---------------------------------------------
regions_with_floorarea = list(regions)
for reg in assumptions.ss_regions_without_floorarea:
regions_with_floorarea.remove(reg)
# ---------------------------------------
# Overall disaggregation factors per enduse and sector
# ---------------------------------------
ss_fuel_disagg = {}
ss_fuel_disagg_only_pop = ss_disaggr(
all_regions=regions,
regions=assumptions.ss_regions_without_floorarea,
sectors=sectors,
enduses=enduses,
base_yr=assumptions.base_yr,
scenario_data=scenario_data,
pop_for_disagg=pop_for_disagg,
service_building_count=service_building_count,
ss_hdd_individ_region=ss_hdd_individ_region,
ss_cdd_individ_region=ss_cdd_individ_region,
ss_national_fuel=ss_national_fuel,
crit_limited_disagg_pop=False, # Set to False
crit_limited_disagg_pop_hdd=True, # Set to True
crit_full_disagg=False)
ss_fuel_disagg.update(ss_fuel_disagg_only_pop)
# Substract from national fuel already disaggregated fuel
ss_national_fuel_remaining = copy.deepcopy(ss_national_fuel)
for enduse in ss_national_fuel:
for sector in ss_national_fuel[enduse]:
for reg in ss_fuel_disagg:
ss_national_fuel_remaining[enduse][sector] -= ss_fuel_disagg[reg][enduse][sector]
# Disaggregate with floor area
ss_fuel_disagg_full_data = ss_disaggr(
all_regions=regions_with_floorarea,
regions=regions_with_floorarea,
sectors=sectors,
enduses=enduses,
base_yr=assumptions.base_yr,
scenario_data=scenario_data,
pop_for_disagg=pop_for_disagg,
service_building_count=service_building_count,
ss_hdd_individ_region=ss_hdd_individ_region,
ss_cdd_individ_region=ss_cdd_individ_region,
ss_national_fuel=ss_national_fuel_remaining,
crit_limited_disagg_pop=crit_limited_disagg_pop,
crit_limited_disagg_pop_hdd=crit_limited_disagg_pop_hdd,
crit_full_disagg=crit_full_disagg)
ss_fuel_disagg.update(ss_fuel_disagg_full_data)
# -----------------
# Check if total fuel is the same before and after aggregation
#------------------
testing_functions.control_disaggregation(
ss_fuel_disagg, ss_national_fuel, enduses, sectors)
return dict(ss_fuel_disagg)