def save_pressure_coordinate_field(ds, var, model='NorESM'): # path_savePressCoord = default_save_pressure_coordinates): # test for pressure coordinates check_list = set(ds[var].attrs.keys()).intersection({'Pres_addj', 'pressure_coords'}) check = False for key in check_list: if ds[var].attrs[key] is True or ds[var].attrs[key] == 'True': check = True elif var in constants.not_pressure_coords: check = True if not check: # (not ds[var].attrs['Pres_addj']) and (not ds[var].attrs['pressure_coords'])\ log.ger.info('Not pressure adjusted! Will not save') else: from_t = ds.attrs['from_time'] # ds['time'][argmin].values to_t = ds.attrs['to_time'] # ds['time'][argmax].values case = ds.attrs['case_name'] filename = get_filename_pressure_coordinate_field(var, model, case, from_t, to_t) dummy = ds[var].copy() make_folders(extract_path_from_filepath(filename)) log.ger.debug('Saving %s pressure coordinate field to file %s' % (var, filename)) # 'Time not in datetime') dummy.attrs['pressure_coords'] = 'True' try: log.ger.info(filename) dummy.to_netcdf(filename, mode='w') # ,encoding={'time':{'units':'days since 2000-01-01 00:00:00'}}) except PermissionError: log.ger.info(f'couldnt access file {filename}') del dummy return
def savepath_coll_ds(self, var_name): sp = self.savepath_root st = sp + '%s' st = '%s/%s/%s/%s_%s' % (sp, self.model_name, self.case_name, var_name, self.case_name) st = st + '_%s_%s' % (self.from_time, self.to_time) st = st + '_%s_%s' % (self.time_resolution, self.space_resolution) fn = st + '.nc' make_folders(fn) return fn
def dataset_savepath_var(self, var_name, case_name, model_name): """ Returns filename of dataset :param var_name: :param case_name: :param model_name: :return: """ case_name = case_name.replace(' ', '_') _savep = self.default_savepath_root st = '%s/%s/%s/%s_%s' % (_savep, model_name, case_name, var_name, case_name) st = st + '_%s_%s' % (self.from_time, self.to_time) st = st + '_%s_%s' % (self.time_resolution, self.space_resolution) fn = st + '.nc' make_folders(fn) return fn
def plot_seasonal_surface_loc_sizedistributions(cases_sec, cases_orig, from_t, to_t, variables=['dNdlogD'], minDiameter=5., maxDiameter=39.6, resolution='month', history_field='.h0.', figsize= [12,6], locations=constants.collocate_locations.keys()): cl = SizedistributionSurface s_list = [] for case in cases_sec: s1 = cl(case, from_t, to_t, [minDiameter, maxDiameter], True, resolution, history_field=history_field) s_list.append(s1) for case in cases_orig: s1 = cl(case, from_t, to_t, [minDiameter, maxDiameter], False, resolution, history_field=history_field) s_list.append(s1) cmap_dic = get_cmap_dic(cases_sec+cases_orig) for loc in locations: fig, axs = plt.subplots(2, 2, figsize=figsize) axs = axs.flatten() for s in s_list: ls = variables #if s.isSectional: # ls = ls + ['dNdlogD_sec'] s.plot_location(variables=ls, c=cmap_dic[s.case_name], axs=axs, loc=loc, ylim=[10,1e4]) fig.tight_layout() savepath = constants.paths_plotsave['sizedist'] +'/season/' _cas = '_'.join(cases_sec) + '_'+'_'.join(cases_orig) savepath = savepath +loc+ _cas + 'mean_%s-%s_%s.png'%(from_t, to_t, resolution) make_folders(savepath) plt.savefig(savepath, dpi=200) plt.show()
def plot_sizedist_time_cases(cases, ss_start_t, ss_end_t, location, figsize=[14,15], resolution='month', history_field='.h0.', minDiameter=5., maxDiameter=39.6, vmin=10., vmax=5.e3): fig, axs = plt.subplots(len(cases),1, figsize=figsize, sharex=True, sharey=True) for case, ax in zip(cases, axs): isSectional = 'noSECT' not in case s = SizedistributionSurface(case, ss_start_t, ss_end_t, [minDiameter, maxDiameter], isSectional , resolution, history_field=history_field) ds = s.get_collocated_dataset() a = plot_sizedist_time(ds, ss_start_t, ss_end_t, location=location, var=None, ax=ax, figsize=figsize, vmin=vmin, vmax=vmax, norm_fun=colors.LogNorm, ) plt.tight_layout() path_save = paths_plotsave['sizedist_time']+'month/'+ '_'.join(cases)+'surf_%s_%s.png' % (ss_start_t,ss_end_t) make_folders(path_save) plt.savefig(path_save, dpi=200) plt.show()
def get_average_map2(ds, varlist, case_name, from_time, to_time, avg_over_lev=True, pmin=850., p_level=1013., pressure_coord=True, save_avg=True, recalculate=False, model_name='NorESM', time_mask=None): """ :param ds: :param varlist: :param case_name: :param from_time: :param to_time: :param avg_over_lev: :param pmin: :param p_level: :param pressure_coord: :param save_avg: :param recalculate: :param model_name: :param time_mask: :return: """ xr_out = ds.copy() for var in varlist: found_map_avg = False # Look for file: if not recalculate: ds_copy, found_map_avg = load_average2map(model_name, case_name, var, from_time, to_time, avg_over_lev, pmin, p_level, pressure_coord, time_mask=time_mask) # if file not found: if not found_map_avg: # some fields require other fields for weighted average: sub_varL = get_fields4weighted_avg(var) ds_copy = ds.copy() for svar in sub_varL: if ('lev' in ds[svar].dims): had_lev_coord = True else: had_lev_coord = False if avg_over_lev: ds_copy = average_model_var( ds_copy, svar, area='Global', dim=list(set(ds.dims) - {'lat', 'lon'}), minp=pmin, time_mask=time_mask) else: ds_copy = average_model_var( ds_copy, svar, area='Global', dim=list(set(ds.dims) - {'lat', 'lon', 'lev'}), time_mask=time_mask) if 'lev' in ds_copy[svar].dims: ds_copy[svar] = ds_copy[svar].sel(lev=p_level, method='nearest') ds_copy = compute_weighted_averages(ds_copy, var, model_name) ds_copy[var].attrs['Calc_weight_mean'] = str( is_weighted_avg_var(var)) + ' map' if save_avg: filen = filename_map_avg(model_name, case_name, var, from_time, to_time, avg_over_lev, pmin, p_level, pressure_coord, lev_was_coord=had_lev_coord, time_mask=time_mask) practical_functions.make_folders(filen) practical_functions.save_dataset_to_netcdf(ds_copy, filen) xr_out[var] = ds_copy[var] return xr_out
# name: python3 # --- # %% from useful_scit.plot.fig_manip import subp_insert_abc # %% from sectional_v2.constants import get_plotpath from sectional_v2.util.practical_functions import make_folders from IPython.display import clear_output plot_path = get_plotpath('comparison') +'prof_map_abs' print(plot_path) make_folders(plot_path) fn_base = plot_path + '/abs_' print(fn_base) make_folders(fn_base) # %% from sectional_v2.util.plot.plot_maps import plot_map_diff, fix_axis4map_plot, plot_map_abs_abs_diff, plot_map,plot_map_diff_only from useful_scit.imps import (np, xr, plt, pd) from sectional_v2.util.imports import get_averaged_fields from sectional_v2.util.plot.plot_profiles import plot_profile, set_legend_area_profs, set_scalar_formatter # load and autoreload from useful_scit.plot import get_cmap_dic from IPython import get_ipython # noinspection PyBroadException
# %% cases_sec = ['SECTv21_ctrl'] cases_orig = ['noSECTv21_default_dd', 'noSECTv21_ox_ricc_dd'] # cases_orig =['noSECTv21_ox_ricc'] cases = cases_orig + cases_sec # %% # %% version = 'v21dd' plot_path = get_plotpath('levlat') filen_base = plot_path + '/_%s' % version # print(plot_path) make_folders(plot_path) # %% # %% def load_and_plot_diffs(varl, case_ctrl, case_other, start_time, end_time, pressure_coords=True, relative=False, cbar_orient='vertical', asp_ratio=2, subfig_size=3, ncol=None, ylim=None, yscale='log', norm=None ): if ylim is None:
print('combining to total distribution:') ds = combine_to_total_dist(ds) # %% print('Computing all subsets and flags') ds: xr.Dataset ds_out = compute_all_subsets_percs_flag(ds) # %% ds_out['dNdlog10dp'] = np.log(10) * ds_out['dNdlogD'] ds_out['dNdlog10dp_mod'] = np.log(10) * ds_out['dNdlogD_mod'] if 'dNdlogD_sec' in ds: ds_out['dNdlog10dp_sec'] = np.log(10) * ds_out['dNdlogD_sec'] del_o = ds_out.to_netcdf(fn, compute=False) with ProgressBar(): results = del_o.compute() return ds_out # %% def combine_to_total_dist(ds): if 'dNdlogD_sec' in ds: ds['dNdlogD'] = ds['dNdlogD_mod'] + ds['dNdlogD_sec'] else: ds['dNdlogD'] = ds['dNdlogD_mod'] return ds def get_savepath_distc_model_ds(case, from_t, to_t): fn = savepath_distc_model_ds + '/distc_%s_%s_%s.nc' % (case, from_t, to_t) make_folders(fn) return fn
def get_average_area(xr_ds: xr.Dataset, varList: list, case_name: str, area: str, from_time, to_time, model_name: str, pmin: float, avg_over_lev: bool, p_level: float, pressure_coords: bool, look_for_file: bool = True, ) -> xr.Dataset: """ :param from_time: :param to_time: :param xr_ds: :param varList: :param model_name: :param pmin: :param case_name: :param avg_over_lev: :param p_level: :param pressure_coords: :param look_for_file: :return: """ from_time = from_time #xr_ds.attrs['startyear'] to_time = to_time #xr_ds.attrs['endyear'] xr_out = xr_ds.copy() for var in varList: print(var) found_area_mean = False ds_area_avgs, file_found = load_area_file_var(model_name, case_name, var, area, from_time, to_time, avg_over_lev, pmin, p_level, pressure_coords) if file_found: xr_out[var] = ds_area_avgs[var] if not found_area_mean or not look_for_file: sub_varL = get_fields4weighted_avg(var) dummy = xr_ds.copy() for svar in sub_varL: lev_was_coord = False if 'lev' in xr_ds[svar].dims: lev_was_coord=True if avg_over_lev: dummy = average_model_var(dummy, svar, area=area, minp=pmin, dim = list(xr_ds[svar].dims)) #\ else: dummy = average_model_var(dummy, svar, area=area, dim = list(set(xr_ds[svar].dims)-{'lev'}))#.sel(lev=p_level, method='nearest') print(dummy) print(list(set(xr_ds[svar].dims)-{'lev'})) if 'lev' in dummy.dims: dummy = dummy.sel(lev=p_level, method='nearest') dummy = compute_weighted_averages(dummy, var, model_name) dummy[var].attrs['Calc_weight_mean']=str(is_weighted_avg_var(var)) + ' area: %s'%area filen = filename_area_avg(var, model_name, case_name, area, from_time, to_time, avg_over_lev, pmin, p_level, pressure_coords, lev_was_coord=lev_was_coord) practical_functions.make_folders(filen) if ds_area_avgs is None: practical_functions.save_dataset_to_netcdf(dummy, filen) else: ds_area_avgs[var] = dummy[var] practical_functions.save_dataset_to_netcdf(ds_area_avgs, filen) xr_out[var] = dummy[var] return xr_out
def get_Nd_output_name(self, out_varn): fn = self.coll_mod.savepath_coll_ds( out_varn ) #(out_varn, self.model_name, self.case_name, self.from_time, self.to_time) make_folders(fn) return fn
#pd.DataFrame.to_xarray() # %% def backup_filename(path): npath = str(path) _ss = npath.split('/') npath = '/'.join(_ss[:-1]) + '/backup/' + _ss[-1] return npath # %% paths = list(Path(dir_collocated).rglob('*.nc')) list(paths) len(paths) # %% for path in paths: if '/backup/' in str(path): continue print(path.name) ds = xr.open_dataset(path).load() if 'station_tab' in ds: ds.close() continue ds.close() npath = backup_filename(path) make_folders(npath) shutil.copy2(path, npath) ds.to_netcdf(npath) ds_n = fix_coord_station(ds) ds_n.to_netcdf(path)
def plot_Nd_bars_all_models_break_ECHAM(nested_pd_model, models, area, N_vars, relative=True, sharey_for_diffrel=False, sharey_for_ctrl=False, fn_bs='', plt_path='plots/bars_non_stacked/', cmap='colorblind', format='png'): """ Break axis for ECHAM :param nested_pd_model: :param models: :param area: :param N_vars: :param relative: :param sharey_for_diffrel: :param sharey_for_ctrl: :param without_be20: :param plt_path: :param cmap: :return: """ plt_path = plt_path + area + '/' practical_functions.make_folders(plt_path) filen_base = plt_path + fn_bs cmap = sns.color_palette(cmap, len(N_vars)) # If relative, break only ctrl: if relative: fig, gs, axs = mba.make_my_grid_subplots([1, 5], [4, 4, 1, 3]) else: fig, gs, axs = mba.make_my_grid_subplots([3, 8], [4, 4, 1, 3]) for ax in axs.flatten(): ax.grid(True, axis='x') ii = 0 filen = filen_base # plt_path+'bars_Nd_ctr_diff' for model in models + ['ECHAM']: pl_pd = nested_pd_model[ model] # .drop(['N$_{d<20}$'])#, axis=1)#, axis=0)#.transpose() pl_pd.index.name = None plot_Nd_bars_in_ax_CTRL(axs[ii, 0], model, pl_pd, cmap) plot_Nd_bars_in_ax_DIFF(axs[ii, 1], model, pl_pd, relative, cmap) if relative: axs[ii, 0].set_ylabel('#/cm$^3$', fontsize=14) axs[ii, 1].set_ylabel('%', fontsize=14) else: axs[ii, 0].set_ylabel('#/cm$^3$', fontsize=14) axs[ii, 1].set_ylabel('#/cm$^3$', fontsize=14) filen = filen + '_' + model if ii < len(models): # remove tick labels axs[ii, 1].get_xaxis().set_ticklabels([]) axs[ii, 0].get_xaxis().set_ticklabels([]) ii += 1 if relative: model = 'ECHAM' ax = fig.add_subplot(gs[8:, 1:]) pl_pd = nested_pd_model[model] pl_pd.index.name = None plot_Nd_bars_in_ax_DIFF(ax, model, pl_pd, relative, cmap) ax.set_ylabel('%', fontsize=14) fig.delaxes(axs[2, 1]) fig.delaxes(axs[3, 1]) plot_settings.insert_abc_where(ax, 14, 2 * 2 + 1, ratioxy=1.2) axs[2, 0].set_ylabel('', visible=False) axs[3, 0].set_ylabel(' #/cm$^3$', fontsize=14) # , visible=False) if not relative: axs[2, 1].set_ylabel('', visible=False) axs[3, 1].set_ylabel(' #/cm$^3$', fontsize=14) # , visible=False) for ax in axs[3, :]: ax.title.set_visible(False) if sharey_for_diffrel: set_equal_axis(axs[:, 1], which='y') if sharey_for_ctrl: set_equal_axis(axs[:, 0], which='y') for ii in np.arange(len(models) - 1): plot_settings.insert_abc_where(axs[ii, 0], 14, ii * 2, ratioxy=.8) plot_settings.insert_abc_where(axs[ii, 1], 14, ii * 2 + 1, ratioxy=1.2) plot_settings.insert_abc_where(axs[2, 0], 14, 2 * 2, ratioxy=.8) if not relative: plot_settings.insert_abc_where(axs[2, 1], 14, 2 * 2 + 1, ratioxy=3.) if relative: filen = filen + '_rel.%s' % format else: filen = filen + '.%s' % format print(filen) if relative: mba.broken_axis(axs[2:, 0], [1000, 5500]) else: mba.broken_axis(axs[2:, 0], [1000, 5500]) mba.broken_axis(axs[2:, 1], [21, 25]) gs.tight_layout(fig, pad=0.3) print('Saving file to: %s' % filen) plt.savefig(filen, dpi=300) plt.show()
def plot_Nd_bars_n_areas(nested_pd_areas, model, areas, N_vars, cases, areas_label, relative=True, sharey_for_diffrel=False, sharey_for_ctrl=False, without_be20=True, plt_path='plots/bars_non_stacked/', cmap='colorblind', fn_base='bars_Nd_areas', format='png'): """ :param nested_pd_model: :param models: :param area: :param N_vars: :param relative: :param sharey_for_diffrel: :param sharey_for_ctrl: :param without_be20: :param plt_path: :param cmap: :return: """ areas_str = '_'.join(areas) plt_path = plt_path + 'm_areas/' practical_functions.make_folders(plt_path) filen_base = plt_path + fn_base + areas_str cmap = sns.color_palette(cmap, len(N_vars)) if len(cases) == 3: #Yields_only: fig, axs = plt.subplots(2, 2, figsize=[8, 4 * len(areas)], gridspec_kw={'width_ratios': [1, 2]}) else: fig, axs = plt.subplots(2, 2, figsize=[11, 5 * len(areas)], gridspec_kw={'width_ratios': [1, 4]}) #fig, axs = plt.subplots(len(areas), 2, figsize=[12, 11], gridspec_kw={'width_ratios': [1, 5]}) ii = 0 filen = filen_base # plt_path+'bars_Nd_ctr_diff' if without_be20: filen = filen + 'no_sub20' for area, ii in zip(areas, range(0, len(areas))): nested_pd_model = nested_pd_areas[area][model][cases] if without_be20 and ('N$_{d<20}$' in nested_pd_model.index): pl_pd = nested_pd_model.drop( ['N$_{d<20}$']) # , axis=1)#, axis=0)#.transpose() else: pl_pd = nested_pd_model # .drop(['N$_{d<20}$'])#, axis=1)#, axis=0)#.transpose() pl_pd.index.name = None plot_Nd_bars_in_ax_CTRL(axs[ii, 0], model, pl_pd, cmap, header=areas_label[area]) plot_Nd_bars_in_ax_DIFF(axs[ii, 1], model, pl_pd, relative, cmap, header=areas_label[area]) if relative: axs[ii, 0].set_ylabel('#/cm$^3$', fontsize=14) axs[ii, 1].set_ylabel('%', fontsize=14) else: axs[ii, 0].set_ylabel('#/cm$^3$', fontsize=14) axs[ii, 1].set_ylabel('#/cm$^3$', fontsize=14) filen = filen + '_' + model if ii < len(areas) - 1: axs[ii, 1].get_xaxis().set_ticklabels([]) axs[ii, 0].get_xaxis().set_ticklabels([]) ii += 1 if sharey_for_diffrel: set_equal_axis(axs[:, 1], which='y') if sharey_for_ctrl: set_equal_axis(axs[:, 0], which='y') for ii in np.arange(len(areas)): plot_settings.insert_abc_where(axs[ii, 0], 14, ii * 2, ratioxy=.8) plot_settings.insert_abc_where(axs[ii, 1], 14, ii * 2 + 1, ratioxy=1.1) # sensitivity_scripts.plot_settings.insert_abc(axs[ii,0],14,ii*2) # sensitivity_scripts.plot_settings.insert_abc(axs[ii,1],14,ii*2+1) if relative: filen = filen + '_rel.%s' % format else: filen = filen + '.%s' % format print(filen) plt.tight_layout(pad=2.) plt.savefig(filen, dpi=300) plt.show()
def plot_bars_ctr_and_diff(nested_cases, var, versions_dic, ctrl, sens_cases, versions, avg_over_lev, pmin, p_level, area, relative=False, pressure_coord=True, figsize = [6,4], FONT_SIZE = 12): """ Plots two or more versions or models with corresponding sensitivity tests. E.g. NorESM and EC-Earth with sensitivity tests 2xCO2 and 4xCO2 would look like: EXAMPLE: nested_cases={'NorESM_CTRL': xr_ds1, 'EC_Earth_CTRL': xr_ds2, 'NorESM_2xCO2':xr_ds3,'EC_Earth_2xCO2': xr_ds4 etc} versions_dic = {'NorESM':{'CTRL':'NorESM_CTRL', '2xCO2':'NorESM_2xCO2', '4xCO2':NorESM_4xCO2'}, 'EC-Earth':{'CTRL':'EC_Earth_CTRL','2xCO2':'EC_Earth_2xCO2,..etc.}} var = 'N_AER' # number concentration aerosols ctrl = 'CTRL' sens_cases = ['2xCO2','4xCO2'] versions = ['NorESM', 'EC-Earth'] avg_over_lev=True # if plotted variable avg over lev pmin= 850. # avg up to 850. p_level = 1013. # if not avg_over_lev relative = False plot_bars_ctr_and_diff(nested_cases, var, versions_dic, ctrl, sens_cases, versions, avg_over_lev, pmin, p_level, relative=relative) :param nested_cases: :param var: :param versions_dic: :param ctrl: :param sens_cases: :param versions: :param avg_over_lev: :param pmin: :param p_level: :param relative: :param figsize: :param FONT_SIZE: :return: """ fig, axs = plt.subplots(1, 2, figsize=figsize, gridspec_kw={'width_ratios': [1, len(sens_cases)]}) plot_bars_2gr_diff(axs, ctrl, nested_cases, relative, sens_cases, var, versions, versions_dic) plt.tight_layout() plt_path = 'plots/bar_plots/' figname = plt_path + area + '/'# for version in versions: figname = figname + '_' + version.replace(' ','_') figname = figname + '/' + var if avg_over_lev: figname = figname + '_2lev%.0f' %pmin else: figname = figname + '_atlev%.0f' %p_level if not pressure_coord: figname = figname + '_not_pres_coord' for version in versions: figname = figname + '_' + version.replace(' ','_') for case in sens_cases: figname = figname + '_' + case.replace(' ','_') if relative: figname = figname + 'relative' figname = figname + '.png' axs[1].set_title('Difference to CTRL')#, fontsize=FONT_SIZE) axs[0].set_title('CTRL')#, fontsize=FONT_SIZE) practical_functions.make_folders(figname) print(figname) plt.savefig(figname, dpi=300) return axs