MPAS-JEDI
basic_plot_functions.py
Go to the documentation of this file.
1 #!/usr/bin/env python3
2 
3 import datetime as dt
4 import logging
5 from pandas.plotting import register_matplotlib_converters
6 register_matplotlib_converters()
7 import matplotlib
8 matplotlib.use('AGG')
9 import matplotlib.axes as maxes
10 import matplotlib.cm as cm
11 import matplotlib.colors as colors
12 from matplotlib.colors import BoundaryNorm
13 import matplotlib.pyplot as plt
14 from matplotlib.ticker import MaxNLocator
15 from mpl_toolkits.basemap import Basemap
16 from mpl_toolkits.axes_grid1 import make_axes_locatable
17 import numpy as np
18 import plot_utils as pu
19 import var_utils as vu
20 import os
21 
22 _logger = logging.getLogger(__name__)
23 
24 cmGray = plt.cm.get_cmap("gist_gray")
25 cmRainbow = plt.cm.get_cmap("gist_rainbow")
26 cmSpectral = plt.cm.get_cmap("nipy_spectral")
27 cmHeat = plt.cm.get_cmap("gist_heat")
28 cmOcean = plt.cm.get_cmap("ocean")
29 cmNCAR = plt.cm.get_cmap("gist_ncar")
30 
31 WhiteBlack1 = cmGray(np.linspace(1.0,0.0,17)) # white to black (-90 to -74 C)
32 BlackRed = cmHeat(np.linspace(0.0,0.5,10)) #black to red (-74 to -65 C)
33 ROYG = cmSpectral(np.linspace(0.9,0.43,27)) # red, orange, yellow, green, blue (-65 to -39 C)
34 #GreenBlue = cmNCAR(np.linspace(0.05,0.1,8)) # green to blue (-39 to -32 C)
35 #BlueCyan = cmRainbow(np.linspace(0.8,0.6,13)) # blue to cyan (-32 to -20 C)
36 GreenBlueCyan = cmNCAR(np.linspace(0.05,0.2,20)) # green to blue (-39 to -20 C)
37 #WhiteBlack2 = cmGray(np.linspace(0.9,0.0,51)) # white to black (-20 to 30 C)
38 MVW = cmNCAR(np.linspace(0.8,0.98,21)) # magenta to violet to white (-20 to 0 C)
39 WhiteBlack2 = cmGray(np.linspace(0.9,0.0,31)) # white to black (0 to 30 C)
40 
41 #btcolors = np.concatenate((WhiteBlack1, BlackRed, ROYG, GreenBlue, BlueCyan, WhiteBlack2))
42 #btcolors = np.concatenate((WhiteBlack1, BlackRed, ROYG, GreenBlueCyan, WhiteBlack2))
43 btcolors = np.concatenate((WhiteBlack1, BlackRed, ROYG, GreenBlueCyan, MVW, WhiteBlack2))
44 
45 btCMap = colors.ListedColormap(btcolors)
46 
47 #This script includes basic plotting functions.
48 
49 distriZooms = {}
50 
51 #Full Earth
52 distriZooms['default'] = {
53  'cLon': None,
54  'minLon': -180,
55  'maxLon': 180,
56  'minLat': -90,
57  'maxLat': 90,
58 }
59 distriZooms['abi'] = {
60  'cLon': -75.2,
61  'minLon': None,
62  'maxLon': None,
63  'minLat': None,
64  'maxLat': None,
65 }
66 distriZooms['ahi'] = {
67  'cLon': 140.7,
68  'minLon': None,
69  'maxLon': None,
70  'minLat': None,
71  'maxLat': None,
72 }
73 
74 def plotDistri(lats,lons,values, \
75  ObsType,VarName,var_unit,out_name,nstation,levbin, \
76  dmin=None,dmax=None,dotsize=6,color="rainbow"):
77 #================================================================
78 #INPUTS:
79 # lats - latitude
80 # lons - longitude
81 # values - values will be plotted
82 # ObsType - observation type
83 # VarName - variable name
84 # var_unit - variable units
85 # out_name - will be included in output file name. It can be experiment name.
86 # nstation - station numbers for sondes.
87 # levbin - plot all levels together (levbin=all); or plot every level.
88 # dmin, dmax - min/max values of colorbars, optional
89 # dotsize - dot size, optional
90 # color - color scheme, optional
91 #================================================================
92 # For some plots that need to change longitude from [-180,180] to [0,360]
93 # tmp = np.logical_not(lons > 0)
94 # lons[tmp] = lons[tmp] + 360
95 
96 #set map=======================================================================
97  cLon = distriZooms['default']['cLon']
98  minLon = distriZooms['default']['minLon']
99  maxLon = distriZooms['default']['maxLon']
100  minLat = distriZooms['default']['minLat']
101  maxLat = distriZooms['default']['maxLat']
102 
103  for key, val in distriZooms.items():
104  if key in ObsType:
105  cLon = val['cLon']
106  minLon = val['minLon']
107  maxLon = val['maxLon']
108  minLat = val['minLat']
109  maxLat = val['maxLat']
110 
111  parallels=np.arange(-90,90,30) #lat
112 
113  if cLon is not None:
114  fig,ax=plt.subplots(figsize=(5,5))
115  m=Basemap(projection='nsper', #map projection
116  lon_0 = cLon,
117  lat_0 = 0.0,
118  resolution='l') #c: crude; l:low; i:intermediate, h:high, f:full; sometimes can only >=h
119  #set the lat lon grid and the ticks of x y axies ==============================
120  m.drawparallels(parallels, linewidth=0.2, dashes=[1,3])
121  meridians=np.arange(-180,180,30) #lon
122  m.drawmeridians(meridians, linewidth=0.2, dashes=[1,3])
123  else:
124  fig,ax=plt.subplots(figsize=(8,8))
125  m=Basemap(projection='cyl', #map projection
126  llcrnrlon=minLon, llcrnrlat=minLat, #the lat lon of leftlower corner
127  urcrnrlon=maxLon, urcrnrlat=maxLat, #the lat lon of rightupper corner
128  resolution='l') #c: crude; l:low; i:intermediate, h:high, f:full; sometimes can only >=h
129  #set the lat lon grid and the ticks of x y axies ==============================
130  m.drawparallels(parallels, linewidth=0.2, dashes=[1,3],
131  labels=[True,True,True,True]) #Turn the ticks on or off
132  meridians=np.arange(-180,180,60) #lon
133  m.drawmeridians(meridians, linewidth=0.2, dashes=[1,3],
134  labels=[True,True,True,True])
135 
136  m.drawcoastlines(linewidth=0.2,zorder=10) #draw coastline
137 # m.drawmapboundary(fill_color='lightblue') #the whole map is filled with the specified color
138 # m.fillcontinents(color='wheat',lake_color='lightblue') #the continents are filled
139 
140 
141 #set title ===================================================================
142  if nstation == 0:
143  plt.text(0.5, 1.25, '%s %s %s nlocs:%s' \
144  %(ObsType,VarName,var_unit,len(values[~np.isnan(values)])), \
145  horizontalalignment='center', \
146  fontsize=12, transform = ax.transAxes)
147  else:
148  if ObsType[:6] == 'gnssro':
149  plt.text(0.5, 1.25, '%s %s %s nlocs:%s nprofile:%s' \
150  %(ObsType,VarName,var_unit,len(values[~np.isnan(values)]),nstation), \
151  horizontalalignment='center', \
152  fontsize=12, transform = ax.transAxes)
153  elif ObsType == 'aircraft':
154  plt.text(0.5, 1.25, '%s %s %s nlocs:%s nflight:%s' \
155  %(ObsType,VarName,var_unit,len(values[~np.isnan(values)]),nstation), \
156  horizontalalignment='center', \
157  fontsize=12, transform = ax.transAxes)
158  else:
159  plt.text(0.5, 1.25, '%s %s %s nlocs:%s nstation:%s' \
160  %(ObsType,VarName,var_unit,len(values[~np.isnan(values)]),nstation), \
161  horizontalalignment='center', \
162  fontsize=12, transform = ax.transAxes)
163 
164 #draw points onto map =========================================================
165  if color == "BT":
166  if ("abi" in ObsType or "ahi" in ObsType):
167  cm = btCMap
168  if dmin is None: dmin = 183
169  if dmax is None: dmax = 303
170  else:
171  cm = plt.cm.get_cmap("gist_ncar")
172  if dmin is None: dmin = 190
173  if dmax is None: dmax = 270
174  else:
175  cm = plt.cm.get_cmap(color)
176 
177  finite = np.isfinite(values)
178  if ((("abi" in ObsType or "ahi" in ObsType)
179  and finite.sum() > 4e4)
180  or "model" in ObsType):
181  # option 1: smoothed contours (note: color bar is not quite right)
182  # sc=m.contourf(lons[finite], lats[finite], values[finite],
183  # cm.N, cmap = cm, vmin = dmin, vmax = dmax,
184  # latlon = True, tri = True, extend='both')
185 
186  # option 2: pixel contours
187  # first sort by longitude to avoid bug for cyclic projections in basemap
188  lonsPlot = lons[finite]
189  lonsPlot[lonsPlot > 180.0] -= 360.0 # fixes latitude swap bug for cyclic projections
190  latsPlot = lats[finite]
191  valuesPlot = values[finite]
192  lonSort = np.argsort(lonsPlot)
193 
194  sc = m.pcolor(lonsPlot[lonSort], latsPlot[lonSort], valuesPlot[lonSort],
195  cmap = cm, vmin = dmin, vmax = dmax,
196  latlon = True, tri = True)
197 
198  else:
199  sc = m.scatter(lons[finite], lats[finite], c=values[finite],
200  latlon = True,
201  s = dotsize, cmap = cm, vmin = dmin, vmax = dmax,
202  marker = '.', linewidth = 0,
203  zorder=11) #10 ; zorder determines the order of the layer. If not set,
204  #the point on continent will be blocked
205 
206 #create axes for colorbar======================================================
207  divider = make_axes_locatable(ax)
208  cax = divider.append_axes("top",
209  size="3%", #width of the colorbar
210  pad=0.3) #space between colorbar and graph
211  plt.colorbar(sc,cax=cax,ax=ax,orientation='horizontal')
212  cax.xaxis.set_ticks_position('top') #set the orientation of the ticks of the colorbar
213 
214  plt.savefig('distri_%s_%s_%s.png'%(VarName,out_name,levbin),dpi=200,bbox_inches='tight')
215  plt.close()
216 
217 
218 def scatterMapFields(
219  lons, lats, fields,
220  filename,
221  minLon = -180., maxLon = 180.,
222  minLat = -90., maxLat = 90.,
223  cLon = None,
224  projection = 'default',
225  dmin = None, dmax = None,
226  markers = {},
227  sizes = {},
228  cmap = 'gist_ncar',
229  cbarType = None,
230  c = {},
231  logVLim = 1.e-12,
232  ):
233 
234  # set up projection
235  if cLon is not None:
236  fig,ax=plt.subplots(figsize=(5,5))
237  if projection == 'default':
238  proj = 'nsper'
239  else:
240  proj = projection
241  m=Basemap(projection=proj,
242  lon_0 = cLon,
243  lat_0 = 0.0,
244  resolution='l') #c: crude; l:low; i:intermediate, h:high, f:full; sometimes can only >=h
245  #set the lat lon grid and the ticks of x y axies ==============================
246  parallels=np.arange(-90, 90, 30)
247  m.drawparallels(parallels, linewidth=0.2, dashes=[1,3], zorder = 3)
248  meridians=np.arange(-180, 180, 30)
249  m.drawmeridians(meridians, linewidth=0.2, dashes=[1,3], zorder = 3)
250  else:
251  fig,ax=plt.subplots(figsize=(8,8))
252  if projection == 'default':
253  proj = 'cyl'
254  else:
255  proj = projection
256  m=Basemap(projection=proj,
257  llcrnrlon=minLon, llcrnrlat=minLat, #the lat lon of leftlower corner
258  urcrnrlon=maxLon, urcrnrlat=maxLat, #the lat lon of rightupper corner
259  resolution='l') #c: crude; l:low; i:intermediate, h:high, f:full; sometimes can only >=h
260  #set the lat lon grid and the ticks of x y axies ==============================
261  parallels = np.arange(minLat, maxLat, (maxLat - minLat) / 6.)
262  m.drawparallels(parallels, linewidth=0.2, dashes=[1,3],
263  labels=[True,True,True,True], zorder = 3)
264  meridians = np.arange(minLon, maxLon, (maxLon - minLon) / 6.)
265  m.drawmeridians(meridians, linewidth=0.2, dashes=[1,3],
266  labels=[True,True,True,True], zorder = 3)
267 
268  m.drawcoastlines(linewidth=0.2, zorder=2) #draw coastline
269 
270  # title
271 # plt.text(0.5, 1.25, '%s %s %s nlocs:%s' \
272 # %(ObsType,VarName,var_unit,len(values)), \
273 # horizontalalignment='center', \
274 # fontsize=12, transform = ax.transAxes)
275 
276  assert (cbarType is None or cbarType in ['Log', 'SymLog']), \
277  'scatterMapFields: invalid cbarType: '+cbarType
278 
279  for name, field in fields.items():
280  finite = np.isfinite(field)
281  if dmin is None:
282  vmin = field[finite].min()
283  else:
284  vmin = dmin
285  if dmax is None:
286  vmax = field[finite].max()
287  else:
288  vmax = dmax
289 
290  if cbarType is None:
291  sc = m.scatter(lons[name][finite], lats[name][finite], c=c.get(name, field[finite]),
292  latlon = True,
293  s = sizes.get(name, 1),
294  cmap = cmap, vmin = vmin, vmax = vmax,
295  marker = markers.get(name, '.'), linewidth = 0,
296  zorder=1) #10 ; zorder determines the order of the layer. If not set,
297  #the point on continent will be blocked
298  elif cbarType == 'Log':
299  if vmin <= logVLim: vmin = logVLim
300  field_ = field[finite]
301  field_[field_ < vmin] = vmin
302  sc = m.scatter(lons[name][finite], lats[name][finite], c=c.get(name, field_),
303  latlon = True,
304  s = sizes.get(name, 1),
305  cmap = cmap,
306  marker = markers.get(name, '.'), linewidth = 0,
307  norm=colors.LogNorm(vmin=vmin, vmax=vmax),
308  zorder=1) #10 ; zorder determines the order of the layer. If not set,
309  #the point on continent will be blocked
310  elif cbarType == 'SymLog':
311  sc = m.scatter(lons[name][finite], lats[name][finite], c=c.get(name, field[finite]),
312  latlon = True,
313  s = sizes.get(name, 1),
314  cmap = cmap,
315  marker = markers.get(name, '.'), linewidth = 0,
316  norm=colors.SymLogNorm(vmin=vmin, vmax=vmax,
317  linthresh=1.e-4*vmax, linscale=1.0, base=10),
318  zorder=1) #10 ; zorder determines the order of the layer. If not set,
319  #the point on continent will be blocked
320 
321  divider = make_axes_locatable(ax)
322  cax = divider.append_axes("top",
323  size="3%", #width of the colorbar
324  pad=0.3) #space between colorbar and graph
325  plt.colorbar(sc, cax=cax, ax=ax, orientation='horizontal')
326  cax.xaxis.set_ticks_position('top') #set the orientation of the ticks of the colorbar
327 
328  plt.savefig(filename, dpi=200, bbox_inches='tight')
329  plt.close()
330 
331 def plotTimeserial2D(Stats,xlabeltime,ylevels,VarName):
332 #================================================================
333 #INPUTS:
334 # Stats - statistics
335 # xlabeltime - time labels for x-axis
336 # ylevels - vertical levels for y-axis
337 # VarName - variable name
338 #================================================================
339  zgrid = np.loadtxt("/glade/work/jban/pandac/fix_input/graphics/zgrid_v55.txt")
340 
341  fig, ax1 = plt.subplots()
342 
343  xarray = range(len(xlabeltime))
344  valuemin = np.amin(Stats)
345  valuemax = np.amax(Stats)
346  # yonggangyu introduce epsilon and xi for plotting absolutely zero field,
347  # solving vmin, vcenter, vmax ascending order issue
348  epsilon = 1.e-8
349  if (valuemin > 0 or valuemax < 0):
350  color = 'rainbow'
351  plt.contourf(xarray,ylevels,Stats,40,vmin=valuemin, vmax=valuemax,cmap=color)
352  xi=-1
353  else:
354  cmap = 'coolwarm'
355  if ( -valuemin < epsilon and valuemax < epsilon ):
356  xi=1
357  valuemin = -epsilon
358  valuemax = epsilon
359  elif ( -valuemin < epsilon and valuemax > epsilon ):
360  xi=2
361  valuemin = -epsilon
362  elif ( -valuemin > epsilon and valuemax < epsilon ):
363  xi=3
364  valuemax = epsilon
365  else:
366  xi=4
367  #print('xi= '+str(xi)+' valuemin= ',str(valuemin)+' valuemax= ',str(valuemax))
368  norm = matplotlib.colors.DivergingNorm(vmin=valuemin, vcenter=0, vmax=valuemax)
369  plt.contourf(xarray,ylevels,Stats,40,vmin=valuemin, vmax=valuemax,norm=norm,cmap=cmap)
370  xarray = range(len(xlabeltime))
371  major_ticks = np.arange(0, 56, 5)
372  ax1.set_yticks(major_ticks)
373  ax1.set_ylim([0,54])
374  ax1.set_ylabel('Vertical level',fontsize=15)
375 
376  ax2 = ax1.twinx()
377  ax2.set_yticks(major_ticks-1)
378  ax2.set_yticklabels((zgrid[::5]).astype(int))
379 
380  ax2.set_ylabel('Height (m)',fontsize=13)
381 
382  FCDay = ''.join(VarName.split("_")[1:][:-3])
383  if (FCDay == 'day0.0'):
384  ax1.set_xlabel('Analysis Time',fontsize=15)
385  ax1.set_xticks(xarray[::4])
386  ax1.set_xticklabels(xlabeltime[::4],rotation=90)
387  elif (FCDay == 'day0.25'):
388  ax1.set_xlabel( '6h Forecast',fontsize=15)
389  ax1.set_xticks(xarray[::4])
390  ax1.set_xticklabels(xlabeltime[::4],rotation=90)
391  else:
392  ax1.set_xlabel( 'Lead Time',fontsize=15)
393 
394  plt.colorbar(extend='both',orientation="horizontal",pad=0.2)
395  ax1.grid(True)
396  region = ''.join(VarName.split("_")[2:][:-2])
397  var = ''.join(VarName.split("_")[3:][:-1])
398  stats = ''.join(VarName.split("_")[4:])
399  plt.title(stats+' variable:'+vu.varDictModel[var][1]+'('+ vu.varDictModel[var][0]+') '+region, fontsize = 12)
400  plt.savefig(VarName+'_TS_2d.png',dpi=200,bbox_inches='tight')
401  plt.close()
402 
403 maxLegendEntries = 12
404 
405 ###############################################################################
406 lenWarnSer = 0
407 nanWarnSer = 0
408 def plotSeries(fig, \
409  linesVals, xVals, \
410  linesLabel, \
411  title="", dataLabel="y", \
412  sciticks=False, logscale= False, signdef=False, \
413  indepLabel="x", invert_ind_axis=False, \
414  ny=1, nx=1, nplots=1, iplot=0, \
415  linesValsMinCI=None, linesValsMaxCI=None, \
416  dmin=np.NaN, dmax=np.NaN, \
417  lineAttribOffset=0, \
418  legend_inside=True,
419  interiorLabels=True):
420 
421 # ARGUMENTS
422 # fig - matplotlib figure object
423 # linesVals - dependent variable (list of arrays)
424 # xVals - independent variable on x-axis (array)
425 # linesLabel - legend label for linesVals (list)
426 
427 # title - subplot title, optional
428 # dataLabel - label for linesVals, optional
429 # sciticks - whether linesVals needs scientific formatting for ticks, optional
430 # logscale - y-axis is scaled logarithmically, optional, overrides sciticks
431 # signdef - whether linesVals is positive/negative definite, optional
432 # indepLabel - label for xVals, optional
433 # invert_ind_axis - whether to invert x-axis orientation, optional
434 
435 # ny, nx - number of subplots in x/y direction, optional
436 # nplots - total number of subplots, optional
437 # iplot - this subplot index (starting at 0), optional
438 
439 # linesValsMinCI - minimum error bound for linesVals (list of arrays), optional
440 # linesValsMaxCI - maximum error bound for linesVals (list of arrays), optional
441 # Note: linesValsMinCI and linesValsMaxCI must be specified together
442 
443 # lineAttribOffset - offset for selecting line attributes, optional
444 # dmin, dmax - min/max values of linesVals, optional
445 # legend_inside - whether legend should be placed inside the subplot, optional
446 
447  ax = fig.add_subplot(ny, nx, iplot+1)
448 
449  #title
450  ax.set_title(title,fontsize=5)
451 
452  #add lines
453  plotVals = np.asarray([])
454  nLines = 0
455  for iline, lineVals in enumerate(linesVals):
456  if np.all(np.isnan(lineVals)):
457  global nanWarnSer
458  if nanWarnSer==0:
459  _logger.warning("skipping all-NaN data")
460  _logger.warning(title+"; "+indepLabel+"; "+linesLabel[iline])
461  nanWarnSer=nanWarnSer+1
462  continue
463  if len(lineVals)!=len(xVals):
464  global lenWarnSer
465  if lenWarnSer==0:
466  _logger.warning("skipping data where len(x)!=len(y)")
467  _logger.warning(title+"; "+indepLabel+"; "+linesLabel[iline])
468  lenWarnSer=lenWarnSer+1
469  continue
470 
471  # Plot line for each lineVals that has non-missing data
472  pColor = pu.plotColor(len(linesVals),iline+lineAttribOffset)
473 
474  ax.plot(xVals, lineVals, \
475  color=pColor, \
476  label=linesLabel[iline], \
477  ls=pu.plotLineStyle(len(linesVals),iline+lineAttribOffset), \
478  linewidth=0.5)
479  nLines += 1
480  plotVals = np.append(plotVals, lineVals)
481 
482  # Add shaded error regions if specified
483  if linesValsMinCI is not None and \
484  linesValsMaxCI is not None:
485 
486  # test statistical significance versus zero
487  if signdef:
488  significant = np.empty(len(lineVals))
489  significant[:] = np.NaN
490  else:
491  significant = np.multiply(linesValsMinCI[iline], linesValsMaxCI[iline])
492  significant = np.array([x if np.isfinite(x) else -1.0 for x in significant])
493 
494  lineArr = np.array(lineVals)
495  xArr = np.array(xVals)
496  negsiginds = np.array([i for i,x in enumerate(significant)
497  if (x > 0.0 and lineArr[i] < 0.0)],dtype=int)
498  if len(negsiginds) > 0:
499  ax.plot(xArr[negsiginds], lineArr[negsiginds], \
500  color=pColor, \
501  ls='', \
502  marker='v', \
503  markersize=1.5)
504 
505  possiginds = np.array([i for i,x in enumerate(significant)
506  if (x > 0.0 and lineArr[i] > 0.0)],dtype=int)
507  if len(possiginds) > 0:
508  ax.plot(xArr[possiginds], lineArr[possiginds], \
509  color=pColor, \
510  ls='', \
511  marker='^', \
512  markersize=1.5)
513 
514  ax.plot(xVals, linesValsMinCI[iline], \
515  color=pColor, \
516  alpha=0.4, \
517  ls='-', \
518  linewidth=0.5)
519  ax.plot(xVals, linesValsMaxCI[iline], \
520  color=pColor, \
521  alpha=0.4, \
522  ls='-', \
523  linewidth=0.5)
524  ax.fill_between(xVals, linesValsMinCI[iline], linesValsMaxCI[iline], \
525  color=pColor, \
526  edgecolor=pColor, \
527  linewidth=0.0, alpha = 0.1)
528  ax.fill_between(xVals, linesValsMinCI[iline], linesValsMaxCI[iline], \
529  where=significant > 0.0, \
530  color=pColor, \
531  edgecolor=pColor, \
532  linewidth=0.2, alpha = 0.3)
533 
534  if nLines == 0:
535  ax.tick_params(axis='x',labelbottom=False)
536  ax.tick_params(axis='y',labelleft=False)
537  return
538 
539  # add horizontal zero line for unbounded quantities
540  if not signdef:
541  ax.plot([xVals[0], xVals[-1]], [0., 0.], ls="--", c=".3", \
542  linewidth=0.7,markersize=0)
543 
544  # standardize x-limits
545  mindval, maxdval = pu.get_clean_ax_limits(dmin,dmax,plotVals,signdef)
546 
547  #axes settings
548  ax.xaxis.set_tick_params(labelsize=3)
549  ax.yaxis.set_tick_params(labelsize=3)
550 
551  isLogScale = logscale
552  if logscale:
553  nonzero = np.logical_and(np.greater(np.abs(plotVals), 0.), np.isfinite(plotVals))
554  if nonzero.sum() > 0:
555  vmin = np.nanmin(np.abs(plotVals[nonzero]))
556  vmax = np.nanmax(np.abs(plotVals[nonzero]))
557  if signdef:
558  # log tick labels look bad for single decade
559  if vmax / vmin > 10.0:
560  ax.set_yscale('log')
561  else:
562  isLogScale = False
563  else:
564  ax.set_yscale('symlog')
565  else:
566  isLogScale = False
567 
568  if isLogScale and np.isfinite(maxdval) and maxdval > 0.:
569  ax.set_ylim(None, maxdval)
570  if np.abs(vmin) > 0.:
571  ax.set_ylim(vmin, None)
572 
573  if not isLogScale:
574  if sciticks:
575  ax.ticklabel_format(style='sci', axis='y', scilimits=(0,0))
576  if (np.isfinite(mindval) and
577  np.isfinite(maxdval)):
578  ax.set_ylim(mindval,maxdval)
579  if maxdval-mindval < 1.0 or \
580  maxdval-mindval > 100.0:
581  ax.tick_params(axis='y',rotation=-35)
582  ax.yaxis.get_offset_text().set_fontsize(3)
583 
584  #handle interior subplot ticks/labels
585  ix = int(iplot)%int(nx)
586  iy = int(iplot)/int(nx)
587  if not interiorLabels \
588  and (iy < ny-2 or ( iy == ny-2 and (int(nplots)%int(nx)==0 or ix <= (int(nplots)%int(nx) - 1)) )):
589  ax.tick_params(axis='x',labelbottom=False)
590  if interiorLabels or ix == 0:
591  ax.set_xlabel(indepLabel,fontsize=4)
592  if interiorLabels or iy == ny-1:
593  ax.set_ylabel(dataLabel,fontsize=4)
594 
595  #legend
596  if nLines <= maxLegendEntries:
597  if legend_inside:
598  #INSIDE AXES
599  lh = ax.legend(loc='best',fontsize=3,frameon=True,\
600  framealpha=0.4,ncol=1)
601  lh.get_frame().set_linewidth(0.0)
602  elif ix==nx-1 or iplot==nplots-1:
603  #OUTSIDE AXES
604  ax.legend(loc='upper left',fontsize=3,frameon=False, \
605  bbox_to_anchor=(1.02, 1), borderaxespad=0)
606 
607  if invert_ind_axis:
608  ax.invert_xaxis()
609 
610  ax.grid()
611 
612  return
613 
614 ###############################################################################
615 lenWarnProf = 0
616 nanWarnProf = 0
617 def plotProfile(fig, \
618  linesVals, yVals, \
619  linesLabel, \
620  title="", dataLabel="x", \
621  sciticks=False, logscale=False, signdef=False, \
622  indepLabel="y", invert_ind_axis=False, \
623  ny=1, nx=1, nplots=1, iplot=0, \
624  linesValsMinCI=None, linesValsMaxCI=None, \
625  dmin=np.NaN, dmax=np.NaN, \
626  lineAttribOffset=0, \
627  legend_inside=True,
628  interiorLabels=True):
629 
630 # ARGUMENTS
631 # fig - matplotlib figure object
632 # linesVals - dependent variable (list of arrays)
633 # yVals - independent variable on y-axis (array)
634 # linesLabel - legend label for linesVals (list)
635 
636 # title - subplot title, optional
637 # dataLabel - label for linesVals, optional
638 # sciticks - whether linesVals needs scientific formatting for ticks, optional
639 # logscale - x-axis is scaled logarithmically, optional, overrides sciticks
640 # signdef - whether linesVals is positive/negative definite, optional
641 # indepLabel - label for yVals, optional
642 # invert_ind_axis - whether to invert y-axis orientation, optional
643 
644 # ny, nx - number of subplots in x/y direction, optional
645 # nplots - total number of subplots, optional
646 # iplot - this subplot index (starting at 0), optional
647 
648 # linesValsMinCI - minimum error bound for linesVals (list of arrays), optional
649 # linesValsMaxCI - maximum error bound for linesVals (list of arrays), optional
650 # Note: linesValsMinCI and linesValsMaxCI must be specified together
651 
652 # lineAttribOffset - offset for selecting line attributes, optional
653 # dmin, dmax - min/max values of linesVals, optional
654 # legend_inside - whether legend should be placed inside the subplot, optional
655 
656  ax = fig.add_subplot(ny, nx, iplot+1)
657 
658  #title
659  ax.set_title(title,fontsize=5)
660 
661  #add lines
662  plotVals = np.asarray([])
663  nLines = 0
664  for iline, lineVals in enumerate(linesVals):
665  if np.all(np.isnan(lineVals)):
666  global nanWarnProf
667  if nanWarnProf==0:
668  _logger.warning("skipping all-NaN data")
669  _logger.warning(title+"; "+dataLabel+"; "+linesLabel[iline])
670  nanWarnProf=nanWarnProf+1
671  continue
672  if len(lineVals)!=len(yVals):
673  global lenWarnProf
674  if lenWarnProf==0:
675  _logger.warning("skipping data where len(x)!=len(y)")
676  _logger.warning(title+"; "+dataLabel+"; "+linesLabel[iline])
677  lenWarnProf=lenWarnProf+1
678  continue
679 
680  # Plot line for each lineVals that has non-missing data
681  pColor = pu.plotColor(len(linesVals),iline+lineAttribOffset)
682 
683  ax.plot(lineVals, yVals, \
684  color=pColor, \
685  label=linesLabel[iline], \
686  ls=pu.plotLineStyle(len(linesVals),iline+lineAttribOffset), \
687  linewidth=0.5)
688  nLines += 1
689  plotVals = np.append(plotVals,lineVals)
690 
691  # Add shaded error regions if specified
692  if linesValsMinCI is not None and \
693  linesValsMaxCI is not None:
694 
695  # test statistical significance versus zero
696  if signdef:
697  significant = np.empty(len(lineVals))
698  significant[:] = np.NaN
699  else:
700  significant = np.multiply(linesValsMinCI[iline], linesValsMaxCI[iline])
701  significant = np.array([x if np.isfinite(x) else -1.0 for x in significant])
702 
703  lineArr = np.array(lineVals)
704  yArr = np.array(yVals)
705  negsiginds = np.array([i for i,x in enumerate(significant)
706  if (x > 0.0 and lineArr[i] < 0.0)],dtype=int)
707  if len(negsiginds) > 0:
708  ax.plot(lineArr[negsiginds], yArr[negsiginds], \
709  color=pColor, \
710  ls='', \
711  marker='<', \
712  markersize=1.5)
713 
714  possiginds = np.array([i for i,x in enumerate(significant)
715  if (x > 0.0 and lineArr[i] > 0.0)],dtype=int)
716  if len(possiginds) > 0:
717  ax.plot(lineArr[possiginds], yArr[possiginds], \
718  color=pColor, \
719  ls='', \
720  marker='>', \
721  markersize=1.5)
722 
723  ax.plot(linesValsMinCI[iline], yVals, \
724  color=pColor, \
725  alpha=0.4, \
726  ls='-', \
727  linewidth=0.5)
728  ax.plot(linesValsMaxCI[iline], yVals, \
729  color=pColor, \
730  alpha=0.4, \
731  ls='-', \
732  linewidth=0.5)
733  ax.fill_betweenx(yVals, linesValsMinCI[iline], linesValsMaxCI[iline], \
734  color=pColor, \
735  edgecolor=pColor, \
736  linewidth=0.0, alpha = 0.1)
737  ax.fill_betweenx(yVals, linesValsMinCI[iline], linesValsMaxCI[iline], \
738  where=significant > 0.0, \
739  color=pColor, \
740  edgecolor=pColor, \
741  linewidth=0.2, alpha = 0.3)
742 
743  if nLines == 0:
744  ax.tick_params(axis='x',labelbottom=False)
745  ax.tick_params(axis='y',labelleft=False)
746  return
747 
748  # add vertical zero line for unbounded quantities
749  if not signdef:
750  ax.plot([0., 0.], [yVals[0], yVals[-1]], ls="--", c=".3", \
751  linewidth=0.7,markersize=0)
752 
753  # standardize x-limits
754  mindval, maxdval = pu.get_clean_ax_limits(dmin,dmax,plotVals,signdef)
755 
756  #axes settings
757  ax.xaxis.set_tick_params(labelsize=3)
758  ax.yaxis.set_tick_params(labelsize=3)
759 
760  isLogScale = logscale
761  if logscale:
762  nonzero = np.logical_and(np.greater(np.abs(plotVals), 0.), np.isfinite(plotVals))
763  if nonzero.sum() > 0:
764  vmin = np.nanmin(np.abs(plotVals[nonzero]))
765  vmax = np.nanmax(np.abs(plotVals[nonzero]))
766  if signdef:
767  # log tick labels look bad for single decade
768  if vmax / vmin > 10.0:
769  ax.set_xscale('log')
770  else:
771  isLogScale = False
772  else:
773  ax.set_xscale('symlog')
774  else:
775  isLogScale = False
776 
777  if isLogScale and np.isfinite(maxdval) and maxdval > 0.:
778  ax.set_xlim(None, maxdval)
779  if np.abs(mindval) > 0.:
780  ax.set_xlim(mindval, None)
781 
782  if not isLogScale:
783  if sciticks:
784  ax.ticklabel_format(style='sci', axis='x', scilimits=(0,0))
785  if (np.isfinite(mindval) and
786  np.isfinite(maxdval)):
787  ax.set_xlim(mindval,maxdval)
788  if maxdval-mindval < 1.0 or \
789  maxdval-mindval > 100.0:
790  ax.tick_params(axis='x',rotation=-35)
791  ax.xaxis.get_offset_text().set_fontsize(3)
792 
793 
794  #handle interior subplot ticks/labels
795  ix = int(iplot)%int(nx)
796  iy = int(iplot)/int(nx)
797  if not interiorLabels \
798  and (iy < ny-2 or ( iy == ny-2 and (int(nplots)%int(nx)==0 or ix <= (int(nplots)%int(nx) - 1)) )):
799  ax.tick_params(axis='x',labelbottom=False)
800  if interiorLabels or ix == 0:
801  ax.set_xlabel(dataLabel,fontsize=4)
802  if interiorLabels or iy == ny-1:
803  ax.set_ylabel(indepLabel,fontsize=4)
804 
805  #legend
806  if nLines <= maxLegendEntries:
807  if legend_inside:
808  #INSIDE AXES
809  lh = ax.legend(loc='best',fontsize=3,frameon=True,\
810  framealpha=0.4,ncol=1)
811  lh.get_frame().set_linewidth(0.0)
812  elif ix==nx-1 or iplot==nplots-1:
813  #OUTSIDE AXES
814  ax.legend(loc='upper left',fontsize=3,frameon=False, \
815  bbox_to_anchor=(1.02, 1), borderaxespad=0)
816 
817  if invert_ind_axis:
818  ax.invert_yaxis()
819 
820  ax.grid()
821 
822  return
823 
824 
825 ###############################################################################
826 lenWarnTS=0
827 nanWarnTS=0
828 def plotTimeSeries(fig, \
829  xsDates, linesVals, \
830  linesLabel, \
831  title="", dataLabel="", \
832  sciticks=False, logscale = False, signdef=False, \
833  ny=1, nx=1, nplots=1, iplot=0, \
834  linesValsMinCI=None, linesValsMaxCI=None, \
835  dmin=np.NaN, dmax=np.NaN, \
836  lineAttribOffset=0, \
837  legend_inside=True,
838  interiorLabels=True):
839 
840 # ARGUMENTS
841 # fig - matplotlib figure object
842 # xsDates - date x-values (list/array or list of lists/arrays
843 # of float seconds, dt.timedelta, dt.datetime)
844 # linesVals - dependent variable (list of arrays)
845 # linesLabel - legend label for linesVals (list)
846 
847 # title - subplot title, optional
848 # dataLabel - label for linesVals, optional
849 # sciticks - whether linesVals needs scientific formatting for ticks, optional
850 # logscale - y-axis is scaled logarithmically, optional, overrides sciticks
851 # signdef - whether linesVals is positive/negative definite, optional
852 
853 # ny, nx - number of subplots in x/y direction, optional
854 # nplots - total number of subplots, optional
855 # iplot - this subplot index (starting at 0), optional
856 
857 # linesValsMinCI - minimum error bound for linesVals (list of arrays), optional
858 # linesValsMaxCI - maximum error bound for linesVals (list of arrays), optional
859 # Note: linesValsMinCI and linesValsMaxCI must be specified together
860 
861 # lineAttribOffset - offset for selecting line attributes, optional
862 # dmin, dmax - min/max values of linesVals, optional
863 # legend_inside - whether legend should be placed inside the subplot, optional
864 
865  ax = fig.add_subplot(ny, nx, iplot+1)
866 
867  #title
868  ax.set_title(title,fontsize=5)
869 
870  #add lines
871  plotVals = np.asarray([])
872  nLines = 0
873  jline = 0
874  for iline, lineVals in enumerate(linesVals):
875  if np.all(np.isnan(lineVals)):
876  global nanWarnTS
877  if nanWarnTS==0:
878  _logger.warning("skipping all-NaN data")
879  _logger.warning(title+"; "+dataLabel+"; "+linesLabel[iline])
880  nanWarnTS=nanWarnTS+1
881  continue
882 
883  #float xVals
884  if isinstance(xsDates[0],(list,np.ndarray)):
885  xVals = pu.TDeltas2Seconds(xsDates[min([iline,len(xsDates)-1])])
886  else:
887  xVals = pu.TDeltas2Seconds(xsDates)
888 
889  if len(lineVals)!=len(xVals):
890  global lenWarnTS
891  if lenWarnTS==0:
892  _logger.warning("skipping data where len(x)!=len(y)")
893  _logger.warning(title+"; "+dataLabel+"; "+linesLabel[iline])
894  lenWarnTS=lenWarnTS+1
895  continue
896 
897  if jline == 0:
898  minX = xVals[0]
899  maxX = xVals[-1]
900  else:
901  minX = min([xVals[0], minX])
902  maxX = max([xVals[-1], maxX])
903  jline += 1
904 
905  # Plot line for each lineVals that has non-missing data
906  pColor = pu.plotColor(len(linesVals),iline+lineAttribOffset)
907 
908  ax.plot(xVals, lineVals, \
909  label=linesLabel[iline], \
910  color=pColor, \
911  ls=pu.plotLineStyle(len(linesVals),iline+lineAttribOffset), \
912  linewidth=0.5)
913  nLines += 1
914  plotVals = np.append(plotVals, lineVals)
915 
916  # Add shaded CI regions if specified
917  if linesValsMinCI is not None and \
918  linesValsMaxCI is not None:
919 
920  # test statistical significance versus zero
921  if signdef:
922  significant = np.empty(len(lineVals))
923  significant[:] = np.NaN
924  else:
925  significant = np.multiply(linesValsMinCI[iline], linesValsMaxCI[iline])
926  significant = np.array([x if np.isfinite(x) else -1.0 for x in significant])
927 
928  lineArr = np.array(lineVals)
929  xArr = np.array(xVals)
930  negsiginds = np.array([i for i,x in enumerate(significant)
931  if (x > 0.0 and lineArr[i] < 0.0)],dtype=int)
932  if len(negsiginds) > 0:
933  ax.plot(xArr[negsiginds], lineArr[negsiginds], \
934  color=pColor, \
935  ls='', \
936  marker='v', \
937  markersize=1.5)
938 
939  possiginds = np.array([i for i,x in enumerate(significant)
940  if (x > 0.0 and lineArr[i] > 0.0)],dtype=int)
941  if len(possiginds) > 0:
942  ax.plot(xArr[possiginds], lineArr[possiginds], \
943  color=pColor, \
944  ls='', \
945  marker='^', \
946  markersize=1.5)
947 
948  ax.plot(xVals, linesValsMinCI[iline], \
949  color=pColor, \
950  alpha=0.4, \
951  ls='-', \
952  linewidth=0.5)
953  ax.plot(xVals, linesValsMaxCI[iline], \
954  color=pColor, \
955  alpha=0.4, \
956  ls='-', \
957  linewidth=0.5)
958  ax.fill_between(xVals, linesValsMinCI[iline], linesValsMaxCI[iline], \
959  color=pColor, \
960  edgecolor=pColor, \
961  linewidth=0.0, alpha = 0.1)
962  ax.fill_between(xVals, linesValsMinCI[iline], linesValsMaxCI[iline], \
963  where=significant > 0.0, \
964  color=pColor, \
965  edgecolor=pColor, \
966  linewidth=0.2, alpha = 0.3)
967 
968  if nLines == 0:
969  ax.tick_params(axis='x',labelbottom=False)
970  ax.tick_params(axis='y',labelleft=False)
971  return
972 
973  # standardize y-limits
974  mindval, maxdval = pu.get_clean_ax_limits(dmin,dmax,plotVals,signdef)
975 
976  # add horizontal zero line for unbounded quantities
977  if not signdef:
978  ax.plot([minX, maxX], [0., 0.], ls="--", c=".3", \
979  linewidth=0.7,markersize=0)
980 
981  #axes settings
982  if isinstance(xsDates[0],(list,np.ndarray)):
983  pu.format_x_for_dates(ax, xsDates[0])
984  else:
985  pu.format_x_for_dates(ax, xsDates)
986 
987  ax.xaxis.set_tick_params(labelsize=3)
988  ax.yaxis.set_tick_params(labelsize=3)
989  isLogScale = logscale
990  if logscale:
991  nonzero = np.logical_and(np.greater(np.abs(plotVals), 0.), np.isfinite(plotVals))
992  if nonzero.sum() > 0:
993  vmin = np.nanmin(np.abs(plotVals[nonzero]))
994  vmax = np.nanmax(np.abs(plotVals[nonzero]))
995  if signdef:
996  # log tick labels look bad for single decade
997  if vmax / vmin > 10.0:
998  ax.set_yscale('log')
999  else:
1000  isLogScale = False
1001  else:
1002  ax.set_yscale('symlog')
1003  else:
1004  isLogScale = False
1005 
1006  if isLogScale and np.isfinite(maxdval) and maxdval > 0.:
1007  ax.set_ylim(None, maxdval)
1008  if np.abs(vmin) > 0.:
1009  ax.set_ylim(vmin, None)
1010 
1011  if not isLogScale:
1012  if sciticks:
1013  ax.ticklabel_format(style='sci', axis='y', scilimits=(0,0))
1014  if (np.isfinite(mindval) and
1015  np.isfinite(maxdval)):
1016  ax.set_ylim(mindval,maxdval)
1017  if maxdval-mindval < 1.0 or \
1018  maxdval-mindval > 100.0:
1019  ax.tick_params(axis='y',rotation=-35)
1020  ax.yaxis.get_offset_text().set_fontsize(3)
1021 
1022  ax.grid()
1023 
1024  #handle interior subplot ticks/labels
1025  ix = int(iplot)%int(nx)
1026  iy = int(iplot)/int(nx)
1027  if not interiorLabels \
1028  and (iy < ny-2 or ( iy == ny-2 and (int(nplots)%int(nx)==0 or ix <= (int(nplots)%int(nx) - 1)) )):
1029  ax.tick_params(axis='x',labelbottom=False)
1030  if interiorLabels or ix == 0:
1031  ax.set_ylabel(dataLabel,fontsize=4)
1032 
1033  #legend
1034  if nLines <= maxLegendEntries:
1035  if legend_inside:
1036  #INSIDE AXES
1037  nlcol = np.int(np.ceil(np.sqrt(nLines)))
1038  lh = ax.legend(loc='best',fontsize=3,frameon=True,\
1039  framealpha=0.4,ncol=nlcol)
1040  lh.get_frame().set_linewidth(0.0)
1041  elif ix==nx-1 or iplot==nplots-1:
1042  #OUTSIDE AXES
1043  ax.legend(loc='upper left',fontsize=3,frameon=False, \
1044  bbox_to_anchor=(1.02, 1), borderaxespad=0)
1045 
1046 
1047  return
1048 
1049 
1050 ###############################################################################
1051 def plotTimeSeries2D(fig, \
1052  xDates, yVals, contourVals, \
1053  title="", clabel="", \
1054  sciticks=False, logscale=False, signdef=False, \
1055  dataLabel="y", invert_ind_axis=False, \
1056  ny=1, nx=1, nplots=1, iplot=0, \
1057  dmin=np.NaN, dmax=np.NaN,
1058  interiorLabels=True):
1059 
1060 # ARGUMENTS
1061 # fig - matplotlib figure object
1062 # xDates - date x-values (array of float seconds, dt.timedelta, dt.datetime)
1063 # yVals - second independent variable
1064 # contourVals - dependent variable (2d array)
1065 
1066 # title - subplot title, optional
1067 # clabel - label for dependent variable, optional
1068 # sciticks - whether contourVals needs scientific formatting for ticks, optional
1069 # logscale - whether contours are spaced logarithmically, optional, overrides sciticks
1070 # signdef - whether contourVals is positive/negative definite, optional
1071 # dataLabel - label for yVals, optional
1072 # invert_ind_axis - whether to invert y-axis orientation, optional
1073 
1074 # ny, nx - number of subplots in x/y direction, optional
1075 # nplots - total number of subplots, optional
1076 # iplot - this subplot index (starting at 0), optional
1077 
1078 # dmin, dmax - min/max values of contourVals, optional
1079 
1080  ax = fig.add_subplot(ny, nx, iplot+1)
1081 
1082  if (np.isnan(contourVals)).all():
1083  ax.tick_params(axis='x',labelbottom=False)
1084  ax.tick_params(axis='y',labelleft=False)
1085  return
1086 
1087  xVals = pu.TDeltas2Seconds(xDates)
1088 
1089  # standardize c-limits
1090  mindval, maxdval = pu.get_clean_ax_limits(dmin,dmax,contourVals,signdef)
1091  if signdef:
1092  cmapName = 'BuPu'
1093  nlevs = 18
1094 
1095  # scientific contours
1096  cint = contourVals.astype(int)
1097  isInt = np.all((contourVals - cint) == 0)
1098  if isInt:
1099  minscid = np.nanmax(np.array([1., dmin]))
1100  else:
1101  minscid = maxdval*1.e-5
1102  lognorm = colors.LogNorm(vmin=minscid, vmax=maxdval)
1103  else:
1104  cmapName = 'seismic'
1105  nlevs = 28
1106 
1107  # scientific contours
1108  lognorm = colors.SymLogNorm(vmin=mindval, vmax=maxdval,
1109  linthresh=1.e-3*maxdval, linscale=1.3, base=10)
1110 
1111  # plot contour
1112  # option 1: smoothed contours
1113  #cp = ax.contourf(xVals, yVals, contourVals, nlevs, cmap=cmapName, extend='both', \
1114  # vmin=mindval, vmax=maxdval)
1115 
1116  # option 2: pixel contours
1117  cmap = plt.get_cmap(cmapName)
1118  cmap.set_bad(color = 'k', alpha = 1.0)
1119  if logscale:
1120  norm = lognorm
1121  else:
1122  levels = MaxNLocator(nbins=nlevs).tick_values(mindval,maxdval)
1123  norm = BoundaryNorm(levels, ncolors=cmap.N, clip=True)
1124  xVals_pcolor, yVals_pcolor = transformXY_for_pcolor(xVals,yVals)
1125  cp = ax.pcolormesh(xVals_pcolor, yVals_pcolor, contourVals, cmap=cmap, norm=norm)
1126 
1127  #title
1128  ax.set_title(title,fontsize=5)
1129 
1130  #axes settings
1131  pu.format_x_for_dates(ax, xDates)
1132  ax.xaxis.set_tick_params(labelsize=3)
1133  ax.yaxis.set_tick_params(labelsize=3)
1134 
1135  #handle interior subplot ticks/labels
1136  ix = int(iplot)%int(nx)
1137  iy = int(iplot)/int(nx)
1138  if not interiorLabels \
1139  and (iy < ny-2 or ( iy == ny-2 and (int(nplots)%int(nx)==0 or ix <= (int(nplots)%int(nx) - 1)) )):
1140  ax.tick_params(axis='x',labelbottom=False)
1141  if interiorLabels or ix == 0:
1142  ax.set_ylabel(dataLabel,fontsize=4)
1143  if interiorLabels or ix == nx-1:
1144  #colorbar
1145  m = plt.cm.ScalarMappable(cmap=cmap)
1146  m.set_array(contourVals)
1147  m.set_norm(norm)
1148  if (np.isfinite(mindval) and
1149  np.isfinite(maxdval) and
1150  not logscale):
1151  m.set_clim(mindval,maxdval)
1152  cb = plt.colorbar(m, ax=ax)
1153  #scientific formatting
1154  if sciticks and not logscale:
1155  cb.ax.ticklabel_format(style='sci', axis='y', scilimits=(0,0))
1156  cb.ax.yaxis.get_offset_text().set_fontsize(3)
1157 
1158  cb.ax.tick_params(labelsize=3)
1159  cb.set_label(clabel,fontsize=5)
1160 
1161  if invert_ind_axis:
1162  ax.invert_yaxis()
1163 
1164  # optionally add a grid
1165  #ax.grid()
1166 
1167  return
1168 
1169 
1170 ###############################################################################
1171 def transformXY_for_pcolor(xs,ys):
1172  # adjust centered x and y values to edges to work with pcolormesh
1173  # note: works best for regularly spaced data
1174  xs_diff = xs[1] - xs[0]
1175  # extend xs by 2
1176  # fill in first endpoint
1177  xs_extend = [xs[0]-xs_diff]
1178  # fill in internal values
1179  for x in xs: xs_extend.append(x)
1180  # fill in last endpoint
1181  xs_extend.append(xs_extend[-1]+(xs[-1]-xs[-2]))
1182  # calculate the midpoints
1183  xs_pcolormesh_midpoints = []
1184  for ii, x in enumerate(xs_extend[:-1]):
1185  xs_pcolormesh_midpoints.append(x+0.5*(xs_extend[ii+1] - xs_extend[ii]))
1186 
1187  ys_diff = ys[1] - ys[0]
1188  # extend ys by 2
1189  # fill in first endpoint
1190  ys_extend = [ys[0]-ys_diff]
1191  # fill in internal values
1192  for y in ys: ys_extend.append(y)
1193  # fill in last endpoint
1194  ys_extend.append(ys_extend[-1]+(ys[-1]-ys[-2]))
1195  # calculate the midpoints
1196  ys_pcolormesh_midpoints = []
1197  for ii, y in enumerate(ys_extend[:-1]):
1198  ys_pcolormesh_midpoints.append(y+0.5*(ys_extend[ii+1] - ys_extend[ii]))
1199 
1200  return xs_pcolormesh_midpoints, ys_pcolormesh_midpoints
1201 
1202 
1203 ###############################################################################
1204 lenWarnPDF = 0
1205 nanWarnPDF = 0
1206 def plotPDF(fig,
1207  countsVals, xVals,
1208  countsLabel,
1209  title="",
1210  indepLabel="x",
1211  ny=1, nx=1, nplots=1, iplot=0,
1212  lineAttribOffset=1,
1213  legend_inside=True,
1214  interiorLabels=True):
1215 
1216 # ARGUMENTS
1217 # fig - matplotlib figure object
1218 # countsVals - list of arrays, each containing counts across xVals
1219 # xVals - independent variable on x-axis (array)
1220 # countsLabel - legend label for countsVals (list)
1221 
1222 # title - subplot title, optional
1223 # indepLabel - label for xVals, optional
1224 
1225 # ny, nx - number of subplots in x/y direction, optional
1226 # nplots - total number of subplots, optional
1227 # iplot - this subplot index (starting at 0), optional
1228 
1229 # lineAttribOffset - offset for selecting line attributes, optional
1230 # legend_inside - whether legend should be placed inside the subplot, optional
1231 
1232  ax = fig.add_subplot(ny, nx, iplot+1)
1233 
1234  #title
1235  ax.set_title(title,fontsize=5)
1236 
1237  #add counts
1238  plotVals = []
1239  nPDFs = 0
1240  for ihist, countVals in enumerate(countsVals):
1241  if np.all(np.isnan(countVals)):
1242  global nanWarnPDF
1243  if nanWarnPDF==0:
1244  _logger.warning("skipping all-NaN data")
1245  _logger.warning(title+"; "+indepLabel+"; "+countsLabel[ihist])
1246  nanWarnPDF=nanWarnPDF+1
1247  continue
1248  if len(countVals)!=len(xVals):
1249  global lenWarnPDF
1250  if lenWarnPDF==0:
1251  _logger.warning("skipping data where len(x)!=len(y)")
1252  _logger.warning(title+"; "+indepLabel+"; "+countsLabel[ihist])
1253  lenWarnPDF=lenWarnPDF+1
1254  continue
1255 
1256  # Plot line for each countVals that has non-missing data
1257 
1258  # assume constant dx between bins
1259  dx = xVals[1] - xVals[0]
1260 
1261  ax.plot(xVals, np.divide(countVals,np.sum(countVals)*dx),
1262  color=pu.plotColor(len(countsVals),ihist+lineAttribOffset),
1263  label=countsLabel[ihist],
1264  ls=pu.plotLineStyle(len(countsVals),ihist+lineAttribOffset),
1265  linewidth=0.5)
1266  nPDFs = nPDFs + 1
1267  plotVals.append(countVals)
1268 
1269 
1270  if nPDFs == 0:
1271  ax.tick_params(axis='x',labelbottom=False)
1272  ax.tick_params(axis='y',labelleft=False)
1273  return
1274 
1275  # add a standard normal pdf
1276  from scipy.stats import norm
1277  ax.plot(xVals, norm.pdf(xVals),
1278  color='k',
1279  ls='-',
1280  linewidth=0.35,
1281  label='N(0,1)'
1282  )
1283 
1284  #axes settings
1285  ax.xaxis.set_tick_params(labelsize=3)
1286  ax.yaxis.set_tick_params(labelsize=3)
1287  plt.yscale('log')
1288  ax.set_ylim(bottom=1.e-6)
1289 
1290  #handle interior subplot ticks/labels
1291  ix = int(iplot)%int(nx)
1292  iy = int(iplot)/int(nx)
1293  if not interiorLabels \
1294  and (iy < ny-2 or ( iy == ny-2 and (int(nplots)%int(nx)==0 or ix <= (int(nplots)%int(nx) - 1)) )):
1295  ax.tick_params(axis='x',labelbottom=False)
1296  if interiorLabels or ix == 0:
1297  ax.set_xlabel(indepLabel,fontsize=4)
1298  ax.set_ylabel('PDF',fontsize=4)
1299 
1300  #legend
1301  if legend_inside:
1302  #INSIDE AXES
1303  lh = ax.legend(loc='best',fontsize=3,frameon=True,\
1304  framealpha=0.4,ncol=1)
1305  lh.get_frame().set_linewidth(0.0)
1306  elif ix==nx-1 or iplot==nplots-1:
1307  #OUTSIDE AXES
1308  ax.legend(loc='upper left',fontsize=3,frameon=False, \
1309  bbox_to_anchor=(1.02, 1), borderaxespad=0)
1310 
1311  ax.grid()
1312 
1313  return
1314 
1315 
1316 ###############################################################################
1317 lenWarnRamp = 0
1318 nanWarnRamp = 0
1319 def plotfitRampComposite(fig,
1320  xVals,
1321  countVals,
1322  meanVals,
1323  rmsVals,
1324  stdVals,
1325  title="", dataLabel="y", \
1326  indepLabel="x",
1327  ny=1, nx=1, nplots=1, iplot=0,
1328  lineAttribOffset=1,
1329  legend_inside=True,
1330  interiorLabels=True):
1331 
1332 # ARGUMENTS
1333 # fig - matplotlib figure object
1334 # countVals - Count of quantity (array)
1335 # meanVals - Mean of quantity (array)
1336 # rmsVals - RMS of quantity (array)
1337 # stdVals - STD of quantity (array)
1338 
1339 # xVals - independent variable on x-axis (array)
1340 
1341 # title - subplot title, optional
1342 # dataLabel - label for y-axis, optional
1343 # indepLabel - label for xVals, optional
1344 
1345 # ny, nx - number of subplots in x/y direction, optional
1346 # nplots - total number of subplots, optional
1347 # iplot - this subplot index (starting at 0), optional
1348 
1349 # lineAttribOffset - offset for selecting line attributes, optional
1350 # legend_inside - whether legend should be placed inside the subplot, optional
1351 
1352  ax = fig.add_subplot(ny, nx, iplot+1)
1353  ix = int(iplot)%int(nx)
1354  iy = int(iplot)/int(nx)
1355 
1356  #title
1357  ax.set_title(title,fontsize=5)
1358 
1359  #add lines
1360  plotVals = []
1361  nLines = 0
1362  linesLabel = ['RMS','STD','Mean']
1363  for iline, lineVals in enumerate([rmsVals,stdVals,meanVals]):
1364  if np.all(np.isnan(lineVals)):
1365  global nanWarnRamp
1366  if nanWarnRamp==0:
1367  _logger.warning("skipping all-NaN data")
1368  _logger.warning(title+"; "+indepLabel+"; "+linesLabel[iline])
1369  nanWarnRamp=nanWarnRamp+1
1370  continue
1371  if len(lineVals)!=len(xVals):
1372  global lenWarnRamp
1373  if lenWarnRamp==0:
1374  _logger.warning("skipping data where len(x)!=len(y)")
1375  _logger.warning(title+"; "+indepLabel+"; "+linesLabel[iline])
1376  lenWarnRamp=lenWarnRamp+1
1377  continue
1378 
1379  # Plot line for each lineVals that has non-missing data
1380  pColor = pu.plotColor(4,iline+lineAttribOffset)
1381 
1382  ax.plot(xVals, lineVals,
1383  color=pColor,
1384  label=linesLabel[iline],
1385  ls=pu.plotLineStyle(4,iline+lineAttribOffset),
1386  linewidth=0.6)
1387  nLines += 1
1388  plotVals.append(lineVals)
1389 
1390  if nLines == 0:
1391  ax.tick_params(axis='x',labelbottom=False)
1392  ax.tick_params(axis='y',labelleft=False)
1393  return
1394 
1395  # Add fit for stdVals here using info from countVals
1396  ind0 = np.argmax(countVals)
1397 
1398  indexMaxX4Std = 0
1399  for ii, std in enumerate(stdVals):
1400  if np.isfinite(std): indexMaxX4Std = ii
1401  indexMaxX = indexMaxX4Std
1402  maxCount = 0
1403  for ii, count in enumerate(countVals):
1404  if count > maxCount: maxCount = count
1405  if count < 0.002*maxCount:
1406  indexMaxX = ii
1407  break
1408  if indexMaxX > indexMaxX4Std:
1409  ind1 = np.argmax(stdVals[0:indexMaxX4Std])
1410  else:
1411  ind1 = np.argmax(stdVals[0:indexMaxX])
1412 
1413  weights = [0.2]*(ind1-ind0+1)
1414  weights[0] = 1.0
1415  p = np.polyfit(xVals[ind0:ind1+1],stdVals[ind0:ind1+1],1,
1416  w=weights)
1417 
1418  X0 = xVals[ind0]
1419  ERR0 = X0 * p[0] + p[1]
1420 
1421  # X1 = xVals[ind1]
1422  # ERR1 = X1 * p[0] + p[1]
1423  ERR1 = stdVals[ind1]
1424  X1 = (ERR1 - p[1]) / p[0]
1425 
1426 
1427  ERRfitDict = {
1428  'bu':{
1429  'X': [round(X0,2), round(X1,2)],
1430  'ERR': [round(ERR0,2), round(ERR1,2)],
1431  },
1432  'YAML':{
1433  'X0': [round(X0,2)],
1434  'X1': [round(X1,2)],
1435  'ERR0': [round(ERR0,2)],
1436  'ERR1': [round(ERR1,2)],
1437  },
1438  }
1439 
1440  fitX = np.asarray([0.0] + ERRfitDict['bu']['X'] + [xVals[indexMaxX4Std]])
1441  fitERR = np.asarray([ERR0] + ERRfitDict['bu']['ERR'] + [ERR1])
1442 
1443  plotVals.append(fitERR)
1444 
1445  pColor = pu.plotColor(4,1+lineAttribOffset)
1446 
1447  ax.plot(fitX, fitERR,
1448  color=pColor,
1449  label='Fit-STD',
1450  ls='-.',
1451  linewidth=1.2,
1452  marker='+',
1453  ms=1.5
1454  )
1455 
1456  #axes settings
1457  ax.xaxis.set_tick_params(labelsize=3)
1458  ax.yaxis.set_tick_params(labelsize=3)
1459 
1460  # standardize x-limits
1461  mindval, maxdval = pu.get_clean_ax_limits(plotVals=plotVals)
1462  if (np.isfinite(mindval) and
1463  np.isfinite(maxdval)):
1464  ax.set_ylim(mindval,maxdval)
1465 
1466  #handle interior subplot ticks/labels
1467  if not interiorLabels \
1468  and (iy < ny-2 or ( iy == ny-2 and (int(nplots)%int(nx)==0 or ix <= (int(nplots)%int(nx) - 1)) )):
1469  ax.tick_params(axis='x',labelbottom=False)
1470  if interiorLabels or ix == 0:
1471  ax.set_xlabel(indepLabel,fontsize=4)
1472  if interiorLabels or iy == ny-1:
1473  ax.set_ylabel(dataLabel,fontsize=4)
1474 
1475  #legend
1476  if legend_inside:
1477  #INSIDE AXES
1478  lh = ax.legend(loc='best',fontsize=3,frameon=True,\
1479  framealpha=0.4,ncol=1)
1480  lh.get_frame().set_linewidth(0.0)
1481  elif ix==nx-1 or iplot==nplots-1:
1482  #OUTSIDE AXES
1483  ax.legend(loc='upper left',fontsize=3,frameon=False, \
1484  bbox_to_anchor=(1.02, 1), borderaxespad=0)
1485 
1486  ax.grid()
1487 
1488  # Add count on RHS y-axis
1489  ax2 = ax.twinx()
1490  color = 'black'
1491  if interiorLabels or ix == nx:
1492  ax2.set_ylabel('Count',fontsize=4,color=color)
1493  ax2.plot(xVals[:indexMaxX4Std], countVals[:indexMaxX4Std],
1494  color=color,
1495  label='Count',
1496  ls=':',
1497  linewidth=0.5)
1498  ax2.tick_params(axis='y', labelcolor=color)
1499  ax2.yaxis.set_tick_params(labelsize=3)
1500  plt.yscale('log')
1501  ax2.set_ylim(bottom=100.)
1502 
1503  return ERRfitDict
basic_plot_functions.cmSpectral
cmSpectral
Definition: basic_plot_functions.py:26
basic_plot_functions.plotfitRampComposite
def plotfitRampComposite(fig, xVals, countVals, meanVals, rmsVals, stdVals, title="", dataLabel="y", indepLabel="x", ny=1, nx=1, nplots=1, iplot=0, lineAttribOffset=1, legend_inside=True, interiorLabels=True)
Definition: basic_plot_functions.py:1330
basic_plot_functions.plotTimeserial2D
def plotTimeserial2D(Stats, xlabeltime, ylevels, VarName)
Definition: basic_plot_functions.py:331
basic_plot_functions.transformXY_for_pcolor
def transformXY_for_pcolor(xs, ys)
Definition: basic_plot_functions.py:1171
basic_plot_functions.plotTimeSeries
def plotTimeSeries(fig, xsDates, linesVals, linesLabel, title="", dataLabel="", sciticks=False, logscale=False, signdef=False, ny=1, nx=1, nplots=1, iplot=0, linesValsMinCI=None, linesValsMaxCI=None, dmin=np.NaN, dmax=np.NaN, lineAttribOffset=0, legend_inside=True, interiorLabels=True)
Definition: basic_plot_functions.py:838
basic_plot_functions.plotSeries
def plotSeries(fig, linesVals, xVals, linesLabel, title="", dataLabel="y", sciticks=False, logscale=False, signdef=False, indepLabel="x", invert_ind_axis=False, ny=1, nx=1, nplots=1, iplot=0, linesValsMinCI=None, linesValsMaxCI=None, dmin=np.NaN, dmax=np.NaN, lineAttribOffset=0, legend_inside=True, interiorLabels=True)
Definition: basic_plot_functions.py:419
basic_plot_functions.cmHeat
cmHeat
Definition: basic_plot_functions.py:27
basic_plot_functions.scatterMapFields
def scatterMapFields(lons, lats, fields, filename, minLon=-180., maxLon=180., minLat=-90., maxLat=90., cLon=None, projection='default', dmin=None, dmax=None, markers={}, sizes={}, cmap='gist_ncar', cbarType=None, c={}, logVLim=1.e-12)
Definition: basic_plot_functions.py:232
basic_plot_functions.cmGray
cmGray
Definition: basic_plot_functions.py:24
basic_plot_functions.plotPDF
def plotPDF(fig, countsVals, xVals, countsLabel, title="", indepLabel="x", ny=1, nx=1, nplots=1, iplot=0, lineAttribOffset=1, legend_inside=True, interiorLabels=True)
Definition: basic_plot_functions.py:1214
basic_plot_functions.plotTimeSeries2D
def plotTimeSeries2D(fig, xDates, yVals, contourVals, title="", clabel="", sciticks=False, logscale=False, signdef=False, dataLabel="y", invert_ind_axis=False, ny=1, nx=1, nplots=1, iplot=0, dmin=np.NaN, dmax=np.NaN, interiorLabels=True)
Definition: basic_plot_functions.py:1058
basic_plot_functions.plotDistri
def plotDistri(lats, lons, values, ObsType, VarName, var_unit, out_name, nstation, levbin, dmin=None, dmax=None, dotsize=6, color="rainbow")
Definition: basic_plot_functions.py:76
basic_plot_functions.cmNCAR
cmNCAR
Definition: basic_plot_functions.py:29
basic_plot_functions.plotProfile
def plotProfile(fig, linesVals, yVals, linesLabel, title="", dataLabel="x", sciticks=False, logscale=False, signdef=False, indepLabel="y", invert_ind_axis=False, ny=1, nx=1, nplots=1, iplot=0, linesValsMinCI=None, linesValsMaxCI=None, dmin=np.NaN, dmax=np.NaN, lineAttribOffset=0, legend_inside=True, interiorLabels=True)
Definition: basic_plot_functions.py:628