def gridmasks(event, lon, lat, trkkey=False, compress=True):
'''This simple script produces grid masks for each contour associated with
each event
Usage: masks = event.gridmasks(lat,lon)
lat and lon are the coordinates of the associated gridded data
trkkey=False implies get the masks for all mbskeys
trkkey='noaa-olr-0-all' implies compute the masks for only
that dataset
compress=True means multi-track variables are going to be flattened
into one mask
Returns: masks (dict) mask['mbs-keys-you-specified'] = {}
'''
e = event
if trkkey == False:
mbskeys = e.trkarrs.keys()
mbskeys.sort()
elif isinstance(trkkey, str):
mbskeys = [trkkey]
elif isinstance(trkkey, list):
mbskeys = trkkey
# MAIN LOOP OF METHOD
masks = {}
for mbk in mbskeys:
if isinstance(e.trkarrs[mbk], dict):
print 'No track array for', mbk, 'in event', e.trkkey
continue
trkarr = np.int32(e.trkarrs[mbk])
if trkarr.ndim == 2:
ntimes = trkarr.shape[0]
maskarr = np.bool8(np.ones((ntimes, len(lat), len(lon))))
for t in xrange(ntimes):
if trkarr[t, 1] != -1:
maskarr[t, :, :] = my.poly2mask(
lon,
lat,
event.blobs[mbk]['ch'][trkarr[t, 1]],
invert=True)
elif trkarr.ndim == 3:
ntimes, ntrks = trkarr.shape[0], trkarr.shape[2]
maskarr = np.bool8(np.ones((ntimes, len(lat), len(lon), ntrks)))
for t in xrange(ntimes):
for n in xrange(ntrks):
if trkarr[t, 1, n] != -1:
maskarr[t, :, :, n] = my.poly2mask(
lon,
lat,
e.blobs[mbk]['ch'][trkarr[t, 1, n]],
invert=True)
if compress:
maskarr_c = maskarr[:, :, :, 0]
for z in xrange(ntrks):
maskarr_c = maskarr_c & maskarr[:, :, :, z]
maskarr = maskarr_c
masks[mbk] = maskarr
return masks
def grideventmask(allpolys, s, lon, lat):
'''Returns a mask for gridded dataset for each day of each event
format: dictionary for each entry'''
keylist = allpolys.keys()
keylist.sort()
gridmasks = {}
masklist = []
maskdtimes = []
maskekeys = []
for k in keylist:
polylist = []
hrsince = s.events[k].trkarrs[s.events[k].refkey][:, 0]
dtimes = my.hrnum2dates(hrsince)
chulltrue = s.events[k].trkarrs[s.events[k].refkey][:, 1] != -1
print chulltrue, dtimes
cnt = 0
for poly in allpolys[k]:
if chulltrue[cnt]:
chmask = my.poly2mask(lon, lat, poly)
polylist.append(chmask)
masklist.append(chmask)
maskdtimes.append(dtimes[cnt])
maskekeys.append(k)
cnt += 1
gridmasks[k] = polylist
return gridmasks, masklist, maskdtimes, maskekeys
erain.append((rmn, rmx, wetness, heavyness, ormn, ormx,
owetness, rsum, hsum))
# GRIDDED RAINFALL
elif rain.ndim == 3:
#print 'Gridded rainfall dataset:',rainkey
for t in xrange(len(event.trkdtimes)):
ix = my.ixdtimes(date,[event.trkdtimes[t,0]],\
[event.trkdtimes[t,1]],[event.trkdtimes[t,2]],[0])
#ix = my.ixdtimes(date,[event.trkdtimes[t,0]],\
# [event.trkdtimes[t,1]],[event.trkdtimes[t,2]],[event.trkdtimes[t,3]])
if len(ix) > 1: print 'We have a problem'
elif len(ix) == 0:
if t == 0:
print 'No time match in', rainkey, event.trkdtimes[t]
continue
chmask = my.poly2mask(xypts[0],xypts[1],\
event.blobs[event.refkey]['ch'][event.trk[t]])
wetmask = rain[ix, :, :] >= 1.0
rmask = chmask & wetmask
heavymask = rain[ix, :, :] >= heavythresh
hmask = chmask & heavymask
r = np.ma.MaskedArray(rain[ix, :, :], mask=~rmask)
h = np.ma.MaskedArray(rain[ix, :, :], mask=~hmask)
if np.any(rmask):
# RAIN FALL INSIDE OLR COUNTOUR
rmn = r.mean()
rmx = r.max()
rsum = r.sum()
hsum = np.nansum(h)
wetness=len(np.where(rmask.ravel())[0])/\
float(len(np.where(chmask.ravel())[0]))
heavyness=len(np.where(hmask.ravel())[0])/\
def spatiofreq2(m,s,lat,lon,yrs,eventkeys,meanmask=False,figno=1,\
clim=(4,36,4),month=False,flagonly=False,fontdict=False):
'''Get grid-cell frequencies for no. of times a grid-cell falls within a
contour describing a feature from metblobs.
USAGE: If wish to create Basemap within function, m will be "create"
if wish to have only for particular month, month=yourchoice
if wish to only count for flagged days, flagonly=True'''
#plt.close('all')
if not fontdict: fd = {'fontsize': 14, 'fontweight': 'bold'}
else: fd = fontdict
mbskeys = s.mbskeys
refkey = s.events.values()[0].refkey
basekey = refkey
try:
dset, varstr, levsel, deriv, expid = basekey.split('-')
descr = dset + '-' + varstr
except:
dset, varstr, levsel, deriv = basekey.split('-')
descr = dset + '-' + varstr
#vkey='%s-%s-%s-%s' %(dset, varstr, levsel, deriv)
#x1,x2,y1,y2=blb.blobfilters[sub+'cloudband'][vkey]['ROI']
#nx, ny = np.abs(x1-x2)/res, np.abs(y1-y2)/res
#grdsz = (np.int32(nx),np.int32(ny))
if not eventkeys:
eventkeys = []
for ed in s.uniques:
eventkeys.append(ed[0])
x, y = np.array(()), np.array(())
#lon=np.arange(lon[0],lon[-1]+1,0.5)
#lat=np.arange(lat[0],lat[-1]-1,-0.5)
allmask = np.zeros((lat.shape[0], lon.shape[0]), dtype=np.float32)
#Determine which variable we dealing with
countkey = refkey
if flagonly: countkey = s.flagkey
for k in eventkeys:
e = s.events[k]
if month:
mn = month
mst = e.trkdtimes[0, 1]
if mst != mn: continue
if flagonly:
itrk = e.ixflags
else:
trkarr = np.int32(e.trkarrs[countkey])
if trkarr.ndim == 2:
ixt = np.where(trkarr[:, 1] > 0)[0]
uni, iu = np.unique(trkarr[ixt, 0], return_index=True)
itrk = trkarr[ixt, 1]
#print len(itrk),":",itrk
elif trkarr.ndim == 3:
itrk = np.ndarray((0, ), dtype=np.int32)
for d in xrange(trkarr.shape[2]):
ixt = np.where(trkarr[:, 1, d] > 0)[0]
uni, iu = np.unique(trkarr[ixt, 0], return_index=True)
ixt = ixt[iu]
itrk = np.append(itrk, trkarr[ixt, 1, d].squeeze())
# Get masks for each contour feature of a track
for ixtrk in itrk:
mask = my.poly2mask(lon, lat, e.blobs[countkey]['ch'][ixtrk])
allmask = allmask + np.float32(mask)
#cm=plt.cm.PuBu
#cm=plt.cm.gist_earth_r
#cm=plt.cm.YlGnBu
#cm=plt.cm.binary
#cm=plt.cm.OrRd
if isinstance(meanmask, np.ndarray):
cm = plt.cm.RdBu
#cm=plt.cm.bwr
else:
cm = plt.cm.gist_gray_r
#cm=plt.cm.jet
#cm=plt.cm.gray_r
cm.set_under(color='w')
if m == 'create':
m, f = blb.SAfrBasemap(lat[3:-6],lon[3:-3],drawstuff=True,\
prj='cyl',fno=figno,rsltn='l')
#df=m.transform_scalar(allmask[::-1,:],lon,lat[::-1],len(lon),len(lat))
#m.imshow(df,cm,interpolation='nearest')
#m.pcolor(lon,lat,allmask,cmap=cm)
#plt.clim(300,1200)
lon, lat = np.meshgrid(lon, lat)
#m.contourf(lon,lat,(allmask/len(yrs)),cmap=cm)
#
### Next is dirty trick to drop out permanent mid-latitude cloudiness
### allowing colormap to enhance cloud bands better
allmask[-9:, :] = 0
std_mask = allmask / len(yrs)
if isinstance(m, bool):
return std_mask
# IF M WAS NOT A BOOLEAN (False) THIS WILL CONTINUE TO PLOTTING
if isinstance(meanmask, np.ndarray):
std_mask = std_mask - meanmask
std_mask = np.where(np.abs(std_mask) < .5, np.nan, std_mask)
lnmin,lnmx,latmn,latmx =\
blb.filters.blobfilters['SAcloudband'][countkey]['ROI']
latmask = (lat < latmn) & (lat > latmx) # this is for S. Hemisphere
meanmasked = np.ma.MaskedArray(meanmask, mask=~latmask)
cs = m.contour(lon, lat, meanmasked, [1, 2, 3, 4], colors='k')
labels=plt.clabel(cs, [1,2,3,4],inline_spacing=2, fmt='%d',\
fontsize=14)
#m.contourf(lon,lat,meanmasked,[2,4,14],hatches=['.','..'],\
# colors='none',linestyles='-',linewidths='1',alpha=.1)
## NEED TO DO THIS SINCE PCOLOR IS NOT SHADING VALUES OUTSIDE OF THE CLIMS
cstd_mask = np.where(std_mask > clim[1], clim[1], std_mask)
cstd_mask = np.where(cstd_mask < clim[0], clim[0], cstd_mask)
# Plot pcolor
pcolmap = m.pcolormesh(lon, lat, cstd_mask, cmap=cm, zorder=1)
img = plt.gci()
for k in eventkeys:
e = s.events[k]
if month:
mn = month
mst = e.trkdtimes[0, 1]
if mst != mn: continue
m.plot(e.trkcX[0], e.trkcY[0], color='w', marker='o', markersize=4)
if 'COL' in e.mbskeys:
if len(e.assoctrks['COL']) > 0:
trar = e.trkarrs['COL']
for ntrk in xrange(trar.shape[2]):
ixx = np.where(trar[:, 1, ntrk] > 0)[0]
xx, yy = trar[ixx, 2, ntrk], trar[ixx, 3, ntrk]
off = np.random.rand() * .5
m.scatter(xx[-1]+off,yy[-1]+off,50,color='none',\
edgecolor='k',marker='o',linewidth='2')
plt.sci(img)
#m.plot(e.trkcX,e.trkcY,'0.5')
plt.clim(clim[0], clim[1])
bounds = np.arange(clim[0], clim[1] + clim[2], clim[2])
#vals=np.arange(0,35,2)
if not month:
f, ax = plt.gcf(), plt.gca()
axcol = f.add_axes([0.93, 0.2, 0.02, 0.6])
plt.colorbar(mappable=img, cax=axcol, boundaries=bounds)
my.ytickfonts()
if isinstance(meanmask, np.ndarray):
plt.ylabel('anomaly grid-point count / year', fontdict=fd)
else:
plt.ylabel('grid-point count / year', fontdict=fd)
plt.axes(ax)
plt.title('Cloudband Annual Grid-Point Count Climatology: '\
+descr.upper(),fontsize='14',fontdict=fd)
fname = figdir + '/FootprintFreqencygray-' + descr + '.png'
if flagonly:
fname = figdir + '/FootprintFreqencygray-' + descr + '_flagonly.png'
plt.savefig(fname, dpi=150)
elif month:
f, ax = plt.gcf(), plt.gca()
axcol = f.add_axes([0.93, 0.2, 0.02, 0.6])
plt.colorbar(cax=axcol, boundaries=bounds)
my.ytickfonts()
if isinstance(meanmask, np.ndarray):
plt.ylabel('anomaly grid-point count / year', fontdict=fd)
else:
plt.ylabel('grid-point count / year', fontdict=fd)
plt.axes(ax)
plt.title(mndict[month], fontweight='demibold')
return std_mask