def geometry_plot(self,Npoints = 256): x = np.linspace(-self.a, self.a) y = np.linspace(-self.b, self.b) X,Y = np.meshgrid(x,y) n_plot = np.zeros(np.shape(X)) k_plot = np.zeros(np.shape(X)) for i,xx in enumerate(x): for j,yy in enumerate(y): n_plot[i,j] = ref([xx,yy])*10000000 k_plot[i,j] = extinction([xx,yy])*10000000 cmap1, norm1 = from_levels_and_colors([1,ref([r_core,0])*10000000,ref([r_clad,0])*10000000], ['blue', 'green','red'],extend='max') cmap2, norm2 = from_levels_and_colors([0,extinction([r_core,0])*10000000,extinction([r_clad,0])*10000000], ['blue', 'green','red'],extend='max') fig = plt.figure(figsize=(20.0, 20.0)) ax1 = fig.add_subplot(221) ax1.pcolormesh(X,Y,n_plot, cmap=cmap1, norm=norm1) ax1.set_title('real part profile') ax1.axis('equal') ax2 = fig.add_subplot(222) ax2.pcolormesh(X,Y,k_plot, cmap=cmap2, norm=norm2) ax2.set_title('Imaginary part profile') ax2.axis('equal') return n_plot,k_plot
def testplot(cats, catsavg, xy, data, levels=[0, 1, 2, 3, 4, 5, 10, 15, 20, 25, 30, 40, 50, 100], title=""): """Quick test plot layout for this example file """ colors = plt.cm.spectral(np.linspace(0, 1, len(levels))) mycmap, mynorm = from_levels_and_colors(levels, colors, extend="max") radolevels = [0, 1, 2, 3, 4, 5, 10, 15, 20, 25, 30, 40, 50, 100] radocolors = plt.cm.spectral(np.linspace(0, 1, len(radolevels))) radocmap, radonorm = from_levels_and_colors(radolevels, radocolors, extend="max") fig = plt.figure(figsize=(14, 8)) # Average rainfall sum ax = fig.add_subplot(121, aspect="equal") coll = PatchCollection(cats, array=catsavg, cmap=mycmap, norm=mynorm, edgecolors='white', lw=0.5) ax.add_collection(coll) ax.autoscale() plt.colorbar(coll, ax=ax, shrink=0.5) plt.xlabel("GK2 Easting") plt.ylabel("GK2 Northing") plt.title(title) plt.draw() # Original radar data ax1 = fig.add_subplot(122, aspect="equal") pm = plt.pcolormesh(xy[:, :, 0], xy[:, :, 1], np.ma.masked_invalid(data), cmap=radocmap, norm=radonorm) coll = PatchCollection(cats, facecolor='None', edgecolor='white', lw=0.5) ax1.add_collection(coll) cb = plt.colorbar(pm, ax=ax1, shrink=0.5) cb.set_label("(mm/h)") plt.xlabel("GK2 Easting") plt.ylabel("GK2 Northing") plt.title("Original radar rain sums") plt.draw() plt.tight_layout()
def test_cmap_and_norm_from_levels_and_colors2(): levels = [-1, 2, 2.5, 3] colors = ['red', (0, 1, 0), 'blue', (0.5, 0.5, 0.5), (0.0, 0.0, 0.0, 1.0)] clr = mcolors.to_rgba_array(colors) bad = (0.1, 0.1, 0.1, 0.1) no_color = (0.0, 0.0, 0.0, 0.0) masked_value = 'masked_value' # Define the test values which are of interest. # Note: levels are lev[i] <= v < lev[i+1] tests = [('both', None, {-2: clr[0], -1: clr[1], 2: clr[2], 2.25: clr[2], 3: clr[4], 3.5: clr[4], masked_value: bad}), ('min', -1, {-2: clr[0], -1: clr[1], 2: clr[2], 2.25: clr[2], 3: no_color, 3.5: no_color, masked_value: bad}), ('max', -1, {-2: no_color, -1: clr[0], 2: clr[1], 2.25: clr[1], 3: clr[3], 3.5: clr[3], masked_value: bad}), ('neither', -2, {-2: no_color, -1: clr[0], 2: clr[1], 2.25: clr[1], 3: no_color, 3.5: no_color, masked_value: bad}), ] for extend, i1, cases in tests: cmap, norm = mcolors.from_levels_and_colors(levels, colors[0:i1], extend=extend) cmap.set_bad(bad) for d_val, expected_color in cases.items(): if d_val == masked_value: d_val = np.ma.array([1], mask=True) else: d_val = [d_val] assert_array_equal(expected_color, cmap(norm(d_val))[0], 'Wih extend={0!r} and data ' 'value={1!r}'.format(extend, d_val)) with pytest.raises(ValueError): mcolors.from_levels_and_colors(levels, colors)
def smart_colormap(clevs, name='jet', extend='both', minval=0.0, maxval=1.0): ''' Automatically grabs the colors to extend the colorbar from the colormap. ''' # Define number of colors if extend == 'both': nrColors = len(clevs)+1 elif (extend == 'min') | (extend == 'max'): nrColors = len(clevs) elif (extend == 'neither'): nrColors = len(clevs)-1 else: nrColors = len(clevs)-1 extend = 'neither' # Get colormap cmap = get_cmap(name, nrColors) # Truncate colormap if asked if (minval != 0.0) or (maxval != 1.0): cmap = truncate_colormap(cmap, minval=minval, maxval=maxval, n=nrColors/2) # Get the list of colors colors = [] for i in range(0, nrColors): colors.append(cmap(i/(nrColors-1))) # Use utility function to get cmap and norm at the same time cmap, norm = from_levels_and_colors(clevs, colors, extend=extend) return(cmap, norm)
def make_plot(a, b, z, title, maxterms): approx, terms = optimal_terms.asymptotic_series(a, b, z, maxterms) ref = np.float64(mpmath.hyp1f1(a, b, z)) cd = correct_digits(approx, ref) termsize = np.abs(terms/terms[0]) fig, ax1 = plt.subplots() ax1.plot(cd, '-', linewidth=2, color=GREEN) ax1.set_ylim(0, 17) ax1.set_xlabel('term number') # Make the y-axis label and tick labels match the line color. ax1.set_ylabel('correct digits', color=GREEN) for tl in ax1.get_yticklabels(): tl.set_color(GREEN) ax2 = ax1.twinx() cmap, norm = colors.from_levels_and_colors([-np.inf, 0, np.inf], [BLUE, RED]) ax2.scatter(np.arange(termsize.shape[0]), termsize, c=terms, cmap=cmap, norm=norm, edgecolors='') # ax2.semilogy(termsize, 'r--', linewidth=2) ax2.set_yscale('log') ax2.set_ylabel('relative term size', color=RED) # Set the limits, with a little margin. ax2.set_xlim(0, termsize.shape[0]) ax2.set_ylim(np.min(termsize), np.max(termsize)) for tl in ax2.get_yticklabels(): tl.set_color(RED) ax1.set_title("a = {:.2e}, b = {:.2e}, z = {:.2e}".format(a, b, z)) plt.savefig("{}.png".format(title))
def animate(self, steps=10, start_fire_power=0): fig = plt.figure() colors = ['#990000', '#CC0000', '#FF0000', '#FF8000', '#FFFF00', '#AFCB96', '#66FF66', '#33FF33', '#00FF00', '#00CC00', '#009900'] scale = [-1000, -80, -60, -40, -20, -0.1, 0.1, 50, 100, 200, 400, 1000] cmap, norm = mcolors.from_levels_and_colors(scale, colors) df = self.prepare_data_to_draw() images = [[plt.pcolor(df, cmap=cmap, norm=norm)]] self.start_fire(start_fire_power) df = self.prepare_data_to_draw() images.append([plt.pcolor(df, cmap=cmap, norm=norm)]) drzewa = [sum([x.wood for x in sum(self.forest.forest, [])])] ogien = [sum([x.fire for x in sum(self.forest.forest, [])])] for i in range(steps): print i self.next_step() self.burn() drzewa.append(sum([x.wood for x in sum(self.forest.forest, [])])) ogien.append(sum([x.fire for x in sum(self.forest.forest, [])])) df = self.prepare_data_to_draw() images.append([plt.pcolor(df, cmap=cmap, norm=norm,)]) ani = animation.ArtistAnimation(fig, images, interval=500, repeat_delay=0, repeat=True) plt.show() plt.plot(range(0, steps + 1), drzewa) plt.show() plt.plot(range(0, steps + 1), ogien) plt.show()
def view(self, original, segmented, reduced): r""" This method is implemented for test purposes, it takes as arguments an untreated slice, a segmented slice and a reduced and segmented slice showing its differences on screen using a matplotlib figure view(original, segmented, reduced) """ f = pyplot.figure() levels = [0, 1, 2] colores = ['red', 'white', 'blue', 'red'] cmap, norm = colors.from_levels_and_colors(levels, colores, extend='both') # org = self.sample_mask(original) #Mask irelevant data f.add_subplot(1, 3, 1) # Original image pyplot.imshow(original, cmap='binary', interpolation='nearest') pyplot.colorbar() f.add_subplot(1, 3, 2) # Segmented image by K-means pyplot.imshow(segmented, interpolation='nearest', cmap=cmap, norm=norm) pyplot.colorbar() f.add_subplot(1, 3, 3) # Reduced image pyplot.imshow(reduced, interpolation='nearest', origin='lower', cmap = cmap, norm = norm) pyplot.colorbar() pyplot.show()
def heatmap(data_, num_levels_=20, mode=None, xlabel='', ylabel='', xlabels=None, ylabels=None, rotation=90, changeTicks=True): '''generates a nice heatmap''' if mode == 'special': vmin, vmax = data_.min(), data_.max() midpoint = data_.mean() else: vmin, vmax = -1.0001, 1.0001 midpoint = 0.0 levels = np.linspace(vmin, vmax, num_levels_) midp = np.mean(np.c_[levels[:-1], levels[1:]], axis=1) vals = np.interp(midp, [vmin, midpoint, vmax], [0, 0.5, 1]) colors = plt.cm.seismic(vals) cmap, norm = from_levels_and_colors(levels, colors) fig, ax = plt.subplots() im = ax.imshow(data_, cmap=cmap, norm=norm, interpolation='none') fig.colorbar(im) ax.xaxis.tick_top() ax.set_xlabel(xlabel) ax.set_ylabel(ylabel) ax.xaxis.set_label_position('top') if xlabels is not None: ax.set_xticklabels(xlabels, minor=False) if ylabels is not None: ax.set_yticklabels(ylabels, minor=False) if changeTicks: plt.xticks(np.arange(len(data_)), rotation=rotation, fontsize=10) plt.yticks(np.arange(len(data_)), fontsize=10) plt.show()
def create_wind_color_map(levels): # replicate XWS colours for wind speed # cmap = ["#ffffff", "#fff4e8", "#ffe1c1", "#ffaa4e", "#ff6d00", "#d33100", "#890000"] #, "#650000", "#390000"] ccmap, norm = col.from_levels_and_colors(levels, cmap, 'neither') return ccmap, norm
def generer_image_transp(self): """Fonction graphique. Elle est identique à la fonction précédente mais permet de générer une image transparente sauf pour les individus qui possèdent une couleur par tribu. Les deux images sont ensuite superposée pour donner l'illusion que la simulation se déroule sur la carte du dessous. Arguments: verbose (bool): Active ou désactive la sortie console. Retour: Modifie img_transp par référence interne. """ nombre_tribus = len(self.liste_tribus) levels = list(range(0, 6)) + self.liste_tribus_int colors_void = [(0., 0., 0., 0.) for i in range(0, 6)] jet = plt.get_cmap('gist_rainbow') colors_tribu = [jet(x/(max(self.liste_tribus_int) - 10)) for x in range(0, nombre_tribus)] colors = colors_void + colors_tribu self.colormap_indiv, self.norm = from_levels_and_colors(levels, colors, extend='max') self.img_transp = self.matrice_tribus.astype(str).astype(int)
def test_cmap_and_norm_from_levels_and_colors2(): levels = [-1, 2, 2.5, 3] colors = ["red", (0, 1, 0), "blue", (0.5, 0.5, 0.5), (0.0, 0.0, 0.0, 1.0)] clr = mcolors.colorConverter.to_rgba_array(colors) bad = (0.1, 0.1, 0.1, 0.1) no_color = (0.0, 0.0, 0.0, 0.0) masked_value = "masked_value" # Define the test values which are of interest. # Note: levels are lev[i] <= v < lev[i+1] tests = [ ("both", None, {-2: clr[0], -1: clr[1], 2: clr[2], 2.25: clr[2], 3: clr[4], 3.5: clr[4], masked_value: bad}), ("min", -1, {-2: clr[0], -1: clr[1], 2: clr[2], 2.25: clr[2], 3: no_color, 3.5: no_color, masked_value: bad}), ("max", -1, {-2: no_color, -1: clr[0], 2: clr[1], 2.25: clr[1], 3: clr[3], 3.5: clr[3], masked_value: bad}), ( "neither", -2, {-2: no_color, -1: clr[0], 2: clr[1], 2.25: clr[1], 3: no_color, 3.5: no_color, masked_value: bad}, ), ] for extend, i1, cases in tests: cmap, norm = mcolors.from_levels_and_colors(levels, colors[0:i1], extend=extend) cmap.set_bad(bad) for d_val, expected_color in cases.items(): if d_val == masked_value: d_val = np.ma.array([1], mask=True) else: d_val = [d_val] assert_array_equal( expected_color, cmap(norm(d_val))[0], "Wih extend={0!r} and data " "value={1!r}".format(extend, d_val) ) assert_raises(ValueError, mcolors.from_levels_and_colors, levels, colors)
def plotheat(data_, num_levels_=20, mode=None, xlabel='', ylabel='', xlabels=None, ylabels=None, rotation=90, changeTicks=True, annotation=None, vmin=None, vmax=None, showplot=True, removebar=False): '''generates a nice heatmap''' if mode == 'special': if vmin is None or vmax is None: vmin, vmax = data_.min() - 0.0001, data_.max() + 0.0001 midpoint = data_.mean() else: midpoint = data_.mean() else: vmin, vmax = -1.0001, 1.0001 midpoint = 0.0 levels = np.linspace(vmin, vmax, num_levels_) midp = np.mean(np.c_[levels[:-1], levels[1:]], axis=1) vals = np.interp(midp, [vmin, midpoint, vmax], [0, 0.5, 1]) colors = plt.cm.seismic(vals) # == 6 option is photocopy friendly, == 7 is almost photocopy friendly if num_levels_ == 6: colors = [[215, 25, 28, 255], [253, 174, 97, 255], [255, 255, 191, 255], [171, 221, 164, 255], [43, 131, 186, 255]] colors = [[x / 255.0 for x in c] for c in colors] if num_levels_ == 7: colors = [[213, 62, 79, 255], [252, 141, 89, 255], [254, 224, 139, 255], [230, 245, 152, 255], [153, 213, 148, 255], [50, 136, 189, 255]] colors = [[x / 255.0 for x in c] for c in colors] # print(colors) cmap, norm = from_levels_and_colors(levels, colors) fig, ax = plt.subplots() im = ax.imshow(data_, cmap=cmap, norm=norm, interpolation='none') if not removebar: fig.colorbar(im) ax.xaxis.tick_top() ax.set_xlabel(xlabel) ax.set_ylabel(ylabel) ax.xaxis.set_label_position('top') if xlabels is not None: ax.set_xticklabels(xlabels, minor=False) if ylabels is not None: ax.set_yticklabels(ylabels, minor=False) if changeTicks: plt.xticks(np.arange(len(data_)), rotation=rotation, fontsize=14) plt.yticks(np.arange(len(data_)), fontsize=14) if annotation is not None: for t in annotation: if len(t[1]) == 1: x = -50 else: x = -35 ax.annotate(t[1], xy=(0, t[0]), xytext=(x, t[0]), arrowprops=dict(facecolor='black', shrink=0.05), annotation_clip=False ) if showplot: plt.show()
def create_color_map(): # this is the color scale from Neu et al 2013 (BAMS) levels = numpy.array([0,0.0001,0.001,0.01,0.1,1.0,2.0,3.0,4.0,5.0,6.0], 'f') cmap = ["#ffffff", "#f8e73d", "#e9a833", "#009a4a", "#00aeca", "#0088b7", "#295393", "#2e3065", "#973683", "#ff0000", "#999999"] ccmap, norm = col.from_levels_and_colors(levels, cmap, 'max') return ccmap, norm, levels
def testplot(cats, catsavg, xy, data, levels = np.arange(0,320,20), title=""): """Quick test plot layout for this example file """ colors = plt.cm.spectral(np.linspace(0,1,len(levels)) ) mycmap, mynorm = from_levels_and_colors(levels, colors, extend="max") radolevels = levels.copy()#[0,1,2,3,4,5,10,15,20,25,30,40,50,100] radocolors = plt.cm.spectral(np.linspace(0,1,len(radolevels)) ) radocmap, radonorm = from_levels_and_colors(radolevels, radocolors, extend="max") fig = plt.figure(figsize=(12,12)) # Average rainfall sum ax = fig.add_subplot(111, aspect="equal") wradlib.vis.add_lines(ax, cats, color='black', lw=0.5) catsavg[np.isnan(catsavg)]=-9999 coll = PolyCollection(cats, array=catsavg, cmap=mycmap, norm=mynorm, edgecolors='none') ax.add_collection(coll) ax.autoscale() cb = plt.colorbar(coll, ax=ax, shrink=0.75) plt.xlabel("UTM 51N Easting") plt.ylabel("UTM 51N Northing") # plt.title("Subcatchment rainfall depth") plt.grid() plt.draw() plt.savefig(r"E:\docs\_projektantraege\SUSTAIN_EU_ASIA\workshop\maik\pampanga_cat.png") # plt.close() # Original RADOLAN data fig = plt.figure(figsize=(12,12)) # Average rainfall sum ax1 = fig.add_subplot(111, aspect="equal") pm = plt.pcolormesh(xy[:, :, 0], xy[:, :, 1], np.ma.masked_invalid(data), cmap=radocmap, norm=radonorm) wradlib.vis.add_lines(ax1, cats, color='black', lw=0.5) plt.xlim(ax.get_xlim()) plt.ylim(ax.get_ylim()) cb = plt.colorbar(pm, ax=ax1, shrink=0.75) cb.set_label("(mm/h)") plt.xlabel("UTM 51N Easting") plt.ylabel("UTM 51N Northing") # plt.title("Composite rainfall depths") plt.grid() plt.draw() plt.savefig(r"E:\docs\_projektantraege\SUSTAIN_EU_ASIA\workshop\maik\pampanga_comp.png") plt.close()
def setup_colormap_with_zeroval(vmin, vmax, nlevs=5, cmap=plt.get_cmap('Greens'), extend='both'): """create a discrete colormap with reserved level for small values setup a colormap based on a existing colormap with a specified number N of levels reserving the lowest colormap level for extremely small values. Extremely small are currently defined as [0.0, 1e-8]. Returns the N-level colormap and a normalizer to plot arbitrary data using the colormap. The normalizing places the N levels at constant intervals between the vmin and vmax. ARGS: vmin (float): value to map to the lowest color level vmax (float): value to map to the highest color level nlevs (integer): number of levels for the colormap (default is 5) cmap (:class:`matplotlib.colors.Colormap` instance): colormap to use for the N-level colormap extend (string): ({'both'} | 'min' | 'max' | 'neither') should the top or bottom of the colormap use an arrow to indicate "and larger" or "and smaller" RETURNS: tuple (cmap, norm) containing a :class:`matplotlib.colors.Colormap` object and a :class:`matplotlib.colors.Normalize object`. EXAMPLE: >>> import matplotlib.pyplot as plt >>> import numpy as np >>> from timutils.colormap_nlevs import setup_colormap_with_zeroval >>> data = np.random.rand(100, 100) >>> mycmap, mynorm = setup_colormap_with_zeroval(vmin=data.min(), vmax=data.max(), nlevs=7, extend='neither') >>> fig, ax = plt.subplots() >>> cm = ax.pcolormesh(data, cmap=mycmap, norm=mynorm) >>> plt.colorbar(cm) >>> plt.title(('setup_colormap_with_zeroval example\\n data values 0 to 1; nlevs=5')) >>> plt.show() """ # Pick some of the nicer colors from the palette... if extend is "neither": ncolors = nlevs elif (extend is "min") or (extend is "max"): ncolors = nlevs + 1 elif extend is "both": ncolors = nlevs + 2 levels = np.concatenate((np.array([0.0, 1e-8]), np.linspace(start=vmin, stop=vmax, num=nlevs)[1:])) colors = cmap(np.linspace(start=0.0, stop=1.0, num=ncolors)) cmap, norm = from_levels_and_colors(levels, colors, extend=extend) return((cmap, norm))
def main(): bathymetry_path = "" topo_path = "/RECH2/huziy/coupling/coupled-GL-NEMO1h_30min/geophys_452x260_directions_new_452x260_GL+NENA_0.1deg_SAND_CLAY_LDPT_DPTH.fst" plot_utils.apply_plot_params() with RPN(topo_path) as r: assert isinstance(r, RPN) topo = r.get_first_record_for_name("ME") lons, lats = r.get_longitudes_and_latitudes_for_the_last_read_rec() print(lons.shape) prj_params = r.get_proj_parameters_for_the_last_read_rec() rll = RotatedLatLon(**prj_params) bmap = rll.get_basemap_object_for_lons_lats(lons2d=lons, lats2d=lats, resolution="i") xx, yy = bmap(lons, lats) plt.figure() ax = plt.gca() lons1 = np.where(lons <= 180, lons, lons - 360) topo = maskoceans(lons1, lats, topo) topo_clevs = [0, 100, 200, 300, 400, 500, 600, 800, 1000, 1200] # bn = BoundaryNorm(topo_clevs, len(topo_clevs) - 1) cmap = cm.get_cmap("terrain") ocean_color = cmap(0.18) cmap, norm = colors.from_levels_and_colors(topo_clevs, cmap(np.linspace(0.3, 1, len(topo_clevs) - 1))) add_rectangle(ax, xx, yy, margin=20, edge_style="solid") add_rectangle(ax, xx, yy, margin=10, edge_style="dashed") im = bmap.pcolormesh(xx, yy, topo, cmap=cmap, norm=norm) bmap.colorbar(im, ticks=topo_clevs) bmap.drawcoastlines(linewidth=0.3) bmap.drawmapboundary(fill_color=ocean_color) bmap.drawparallels(np.arange(-90, 90, 10), labels=[1, 0, 0, 1], color="0.3") bmap.drawmeridians(np.arange(-180, 190, 10), labels=[1, 0, 0, 1], color="0.3") plt.savefig("GL_452x260_0.1deg_domain.png", dpi=300, bbox_inches="tight")
def get_colormap_norm(cmap_type, levels): """Create a custom colormap.""" if cmap_type == "rain": cmap, norm = from_levels_and_colors(levels, sns.color_palette("Blues", n_colors=len(levels)), extend='max') elif cmap_type == "snow": cmap, norm = from_levels_and_colors(levels, sns.color_palette("PuRd", n_colors=len(levels)), extend='max') elif cmap_type == "snow_discrete": colors = ["#DBF069","#5AE463","#E3BE45","#65F8CA","#32B8EB", "#1D64DE","#E97BE4","#F4F476","#E78340","#D73782","#702072"] cmap, norm = from_levels_and_colors(levels, colors, extend='max') elif cmap_type == "rain_acc": cmap, norm = from_levels_and_colors(levels, sns.color_palette('gist_stern_r', n_colors=len(levels)), extend='max') elif cmap_type == "rain_new": colors_tuple = pd.read_csv('/home/mpim/m300382/icon_forecasts/cmap_prec.rgba').values cmap, norm = from_levels_and_colors(levels, sns.color_palette(colors_tuple, n_colors=len(levels)), extend='max') return(cmap, norm)
def test_cmap_and_norm_from_levels_and_colors(): data = np.linspace(-2, 4, 49).reshape(7, 7) levels = [-1, 2, 2.5, 3] colors = ['red', 'green', 'blue', 'yellow', 'black'] extend = 'both' cmap, norm = mcolors.from_levels_and_colors(levels, colors, extend=extend) ax = plt.axes() m = plt.pcolormesh(data, cmap=cmap, norm=norm) plt.colorbar(m) # Hide the axes labels (but not the colorbar ones, as they are useful) ax.tick_params(labelleft=False, labelbottom=False)
def test_cmap_and_norm_from_levels_and_colors(): data = np.linspace(-2, 4, 49).reshape(7, 7) levels = [-1, 2, 2.5, 3] colors = ['red', 'green', 'blue', 'yellow', 'black'] extend = 'both' cmap, norm = mcolors.from_levels_and_colors(levels, colors, extend=extend) ax = plt.axes() m = plt.pcolormesh(data, cmap=cmap, norm=norm) plt.colorbar(m) # Hide the axes labels (but not the colorbar ones, as they are useful) for lab in ax.get_xticklabels() + ax.get_yticklabels(): lab.set_visible(False)
def colorbar(nvalues,nticks=None,cmap='gnuplot', start=0.1, stop=0.8,strmap = '%.3f', shrink=1, aspect=20): ncolors = len(nvalues) if nticks==None: nticks = ncolors colors = mpltools.color.colors_from_cmap(ncolors, cmap=cmap, start=start, stop=stop) cmap, norm = mcolors.from_levels_and_colors(range(ncolors + 1), colors) mappable = matplotlib.cm.ScalarMappable(cmap=cmap) mappable.set_array([]) mappable.set_clim(-0.5, ncolors+0.5) colorbar = plt.colorbar(mappable,shrink=shrink,aspect=aspect) tickpos = np.linspace(0, ncolors,nticks) tickvalues = np.linspace(min(nvalues), max(nvalues), nticks) tickvalues = [strmap%f for f in tickvalues] colorbar.set_ticks(tickpos) colorbar.set_ticklabels(tickvalues) return colorbar
def setup_colormap(vmin, vmax, nlevs=5, cmap=plt.get_cmap('Greens'), extend='both'): """ create a discrete colormap from a continuous colormap Returns the N-level colormap and a normalizer to plot arbitrary data using the colormap. The normalizing places the N levels at constant intervals between the vmin and vmax. ARGS: vmin (float): value to map to the lowest color level vmax (float): value to map to the highest color level nlevs (integer): number of levels for the colormap (default is 5) cmap (:class:`matplotlib.colors.Colormap` instance): colormap to use for the N-level colormap extend (string): ({'both'} | 'min' | 'max' | 'neither'}) should the top or bottom of the colormap use an arrow to indicate "and larger" or "and smaller" RETURNS: tuple (cmap, norm) containing a :class:`matplotlib.colors.Colormap` object and a :class:`matplotlib.colors.Normalize` object. EXAMPLES: >>> import matplotlib.pyplot as plt >>> import numpy as np >>> from timutils.colormap_nlevs import setup_colormap >>> data = np.random.rand(100, 100) * 1000 >>> mycmap, mynorm = setup_colormap(vmin=200.0, vmax=800.0, extend='max') >>> fig, ax = plt.subplots() >>> cm = ax.pcolormesh(data, cmap=mycmap, norm=mynorm) >>> plt.colorbar(cm) >>> plt.title(('setup_colormap example\\n data values 0 to 1000; nlevs=5, vmin=200, vmax=800')) >>> plt.show() """ print('setting up colormaps') # Pick some of the nicer colors from the palette... if extend is "neither": ncolors = nlevs - 1 elif (extend is "min") or (extend is "max"): ncolors = nlevs elif extend is "both": ncolors = nlevs + 1 levels = np.linspace(start=vmin, stop=vmax, num=nlevs) colors = cmap(np.linspace(start=0.0, stop=1.0, num=ncolors)) cmap, norm = from_levels_and_colors(levels, colors, extend=extend) return((cmap, norm))
def make_colors(levels, coloring, cmap): """ Generate colormaps and norms based on user-defined level sets. Parameters: ----------- levels : iterable of floats List of level demarcations. coloring : str Either 'continuous' or 'discrete'; 'discrete' colorings have a set number of color elements, whereas 'continuous' ones span value in between the elements of `levels`. cmap : str The color palette / map name to use Returns: -------- cmap A colormap that matplotlib can use to set plot colors norm The normalization controlling how the data is colored based on the user-defined levels. """ ncolors = len(levels) + 1 assert coloring in ['continuous', 'discrete'] ## reverse the colorbar if its cubehelix and a negative scale if ("cubehelix" in cmap) and (levels[0] < 0): if "_r" in cmap: cmap = cmap.replace("_r", "") else: cmap = cmap+"_r" if coloring == 'continuous': norm = MidpointNorm(vmin=levels[0], vmax=levels[-1], midpoint=levels[len(levels)/2]) elif coloring == 'discrete': cmap = get_cmap(cmap) colors = [cmap(1.*i/ncolors) for i in range(ncolors)] cmap, norm = from_levels_and_colors(levels, colors, extend='both') else: raise ValueError("Received unknown coloring option (%r)" % coloring) return cmap, norm
def animate(grid, arm, route): fig, axs = plt.subplots(1, 2) fig.canvas.mpl_connect('key_press_event', press) colors = ['white', 'black', 'red', 'pink', 'yellow', 'green', 'orange'] levels = [0, 1, 2, 3, 4, 5, 6, 7] cmap, norm = from_levels_and_colors(levels, colors) for i, node in enumerate(route): plt.subplot(1, 2, 1) grid[node] = 6 plt.cla() plt.imshow(grid, cmap=cmap, norm=norm, interpolation=None) theta1 = 2 * pi * node[0] / M - pi theta2 = 2 * pi * node[1] / M - pi arm.update_joints([theta1, theta2]) plt.subplot(1, 2, 2) arm.plot_arm(plt, obstacles=obstacles) plt.xlim(-2.0, 2.0) plt.ylim(-3.0, 3.0) plt.show() # Uncomment here to save the sequence of frames # plt.savefig('frame{:04d}.png'.format(i)) plt.pause(0.1)
def astar_torus(grid, start_node, goal_node): """ Finds a path between an initial and goal joint configuration using the A* Algorithm on a tororiadal grid. Args: grid: An occupancy grid (ndarray) start_node: Initial joint configuation (tuple) goal_node: Goal joint configuration (tuple) Returns: Obstacle-free route in joint space from start_node to goal_node """ colors = ['white', 'black', 'red', 'pink', 'yellow', 'green', 'orange'] levels = [0, 1, 2, 3, 4, 5, 6, 7] cmap, norm = from_levels_and_colors(levels, colors) grid[start_node] = 4 grid[goal_node] = 5 parent_map = [[() for _ in range(M)] for _ in range(M)] heuristic_map = calc_heuristic_map(M, goal_node) explored_heuristic_map = np.full((M, M), np.inf) distance_map = np.full((M, M), np.inf) explored_heuristic_map[start_node] = heuristic_map[start_node] distance_map[start_node] = 0 while True: grid[start_node] = 4 grid[goal_node] = 5 current_node = np.unravel_index( np.argmin(explored_heuristic_map, axis=None), explored_heuristic_map.shape) min_distance = np.min(explored_heuristic_map) if (current_node == goal_node) or np.isinf(min_distance): break grid[current_node] = 2 explored_heuristic_map[current_node] = np.inf i, j = current_node[0], current_node[1] neighbors = find_neighbors(i, j) for neighbor in neighbors: if grid[neighbor] == 0 or grid[neighbor] == 5: distance_map[neighbor] = distance_map[current_node] + 1 explored_heuristic_map[neighbor] = heuristic_map[neighbor] parent_map[neighbor[0]][neighbor[1]] = current_node grid[neighbor] = 3 if np.isinf(explored_heuristic_map[goal_node]): route = [] print("No route found.") else: route = [goal_node] while parent_map[route[0][0]][route[0][1]] != (): route.insert(0, parent_map[route[0][0]][route[0][1]]) print("The route found covers %d grid cells." % len(route)) for i in range(1, len(route)): grid[route[i]] = 6 plt.cla() plt.imshow(grid, cmap=cmap, norm=norm, interpolation=None) plt.show() plt.pause(1e-2) return route
m =\ Basemap(llcrnrlon=lon_low_plot,llcrnrlat=lat_low_plot,urcrnrlon=lon_high_plot,urcrnrlat=lat_high_plot,projection='mill', rsphere=6371229) x, y = m(lons, lats) fig = plt.figure(figsize=(8, 8)) ax = fig.add_axes([0.05, 0.05, 0.9, 0.85]) clevs = np.linspace(min_contour, max_contour, 256) midpoint = 0 midp = np.mean(np.c_[clevs[:-1], clevs[1:]], axis=1) vals = np.interp(midp, [min_contour, midpoint, max_contour], [0, 0.5, 1]) cols = plt.cm.RdBu_r(vals) clevs_extend = np.linspace(min_contour, max_contour, 254) cmap, norm = from_levels_and_colors(clevs_extend, cols, extend='both') # draw coastlines, state and country boundaries, edge of map. m.drawcoastlines(linewidth=0.5, color='#262626') #m.drawstates() m.drawcountries(linewidth=0.5, color='#262626') # draw parallels. parallels = np.arange(0., 90, divisor) m.drawparallels(parallels, labels=[1, 0, 0, 0], fontsize=10, color='#262626') # draw meridians meridians = np.arange(0., 360., divisor) m.drawmeridians(meridians, labels=[0, 0, 0, 1], fontsize=10, color='#262626') cs_col = m.contourf(x, y, total_mean, clevs, cmap=cmap, extend='both') cbar = m.colorbar(cs_col, location='bottom', pad="5%") #cbar.ax.tick_params(labelsize=12, colors='#262626')
yi = np.linspace(data_y.min(), data_y.max(), numrows) xi, yi = np.meshgrid(xi, yi) #-- Interpolating at the points in xi, yi x, y, z = data_x, data_y, data_z zi = griddata(x, y, z, xi, yi) fig = plt.figure() bands_time = [0, 5, 10, 15, 20, 25, 30, 40, 50, 60, 75 , 90, 105, 120 , 150, 1000] bands_cost = [0, 0.5, 1, 1.5, 2.0, 2.5, 3.0, 4.0, 5.0, 6.0, 7.5, 9.0, 10.5, 12.0, 15.0, 100.0] bands_gen_cost = [0, 1.5, 3, 4.5, 6.0, 7.5, 9.0, 12.0, 15.0, 18.0, 22.5, 27.0, 31.5, 36.0, 45.0, 100.0] # my_rgbs =['#800026', '#800026', '#bd0026', '#e31a1c', '#fc4e2a', '#fd8d3c', '#feb24c', '#fed976', '#ffeda0', '#ffffcc', '#d0d1e6', '#a6bddb', '#74a9cf', '#3690c0', '#0570b0', '#034e7b'] ################################## # generate PT time contour map ### ################################## cmap_time, norm_time = from_levels_and_colors(bands_time, my_rgbs, extend='min') m = plt.contourf(xi, yi, zi, latlon=True, levels= bands_time, cmap = cmap_time, norm=norm_time) # set the path to generate PT time map mapfile = file_path + '/map/PT_time.html' # convert to leaflet map save(fig = fig, path=mapfile, template = 'base_time.html', tiles='mapbox bright') # fig.colorbar(m) # plt.show() ################################## # generate PT cost contour map ### ################################## data_z = np.loadtxt(file_path+'/data/PT cost.txt') x, y, z = data_x, data_y, data_z zi = griddata(x, y, z, xi, yi) fig = plt.figure() cmap_cost, norm_cost = from_levels_and_colors(bands_cost, my_rgbs, extend='min')
def track_height_image( self, field, track_key=None, plot_height_km=False, plot_track_km=False, mask_procedure=None, mask_tuple=None, plot_log10_var=False, cminmax=(0.0, 60.0), clevs=25, vmin=None, vmax=None, cmap="gist_ncar", discrete_cmap_levels=None, track_min=None, track_max=None, height_min=None, height_max=None, start_time=None, end_time=None, zero_track_start=False, track_MajTicks=None, track_MinTicks=None, height_MajTicks=None, height_MinTicks=None, fill_surface=False, fill_min=None, fill_color=None, color_bar=True, cb_orient="vertical", cb_pad=0.05, cb_tick_int=2, cb_label=None, cb_fontsize=None, cb_ticklabel_size=None, title=None, xlab=" ", xlabFontSize=16, xpad=7, ylab=" ", ylabFontSize=16, ypad=7, ax=None, fig=None, ): """ Wrapper function to produce a contoured plot along a track of variable indicated. Parameters ---------- field : array Variable to plot as time series. track_key : str Key name of track distance variable. mask_procedure : str String indicating how to apply mask via numpy, possibilities are: 'less', 'less_equal', 'greater', 'greater_equal', 'equal', 'inside', 'outside'. mask_tuple : (str, float[, float]) Tuple containing the field name and value(s) below which to mask field prior to plotting. plot_log10_var : boolean True plots the log base 10 of Data field. cminmax : tuple (min, max) values for controur levels. clevs : int Number of contour levels. vmin : float Minimum contour value to display. vmax : float Maximum contour value to display. cmap : str Matplotlib color map to use. discrete_cmap_levels : array A list of levels to be used for display. If chosen discrete color will be used in the colorbar instead of a linear luminance mapping. height_min : float Minimum value for height axis. height_max : float Maximum value for height axis. start_time : str UTC time to use as start time for subsetting in datetime format. (e.g. 2014-08-20 12:30:00) end_time : str UTC time to use as an end time for subsetting in datetime format. (e.g. 2014-08-20 16:30:00) zero_track_start : bool If True the first element in the track will be forced to zero. Of interest if using start_time keyword. Defaults to False. track_MajTicks : float Values for major tickmark spacing on track axis. track_MinTicks : float Values for minor tickmark spacing on track axis. height_MajTicks : float Values for major tickmark spacing on height axis. height_MinTicks : float Values for minor tickmark spacing on height axis. track_min : float Minimum value for track distance axis. track_max : float Maximum value for track distance axis. title : str Plot title. xlab : str X-axis label. ylab : str Y-axis label. xpad : int Padding for X-axis label. ypad : int Padding for Y-axis label. color_bar : boolean True adds colorbar, False does not. cb_pad : str Pad to move colorbar, in the form "5%", pos is to right for righthand location. cb_orient : str Colorbar orientation, either 'vertical' or 'horizontal'. cb_tick_int : int Interval to use for colorbar tick labels, higher number "thins" labels. cb_label : str Label for colorbar (e.g. units 'dBZ'). cb_fontsize : int Font size of the colorbar label. cb_ticklabel_size : int Font size of colorbar tick labels. ax : Matplotlib axes instance Optional axes instance to plot the graph. fig : Matplotlib figure instance Figure which to add the plot. None will use the current figure. """ # parse parameters ax, fig = common._parse_ax_fig(ax, fig) # Return masked or unmasked variable # Subsetted if desired Var, tsub, Data = self._get_variable_dict_data_time_subset(field, start_time, end_time) if mask_procedure is not None: Data = common.get_masked_data(Data, mask_procedure, mask_tuple) if track_key is None: try: track = self.radar["track_distance_air"] except: ValueError("Did not find suitable track distance variable") else: track = self.radar[track_key] trackd = self._get_variable_subset(track["data"][:], start_time, end_time) if plot_track_km: if track["units"] != "km": trackd = trackd / 1000.0 if zero_track_start: trackd = trackd - trackd[0] if plot_log10_var: Data = np.log10(Data) if cb_label is not None: cb_label = r"log$_{10}$[" + cb_label + "]" # Print out min and max values to screen print("Minimum value of %s = %g" % (field, np.ma.min(Data))) print("Maximum value of %s = %g" % (field, np.ma.max(Data))) # Get vmin/vmax if not given if vmin is None: vmin = np.ma.min(Data) if vmax is None: vmax = np.ma.max(Data) # Create contour level array clevels = np.linspace(cminmax[0], cminmax[1], clevs) if len(self.height["data"].shape) == 2: track2D, junk = np.meshgrid(trackd, self.height["data"][0, :]) Ht2D = Height.T del junk else: track2D, Ht2D = np.meshgrid(trackd, self.height["data"][:]) if plot_height_km: Ht2D = Ht2D / 1000.0 # Get the colormap and calculate data spaced by number of levels norm = None if discrete_cmap_levels is not None: cm = plt.get_cmap(cmap) try: levpos = np.rint(np.squeeze([np.linspace(0, 255, len(discrete_cmap_levels))])).astype(int) # Convert levels to colormap values cmap, norm = from_levels_and_colors(discrete_cmap_levels, cm(levpos), extend="max") except: print("Keyword error: 'discrete_cmap_levels' must " "be a list of float or integer") # Plot the time series ts = common.image_2d( track2D, Ht2D, Data.T, vmin=vmin, vmax=vmax, clevs=clevs, cmap=cmap, norm=norm, x_min=track_min, x_max=track_max, y_min=height_min, y_max=height_max, x_minor_ticks=track_MinTicks, x_major_ticks=track_MajTicks, y_minor_ticks=height_MinTicks, y_major_ticks=height_MajTicks, title=title, xlab=xlab, xlabFontSize=xlabFontSize, xpad=xpad, ylab=ylab, ylabFontSize=ylabFontSize, ypad=ypad, color_bar=color_bar, cb_orient=cb_orient, cb_pad=cb_pad, cb_tick_int=cb_tick_int, cb_label=cb_label, cb_fontsize=cb_fontsize, cb_ticklabel_size=cb_ticklabel_size, ax=ax, fig=fig, ) if fill_surface: if self.surface is not None: sfc = self._get_variable_subset(self.surface["data"][:], start_time, end_time) ft = common.plot_fill_surface(trackd, sfc, ymin=fill_min, color=fill_color, ax=ax) else: print("No surface height information, cannot fill...") return
def plot_cross_section( self, field, start_pt, end_pt, xs_length=500, mask_procedure=None, mask_tuple=None, plot_km=False, title=" ", title_size=20, cminmax=(0.0, 60.0), clevs=25, vmin=15.0, vmax=60.0, cmap="gist_ncar", discrete_cmap_levels=None, color_bar=True, clabel="dBZ", cb_pad=None, cb_orient=None, cb_fontsize=None, cb_ticklabel_size=None, cb_tick_int=None, ax=None, fig=None, ): """ Plot a cross-section between two points. Parameters ---------- field : str 3-D variable (e.g. Reflectivity [dBZ]) to use in plot. start_pt, end_pt : tuple (lat, lon) Tuple of start, end points for cross-section. xs_length : int Number of to use for the cross section. mask_procedure : str String indicating how to apply mask via numpy, possibilities are: 'less', 'less_equal', 'greater', 'greater_equal', 'equal', 'inside', 'outside'. mask_tuple : (str, float[, float]) Tuple containing the field name and value(s) below which to mask field prior to plotting, for example to mask all data where. plot_km : boolean True to convert meters to kilometers for cappi_height. False retains meters information. title : str Plot title. title_size : int Font size of title to display. cminmax : tuple (min,max) values for controur levels. clevs : int Number of contour levels. vmin : float Minimum contour value to display. vmax : float Maximum contour value to display. cmap : str Matplotlib color map to use. discrete_cmap_levels : array A list of levels to be used for display. If chosen discrete color will be used in the colorbar instead of a linear luminance mapping. color_bar : bool True to add colorbar, False does not. clabel : str Label for colorbar (e.g. units 'dBZ'). cb_fontsize : int Font size of the colorbar label. cb_ticklabel_size : int Font size of colorbar tick labels. cb_pad : str Pad to move colorbar, in the form "5%", pos is to right for righthand location. cb_orient : str Colorbar orientation, either 'vertical' or 'horizontal'. cb_tick_int : int Interval to use for colorbar tick labels, higher number "thins" labels. ax : Matplotlib axis instance Axis to plot. None will use the current axis. fig : Matplotlib figure instance Figure on which to add the plot. None will use the current figure. """ # parse parameters ax, fig = common._parse_ax_fig(ax, fig) # Return masked or unmasked variable Var, Data = common._get_variable_dict_data(self.fields, field) if mask_procedure is not None: Data = common.get_masked_data(Data, mask_procedure, mask_tuple) # Create contour level array clevels = np.linspace(cminmax[0], cminmax[1], clevs) # Create lon and lat arrays for display xslon = np.linspace(start_pt[0], end_pt[0], xs_length) xslat = np.linspace(start_pt[1], end_pt[1], xs_length) # Create an array to hold the interpolated cross-section xs_data = np.empty([xs_length, len(self.height["data"][:])]) # Create arrays for cross-section lon-lat points startloclon = self._get_lon_index(start_pt[0]) startloclat = self._get_lat_index(start_pt[1]) endloclon = self._get_lon_index(end_pt[0]) endloclat = self._get_lat_index(end_pt[1]) xsY = np.linspace(startloclat, endloclat, xs_length) xsX = np.linspace(startloclon, endloclon, xs_length) # Loop through each level to create cross-section and stack them for nlev in range(len(self.height["data"][:])): # Extract the values along the line, using cubic interpolation xs_data[:, nlev] = scim.map_coordinates(Data[nlev, :, :], np.vstack((xsY, xsX)), prefilter=False) # , mode='nearest') # Calculate the distance array along the cross-section Xdist = np.absolute((np.pi * common.EARTH_RADIUS / 180.0) * (xslon - xslon[0])) Ydist = np.absolute((np.pi * common.EARTH_RADIUS / 180.0) * (xslat - xslat[0])) xsDist = np.sqrt(Xdist ** 2 + Ydist ** 2) # Define the angle of the cross-secton Dlon = start_pt[1] - end_pt[1] Dlat = start_pt[0] - end_pt[0] Ang = np.arctan2(Dlat, Dlon) if Ang < 0: AngNref = 2 * np.pi + Ang else: AngNref = Ang # Convert Height, distance arrays to 2D if plot_km: Ht2D, Dist2D = np.meshgrid(self.height["data"][:] / 1000.0, xsDist) ylabel = "Altitude (km)" else: Ht2D, Dist2D = np.meshgrid(self.height["data"][:], xsDist) ylabel = "Altitude (m)" # Get the colormap and calculate data spaced by number of levels norm = None if discrete_cmap_levels is not None: cm = plt.get_cmap(cmap) try: levpos = np.rint(np.squeeze([np.linspace(0, 255, len(discrete_cmap_levels))])).astype(int) # Convert levels to colormap values cmap, norm = from_levels_and_colors(discrete_cmap_levels, cm(levpos), extend="max") except: print("Keyword error: 'discrete_cmap_levels' must " "be a list of float or integer") p = ax.pcolormesh( Dist2D, Ht2D, np.ma.masked_less_equal(xs_data, -800.0), vmin=vmin, vmax=vmax, norm=norm, cmap=cmap ) ax.set_xlabel("Distance along track (km)") ax.set_ylabel(ylabel) # Add title ax.set_title(title, fontsize=title_size) # Add Colorbar if color_bar: cbStr = Var["long_name"] + " " + self.height["units"] cb = common.add_colorbar( ax, p, orientation=cb_orient, pad=cb_pad, label=cbStr, fontsize=cb_fontsize, ticklabel_size=cb_ticklabel_size, clevs=clevs, tick_interval=cb_tick_int, ) # Add title ax.set_title(title, fontsize=title_size)
def plot_unitigs(genome, reads, read_len=30, filename="unitigs.txt"): mmers = {} mmer = "" line_no = 0 char_no = 0 unitigs = [] with open(filename, "r") as fin: lines = fin.read().splitlines() while (line_no < len(lines)): # if line is clear mmer and skip line if not lines[line_no]: mmer = "" line_no += 1 continue # if mmer is blank read new mmer if not mmer: mmer = lines[line_no] if mmer not in mmers: mmers[mmer] = 0 line_no += 1 # if read mmer read kmer and read ids else: kmer = lines[line_no] mmers[mmer] += 1 line_no += 1 char_no = 0 unitig = {} while (char_no < len(kmer)): read_ids = list( map(int, lines[line_no].rstrip().split(" "))) for read_id in read_ids: if read_id not in unitig: unitig[read_id] = "" for key in unitig.keys(): if key in read_ids: unitig[key] = unitig[key] + kmer[char_no] else: unitig[key] = unitig[key] + " " line_no += 1 char_no += 1 # split across reads ids to find portions of genome that contribute to unitigs.append(unitig) # generate graph for mmers mpl.rcParams['xtick.labelsize'] = 8 plt.bar(range(len(mmers)), list(mmers.values()), align='center') plt.xticks( range(len(mmers)), list(mmers.keys()), rotation='vertical', ) # reduce font size plt.savefig("mmers.png") # generate graphs for unitigs matrix = np.zeros((len(unitigs), len(genome)), dtype=int) for i, unitig in enumerate(unitigs): for key, val in unitig.items(): for part in val.split(" "): start = reads[key] index = start + genome[start:start + read_len].find(part) if not index: index = start + rev_comp( genome[start:start + read_len]).find(part) for j in range(index, index + len(part)): matrix[i][j] = 1 # define the colors cmap, norm = from_levels_and_colors([0, 0.5, 1], ['r', 'k']) # create a normalize object the describes the limits of # each color bounds = [0., 0.5, 1.] norm = mpl.colors.BoundaryNorm(bounds, cmap.N) plt.figure(figsize=(20, 10)) plt.imshow(matrix, interpolation='nearest', cmap=cmap, norm=norm) plt.savefig("kmers.png") plt.close()
def astar_torus(grid, start_node, goal_node): """ Finds a path between an initial and goal joint configuration using the A* Algorithm on a tororiadal grid. Args: grid: An occupancy grid (ndarray) start_node: Initial joint configuation (tuple) goal_node: Goal joint configuration (tuple) Returns: Obstacle-free route in joint space from start_node to goal_node """ colors = ['white', 'black', 'red', 'pink', 'yellow', 'green', 'orange'] levels = [0, 1, 2, 3, 4, 5, 6, 7] cmap, norm = from_levels_and_colors(levels, colors) grid[start_node] = 4 grid[goal_node] = 5 parent_map = [[() for _ in range(M)] for _ in range(M)] X, Y = np.meshgrid([i for i in range(M)], [i for i in range(M)]) heuristic_map = np.abs(X - goal_node[1]) + np.abs(Y - goal_node[0]) for i in range(heuristic_map.shape[0]): for j in range(heuristic_map.shape[1]): heuristic_map[i, j] = min(heuristic_map[i, j], i + 1 + heuristic_map[M - 1, j], M - i + heuristic_map[0, j], j + 1 + heuristic_map[i, M - 1], M - j + heuristic_map[i, 0] ) explored_heuristic_map = np.full((M, M), np.inf) distance_map = np.full((M, M), np.inf) explored_heuristic_map[start_node] = heuristic_map[start_node] distance_map[start_node] = 0 while True: grid[start_node] = 4 grid[goal_node] = 5 current_node = np.unravel_index( np.argmin(explored_heuristic_map, axis=None), explored_heuristic_map.shape) min_distance = np.min(explored_heuristic_map) if (current_node == goal_node) or np.isinf(min_distance): break grid[current_node] = 2 explored_heuristic_map[current_node] = np.inf i, j = current_node[0], current_node[1] neighbors = [] if i - 1 >= 0: neighbors.append((i - 1, j)) else: neighbors.append((M - 1, j)) if i + 1 < M: neighbors.append((i + 1, j)) else: neighbors.append((0, j)) if j - 1 >= 0: neighbors.append((i, j - 1)) else: neighbors.append((i, M - 1)) if j + 1 < M: neighbors.append((i, j + 1)) else: neighbors.append((i, 0)) for neighbor in neighbors: if grid[neighbor] == 0 or grid[neighbor] == 5: distance_map[neighbor] = distance_map[current_node] + 1 explored_heuristic_map[neighbor] = heuristic_map[neighbor] parent_map[neighbor[0]][neighbor[1]] = current_node grid[neighbor] = 3 ''' plt.cla() plt.imshow(grid, cmap=cmap, norm=norm, interpolation=None) plt.show() plt.pause(1e-5) ''' if np.isinf(explored_heuristic_map[goal_node]): route = [] print("No route found.") else: route = [goal_node] while parent_map[route[0][0]][route[0][1]] is not (): route.insert(0, parent_map[route[0][0]][route[0][1]]) print("The route found covers %d grid cells." % len(route)) for i in range(1, len(route)): grid[route[i]] = 6 plt.cla() plt.imshow(grid, cmap=cmap, norm=norm, interpolation=None) plt.show() plt.pause(1e-2) return route
fourth, = plt.plot(xs_2, ys_2) # plot all points plt.setp(fourth, linestyle='', marker='.', color=color4) fifth, = plt.plot(xs_2, ys_2) # plot all points plt.setp(fifth, linestyle='', marker='.', color=color5) sixth, = plt.plot(xs_2, ys_2) # plot all points plt.setp(sixth, linestyle='', marker='.', color=color6) # VERSION 2 fig, ax = plt.subplots(figsize=(5, 5)) nearness1 = np.where(np.array(zs_1) < 26, 0, 1) cmap, norm = clr.from_levels_and_colors(levels=[0, 1], colors=['#ccccff', '#e5e5ff'], extend='max') ax.scatter(xs_1, ys_1, c=nearness1, s=150, marker='.', edgecolor='none', cmap=cmap, norm=norm) nearness2 = np.where(np.array(zs_2) < 29, 0, 1) cmap, norm = clr.from_levels_and_colors(levels=[0, 1], colors=['#9999ff', '#b2b2ff'], extend='max') ax.scatter(xs_2,
x[z[:, 1]] = xs[1][z[:, 1]] x[z[:, 2]] = xs[2][z[:, 2]] z_ind = np.zeros(n, dtype=int) z_ind[z[:, 1]] = 1 z_ind[z[:, 2]] = 2 np.savetxt('./intermediate_data/sim_data.csv', np.column_stack((x, z_ind)), header='x1, x2, z', delimiter=',', comments='') # Plot data cmap, norm = colors.from_levels_and_colors(levels=[0, 1, 2], colors=['magenta', 'cyan', 'green'], extend='max') fig = plt.figure() ax = fig.add_subplot(1, 1, 1) ax.scatter(x[:, 0], x[:, 1], c=z_ind, cmap=cmap, norm=norm) fig.savefig('./sim_data.pdf') # Estimate init_mu = np.array([[0., 0.], [1., 1.], [2., 2.]]) init_sigma = [np.identity(2) for i in range(3)] init_mix = np.array([1., 1., 1.]) / 3 res_em, (logliks_em, times_em) = em_alg(x, init_mu, init_sigma,
def disc_cube_plot( cube, bin_edges, fig=None, ax=None, cax=None, cmap="inferno_r", aux0=None, aux1=None, extend="neither", aux0_label="", aux1_label="", aux0_c=plotting_configuration.aux0_c, aux1_c=plotting_configuration.aux1_c, cbar=True, cbar_label="", cbar_orientation="vertical", cbar_fraction=0.02, cbar_pad=0.07, cbar_aspect=24, cbar_shrink=0.6, cbar_extendfrac=0.07, cbar_anchor=(0.5, 1.0), cbar_panchor=(0.5, 0.0), cbar_format=get_sci_format(ndigits=1), loc=(0.7, 0.2), height=0.04, aspect=2, spacing=0.04 * 0.2, cmap_midpoint=None, cmap_symmetric=False, ): """Plotting of cube using given bin edges.""" if not isinstance(cube, iris.cube.Cube): raise ValueError("cube is not an iris Cube.") if len(cube.shape) != 2: raise ValueError("cube is not 2-dimensional.") if cmap_symmetric and cmap_midpoint is None: raise ValueError("If cmap_symmetric is True, cmap_midpoint has to be given.") if cmap_midpoint is not None and np.sum(np.isclose(bin_edges, cmap_midpoint)) != 1: raise ValueError("cmap_midpoint has to match one of the given bin edges.") gridlons = cube.coord("longitude").contiguous_bounds() gridlats = cube.coord("latitude").contiguous_bounds() data = cube.data if not isinstance(data, np.ma.MaskedArray): raise ValueError("Data should be a MaskedArray.") projection = ccrs.Robinson() if fig is None and ax is None: fig = plt.figure() elif fig is None: fig = ax.get_figure() if ax is None: ax = plt.axes(projection=projection) cmap_slice = slice(None) try: orig_cmap = plt.get_cmap(cmap) except ValueError: if isinstance(cmap, str) and "_r" in cmap: # Try to reverse the colormap manually, in case a reversed colormap was # requested using the '_r' suffix, but this is not available. cmap = cmap.rstrip("_r") orig_cmap = plt.get_cmap(cmap) # Flip limits to achieve reversal effect. cmap_slice = slice(None, None, -1) cmap_sample_lims = [0, 1] if extend == "neither": add_colors = -1 assert np.min(data) >= bin_edges[0] assert np.max(data) <= bin_edges[-1] elif extend in ("min", "max"): add_colors = 0 if extend == "min": assert np.max(data) <= bin_edges[-1] else: assert np.min(data) >= bin_edges[0] elif extend == "both": add_colors = 1 n_colors = len(bin_edges) + add_colors if cmap_midpoint is None: colors = orig_cmap(np.linspace(*cmap_sample_lims[cmap_slice], n_colors)) else: if cmap_symmetric: # Adjust the colormap sample limits such that the deviation from # 0.5 is proportional to the magnitude of the maximum deviation # from the midpoint. diffs = np.array( (bin_edges[0] - cmap_midpoint, bin_edges[-1] - cmap_midpoint) ) max_diff = max(np.abs(diffs)) scaled = diffs / max_diff cmap_sample_lims = 0.5 + scaled * 0.5 # Find closest bin edge. closest_bound_index = np.argmin( np.abs(np.asarray(bin_edges[cmap_slice]) - cmap_midpoint) ) lower_range = 0.5 - cmap_sample_lims[0] n_lower = closest_bound_index + (1 if extend in ("min", "both") else 0) upper_range = cmap_sample_lims[1] - 0.5 n_upper = ( len(bin_edges) - 1 - closest_bound_index + (1 if extend in ("max", "both") else 0) ) colors = np.vstack( ( orig_cmap( cmap_sample_lims[0] + np.arange(n_lower) * (2 * lower_range / (1 + 2 * n_lower)) ), orig_cmap( cmap_sample_lims[1] - np.arange(n_upper - 1, -1, -1) * (2 * upper_range / (1 + 2 * n_upper)) ), ) )[cmap_slice] cmap, norm = from_levels_and_colors( levels=list(bin_edges), colors=colors, # 'neither', 'min', 'max', 'both' extend=extend, ) mesh = ax.pcolormesh( gridlons, gridlats, data, cmap=cmap, norm=norm, rasterized=True, transform=ccrs.PlateCarree(), ) if cbar: colorbar = fig.colorbar( mesh, label=cbar_label, orientation=cbar_orientation, fraction=cbar_fraction, pad=cbar_pad, aspect=cbar_aspect, shrink=cbar_shrink, extendfrac=cbar_extendfrac, anchor=cbar_anchor, panchor=cbar_panchor, format=cbar_format, cax=cax, ax=ax, ) else: colorbar = None if aux0 is not None or aux1 is not None: if aux0 is not None and aux1 is not None: # Ensure they do not overlap. assert not np.any(aux0 & aux1) # Draw data including these auxiliary points. data = data.copy() min_data = np.min(data) if aux0 is not None: data[aux0 & data.mask] = min_data - 2 if aux1 is not None: data[aux1 & data.mask] = min_data - 1 colors = np.vstack((np.array([aux0_c, aux1_c]), colors)) cmap, norm = from_levels_and_colors( levels=[ min_data - 2.5, min_data - 1.5, *((min_data - 0.5,) if extend in ("min", "both") else ()), ] + list(bin_edges), colors=colors, extend="max" if extend in ("max", "both") else "neither", ) mesh = ax.pcolormesh( gridlons, gridlats, data, cmap=cmap, norm=norm, rasterized=True, transform=ccrs.PlateCarree(), ) # Do not re-draw colorbar including the aux0 and aux1 colours. # Instead, add rectangles to indicate the meaning of the auxiliary levels. width = height * aspect label_kwargs = dict( x=loc[0] + width + spacing, transform=fig.transFigure, verticalalignment="center", ) rect_kwargs = dict( width=width, height=height, fill=True, alpha=1, zorder=1000, transform=fig.transFigure, figure=fig, ) if aux0 is not None and aux0_label: fig.patches.extend( [ plt.Rectangle( loc, color=aux0_c, **rect_kwargs, ), ] ) ax.text(y=loc[1] + height / 2, s=aux0_label, **label_kwargs) if aux1 is not None and aux1_label: fig.patches.extend( [ plt.Rectangle( (loc[0], loc[1] - height - spacing), color=aux1_c, **rect_kwargs ), ] ) ax.text(y=loc[1] - height / 2 - spacing, s=aux1_label, **label_kwargs) ax.gridlines(zorder=0, alpha=0.4, linestyle="--", linewidth=0.3) ax.coastlines(resolution="110m", linewidth=0.5) return fig, ax, colorbar
plt.grid() plt.ylim([-2.5, 2.5]) plt.title('Aire de la CIF - Sections SI, BB & FC', weight='bold', fontsize=14) ax2.tick_params(axis='x', rotation=0) fig_name = 'section_CIL_anomaly_FR.png' fig.set_size_inches(w=15, h=7) fig.savefig(fig_name, dpi=200) os.system('convert -trim ' + fig_name + ' ' + fig_name) ## ---- CIL area for ms_climate index ---- ## # Build the colormap from matplotlib.colors import from_levels_and_colors YlGn = plt.cm.YlGn(np.linspace(0, 1, num=12)) YlGn = YlGn[1:, ] cmap, norm = from_levels_and_colors(np.arange(0, 10), YlGn, extend='both') std_vol_std = pd.concat( [std_anom_SI.vol_itp, std_anom_BB.vol_itp, std_anom_FC.vol_itp], axis=1) / 3 std_vol_std.columns = ['SI', 'BB', 'FC'] n = 5 # xtick every n years #ax = std_vol_std.plot(kind='bar', stacked=True, cmap='tab10') ax = std_vol_std.plot(kind='bar', stacked=True, cmap=cmap) ticks = ax.xaxis.get_ticklocs() ticklabels = [l.get_text() for l in ax.xaxis.get_ticklabels()] ax.xaxis.set_ticks(ticks[::n]) ax.xaxis.set_ticklabels(ticklabels[::n]) plt.fill_between([ticks[0], ticks[-1]], [-.5, -.5], [.5, .5], facecolor='gray', alpha=.2)
m = wrf.get_basemap(tmp) ; x, y = m(wrf.to_np(lons), wrf.to_np(lats)) Z=maskoceans(lons,lats,wrf.to_np(vis)[ii,:,:],inlands=False)#, resolution='c', grid=2.5) #Z=wrf.to_np(vis)[ii,:,:] #nice_cmap=plt.get_cmap('RdYlGn_r') ; clevs=[0,1,2,3,4,5,6,7,8,9,10] #['white 0 ','lime 1','limegreen 2','greenyellow 3','yellow 4','gold 5','orange 6','indianred 7', #'firebrick 8', 'darkred 9','lightskyblue 10','deepskyblue 11','royalblue 12 ','blue 13'] mymap = mcolors.ListedColormap(['white','ghostwhite','floralwhite','greenyellow','yellow','gold','orange','indianred','firebrick', \ 'darkred','lightskyblue','deepskyblue','royalblue','blue']) nice_cmap= plt.get_cmap(mymap) #colors = nice_cmap([0,1, 2, 3, 4, 5,6,7,8,9,10,11,12,13]) colors = nice_cmap([13,11,12,9,8,7,6,4,3,2,0,1]) cmap, norm = mcolors.from_levels_and_colors(clevs, colors, extend='both') norml = mcolors.BoundaryNorm(clevs, ncolors=cmap.N, clip=True) #m.contour(x, y, wrf.to_np(vis)[ii,:,:], 10, colors="black") cs=m.contourf(x, y,Z , levels=clevs,cmap=cmap,norm=norml,extended='both') m.readshapefile('/home/vkvalappil/Data/shapeFiles/uae/ARE_adm1','uae',drawbounds=True, zorder=None, linewidth=1.0, color='k', antialiased=1, ax=None, default_encoding='utf-8') #m.drawlsmask(land_color='0.8',ocean_color='w',lsmask=True) #m.drawlsmask(land_color=(0, 0, 0, 0), ocean_color='deeppink', lakes=True) m.drawcoastlines(linewidth=0.25,ax=ax) ; m.drawcountries(linewidth=0.25,ax=ax) ; m.drawstates(linewidth=0.25,ax=ax) parallels = np.arange(np.amin(lats), np.amax(lats), 2.5) ; m.drawparallels(parallels, ax=ax, color="k", labels=[1,0,0,0]) merids = np.arange(np.amin(lons), np.amax(lons), 2.5) ; m.drawmeridians(merids, ax=ax, color="k", labels=[0,0,0,1]) #m.drawmapboundary(fill_color='white') ; #plt.colorbar(shrink=.62) location='right', pad='5%')
taxon_gene_dict[taxon] = [gene_names,gene_values] # 0 = no test # 1 = tested, P > P* # 2 = tested, P < P* cols = {0:'lightgrey',1:'orangered',2:'deepskyblue'} # ,-1:'black' cvr = colors.ColorConverter() tmp = sorted(cols.keys()) cols_rgb = [cvr.to_rgb(cols[k]) for k in tmp] intervals = np.asarray(tmp + [tmp[-1]+1]) - 0.5 cmap, norm = colors.from_levels_and_colors(intervals,cols_rgb) legend_elements = [Patch(color='lightgrey', label=r'$n_{mut} < 3$'), Patch(color='orangered', label=r'$P\nless P^{*}$'), Patch(color='deepskyblue', label=r'$P < P^{*}$')] # Patch(color='black', label="No data") for taxon in taxa: if taxon in pt.treatment_taxa_to_ignore: continue if taxon == 'J': continue
def choropleth(geodf, figsize=12, column=None, scheme='fisher_jenks', n_colors=5, palette='viridis', alpha=0.75, cbar_orientation='vertical'): bounds = geodf.total_bounds bbox = (bounds[1], bounds[0], bounds[3], bounds[2]) smopy_map = SmopyMap(bbox, z=12, margin=0) fig_shape = smopy_map.to_numpy().shape aspect = fig_shape[0] / fig_shape[1] fig = plt.figure(figsize=(figsize, figsize / aspect)) plt.imshow(smopy_map.img) ax = plt.gca() plt.axis('off') choro = [] patch_values = [] if scheme != 'categorical': for idx, row in geodf.iterrows(): feature = row.geometry value = row[column] if feature.geom_type == 'Polygon': choro.append(feature_to_patch(feature, smopy_map)) patch_values.append(value) elif feature.geom_type == 'MultiPolygon': for subfeature in feature: choro.append(feature_to_patch(subfeature, smopy_map)) patch_values.append(value) else: continue binning = gpd.plotting.__pysal_choro(geodf[column], scheme='fisher_jenks', k=n_colors) bins = np.insert(binning.bins, 0, geodf[column].min()) palette_values = sns.color_palette(palette, n_colors=n_colors) cmap, norm = from_levels_and_colors(bins, palette_values, extend='neither') cmap.set_over(palette_values[-1], alpha=alpha) collection = PatchCollection(choro, alpha=alpha, cmap=cmap, norm=norm) collection.set_array(np.array(patch_values)) if cbar_orientation is not None: plt.colorbar(collection, shrink=0.5, orientation='vertical', label=column, fraction=0.05, pad=0.01) else: category_values = sorted(geodf[column].unique()) n_colors = len(category_values) palette = sns.color_palette(palette, n_colors=n_colors) color_dict = dict(zip(category_values, palette)) for idx, row in geodf.iterrows(): feature = row.geometry value = row[column] if feature.geom_type == 'Polygon': choro.append(feature_to_patch(feature, smopy_map)) patch_values.append(color_dict[value]) elif feature.geom_type == 'MultiPolygon': for subfeature in feature: choro.append(feature_to_patch(subfeature, smopy_map)) patch_values.append(color_dict[value]) else: continue collection = PatchCollection(choro, alpha=alpha, color=patch_values) bbox_to_anchor = None #(0.99, 0.75) legend_parts = [ Patch(color=color, label=label) for label, color in zip(category_values, palette) ] plt.legend(legend_parts, [p.get_label() for p in legend_parts], bbox_to_anchor=bbox_to_anchor) ax.add_collection(collection) plt.tight_layout() return ax
def main(): experiment_ids = [ 'djzny', 'djznq', 'djzns', 'djznw', 'dkjxq', 'dklyu', 'dkmbq', 'dklwu', 'dklzq' ] #experiment_ids = ['djzny' ] for experiment_id in experiment_ids: expmin1 = experiment_id[:-1] pfile1201 = '/nfs/a90/eepdw/Data/EMBRACE/Mean_State/pp_files/%s/%s/%s.pp' % ( expmin1, experiment_id, pp_file1201) pfile2201 = '/nfs/a90/eepdw/Data/EMBRACE/Mean_State/pp_files/%s/%s/%s.pp' % ( expmin1, experiment_id, pp_file2201) pfile3217 = '/nfs/a90/eepdw/Data/EMBRACE/Mean_State/pp_files/%s/%s/%s.pp' % ( expmin1, experiment_id, pp_file3217) pfile3234 = '/nfs/a90/eepdw/Data/EMBRACE/Mean_State/pp_files/%s/%s/%s.pp' % ( expmin1, experiment_id, pp_file3234) #pc = iris(pfile) pcube1201 = iris.load_cube(pfile1201) pcube2201 = iris.load_cube(pfile2201) pcube3217 = iris.load_cube(pfile3217) pcube3234 = iris.load_cube(pfile3234) pcubetotal = pcube1201 + pcube2201 - pcube3217 - pcube3234 print pcubetotal #print pc # Get min and max latitude/longitude and unrotate to get min/max corners to crop plot automatically - otherwise end with blank bits on the edges lats = pcubetotal.coord('grid_latitude').points lons = pcubetotal.coord('grid_longitude').points cs = pcubetotal.coord_system('CoordSystem') if isinstance(cs, iris.coord_systems.RotatedGeogCS): print 'Rotated CS %s' % cs lon_low = np.min(lons) lon_high = np.max(lons) lat_low = np.min(lats) lat_high = np.max(lats) lon_corners, lat_corners = np.meshgrid((lon_low, lon_high), (lat_low, lat_high)) lon_corner_u, lat_corner_u = unrotate.unrotate_pole( lon_corners, lat_corners, cs.grid_north_pole_longitude, cs.grid_north_pole_latitude) lon_low = lon_corner_u[0, 0] lon_high = lon_corner_u[0, 1] lat_low = lat_corner_u[0, 0] lat_high = lat_corner_u[1, 0] else: lon_low = np.min(lons) lon_high = np.max(lons) lat_low = np.min(lats) lat_high = np.max(lats) lon_low_tick = lon_low - (lon_low % divisor) lon_high_tick = math.ceil(lon_high / divisor) * divisor lat_low_tick = lat_low - (lat_low % divisor) lat_high_tick = math.ceil(lat_high / divisor) * divisor print lat_high_tick print lat_low_tick plt.figure(figsize=(8, 8)) cmap = plt.cm.RdBu_r ax = plt.axes(projection=ccrs.PlateCarree(), extent=(lon_low, lon_high, lat_low + degs_crop_bottom, lat_high - degs_crop_top)) clevs = np.linspace(min_contour, max_contour, 256) midpoint = 0 midp = np.mean(np.c_[clevs[:-1], clevs[1:]], axis=1) vals = np.interp(midp, [min_contour, midpoint, max_contour], [0, 0.5, 1]) cols = plt.cm.RdBu_r(vals) clevs_extend = np.linspace(min_contour, max_contour, 254) cmap, norm = from_levels_and_colors(clevs_extend, cols, extend='both') cont = iplt.contourf(pcubetotal, clevs, cmap=cmap, extend='both', norm=norm) #cont = iplt.contourf(pcubetotal, cmap=cmap, extend='both') #plt.clabel(cont, fmt='%d') #ax.stock_img() ax.coastlines(resolution='110m', color='#262626') gl = ax.gridlines(draw_labels=True, linewidth=0.5, color='#262626', alpha=0.5, linestyle='--') gl.xlabels_top = False gl.ylabels_right = False #gl.xlines = False gl.xlocator = mticker.FixedLocator( range(int(lon_low_tick), int(lon_high_tick) + divisor, divisor)) gl.ylocator = mticker.FixedLocator( range(int(lat_low_tick), int(lat_high_tick) + divisor, divisor)) gl.xformatter = LONGITUDE_FORMATTER gl.yformatter = LATITUDE_FORMATTER gl.xlabel_style = {'size': 12, 'color': '#262626'} #gl.xlabel_style = {'color': '#262626', 'weight': 'bold'} gl.ylabel_style = {'size': 12, 'color': '#262626'} cbar = plt.colorbar(cont, orientation='horizontal', pad=0.05, extend='both', format='$%d$') cbar.set_label('$W m^{-2}$') #cbar.set_label(pcubetotal.units, fontsize=10) cbar.set_ticks( np.arange(min_contour, max_contour + tick_interval, tick_interval)) ticks = (np.arange(min_contour, max_contour + tick_interval, tick_interval)) cbar.set_ticklabels(['${%d}$' % i for i in ticks]) #main_title=pcubetotal.standard_name.title().replace('_',' ') #main_title=('Total #model_info=re.sub('(.{68} )', '\\1\n', str(model_name_convert_title.main(experiment_id)), 0, re.DOTALL) #model_info = re.sub(r'[(\']', ' ', model_info) #model_info = re.sub(r'[\',)]', ' ', model_info) #print model_info if not os.path.exists('%s%s/%s' % (save_path, experiment_id, pp_file)): os.makedirs('%s%s/%s' % (save_path, experiment_id, pp_file)) plt.savefig( '%s%s/%s/%s_%s_notitle.png' % (save_path, experiment_id, pp_file, experiment_id, pp_file), format='png', bbox_inches='tight') #plt.title('\n'.join(wrap('%s\n%s' % (main_title, model_info), 1000,replace_whitespace=False)), fontsize=16) #plt.show() #plt.savefig('%s%s/%s/%s_%s.png' % (save_path, experiment_id, pp_file, experiment_id, pp_file), format='png', bbox_inches='tight') plt.close()
def azmp_map(my_file, my_year, my_season, my_depth, my_variable): pd.set_option('display.max_rows', 500) df = my_file df = df.set_index('timestamp', drop=False) #########remove unwanted sections################## #SSdrop = ('L3', 'YL', 'PS', 'BANQ', 'PL', 'SG', 'SPB', 'BP', 'LCC', 'LCM', 'VB') #for i in SSdrop: # df.drop((df.loc[df['StationID'].str.contains(i, na=False)].index), inplace=True) ############################set data parameters here####################### # my_year='2014' # my_season='spring' # my_depth='bottom' # my_variable='pH' # df = df.loc[my_year] if my_season == 'spring': df = df[(df.index.month >= 3) & (df.index.month <= 6)] elif my_season == 'summer': df = df[~df.Region.str.contains('SS')] df = df.assign(x=df.index.strftime('%m-%d')).query( "'07-01' <= x <= '10-14'").drop('x', 1) elif my_season == 'fall': dfng = df[~df.Region.str.contains('SS')] dfng = dfng.assign(x=dfng.index.strftime('%m-%d')).query( "'10-15' <= x <= '12-31'").drop('x', 1) dfss = df[df.Region.str.contains('SS')] dfss = dfss[(dfss.index.month >= 9) & (dfss.index.month <= 12)] df = pd.concat([dfng, dfss], axis=0) else: print 'All seasons selected' if df[my_variable].isna().values.all(): #if df.size == 0 or print('!!! no data for this season !!!') return df.dropna(subset=[my_variable], axis=0, inplace=True) df = df.reset_index(drop=True) if my_depth == 'surface': df = df.loc[df.groupby('StationID')['depth'].idxmin( )] #group by station then pull "min or max depth" df = df.loc[ df.depth < 20] #take all depths >10m (for bottom) to eliminate lone surface samples, all depths <20m (for surface) to eliminate lone deep sample if my_depth == 'bottom': df = df.loc[df.groupby('StationID')['depth'].idxmax( )] #group by station then pull "min or max depth" df = df.loc[ df.depth > 10] #take all depths >10m (for bottom) to eliminate lone surface samples, all depths <20m (for surface) to eliminate lone deep sample v = vl.variable_parameters(my_variable) num_levels = v[0] vmin = v[1] vmax = v[2] midpoint = v[3] colors = v[4] ticks = v[5] axis_label = v[6] extent = v[7] os.environ[ "CARTOPY_USER_BACKGROUNDS"] = "C:\ProgramData\Anaconda2\Lib\site-packages\cartopy\BG" dataFile = 'C:\Users\gibbo\Documents\data\GRIDONE_1D.nc' lonLims = [-72, -41.5] # latLims = [40.5, 58.4] lat_data = np.array(df.latitude) lon_data = np.array(df.longitude) data = np.array(df[my_variable]) lon_data = lon_data[~np.isnan(data)] lat_data = lat_data[~np.isnan(data)] data = data[~np.isnan(data)] ### Bathymetry print('Load and grid bathymetry') h5_outputfile = 'cc_bathymetry.h5' if os.path.isfile(h5_outputfile): print[h5_outputfile + ' exists! Reading directly'] h5f = h5py.File(h5_outputfile, 'r') lon = h5f['lon'][:] lat = h5f['lat'][:] Z = h5f['Z'][:] h5f.close() print(' -> Done!') else: dataset = netCDF4.Dataset(dataFile) # Extract variables x = dataset.variables['x_range'] y = dataset.variables['y_range'] spacing = dataset.variables['spacing'] # Compute Lat/Lon nx = int((x[-1] - x[0]) / spacing[0]) + 1 # num pts in x-dir ny = int((y[-1] - y[0]) / spacing[1]) + 1 # num pts in y-dir lon = np.linspace(x[0], x[-1], nx) lat = np.linspace(y[0], y[-1], ny) ## interpolate data on regular grid (temperature grid) ## Reshape data zz = dataset.variables['z'] Z = zz[:].reshape(ny, nx) Z = np.flipud(Z) # <------------ important!!! # Reduce data according to Region params idx_lon = np.where((lon >= lonLims[0]) & (lon <= lonLims[1])) idx_lat = np.where((lat >= latLims[0]) & (lat <= latLims[1])) Z = Z[idx_lat[0][0]:idx_lat[0][-1] + 1, idx_lon[0][0]:idx_lon[0][-1] + 1] lon = lon[idx_lon[0]] lat = lat[idx_lat[0]] print(' -> Done!') # Save data for later use if np.size(h5_outputfile): h5f = h5py.File(h5_outputfile, 'w') h5f.create_dataset('lon', data=lon) h5f.create_dataset('lat', data=lat) h5f.create_dataset('Z', data=Z) h5f.close() #############now make map######################################################## fig = plt.figure(figsize=(7, 5)) ax = fig.add_subplot(111, projection=ccrs.Mercator()) ax.set_extent([-72, -41.5, 40.5, 58.4], crs=ccrs.PlateCarree()) ax.add_feature( cpf.NaturalEarthFeature('physical', 'coastline', '10m', edgecolor='k', alpha=0.7, linewidth=0.6, facecolor='black')) #cpf.COLORS['land'])) m = ax.gridlines(linewidth=0.5, color='black', draw_labels=True, alpha=0.5) m.xlabels_top = False m.ylabels_right = False m.xlocator = mticker.FixedLocator([-75, -70, -60, -50, -40]) m.ylocator = mticker.FixedLocator([40, 45, 50, 55, 60, 65]) m.xformatter = LONGITUDE_FORMATTER m.yformatter = LATITUDE_FORMATTER m.ylabel_style = {'size': 7, 'color': 'black', 'weight': 'bold'} m.xlabel_style = {'size': 7, 'color': 'black', 'weight': 'bold'} lightdeep = cmocean.tools.lighten(cmo.deep, 0.5) v = np.linspace(0, 5500, 20) c = plt.contourf(lon, lat, -Z, v, transform=ccrs.PlateCarree(), cmap=lightdeep, extend='max', zorder=1) cc = plt.contour(lon, lat, -Z, [100, 500, 1000, 2000, 3000, 4000, 5000], colors='lightgrey', linewidths=.5, transform=ccrs.PlateCarree(), zorder=10) plt.clabel(cc, inline=True, fontsize=8, fmt='%i') #################to adjust the colorbar################################### levels = np.linspace(vmin, vmax, num_levels) midp = np.mean(np.c_[levels[:-1], levels[1:]], axis=1) vals = np.interp(midp, [vmin, midpoint, vmax], [0, 0.5, 1]) colors = colors(vals) colors = np.concatenate([[colors[0, :]], colors, [colors[-1, :]]], 0) cmap, norm = from_levels_and_colors(levels, colors, extend=extent) #######################plot data onto map###################################### s = ax.scatter(lon_data, lat_data, c=data, s=40, lw=0.3, edgecolor='black', vmin=vmin, vmax=vmax, cmap=cmap, transform=ccrs.Geodetic(), zorder=10) cax = plt.axes([0.83, 0.125, 0.03, 0.756]) #([0.863,0.11,0.03,0.771]) cb = plt.colorbar(s, cax=cax, extend=extent, ticks=ticks) cb.ax.tick_params(labelsize=8) cb.set_label(axis_label, fontsize=12, fontweight='normal') fig.savefig( 'C:\Users\gibbo\Documents\carbonates\AZMP_OA\AZMP_OA data\AZMP_OA plots\AZMP_OA maps\AZMP_OA maps\AZMP_OA_' + my_season + '_' + my_variable + '_' + my_depth + '.png', format='png', dpi=500, bbox_inches='tight') plt.close() print(' -> plot saved!')
def main(): experiment_ids = ['djzny','djznq', 'djzns', 'djznw', 'dkjxq', 'dklyu', 'dkmbq', 'dklwu', 'dklzq' ] #experiment_ids = ['djzny' ] for experiment_id in experiment_ids: expmin1 = experiment_id[:-1] pfile1201 = '/nfs/a90/eepdw/Data/EMBRACE/Mean_State/pp_files/%s/%s/%s.pp' % (expmin1, experiment_id, pp_file1201) pfile2201 = '/nfs/a90/eepdw/Data/EMBRACE/Mean_State/pp_files/%s/%s/%s.pp' % (expmin1, experiment_id, pp_file2201) pfile3217 = '/nfs/a90/eepdw/Data/EMBRACE/Mean_State/pp_files/%s/%s/%s.pp' % (expmin1, experiment_id, pp_file3217) pfile3234 = '/nfs/a90/eepdw/Data/EMBRACE/Mean_State/pp_files/%s/%s/%s.pp' % (expmin1, experiment_id, pp_file3234) #pc = iris(pfile) pcube1201 = iris.load_cube(pfile1201) pcube2201 = iris.load_cube(pfile2201) pcube3217 = iris.load_cube(pfile3217) pcube3234 = iris.load_cube(pfile3234) pcubetotal = pcube1201 + pcube2201 - pcube3217 - pcube3234 print pcubetotal #print pc # Get min and max latitude/longitude and unrotate to get min/max corners to crop plot automatically - otherwise end with blank bits on the edges lats = pcubetotal.coord('grid_latitude').points lons = pcubetotal.coord('grid_longitude').points cs = pcubetotal.coord_system('CoordSystem') if isinstance(cs, iris.coord_systems.RotatedGeogCS): print 'Rotated CS %s' % cs lon_low= np.min(lons) lon_high = np.max(lons) lat_low = np.min(lats) lat_high = np.max(lats) lon_corners, lat_corners = np.meshgrid((lon_low, lon_high), (lat_low, lat_high)) lon_corner_u,lat_corner_u = unrotate.unrotate_pole(lon_corners, lat_corners, cs.grid_north_pole_longitude, cs.grid_north_pole_latitude) lon_low = lon_corner_u[0,0] lon_high = lon_corner_u[0,1] lat_low = lat_corner_u[0,0] lat_high = lat_corner_u[1,0] else: lon_low= np.min(lons) lon_high = np.max(lons) lat_low = np.min(lats) lat_high = np.max(lats) lon_low_tick=lon_low -(lon_low%divisor) lon_high_tick=math.ceil(lon_high/divisor)*divisor lat_low_tick=lat_low - (lat_low%divisor) lat_high_tick=math.ceil(lat_high/divisor)*divisor print lat_high_tick print lat_low_tick plt.figure(figsize=(8,8)) cmap=plt.cm.RdBu_r ax = plt.axes(projection=ccrs.PlateCarree(), extent=(lon_low,lon_high,lat_low+degs_crop_bottom,lat_high-degs_crop_top)) clevs = np.linspace(min_contour, max_contour,256) midpoint=0 midp = np.mean(np.c_[clevs[:-1], clevs[1:]], axis=1) vals = np.interp(midp, [min_contour, midpoint, max_contour], [0, 0.5, 1]) cols = plt.cm.RdBu_r(vals) clevs_extend = np.linspace(min_contour, max_contour,254) cmap, norm = from_levels_and_colors(clevs_extend, cols, extend='both') cont = iplt.contourf(pcubetotal, clevs, cmap=cmap, extend='both', norm=norm) #cont = iplt.contourf(pcubetotal, cmap=cmap, extend='both') #plt.clabel(cont, fmt='%d') #ax.stock_img() ax.coastlines(resolution='110m', color='#262626') gl = ax.gridlines(draw_labels=True,linewidth=0.5, color='#262626', alpha=0.5, linestyle='--') gl.xlabels_top = False gl.ylabels_right = False #gl.xlines = False gl.xlocator = mticker.FixedLocator(range(int(lon_low_tick),int(lon_high_tick)+divisor,divisor)) gl.ylocator = mticker.FixedLocator(range(int(lat_low_tick),int(lat_high_tick)+divisor,divisor)) gl.xformatter = LONGITUDE_FORMATTER gl.yformatter = LATITUDE_FORMATTER gl.xlabel_style = {'size': 12, 'color':'#262626'} #gl.xlabel_style = {'color': '#262626', 'weight': 'bold'} gl.ylabel_style = {'size': 12, 'color':'#262626'} cbar = plt.colorbar(cont, orientation='horizontal', pad=0.05, extend='both', format = '$%d$') cbar.set_label('$W m^{-2}$') #cbar.set_label(pcubetotal.units, fontsize=10) cbar.set_ticks(np.arange(min_contour, max_contour+tick_interval,tick_interval)) ticks = (np.arange(min_contour, max_contour+tick_interval,tick_interval)) cbar.set_ticklabels(['${%d}$' % i for i in ticks]) #main_title=pcubetotal.standard_name.title().replace('_',' ') #main_title=('Total #model_info=re.sub('(.{68} )', '\\1\n', str(model_name_convert_title.main(experiment_id)), 0, re.DOTALL) #model_info = re.sub(r'[(\']', ' ', model_info) #model_info = re.sub(r'[\',)]', ' ', model_info) #print model_info if not os.path.exists('%s%s/%s' % (save_path, experiment_id, pp_file)): os.makedirs('%s%s/%s' % (save_path, experiment_id, pp_file)) plt.savefig('%s%s/%s/%s_%s_notitle.png' % (save_path, experiment_id, pp_file, experiment_id, pp_file), format='png', bbox_inches='tight') #plt.title('\n'.join(wrap('%s\n%s' % (main_title, model_info), 1000,replace_whitespace=False)), fontsize=16) #plt.show() #plt.savefig('%s%s/%s/%s_%s.png' % (save_path, experiment_id, pp_file, experiment_id, pp_file), format='png', bbox_inches='tight') plt.close()
datafile = os.path.join(filepath, filename) font_size = 20 font_weight = 'normal' ifile = pd.read_csv(datafile) x = ifile['Days'] y = ifile.columns[2:] zmatrix = np.zeros((len(y), len(x))) for i in range(len(x)): for j in range(len(y)): zmatrix[j][i] = ifile.at[i, y[j]] X, Y = np.meshgrid(y, x) bounds = [0, 35, 75, 115, 150, 250, 600] cmap, norm = from_levels_and_colors( bounds, ['limegreen', 'yellow', 'orange', 'r', 'purple', 'maroon']) fig, ax = plt.subplots(figsize=[50, 18], ncols=1, nrows=1) # cax = ax.pcolormesh(zmatrix, shading = 'gouraud', snap = 'True',cmap = cmap, norm=norm) #BTHS_matri2.pdf cax = ax.pcolor(zmatrix, cmap=cmap, norm=norm) #不能修改shading方式 # cax = ax.imshow(zmatrix, interpolation="nearest",cmap = cmap, norm=norm) #只适合len(x),len(y)相差不大的情况 cbar = fig.colorbar(cax, ax=ax, pad=0.01, ticks=bounds) # cbar.make_axes(fraction= 0.5,aspect = 20) font1 = { 'family': 'Times New Roman', 'weight': 'normal', 'size': 25, } #图例的字体设置,prop参数适用于plt.legend
def plot_domain_and_interest_region(ax: Axes, topo_nc_file_path: Path, focus_region_lonlat_nc_file: Path = None): """ :param focus_region_lonlat_nc_file: Path to the file containing focus region lons and lats :param region_mask_lats: latitudes corresponding to the region mask :param region_mask_lons: :param ax: :param topo_nc_file_path: :param region_mask: Note: below is the expected structure of the input netcdf file $ ncdump -h geophys_452x260_me.nc netcdf geophys_452x260_me { dimensions: x = 452 ; y = 260 ; variables: float ME(x, y) ; float lon(x, y) ; float lat(x, y) ; int proj_params ; proj_params:grid_type = "E" ; proj_params:lat1 = 0. ; proj_params:lon1 = 180. ; proj_params:lat2 = 1. ; proj_params:lon2 = 276. ; } """ # read the model topography from the file with xarray.open_dataset(topo_nc_file_path) as topo_ds: topo_lons, topo_lats, topo = [ topo_ds[k].values for k in ["lon", "lat", "ME"] ] prj_params = topo_ds["proj_params"] rll = RotatedLatLon(lon1=prj_params.lon1, lat1=prj_params.lat1, lon2=prj_params.lon2, lat2=prj_params.lat2) rot_pole_cpy = rll.get_cartopy_projection_obj() ax.set_visible(False) ax = ax.figure.add_axes(ax.get_position().bounds, projection=rot_pole_cpy) # ax.coastlines() gl_mask = get_gl_mask(topo_nc_file_path) region_mask = get_mask_of_points_near_lakes(gl_mask, npoints_radius=20) topo_lons[topo_lons > 180] -= 360 xll, yll = rot_pole_cpy.transform_point(topo_lons[0, 0], topo_lats[0, 0], cartopy.crs.PlateCarree()) xur, yur = rot_pole_cpy.transform_point(topo_lons[-1, -1], topo_lats[-1, -1], cartopy.crs.PlateCarree()) map_extent = [xll, xur, yll, yur] print("Map extent: ", map_extent) topo_clevs = [0, 100, 200, 300, 400, 500, 600, 800, 1000, 1200] # bn = BoundaryNorm(topo_clevs, len(topo_clevs) - 1) cmap = cm.get_cmap("terrain") ocean_color = cmap(0.18) cmap, norm = colors.from_levels_and_colors( topo_clevs, cmap(np.linspace(0.3, 1, len(topo_clevs) - 1))) xyz_coords = rot_pole_cpy.transform_points(cartopy.crs.PlateCarree(), topo_lons, topo_lats) xx = xyz_coords[:, :, 0] yy = xyz_coords[:, :, 1] add_rectangle(ax, xx, yy, margin=20, edge_style="solid", zorder=10, linewidth=0.5) add_rectangle(ax, xx, yy, margin=10, edge_style="dashed", zorder=10, linewidth=0.5) # plot a rectangle for the focus region if focus_region_lonlat_nc_file is not None: with xarray.open_dataset(focus_region_lonlat_nc_file) as fr: focus_lons, focus_lats = fr["lon"].data, fr["lat"].data xyz_coords = rot_pole_cpy.transform_points( cartopy.crs.PlateCarree(), focus_lons, focus_lats) xxf, yyf = xyz_coords[..., 0], xyz_coords[..., 1] add_rectangle(ax, xxf, yyf, edge_style="solid", margin=0, edgecolor="magenta", zorder=10, linewidth=1) cs = ax.pcolormesh(topo_lons[:, :], topo_lats[:, :], topo[:, :], transform=cartopy.crs.PlateCarree(), cmap=cmap, norm=norm) to_plot = np.ma.masked_where(region_mask < 0.5, region_mask) ax.scatter(topo_lons, topo_lats, to_plot * 0.01, c="cyan", transform=cartopy.crs.PlateCarree(), alpha=0.5) # Add geographic features line_color = "k" ax.add_feature(common_params.LAKES_50m, facecolor=cartopy.feature.COLORS["water"], edgecolor=line_color, linewidth=0.5) ax.add_feature(common_params.OCEAN_50m, facecolor=cartopy.feature.COLORS["water"], edgecolor=line_color, linewidth=0.5) ax.add_feature(common_params.COASTLINE_50m, facecolor="none", edgecolor=line_color, linewidth=0.5) ax.add_feature(common_params.RIVERS_50m, facecolor="none", edgecolor=line_color, linewidth=0.5) ax.set_extent(map_extent, crs=rot_pole_cpy) # improve colorbar divider = make_axes_locatable(ax) ax_cb = divider.new_vertical(size="5%", pad=0.1, axes_class=plt.Axes, pack_start=True) ax.figure.add_axes(ax_cb) cb = plt.colorbar(cs, cax=ax_cb, orientation="horizontal") cb.ax.set_xticklabels(topo_clevs, rotation=45) return ax
def plot_rain_contr(cube_a, cube_b, plotname, runtitle, timescale_a, timescale_b, all_ppn_bounds=None, region=None, frac=0): """ Function to plot set of histogram maps as rainfall contributions on two different timescales side by side. Inputs can be ACTUAL (assumed) or FRACTIONAL (if frac=1) contributions Args: * cube_a, cube_b: histogram cubes of rainfall contributions from each bin on timescale_a and timescale_b * plotname: filename for plot * runtitle: Name for dataset being plotted * timescale_a, timescale_b: Strings detailing time frequency of data from which histogram cubes were calculated e.g. 'Daily' * all_ppn_bounds: (optional) defines range of bin limits to lump together for plotting, otherwise is set to 4 default groups: [(0.005, 10.), (10., 50.), (50., 100.), (100., 3000.)] kg/m2/day Note that plots will work best for no more than 5 or 6 groups. * region: (optional) defines region to plot, otherwise just plots everywhere there are data. * frac: (optional) If frac=1, expects FRACTIONAL contributions have been input otherwise assumes ACTUAL contributions have been input """ # Check that the correct fields have been input test_a = cube_a.collapsed('precipitation_flux', iris.analysis.SUM) test_b = cube_b.collapsed('precipitation_flux', iris.analysis.SUM) if frac != 0: if round(np.max(test_a.data), 12) != 1.0 or round( np.max(test_b.data), 12) != 1.0: raise Exception( 'One or more input cube(s) is not a fractional histogram') else: if round(np.max(test_a.data), 12) == 1.0 or round( np.max(test_b.data), 12) == 1.0: raise Exception( 'One or more input cube(s) is a fractional histogram') # Extract region if required if region: avg_rain_bins_a = extract_region(cube_a, region) if avg_rain_bins_a is None: raise Exception( 'No data points in first dataset exist within region!') avg_rain_bins_b = extract_region(cube_b, region) if avg_rain_bins_b is None: raise Exception( 'No data points in second dataset exist within region!') else: avg_rain_bins_a = cube_a avg_rain_bins_b = cube_b # Put timescale and runtitle data into cube attributes so that they can be extracted later. avg_rain_bins_a.attributes['timescale'] = timescale_a avg_rain_bins_a.attributes['runtitle'] = runtitle avg_rain_bins_b.attributes['timescale'] = timescale_b avg_rain_bins_b.attributes['runtitle'] = runtitle # Set up contour levels and colours if frac != 0: contour_levels = [ 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0 ] else: contour_levels = [0.25, 0.5, 0.75, 1, 1.5, 2, 2.5, 3, 4, 6, 8, 10, 12] # Make a range of colours from dark blue through near-white to red by concatenating # part of two Cynthia Brewer color maps. colors = np.concatenate([ plt.get_cmap('brewer_RdBu_11')(range(1, 10)), plt.get_cmap('brewer_YlOrBr_09')(range(5, 0, -1)) ]) cmap, norm = from_levels_and_colors(contour_levels, colors, extend='both') # Plot contribution amounts, lumped into bins as defined in all_ppn_bounds if not all_ppn_bounds: all_ppn_bounds = [(0.005, 10.), (10., 50.), (50., 100.), (100., 3000.)] cubes = [avg_rain_bins_a, avg_rain_bins_b] plot_shape = [len(all_ppn_bounds), len(cubes)] fig = plt.figure(figsize=(10, 6), dpi=300) plot_number = 0 for ppn_bounds in all_ppn_bounds: for cube in cubes: plot_number += 1 cf = _make_panel(tuple(plot_shape + [plot_number]), cube, ppn_bounds, cmap, norm) # Make an axes to put the shared colorbar in colorbar_axes = plt.gcf().add_axes([0.25, 0.05, 0.5, 0.02]) colorbar = plt.colorbar(cf, colorbar_axes, orientation='horizontal') colorbar.ax.tick_params(labelsize=8) colorbar.ax.xaxis.set_label_position('top') if frac != 0: colorbar.set_label('Fractional contribution from events', fontsize=10) else: colorbar.set_label('Actual contribution from events (mm/day)', fontsize=10) plt.suptitle('Histogram of total rainfall events (mm/day)' + '\n' + runtitle, fontsize=10) plt.savefig(plotname) plt.clf()
def time_height_image( self, field, plot_km=False, mask_procedure=None, mask_tuple=None, plot_log10_var=False, cminmax=(0.0, 60.0), clevs=25, vmin=15.0, vmax=60.0, cmap="gist_ncar", discrete_cmap_levels=None, date_format="%H:%M", tz=None, xdate=True, date_minor_string="minute", height_MajTicks=None, height_MinTicks=None, height_min=None, height_max=None, fill_surface=False, fill_min=None, fill_color=None, start_time=None, end_time=None, color_bar=True, cb_orient="vertical", cb_pad=0.05, cb_tick_int=2, cb_label=None, cb_fontsize=None, cb_ticklabel_size=None, title=None, xlab=" ", xlabFontSize=16, xpad=7, ylab=" ", ylabFontSize=16, ypad=7, ax=None, fig=None, ): """ Wrapper function to produce a time series vs. height plot of variable indicated. Parameters ---------- field : float Variable to plot as time series. plot_km : boolean True to convert meters to kilometers for cappi_height. False retains meters information. mask_procedure : str String indicating how to apply mask via numpy, possibilities are: 'less', 'less_equal', 'greater', 'greater_equal', 'equal', 'inside', 'outside'. mask_tuple : (str, float[, float]) Tuple containing the field name and value(s) below which to mask field prior to plotting, for example to mask all data where. plot_log10_var : bool True plots the log base 10 of Data field. cminmax : tuple (min,max) values for controur levels. clevs : int Number of contour levels. vmin : float Minimum value to display. vmax : float Maximum value to display. cmap : str Matplotlib color map to use. discrete_cmap_levels : array A list of levels to be used for display. If chosen discrete color will be used in the colorbar instead of a linear luminance mapping. date_format : str Format of the time string for x-axis labels. tz : str Time zone info to use when creating axis labels (see datetime). xdate : bool True to use X-axis as date axis, false implies Y-axis is date axis. date_minor_string : str Sting to set minor ticks of date axis, 'second','minute','hour','day' supported. height_MajTicks : float Values for major tickmark spacing on height axis. height_MinTicks : float Values for minor tickmark spacing on height axis. height_min : float Minimum value for height axis. height_max : float Maximum value for height axis. fill_surface : boolean True to fill in surface, False to leave alone. fill_min : float Minimum surface elvation to shade. Only applied if fill_surface is True. fill_color : float Color to use if fill_surface is True. start_time : str UTC time to use as start time for subsetting in datetime format. (e.g. 2014-08-20 12:30:00) end_time : str UTC time to use as an end time for subsetting in datetime format. (e.g. 2014-08-20 16:30:00) title : str Plot title. xlab : str X-axis label. ylab : str Y-axis label. xpad : int Padding for X-axis label. ypad : int Padding for Y-axis label. color_bar : bool True to add colorbar, False does not. cb_pad : str Pad to move colorbar, in the form "5%", pos is to right for righthand location. cb_orient : str Colorbar orientation, either 'vertical' or 'horizontal'. cb_tick_int : int Interval to use for colorbar tick labels, higher number "thins" labels. cb_label : str Label for colorbar (e.g. units 'dBZ'). cb_fontsize : int Font size of the colorbar label. cb_ticklabel_size : int Font size of colorbar tick labels. ax : Matplotlib axis instance Axis to plot. None will use the current axis. fig : Matplotlib figure instance Figure on which to add the plot. None will use the current figure. """ # parse parameters ax, fig = common._parse_ax_fig(ax, fig) # Return masked or unmasked variable # Subsetted if desired Var, tsub, Data = self._get_variable_dict_data_time_subset(field, start_time, end_time) if mask_procedure is not None: Data = common.get_masked_data(Data, mask_procedure, mask_tuple) if len(self.height["data"].shape) == 2: Height = self._get_2d_height_time_subset(start_time, end_time) if plot_log10_var: Data = np.log10(Data) if cb_label is not None: cb_label = r"log$_{10}$[" + cb_label + "]" # Create contour level array clevels = np.linspace(cminmax[0], cminmax[1], clevs) if len(self.height["data"].shape) == 2: tSub2D, junk = np.meshgrid(date2num(tsub), self.height["data"][0, :]) Ht2D = Height.T del junk else: tSub2D, Ht2D = np.meshgrid(date2num(tsub), self.height["data"][:]) if plot_km: Ht2D = Ht2D / 1000.0 # Get the colormap and calculate data spaced by number of levels norm = None if discrete_cmap_levels is not None: cm = plt.get_cmap(cmap) try: levpos = np.rint(np.squeeze([np.linspace(0, 255, len(discrete_cmap_levels))])).astype(int) # Convert levels to colormap values cmap, norm = from_levels_and_colors(discrete_cmap_levels, cm(levpos), extend="max") except: print("Keyword error: 'discrete_cmap_levels' must " "be a list of float or integer") # Plot the time series ts = common.image_2d_date( tSub2D, Ht2D, Data.T, vmin=vmin, vmax=vmax, clevs=clevs, cmap=cmap, norm=norm, date_format=date_format, tz=tz, xdate=xdate, date_minor_string=date_minor_string, other_major_ticks=height_MajTicks, other_minor_ticks=height_MinTicks, other_min=height_min, other_max=height_max, title=title, xlab=xlab, xlabFontSize=xlabFontSize, xpad=xpad, ylab=ylab, ylabFontSize=ylabFontSize, ypad=ypad, color_bar=color_bar, cb_orient=cb_orient, cb_pad=cb_pad, cb_tick_int=cb_tick_int, cb_label=cb_label, cb_fontsize=cb_fontsize, cb_ticklabel_size=cb_ticklabel_size, ax=ax, fig=fig, ) if fill_surface: if self.surface is not None: sfc = self._get_variable_subset(self.surface["data"][:], start_time, end_time) ft = common.plot_fill_surface(tsub, sfc, ymin=fill_min, color=fill_color, ax=ax) else: print("No surface height information, cannot fill...") return
def draw(self, read_log, write_log, step, visual_mode): assert visual_mode in [0, 1, 2] # read_log: (1, 1, mem_slots) * L_gen # write_log: (B, L_gen, mem_slots) current_gen_chars = [c for c in self._gen_lines[-1]] gen_len = len(current_gen_chars) if len(self._gen_lines) >= 2: last_gen_chars = [c for c in self._gen_lines[-2]] last_gen_len = len(last_gen_chars) else: last_gen_chars = [''] * gen_len last_gen_len = gen_len # (L_gen, mem_slots) mem_slots = self._topic_slots + self._history_slots + last_gen_len read_matrix = torch.cat(read_log, dim=1)[0, 0:gen_len, 0:mem_slots].detach().cpu().numpy() read_matrix = self.normalization(read_matrix) plt.figure(figsize=(11, 5)) # visualization of reading attention weights num_levels = 100 vmin, vmax = read_matrix.min(), read_matrix.max() midpoint = 0 levels = np.linspace(vmin, vmax, num_levels) midp = np.mean(np.c_[levels[:-1], levels[1:]], axis=1) vals = np.interp(midp, [vmin, midpoint, vmax], [0, 0.5, 1]) colors = plt.cm.seismic(vals) cmap, norm = from_levels_and_colors(levels, colors) plt.imshow(read_matrix, cmap=cmap, interpolation='none') # print generated chars and chars in the memory fontsize = 14 plt.text(0.2, gen_len + 0.5, "Topic Memory", fontsize=fontsize) plt.text(self._topic_slots, gen_len + 0.5, "History Memory", fontsize=fontsize) if last_gen_len == 5: shift = 5 else: shift = 6 plt.text(self._topic_slots + shift, gen_len + 0.5, "Local Memory", fontsize=fontsize) # topic memory for i in range(0, len(self._keywords)): key = self._keywords[i] if len(key) == 1: key = " " + key + " " key = key + "|" plt.text(i - 0.4, -0.7, key, fontsize=fontsize) start_pos = self._topic_slots end_pos = self._topic_slots + self._history_slots # history memory for i in range(start_pos, end_pos): c = self._history_mem[i - start_pos] if i == end_pos - 1: c = c + " |" plt.text(i - 0.2, -0.7, c, fontsize=fontsize) start_pos = end_pos end_pos = start_pos + last_gen_len # local memory for i in range(start_pos, end_pos): idx = i - start_pos plt.text(i - 0.2, -0.7, last_gen_chars[idx], fontsize=fontsize) # generated line for i in range(0, len(current_gen_chars)): plt.text(-1.2, i + 0.15, current_gen_chars[i], fontsize=fontsize) plt.colorbar() plt.tick_params(labelbottom=False, labelleft=False) x_major_locator = plt.MultipleLocator(1) y_major_locator = plt.MultipleLocator(1) ax = plt.gca() ax.xaxis.set_major_locator(x_major_locator) ax.yaxis.set_major_locator(y_major_locator) #plt.tight_layout() if visual_mode == 1: fig = plt.gcf() fig.savefig(self._log_path + 'visual_step_{}.png'.format(step), dpi=300, quality=100, bbox_inches="tight") elif visual_mode == 2: plt.show() # update history memory if write_log is not None: if len(last_gen_chars) == 0: print("last generated line is empty!") write_log = write_log[0, :, :].detach().cpu().numpy() history_mem = copy.deepcopy(self._history_mem) for i, c in enumerate(last_gen_chars): selected_slot = np.argmax(write_log[i, :]) if selected_slot >= self._history_slots: continue history_mem[selected_slot] = c self._history_mem = history_mem
def plot_cfad(self, field, height_axis=1, xbinsminmax=None, nbinsx=50, points_thresh_fraction=None, start_time=None, end_time=None, vmin=None, vmax=None, cmap=None, discrete_cmap_levels=None, mask_below=None, plot_percent=False, plot_colorbar=True, x_min=None, x_max=None, y_min=None, y_max=None, xlab=None, xlabFontSize=None, xpad=None, ylab=None, ylabFontSize=None, ypad=None, title=None, titleFontSize=None, cb_fontsize=None, cb_ticklabel_size=None, cb_orient=None, cb_pad=None, cb_levs=None, cb_tick_int=None, quantiles=None, qcolor='k', qlabels_on=False, qlabel_color=None, qlabel_size=None, qmask_above_height=None, qmask_below_height=None, qmask_between_height=None, ax=None, fig=None): """ Create a frequency by altitude distribution plot of two variables. This is the traditional method of calculating a frequency distribution at each height of input array by iterating through the height array and input data array. NOTE: This routine only works with Cartesian data. Parameters ---------- field : str Name of the field to use in CFAD calculation. height_axis : int The dimension to use as the height axis. xbinsminmax : 2-tuple A tuple with the minimum and maximax values to use with xarr. None will use min/max of xarr. nbinsx : int The number of bins to use with xarr, default is 50. points_thresh_fraction : float The fraction of points that must be present for the CFAD to be calculated. Following Yuter and Houzed 1995, the default values is 0.1 (10%) of potential data coverage is required. This threshold removes anomolous results when a small number of points is present. start_time : str UTC time to use as start time for subsetting in datetime format. (e.g. 2014-08-20 12:30:00) end_time : str UTC time to use as an end time for subsetting in datetime format. (e.g. 2014-08-20 16:30:00) vmin : float Minimum value to display. vmax : float Maximum value to display. cmap : str Matplotlib colormap string. discrete_cmap_levels : array A list of levels to be used for display. If chosen discrete color will be used in the colorbar instead of a linear luminance mapping. mask_below : float If provided, values less than mask_below will be masked. plot_percent : boolean True to display percentage. Default is to display fraction. plot_colorbar : boolean True to diaplay colorbar. False does not display colorbar. x_min : float Minimum value for X-axis. x_max : float Maximum value for X-axis. y_min : float Minimum value for Y-axis. y_max : float Maximum value for Y-axis. xlab : str X-axis label. ylab : str Y-axis label. xpad : int Padding for X-axis label. ypad : int Padding for Y-axis label. xlabFontSize : int Font size to use for X-axis label. ylabFontSize : int Font size to use for Y-axis label. title : str Plot title. titleFontSize : int Font size to use for Title label. cb_fontsize : int Font size of the colorbar label. cb_ticklabel_size : int Font size of colorbar tick labels. cb_pad : str Pad to move colorbar, in the form "5%", pos is to right for righthand location. cb_orient : str Colorbar orientation, either 'vertical' or 'horizontal'. cb_levs : int Number of colorbar levels to use in tick calculation. cb_tick_int : int Interval to use for colorbar tick labels, higher number "thins" labels. quantiles : list A list of percentage values for quantile calculations. qcolor : str Color to use for quantile plot lines. qlabels_on : boolean True to print labels of quantiles on plot. False for no labels. qlabel_color : str Color of quantile labels if activated. Default black. qlabel_size : int Size of the quantile labels. qmask_above_height : float Mask quantile data above this height. qmask_below_height : float Mask quantile data below this height. qmask_between_height : tuple, float Mask quantile data between this height. ax : Matplotlib axis instance Axis to plot. None will use the current axis. fig : Matplotlib figure instance Figure on which to add the plot. None will use the current figure. """ # parse parameters ax = common._parse_ax(ax) # Snag the data from requested field xarr = self._get_fields_variable_dict_data_time_subset( field, start_time, end_time) if xbinsminmax is None: xbinsminmax = (np.ma.min(xarr), np.ma.max(xarr)) binsx = np.linspace(xbinsminmax[0], xbinsminmax[1], nbinsx, endpoint=True) cb_label = "Frequency" if plot_percent: cb_label = cb_label + " (%)" # Reshape the array so that height axis is first dimension if height_axis != 0: ht = np.rollaxis(self.heightfield['data'], height_axis) xarr = np.rollaxis(xarr, height_axis) else: ht = self.heightfield['data'].copy() cfad_dict = self.calc_cfad(xarr, binsx, self.height['data'][:], points_thresh_fraction) if plot_percent: CFAD = cfad_dict['frequency_percent'] else: CFAD = cfad_dict['frequency_points'] if mask_below is not None: CFAD = np.ma.masked_where(CFAD < mask_below, CFAD) # Set the axes common._set_axes(ax, x_min=x_min, x_max=x_max, y_min=y_min, y_max=y_max, title=title, titleFontSize=titleFontSize, xlab=xlab, ylab=ylab, xpad=xpad, ypad=ypad, xlabFontSize=xlabFontSize, ylabFontSize=ylabFontSize) # Plot the data # Get the colormap and calculate data spaced by number of levels norm = None if discrete_cmap_levels is not None: cm = plt.get_cmap(cmap) try: levpos = np.rint( np.squeeze( [np.linspace(0, 255, len(discrete_cmap_levels))])).astype(int) # Convert levels to colormap values cmap, norm = from_levels_and_colors(discrete_cmap_levels, cm(levpos), extend='max') except: print("Keyword error: 'discrete_cmap_levels' must " "be a list of float or integer") p = ax.pcolormesh(cfad_dict['xaxis'], cfad_dict['yaxis'], CFAD, vmin=vmin, vmax=vmax, norm=norm, cmap=cmap) if plot_colorbar: cb = common.add_colorbar(ax, p, orientation=cb_orient, pad=cb_pad, label=cb_label, fontsize=cb_fontsize, ticklabel_size=cb_ticklabel_size, clevs=cb_levs, tick_interval=cb_tick_int) if quantiles is not None: qArr = self.plot_quantiles( field, quantiles=quantiles, height_axis=height_axis, start_time=start_time, end_time=end_time, qcolor=qcolor, qlabels_on=qlabels_on, qlabel_color=qlabel_color, qlabel_size=qlabel_size, qmask_above_height=qmask_above_height, qmask_below_height=qmask_below_height, qmask_between_height=qmask_between_height, setup_axes=False, ax=ax) del (CFAD, norm) return cfad_dict
def main(): clevs_lkeff_snowfalldays = [0, 0.1, 0.8, 1.6, 2.4, 3.2, 4.0, 5] clevs_lkeff_snowfall = [0, 0.01, 0.1, 0.2, 0.3, 0.4, 0.5, 1, 2, 5, 10] mycolors = ["white", "indigo", "blue", "dodgerblue", "aqua", "lime", "yellow", "gold", "orange", "orangered", "red", "firebrick", ] start_year = 1980 end_year = 2009 label_to_hles_dir = OrderedDict( [ ("Obs", Path("/RESCUE/skynet3_rech1/huziy/Netbeans Projects/Python/RPN/lake_effect_analysis_Obs_monthly_icefix_1980-2009")), ("CRCM5_NEMO", Path("/RESCUE/skynet3_rech1/huziy/Netbeans Projects/Python/RPN/lake_effect_analysis_CRCM5_NEMO_1980-2009")), ("CRCM5_HL", Path("/RESCUE/skynet3_rech1/huziy/Netbeans Projects/Python/RPN/lake_effect_analysis_CRCM5_Hostetler_1980-2009")), # ("CRCM5_NEMO_TT_PR", Path("/RESCUE/skynet3_rech1/huziy/Netbeans Projects/Python/RPN/lake_effect_analysis_CRCM5_NEMO_based_on_TT_PR_1980-2009")) ] ) label_to_line_style = { "Obs": "k.-", "CRCM5_NEMO": "r", "CRCM5_HL": "b", "CRCM5_NEMO_TT_PR": "g" } # clevs = clevs_lkeff_snowfall # vname = "snow_fall" # units = "cm" clevs = clevs_lkeff_snowfalldays vname = "lkeff_snowfall_days" units = "days" npc = 1 cmap, bn = colors.from_levels_and_colors(clevs, mycolors[:len(clevs) - 1]) cmap.set_over(mycolors[len(clevs) - 2]) label_to_y_to_snfl = {} label_to_pc = {} label_to_eof = OrderedDict() label_to_varfraction = OrderedDict() mask = None plot_utils.apply_plot_params(font_size=12) years = None lats = None lons = None the_mask = None for label, folder in label_to_hles_dir.items(): y_to_snfl = {} for the_file in folder.iterdir(): if not the_file.name.endswith(".nc"): continue with Dataset(str(the_file)) as ds: print(ds) snfl = ds.variables[vname][:] year_current = ds.variables["year"][:] if mask is None: lons, lats = [ds.variables[k][:] for k in ["lon", "lat"]] lons[lons > 180] -= 360 mask = maskoceans(lons, lats, lons, inlands=True, resolution="i") if start_year <= year_current[0] <= end_year: y_to_snfl[year_current[0]] = snfl[0] label_to_y_to_snfl[label] = y_to_snfl lons[lons < 0] += 360 b = Basemap(lon_0=180, llcrnrlon=lons[0, 0], llcrnrlat=lats[0, 0], urcrnrlon=lons[-1, -1], urcrnrlat=lats[-1, -1], resolution="i", area_thresh=2000) # plot the eofs plot_utils.apply_plot_params(font_size=10, width_cm=30, height_cm=8) xx, yy = b(lons, lats) fig = plt.figure() gs = GridSpec(1, len(label_to_hles_dir), wspace=0) for col, label in enumerate(label_to_hles_dir): y_to_snfl = label_to_y_to_snfl[label] snfl_clim = np.array([field for field in y_to_snfl.values()]).mean(axis=0) # snfl_clim = np.ma.masked_where(mask.mask, snfl_clim) ax = fig.add_subplot(gs[0, col]) im = b.pcolormesh(xx, yy, snfl_clim, cmap=cmap, norm=bn, ax=ax) cb = b.colorbar(im, extend="max") cb.ax.set_visible(col == len(label_to_hles_dir) - 1) ax.set_title("{}".format(label)) b.drawcoastlines(ax=ax) fig.savefig(str(label_to_hles_dir["Obs"].joinpath("hles_clim_{}_{}-{}.png".format(vname, start_year, end_year))), bbox_inches="tight", dpi=300)
def cross_section(variable_name, date, time, start_lat, start_lon, end_lat, end_lon, save=False): '''This function plots a vertical cross section of the chosen variable. Supported variables for plotting procedure are vertical_velocity, rh, omega, absolute_vorticity, theta_e and reflectivity.''' ### Predefine some variables ### # Define data filename data_dir = '/scratch3/thomasl/work/data/casestudy_baden/' filename = '{}wrfout_d02_{}_{}:00'.format(data_dir, date, time) # Define save directory save_dir = '/scratch3/thomasl/work/retrospective_part/' 'casestudy_baden/cross_section/' # Create the start point and end point for the cross section start_point = CoordPair(lat=start_lat, lon=start_lon) end_point = CoordPair(lat=end_lat, lon=end_lon) ### Start plotting procedure ### # Open NetCDF file ncfile = Dataset(filename) # Extract the model height, terrain height and variables ht = getvar(ncfile, 'z') / 1000 # change to km ter = getvar(ncfile, 'ter') / 1000 if variable_name == 'vertical_velocity': variable = getvar(ncfile, 'wa', units='kt') title_name = 'Vertical Velocity' colorbar_label = 'Vertical Velocity [$kn$]' variable_min = -2 variable_max = 2 elif variable_name == 'rh': variable = getvar(ncfile, 'rh') title_name = 'Relative Humidity' colorbar_label = 'Relative Humidity [$pct$]' variable_min = 0 variable_max = 100 elif variable_name == 'omega': variable = getvar(ncfile, 'omega') title_name = 'Vertical Motion (Omega)' colorbar_label = 'Omega [$Pa$ $s^-$$^1$]' variable_min = -5 variable_max = 5 elif variable_name == 'absolute_vorticity': variable = getvar(ncfile, 'avo') title_name = 'Absolute Vorticity' colorbar_label = 'Absolute Vorticity [$10^{-5}$' '$s^{-1}$]' variable_min = -50 variable_max = 100 elif variable_name == 'theta_e': variable = getvar(ncfile, 'theta_e') title_name = 'Theta-E' colorbar_label = 'Theta-E [$K$]' variable_min = 315 variable_max = 335 elif variable_name == 'reflectivity': variable = getvar(ncfile, 'dbz') #, timeidx=-1 title_name = 'Reflectivity' colorbar_label = 'Reflectivity [$dBZ$]' variable_min = 5 variable_max = 75 # Linear Z for interpolation Z = 10**(variable / 10) # Compute the vertical cross-section interpolation z_cross = vertcross(Z, ht, wrfin=ncfile, start_point=start_point, end_point=end_point, latlon=True, meta=True) # Convert back after interpolation variable_cross = 10.0 * np.log10(z_cross) # Make a copy of the z cross data variable_cross_filled = np.ma.copy(to_np(variable_cross)) # For each cross section column, find the first index with # non-missing values and copy these to the missing elements below for i in range(variable_cross_filled.shape[-1]): column_vals = variable_cross_filled[:, i] first_idx = int(np.transpose((column_vals > -200).nonzero())[0]) variable_cross_filled[0:first_idx, i] = variable_cross_filled[first_idx, i] ter_line = interpline(ter, wrfin=ncfile, start_point=start_point, end_point=end_point) # Get latitude and longitude points lats, lons = latlon_coords(variable) # Create the figure fig = plt.figure(figsize=(15, 10)) ax = plt.axes() ys = to_np(variable_cross.coords['vertical']) xs = np.arange(0, variable_cross.shape[-1], 1) # Make contour plot if variable_name == 'reflectivity': levels = np.arange(variable_min, variable_max, 5) # Create the dbz color table found on NWS pages. dbz_rgb = np.array( [[4, 233, 231], [1, 159, 244], [3, 0, 244], [2, 253, 2], [1, 197, 1], [0, 142, 0], [253, 248, 2], [229, 188, 0], [253, 149, 0], [253, 0, 0], [212, 0, 0], [188, 0, 0], [248, 0, 253], [152, 84, 198]], np.float32) / 255.0 dbz_cmap, dbz_norm = from_levels_and_colors(levels, dbz_rgb, extend='max') else: levels = np.linspace(variable_min, variable_max, 11) if variable_name == 'omega' or variable_name == 'vertical_velocity': def truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100): new_cmap = colors.LinearSegmentedColormap.from_list( 'trunc({n},{a:.2f},{b:.2f})'.format(n=cmap.name, a=minval, b=maxval), cmap(np.linspace(minval, maxval, n))) return new_cmap old_cmap = plt.get_cmap('RdYlBu') cmap = truncate_colormap(old_cmap, 0.05, 0.9) norm = colors.DivergingNorm(vmin=variable_min, vcenter=0, vmax=variable_max) else: cmap = ListedColormap(sns.cubehelix_palette(20, start=.5, rot=-.75)) if variable_name == 'omega' or variable_name == 'vertical_velocity': variable_contours = ax.contourf(xs, ys, to_np(variable_cross_filled), levels=levels, cmap=cmap, extend='both', norm=norm) elif variable_name == 'rh': variable_contours = ax.contourf(xs, ys, to_np(variable_cross_filled), levels=levels, cmap=cmap, extend='max') elif variable_name == 'reflectivity': variable_contours = ax.contourf(xs, ys, to_np(variable_cross_filled), levels=levels, cmap=dbz_cmap, norm=dbz_norm, extend='both') else: variable_contours = ax.contourf(xs, ys, to_np(variable_cross_filled), levels=levels, cmap=cmap, extend='both') # Plot wind barbs if variable_name == 'vertical_velocity': u = getvar(ncfile, 'ua', units='kt') U = 10**(u / 10) u_cross = vertcross(U, ht, wrfin=ncfile, start_point=start_point, end_point=end_point, latlon=True, meta=True) u_cross = 10.0 * np.log10(u_cross) u_cross_filled = np.ma.copy(to_np(u_cross)) for i in range(u_cross_filled.shape[-1]): column_vals = u_cross_filled[:, i] first_idx = int(np.transpose((column_vals > -200).nonzero())[0]) u_cross_filled[0:first_idx, i] = u_cross_filled[first_idx, i] ax.barbs(xs[::3], ys[::3], to_np(u_cross_filled[::3, ::3]), to_np(variable_cross_filled[::3, ::3]), length=7, zorder=1) if variable_name == 'omega': u = getvar(ncfile, 'ua', units='kt') U = 10**(u / 10) u_cross = vertcross(U, ht, wrfin=ncfile, start_point=start_point, end_point=end_point, latlon=True, meta=True) u_cross = 10.0 * np.log10(u_cross) u_cross_filled = np.ma.copy(to_np(u_cross)) for i in range(u_cross_filled.shape[-1]): column_vals = u_cross_filled[:, i] first_idx = int(np.transpose((column_vals > -200).nonzero())[0]) u_cross_filled[0:first_idx, i] = u_cross_filled[first_idx, i] w = getvar(ncfile, 'wa', units='kt') W = 10**(w / 10) w_cross = vertcross(W, ht, wrfin=ncfile, start_point=start_point, end_point=end_point, latlon=True, meta=True) w_cross = 10.0 * np.log10(w_cross) w_cross_filled = np.ma.copy(to_np(w_cross)) for i in range(w_cross_filled.shape[-1]): column_vals = w_cross_filled[:, i] first_idx = int(np.transpose((column_vals > -200).nonzero())[0]) w_cross_filled[0:first_idx, i] = w_cross_filled[first_idx, i] ax.barbs(xs[::3], ys[::3], to_np(u_cross_filled[::3, ::3]), to_np(w_cross_filled[::3, ::3]), length=7, zorder=1, color='grey') # Add color bar cbar = mpu.colorbar(variable_contours, ax, orientation='vertical', aspect=40, shrink=.05, pad=0.05) cbar.set_label(colorbar_label, fontsize=15) cbar.set_ticks(levels) # Set x-ticks to use latitude and longitude labels coord_pairs = to_np(variable_cross.coords['xy_loc']) x_ticks = np.arange(coord_pairs.shape[0]) x_labels = [ pair.latlon_str(fmt='{:.2f}, {:.2f}') for pair in to_np(coord_pairs) ] # Set desired number of x ticks below num_ticks = 5 thin = int((len(x_ticks) / num_ticks) + .5) ax.set_xticks(x_ticks[::thin]) ax.set_xticklabels(x_labels[::thin], rotation=45, fontsize=10) ax.set_xlim(x_ticks[0], x_ticks[-1]) # Set y-ticks and limit the height ax.set_yticks(np.linspace(0, 12, 13)) ax.set_ylim(0, 12) # Set x-axis and y-axis labels ax.set_xlabel('Latitude, Longitude', fontsize=12.5) ax.set_ylabel('Height [$km$]', fontsize=12.5) # Fill in mountian area ht_fill = ax.fill_between(xs, 0, to_np(ter_line), facecolor='saddlebrown', zorder=2) # Make nicetime xr_file = xr.open_dataset(filename) nicetime = pd.to_datetime(xr_file.QVAPOR.isel(Time=0).XTIME.values) # Add title ax.set_title('Vertical Cross-Section of {}'.format(title_name), fontsize=20, loc='left') ax.set_title('Valid time: {} {}'.format( nicetime.strftime('%Y-%m-%d %H:%M'), 'UTC'), fontsize=15, loc='right') # Add grid for y axis ax.grid(axis='y', linestyle='--', color='grey') plt.show() ### Save figure ### if save == True: fig.savefig('{}cross_section_{}.png'.format(save_dir, variable_name), bbox_inches='tight', dpi=300)
def cfad_plot(var, data=None, cfad=None, hts=None, nbins=20, ax=None, maxval=10.0, above=2.0, below=15.0, bins=None, log=False, pick=None, z_resolution=1.0, levels=None, tspan=None, cont=False, rconf=None, mask=None, **kwargs): if hts is None: print('please provide nominal heights to cfad_plot') return if data is not None: # hold = deepcopy(data) # if mask is not None: # data[mask] = -1 cfad, reshts, vbins = GF.cfad(data, hts, value_bins=bins, above=above, below=below, pick=pick, z_resolution=z_resolution, tspan=tspan, z_ind=0, ret_z=1, ret_bin=1, mask=mask) elif cfad is not None: if bins is not None: vbins = bins[:-1] else: try: vbins = np.arange(np.nanmin(data), np.nanmax(data), nbins) except: vbins = np.arange(0, 10, nbins) bins = np.arange(0, 10, nbins) reshts = hts else: print('please specify data or cfad') return if ax is None: fig, ax = plt.subplots() else: # ax has been passed in, do nothing to ax, but need to get the parent fig fig = ax.get_figure() if log: norm = colors.LogNorm(vmin=1e-5, vmax=1e2) else: norm = None # plot the CFAD cfad_ma = np.ma.masked_where(cfad == 0, cfad) print(np.shape(cfad_ma), 'cfad shape') if cont is True: levs = [0.02, 0.05, 0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.0, 15.0, 20., 25.] cols = [ 'silver', 'darkgray', 'slategrey', 'dimgray', 'blue', 'mediumaquamarine', 'yellow', 'orange', 'red', 'fuchsia', 'violet' ] try: pc = ax.contourf(bins[:-1], reshts, cfad_ma, levs, colors=cols, extend='both') except TypeError as e: print('Can not plot {v} with exception {e}'.format(v=var, e=e)) return fig, ax else: if levels is not None: cmap, norm = from_levels_and_colors([ 0.02, 0.05, 0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.0, 15.0, 20., 25. ], [ 'silver', 'darkgray', 'slategrey', 'dimgray', 'blue', 'mediumaquamarine', 'yellow', 'orange', 'red', 'fuchsia', 'violet' ]) # mention levels and colors here #print cmap pc = ax.pcolormesh(bins, reshts, cfad_ma, norm=norm, cmap=cmap) else: pc = ax.pcolormesh(bins, reshts, cfad_ma, vmin=0, vmax=maxval, norm=norm, **kwargs) cb = fig.colorbar(pc, ax=ax) cb.set_label('Frequency (%)') ax.set_ylabel('Height (km MSL)') # try: if rconf is not None: if var == 'DRC' or var == 'DRS': varn = rconf.zdr_name elif var == 'DZC' or var == 'DZS': varn = rconf.dz_name elif var == 'KDC' or var == 'KDS': varn = rconf.kdp_name elif var == 'WSvar' or var == 'WCvar': varn = rconf.w_name else: varn = var # print 'ln192',varn # if varn in rconf.names.keys(): # # ax.set_xlabel('{n} {u}'.format(n=rconf.names[varn], u=rconf.units[varn])) # #print rconf.print_title(tm=tspan) # # ax.set_title("{d}".format(d=rconf.print_title(tm=tspan))) # # ax.set_title('%s %s %s CFAD' % (self.print_date(), self.radar_name, self.longnames[var])) # else: # ax.set_xlabel('{n}'.format(n=var)) # #print rconf.print_title(tm=tspan) # # ax.set_title("{d}".format(d=rconf.print_title(tm=tspan))) # # except: # # pass return fig, ax
def plot_number_of_bins(): multiplier = 1 selected_vars = { "NBIN": [ 8, ] } nbins_max = 8 data_source = { # "(CRCM5-default, from GenPhysX)": "/RESCUE/skynet3_rech1/huziy/NEI_geophysics/WC_0.11_deg/geophys_CORDEX_NA_0.11deg_695x680_filled_grDes_barBor_Crop2Gras_peat_with_directions", # "(MODIS)": "/RESCUE/skynet3_rech1/huziy/NEI_geophysics/WC_0.11_deg/fields_from_Bernardo/VF_WCAN.rpn", "": "/RESCUE/skynet3_rech1/huziy/NEI_geophysics/WC_0.11_deg/fields_from_Caio/bins_WC011" } file_with_target_coords = "/RESCUE/skynet3_rech1/huziy/NEI_geophysics/WC_0.11_deg/fields_from_Caio/WC011_VF2.rpn" shape_files = { # "k": "/BIG1/aganji/skynet3_rech3/CLASS_snow/output_31year_HiRes_ck_paper_aug26/CORDEX_NA_0.44/PROVINCE.shp", "m": "/RESCUE/skynet3_rech1/huziy/CNRCWP/C3/GRDC_basins/GRDC_405_basins_from_mouth.shp" } with RPN(file_with_target_coords) as r: assert isinstance(r, RPN) glacier_fraction = r.get_first_record_for_name_and_level(varname="VF", level=2) lons_t, lats_t, bmap = get_lons_lats_basemap(file_with_target_coords) nx, ny = lons_t.shape indx_subspace = IndexSubspace(i_start=0, i_end=nx // 1.5, j_start=80, j_end=ny - 60) lons_t, lats_t, bmap = get_lons_lats_basemap(file_with_target_coords, index_subset=indx_subspace) xx, yy = bmap(lons_t, lats_t) clevels = np.arange(0.5, 9, 1) color_list = [ "blue", "royalblue", "dodgerblue", "cyan", "lime", "yellow", "orange", "red", "darkred", "brown" ][:len(clevels) - 1] print(len(clevels), len(color_list)) assert len(clevels) == len(color_list) + 1 cmap, norm = colors.from_levels_and_colors(clevels, color_list) # create the folder for images if it does not exist yet if not img_folder.is_dir(): img_folder.mkdir() plot_utils.apply_plot_params() for ds_label, ds_path in data_source.items(): with RPN(ds_path) as r: assert isinstance(r, RPN) print(r.get_list_of_varnames()) for vname, levels in selected_vars.items(): lev_to_field = r.get_2D_field_on_all_levels(name=vname) lons_s, lats_s = r.get_longitudes_and_latitudes_for_the_last_read_rec( ) xs, ys, zs = lat_lon.lon_lat_to_cartesian( lons_s.flatten(), lats_s.flatten()) xt, yt, zt = lat_lon.lon_lat_to_cartesian( lons_t.flatten(), lats_t.flatten()) ktree = KDTree(list(zip(xs, ys, zs))) dists, inds = ktree.query(list(zip(xt, yt, zt))) for the_level in levels: the_field = lev_to_field[the_level] # Do the plotting fig = plt.figure() ax = plt.gca() ax.set_title(vname_to_level_to_title[vname][the_level] + " {}".format(ds_label)) to_plot = the_field.flatten()[inds].reshape(xx.shape) to_plot *= multiplier # mask points without glacier fractions to_plot = np.ma.masked_where(glacier_fraction < 0.01, to_plot) to_plot = maskoceans( np.where(lons_t < 180, lons_t, lons_t - 360), lats_t, to_plot) if vname not in ["FACC"]: # cs = bmap.contourf(xx, yy, to_plot, 20, ax=ax) cs = bmap.pcolormesh(xx, yy, to_plot, cmap=cmap, norm=norm, ax=ax) else: cs = bmap.contourf(xx, yy, to_plot, 20, ax=ax, norm=LogNorm()) bmap.colorbar(cs, ticks=clevels) bmap.drawcoastlines(ax=ax) bmap.drawcountries() bmap.drawstates() # read the relevant shape files for i, (clr, shp) in enumerate(shape_files.items()): bmap.readshapefile(shp[:-4], "field_{}".format(i), color=clr) img_path = img_folder.joinpath("{}_{}_{}_{}.png".format( vname, the_level, ds_label, vname_to_level_to_title[vname][the_level].replace( " ", "_"))) fig.tight_layout() fig.savefig(str(img_path), bbox_inches="tight") plt.close(fig)
def plotFig(heatMapDF, droppedPercentDF, droppedNumDF, numOrPercent, generation): global filePath global frequencies global threshNum global totalFreq global numGroup global meanPath meanDF = getMeanDF(heatMapDF) print(meanDF) ax = [] with sns.axes_style('white'): #Plus 2 for dropped row and average row gs = gridspec.GridSpec(int(numGroup) + 2, 10) ax.append(plt.subplot(gs[:-3, 2:-1])) if (numOrPercent == 'num'): #Dropped ax.append(plt.subplot(gs[-2, 2:-1])) #Mean ax.append(plt.subplot(gs[-1, 2:-1])) else: #Dropped ax.append(plt.subplot(gs[-1, 2:-1])) #Show absolute number if numOrPercent == 'num': for i in range(len(frequencies)): trick = threshNum[i] + 10 cmap, norm = mcolors.from_levels_and_colors( [0, threshNum[i], trick], ['white', 'grey', 'grey'], extend='max') sns.heatmap( heatMapDF.mask(( (heatMapDF == heatMapDF) | heatMapDF.isnull()) & (heatMapDF.columns != frequencies[i])), ax=ax[0], cbar=False, annot=True, fmt='g', cmap=cmap, norm=norm) #Dropped row for i in range(len(frequencies)): cmap, norm = mcolors.from_levels_and_colors( [0, threshNum[i], trick], ['white', 'white', 'white'], extend='max') sns.heatmap(droppedNumDF.mask( ((droppedNumDF == droppedNumDF) | droppedNumDF.isnull()) & (droppedNumDF.columns != frequencies[i])), ax=ax[1], cbar=False, annot=True, fmt='g', cmap=cmap, norm=norm) #Mean row for i in range(len(frequencies)): cmap, norm = mcolors.from_levels_and_colors( [0, threshNum[i], trick], ['white', 'white', 'white'], extend='max') sns.heatmap(meanDF.mask(((meanDF == meanDF) | meanDF.isnull()) & (meanDF.columns != frequencies[i])), ax=ax[2], cbar=False, annot=True, fmt='g', cmap=cmap, norm=norm) #Show percentage elif numOrPercent == 'percent': percentHeatMap = pd.DataFrame() for i in range(heatMapDF.shape[1]): percentHeatMap[frequencies[i]] = heatMapDF[ frequencies[i]].values / float(totalFreq[i]) for i in range(len(frequencies)): trick = threshNum[i] + 10 cmap, norm = mcolors.from_levels_and_colors( [0, threshNum[i] / float(totalFreq[i]), trick], ['white', 'grey', 'grey'], extend='max') sns.heatmap(percentHeatMap.mask( ((percentHeatMap == percentHeatMap) | percentHeatMap.isnull()) & (percentHeatMap.columns != frequencies[i])), ax=ax[0], cbar=False, annot=True, fmt="2.1%", cmap=cmap, norm=norm) for i in range(len(frequencies)): cmap, norm = mcolors.from_levels_and_colors( [0, threshNum[i], trick], ['white', 'white', 'white'], extend='max') sns.heatmap(droppedPercentDF.mask( ((droppedPercentDF == droppedPercentDF) | droppedPercentDF.isnull()) & (droppedPercentDF.columns != frequencies[i])), ax=ax[1], cbar=False, annot=True, fmt="1.1%", cmap=cmap, norm=norm) # want a more natural, table-like display ax[0].xaxis.tick_top() ax[0].set_xticklabels(frequencies, minor=False) global yRange ax[0].set_yticklabels(yRange, minor=False, rotation=0) ax[1].set_yticklabels(['Dropped'], minor=False, rotation=0) ax[1].set_xticklabels([], minor=False) if (numOrPercent == 'num'): ax[2].set_yticklabels(['Mean'], minor=False, rotation=0) ax[2].set_xticklabels([], minor=False) fileName = filePath.split('.')[0] name = fileName.split('/')[-1] if generation == 0: ax[0].set_title('Prior Shrinking Range: Distribution of ' + col + ' while measuring ' + name, y=1.1) else: ax[0].set_title('After Shrinking Range: Distribution of ' + col + ' while measuring ' + name, y=1.1) cur_pos = [] # for i in range(2): # cur_pos.append(ax[i].get_position()) # ax[i].set_position([cur_pos[i].x0 + cur_pos[i].width * 0.15, cur_pos[i].y0 + cur_pos[i].height * 0.1, cur_pos[i].width * 0.75, cur_pos[i].height * 0.8]) #plt.colorbar(heatmap) figName = path( ) + "data/sunflow/fig/" + col + '_' + name + '_HeatMap_DVFS_' + numOrPercent + '_' + str( generation) plt.savefig(figName + ".eps", format='eps')
def main(): begin_time = time() # ============================= # Loading the verification data # ============================= vtype = {'assim': 'Assimilated proxies', 'verif':'Non-assimilated proxies'} nbperiods = len(verif_period) assim_dict = [dict() for x in range(nbperiods)] verif_dict = [dict() for x in range(nbperiods)] # loop over verification periods & load data in dictionaries for p in range(nbperiods): # Read the pickle files containing summary stats fname_assim = datadir_input+'/'+nexp+'/'+'verifProxy_'+str(verif_period[p][0])+'to'+str(verif_period[p][1])+\ '/reconstruction_eval_assimilated_proxy_summary.pckl' fname_verif = datadir_input+'/'+nexp+'/'+'verifProxy_'+str(verif_period[p][0])+'to'+str(verif_period[p][1])+\ '/reconstruction_eval_withheld_proxy_summary.pckl' infile_assim = open(fname_assim,'rb') assim_dict[p] = pickle.load(infile_assim) infile_assim.close() if os.path.isfile(fname_verif): infile_verif = open(fname_verif,'rb') verif_dict[p] = pickle.load(infile_verif) infile_verif.close() verif_data = True else: verif_data = False # get list of all proxy types in the assimilated/withheld data lst = [] for p in range(nbperiods): a_sites = list(assim_dict[p].keys()) lst = lst + list(set([item[0] for item in a_sites])) if verif_data: v_sites = list(verif_dict[p].keys()) lst = lst + list(set([item[0] for item in v_sites])) master_proxy_types = list(set([item for item in lst])) master_proxy_types.insert(0,'All') # ================== # Now creating plots # ================== if datadir_output != '.': figdir = datadir_output+'/VerifFigs' if not os.path.isdir(figdir): os.system('mkdir %s' % figdir) else: figdir = '.' # ============================================================================================================ # 1) Histograms of (recon, proxy) CORRELATION, CE across grand ensemble for all proxy types and per proxy type # ============================================================================================================ if make_plots_hist: # loop over proxy types for proxy in master_proxy_types: print('Proxies: %s' %proxy) fig = plt.figure(figsize=(12,8)) irow = 1 for v in list(vtype.keys()): # "assim" & "verif" proxies if v == 'verif' and not verif_data: break ax_master = fig.add_subplot(2,1,irow) # Turn off axis lines and ticks of the big subplot ax_master.tick_params(labelcolor=(1.,1.,1., 0.0), top='off', bottom='off', left='off', right='off') # Removes the white frame ax_master._frameon = False ax_master.set_title("%s\n" % vtype[v], fontsize=16, fontweight='bold') facecolor = fcolor[0] if v == 'assim': pos = [1,2,3] else: pos = [4,5,6] bins_corr = np.arange(-1.-binwidth/2, 1.+binwidth/2, binwidth) bins_ce = np.arange(-2.-binwidth/2, 1.+binwidth/2, binwidth) # 1) --- Correlation --- ax = fig.add_subplot(2,3,pos[0]) mean_stat = np.zeros([nbperiods]) std_stat = np.zeros([nbperiods]) prior_tmp = [] stat_comp = [] for p in range(nbperiods): # pick right dict and associate to "workdict" dname = v+'_dict' workdict = eval(dname) sitetag = list(workdict[p].keys()) if proxy == 'All': proxy_types = list(set([item[0] for item in sitetag])) else: proxy_types = proxy tmp = [workdict[p][k]['MCensCorr'] for k in sitetag if k[0] in proxy_types and np.abs(workdict[p][k]['PSMinfo']['corr'])>=r_crit] stat = [item for sublist in tmp for item in sublist] # flatten list of lists nbdata = len(stat) mean_stat[p] = np.mean(stat) std_stat[p] = np.std(stat) results, edges = np.histogram(stat, bins=bins_corr, normed=True) plt.bar(edges[:-1]+binwidth/2,results,binwidth,color=fcolor[p],alpha=alpha,linewidth=0,align="center") # kernel density estimation statv = np.asarray(stat) kde = sm.nonparametric.KDEUnivariate(statv) nbpts, = statv.shape if nbpts > 0: kde.fit(kernel='gau') plt.plot(kde.support,kde.density,color=fcolor[p],lw=2,label=str(verif_period[p][0])+' to '+str(verif_period[p][1])) stat_comp.append(stat) # Accumulate prior stat tmp = [workdict[p][k]['PriorMCensCorr'] for k in sitetag if k[0] in proxy_types and np.abs(workdict[p][k]['PSMinfo']['corr'])>=r_crit] prior_tmp.append([item for sublist in tmp for item in sublist]) # flatten list of lists # Kolmogorov-Smirnov significance testing of difference between distributions from both tested periods nbdist = len(stat_comp) if nbdist > 1: dist_test = stats.ks_2samp(stat_comp[0],stat_comp[1]) #print('Corr: %f %f' %(dist_test.statistic, dist_test.pvalue)) xmind,xmaxd,ymind,ymaxd = plt.axis() prior_corr = [item for sublist in prior_tmp for item in sublist] results, edges = np.histogram(prior_corr, bins=bins_corr, normed=True) plt.plot(edges[:-1]+binwidth,results,linewidth=1,ls='steps',color='black',label='Prior') plt.xlabel("Correlation",fontweight='bold') plt.ylabel("Probability density",fontweight='bold') ymin = 0.0 #ymax = 0.04; nbins = 4 #ymax = 0.05; nbins = 5 # for r_crit = 0.2 #ymax = 0.1; nbins = 5 #ymax = 2.0; nbins = 5 if proxy == 'All': ymax = 2.0; nbins = 5 else: ymax = ymaxd plt.axis((CORRrange[0],CORRrange[1],ymin,ymax)) plt.locator_params(axis = 'y', nbins = nbins) plt.legend(loc=2,fontsize=9,frameon=False,handlelength=1.2) xmin,xmax,ymin,ymax = plt.axis() xpos = xmin+0.025*(xmax-xmin) ypos = ymin+0.5*(ymax-ymin) for p in range(nbperiods): plt.text(xpos,ypos,'Mean = %s' %"{:.2f}".format(mean_stat[p]),fontsize=10,fontweight='bold',color=fcolor[p]) ypos = ypos-0.075*(ymax-ymin) if nbdist > 1: plt.text(xpos,ypos,' p-value = %s' %"{:.3f}".format(dist_test.pvalue),fontsize=9,fontweight='bold') ypos = ypos-0.075*(ymax-ymin) plt.text(xpos,ypos,'Mean = %s' %"{:.2f}".format(np.mean(prior_corr)),fontsize=10,fontweight='bold') # 2) --- CE --- ax = fig.add_subplot(2,3,pos[1]) mean_stat = np.zeros([nbperiods]) std_stat = np.zeros([nbperiods]) prior_tmp = [] stat_comp = [] for p in range(nbperiods): # pick right dict and associate to "workdict" dname = v+'_dict' workdict = eval(dname) sitetag = list(workdict[p].keys()) if proxy == 'All': proxy_types = list(set([item[0] for item in sitetag])) else: proxy_types = proxy tmp = [workdict[p][k]['MCensCE'] for k in sitetag if k[0] in proxy_types and np.abs(workdict[p][k]['PSMinfo']['corr'])>=r_crit] stat = [item for sublist in tmp for item in sublist] # flatten list of lists nbdata = len(stat) mean_stat[p] = np.mean(stat) std_stat[p] = np.std(stat) # Since CE is not bounded at the lower end, assign values smaller than 1st bin to value of 1st bin #stat = [bins[0] if x<bins[0] else x for x in stat] results, edges = np.histogram(stat, bins=bins_ce, normed=True) plt.bar(edges[:-1],results,binwidth,color=fcolor[p],alpha=alpha,linewidth=0) # kernel density estimation statv = np.asarray(stat) kde = sm.nonparametric.KDEUnivariate(statv) nbpts, = statv.shape if nbpts > 0: kde.fit(kernel='gau') plt.plot(kde.support,kde.density,color=fcolor[p],lw=2,label=str(verif_period[p][0])+' to '+str(verif_period[p][1])) stat_comp.append(stat) # Accumulate prior stat tmp = [workdict[p][k]['PriorMCensCE'] for k in sitetag if k[0] in proxy_types and np.abs(workdict[p][k]['PSMinfo']['corr'])>=r_crit] prior_tmp.append([item for sublist in tmp for item in sublist]) # flatten list of lists # Kolmogorov-Smirnov significance testing of difference between distributions from both tested periods nbdist = len(stat_comp) if nbdist > 1: dist_test = stats.ks_2samp(stat_comp[0],stat_comp[1]) #print('CE: %f %f' %(dist_test.statistic, dist_test.pvalue)) prior_ce = [item for sublist in prior_tmp for item in sublist] # Since CE is not bounded at the lower end, assign values smaller than 1st bin to value of 1st bin prior_ce = [bins_ce[0] if x<bins_ce[0] else x for x in prior_ce] results, edges = np.histogram(prior_ce, bins=bins_ce, normed=True) plt.plot(edges[:-1]+binwidth,results,linewidth=1,ls='steps',color='black',label='Prior') plt.xlabel("Coefficient of efficiency",fontweight='bold') plt.ylabel("Probability density",fontweight='bold') xmin,xmax,ymin,ymax = plt.axis() ymin = 0.0 #ymax = 0.45 #ymax = 0.1 # for r_crit = 0.2 #ymax = 0.5; nbins = 5 ymax = 12.0; nbins = 6 plt.axis((CErange[0],CErange[1],ymin,ymax)) plt.legend(loc=2,fontsize=9,frameon=False,handlelength=1.2) xmin,xmax,ymin,ymax = plt.axis() xpos = xmin+0.025*(xmax-xmin) ypos = ymin+0.5*(ymax-ymin) for p in range(nbperiods): plt.text(xpos,ypos,'Mean = %s' %"{:.2f}".format(mean_stat[p]),fontsize=10,fontweight='bold',color=fcolor[p]) ypos = ypos-0.075*(ymax-ymin) if nbdist > 1: plt.text(xpos,ypos,' p-value = %s' %"{:.3f}".format(dist_test.pvalue),fontsize=9,fontweight='bold') ypos = ypos-0.075*(ymax-ymin) plt.text(xpos,ypos,'Mean = %s' %"{:.2f}".format(np.mean(prior_ce)),fontsize=10,fontweight='bold') # 3) --- Change in CE from prior to posterior --- ax = fig.add_subplot(2,3,pos[2]) prior_tmp = [] stat_comp = [] for p in range(nbperiods): # pick right dict and associate to "workdict" dname = v+'_dict' workdict = eval(dname) sitetag = list(workdict[p].keys()) if proxy == 'All': proxy_types = list(set([item[0] for item in sitetag])) else: proxy_types = proxy tmpPost = [workdict[p][k]['MCensCE'] for k in sitetag if k[0] in proxy_types and np.abs(workdict[p][k]['PSMinfo']['corr'])>=r_crit] tmpPrior = [workdict[p][k]['PriorMCensCE'] for k in sitetag if k[0] in proxy_types and np.abs(workdict[p][k]['PSMinfo']['corr'])>=r_crit] statPost = [item for sublist in tmpPost for item in sublist] # flatten list of lists statPrior = [item for sublist in tmpPrior for item in sublist] # flatten list of lists # difference stat = [statPost[i]-statPrior[i] for i in range(len(statPost))] nbdata = len(stat) mean_stat = np.mean(stat) std_stat = np.std(stat) # % of positive change dCEplus = [stat[i] for i in range(len(stat)) if stat[i] > 0.0] if nbdata > 0: frac = int(float(len(dCEplus))/float(len(stat))*100.) fractiondCEplus = str(int('%d' % frac )) else: fractiondCEplus = 'n/a' print('CE_stats: period= ', str('%12s' %verif_period[p]), ' category= ', v, ':', str('%8s' %str(len(dCEplus))), str('%8s' %str(len(stat))), \ ' Fraction of +change:', fractiondCEplus, '%') results, edges = np.histogram(stat, bins=bins_ce, normed=True) leg = str(verif_period[p][0])+' to '+str(verif_period[p][1])+' : % +change='+str(fractiondCEplus) plt.bar(edges[:-1],results,binwidth,color=fcolor[p],alpha=alpha,linewidth=0) # kernel density estimation statv = np.asarray(stat) kde = sm.nonparametric.KDEUnivariate(statv) nbpts, = statv.shape if nbpts > 0: kde.fit(kernel='gau') plt.plot(kde.support,kde.density,color=fcolor[p],lw=2,label=leg) stat_comp.append(stat) # Kolmogorov-Smirnov significance testing of difference between distributions from both periods nbdist = len(stat_comp) if nbdist > 1: dist_test = stats.ks_2samp(stat_comp[0],stat_comp[1]) #print('deltaCE: %f %f' %(dist_test.statistic, dist_test.pvalue)) plt.xlabel("Change in coefficient of efficiency",fontweight='bold') plt.ylabel("Probability density",fontweight='bold') xmin,xmax,ymin,ymax = plt.axis() ymin = 0.0 ymax = 8.0; nbins = 5 plt.axis((CEchangerange[0],CEchangerange[1],ymin,ymax)) plt.legend(loc=2,fontsize=9,frameon=False,handlelength=1.2) if nbdist > 1: xmin,xmax,ymin,ymax = plt.axis() xpos = xmin+0.025*(xmax-xmin) ypos = ymin+0.75*(ymax-ymin) plt.text(xpos,ypos,' p-value = %s' %"{:.3f}".format(dist_test.pvalue),fontsize=9,fontweight='bold') irow = irow + 1 fig.tight_layout() if proxy == 'All': proxy_tag = 'Allproxies' else: proxy_tag = proxy.replace(' ','_') plt.savefig('%s/%s_verify_proxy_hist_corr_ce_%s.png' % (figdir,nexp,proxy_tag),bbox_inches='tight') if make_pdfs: plt.savefig('%s/%s_verify_proxy_hist_corr_ce_%s.pdf' % (figdir,nexp,proxy_tag),bbox_inches='tight',dpi=300, format='pdf') plt.close() # ========================================================================== # PART 2: MAPS of site-based verification metrics -------------------------- # ========================================================================== if make_plots_maps: #water = '#9DD4F0' #continents = '#888888' water = '#D3ECF8' continents = '#F2F2F2' # Loop over proxy sets (assim vs verif) for v in list(vtype.keys()): # Loop over verification periods for p in range(nbperiods): # pick right dict and associate to "workdict" dname = v+'_dict' workdict = eval(dname) sites = list(workdict[p].keys()) proxy_types = list(set([item[0] for item in sitetag])) verif_period_label = str(verif_period[p][0])+'-'+str(verif_period[p][1]) proxy_types = [] for sitetag in sites: sitetype = sitetag[0] if sitetype not in proxy_types: proxy_types.append(sitetype) proxy_types = sorted(proxy_types) m = Basemap(projection='robin', lat_0=0, lon_0=0,resolution='l', area_thresh=700.0); latres = 20.; lonres=40. # GLOBAL x, y = m(0.,0.) l = [] for sitetype in sorted(proxy_types): l.append(m.scatter(x,y,35,c='white',marker=proxy_verif[sitetype],edgecolor='black',linewidth='1')) # =========================================================================== # 2) Maps with proxy sites plotted with dots colored according to correlation # =========================================================================== verif_metric = 'Correlation' mapcolor = plt.cm.seismic cbarfmt = '%4.1f' fmin = -1.0; fmax = 1.0 fval = np.linspace(fmin, fmax, 100); fvalc = np.linspace(0, fmax, 101); scaled_colors = mapcolor(fvalc) cmap, norm = from_levels_and_colors(levels=fval, colors=scaled_colors, extend='both') cbarticks=np.linspace(fmin,fmax,11) fig = plt.figure(figsize=[8,5]) #ax = fig.add_axes([0.1,0.1,0.8,0.8]) m = Basemap(projection='robin', lat_0=0, lon_0=0,resolution='l', area_thresh=700.0); latres = 20.; lonres=40. # GLOBAL m.drawmapboundary(fill_color=water) m.drawcoastlines(linewidth=0.5); m.drawcountries(linewidth=0.5) m.fillcontinents(color=continents,lake_color=water) m.drawparallels(np.arange(-80.,81.,latres),linewidth=0.5) m.drawmeridians(np.arange(-180.,181.,lonres),linewidth=0.5) # loop over proxy sites for sitetag in sites: sitetype = sitetag[0] sitename = sitetag[1] sitemarker = proxy_verif[sitetype] lat = workdict[p][sitetag]['lat'] lon = workdict[p][sitetag]['lon'] x, y = m(lon,lat) Gplt = m.scatter(x,y,35,c=workdict[p][sitetag]['MeanCorr'],marker=sitemarker,edgecolor='black',linewidth='1',zorder=4,cmap=cmap,norm=norm) cbar = m.colorbar(Gplt,location='right',pad="2%",size="2%",ticks=cbarticks,format=cbarfmt,extend='both') cbar.outline.set_linewidth(1.0) cbar.set_label('%s' % verif_metric,size=11,weight='bold') cbar.ax.tick_params(labelsize=10) plt.title('Period: '+verif_period_label+' : '+vtype[v],fontweight='bold') plt.legend(l,proxy_types, scatterpoints=1, loc='lower center', bbox_to_anchor=(0.5, -0.30), ncol=3, fontsize=9) plt.savefig('%s/%s_verify_proxy_map_%s_corr_%s.png' % (figdir,nexp,v,verif_period_label),bbox_inches='tight') if make_pdfs: plt.savefig('%s/%s_verify_proxy_map_%s_corr_%s.pdf' % (figdir,nexp,v,verif_period_label),bbox_inches='tight', dpi=300, format='pdf') plt.close() # =========================================================================== # 3) Maps with proxy sites plotted with dots colored according to CE # =========================================================================== verif_metric = 'Coefficient of efficiency' mapcolor = plt.cm.seismic cbarfmt = '%4.1f' fmin = -1.0; fmax = 1.0 fval = np.linspace(fmin, fmax, 100); fvalc = np.linspace(0, fmax, 101); scaled_colors = mapcolor(fvalc) cmap, norm = from_levels_and_colors(levels=fval, colors=scaled_colors, extend='both') cbarticks=np.linspace(fmin,fmax,11) # Prior & Posterior fig = plt.figure(figsize=[8,10]) dplot = {'Prior':'PriorMeanCE', 'Posterior':'MeanCE'} irow = 1 for dd in list(dplot.keys()): ax = fig.add_subplot(2,1,irow) m = Basemap(projection='robin', lat_0=0, lon_0=0,resolution='l', area_thresh=700.0); latres = 20.; lonres=40. # GLOBAL m.drawmapboundary(fill_color=water) m.drawcoastlines(linewidth=0.5); m.drawcountries(linewidth=0.5) m.fillcontinents(color=continents,lake_color=water) m.drawparallels(np.arange(-80.,81.,latres),linewidth=0.5) m.drawmeridians(np.arange(-180.,181.,lonres),linewidth=0.5) # loop over proxy sites for sitetag in sites: sitetype = sitetag[0] sitename = sitetag[1] sitemarker = proxy_verif[sitetype] lat = workdict[p][sitetag]['lat'] lon = workdict[p][sitetag]['lon'] x, y = m(lon,lat) plot_var = dplot[dd] Gplt = m.scatter(x,y,35,c=workdict[p][sitetag][plot_var],marker=sitemarker,edgecolor='black',linewidth='1',zorder=4,cmap=cmap,norm=norm) cbar = m.colorbar(Gplt,location='right',pad="2%",size="2%",ticks=cbarticks,format=cbarfmt,extend='both') cbar.outline.set_linewidth(1.0) cbar.set_label('%s' % verif_metric,size=11,weight='bold') cbar.ax.tick_params(labelsize=10) if irow == 1: plt.title('Period: '+verif_period_label+'\n\n'+vtype[v]+' : '+ dd,fontweight='bold') else: plt.title(vtype[v]+' : '+ dd,fontweight='bold') irow = irow + 1 plt.legend(l,proxy_types, scatterpoints=1, loc='lower center', bbox_to_anchor=(0.5, -0.30), ncol=3, fontsize=9) fig.tight_layout() plt.savefig('%s/%s_verify_proxy_map_%s_ce_%s.png' % (figdir,nexp,v,verif_period_label),bbox_inches='tight') if make_pdfs: plt.savefig('%s/%s_verify_proxy_map_%s_ce_%s.pdf' % (figdir,nexp,v,verif_period_label),bbox_inches='tight', dpi=300, format='pdf') plt.close() # ============================================================================ # 4) Maps with proxy sites plotted with dots colored according to change in CE # ============================================================================ # Change in CE from Prior to Posterior fig = plt.figure(figsize=[8,5]) m = Basemap(projection='robin', lat_0=0, lon_0=0,resolution='l', area_thresh=700.0); latres = 20.; lonres=40. # GLOBAL m.drawmapboundary(fill_color=water) m.drawcoastlines(linewidth=0.5); m.drawcountries(linewidth=0.5) m.fillcontinents(color=continents,lake_color=water) m.drawparallels(np.arange(-80.,81.,latres),linewidth=0.5) m.drawmeridians(np.arange(-180.,181.,lonres),linewidth=0.5) # loop over proxy sites for sitetag in sites: sitetype = sitetag[0] sitename = sitetag[1] sitemarker = proxy_verif[sitetype] lat = workdict[p][sitetag]['lat'] lon = workdict[p][sitetag]['lon'] x, y = m(lon,lat) plot_var = workdict[p][sitetag]['MeanCE'] - workdict[p][sitetag]['PriorMeanCE'] Gplt = m.scatter(x,y,35,c=plot_var,marker=sitemarker,edgecolor='black',linewidth='1',zorder=4,cmap=cmap,norm=norm) cbar = m.colorbar(Gplt,location='right',pad="2%",size="2%",ticks=cbarticks,format=cbarfmt,extend='both') cbar.outline.set_linewidth(1.0) cbar.set_label('Change in coefficient of efficiency',size=11,weight='bold') cbar.ax.tick_params(labelsize=10) plt.title('Period: '+verif_period_label+' : '+vtype[v],fontweight='bold') plt.legend(l,proxy_types, scatterpoints=1, loc='lower center', bbox_to_anchor=(0.5, -0.30), ncol=3, fontsize=9) fig.tight_layout() plt.savefig('%s/%s_verify_proxy_map_%s_delta_ce_%s.png' % (figdir,nexp,v,verif_period_label),bbox_inches='tight') if make_pdfs: plt.savefig('%s/%s_verify_proxy_map_%s_delta_ce_%s.pdf' % (figdir,nexp,v,verif_period_label),bbox_inches='tight', dpi=300, format='pdf') plt.close() # ========================================================================================== # 5) Maps with proxy sites plotted with dots colored according to ensemble calibration ratio # ========================================================================================== verif_metric = 'Ensemble calibration' mapcolor = plt.cm.seismic cbarfmt = '%4.1f' fmin = 0.0; fmax = 2.0 fval = np.linspace(fmin, fmax, 100); fvalc = np.linspace(0, 1, 100); scaled_colors = mapcolor(fvalc) cmap, norm = from_levels_and_colors(levels=fval, colors=scaled_colors, extend='max') cbarticks=np.linspace(fmin,fmax,11) # Prior & Posterior fig = plt.figure(figsize=[8,10]) dplot = {'Prior':'PriorMeanCalRatio', 'Posterior':'MeanCalRatio'} irow = 1 for dd in list(dplot.keys()): ax = fig.add_subplot(2,1,irow) m = Basemap(projection='robin', lat_0=0, lon_0=0,resolution='l', area_thresh=700.0); latres = 20.; lonres=40. # GLOBAL m.drawmapboundary(fill_color=water) m.drawcoastlines(linewidth=0.5); m.drawcountries(linewidth=0.5) m.fillcontinents(color=continents,lake_color=water) m.drawparallels(np.arange(-80.,81.,latres),linewidth=0.5) m.drawmeridians(np.arange(-180.,181.,lonres),linewidth=0.5) # loop over proxy sites for sitetag in sites: sitetype = sitetag[0] sitename = sitetag[1] sitemarker = proxy_verif[sitetype] lat = workdict[p][sitetag]['lat'] lon = workdict[p][sitetag]['lon'] x, y = m(lon,lat) plot_var = dplot[dd] Gplt = m.scatter(x,y,35,c=workdict[p][sitetag][plot_var],marker=sitemarker,edgecolor='black',linewidth='1',zorder=4,cmap=cmap,norm=norm) cbar = m.colorbar(Gplt,location='right',pad="2%",size="2%",ticks=cbarticks,format=cbarfmt,extend='max') cbar.outline.set_linewidth(1.0) cbar.set_label('%s' % verif_metric,size=11,weight='bold') cbar.ax.tick_params(labelsize=10) if irow == 1: plt.title('Period: '+verif_period_label+'\n\n'+vtype[v]+' : '+ dd,fontweight='bold') else: plt.title(vtype[v]+' : '+ dd,fontweight='bold') irow = irow + 1 plt.legend(l,proxy_types, scatterpoints=1, loc='lower center', bbox_to_anchor=(0.5, -0.30), ncol=3, fontsize=9) fig.tight_layout() plt.savefig('%s/%s_verify_proxy_map_%s_EnsCal_%s.png' % (figdir,nexp,v,verif_period_label),bbox_inches='tight') if make_pdfs: plt.savefig('%s/%s_verify_proxy_map_%s_EnsCal_%s.pdf' % (figdir,nexp,v,verif_period_label),bbox_inches='tight', dpi=300, format='pdf') plt.close() # ========================================================================== # PART 3: Plots of individual time series of proxy records ---------------- # ========================================================================== if make_plots_individual_sites: assimilated_sites = sorted(assim_dict[p].keys()) withheld_sites = verif_dict[p].keys() if nbperiods > 1: period_bnds = [item[0] for item in verif_period] else: period_bnds = verif_period[0] # Loop over sites siteCount = 0 for site in assimilated_sites: sitename = site[0].replace(' ','_')+'_'+site[1].replace(' ','_') AssimPriorR = np.zeros([nbperiods],dtype=float) AssimPriorCE = np.zeros([nbperiods],dtype=float) AssimReconR = np.zeros([nbperiods],dtype=float) AssimReconCE = np.zeros([nbperiods],dtype=float) VerifPriorR = np.zeros([nbperiods],dtype=float) VerifPriorCE = np.zeros([nbperiods],dtype=float) VerifReconR = np.zeros([nbperiods],dtype=float) VerifReconCE = np.zeros([nbperiods],dtype=float) # setup the figure fig, ax = plt.subplots(2,1, figsize=(10,6)) plt.subplots_adjust(bottom=0.35,hspace=0.4) # loop over periods for p in range(nbperiods): # assimilated -- try: assimCE = '{:7.2f}'.format(np.mean(assim_dict[p][site]['MCensCE'])) except KeyError: assimCE = 'n/a' # withheld -- try: verifCE = '{:7.2f}'.format(np.mean(verif_dict[p][site]['MCensCE'])) except KeyError: verifCE = 'n/a' print('{:120}'.format(sitename), '{:12}'.format(str(verif_period[p])), '{:7}'.format(str(assimCE)), '{:7}'.format(str(verifCE))) ts_years_assim = assim_dict[p][site]['ts_years'] ts_obs_assim = assim_dict[p][site]['ts_ProxyValues'] ts_prior_m_assim = assim_dict[p][site]['ts_MeanPrior'] ts_prior_v_assim = assim_dict[p][site]['ts_SpreadPrior'] ts_recon_m_assim = assim_dict[p][site]['ts_MeanRecon'] ts_recon_v_assim = assim_dict[p][site]['ts_SpreadRecon'] ts_years_plot = np.linspace(np.min(ts_years_assim),np.max(ts_years_assim),(np.max(ts_years_assim)-np.min(ts_years_assim))+1) ts_prior_m_plot = np.zeros(ts_years_plot.shape); ts_prior_m_plot[:] = np.nan ts_recon_m_plot = np.zeros(ts_years_plot.shape); ts_recon_m_plot[:] = np.nan ts_prior_m_plot[np.in1d(ts_years_plot,ts_years_assim)] = ts_prior_m_assim ts_recon_m_plot[np.in1d(ts_years_plot,ts_years_assim)] = ts_recon_m_assim AssimPriorR[p] = '{:.2f}'.format(np.mean(assim_dict[p][site]['PriorMCensCorr'])) AssimReconR[p] = '{:.2f}'.format(np.mean(assim_dict[p][site]['MCensCorr'])) AssimPriorCE[p] = '{:.2f}'.format(np.mean(assim_dict[p][site]['PriorMCensCE'])) AssimReconCE[p] = '{:.2f}'.format(np.mean(assim_dict[p][site]['MCensCE'])) # make the upper subplot ax[0].plot(ts_years_assim,ts_obs_assim, '.', color='#5CB8E6', label='Proxy values') ax[0].plot(ts_years_plot,ts_prior_m_plot,'-k',lw=3,alpha=0.5, label='Prior') ax[0].plot(ts_years_plot,ts_recon_m_plot,'-r',lw=2,alpha=0.75, label='Analysis') stitle = str(site)+'\nAssimilated' ax[0].set_title(stitle,fontsize=10) ax[0].set_ylabel('Proxy value') xmin,xmax,ymin,ymax = ax[0].axis() if nbperiods > 1: for bndy in period_bnds: if bndy > xmin: ax[0].plot([bndy,bndy],[ymin,ymax],':k',lw=2) # --- # records are not always in the "withheld" (verif) set try: ts_years_verif = verif_dict[p][site]['ts_years'] ts_obs_verif = verif_dict[p][site]['ts_ProxyValues'] ts_prior_m_verif = verif_dict[p][site]['ts_MeanPrior'] ts_prior_v_verif = verif_dict[p][site]['ts_SpreadPrior'] ts_recon_m_verif = verif_dict[p][site]['ts_MeanRecon'] ts_recon_v_verif = verif_dict[p][site]['ts_SpreadRecon'] VerifPriorR[p] = '{:.2f}'.format(np.mean(verif_dict[p][site]['PriorMCensCorr'])) VerifReconR[p] = '{:.2f}'.format(np.mean(verif_dict[p][site]['MCensCorr'])) VerifPriorCE[p] = '{:.2f}'.format(np.mean(verif_dict[p][site]['PriorMCensCE'])) VerifReconCE[p] = '{:.2f}'.format(np.mean(verif_dict[p][site]['MCensCE'])) except KeyError: ts_years_verif = assim_dict[p][site]['ts_years'] ts_obs_verif = assim_dict[p][site]['ts_ProxyValues'] ts_prior_m_verif = np.zeros(ts_years_verif.shape); ts_prior_m_verif[:] = np.nan ts_prior_v_verif = np.zeros(ts_years_verif.shape); ts_prior_v_verif[:] = np.nan ts_recon_m_verif = np.zeros(ts_years_verif.shape); ts_recon_m_verif[:] = np.nan ts_recon_v_verif = np.zeros(ts_years_verif.shape); ts_recon_m_verif[:] = np.nan VerifPriorR[p] = '{:.2f}'.format(np.nan) VerifReconR[p] = '{:.2f}'.format(np.nan) VerifPriorCE[p] = '{:.2f}'.format(np.nan) VerifReconCE[p] = '{:.2f}'.format(np.nan) ts_years_plot = np.linspace(np.min(ts_years_verif),np.max(ts_years_verif),(np.max(ts_years_verif)-np.min(ts_years_verif))+1) ts_prior_m_plot = np.zeros(ts_years_plot.shape); ts_prior_m_plot[:] = np.nan ts_recon_m_plot = np.zeros(ts_years_plot.shape); ts_recon_m_plot[:] = np.nan ts_prior_m_plot[np.in1d(ts_years_plot,ts_years_verif)] = ts_prior_m_verif ts_recon_m_plot[np.in1d(ts_years_plot,ts_years_verif)] = ts_recon_m_verif # make the lower subplot if p == 0: ax[1].plot(ts_years_verif,ts_obs_verif, '.', color='#5CB8E6',label='Proxy data') ax[1].plot(ts_years_plot,ts_prior_m_plot,'-k',lw=3,alpha=0.5,label='Prior') ax[1].plot(ts_years_plot,ts_recon_m_plot,'-r',lw=2,alpha=0.75,label='Analysis') else: ax[1].plot(ts_years_verif,ts_obs_verif, '.', color='#5CB8E6') ax[1].plot(ts_years_plot,ts_prior_m_plot,'-k',lw=3,alpha=0.5) ax[1].plot(ts_years_plot,ts_recon_m_plot,'-r',lw=2,alpha=0.75) ax[1].set_title('Withheld',fontsize=10) ax[1].set_ylabel('Proxy value') ax[1].set_xlabel('Years (CE)') ax[1].legend(loc='upper left',bbox_to_anchor=(.85,-.2),handlelength=.2,fontsize=10) xmin,xmax,ymin,ymax = ax[1].axis() if nbperiods > 1: for bndy in period_bnds: if bndy > xmin: ax[1].plot([bndy,bndy],[ymin,ymax],':k',lw=2) # --- Annotate with summary stats in table format --- plt.text(.025,-.62, 'Summary\nstatistics',transform=ax[1].transAxes,fontsize=10) header_col_labels = verif_period header = plt.table(cellText=[[' ']*nbperiods],colWidths=[0.2]*nbperiods, colLabels=header_col_labels, loc='bottom',bbox=[0.15,-0.65,0.2*nbperiods,0.25]) cellDict = header.get_celld() cells = cellDict.keys() for c in cells: cellDict[c].set_width(0.2) row_labels = ['Prior R', 'Posterior R', 'Prior CE', 'Posterior CE'] indPrior = [i+1 for i,s in enumerate(row_labels) if 'Prior' in s] indPost = [i+1 for i,s in enumerate(row_labels) if 'Posterior' in s] categories = ['Assimilated', 'Withheld'] col_labels = [] for i in range(nbperiods): col_labels.extend(categories) table_vals = np.zeros([4,nbperiods*2]) for i in range(nbperiods): j = i*2 table_vals[0,j] = AssimPriorR[i] table_vals[0,j+1] = VerifPriorR[i] table_vals[1,j] = AssimReconR[i] table_vals[1,j+1] = VerifReconR[i] table_vals[2,j] = AssimPriorCE[i] table_vals[2,j+1] = VerifPriorCE[i] table_vals[3,j] = AssimReconCE[i] table_vals[3,j+1] = VerifReconCE[i] the_table = plt.table(cellText=table_vals,colWidths=[0.1]*5, rowLabels=row_labels, colLabels=col_labels, loc='bottom',bbox=[0.15,-1.29,0.2*nbperiods,0.75]) cellDict = the_table.get_celld() cells = cellDict.keys() for c in cells: cellDict[c].set_width(0.0999) cellsPrior = [item for item in cells if item[0] in indPrior] for c in cellsPrior: cellDict[c].set_facecolor('lightgray') cellsPost = [item for item in cells if item[0] in indPost] for c in cellsPost: cellDict[c].set_facecolor('darkgray') figname = figdir+'/'+nexp+'_verify_proxy_'+sitename plt.savefig(figname+'.png') plt.close() end_time = time() - begin_time print('=======================================================') print('All completed in %s mins' %str(end_time/60.0)) print('=======================================================')
def nostradamus_rain(in_msg): if in_msg.datetime is None: in_msg.get_last_SEVIRI_date() if in_msg.end_date is None: in_msg.end_date = in_msg.datetime #in_msg.end_date = in_msg.datetime + timedelta(15) delta = timedelta(minutes=15) # automatic choise of the FULL DISK SERVICE Meteosat satellite if in_msg.datetime < datetime(2008, 5, 13, 0, 0): # before 13.05.2008 only nominal MSG1 (meteosat8), no Rapid Scan Service yet sat_nr = "08" elif in_msg.datetime < datetime(2013, 2, 27, 9, 0): # 13.05.2008 ... 27.02.2013 sat_nr = "09" # MSG-2 (meteosat9) became nominal satellite, MSG-1 (meteosat8) started RSS elif in_msg.datetime < datetime(2018, 3, 9, 0, 0): # 27.02.2013 9:00UTC ... 09.03.2013 sat_nr = "10" # MSG-3 (meteosat10) became nominal satellite, MSG-2 started RSS (MSG1 is backup for MSG2) else: sat_nr = "11" print ("... work with Meteosat"+str(sat_nr)) print ("") if in_msg.verbose: print ('*** Create plots for ') print (' Satellite/Sensor: ' + in_msg.sat_str()) print (' Satellite number: ' + in_msg.sat_nr_str() +' // ' +str(in_msg.sat_nr)) print (' Satellite instrument: ' + in_msg.instrument) print (' Start Date/Time: '+ str(in_msg.datetime)) print (' End Date/Time: '+ str(in_msg.datetime)) print (' Areas: ', in_msg.areas) for area in in_msg.plots.keys(): print (' plots['+area+']: ', in_msg.plots[area]) #print (' parallax_correction: ', in_msg.parallax_correction) #print (' reader level: ', in_msg.reader_level) ## read in all the constants files print('=================================') print('*** load the constant fields (radar mask, viewing geometry, and land/sea mask plus surface elevation)') global_radar_mask, global_vg, global_ls_ele = load_constant_fields(sat_nr) ############################################### ## load the mlp for the precip detection (pd) # ############################################### if in_msg.model == 'mlp': dir_start_pd= './models/precipitation_detection/mlp/2hl_100100hu_10-7alpha_log/' dir_start_rr= './models/precipitation_rate/mlp/2hl_5050hu_10-2alpha_log/' if not in_msg.read_from_netCDF: clf_pd = joblib.load(dir_start_pd+'clf.pkl') scaler_pd = joblib.load(dir_start_pd+'scaler.pkl') feature_list_pd = joblib.load(dir_start_pd+'featurelist.pkl') thres_pd=np.load(dir_start_pd+'opt_orig_posteriorprobab_thres.npy') ######################################### ## load the mlp for the rain rates (rr) # ######################################### reg_rr = joblib.load(dir_start_rr+'reg.pkl') scaler_rr = joblib.load(dir_start_rr+'scaler.pkl') feature_list_rr = joblib.load(dir_start_rr+'featurelist.pkl') #################################### ## load the reference sets for a climatological probab matching (pm) if requested #################################### if in_msg.probab_match: # load in the ref data sets created with the script: rr_probab_matching_create_refset.ipynb ody_rr_ref=np.load(dir_start_rr+'pm_valid_data_ody_rr_ref.npy') pred_rr_ref=np.load(dir_start_rr+'pm_valid_data_pred_rr_ref.npy') # initialize processed RGBs plots_done={} time_slot = copy.deepcopy(in_msg.datetime) while time_slot <= in_msg.end_date: print('... processing for time: ', time_slot) ################################################ ## CHOOSE THE SETUP (time_slot, area, model) ################################################ ########################## ## LOAD THE NEEDED INPUTS ########################## if not in_msg.read_from_netCDF: ## read observations at the specific time print('=================================') print('*** load the time slot specific fields with in_msg.parallax_gapfilling:', in_msg.parallax_gapfilling) global_radar, global_sat, global_nwc, global_cth, global_hsaf = load_input(sat_nr, time_slot, in_msg.parallax_gapfilling, read_HSAF=in_msg.read_HSAF) # def load_input(sat_nr, time_slot, par_fill, read_HSAF=True): else: print('read Odyssey radar composite') from mpop.satellites import GeostationaryFactory global_radar = GeostationaryFactory.create_scene("odyssey", "", "radar", time_slot) global_radar.load(['RATE']) print(global_radar) print('=========================') for area in in_msg.areas: print ("================================") print ("*** PROCESSING FOR AREA: "+area) # declare "precipitation detection" and "rainrate dictionary", the applied model (e.g. MLP) is used as key pd = {} rr = {} plots_done[area]=[] if in_msg.read_from_netCDF: # reproject Odyssey radar mask to area of interest #radar_mask = global_radar_mask.project(area, precompute=True) data_radar = global_radar.project(area, precompute=True) # radar mask to see where odyssey ground truth exists mask_r = data_radar['RATE-MASK'].data.data==False rr['ody'] = copy.deepcopy(data_radar['RATE'].data.data) # do not trust values below 0.3 & above 130 -> do not consider it as rain and set all values to 0 rr['ody'][np.logical_or(rr['ody'] < 0.3,rr['ody'] >= 130.0)] = 0.0 print (rr['ody'].min(), rr['ody'].max(), rr['ody'].shape, type(rr['ody'])) from netCDF4 import Dataset # read from file outdir_netCDF = time_slot.strftime('/data/COALITION2/database/meteosat/nostradamus_RR/%Y/%m/%d/') file_netCDF = time_slot.strftime('MSG_rr-'+in_msg.model+'-'+area+'_%Y%m%d%H%M.nc') print ("*** read precip prediction from", outdir_netCDF+"/"+file_netCDF) ncfile = Dataset(outdir_netCDF+"/"+file_netCDF,'r') rr_tmp = ncfile.variables['rainfall_rate'][:,:] ### now, we read radar data directly from odyssey file #rr['ody'] = ncfile.variables['rainfall_rate (odyssey)'][:,:] #print (rr['ody'].min(), rr['ody'].max(), rr['ody'].shape, type(rr['ody'])) ### now, we read radar mask directly from odyssey file #mask_r = ncfile.variables['odyssey_mask'][:,:] #print ("... convert mask_r (1, 0) from int to bolean (True, False)") #mask_r = (mask_r == 1) # create fake mask_h (where rainfall is larger than 0 mm/h) mask_h = rr_tmp>0 pd[in_msg.model] = rr_tmp>0 rr_tmp = rr_tmp.flatten() # remove 0 entries rr_tmp = rr_tmp [ rr_tmp != 0 ] if False: import matplotlib.pyplot as plt #fig = plt.figure() fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(6,6)) plt.subplot(2, 1, 1) plt.imshow(mask_h) #plt.colorbar() plt.subplot(2, 1, 2) plt.imshow(mask_r) #plt.colorbar() fig.savefig("mask_h_mask_r_netCDF.png") print("... display mask_h_mask_r_netCDF.png &") #plt.show() #quit() else: ## project all data to the desired projection radar_mask, vg, ls_ele, data_radar, data_sat, data_nwc, data_cth, data_hsaf = \ project_data(area, global_radar_mask, global_vg, global_ls_ele, global_radar, global_sat, global_nwc, global_cth, global_hsaf, read_HSAF=in_msg.read_HSAF) ########################################################### ## SINGLE TIME SLOT TO CARRY OUT A FULL RAIN RATE RETRIEVAL ########################################################### # preprocess the data # mask_h: field indicating where NWCSAF products are available & thus where predictions are carried out: True if NWCSAF products available # mask_r: field indicating where radar products are available: True if radar product is available # mask_rnt: field indicating where radar product available but not trustworthy: i.e. in threshold_mask, 0<rr<0.3, rr>130 overlaid: True if radar product is NOT trustworthy all_data, all_data_names, mask_h, mask_r, mask_rnt, rr['ody'], rr['hsaf'], lon, lat = \ pd_rr_preprocess_data_single_scene( area, time_slot, radar_mask, vg, ls_ele, data_radar, data_sat, data_nwc, data_cth, data_hsaf, in_msg.parallax_gapfilling, 'rr', read_HSAF=in_msg.read_HSAF) #pd_rr_preprocess_data_single_scene( sat_nr, area, time_slot, 'nearest', 'rr', read_HSAF=False) if False: import matplotlib.pyplot as plt #fig = plt.figure() fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(6,6)) plt.subplot(2, 1, 1) plt.imshow(mask_h) #plt.colorbar() plt.subplot(2, 1, 2) plt.imshow(mask_r) #plt.colorbar() fig.savefig("mask_h_mask_r.png") print("... display mask_h_mask_r.png &") #plt.show() #quit() del rr['hsaf'] # since not actually needed in this script # project all data to desired projection # ... print('... predictions at ' + str(mask_h.sum())+' out of ' +str(mask_h.flatten().shape[0])+ ' points') #################################### ## precip detection #################################### # create y_pd, y_hsaf_pd, X_raw_pd y_pd_vec, y_hsaf_pd_vec, X_raw, feature_list = pd_rr_create_y_yhsaf_Xraw( all_data, all_data_names, 'pd', cut_precip=False ) del y_pd_vec, y_hsaf_pd_vec # (since not actually ever needed in this script) if in_msg.remove_vg==True: print('... remove viewing geometry from predictors') feature_list = np.append(feature_list[:6],feature_list[8:]) X_raw = np.hstack([X_raw[:,:6],X_raw[:,8:]]) print(' new X_raw.shape:', X_raw.shape) feature_list # check features if np.array_equal(feature_list, feature_list_pd): print('OK, input features correspond to input features required by the loaded model') else: print('ATTENTION, input features do not correspond to input features required by the loaded model') quit() # create X_pd X_pd=scaler_pd.transform(X_raw) # create final precip detection fields: opera + hsaf pd['ody']=rr['ody']>=0.3 # make precip detection predictions print ("*** make precip detection predictions") pd_probab = clf_pd.predict_proba(X_pd)[:,1] # probab precip balanced classes pd_vec_h = pd_probab>=thres_pd pd[in_msg.model] = np.zeros(lon.shape,dtype=bool) pd[in_msg.model][mask_h] = pd_vec_h #################################### ## rain rate on above identified precipitating pixels #################################### # reduce X_raw to the points where rain was predicted by the mlp X_raw= X_raw[pd_vec_h,:] # check, if read features correspond to the trained model if np.array_equal(feature_list, feature_list_rr): print('OK, input features correspond to input features required by the loaded model') else: print('ATTENTION, input features do not correspond to input features required by the loaded model') quit() # create X_rr X_rr=scaler_rr.transform(X_raw) # rain rate prediction at places where precip detected by mlp rr_tmp=reg_rr.predict(X_rr) # carry out a probability machting if requested if in_msg.probab_match: print("... do probability matching for:", in_msg.model) pm_str = str(in_msg.model)+'_pm' rr_tmp_pm = probab_match_rr_refprovide(ody_rr_ref,pred_rr_ref,rr_tmp) #rr[pm_str] = np.zeros_like(lon) rr[pm_str] = np.zeros_like(rr['ody']) # also casts the type float rr[pm_str][pd[in_msg.model]]=rr_tmp_pm print("... probability matching done for:", in_msg.model) # copy rainrate data to the final place # replace all prediction lower than precipitation detection threshold with threhold rain rate rr_tmp[rr_tmp<0.3]=0.3 # correct upward all too low predictions (i.e. the ones below the precip detection threshold) rr[in_msg.model] = np.zeros_like(rr['ody']) rr[in_msg.model][pd[in_msg.model]]=rr_tmp ##################################### ## SAVE RESULT AS NETCDF ##################################### if area in in_msg.save_netCDF and (not in_msg.read_from_netCDF): outdir_netCDF = time_slot.strftime(in_msg.outdir_netCDF) file_netCDF = time_slot.strftime(in_msg.file_netCDF) file_netCDF = file_netCDF.replace("%(area)s", area) file_netCDF = file_netCDF.replace("%(model)s", in_msg.model) #save_RR_as_netCDF(outdir_netCDF, file_netCDF, rr[in_msg.model], save_rr_ody=True, rr_ody=rr['ody'], save_ody_mask=True, ody_mask=mask_r, zlib=True) save_RR_as_netCDF(outdir_netCDF, file_netCDF, rr[in_msg.model]) ##################################### ## SINGLE TIME SLOT TO DRAW THE MAPS ##################################### print ("*** start to create plots") #################################### ## plot precip detection #################################### if 'pdMlp' in in_msg.plots[area]: mask_rt = np.logical_and(mask_r, mask_rnt==False) # trusted radar i.e. True where I have a trustworthy radar product available mod_ss = [in_msg.model] + ['ody'] # ver for verification; ver={} for x in mod_ss: ver[x]=np.zeros_like(lon) # sat: no ver[x][pd[x]>0] = 1 # sat: yes ver[x][np.logical_and(ver[x]==0,mask_rnt)] = 2 # sat: no (rad clutter) ver[x][np.logical_and(ver[x]==1,mask_rnt)] = 3 # sat: yes (rad clutter) ver[x][np.logical_and(mask_rt,np.logical_and(pd[x]==1,pd['ody']==1))] = 4 # hit ver[x][np.logical_and(mask_rt,np.logical_and(pd[x]==1,pd['ody']==0))] = 5 # false alarm ver[x][np.logical_and(mask_rt,np.logical_and(pd[x]==0,pd['ody']==0))] = 6 # correct reject ver[x][np.logical_and(mask_rt,np.logical_and(pd[x]==0,pd['ody']==1))] = 7 # miss # define colorkey v_pd=np.array([-0.5,0.5,1.5,2.5,3.5,4.5,5.5,6.5,7.5]) cmap_pd, norm_pd = from_levels_and_colors(v_pd, colors =['darkgrey', '#984ea3','lightgrey','plum', '#377eb8', '#e41a1c','ivory','#ff7f00'], extend='neither') plot_precipitation_detection=False if plot_precipitation_detection: # single prediction plot #fig,ax= plt.subplots(figsize=(20, 10)) #plt.rcParams.update({'font.size': 16}) fig,ax= plt.subplots(figsize=(10, 5)) plt.rcParams.update({'font.size': 8}) plt.rcParams.update({'mathtext.default':'regular'}) m = map_plot(axis=ax,area=area) m.ax.set_title('precip detection based on sat vs opera') # plot sat precip detection product against opera product tick_label_pd_nr=np.array([0,1,2,3,4,5,6,7]) tick_label_pd=['sat: no','sat: yes','sat: no (rad unr)','sat: yes (rad unr)','hit','false alarm','correct reject','miss'] im=m.pcolormesh( lon, lat, ver['mlp'], cmap=cmap_pd, norm=norm_pd, latlon=True ) divider = make_axes_locatable(ax) cax = divider.append_axes("right", size="4%", pad=0.05) cbar = fig.colorbar(im, cax=cax, ticks=tick_label_pd_nr, spacing='uniform') a=cbar.ax.set_yticklabels(tick_label_pd) outfile= 'precip_detection_sat'+in_msg.model+'_vs_opera_%s' fig.savefig((in_msg.outputDir+outfile %time_slot.strftime('%Y%m%d%H%M')), dpi=300, bbox_inches='tight') print('... create figure: display ' + in_msg.outputDir+outfile %time_slot.strftime('%Y%m%d%H%M') + '.png') plots_done[area].append('pdMlp') #################################### ## plot rain rate with matplotlib #################################### if 'rrMatplotlib' in in_msg.plots[area]: # create the combi rr field rr['combi']=copy.deepcopy(rr[in_msg.model+'_pm']) rr['combi'][mask_r]=rr['ody'][mask_r] # determine where I have >0.3 mm/h precip on the permanent mask -> overlay end picture with a pink(?) color there pd_nt=np.logical_and(mask_rnt,pd['ody']>=0.3) #precip detected but not trusted t = time.time() #fig, axes = plt.subplots(1, 2,figsize=(19, 6)) #plt.rcParams.update({'font.size': 16}) fig, axes = plt.subplots(1, 2,figsize=(9.5, 3)) plt.rcParams.update({'font.size': 8}) plt.rcParams.update({'mathtext.default':'regular'}) ## 1st subplot m = map_plot(axis=axes[0],area=area) m.ax.set_title('Rain Rate (opera + MSG ANN), '+str(time_slot)) # plot a white colored background where I have data available v_pd_nt=np.array([0.5,1.5]) cmap_pd_nt, norm_pd_nt = from_levels_and_colors(v_pd_nt, colors=['white'], extend='neither') im4=m.pcolormesh(lon,lat,np.ones(lon.shape),cmap=cmap_pd_nt,norm=norm_pd_nt,latlon=True) # plot mask which contains no rad & not trusted rad values nr_ntr = copy.deepcopy(ver['ody']) nr_ntr=np.ma.masked_greater(nr_ntr,2) nr_ntr=np.ma.masked_equal(nr_ntr,1) im2=m.pcolormesh(lon,lat,nr_ntr,cmap=cmap_pd,norm=norm_pd,latlon=True) # plot combined precip opera + sat v_rr = [0.3,0.6,1.2,2.4,4.8,9.6] cmap_rr,norm_rr=smart_colormap(v_rr,name='coolwarm',extend='max') im=m.pcolormesh(lon,lat,rr['combi'],cmap=cmap_rr,norm=norm_rr,latlon=True) # plot pink pixels everywhere on permanently not trusted radar mask where we observe > 0.3 mm/h precip v_pd_nt=np.array([0.5,1.5]) cmap_pd_nt, norm_pd_nt = from_levels_and_colors(v_pd_nt, colors=['plum'], extend='neither') im3=m.pcolormesh(lon,lat,pd_nt,cmap=cmap_pd_nt,norm=norm_pd_nt,latlon=True) ## 2nd subplot # plot purely satellite based precip product m = map_plot(axis=axes[1],area=area) m.ax.set_title('Rain Rate (MSG ANN), '+str(time_slot)) if in_msg.IR_108 and not in_msg.read_from_netCDF: # plot the IR_108 channel clevs = np.arange(225,316,10) cmap_sat,norm_sat=smart_colormap(clevs,name='Greys',extend='both') im4 = m.pcolormesh(lon,lat,data_sat['IR_108_PC'].data,cmap=cmap_sat,norm=norm_sat,latlon=True) else: # plot a white surface to distinguish between the regions where the produ v_pd_nt=np.array([0.5,1.5]) cmap_pd_nt, norm_pd_nt = from_levels_and_colors(v_pd_nt, colors=['white'], extend='neither') im4=m.pcolormesh(lon,lat,np.ones(lon.shape),cmap=cmap_pd_nt,norm=norm_pd_nt,latlon=True) if in_msg.probab_match: im=m.pcolormesh(lon, lat,rr[in_msg.model+'_pm'], cmap=cmap_rr, norm=norm_rr, latlon=True) else: im=m.pcolormesh(lon, lat,rr[in_msg.model], cmap=cmap_rr, norm=norm_rr, latlon=True) if in_msg.IR_108 and in_msg.probab_match: outfile= 'rr_combioperasat'+in_msg.model+'pm_satIR108'+in_msg.model+'pm_%s' elif in_msg.IR_108 and (in_msg.probab_match==False): outfile= 'rr_combioperasat'+in_msg.model+'_satIR108'+in_msg.model+'_%s' elif (in_msg.IR_108==False) and in_msg.probab_match: outfile= 'rr_combioperasat'+in_msg.model+'pm_sat'+in_msg.model+'pm_%s' elif (in_msg.IR_108==False) and (in_msg.probab_match==False): outfile= 'rr_combioperasat'+in_msg.model+'_sat'+in_msg.model+'_%s' fig.subplots_adjust(bottom=0.15) cbar_ax = fig.add_axes([0.25, 0.05, 0.5, 0.05]) cbar=fig.colorbar(im, cax=cbar_ax, orientation='horizontal') cbar.set_label('$mm\,h^{-1}$') fig.savefig((in_msg.outputDir+outfile %time_slot.strftime('%Y%m%d%H%M')), dpi=300, bbox_inches='tight') print('... create figure: display ' + in_msg.outputDir+outfile %time_slot.strftime('%Y%m%d%H%M') + '.png') elapsed = time.time() - t print("... elapsed time for creating the rainrate image in seconds: "+str(elapsed)) plots_done[area].append('rrMatplotlib') #################################### ## plot rain rate with trollimage #################################### plot_trollimage=True if plot_trollimage: from plotting_tools import create_trollimage from plot_msg import add_title print ("*** create plot with trollimage") from copy import deepcopy from trollimage.colormap import RainRate colormap = deepcopy(RainRate) # define contour write for coasts, borders, rivers from pycoast import ContourWriterAGG cw = ContourWriterAGG(in_msg.mapDir) from plot_msg import choose_map_resolution resolution = choose_map_resolution(area, None) #resolution='l' # odyssey, europe #resolution='i' # ccs4 print (" resolution=", resolution) IR_file=time_slot.strftime(in_msg.outputDir+'MSG_IR-108-'+area+'_%Y%m%d%H%M.png') if 'IR_108' in in_msg.plots[area] and not in_msg.read_from_netCDF: # create black white background #img_IR_108 = data_sat.image.channel_image('IR_108_PC') img_IR_108 = data_sat.image.ir108() img_IR_108.save(IR_file) for rgb in in_msg.plots[area]: if rgb == 'RATE': prop = np.ma.masked_equal(rr['ody'], 0) mask2plot=deepcopy(mask_r) elif rgb =='rrMlp': prop = np.ma.masked_equal(rr[in_msg.model], 0) mask2plot=None elif rgb == 'rrMlpPm': prop = np.ma.masked_equal(rr[in_msg.model+'_pm'], 0) mask2plot=None elif rgb == 'rrOdyMlp': rr['combi']=copy.deepcopy(rr[in_msg.model]) rr['combi'][mask_r]=rr['ody'][mask_r] prop = np.ma.masked_equal(rr['combi'], 0) mask2plot=deepcopy(mask_r) elif rgb == 'rrOdyMlpPm': rr['combi']=copy.deepcopy(rr[in_msg.model+'_pm']) rr['combi'][mask_r] = rr['ody'][mask_r] prop = np.ma.masked_equal(rr['combi'], 0) mask2plot=deepcopy(mask_r) elif rgb == 'IR_108': continue else: "*** Error, unknown product requested" quit() filename = None if area in in_msg.postprocessing_composite: composite_file = in_msg.outputDir+"/"+'MSG_'+in_msg.postprocessing_composite[area][0]+"-"+area+'_%Y%m%d%H%M.png' composite_file = composite_file.replace("%(rgb)s", rgb) else: composite_file = None PIL_image = create_trollimage(rgb, prop, colormap, cw, filename, time_slot, area, composite_file=composite_file, background=IR_file, mask=mask2plot, resolution=resolution, scpOutput=in_msg.scpOutput) # add title to image dc = DecoratorAGG(PIL_image) if in_msg.add_title: add_title(PIL_image, in_msg.title, rgb, 'MSG', sat_nr, in_msg.datetime, area, dc, in_msg.font_file, True, title_color=in_msg.title_color, title_y_line_nr=in_msg.title_y_line_nr ) # !!! needs change # save image as file outfile = time_slot.strftime(in_msg.outputDir+"/"+in_msg.outputFile).replace("%(rgb)s", rgb).replace("%(area)s", area).replace("%(model)s", in_msg.model) PIL_image.save(outfile, optimize=True) if isfile(outfile): print ("... create figure: display "+outfile+" &") chmod(outfile, 0777) plots_done[area].append(rgb) else: print ("*** Error: "+outfile+" could not be generated") quit() print('=================================') ############################################## ## potential other map setups ############################################## ############################################## ############################################## ## opera composite vs the prediction... but I think it'd be less confusing to only show the prediction ############################################## if 'OdyVsRr' in in_msg.plots[area]: fig, axes = plt.subplots(1, 2,figsize=(23.5, 5)) # will be switched to basemap once have new training set together plt.rcParams.update({'font.size': 16}) plt.rcParams.update({'mathtext.default':'regular'}) # set up nn subplot m = map_plot(axis=axes[0],area=area) m.ax.set_title('precip detection based on mlp vs opera') v_pd=np.array([-0.5,0.5,1.5,2.5,3.5,4.5,5.5,6.5,7.5]) cmap_pd, norm_pd = from_levels_and_colors(v_pd, colors=['darkgrey', '#984ea3','lightgrey','plum', '#377eb8', '#e41a1c','ivory','#ff7f00'], extend='neither') tick_label_pd_nr=np.array([0,1,2,3,4,5,6,7]) tick_label_pd=['sat: no','sat: yes','sat: no (rad unr)','sat: yes (rad unr)','hit','false alarm','correct reject','miss'] im=m.pcolormesh(lon,lat,ver['mlp'],cmap=cmap_pd, norm=norm_pd, latlon=True) divider = make_axes_locatable(m.ax) cax = divider.append_axes("right", size="4%", pad=0.05) cbar = fig.colorbar(im,cax=cax, ticks=tick_label_pd_nr, spacing='uniform') cbar.ax.set_yticklabels(tick_label_pd, fontsize=14) m = map_plot(axis=axes[1],area=area) m.ax.set_title('precip detection based on opera vs opera') v_pd=np.array([-0.5,0.5,2.5,3.5,4.5,6.5]) cmap_pd, norm_pd = from_levels_and_colors(v_pd, colors=['darkgrey','lightgrey','plum', '#377eb8','ivory'], extend='neither') tick_label_pd_nr=np.array([0,1.5,3,4,5.5]) tick_label_pd=['no rad','rad clutter: no','rad clutter: yes','rad: yes','rad: no'] im=m.pcolormesh(lon,lat,ver['ody'],cmap=cmap_pd,norm=norm_pd,latlon=True) divider = make_axes_locatable(m.ax) cax = divider.append_axes("right", size="4%", pad=0.05) cbar = fig.colorbar(im,cax=cax,ticks=tick_label_pd_nr,spacing='uniform') a=cbar.ax.set_yticklabels(tick_label_pd,fontsize=14) outfile= 'test_%s' fig.savefig((in_msg.outputDir+ outfile %time_slot.strftime('%Y%m%d%H%M')), dpi=300, bbox_inches='tight') print('... create figure: display ' + in_msg.outputDir+outfile %time_slot.strftime('%Y%m%d%H%M') + '.png') plots_done[area].append('OdyVsRr') ############################################## ## cth visualisation without parallax corr for a test ############################################## if 'CTH' in in_msg.plots[area]: fig, axes = plt.subplots(1, 1,figsize=(5, 3)) plt.rcParams.update({'font.size': 16}) plt.rcParams.update({'mathtext.default':'regular'}) ## 1st subplot m = map_plot(axis=axes,area=area) m.ax.set_title('CTH (without parallax corr)') v_rr = np.arange(6000,12001,1000) cmap_rr,norm_rr=smart_colormap(v_rr,name='coolwarm',extend='neither') im4 = m.pcolormesh(lon,lat,data_cth['CTTH'].height,cmap=cmap_rr,norm=norm_rr,latlon=True) fig.colorbar(im4) data_cth['CTTH'].height outfile= 'CTH_without_parallax_%s' fig.savefig((in_msg.outputDir+ outfile %time_slot.strftime('%Y%m%d%H%M')), dpi=300, bbox_inches='tight') print('... create figure: display ' + in_msg.outputDir+outfile %time_slot.strftime('%Y%m%d%H%M') + '.png') plots_done[area].append('CTH') # end of area loop ## start postprocessing for area in in_msg.postprocessing_areas: postprocessing(in_msg, time_slot, int(sat_nr), area) # increase the time by a time delta time_slot += delta # end of time loop return plots_done
def test_cmap_and_norm_from_levels_and_colors2(): levels = [-1, 2, 2.5, 3] colors = ['red', (0, 1, 0), 'blue', (0.5, 0.5, 0.5), (0.0, 0.0, 0.0, 1.0)] clr = mcolors.to_rgba_array(colors) bad = (0.1, 0.1, 0.1, 0.1) no_color = (0.0, 0.0, 0.0, 0.0) masked_value = 'masked_value' # Define the test values which are of interest. # Note: levels are lev[i] <= v < lev[i+1] tests = [ ('both', None, { -2: clr[0], -1: clr[1], 2: clr[2], 2.25: clr[2], 3: clr[4], 3.5: clr[4], masked_value: bad }), ('min', -1, { -2: clr[0], -1: clr[1], 2: clr[2], 2.25: clr[2], 3: no_color, 3.5: no_color, masked_value: bad }), ('max', -1, { -2: no_color, -1: clr[0], 2: clr[1], 2.25: clr[1], 3: clr[3], 3.5: clr[3], masked_value: bad }), ('neither', -2, { -2: no_color, -1: clr[0], 2: clr[1], 2.25: clr[1], 3: no_color, 3.5: no_color, masked_value: bad }), ] for extend, i1, cases in tests: cmap, norm = mcolors.from_levels_and_colors(levels, colors[0:i1], extend=extend) cmap.set_bad(bad) for d_val, expected_color in cases.items(): if d_val == masked_value: d_val = np.ma.array([1], mask=True) else: d_val = [d_val] assert_array_equal( expected_color, cmap(norm(d_val))[0], 'Wih extend={0!r} and data ' 'value={1!r}'.format(extend, d_val)) with pytest.raises(ValueError): mcolors.from_levels_and_colors(levels, colors)
mlab.view(180, 0, 450, [0, 10, 0]) mlab.savefig('{d}{cont}_connectivity_{f}_sum_top.png'.format( d=save_dir, cont=contrast, f=freq), magnification=4) mlab.view(180, 180, 480, [0, 10, 0]) mlab.savefig('{d}{cont}_connectivity_{f}_sum_bottom.png'.format( d=save_dir, cont=contrast, f=freq), magnification=4) mlab.close(fig) # Plot the connectivity diagram with optimized diverging colorspace con_parc_sum.data = con_parc_sum.data * 1000 vmax = con_parc_sum.data.max() vmin = con_parc_sum.data.min() num_levels = 40 midpoint = 0 levels = np.linspace(vmin, vmax, num_levels) midp = np.mean(np.c_[levels[:-1], levels[1:]], axis=1) vals = np.interp(midp, [vmin, midpoint, vmax], [0, 0.5, 1]) colors = plt.cm.seismic(vals) cmap, norm = from_levels_and_colors(levels, colors) fig, _ = con_parc_sum.plot(title='Parcel-wise Connectivity by Sum', facecolor='white', textcolor='black', node_edgecolor='white', colormap=cmap, show=True) fig.savefig('{d}{cont}_connectivity_{f}_sum_squircle.pdf'.format( d=save_dir, cont=contrast, f=freq), bbox_inches='tight')