sigma = np.zeros(z.size) l_ms = np.zeros(z.size) v_ns = np.zeros(z.size-1) divs = np.zeros(z.size-1) divh = np.zeros(z.size-1) div = np.zeros(z.size-1) Aup = np.zeros(z.size) h_convs = np.zeros(z.size-1) s_convs = np.zeros(z.size-1) Wh_tave = np.multiply(Wtave, h_tave) Ws_tave = np.multiply(Wtave, s_tave) Wh_tave = blockave3D(Wh_tave, db) Ws_tave = blockave3D(Ws_tave, db) #block averaging Wtave = blockave3D(Wtave, db) h_tave = blockave3D(h_tave, db) s_tave = blockave3D(s_tave, db) nxblock = nx // db nyblock = ny // db totpoints = nxblock*nyblock #for i, zlev in enumerate(z): # Wz = Wtave[i,:,:] # sigma[i] = len(Wz[Wz >= Wcrit])/(1.*totpoints) # Aup[i] = sigma[i]*(domsize*1e3)**2
for k, t in enumerate(t3D): k2 = (ntave2D / ntave3D) * k #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
#varis3D = nc_data3D.variables varis2D = nc_data2D.variables t2D = varis2D['time'][:] nt2D = t2D.size field = varis2D[varname][:] #ntrunc = nt2D%ntave2D #ntrunc=0 #field = field[ntrunc:,:,:] units = varis2D[varname].units #field_tmp = field.reshape(nt2D/ntave2D, ntave2D, nx, ny) #field_tave = np.mean(field_tmp, axis=1) if db == 1: field_blockave = field else: field_blockave = blockave3D(field, db) nt = field_blockave.shape[0] convfrac = np.zeros(nt) #subsfrac = np.zeros(nt) for k, t in enumerate(t2D): field_t = field_blockave[k, :, :] convfrac[k] = len( field_t[field_t[:, :] > W_c]) / (1. * nxprime * nyprime) #subsfrac[i] = 1 - convfrac[i] # buoyflux = np.vstack((buoyflux, buoyflux_temp)) if buoyflux.size else buoyflux_temp convfracs = np.concatenate( (convfracs, convfrac)) if convfracs.size else convfrac times = np.concatenate((times, t2D)) if times.size else t2D #ntimes = convfracs.shape[0]
nc_fs = glob.glob(fpath2D + '*256x256*3000m*302K.nc') CRHs = np.array([]) for nc_in2D in nc_fs: #nc_data3D = Dataset(nc_in3D) nc_data2D = Dataset(nc_in2D) #varis3D = nc_data3D.variables varis2D = nc_data2D.variables PW = varis2D['PW'][:] SWVP = varis2D['SWVP'][:] CRH = PW/SWVP CRH_tmp = CRH.reshape(nt2D/ntave2D, ntave2D, nx, ny) CRH_tave = np.mean(CRH_tmp, axis=1) db=16 CRHs_temp = blockave3D(CRH_tave, db) # buoyflux = np.vstack((buoyflux, buoyflux_temp)) if buoyflux.size else buoyflux_temp CRHs = np.vstack((CRHs, CRHs_temp)) if CRHs.size else CRHs_temp ntimes = CRHs.shape[0] #calculate CRH PW = varis2D['PW'][:] SWVP = varis2D['SWVP'][:] CRH = PW/SWVP CRH_tmp = CRH.reshape(nt2D/ntave2D, ntave2D, nx, ny) #daily average
T = varis3D['TABS'][t3 - aveperiod3D:t3, :, :, :] rhoz = p / (c.Rd * np.mean(np.mean(T, axis=3), axis=2)) rhoz_tave = np.mean(rhoz, axis=0) fac = (rhoz_tave * c.g / theta_bar) for k, zlev in enumerate(z[:-1]): #W_zbar = np.mean(np.mean(W_tave[k,:,:], axis=0), axis=0) #W_prime[ti,k,:,:] = W_tave[k,:,:] - W_zbar thetav_prime[ti, k, :, :] = buoyflux[ti, k, :, :] / (fac[k] * W_tave[k, :, :]) #W_primeblock = blockave3D(W_prime[ti,:,:,:], db) W_block = blockave3D(W_tave, db) thetav_primeblock = blockave3D(thetav_prime[ti, :, :, :], db) W_block = W_block[:-1, :, :] #fac = (rhoz_tave*c.g/theta_bar) #fac3D = np.zeros((W_primeblock.shape)).T fac3D = np.zeros((W_block.shape)).T fac3D[:, :, :] = fac[:-1] fac3D = fac3D.T #buoyfluxblock = np.multiply(W_primeblock, thetav_primeblock) buoyfluxblock = np.multiply(W_block, thetav_primeblock) buoyfluxblock = np.multiply(buoyfluxblock, fac3D) buoyfluxblockbar_zt = np.mean(np.mean(buoyfluxblock, axis=2), axis=1)
#p = varis3D['p'][:] #p = p*1e2 W = varis3D['W'][t - aveperiod3D:t, :, :, :] W_tave = np.mean(W, axis=0) QV = varis3D['QV'][t - aveperiod3D:t, :, :, :] QV_tave = np.mean(QV, axis=0) TABS = varis3D['TABS'][t - aveperiod3D:t, :, :, :] TABS_tave = np.mean(TABS, axis=0) RH_tave = np.zeros(QV_tave.shape) for pi, plev in enumerate(p): wsat_tave = 1000 * wsat(TABS_tave[pi, :, :], plev) #convert to g/kg RH_tave[pi, :, :] = 100 * (QV_tave[pi, :, :] / wsat_tave ) #convert to percent RH_tave = blockave3D(RH_tave, db) W_tave = blockave3D(W_tave, db) #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
sigma = np.zeros((nt_samp, z.size)) l_ms = np.zeros((nt_samp, z.size)) v_ns = np.zeros((nt_samp, z.size - 1)) divs = np.zeros((nt_samp, z.size - 1)) Aup = np.zeros((nt_samp, z.size)) #block averaging #Wtave = blockave3D(Wtave, db) nxblock = nx / db nyblock = ny / db totpoints = nxblock * nyblock for i, zlev in enumerate(z): Wz = W[:, i, :, :] Wblock = blockave3D(Wz, db) for j in range(nt_samp): Wblock_t = Wblock[j, :, :] sigma[j, i] = len(Wblock_t[Wblock_t >= Wcrit]) / (1. * totpoints) Aup[j, i] = sigma[j, i] * (domsize * 1e3)**2 l_ms[j, i] = np.sqrt(Aup[j, i] / np.pi) #print 'vertically averaged Aup (km^2)', np.mean(Aup/1e6) for i in np.arange(0, z.size - 1): #print z[i] delz = z[i + 1] - z[i] Wz = W[:, i, :, :] #Uz = U[:,i,:,:] #Vz = V[:,i,:,:] #diffU = Uz[:,1:,:] - Uz[:,:-1,:]
varname='LWNT' print 'loading', nc_f #averaging time period for 2D & 3D fields ntave2D=24 ntave3D=4 nc_data2D = Dataset(nc_f) varis2D = nc_data2D.variables t2D = varis2D['time'][:] nt2D = t2D.size vari = varis2D[varname] field = vari[:] fieldblock = blockave3D(field, db) W500 = varis2D['W500'][:] W500block = blockave3D(W500, db) nt = W500block.shape[0] #convective region and dry region time series print 'calculating convective region + dry region averages' for k,t in enumerate(t2D): W500block_t = W500block[k,:,:] conv_points = W500block_t >= W_crit dry_points = W500block_t < W_crit
ny = y.size if varname == 'W': units = varis3D[varname].units.strip() vari = varis3D[varname][t-aveperiod3D:t,:,:,:] vari = np.mean(vari,axis=0) else: units = varis2D[varname].units.strip() vari = varis2D[varname][t-aveperiod:t,:,:] vari = np.mean(vari,axis=0) t3D = varis2D['time'][:] t2D = varis2D['time'][:] nt2D = t2D.size #vari = varis2D[varname] #field = np.mean(vari[t-aveperiod:t,:,:], axis=0) field = blockave3D(vari, db) nz = field.shape[0] nxprime = nx / db nyprime = ny / db field = field.flatten() bins = np.linspace(1,10, 100) bins=np.linspace(-2,2,100) var = np.var(field) print 'variance of {:s} = {:3.5f}'.format(varname, var) print 'max of {:s} = {:3.5f}'.format(varname, np.max(field)) freqs, bin_edges = np.histogram(field, bins=bins, weights=np.zeros_like(field) + 1. / (nz*nxprime*nyprime)) bin_c = (bin_edges[1:] + bin_edges[:-1])/2
theta = varisSTAT['THETA'][t2-aveperiod2D:t2,:] theta_bar = np.mean(theta, axis=0) T = varis3D['TABS'][t3-aveperiod3D:t3,:,:,:] rhoz = p/(c.Rd*np.mean(np.mean(T, axis=3), axis=2)) rhoz_tave = np.mean(rhoz, axis=0) fac = (rhoz_tave*c.g/theta_bar) for k, zlev in enumerate(z[:-1]): #W_zbar = np.mean(np.mean(W_tave[k,:,:], axis=0), axis=0) #W_prime[ti,k,:,:] = W_tave[k,:,:] - W_zbar thetav_prime[ti,k,:,:] = buoyflux[ti,k,:,:]/(fac[k]*W_tave[k,:,:]) #W_primeblock = blockave3D(W_prime[ti,:,:,:], db) W_block = blockave3D(W_tave, db) thetav_primeblock = blockave3D(thetav_prime[ti,:,:,:], db) W_block = W_block[:-1,:,:] #fac = (rhoz_tave*c.g/theta_bar) #fac3D = np.zeros((W_primeblock.shape)).T fac3D = np.zeros((W_block.shape)).T fac3D[:,:,:] = fac[:-1] fac3D = fac3D.T #buoyfluxblock = np.multiply(W_primeblock, thetav_primeblock) buoyfluxblock = np.multiply(W_block, thetav_primeblock) buoyfluxblock = np.multiply(buoyfluxblock, fac3D) buoyfluxblockbar_zt = np.mean(np.mean(buoyfluxblock, axis=2), axis=1)
Aup = np.zeros(z.size) h_convs = np.zeros(z.size-1) s_convs = np.zeros(z.size-1) #Wh_tave = np.multiply(Wtave, h_tave) #Ws_tave = np.multiply(Wtave, s_tave) #Wh_tave = blockave3D(Wh_tave, db) #Ws_tave = blockave3D(Ws_tave, db) #block averaging Wtave = blockave3D(Wtave, db) h_tave = blockave3D(h_tave, db) s_tave = blockave3D(s_tave, db) divhu_tave = blockave3D(divhu_tave, db) nxblock = nx // db nyblock = ny // db totpoints = nxblock*nyblock for i, zlev in enumerate(z): Wz = Wtave[i,:,:] sigma[i] = len(Wz[Wz >= Wcrit])/(1.*totpoints) Aup[i] = sigma[i]*(domsize*1e3)**2 l_ms[i] = np.sqrt(Aup[i]/np.pi) #print 'vertically averaged Aup (km^2)', np.mean(Aup/1e6)
varis2D = nc_data2D.variables t2D = varis2D['time'][:] nt2D = t2D.size field = varis2D[varname][:] #ntrunc = nt2D%ntave2D #ntrunc=0 #field = field[ntrunc:,:,:] #print field.shape units = varis2D[varname].units #field_tmp = field.reshape(nt2D/ntave2D, ntave2D, nx, ny) #field_tave = np.mean(field_tmp, axis=1) if db == 1: #fields_temp = field_tave fields_temp = field else: fields_temp = blockave3D(field, db) # buoyflux = np.vstack((buoyflux, buoyflux_temp)) if buoyflux.size else buoyflux_temp fields = np.vstack((fields, fields_temp)) if fields.size else fields_temp #times_temp = np.arange( #times = np.concatenate((times, t2D)) if times.size else t2D ntimes = fields.shape[0] times = np.arange(tinit, tinit+ntimes) nx = fields.shape[1] #nfieldbins= 1024 #nfieldbins = np.linspace(-0.1, 0.1, 300) nfieldbins=1024
print 'z_BL (m)', z_BL print 'calculating dry region and convective region average profiles' print 'domain length = {:3.0f}, day {:3.0f} to day {:3.0f}'.format( domsize, t3D[0], t3D[-1]) for k, varname in enumerate(varnames): print 'loading', varname if varname == 'URADIAL': #plot radial velocity in moist region/convective region? U_rfname = glob.glob( foutdata + '*{:d}*{:3.0f}to{:3.0f}*'.format(domsize, t3D[0], t3D[-1]))[0] field_tave = np.load(U_rfname) field_tave = blockave3D(field_tave, db) elif varname == 'BUOY': buoy_fname = glob.glob( foutdata + '*{:d}*_buoy_*to{:3.0f}*'.format(domsize, t3D[-1]))[0] print 'loading', buoy_fname field_tave = np.load(buoy_fname) field_tave = np.mean(field_tave[-nave:, :, :, :], axis=0) field_tave = blockave3D(field_tave, db) elif varname == 'CLOUD AMOUNT': QN = varis3D['QN'][t3 - aveperiod3D:t3, :, :, :] QN_tave = np.mean(QN, axis=0) field_tave = blockave3D(QN_tave, db)
rhoz_tave = np.mean(rhoz, axis=0) sigma = np.zeros(z.size) l_ms = np.zeros(z.size) v_ns = np.zeros(z.size - 1) divs = np.zeros(z.size - 1) divh = np.zeros(z.size - 1) div = np.zeros(z.size - 1) Aup = np.zeros(z.size) h_convs = np.zeros(z.size - 1) s_convs = np.zeros(z.size - 1) Wh_tave = np.multiply(Wtave, h_tave) Ws_tave = np.multiply(Wtave, s_tave) Wh_tave = blockave3D(Wh_tave, db) Ws_tave = blockave3D(Ws_tave, db) #block averaging Wtave = blockave3D(Wtave, db) h_tave = blockave3D(h_tave, db) s_tave = blockave3D(s_tave, db) nxblock = nx // db nyblock = ny // db totpoints = nxblock * nyblock #for i, zlev in enumerate(z): # Wz = Wtave[i,:,:] # sigma[i] = len(Wz[Wz >= Wcrit])/(1.*totpoints) # Aup[i] = sigma[i]*(domsize*1e3)**2 # l_ms[i] = np.sqrt(Aup[i]/np.pi)
#U = U[:,:,:-1,:-1] #V = V[:,:,:-1,:-1] QVadv = QV_BL*(diffU/delx + diffV/dely) + U_BL*(diffQVx/delx) + V_BL*(diffQVy/dely) #QVadv = U_BL*(diffQVx/delx) + V_BL*(diffQVy/dely) #QVadv = QV*(diffU/delx + diffV/dely) + U*(diffQVx/delx) + V*(diffQVy/dely) #field_tave = np.mean(QVadv, axis=1) #field_tave = np.mean(field_tave, axis=0) field_tave = np.mean(QVadv, axis=0) elif varname == 'BLCONV': field = varis3D['W'] W = field[t3-nave3D:t3,:,:,:] W_tave = np.mean(W, axis=0) Wblock = blockave3D(W_tave, db) nxprime = nx / db nyprime = ny / db nt = W.shape[0] nz = z.size #W_tave = np.mean(W, axis=0) z_BL = 1e3 BLi = np.where(z > z_BL)[0][0] #diffz3D = np.zeros((nx, ny, nz-1)) diffz3D = np.zeros((nxprime, nyprime, nz-1)) diffz3D[:,:,:] = np.diff(z) diffz3D = diffz3D.T #diffz4D = np.tile(diffz3D[:,:,:,np.newaxis], nt) #diffz4D = diffz4D.T #diffW = np.diff(W, axis=1) diffW = np.diff(Wblock, axis=0)
#varis3D = nc_data3D.variables varis2D = nc_data2D.variables t2D = varis2D['time'][:] nt2D = t2D.size field = varis2D[varname][:] #ntrunc = nt2D%ntave2D #ntrunc=0 #field = field[ntrunc:,:,:] units = varis2D[varname].units #field_tmp = field.reshape(nt2D/ntave2D, ntave2D, nx, ny) #field_tave = np.mean(field_tmp, axis=1) if db == 1: field_blockave = field else: field_blockave = blockave3D(field, db) nt = field_blockave.shape[0] convfrac = np.zeros(nt) #subsfrac = np.zeros(nt) for k, t in enumerate(t2D): field_t = field_blockave[k,:,:] convfrac[k] = len(field_t[field_t[:,:] > W_c])/(1.*nxprime*nyprime) #subsfrac[i] = 1 - convfrac[i] # buoyflux = np.vstack((buoyflux, buoyflux_temp)) if buoyflux.size else buoyflux_temp convfracs = np.concatenate((convfracs, convfrac)) if convfracs.size else convfrac times = np.concatenate((times, t2D)) if times.size else t2D #ntimes = convfracs.shape[0] print 'plotting'
#EDIT THIS TO CHANGE HOW MANY STD ABOVE MEAN FOR MOIST REGION THRESHOLD a=1.5 mfieldcrit = np.mean(mfield) + a*np.std(mfield) moist_points = mfield_t >= mfieldcrit dry_points = mfield_t < mfieldcrit #UNCOMMENT TO USE W > W_crit AS CONVECTIVE REGION THRESHOLD W=varis3D['W'][t3-aveperiod3D:t3,:,:] W_tave = np.mean(W, axis=0) db=16 W_crit = 0.01 W_tave = blockave3D(W_tave, db) nxprime = nx/db nyprime = ny/db #moist_points = W_tave >= W_crit #dry_points = W_tave < W_crit #find BL to get w_BL and w_m dthetadz = (theta_tave[1:]-theta_tave[:-1])/np.diff(z) dthetadz_crit = 2e-3 BLi = np.where(dthetadz > dthetadz_crit)[0][0] BLi = 0
for nc_f in nc_flist: varname = 'LWNT' print 'loading', nc_f #averaging time period for 2D & 3D fields ntave2D = 24 ntave3D = 4 nc_data2D = Dataset(nc_f) varis2D = nc_data2D.variables t2D = varis2D['time'][:] nt2D = t2D.size vari = varis2D[varname] field = vari[:] fieldblock = blockave3D(field, db) W500 = varis2D['W500'][:] W500block = blockave3D(W500, db) nt = W500block.shape[0] #convective region and dry region time series print 'calculating convective region + dry region averages' for k, t in enumerate(t2D): W500block_t = W500block[k, :, :] conv_points = W500block_t >= W_crit dry_points = W500block_t < W_crit
#totpoints=nx*ny rhoz = p/(c.Rd*np.mean(np.mean(T, axis=3), axis=2)) rhoz_tave = np.mean(rhoz, axis=0) sigma = np.zeros(z.size) l_ms = np.zeros(z.size) v_ns = np.zeros(z.size-1) divs = np.zeros(z.size-1) Aup = np.zeros(z.size) db=16 Wcrit=0.01 #block averaging Wtave = blockave3D(Wtave, db) nxblock = nx / db nyblock = ny / db totpoints = nxblock*nyblock for i, zlev in enumerate(z): Wz = Wtave[i,:,:] sigma[i] = len(Wz[Wz >= Wcrit])/(1.*totpoints) Aup[i] = sigma[i]*(domsize*1e3)**2 l_ms[i] = np.sqrt(Aup[i]/np.pi) #print 'vertically averaged Aup (km^2)', np.mean(Aup/1e6) for i in np.arange(0, z.size-1):
#EDIT THIS TO CHANGE HOW MANY STD ABOVE MEAN FOR MOIST REGION THRESHOLD a=1.5 mfieldcrit = np.mean(mfield) + a*np.std(mfield) moist_points = mfield_t >= mfieldcrit dry_points = mfield_t < mfieldcrit #UNCOMMENT TO USE W > W_crit AS CONVECTIVE REGION THRESHOLD W=varis3D['W'][t3-aveperiod3D:t3,:,:] W_tave = np.mean(W, axis=0) db=16 W_crit = 0.01 W_tave = blockave3D(W_tave, db) nxprime = nx/db nyprime = ny/db #moist_points = W_tave >= W_crit #dry_points = W_tave < W_crit #find BL to get w_BL and w_m dthetadz = (theta_tave[1:]-theta_tave[:-1])/np.diff(z) dthetadz_crit = 2e-3 BLi = np.where(z > 1000)[0][0] #BLi = 0
elif varname == 'NETLW': LWNTOA = varis2D['LWNT'][t2 - nave2D:t2, :, :] LWNS = varis2D['LWNS'][t2 - nave2D:t2, :, :] netLW = LWNS - LWNTOA field_tave = np.mean(netLW, axis=0) field_tave = blockave2D(field_tave, db) elif varname == 'NETSW': SWNTOA = varis2D['SWNT'][t2 - nave2D:t2, :, :] SWNS = varis2D['SWNS'][t2 - nave2D:t2, :, :] netLW = SWNTOA - SWNS field_tave = np.mean(netLW, axis=0) field_tave = blockave2D(field_tave, db) elif varname == 'ALPHA': LHF = varis2D['LHF'][t2 - nave2D:t2, :, :] P = varis2D['Prec'][t2 - nave2D:t2, :, :] LHF = blockave3D(LHF, db) P = blockave3D(P, db) E = (LHF * 1000 * 86400) / (L_v * rho_w) alpha = E / P field_tave = np.mean(alpha, axis=0) indx = np.isfinite(field_tave) alpha_t[i] = np.mean(field_tave[indx]) #field_tave = blockave2D(field_tave, db) else: field = varis2D[varname][t2 - nave2D:t2, :, :] field_tave = np.mean(field, axis=0) field_tave = blockave2D(field_tave, db) #w_tave = np.mean(wfield_p[t3-nave3D:t3,:,:], axis=0) #w_tave = blockave2D(w_tave, db)
ny = y.size if varname == 'W': units = varis3D[varname].units.strip() vari = varis3D[varname][t - aveperiod3D:t, :, :, :] vari = np.mean(vari, axis=0) else: units = varis2D[varname].units.strip() vari = varis2D[varname][t - aveperiod:t, :, :] vari = np.mean(vari, axis=0) t3D = varis2D['time'][:] t2D = varis2D['time'][:] nt2D = t2D.size #vari = varis2D[varname] #field = np.mean(vari[t-aveperiod:t,:,:], axis=0) field = blockave3D(vari, db) nz = field.shape[0] nxprime = nx / db nyprime = ny / db field = field.flatten() bins = np.linspace(1, 10, 100) bins = np.linspace(-2, 2, 100) var = np.var(field) print 'variance of {:s} = {:3.5f}'.format(varname, var) print 'max of {:s} = {:3.5f}'.format(varname, np.max(field)) freqs, bin_edges = np.histogram(field, bins=bins, weights=np.zeros_like(field) + 1. /
#totpoints=nx*ny rhoz = p / (c.Rd * np.mean(np.mean(T, axis=3), axis=2)) rhoz_tave = np.mean(rhoz, axis=0) sigma = np.zeros(z.size) l_ms = np.zeros(z.size) v_ns = np.zeros(z.size - 1) divs = np.zeros(z.size - 1) Aup = np.zeros(z.size) db = 16 Wcrit = 0.01 #block averaging Wtave = blockave3D(Wtave, db) nxblock = nx / db nyblock = ny / db totpoints = nxblock * nyblock for i, zlev in enumerate(z): Wz = Wtave[i, :, :] sigma[i] = len(Wz[Wz >= Wcrit]) / (1. * totpoints) Aup[i] = sigma[i] * (domsize * 1e3)**2 l_ms[i] = np.sqrt(Aup[i] / np.pi) #print 'vertically averaged Aup (km^2)', np.mean(Aup/1e6) for i in np.arange(0, z.size - 1): delz = z[i + 1] - z[i] Wz = Wtave[i, :, :]
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, :, :, :] W_tave = np.mean(W, axis=0) Wblock = blockave3D(W_tave, db) nz = Wblock.shape[0] Wconv = np.zeros(nz) for j in range(nz): Wblockz = Wblock[j, :, :] Wconvblockz = Wblockz[Wblockz > W_c] Wconvz = np.mean(Wconvblockz) Wconv[j] = Wconvz #Wdryblockz = Wblockz[Wblockz < W_c] maxconvi = np.nanargmax(Wconv) Wblock = Wblock[maxconvi, :, :]
elif varname == 'NETLW': LWNTOA = varis2D['LWNT'][t2-nave2D:t2,:,:] LWNS = varis2D['LWNS'][t2-nave2D:t2,:,:] netLW = LWNS - LWNTOA field_tave = np.mean(netLW, axis=0) field_tave = blockave2D(field_tave, db) elif varname == 'NETSW': SWNTOA = varis2D['SWNT'][t2-nave2D:t2,:,:] SWNS = varis2D['SWNS'][t2-nave2D:t2,:,:] netLW = SWNTOA - SWNS field_tave = np.mean(netLW, axis=0) field_tave = blockave2D(field_tave, db) elif varname == 'ALPHA': LHF = varis2D['LHF'][t2-nave2D:t2,:,:] P = varis2D['Prec'][t2-nave2D:t2,:,:] LHF = blockave3D(LHF, db) P = blockave3D(P, db) E = (LHF*1000*86400)/(L_v*rho_w) alpha = E/P field_tave = np.mean(alpha, axis=0) indx = np.isfinite(field_tave) alpha_t[i] = np.mean(field_tave[indx]) #field_tave = blockave2D(field_tave, db) else: field = varis2D[varname][t2-nave2D:t2,:,:] field_tave = np.mean(field, axis=0) field_tave = blockave2D(field_tave, db) if varname == 'PSFC': field_tave = field_tave - np.mean(field_tave)
for k, t in enumerate(t3D): k2 = (ntave2D/ntave3D)*k #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
#Wtave = np.mean(W, axis=0) #EDIT: this critical w threshold determines where convective region is. #What is a good way to choose this value? (want to neglect gravity wave perturbations) totpoints=nx*ny #rhoz = p/(c.Rd*np.mean(np.mean(T, axis=2), axis=1)) #rhoz_tave = np.mean(rhoz, axis=0) sigma_temp = np.zeros(z.size) db=16 Wcrit=0.01 #block averaging Wblock = blockave3D(W, db) nxblock = nx // db nyblock = ny // db totpoints = nxblock*nyblock for j, zlev in enumerate(z): Wz = Wblock[j,:,:] sigma_temp[j] = len(Wz[Wz >= Wcrit])/(1.*totpoints) sigmas[i,:] = sigma_temp times = np.concatenate((times, t3D)) sigma = np.vstack((sigma, sigmas)) if sigma.size else sigmas
l_ms = np.zeros((nt_samp, z.size)) v_ns = np.zeros((nt_samp, z.size-1)) divs = np.zeros((nt_samp, z.size-1)) Aup = np.zeros((nt_samp, z.size)) #block averaging #Wtave = blockave3D(Wtave, db) nxblock = nx / db nyblock = ny / db totpoints = nxblock*nyblock for i, zlev in enumerate(z): Wz = W[:,i,:,:] Wblock = blockave3D(Wz, db) for j in range(nt_samp): Wblock_t = Wblock[j,:,:] sigma[j,i] = len(Wblock_t[Wblock_t >= Wcrit])/(1.*totpoints) Aup[j,i] = sigma[j,i]*(domsize*1e3)**2 l_ms[j,i] = np.sqrt(Aup[j,i]/np.pi) #print 'vertically averaged Aup (km^2)', np.mean(Aup/1e6) for i in np.arange(0, z.size-1): #print z[i] delz = z[i+1] - z[i] Wz = W[:,i,:,:] #Uz = U[:,i,:,:] #Vz = V[:,i,:,:]
#z = varis3D['z'][:] #p = varis3D['p'][:] #p = p*1e2 W = varis3D['W'][t-aveperiod3D:t,:,:,:] W_tave = np.mean(W, axis=0) QV = varis3D['QV'][t-aveperiod3D:t,:,:,:] QV_tave = np.mean(QV, axis=0) TABS = varis3D['TABS'][t-aveperiod3D:t,:,:,:] TABS_tave = np.mean(TABS, axis=0) RH_tave = np.zeros(QV_tave.shape) for pi, plev in enumerate(p): wsat_tave = 1000*wsat(TABS_tave[pi,:,:], plev) #convert to g/kg RH_tave[pi,:,:] = 100*(QV_tave[pi,:,:]/wsat_tave) #convert to percent RH_tave = blockave3D(RH_tave, db) W_tave = blockave3D(W_tave, db) #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
QVadv = U_BL*(diffQVx/delx) + V_BL*(diffQVy/dely) #QVadv = QV*(diffU/delx + diffV/dely) + U*(diffQVx/delx) + V*(diffQVy/dely) #field_tave = np.mean(QVadv, axis=1) #field_tave = np.mean(field_tave, axis=0) field_tave = np.mean(QVadv, axis=0) elif varname == 'CONV': W = varis3D['W'][t3-nave3D:t3,:,:,:] z = varis3D['z'][:] W_tave = np.mean(W, axis=0) z3D = np.zeros(W_tave.shape) z3D[:,:,:] = z diffz3D = np.diff(z3D, axis=0) field_tave = W_tave[:-1,:,:]/diffz3D field_tave = blockave3D(field_tave, db) elif varname == 'PSFC': vari = varis2D[varname] field = vari[t2-nave2D:t2:,:,:] field_tave = np.mean(field, axis=0) field_bar = np.zeros(field_tave.shape) field_bar[:,:] = np.mean(np.mean(field, axis=1), axis=1) field_tave = field_tave - field_bar field_tave = blockave2D(field_tave, db) units = vari.units.strip()
nc_data2D = Dataset(nc_in2D) #varis3D = nc_data3D.variables varis2D = nc_data2D.variables t2D = varis2D['time'][:] nt2D = t2D.size trunc = nt2D%ntave2D PW = varis2D['PW'][trunc:] #SWVP = varis2D['SWVP'][trunc:] #CRH = PW/SWVP #CRH_tmp = CRH.reshape(nt2D/ntave2D, ntave2D, nx, ny) PW_tmp = PW.reshape(nt2D/ntave2D, ntave2D, nx, ny) PW_tave = np.mean(PW_tmp, axis=1) #CRH_tave = np.mean(CRH_tmp, axis=1) db=16 #CRHs_temp = blockave3D(CRH_tave, db) PWs_temp = blockave3D(PW_tave, db) # buoyflux = np.vstack((buoyflux, buoyflux_temp)) if buoyflux.size else buoyflux_temp #CRHs = np.vstack((CRHs, CRHs_temp)) if CRHs.size else CRHs_temp PWs = np.vstack((PWs, PWs_temp)) if PWs.size else PWs_temp #ntimes = CRHs.shape[0] ntimes = PWs.shape[0] times = np.arange(tinit, tinit+ntimes) nblocks = (nx/db)*(ny/db) #CRHranks = np.arange(nblocks) #CRHbins = np.linspace(0, 1, nblocks) PWbins = np.linspace(0, 85, nblocks) #CRHrankss, tt = np.meshgrid(CRHbins, times)