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
