def plot_granule_tropomi_no2(
*args,
ax=None,
fig=None,
xtick=None,
ytick=None,
region_limit=None,
valid_min=None,
valid_max=None,
cbar=True,
cbar_prop={},
title='',
**kwargs,
):
""" Plot a granule of TROPOMI
nitrogendioxide_tropospheric_column.
Parameters
----------
Most parameters are transfered to
cartopy_plot in cartopy_plot.py
"""
# get *agrs
if (len(args) == 4):
filename = args[3]
var_name = args[0:3]
in_data = read_tropomi_no2(filename,
varnames=var_name,
replace=True,
verbose=True)
lon = in_data[args[0]]
lat = in_data[args[1]]
var = in_data[args[2]]
else:
lon = copy.deepcopy(args[0])
lat = copy.deepcopy(args[1])
var = copy.deepcopy(args[2])
out_dict = cartopy_plot(lon,
lat,
var,
ax=None,
fig=None,
xtick=xtick,
ytick=ytick,
region_limit=region_limit,
valid_min=valid_min,
valid_max=valid_max,
cbar=cbar,
cbar_prop=cbar_prop,
title=title,
**kwargs)
return out_dict
def plot_ave(
ave,
lat_e,
lon_e,
xticks=np.arange(-180.0, 180.1, 60.0),
yticks=np.arange(-90.0, 90.1, 30.0),
region_limit=[-90.0, -180.0, 90.0, 180.0],
vmin=None,
vmax=None,
units='',
):
""" plot average
(ywang, 04/12/20)
Parameters
----------
ave : 2D array
PCA modes
lat_e : shape (n_lat+1, n_lon+1)
Latitude edges
lon_e : shape (n_lat+1, n_lon+1)
Longitude edges
"""
# begin plot
nrow = 2
ncol = 1
figsize = (8, 6)
projPos = [0]
layout_dict = multiFigure(nrow, ncol, figsize=figsize, projPos=projPos)
fig = layout_dict['fig']
axes = layout_dict['axes']
# plot average
pout = cartopy_plot(lon_e,
lat_e,
ave,
ax=axes[0],
vmin=vmin,
vmax=vmax,
cmap=deepcopy(WhGrYlRd_map),
cbar=True)
pout['cb'].set_label(units)
states_provinces = cfeature.NaturalEarthFeature(
category='cultural',
name='admin_1_states_provinces_lines',
scale='50m',
facecolor='none')
panel_tick_label(axes[0:1], ncol, xticks=xticks, yticks=yticks)
axes[0].add_feature(cfeature.BORDERS)
axes[0].add_feature(states_provinces, edgecolor='k', linewidth=0.5)
axes[0].add_feature(cfeature.COASTLINE, zorder=200)
axes[0].set_xlim((region_limit[1], region_limit[3]))
axes[0].set_ylim((region_limit[0], region_limit[2]))
def plot_comparison(
var1,
var2,
lat_e,
lon_e,
figsize=(6, 7),
vmin=None,
vmax=None,
diff_vmin=None,
diff_vmax=None,
cb_diff_ticks=None,
left=0.25,
right=0.75,
top=0.95,
bottom=0.1,
hspace=None,
wspace=None,
cl_color='k',
lw=None,
region_limit=None,
xticks=np.arange(-180, 180.0, 60),
yticks=np.arange(-90, 90.1, 30),
title_dict={},
cmap=deepcopy(WhGrYlRd_map),
diff_cmap=deepcopy(gbcwpry_map),
units='',
cb_ratio=0.03,
cb_y_off=-0.05,
mask_ocean=False,
):
""" Plot var1, var2 and var2 - var1.
(Yi Wang, 09/02/2020)
Parameters
----------
var1 : 2-D numpy array
The first variable.
var2 : 2-D numpy array
The second variable.
lat_e : 2-D numpy array
Latitude edges.
lon_e : 2-D numpy array
Longitude edge.
figsize : 2-element tuple
Figure size
vmin : float or None
Minimum to be plotted for var1 and var2.
If vmin is None, it will be set as the valid minimum of var1
or var2, which is smaller.
vmax : float or None
Similar to vmin, but of maximum
diff_vmin : float or None
Minimum to be plotted for var2 - var1.
diff_vmax : float or None
Maximum to be plotted for var2 = var1.
Returns
-------
"""
# define figure
nrow = 3
ncol = 1
projPos = list(range(nrow * ncol))
layout_dict = multiFigure(nrow,
ncol,
left=left,
right=right,
top=top,
bottom=bottom,
wspace=wspace,
hspace=hspace,
figsize=figsize,
projPos=projPos,
countries=True,
states=True,
coastlines=True,
mask_ocean=mask_ocean)
fig = layout_dict['fig']
axes = layout_dict['axes']
# get min and max for var1 and var2
if vmin is None:
vmin = min(np.min(var1), np.min(var2))
if vmax is None:
vmax = max(np.max(var1), np.max(var2))
# plot var1 and var2
var_list = [var1, var2]
varname_list = ['var1', 'var2']
for i in range(len(var_list)):
ax = axes[i]
var = var_list[i]
title = title_dict.get(varname_list[i], None)
pout = cartopy_plot(lon_e,
lat_e,
var,
ax=ax,
title=title,
cbar=False,
vmin=vmin,
vmax=vmax,
cmap=deepcopy(cmap))
# plot var2 - var1
diff = var2 - var1
ax = axes[2]
title = title_dict.get('diff', None)
diff_pout = cartopy_plot(lon_e,
lat_e,
diff,
ax=ax,
title=title,
cbar=False,
vmin=diff_vmin,
vmax=diff_vmax,
cmap=deepcopy(diff_cmap))
# ticks
panel_tick_label(axes, ncol, xticks=xticks, yticks=yticks)
# set limit
for ax in axes:
if region_limit is not None:
ax.set_xlim((region_limit[1], region_limit[3]))
ax.set_ylim((region_limit[0], region_limit[2]))
# colorbar for var1 and var2
cax1 = h_1_ax(fig, axes[1], ratio=cb_ratio, y_off=cb_y_off)
cb1 = plt.colorbar(pout['mesh'], cax=cax1, orientation='horizontal')
right_center_label(cax1, units)
# colorbar for diff
cax2 = h_1_ax(fig, axes[2], ratio=cb_ratio, y_off=cb_y_off)
cb2 = plt.colorbar(diff_pout['mesh'], cax=cax2, orientation='horizontal')
if cb_diff_ticks is not None:
cb2.set_ticks(cb_diff_ticks)
right_center_label(cax2, units)
def plot_comparison_2(
var1,
var2,
lat_e,
lon_e,
figsize=(8, 6),
vmin=None,
vmax=None,
diff_vmin=None,
diff_vmax=None,
rel_pct_vmin=None,
rel_pct_vmax=None,
cb_diff_ticks=None,
cb_rel_pct_ticks=None,
extend='neither',
diff_extend='neither',
rel_pct_extend='neither',
left=0.08,
right=0.80,
top=0.95,
bottom=0.1,
hspace=None,
wspace=None,
cl_color='k',
lw=None,
region_limit=None,
region_limit_2=None,
xticks=np.arange(-180, 180.0, 60),
yticks=np.arange(-90, 90.1, 30),
title_dict={},
cmap=deepcopy(WhGrYlRd_map),
diff_cmap=deepcopy(gbcwpry_map),
rel_pct_cmap=deepcopy(gbcwpry_map),
units='',
diff_units='',
cb_ratio=0.06,
cb_y_off_t=-0.04,
cb_y_off_b=-0.07,
mask_ocean=False,
):
""" Plot var1, var2 and var2 - var1.
(Yi Wang, 10/08/2020)
Parameters
----------
var1 : 2-D numpy array
The first variable.
var2 : 2-D numpy array
The second variable.
lat_e : 2-D numpy array
Latitude edges.
lon_e : 2-D numpy array
Longitude edge.
figsize : 2-element tuple
Figure size
vmin : float or None
Minimum to be plotted for var1 and var2.
If vmin is None, it will be set as the valid minimum of var1
or var2, which is smaller.
vmax : float or None
Similar to vmin, but of maximum
diff_vmin : float or None
Minimum to be plotted for var2 - var1.
diff_vmax : float or None
Maximum to be plotted for var2 = var1.
rel_pct_vmin : float or None
Minimum to be plotted for (var2 - var1) / var1 * 100
rel_pct_vmax : float or None
Maximum to be plotted for (var2 - var1) / var1 * 100
Returns
-------
"""
if region_limit is not None:
i1, i2, j1, j2 = \
get_center_index_latlon(lat_e[:,0], lon_e[0,:], region_limit)
# define figure
nrow = 2
ncol = 2
projPos = list(range(nrow * ncol))
layout_dict = multiFigure(nrow,
ncol,
left=left,
right=right,
top=top,
bottom=bottom,
wspace=wspace,
hspace=hspace,
figsize=figsize,
projPos=projPos,
countries=True,
states=True,
coastlines=True,
mask_ocean=mask_ocean)
fig = layout_dict['fig']
axes = layout_dict['axes']
# get min and max for var1 and var2
if vmin is None:
vmin = min(np.nanmin(var1), np.nanmin(var2))
if vmax is None:
vmax = max(np.nanmax(var1), np.nanmax(var2))
# plot var1 and var2
var_list = [var1, var2]
varname_list = ['var1', 'var2']
for i in range(len(var_list)):
ax = axes[i]
var = var_list[i]
title = title_dict.get(varname_list[i], None)
pout = cartopy_plot(lon_e,
lat_e,
var,
ax=ax,
title=title,
cbar=False,
vmin=vmin,
vmax=vmax,
cmap=deepcopy(cmap))
# plot (var2 - var1) / var1 * 100
rel_pct = (var2 - var1) / var1 * 100
if (rel_pct_vmin is None) and (rel_pct_vmax is None):
rel_pct_vmax = np.nanmax(np.absolute(rel_pct))
rel_pct_vmin = -rel_pct_vmax
ax = axes[2]
title = title_dict.get('relative_diff', None)
rel_pct_pout = cartopy_plot(lon_e,
lat_e,
rel_pct,
ax=ax,
title=title,
cbar=False,
vmin=rel_pct_vmin,
vmax=rel_pct_vmax,
cmap=deepcopy(rel_pct_cmap))
if region_limit is None:
sub_rel_pct = rel_pct
else:
sub_rel_pct = rel_pct[i1:i2 + 1, j1:j2 + 1]
print('plot_comparison_2:')
print('rel_pct min={:}, max={:}'.format(np.nanmin(sub_rel_pct),
np.nanmax(sub_rel_pct)))
# plot var2 - var1
diff = var2 - var1
if (diff_vmin is None) and (diff_vmax is None):
diff_vmax = np.nanmax(np.absolute(diff))
diff_vmin = -diff_vmax
ax = axes[3]
title = title_dict.get('diff', None)
diff_pout = cartopy_plot(lon_e,
lat_e,
diff,
ax=ax,
title=title,
cbar=False,
vmin=diff_vmin,
vmax=diff_vmax,
cmap=deepcopy(diff_cmap))
# ticks
panel_tick_label(axes, ncol, xticks=xticks, yticks=yticks)
# set limit
for ax in axes:
if region_limit is not None:
ax.set_xlim((region_limit[1], region_limit[3]))
ax.set_ylim((region_limit[0], region_limit[2]))
if region_limit_2 is not None:
ax.set_xlim((region_limit_2[1], region_limit_2[3]))
ax.set_ylim((region_limit_2[0], region_limit_2[2]))
# colorbar for var1 and var2
cax1 = h_2_ax(fig, axes[0], axes[1], ratio=cb_ratio, y_off=cb_y_off_t)
cb1 = plt.colorbar(pout['mesh'],
cax=cax1,
orientation='horizontal',
extend=extend)
right_center_label(cax1, units)
# colorbar for (var2 - var1) / var1 * 100
cax2 = h_1_ax(fig, axes[2], ratio=cb_ratio, y_off=cb_y_off_b)
cb2 = plt.colorbar(rel_pct_pout['mesh'],
cax=cax2,
orientation='horizontal',
extend=rel_pct_extend)
if cb_rel_pct_ticks is not None:
cb2.set_ticks(cb_rel_pct_ticks)
right_center_label(cax2, '[%]')
# colorbar for diff
cax3 = h_1_ax(fig, axes[3], ratio=cb_ratio, y_off=cb_y_off_b)
cb3 = plt.colorbar(diff_pout['mesh'],
cax=cax3,
orientation='horizontal',
extend=diff_extend)
if cb_diff_ticks is not None:
cb3.set_ticks(cb_diff_ticks)
right_center_label(cax3, diff_units)
def plot_pearsonr_map(filename,
fig_dir,
varname,
name='',
p_thre=0.05,
r_vmin=None,
r_vmax=None,
r_cmap=plt.get_cmap('seismic'),
r_signi_cmap=plt.get_cmap('seismic'),
r_signi_vmin=None,
r_signi_vmax=None,
r_signi_min_valid=None,
p_vmin=None,
p_vmax=None,
p_cmap=None,
signi_ocean_color=None,
countries=True,
states=True,
cl_res='110m',
cl_color=None,
lw=None,
equator=False,
NH_label='',
SH_label=''):
""" Plot pearson correlation coefficent.
(ywang, 05/27/20)
Parameters
----------
filename : str
netCDF file of trend_analysis results.
fig_dir : str
Directory to save figures.
varname : str
variable name
name : str
Prefix of figure names.
p_thre : float
p-value threshod.
signi_ocean_color : None or str
If None, the *signi_ocean_color* color to
mask r_signi map if it is not None
"""
# directory
if fig_dir[-1] != '/':
fig_dir = fig_dir + '/'
# variables to be read
varnames = ['Latitude_e', 'Longitude_e', \
'r_'+varname, 'p_'+varname]
# read data
data = read_nc(filename, varnames, verbose=True)
# get latitude and longitude edges
lat_e = data['Latitude_e']
lon_e = data['Longitude_e']
# get correlation coefficients and p-value
r_val = data['r_' + varname]
p_val = data['p_' + varname]
cbar_prop = {}
cbar_prop['orientation'] = 'horizontal'
# equator line
eqr_c = 'white'
eqr_ls = '--'
eqr_ls_lw = 2
# plot correlation coefficients
r_plot = cartopy_plot(lon_e,
lat_e,
r_val,
cbar_prop=cbar_prop,
countries=countries,
states=states,
cmap=r_cmap,
vmin=r_vmin,
vmax=r_vmax)
r_plot['cb'].set_label('Linear correlation coefficient')
if equator:
r_plot['ax'].plot([-180, 180], [0, 0],
color=eqr_c,
linestyle=eqr_ls,
lw=eqr_ls_lw,
transform=ccrs.PlateCarree())
r_plot['ax'].text(-175,
5,
NH_label,
color=eqr_c,
ha='left',
va='bottom',
transform=ccrs.Geodetic())
r_plot['ax'].text(-175,
-5,
SH_label,
color=eqr_c,
ha='left',
va='top',
transform=ccrs.Geodetic())
# save correlation coefficients plot
fig_r = fig_dir + name + '_r_' + varname + '.png'
plt.savefig(fig_r, format='png', dpi=300)
# plot p value
p_plot = cartopy_plot(lon_e,
lat_e,
p_val,
cbar_prop=cbar_prop,
countries=countries,
states=states,
cmap=p_cmap,
vmin=p_vmin,
vmax=p_vmax)
p_plot['cb'].set_label('p-value')
if equator:
p_plot['ax'].plot([-180, 180], [0, 0],
color=eqr_c,
linestyle=eqr_ls,
lw=eqr_ls_lw,
transform=ccrs.PlateCarree())
p_plot['ax'].text(-175,
5,
NH_label,
color=eqr_c,
ha='left',
va='bottom',
transform=ccrs.Geodetic())
p_plot['ax'].text(-175,
-5,
SH_label,
color=eqr_c,
ha='left',
va='top',
transform=ccrs.Geodetic())
# save p-value
fig_p = fig_dir + name + '_p_' + varname + '.png'
plt.savefig(fig_p, format='png', dpi=300)
# plot correlation coefficients with p-value less than p_thre
r_val_signi = deepcopy(r_val)
flag = (p_val < p_thre)
r_val_signi[np.logical_not(flag)] = np.nan
if r_signi_min_valid is not None:
r_val_signi[r_val_signi < r_signi_min_valid] = np.nan
r_signi_plot = cartopy_plot(lon_e,
lat_e,
r_val_signi,
cbar_prop=cbar_prop,
countries=countries,
states=states,
cmap=r_signi_cmap,
vmin=r_signi_vmin,
vmax=r_signi_vmax)
r_signi_plot['cb'].set_label('Linear correlation coefficient' + \
' (p<{:})'.format(p_thre))
if equator:
r_signi_plot['ax'].plot([-180, 180], [0, 0],
color=eqr_c,
linestyle=eqr_ls,
lw=eqr_ls_lw,
transform=ccrs.PlateCarree(),
zorder=200)
r_signi_plot['ax'].text(-175,
5,
NH_label,
color=eqr_c,
ha='left',
va='bottom',
transform=ccrs.Geodetic(),
zorder=200)
r_signi_plot['ax'].text(-175,
-5,
SH_label,
color=eqr_c,
ha='left',
va='top',
transform=ccrs.Geodetic(),
zorder=200)
if signi_ocean_color is not None:
r_signi_plot['ax'].add_feature(cfeature.OCEAN,
color=signi_ocean_color,
zorder=100)
r_signi_plot['ax'].coastlines(resolution=cl_res,
color=cl_color,
lw=lw,
zorder=300)
# save correlation coefficients plot
fig_r_signi = fig_dir + name + '_r_p' + str(p_thre) + '_' + \
varname + '.png'
plt.savefig(fig_r_signi, format='png', dpi=300)
def fill_region_color(lon,
lat,
region_flag_list,
color_list,
region_limit=None,
ax=None,
fig=None,
xtick=None,
ytick=None,
cl_res=None,
countries=True,
states=True):
""" Fill regions by different colors.
(ywang, 06/12/2020)
Parameters
----------
lon : 2-D numpy array
2-D longitude
lat : 2-D numpy array
2-D latitude array
region_flag_list : list
Elements are region_flag, and a region_flag is a 2-D
bool array with True means the girds need to be filled.
color_list : list
Filled colors for each region.
region_limit : tuple-like or None
(min_lat, min_lon, max_lat, max_lon)
ax : GeoAxes or None (default)
Create a GeoAxes if ax is None.
fig : plt.figure() or None (default)
Create a plt.figure() if both fig and ax are None
xtick : list-like
Longitude ticks
ytick : list-like
Latitude ticks
cl_res : str
Coastline resolution.
Currently can be one of “110m”, “50m”, and “10m”
Returns
-------
out_dict :
keys : ax, fig, mesh
"""
# region index
region_ind = np.full_like(region_flag_list[0], np.nan, dtype=float)
for i in range(len(region_flag_list)):
region_flag = region_flag_list[i]
region_ind[region_flag] = i + 0.5
# plot
out_dict = cartopy_plot(lon,
lat,
region_ind,
ax=ax,
fig=fig,
region_limit=region_limit,
xtick=xtick,
ytick=ytick,
cmap=matplotlib.colors.ListedColormap(color_list),
bad_c='white',
cbar=False,
vmin=0.0,
vmax=len(region_flag_list),
cl_res=cl_res,
countries=countries,
states=states)
return out_dict
def plot_two_variables(lat1,
lon1,
var1,
lat2,
lon2,
var2,
figsize=None,
region_limit=None,
cl_res=None,
xtick=np.arange(-180, 180.1, 5),
ytick=np.arange(-90, 90.1, 5),
xtick1=None,
ytick1=None,
xtick2=None,
ytick2=None,
title1=None,
title2=None,
vmin1=None,
vmax1=None,
vmin2=None,
vmax2=None,
cl_color2='black',
lw1=1,
lw2=1,
unit1='',
unit2='',
y_offset=-0.08,
cmap1=None,
cmap2=None):
""" Plot two variables
Parameters
----------
"""
out_data = {}
out_data['pout'] = []
# figure and ax_list
if figsize is None:
figsize = (10, 5)
fig = plt.figure(figsize=figsize)
ax_list = []
# ticks
if xtick1 is None:
xtick1 = xtick
if ytick1 is None:
ytick1 = ytick
if xtick2 is None:
xtick2 = xtick
if ytick2 is None:
ytick2 = []
# colorbar paramters
h = 0.03
# plot var1
ax1 = add_geoaxes(fig,
121,
title=title1,
xtick=xtick1,
ytick=ytick1,
cl_res=cl_res,
lw=lw1)
pout1 = cartopy_plot(lon1,
lat1,
var1,
ax=ax1,
vmin=vmin1,
vmax=vmax1,
cbar=False,
cmap=cmap1)
ax1.reset_position()
ax_list.append(ax1)
out_data['pout'].append(pout1)
pos1 = pout1['ax'].get_position()
cax1 = fig.add_axes([pos1.x0, pos1.y0 + y_offset, pos1.width, h])
cb1 = plt.colorbar(pout1['mesh'],
cax=cax1,
orientation='horizontal',
extend='max')
cb1.set_label(unit1)
# plot var2
ax2 = add_geoaxes(fig,
122,
title=title2,
xtick=xtick2,
ytick=ytick2,
cl_res=cl_res,
lw=lw2,
cl_color=cl_color2)
ax_list.append(ax2)
pout2 = cartopy_plot(lon2,
lat2,
var2,
ax=ax2,
vmin=vmin2,
vmax=vmax2,
cbar=False,
cmap=cmap2)
out_data['pout'].append(pout2)
pos2 = pout2['ax'].get_position()
cax2 = fig.add_axes([pos2.x0, pos2.y0 + y_offset, pos2.width, h])
cb2 = plt.colorbar(pout2['mesh'],
cax=cax2,
orientation='horizontal',
extend='max')
cb2.set_label(unit2)
# set region limit
if region_limit is not None:
for i in range(len(ax_list)):
ax = ax_list[i]
ax.set_xlim(region_limit[1], region_limit[3])
ax.set_ylim(region_limit[0], region_limit[2])
return out_data
def plot_mxd04(filename,
varname,
ind=None,
ax=None,
fig=None,
title=None,
xtick=None,
ytick=None,
cl_res=None,
cmap=plt.get_cmap('rainbow'),
region_limit=None,
verbose=True,
**kwargs):
""" Plot a variable from MxD04_L2 product
Parameters
----------
filename : str
MxD04_L2 file.
varname : str
The variable to be plotted.
ind : None or int
If ind is int, it is index for band
ax : GeoAxes or None (default)
Create a GeoAxes if ax is None.
fig : plt.figure() or None (default)
Create a plt.figure() if both fig and ax are None
title : None or str
None: varname
verbose : logical
Whether or not output more informations.
"""
# ticks
if xtick is None:
xtick = np.arange(-180, 180.1, 10)
if ytick is None:
ytick = np.arange(-90, 90.1, 5)
if title is None:
title = varname
if verbose:
print(' - plot_mxd04: reading ' + filename)
# read data
fid = Dataset(filename, 'r')
lat = fid['Latitude'][:]
lon = fid['Longitude'][:]
var = fid[varname][:]
if ind is not None:
var = var[ind, :, :]
fid.close()
# plot
lon_e, lat_e = calculate_pixel_edge2(lon, lat)
cartopy_plot(lon_e,
lat_e,
var,
ax=ax,
fig=fig,
title=title,
xtick=xtick,
ytick=ytick,
cmap=cmap,
cl_res=cl_res,
region_limit=region_limit,
**kwargs)
def plot_modis_1km_rgb(mxd021km_file,
ax=None,
fig=None,
title='date',
xtick=None,
ytick=None,
cl_res=None,
region_limit=None,
verbose=False):
""" Read MxD021KM file to plot RGB image.
(Yi Wang, 12/04/2019)
Parameters
----------
mxd021km_file : str
MxD021KM file.
ax : GeoAxes or None (default)
Create a GeoAxes if ax is None.
fig : plt.figure() or None (default)
Create a plt.figure() if both fig and ax are None
title : None or str
None: no title
'date': date calcuated from filename
other str: title
Returns
-------
"""
# ticks
if xtick is None:
xtick = np.arange(-180, 180.1, 10)
if ytick is None:
ytick = np.arange(-90, 90.1, 5)
# get RGB, lat, and lon
lat, lon, rgb = get_modis_1km_rgb(mxd021km_file)
# title
if title == 'date':
tmp = mxd021km_file.split('/')[-1].split('.')
year = tmp[1][1:5]
day_of_year = int(tmp[1][5:8])
curr_date_d = \
datetime.datetime.strptime(year+'-01-01', '%Y-%m-%d') \
+ datetime.timedelta(days=(day_of_year-1))
ymd = str(curr_date_d)[0:10]
title = ymd
# plot RGB
cartopy_plot(lon,
lat,
rgb,
ax=ax,
fig=fig,
title=title,
xtick=xtick,
ytick=ytick,
cl_res=cl_res,
region_limit=region_limit)
def plot_trend_map(
filename,
fig_dir,
mean_flag=True,
trend_flag=True,
sigma_flag=True,
name='',
mean_vmin=None,
mean_vmax=None,
mean_cmap=None,
mean_units='',
trend_vmin=None,
trend_vmax=None,
trend_cmap=plt.get_cmap('seismic'),
trend_units='',
sigma_units='',
region_limit=None,
xtick=np.arange(-180, 180.0, 60),
ytick=np.arange(-90, 90.1, 30),
countries=True,
states=True,
mean_mask=None,
):
""" Plot results from trend_analysis.
(ywang, 05/21/20)
Parameters
----------
filename : str
netCDF file of trend_analysis results.
fig_dir : str
Directory to save figures.
mean_flag : bool
Plot mean or not
trend_flag : bool
Plot trend or not
sigma_flag : bool
Plot trend standard deviation or not
name : str
Prefix of figure names.
"""
# directory
if fig_dir[-1] != '/':
fig_dir = fig_dir + '/'
# variables to be read
varnames = ['Latitude_e', 'Longitude_e']
if mean_flag:
varnames.append('mean')
if trend_flag:
varnames.append('trend')
if sigma_flag:
varnames.append('trend_sigma')
# read data
data = read_nc(filename, varnames, verbose=True)
# get latitude and longitude edges
lat_e = data['Latitude_e']
lon_e = data['Longitude_e']
cbar_prop = {}
cbar_prop['orientation'] = 'horizontal'
# plot mean
if mean_flag:
mean = data['mean']
if mean_mask is None:
mean_mask = np.full_like(mean, False)
mean = np.ma.masked_array(mean, mean_mask)
mean_p = cartopy_plot(lon_e,
lat_e,
mean,
cbar_prop=cbar_prop,
countries=countries,
states=states,
cmap=mean_cmap,
xtick=xtick,
ytick=ytick,
vmin=mean_vmin,
vmax=mean_vmax)
mean_p['cb'].set_label(mean_units)
if region_limit is not None:
mean_p['ax'].set_xlim((region_limit[1], region_limit[3]))
mean_p['ax'].set_ylim((region_limit[0], region_limit[2]))
fig_mean = fig_dir + name + '_mean.png'
plt.savefig(fig_mean, format='png', dpi=300)
# plot trend
if trend_flag:
trend = data['trend']
trend_p = cartopy_plot(lon_e,
lat_e,
trend,
cbar_prop=cbar_prop,
vmin=trend_vmin,
vmax=trend_vmax,
countries=countries,
states=states,
xtick=xtick,
ytick=ytick,
cmap=trend_cmap)
trend_p['cb'].set_label(trend_units)
if region_limit is not None:
trend_p['ax'].set_xlim((region_limit[1], region_limit[3]))
trend_p['ax'].set_ylim((region_limit[0], region_limit[2]))
fig_trend = fig_dir + name + '_trend.png'
plt.savefig(fig_trend, format='png', dpi=300)
# plot trend_sigma
if sigma_flag:
sigma = data['trend_sigma']
if not trend_flag:
trend = data['trend']
# plot sigma
sigma_p = cartopy_plot(lon_e,
lat_e,
sigma,
cbar_prop=cbar_prop,
xtick=xtick,
ytick=ytick,
countries=countries,
states=states)
sigma_p['cb'].set_label(sigma_units)
if region_limit is not None:
sigma_p['ax'].set_xlim((region_limit[1], region_limit[3]))
sigma_p['ax'].set_ylim((region_limit[0], region_limit[2]))
# save sigma plot
fig_sigma = fig_dir + name + '_sigma.png'
plt.savefig(fig_sigma, format='png', dpi=300)
# trends that are significant
trend_signi_flag = (np.absolute(trend) / sigma) >= 2.0
trend_signi = \
np.ma.masked_array(trend, np.logical_not(trend_signi_flag))
# plot trends that are significant
trend_signi_p = cartopy_plot(lon_e,
lat_e,
trend_signi,
cbar_prop=cbar_prop,
countries=countries,
states=states,
xtick=xtick,
ytick=ytick,
vmin=trend_vmin,
vmax=trend_vmax,
cmap=trend_cmap)
trend_signi_p['cb'].set_label(trend_units)
if region_limit is not None:
trend_signi_p['ax'].set_xlim((region_limit[1], region_limit[3]))
trend_signi_p['ax'].set_ylim((region_limit[0], region_limit[2]))
# save trends that are significant plot
fig_trend_signi = fig_dir + name + '_trend_signi.png'
plt.savefig(fig_trend_signi, format='png', dpi=300)
lon_c, lat_c = np.meshgrid(lon_c, lat_c)
lon_e, lat_e = np.meshgrid(lon_e, lat_e)
pixel = np.array([lon_c.flatten(), lat_c.flatten()]).T
###############################
# test pixel_in_contiguous_US
###############################
# multiple pixels
out_dict = pixel_in_contiguous_US(pixel)
flag = np.reshape(out_dict['flag'], lat_c.shape)
pout = cartopy_plot(lon_e, lat_e, flag, cbar=False,
region_limit=[min_lat, min_lon, max_lat, max_lon],
xtick=np.arange(min_lon, max_lon + 0.1, 20.0),
ytick=np.arange(min_lat, max_lat + 0.1, 10.0),
cl_res='10m', countries=True
)
# One pixel
lat_in, lon_in = 40.0, -100.0
lat_out, lon_out = 30.0, -70.0
out_dict = pixel_in_contiguous_US(np.array([lon_in, lat_in ]))
flag_in = out_dict['flag']
out_dict = pixel_in_contiguous_US(np.array([lon_out, lat_out]))
flag_out = out_dict['flag']
print('Is lat = {}, lon = {} in the US? {}'.format(lat_in,
lon_in, flag_in))
print('Is lat = {}, lon = {} in the US? {}'.format(lat_out,
lon_out, flag_out))
def plot_2D_components_and_coeffs(
components,
lat_e,
lon_e,
coeffs,
explained_variance_ratio,
fig_dir,
name='',
n_components=5,
xticks=np.arange(-180.0, 180.1, 60.0),
yticks=np.arange(-90.0, 90.1, 30.0),
region_limit=[-90.0, -180.0, 90.0, 180.0],
time_ticks=None,
rotation=30.0,
reverse=[],
):
""" plot 2D PCA spatial pattern
(ywang, 04/12/20)
Parameters
----------
components : shape (n_lat, n_lon, n_components)
PCA modes
lat_e : shape (n_lat+1, n_lon+1)
Latitude edges
lon_e : shape (n_lat+1, n_lon+1)
Longitude edges
coeffs : shape (n_samples, n_components)
PCA coefficients
explained_variance_ratio : shape (n_components, )
Explained variance ratio
fig_dir : str
Directory to save figures
n_components : int
The first *n_component* modes and coeffs will be plotted.
time_ticks : tuple
The first element is tick positions, and the second
element is tick labels.
reverse : list
Mode and time series to be reversed. 1-based
"""
# directory
if fig_dir[-1] != '/':
fig_dir = fig_dir + '/'
# n_components
n_components = min([n_components, components.shape[2], coeffs.shape[1]])
for ic in range(n_components):
# begin plot
nrow = 2
ncol = 1
figsize = (8, 6)
projPos = [0]
layout_dict = multiFigure(nrow, ncol, figsize=figsize, projPos=projPos)
fig = layout_dict['fig']
axes = layout_dict['axes']
# reverse
if (ic + 1) in reverse:
sign = -1
else:
sign = 1
# plot mode
mode = components[:, :, ic] * sign
vmax = np.max(np.absolute(mode))
vmin = -vmax
pout = cartopy_plot(lon_e,
lat_e,
mode,
ax=axes[0],
vmin=vmin,
vmax=vmax,
cmap=deepcopy(gbcwpry_map),
cbar=True)
states_provinces = cfeature.NaturalEarthFeature(
category='cultural',
name='admin_1_states_provinces_lines',
scale='50m',
facecolor='none')
axes[0].add_feature(cfeature.BORDERS)
axes[0].add_feature(states_provinces, edgecolor='k', linewidth=0.5)
axes[0].add_feature(cfeature.COASTLINE, zorder=200)
axes[0].set_xlim((region_limit[1], region_limit[3]))
axes[0].set_ylim((region_limit[0], region_limit[2]))
# add title
y_p = 1.03
left_title = 'Mode {}'.format(ic + 1)
axes[0].text(0,
y_p,
left_title,
ha='left',
va='bottom',
transform=axes[0].transAxes)
right_title = '{:.1f}%'.format(explained_variance_ratio[ic] * 100)
axes[0].text(1,
y_p,
right_title,
ha='right',
va='bottom',
transform=axes[0].transAxes)
# ticks
panel_tick_label(axes[0:1], ncol, xticks=xticks, yticks=yticks)
# plot coeff
coeff = coeffs[:, ic] * sign
x = range(len(coeff))
axes[1].plot(x, coeff, '-o', markersize=3)
axes[1].set_xlabel('Month')
if time_ticks is not None:
axes[1].set_xticks(time_ticks[0])
axes[1].set_xticklabels(time_ticks[1], rotation=rotation)
# save figure
if (name != ''):
figname = fig_dir + name + '_mode{}'.format(ic + 1) + '.png'
else:
figname = fig_dir + 'mode{}'.format(ic + 1) + '.png'
plt.savefig(figname, format='png', dpi=300)
def compare_two_varilables(filename, varname1, varname2,
vmin=0.0, vmax=0.8,
diff_min=None, diff_max=None,
seperate_cbar=False,
region_limit=None,
sc_xlabel='',
sc_ylabel='',
sc_max=1.0,
verbose=True):
"""
"""
# read data
coord_varns = ['Latitude_e', 'Longitude_e']
some_varns = [varname1, varname2]
varnames = coord_varns + some_varns
data_dict = read_nc(filename, varnames, verbose=verbose)
# region_limit
if region_limit is not None:
lat_e_1D = data_dict['Latitude_e'][:,0]
lon_e_1D = data_dict['Longitude_e'][0,:]
# index
i1 = get_center_index(lat_e_1D, region_limit[0])
i2 = get_center_index(lat_e_1D, region_limit[2])
j1 = get_center_index(lon_e_1D, region_limit[1])
j2 = get_center_index(lon_e_1D, region_limit[3])
for varn in varnames:
if varn in coord_varns:
data_dict[varn] = data_dict[varn][i1:i2+2,j1:j2+2]
if varn in some_varns:
data_dict[varn] = data_dict[varn][i1:i2+1,j1:j2+1]
# plot
fig = plt.figure(figsize=(8,7))
plt.subplots_adjust(top=0.98)
ax_list = []
xtick = [100, 110, 120]
ytick = [30, 40, 50]
xtick_list = [xtick, xtick, xtick]
ytick_list = [ytick, [], ytick]
for i in range(len(xtick_list)):
ax = add_geoaxes(fig, int('22'+str(i+1)),
xtick=xtick_list[i], ytick=ytick_list[i])
ax_list.append(ax)
lat_e = data_dict['Latitude_e']
lon_e = data_dict['Longitude_e']
# colorbar height
h = 0.02
# variables
for i in range(len(some_varns)):
varn = some_varns[i]
var = data_dict[varn]
ax = ax_list[i]
var_out = cartopy_plot(lon_e, lat_e, var, ax=ax,
vmin=vmin, vmax=vmax,
cbar=seperate_cbar, cmap=deepcopy(WhGrYlRd_map))
add_China_province(ax)
# colorbar for variables
ax1 = ax_list[0]
ax2 = ax_list[1]
cax_v = h_2_ax(fig, ax1, ax2, y_off=-0.06, height=h)
plt.colorbar(var_out['mesh'], cax=cax_v, orientation='horizontal')
right_center_label(cax_v, '[DU]')
# difference
ax = ax_list[2]
var_diff = data_dict[varname2] - data_dict[varname1]
diff_out = cartopy_plot(lon_e, lat_e, var_diff, ax=ax,
vmin=diff_min, vmax=diff_max,
cbar=seperate_cbar, cmap=plt.get_cmap('seismic'))
add_China_province(ax)
# colorbar of difference
ax = ax_list[2]
cax_diff = h_1_ax(fig, ax, y_off=-0.06, height=h)
plt.colorbar(diff_out['mesh'], cax=cax_diff, orientation='horizontal')
right_center_label(cax_diff, '[DU]')
# scatter plot
ax_sc = fig.add_subplot(224)
ax_sc.set_aspect('equal')
ax_sc.set_xlabel(sc_xlabel)
ax_sc.set_ylabel(sc_ylabel)
ax_sc.set_xlim([0,1.0])
ax_sc.set_ylim([0,1.0])
label_ul = ['R', 'linear_eq', 'rmse', 'nmb', 'mb', 'N']
scatter(ax_sc, data_dict[varname1], data_dict[varname2], s=3,
label_ul=label_ul)
# region
if region_limit is not None:
for ax in ax_list:
ax.set_xlim(region_limit[1], region_limit[3])
ax.set_ylim(region_limit[0], region_limit[2])
def plot_monthly_anomaly_for_6yrs(dir_mean,
dir_month,
start_year,
end_year,
year_list,
month,
verbose=False,
region_limit=[-90.0, -180.0, 90.0, 180.0],
left=0.05,
right=0.98,
top=0.9,
bottom=0.1,
wspace=0.05,
hspace=0.05,
y_off=-0.06,
dir_fig=None,
vmin_ano=-0.1,
vmax_ano=0.1,
xticks=np.arange(-180.0, 180.1, 20.0),
yticks=np.arange(-90.0, 90.1, 10.0),
name='',
vmin_ano_per=-50.0,
vmax_ano_per=50.0):
""" Plot monhtly anomaly for 6 years
"""
# used to convert unit
toDU = 2.69e16
# read monthly data
NO2_month_dict = {}
for year in year_list:
file_month = dir_month + 'OMI_NO2_' + year + '-' + month \
+ '_monthly.nc'
NO2_month = io.read_month_OMI_NO2_L3(file_month, verbose=verbose)
NO2_month = NO2_month / toDU
NO2_month_dict[year] = NO2_month
# read mutli-year mean of monthly NO2
NO2_mean = io.read_multi_year_month_OMI_NO2_L3(dir_mean,
start_year,
end_year,
month,
verbose=verbose)
NO2_mean = NO2_mean / toDU
# NO2 anomaly and relative anoamly
NO2_ano_dict = {}
NO2_ano_percent_dict = {}
for year in year_list:
# anomaly
NO2_ano = NO2_month_dict[year] - NO2_mean
NO2_ano_dict[year] = NO2_ano
# relative anomaly
NO2_ano_percent = NO2_ano / NO2_mean * 100.0
NO2_ano_percent_dict[year] = NO2_ano_percent
# generate grid
nlat_c, nlon_c = 720, 1440
lat_e, lon_e, lat_c, lon_c = generate_grid(nlat_c, nlon_c)
# get region data
i1 = get_center_index(lat_e, region_limit[0])
i2 = get_center_index(lat_e, region_limit[2])
j1 = get_center_index(lon_e, region_limit[1])
j2 = get_center_index(lon_e, region_limit[3])
lat_e = lat_e[i1:i2 + 2]
lon_e = lon_e[j1:j2 + 2]
# begin plot
nrow = 3
ncol = 4
figsize = (12, 6)
projPos = list(range(nrow * ncol))
layout_dict = multiFigure(nrow,
ncol,
left=left,
right=right,
top=top,
bottom=bottom,
wspace=wspace,
hspace=hspace,
figsize=figsize,
projPos=projPos)
fig = layout_dict['fig']
axes = layout_dict['axes']
ano_ax_ind = [0, 1, 4, 5, 8, 9]
ano_per_ax_ind = [2, 3, 6, 7, 10, 11]
pout1_list = []
pout2_list = []
for iyr in range(len(year_list)):
year = year_list[iyr]
# anomaly
NO2_ano = NO2_ano_dict[year][i1:i2 + 1, j1:j2 + 1]
pout1 = cartopy_plot(lon_e, lat_e, NO2_ano, ax=axes[ano_ax_ind[iyr]], \
vmin=vmin_ano, vmax=vmax_ano, cbar=False, \
title=year+month, cmap=plt.get_cmap('seismic'))
pout1_list.append(pout1)
# relative anomaly
NO2_ano_percent = NO2_ano_percent_dict[year][i1:i2 + 1, j1:j2 + 1]
pout2 = cartopy_plot(lon_e, lat_e, NO2_ano_percent, \
ax=axes[ano_per_ax_ind[iyr]], cbar=False, \
vmin=vmin_ano_per, vmax=vmax_ano_per, \
title=year+month, cmap=plt.get_cmap('seismic'))
pout2_list.append(pout2)
states_provinces = cfeature.NaturalEarthFeature(
category='cultural',
name='admin_1_states_provinces_lines',
scale='50m',
facecolor='none')
# ticks
panel_tick_label(axes, ncol, xticks=xticks, yticks=yticks)
# set limit
for ax in axes:
ax.set_xlim([lon_e[0], lon_e[-1]])
ax.set_ylim([lat_e[0], lat_e[-1]])
ax.add_feature(cfeature.BORDERS)
ax.add_feature(states_provinces, edgecolor='k', linewidth=0.5)
ax.add_feature(cfeature.COASTLINE, zorder=200)
ax.add_feature(cfeature.OCEAN, color='w', zorder=100)
# anomaly colorbar
cax1 = h_2_ax(fig, pout1_list[4]['ax'], pout1_list[5]['ax'], y_off=y_off)
cb1 = plt.colorbar(pout1_list[4]['mesh'], cax=cax1, \
orientation='horizontal', extend='both')
cb1.set_label('OMI NO2 anomaly [DU]')
# relative anomaly colorbar
cax2 = h_2_ax(fig, pout2_list[4]['ax'], pout2_list[5]['ax'], y_off=y_off)
cb2 = plt.colorbar(pout2_list[4]['mesh'], cax=cax2, \
orientation='horizontal', extend='both')
cb2.set_label('OMI NO2 relative anomaly [%]')
# save figure
if dir_fig is not None:
figname = dir_fig + name + 'NO2_anomaly_6yrs_' + month \
+ '_from_' + start_year + '-' + end_year + '.png'
plt.savefig(figname, format='png', dpi=300)