def plot_swe_bfes(runconfig_rea, runconfig_gcm, vname_model="I5", season_to_months=None,
bmp_info=None, axes_list=None):
seasonal_clim_fields_rea = analysis.get_seasonal_climatology_for_runconfig(run_config=runconfig_rea,
varname=vname_model, level=0,
season_to_months=season_to_months)
seasonal_clim_fields_gcm = analysis.get_seasonal_climatology_for_runconfig(run_config=runconfig_gcm,
varname=vname_model, level=0,
season_to_months=season_to_months)
lons = bmp_info.lons.copy()
lons[lons > 180] -= 360
assert len(seasonal_clim_fields_rea) > 0
season_to_err = OrderedDict()
for season, field in seasonal_clim_fields_rea.items():
rea = field
gcm = seasonal_clim_fields_gcm[season]
# Mask oceans and lakes
season_to_err[season] = maskoceans(lons, bmp_info.lats, gcm - rea)
assert hasattr(season_to_err[season], "mask")
plot_performance_err_with_cru.plot_seasonal_mean_biases(season_to_error_field=season_to_err,
varname=vname_model, basemap_info=bmp_info,
axes_list=axes_list)
def compare_vars(vname_model, vname_to_obs, r_config, season_to_months,
bmp_info_agg, axes_list):
season_to_clim_fields_model = analysis.get_seasonal_climatology_for_runconfig(
run_config=r_config,
varname=vname_model,
level=0,
season_to_months=season_to_months)
for season, field in season_to_clim_fields_model.items():
print(field.shape)
if vname_model == "PR":
field *= 1.0e3 * 24 * 3600
seasonal_clim_fields_obs = vname_to_obs[vname_model]
lons = bmp_info_agg.lons.copy()
lons[lons > 180] -= 360
season_to_err = OrderedDict()
for season in seasonal_clim_fields_obs:
season_to_err[season] = season_to_clim_fields_model[
season] - seasonal_clim_fields_obs[season]
season_to_err[season] = maskoceans(lons,
bmp_info_agg.lats,
season_to_err[season],
inlands=False)
cs = plot_seasonal_mean_biases(season_to_error_field=season_to_err,
varname=vname_model,
basemap_info=bmp_info_agg,
axes_list=axes_list)
return cs
def compare_vars(vname_model, vname_to_obs, r_config, season_to_months, bmp_info_agg, axes_list):
season_to_clim_fields_model = analysis.get_seasonal_climatology_for_runconfig(run_config=r_config,
varname=vname_model, level=0,
season_to_months=season_to_months)
for season, field in season_to_clim_fields_model.items():
print(field.shape)
if vname_model == "PR":
field *= 1.0e3 * 24 * 3600
seasonal_clim_fields_obs = vname_to_obs[vname_model]
lons = bmp_info_agg.lons.copy()
lons[lons > 180] -= 360
season_to_err = OrderedDict()
for season in seasonal_clim_fields_obs:
season_to_err[season] = season_to_clim_fields_model[season] - seasonal_clim_fields_obs[season]
season_to_err[season] = maskoceans(lons, bmp_info_agg.lats, season_to_err[season], inlands=False)
cs = plot_seasonal_mean_biases(season_to_error_field=season_to_err,
varname=vname_model,
basemap_info=bmp_info_agg,
axes_list=axes_list)
return cs
def compare_vars(vname_model, vname_to_obs, r_config, season_to_months,
bmp_info_agg, axes_list):
season_to_clim_fields_model = analysis.get_seasonal_climatology_for_runconfig(
run_config=r_config,
varname=vname_model,
level=0,
season_to_months=season_to_months)
for season, field in season_to_clim_fields_model.items():
print(field.shape)
if vname_model == "PR":
field *= 1.0e3 * 24 * 3600
seasonal_clim_fields_obs = vname_to_obs[vname_model]
lons = bmp_info_agg.lons.copy()
lons[lons > 180] -= 360
season_to_err = OrderedDict()
print(
"-------------var: {} (PE with anusplin)---------------------".format(
vname_model))
for season in seasonal_clim_fields_obs:
seasonal_clim_fields_obs[season] = np.ma.masked_where(
np.isnan(seasonal_clim_fields_obs[season]),
seasonal_clim_fields_obs[season])
season_to_err[season] = season_to_clim_fields_model[
season] - seasonal_clim_fields_obs[season]
season_to_err[season] = maskoceans(lons,
bmp_info_agg.lats,
season_to_err[season],
inlands=False)
season_to_err[season] = np.ma.masked_where(
np.isnan(season_to_err[season]), season_to_err[season])
good_vals = season_to_err[season]
good_vals = good_vals[~good_vals.mask]
print("{}: min={}; max={}; avg={}".format(season, good_vals.min(),
good_vals.max(),
good_vals.mean()))
print("---------percetages --- anuplin ---")
print("{}: {} %".format(
season,
good_vals.mean() / seasonal_clim_fields_obs[season]
[~season_to_err[season].mask].mean() * 100))
cs = plot_seasonal_mean_biases(season_to_error_field=season_to_err,
varname=vname_model,
basemap_info=bmp_info_agg,
axes_list=axes_list)
return cs
def compare_vars(vname_model="TT",
vname_obs="tmp",
r_config=None,
season_to_months=None,
obs_path=None,
nx_agg=5,
ny_agg=5,
bmp_info_agg=None,
axes_list=None):
seasonal_clim_fields_model = analysis.get_seasonal_climatology_for_runconfig(
run_config=r_config,
varname=vname_model,
level=0,
season_to_months=season_to_months)
season_to_clim_fields_model_agg = OrderedDict()
for season, field in seasonal_clim_fields_model.items():
print(field.shape)
season_to_clim_fields_model_agg[season] = aggregate_array(
field, nagg_x=nx_agg, nagg_y=ny_agg)
if vname_model == "PR":
season_to_clim_fields_model_agg[season] *= 1.0e3 * 24 * 3600
if obs_path is None:
cru = CRUDataManager(var_name=vname_obs)
else:
cru = CRUDataManager(var_name=vname_obs, path=obs_path)
seasonal_clim_fields_obs = cru.get_seasonal_means(
season_name_to_months=season_to_months,
start_year=r_config.start_year,
end_year=r_config.end_year)
seasonal_clim_fields_obs_interp = OrderedDict()
for season, cru_field in seasonal_clim_fields_obs.items():
seasonal_clim_fields_obs_interp[season] = cru.interpolate_data_to(
cru_field,
lons2d=bmp_info_agg.lons,
lats2d=bmp_info_agg.lats,
nneighbours=1)
assert hasattr(seasonal_clim_fields_obs_interp[season], "mask")
season_to_err = OrderedDict()
for season in seasonal_clim_fields_obs_interp:
if vname_model == "PR":
# * 10, because in the UDEL dataset, precipitation is in cm
season_to_err[season] = season_to_clim_fields_model_agg[season] - \
seasonal_clim_fields_obs_interp[season] * MM_PER_CM
else:
season_to_err[season] = season_to_clim_fields_model_agg[
season] - seasonal_clim_fields_obs_interp[season]
plot_performance_err_with_cru.plot_seasonal_mean_biases(
season_to_error_field=season_to_err,
varname=vname_model,
basemap_info=bmp_info_agg,
axes_list=axes_list)
def compare_vars(vname_model, vname_to_obs, r_config, season_to_months, bmp_info_agg, axes_list):
season_to_clim_fields_model = analysis.get_seasonal_climatology_for_runconfig(run_config=r_config,
varname=vname_model, level=0,
season_to_months=season_to_months)
for season, field in season_to_clim_fields_model.items():
print(field.shape)
if vname_model == "PR":
field *= 1.0e3 * 24 * 3600
seasonal_clim_fields_obs = vname_to_obs[vname_model]
lons = bmp_info_agg.lons.copy()
lons[lons > 180] -= 360
season_to_err = OrderedDict()
print("-------------var: {} (PE with anusplin)---------------------".format(vname_model))
for season in seasonal_clim_fields_obs:
seasonal_clim_fields_obs[season] = np.ma.masked_where(np.isnan(seasonal_clim_fields_obs[season]),
seasonal_clim_fields_obs[season])
season_to_err[season] = season_to_clim_fields_model[season] - seasonal_clim_fields_obs[season]
season_to_err[season] = maskoceans(lons, bmp_info_agg.lats, season_to_err[season], inlands=False)
season_to_err[season] = np.ma.masked_where(np.isnan(season_to_err[season]), season_to_err[season])
good_vals = season_to_err[season]
good_vals = good_vals[~good_vals.mask]
print("{}: min={}; max={}; avg={}".format(season,
good_vals.min(),
good_vals.max(),
good_vals.mean()))
print("---------percetages --- anuplin ---")
print("{}: {} %".format(season, good_vals.mean() / seasonal_clim_fields_obs[season][~season_to_err[season].mask].mean() * 100))
cs = plot_seasonal_mean_biases(season_to_error_field=season_to_err, varname=vname_model, basemap_info=bmp_info_agg,
axes_list=axes_list)
return cs
def compare_vars(vname_model="TT", vname_obs="tmp", r_config=None,
season_to_months=None,
obs_path=None, nx_agg=5, ny_agg=5, bmp_info_agg=None, axes_list=None):
seasonal_clim_fields_model = analysis.get_seasonal_climatology_for_runconfig(run_config=r_config,
varname=vname_model, level=0,
season_to_months=season_to_months)
season_to_clim_fields_model_agg = OrderedDict()
for season, field in seasonal_clim_fields_model.items():
print(field.shape)
season_to_clim_fields_model_agg[season] = aggregate_array(field, nagg_x=nx_agg, nagg_y=ny_agg)
if vname_model == "PR":
season_to_clim_fields_model_agg[season] *= 1.0e3 * 24 * 3600
if obs_path is None:
cru = CRUDataManager(var_name=vname_obs)
else:
cru = CRUDataManager(var_name=vname_obs, path=obs_path)
seasonal_clim_fields_obs = cru.get_seasonal_means(season_name_to_months=season_to_months,
start_year=r_config.start_year,
end_year=r_config.end_year)
seasonal_clim_fields_obs_interp = OrderedDict()
for season, cru_field in seasonal_clim_fields_obs.items():
seasonal_clim_fields_obs_interp[season] = cru.interpolate_data_to(cru_field,
lons2d=bmp_info_agg.lons,
lats2d=bmp_info_agg.lats, nneighbours=1)
assert hasattr(seasonal_clim_fields_obs_interp[season], "mask")
season_to_err = OrderedDict()
for season in seasonal_clim_fields_obs_interp:
if vname_model == "PR":
# * 10, because in the UDEL dataset, precipitation is in cm
season_to_err[season] = season_to_clim_fields_model_agg[season] - \
seasonal_clim_fields_obs_interp[season] * MM_PER_CM
else:
season_to_err[season] = season_to_clim_fields_model_agg[season] - seasonal_clim_fields_obs_interp[season]
plot_performance_err_with_cru.plot_seasonal_mean_biases(season_to_error_field=season_to_err, varname=vname_model,
basemap_info=bmp_info_agg,
axes_list=axes_list)
def compare_vars(vname_model="TT", vname_obs="tmp", r_config=None,
season_to_months=None,
obs_path=None, nx_agg=5, ny_agg=5, bmp_info_agg=None,
diff_axes_list=None, obs_axes_list=None,
model_axes_list=None, bmp_info_model=None,
mask_shape_file=None):
"""
if obs_axes_list is not None, plot observation data in those
:param mask_shape_file:
:param bmp_info_model: basemap info native to the model
:param model_axes_list: Axes to plot model outputs
:param vname_model:
:param vname_obs:
:param r_config:
:param season_to_months:
:param obs_path:
:param nx_agg:
:param ny_agg:
:param bmp_info_agg:
:param diff_axes_list: if it is None the plots for each variable is done in separate figures
"""
if vname_obs is None:
vname_model_to_vname_obs = {"TT": "tmp", "PR": "pre"}
vname_obs = vname_model_to_vname_obs[vname_model]
seasonal_clim_fields_model = analysis.get_seasonal_climatology_for_runconfig(run_config=r_config,
varname=vname_model, level=0,
season_to_months=season_to_months)
season_to_clim_fields_model_agg = OrderedDict()
for season, field in seasonal_clim_fields_model.items():
print(field.shape)
season_to_clim_fields_model_agg[season] = aggregate_array(field, nagg_x=nx_agg, nagg_y=ny_agg)
if vname_model == "PR":
season_to_clim_fields_model_agg[season] *= 1.0e3 * 24 * 3600
if vname_obs in ["SWE", ]:
obs_manager = SweDataManager(path=obs_path, var_name=vname_obs)
elif obs_path is None:
obs_manager = CRUDataManager(var_name=vname_obs)
else:
obs_manager = CRUDataManager(var_name=vname_obs, path=obs_path)
seasonal_clim_fields_obs = obs_manager.get_seasonal_means(season_name_to_months=season_to_months,
start_year=r_config.start_year,
end_year=r_config.end_year)
seasonal_clim_fields_obs_interp = OrderedDict()
# Derive the mask from a shapefile if provided
if mask_shape_file is not None:
the_mask = get_mask(bmp_info_agg.lons, bmp_info_agg.lats, shp_path=mask_shape_file)
else:
the_mask = np.zeros_like(bmp_info_agg.lons)
for season, obs_field in seasonal_clim_fields_obs.items():
obs_field = obs_manager.interpolate_data_to(obs_field,
lons2d=bmp_info_agg.lons,
lats2d=bmp_info_agg.lats,
nneighbours=1)
obs_field = np.ma.masked_where(the_mask > 0.5, obs_field)
seasonal_clim_fields_obs_interp[season] = obs_field
# assert hasattr(seasonal_clim_fields_obs_interp[season], "mask")
season_to_err = OrderedDict()
print("-------------var: {} (PE with CRU)---------------------".format(vname_model))
for season in seasonal_clim_fields_obs_interp:
seasonal_clim_fields_obs_interp[season] = np.ma.masked_where(np.isnan(seasonal_clim_fields_obs_interp[season]),
seasonal_clim_fields_obs_interp[season])
season_to_err[season] = season_to_clim_fields_model_agg[season] - seasonal_clim_fields_obs_interp[season]
if vname_model in ["I5"]:
lons = bmp_info_agg.lons.copy()
lons[lons > 180] -= 360
season_to_err[season] = maskoceans(lons, bmp_info_agg.lats, season_to_err[season])
good_vals = season_to_err[season]
good_vals = good_vals[~good_vals.mask]
print("{}: min={}; max={}; avg={}".format(season,
good_vals.min(),
good_vals.max(),
good_vals.mean()))
print("---------percetages --- CRU ---")
print("{}: {} \%".format(season, good_vals.mean() / seasonal_clim_fields_obs_interp[season][~season_to_err[season].mask].mean() * 100))
cs = plot_seasonal_mean_biases(season_to_error_field=season_to_err,
varname=vname_model,
basemap_info=bmp_info_agg,
axes_list=diff_axes_list)
if obs_axes_list is not None and vname_model in ["I5"]:
clevs = [0, 50, 60, 70, 80, 90, 100, 150, 200, 250, 300, 350, 400, 500]
cs_obs = None
xx, yy = bmp_info_agg.get_proj_xy()
lons = bmp_info_agg.lons.copy()
lons[lons > 180] -= 360
lons_model = None
xx_model, yy_model = None, None
cs_mod = None
norm = BoundaryNorm(clevs, 256)
for col, (season, obs_field) in enumerate(seasonal_clim_fields_obs_interp.items()):
# Obsrved fields
ax = obs_axes_list[col]
if bmp_info_agg.should_draw_basin_boundaries:
bmp_info_agg.basemap.readshapefile(BASIN_BOUNDARIES_SHP[:-4], "basin", ax=ax)
to_plot = maskoceans(lons, bmp_info_agg.lats, obs_field)
cs_obs = bmp_info_agg.basemap.contourf(xx, yy, to_plot, levels=clevs, ax=ax, norm=norm, extend="max")
bmp_info_agg.basemap.drawcoastlines(ax=ax, linewidth=0.3)
ax.set_title(season)
# Model outputs
if model_axes_list is not None:
ax = model_axes_list[col]
if bmp_info_agg.should_draw_basin_boundaries:
bmp_info_agg.basemap.readshapefile(BASIN_BOUNDARIES_SHP[:-4], "basin", ax=ax)
if lons_model is None:
lons_model = bmp_info_model.lons.copy()
lons_model[lons_model > 180] -= 360
xx_model, yy_model = bmp_info_model.basemap(lons_model, bmp_info_model.lats)
model_field = seasonal_clim_fields_model[season]
to_plot = maskoceans(lons_model, bmp_info_model.lats, model_field)
cs_mod = bmp_info_agg.basemap.contourf(xx_model, yy_model, to_plot, levels=cs_obs.levels, ax=ax,
norm=cs_obs.norm, cmap=cs_obs.cmap, extend="max")
bmp_info_agg.basemap.drawcoastlines(ax=ax, linewidth=0.3)
plt.colorbar(cs_obs, cax=obs_axes_list[-1])
return cs
def main():
vname_model = "I5"
nx_agg = 2
ny_agg = 2
start_year = 1980
end_year = 2006
r_config = RunConfig(
data_path="/RESCUE/skynet3_rech1/huziy/hdf_store/quebec_0.1_crcm5-hcd-rl.hdf5",
start_year=start_year, end_year=end_year, label="ERAI-CRCM5-L"
)
bmp_info = analysis.get_basemap_info(r_config=r_config)
bmp_info_agg = bmp_info.get_aggregated(nagg_x=nx_agg, nagg_y=ny_agg)
season_to_months = OrderedDict([
("Winter", [12, 1, 2]),
("Spring", [3, 4, 5])
])
# Get the model data
seasonal_clim_fields_model = analysis.get_seasonal_climatology_for_runconfig(run_config=r_config,
varname=vname_model, level=0,
season_to_months=season_to_months)
season_to_clim_fields_model_agg = OrderedDict()
for season, field in seasonal_clim_fields_model.items():
season_to_clim_fields_model_agg[season] = aggregate_array(field, nagg_x=nx_agg, nagg_y=ny_agg)
# Get the EASE data
obs_manager = EaseSweManager()
season_to_clim_fields_obs = obs_manager.get_seasonal_clim_interpolated_to(target_lon2d=bmp_info_agg.lons, target_lat2d=bmp_info_agg.lats,
season_to_months=season_to_months, start_year=start_year, end_year=end_year)
# Do the plotting
plot_utils.apply_plot_params(font_size=10, width_cm=16, height_cm=24)
fig = plt.figure()
xx, yy = bmp_info_agg.get_proj_xy()
gs = GridSpec(3, len(season_to_clim_fields_model_agg) + 1, width_ratios=[1.0, ] * len(season_to_clim_fields_model_agg) + [0.05, ])
clevs = [0, 50, 60, 70, 80, 90, 100, 150, 200, 250, 300, 350, 400, 500]
norm = BoundaryNorm(clevs, 256)
clevs_diff = np.arange(-100, 110, 10)
cs_val = None
cs_diff = None
col = 0
lons_agg_copy = bmp_info_agg.lons.copy()
lons_agg_copy[lons_agg_copy > 180] -= 360
lons_copy = bmp_info.lons.copy()
lons_copy[lons_copy > 180] -= 360
xx1, yy1 = bmp_info.get_proj_xy()
for season, mod_field in seasonal_clim_fields_model.items():
obs_field = season_to_clim_fields_obs[season]
row = 0
ax = fig.add_subplot(gs[row, col])
ax.set_title(season)
obs_field = maskoceans(lons_agg_copy, bmp_info_agg.lats, obs_field)
cs_val = bmp_info_agg.basemap.contourf(xx, yy, obs_field, levels=clevs, norm=norm, ax=ax, extend="max")
bmp_info_agg.basemap.drawcoastlines(linewidth=0.3, ax=ax)
if col == 0:
ax.set_ylabel("NSIDC")
row += 1
ax = fig.add_subplot(gs[row, col])
mod_field = maskoceans(lons_copy, bmp_info.lats, mod_field)
bmp_info.basemap.contourf(xx1, yy1, mod_field, levels=cs_val.levels, norm=cs_val.norm, ax=ax, extend="max")
bmp_info.basemap.drawcoastlines(linewidth=0.3, ax=ax)
if col == 0:
ax.set_ylabel(r_config.label)
row += 1
ax = fig.add_subplot(gs[row, col])
cs_diff = bmp_info_agg.basemap.contourf(xx, yy, season_to_clim_fields_model_agg[season] - obs_field, levels=clevs_diff, ax=ax, extend="both", cmap="seismic")
bmp_info_agg.basemap.drawcoastlines(linewidth=0.3, ax=ax)
if col == 0:
ax.set_ylabel("{} minus {}".format(r_config.label, "NSIDC"))
col += 1
# Add values colorbar
ax = fig.add_subplot(gs[0, -1])
plt.colorbar(cs_val, cax=ax)
ax.set_title("mm")
# Add differences colorbaar
ax = fig.add_subplot(gs[-1, -1])
plt.colorbar(cs_diff, cax=ax)
ax.set_title("mm")
fig.tight_layout()
fig.savefig(os.path.join(img_folder, "NSIDC_vs_CRCM_swe.png"), dpi=common_plot_params.FIG_SAVE_DPI, bbox_inches="tight")
def main():
season_to_months = DEFAULT_SEASON_TO_MONTHS
varnames = ["PR", "TT"]
plot_utils.apply_plot_params(font_size=5, width_pt=None, width_cm=15, height_cm=4)
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")
bmp_info = analysis.get_basemap_info(r_config=reanalysis_driven_config)
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"
}
xx_agg = None
yy_agg = None
for vname in varnames:
# 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)
# get CRU obs 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
)
if xx_agg is None:
xx_agg, yy_agg = bmp_info_agg.get_proj_xy()
# get model data
seasonal_clim_fields_model = analysis.get_seasonal_climatology_for_runconfig(run_config=reanalysis_driven_config,
varname=vname,
level=0,
season_to_months=season_to_months)
###
biases_with_anusplin = OrderedDict()
biases_with_cru = OrderedDict()
nx_agg = 5
ny_agg = 5
season_to_clim_fields_model_agg = OrderedDict()
for season, field in seasonal_clim_fields_model.items():
print(field.shape)
season_to_clim_fields_model_agg[season] = aggregate_array(field, nagg_x=nx_agg, nagg_y=ny_agg)
if vname == "PR":
season_to_clim_fields_model_agg[season] *= 1.0e3 * 24 * 3600
biases_with_cru[season] = season_to_clim_fields_model_agg[season] - season_to_obs_cru[season]
biases_with_anusplin[season] = season_to_clim_fields_model_agg[season] - aggregate_array(season_to_obs_anusplin[season], nagg_x=nx_agg, nagg_y=ny_agg)
# Do the plotting
fig = plt.figure()
clevs = [c for c in np.arange(-0.5, 0.55, 0.05)] if vname == "PR" else np.arange(-2, 2.2, 0.2)
gs = GridSpec(1, len(biases_with_cru) + 1, width_ratios=len(biases_with_cru) * [1., ] + [0.05, ])
col = 0
cs = None
cmap = "seismic"
fig.suptitle(r"$\left| \delta_{\rm Hopkinson} \right| - \left| \delta_{\rm CRU} \right|$")
for season, cru_err in biases_with_cru.items():
anu_err = biases_with_anusplin[season]
ax = fig.add_subplot(gs[0, col])
diff = np.abs(anu_err) - np.abs(cru_err)
cs = bmp_info_agg.basemap.contourf(xx_agg, yy_agg, diff, levels=clevs, ax=ax, extend="both", cmap=cmap)
bmp_info_agg.basemap.drawcoastlines(ax=ax, linewidth=0.3)
good = diff[~diff.mask & ~np.isnan(diff)]
n_neg = sum(good < 0) / sum(good > 0)
print("season: {}, n-/n+ = {}".format(season, n_neg))
ax.set_title(season)
ax.set_xlabel(r"$n_{-}/n_{+} = $" + "{:.1f}".format(n_neg) + "\n" + r"$\overline{\varepsilon} = $" + "{:.2f}".format(good.mean()))
col += 1
ax = fig.add_subplot(gs[0, -1])
plt.colorbar(cs, cax=ax)
ax.set_title("mm/day" if vname == "PR" else r"${\rm ^\circ C}$")
fig.savefig(os.path.join(img_folder, "comp_anu_and_cru_biases_for_{}.png".format(vname)), bbox_inches="tight", dpi=common_plot_params.FIG_SAVE_DPI)
def main():
lkfr_limit = 0.05
model_data_current_path = "/skynet3_rech1/huziy/hdf_store/cc-canesm2-driven/" \
"quebec_0.1_crcm5-hcd-rl-cc-canesm2-1980-2010.hdf5"
modif_label = "CanESM2-CRCM5-L"
start_year_c = 1980
end_year_c = 2010
future_shift_years = 90
params = dict(
start_year=start_year_c, end_year=end_year_c
)
params.update(
dict(data_path=model_data_current_path, label=modif_label)
)
model_config_c = RunConfig(**params)
model_config_f = model_config_c.get_shifted_config(future_shift_years)
bmp_info = analysis.get_basemap_info(r_config=model_config_c)
specific_cond_heat = 0.250100e7 # J/kg
water_density = 1000.0 # kg/m**3
season_to_months = OrderedDict([
("Summer", [6, 7, 8]),
])
lkfr = analysis.get_array_from_file(path="/RESCUE/skynet3_rech1/huziy/hdf_store/quebec_0.1_crcm5-hcd-rl.hdf5", var_name=infovar.HDF_LAKE_FRACTION_NAME)
assert lkfr is not None, "Could not find lake fraction in the file"
# Current climate
traf_c = analysis.get_seasonal_climatology_for_runconfig(run_config=model_config_c, varname="TRAF", level=5, season_to_months=season_to_months)
pr_c = analysis.get_seasonal_climatology_for_runconfig(run_config=model_config_c, varname="PR", level=0, season_to_months=season_to_months)
lktemp_c = analysis.get_seasonal_climatology_for_runconfig(run_config=model_config_c, varname="L1", level=0, season_to_months=season_to_months)
airtemp_c = analysis.get_seasonal_climatology_for_runconfig(run_config=model_config_c, varname="TT", level=0, season_to_months=season_to_months)
lhc = OrderedDict([
(s, specific_cond_heat * (pr_c[s] * water_density - traf_c[s])) for s, traf in traf_c.items()
])
avc = analysis.get_seasonal_climatology_for_runconfig(run_config=model_config_c, varname="AV", level=0, season_to_months=season_to_months)
plt.figure()
lhc["Summer"] = np.ma.masked_where(lkfr < lkfr_limit, lhc["Summer"])
print("min: {}, max: {}".format(lhc["Summer"].min(), lhc["Summer"].max()))
cs = plt.contourf(lhc["Summer"].T)
plt.title("lhc")
plt.colorbar()
plt.figure()
cs = plt.contourf(avc["Summer"].T, levels=cs.levels, norm=cs.norm, cmap=cs.cmap)
plt.title("avc")
plt.colorbar()
# Future climate
traf_f = analysis.get_seasonal_climatology_for_runconfig(run_config=model_config_f, varname="TRAF", level=5, season_to_months=season_to_months)
pr_f = analysis.get_seasonal_climatology_for_runconfig(run_config=model_config_f, varname="PR", level=0,
season_to_months=season_to_months)
lktemp_f = analysis.get_seasonal_climatology_for_runconfig(run_config=model_config_f, varname="L1", level=0,
season_to_months=season_to_months)
airtemp_f = analysis.get_seasonal_climatology_for_runconfig(run_config=model_config_f, varname="TT", level=0,
season_to_months=season_to_months)
lhf = OrderedDict([
(s, specific_cond_heat * (pr_f[s] * water_density - traf_f[s])) for s, traf in traf_f.items()
])
plt.figure()
plt.pcolormesh(traf_c["Summer"].T)
plt.title("TRAF over lakes current")
plt.colorbar()
avf = analysis.get_seasonal_climatology_for_runconfig(run_config=model_config_f, varname="AV", level=0,
season_to_months=season_to_months)
plt.figure()
cs = plt.contourf(avf["Summer"].T)
plt.title("avf")
plt.colorbar()
plt.figure()
cs = plt.contourf(avf["Summer"].T - avc["Summer"].T, levels=np.arange(-40, 45, 5))
plt.title("d(av)")
plt.colorbar()
plt.figure()
plt.contourf(lhf["Summer"].T - lhc["Summer"].T, levels=cs.levels, cmap=cs.cmap, norm=cs.norm)
plt.title("d(lh)")
plt.colorbar()
# plotting
plot_utils.apply_plot_params(width_cm=15, height_cm=15, font_size=10)
gs = GridSpec(2, 2)
# tair_c_ts = analysis.get_area_mean_timeseries(model_config_c.data_path, var_name="TT", level_index=0,
# start_year=model_config_c.start_year, end_year=model_config_c.end_year,
# the_mask=lkfr >= lkfr_limit)
#
# tair_f_ts = analysis.get_area_mean_timeseries(model_config_f.data_path, var_name="TT", level_index=0,
# start_year=model_config_f.start_year, end_year=model_config_f.end_year,
# the_mask=lkfr >= lkfr_limit)
#
#
# tlake_c_ts = analysis.get_area_mean_timeseries(model_config_c.data_path, var_name="TT", level_index=0,
# start_year=model_config_c.start_year, end_year=model_config_c.end_year,
# the_mask=lkfr >= lkfr_limit)
#
# tlake_f_ts = analysis.get_area_mean_timeseries(model_config_f.data_path, var_name="TT", level_index=0,
# start_year=model_config_f.start_year, end_year=model_config_f.end_year,
# the_mask=lkfr >= lkfr_limit)
for season in season_to_months:
fig = plt.figure()
lktemp_c[season] -= 273.15
dT_c = np.ma.masked_where(lkfr < lkfr_limit, lktemp_c[season] - airtemp_c[season])
lktemp_f[season] -= 273.15
dT_f = np.ma.masked_where(lkfr < lkfr_limit, lktemp_f[season] - airtemp_f[season])
d = np.round(max(np.ma.abs(dT_c).max(), np.ma.abs(dT_f).max()))
vmin = -d
vmax = d
clevs = np.arange(-12, 13, 1)
ncolors = len(clevs) - 1
bn = BoundaryNorm(clevs, ncolors=ncolors)
cmap = cm.get_cmap("seismic", ncolors)
ax_list = []
fig.suptitle(season)
xx, yy = bmp_info.get_proj_xy()
# Current gradient
ax = fig.add_subplot(gs[0, 0])
ax.set_title(r"current: $T_{\rm lake} - T_{\rm atm}$")
cs = bmp_info.basemap.pcolormesh(xx, yy, dT_c, ax=ax, norm=bn, cmap=cmap)
bmp_info.basemap.colorbar(cs, ax=ax, extend="both")
ax_list.append(ax)
# Future Gradient
ax = fig.add_subplot(gs[0, 1])
ax.set_title(r"future: $T_{\rm lake} - T_{\rm atm}$")
cs = bmp_info.basemap.pcolormesh(xx, yy, dT_f, ax=ax, norm=cs.norm, cmap=cs.cmap, vmin=vmin, vmax=vmax)
bmp_info.basemap.colorbar(cs, ax=ax, extend="both")
ax_list.append(ax)
# Change in the gradient
ax = fig.add_subplot(gs[1, 0])
ax.set_title(r"$\Delta T_{\rm future} - \Delta T_{\rm current}$")
ddT = dT_f - dT_c
d = np.round(np.ma.abs(ddT).max())
clevs = np.arange(-3, 3.1, 0.1)
ncolors = len(clevs) - 1
bn = BoundaryNorm(clevs, ncolors=ncolors)
cmap = cm.get_cmap("seismic", ncolors)
cs = bmp_info.basemap.pcolormesh(xx, yy, ddT, norm=bn, cmap=cmap)
bmp_info.basemap.colorbar(cs, ax=ax, extend="both")
ax_list.append(ax)
# Change in the latent heat flux
# ax = fig.add_subplot(gs[1, 1])
# ax.set_title(r"$LE_{\rm future} - LE_{\rm current}$")
# dlh = np.ma.masked_where(lkfr < lkfr_limit, lhf[season] - lhc[season])
#
# d = np.round(np.ma.abs(dlh).max() // 10) * 10
# clevs = np.arange(0, 105, 5)
# bn = BoundaryNorm(clevs, ncolors=ncolors)
# cmap = cm.get_cmap("jet", ncolors)
#
# cs = bmp_info.basemap.pcolormesh(xx, yy, dlh, norm=bn, cmap=cmap)
# bmp_info.basemap.colorbar(cs, ax=ax, extend="max") # Change in the latent heat flux
# ax_list.append(ax)
for the_ax in ax_list:
bmp_info.basemap.drawcoastlines(linewidth=0.3, ax=the_ax)
fig.tight_layout()
fig.savefig(os.path.join(img_folder, "lake_atm_gradients_and_fluxes_{}-{}_{}-{}.png".format(model_config_f.start_year, model_config_f.end_year, start_year_c, end_year_c)),
dpi=800,
bbox_inches="tight")
def main():
"""
Everything is aggregated to the CRU resolution before calculating biases
"""
season_to_months = DEFAULT_SEASON_TO_MONTHS
varnames = ["PR", "TT"]
plot_utils.apply_plot_params(font_size=5,
width_pt=None,
width_cm=15,
height_cm=4)
# 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-RL_0.4deg")
bmp_info = analysis.get_basemap_info(r_config=reanalysis_driven_config)
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"
}
xx_agg = None
yy_agg = None
for vname in varnames:
# 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)
# get CRU obs 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)
if xx_agg is None:
xx_agg, yy_agg = bmp_info_agg.get_proj_xy()
# get model data
seasonal_clim_fields_model = analysis.get_seasonal_climatology_for_runconfig(
run_config=reanalysis_driven_config,
varname=vname,
level=0,
season_to_months=season_to_months)
###
biases_with_anusplin = OrderedDict()
biases_with_cru = OrderedDict()
nx_agg_anusplin = 4
ny_agg_anusplin = 4
nx_agg_model = 1
ny_agg_model = 1
season_to_clim_fields_model_agg = OrderedDict()
for season, field in seasonal_clim_fields_model.items():
print(field.shape)
season_to_clim_fields_model_agg[season] = aggregate_array(
field, nagg_x=nx_agg_model, nagg_y=ny_agg_model)
if vname == "PR":
season_to_clim_fields_model_agg[season] *= 1.0e3 * 24 * 3600
biases_with_cru[season] = season_to_clim_fields_model_agg[
season] - season_to_obs_cru[season]
biases_with_anusplin[season] = season_to_clim_fields_model_agg[
season] - aggregate_array(season_to_obs_anusplin[season],
nagg_x=nx_agg_anusplin,
nagg_y=ny_agg_anusplin)
# Do the plotting
fig = plt.figure()
clevs = [c for c in np.arange(-0.5, 0.55, 0.05)
] if vname == "PR" else np.arange(-2, 2.2, 0.2)
gs = GridSpec(1,
len(biases_with_cru) + 1,
width_ratios=len(biases_with_cru) * [
1.,
] + [
0.05,
])
col = 0
cs = None
cmap = "seismic"
fig.suptitle(
r"$\left| \delta_{\rm Hopkinson} \right| - \left| \delta_{\rm CRU} \right|$"
)
for season, cru_err in biases_with_cru.items():
anu_err = biases_with_anusplin[season]
ax = fig.add_subplot(gs[0, col])
diff = np.abs(anu_err) - np.abs(cru_err)
cs = bmp_info_agg.basemap.contourf(xx_agg,
yy_agg,
diff,
levels=clevs,
ax=ax,
extend="both",
cmap=cmap)
bmp_info_agg.basemap.drawcoastlines(ax=ax, linewidth=0.3)
good = diff[~diff.mask & ~np.isnan(diff)]
n_neg = sum(good < 0) / sum(good > 0)
print("season: {}, n-/n+ = {}".format(season, n_neg))
ax.set_title(season)
ax.set_xlabel(r"$n_{-}/n_{+} = $" + "{:.1f}".format(n_neg) + "\n" +
r"$\overline{\varepsilon} = $" +
"{:.2f}".format(good.mean()))
col += 1
ax = fig.add_subplot(gs[0, -1])
plt.colorbar(cs, cax=ax)
ax.set_title("mm/day" if vname == "PR" else r"${\rm ^\circ C}$")
fig.savefig(os.path.join(
img_folder, "comp_anu_and_cru_biases_for_{}_{}.png".format(
vname, reanalysis_driven_config.label)),
bbox_inches="tight",
dpi=common_plot_params.FIG_SAVE_DPI)
def compare_vars(vname_model="TT",
vname_obs="tmp",
r_config=None,
season_to_months=None,
obs_path=None,
nx_agg_model=5,
ny_agg_model=5,
bmp_info_agg=None,
diff_axes_list=None,
obs_axes_list=None,
model_axes_list=None,
bmp_info_model=None,
mask_shape_file=None,
nx_agg_obs=1,
ny_agg_obs=1):
"""
if obs_axes_list is not None, plot observation data in those
:param mask_shape_file:
:param bmp_info_model: basemap info native to the model
:param model_axes_list: Axes to plot model outputs
:param vname_model:
:param vname_obs:
:param r_config:
:param season_to_months:
:param obs_path:
:param nx_agg_model:
:param ny_agg_model:
:param bmp_info_agg:
:param diff_axes_list: if it is None the plots for each variable is done in separate figures
"""
if vname_obs is None:
vname_model_to_vname_obs = {"TT": "tmp", "PR": "pre"}
vname_obs = vname_model_to_vname_obs[vname_model]
seasonal_clim_fields_model = analysis.get_seasonal_climatology_for_runconfig(
run_config=r_config,
varname=vname_model,
level=0,
season_to_months=season_to_months)
season_to_clim_fields_model_agg = OrderedDict()
for season, field in seasonal_clim_fields_model.items():
print(field.shape)
season_to_clim_fields_model_agg[season] = aggregate_array(
field, nagg_x=nx_agg_model, nagg_y=ny_agg_model)
if vname_model == "PR":
season_to_clim_fields_model_agg[season] *= 1.0e3 * 24 * 3600
if vname_obs in [
"SWE",
]:
obs_manager = SweDataManager(path=obs_path, var_name=vname_obs)
elif obs_path is None:
obs_manager = CRUDataManager(var_name=vname_obs)
else:
obs_manager = CRUDataManager(var_name=vname_obs, path=obs_path)
seasonal_clim_fields_obs = obs_manager.get_seasonal_means(
season_name_to_months=season_to_months,
start_year=r_config.start_year,
end_year=r_config.end_year)
seasonal_clim_fields_obs_interp = OrderedDict()
# Derive the mask from a shapefile if provided
if mask_shape_file is not None:
the_mask = get_mask(bmp_info_agg.lons,
bmp_info_agg.lats,
shp_path=mask_shape_file)
else:
the_mask = np.zeros_like(bmp_info_agg.lons)
for season, obs_field in seasonal_clim_fields_obs.items():
obs_field = obs_manager.interpolate_data_to(obs_field,
lons2d=bmp_info_agg.lons,
lats2d=bmp_info_agg.lats,
nneighbours=nx_agg_obs *
ny_agg_obs)
obs_field = np.ma.masked_where(the_mask > 0.5, obs_field)
seasonal_clim_fields_obs_interp[season] = obs_field
# assert hasattr(seasonal_clim_fields_obs_interp[season], "mask")
season_to_err = OrderedDict()
print("-------------var: {} (PE with CRU)---------------------".format(
vname_model))
for season in seasonal_clim_fields_obs_interp:
seasonal_clim_fields_obs_interp[season] = np.ma.masked_where(
np.isnan(seasonal_clim_fields_obs_interp[season]),
seasonal_clim_fields_obs_interp[season])
season_to_err[season] = season_to_clim_fields_model_agg[
season] - seasonal_clim_fields_obs_interp[season]
if vname_model in ["I5"]:
lons = bmp_info_agg.lons.copy()
lons[lons > 180] -= 360
season_to_err[season] = maskoceans(lons, bmp_info_agg.lats,
season_to_err[season])
good_vals = season_to_err[season]
good_vals = good_vals[~good_vals.mask]
print("{}: min={}; max={}; avg={}".format(season, good_vals.min(),
good_vals.max(),
good_vals.mean()))
print("---------percetages --- CRU ---")
print("{}: {} \%".format(
season,
good_vals.mean() / seasonal_clim_fields_obs_interp[season]
[~season_to_err[season].mask].mean() * 100))
cs = plot_seasonal_mean_biases(season_to_error_field=season_to_err,
varname=vname_model,
basemap_info=bmp_info_agg,
axes_list=diff_axes_list)
if obs_axes_list is not None and vname_model in ["I5"]:
clevs = [0, 50, 60, 70, 80, 90, 100, 150, 200, 250, 300, 350, 400, 500]
cs_obs = None
xx, yy = bmp_info_agg.get_proj_xy()
lons = bmp_info_agg.lons.copy()
lons[lons > 180] -= 360
lons_model = None
xx_model, yy_model = None, None
cs_mod = None
norm = BoundaryNorm(clevs, 256)
for col, (season, obs_field) in enumerate(
seasonal_clim_fields_obs_interp.items()):
# Obsrved fields
ax = obs_axes_list[col]
if bmp_info_agg.should_draw_basin_boundaries:
bmp_info_agg.basemap.readshapefile(BASIN_BOUNDARIES_SHP[:-4],
"basin",
ax=ax)
to_plot = maskoceans(lons, bmp_info_agg.lats, obs_field)
cs_obs = bmp_info_agg.basemap.contourf(xx,
yy,
to_plot,
levels=clevs,
ax=ax,
norm=norm,
extend="max")
bmp_info_agg.basemap.drawcoastlines(ax=ax, linewidth=0.3)
ax.set_title(season)
# Model outputs
if model_axes_list is not None:
ax = model_axes_list[col]
if bmp_info_agg.should_draw_basin_boundaries:
bmp_info_agg.basemap.readshapefile(
BASIN_BOUNDARIES_SHP[:-4], "basin", ax=ax)
if lons_model is None:
lons_model = bmp_info_model.lons.copy()
lons_model[lons_model > 180] -= 360
xx_model, yy_model = bmp_info_model.basemap(
lons_model, bmp_info_model.lats)
model_field = seasonal_clim_fields_model[season]
to_plot = maskoceans(lons_model, bmp_info_model.lats,
model_field)
cs_mod = bmp_info_agg.basemap.contourf(xx_model,
yy_model,
to_plot,
levels=cs_obs.levels,
ax=ax,
norm=cs_obs.norm,
cmap=cs_obs.cmap,
extend="max")
bmp_info_agg.basemap.drawcoastlines(ax=ax, linewidth=0.3)
plt.colorbar(cs_obs, cax=obs_axes_list[-1])
return cs
