def run(name_fig, path_result, ed_yh, days_to_plot=365, plot_crit=False): """Plot individual enduse """ ed_yh_365 = np.copy(ed_yh.reshape(365, 24)) nr_of_h_to_plot = len(days_to_plot) * 24 x_data = range(nr_of_h_to_plot) y_calculated = [] for day in days_to_plot: for hour in range(24): y_calculated.append(ed_yh_365[day][hour]) # ---------- # Plot figure # ---------- fig = plt.figure(figsize=basic_plot_functions.cm2inch(16, 8)) plt.plot(x_data, y_calculated, label='model', linestyle='--', linewidth=0.5, fillstyle='full', color='blue') plt.xlim([0, 8760]) plt.margins(x=0) plt.axis('tight') # ---------- # Labelling # ---------- plt.xlabel("hour", fontsize=10) plt.ylabel("uk elec use [GW]", fontsize=10) plt.legend(frameon=False) plt.savefig(os.path.join(path_result, name_fig)) if plot_crit: plt.show() plt.close() else: plt.close()
def plot_cross_graphs(base_yr, comparison_year, regions, ed_year_fueltype_regs_yh, reg_load_factor_y, fueltype_int, fueltype_str, fig_name, label_points, plotshow): result_dict = defaultdict(dict) # ------------------------------------------- # Get base year modelled demand # ------------------------------------------- for year, fuels in ed_year_fueltype_regs_yh.items(): if year == base_yr: for reg_nr, reg_geocode in enumerate(regions): result_dict['demand_by'][reg_geocode] = np.sum( fuels[fueltype_int][reg_nr]) result_dict['peak_h_demand_by'][reg_geocode] = np.max( fuels[fueltype_int][reg_nr]) # Demand across all regs result_dict['demand_by_all_regs'] = np.sum(fuels[fueltype_int]) # Peak demand fuel_all_reg_yh = np.sum(fuels[fueltype_int], axis=0) # Sum across all regions result_dict['peak_h_demand_by_all_regs'] = np.max(fuel_all_reg_yh) # Calculate national load factor fuel_all_fueltype_reg_yh = np.sum( fuels, axis=1) # Sum across all regions per fueltype load_factor_y = load_factors.calc_lf_y(fuel_all_fueltype_reg_yh) result_dict['lf_by_all_regs_av'] = load_factor_y[fueltype_int] elif year == comparison_year: for reg_nr, reg_geocode in enumerate(regions): result_dict['demand_cy'][reg_geocode] = np.sum( fuels[fueltype_int][reg_nr]) result_dict['peak_h_demand_cy'][reg_geocode] = np.max( fuels[fueltype_int][reg_nr]) # Demand across all regs result_dict['demand_cy_all_regs'] = np.sum(fuels[fueltype_int]) # Peak demand fuel_all_reg_yh = np.sum(fuels[fueltype_int], axis=0) # Sum across all regions result_dict['peak_h_demand_cy_all_regs'] = np.max(fuel_all_reg_yh) # Calculate national load factor fuel_all_fueltype_reg_yh = np.sum( fuels, axis=1) # Sum across all regions per fueltype load_factor_y = load_factors.calc_lf_y(fuel_all_fueltype_reg_yh) result_dict['lf_cy_all_regs_av'] = load_factor_y[fueltype_int] else: pass # Get load factor result_dict['lf_cy'] = {} result_dict['lf_by'] = {} for year, lf_fueltype_regs in reg_load_factor_y.items(): print("lf_fueltype_regs") print(lf_fueltype_regs.shape) if year == base_yr: for reg_nr, reg_geocode in enumerate(regions): result_dict['lf_by'][reg_geocode] = lf_fueltype_regs[ fueltype_int][reg_nr] elif year == comparison_year: for reg_nr, reg_geocode in enumerate(regions): result_dict['lf_cy'][reg_geocode] = lf_fueltype_regs[ fueltype_int][reg_nr] else: pass labels = [] #Base year x_values, y_values = [], [] x_values_0_quadrant, y_values_0_quadrant = [], [] x_values_1_quadrant, y_values_1_quadrant = [], [] x_values_2_quadrant, y_values_2_quadrant = [], [] x_values_3_quadrant, y_values_3_quadrant = [], [] for reg_nr, reg_geocode in enumerate(regions): # Change in load factor lf_change_p = ((100 / result_dict['lf_by'][reg_geocode]) * result_dict['lf_cy'][reg_geocode]) - 100 # Change in peak h deman demand_peak_h_p = ( (100 / result_dict['peak_h_demand_by'][reg_geocode]) * result_dict['peak_h_demand_cy'][reg_geocode]) - 100 # Change in total regional demand tot_demand_p = ((100 / result_dict['demand_by'][reg_geocode]) * result_dict['demand_cy'][reg_geocode]) - 100 x_values.append(lf_change_p) #y_values.append(tot_demand_p) y_values.append(demand_peak_h_p) labels.append(reg_geocode) if lf_change_p < 0 and tot_demand_p > 0: x_values_0_quadrant.append(lf_change_p) y_values_0_quadrant.append(tot_demand_p) elif lf_change_p > 0 and tot_demand_p > 0: x_values_1_quadrant.append(lf_change_p) y_values_1_quadrant.append(tot_demand_p) elif lf_change_p > 0 and tot_demand_p < 0: x_values_2_quadrant.append(lf_change_p) y_values_2_quadrant.append(tot_demand_p) else: x_values_3_quadrant.append(lf_change_p) y_values_3_quadrant.append(tot_demand_p) # Add average national_tot_cy_p = ((100 / result_dict['lf_by_all_regs_av']) * result_dict['lf_cy_all_regs_av']) - 100 #national_tot_demand_p = ((100 / result_dict['demand_by_all_regs']) * result_dict['demand_cy_all_regs']) - 100 national_peak_h_p = ((100 / result_dict['peak_h_demand_by_all_regs']) * result_dict['peak_h_demand_cy_all_regs']) - 100 x_val_national_lf_demand_cy = [national_tot_cy_p] #y_val_national_lf_demand_cy = [national_tot_demand_p] y_val_national_lf_demand_cy = [national_peak_h_p] # ------------------------------------- # Plot # ------------------------------------- fig = plt.figure(figsize=basic_plot_functions.cm2inch(9, 8)) #width, height ax = fig.add_subplot(1, 1, 1) ax.scatter(x_values_0_quadrant, y_values_0_quadrant, alpha=0.6, color='rosybrown', s=8) ax.scatter(x_values_1_quadrant, y_values_1_quadrant, alpha=0.6, color='firebrick', s=8) ax.scatter(x_values_2_quadrant, y_values_2_quadrant, alpha=0.6, color='forestgreen', s=8) ax.scatter(x_values_3_quadrant, y_values_3_quadrant, alpha=0.6, color='darkolivegreen', s=8) # Add average ax.scatter(x_val_national_lf_demand_cy, y_val_national_lf_demand_cy, alpha=1.0, color='black', s=20, marker="v", linewidth=0.5, edgecolor='black', label='national') # -------- # Axis # -------- ax.set_xlabel("load factor change (%) {}".format(fueltype_str)) ax.set_ylabel("change in peak h (%) {}".format(fueltype_str)) plt.tick_params( axis='x', # changes apply to the x-axis which='both', # both major and minor ticks are affected bottom='on', # ticks along the bottom edge are off top='off', # ticks along the top edge are off labelbottom='on') # labels along the bottom edge are off # -------- # Grd # -------- ax.set_axisbelow(True) ax.set_xticks([0], minor=True) ax.set_yticks([0], minor=True) ax.yaxis.grid(True, which='minor', linewidth=0.7, color='grey', linestyle='--') ax.xaxis.grid(True, which='minor', linewidth=0.7, color='grey', linestyle='--') # Limit #plt.ylim(ymin=0) # ----------- # Labelling # ----------- if label_points: for pos, txt in enumerate(labels): ax.text(x_values[pos], y_values[pos], txt, horizontalalignment="right", verticalalignment="top", fontsize=6) # -------- # Legend # -------- '''legend( loc=3, prop={ 'family': 'arial', 'size': 8}, frameon=False)''' # Tight layout plt.margins(x=0) plt.tight_layout() plt.savefig(fig_name) if plotshow: plt.show() plt.close()
def plot_tot_fueltype_y_over_time(scenario_data, fueltypes, fueltypes_to_plot, fig_name, txt_name, plotshow=False): """Plot total demand over simulation period for every scenario for all regions """ results_txt = [] # Set figure size fig = plt.figure(figsize=basic_plot_functions.cm2inch(9, 8)) ax = fig.add_subplot(1, 1, 1) y_scenario = {} for scenario_name, scen_data in scenario_data.items(): # Read out fueltype specific max h load data_years = {} for year, fueltype_reg_time in scen_data['ed_fueltype_regs_yh'].items( ): # Sum all regions tot_gwh_fueltype_yh = np.sum(fueltype_reg_time, axis=1) # Sum all hours tot_gwh_fueltype_y = np.sum(tot_gwh_fueltype_yh, axis=1) # Convert to TWh tot_gwh_fueltype_y = conversions.gwh_to_twh(tot_gwh_fueltype_y) data_years[year] = tot_gwh_fueltype_y y_scenario[scenario_name] = data_years # ----------------- # Axis # ----------------- base_yr, year_interval = 2020, 10 first_scen = list(y_scenario.keys())[0] end_yr = list(y_scenario[first_scen].keys()) major_ticks = np.arange(base_yr, end_yr[-1] + year_interval, year_interval) plt.xticks(major_ticks, major_ticks) # ---------- # Plot lines # ---------- #color_list_selection_fueltypes = plotting_styles.color_list_selection() color_list_selection = plotting_styles.color_list_scenarios() linestyles = ['--', '-', ':', "-.", ".-"] #linestyles = plotting_styles.linestyles() cnt_scenario = -1 for scenario_name, fuel_fueltype_yrs in y_scenario.items(): cnt_scenario += 1 color = color_list_selection[cnt_scenario] cnt_linestyle = -1 for fueltype_str, fueltype_nr in fueltypes.items(): if fueltype_str in fueltypes_to_plot: cnt_linestyle += 1 # Get fuel per fueltpye for every year fuel_fueltype = [] for entry in list(fuel_fueltype_yrs.values()): fuel_fueltype.append(entry[fueltype_nr]) plt.plot( list(fuel_fueltype_yrs.keys()), # years fuel_fueltype, # yearly data per fueltype color=color, linestyle=linestyles[cnt_linestyle], label="{}_{}".format(scenario_name, fueltype_str)) # --- # Calculate difference in demand from 2015 - 2050 # --- tot_2015 = fuel_fueltype[0] tot_2050 = fuel_fueltype[-1] diff_abs = tot_2050 - tot_2015 p_diff_2015_2015 = ((100 / tot_2015) * tot_2050) - 100 # Diff txt = "fueltype_str: {} ed_tot_by: {} ed_tot_cy: {}, diff_p: {}, diff_abs: {} scenario: {}".format( fueltype_str, round(tot_2015, 1), round(tot_2050, 1), round(p_diff_2015_2015, 1), round(diff_abs, 1), scenario_name) results_txt.append(txt) # -------------------------- # Save model results to txt # -------------------------- write_data.write_list_to_txt(txt_name, results_txt) # ---- # Axis # ---- plt.ylim(ymin=0) # ------------ # Plot legend # ------------ ax.legend(ncol=2, frameon=False, loc='upper center', prop={ 'family': 'arial', 'size': 4 }, bbox_to_anchor=(0.5, -0.1)) # --------- # Labels # --------- font_additional_info = plotting_styles.font_info(size=5) plt.ylabel("TWh") plt.xlabel("year") # Tight layout plt.tight_layout() plt.margins(x=0) plt.savefig(fig_name) if plotshow: plt.show() plt.close()
def plot_tot_y_peak_hour(scenario_data, fig_name, fueltype_str_input, plotshow=False): """Plot fueltype specific peak h of all regions """ plt.figure(figsize=basic_plot_functions.cm2inch(14, 8)) # ----------------- # Axis # ----------------- base_yr, year_interval = 2015, 5 first_scen = list(scenario_data.keys())[0] end_yr = list(scenario_data[first_scen]['ed_peak_h'].keys())[-1] major_ticks = np.arange(base_yr, end_yr + year_interval, year_interval) plt.xticks(major_ticks, major_ticks) # ---------- # Plot lines # ---------- color_list_selection = plotting_styles.color_list_selection() for scenario_name, fuel_fueltype_yrs in scenario_data.items(): data_container = [] for year, fuel_fueltypes in fuel_fueltype_yrs['ed_peak_h'].items(): data_container.append(fuel_fueltypes[fueltype_str_input]) # Calculate max peak in end year peak_gw = round(data_container[-1], 1) peak_p = round((100 / data_container[0]) * data_container[-1], 1) # Label label_scenario = "{} (peak: GW {} p: {})".format( scenario_name, peak_gw, peak_p) plt.plot( list(fuel_fueltype_yrs['ed_peak_h'].keys()), # years list(data_container), # yearly data color=str(color_list_selection.pop()), label=label_scenario) #scenario_name) # ---- # Axis # ---- plt.ylim(ymin=0) # ------------ # Plot legend # ------------ plt.legend(ncol=1, loc=3, prop={ 'family': 'arial', 'size': 8 }, frameon=False) # --------- # Labels # --------- plt.ylabel("GWh") plt.xlabel("year") plt.title("peak_h {} [GW]".format(fueltype_str_input)) # Tight layout plt.tight_layout() plt.margins(x=0) plt.savefig(fig_name) if plotshow: plt.show() plt.close() else: plt.close()
def plot_radar_plot_multiple_lines(dh_profiles, fig_name, plot_steps, scenario_names, plotshow=False, lf_y_by=None, lf_y_cy=None, list_diff_max_h=None): """Plot daily load profile on a radar plot Arguments --------- dh_profile : list Dh values to plot fig_name : str Path to save figure SOURCE: https://python-graph-gallery.com/390-basic-radar-chart/ """ fig = plt.figure(figsize=basic_plot_functions.cm2inch(9, 14)) # Get maximum demand of all lines max_entry = 0 for line_entries in dh_profiles: max_in_line = max(line_entries) if max_in_line > max_entry: max_entry = max_in_line max_demand = round(max_entry, -1) + 10 # Round to nearest 10 plus add 10 nr_of_plot_steps = int(max_demand / plot_steps) + 1 axis_plots_inner = [] axis_plots_innter_position = [] # -------------------- # Ciruclar axis # -------------------- for i in range(nr_of_plot_steps): axis_plots_inner.append(plot_steps * i) axis_plots_innter_position.append(str(plot_steps * i)) # Minor ticks minor_tick_interval = plot_steps / 2 minor_ticks = [] for i in range(nr_of_plot_steps * 2): minor_ticks.append(minor_tick_interval * i) # ---- # Select color scheme # ---- # Colors with scenarios #color_scenarios = plotting_styles.color_list_scenarios() #Color scheme Fig 13 # Colors for plotting Fig. 13 #color_scenarios = plotting_styles.color_list_selection_dm() # Color scheme Fig 13 # Color sheme multiple scenarios color_scenarios = ['orange', 'darkred', '#3b2c85', '#85cfcb'] #Lines for Fig 12 color_lines = ['black'] + color_scenarios #color_lines = color_scenarios years = ['2015', '2050'] linewidth_list = [1.0, 0.7] linestyle_list = ['-', '--'] scenario_names.insert(0, "any") # Iterate lines cnt = -1 for dh_profile in dh_profiles: if cnt >= 0: cnt_year = 1 else: cnt_year = 0 cnt += 1 # Line properties color_line = color_lines[cnt] year_line = years[cnt_year] data = {'dh_profile': ['testname']} # Key: Label outer circle for hour in range(24): data[hour] = dh_profile[hour] # Set data df = pd.DataFrame(data) # number of variable categories = list(df)[1:] N = len(categories) # We are going to plot the first line of the data frame. # But we need to repeat the first value to close the circular graph: values = df.loc[0].drop('dh_profile').values.flatten().tolist() values += values[:1] # What will be the angle of each axis in the plot? (we divide the plot / number of variable) angles = [n / float(N) * 2 * math.pi for n in range(N)] angles += angles[:1] # Initialise the spider plot ax = plt.subplot(111, polar=True) # Change axis properties ax.yaxis.grid(color='grey', linestyle=':', linewidth=0.4) ax.xaxis.grid(color='lightgrey', linestyle=':', linewidth=0.4) # Change to clockwise cirection ax.set_theta_direction(-1) # Set first hour on top ax.set_theta_zero_location("N") # Draw one axe per variable + add labels labels yet (numbers) plt.xticks(angles[:-1], categories, color='black', size=8) # Draw ylabels (numbers) ax.set_rlabel_position(0) # Working alternative plt.yticks(axis_plots_inner, axis_plots_innter_position, color="black", size=8) #ax.set_yticks(axis_plots_inner, minor=False) #ax.tick_params(axis='y', pad=35) #ax.set_yticks(minor_ticks, minor=True) #Somehow not working # Set limit to size plt.ylim(0, max_demand) plt.ylim(0, nr_of_plot_steps * plot_steps) # Smooth lines angles_smoothed, values_smoothed = basic_plot_functions.smooth_data( angles, values, spider=True) # Plot data ax.plot(angles_smoothed, values_smoothed, color=color_line, linestyle=linestyle_list[cnt_year], linewidth=linewidth_list[cnt_year], label="{} {}".format(year_line, scenario_names[cnt])) # Radar area ax.fill(angles_smoothed, values_smoothed, color_line, alpha=0.05) # ------------ # Write outs # ------------ font_additional_info = plotting_styles.font_info(size=4) for cnt, entry in enumerate(list_diff_max_h): plt.text(0.15, 0 + cnt / 50, entry, fontsize=2, fontdict=font_additional_info, transform=plt.gcf().transFigure) # ------------ # Legend # ------------ plt.legend(ncol=1, bbox_to_anchor=(0.3, -0.05), prop={'size': 4}, frameon=False) plt.savefig(fig_name) if plotshow: plt.show() plt.close()
def run(path_to_weather_data, folder_path_weater_stations, path_shapefile, fig_path): """ """ # ---------------------------------------------------------- # Iterate all calculated weather stations # ---------------------------------------------------------- weather_yrs_stations = read_weather_data.get_all_station_per_weather_yr( path_to_weather_data) weather_station_coordinates = data_loader.read_weather_stations_raw( folder_path_weater_stations) # ---------------------------------------------------------- # Station nr and how many times over simulation period # ---------------------------------------------------------- station_counting_over_yr = {} for weather_yr, stations in weather_yrs_stations.items(): for station in stations: try: station_counting_over_yr[station].append(weather_yr) except: station_counting_over_yr[station] = [weather_yr] # Count number of years for station in station_counting_over_yr: station_counting_over_yr[station] = len( station_counting_over_yr[station]) # ---------------------------------------------------------- # Create dataframe #{station_id: all_weather_stations[weather_yr][station_id]} #df = pd.DataFrame({'src_id': [...], 'longitude': [...], 'latitude': [...]}) # ---------------------------------------------------------- stations_as_dict = {} for station_id in station_counting_over_yr: try: stations_as_dict[station_id] = { 'longitude': weather_station_coordinates[station_id]['longitude'], 'latitude': weather_station_coordinates[station_id]['latitude'], 'nr_of_weather_yrs': station_counting_over_yr[station_id] } except: print("The station nr {} coul not be found".format(station_id)) df = pd.DataFrame.from_dict(stations_as_dict, orient='index') df['Coordinates'] = list(zip(df.longitude, df.latitude)) df['Coordinates'] = df['Coordinates'].apply(Point) # Load uk shapefile uk_shapefile = gpd.read_file(path_shapefile) # Assign correct projection crs = {'init': 'epsg:27700'} #27700 == OSGB_1936_British_National_Grid uk_gdf = gpd.GeoDataFrame(uk_shapefile, crs=crs) # Plot ax = uk_gdf.plot(linewidth=0.3, color='whitesmoke', edgecolor='black', figsize=basic_plot_functions.cm2inch(25, 20)) # plot coordinates crs = {'init': 'epsg:4326'} gdf = gpd.GeoDataFrame(df, geometry='Coordinates', crs=crs) gdf = gdf.to_crs({'init': 'epsg:27700'}) field_to_plot = 'nr_of_weather_yrs' nr_of_intervals = 6 bin_values = result_mapping.get_reasonable_bin_values_II( data_to_plot=list(gdf[field_to_plot]), nr_of_intervals=nr_of_intervals) print("BINS " + str(bin_values)) gdf, cmap_rgb_colors, color_zero, min_value, max_value = fig_p2_weather_val.user_defined_bin_classification( gdf, field_to_plot, bin_values=bin_values, cmap_sequential='PuRd') #'Reds') # plot with face color attribute gdf.plot(ax=ax, markersize=20, facecolor=gdf['bin_color'], edgecolor='black', linewidth=0.3) legend_handles = result_mapping.add_simple_legend(bin_values, cmap_rgb_colors, color_zero, patch_form='circle') plt.legend(handles=legend_handles, title=str(field_to_plot), prop={'size': 8}, loc='center left', bbox_to_anchor=(1, 0.5), frameon=False) try: os.remove(fig_path) except: pass plt.savefig(fig_path) #def plot_map_
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 compare_results(name_fig, path_result, y_factored_indo, y_calculated_array, title_left, days_to_plot, plot_crit=False): """Compare national electrictiy demand data with model results Note ---- RMSE fit criteria : Lower values of RMSE indicate better fit https://stackoverflow.com/questions/17197492/root-mean-square-error-in-python https://matplotlib.org/examples/lines_bars_and_markers/marker_fillstyle_reference.html """ logging.debug("...compare elec results") nr_of_h_to_plot = len(days_to_plot) * 24 x_data = range(nr_of_h_to_plot) y_real_indo_factored = [] y_calculated_list = [] y_diff_p = [] y_diff_abs = [] for day in days_to_plot: for hour in range(24): y_calculated_list.append(y_calculated_array[day][hour]) y_real_indo_factored.append(y_factored_indo[day][hour]) # Calculate absolute differences abs_diff = abs(y_factored_indo[day][hour] - y_calculated_array[day][hour]) y_diff_abs.append(abs_diff) # Calculate difference in percent if abs_diff == 0: p_diff = 0 else: p_diff = (100 / y_factored_indo[day][hour] ) * y_calculated_array[day][hour] - 100 y_diff_p.append(p_diff) # ------------- # RMSE # ------------- rmse_val_corrected = basic_functions.rmse(np.array(y_real_indo_factored), np.array(y_calculated_list)) # ---------- # Standard deviation # ---------- standard_dev_real_modelled = np.std(y_diff_p) # Differences in % standard_dev_real_modelled_abs = np.std(y_diff_abs) # Absolute differences logging.info("Standard deviation given as percentage: " + str(standard_dev_real_modelled)) logging.info("Standard deviation given as GW: " + str(standard_dev_real_modelled_abs)) # --------- # R squared # --------- slope, intercept, r_value, p_value, std_err = stats.linregress( y_real_indo_factored, y_calculated_list) # ---------- # Plot residuals # ---------- #try: # plot_residual_histogram( # y_diff_p, path_result, "residuals_{}".format(name_fig)) #except: # pass # ---------- # Plot figure # ---------- fig = plt.figure(figsize=basic_plot_functions.cm2inch(22, 8)) # smooth line x_data_smoothed, y_real_indo_factored_smoothed = basic_plot_functions.smooth_data( x_data, y_real_indo_factored, num=40000) # plot points plt.plot(x_data_smoothed, y_real_indo_factored_smoothed, label='indo_factored', linestyle='-', linewidth=0.5, fillstyle='full', color='black') # smooth line x_data_smoothed, y_calculated_list_smoothed = basic_plot_functions.smooth_data( x_data, y_calculated_list, num=40000) plt.plot(x_data_smoothed, y_calculated_list_smoothed, label='model', linestyle='--', linewidth=0.5, fillstyle='full', color='blue') plt.xlim([0, 8760]) plt.margins(x=0) plt.axis('tight') # -------------------------------------- # Label x axis in dates # -------------------------------------- major_ticks_days, major_ticks_labels = get_date_strings(days_to_plot, daystep=1) plt.xticks(major_ticks_days, major_ticks_labels) # ---------- # Labelling # ---------- font_additional_info = plotting_styles.font_info(size=4) plt.title('RMSE: {} Std_dev_% {} (+-{} GW) R_2: {}'.format( round(rmse_val_corrected, 3), round(standard_dev_real_modelled, 3), round(standard_dev_real_modelled_abs, 3), round(r_value, 3)), fontdict=font_additional_info, loc='right') plt.title(title_left, loc='left') plt.xlabel("hour", fontsize=10) plt.ylabel("uk elec use [GW] for {}".format(title_left), fontsize=10) plt.legend(frameon=False) plt.savefig(os.path.join(path_result, name_fig)) if plot_crit: plt.show() plt.close()
def scenario_over_time( scenario_result_container, field_name, sim_yrs, fig_name, result_path, plot_points, crit_smooth_line=True, seperate_legend=False ): """Plot peak over time """ statistics_to_print = [] fig = plt.figure(figsize=basic_plot_functions.cm2inch(10, 10)) #width, height ax = fig.add_subplot(1, 1, 1) for cnt_scenario, i in enumerate(scenario_result_container): scenario_name = i['scenario_name'] national_peak = i[field_name] # dataframe with national peak (columns= simulation year, row: Realisation) # Calculate quantiles #quantile_95 = 0.68 #0.95 #0.68 #quantile_05 = 0.32 #0.05 #0.32 try: color = colors[scenario_name] marker = marker_styles[scenario_name] except KeyError: color = list(colors.values())[cnt_scenario] try: marker = marker_styles[scenario_name] except KeyError: marker = list(marker_styles.values())[cnt_scenario] #print("SCENARIO NAME {} {}".format(scenario_name, color)) # Calculate average across all weather scenarios mean_national_peak = national_peak.mean(axis=0) mean_national_peak_sim_yrs = copy.copy(mean_national_peak) statistics_to_print.append("scenario: {} values over years: {}".format(scenario_name, mean_national_peak_sim_yrs)) # Standard deviation over all realisations #df_q_05 = national_peak.quantile(quantile_05) #df_q_95 = national_peak.quantile(quantile_95) # Number of sigma nr_of_sigma = 1 std_dev = national_peak.std(axis=0) two_std_line_pos = mean_national_peak + (nr_of_sigma * std_dev) two_std_line_neg = mean_national_peak - (nr_of_sigma * std_dev) # Maximum and minium values max_values = national_peak.max() min_values = national_peak.min() median_values = national_peak.median() statistics_to_print.append("scenario: {} two_sigma_pos: {}".format(scenario_name, two_std_line_pos)) statistics_to_print.append("scenario: {} two_sigma_neg: {}".format(scenario_name, two_std_line_neg)) statistics_to_print.append("--------min-------------- {}".format(scenario_name)) statistics_to_print.append("{}".format(min_values)) #Get minimum value for every simulation year of all realizations statistics_to_print.append("--------max-------------- {}".format(scenario_name)) statistics_to_print.append("{}".format(max_values)) statistics_to_print.append("--------median_-------------- {}".format(scenario_name)) statistics_to_print.append("{}".format(median_values)) # -------------------- # Try to smooth lines # -------------------- sim_yrs_smoothed = sim_yrs if crit_smooth_line: try: sim_yrs_smoothed, mean_national_peak_smoothed = basic_plot_functions.smooth_data(sim_yrs, mean_national_peak, num=40000) #_, df_q_05_smoothed = basic_plot_functions.smooth_data(sim_yrs, df_q_05, num=40000) #_, df_q_95_smoothed = basic_plot_functions.smooth_data(sim_yrs, df_q_95, num=40000) _, two_std_line_pos_smoothed = basic_plot_functions.smooth_data(sim_yrs, two_std_line_pos, num=40000) _, two_std_line_neg_smoothed = basic_plot_functions.smooth_data(sim_yrs, two_std_line_neg, num=40000) _, max_values_smoothed = basic_plot_functions.smooth_data(sim_yrs, max_values, num=40000) _, min_values_smoothed = basic_plot_functions.smooth_data(sim_yrs, min_values, num=40000) mean_national_peak = pd.Series(mean_national_peak_smoothed, sim_yrs_smoothed) #df_q_05 = pd.Series(df_q_05_smoothed, sim_yrs_smoothed) #df_q_95 = pd.Series(df_q_95_smoothed, sim_yrs_smoothed) two_std_line_pos = pd.Series(two_std_line_pos_smoothed, sim_yrs_smoothed) two_std_line_neg = pd.Series(two_std_line_neg_smoothed, sim_yrs_smoothed) max_values = pd.Series(max_values_smoothed, sim_yrs_smoothed).values min_values = pd.Series(min_values_smoothed, sim_yrs_smoothed).values except: sim_yrs_smoothed = sim_yrs # ----------------------- # Plot lines # ------------------------ plt.plot( mean_national_peak, label="{} (mean)".format(scenario_name), zorder=1, color=color) # ------------------------ # Plot markers # ------------------------ if plot_points: plt.scatter( sim_yrs, mean_national_peak_sim_yrs, c=color, marker=marker, edgecolor='black', linewidth=0.5, zorder=2, s=15, clip_on=False) #do not clip points on axis # ------------------ # Start with uncertainty one model step later (=> 2020) # ------------------ start_yr_uncertainty = 2020 if crit_smooth_line: #Get position in array of start year uncertainty pos_unc_yr = len(np.where(sim_yrs_smoothed < start_yr_uncertainty)[0]) else: pos_unc_yr = 0 for cnt, year in enumerate(sim_yrs_smoothed): if year == start_yr_uncertainty: pos_unc_yr = cnt # select based on index which is year #df_q_05 = df_q_05.loc[start_yr_uncertainty:] #df_q_95 = df_q_95.loc[start_yr_uncertainty:] two_std_line_pos = two_std_line_pos.loc[start_yr_uncertainty:] two_std_line_neg = two_std_line_neg.loc[start_yr_uncertainty:] sim_yrs_smoothed = sim_yrs_smoothed[pos_unc_yr:] min_values = min_values[pos_unc_yr:] #min_values.loc[start_yr_uncertainty:] max_values = max_values[pos_unc_yr:] #max_values.loc[start_yr_uncertainty:] # -------------------------------------- # Plottin qunatilse and average scenario # -------------------------------------- #df_q_05.plot.line(color=color, linestyle='--', linewidth=0.1, label='_nolegend_') #df_q_95.plot.line(color=color, linestyle='--', linewidth=0.1, label='_nolegend_') # Plot standard deviation #two_std_line_pos.plot.line(color=color, linestyle='--', linewidth=0.1, label='_nolegend_') #two_std_line_neg.plot.line(color=color, linestyle='--', linewidth=0.1, label='_nolegend_') # plot min and maximum values plt.plot(sim_yrs_smoothed, min_values, color=color, linestyle='--', linewidth=0.3, label='_nolegend_') plt.plot(sim_yrs_smoothed, max_values, color=color, linestyle='--', linewidth=0.3, label='_nolegend_') plt.fill_between( sim_yrs_smoothed, list(two_std_line_pos), list(two_std_line_neg), alpha=0.25, facecolor=color) plt.xlim(2015, 2050) plt.ylim(0) # -------- # Different style # -------- ax = plt.gca() ax.grid(which='major', color='black', axis='y', linestyle='--') ax.spines['right'].set_visible(False) ax.spines['left'].set_visible(False) ax.spines['top'].set_visible(False) plt.tick_params( axis='y', # changes apply to the x-axis which='both', # both major and minor ticks are affected bottom=False, # ticks along the bottom edge are off top=False, # ticks along the top edge are off left=False, right=False, labelbottom=False, labeltop=False, labelleft=True, labelright=False) # labels along the bottom edge are off # -------- # Legend # -------- legend = plt.legend( ncol=2, prop={'size': 10}, loc='upper center', bbox_to_anchor=(0.5, -0.1), frameon=False) legend.get_title().set_fontsize(8) if seperate_legend: basic_plot_functions.export_legend( legend, os.path.join(result_path, "{}__legend.pdf".format(fig_name[:-4]))) legend.remove() # -------- # Labeling # -------- plt.ylabel("national peak demand (GW)") plt.tight_layout() plt.savefig(os.path.join(result_path, fig_name)) plt.close() # Write info to txt write_data.write_list_to_txt( os.path.join(result_path, fig_name).replace(".pdf", ".txt"), statistics_to_print)
def plot_std_dev_vs_contribution( scenario_result_container, sim_yrs, fig_name, fueltypes, result_path, plot_points=False, path_shapefile_input=False, unit='TWh', crit_smooth_line=True, seperate_legend=False): colors = { 2020: 'dimgrey', 2050: 'forestgreen' } #plot_numbers = { # 'h_max': {'row': 0, 'col': 0}, # 'h_min': {'row': 0, 'col': 1}, # 'l_max': {'row': 1, 'col': 0}, # 'l_min': {'row': 1, 'col': 1}} plot_numbers = { 'h_max': 1, 'h_min': 2, 'l_max': 3, 'l_min': 4} sizes = { 2020: 2, 2050: 5} scenarios = ['l_max', 'l_min', 'h_max', 'h_min'] threshold = 5 # percent # ----------- # Plot 4x4 chart with relative differences # ------------ fig = plt.figure(figsize=basic_plot_functions.cm2inch(20, 20)) #width, height for scenario in scenarios: plot_nr = plot_numbers[scenario] plt.subplot(2, 2, plot_nr) mean_2020 = scenario_result_container[2020][scenario]['regional_share_national_peak'].mean(axis=0) mean_2050 = scenario_result_container[2050][scenario]['regional_share_national_peak'].mean(axis=0) std_2020 = scenario_result_container[2020][scenario]['regional_share_national_peak'].std(axis=0) std_2050 = scenario_result_container[2050][scenario]['regional_share_national_peak'].std(axis=0) diff_2020_2050_reg_share = ((100 / mean_2020) * mean_2050) - 100 diff_2020_2050_reg_share_std = ((100 / std_2020) * std_2050) - 100 if scenario not in ['h_min', 'l_min']: plt.ylabel("Δ standard deviation [%]", fontsize=10) if scenario not in ['h_max', 'h_min']: plt.xlabel("Δ mean of total peak [%]", fontsize=10) regions = diff_2020_2050_reg_share.index for region in regions.values: diff_mean = diff_2020_2050_reg_share.loc[region] diff_std = diff_2020_2050_reg_share_std.loc[region] color_pos = clasify_color(diff_mean, diff_std, threshold=threshold) color = colors_quadrates[color_pos] plt.scatter( diff_mean, diff_std, #alpha=0.6, color=color, edgecolor=color, linewidth=0.5, s=3) plt.xlim(-30, 60) plt.ylim(-50, 300) plt.title("{}".format(scenario), size=10) plt.axhline(y=0, linewidth=0.7, color='grey', linestyle='--') # horizontal line plt.axvline(x=0, linewidth=0.7, color='grey', linestyle='--') # vertical line # ----------------- # Plot spatial map # ----------------- regions = diff_2020_2050_reg_share.index relclassified_values = pd.DataFrame() relclassified_values['reclassified'] = 0 relclassified_values['name'] = regions relclassified_values = relclassified_values.set_index(('name')) relclassified_values['name'] = regions for region in regions.values: diff_mean = diff_2020_2050_reg_share.loc[region] diff_std = diff_2020_2050_reg_share_std.loc[region] relclassified_values.loc[region, 'reclassified'] = clasify_color(diff_mean, diff_std, threshold=threshold) fig_3_weather_map.plot_4_cross_map( cmap_rgb_colors=colors_quadrates, reclassified=relclassified_values, result_path=os.path.join(result_path, "spatial_final_{}.pdf".format(scenario)), threshold=threshold, path_shapefile_input=path_shapefile_input, seperate_legend=True) plt.savefig(os.path.join(result_path, "cross_chart_relative.pdf")) # ----------- # Plot 4x4 chart with absolute # ------------ fig = plt.figure(figsize=basic_plot_functions.cm2inch(20, 20)) #width, height for year, scenario_results in scenario_result_container.items(): for scenario_name, scenario_results in scenario_results.items(): plot_nr = plot_numbers[scenario_name] plt.subplot(2, 2, plot_nr) if year in [2020, 2050]: #regions = list(regional_share_national_peak.columns) #nr_of_regions = regional_share_national_peak.shape[1] #nr_of_realisations = regional_share_national_peak.shape[0] # Mean over all realisations mean = scenario_results['regional_share_national_peak'].mean(axis=0) / 100 # Standard deviation over all realisations std_dev = scenario_results['regional_share_national_peak'].std(axis=0) / 100 # Convert standard deviation given as % of peak into GW (multiply national peak per region share across the columns) abs_gw = pd.DataFrame() national_peak_per_run = scenario_results['peak_hour_demand'].sum(axis=1).to_frame() for reg_column in scenario_results['regional_share_national_peak'].columns.values: #reg share * national peak column_national_peak = national_peak_per_run.columns[0] abs_gw[reg_column] = (scenario_results['regional_share_national_peak'][reg_column] / 100) * national_peak_per_run[column_national_peak] # Absolute values std_dev_gw = abs_gw.std(axis=0) mean_gw = abs_gw.mean(axis=0) plt.ylim(0, np.max(std_dev_gw)) plt.ylim(0, 0.06) plt.xlim(0, 1.5) if scenario_name not in ['h_min', 'l_min']: plt.ylabel("standard deviation [GW]", fontsize=10) if scenario_name not in ['h_max', 'h_min']: plt.xlabel("mean of total peak [GW]", fontsize=10) plt.title(scenario_name, size=10) plt.scatter( list(mean_gw), #list(mean), list(std_dev_gw), #list(std_dev), color=colors[year], s=sizes[year]) #, #label="{} {}".format(year, scenario_name)) plt.savefig(os.path.join(result_path, "cross_chart_absolute.pdf"))
def plot_lad_comparison(base_yr, comparison_year, regions, ed_year_fueltype_regs_yh, fueltype_int, fueltype_str, fig_name, label_points=False, plotshow=False): """Compare energy demand for regions for the base yeard and a future year Arguments ---------- comparison_year : int Year to compare base year values to Note ----- SOURCE OF LADS: - Data for northern ireland is not included in that, however in BEIS dataset! """ result_dict = defaultdict(dict) # ------------------------------------------- # Get base year modelled demand # ------------------------------------------- for year, fuels in ed_year_fueltype_regs_yh.items(): if year == base_yr: for region_array_nr, reg_geocode in enumerate(regions): gw_per_region_modelled = np.sum( fuels[fueltype_int][region_array_nr]) result_dict['demand_by'][reg_geocode] = gw_per_region_modelled elif year == comparison_year: for region_array_nr, reg_geocode in enumerate(regions): gw_per_region_modelled = np.sum( fuels[fueltype_int][region_array_nr]) result_dict['demand_cy'][reg_geocode] = gw_per_region_modelled else: pass logging.info("Comparison: modelled: %s real: %s".format( sum(result_dict['demand_by'].values()), sum(result_dict['demand_cy'].values()))) # ----------------- # Sort results according to size # ----------------- sorted_dict_real = sorted(result_dict['demand_by'].items(), key=operator.itemgetter(1)) # ------------------------------------- # Plot # ------------------------------------- fig = plt.figure(figsize=basic_plot_functions.cm2inch(9, 8)) #width, height ax = fig.add_subplot(1, 1, 1) x_values = np.arange(0, len(sorted_dict_real), 1) y_real_elec_demand = [] y_modelled_elec_demand = [] labels = [] for sorted_region in sorted_dict_real: geocode_lad = sorted_region[0] y_real_elec_demand.append(result_dict['demand_by'][geocode_lad]) y_modelled_elec_demand.append(result_dict['demand_cy'][geocode_lad]) logging.debug( "validation for LAD region: %s %s diff: %s", result_dict['demand_by'][geocode_lad], result_dict['demand_cy'][geocode_lad], result_dict['demand_cy'][geocode_lad] - result_dict['demand_by'][geocode_lad]) labels.append(geocode_lad) # -------- # 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 # ---------------------------------------------- plt.plot( x_values, y_real_elec_demand, linestyle='None', marker='o', markersize=1.6, #1.6 fillstyle='full', markerfacecolor='grey', markeredgewidth=0.2, color='black', label='base year: {}'.format(base_yr)) plt.plot(x_values, y_modelled_elec_demand, marker='o', linestyle='None', markersize=1.6, markerfacecolor='white', fillstyle='none', markeredgewidth=0.5, markeredgecolor='blue', color='black', label='current year: {}'.format(comparison_year)) # Limit plt.ylim(ymin=0) # ----------- # Labelling # ----------- if label_points: for pos, txt in enumerate(labels): ax.text(x_values[pos], y_modelled_elec_demand[pos], txt, horizontalalignment="right", verticalalignment="top", fontsize=3) 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_name) if plotshow: plt.show() plt.close() else: plt.close()
def plot_4_cross_map( cmap_rgb_colors, reclassified, result_path, path_shapefile_input, threshold=None, seperate_legend=False ): """Plot classifed 4 cross map """ # -------------- # Use Cartopy to plot geometreis with reclassified faceolor # -------------- plt.figure(figsize=basic_plot_functions.cm2inch(10, 10)) #, dpi=150) proj = ccrs.OSGB() #'epsg:27700' ax = plt.axes(projection=proj) ax.outline_patch.set_visible(False) # set up a dict to hold geometries keyed by our key geoms_by_key = defaultdict(list) # for each records, pick out our key's value from the record # and store the geometry in the relevant list under geoms_by_key for record in shpreader.Reader(path_shapefile_input).records(): region_name = record.attributes['name'] geoms_by_key[region_name].append(record.geometry) # now we have all the geometries in lists for each value of our key # add them to the axis, using the relevant color as facecolor for key, geoms in geoms_by_key.items(): region_reclassified_value = reclassified.loc[key]['reclassified'] facecolor = cmap_rgb_colors[region_reclassified_value] ax.add_geometries(geoms, crs=proj, edgecolor='black', facecolor=facecolor, linewidth=0.1) # -------------- # Create Legend # -------------- legend_handles = [ mpatches.Patch(color=cmap_rgb_colors[0], label=str("+- threshold {}".format(threshold))), mpatches.Patch(color=cmap_rgb_colors[1], label=str("a")), mpatches.Patch(color=cmap_rgb_colors[2], label=str("b")), mpatches.Patch(color=cmap_rgb_colors[3], label=str("c")), mpatches.Patch(color=cmap_rgb_colors[4], label=str("d"))] legend = plt.legend( handles=legend_handles, #title="test", prop={'size': 8}, loc='upper center', bbox_to_anchor=(0.5, -0.05), frameon=False) if seperate_legend: basic_plot_functions.export_legend( legend, os.path.join(result_path, "{}__legend.pdf".format(result_path))) legend.remove() # Remove coordinates from figure ax.set_yticklabels([]) ax.set_xticklabels([]) legend.get_title().set_fontsize(8) # -------- # Labeling # -------- plt.tight_layout() plt.savefig(os.path.join(result_path)) plt.close()
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 plt_regions_peak_h(results_every_year, lookups, regions, path_plot_fig, fueltype_str_to_plot): """Plot Arguments --------- """ 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 = [] for fueltype_str, fueltype in lookups['fueltypes'].items(): if fueltype_str != fueltype_str_to_plot: pass else: # Legend # Read out fueltype specific load data_over_years = {} for reg_nr, reg_geocode in enumerate(regions): data_over_years[reg_nr] = [] for model_year_object in results_every_year.values(): for reg_nr, reg_geocode in enumerate(regions): # Get peak hour value _, peak_fueltyp_h = enduse_func.get_peak_day_single_fueltype( model_year_object[fueltype][reg_nr]) # Add peak hour data_over_years[reg_nr].append(peak_fueltyp_h) y_init = data_over_years # ---------- # Plot lines # ---------- #linestyles = plotting_styles.linestyles() years = list(results_every_year.keys()) for reg in y_init: plt.plot( years, y_init[reg], #linestyle=linestyles[fueltype], color='lightblue', linewidth=0.2, ) 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, single regs") # Tight layout plt.tight_layout() plt.margins(x=0) # Save fig fig.savefig(path_plot_fig) plt.close()
def plot_cross_graphs_scenarios(base_yr, comparison_year, regions, scenario_data, fueltype_int, fueltype_str, fig_name, label_points, plotshow): result_dict = defaultdict(dict) # ------------------------------------------- # Get base year modelled demand of any scenario (becasue base year the same in every scenario) # -------------------------------------------$ all_scenarios = list(scenario_data.keys()) first_scenario = all_scenarios[0] ed_year_fueltype_regs_yh = scenario_data[first_scenario][ 'ed_fueltype_regs_yh'] for year, fuels in ed_year_fueltype_regs_yh.items(): if year == base_yr: for reg_nr, reg_geocode in enumerate(regions): result_dict['demand_by'][reg_geocode] = np.sum( fuels[fueltype_int][reg_nr]) result_dict['peak_h_demand_by'][reg_geocode] = np.max( fuels[fueltype_int][reg_nr]) # Demand across all regs result_dict['demand_by_all_regs'] = np.sum(fuels[fueltype_int]) # Peak demand fuel_all_reg_yh = np.sum(fuels[fueltype_int], axis=0) # Sum across all regions result_dict['peak_h_demand_by_all_regs'] = np.max(fuel_all_reg_yh) # Calculate national load factor fuel_all_fueltype_reg_yh = np.sum( fuels, axis=1) # Sum across all regions per fueltype load_factor_y = load_factors.calc_lf_y(fuel_all_fueltype_reg_yh) result_dict['lf_by_all_regs_av'] = load_factor_y[fueltype_int] for scenario, data in scenario_data.items(): result_dict['demand_cy'][scenario] = {} result_dict['peak_h_demand_cy'][scenario] = {} for year, fuels in data['ed_fueltype_regs_yh'].items(): if year == comparison_year: for reg_nr, reg_geocode in enumerate(regions): result_dict['demand_cy'][scenario][reg_geocode] = np.sum( fuels[fueltype_int][reg_nr]) result_dict['peak_h_demand_cy'][scenario][ reg_geocode] = np.max(fuels[fueltype_int][reg_nr]) # Demand across all regs result_dict['demand_cy_all_regs'][scenario] = np.sum( fuels[fueltype_int]) # Peak demand fuel_all_reg_yh = np.sum(fuels[fueltype_int], axis=0) # Sum across all regions result_dict['peak_h_demand_cy_all_regs'][scenario] = np.max( fuel_all_reg_yh) # Calculate national load factor fuel_all_fueltype_reg_yh = np.sum( fuels, axis=1) # Sum across all regions per fueltype load_factor_y = load_factors.calc_lf_y( fuel_all_fueltype_reg_yh) result_dict['lf_cy_all_regs_av'][scenario] = load_factor_y[ fueltype_int] else: pass # Get load factor of base year reg_load_factor_y = scenario_data[first_scenario]['reg_load_factor_y'] for year, lf_fueltype_regs in reg_load_factor_y.items(): if year == base_yr: for reg_nr, reg_geocode in enumerate(regions): result_dict['lf_by'][reg_geocode] = lf_fueltype_regs[ fueltype_int][reg_nr] for scenario, data in scenario_data.items(): reg_load_factor_y = scenario_data[scenario]['reg_load_factor_y'] result_dict['lf_cy'][scenario] = {} for year, lf_fueltype_regs in reg_load_factor_y.items(): if year == comparison_year: for reg_nr, reg_geocode in enumerate(regions): result_dict['lf_cy'][scenario][ reg_geocode] = lf_fueltype_regs[fueltype_int][reg_nr] else: pass # -------------------------- # Iterate scenario and plot # -------------------------- fig = plt.figure(figsize=basic_plot_functions.cm2inch(18, 8)) #width, height ax = fig.add_subplot(1, 1, 1) color_list = plotting_styles.color_list_scenarios() marker_list = plotting_styles.marker_list() all_x_values = [] all_y_values = [] for scenario_nr, scenario in enumerate(all_scenarios): labels = [] x_values, y_values = [], [] for reg_nr, reg_geocode in enumerate(regions): # Change in load factor lf_change_p = ((100 / result_dict['lf_by'][reg_geocode]) * result_dict['lf_cy'][scenario][reg_geocode]) - 100 # Change in peak h deman demand_peak_h_p = ( (100 / result_dict['peak_h_demand_by'][reg_geocode]) * result_dict['peak_h_demand_cy'][scenario][reg_geocode]) - 100 # Change in total regional demand tot_demand_p = ( (100 / result_dict['demand_by'][reg_geocode]) * result_dict['demand_cy'][scenario][reg_geocode]) - 100 x_values.append(lf_change_p) #y_values.append(tot_demand_p) y_values.append(demand_peak_h_p) #print("ADDING {} {} {}".format(reg_nr, round(lf_change_p, 3), round(demand_peak_h_p, 3))) labels.append(reg_geocode) # Add average national_tot_cy_p = ((100 / result_dict['lf_by_all_regs_av']) * result_dict['lf_cy_all_regs_av'][scenario]) - 100 #national_tot_demand_p = ((100 / result_dict['demand_by_all_regs']) * result_dict['demand_cy_all_regs'][scenario]) - 100 national_peak_h_p = ( (100 / result_dict['peak_h_demand_by_all_regs']) * result_dict['peak_h_demand_cy_all_regs'][scenario]) - 100 x_val_national_lf_demand_cy = [national_tot_cy_p] #y_val_national_lf_demand_cy = [national_tot_demand_p] y_val_national_lf_demand_cy = [national_peak_h_p] all_x_values += x_values all_y_values += y_values # ------------------------------------- # Plot # ------------------------------------- color = color_list[scenario_nr] marker = marker_list[scenario_nr] alpha_value = 0.6 marker_size = 7 ax.scatter( x_values, y_values, alpha=alpha_value, color=color, #marker=marker, edgecolor=color, linewidth=0.5, s=marker_size, label=scenario) # Add average ax.scatter(x_val_national_lf_demand_cy, y_val_national_lf_demand_cy, alpha=1.0, color=color, s=20, marker="v", linewidth=0.5, edgecolor='black', label='national') # -------- # Axis # -------- ax.set_xlabel("load factor change (%) {}".format(fueltype_str)) ax.set_ylabel("change in peak h (%) {}".format(fueltype_str)) plt.tick_params( axis='x', # changes apply to the x-axis which='both', # both major and minor ticks are affected bottom='on', # ticks along the bottom edge are off top='off', # ticks along the top edge are off labelbottom='on') # labels along the bottom edge are off # -------- # Grd # -------- ax.set_axisbelow(True) #ax.grid(True) #ax.set_xticks(minor=False) ax.set_xticks([0], minor=True) #ax.set_yticks(minor=False) ax.set_yticks([0], minor=True) #ax.yaxis.grid(True, which='major') ax.yaxis.grid(True, which='minor', linewidth=0.7, color='grey', linestyle='--') #ax.xaxis.grid(True, which='major') ax.xaxis.grid(True, which='minor', linewidth=0.7, color='grey', linestyle='--') # Limit #plt.ylim(ymin=0) # ----------- # Labelling # ----------- if label_points: for pos, txt in enumerate(labels): ax.text(x_values[pos], y_values[pos], txt, horizontalalignment="right", verticalalignment="top", fontsize=6) # ------- # Title information # ------- max_lf = round(max(all_x_values), 2) min_lf = round(min(all_x_values), 2) min_peak_h = round(min(all_y_values), 2) max_peak_h = round(max(all_y_values), 2) font_additional_info = plotting_styles.font_info(size=4) plt.title("max_peak_h: {} min_peak_h: {}, min_lf: {} max_lf: {}".format( max_peak_h, min_peak_h, min_lf, max_lf), fontdict=font_additional_info) # -------- # Legend # -------- plt.legend(loc='best', ncol=1, prop={ 'family': 'arial', 'size': 3 }, frameon=False) # Tight layout plt.margins(x=0) plt.tight_layout() plt.savefig(fig_name) if plotshow: plt.show() plt.close()
def scenario_over_time(scenario_result_container, sim_yrs, fig_name, result_path, plot_points, crit_smooth_line=True, seperate_legend=False): """Plot peak over time """ statistics_to_print = [] fig = plt.figure(figsize=basic_plot_functions.cm2inch(10, 10)) #width, height ax = fig.add_subplot(1, 1, 1) for cnt_scenario, i in enumerate(scenario_result_container): scenario_name = i['scenario_name'] national_peak = i['national_peak'] # dataframe with national peak (columns= simulation year, row: Realisation) # Calculate quantiles quantile_95 = 0.95 quantile_05 = 0.05 try: color = colors[scenario_name] marker = marker_styles[scenario_name] except KeyError: color = list(colors.values())[cnt_scenario] try: marker = marker_styles[scenario_name] except KeyError: marker = list(marker_styles.values())[cnt_scenario] print("SCENARIO NAME {} {}".format(scenario_name, color)) # Calculate average across all weather scenarios mean_national_peak = national_peak.mean(axis=0) mean_national_peak_sim_yrs = copy.copy(mean_national_peak) statistics_to_print.append("scenario: {} values over years: {}".format( scenario_name, mean_national_peak_sim_yrs)) # Standard deviation over all realisations df_q_05 = national_peak.quantile(quantile_05) df_q_95 = national_peak.quantile(quantile_95) statistics_to_print.append("scenario: {} df_q_05: {}".format( scenario_name, df_q_05)) statistics_to_print.append("scenario: {} df_q_95: {}".format( scenario_name, df_q_95)) # -------------------- # Try to smooth lines # -------------------- sim_yrs_smoothed = sim_yrs if crit_smooth_line: try: sim_yrs_smoothed, mean_national_peak_smoothed = basic_plot_functions.smooth_data( sim_yrs, mean_national_peak, num=40000) _, df_q_05_smoothed = basic_plot_functions.smooth_data( sim_yrs, df_q_05, num=40000) _, df_q_95_smoothed = basic_plot_functions.smooth_data( sim_yrs, df_q_95, num=40000) mean_national_peak = pd.Series(mean_national_peak_smoothed, sim_yrs_smoothed) df_q_05 = pd.Series(df_q_05_smoothed, sim_yrs_smoothed) df_q_95 = pd.Series(df_q_95_smoothed, sim_yrs_smoothed) except: sim_yrs_smoothed = sim_yrs # ----------------------- # Plot lines # ------------------------ plt.plot(mean_national_peak, label="{} (mean)".format(scenario_name), color=color) # ------------------------ # Plot markers # ------------------------ if plot_points: plt.scatter(sim_yrs, mean_national_peak_sim_yrs, c=color, marker=marker, edgecolor='black', linewidth=0.5, s=15, clip_on=False) #do not clip points on axis # Plottin qunatilse and average scenario df_q_05.plot.line(color=color, linestyle='--', linewidth=0.1, label='_nolegend_') #, label="0.05") df_q_95.plot.line(color=color, linestyle='--', linewidth=0.1, label='_nolegend_') #, label="0.05") plt.fill_between( sim_yrs_smoothed, list(df_q_95), #y1 list(df_q_05), #y2 alpha=0.25, facecolor=color, ) plt.xlim(2015, 2050) plt.ylim(0) # -------- # Different style # -------- ax = plt.gca() ax.grid(which='major', color='black', axis='y', linestyle='--') ax.spines['right'].set_visible(False) ax.spines['left'].set_visible(False) ax.spines['top'].set_visible(False) plt.tick_params( axis='y', # changes apply to the x-axis which='both', # both major and minor ticks are affected bottom=False, # ticks along the bottom edge are off top=False, # ticks along the top edge are off left=False, right=False, labelbottom=False, labeltop=False, labelleft=True, labelright=False) # labels along the bottom edge are off # -------- # Legend # -------- legend = plt.legend( #title="tt", ncol=2, prop={'size': 10}, loc='upper center', bbox_to_anchor=(0.5, -0.1), frameon=False) legend.get_title().set_fontsize(8) if seperate_legend: basic_plot_functions.export_legend( legend, os.path.join(result_path, "{}__{}__legend.pdf".format(fig_name))) legend.remove() # -------- # Labeling # -------- plt.ylabel("national peak demand (GW)") #plt.xlabel("year") #plt.title("Title") plt.tight_layout() plt.savefig(os.path.join(result_path, fig_name)) plt.close() # Write info to txt write_data.write_list_to_txt( os.path.join(result_path, fig_name).replace(".pdf", ".txt"), statistics_to_print)
def spatial_validation_multiple(reg_coord, input_data, regions, fueltype_str, fig_name, label_points=False, plotshow=False): """Compare gas/elec demand for LADs Arguments ---------- lad_infos_shapefile : dict Infos of shapefile (dbf / csv) ed_fueltype_regs_yh : object Regional fuel Given as GWh (?) subnational_real : dict for electricity: Sub-national electrcity demand given as GWh Note ----- SOURCE OF LADS: - Data for northern ireland is not included in that, however in BEIS dataset! """ logging.debug("... Validation of spatial disaggregation") color_list = ['firebrick', 'darkseagreen'] label_list = ['domestic', 'non_domestic'] # ------------------------------------- # Plot # ------------------------------------- fig = plt.figure(figsize=basic_plot_functions.cm2inch(9, 8)) #width, height ax = fig.add_subplot(1, 1, 1) cnt_color = 0 for i in input_data: subnational_modelled = i[0] subnational_real = i[1] result_dict = {} result_dict['real_demand'] = {} result_dict['modelled_demand'] = {} # ------------------------------------------- # Match ECUK sub-regional demand with geocode # ------------------------------------------- for region in regions: for reg_geocode in reg_coord: if reg_geocode == region: try: # Test wheter data is provided for LAD or owtherwise ignore if subnational_real[reg_geocode] == 0: pass else: # --Sub Regional Electricity demand (as GWh) result_dict['real_demand'][ reg_geocode] = subnational_real[reg_geocode] result_dict['modelled_demand'][ reg_geocode] = subnational_modelled[ reg_geocode] except KeyError: logging.debug( "Sub-national spatial validation: No fuel for region %s", reg_geocode) # -------------------- # Calculate statistics # -------------------- diff_real_modelled_p = [] diff_real_modelled_abs = [] y_real_demand = [] y_modelled_demand = [] # ----------------- # Sort results according to size # ----------------- sorted_dict_real = sorted(result_dict['real_demand'].items(), key=operator.itemgetter(1)) #for reg_geocode in regions: for reg_geocode, _ in sorted_dict_real: # Test if real and modelled data are both available try: real = result_dict['real_demand'][reg_geocode] modelled = result_dict['modelled_demand'][reg_geocode] diff_real_modelled_p.append( abs(100 - ((100 / real) * modelled))) # Average abs deviation diff_real_modelled_abs.append(real - modelled) y_real_demand.append(real) y_modelled_demand.append(modelled) except KeyError: pass # Calculate the average deviation between reald and modelled av_deviation_real_modelled = np.average( diff_real_modelled_p) # average deviation 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 x_values = np.arange(0, len(y_real_demand), 1) labels = [] for sorted_region in sorted_dict_real: if sorted_region in y_real_demand: geocode_lad = sorted_region[0] logging.debug( "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 # ---------------------------------------------- plt.plot(x_values, y_real_demand, linestyle='None', marker='o', alpha=0.7, markersize=1.6, fillstyle='full', markerfacecolor='grey', markeredgewidth=0.2, color=color_list[cnt_color], markeredgecolor=color_list[cnt_color], label='actual') plt.plot(x_values, y_modelled_demand, marker='o', linestyle='None', markersize=1.6, alpha=0.7, markerfacecolor='white', fillstyle='none', markeredgewidth=0.5, markeredgecolor=color_list[cnt_color], color=color_list[cnt_color], label='model' + label_list[cnt_color]) # ----------- # 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=3, color=color_list[cnt_color]) 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.text(0.4, 0.9 - cnt_color / 10, title_info, ha='center', va='center', transform=ax.transAxes, fontdict=font_additional_info) cnt_color = +1 plt.xlabel("UK regions (excluding northern ireland)") plt.ylabel("{} [GWh]".format(fueltype_str)) plt.ylim(ymin=0) # -------- # Legend # -------- plt.legend(prop={'family': 'arial', 'size': 6}, frameon=False) # Tight layout plt.margins(x=0) plt.tight_layout() plt.savefig(fig_name) if plotshow: plt.show() else: plt.close()
def run(years_simulated, results_enduse_every_year, enduses, color_list, fig_name, plot_legend=True): """Plots stacked energy demand Arguments ---------- years_simulated : list Simulated years results_enduse_every_year : dict Results [year][enduse][fueltype_array_position] enduses : fig_name : str Figure name Note ---- - Sum across all fueltypes - Not possible to plot single year https://matplotlib.org/examples/pylab_examples/stackplot_demo.html """ print("...plot stacked enduses") nr_of_modelled_years = len(years_simulated) x_data = np.array(years_simulated) y_value_arrays = [] legend_entries = [] for enduse in enduses: legend_entries.append(enduse) y_values_enduse_yrs = np.zeros((nr_of_modelled_years)) for year_array_nr, model_year in enumerate( results_enduse_every_year.keys()): # Sum across all fueltypes tot_across_fueltypes = np.sum( results_enduse_every_year[model_year][enduse]) # Conversion: Convert GWh per years to GW yearly_sum_twh = conversions.gwh_to_twh(tot_across_fueltypes) logging.debug("... model_year {} enduse {} twh {}".format( model_year, enduse, np.sum(yearly_sum_twh))) if yearly_sum_twh < 0: raise Exception("no minus values allowed {} {} {}".format( enduse, yearly_sum_twh, model_year)) y_values_enduse_yrs[year_array_nr] = yearly_sum_twh # Add array with values for every year to list y_value_arrays.append(y_values_enduse_yrs) # Try smoothing line try: x_data_smoothed, y_value_arrays_smoothed = basic_plot_functions.smooth_data( x_data, y_value_arrays, num=40000) except: x_data_smoothed = x_data y_value_arrays_smoothed = y_value_arrays # Convert to stacked y_stacked = np.row_stack((y_value_arrays_smoothed)) # Set figure size fig = plt.figure(figsize=basic_plot_functions.cm2inch(8, 8)) ax = fig.add_subplot(1, 1, 1) # ---------- # Stack plot # ---------- color_stackplots = color_list[:len(enduses)] ax.stackplot(x_data_smoothed, y_stacked, alpha=0.8, colors=color_stackplots) if plot_legend: plt.legend(legend_entries, prop={ 'family': 'arial', 'size': 5 }, ncol=2, loc='upper center', bbox_to_anchor=(0.5, -0.1), frameon=False, shadow=True) # ------- # Axis # ------- year_interval = 10 major_ticks = np.arange(years_simulated[0], years_simulated[-1] + year_interval, year_interval) plt.xticks(major_ticks, major_ticks) plt.ylim(ymax=500) #yticks = [100, 200, 300, 400, 500] #plt.yticks(yticks, yticks) # ------- # Labels # ------- plt.ylabel("TWh", fontsize=10) plt.xlabel("Year", fontsize=10) #plt.title("ED whole UK", fontsize=10) # Tight layout fig.tight_layout() plt.margins(x=0) plt.savefig(fig_name) plt.close()
def compare_peak(name_fig, path_result, real_elec_2015_peak, modelled_peak_dh, peak_day): """Compare peak electricity day with calculated peak energy demand Arguments --------- name_fig : str Name of figure local_paths : dict Paths real_elec_2015_peak : array Real data of peak day modelled_peak_dh : array Modelled peak day """ logging.debug("...compare elec peak results") real_elec_peak = np.copy(real_elec_2015_peak) # ------------------------------- # Compare values # ------------------------------- fig = plt.figure(figsize=basic_plot_functions.cm2inch(8, 8)) # smooth line x_smoothed, y_modelled_peak_dh_smoothed = basic_plot_functions.smooth_data( range(24), modelled_peak_dh, num=500) plt.plot(x_smoothed, y_modelled_peak_dh_smoothed, color='blue', linestyle='--', linewidth=0.5, label='model') x_smoothed, real_elec_peak_smoothed = basic_plot_functions.smooth_data( range(24), real_elec_peak, num=500) plt.plot(x_smoothed, real_elec_peak_smoothed, color='black', linestyle='-', linewidth=0.5, label='validation') #raise Exception # Calculate hourly differences in % diff_p_h = np.round((100 / real_elec_peak) * modelled_peak_dh, 1) # Calculate maximum difference max_h_real = np.max(real_elec_peak) max_h_modelled = np.max(modelled_peak_dh) max_h_diff = round((100 / max_h_real) * max_h_modelled, 2) max_h_diff_gwh = round((abs(100 - max_h_diff) / 100) * max_h_real, 2) # Y-axis ticks plt.xlim(0, 23) plt.yticks(range(0, 60, 10)) # because position 0 in list is 01:00, the labelling starts with 1 plt.xticks([0, 5, 11, 17, 23], [1, 6, 12, 18, 24]) #ticks, labels plt.legend(frameon=False) # Labelling date_yearday = date_prop.yearday_to_date(2015, peak_day) plt.title("peak comparison {}".format(date_yearday)) plt.xlabel("h (max {} ({} GWH)".format(max_h_diff, max_h_diff_gwh)) plt.ylabel("uk electrictiy use [GW]") plt.text( 5, #position 5, #position diff_p_h, fontdict={ 'family': 'arial', 'color': 'black', 'weight': 'normal', 'size': 4 }) # Tight layout plt.tight_layout() plt.margins(x=0) # Save fig plt.savefig(os.path.join(path_result, name_fig)) plt.close()
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 run(path_fig_folder, path_plot_fig, calc_av_lp_modelled, calc_av_lp_real, calc_lp_modelled=None, calc_lp_real=None, plot_peak=False, plot_radar=False, plot_all_entries=False, plot_max_min_polygon=True, plotshow=False, max_y_to_plot=60, fueltype_str=False, year=False): """Plotting average saisonal loads for each daytype. As an input GWh is provided, which for each h is cancelled out to GW. https://stackoverflow.com/questions/4325733/save-a-subplot-in-matplotlib http://matthiaseisen.com/matplotlib/shapes/reg-polygon/ """ fig = plt.figure(figsize=basic_plot_functions.cm2inch(14, 25)) # ax = fig.add_subplot(nrows=4, ncols=2) plot_nr = 0 row = -1 for season in calc_av_lp_modelled: row += 1 col = -1 for daytype in calc_av_lp_modelled[season]: col += 1 plot_nr += 1 axes = plt.subplot(4, 2, plot_nr) # ------------------ # Plot average # ------------------ x_values = range(24) plt.plot(x_values, list(calc_av_lp_real[season][daytype]), color='black', label='av_real or av by', linestyle='--', linewidth=0.5) plt.plot(x_values, list(calc_av_lp_modelled[season][daytype]), color='blue', label='av_modelled or av cy', linestyle='--', linewidth=0.5) # -------------- # Radar plots # -------------- if plot_radar: name_spider_plot = os.path.join( path_fig_folder, "spider_{}_{}_{}_{}_.pdf".format(year, fueltype_str, season, daytype)) plot_radar_plot(list(calc_av_lp_modelled[season][daytype]), name_spider_plot, plot_steps=20, plotshow=False) # ------------------ # Plot every single line # ------------------ if plot_all_entries: for entry in range(len(calc_lp_real[season][daytype])): plt.plot(x_values, list(calc_lp_real[season][daytype][entry]), color='grey', markersize=0.5, alpha=0.2) plt.plot(x_values, list(calc_lp_modelled[season][daytype][entry]), color='blue', markersize=0.5, alpha=0.2) # ---------- # Plot max_min range polygons # ---------- if plot_max_min_polygon: # ----Draw real min_max_polygon = [] upper_boundary = [] lower_bdoundary = [] # Get min and max of all entries for hour for hour in range(24): min_y = np.min(calc_lp_real[season][daytype][:, hour], axis=0) max_y = np.max(calc_lp_real[season][daytype][:, hour], axis=0) upper_boundary.append((hour, min_y)) lower_bdoundary.append((hour, max_y)) # create correct sorting to draw filled polygon min_max_polygon = fig_lf.order_polygon(upper_boundary, lower_bdoundary) #min_max_polygon = create_min_max_polygon_from_lines(reg_load_factor_y) polygon = plt.Polygon(min_max_polygon, color='grey', alpha=0.2, edgecolor=None, linewidth=0, fill='True') axes.add_patch(polygon) # -----Draw modelled min_max_polygon = [] upper_boundary = [] lower_bdoundary = [] # Get min and max of all entries for hour for hour in range(24): min_y = np.min(calc_lp_modelled[season][daytype][:, hour], axis=0) max_y = np.max(calc_lp_modelled[season][daytype][:, hour], axis=0) upper_boundary.append((hour, min_y)) lower_bdoundary.append((hour, max_y)) # create correct sorting to draw filled polygon min_max_polygon = fig_lf.order_polygon(upper_boundary, lower_bdoundary) polygon = plt.Polygon(min_max_polygon, color='blue', alpha=0.2, edgecolor=None, linewidth=0, fill='True') axes.add_patch(polygon) # -------------------- # Get load shape within season with highest houly load # -------------------- if plot_peak: # Get row with maximum hourly value day_with_max_h = np.argmax( np.max(calc_lp_real[season][daytype], axis=1)) plt.plot(x_values, list(calc_lp_real[season][daytype][day_with_max_h]), color='grey', markersize=1.0, label='real_peak or by peak', linestyle='-.', linewidth=0.5) # Get row with maximum hourly value day_with_max_h = np.argmax( np.max(calc_lp_modelled[season][daytype], axis=1)) plt.plot( x_values, list(calc_lp_modelled[season][daytype][day_with_max_h]), color='blue', markersize=1.0, label='modelled_peak or cy peak', linestyle='-.', linewidth=0.5) # ----------------- # Axis # ----------------- plt.ylim(0, max_y_to_plot) plt.xlim(0, 23) # Tight layout plt.tight_layout() plt.margins(x=0) # Calculate RMSE rmse = basic_functions.rmse(calc_av_lp_modelled[season][daytype], calc_av_lp_real[season][daytype]) # Calculate R_squared slope, intercept, r_value, p_value, std_err = stats.linregress( calc_av_lp_modelled[season][daytype], calc_av_lp_real[season][daytype]) # Calculate standard deviation std_dev_p = np.std(calc_av_lp_real[season][daytype] - calc_av_lp_modelled[season][daytype]) std_dev_abs = np.std( abs(calc_av_lp_real[season][daytype] - calc_av_lp_modelled[season][daytype])) # ----------- # Labelling # ----------- font_additional_info = plotting_styles.font_info() title_info = ('{}, {}'.format(season, daytype)) plt.text( 1, 0.55, "RMSE: {}, R_squared: {}, std: {} (+- {})".format( round(rmse, 2), round(r_value, 2), round(std_dev_p, 2), round(std_dev_abs, 2), fontdict=font_additional_info)) plt.title(title_info, loc='left', fontdict=font_additional_info) # ------------ # Plot legend # ------------ plt.legend(ncol=1, loc=2, prop={ 'family': 'arial', 'size': 5 }, frameon=False) # Tight layout plt.tight_layout() plt.margins(x=0) fig.savefig(path_plot_fig) if plotshow: plt.show() plt.close() else: plt.close()
def run(lookups, years_simulated, results_enduse_every_year, rs_enduses, ss_enduses, is_enduses, fig_name): """Plots summarised endues for the three sectors. Annual GWh are converted into GW. Arguments ---------- data : dict Data container results_objects : enduses_data : Note ---- - Sum across all fueltypes # INFO Cannot plot a single year? """ logging.info("plot annual demand for enduses for all submodels") submodels = ['residential', 'service', 'industry'] nr_submodels = len(submodels) x_data = years_simulated y_data = np.zeros((nr_submodels, len(years_simulated))) # Set figure size fig = plt.figure(figsize=basic_plot_functions.cm2inch(8, 8)) ax = fig.add_subplot(1, 1, 1) for model_year, data_model_run in enumerate( results_enduse_every_year.values()): submodel = 0 for fueltype_int in range(lookups['fueltypes_nr']): for enduse in rs_enduses: # Conversion: Convert gwh per years to gw yearly_sum_gw = np.sum(data_model_run[enduse][fueltype_int]) yearly_sum_twh = conversions.gwh_to_twh(yearly_sum_gw) y_data[submodel][model_year] += yearly_sum_twh #yearly_sum_gw submodel = 1 for fueltype_int in range(lookups['fueltypes_nr']): for enduse in ss_enduses: # Conversion: Convert gwh per years to gw yearly_sum_gw = np.sum(data_model_run[enduse][fueltype_int]) yearly_sum_twh = conversions.gwh_to_twh(yearly_sum_gw) y_data[submodel][model_year] += yearly_sum_twh #yearly_sum_gw submodel = 2 for fueltype_int in range(lookups['fueltypes_nr']): for enduse in is_enduses: # Conversion: Convert gwh per years to gw yearly_sum_gw = np.sum(data_model_run[enduse][fueltype_int]) yearly_sum_twh = conversions.gwh_to_twh(yearly_sum_gw) y_data[submodel][model_year] += yearly_sum_twh #yearly_sum_gw # Convert to stack y_stacked = np.row_stack((y_data)) color_stackplots = ['darkturquoise', 'orange', 'firebrick'] # ---------- # Stack plot # ---------- ax.stackplot(x_data, y_stacked, colors=color_stackplots) # ------------ # Plot color legend with colors for every SUBMODEL # ------------ plt.legend(submodels, ncol=1, prop={ 'family': 'arial', 'size': 5 }, loc='best', frameon=False) # ------- # Axis # ------- plt.xticks(years_simulated, years_simulated) plt.axis('tight') # ------- # Labels # ------- plt.ylabel("TWh") plt.xlabel("year") plt.title("UK ED per sector") # Tight layout plt.margins(x=0) fig.tight_layout() # Save fig plt.savefig(fig_name) plt.close()
def plot_LAD_comparison_scenarios(scenario_data, year_to_plot, fig_name, plotshow=True): """Plot chart comparing total annual demand for all LADs Arguments --------- scenario_data : dict Scenario name, scenario data year_to_plot : int Year to plot different LAD values fig_name : str Path to out pdf figure plotshow : bool Plot figure or not Info ----- if scenario name starts with _ the legend does not work """ # Get first scenario in dict all_scenarios = list(scenario_data.keys()) first_scenario = str(all_scenarios[:1][0]) # ---------------- # Sort regions according to size # ----------------- regions = {} for fueltype, fuels_regs in enumerate( scenario_data[first_scenario]['ed_fueltype_regs_yh'][2015]): for region_array_nr, fuel_reg in enumerate(fuels_regs): try: regions[region_array_nr] += np.sum(fuel_reg) except KeyError: regions[region_array_nr] = np.sum(fuel_reg) sorted_regions = sorted(regions.items(), key=operator.itemgetter(1)) sorted_regions_nrs = [] for sort_info in sorted_regions: sorted_regions_nrs.append(sort_info[0]) # Labels labels = [] for sorted_region in sorted_regions_nrs: geocode_lad = sorted_region # If actual LAD name, change this labels.append(geocode_lad) # ------------------------------------- # 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_regions_nrs), 1) # ---------------------------------------------- # Plot base year values # ---------------------------------------------- base_year_data = [] for reg_array_nr in sorted_regions_nrs: base_year_data.append(regions[reg_array_nr]) total_base_year_sum = sum(base_year_data) plt.plot(x_values, base_year_data, linestyle='None', marker='o', markersize=1.6, fillstyle='full', markerfacecolor='grey', markeredgewidth=0.4, color='black', label='actual_by ({})'.format(total_base_year_sum)) # ---------------------------------------------- # Plot all future scenario values # ---------------------------------------------- color_list = plotting_styles.color_list() for scenario_nr, (scenario_name, fuel_data) in enumerate(scenario_data.items()): sorted_year_data = [] for reg_array_nr in sorted_regions_nrs: tot_fuel_across_fueltypes = 0 for fueltype, fuel_regs in enumerate( fuel_data['ed_fueltype_regs_yh'][year_to_plot]): tot_fuel_across_fueltypes += np.sum(fuel_regs[reg_array_nr]) sorted_year_data.append(tot_fuel_across_fueltypes) tot_fuel_all_reg = np.sum( fuel_data['ed_fueltype_regs_yh'][year_to_plot]) print("TOTAL FUEL in GWH " + str(tot_fuel_all_reg)) # Calculate total annual demand tot_demand = sum(sorted_year_data) scenario_name = "{} (tot: {} [GWh])".format(scenario_name, round(tot_demand, 2)) plt.plot(x_values, sorted_year_data, linestyle='None', marker='o', markersize=1.6, fillstyle='full', markerfacecolor=color_list[scenario_nr], markeredgewidth=0.4, color=color_list[scenario_nr], label=scenario_name) # -------- # 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 # Limit plt.ylim(ymin=0) # ----------- # Labelling # ----------- label_points = False if label_points: for pos, txt in enumerate(labels): ax.text(x_values[pos], sorted_year_data[pos], txt, horizontalalignment="right", verticalalignment="top", fontsize=3) plt.title("TEST", loc='left', fontdict=plotting_styles.font_info()) plt.xlabel("UK regions (excluding northern ireland)") plt.ylabel("[GWh]") # -------- # Legend # -------- plt.legend(prop={'family': 'arial', 'size': 8}, frameon=False) # Tight layout plt.margins(x=0) plt.tight_layout() plt.savefig(fig_name) if plotshow: plt.show() else: plt.close()
def plot_seasonal_lf(fueltype_int, fueltype_str, load_factors_seasonal, reg_nrs, path_plot_fig, plot_individ_lines=False, plot_max_min_polygon=True): """Plot load factors per region for every year Arguments -------- fueltype_int : int Fueltype_int to print (see lookup) fueltype_str : str Fueltype string to print load_factors_seasonal : dict Seasonal load factors per season reg_nrs : int Number of region """ print("... plotting seasonal load factors") # Set figure size fig = plt.figure(figsize=basic_plot_functions.cm2inch(8, 8)) ax = fig.add_subplot(1, 1, 1) # Settings color_list = { 'winter': 'midnightblue', 'summer': 'olive', 'spring': 'darkgreen', 'autumn': 'gold' } classes = list(color_list.keys()) #class_colours = list(color_list.values()) # ------------ # Iterate regions and plot load factors for every region # ------------ if plot_individ_lines: for reg_nr in range(reg_nrs): for season, lf_fueltypes_season in load_factors_seasonal.items(): x_values_season_year = [] y_values_season_year = [] for year, lf_fueltype_reg in lf_fueltypes_season.items(): x_values_season_year.append(year) y_values_season_year.append( lf_fueltype_reg[fueltype_int][reg_nr]) # plot individual saisonal data point plt.plot(x_values_season_year, y_values_season_year, color=color_list[season], linewidth=0.2, alpha=0.2) # ----------------- # Plot min_max_area # ----------------- if plot_max_min_polygon: for season, lf_fueltypes_season in load_factors_seasonal.items(): upper_boundary = [] lower_bdoundary = [] min_max_polygon = create_min_max_polygon_from_lines( lf_fueltypes_season) '''for year_nr, lf_fueltype_reg in lf_fueltypes_season.items(): # Get min and max of all entries of year of all regions min_y = np.min(lf_fueltype_reg[fueltype_int]) max_y = np.max(lf_fueltype_reg[fueltype_int]) upper_boundary.append((year_nr, min_y)) lower_bdoundary.append((year_nr, max_y)) # create correct sorting to draw filled polygon min_max_polygon = order_polygon(upper_boundary, lower_bdoundary)''' polygon = plt.Polygon(min_max_polygon, color=color_list[season], alpha=0.2, edgecolor=None, linewidth=0, fill='True') ax.add_patch(polygon) # ------------------------------------ # Calculate average per season for all regions # and plot average line a bit thicker # ------------------------------------ for season in classes: years = [] average_season_year_years = [] for year in load_factors_seasonal[season].keys(): average_season_year = [] # Iterate over regions for reg_nr in range(reg_nrs): average_season_year.append( load_factors_seasonal[season][year][fueltype_int][reg_nr]) years.append(int(year)) average_season_year_years.append(np.average(average_season_year)) # plot average plt.plot(years, average_season_year_years, color=color_list[season], linewidth=0.5, linestyle='--', alpha=1.0, markersize=0.5, marker='o', label=season) # Plot markers for average line '''plt.plot( years, average_season_year_years, color=color_list[season], markersize=0.5, linewidth=0.5, marker='o')''' # ----------------- # Axis # ----------------- plt.ylim(0, 100) # ----------------- # Axis labelling and ticks # ----------------- plt.xlabel("years") plt.ylabel("load factor {} [%]".format(fueltype_str)) base_yr = 2015 minor_interval = 5 major_interval = 10 # Major ticks major_ticks = np.arange(base_yr, years[-1] + major_interval, major_interval) ax.set_xticks(major_ticks) #ax.set_xlabel(major_ticks) # Minor ticks minor_ticks = np.arange(base_yr, years[-1] + minor_interval, minor_interval) ax.set_xticks(minor_ticks, minor=True) #ax.set_xlabel(minor_ticks) # ------------ # Plot color legend with colors for every season # ------------ plt.legend(ncol=2, prop={ 'family': 'arial', 'size': 5 }, loc='best', frameon=False) # Tight layout plt.tight_layout() plt.margins(x=0) # Save fig plt.savefig(path_plot_fig) plt.close()
def plot_heat_pump_chart(lookups, regions, scenario_data, fig_name, fueltype_str_input, plotshow=False): """ Compare share of element on x axis (provided in name of scenario) with load factor Info ----- Run scenarios with different value in scenarion name e.g. 0.1 heat pump --> scen_0.1 """ year_to_plot = 2050 # Collect value to display on axis result_dict = { } # {scenario_value: {year: {fueltype: np.array(reg, value))}} for scenario_name, scenario_data in scenario_data.items(): print("Scenario to process: " + str(scenario_name)) # Scenario value value_scenario = float(scenario_name.split("__")[1]) # Get peak for all regions {year: {fueltype: np.array(reg,value))} y_lf_fueltype = {} # Load factor '''for year, data_lf_fueltypes in scenario_data['reg_load_factor_y'].items(): # {scenario_value: np.array((regions, result_value))} if year != year_to_plot: continue y_lf_fueltype[year] = {} for fueltype_int, data_lf in enumerate(data_lf_fueltypes): fueltype_str = tech_related.get_fueltype_str(lookups['fueltypes'], fueltype_int) # Select only fueltype data if fueltype_str == fueltype_str_input: y_lf_fueltype[year] = data_lf else: pass ''' # PEAK VALUE ed_peak_regs_h ed_peak_h #for year, data_lf_fueltypes in scenario_data['ed_peak_regs_h'].items(): for year, data_lf_fueltypes in scenario_data['ed_peak_h'].items(): if year != year_to_plot: continue y_lf_fueltype[year] = {} for fueltype_str, data_lf in data_lf_fueltypes.items(): # Select only fueltype data if fueltype_str == fueltype_str_input: y_lf_fueltype[year] = data_lf else: pass result_dict[value_scenario] = y_lf_fueltype # Sort dict and convert to OrderedDict result_dict = collections.OrderedDict(sorted(result_dict.items())) #----- # Plot # ----- # Criteria to plot maximum boundaries plot_max_min_polygon = False plot_all_regs = False # Set figure size fig = plt.figure(figsize=basic_plot_functions.cm2inch(16, 8)) ax = fig.add_subplot(1, 1, 1) # ----------------- # Axis # ----------------- # Percentages on x axis major_ticks = list(result_dict.keys()) plt.xticks(major_ticks, major_ticks) # ---------- # Plot lines # ---------- color_list_selection = plotting_styles.get_colorbrewer_color( color_prop='sequential', #sequential color_palette='PuBu_4', inverse=False ) # #https://jiffyclub.github.io/palettable/colorbrewer/sequential/ # all percent values all_percent_values = list(result_dict.keys()) # Nr of years for _percent_value, fuel_fueltype_yrs in result_dict.items(): years = list(fuel_fueltype_yrs.keys()) break legend_entries = [] for year in years: color_scenario = color_list_selection.pop() legend_entries.append("mean {}".format(year)) # ---------------- # For every region # ---------------- '''for reg_nr, _ in enumerate(regions): year_data = [] for _percent_value, fuel_fueltype_yrs in result_dict.items(): year_data.append(fuel_fueltype_yrs[year][reg_nr]) # Paste out if not individual regions and set plot_max_min_polygon to True if plot_all_regs: plt.plot( list(all_percent_values), list(year_data), color=str(color_scenario))''' # -------------------- # Plot max min polygon # -------------------- if plot_max_min_polygon: # Create value {x_vals: [y_vals]} x_y_values = {} for _percent_value, fuel_fueltype_yrs in result_dict.items(): x_y_values[_percent_value] = [] for reg_nr, _ in enumerate(regions): x_y_values[_percent_value].append( result_dict[_percent_value][year]) # Create polygons min_max_polygon = plotting_results.create_min_max_polygon_from_lines( x_y_values) polygon = plt.Polygon(min_max_polygon, color=color_scenario, alpha=0.2, edgecolor=None, linewidth=0, fill='True') ax.add_patch(polygon) # Average across all regs year_data = [] for _percent_value, fuel_fueltype_yrs in result_dict.items(): regs = fuel_fueltype_yrs[year] # -------------------------------------- # Average load factor across all regions # -------------------------------------- lf_peak_across_all_regs = np.average(regs) year_data.append(lf_peak_across_all_regs) plt.plot(list(all_percent_values), list(year_data), color=str(color_scenario)) # ---- # Axis # ---- plt.ylim(ymin=0) plt.ylim(ymax=80) #plt.ylim(ymax=1.2) plt.xlim(xmin=0, xmax=60) # ------------ # Plot legend # ------------ plt.legend(legend_entries, ncol=1, loc=3, prop={ 'family': 'arial', 'size': 10 }, frameon=False) # --------- # Labels # --------- plt.xlabel("heat pump residential heating [%]") #plt.ylabel("load factor [%] [{}]".format(fueltype_str_input)) plt.ylabel("Peak demand h [GW] {}".format(fueltype_str_input)) #plt.title("impact of changing residential heat pumps to load factor") # Tight layout plt.tight_layout() plt.margins(x=0) plt.savefig(fig_name) if plotshow: plt.show() plt.close() else: plt.close()
def plot_lf_y(fueltype_int, fueltype_str, reg_load_factor_y, reg_nrs, path_plot_fig, plot_individ_lines=False, plot_max_min_polygon=True): """Plot load factors per region for every year Arguments -------- """ print("... plotting load factors") # Set figure size fig = plt.figure(figsize=basic_plot_functions.cm2inch(8, 8)) ax = fig.add_subplot(1, 1, 1) if plot_individ_lines: # Line plot for every region over years for reg_nr in range(reg_nrs): x_values_year = [] y_values_year = [] for year, lf_fueltype_reg in reg_load_factor_y.items(): x_values_year.append(year) y_values_year.append(lf_fueltype_reg[fueltype_int][reg_nr]) plt.plot(x_values_year, y_values_year, linewidth=0.2, color='grey') if plot_max_min_polygon: '''lower_bdoundary = [] upper_boundary = [] for year_nr, lf_fueltype_reg in reg_load_factor_y.items(): # Get min and max of all entries of year of all regions min_y = np.min(lf_fueltype_reg[fueltype_int]) max_y = np.max(lf_fueltype_reg[fueltype_int]) upper_boundary.append((year_nr, min_y)) lower_bdoundary.append((year_nr, max_y)) # create correct sorting to draw filled polygon min_max_polygon = order_polygon(upper_boundary, lower_bdoundary)''' min_max_polygon = create_min_max_polygon_from_lines(reg_load_factor_y) polygon = plt.Polygon(min_max_polygon, color='grey', alpha=0.2, edgecolor=None, linewidth=0, fill='True') ax.add_patch(polygon) # ----------------- # Axis # ----------------- plt.ylim(0, 100) # ----------------- # Axis labelling # ----------------- plt.xlabel("years") plt.ylabel("load factor, fueltpye {} [%]".format(fueltype_str)) years = list(reg_load_factor_y.keys()) base_yr = 2015 # Major ticks major_interval = 10 major_ticks = np.arange(base_yr, years[-1] + major_interval, major_interval) ax.set_xticks(major_ticks) # Minor ticks minor_interval = 5 minor_ticks = np.arange(base_yr, years[-1] + minor_interval, minor_interval) ax.set_xticks(minor_ticks, minor=True) # Tight layout plt.tight_layout() plt.margins(x=0) plt.savefig(path_plot_fig) plt.close()
def plot_reg_y_over_time(scenario_data, fig_name, plotshow=False): """Plot total demand over simulation period for every scenario for all regions """ # Set figure size plt.figure(figsize=basic_plot_functions.cm2inch(14, 8)) y_scenario = {} for scenario_name, scen_data in scenario_data.items(): data_years_regs = {} for year, fueltype_reg_time in scen_data['ed_fueltype_regs_yh'].items( ): data_years_regs[year] = {} for _fueltype, regions_fuel in enumerate(fueltype_reg_time): for region_nr, region_fuel in enumerate(regions_fuel): # Sum all regions and fueltypes reg_gwh_fueltype_y = np.sum(region_fuel) try: data_years_regs[year][region_nr] += reg_gwh_fueltype_y except: data_years_regs[year][region_nr] = reg_gwh_fueltype_y y_scenario[scenario_name] = data_years_regs # ----------------- # Axis # ----------------- base_yr, year_interval = 2015, 5 first_scen = list(y_scenario.keys())[0] end_yr = list(y_scenario[first_scen].keys())[-1] major_ticks = np.arange(base_yr, end_yr + year_interval, year_interval) plt.xticks(major_ticks, major_ticks) # ---------- # Plot lines # ---------- color_list_selection = plotting_styles.color_list_scenarios() cnt = -1 for scenario_name, fuel_fueltype_yrs in y_scenario.items(): cnt += 1 color_scenario = color_list_selection[cnt] for year, regs in fuel_fueltype_yrs.items(): nr_of_reg = len(regs.keys()) break for reg_nr in range(nr_of_reg): reg_data = [] for year, regions_fuel in fuel_fueltype_yrs.items(): reg_data.append(regions_fuel[reg_nr]) plt.plot(list(fuel_fueltype_yrs.keys()), list(reg_data), label="{}".format(scenario_name), color=str(color_scenario)) # ---- # Axis # ---- plt.ylim(ymin=0) # ------------ # Plot legend # ------------ '''plt.legend( ncol=2, loc=3, prop={ 'family': 'arial', 'size': 10}, frameon=False)''' # --------- # Labels # --------- font_additional_info = plotting_styles.font_info(size=5) plt.ylabel("GWh") plt.xlabel("year") plt.title("tot_y", fontdict=font_additional_info) # Tight layout plt.tight_layout() plt.margins(x=0) plt.savefig(fig_name) if plotshow: plt.show() plt.close() else: plt.close()
def plotting_weather_data(path): """ Things to plot - annual t_min of all realizations - annual t_max of all realizations - annual maximum t_max - annual minimum t_min """ sim_yrs = range(2015, 2051, 5) weather_reationzations = ["NF{}".format(i) for i in range(1, 101, 1)] container_weather_stations = {} container_temp_data = {} # All used weather stations from model run used_stations = [ 'station_id_253', 'station_id_252', 'station_id_253', 'station_id_252', 'station_id_252', 'station_id_328', 'station_id_329', 'station_id_305', 'station_id_282', 'station_id_335', 'station_id_335', 'station_id_359', 'station_id_358', 'station_id_309', 'station_id_388', 'station_id_418', 'station_id_420', 'station_id_389', 'station_id_433', 'station_id_385', 'station_id_374', 'station_id_481', 'station_id_481', 'station_id_480', 'station_id_466', 'station_id_531', 'station_id_532', 'station_id_535', 'station_id_535', 'station_id_484', 'station_id_421', 'station_id_472', 'station_id_526', 'station_id_525', 'station_id_526', 'station_id_504', 'station_id_503', 'station_id_504', 'station_id_505', 'station_id_504', 'station_id_504', 'station_id_455', 'station_id_548', 'station_id_546', 'station_id_537', 'station_id_545', 'station_id_236', 'station_id_353', 'station_id_352', 'station_id_384', 'station_id_510', 'station_id_527', 'station_id_550', 'station_id_501', 'station_id_456', 'station_id_472', 'station_id_201', 'station_id_470', 'station_id_487', 'station_id_505', 'station_id_486', 'station_id_457', 'station_id_533', 'station_id_458', 'station_id_441', 'station_id_440', 'station_id_473', 'station_id_217', 'station_id_247', 'station_id_199', 'station_id_232', 'station_id_234', 'station_id_478', 'station_id_248', 'station_id_388', 'station_id_377', 'station_id_376', 'station_id_376', 'station_id_388', 'station_id_354', 'station_id_376', 'station_id_388', 'station_id_515', 'station_id_514', 'station_id_514', 'station_id_531', 'station_id_532', 'station_id_494', 'station_id_512', 'station_id_535', 'station_id_535', 'station_id_517', 'station_id_534', 'station_id_533', 'station_id_549', 'station_id_549', 'station_id_550', 'station_id_549', 'station_id_508', 'station_id_490', 'station_id_507', 'station_id_526', 'station_id_508', 'station_id_491', 'station_id_507', 'station_id_489', 'station_id_509', 'station_id_526', 'station_id_545', 'station_id_492', 'station_id_490', 'station_id_451', 'station_id_467', 'station_id_450', 'station_id_451', 'station_id_466', 'station_id_451', 'station_id_521', 'station_id_538', 'station_id_537', 'station_id_537', 'station_id_522', 'station_id_546', 'station_id_536', 'station_id_522', 'station_id_520', 'station_id_537', 'station_id_488', 'station_id_487', 'station_id_488', 'station_id_472', 'station_id_487', 'station_id_487', 'station_id_551', 'station_id_544', 'station_id_419', 'station_id_525', 'station_id_552', 'station_id_525', 'station_id_543', 'station_id_542', 'station_id_552', 'station_id_543', 'station_id_544', 'station_id_542', 'station_id_542', 'station_id_306', 'station_id_305', 'station_id_282', 'station_id_306', 'station_id_406', 'station_id_264', 'station_id_306', 'station_id_283', 'station_id_284', 'station_id_306', 'station_id_305', 'station_id_304', 'station_id_283', 'station_id_418', 'station_id_403', 'station_id_419', 'station_id_418', 'station_id_403', 'station_id_402', 'station_id_392', 'station_id_379', 'station_id_391', 'station_id_422', 'station_id_404', 'station_id_379', 'station_id_443', 'station_id_444', 'station_id_445', 'station_id_423', 'station_id_469', 'station_id_425', 'station_id_444', 'station_id_461', 'station_id_438', 'station_id_437', 'station_id_439', 'station_id_438', 'station_id_455', 'station_id_454', 'station_id_438', 'station_id_284', 'station_id_268', 'station_id_286', 'station_id_266', 'station_id_288', 'station_id_270', 'station_id_333', 'station_id_389', 'station_id_378', 'station_id_389', 'station_id_389', 'station_id_377', 'station_id_390', 'station_id_403', 'station_id_469', 'station_id_485', 'station_id_484', 'station_id_469', 'station_id_499', 'station_id_498', 'station_id_516', 'station_id_497', 'station_id_479', 'station_id_400', 'station_id_387', 'station_id_401', 'station_id_374', 'station_id_400', 'station_id_386', 'station_id_375', 'station_id_401', 'station_id_491', 'station_id_459', 'station_id_492', 'station_id_476', 'station_id_475', 'station_id_477', 'station_id_462', 'station_id_523', 'station_id_523', 'station_id_522', 'station_id_523', 'station_id_523', 'station_id_523', 'station_id_505', 'station_id_522', 'station_id_541', 'station_id_539', 'station_id_523', 'station_id_417', 'station_id_417', 'station_id_437', 'station_id_436', 'station_id_436', 'station_id_548', 'station_id_547', 'station_id_488', 'station_id_539', 'station_id_540', 'station_id_540', 'station_id_540', 'station_id_547', 'station_id_416', 'station_id_434', 'station_id_435', 'station_id_434', 'station_id_434', 'station_id_415', 'station_id_488', 'station_id_488', 'station_id_489', 'station_id_329', 'station_id_330', 'station_id_330', 'station_id_330', 'station_id_330', 'station_id_329', 'station_id_354', 'station_id_330', 'station_id_329', 'station_id_329', 'station_id_328', 'station_id_328', 'station_id_328', 'station_id_304', 'station_id_327', 'station_id_331', 'station_id_357', 'station_id_356', 'station_id_355', 'station_id_221', 'station_id_221', 'station_id_221', 'station_id_237', 'station_id_416', 'station_id_417', 'station_id_416', 'station_id_416', 'station_id_417', 'station_id_400', 'station_id_400', 'station_id_307', 'station_id_307', 'station_id_331', 'station_id_308', 'station_id_332', 'station_id_221', 'station_id_506', 'station_id_507', 'station_id_506', 'station_id_525', 'station_id_506', 'station_id_524', 'station_id_506', 'station_id_524', 'station_id_505', 'station_id_506', 'station_id_524', 'station_id_506', 'station_id_506', 'station_id_506', 'station_id_505', 'station_id_507', 'station_id_505', 'station_id_505', 'station_id_506', 'station_id_506', 'station_id_523', 'station_id_524', 'station_id_524', 'station_id_524', 'station_id_506', 'station_id_507', 'station_id_505', 'station_id_524', 'station_id_524', 'station_id_506', 'station_id_506', 'station_id_524', 'station_id_506', 'station_id_172', 'station_id_193', 'station_id_173', 'station_id_133', 'station_id_130', 'station_id_168', 'station_id_194', 'station_id_152', 'station_id_170', 'station_id_214', 'station_id_195', 'station_id_103', 'station_id_124', 'station_id_110', 'station_id_176', 'station_id_136', 'station_id_125', 'station_id_121', 'station_id_9', 'station_id_111', 'station_id_105', 'station_id_36', 'station_id_108', 'station_id_52', 'station_id_119', 'station_id_4', 'station_id_94', 'station_id_159', 'station_id_137', 'station_id_102', 'station_id_77', 'station_id_303', 'station_id_2', 'station_id_154', 'station_id_64', 'station_id_89', 'station_id_124', 'station_id_109', 'station_id_109', 'station_id_123', 'station_id_86', 'station_id_105', 'station_id_110', 'station_id_110', 'station_id_448', 'station_id_348', 'station_id_349', 'station_id_350', 'station_id_351', 'station_id_372', 'station_id_394', 'station_id_449', 'station_id_464', 'station_id_407', 'station_id_428', 'station_id_446', 'station_id_446', 'station_id_463', 'station_id_463', 'station_id_464', 'station_id_447', 'station_id_448', 'station_id_448', 'station_id_396', 'station_id_447' ] # Load full data for weather_realisation in weather_reationzations: print("weather_realisation: " + str(weather_realisation)) path_weather_data = path weather_stations, temp_data = data_loader.load_temp_data( {}, sim_yrs=sim_yrs, weather_realisation=weather_realisation, path_weather_data=path_weather_data, same_base_year_weather=False, crit_temp_min_max=True, load_np=False, load_parquet=False, load_csv=True) # Load only data from selected weather stations temp_data_used = {} for year in sim_yrs: temp_data_used[year] = {} all_station_data = temp_data[year].keys() for station in all_station_data: if station in used_stations: temp_data_used[year][station] = temp_data[year][station] container_weather_stations[weather_realisation] = weather_stations container_temp_data[weather_realisation] = temp_data_used # Create plot with daily min print("... creating min max plot") t_min_average_every_day = [] t_max_average_every_day = [] t_min_min_every_day = [] t_max_max_every_day = [] std_dev_t_min = [] std_dev_t_max = [] std_dev_t_min_min = [] std_dev_t_max_max = [] for year in sim_yrs: for realization in container_weather_stations.keys(): t_min_average_stations = [] t_max_average_stations = [] t_min_min_average_stations = [] t_max_max_average_stations = [] stations_data = container_temp_data[realization][year] for station in stations_data.keys(): t_min_annual_average = np.average( stations_data[station]['t_min']) t_max_annual_average = np.average( stations_data[station]['t_max']) t_min_min_stations = np.min(stations_data[station]['t_min']) t_max_max_stations = np.max(stations_data[station]['t_max']) t_min_average_stations.append( t_min_annual_average) #average cross all stations t_max_average_stations.append( t_max_annual_average) #average cross all stations t_min_min_average_stations.append(t_min_min_stations) t_max_max_average_stations.append(t_max_max_stations) av_t_min = np.average( t_min_average_stations) #average across all realizations av_t_max = np.average( t_max_average_stations) #average across all realizations av_min_t_min = np.average( t_min_min_average_stations) #average across all realizations av_max_t_max = np.average( t_max_max_average_stations) #average across all realizations std_t_min = np.std(t_min_average_stations) std_t_max = np.std(t_max_average_stations) std_t_min_min = np.std(t_min_min_average_stations) std_t_max_max = np.std(t_max_max_average_stations) t_min_average_every_day.append(av_t_min) t_max_average_every_day.append(av_t_max) t_min_min_every_day.append(av_min_t_min) t_max_max_every_day.append(av_max_t_max) std_dev_t_min.append(std_t_min) std_dev_t_max.append(std_t_max) std_dev_t_min_min.append(std_t_min_min) std_dev_t_max_max.append(std_t_max_max) # Plot variability fig = plt.figure(figsize=basic_plot_functions.cm2inch(9, 6)) #width, height colors = { 't_min': 'steelblue', 't_max': 'tomato', 't_min_min': 'peru', 't_max_max': 'r' } # plot plt.plot(sim_yrs, t_min_average_every_day, color=colors['t_min'], label="t_min") plt.plot(sim_yrs, t_max_average_every_day, color=colors['t_max'], label="t_max") plt.plot(sim_yrs, t_min_min_every_day, color=colors['t_min_min'], label="t_min_min") plt.plot(sim_yrs, t_max_max_every_day, color=colors['t_max_max'], label="t_max_max") # Variations plt.fill_between( sim_yrs, list( np.array(t_min_average_every_day) - (2 * np.array(std_dev_t_min))), list( np.array(t_min_average_every_day) + (2 * np.array(std_dev_t_min))), color=colors['t_min'], alpha=0.25) plt.fill_between( sim_yrs, list( np.array(t_max_average_every_day) - (2 * np.array(std_dev_t_max))), list( np.array(t_max_average_every_day) + (2 * np.array(std_dev_t_max))), color=colors['t_max'], alpha=0.25) plt.fill_between( sim_yrs, list( np.array(t_min_min_every_day) - (2 * np.array(std_dev_t_min_min))), list( np.array(t_min_min_every_day) + (2 * np.array(std_dev_t_min_min))), color=colors['t_min_min'], alpha=0.25) plt.fill_between( sim_yrs, list( np.array(t_max_max_every_day) - (2 * np.array(std_dev_t_max_max))), list( np.array(t_max_max_every_day) + (2 * np.array(std_dev_t_max_max))), color=colors['t_max_max'], alpha=0.25) # Legend legend = plt.legend(ncol=2, prop={'size': 10}, loc='upper center', bbox_to_anchor=(0.5, -0.1), frameon=False) legend.get_title().set_fontsize(8) result_path = "C:/_scrap/" seperate_legend = True if seperate_legend: basic_plot_functions.export_legend( legend, os.path.join(result_path, "{}__legend.pdf".format(result_path))) legend.remove() plt.legend(ncol=2) plt.xlabel("Year") plt.ylabel("Temperature (°C)") plt.tight_layout() plt.margins(x=0) fig.savefig(os.path.join(result_path, "test.pdf"))
def plot_tot_y_over_time(scenario_data, fig_name, plotshow=False): """Plot total demand over simulation period for every scenario for all regions """ # Set figure size plt.figure(figsize=basic_plot_functions.cm2inch(14, 8)) y_scenario = {} for scenario_name, scen_data in scenario_data.items(): # Read out fueltype specific max h load data_years = {} for year, fueltype_reg_time in scen_data['ed_fueltype_regs_yh'].items( ): # Sum all regions and fueltypes tot_gwh_fueltype_y = np.sum(fueltype_reg_time) # Convert to TWh tot_twh_fueltype_y = conversions.gwh_to_twh(tot_gwh_fueltype_y) data_years[year] = tot_twh_fueltype_y y_scenario[scenario_name] = data_years # ----------------- # Axis # ----------------- base_yr, year_interval = 2015, 5 first_scen = list(y_scenario.keys())[0] end_yr = list(y_scenario[first_scen].keys()) major_ticks = np.arange(base_yr, end_yr[-1] + year_interval, year_interval) plt.xticks(major_ticks, major_ticks) # ---------- # Plot lines # ---------- # color_list_selection = plotting_styles.color_list_selection() color_list_selection = plotting_styles.color_list_scenarios() for scenario_name, fuel_fueltype_yrs in y_scenario.items(): plt.plot( list(fuel_fueltype_yrs.keys()), # years list(fuel_fueltype_yrs.values()), # yearly data per fueltype color=str(color_list_selection.pop()), label=scenario_name) # ---- # Axis # ---- plt.ylim(ymin=0) # ------------ # Plot legend # ------------ plt.legend(ncol=1, loc=3, prop={ 'family': 'arial', 'size': 10 }, frameon=False) # --------- # Labels # --------- plt.ylabel("TWh") plt.xlabel("year") plt.title("tot y ED all fueltypes") # Tight layout plt.tight_layout() plt.margins(x=0) plt.savefig(fig_name) if plotshow: plt.show() plt.close()
def fueltypes_over_time(scenario_result_container, sim_yrs, fig_name, fueltypes, result_path, plot_points=False, unit='TWh', crit_smooth_line=True, seperate_legend=False): """Plot fueltypes over time """ statistics_to_print = [] fig = plt.figure(figsize=basic_plot_functions.cm2inch(10, 10)) #width, height ax = fig.add_subplot(1, 1, 1) colors = { # Low elec 'electricity': '#3e3838', 'gas': '#ae7c7c', 'hydrogen': '#6cbbb3', } line_styles_default = plotting_styles.linestyles() linestyles = { 'h_max': line_styles_default[0], 'h_min': line_styles_default[6], 'l_min': line_styles_default[8], 'l_max': line_styles_default[9], } for cnt_scenario, i in enumerate(scenario_result_container): scenario_name = i['scenario_name'] for cnt_linestyle, fueltype_str in enumerate(fueltypes): national_sum = i['national_{}'.format(fueltype_str)] if unit == 'TWh': unit_factor = conversions.gwh_to_twh(1) elif unit == 'GWh': unit_factor = 1 else: raise Exception("Wrong unit") national_sum = national_sum * unit_factor # Calculate quantiles quantile_95 = 0.95 quantile_05 = 0.05 try: color = colors[fueltype_str] except KeyError: #color = list(colors.values())[cnt_linestyle] raise Exception("Wrong color") try: linestyle = linestyles[scenario_name] except KeyError: linestyle = list(linestyles.values())[cnt_scenario] try: marker = marker_styles[scenario_name] except KeyError: marker = list(marker_styles.values())[cnt_scenario] # Calculate average across all weather scenarios mean_national_sum = national_sum.mean(axis=0) mean_national_sum_sim_yrs = copy.copy(mean_national_sum) statistics_to_print.append( "{} fueltype_str: {} mean_national_sum_sim_yrs: {}".format( scenario_name, fueltype_str, mean_national_sum_sim_yrs)) # Standard deviation over all realisations df_q_05 = national_sum.quantile(quantile_05) df_q_95 = national_sum.quantile(quantile_95) statistics_to_print.append( "{} fueltype_str: {} df_q_05: {}".format( scenario_name, fueltype_str, df_q_05)) statistics_to_print.append( "{} fueltype_str: {} df_q_95: {}".format( scenario_name, fueltype_str, df_q_95)) # -------------------- # Try to smooth lines # -------------------- sim_yrs_smoothed = sim_yrs if crit_smooth_line: try: sim_yrs_smoothed, mean_national_sum_smoothed = basic_plot_functions.smooth_data( sim_yrs, mean_national_sum, num=500) _, df_q_05_smoothed = basic_plot_functions.smooth_data( sim_yrs, df_q_05, num=500) _, df_q_95_smoothed = basic_plot_functions.smooth_data( sim_yrs, df_q_95, num=500) mean_national_sum = pd.Series(mean_national_sum_smoothed, sim_yrs_smoothed) df_q_05 = pd.Series(df_q_05_smoothed, sim_yrs_smoothed) df_q_95 = pd.Series(df_q_95_smoothed, sim_yrs_smoothed) except: print("did not owrk {} {}".format(fueltype_str, scenario_name)) pass # ------------------------ # Plot lines # ------------------------ plt.plot(mean_national_sum, label="{} {}".format(fueltype_str, scenario_name), linestyle=linestyle, color=color, zorder=1, clip_on=True) # ------------------------ # Plot markers # ------------------------ if plot_points: plt.scatter(sim_yrs, mean_national_sum_sim_yrs, marker=marker, edgecolor='black', linewidth=0.5, c=color, zorder=2, s=15, clip_on=False) #do not clip points on axis # Plottin qunatilse and average scenario df_q_05.plot.line(color=color, linestyle='--', linewidth=0.1, label='_nolegend_') #, label="0.05") df_q_95.plot.line(color=color, linestyle='--', linewidth=0.1, label='_nolegend_') #, label="0.05") plt.fill_between( sim_yrs_smoothed, list(df_q_95), #y1 list(df_q_05), #y2 alpha=0.25, facecolor=color, ) plt.xlim(2015, 2050) plt.ylim(0) ax = plt.gca() # Major ticks every 20, minor ticks every 5 major_ticks = [200, 400, 600] #np.arange(0, 600, 200) minor_ticks = [100, 200, 300, 400, 500, 600] #np.arange(0, 600, 100) ax.set_yticks(major_ticks) ax.set_yticks(minor_ticks, minor=True) # And a corresponding grid ax.grid(which='both', color='black', linewidth=0.5, axis='y', linestyle=line_styles_default[3]) #[6]) # Or if you want different settings for the grids: ax.grid(which='minor', axis='y', alpha=0.4) ax.grid(which='major', axis='y', alpha=0.8) # Achsen ax.spines['right'].set_visible(False) ax.spines['left'].set_visible(False) ax.spines['top'].set_visible(False) # Ticks plt.tick_params( axis='y', # changes apply to the x-axis which='both', # both major and minor ticks are affected bottom=False, # ticks along the bottom edge are off top=False, # ticks along the top edge are off left=False, right=False, labelbottom=False, labeltop=False, labelleft=True, labelright=False) # labels along the bottom edge are off # -------- # Legend # -------- legend = plt.legend( #title="tt", ncol=2, prop={'size': 6}, loc='upper center', bbox_to_anchor=(0.5, -0.1), frameon=False) legend.get_title().set_fontsize(8) if seperate_legend: basic_plot_functions.export_legend( legend, os.path.join(result_path, "{}__legend.pdf".format(fig_name))) legend.remove() # -------- # Labeling # -------- plt.ylabel("national fuel over time [in {}]".format(unit)) #plt.xlabel("year") #plt.title("Title") plt.tight_layout() #plt.show() plt.savefig(os.path.join(result_path, fig_name)) plt.close() write_data.write_list_to_txt( os.path.join(result_path, fig_name).replace(".pdf", ".txt"), statistics_to_print)