SWN_tave = np.mean(SWN, axis=0) xx, yy = np.meshgrid(x, y) times = np.arange(t2D[0], t2D[-1]) db = 1 #AVERAGING PERIOD IN DAYS nave = 5 #PW_t = PW_tave[t,:,:] #PW_t = np.mean(PW_tave[t-nave:t,:,:], axis=0) #QNTOA_t = QNTOA_tave[t,:,:] #QNTOA_t = np.mean(QNTOA_tave[t-nave:t,:,:], axis=0) #QN_t = np.mean(QN_tave[t-nave:t,:,:], axis=0) PW_blocked = blockave2D(PW_tave, db) QNTOA_blocked = blockave2D(QNTOA_tave, db) SWN_blocked = blockave2D(SWN_tave, db) QN_blocked = blockave2D(QN_tave, db) PWxy_sorted = blockxysort2D(PW_tave, xx, yy, db) #fieldxy_sorted = blockxysort2D(field_t, xx, yy, db) PWsort = PWxy_sorted.keys() PWxycoords = PWxy_sorted.values() #fieldsort = fieldxy_sorted.keys() #fieldxycoords = fieldxy_sorted.values() mcenter = PWxycoords[-1] d = raddist(xx, yy, mcenter)
#Wvertbar = np.mean(np.mean(W, axis=0),axis=0)
#Wblock = blockave2D(Wvertbar, db)
#W500 = varis2D['W500'][t-aveperiod:t,:,:]
#W500_tave = np.mean(W500, axis=0)
#W500_block = blockave2D(W500_tave, db)
#nt3D = t3D.size
#nz = z.size
nx = x.size
ny = y.size
t3D = varis3D['time'][:]
nt3D = t3D.size
vari = varis2D[varname]
field = np.mean(vari[t - aveperiod:t, :, :], axis=0)
field = blockave2D(field, db)
nxprime = nx / db
nyprime = ny / db
field = field.flatten()
#W500_flat = W500_block.flatten()
W_flat = Wblock.flatten()
nbins = 100
#counts, bin_edges = np.histogram(W500_flat, bins=50)
#PWsum, bin_edges = np.histogram(W500_flat, bins=50, weights=field)
counts, bin_edges = np.histogram(W_flat, bins=nbins)
PWsum, bin_edges = np.histogram(W_flat, bins=nbins, weights=field)
bin_c = (bin_edges[1:] + bin_edges[:-1]) / 2
PWbar = PWsum / counts
plt.figure(1)
aveperiod = 24*nave aveperiod3D = 4*nave nc_data2D = Dataset(nc_in2D) nc_data3D = Dataset(nc_in3D) #varis3D = nc_data3D.variables varis2D = nc_data2D.variables varis3D = nc_data3D.variables x = varis2D['x'][:] y = varis2D['y'][:] #z = varis3D['z'][:] #p = varis3D['p'][:] #p = p*1e2 W = varis3D['W'][t-aveperiod3D:t,:,:,:] Wvertbar = np.mean(np.mean(W, axis=0),axis=0) Wblock = blockave2D(Wvertbar, db) #W_c=0.5 Wconvblock = Wblock[Wblock > W_c] Wdryblock = Wblock[Wblock < W_c] #W500 = varis2D['W500'][t-aveperiod:t,:,:] #W500_tave = np.mean(W500, axis=0) #W500_block = blockave2D(W500_tave, db) #nt3D = t3D.size #nz = z.size nx = x.size ny = y.size t3D = varis3D['time'][:] nt3D = t3D.size vari = varis2D[varname]
aveperiod2D = nave * ntave2D aveperiod3D = nave * ntave3D PW = varis2D['PW'][t - aveperiod2D:t, :, :] W = varis3D['W'][t - aveperiod3D:t, :, :, :] W_tave = np.mean(W, axis=0) W_ztave = np.mean(W_tave, axis=0) PW_tave = np.mean(PW, axis=0) db = 1 dbw = 2 W_ztave = blockave2D(W_ztave, dbw) PW_blocked = blockave2D(PW_tave, db) PWxy_sorted = blockxysort2D(PW_tave, xx, yy, db) #fieldxy_sorted = blockxysort2D(field_t, xx, yy, db) PWsort = PWxy_sorted.keys() PWxycoords = PWxy_sorted.values() #fieldsort = fieldxy_sorted.keys() #fieldxycoords = fieldxy_sorted.values() mcenter = PWxycoords[-1] d = raddist(xx, yy, mcenter)
#Pfield_t = P2D[k2,:,:]
#wfield_t = wfield[k,:,:,:]
w = varis3D['W'][k,:,:,:]
T = varis3D['TABS'][k,:,:,:]
QV = varis3D['QV'][k,:,:,:]
QV = QV*1e-3
nt = T.shape[0]
p3D = np.zeros((ny, nx, nz))
p3D[:,:,:] = p
p3D = p3D.T
rho = p3D/(T*c.Rd)
massflux = np.multiply(w, rho)
massflux_blockave = blockave3D(massflux, db)
wfield_blockave = blockave3D(w, db)
QV_blockave = blockave3D(QV, db)
P_blockave = blockave2D(P[k2,:,:], db)
#P_blockave = blockave2D(Pfield_t, db)
massflux_BLave = np.mean(massflux_blockave[:BLi,:,:], axis=0)
QV_BLave = np.mean(QV_blockave[:BLi,:,:], axis=0)
w_BLave = np.mean(wfield_blockave[:BLi,:,:], axis=0)
convBL_points = w_BLave > W_c
massflux_convave = np.mean(massflux_BLave[convBL_points])
QV_convave = np.mean(QV_BLave[convBL_points])
P_convave = np.mean(P_blockave[convBL_points])
qvflux[k] = massflux_convave*QV_convave
mflux[k] = massflux_convave
qvBL[k] = QV_convave
Pconv[k] = P_convave
#Pfield_t = P2D[k2,:,:]
#wfield_t = wfield[k,:,:,:]
w = varis3D['W'][k, :, :, :]
T = varis3D['TABS'][k, :, :, :]
QV = varis3D['QV'][k, :, :, :]
QV = QV * 1e-3
nt = T.shape[0]
p3D = np.zeros((ny, nx, nz))
p3D[:, :, :] = p
p3D = p3D.T
rho = p3D / (T * c.Rd)
massflux = np.multiply(w, rho)
massflux_blockave = blockave3D(massflux, db)
wfield_blockave = blockave3D(w, db)
QV_blockave = blockave3D(QV, db)
P_blockave = blockave2D(P[k2, :, :], db)
#P_blockave = blockave2D(Pfield_t, db)
massflux_BLave = np.mean(massflux_blockave[:BLi, :, :], axis=0)
QV_BLave = np.mean(QV_blockave[:BLi, :, :], axis=0)
w_BLave = np.mean(wfield_blockave[:BLi, :, :], axis=0)
convBL_points = w_BLave > W_c
massflux_convave = np.mean(massflux_BLave[convBL_points])
QV_convave = np.mean(QV_BLave[convBL_points])
P_convave = np.mean(P_blockave[convBL_points])
qvflux[k] = massflux_convave * QV_convave
mflux[k] = massflux_convave
qvBL[k] = QV_convave
Pconv[k] = P_convave
varname = 'W500' #W = varis2D[varname][:] W = varis3D['W'][t-nave3D:t,:,:,:] #W = varis2D[varname][t-aveperiod2D:t,:,:] W_tave = np.mean(W, axis=0) #W_blockave = blockave2D(W_tave, db) Wlow = np.mean(W_tave[plow_bi:plow_ti,:,:], axis=0) Wmid = np.mean(W_tave[plow_ti:phigh_bi,:,:], axis=0) Whigh = np.mean(W_tave[phigh_bi:phigh_ti,:,:], axis=0) Wlow_block = blockave2D(Wlow, db) Wmid_block = blockave2D(Wmid, db) Whigh_block = blockave2D(Whigh, db) #put code to select W at specific level #W_blockave = blockave2D(W_tavez, db) QN = varis3D['QN'][:] QN_tave = np.mean(QN[t-aveperiod3D:t,:,:,:], axis=0) cloudfreq = np.sign(QN_tave) cloudcount = blocksum3D(cloudfreq, db)
#time period to look at #t=-25*ntave3D #nave=5 #nave2D=5*ntave2D #nave3D=5*ntave3D #number of blocks to find PW max db = 1 print 'calulating max PW, blocked' #PW_t = np.mean(PW_tave[t-nave:t,:,:], axis=0) #PW_t = np.mean(PW[t-nave2D:t,:,:], axis=0) #calculate where the convective center is by using blocked max(PW) PW_tave = np.mean(PW, axis=0) PW_blocked = blockave2D(PW_tave, db) PWxy_sorted = blockxysort2D(PW_tave, xx, yy, db) PWsort = PWxy_sorted.keys() PWxycoords = PWxy_sorted.values() mcenter = PWxycoords[-1] binwidth = 5e3 rbins = np.arange(0, 1 / np.sqrt(2) * domsize * 1e3, binwidth) #calculate where the convective 'edge' is by using standard deviation definition #(other definitions may be better) PWrbins, PWmeans = radprof(PW_tave, xx, yy, mcenter, rbins) PWrbin_centers = (PWrbins[1:] + PWrbins[:-1]) / 2. a = 1.5
SWN_tave = np.mean(SWN, axis=0) xx, yy = np.meshgrid(x, y) times = np.arange(t2D[0], t2D[-1]) db=1 #AVERAGING PERIOD IN DAYS nave=5 #PW_t = PW_tave[t,:,:] #PW_t = np.mean(PW_tave[t-nave:t,:,:], axis=0) #QNTOA_t = QNTOA_tave[t,:,:] #QNTOA_t = np.mean(QNTOA_tave[t-nave:t,:,:], axis=0) #QN_t = np.mean(QN_tave[t-nave:t,:,:], axis=0) PW_blocked = blockave2D(PW_tave, db) QNTOA_blocked=blockave2D(QNTOA_tave, db) SWN_blocked = blockave2D(SWN_tave, db) QN_blocked=blockave2D(QN_tave, db) PWxy_sorted = blockxysort2D(PW_tave, xx, yy, db) #fieldxy_sorted = blockxysort2D(field_t, xx, yy, db) PWsort = PWxy_sorted.keys() PWxycoords = PWxy_sorted.values() #fieldsort = fieldxy_sorted.keys() #fieldxycoords = fieldxy_sorted.values() mcenter = PWxycoords[-1] d = raddist(xx, yy, mcenter)
p3D[:,:,:] = p
p3D = p3D.T
#p3D = p3D.T
#p4D = np.tile(p3D[:,:,:, np.newaxis], T.shape[0])
#p4D = p4D.T
THETA_tave = T_tave*(p0/p3D)**(c.Rd/c.cp)
diffTHETA = THETA_tave[1:,:,:] - THETA_tave[:-1,:,:]
diffz = np.diff(z)
diffz3D = np.zeros((nz-1, nx, ny))
diffz3D = diffz3D.T
diffz3D[:,:,:] = diffz
diffz3D = diffz3D.T
THETA_mid = (THETA_tave[1:,:,:] + THETA_tave[:-1,:,:])/2.
N_tave = (c.g*diffTHETA)/np.multiply(diffz3D, THETA_mid)
N_tave_vertave = np.mean(N_tave, axis=0)
field_tave = blockave2D(N_tave_vertave, db)
elif varname == 'URADIAL':
U_r_p = U_r[plevi,:,:]
field_tave = blockave2D(U_r_p, db)
elif varname == 'SFCSPEED':
USFC = varis2D['USFC'][t2-nave2D:t2,:,:]
VSFC = varis2D['VSFC'][t2-nave2D:t2,:,:]
speed = np.sqrt(np.power(USFC, 2) + np.power(VSFC, 2))
field_tave = np.mean(speed, axis=0)
field_tave = blockave2D(field_tave, db)
#look at different levels here
#p = varis3D['p'][:]
LWN_tave = np.mean(LWN, axis=0)
SWNC_tave = np.mean(SWNC, axis=0)
LWNC_tave = np.mean(LWNC, axis=0)
xx, yy = np.meshgrid(x, y)
times = np.arange(t2D[0], t2D[-1])
db = 1
#AVERAGING PERIOD IN DAYS
#PW_t = PW_tave[t,:,:]
#PW_t = np.mean(PW_tave[t-nave:t,:,:], axis=0)
#QNTOA_t = QNTOA_tave[t,:,:]
#QNTOA_t = np.mean(QNTOA_tave[t-nave:t,:,:], axis=0)
#QN_t = np.mean(QN_tave[t-nave:t,:,:], axis=0)
PW_blocked = blockave2D(PW_tave, db)
QNTOA_blocked = blockave2D(QNTOA_tave, db)
SWN_blocked = blockave2D(SWN_tave, db)
LWN_blocked = blockave2D(LWN_tave, db)
QN_blocked = blockave2D(QN_tave, db)
SWNC_blocked = blockave2D(SWNC_tave, db)
LWNC_blocked = blockave2D(LWNC_tave, db)
PWxy_sorted = blockxysort2D(PW_tave, xx, yy, db)
#fieldxy_sorted = blockxysort2D(field_t, xx, yy, db)
PWsort = PWxy_sorted.keys()
PWxycoords = PWxy_sorted.values()
#fieldsort = fieldxy_sorted.keys()
#fieldxycoords = fieldxy_sorted.values()
xx, yy = np.meshgrid(x, y) times = np.arange(t3D[0], np.max(t3D)) PW = ds2D['PW'][:] #2D fields ntrunc = PW.shape[0]%ntave2D PW = PW[ntrunc:,:,:] #PW_tmp = PW.reshape(nt2D/ntave2D, ntave2D, nx, ny) #PW_tave = np.mean(PW_tmp, axis=1) #time period to look at t=-25*ntave3D nave=5 nave2D=5*ntave2D nave3D=5*ntave3D #number of blocks to find PW max db=1 print 'calulating max PW, blocked' #PW_t = np.mean(PW_tave[t-nave:t,:,:], axis=0) PW_t = np.mean(PW[t-nave2D:t,:,:], axis=0) PW_blocked = blockave2D(PW_t, db) PWxy_sorted = blockxysort2D(PW_t, xx, yy, db) PWsort = PWxy_sorted.keys() PWxycoords = PWxy_sorted.values() mcenter = PWxycoords[-1] nbins=[100, z]
t = -1
db = 16
nxprime = nx // db
varname = 'W500'
W = varis2D[varname][:]
#W = varis3D['W'][t-nave3D:t,:,:,:]
W = varis2D[varname][t - aveperiod2D:t, :, :]
W_tave = np.mean(W, axis=0)
W_blockave = blockave2D(W_tave, db)
#put code to select W at specific level
#W_blockave = blockave2D(W_tavez, db)
QN = varis3D['QN'][:]
QN_tave = np.mean(QN[t - aveperiod3D:t, :, :, :], axis=0)
cloudfreq = np.sign(QN_tave)
cloudcount = blocksum3D(cloudfreq, db)
cloudfrac = cloudcount / (db * db)
plow_ti = np.where(p > 680)[0][-1]
t = -1 db=16 nxprime = nx // db varname = 'W500' W = varis2D[varname][:] #W = varis3D['W'][t-nave3D:t,:,:,:] W = varis2D[varname][t-aveperiod2D:t,:,:] W_tave = np.mean(W, axis=0) W_blockave = blockave2D(W_tave, db) #put code to select W at specific level #W_blockave = blockave2D(W_tavez, db) QN = varis3D['QN'][:] QN_tave = np.mean(QN[t-aveperiod3D:t,:,:,:], axis=0) cloudfreq = np.sign(QN_tave) cloudcount = blocksum3D(cloudfreq, db) cloudfrac = cloudcount/(db*db)
aveperiod = 24*nave aveperiod3D = 4*nave nc_data2D = Dataset(nc_in2D) nc_data3D = Dataset(nc_in3D) #varis3D = nc_data3D.variables varis2D = nc_data2D.variables varis3D = nc_data3D.variables x = varis2D['x'][:] y = varis2D['y'][:] #z = varis3D['z'][:] #p = varis3D['p'][:] #p = p*1e2 W = varis3D['W'][t-aveperiod3D:t,:,:,:] Wvertbar = np.mean(np.mean(W, axis=0),axis=0) Wblock = blockave2D(Wvertbar, db) #W500 = varis2D['W500'][t-aveperiod:t,:,:] #W500_tave = np.mean(W500, axis=0) #W500_block = blockave2D(W500_tave, db) #nt3D = t3D.size #nz = z.size nx = x.size ny = y.size t3D = varis3D['time'][:] nt3D = t3D.size vari = varis2D[varname] field = np.mean(vari[t-aveperiod:t,:,:], axis=0) field = blockave2D(field, db) nxprime = nx / db
#PW_tmp = PW.reshape(nt2D/ntave2D, ntave2D, nx, ny) #PW_tave = np.mean(PW_tmp, axis=1) #time period to look at #t=-25*ntave3D #nave=5 #nave2D=5*ntave2D #nave3D=5*ntave3D #number of blocks to find PW max db=16 print 'calulating max PW, blocked' #PW_t = np.mean(PW_tave[t-nave:t,:,:], axis=0) #PW_t = np.mean(PW[t-nave2D:t,:,:], axis=0) PW_tave = np.mean(PW, axis=0) PW_blocked = blockave2D(PW_tave, db) PWxy_sorted = blockxysort2D(PW_tave, xx, yy, db) PWsort = PWxy_sorted.keys() PWxycoords = PWxy_sorted.values() mcenter = PWxycoords[-1] binwidth=5e3 rbins = np.arange(0, domsize*1e3, binwidth) #FIND BL TOP dthetadz = (theta_tave[1:]-theta_tave[:-1])/np.diff(z) dRHdz = (RELH_tave[1:] - RELH_tave[:-1])/np.diff(z) dthetadz_crit = 1e-3
#Wvertbar = np.mean(np.mean(W, axis=0),axis=0)
#Wblock = blockave2D(Wvertbar, db)
#W500 = varis2D['W500'][t-aveperiod:t,:,:]
#W500_tave = np.mean(W500, axis=0)
#W500_block = blockave2D(W500_tave, db)
#nt3D = t3D.size
#nz = z.size
nx = x.size
ny = y.size
t3D = varis3D['time'][:]
nt3D = t3D.size
vari = varis2D[varname]
field = np.mean(vari[t-aveperiod:t,:,:], axis=0)
field = blockave2D(field, db)
nxprime = nx / db
nyprime = ny / db
field = field.flatten()
#W500_flat = W500_block.flatten()
W_flat = Wblock.flatten()
nbins=100
#counts, bin_edges = np.histogram(W500_flat, bins=50)
#PWsum, bin_edges = np.histogram(W500_flat, bins=50, weights=field)
counts, bin_edges = np.histogram(W_flat, bins=nbins)
PWsum, bin_edges = np.histogram(W_flat, bins=nbins, weights=field)
bin_c = (bin_edges[1:] + bin_edges[:-1])/2
PWbar = PWsum/counts
plt.figure(1)
y = varis2D['y'][:]
times = varis2D['time'][:]
daytimes=np.arange(0, times[-1]+1)
#print 'domain size ({:3.0f} km)^2 fields averaged at day {:2.0f} over previous {:2.1f} days'.format(domsize[i], times[t], ndays)
nx = x.size
ny = y.size
nxprime = nx / db
nyprime = ny / db
totpointsprime = nxprime*nyprime
xx, yy = np.meshgrid(x, y)
PW = varis2D['PW'][t-nave:t,:,:]
W500 = varis2D['W500'][t-nave:t,:,:]
P = varis2D['Prec'][t-nave:t,:,:]
PWtave= np.mean(PW, axis=0)
W500tave = np.mean(W500, axis=0)
W500block = blockave2D(W500tave, db)
Ptave = np.mean(P, axis=0)
#fracA_Prec= fracclusterarea('Prec', varis2D, nave, t, a)
fracA_PW = fracclusterarea('PW', varis2D, nave, t, a)
W500crit = 0.01
# fracA_W500 = fracclusterarea('W500', varis2D, nave, t, a, W500crit)
totpoints=nx*ny
fracA_W500 = len(W500block[W500block >= W500crit])/(1.*totpointsprime)
fracA_Phat = fracclusterarea('PrecNEW', varis2D, nave, t)
PWcrit = np.mean(PWtave) + a*np.std(PWtave)
Pcrit = np.mean(Ptave) + a*np.std(Ptave)
print 'moist edge PW threshold {:2.1f} (mm), mean PW = {:2.1f}, std PW = {:2.1f}'.format(PWcrit, np.mean(PWtave), np.std(PWtave))
varname = 'W500'
#W = varis2D[varname][:]
W = varis3D['W'][t - nave3D:t, :, :, :]
#W = varis2D[varname][t-aveperiod2D:t,:,:]
W_tave = np.mean(W, axis=0)
#W_blockave = blockave2D(W_tave, db)
Wlow = np.mean(W_tave[plow_bi:plow_ti, :, :], axis=0)
Wmid = np.mean(W_tave[plow_ti:phigh_bi, :, :], axis=0)
Whigh = np.mean(W_tave[phigh_bi:phigh_ti, :, :], axis=0)
Wlow_block = blockave2D(Wlow, db)
Wmid_block = blockave2D(Wmid, db)
Whigh_block = blockave2D(Whigh, db)
#put code to select W at specific level
#W_blockave = blockave2D(W_tavez, db)
QN = varis3D['QN'][:]
QN_tave = np.mean(QN[t - aveperiod3D:t, :, :, :], axis=0)
cloudfreq = np.sign(QN_tave)
cloudcount = blocksum3D(cloudfreq, db)
cloudfrac = cloudcount / (db * db)
aveperiod = 24 * nave
aveperiod3D = 4 * nave
nc_data2D = Dataset(nc_in2D)
nc_data3D = Dataset(nc_in3D)
#varis3D = nc_data3D.variables
varis2D = nc_data2D.variables
varis3D = nc_data3D.variables
x = varis2D['x'][:]
y = varis2D['y'][:]
#z = varis3D['z'][:]
#p = varis3D['p'][:]
#p = p*1e2
W = varis3D['W'][t - aveperiod3D:t, :, :, :]
Wvertbar = np.mean(np.mean(W, axis=0), axis=0)
Wblock = blockave2D(Wvertbar, db)
#W500 = varis2D['W500'][t-aveperiod:t,:,:]
#W500_tave = np.mean(W500, axis=0)
#W500_block = blockave2D(W500_tave, db)
#nt3D = t3D.size
#nz = z.size
nx = x.size
ny = y.size
t3D = varis3D['time'][:]
nt3D = t3D.size
vari = varis2D[varname]
field = np.mean(vari[t - aveperiod:t, :, :], axis=0)
field = blockave2D(field, db)
nxprime = nx / db
corr_netSWcld = (hfhatprime*netSWcldprime)
corr_netLWcld = (hfhatprime*netLWcldprime)
corr_netSWC = (hfhatprime*netSWCprime)
corr_netLWC = (hfhatprime*netLWCprime)
print 'CRH block sorting'
#CRH_SEFsort = blocksort2D(CRH[i,:,:], corr_SEF, db)
#CRH_netLWsort = blocksort2D(CRH[i,:,:], corr_netLW, db)
#CRH_netSWsort = blocksort2D(CRH[i,:,:], corr_netSW, db)
#CRH_netSWcldsort = blocksort2D(CRH[i,:,:], corr_netSWcld, db)
#CRH_netLWcldsort = blocksort2D(CRH[i,:,:], corr_netLWcld, db)
#CRH_netSWCsort = blocksort2D(CRH[i,:,:], corr_netSWC, db)
#CRH_netLWCsort = blocksort2D(CRH[i,:,:], corr_netLWC, db)
#CRH_hfhatprimesort = blocksort2D(CRH[i, :, :], hfhatprime, db)
CRHblock = blockave2D(CRH[i,:,:], db).flatten()
CRH_SEFblock = blockave2D(corr_SEF, db).flatten()
CRH_netLWblock = blockave2D(corr_netLW, db).flatten()
CRH_netSWblock = blockave2D(corr_netSW, db).flatten()
CRH_netSWcldblock = blockave2D(corr_netSWcld, db).flatten()
CRH_netLWcldblock = blockave2D(corr_netLWcld, db).flatten()
CRH_netSWCblock = blockave2D( corr_netSWC, db).flatten()
CRH_netLWCblock = blockave2D(corr_netLWC, db).flatten()
CRH_hfhatprimeblock = blockave2D(hfhatprime, db).flatten()
p3D[:,:,:] = p
p3D = p3D.T
#p3D = p3D.T
#p4D = np.tile(p3D[:,:,:, np.newaxis], T.shape[0])
#p4D = p4D.T
THETA_tave = T_tave*(p0/p3D)**(c.Rd/c.cp)
diffTHETA = THETA_tave[1:,:,:] - THETA_tave[:-1,:,:]
diffz = np.diff(z)
diffz3D = np.zeros((nz-1, nx, ny))
diffz3D = diffz3D.T
diffz3D[:,:,:] = diffz
diffz3D = diffz3D.T
THETA_mid = (THETA_tave[1:,:,:] + THETA_tave[:-1,:,:])/2.
N_tave = (c.g*diffTHETA)/np.multiply(diffz3D, THETA_mid)
N_tave_vertave = np.mean(N_tave, axis=0)
field_tave = blockave2D(N_tave_vertave, db)
elif varname == 'URADIAL':
U_r_p = U_r[plevi,:,:]
field_tave = blockave2D(U_r_p, db)
elif varname == 'SFCSPEED':
USFC = varis2D['USFC'][t2-nave2D:t2,:,:]
VSFC = varis2D['VSFC'][t2-nave2D:t2,:,:]
speed = np.sqrt(np.power(USFC, 2) + np.power(VSFC, 2))
field_tave = np.mean(speed, axis=0)
field_tave = blockave2D(field_tave, db)
#look at different levels here
#p = varis3D['p'][:]
aveperiod = 24 * nave
aveperiod3D = 4 * nave
nc_data2D = Dataset(nc_in2D)
nc_data3D = Dataset(nc_in3D)
#varis3D = nc_data3D.variables
varis2D = nc_data2D.variables
varis3D = nc_data3D.variables
x = varis2D['x'][:]
y = varis2D['y'][:]
#z = varis3D['z'][:]
#p = varis3D['p'][:]
#p = p*1e2
W = varis3D['W'][t - aveperiod3D:t, :, :, :]
Wvertbar = np.mean(np.mean(W, axis=0), axis=0)
Wblock = blockave2D(Wvertbar, db)
#W_c=0.5
Wconvblock = Wblock[Wblock > W_c]
Wdryblock = Wblock[Wblock < W_c]
#W500 = varis2D['W500'][t-aveperiod:t,:,:]
#W500_tave = np.mean(W500, axis=0)
#W500_block = blockave2D(W500_tave, db)
#nt3D = t3D.size
#nz = z.size
nx = x.size
ny = y.size
t3D = varis3D['time'][:]
nt3D = t3D.size
vari = varis2D[varname]
