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)
