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)