def plot_bfe_row_for_var(finfo_to_season_to_diff=None, ax_list=None, season_titles=False,
varname="", basemap_info=None):
cmap = cm.get_cmap("RdBu_r", 20)
assert isinstance(basemap_info, BasemapInfo)
xx, yy = None, None
cs = None
for finfo, season_to_diff in finfo_to_season_to_diff.items():
assert isinstance(finfo, FieldInfo)
if finfo.varname != varname:
continue
for season in season_to_diff:
season_to_diff[season] = infovar.get_to_plot(varname, season_to_diff[season], difference=True,
lons=basemap_info.lons, lats=basemap_info.lats)
clevs = get_diff_levels(season_to_diff, ncolors=cmap.N, varname=varname)
for i, (season, diff) in enumerate(season_to_diff.items()):
ax = ax_list[i]
if xx is None or yy is None:
xx, yy = basemap_info.get_proj_xy()
print(diff.shape)
cs = basemap_info.basemap.contourf(xx, yy, diff[:], cmap=cmap,
levels=clevs,
extend="both", ax=ax)
basemap_info.basemap.drawcoastlines(ax=ax)
# ax.set_aspect("auto")
basemap_info.basemap.readshapefile(BASIN_BOUNDARIES_SHP[:-4], "basin", ax=ax)
if season_titles:
ax.set_title(season)
if i == 0:
ax.set_ylabel(infovar.get_long_display_label_for_var(finfo.varname))
if finfo.varname in ["I5", ] and season.lower() in ["summer"]:
ax.set_visible(False)
ax = ax_list[-1]
# ax.set_aspect(30)
ax.set_title(infovar.get_units(varname))
plt.colorbar(cs, cax=ax_list[-1])
def plot_seasonal_mean_biases(season_to_error_field=None, varname="", basemap_info=None):
assert isinstance(basemap_info, BasemapInfo)
cmap = cm.get_cmap("RdBu_r", 20)
# Set to False if you want the limits to be recalculated from data
manual_limits = True
minval = min([np.percentile(field[~field.mask], 95) for s, field in season_to_error_field.items()])
maxval = max([np.percentile(field[~field.mask], 95) for s, field in season_to_error_field.items()])
if manual_limits:
if varname == "PR":
minval, maxval = -3, 3
if varname == "TT":
minval, maxval = -7, 7
d = max(abs(minval), abs(maxval))
clevs = MaxNLocator(nbins=cmap.N, symmetric=True).tick_values(-d, d)
fig_path = img_folder.joinpath("{}.png".format(varname))
fig = plt.figure()
nrows = 2
ncols = 2
gs = GridSpec(nrows, ncols=ncols + 1, width_ratios=[1, 1, 0.05])
xx, yy = basemap_info.get_proj_xy()
cs = None
for i, season in enumerate(season_to_error_field):
row = i // ncols
col = i % ncols
ax = fig.add_subplot(gs[row, col])
cs = basemap_info.basemap.contourf(xx, yy, season_to_error_field[season], ax=ax, cmap=cmap, levels=clevs,
extend="both")
basemap_info.basemap.drawcoastlines()
ax.set_title(season)
# basemap_info.basemap.colorbar(cs)
cax = fig.add_subplot(gs[:, -1])
cax.set_title(infovar.get_units(var_name=varname))
plt.colorbar(cs, cax=cax)
with fig_path.open("wb") as figfile:
fig.savefig(figfile, format="png", bbox_inches="tight")
plt.close(fig)
def plot_seasonal_mean_biases(season_to_error_field=None, varname="", basemap_info=None,
axes_list=None):
assert isinstance(basemap_info, BasemapInfo)
# Set to False if you want the limits to be recalculated from data
manual_limits = True
d = max([np.percentile(np.abs(field[~field.mask]), 95) for s, field in season_to_error_field.items()])
if manual_limits and varname in ["PR", "TT", "I5"]:
clevs = np.arange(-d, 1.1 * d, 0.1 * d)
if varname == "PR":
clevs = np.arange(-3, 3.5, 0.5)
if varname == "TT":
clevs = np.arange(-7, 8, 1)
if varname == "I5":
clevs = np.arange(-100, 110, 10)
else:
clevs = MaxNLocator(nbins=10, symmetric=True).tick_values(-d, d)
cmap = cm.get_cmap("RdBu_r", len(clevs) - 1)
fig = None
fig_path = None
if axes_list is None:
fig_path = img_folder.joinpath("{}.png".format(varname))
fig = plt.figure()
nrows = 2
ncols = 2
gs = GridSpec(nrows, ncols=ncols + 1, width_ratios=[1, 1, 0.05])
xx, yy = basemap_info.get_proj_xy()
cs = None
for i, season in enumerate(season_to_error_field):
row = i // ncols
col = i % ncols
if axes_list is None:
ax = fig.add_subplot(gs[row, col])
else:
ax = axes_list[i]
basemap_info.draw_map_background(ax)
cs = basemap_info.basemap.contourf(xx, yy, season_to_error_field[season][:], ax=ax, cmap=cmap, levels=clevs,
extend="both")
basemap_info.basemap.drawcoastlines(ax=ax, linewidth=0.3)
ax.set_title(season)
if i == 0:
ax.set_ylabel(infovar.get_long_display_label_for_var(varname=varname))
# basemap_info.basemap.colorbar(cs)
if basemap_info.should_draw_basin_boundaries:
basemap_info.basemap.readshapefile(BASIN_BOUNDARIES_SHP[:-4], "basin", ax=ax)
# Hide snow plots for summer
if varname in ["I5"] and season.lower() in ["summer"]:
ax.set_visible(False)
# Plot a colorbar for each subplot if required.
if hasattr(basemap_info, "draw_colorbar_for_each_subplot"):
if basemap_info.draw_colorbar_for_each_subplot:
cb = basemap_info.basemap.colorbar(cs, ax=ax)
cb.ax.set_title(infovar.get_units(var_name=varname))
cax = fig.add_subplot(gs[:, -1]) if axes_list is None else axes_list[-1]
# Add the colorbar if there are additional axes supplied for it
if len(axes_list) > len(season_to_error_field):
cax.set_title(infovar.get_units(var_name=varname))
plt.colorbar(cs, cax=cax)
if axes_list is None:
with fig_path.open("wb") as figfile:
fig.savefig(figfile, format="png", bbox_inches="tight")
plt.close(fig)
return cs
def _plot_row(vname="", level=0, config_dict=None, plot_cc_only_for=None, mark_significance=True):
"""
if plot_cc_only_for is not None, should be equal to the label of the simulation to be plotted
"""
lons, lats = config_dict.lons, config_dict.lats
bmp = config_dict.basemap
"""
:type bmp: mpl_toolkits.basemap.Basemap
"""
xx, yy = bmp(lons, lats)
lons[lons > 180] -= 360
fig = config_dict.fig
gs = config_dict.gs
""":type : matplotlib.gridspec.GridSpec """
nrows_subplots, ncols_subplots = gs.get_geometry()
label_base = config_dict.label_base
label_modif = config_dict.label_modif
the_row = config_dict.the_row
season_to_months = config_dict.season_to_months
if "+" in vname or "-" in vname:
op = "+" if "+" in vname else "-"
vname1, vname2 = vname.split(op)
vname1 = vname1.strip()
vname2 = vname2.strip()
current_base = {}
future_base = {}
current_modif = {}
future_modif = {}
# vname1
current_base1 = compute_seasonal_means_for_each_year(config_dict["Current"][label_base], var_name=vname1,
level=level,
season_to_months=season_to_months)
future_base1 = compute_seasonal_means_for_each_year(config_dict["Future"][label_base], var_name=vname1,
level=level,
season_to_months=season_to_months)
current_modif1 = compute_seasonal_means_for_each_year(config_dict["Current"][label_modif], var_name=vname1,
level=level,
season_to_months=season_to_months)
future_modif1 = compute_seasonal_means_for_each_year(config_dict["Future"][label_modif], var_name=vname1,
level=level,
season_to_months=season_to_months)
# vname2
current_base2 = compute_seasonal_means_for_each_year(config_dict["Current"][label_base], var_name=vname2,
level=level,
season_to_months=season_to_months)
future_base2 = compute_seasonal_means_for_each_year(config_dict["Future"][label_base], var_name=vname2,
level=level,
season_to_months=season_to_months)
current_modif2 = compute_seasonal_means_for_each_year(config_dict["Current"][label_modif], var_name=vname2,
level=level,
season_to_months=season_to_months)
future_modif2 = compute_seasonal_means_for_each_year(config_dict["Future"][label_modif], var_name=vname2,
level=level,
season_to_months=season_to_months)
for season in current_base1:
current_base[season] = eval("current_base2[season]{}current_base1[season]".format(op))
future_base[season] = eval("future_base2[season]{}future_base1[season]".format(op))
current_modif[season] = eval("current_modif2[season]{}current_modif1[season]".format(op))
future_modif[season] = eval("future_modif2[season]{}future_modif1[season]".format(op))
else:
current_base = compute_seasonal_means_for_each_year(config_dict["Current"][label_base], var_name=vname,
level=level,
season_to_months=season_to_months)
future_base = compute_seasonal_means_for_each_year(config_dict["Future"][label_base], var_name=vname,
level=level,
season_to_months=season_to_months)
current_modif = compute_seasonal_means_for_each_year(config_dict["Current"][label_modif], var_name=vname,
level=level,
season_to_months=season_to_months)
future_modif = compute_seasonal_means_for_each_year(config_dict["Future"][label_modif], var_name=vname,
level=level,
season_to_months=season_to_months)
# Calculate the differences in cc signal
season_to_diff = OrderedDict()
season_to_plot_diff = OrderedDict()
diff_max = 0
print(list(current_base.keys()))
# Get the ranges for colorbar and calculate p-values
print("------------------ impacts on projected changes to {} -----------------------".format(vname))
season_to_pvalue = OrderedDict()
for season in list(current_base.keys()):
_, pvalue_current = ttest_ind(current_modif[season], current_base[season], axis=0, equal_var=False)
_, pvalue_future = ttest_ind(future_modif[season], future_base[season], axis=0, equal_var=False)
if plot_cc_only_for is None:
season_to_pvalue[season] = np.minimum(pvalue_current, pvalue_future)
season_to_diff[season] = (future_modif[season] - current_modif[season]) - \
(future_base[season] - current_base[season])
else:
if plot_cc_only_for == label_base:
_, season_to_pvalue[season] = ttest_ind(future_base[season], current_base[season], axis=0, equal_var=False)
c_data = current_base[season]
f_data = future_base[season]
else:
_, season_to_pvalue[season] = ttest_ind(future_modif[season], current_modif[season], axis=0, equal_var=False)
c_data = current_modif[season]
f_data = future_modif[season]
season_to_diff[season] = f_data - c_data
# Convert units if required
if vname in config_dict.multipliers:
season_to_diff[season] *= config_dict.multipliers[vname]
field_to_plot = infovar.get_to_plot(vname, season_to_diff[season].mean(axis=0), lons=lons, lats=lats)
season_to_plot_diff[season] = field_to_plot
print("{}: {}".format(season, season_to_plot_diff[season].mean()))
if hasattr(field_to_plot, "mask"):
diff_max = max(np.percentile(np.abs(field_to_plot[~field_to_plot.mask]), 95), diff_max)
else:
diff_max = max(np.percentile(np.abs(field_to_plot), 95), diff_max)
print("--------------------------------------------------------")
img = None
locator = MaxNLocator(nbins=10, symmetric=True)
clevels = locator.tick_values(-diff_max, diff_max)
bn = BoundaryNorm(clevels, len(clevels) - 1)
cmap = cm.get_cmap("RdBu_r", len(clevels) - 1)
for col, season in enumerate(current_base.keys()):
ax = fig.add_subplot(gs[the_row, col])
if not col:
ax.set_ylabel(infovar.get_long_display_label_for_var(vname))
if not the_row:
ax.set_title(season)
img = bmp.pcolormesh(xx, yy, season_to_plot_diff[season].copy(),
vmin=-diff_max, vmax=diff_max,
cmap=cmap, norm=bn, ax=ax)
# logging
good_vals = season_to_plot_diff[season]
good_vals = good_vals[~good_vals.mask]
print("------" * 10)
print("{}: min={}; max={}; area-avg={};".format(season, good_vals.min(), good_vals.max(), good_vals.mean()))
bmp.readshapefile(quebec_info.BASIN_BOUNDARIES_DERIVED_10km[:-4], "basin_edge", ax=ax)
p = season_to_pvalue[season]
if hasattr(season_to_plot_diff[season], "mask"):
p = np.ma.masked_where(season_to_plot_diff[season].mask, p)
if plot_cc_only_for is not None and mark_significance:
cs = bmp.contourf(xx, yy, p, hatches=["..."], levels=[0.05, 1], colors='none')
if (col == ncols_subplots - 2) and (the_row == nrows_subplots - 1):
# create a legend for the contour set
artists, labels = cs.legend_elements()
labels = ["not significant"]
ax.legend(artists, labels, handleheight=1, loc="upper right",
bbox_to_anchor=(1.0, -0.05), borderaxespad=0., frameon=False)
bmp.drawcoastlines(ax=ax, linewidth=0.4)
if vname in ["I5"] and season.lower() in ["summer"]:
ax.set_visible(False)
cb = plt.colorbar(img, cax=fig.add_subplot(gs[the_row, len(current_base)]), extend="both")
if hasattr(config_dict, "name_to_units") and vname in config_dict.name_to_units:
cb.ax.set_title(config_dict.name_to_units[vname])
else:
cb.ax.set_title(infovar.get_units(vname))
def compare(paths=None, path_to_control_data=None, control_label="",
labels=None, varnames=None, levels=None, months_of_interest=None,
start_year=None, end_year=None):
"""
Comparing 2D fields
:param paths: paths to the simulation results
:param varnames:
:param labels: Display name for each simulation (number of labels should
be equal to the number of paths)
:param path_to_control_data: the path with which the comparison done i.e. a in the following
formula
delta = (x - a)/a * 100%
generates one image file per variable (in the folder images_for_lake-river_paper):
compare_varname_<control_label>_<label1>_..._<labeln>_startyear_endyear.png
"""
# get coordinate data (assumes that all the variables and runs have the same coordinates)
lons2d, lats2d, basemap = analysis.get_basemap_from_hdf(file_path=path_to_control_data)
x, y = basemap(lons2d, lats2d)
lake_fraction = analysis.get_array_from_file(path=path_to_control_data, var_name="lake_fraction")
if lake_fraction is None:
lake_fraction = np.zeros(lons2d.shape)
ncolors = 10
# +1 to include white
diff_cmap = cm.get_cmap("RdBu_r", ncolors + 1)
for var_name, level in zip(varnames, levels):
sfmt = infovar.get_colorbar_formatter(var_name)
control_means = analysis.get_mean_2d_fields_for_months(path=path_to_control_data, var_name=var_name,
months=months_of_interest,
start_year=start_year, end_year=end_year,
level=level)
control_mean = np.mean(control_means, axis=0)
fig = plt.figure()
assert isinstance(fig, Figure)
gs = gridspec.GridSpec(2, len(paths) + 1, wspace=0.5)
# plot the control
ax = fig.add_subplot(gs[0, 0])
assert isinstance(ax, Axes)
ax.set_title("{0}".format(control_label))
ax.set_ylabel("Mean: $X_{0}$")
to_plot = infovar.get_to_plot(var_name, control_mean,
lake_fraction=lake_fraction, mask_oceans=True, lons=lons2d, lats=lats2d)
# determine colorabr extent and spacing
field_cmap, field_norm = infovar.get_colormap_and_norm_for(var_name, to_plot, ncolors=ncolors)
basemap.pcolormesh(x, y, to_plot, cmap=field_cmap, norm=field_norm)
cb = basemap.colorbar(format=sfmt)
assert isinstance(cb, Colorbar)
# cb.ax.set_ylabel(infovar.get_units(var_name))
units = infovar.get_units(var_name)
info = "Variable:" \
"\n{0}" \
"\nPeriod: {1}-{2}" \
"\nMonths: {3}" \
"\nUnits: {4}"
info = info.format(infovar.get_long_name(var_name), start_year, end_year,
",".join([datetime(2001, m, 1).strftime("%b") for m in months_of_interest]), units)
ax.annotate(info, xy=(0.1, 0.3), xycoords="figure fraction")
sel_axes = [ax]
for the_path, the_label, column in zip(paths, labels, list(range(1, len(paths) + 1))):
means_for_years = analysis.get_mean_2d_fields_for_months(path=the_path, var_name=var_name,
months=months_of_interest,
start_year=start_year, end_year=end_year)
the_mean = np.mean(means_for_years, axis=0)
# plot the mean value
ax = fig.add_subplot(gs[0, column])
sel_axes.append(ax)
ax.set_title("{0}".format(the_label))
to_plot = infovar.get_to_plot(var_name, the_mean, lake_fraction=lake_fraction,
mask_oceans=True, lons=lons2d, lats=lats2d)
basemap.pcolormesh(x, y, to_plot, cmap=field_cmap, norm=field_norm)
ax.set_ylabel("Mean: $X_{0}$".format(column))
cb = basemap.colorbar(format=sfmt)
# cb.ax.set_ylabel(infovar.get_units(var_name))
# plot the difference
ax = fig.add_subplot(gs[1, column])
sel_axes.append(ax)
ax.set_ylabel("$X_{0} - X_0$".format(column))
# #Mask only if the previous plot (means) is masked
thediff = the_mean - control_mean
if hasattr(to_plot, "mask"):
to_plot = np.ma.masked_where(to_plot.mask, thediff)
else:
to_plot = thediff
if var_name == "PR": # convert to mm/day
to_plot = infovar.get_to_plot(var_name, to_plot, mask_oceans=False)
vmin = np.ma.min(to_plot)
vmax = np.ma.max(to_plot)
d = max(abs(vmin), abs(vmax))
vmin = -d
vmax = d
field_norm, bounds, vmn_nice, vmx_nice = infovar.get_boundary_norm(vmin, vmax, diff_cmap.N,
exclude_zero=False)
basemap.pcolormesh(x, y, to_plot, cmap=diff_cmap, norm=field_norm, vmin=vmn_nice, vmax=vmx_nice)
cb = basemap.colorbar(format=sfmt)
t, pval = ttest_ind(means_for_years, control_means, axis=0)
sig = pval < 0.1
basemap.contourf(x, y, sig.astype(int), nlevels=2, hatches=["+", None], colors="none")
# cb.ax.set_ylabel(infovar.get_units(var_name))
# plot coastlines
for the_ax in sel_axes:
basemap.drawcoastlines(ax=the_ax, linewidth=common_plot_params.COASTLINE_WIDTH)
# depends on the compared simulations and the months of interest
fig_file_name = "compare_{0}_{1}_{2}_months-{3}.jpeg".format(var_name, control_label,
"_".join(labels),
"-".join([str(m) for m in months_of_interest]))
figpath = os.path.join(images_folder, fig_file_name)
fig.savefig(figpath, dpi=cpp.FIG_SAVE_DPI, bbox_inches="tight")
plt.close(fig)
def _plot_row(axes, data, sim_label, var_name, increments=False,
domain_props=None, season_list=None, significance=None):
# data is a dict of season -> field
# the field is a control mean in the case of the control mean
# and the difference between the modified simulation and the control mean in the case of the modified simulation
exclude_0_from_diff_colorbar = False
assert isinstance(domain_props, DomainProperties)
print("plotting row for {0}; increments = ({1})".format(var_name, increments))
lons2d, lats2d, basemap = domain_props.get_lon_lat_and_basemap()
x, y = domain_props.x, domain_props.y
vmin = None
vmax = None
# determine vmin and vmax for the row
for season, field in data.items():
# field = _get_to_plot(var_name, field, lake_fraction=domain_props.lake_fraction, lons=lons2d, lats = lats2d)
min_current, max_current = np.percentile(field[~field.mask], 1), np.percentile(field[~field.mask], 99)
if vmin is None or min_current < vmin:
vmin = min_current
if vmax is None or max_current > vmax:
vmax = max_current
ncolors = 13 if exclude_0_from_diff_colorbar else 10
bounds = None
if increments:
# +1 to include white
if vmin * vmax >= 0:
if vmin >= 0:
field_cmap = cm.get_cmap("YlOrBr_r", ncolors)
else:
field_cmap = cm.get_cmap("YlGnBu_r", ncolors)
field_norm, bounds, bounds_min, bounds_max = infovar.get_boundary_norm(vmin, vmax, ncolors,
exclude_zero=exclude_0_from_diff_colorbar,
varname=var_name,
difference=increments)
else:
field_cmap = cm.get_cmap("RdBu_r", ncolors)
d = max(abs(vmin), abs(vmax))
field_norm, bounds, bounds_min, bounds_max = infovar.get_boundary_norm(-d, d, ncolors,
exclude_zero=exclude_0_from_diff_colorbar,
varname=var_name,
difference=increments)
else:
# determine colorabr extent and spacing
field_cmap, field_norm = infovar.get_colormap_and_norm_for(var_name, vmin=vmin, vmax=vmax, ncolors=ncolors)
print("vmin = {0}; vmax = {1}".format(vmin, vmax))
col = 0
# axes[0].set_ylabel(sim_label)
im = None
for season in season_list:
field = data[season]
ax = axes[col]
if not increments:
# since the increments go below
ax.set_title(season)
else:
mean_val = float("{0:.1e}".format(field.mean()))
sf = ScalarFormatter(useMathText=True)
sf.set_powerlimits((-2, 3))
# ax.set_title(r"$\Delta_{\rm mean} = " + sf.format_data(mean_val) + " $")
basemap.drawmapboundary(ax=ax, fill_color="gray")
im = basemap.pcolormesh(x, y, field, norm=field_norm, cmap=field_cmap, ax=ax)
basemap.drawcoastlines(ax=ax, linewidth=cpp.COASTLINE_WIDTH)
if significance is not None:
cs = basemap.contourf(x, y, significance[season], levels=[0, 0.5, 1],
colors="none",
hatches=[None, ".."],
ax=ax)
# basemap.contour(x, y, significance[season], levels = [0.5, ], ax = ax,
# linewidths = 0.5, colors="k")
if col == 0 and False:
# create a legend for the contour set
artists, labels = cs.legend_elements()
ax.legend([artists[-1], ], ["Significant changes \n with (p = 0.1)", ],
handleheight=0.5, fontsize="x-small")
col += 1
# plot the common colorbar
if isinstance(field_norm, LogNorm):
cb = plt.colorbar(im, cax=axes[-1])
else:
cb = plt.colorbar(im, cax=axes[-1], extend="both", ticks=bounds)
cb.ax.set_title(infovar.get_units(var_name))
def compare(paths=None,
path_to_control_data=None,
control_label="",
labels=None,
varnames=None,
levels=None,
months_of_interest=None,
start_year=None,
end_year=None):
"""
Comparing 2D fields
:param paths: paths to the simulation results
:param varnames:
:param labels: Display name for each simulation (number of labels should
be equal to the number of paths)
:param path_to_control_data: the path with which the comparison done i.e. a in the following
formula
delta = (x - a)/a * 100%
generates one image file per variable (in the folder images_for_lake-river_paper):
compare_varname_<control_label>_<label1>_..._<labeln>_startyear_endyear.png
"""
# get coordinate data (assumes that all the variables and runs have the same coordinates)
lons2d, lats2d, basemap = analysis.get_basemap_from_hdf(
file_path=path_to_control_data)
x, y = basemap(lons2d, lats2d)
lake_fraction = analysis.get_array_from_file(path=path_to_control_data,
var_name="lake_fraction")
if lake_fraction is None:
lake_fraction = np.zeros(lons2d.shape)
ncolors = 10
# +1 to include white
diff_cmap = cm.get_cmap("RdBu_r", ncolors + 1)
for var_name, level in zip(varnames, levels):
sfmt = infovar.get_colorbar_formatter(var_name)
control_means = analysis.get_mean_2d_fields_for_months(
path=path_to_control_data,
var_name=var_name,
months=months_of_interest,
start_year=start_year,
end_year=end_year,
level=level)
control_mean = np.mean(control_means, axis=0)
fig = plt.figure()
assert isinstance(fig, Figure)
gs = gridspec.GridSpec(2, len(paths) + 1, wspace=0.5)
# plot the control
ax = fig.add_subplot(gs[0, 0])
assert isinstance(ax, Axes)
ax.set_title("{0}".format(control_label))
ax.set_ylabel("Mean: $X_{0}$")
to_plot = infovar.get_to_plot(var_name,
control_mean,
lake_fraction=lake_fraction,
mask_oceans=True,
lons=lons2d,
lats=lats2d)
# determine colorabr extent and spacing
field_cmap, field_norm = infovar.get_colormap_and_norm_for(
var_name, to_plot, ncolors=ncolors)
basemap.pcolormesh(x, y, to_plot, cmap=field_cmap, norm=field_norm)
cb = basemap.colorbar(format=sfmt)
assert isinstance(cb, Colorbar)
# cb.ax.set_ylabel(infovar.get_units(var_name))
units = infovar.get_units(var_name)
info = "Variable:" \
"\n{0}" \
"\nPeriod: {1}-{2}" \
"\nMonths: {3}" \
"\nUnits: {4}"
info = info.format(
infovar.get_long_name(var_name), start_year, end_year, ",".join([
datetime(2001, m, 1).strftime("%b") for m in months_of_interest
]), units)
ax.annotate(info, xy=(0.1, 0.3), xycoords="figure fraction")
sel_axes = [ax]
for the_path, the_label, column in zip(paths, labels,
list(range(1,
len(paths) + 1))):
means_for_years = analysis.get_mean_2d_fields_for_months(
path=the_path,
var_name=var_name,
months=months_of_interest,
start_year=start_year,
end_year=end_year)
the_mean = np.mean(means_for_years, axis=0)
# plot the mean value
ax = fig.add_subplot(gs[0, column])
sel_axes.append(ax)
ax.set_title("{0}".format(the_label))
to_plot = infovar.get_to_plot(var_name,
the_mean,
lake_fraction=lake_fraction,
mask_oceans=True,
lons=lons2d,
lats=lats2d)
basemap.pcolormesh(x, y, to_plot, cmap=field_cmap, norm=field_norm)
ax.set_ylabel("Mean: $X_{0}$".format(column))
cb = basemap.colorbar(format=sfmt)
# cb.ax.set_ylabel(infovar.get_units(var_name))
# plot the difference
ax = fig.add_subplot(gs[1, column])
sel_axes.append(ax)
ax.set_ylabel("$X_{0} - X_0$".format(column))
# #Mask only if the previous plot (means) is masked
thediff = the_mean - control_mean
if hasattr(to_plot, "mask"):
to_plot = np.ma.masked_where(to_plot.mask, thediff)
else:
to_plot = thediff
if var_name == "PR": # convert to mm/day
to_plot = infovar.get_to_plot(var_name,
to_plot,
mask_oceans=False)
vmin = np.ma.min(to_plot)
vmax = np.ma.max(to_plot)
d = max(abs(vmin), abs(vmax))
vmin = -d
vmax = d
field_norm, bounds, vmn_nice, vmx_nice = infovar.get_boundary_norm(
vmin, vmax, diff_cmap.N, exclude_zero=False)
basemap.pcolormesh(x,
y,
to_plot,
cmap=diff_cmap,
norm=field_norm,
vmin=vmn_nice,
vmax=vmx_nice)
cb = basemap.colorbar(format=sfmt)
t, pval = ttest_ind(means_for_years, control_means, axis=0)
sig = pval < 0.1
basemap.contourf(x,
y,
sig.astype(int),
nlevels=2,
hatches=["+", None],
colors="none")
# cb.ax.set_ylabel(infovar.get_units(var_name))
# plot coastlines
for the_ax in sel_axes:
basemap.drawcoastlines(
ax=the_ax, linewidth=common_plot_params.COASTLINE_WIDTH)
# depends on the compared simulations and the months of interest
fig_file_name = "compare_{0}_{1}_{2}_months-{3}.jpeg".format(
var_name, control_label, "_".join(labels),
"-".join([str(m) for m in months_of_interest]))
figpath = os.path.join(images_folder, fig_file_name)
fig.savefig(figpath, dpi=cpp.FIG_SAVE_DPI, bbox_inches="tight")
plt.close(fig)
def _plot_row(axes,
data,
sim_label,
var_name,
increments=False,
domain_props=None,
season_list=None,
significance=None):
# data is a dict of season -> field
# the field is a control mean in the case of the control mean
# and the difference between the modified simulation and the control mean in the case of the modified simulation
exclude_0_from_diff_colorbar = False
assert isinstance(domain_props, DomainProperties)
print("plotting row for {0}; increments = ({1})".format(
var_name, increments))
lons2d, lats2d, basemap = domain_props.get_lon_lat_and_basemap()
x, y = domain_props.x, domain_props.y
vmin = None
vmax = None
# determine vmin and vmax for the row
for season, field in data.items():
# field = _get_to_plot(var_name, field, lake_fraction=domain_props.lake_fraction, lons=lons2d, lats = lats2d)
min_current, max_current = np.percentile(field[~field.mask],
1), np.percentile(
field[~field.mask], 99)
if vmin is None or min_current < vmin:
vmin = min_current
if vmax is None or max_current > vmax:
vmax = max_current
ncolors = 13 if exclude_0_from_diff_colorbar else 10
bounds = None
if increments:
# +1 to include white
if vmin * vmax >= 0:
if vmin >= 0:
field_cmap = cm.get_cmap("YlOrBr_r", ncolors)
else:
field_cmap = cm.get_cmap("YlGnBu_r", ncolors)
field_norm, bounds, bounds_min, bounds_max = infovar.get_boundary_norm(
vmin,
vmax,
ncolors,
exclude_zero=exclude_0_from_diff_colorbar,
varname=var_name,
difference=increments)
else:
field_cmap = cm.get_cmap("RdBu_r", ncolors)
d = max(abs(vmin), abs(vmax))
field_norm, bounds, bounds_min, bounds_max = infovar.get_boundary_norm(
-d,
d,
ncolors,
exclude_zero=exclude_0_from_diff_colorbar,
varname=var_name,
difference=increments)
else:
# determine colorabr extent and spacing
field_cmap, field_norm = infovar.get_colormap_and_norm_for(
var_name, vmin=vmin, vmax=vmax, ncolors=ncolors)
print("vmin = {0}; vmax = {1}".format(vmin, vmax))
col = 0
# axes[0].set_ylabel(sim_label)
im = None
for season in season_list:
field = data[season]
ax = axes[col]
if not increments:
# since the increments go below
ax.set_title(season)
else:
mean_val = float("{0:.1e}".format(field.mean()))
sf = ScalarFormatter(useMathText=True)
sf.set_powerlimits((-2, 3))
# ax.set_title(r"$\Delta_{\rm mean} = " + sf.format_data(mean_val) + " $")
basemap.drawmapboundary(ax=ax, fill_color="gray")
im = basemap.pcolormesh(x,
y,
field,
norm=field_norm,
cmap=field_cmap,
ax=ax)
basemap.drawcoastlines(ax=ax, linewidth=cpp.COASTLINE_WIDTH)
if significance is not None:
cs = basemap.contourf(x,
y,
significance[season],
levels=[0, 0.5, 1],
colors="none",
hatches=[None, ".."],
ax=ax)
# basemap.contour(x, y, significance[season], levels = [0.5, ], ax = ax,
# linewidths = 0.5, colors="k")
if col == 0 and False:
# create a legend for the contour set
artists, labels = cs.legend_elements()
ax.legend([
artists[-1],
], [
"Significant changes \n with (p = 0.1)",
],
handleheight=0.5,
fontsize="x-small")
col += 1
# plot the common colorbar
if isinstance(field_norm, LogNorm):
cb = plt.colorbar(im, cax=axes[-1])
else:
cb = plt.colorbar(im, cax=axes[-1], extend="both", ticks=bounds)
cb.ax.set_title(infovar.get_units(var_name))
def plot_bfe_row_for_var(finfo_to_season_to_diff=None,
ax_list=None,
season_titles=False,
varname="",
basemap_info=None):
cmap = cm.get_cmap("RdBu_r", 20)
assert isinstance(basemap_info, BasemapInfo)
xx, yy = None, None
cs = None
for finfo, season_to_diff in finfo_to_season_to_diff.items():
assert isinstance(finfo, FieldInfo)
if finfo.varname != varname:
continue
for season in season_to_diff:
season_to_diff[season] = infovar.get_to_plot(
varname,
season_to_diff[season],
difference=True,
lons=basemap_info.lons,
lats=basemap_info.lats)
clevs = get_diff_levels(season_to_diff,
ncolors=cmap.N,
varname=varname)
for i, (season, diff) in enumerate(season_to_diff.items()):
ax = ax_list[i]
if xx is None or yy is None:
xx, yy = basemap_info.get_proj_xy()
print(diff.shape)
cs = basemap_info.basemap.contourf(xx,
yy,
diff[:],
cmap=cmap,
levels=clevs,
extend="both",
ax=ax)
basemap_info.basemap.drawcoastlines(ax=ax)
# ax.set_aspect("auto")
basemap_info.basemap.readshapefile(BASIN_BOUNDARIES_SHP[:-4],
"basin",
ax=ax)
if season_titles:
ax.set_title(season)
if i == 0:
ax.set_ylabel(
infovar.get_long_display_label_for_var(finfo.varname))
if finfo.varname in [
"I5",
] and season.lower() in ["summer"]:
ax.set_visible(False)
ax = ax_list[-1]
# ax.set_aspect(30)
ax.set_title(infovar.get_units(varname))
plt.colorbar(cs, cax=ax_list[-1])
def main():
if not img_folder.is_dir():
img_folder.mkdir(parents=True)
season_to_months = OrderedDict([
("Winter (DJF)", (1, 2, 12)),
("Spring (MAM)", range(3, 6)),
("Summer (JJA)", range(6, 9)),
("Fall (SON)", range(9, 12)),
])
varnames = ["TT", "PR"]
plot_utils.apply_plot_params(font_size=10, width_pt=None, width_cm=20, height_cm=17)
# reanalysis_driven_config = RunConfig(data_path="/RESCUE/skynet3_rech1/huziy/hdf_store/quebec_0.1_crcm5-hcd-rl.hdf5",
# start_year=1980, end_year=2010, label="ERAI-CRCM5-L")
#
reanalysis_driven_config = RunConfig(data_path="/RESCUE/skynet3_rech1/huziy/hdf_store/quebec_0.4_crcm5-hcd-rl.hdf5",
start_year=1980, end_year=2010, label="ERAI-CRCM5-L(0.4)")
nx_agg_model = 1
ny_agg_model = 1
nx_agg_anusplin = 4
ny_agg_anusplin = 4
gcm_driven_config = RunConfig(
data_path="/RESCUE/skynet3_rech1/huziy/hdf_store/cc-canesm2-driven/quebec_0.1_crcm5-hcd-rl-cc-canesm2-1980-2010.hdf5",
start_year=1980, end_year=2010, label="CanESM2-CRCM5-L")
bmp_info = analysis.get_basemap_info(r_config=reanalysis_driven_config)
xx, yy = bmp_info.get_proj_xy()
field_cmap = cm.get_cmap("jet", 10)
vname_to_clevels = {
"TT": np.arange(-30, 32, 2), "PR": np.arange(0, 6.5, 0.5)
}
vname_to_anusplin_path = {
"TT": "/home/huziy/skynet3_rech1/anusplin_links",
"PR": "/home/huziy/skynet3_rech1/anusplin_links"
}
vname_to_cru_path = {
"TT": "/HOME/data/Validation/CRU_TS_3.1/Original_files_gzipped/cru_ts_3_10.1901.2009.tmp.dat.nc",
"PR": "/HOME/data/Validation/CRU_TS_3.1/Original_files_gzipped/cru_ts_3_10.1901.2009.pre.dat.nc"
}
for vname in varnames:
fig = plt.figure()
ncols = len(season_to_months)
gs = GridSpec(4, ncols + 1, width_ratios=ncols * [1., ] + [0.09, ])
clevels = vname_to_clevels[vname]
# get anusplin obs climatology
season_to_obs_anusplin = plot_performance_err_with_anusplin.get_seasonal_clim_obs_data(
rconfig=reanalysis_driven_config,
vname=vname, season_to_months=season_to_months, bmp_info=bmp_info,
n_agg_x=nx_agg_anusplin, n_agg_y=ny_agg_anusplin)
row = 0
# Plot CRU values-------------------------
bmp_info_agg, season_to_obs_cru = plot_performance_err_with_cru.get_seasonal_clim_obs_data(
rconfig=reanalysis_driven_config, bmp_info=bmp_info, season_to_months=season_to_months,
obs_path=vname_to_cru_path[vname], vname=vname
)
# Mask out the Great Lakes
cru_mask = get_mask(bmp_info_agg.lons, bmp_info_agg.lats, shp_path=os.path.join(GL_SHP_FOLDER, "gl_cst.shp"))
for season in season_to_obs_cru:
season_to_obs_cru[season] = np.ma.masked_where(cru_mask > 0.5, season_to_obs_cru[season])
ax_list = [fig.add_subplot(gs[row, j]) for j in range(ncols)]
cs = None
xx_agg, yy_agg = bmp_info_agg.get_proj_xy()
for j, (season, obs_field) in enumerate(season_to_obs_cru.items()):
ax = ax_list[j]
cs = bmp_info_agg.basemap.contourf(xx_agg, yy_agg, obs_field.copy(), levels=clevels, ax=ax)
bmp_info.basemap.drawcoastlines(ax=ax)
bmp_info.basemap.readshapefile(BASIN_BOUNDARIES_SHP[:-4], "basin", ax=ax)
ax.set_title(season)
ax_list[0].set_ylabel("CRU")
# plt.colorbar(cs, caax=ax_list[-1])
row += 1
# Plot ANUSPLIN values-------------------------
ax_list = [fig.add_subplot(gs[row, j]) for j in range(ncols)]
cs = None
for j, (season, obs_field) in enumerate(season_to_obs_anusplin.items()):
ax = ax_list[j]
cs = bmp_info.basemap.contourf(xx, yy, obs_field, levels=clevels, ax=ax)
bmp_info.basemap.drawcoastlines(ax=ax)
bmp_info.basemap.readshapefile(BASIN_BOUNDARIES_SHP[:-4], "basin", ax=ax)
ax.set_title(season)
ax_list[0].set_ylabel("Hopkinson")
cb = plt.colorbar(cs, cax=fig.add_subplot(gs[:2, -1]))
cb.ax.set_xlabel(infovar.get_units(vname))
_format_axes(ax_list, vname=vname)
row += 1
# Plot model (CRCM) values-------------------------
# ax_list = [fig.add_subplot(gs[row, j]) for j in range(ncols)]
# cs = None
#
# season_to_field_crcm = analysis.get_seasonal_climatology_for_runconfig(run_config=reanalysis_driven_config,
# varname=vname, level=0,
# season_to_months=season_to_months)
#
# for j, (season, crcm_field) in enumerate(season_to_field_crcm.items()):
# ax = ax_list[j]
# cs = bmp_info.basemap.contourf(xx, yy, crcm_field * 1000 * 24 * 3600, levels=clevels, ax=ax)
# bmp_info.basemap.drawcoastlines(ax=ax)
# bmp_info.basemap.readshapefile(BASIN_BOUNDARIES_SHP[:-4], "basin", ax=ax)
# ax.set_title(season)
#
# ax_list[0].set_ylabel(reanalysis_driven_config.label)
# cb = plt.colorbar(cs, cax=fig.add_subplot(gs[:2, -1]))
# cb.ax.set_xlabel(infovar.get_units(vname))
# _format_axes(ax_list, vname=vname)
# row += 1
# Plot (Model - CRU) Performance biases-------------------------
ax_list = [fig.add_subplot(gs[row, j]) for j in range(ncols)]
cs = plot_performance_err_with_cru.compare_vars(vname_model=vname, vname_obs=None,
r_config=reanalysis_driven_config,
season_to_months=season_to_months,
obs_path=vname_to_cru_path[vname],
bmp_info_agg=bmp_info_agg, diff_axes_list=ax_list,
mask_shape_file=os.path.join(GL_SHP_FOLDER, "gl_cst.shp"),
nx_agg_model=nx_agg_model, ny_agg_model=ny_agg_model)
ax_list[0].set_ylabel("{label}\n--\nCRU".format(label=reanalysis_driven_config.label))
_format_axes(ax_list, vname=vname)
row += 1
# Plot performance+BFE errors with respect to CRU (Model - CRU)-------------------------
# ax_list = [fig.add_subplot(gs[row, j]) for j in range(ncols)]
# plot_performance_err_with_cru.compare_vars(vname, vname_obs=None, obs_path=vname_to_cru_path[vname],
# r_config=gcm_driven_config,
# bmp_info_agg=bmp_info_agg, season_to_months=season_to_months,
# axes_list=ax_list)
# _format_axes(ax_list, vname=vname)
# ax_list[0].set_ylabel("{label}\nvs\nCRU".format(label=gcm_driven_config.label))
# row += 1
# Plot performance errors with respect to ANUSPLIN (Model - ANUSPLIN)-------------------------
ax_list = [fig.add_subplot(gs[row, j]) for j in range(ncols)]
plot_performance_err_with_anusplin.compare_vars(vname, {vname: season_to_obs_anusplin},
r_config=reanalysis_driven_config,
bmp_info_agg=bmp_info, season_to_months=season_to_months,
axes_list=ax_list)
_format_axes(ax_list, vname=vname)
ax_list[0].set_ylabel("{label}\n--\nHopkinson".format(label=reanalysis_driven_config.label))
row += 1
# Plot performance+BFE errors with respect to ANUSPLIN (Model - ANUSPLIN)-------------------------
# ax_list = [fig.add_subplot(gs[row, j]) for j in range(ncols)]
# plot_performance_err_with_anusplin.compare_vars(vname, {vname: season_to_obs_anusplin},
# r_config=gcm_driven_config,
# bmp_info_agg=bmp_info, season_to_months=season_to_months,
# axes_list=ax_list)
# _format_axes(ax_list, vname=vname)
# ax_list[0].set_ylabel("{label}\nvs\nHopkinson".format(label=gcm_driven_config.label))
cb = plt.colorbar(cs, cax=fig.add_subplot(gs[-2:, -1]))
cb.ax.set_xlabel(infovar.get_units(vname))
# Save the plot
img_file = "{vname}_{sy}-{ey}_{sim_label}.png".format(
vname=vname, sy=reanalysis_driven_config.start_year, ey=reanalysis_driven_config.end_year,
sim_label=reanalysis_driven_config.label)
img_file = img_folder.joinpath(img_file)
with img_file.open("wb") as f:
fig.savefig(f, bbox_inches="tight")
plt.close(fig)
def main():
if not img_folder.is_dir():
img_folder.mkdir(parents=True)
season_to_months = OrderedDict([
("Winter (DJF)", (1, 2, 12)),
("Spring (MAM)", range(3, 6)),
("Summer (JJA)", range(6, 9)),
("Fall (SON)", range(9, 12)),
])
varnames = ["TT", "PR"]
plot_utils.apply_plot_params(font_size=10,
width_pt=None,
width_cm=20,
height_cm=17)
# reanalysis_driven_config = RunConfig(data_path="/RESCUE/skynet3_rech1/huziy/hdf_store/quebec_0.1_crcm5-hcd-rl.hdf5",
# start_year=1980, end_year=2010, label="ERAI-CRCM5-L")
#
reanalysis_driven_config = RunConfig(
data_path=
"/RESCUE/skynet3_rech1/huziy/hdf_store/quebec_0.4_crcm5-hcd-rl.hdf5",
start_year=1980,
end_year=2010,
label="ERAI-CRCM5-L(0.4)")
nx_agg_model = 1
ny_agg_model = 1
nx_agg_anusplin = 4
ny_agg_anusplin = 4
gcm_driven_config = RunConfig(
data_path=
"/RESCUE/skynet3_rech1/huziy/hdf_store/cc-canesm2-driven/quebec_0.1_crcm5-hcd-rl-cc-canesm2-1980-2010.hdf5",
start_year=1980,
end_year=2010,
label="CanESM2-CRCM5-L")
bmp_info = analysis.get_basemap_info(r_config=reanalysis_driven_config)
xx, yy = bmp_info.get_proj_xy()
field_cmap = cm.get_cmap("jet", 10)
vname_to_clevels = {
"TT": np.arange(-30, 32, 2),
"PR": np.arange(0, 6.5, 0.5)
}
vname_to_anusplin_path = {
"TT": "/home/huziy/skynet3_rech1/anusplin_links",
"PR": "/home/huziy/skynet3_rech1/anusplin_links"
}
vname_to_cru_path = {
"TT":
"/HOME/data/Validation/CRU_TS_3.1/Original_files_gzipped/cru_ts_3_10.1901.2009.tmp.dat.nc",
"PR":
"/HOME/data/Validation/CRU_TS_3.1/Original_files_gzipped/cru_ts_3_10.1901.2009.pre.dat.nc"
}
for vname in varnames:
fig = plt.figure()
ncols = len(season_to_months)
gs = GridSpec(4, ncols + 1, width_ratios=ncols * [
1.,
] + [
0.09,
])
clevels = vname_to_clevels[vname]
# get anusplin obs climatology
season_to_obs_anusplin = plot_performance_err_with_anusplin.get_seasonal_clim_obs_data(
rconfig=reanalysis_driven_config,
vname=vname,
season_to_months=season_to_months,
bmp_info=bmp_info,
n_agg_x=nx_agg_anusplin,
n_agg_y=ny_agg_anusplin)
row = 0
# Plot CRU values-------------------------
bmp_info_agg, season_to_obs_cru = plot_performance_err_with_cru.get_seasonal_clim_obs_data(
rconfig=reanalysis_driven_config,
bmp_info=bmp_info,
season_to_months=season_to_months,
obs_path=vname_to_cru_path[vname],
vname=vname)
# Mask out the Great Lakes
cru_mask = get_mask(bmp_info_agg.lons,
bmp_info_agg.lats,
shp_path=os.path.join(GL_SHP_FOLDER, "gl_cst.shp"))
for season in season_to_obs_cru:
season_to_obs_cru[season] = np.ma.masked_where(
cru_mask > 0.5, season_to_obs_cru[season])
ax_list = [fig.add_subplot(gs[row, j]) for j in range(ncols)]
cs = None
xx_agg, yy_agg = bmp_info_agg.get_proj_xy()
for j, (season, obs_field) in enumerate(season_to_obs_cru.items()):
ax = ax_list[j]
cs = bmp_info_agg.basemap.contourf(xx_agg,
yy_agg,
obs_field.copy(),
levels=clevels,
ax=ax)
bmp_info.basemap.drawcoastlines(ax=ax)
bmp_info.basemap.readshapefile(BASIN_BOUNDARIES_SHP[:-4],
"basin",
ax=ax)
ax.set_title(season)
ax_list[0].set_ylabel("CRU")
# plt.colorbar(cs, caax=ax_list[-1])
row += 1
# Plot ANUSPLIN values-------------------------
ax_list = [fig.add_subplot(gs[row, j]) for j in range(ncols)]
cs = None
for j, (season,
obs_field) in enumerate(season_to_obs_anusplin.items()):
ax = ax_list[j]
cs = bmp_info.basemap.contourf(xx,
yy,
obs_field,
levels=clevels,
ax=ax)
bmp_info.basemap.drawcoastlines(ax=ax)
bmp_info.basemap.readshapefile(BASIN_BOUNDARIES_SHP[:-4],
"basin",
ax=ax)
ax.set_title(season)
ax_list[0].set_ylabel("Hopkinson")
cb = plt.colorbar(cs, cax=fig.add_subplot(gs[:2, -1]))
cb.ax.set_xlabel(infovar.get_units(vname))
_format_axes(ax_list, vname=vname)
row += 1
# Plot model (CRCM) values-------------------------
# ax_list = [fig.add_subplot(gs[row, j]) for j in range(ncols)]
# cs = None
#
# season_to_field_crcm = analysis.get_seasonal_climatology_for_runconfig(run_config=reanalysis_driven_config,
# varname=vname, level=0,
# season_to_months=season_to_months)
#
# for j, (season, crcm_field) in enumerate(season_to_field_crcm.items()):
# ax = ax_list[j]
# cs = bmp_info.basemap.contourf(xx, yy, crcm_field * 1000 * 24 * 3600, levels=clevels, ax=ax)
# bmp_info.basemap.drawcoastlines(ax=ax)
# bmp_info.basemap.readshapefile(BASIN_BOUNDARIES_SHP[:-4], "basin", ax=ax)
# ax.set_title(season)
#
# ax_list[0].set_ylabel(reanalysis_driven_config.label)
# cb = plt.colorbar(cs, cax=fig.add_subplot(gs[:2, -1]))
# cb.ax.set_xlabel(infovar.get_units(vname))
# _format_axes(ax_list, vname=vname)
# row += 1
# Plot (Model - CRU) Performance biases-------------------------
ax_list = [fig.add_subplot(gs[row, j]) for j in range(ncols)]
cs = plot_performance_err_with_cru.compare_vars(
vname_model=vname,
vname_obs=None,
r_config=reanalysis_driven_config,
season_to_months=season_to_months,
obs_path=vname_to_cru_path[vname],
bmp_info_agg=bmp_info_agg,
diff_axes_list=ax_list,
mask_shape_file=os.path.join(GL_SHP_FOLDER, "gl_cst.shp"),
nx_agg_model=nx_agg_model,
ny_agg_model=ny_agg_model)
ax_list[0].set_ylabel(
"{label}\n--\nCRU".format(label=reanalysis_driven_config.label))
_format_axes(ax_list, vname=vname)
row += 1
# Plot performance+BFE errors with respect to CRU (Model - CRU)-------------------------
# ax_list = [fig.add_subplot(gs[row, j]) for j in range(ncols)]
# plot_performance_err_with_cru.compare_vars(vname, vname_obs=None, obs_path=vname_to_cru_path[vname],
# r_config=gcm_driven_config,
# bmp_info_agg=bmp_info_agg, season_to_months=season_to_months,
# axes_list=ax_list)
# _format_axes(ax_list, vname=vname)
# ax_list[0].set_ylabel("{label}\nvs\nCRU".format(label=gcm_driven_config.label))
# row += 1
# Plot performance errors with respect to ANUSPLIN (Model - ANUSPLIN)-------------------------
ax_list = [fig.add_subplot(gs[row, j]) for j in range(ncols)]
plot_performance_err_with_anusplin.compare_vars(
vname, {vname: season_to_obs_anusplin},
r_config=reanalysis_driven_config,
bmp_info_agg=bmp_info,
season_to_months=season_to_months,
axes_list=ax_list)
_format_axes(ax_list, vname=vname)
ax_list[0].set_ylabel("{label}\n--\nHopkinson".format(
label=reanalysis_driven_config.label))
row += 1
# Plot performance+BFE errors with respect to ANUSPLIN (Model - ANUSPLIN)-------------------------
# ax_list = [fig.add_subplot(gs[row, j]) for j in range(ncols)]
# plot_performance_err_with_anusplin.compare_vars(vname, {vname: season_to_obs_anusplin},
# r_config=gcm_driven_config,
# bmp_info_agg=bmp_info, season_to_months=season_to_months,
# axes_list=ax_list)
# _format_axes(ax_list, vname=vname)
# ax_list[0].set_ylabel("{label}\nvs\nHopkinson".format(label=gcm_driven_config.label))
cb = plt.colorbar(cs, cax=fig.add_subplot(gs[-2:, -1]))
cb.ax.set_xlabel(infovar.get_units(vname))
# Save the plot
img_file = "{vname}_{sy}-{ey}_{sim_label}.png".format(
vname=vname,
sy=reanalysis_driven_config.start_year,
ey=reanalysis_driven_config.end_year,
sim_label=reanalysis_driven_config.label)
img_file = img_folder.joinpath(img_file)
with img_file.open("wb") as f:
fig.savefig(f, bbox_inches="tight")
plt.close(fig)
def plot_seasonal_mean_biases(season_to_error_field=None,
varname="",
basemap_info=None):
assert isinstance(basemap_info, BasemapInfo)
cmap = cm.get_cmap("RdBu_r", 20)
# Set to False if you want the limits to be recalculated from data
manual_limits = True
minval = min([
np.percentile(field[~field.mask], 95)
for s, field in season_to_error_field.items()
])
maxval = max([
np.percentile(field[~field.mask], 95)
for s, field in season_to_error_field.items()
])
if manual_limits:
if varname == "PR":
minval, maxval = -3, 3
if varname == "TT":
minval, maxval = -7, 7
d = max(abs(minval), abs(maxval))
clevs = MaxNLocator(nbins=cmap.N, symmetric=True).tick_values(-d, d)
fig_path = img_folder.joinpath("{}.png".format(varname))
fig = plt.figure()
nrows = 2
ncols = 2
gs = GridSpec(nrows, ncols=ncols + 1, width_ratios=[1, 1, 0.05])
xx, yy = basemap_info.get_proj_xy()
cs = None
for i, season in enumerate(season_to_error_field):
row = i // ncols
col = i % ncols
ax = fig.add_subplot(gs[row, col])
cs = basemap_info.basemap.contourf(xx,
yy,
season_to_error_field[season],
ax=ax,
cmap=cmap,
levels=clevs,
extend="both")
basemap_info.basemap.drawcoastlines()
ax.set_title(season)
# basemap_info.basemap.colorbar(cs)
cax = fig.add_subplot(gs[:, -1])
cax.set_title(infovar.get_units(var_name=varname))
plt.colorbar(cs, cax=cax)
with fig_path.open("wb") as figfile:
fig.savefig(figfile, format="png", bbox_inches="tight")
plt.close(fig)
def plot_seasonal_mean_biases(season_to_error_field=None,
varname="",
basemap_info=None,
axes_list=None):
assert isinstance(basemap_info, BasemapInfo)
# Set to False if you want the limits to be recalculated from data
manual_limits = True
d = max([
np.percentile(np.abs(field[~field.mask]), 95)
for s, field in season_to_error_field.items()
])
if manual_limits and varname in ["PR", "TT", "I5"]:
clevs = np.arange(-d, 1.1 * d, 0.1 * d)
if varname == "PR":
clevs = np.arange(-3, 3.5, 0.5)
if varname == "TT":
clevs = np.arange(-7, 8, 1)
if varname == "I5":
clevs = np.arange(-100, 110, 10)
else:
clevs = MaxNLocator(nbins=10, symmetric=True).tick_values(-d, d)
cmap = cm.get_cmap("RdBu_r", len(clevs) - 1)
fig = None
fig_path = None
if axes_list is None:
fig_path = img_folder.joinpath("{}.png".format(varname))
fig = plt.figure()
nrows = 2
ncols = 2
gs = GridSpec(nrows, ncols=ncols + 1, width_ratios=[1, 1, 0.05])
xx, yy = basemap_info.get_proj_xy()
cs = None
for i, season in enumerate(season_to_error_field):
row = i // ncols
col = i % ncols
if axes_list is None:
ax = fig.add_subplot(gs[row, col])
else:
ax = axes_list[i]
basemap_info.draw_map_background(ax)
cs = basemap_info.basemap.contourf(xx,
yy,
season_to_error_field[season][:],
ax=ax,
cmap=cmap,
levels=clevs,
extend="both")
basemap_info.basemap.drawcoastlines(ax=ax, linewidth=0.3)
ax.set_title(season)
if i == 0:
ax.set_ylabel(
infovar.get_long_display_label_for_var(varname=varname))
# basemap_info.basemap.colorbar(cs)
if basemap_info.should_draw_basin_boundaries:
basemap_info.basemap.readshapefile(BASIN_BOUNDARIES_SHP[:-4],
"basin",
ax=ax)
# Hide snow plots for summer
if varname in ["I5"] and season.lower() in ["summer"]:
ax.set_visible(False)
# Plot a colorbar for each subplot if required.
if hasattr(basemap_info, "draw_colorbar_for_each_subplot"):
if basemap_info.draw_colorbar_for_each_subplot:
cb = basemap_info.basemap.colorbar(cs, ax=ax)
cb.ax.set_title(infovar.get_units(var_name=varname))
cax = fig.add_subplot(gs[:, -1]) if axes_list is None else axes_list[-1]
# Add the colorbar if there are additional axes supplied for it
if len(axes_list) > len(season_to_error_field):
cax.set_title(infovar.get_units(var_name=varname))
plt.colorbar(cs, cax=cax)
if axes_list is None:
with fig_path.open("wb") as figfile:
fig.savefig(figfile, format="png", bbox_inches="tight")
plt.close(fig)
return cs
