def __init__(
self,
name=None,
fueltype=None,
eff_by=None,
eff_ey=None,
year_eff_ey=None,
eff_achieved=None,
diff_method=None,
market_entry=2015,
tech_type=None,
tech_max_share=None,
description=None
):
self.name = name
self.fueltype_str = fueltype
self.fueltype_int = tech_related.get_fueltype_int(fueltype)
self.eff_by = eff_by
self.eff_ey = eff_ey
self.year_eff_ey = year_eff_ey
self.eff_achieved = eff_achieved
self.diff_method = diff_method
self.market_entry = market_entry
self.tech_type = tech_type
self.tech_max_share = tech_max_share
self.description = description
def test_get_fueltype_int():
"""Testing function
"""
fueltypes = {'gas': 1}
in_value = 'gas'
expected = 1
# call function
out_value = tech_related.get_fueltype_int(fueltypes, in_value)
assert out_value == expected
def __init__(self,
name,
tech_type,
fueltype_str=None,
eff_achieved=None,
diff_method=None,
eff_by=None,
eff_ey=None,
year_eff_ey=None,
market_entry=None,
tech_max_share=None,
other_enduse_mode_info=None,
base_yr=None,
curr_yr=None,
fueltypes=None,
temp_by=None,
temp_cy=None,
t_base_heating_by=None,
t_base_heating_cy=None,
description=''):
"""Contructor
"""
self.name = name
self.tech_type = tech_type
self.description = description
self.fueltype_str = fueltype_str
self.fueltype_int = tech_related.get_fueltype_int(
fueltypes, fueltype_str)
self.eff_achieved_f = eff_achieved
self.diff_method = diff_method
self.market_entry = market_entry
self.tech_max_share = tech_max_share
if tech_type == 'placeholder_tech':
self.eff_by = 1.0
self.eff_cy = 1.0
elif tech_type == 'heat_pump':
self.eff_by = tech_related.calc_hp_eff(temp_by, eff_by,
t_base_heating_by)
self.eff_cy = tech_related.calc_hp_eff(
temp_cy,
tech_related.calc_eff_cy(base_yr, curr_yr, eff_by, eff_ey,
year_eff_ey, other_enduse_mode_info,
self.eff_achieved_f,
self.diff_method), t_base_heating_cy)
else:
self.eff_by = eff_by
self.eff_cy = tech_related.calc_eff_cy(base_yr, curr_yr, eff_by,
eff_ey, year_eff_ey,
other_enduse_mode_info,
self.eff_achieved_f,
self.diff_method)
def test_calc_service_fuel_switched():
"""
"""
fueltype_lookup = {
'solid_fuel': 0,
'gas': 1,
'electricity': 2,
'oil': 3,
'heat_sold': 4,
'biomass': 5,
'hydrogen': 6,
'heat': 7}
technologies = {
'boilerA': read_data.TechnologyData(
fueltype='gas',
eff_by=0.5,
eff_ey=0.5,
year_eff_ey=2015,
eff_achieved=1.0,
diff_method='linear',
market_entry=1990),
'boilerB': read_data.TechnologyData(
fueltype='electricity',
eff_by=0.5,
eff_ey=0.5,
year_eff_ey=2015,
eff_achieved=1.0,
diff_method='linear',
market_entry=1990),
'boilerC': read_data.TechnologyData(
fueltype='gas',
eff_by=0.5,
eff_ey=0.5,
year_eff_ey=2015,
eff_achieved=1.0,
diff_method='linear',
market_entry=1990)}
enduse = 'heating'
fuel_switches = [
read_data.FuelSwitch(
enduse='heating',
technology_install='boilerB',
switch_yr=2020,
fueltype_replace=tech_related.get_fueltype_int('gas'),
fuel_share_switched_ey=1.0
)]
service_fueltype_p = {1: 1.0, 2: 0.0}
s_tech_by_p = {'boilerA': 1.0, 'boilerB': 0.0}
fuel_tech_p_by = {1: {'boilerA': 1.0}, 2: {'boilerB': 1.0}}
result = s_generate_sigmoid.calc_service_fuel_switched(
fuel_switches,
technologies,
service_fueltype_p,
s_tech_by_p,
fuel_tech_p_by,
switch_type='actual_switch')
assert result['boilerB'] == 1.0
assert result['boilerA'] == 0.0
# -------
fuel_switches = [
read_data.FuelSwitch(
enduse='heating',
technology_install='boilerB',
switch_yr=3050,
fueltype_replace=tech_related.get_fueltype_int('gas'),
fuel_share_switched_ey=0.5
)]
service_fueltype_p = {1: 1.0, 2: 0.0}
s_tech_by_p = {'boilerA': 1.0, 'boilerB': 0.0}
fuel_tech_p_by = {1: {'boilerA': 1.0}, 2: {'boilerB': 1.0}}
result = s_generate_sigmoid.calc_service_fuel_switched(
fuel_switches,
technologies,
service_fueltype_p,
s_tech_by_p,
fuel_tech_p_by,
switch_type='actual_switch')
assert result['boilerB'] == 0.5
assert result['boilerA'] == 0.5
# -------
fuel_switches = [
read_data.FuelSwitch(
enduse='heating',
technology_install='boilerB',
switch_yr=3050,
fueltype_replace=tech_related.get_fueltype_int('gas'),
fuel_share_switched_ey=0.5
)]
service_fueltype_p = {1: 0.5, 2: 0.5}
s_tech_by_p = {'boilerA': 0.5, 'boilerB': 0.5}
fuel_tech_p_by = {1: {'boilerA': 1.0}, 2: {'boilerB': 1.0}}
result = s_generate_sigmoid.calc_service_fuel_switched(
fuel_switches,
technologies,
service_fueltype_p,
s_tech_by_p,
fuel_tech_p_by,
switch_type='actual_switch')
assert result['boilerB'] == 0.75
assert result['boilerA'] == 0.25
# -------
fuel_switches = [
read_data.FuelSwitch(
enduse='heating',
technology_install='boilerB',
switch_yr=3050,
fueltype_replace=tech_related.get_fueltype_int('gas'),
fuel_share_switched_ey=0.5
)]
service_fueltype_p = {1: 0.5, 2: 0.5}
s_tech_by_p = {'boilerA': 0.25, 'boilerB': 0.5, 'boilerC': 0.25}
fuel_tech_p_by = {1: {'boilerA': 0.5, 'boilerC': 0.5,}, 2: {'boilerB': 1.0}}
result = s_generate_sigmoid.calc_service_fuel_switched(
fuel_switches,
technologies,
service_fueltype_p,
s_tech_by_p,
fuel_tech_p_by,
switch_type='actual_switch')
assert result['boilerC'] == 0.125
assert result['boilerB'] == 0.75
assert result['boilerA'] == 0.125
def run(results_every_year, lookups, path_plot_fig):
"""Plots
Plot peak hour per fueltype over time for
Arguments
---------
tot_fuel_dh_peak : dict
year, fueltype, peak_dh
"""
# Set figure size
fig = plt.figure(figsize=basic_plot_functions.cm2inch(14, 8))
ax = fig.add_subplot(1, 1, 1)
nr_y_to_plot = len(results_every_year)
legend_entries = []
# Initialise (number of enduses, number of hours to plot)
y_init = np.zeros((lookups['fueltypes_nr'], nr_y_to_plot))
for fueltype_str, fueltype in lookups['fueltypes'].items():
fueltype_int = tech_related.get_fueltype_int(fueltype_str)
# Legend
legend_entries.append(fueltype_str)
# Read out fueltype specific load
data_over_years = []
for model_year_object in results_every_year.values():
# Sum fuel across all regions
fuel_all_regs = np.sum(model_year_object, axis=1) # (fueltypes, 8760 hours)
# Get peak day across all enduses for every region
_, gw_peak_fueltyp_h = enduse_func.get_peak_day_single_fueltype(fuel_all_regs[fueltype_int])
# Add peak hour
data_over_years.append(gw_peak_fueltyp_h)
y_init[fueltype] = data_over_years
# ----------
# Plot lines
# ----------
#linestyles = plotting_styles.linestyles()
years = list(results_every_year.keys())
for fueltype, _ in enumerate(y_init):
plt.plot(
years,
y_init[fueltype],
linewidth=0.7)
ax.legend(
legend_entries,
prop={
'family': 'arial',
'size': 8},
frameon=False)
# -
# Axis
# -
base_yr = 2015
major_interval = 10
minor_interval = 5
# Major ticks
major_ticks = np.arange(base_yr, years[-1] + major_interval, major_interval)
ax.set_xticks(major_ticks)
# Minor ticks
minor_ticks = np.arange(base_yr, years[-1] + minor_interval, minor_interval)
ax.set_xticks(minor_ticks, minor=True)
plt.xlim(2015, years[-1])
# --------
# Labeling
# --------
plt.ylabel("GW")
plt.xlabel("year")
plt.title("ED peak hour, y, all enduses and regions")
# Tight layout
plt.tight_layout()
plt.margins(x=0)
# Save fig
fig.savefig(path_plot_fig)
plt.close()
def run(data_input, simulation_yr_to_plot, period_h, fueltype_str, fig_name):
"""
https://stackoverflow.com/questions/18313322/plotting-quantiles-median-and-spread-using-scipy-and-matplotlib
https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.quantile.html
"""
# Select period and fueltype
fueltype_int = tech_related.get_fueltype_int(fueltype_str)
# -----------------------------------------------------------
# Iterate overall weather_yrs and store data in dataframe
# (columns = timestep, rows: value of year)
# -----------------------------------------------------------
columns = period_h # hours in 8760 hours
# List of selected data for every weather year (which is then converted to array)
weather_yrs_data = []
print("Weather yrs: " + str(list(data_input.keys())), flush=True)
for weather_yr, data_weather_yr in data_input.items():
# Weather year specific data
data_input_fueltype = data_weather_yr[simulation_yr_to_plot][
fueltype_int] # Select fueltype
data_input_reshape = data_input_fueltype.reshape(8760) # reshape
data_input_selection_hrs = data_input_reshape[
period_h] # select period
weather_yrs_data.append(data_input_selection_hrs)
weather_yrs_data = np.array(weather_yrs_data)
# Create dataframe
df = pd.DataFrame(weather_yrs_data, columns=columns)
# Calculate quantiles
quantile_95 = 0.95
quantile_05 = 0.05
df_q_95 = df.quantile(quantile_95)
df_q_05 = df.quantile(quantile_05)
#Transpose for plotting purposes
df = df.T
df_q_95 = df_q_95.T
df_q_05 = df_q_05.T
fig = plt.figure() #(figsize = cm2inch(10,10))
ax = fig.add_subplot(111)
# 2015 weather year
data_2015 = data_weather_yr[2015][fueltype_int].reshape(8760)[period_h]
# ---------------
# Smoothing lines
# ---------------
try:
period_h_smoothed, df_q_95_smoothed = basic_plot_functions.smooth_data(
period_h, df_q_95, num=40000)
period_h_smoothed, df_q_05_smoothed = basic_plot_functions.smooth_data(
period_h, df_q_05, num=40000)
period_h_smoothed, data_2015_smoothed = basic_plot_functions.smooth_data(
period_h, data_2015, num=40000)
except:
period_h_smoothed = period_h
df_q_95_smoothed = df_q_95
df_q_05_smoothed = df_q_05
data_2015_smoothed = data_2015
plt.plot(period_h_smoothed,
data_2015_smoothed,
color='tomato',
linestyle='-',
linewidth=2,
label="2015 weather_yr")
plt.plot(period_h_smoothed,
df_q_05_smoothed,
color='black',
linestyle='--',
linewidth=0.5,
label="0.05")
plt.plot(period_h_smoothed,
df_q_95_smoothed,
color='black',
linestyle='--',
linewidth=0.5,
label="0.95")
# -----------------
# Uncertainty range
# -----------------
plt.fill_between(
period_h_smoothed, #x
df_q_95_smoothed, #y1
df_q_05_smoothed, #y2
alpha=.25,
facecolor="grey",
label="uncertainty band")
plt.legend(prop={
'family': 'arial',
'size': 10
},
loc='best',
frameon=False,
shadow=True)
plt.show()
def read_in_weather_results(
path_result,
seasons,
model_yeardays_daytype,
pop_data,
fueltype_str
):
"""Read and post calculate results from txt files
and store into container
Arguments
---------
path_result : str
Paths
seasons : dict
seasons
model_yeardays_daytype : dict
Daytype of modelled yeardays
"""
logging.info("... Reading in results")
fueltype_int = tech_related.get_fueltype_int(fueltype_str)
results_container = {}
# Read in total regional demands per fueltype
results_container['ed_reg_tot_y'] = read_data.read_results_yh(
path_result, 'only_total')
#print(results_container['ed_reg_tot_y'][2015].shape)
results_container['ed_reg_peakday'] = read_data.read_results_yh(
os.path.join('simulation_results', path_result), 'only_peak')
#print(results_container['ed_reg_peakday'][2015].shape)
results_container['ed_reg_peakday_peak_hour'] = {}
results_container['ed_reg_peakday_peak_hour_per_pop'] = {}
results_container['national_peak'] = {}
results_container['regional_share_national_peak'] = {}
results_container['regional_share_national_peak_pp'] = {}
results_container['pp_peak_abs'] = {}
results_container['regional_peak'] = {}
results_container['national_all_fueltypes'] = {}
results_container['mean_peak_day_demand'] = {}
for year in results_container['ed_reg_peakday']:
reg_pop_yr = pop_data[year]
# Get peak demand of each region
results_container['ed_reg_peakday_peak_hour'][year] = results_container['ed_reg_peakday'][year].max(axis=2)
# Divide peak by number of population
results_container['ed_reg_peakday_peak_hour_per_pop'][year] = results_container['ed_reg_peakday_peak_hour'][year] / reg_pop_yr
# Get national peak
national_demand_per_hour = results_container['ed_reg_peakday'][year].sum(axis=1) #Aggregate hourly across all regions
# Get maximum hour for electricity demand
max_hour = national_demand_per_hour[fueltype_int].argmax()
results_container['national_peak'][year] = national_demand_per_hour[:, max_hour]
# Calculate regional share of peak hour to national peak
national_peak = results_container['national_peak'][year][fueltype_int]
regional_peak = results_container['ed_reg_peakday'][year][fueltype_int][:, max_hour]
results_container['regional_peak'][year] = regional_peak
results_container['regional_share_national_peak'][year] = (100 / national_peak) * regional_peak #1 = 1 %
results_container['regional_share_national_peak_pp'][year] = ((100 / national_peak) * regional_peak) / reg_pop_yr #1 = 1 %
# Calculate mean of peak day demand of peak day
results_container['national_all_fueltypes'][year] = np.sum(results_container['ed_reg_tot_y'][year], axis=1)
results_container['mean_peak_day_demand'][year] = np.mean(national_demand_per_hour, axis=1)
# Calculate contribution per person towards national peak (reg_peak / people) [abs]
#print(results_container['ed_reg_peakday'][year].shape)
#print(reg_pop_yr.shape)
# results_container['pp_peak_abs'][year] = (
# results_container['ed_reg_peakday'][year][:,:, max_hour] / reg_pop_yr)
#(cpp = (regional peak / national peak) / people [%]
logging.info("... Reading in results finished")
return results_container
def run_fig_p2_temporal_validation(
data_input,
weather_yr,
fueltype_str,
simulation_yr_to_plot,
period_h,
validation_elec_2015,
non_regional_elec_2015,
fig_name,
titel="titel",
y_lim_val=100,
plot_validation=False,
plot_show=False
):
"""
"""
fueltype_int = tech_related.get_fueltype_int(fueltype_str)
# -----------------------------------------------------------
# Iterate overall weather_yrs and store data in dataframe
# (columns = timestep, rows: value of year)
# -----------------------------------------------------------
selection_hours = period_h
# List of selected data for every weather year (which is then converted to array)
weather_yrs_data = []
weather_yrs_full_year = []
for station_id, data_weather_yr in data_input[weather_yr].items():
# Weather year specific data
data_input_fueltype = data_weather_yr[simulation_yr_to_plot][fueltype_int] # Select fueltype
data_input_reshape = data_input_fueltype.reshape(8760) # reshape
data_input_selection_hrs = data_input_reshape[selection_hours] # select period
weather_yrs_data.append(data_input_selection_hrs)
weather_yrs_full_year.append(data_input_reshape)
weather_yrs_data = np.array(weather_yrs_data)
# Create dataframe
df = pd.DataFrame(weather_yrs_data, columns=period_h)
df_full_year = pd.DataFrame(weather_yrs_full_year, columns=range(8760))
# Calculate quantiles
quantile_95 = 0.95
quantile_05 = 0.05
df_q_95 = df.quantile(quantile_95)
df_q_05 = df.quantile(quantile_05)
#Transpose for plotting purposes
df = df.T
df_q_95 = df_q_95.T
df_q_05 = df_q_05.T
fig = plt.figure()
ax = fig.add_subplot(111)
# ---------------
# Smoothing lines
# ---------------
try:
period_h_smoothed, df_q_95_smoothed = basic_plot_functions.smooth_data(period_h, df_q_95, num=40000)
period_h_smoothed, df_q_05_smoothed = basic_plot_functions.smooth_data(period_h, df_q_05, num=40000)
#period_h_smoothed, data_2015_smoothed = basic_plot_functions.smooth_data(period_h, data_2015, num=40000)
except:
period_h_smoothed = period_h
df_q_95_smoothed = df_q_95
df_q_05_smoothed = df_q_05
#plt.plot(period_h_smoothed, data_2015_smoothed, color='tomato', linestyle='-', linewidth=2, label="2015 weather_yr")
plt.plot(period_h_smoothed, df_q_05_smoothed, color='black', linestyle='--', linewidth=0.5, label="0.05")
plt.plot(period_h_smoothed, df_q_95_smoothed, color='black', linestyle='--', linewidth=0.5, label="0.95")
# -----------------
# Uncertainty range
# -----------------
plt.fill_between(
period_h_smoothed, #x
df_q_95_smoothed, #y1
df_q_05_smoothed, #y2
alpha=1,
facecolor="lightgrey",
label="uncertainty band")
# -----------------
# All weather stations are used for this data
# -----------------
all_weather_stations_2015 = non_regional_elec_2015.reshape(8760)[period_h]
# -----------------
# Validation data
# -----------------
if plot_validation:
validation_2015 = validation_elec_2015.reshape(8760)[selection_hours]
try:
period_h_smoothed, validation_2015_smoothed = basic_plot_functions.smooth_data(period_h, validation_2015, num=40000)
except:
period_h_smoothed = period_h
validation_2015_smoothed = validation_2015
plt.plot(
period_h_smoothed,
validation_2015_smoothed,
color='green',
linestyle='--',
linewidth=1.5, label="validation 2015")
# -----------
# statistics
# -----------
# Calculate mean of all all single station runs
mean_all_single_runs = df_full_year.mean(axis=0).tolist()
mean_all_single_runs = np.array(mean_all_single_runs)[period_h]
slope, intercept, r_value, p_value, std_err = stats.linregress(
validation_2015,
all_weather_stations_2015)
slope, intercept, r_value2, p_value, std_err = stats.linregress(
validation_2015,
mean_all_single_runs)
print("R_Value_all_stations: " + str(r_value))
print("R_Value_single_stations: " + str(r_value2))
plt.title(
"R_value: all stations: {} mean_single_weather_stations: {}".format(
round(r_value, 2),
round(r_value2, 2)))
try:
period_h_smoothed, all_weather_stations_2015_smoothed = basic_plot_functions.smooth_data(
period_h, all_weather_stations_2015, num=40000)
except:
period_h_smoothed = period_h
all_weather_stations_2015_smoothed = all_weather_stations_2015
plt.plot(
period_h_smoothed,
all_weather_stations_2015_smoothed,
color='blue',
linestyle='--',
linewidth=1.2,
label="all stations")
# Ticks for single day
#major_ticks_days, major_ticks_labels = get_date_strings(
# days_to_plot,
# daystep=1)
#plt.xticks(major_ticks_days, major_ticks_labels)
zero_entry = period_h[0]
plt.xticks([0 + zero_entry, 5 + zero_entry, 11 + zero_entry, 17 + zero_entry, 23 + zero_entry], ['1', '6', '12', '18', '24'])
plt.ylim(0, y_lim_val)
plt.xlim(period_h[0], period_h[-1])
plt.title("Peak day: " + str(titel))
plt.legend(
prop={
'family':'arial',
'size': 10},
loc='best',
frameon=False,
shadow=True)
if plot_show:
plt.show()
else:
pass
plt.savefig(fig_name)
plt.close()
def run(data_input, regions, simulation_yr_to_plot, population, fueltype_str,
path_shapefile, fig_name):
"""
"""
fueltype_int = tech_related.get_fueltype_int(fueltype_str)
# -----------------------------------------------------------
# Iterate overall weather_yrs and store data in dataframe
# (columns = timestep, rows: value of year)
# -----------------------------------------------------------
# List of selected data for every weather year and region (which is then converted to array)
weather_yrs_data = defaultdict(dict)
print("Weather yrs: " + str(list(data_input.keys())), flush=True)
for weather_yr, data_weather_yr in data_input.items():
# Weather year specific data for every region
regions_fuel = data_weather_yr[simulation_yr_to_plot][
fueltype_int] # Select fueltype
for region_nr, region_name in enumerate(regions):
try:
weather_yrs_data[region_name].append(regions_fuel[region_nr])
except (KeyError, AttributeError):
weather_yrs_data[region_name] = [regions_fuel[region_nr]]
regional_statistics_columns = [
'name', 'mean_peak_h', 'diff_av_max', 'mean_peak_h_pp',
'diff_av_max_pp', 'std_dev_average_every_h', 'std_dev_peak_h_norm_pop'
]
df_stats = pd.DataFrame(columns=regional_statistics_columns)
for region_name, region_data in weather_yrs_data.items():
# Convert regional data to dataframe
region_data_array = np.array(region_data)
df = pd.DataFrame(region_data_array, columns=range(8760))
# Calculate regional statistics
mean = df.mean(axis=0)
std_dev = df.std(axis=0) #standard deviation across every hour
# Get maximum per colum
#max_every_h = df.max()
#colum_max_h = max_every_h.argmax() #get colum (respesctively hour) of maximum value
# Average standard deviation across every hour
std_dev_average_every_h = np.std(list(std_dev))
max_entry = df.max(axis=0) #maximum entry for every hour
min_entry = df.min(axis=0) #maximum entry for every hour
# Get hour number with maximum demand
hour_nr_max = max_entry.argmax()
hour_nr_min = min_entry.argmin()
# standard deviation of peak hour
std_dev_peak_h = std_dev[hour_nr_max]
# Difference between average and max
diff_av_max = max_entry[hour_nr_max] - mean[hour_nr_max]
mean_peak_h = mean[hour_nr_max]
# Convert GW to KW
diff_av_max = diff_av_max * 1000000 #GW to KW
mean_peak_h = mean_peak_h * 1000000 #GW to KW
# Weight with population
for region_nr, n in enumerate(regions):
if region_name == n:
nr_of_reg = region_nr
break
pop = population[nr_of_reg]
# Divide standard deviation of peak hour by population
# which gives measure of weather variability in peak hour
std_dev_peak_h_norm_pop = std_dev_peak_h / pop
diff_av_max_pp = diff_av_max / pop
mean_peak_h_pp = mean_peak_h / pop
line_entry = [[
str(region_name), mean_peak_h, diff_av_max, mean_peak_h_pp,
diff_av_max_pp, std_dev_average_every_h, std_dev_peak_h_norm_pop
]]
line_df = pd.DataFrame(line_entry, columns=regional_statistics_columns)
df_stats = df_stats.append(line_df)
print(df_stats['diff_av_max'].max())
print(df_stats['mean_peak_h'].max())
print(df_stats['std_dev_peak_h_norm_pop'].max())
print("-")
print(df_stats['diff_av_max_pp'].max())
print(df_stats['diff_av_max_pp'].min())
print("-")
print(df_stats['mean_peak_h_pp'].max())
print(df_stats['mean_peak_h_pp'].min())
# ---------------
# Create spatial maps
# http://darribas.org/gds15/content/labs/lab_03.html
# http://nbviewer.jupyter.org/gist/jorisvandenbossche/57d392c085901eb4981054402b37b6b1
# ---------------
# Load uk shapefile
uk_shapefile = gpd.read_file(path_shapefile)
# Merge stats to geopanda
shp_gdp_merged = uk_shapefile.merge(df_stats, on='name')
# Assign projection
crs = {'init': 'epsg:27700'} #27700: OSGB_1936_British_National_Grid
uk_gdf = gpd.GeoDataFrame(shp_gdp_merged, crs=crs)
ax = uk_gdf.plot()
# Assign bin colors according to defined cmap and whether
# plot with min_max values or only min/max values
#bin_values = [0, 0.0025, 0.005, 0.0075, 0.01]
#bin_values = [0, 0.02, 0.04, 0.06, 0.08, 0.1] #list(np.arange(0.0, 1.0, 0.1))
# Field to plot
field_to_plot = "diff_av_max_pp" # Difference between average and peak per person in KWh
#field_to_plot = "diff_av_max" # Difference between average and peak
field_to_plot = 'std_dev_peak_h_norm_pop'
nr_of_intervals = 6
bin_values = result_mapping.get_reasonable_bin_values_II(
data_to_plot=list(uk_gdf[field_to_plot]),
nr_of_intervals=nr_of_intervals)
print(float(uk_gdf[field_to_plot]))
print("BINS " + str(bin_values))
uk_gdf, cmap_rgb_colors, color_zero, min_value, max_value = user_defined_bin_classification(
uk_gdf, field_to_plot, bin_values=bin_values)
# plot with face color attribute
uk_gdf.plot(ax=ax,
facecolor=uk_gdf['bin_color'],
edgecolor='black',
linewidth=0.5)
#shp_gdp_merged.plot(column='diff_av_max', scheme='QUANTILES', k=5, cmap='OrRd', linewidth=0.1)
#ax = uk_gdf.plot(column='diff_av_max', scheme='QUANTILES', k=5, cmap='OrRd', linewidth=0.1)
#uk_gdf[uk_gdf['name'] == 'E06000024'].plot(ax=ax, facecolor='green', edgecolor='black')
#uk_gdf[uk_gdf['diff_av_max'] < 0.01].plot(ax=ax, facecolor='blue', edgecolor='black')
# Get legend patches TODO IMPROVE
# TODO IMRPVE: MAKE CORRECT ONE FOR NEW PROCESSING
legend_handles = result_mapping.get_legend_handles(bin_values[1:-1],
cmap_rgb_colors,
color_zero, min_value,
max_value)
plt.legend(handles=legend_handles,
title="tittel_elgend",
prop={'size': 8},
loc='upper center',
bbox_to_anchor=(0.5, -0.05),
frameon=False)
# PLot bins on plot
plt.text(
0,
-20,
bin_values[:-1], #leave away maximum value
fontsize=8)
plt.tight_layout()
plt.show()
raise Exception
plt.savefig(fig_name)
plt.close()
# ----------------------------------
container_all_initialisations = []
for initialization in all_realizations:
path_sim_yr = os.path.join(
path_results, scenario, initialization, "simulation_results",
"model_run_results_txt", "only_fueltype_reg_8760",
"fueltype_reg_8760__{}.npy".format(simulation_yr))
print(" ... loading scenario: {}".format(initialization),
flush=True)
full_result = np.load(path_sim_yr)
container_all_initialisations.append(full_result)
# Check peak
fueltype_int = tech_related.get_fueltype_int('electricity')
national_hourly_demand = np.sum(full_result[fueltype_int], axis=0)
peak_day_electricity, _ = enduse_func.get_peak_day_single_fueltype(
national_hourly_demand)
selected_hours = date_prop.convert_yearday_to_8760h_selection(
peak_day_electricity)
print("PEAK electricity: " +
str(np.max(national_hourly_demand[selected_hours])))
for fueltype_str in fueltypes:
print(" ...fueltype {}".format(fueltype_str), flush=True)
fueltype_int = tech_related.get_fueltype_int(fueltype_str)
# --------
# Calculate
# --------
def disaggr_demand(data, crit_temp_min_max, spatial_calibration=False):
"""Disaggregated demand
Arguments
----------
data : dict
Data
Returns
--------
disagg : dict
Disaggregated energy demand
spatial_calibration : bool
Criteria wheter base year data should be used to
calibrate spatial disaggregation (non-residential demand)
"""
disagg = {}
# ===========================================
# I. Disaggregation
# ===========================================
base_yr = data['assumptions'].base_yr
# Load data for disaggregateion
data['scenario_data']['employment_stats'] = data_loader.read_employment_stats(
data['paths']['path_employment_statistics'])
# Disaggregate fuel for all regions
disagg['residential'], disagg['service'], disagg['industry'] = disaggregate_base_demand(
data['pop_for_disag'],
data['regions'],
data['fuels'],
data['scenario_data'],
data['assumptions'],
data['reg_coord'],
data['weather_stations'], # Base year data used to disaggregate demand
data['temp_data'][base_yr], # Base year data used to disaggregate demand
data['sectors'],
data['enduses'],
data['service_building_count'],
crit_temp_min_max)
if spatial_calibration:
'''The spatial disaggregation of non-residential demand
can be calibrated for gas and electricity based on actual
measured demand data
Note: All other fueltypes are not scaled
'''
calibrate_residential = False # Calibrate residential demands
calibrate_non_residential = True # Calibrate non residential demands
# Non-residential electricity regional demands of base year for electrictiy and gas
fueltype_elec = tech_related.get_fueltype_int('electricity')
fueltype_gas = tech_related.get_fueltype_int('gas')
if calibrate_non_residential:
valid_non_resid_elec = data_loader.read_lad_demands(
data['paths']['val_subnational_elec_non_residential'])
valid_non_resid_gas = data_loader.read_lad_demands(
data['paths']['val_subnational_gas_non_residential'])
# Calculate and apply regional calibration factor
for region in data['regions']:
# Total modeleld non_residential
service_demand_elec = 0
service_demand_gas = 0
for enduse_data in disagg['service'][region].values():
for sector_data in enduse_data.values():
service_demand_elec += np.sum(sector_data[fueltype_elec])
service_demand_gas += np.sum(sector_data[fueltype_gas])
industry_demand_elec = 0
industry_demand_gas = 0
for enduse_data in disagg['industry'][region].values():
for sector_data in enduse_data.values():
industry_demand_elec += np.sum(sector_data[fueltype_elec])
industry_demand_gas += np.sum(sector_data[fueltype_gas])
modelled_elec = service_demand_elec + industry_demand_elec
modelled_gas = service_demand_gas + industry_demand_gas
# Calculate calibration factor
try:
f_spatial_calibration_elec = valid_non_resid_elec[region] / modelled_elec
except KeyError: # No real data available
f_spatial_calibration_elec = 1
try:
f_spatial_calibration_gas = valid_non_resid_gas[region] / modelled_gas
except KeyError: # No real data available
f_spatial_calibration_gas = 1
# Apply calibration factor to spatial disaggregation
for enduse in disagg['service'][region].keys():
for sector in disagg['service'][region][enduse]:
disagg['service'][region][enduse][sector][fueltype_elec] *= f_spatial_calibration_elec
disagg['service'][region][enduse][sector][fueltype_gas] *= f_spatial_calibration_gas
for enduse in disagg['industry'][region].keys():
for sector in disagg['industry'][region][enduse]:
disagg['industry'][region][enduse][sector][fueltype_elec] *= f_spatial_calibration_elec
disagg['industry'][region][enduse][sector][fueltype_gas] *= f_spatial_calibration_gas
if calibrate_residential:
valid_resid_elec = data_loader.read_lad_demands(
data['paths']['val_subnational_elec_residential'])
valid_resid_gas = data_loader.read_lad_demands(
data['paths']['val_subnational_gas_residential'])
# Calculate and apply regional calibration factor
for region in data['regions']:
# Total modeleld residential
modelled_elec = 0
modelled_gas = 0
for enduse_data in disagg['residential'][region].values():
modelled_elec += np.sum(enduse_data[fueltype_elec])
modelled_gas += np.sum(enduse_data[fueltype_gas])
# Calculate calibration factor
try:
real_elec = valid_resid_elec[region]
f_spatial_calibration_elec = real_elec / modelled_elec
real_gas = valid_resid_gas[region]
f_spatial_calibration_gas = real_gas / modelled_gas
except KeyError:
# No real data available
f_spatial_calibration_elec = 1
f_spatial_calibration_gas = 1
# Apply calibration factor to spatial disaggregation
for enduse in disagg['residential'][region].keys():
disagg['residential'][region][enduse][fueltype_elec] *= f_spatial_calibration_elec
disagg['residential'][region][enduse][fueltype_gas] *= f_spatial_calibration_gas
else:
pass
# Sum demand across all sectors for every region
disagg['ss_fuel_disagg_sum_all_sectors'] = init_scripts.sum_across_sectors_all_regs(
disagg['service'])
disagg['is_aggr_fuel_sum_all_sectors'] = init_scripts.sum_across_sectors_all_regs(
disagg['industry'])
# Sum demand across all submodels and sectors for every region
disagg['tot_disaggregated_regs'] = init_scripts.sum_across_all_submodels_regs(
data['regions'],
[disagg['residential'], disagg['service'], disagg['industry']])
disagg['tot_disaggregated_regs_residenital'] = init_scripts.sum_across_all_submodels_regs(
data['regions'],
[disagg['residential']])
disagg['tot_disaggregated_regs_non_residential'] = init_scripts.sum_across_all_submodels_regs(
data['regions'],
[disagg['service'], disagg['industry']])
return disagg
def main(
scenarios_path,
path_shapefile_input,
base_yr,
simulation_yrs_to_plot
):
"""Read in all results and plot PDFs
Arguments
----------
scenarios_path : str
Path to results
path_shapefile_input : str
Path to shapefile
plot_crit_dict : dict
Criteria to select plots to plot
base_yr : int
Base year
comparison_year : int
Year to generate comparison plots
"""
print("Start creating plots")
# -------------------
# Create temperatuere figur plot
# -------------------
plot_weather_chart = False
if plot_weather_chart:
from energy_demand.plotting import fig3_weather_at_home_plot
path_weather_data = "//linux-filestore.ouce.ox.ac.uk/mistral/nismod/data/energy_demand/J-MARIUS_data/_weather_realisation"
fig3_weather_at_home_plot.plotting_weather_data(path_weather_data)
# -------------------
# Create result folder
# -------------------
result_path = os.path.join(scenarios_path, '_results_weather_plots')
basic_functions.del_previous_setup(result_path)
basic_functions.create_folder(result_path)
x_chart_yrs_storage = {}
for simulation_yr_to_plot in simulation_yrs_to_plot:
print("=================")
print("...simulation_yr_to_plot: " + str(simulation_yr_to_plot))
print("=================")
data = {}
x_chart_yrs_storage[simulation_yr_to_plot] = {}
# ---------------------------------------------------------
# Iterate folders and read out all weather years and stations
# ---------------------------------------------------------
to_ignores = [
'model_run_pop',
'PDF_validation',
'_results_weather_plots']
endings_to_ignore = [
'.pdf',
'.txt',
'.ini']
all_scenarios_incl_ignored = os.listdir(scenarios_path)
all_scenarios = []
for scenario in all_scenarios_incl_ignored:
if scenario not in to_ignores:
all_scenarios.append(scenario)
scenario_result_container = []
for scenario_nr, scenario_name in enumerate(all_scenarios):
print(" ")
print("Scenario: {}".format(scenario_name))
print(" ")
scenario_path = os.path.join(scenarios_path, scenario_name)
all_result_folders = os.listdir(scenario_path)
paths_folders_result = []
for result_folder in all_result_folders:
if result_folder not in to_ignores and result_folder[-4:] not in endings_to_ignore:
paths_folders_result.append(
os.path.join(scenario_path, result_folder))
fueltype_str_to_create_maps = ['electricity']
fueltype_str ='electricity'
fueltype_elec_int = tech_related.get_fueltype_int('electricity')
####################################################################
# Collect regional simulation data for every realisation
####################################################################
total_regional_demand_electricity = pd.DataFrame()
peak_hour_demand = pd.DataFrame()
peak_hour_demand_per_person = pd.DataFrame()
national_peak = pd.DataFrame()
regional_share_national_peak = pd.DataFrame()
regional_share_national_peak_pp = pd.DataFrame()
national_electricity = pd.DataFrame()
national_gas = pd.DataFrame()
national_hydrogen = pd.DataFrame()
national_heating_peak = pd.DataFrame()
daily_mean_peak_day = pd.DataFrame()
for path_result_folder in paths_folders_result:
print("... path_result_folder: {}".format(path_result_folder))
data = {}
ed_national_heating_peak = {}
try:
# ================================
# Loading in only heating peak demands (seperate calculations)
# ================================
# Simulation information is read in from .ini file for results
data['enduses'], data['assumptions'], data['regions'] = data_loader.load_ini_param(os.path.join(path_result_folder))
pop_data = read_data.read_scenaric_population_data(os.path.join(path_result_folder, 'model_run_pop'))
path_result_folder_heating = os.path.join(path_result_folder, 'simulation_results')
path_result_folder_model_runs = os.path.join(path_result_folder_heating, 'model_run_results_txt')
data['lookups'] = lookup_tables.basic_lookups()
# Read in heating deamnds
path_heating_demands = os.path.join(path_result_folder_model_runs, 'enduse_specific_results')
all_files = os.listdir(path_heating_demands)
for file_name in all_files:
ending = file_name[-4:]
if ending == ".npy":
year = int(file_name.split("__")[2][:-4])
file_path = os.path.join(path_heating_demands, file_name)
heating_demand = np.load(file_path)
maximum_hour_of_peak_day = heating_demand[fueltype_elec_int].argmax() #get maxim hour of peak day
ed_national_heating_peak[year] = heating_demand[fueltype_elec_int][maximum_hour_of_peak_day]
simulation_yrs_result = [ed_national_heating_peak[year] for year in simulation_yrs_to_plot]
realisation_data = pd.DataFrame(
[simulation_yrs_result],
columns=data['assumptions']['sim_yrs'])
national_heating_peak = national_heating_peak.append(realisation_data)
except:
raise Exception("... no heating peak data available " + str(path_result_folder))
try:
# Simulation information is read in from .ini file for results
data['enduses'], data['assumptions'], data['regions'] = data_loader.load_ini_param(os.path.join(path_result_folder))
pop_data = read_data.read_scenaric_population_data(os.path.join(path_result_folder, 'model_run_pop'))
path_result_folder = os.path.join(path_result_folder, 'simulation_results')
path_result_folder_model_runs = os.path.join(path_result_folder, 'model_run_results_txt')
data['lookups'] = lookup_tables.basic_lookups()
# Other information is read in
data['assumptions']['seasons'] = date_prop.get_season(year_to_model=2015)
data['assumptions']['model_yeardays_daytype'], data['assumptions']['yeardays_month'], data['assumptions']['yeardays_month_days'] = date_prop.get_yeardays_daytype(year_to_model=2015)
# --------------------------------------------
# Reading in results from different model runs
# --------------------------------------------
results_container = read_weather_results.read_in_weather_results(
path_result_folder_model_runs,
data['assumptions']['seasons'],
data['assumptions']['model_yeardays_daytype'],
pop_data,
fueltype_str='electricity')
# --Total demand (dataframe with row: realisation, column=region)
realisation_data = pd.DataFrame(
[results_container['ed_reg_tot_y'][simulation_yr_to_plot][fueltype_elec_int]],
columns=data['regions'])
total_regional_demand_electricity = total_regional_demand_electricity.append(realisation_data)
# National per fueltype electricity
simulation_yrs_result = [results_container['national_all_fueltypes'][year][fueltype_elec_int] for year in simulation_yrs_to_plot]
realisation_data = pd.DataFrame(
[simulation_yrs_result],
columns=data['assumptions']['sim_yrs'])
national_electricity = national_electricity.append(realisation_data)
# National per fueltype gas
fueltype_gas_int = tech_related.get_fueltype_int('gas')
simulation_yrs_result = [results_container['national_all_fueltypes'][year][fueltype_gas_int] for year in simulation_yrs_to_plot]
realisation_data = pd.DataFrame(
[simulation_yrs_result],
columns=data['assumptions']['sim_yrs'])
national_gas = national_gas.append(realisation_data)
# National per fueltype hydrogen
fueltype_hydrogen_int = tech_related.get_fueltype_int('hydrogen')
simulation_yrs_result = [results_container['national_all_fueltypes'][year][fueltype_hydrogen_int] for year in simulation_yrs_to_plot]
realisation_data = pd.DataFrame(
[simulation_yrs_result],
columns=data['assumptions']['sim_yrs'])
national_hydrogen = national_hydrogen.append(realisation_data)
# --Peak hour demand per region (dataframe with row: realisation, column=region)
realisation_data = pd.DataFrame(
[results_container['ed_reg_peakday_peak_hour'][simulation_yr_to_plot][fueltype_elec_int]],
columns=data['regions'])
peak_hour_demand = peak_hour_demand.append(realisation_data)
# --Peak hour demand / pop per region (dataframe with row: realisation, column=region)
realisation_data = pd.DataFrame(
[results_container['ed_reg_peakday_peak_hour_per_pop'][simulation_yr_to_plot][fueltype_elec_int]],
columns=data['regions'])
peak_hour_demand_per_person = peak_hour_demand_per_person.append(realisation_data)
# --National peak
simulation_yrs_result = [results_container['national_peak'][year][fueltype_elec_int] for year in simulation_yrs_to_plot]
realisation_data = pd.DataFrame(
[simulation_yrs_result],
columns=data['assumptions']['sim_yrs'])
national_peak = national_peak.append(realisation_data)
# --Regional percentage of national peak demand
realisation_data = pd.DataFrame(
[results_container['regional_share_national_peak'][simulation_yr_to_plot]],
columns=data['regions'])
regional_share_national_peak = regional_share_national_peak.append(realisation_data)
# --Regional percentage of national peak demand per person
realisation_data = pd.DataFrame(
[results_container['regional_share_national_peak_pp'][simulation_yr_to_plot]],
columns=data['regions'])
regional_share_national_peak_pp = regional_share_national_peak_pp.append(realisation_data)
# Mean demand of peak day
simulation_yrs_result = [results_container['mean_peak_day_demand'][year][fueltype_elec_int] for year in simulation_yrs_to_plot]
realisation_data = pd.DataFrame(
[simulation_yrs_result],
columns=data['assumptions']['sim_yrs'])
daily_mean_peak_day = daily_mean_peak_day.append(realisation_data)
except:
raise Exception("The run '{}' is corrupted".format(path_result_folder))
# Add to scenario container
result_entry = {
'national_heating_peak': national_heating_peak,
'scenario_name': scenario_name,
'peak_hour_demand': peak_hour_demand,
'peak_hour_demand_per_person': peak_hour_demand_per_person,
'national_peak': national_peak,
'regional_share_national_peak': regional_share_national_peak,
'regional_share_national_peak_pp': regional_share_national_peak_pp,
'total_regional_demand_electricity': total_regional_demand_electricity,
'national_electricity': national_electricity,
'national_gas': national_gas,
'national_hydrogen': national_hydrogen,
'daily_mean_peak_day': daily_mean_peak_day}
scenario_result_container.append(result_entry)
# ---------------------------------------------------------------
# TEST PLOT X-axis: Contribution to peak y-axis: Std: deviation
# ---------------------------------------------------------------
x_chart_yrs_storage[simulation_yr_to_plot][scenario_name] = result_entry
# ------------------------------
# Plot national sum over time per fueltype and scenario
# ------------------------------
crit_smooth_line = False
seperate_legend = True
try:
print("... plotting national sum of fueltype over time ")
fig_3_plot_over_time.fueltypes_over_time(
scenario_result_container=scenario_result_container,
sim_yrs=data['assumptions']['sim_yrs'],
fig_name="fueltypes_over_time__{}__{}.pdf".format(simulation_yr_to_plot, fueltype_str),
fueltypes=['electricity', 'gas', 'hydrogen'],
result_path=result_path,
unit='TWh',
plot_points=True,
crit_smooth_line=crit_smooth_line,
seperate_legend=seperate_legend)
except:
raise Exception("FAILS national sum")
# ------------------------------
# Plot national peak change over time for each scenario including weather variability
# ------------------------------
try:
fig_3_plot_over_time.scenario_over_time(
scenario_result_container=scenario_result_container,
field_name='national_peak',
sim_yrs=data['assumptions']['sim_yrs'],
fig_name="scenarios_peak_over_time__{}__{}.pdf".format(simulation_yr_to_plot, fueltype_str),
plot_points=True,
result_path=result_path,
crit_smooth_line=crit_smooth_line,
seperate_legend=seperate_legend)
except:
raise Exception("FAILED")
pass
# ------------------------------
# Plot heating peak change over time for each scenario including weather variability
# ------------------------------
try:
fig_3_plot_over_time.scenario_over_time(
scenario_result_container=scenario_result_container,
field_name='national_heating_peak',
sim_yrs=data['assumptions']['sim_yrs'],
fig_name="scenarios_heating_peak_over_time__{}__{}.pdf".format(simulation_yr_to_plot, fueltype_str),
plot_points=True,
result_path=result_path,
crit_smooth_line=crit_smooth_line,
seperate_legend=seperate_legend)
except:
raise Exception("FAILED")
pass
# ------------------------------
# plot PEAK DAY mean
# ------------------------------
try:
fig_3_plot_over_time.scenario_over_time(
scenario_result_container=scenario_result_container,
field_name='daily_mean_peak_day',
sim_yrs=data['assumptions']['sim_yrs'],
fig_name="mean_demand_of_peak_day{}__{}.pdf".format(simulation_yr_to_plot, fueltype_str),
plot_points=True,
result_path=result_path,
crit_smooth_line=crit_smooth_line,
seperate_legend=seperate_legend)
except:
raise Exception("FAILED")
pass
## ------------------------------
## Plotting x-chart
## ------------------------------
fig_3_plot_over_time.plot_std_dev_vs_contribution(
scenario_result_container=x_chart_yrs_storage,
sim_yrs=data['assumptions']['sim_yrs'],
fig_name="_scenarios_4_chart_absolute.pdf",
fueltypes=['electricity'],
result_path=result_path,
path_shapefile_input=path_shapefile_input,
unit='TWh',
plot_points=True)
print("===================================")
print("... finished reading and plotting results")
print("===================================")
def plot_spatial_validation(simulation_yr_to_plot,
non_regional_modelled,
regional_modelled,
subnational_real,
regions,
fueltype_str,
fig_path,
label_points=False,
plotshow=False):
result_dict = {}
result_dict['real_demand'] = {}
result_dict['modelled_demand'] = {}
result_dict['modelled_demands_regional'] = {}
fueltype_int = tech_related.get_fueltype_int(fueltype_str)
# -------------------------------------------
# Match ECUK sub-regional demand with geocode
# -------------------------------------------
for region_nr, region in enumerate(regions):
try:
# --Sub Regional Electricity demand (as GWh)
real = subnational_real[region]
modelled = non_regional_modelled[region]
result_dict['real_demand'][region] = real
result_dict['modelled_demand'][region] = modelled
except KeyError:
logging.debug(
"Sub-national spatial validation: No fuel for region %s",
region)
# Do this for every weather station data
for weather_station in regional_modelled:
try:
_reg_demand = regional_modelled[weather_station][
simulation_yr_to_plot][fueltype_int][region_nr]
result_dict['modelled_demands_regional'][region].append(
_reg_demand)
except KeyError:
_reg_demand = regional_modelled[weather_station][
simulation_yr_to_plot][fueltype_int][region_nr]
result_dict['modelled_demands_regional'][region] = [
_reg_demand
]
# --------------------
# Calculate statistics
# --------------------
diff_real_modelled_p = []
diff_real_modelled_abs = []
for region in regions:
try:
real = result_dict['real_demand'][region]
modelled = result_dict['modelled_demand'][region]
diff_real_modelled_p.append(abs(100 - ((100 / real) * modelled)))
diff_real_modelled_abs.append(real - modelled)
except KeyError:
pass
# Calculate the average deviation between reald and modelled
av_deviation_real_modelled = np.average(diff_real_modelled_p)
median_absolute_deviation = np.median(
diff_real_modelled_p) # median deviation
# Calculate standard deviation
std_dev_p = np.std(diff_real_modelled_p) # Given as percent
std_dev_abs = np.std(diff_real_modelled_abs) # Given as energy unit
# -----------------
# Sort results according to size
# -----------------
sorted_dict_real = sorted(result_dict['real_demand'].items(),
key=operator.itemgetter(1))
# -------------------------------------
# Plot
# -------------------------------------
fig = plt.figure(figsize=basic_plot_functions.cm2inch(9, 8))
ax = fig.add_subplot(1, 1, 1)
x_values = np.arange(0, len(sorted_dict_real), 1)
y_real_demand = []
y_modelled_demand = []
y_modelled_demands_non_regional = []
labels = []
for sorted_region in sorted_dict_real:
geocode_lad = sorted_region[0]
y_real_demand.append(result_dict['real_demand'][geocode_lad])
y_modelled_demand.append(result_dict['modelled_demand'][geocode_lad])
y_modelled_demands_non_regional.append(
result_dict['modelled_demands_regional'][geocode_lad])
print(
"validation %s LAD %s: real: %s modelled: %s modelled percentage: %s (%sp diff)",
fueltype_str, geocode_lad,
round(result_dict['real_demand'][geocode_lad], 4),
round(result_dict['modelled_demand'][geocode_lad], 4),
round(
100 / result_dict['real_demand'][geocode_lad] *
result_dict['modelled_demand'][geocode_lad], 4),
round(
100 - (100 / result_dict['real_demand'][geocode_lad] *
result_dict['modelled_demand'][geocode_lad]), 4))
labels.append(geocode_lad)
# Calculate r_squared
_slope, _intercept, r_value, _p_value, _std_err = stats.linregress(
y_real_demand, y_modelled_demand)
# --------
# Axis
# --------
plt.tick_params(
axis='x', # changes apply to the x-axis
which='both', # both major and minor ticks are affected
bottom='off', # ticks along the bottom edge are off
top='off', # ticks along the top edge are off
labelbottom='off') # labels along the bottom edge are off
# ----------------------------------------------
# Plot
# ----------------------------------------------
markersize = 3
markeredgewidth = 0
linewidth = 2
color_real = 'black'
color_all_stations = 'green'
color_single_station = 'red'
plt.plot(x_values,
y_real_demand,
linestyle='-',
marker='o',
alpha=0.6,
markersize=markersize,
fillstyle='full',
markerfacecolor='black',
markeredgewidth=markeredgewidth,
color=color_real,
label='actual demand')
plt.plot(x_values,
y_modelled_demand,
marker='o',
linestyle='-',
markersize=markersize,
alpha=0.6,
markerfacecolor='blue',
fillstyle='none',
markeredgewidth=markeredgewidth,
markeredgecolor='blue',
color=color_all_stations,
label='modelled using all stations')
# Demands calculated only from one weather station
station_nr = 0
nr_of_stations = len(y_modelled_demands_non_regional[0])
station_vals = []
for region_vals in y_modelled_demands_non_regional:
station_vals.append(region_vals[station_nr])
plt.plot(x_values,
station_vals,
marker='o',
linestyle='-',
linewidth=linewidth,
markersize=markersize,
alpha=0.6,
markerfacecolor='green',
fillstyle='none',
markeredgewidth=markeredgewidth,
markeredgecolor='green',
color=color_single_station,
label='modelled using only a single stations')
'''for i in range(nr_of_stations):
station_data = []
for reg_nr in range(nr_of_regions):
station_data.append(y_modelled_demands_non_regional[reg_nr][i])
plt.plot(
x_values,
station_data, #y_modelled_demands_non_regional,
marker='o',
linestyle='None',
markersize=1.6,
alpha=0.6,
markerfacecolor='white',
fillstyle='none',
markeredgewidth=0.5,
markeredgecolor='orange',
color='black',
label='model')'''
'''# ------------
# Collect all values per weather_yr
list_with_station_vals = []
for station_i in range(nr_of_stations):
station_vals = []
for region_vals in y_modelled_demands_non_regional:
station_vals.append(region_vals[station_i])
list_with_station_vals.append(station_vals)
df = pd.DataFrame(
list_with_station_vals,
columns=range(nr_of_regions)) #note not region_rn as ordered
period_h = range(nr_of_regions)
quantile_95 = 0.95
quantile_05 = 0.05
df_q_95 = df.quantile(quantile_95)
df_q_05 = df.quantile(quantile_05)
#Transpose for plotting purposes
df = df.T
df_q_95 = df_q_95.T
df_q_05 = df_q_05.T
# ---------------
# Smoothing lines
# ---------------
try:
period_h_smoothed, df_q_95_smoothed = basic_plot_functions.smooth_data(period_h, df_q_95, num=40000)
period_h_smoothed, df_q_05_smoothed = basic_plot_functions.smooth_data(period_h, df_q_05, num=40000)
except:
period_h_smoothed = period_h
df_q_95_smoothed = df_q_95
df_q_05_smoothed = df_q_05
#plt.plot(period_h_smoothed, df_q_05_smoothed, color='black', linestyle='--', linewidth=0.5, label="0.05")
#plt.plot(period_h_smoothed, df_q_95_smoothed, color='black', linestyle='--', linewidth=0.5, label="0.95")
# -----------------
# Uncertainty range
# -----------------
plt.fill_between(
period_h_smoothed, #x
df_q_95_smoothed, #y1
df_q_05_smoothed, #y2
alpha=.40,
facecolor="grey",
label="uncertainty band")
# -----------'''
# Limit
plt.ylim(ymin=0)
# -----------
# Labelling
# -----------
if label_points:
for pos, txt in enumerate(labels):
ax.text(x_values[pos],
y_modelled_demand[pos],
txt,
horizontalalignment="right",
verticalalignment="top",
fontsize=1)
font_additional_info = plotting_styles.font_info(size=4)
title_info = (
'R_2: {}, std_%: {} (GWh {}), av_diff_%: {} median_abs_dev: {}'.format(
round(r_value, 2), round(std_dev_p, 2), round(std_dev_abs, 2),
round(av_deviation_real_modelled, 2),
round(median_absolute_deviation, 2)))
plt.title(title_info, loc='left', fontdict=font_additional_info)
plt.xlabel("UK regions (excluding northern ireland)")
plt.ylabel("{} [GWh]".format(fueltype_str))
# --------
# Legend
# --------
plt.legend(prop={'family': 'arial', 'size': 8}, frameon=False)
# Tight layout
plt.margins(x=0)
plt.tight_layout()
plt.savefig(fig_path)
if plotshow:
plt.show()
else:
plt.close()
def test_tech_l_sigmoid():
"""testing
"""
fueltype_lookup = {
'solid_fuel': 0,
'gas': 1,
'electricity': 2,
'oil': 3,
'heat_sold': 4,
'biomass': 5,
'hydrogen': 6,
'heat': 7}
technologies = {
'boilerA': read_data.TechnologyData(
fueltype='gas',
eff_by=0.5,
eff_ey=0.5,
year_eff_ey=2015,
eff_achieved=1.0,
diff_method='linear',
market_entry=1990,
tech_max_share=1.0),
'boilerB': read_data.TechnologyData(
fueltype='electricity',
eff_by=0.5,
eff_ey=0.5,
year_eff_ey=2015,
eff_achieved=1.0,
diff_method='linear',
market_entry=1990,
tech_max_share=1.0)
}
fuel_switches = [
read_data.FuelSwitch(
enduse='heating',
technology_install='boilerB',
switch_yr=2020,
fueltype_replace=tech_related.get_fueltype_int('gas'),
fuel_share_switched_ey=1.0
)]
service_fueltype_p = {1: 1.0, 2: 0.0}
s_tech_by_p = {
'boilerA': 1.0,
'boilerB': 0.0}
fuel_tech_p_by = {
1: {'boilerA': 1.0},
2: {'boilerB': 1.0}}
installed_tech = ['boilerB']
s_tech_switched_ey = {
'boilerA': 0.0,
'boilerB': 1.0}
result = s_generate_sigmoid.tech_l_sigmoid(
s_tech_switched_ey=s_tech_switched_ey,
enduse_fuel_switches=fuel_switches,
technologies=technologies,
installed_tech=installed_tech,
s_fueltype_by_p=service_fueltype_p,
s_tech_by_p=s_tech_by_p,
fuel_tech_p_by=fuel_tech_p_by)
assert result['boilerB'] == 1.0
# -----
technologies = {
'boilerA': read_data.TechnologyData(
fueltype='gas',
eff_by=0.5,
eff_ey=0.5,
year_eff_ey=2015,
eff_achieved=1.0,
diff_method='linear',
market_entry=1990,
tech_max_share=1.0),
'boilerB': read_data.TechnologyData(
fueltype='electricity',
eff_by=0.5,
eff_ey=0.5,
year_eff_ey=2015,
eff_achieved=1.0,
diff_method='linear',
market_entry=1990,
tech_max_share=0.8)
}
fuel_switches = [
read_data.FuelSwitch(
enduse='heating',
technology_install='boilerB',
switch_yr=2020,
fueltype_replace=tech_related.get_fueltype_int('gas'),
fuel_share_switched_ey=0.5 #info lower than max
)]
service_fueltype_p = {1: 1.0, 2: 0.0}
s_tech_by_p = {'boilerA': 1.0, 'boilerB': 0.0}
fuel_tech_p_by = {1: {'boilerA': 1.0}, 2: {'boilerB': 1.0}}
installed_tech = ['boilerB']
s_tech_switched_ey = {'boilerA': 0.5, 'boilerB': 0.5}
result = s_generate_sigmoid.tech_l_sigmoid(
s_tech_switched_ey=s_tech_switched_ey,
enduse_fuel_switches=fuel_switches,
technologies=technologies,
installed_tech=installed_tech,
s_fueltype_by_p=service_fueltype_p,
s_tech_by_p=s_tech_by_p,
fuel_tech_p_by=fuel_tech_p_by)
assert result['boilerB'] == 0.8
def run(data_input, fueltype_str, fig_name):
"""Plot peak demand and total demand over time in same plot
"""
statistics_to_print = []
# Select period and fueltype
fueltype_int = tech_related.get_fueltype_int(fueltype_str)
# -----------------------------------------------------------
# Modelled years
# -----------------------------------------------------------
# List of selected data for every weather year (which is then converted to array)
weather_yrs_total_demand = []
weather_yrs_peak_demand = []
nr_weather_yrs = list(data_input.keys())
statistics_to_print.append("_____________________________")
statistics_to_print.append("Weather years")
statistics_to_print.append(str(data_input.keys()))
# Iterate weather years
for weather_yr, data_weather_yr in data_input.items():
total_demands = []
peak_demands = []
sim_yrs = []
for sim_yr in data_weather_yr.keys():
sim_yrs.append(sim_yr)
data_input_fueltype = data_weather_yr[sim_yr][
fueltype_int] # Select fueltype
# sum total annual demand and convert gwh to twh
sum_gwh_y = np.sum(data_input_fueltype)
sum_thw_y = conversions.gwh_to_twh(sum_gwh_y)
# Get peak
peak_h = np.max(data_input_fueltype.reshape(8760))
total_demands.append(sum_thw_y)
peak_demands.append(peak_h)
weather_yrs_total_demand.append(total_demands)
weather_yrs_peak_demand.append(peak_demands)
columns = sim_yrs
# Convert to array
weather_yrs_total_demand = np.array(weather_yrs_total_demand)
weather_yrs_peak_demand = np.array(weather_yrs_peak_demand)
# Calculate std per simulation year
std_total_demand = list(np.std(weather_yrs_total_demand,
axis=0)) # across columns calculate std
std_peak_demand = list(np.std(weather_yrs_peak_demand,
axis=0)) # across columns calculate std
# Create dataframe
if len(nr_weather_yrs) > 2:
# Create dataframes
df_total_demand = pd.DataFrame(weather_yrs_total_demand,
columns=columns)
df_peak = pd.DataFrame(weather_yrs_peak_demand, columns=columns)
# Calculate quantiles
quantile_95 = 0.95
quantile_05 = 0.05
# Calculate quantiles
df_total_demand_q_95 = df_total_demand.quantile(quantile_95)
df_total_demand_q_05 = df_total_demand.quantile(quantile_05)
df_peak_q_95 = df_peak.quantile(quantile_95)
df_peak_q_05 = df_peak.quantile(quantile_05)
# convert to list
df_total_demand_q_95 = df_total_demand_q_95.tolist()
df_total_demand_q_05 = df_total_demand_q_05.tolist()
df_peak_q_95 = df_peak_q_95.tolist()
df_peak_q_05 = df_peak_q_05.tolist()
#df_peak = df_peak.T #All indivdiual values
else:
#df_total_demand = weather_yrs_total_demand
#df_peak = weather_yrs_peak_demand
pass
# -------------------
# Base year data (2015)
# -------------------
# total demand
tot_demand_twh_2015 = []
for sim_yr, data_sim_yr in data_input[2015].items():
gwh_2015_y = np.sum(data_sim_yr[fueltype_int])
twh_2015_y = conversions.gwh_to_twh(gwh_2015_y)
tot_demand_twh_2015.append(twh_2015_y)
# peak
df_peak_2015 = []
for sim_yr, data_sim_yr in data_input[2015].items():
peak_gwh_2015_y = np.max(data_sim_yr[fueltype_int])
df_peak_2015.append(peak_gwh_2015_y)
# ---------------
# Smoothing lines
# ---------------
if len(nr_weather_yrs) > 2:
try:
period_h_smoothed, tot_demand_twh_2015_smoothed = basic_plot_functions.smooth_data(
columns, tot_demand_twh_2015, num=40000)
period_h_smoothed, df_total_demand_q_95_smoothed = basic_plot_functions.smooth_data(
list(columns), df_total_demand_q_95, num=40000)
period_h_smoothed, df_total_demand_q_05_smoothed = basic_plot_functions.smooth_data(
columns, df_total_demand_q_05, num=40000)
period_h_smoothed, df_peak_q_95_smoothed = basic_plot_functions.smooth_data(
list(columns), df_peak_q_95, num=40000)
period_h_smoothed, df_peak_q_05_smoothed = basic_plot_functions.smooth_data(
columns, df_peak_q_05, num=40000)
period_h_smoothed, df_peak_2015_smoothed = basic_plot_functions.smooth_data(
columns, df_peak_2015, num=40000)
except:
period_h_smoothed = columns
df_total_demand_q_95_smoothed = df_total_demand_q_95
df_total_demand_q_05_smoothed = df_total_demand_q_05
df_peak_q_95_smoothed = df_peak_q_95
df_peak_q_05_smoothed = df_peak_q_05
tot_demand_twh_2015_smoothed = tot_demand_twh_2015
df_peak_2015_smoothed = df_peak_2015
else:
try:
period_h_smoothed, tot_demand_twh_2015_smoothed = basic_plot_functions.smooth_data(
columns, tot_demand_twh_2015, num=40000)
period_h_smoothed, df_peak_2015_smoothed = basic_plot_functions.smooth_data(
columns, df_peak_2015, num=40000)
except:
period_h_smoothed = columns
tot_demand_twh_2015_smoothed = tot_demand_twh_2015
df_peak_2015_smoothed = df_peak_2015
# --------------
# Two axis figure
# --------------
fig, ax1 = plt.subplots(figsize=basic_plot_functions.cm2inch(15, 10))
ax2 = ax1.twinx()
# Axis label
ax1.set_xlabel('Years')
ax2.set_ylabel('Peak hour {} demand (GW)'.format(fueltype_str),
color='black')
ax1.set_ylabel('Total {} demand (TWh)'.format(fueltype_str), color='black')
# Make the y-axis label, ticks and tick labels match the line color.¨
color_axis1 = 'lightgrey'
color_axis2 = 'blue'
ax1.tick_params('y', colors='black')
ax2.tick_params('y', colors='black')
if len(nr_weather_yrs) > 2:
# -----------------
# Uncertainty range total demand
# -----------------
'''ax1.plot(
period_h_smoothed,
df_total_demand_q_05_smoothed,
color='tomato', linestyle='--', linewidth=0.5, label="0.05_total_demand")'''
'''ax1.plot(
period_h_smoothed,
df_total_demand_q_95_smoothed,
color=color_axis1, linestyle='--', linewidth=0.5, label="0.95_total_demand")
ax1.fill_between(
period_h_smoothed, #x
df_total_demand_q_95_smoothed, #y1
df_total_demand_q_05_smoothed, #y2
alpha=.25,
facecolor=color_axis1,
label="uncertainty band demand")'''
# -----------------
# Uncertainty range peaks
# -----------------
##ax2.plot(period_h_smoothed, df_peak_q_05_smoothed, color=color_axis2, linestyle='--', linewidth=0.5, label="0.05_peak")
##ax2.plot(period_h_smoothed, df_peak_q_95_smoothed, color=color_axis2, linestyle='--', linewidth=0.5, label="0.95_peak")
ax2.plot(period_h_smoothed,
df_peak_2015_smoothed,
color=color_axis2,
linestyle="--",
linewidth=0.4)
# Error bar of bar charts
ax2.errorbar(columns,
df_peak_2015,
linewidth=0.5,
color='black',
yerr=std_peak_demand,
linestyle="None")
# Error bar bar plots
ax1.errorbar(columns,
tot_demand_twh_2015,
linewidth=0.5,
color='black',
yerr=std_total_demand,
linestyle="None")
'''ax2.fill_between(
period_h_smoothed, #x
df_peak_q_95_smoothed, #y1
df_peak_q_05_smoothed, #y2
alpha=.25,
facecolor="blue",
label="uncertainty band peak")'''
# Total demand bar plots
##ax1.plot(period_h_smoothed, tot_demand_twh_2015_smoothed, color='tomato', linestyle='-', linewidth=2, label="tot_demand_weather_yr_2015")
ax1.bar(columns,
tot_demand_twh_2015,
width=2,
alpha=1,
align='center',
color=color_axis1,
label="total {} demand".format(fueltype_str))
statistics_to_print.append("_____________________________")
statistics_to_print.append("total demand per model year")
statistics_to_print.append(str(tot_demand_twh_2015))
# Line of peak demand
#ax2.plot(columns, df_peak, color=color_axis2, linestyle='--', linewidth=0.5, label="peak_0.95")
ax2.plot(period_h_smoothed,
df_peak_2015_smoothed,
color=color_axis2,
linestyle='-',
linewidth=2,
label="{} peak demand (base weather yr)".format(fueltype_str))
statistics_to_print.append("_____________________________")
statistics_to_print.append("peak demand per model year")
statistics_to_print.append(str(df_peak_2015))
# Scatter plots of peak demand
ax2.scatter(columns,
df_peak_2015,
marker='o',
s=20,
color=color_axis2,
alpha=1)
ax1.legend(prop={
'family': 'arial',
'size': 10
},
loc='upper center',
bbox_to_anchor=(0.9, -0.1),
frameon=False,
shadow=True)
ax2.legend(prop={
'family': 'arial',
'size': 10
},
loc='upper center',
bbox_to_anchor=(0.1, -0.1),
frameon=False,
shadow=True)
# More space at bottom
#fig.subplots_adjust(bottom=0.4)
fig.tight_layout()
plt.savefig(fig_name)
plt.close()
# Write info to txt
write_data.write_list_to_txt(
os.path.join(fig_name.replace(".pdf", ".txt")), statistics_to_print)
print("--")
def write_user_defined_results(criterias, result_paths, sim_obj, data, curr_yr,
region_selection, pop_array_cy):
"""
Write annual results to files
"""
logging.info("... Start writing results to file")
if criterias['write_txt_additional_results']:
# Write population data to file
write_data.write_scenaric_population_data(
curr_yr, result_paths['data_results_model_run_pop'], pop_array_cy)
# Write full results (Note: Results in very large data written to file)
##write_data.write_full_results(
## data_handle.current_timestep,
## os.path.join(result_path, 'model_run_results_txt'),
## sim_obj.ed_enduse_fueltype_regs_yh,
## "out_enduse_specific")
write_data.write_supply_results(
curr_yr, "ed_fueltype_regs_yh",
result_paths['data_results_model_run_pop'],
sim_obj.ed_fueltype_regs_yh, "result_tot_submodels_fueltypes")
write_data.write_enduse_specific(
curr_yr, result_paths['data_results_model_run_results_txt'],
sim_obj.tot_fuel_y_enduse_specific_yh, "out_enduse_specific")
write_data.write_lf(result_paths['data_results_model_run_results_txt'],
"result_reg_load_factor_y", [curr_yr],
sim_obj.reg_load_factor_y, 'reg_load_factor_y')
write_data.write_lf(result_paths['data_results_model_run_results_txt'],
"result_reg_load_factor_yd", [curr_yr],
sim_obj.reg_load_factor_yd, 'reg_load_factor_yd')
# ----------------------------------------------------------------------------------------
# Write out national demand for every fueltype (used for first sending of demand data)
# ----------------------------------------------------------------------------------------
if criterias['write_out_national']:
# Write out gas
demand_supply_interaction.write_national_results(
path_folder=result_paths['data_results'],
results_unconstrained=sim_obj.results_unconstrained,
enduse_specific_results=sim_obj.tot_fuel_y_enduse_specific_yh,
fueltype_str='gas',
fuelype_nr=tech_related.get_fueltype_int('gas'),
year=curr_yr,
submodels_names=data['assumptions'].submodels_names)
# Write out elec
demand_supply_interaction.write_national_results(
path_folder=result_paths['data_results'],
results_unconstrained=sim_obj.results_unconstrained,
enduse_specific_results=sim_obj.tot_fuel_y_enduse_specific_yh,
fueltype_str='electricity',
fuelype_nr=tech_related.get_fueltype_int('electricity'),
year=curr_yr,
submodels_names=data['assumptions'].submodels_names)
# ------------------------------------------------
# Temporal Validation
# ------------------------------------------------
if (criterias['validation_criteria']
== True) and (curr_yr == data['assumptions'].base_yr) and (
['cluster_calc'] != True):
lad_validation.spatio_temporal_val(
sim_obj.ed_fueltype_national_yh,
sim_obj.ed_fueltype_regs_yh,
result_paths,
data['paths'],
region_selection,
data['assumptions'].seasons,
data['assumptions'].model_yeardays_daytype,
plot_crit=False)
def main(scenarios_path, path_shapefile_input, base_yr,
simulation_yrs_to_plot):
"""Read in all results and plot PDFs
Arguments
----------
scenarios_path : str
Path to results
path_shapefile_input : str
Path to shapefile
plot_crit_dict : dict
Criteria to select plots to plot
base_yr : int
Base year
comparison_year : int
Year to generate comparison plots
"""
print("Start creating plots")
# -------------------
# Create result folder
# -------------------
result_path = os.path.join(scenarios_path, '_results_weather_plots')
basic_functions.del_previous_setup(result_path)
basic_functions.create_folder(result_path)
for simulation_yr_to_plot in simulation_yrs_to_plot:
print("-----------")
print("...simulation_yr_to_plot: " + str(simulation_yr_to_plot))
print("-----------")
data = {}
# ---------------------------------------------------------
# Iterate folders and read out all weather years and stations
# ---------------------------------------------------------
to_ignores = [
'model_run_pop', 'PDF_validation', '_results_weather_plots'
]
endings_to_ignore = ['.pdf', '.txt', '.ini']
all_scenarios_incl_ignored = os.listdir(scenarios_path)
all_scenarios = []
for scenario in all_scenarios_incl_ignored:
if scenario not in to_ignores:
all_scenarios.append(scenario)
scenario_result_container = []
for scenario_nr, scenario_name in enumerate(all_scenarios):
print(" ")
print("Scenario: {}".format(scenario_name))
print(" ")
scenario_path = os.path.join(scenarios_path, scenario_name)
all_result_folders = os.listdir(scenario_path)
paths_folders_result = []
for result_folder in all_result_folders:
if result_folder not in to_ignores and result_folder[
-4:] not in endings_to_ignore:
paths_folders_result.append(
os.path.join(scenario_path, result_folder))
fueltype_str_to_create_maps = ['electricity']
fueltype_str = 'electricity'
fueltype_int = tech_related.get_fueltype_int(fueltype_str)
####################################################################
# Collect regional simulation data for every realisation
####################################################################
total_regional_demand_electricity = pd.DataFrame()
peak_hour_demand = pd.DataFrame()
national_peak = pd.DataFrame()
regional_share_national_peak = pd.DataFrame()
national_electricity = pd.DataFrame()
national_gas = pd.DataFrame()
national_hydrogen = pd.DataFrame()
for path_result_folder in paths_folders_result:
data = {}
# Simulation information is read in from .ini file for results
data['enduses'], data['assumptions'], data[
'regions'] = data_loader.load_ini_param(
os.path.join(path_result_folder))
pop_data = read_data.read_scenaric_population_data(
os.path.join(path_result_folder, 'model_run_pop'))
path_result_folder = os.path.join(path_result_folder,
'simulation_results')
path_result_folder_model_runs = os.path.join(
path_result_folder, 'model_run_results_txt')
data['lookups'] = lookup_tables.basic_lookups()
# Other information is read in
data['assumptions']['seasons'] = date_prop.get_season(
year_to_model=2015)
data['assumptions']['model_yeardays_daytype'], data[
'assumptions']['yeardays_month'], data['assumptions'][
'yeardays_month_days'] = date_prop.get_yeardays_daytype(
year_to_model=2015)
# --------------------------------------------
# Reading in results from different model runs
# --------------------------------------------
results_container = read_weather_results.read_in_weather_results(
path_result_folder_model_runs,
data['assumptions']['seasons'],
data['assumptions']['model_yeardays_daytype'],
fueltype_str='electricity')
# --Total demand (dataframe with row: realisation, column=region)
realisation_data = pd.DataFrame([
results_container['ed_reg_tot_y'][simulation_yr_to_plot]
[fueltype_int]
],
columns=data['regions'])
total_regional_demand_electricity = total_regional_demand_electricity.append(
realisation_data)
# National per fueltype electricity
fueltype_elec_int = tech_related.get_fueltype_int(
'electricity')
simulation_yrs_result = [
results_container['national_all_fueltypes'][year]
[fueltype_elec_int] for year in
results_container['national_all_fueltypes'].keys()
]
realisation_data = pd.DataFrame(
[simulation_yrs_result],
columns=data['assumptions']['sim_yrs'])
national_electricity = national_electricity.append(
realisation_data)
# National per fueltype gas
fueltype_elec_int = tech_related.get_fueltype_int('gas')
simulation_yrs_result = [
results_container['national_all_fueltypes'][year]
[fueltype_elec_int] for year in
results_container['national_all_fueltypes'].keys()
]
realisation_data = pd.DataFrame(
[simulation_yrs_result],
columns=data['assumptions']['sim_yrs'])
national_gas = national_gas.append(realisation_data)
# National per fueltype hydrogen
fueltype_elec_int = tech_related.get_fueltype_int('hydrogen')
simulation_yrs_result = [
results_container['national_all_fueltypes'][year]
[fueltype_elec_int] for year in
results_container['national_all_fueltypes'].keys()
]
realisation_data = pd.DataFrame(
[simulation_yrs_result],
columns=data['assumptions']['sim_yrs'])
national_hydrogen = national_hydrogen.append(realisation_data)
# --Peak day demand (dataframe with row: realisation, column=region)
realisation_data = pd.DataFrame([
results_container['ed_reg_peakday_peak_hour']
[simulation_yr_to_plot][fueltype_int]
],
columns=data['regions'])
peak_hour_demand = peak_hour_demand.append(realisation_data)
# --National peak
simulation_yrs_result = [
results_container['national_peak'][year][fueltype_int]
for year in results_container['national_peak'].keys()
]
realisation_data = pd.DataFrame(
[simulation_yrs_result],
columns=data['assumptions']['sim_yrs'])
national_peak = national_peak.append(realisation_data)
# --Regional percentage of national peak demand
realisation_data = pd.DataFrame([
results_container['regional_share_national_peak']
[simulation_yr_to_plot]
],
columns=data['regions'])
regional_share_national_peak = regional_share_national_peak.append(
realisation_data)
# Add to scenario container
scenario_result_container.append({
'scenario_name':
scenario_name,
'peak_hour_demand':
peak_hour_demand,
'national_peak':
national_peak,
'regional_share_national_peak':
regional_share_national_peak,
'total_regional_demand_electricity':
total_regional_demand_electricity,
'national_electricity':
national_electricity,
'national_gas':
national_gas,
'national_hydrogen':
national_hydrogen,
})
# ------------------------------
# Plot national sum over time per fueltype and scenario
# ------------------------------
print("... plotting national sum of fueltype over time ")
fig_3_plot_over_time.fueltypes_over_time(
scenario_result_container=scenario_result_container,
sim_yrs=data['assumptions']['sim_yrs'],
fig_name="fueltypes_over_time__{}__{}.pdf".format(
simulation_yr_to_plot, fueltype_str),
fueltypes=['electricity', 'gas', 'hydrogen'],
result_path=result_path,
unit='TWh',
plot_points=True,
crit_smooth_line=True,
seperate_legend=False)
# ------------------------------
# Plot national peak change over time for each scenario including weather variability
# ------------------------------
fig_3_plot_over_time.scenario_over_time(
scenario_result_container=scenario_result_container,
sim_yrs=data['assumptions']['sim_yrs'],
fig_name="scenarios_peak_over_time__{}__{}.pdf".format(
simulation_yr_to_plot, fueltype_str),
plot_points=True,
result_path=result_path,
crit_smooth_line=True,
seperate_legend=False)
# ------------------------------
# Plotting spatial results for electricity
# ------------------------------
for i in scenario_result_container:
scenario_name = i['scenario_name']
total_regional_demand_electricity = i[
'total_regional_demand_electricity']
peak_hour_demand = i['peak_hour_demand']
regional_share_national_peak = i['regional_share_national_peak']
print("... plot spatial map of total annual demand")
field_to_plot = 'std_dev'
fig_3_weather_map.total_annual_demand(
total_regional_demand_electricity,
path_shapefile_input,
data['regions'],
pop_data=pop_data,
simulation_yr_to_plot=simulation_yr_to_plot,
result_path=result_path,
fig_name="{}__tot_demand__{}_{}_{}.pdf".format(
scenario_name, field_to_plot, fueltype_str,
simulation_yr_to_plot),
field_to_plot=field_to_plot,
unit='GW',
seperate_legend=False)
print("... plot spatial map of peak hour demand")
field_to_plot = 'std_dev'
fig_3_weather_map.total_annual_demand(
peak_hour_demand,
path_shapefile_input,
data['regions'],
pop_data=pop_data,
simulation_yr_to_plot=simulation_yr_to_plot,
result_path=result_path,
fig_name="{}__peak_h_demand_{}_{}_{}.pdf".format(
scenario_name, field_to_plot, fueltype_str,
simulation_yr_to_plot),
field_to_plot=field_to_plot,
unit='GW',
seperate_legend=False)
print(
"... plot spatial map of percentage of regional peak hour demand"
)
field_to_plot = 'mean'
fig_3_weather_map.total_annual_demand(
regional_share_national_peak,
path_shapefile_input,
data['regions'],
pop_data=pop_data,
simulation_yr_to_plot=simulation_yr_to_plot,
result_path=result_path,
fig_name="{}__regional_share_national_peak_{}_{}_{}.pdf".
format(scenario_name, field_to_plot, fueltype_str,
simulation_yr_to_plot),
field_to_plot=field_to_plot,
unit='percentage',
seperate_legend=False,
bins=[0.000001, 0.25, 0.5, 0.75, 1, 1.25, 1.5])
field_to_plot = 'std_dev'
fig_3_weather_map.total_annual_demand(
regional_share_national_peak,
path_shapefile_input,
data['regions'],
pop_data=pop_data,
simulation_yr_to_plot=simulation_yr_to_plot,
result_path=result_path,
fig_name="{}__regional_share_national_peak_{}_{}_{}.pdf".
format(scenario_name, field_to_plot, fueltype_str,
simulation_yr_to_plot),
field_to_plot=field_to_plot,
unit='percentage',
seperate_legend=False)
print("===================================")
print("... finished reading and plotting results")
print("===================================")
def plot_fig_spatio_temporal_validation(path_regional_calculations,
path_rolling_elec_demand,
path_temporal_elec_validation,
path_temporal_gas_validation,
path_non_regional_elec_2015,
path_out_plots,
plot_show=False):
"""
Create plot with regional and non-regional plots for second paper
Compare hdd calculations and disaggregation of regional and local
"""
# ---------------------------------------------------------
# Iterate folders and read out all weather years and stations
# ---------------------------------------------------------
all_result_folders = os.listdir(path_regional_calculations)
paths_folders_result = []
data_container = defaultdict(dict)
ed_fueltype_regs_yh = defaultdict(dict)
weather_yr_station_tot_fueltype_yh = defaultdict(dict)
residential_results = defaultdict(dict)
for scenario_folder in all_result_folders:
result_folders = os.listdir(
os.path.join(path_regional_calculations, scenario_folder))
for result_folder in result_folders:
try:
split_path_name = result_folder.split("__")
weather_yr = int(split_path_name[0])
try:
weather_station = int(split_path_name[1])
except:
weather_station = "all_stations"
paths_folders_result.append(
os.path.join(path_regional_calculations, result_folder))
data = {}
data['lookups'] = lookup_tables.basic_lookups()
data['enduses'], data['assumptions'], data[
'regions'] = data_loader.load_ini_param(
os.path.join(
path_regional_calculations,
all_result_folders[0])) # last result folder
data['assumptions']['seasons'] = date_prop.get_season(
year_to_model=2015)
data['assumptions']['model_yeardays_daytype'], data[
'assumptions']['yeardays_month'], data['assumptions'][
'yeardays_month_days'] = date_prop.get_yeardays_daytype(
year_to_model=2015)
results_container = read_data.read_in_results(
os.path.join(path_regional_calculations, scenario_folder,
"{}__{}".format(weather_yr, weather_station),
'model_run_results_txt'),
data['assumptions']['seasons'],
data['assumptions']['model_yeardays_daytype'])
weather_yr_station_tot_fueltype_yh[weather_yr][
weather_station] = results_container['tot_fueltype_yh']
ed_fueltype_regs_yh[weather_yr][
weather_station] = results_container['ed_fueltype_regs_yh']
residential_results[weather_yr][
weather_station] = results_container['residential_results']
except ValueError:
pass
data_container['ed_fueltype_regs_yh'] = ed_fueltype_regs_yh
data_container['tot_fueltype_yh'] = weather_yr_station_tot_fueltype_yh
data_container['residential_results'] = residential_results
data_container = dict(data_container)
# -------------------------------------------------
# Collect non regional 2015 elec data
# Calculated with all regional weather stations
# -------------------------------------------------
year_non_regional = 2015
path_with_txt = os.path.join(
path_non_regional_elec_2015, "{}__{}".format(str(year_non_regional),
"all_stations"),
'model_run_results_txt')
demand_year_non_regional = read_data.read_in_results(
path_with_txt, data['assumptions']['seasons'],
data['assumptions']['model_yeardays_daytype'])
tot_fueltype_yh = demand_year_non_regional['tot_fueltype_yh']
fueltype_int = tech_related.get_fueltype_int('electricity')
non_regional_elec_2015 = tot_fueltype_yh[year_non_regional][fueltype_int]
# ---Collect real electricity data of year 2015
elec_2015_indo, _ = elec_national_data.read_raw_elec_2015(
path_rolling_elec_demand)
# Factor data as total sum is not identical
f_diff_elec = np.sum(non_regional_elec_2015) / np.sum(elec_2015_indo)
elec_factored_yh = f_diff_elec * elec_2015_indo
# *****************************************************************
# Temporal validation
# Compare regional and non regional and actual demand over time
# *****************************************************************
simulation_yr_to_plot = 2015
winter_week, spring_week, summer_week, autumn_week = date_prop.get_seasonal_weeks(
)
# Peak day
peak_day, _ = enduse_func.get_peak_day_single_fueltype(elec_factored_yh)
# Convert days to hours
period_to_plot = list(range(0, 400))
period_to_plot = date_prop.get_8760_hrs_from_yeardays(winter_week)
period_to_plot = date_prop.get_8760_hrs_from_yeardays([peak_day])
period_to_plot_winter = date_prop.get_8760_hrs_from_yeardays(winter_week)
period_to_plot_spring = date_prop.get_8760_hrs_from_yeardays(spring_week)
fig_p2_temporal_validation.run_fig_p2_temporal_validation(
data_input=data_container['tot_fueltype_yh'],
weather_yr=2015,
fueltype_str='electricity',
simulation_yr_to_plot=simulation_yr_to_plot, # Simulation year to plot
period_h=period_to_plot,
validation_elec_2015=elec_factored_yh,
non_regional_elec_2015=non_regional_elec_2015,
fig_name=os.path.join(path_out_plots, "temporal_validation_elec.pdf"),
titel="yearday: {}".format(peak_day),
y_lim_val=55,
plot_validation=False,
plot_show=plot_show)
fueltype_gas = tech_related.get_fueltype_int('gas')
fig_p2_temporal_validation.run_fig_p2_temporal_validation(
data_input=data_container['tot_fueltype_yh'],
weather_yr=2015,
fueltype_str='gas',
simulation_yr_to_plot=simulation_yr_to_plot, # Simulation year to plot
period_h=period_to_plot,
validation_elec_2015=None,
non_regional_elec_2015=tot_fueltype_yh[year_non_regional]
[fueltype_gas],
fig_name=os.path.join(path_out_plots, "temporal_validation_gas.pdf"),
titel="yearday: {}".format(peak_day),
y_lim_val=250,
plot_validation=False,
plot_show=plot_show)
# -------------------
# Spatial validation (not with maps)
# -------------------
# non_regional: All weather station, spatially disaggregated TODO Give BETTER NAMES
# regional: Only one weather station for whole countr but still data for every region
weather_yr = 2015
fig_p2_spatial_val.run(
simulation_yr_to_plot=simulation_yr_to_plot,
demand_year_non_regional=demand_year_non_regional[
'residential_results'][weather_yr],
demand_year_regional=data_container['residential_results'][weather_yr],
fueltypes=data['lookups']['fueltypes'],
fig_path=path_out_plots,
path_temporal_elec_validation=path_temporal_elec_validation,
path_temporal_gas_validation=path_temporal_gas_validation,
regions=data['regions'],
plot_crit=plot_show)
def run_fig_spatial_distribution_of_peak(
scenarios,
path_to_folder_with_scenarios,
path_shapefile,
sim_yrs,
field_to_plot,
unit,
fig_path,
fueltype_str='electricity'
):
"""
"""
weather_yrs = []
calculated_yrs_paths = []
fueltype_int = tech_related.get_fueltype_int(fueltype_str)
for scenario in scenarios:
path_scenario = os.path.join(path_to_folder_with_scenarios, scenario)
all_result_folders = os.listdir(path_scenario)
for result_folder in all_result_folders:
try:
split_path_name = result_folder.split("__")
weather_yr = int(split_path_name[0])
weather_yrs.append(weather_yr)
tupyle_yr_path = (weather_yr, os.path.join(path_scenario))
calculated_yrs_paths.append(tupyle_yr_path)
except ValueError:
pass
for simulation_yr in sim_yrs:
container = {}
container['abs_demand_in_peak_h_pp'] = {}
container['abs_demand_in_peak_h'] = {}
container['p_demand_in_peak_h'] = {}
for weather_yr, path_data_ed in calculated_yrs_paths:
print("... prepare data {} {}".format(weather_yr, path_data_ed))
path_to_weather_yr = os.path.join(path_data_ed, "{}__{}".format(weather_yr, 'all_stations'))
data = {}
data['lookups'] = lookup_tables.basic_lookups()
data['enduses'], data['assumptions'], regions = data_loader.load_ini_param(os.path.join(path_data_ed))
data['assumptions']['seasons'] = date_prop.get_season(year_to_model=2015)
data['assumptions']['model_yeardays_daytype'], data['assumptions']['yeardays_month'], data['assumptions']['yeardays_month_days'] = date_prop.get_yeardays_daytype(year_to_model=2015)
# Population
population_data = read_data.read_scenaric_population_data(os.path.join(path_data_ed, 'model_run_pop'))
results_container = read_data.read_in_results(
os.path.join(path_to_weather_yr, 'model_run_results_txt'),
data['assumptions']['seasons'],
data['assumptions']['model_yeardays_daytype'])
# ---------------------------------------------------
# Calculate hour with national peak demand
# This may be different depending on the weather yr
# ---------------------------------------------------
ele_regions_8760 = results_container['ed_fueltype_regs_yh'][simulation_yr][fueltype_int]
sum_all_regs_fueltype_8760 = np.sum(ele_regions_8760, axis=0) # Sum for every hour
max_day = int(basic_functions.round_down((np.argmax(sum_all_regs_fueltype_8760) / 24), 1))
max_h = np.argmax(sum_all_regs_fueltype_8760)
max_demand = np.max(sum_all_regs_fueltype_8760)
# Calculate the national peak demand in GW
national_peak_GW = np.max(sum_all_regs_fueltype_8760)
# ------------------------------------------------------
# Calculate the contribution of the regional peak demand
# ------------------------------------------------------
demand_in_peak_h = ele_regions_8760[:, max_h]
if unit == 'GW':
container['abs_demand_in_peak_h'][weather_yr] = demand_in_peak_h
elif unit == 'kW':
container['abs_demand_in_peak_h'][weather_yr] = demand_in_peak_h * 1000000 # Convert to KWh
else:
# Use GW as default
container['abs_demand_in_peak_h'][weather_yr] = demand_in_peak_h
container['abs_demand_in_peak_h_pp'][weather_yr] = demand_in_peak_h / population_data[simulation_yr]
# Relative fraction of regional demand in relation to peak
container['p_demand_in_peak_h'][weather_yr] = (demand_in_peak_h / national_peak_GW ) * 100 # given as percent
print("=================================")
print("{} {} {} {}".format(
simulation_yr,
weather_yr,
np.sum(ele_regions_8760),
national_peak_GW))
# --------------
# Create dataframe with all weather yrs calculatiosn for every region
# region1, region2, region3
# weather yr1
# weather yr2
# --------------
# Convert regional data to dataframe
abs_demand_in_peak_h_pp = np.array(list(container['abs_demand_in_peak_h_pp'].values()))
abs_demand_peak_h = np.array(list(container['abs_demand_in_peak_h'].values()))
p_demand_peak_h = np.array(list(container['p_demand_in_peak_h'].values()))
# Absolute demand
df_abs_peak_demand = pd.DataFrame(
abs_demand_peak_h,
columns=regions,
index=list(container['abs_demand_in_peak_h'].keys()))
# Relative demand
df_p_peak_demand = pd.DataFrame(
p_demand_peak_h,
columns=regions,
index=list(container['p_demand_in_peak_h'].keys()))
df_abs_demand_in_peak_h_pp = pd.DataFrame(
abs_demand_in_peak_h_pp,
columns=regions,
index=list(container['abs_demand_in_peak_h_pp'].keys()))
# Absolute peak value - mean
max_peak_h_across_weather_yrs = df_abs_peak_demand.max()
average_across_weather_yrs = df_abs_peak_demand.mean()
diff_peak_h_minus_mean = max_peak_h_across_weather_yrs - average_across_weather_yrs
for index, row in df_p_peak_demand.iterrows():
print("Weather yr: {} Total p: {}".format(index, np.sum(row)))
assert round(np.sum(row), 4) == 100.0
# ----------------------------
# Calculate standard deviation
# ----------------------------
std_deviation_df_abs_demand_in_peak_h_pp = df_abs_demand_in_peak_h_pp.std()
std_deviation_abs_demand_peak_h = df_abs_peak_demand.std()
std_deviation_p_demand_peak_h = df_p_peak_demand.std()
print("=========")
print("National stats")
print("=========")
print("Sum of std of absolut peak demand: " + str(np.sum(std_deviation_abs_demand_peak_h)))
# --------------------
# Create map
# --------------------
regional_statistics_columns = [
'name',
'std_deviation_p_demand_peak_h',
'std_deviation_abs_demand_peak_h',
'std_deviation_df_abs_demand_in_peak_h_pp',
'diff_peak_h_minus_mean']
df_stats = pd.DataFrame(columns=regional_statistics_columns)
for region_name in regions:
# 'name', 'absolute_GW', 'p_GW_peak'
line_entry = [[
region_name,
std_deviation_p_demand_peak_h[region_name],
std_deviation_abs_demand_peak_h[region_name],
std_deviation_df_abs_demand_in_peak_h_pp[region_name],
diff_peak_h_minus_mean[region_name],
]]
line_df = pd.DataFrame(line_entry, columns=regional_statistics_columns)
df_stats = df_stats.append(line_df)
# Load uk shapefile
uk_shapefile = gpd.read_file(path_shapefile)
# Merge stats to geopanda
shp_gdp_merged = uk_shapefile.merge(
df_stats,
on='name')
# Assign projection
crs = {'init': 'epsg:27700'} #27700: OSGB_1936_British_National_Grid
uk_gdf = gpd.GeoDataFrame(shp_gdp_merged, crs=crs)
ax = uk_gdf.plot(
figsize=basic_plot_functions.cm2inch(25, 20))
nr_of_intervals = 6
bin_values = result_mapping.get_reasonable_bin_values_II(
data_to_plot=list(uk_gdf[field_to_plot]),
nr_of_intervals=nr_of_intervals)
# Maual bins
#bin_values = [0, 0.005, 0.01, 0.015, 0.02, 0.025, 0.03]
print(float(uk_gdf[field_to_plot].max()))
print("BINS " + str(bin_values))
uk_gdf, cmap_rgb_colors, color_zero, min_value, max_value = fig_p2_weather_val.user_defined_bin_classification(
uk_gdf,
field_to_plot,
bin_values=bin_values)
# plot with face color attribute
uk_gdf.plot(
ax=ax,
facecolor=uk_gdf['bin_color'],
edgecolor='black',
linewidth=0.5)
legend_handles = result_mapping.add_simple_legend(
bin_values,
cmap_rgb_colors,
color_zero)
plt.legend(
handles=legend_handles,
title="{} [{}]".format(field_to_plot, unit),
prop={'size': 8},
#loc='upper center', bbox_to_anchor=(0.5, -0.05),
loc='center left', bbox_to_anchor=(1, 0.5),
frameon=False)
# PLot bins on plot
'''plt.text(
-20,
-20,
bin_values[:-1], #leave away maximum value
fontsize=8)'''
plt.tight_layout()
fig_out_path = os.path.join(fig_path, str(field_to_plot) + "__" + str(simulation_yr) + ".pdf")
plt.savefig(fig_out_path)
def read_fuel_is(path_to_csv, fueltypes_nr):
"""This function reads in base_data_CSV all fuel types
Arguments
----------
path_to_csv : str
Path to csv file
fueltypes_nr : int
Number of fueltypes
Returns
-------
fuels : dict
Industry fuels
sectors : list
Industral sectors
enduses : list
Industrial enduses
Info
----
Source: User Guide Energy Consumption in the UK
https://www.gov.uk/government/uploads/system/uploads/attach
ment_data/file/573271/ECUK_user_guide_November_2016_final.pdf
https://unstats.un.org/unsd/cr/registry/regcst.asp?Cl=27
http://ec.europa.eu/eurostat/ramon/nomenclatures/
index.cfm?TargetUrl=LST_NOM_DTL&StrNom=NACE_REV2&StrLanguageCode=EN&IntPcKey=&StrLayoutCode=
High temperature processes
=============================
High temperature processing dominates energy consumption in the iron and steel,
non-ferrous metal, bricks, cement, glass and potteries industries. This includes
- coke ovens
- blast furnaces and other furnaces
- kilns and
- glass tanks.
Low temperature processes
=============================
Low temperature processes are the largest end use of energy for the food, drink
and tobacco industry. This includes:
- process heating and distillation in the chemicals sector;
- baking and separation processes in food and drink;
- pressing and drying processes, in paper manufacture;
- and washing, scouring, dyeing and drying in the textiles industry.
Drying/separation
=============================
Drying and separation is important in paper-making while motor processes are used
more in the manufacture of chemicals and chemical products than in any other
individual industry.
Motors
=============================
This includes pumping, fans and machinery drives.
Compressed air
=============================
Compressed air processes are mainly used in the publishing, printing and
reproduction of recorded media sub-sector.
Lighting
=============================
Lighting (along with space heating) is one of the main end uses in engineering
(mechanical and electrical engineering and vehicles industries).
Refrigeration
=============================
Refrigeration processes are mainly used in the chemicals and food and drink
industries.
Space heating
=============================
Space heating (along with lighting) is one of the main end uses in engineering
(mechanical and electrical engineering and vehicles industries).
Other
=============================
-----------------------
Industry classes from BEIS
-----------------------
SIC 2007 Name
-------- ------
08 Other mining and quarrying
10 Manufacture of food products
11 Manufacture of beverages
12 Manufacture of tobacco products
13 Manufacture of textiles
14 Manufacture of wearing apparel
15 Manufacture of leather and related products
16 Manufacture of wood and of products of wood and cork, except furniture; manufacture of articles of straw and plaiting materials
17 Manufacture of paper and paper products
18 Printing and publishing of recorded media and other publishing activities
20 Manufacture of chemicals and chemical products
21 Manufacture of basic pharmaceutical products and pharmaceutical preparations
22 Manufacture of rubber and plastic products
23 Manufacture of other non-metallic mineral products
24 Manufacture of basic metals
25 Manufacture of fabricated metal products, except machinery and equipment
26 Manufacture of computer, electronic and optical products
27 Manufacture of electrical equipment
28 Manufacture of machinery and equipment n.e.c.
29 Manufacture of motor vehicles, trailers and semi-trailers
30 Manufacture of other transport equipment
31 Manufacture of furniture
32 Other manufacturing
36 Water collection, treatment and supply
38 Waste collection, treatment and disposal activities; materials recovery
"""
rows_list = []
fuels = {}
'''# Read csv
raw_csv_file = pd.read_csv(path_to_csv)
# Replace NaN with " " values
raw_csv_file = raw_csv_file.fillna(0)
# Enduses
enduses = list(raw_csv_file.columns.values)'''
with open(path_to_csv, 'r') as csvfile:
rows = csv.reader(csvfile, delimiter=',')
headings = next(rows)
_secondline = next(rows)
# All sectors
enduses = set([])
for enduse in headings[1:]:
if enduse is not '':
enduses.add(enduse)
# All enduses
sectors = set([])
for row in rows:
rows_list.append(row)
sectors.add(row[0])
# Initialise dict
for enduse in enduses:
fuels[enduse] = {}
for sector in sectors:
fuels[str(enduse)][str(sector)] = np.zeros(
(fueltypes_nr), dtype="float")
for row in rows_list:
sector = row[0]
for position, entry in enumerate(row[1:], 1): # Start with position 1
if entry != '':
enduse = str(headings[position])
fueltype = _secondline[position]
fueltype_int = tech_related.get_fueltype_int(fueltype)
fuels[enduse][sector][fueltype_int] += float(row[position])
return fuels, list(sectors), list(enduses)
def read_in_weather_results(path_result, seasons, model_yeardays_daytype,
fueltype_str):
"""Read and post calculate results from txt files
and store into container
Arguments
---------
path_result : str
Paths
seasons : dict
seasons
model_yeardays_daytype : dict
Daytype of modelled yeardays
"""
logging.info("... Reading in results")
fueltype_int = tech_related.get_fueltype_int(fueltype_str)
results_container = {}
# -----------------
# Read in demands
# -----------------
# Read in total regional demands per fueltype
results_container['ed_reg_tot_y'] = read_data.read_results_yh(
path_result, 'only_total')
#print(results_container['ed_reg_tot_y'][2015].shape)
results_container['ed_reg_peakday'] = read_data.read_results_yh(
os.path.join('simulation_results', path_result), 'only_peak')
#print(results_container['ed_reg_peakday'][2015].shape)
results_container['ed_reg_peakday_peak_hour'] = {}
results_container['national_peak'] = {}
results_container['regional_share_national_peak'] = {}
results_container['national_all_fueltypes'] = {}
for year in results_container['ed_reg_peakday']:
# Get peak demand of each region
results_container['ed_reg_peakday_peak_hour'][
year] = results_container['ed_reg_peakday'][year].max(axis=2)
# Get national peak
national_demand_per_hour = results_container['ed_reg_peakday'][
year].sum(axis=1) #Aggregate hourly across all regions
# Get maximum hour for electricity demand
max_hour = national_demand_per_hour[fueltype_int].argmax()
results_container['national_peak'][
year] = national_demand_per_hour[:, max_hour]
# Calculate regional share of peak hour to national peak
national_peak = results_container['national_peak'][year][fueltype_int]
regional_peak = results_container['ed_reg_peakday'][year][
fueltype_int][:, max_hour]
results_container['regional_share_national_peak'][year] = (
100 / national_peak) * regional_peak #1 = 1 %
# Sum all regions for each fueltypes
#print(results_container['ed_reg_tot_y'][year].shape)
results_container['national_all_fueltypes'][year] = np.sum(
results_container['ed_reg_tot_y'][year], axis=1)
#print(results_container['national_all_fueltypes'][year].shape)
logging.info("... Reading in results finished")
return results_container
