def makechi(filename): key = int(filename.split('/')[-1].split('_')[-1].split('.')[0]) print "chi_condensed_profile", key condensedfile = Dataset('cdf/condensed_profile_%08d.nc' % key) envfile = Dataset('cdf/condensed_env_profile_%08d.nc' % key) shellfile = Dataset('cdf/condensed_shell_profile_%08d.nc' % key) statfile = Dataset(mc.get_stat()) t = numpy.atleast_1d(condensedfile.variables['ids'][:]) cloud_duration = len(t) n = len(t) z = envfile.variables['z'][:] p = statfile.variables['PRES'][0,:]*100. area_condensed = numpy.atleast_2d(condensedfile.variables['AREA'][:]) thetal_condensed = numpy.atleast_2d(condensedfile.variables['THETAL'][:]) qt_condensed = numpy.atleast_2d(condensedfile.variables['QT'][:]) ql_condensed = numpy.atleast_2d(condensedfile.variables['QN'][:]) T_condensed = numpy.atleast_2d(condensedfile.variables['TABS'][:]) thetal_env = numpy.atleast_2d(envfile.variables['THETAL'][:]) qt_env = numpy.atleast_2d(envfile.variables['QT'][:]) thetal_shell = numpy.atleast_2d(shellfile.variables['THETAL'][:]) qt_shell = numpy.atleast_2d(shellfile.variables['QT'][:]) mask = ~(area_condensed > 0.) thetal_condensed_mask = numpy.ma.array(thetal_condensed, mask=mask) qt_condensed_mask = numpy.ma.array(qt_condensed, mask=mask) ql_condensed_mask = numpy.ma.array(ql_condensed, mask=mask) T_condensed_mask = numpy.ma.array(T_condensed, mask=mask) thetal_env_mask = numpy.ma.array(thetal_env, mask=mask) qt_env_mask = numpy.ma.array(qt_env, mask=mask) thetal_shell_mask = numpy.ma.array(thetal_shell, mask=mask) qt_shell_mask = numpy.ma.array(qt_shell, mask=mask) chi = SAM.find_chi_ql(ql_condensed, thetal_condensed, thetal_env, qt_condensed, qt_env, T_condensed, p) chi_mean = SAM.find_chi_ql(ql_condensed_mask.mean(0), thetal_condensed_mask.mean(0), thetal_env_mask.mean(0), qt_condensed_mask.mean(0), qt_env_mask.mean(0), T_condensed_mask.mean(0), p) chi_mean_condensed = SAM.find_chi_ql(ql_condensed_mask.mean(0), thetal_condensed_mask.mean(0), thetal_env, qt_condensed_mask.mean(0), qt_env, T_condensed_mask.mean(0), p) chi_mean_env = SAM.find_chi_ql(ql_condensed, thetal_condensed, thetal_env_mask.mean(0), qt_condensed, qt_env_mask.mean(0), T_condensed, p) # chi[isnan(chi)] = 0. savefile = Dataset('cdf/condensed_chi_profile_%08d.nc' % key, 'w', format='NETCDF3_64BIT') savefile.createDimension('id', cloud_duration) savefile.createDimension('z', len(z)) var_t = savefile.createVariable('id', 'd', ('id',)) var_z = savefile.createVariable('z', 'd', ('z',)) var_chi = savefile.createVariable('chi', 'd', ('id', 'z')) var_chi_mean = savefile.createVariable('chi_mean', 'd', ('id', 'z')) var_chi_mean_env = savefile.createVariable('chi_mean_env', 'd', ('id', 'z')) var_chi_mean_condensed = savefile.createVariable('chi_mean_condensed', 'd', ('id', 'z')) var_t[:] = t var_z[:] = z var_chi[:] = chi var_chi_mean[:] = chi_mean*(~mask) var_chi_mean_condensed[:] = chi_mean_condensed*(~mask) var_chi_mean_env[:] = chi_mean_env*(~mask) condensedfile.close() envfile.close() shellfile.close() statfile.close() savefile.close()
def main(): sample_types = ('CONDENSED', 'EDGE', 'SHELL', 'ENV',) stats_dict = {} for l in range(mc.nt): print l cluster_dict = {} nc_files = {} nc_files['CONDENSED'] = Dataset('../time_profiles/cdf/condensed_profile_%08d.nc' % l) nc_files['PLUME'] = Dataset('../time_profiles/cdf/plume_profile_%08d.nc' % l) area = nc_files['CONDENSED'].variables['AREA'][:] mask = (area > 0.) area[~mask] = 0. cluster_dict['AREA'] = area[mask] if mask.sum() == 0: nc_files['CONDENSED'].close() stats_dict[l] = {} continue mask_top = mask.copy() mask_top[:, 1:-1] = mask[:, 1:-1] & ~mask[:, 2:] & mask[:, :-2] mask_bottom = mask.copy() mask_bottom[:, 1:-1] = mask[:, 1:-1] & mask[:, 2:] & ~mask[:, :-2] nc_files['EDGE'] = Dataset('../time_profiles/cdf/condensed_edge_profile_%08d.nc' % l) nc_files['SHELL'] = Dataset('../time_profiles/cdf/condensed_shell_profile_%08d.nc' % l) nc_files['ENV'] = Dataset('../time_profiles/cdf/condensed_env_profile_%08d.nc' % l) entrain_file = Dataset('../time_profiles/cdf/condensed_entrain_profile_%08d.nc' % l) surface_file = Dataset('../time_profiles/cdf/surface_profile_%08d.nc' % l) condensed_shell_file = Dataset('../time_profiles/cdf/condensed_shell_profile_%08d.nc' % l) chi_file = Dataset('../time_profiles/cdf/condensed_chi_profile_%08d.nc' % l) stat_file = Dataset(mc.get_stat()) z = nc_files['CONDENSED'].variables['z'][:] z = np.resize(z, mask.shape) cluster_dict['z'] = z[mask] # Calculate and store cloud thickness for each sample # Use maked arrays to preserve axes; if z_min == z_max, thickness = dz masked_z = np.ma.masked_where(area==0., z) depth = np.ones_like(z)*(masked_z.max(axis=1) - masked_z.min(axis=1))[:, np.newaxis] + mc.dz cluster_dict['depth'] = depth[mask] # Calculate and store condensed shell relative humidity r = condensed_shell_file.variables['QV'][:] p = condensed_shell_file.variables['PRES'][:] T = condensed_shell_file.variables['TABS'][:] relh = thermo.e(r, p)/thermo.e_star(T) cluster_dict['RELH_COND_SHELL'] = relh[mask] z = z*mask zmax = np.ones_like(mask)*(z.max(1))[:, np.newaxis] z[~mask] = 1e8 zmin = np.ones_like(mask)*(z.min(1))[:, np.newaxis] cluster_dict['z_scaled'] = ((z - zmin.min())/(zmax-zmin.min()))[mask] rho = nc_files['CONDENSED'].variables['RHO'][:] cluster_dict['RHO'] = rho[mask] mf = rho*area*nc_files['CONDENSED'].variables['W'][:] cluster_dict['MF'] = mf[mask] for var in ('W', 'QT', 'THETAV', 'THETAL', 'QN'): for type in sample_types: temp = nc_files[type].variables[var][:] cluster_dict[var + '_' + type] = temp[mask] if var != 'W': temp = stat_file.variables[var][:] if var == 'QT': temp = temp/1000. temp2 = nc_files['CONDENSED'].variables[var][:] - temp[l, :] cluster_dict[var + '_' + type + '-MEAN'] = temp2[mask] cluster_dict[var + '_CONDENSED-ENV'] = cluster_dict[var + '_CONDENSED'] - cluster_dict[var + '_ENV'] cluster_dict[var + '_CONDENSED-SHELL'] = cluster_dict[var + '_CONDENSED'] - cluster_dict[var + '_SHELL'] tv = stat_file.variables['THETAV'][l, :] tv[1:-1] = (tv[2:]-tv[:-2])/mc.dz/2. tv = tv*ones_like(temp) cluster_dict['dTHETAV_dz_MEAN'] = tv[mask] for var in ('DWDZ', 'DPDZ', 'THETAV_LAPSE'): temp = nc_files['CONDENSED'].variables[var][:] cluster_dict[var + '_CONDENSED'] = temp[mask] chi = chi_file.variables['chi'][:] # chi_shell = chi_file.variables['chi_shell'][:] # chi_se = chi_file.variables['chi_se'][:] cluster_dict['CHI'] = chi[mask] # cluster_dict['CHI_SHELL'] = chi_shell[mask] surface = surface_file.variables['CONDENSED_SURFACE'][:] cluster_dict['SURFACE'] = surface[mask] lsmf = stat_file.variables['MFTETCLD'][l, :] lsrhoa = stat_file.variables['RHO'][l, :]*stat_file.variables['VTETCLD'][l,:] E = entrain_file.variables['ETETCLD'][:] D = entrain_file.variables['DTETCLD'][:] massflux = entrain_file.variables['MFTETCLD'][:] volume = entrain_file.variables['VTETCLD'][:] epsilon = E/massflux delta = D/massflux wepsilon = E/rho/volume wdelta = D/rho/volume cluster_dict['E'] = E[mask] cluster_dict['D'] = D[mask] cluster_dict['EPSILON'] = epsilon[mask] cluster_dict['DELTA'] = delta[mask] cluster_dict['EPSILON_LS'] = (E/lsmf)[mask] cluster_dict['DELTA_LS'] = (D/lsmf)[mask] cluster_dict['WEPSILON'] = wepsilon[mask] cluster_dict['WDELTA'] = wdelta[mask] cluster_dict['WEPSILON_LS'] = (E/lsrhoa)[mask] cluster_dict['WDELTA_LS'] = (D/lsrhoa)[mask] for var in (('MF', mf), ('AREA', area)): temp = var[1] temp_result = (temp[:, 2:] - temp[:, :-2])/mc.dz/2. temp_top = (temp[:, 2:] - temp[:, 1:-1])/mc.dz temp_bottom = (temp[:, 1:-1] - temp[:, :-2])/mc.dz temp_result[mask_top] = temp_top[mask_top] temp_result[mask_bottom] = temp_bottom[mask_bottom] cluster_dict['d_' + var[0] + '_dz'] = temp_result[mask] cluster_dict['TIME'] = ones_like(z[mask])*l*mc.dt for item in cluster_dict: if item in stats_dict: stats_dict[item].append(cluster_dict[item]) else: stats_dict[item] = [cluster_dict[item]] for type in sample_types: nc_files[type].close() entrain_file.close() chi_file.close() for item in stats_dict: stats_dict[item] = np.hstack(stats_dict[item]) pickle.dump(stats_dict, open('pkl/condensed_time_stats.pkl', 'wb'))
#!/usr/bin/env python #Runtime (690, 130, 128, 128): 3 hours 40 minutes from pylab import * import numpy import cPickle from netCDF4 import Dataset import os from ent_analysis.lib.thermo import SAM import ent_analysis.lib.model_param as mc # Load mean cloud field stat stat_file = Dataset(mc.get_stat()) data = {'z': stat_file.variables['z'][:].astype(double), 'RHO' : stat_file.variables['RHO'][0,:].astype(double), 'PRES' : stat_file.variables['PRES'][0,:].astype(double)*100.} stat_file.close() def create_savefile(t, data, vars, profile_name): ids = data['ids'][:] z = data['z'][:] savefile = Dataset('cdf/%s_profile_%08d.nc' % (profile_name, t), 'w') # Create savefile savefile.createDimension('ids', len(ids)) savefile.createDimension('z', len(z)) tsavevar = savefile.createVariable('ids', 'd', ('ids',)) tsavevar[:] = ids[:] zsavevar = savefile.createVariable('z', 'd', ('z',)) zsavevar[:] = z[:]
def main(): sample_types = ('CORE', 'ENV', 'PLUME') stats_dict = {} for l in range(mc.nt): print l cluster_dict = {} nc_files = {} nc_files['CORE'] = Dataset('../time_profiles/cdf/core_profile_%08d.nc' % l) nc_files['PLUME'] = Dataset('../time_profiles/cdf/plume_profile_%08d.nc' % l) area = nc_files['CORE'].variables['AREA'][:] mask = (area > 0.) area[~mask] = 0. cluster_dict['AREA'] = area[mask] if mask.sum() == 0: nc_files['CORE'].close() nc_files['PLUME'].close() continue nc_files['EDGE'] = Dataset('../time_profiles/cdf/core_edge_profile_%08d.nc' % l) nc_files['SHELL'] = Dataset('../time_profiles/cdf/core_shell_profile_%08d.nc' % l) nc_files['ENV'] = Dataset('../time_profiles/cdf/core_env_profile_%08d.nc' % l) entrain_file = Dataset('../time_profiles/cdf/core_entrain_profile_%08d.nc' % l) surface_file = Dataset('../time_profiles/cdf/surface_profile_%08d.nc' % l) condensed_shell_file = Dataset('../time_profiles/cdf/condensed_shell_profile_%08d.nc' % l) chi_file = Dataset('../time_profiles/cdf/core_chi_profile_%08d.nc' % l) stat_file = Dataset(mc.get_stat()) z = nc_files['CORE'].variables['z'][:] z = np.resize(z, mask.shape) cluster_dict['z'] = z[mask] # Calculate and store cloud thickness for each sample # Use maked arrays to preserve axes; if z_min == z_max, thickness = dz masked_z = np.ma.masked_where(area==0., z) depth = np.ones_like(z)*(masked_z.max(axis=1) - masked_z.min(axis=1))[:, np.newaxis] + mc.dz cluster_dict['depth'] = depth[mask] # Calculate and store condensed shell relative humidity r = condensed_shell_file.variables['QV'][:] p = condensed_shell_file.variables['PRES'][:] T = condensed_shell_file.variables['TABS'][:] relh = thermo.e(r, p)/thermo.e_star(T) cluster_dict['RELH_COND_SHELL'] = relh[mask] stat_core = stat_file.variables['COR'][l, :] if (stat_core > 0.).any(): k_cb = np.nonzero(stat_core > 0.)[0].min() else: k_cb = np.nonzero(area)[1].min() z_cb = ones_like(z)*z[0, k_cb] cluster_dict['z_cb'] = z_cb[mask] z = z*mask zmax = np.ones_like(mask)*(z.max(1))[:, np.newaxis] z[~mask] = 1e10 zmin = np.ones_like(mask)*(z.min(1))[:, np.newaxis] cluster_dict['z_scaled'] = ((z - zmin.min())/(zmax-zmin.min()))[mask] rho = nc_files['CORE'].variables['RHO'][:] cluster_dict['RHO'] = rho[mask] mf = rho*area*nc_files['CORE'].variables['W'][:] cluster_dict['MF'] = mf[mask] for var in ('W', 'QT', 'THETAV', 'THETAL', 'QN'): for type in sample_types: temp = nc_files[type].variables[var][:] cluster_dict[var + '_' + type] = temp[mask] if var != 'W': temp = stat_file.variables[var][:] if var == 'QT': temp = temp/1000. temp2 = nc_files['CORE'].variables[var][:] - temp[l, :] cluster_dict[var + '_' + type + '-MEAN'] = temp2[mask] cluster_dict[var + '_CORE-ENV'] = cluster_dict[var + '_CORE'] - cluster_dict[var + '_ENV'] # cluster_dict[var + '_CORE-SHELL'] = cluster_dict[var + '_CORE'] - cluster_dict[var + '_SHELL'] qsat = SAM.qsatw(nc_files['CORE'].variables['TABS'][:], nc_files['CORE'].variables['PRES'][:]) cluster_dict['QSAT_CORE'] = qsat[mask] qsat_cb = qsat[:, k_cb] qsat_cb = ones_like(qsat)*qsat_cb[:, np.newaxis] cluster_dict['QSAT_CB'] = qsat_cb[mask] tv = stat_file.variables['THETAV'][l, :] tv[1:-1] = (tv[2:]-tv[:-2])/mc.dz/2. tv = tv*ones_like(temp) cluster_dict['dTHETAV_dz_MEAN'] = tv[mask] chi = chi_file.variables['chi_theta'][:] cluster_dict['CHI'] = chi[mask] surface = surface_file.variables['CORE_SURFACE'][:] cluster_dict['SURFACE'] = surface[mask] lsmf = stat_file.variables['MFTETCOR'][l, :] lsrhoa = stat_file.variables['RHO'][l, :]*stat_file.variables['VTETCOR'][l,:] qc = stat_file.variables['QTCOR'][l, :]/1000. qe = stat_file.variables['QTCEN'][l, :]/1000. tc = stat_file.variables['TLCOR'][l, :] te = stat_file.variables['TLCEN'][l, :] wc = stat_file.variables['WCOR'][l, :] we = stat_file.variables['WCEN'][l, :] dwdt = entrain_file.variables['DWDT'][:] E = entrain_file.variables['ETETCOR'][:] D = entrain_file.variables['DTETCOR'][:] Eq = entrain_file.variables['EQTETCOR'][:] Dq = entrain_file.variables['DQTETCOR'][:] Et = entrain_file.variables['ETTETCOR'][:] Dt = entrain_file.variables['DTTETCOR'][:] Ew = entrain_file.variables['EWTETCOR'][:] Dw = entrain_file.variables['DWTETCOR'][:] massflux = entrain_file.variables['MFTETCOR'][:] volume = entrain_file.variables['VTETCOR'][:] cluster_dict['DWDT'] = dwdt[mask] cluster_dict['E'] = E[mask] cluster_dict['D'] = D[mask] cluster_dict['EQ'] = Eq[mask] cluster_dict['DQ'] = Dq[mask] cluster_dict['ET'] = Et[mask] cluster_dict['DT'] = Dt[mask] cluster_dict['EW'] = Ew[mask] cluster_dict['DW'] = Dw[mask] Aq = ((Eq/E) - qe)/(qc - qe) Bq = (qc - (Dq/D))/(qc - qe) At = ((Et/E) - te)/(tc - te) Bt = (tc - (Dt/D))/(tc - te) Aw = ((Ew/E) - we)/(wc - we) Bw = (wc -(Dw/D))/(wc - we) cluster_dict['AQ'] = Aq[mask] cluster_dict['BQ'] = Bq[mask] cluster_dict['AT'] = At[mask] cluster_dict['BT'] = Bt[mask] cluster_dict['AW'] = Aw[mask] cluster_dict['BW'] = Bw[mask] Eq_T = ((qc*(E-D) - (Eq-Dq))/(qc-qe)) Dq_T = ((qe*(E-D) - (Eq-Dq))/(qc-qe)) Et_T = ((tc*(E-D) - (Et-Dt))/(tc-te)) Dt_T = ((te*(E-D) - (Et-Dt))/(tc-te)) Ew_T = ((wc*(E-D) - (Ew-Dw))/(wc-we)) Dw_T = ((we*(E-D) - (Ew-Dw))/(wc-we)) cluster_dict['EQ_T'] = Eq_T[mask] cluster_dict['DQ_T'] = Dq_T[mask] cluster_dict['ET_T'] = Et_T[mask] cluster_dict['DT_T'] = Dt_T[mask] cluster_dict['EW_T'] = Ew_T[mask] cluster_dict['DW_T'] = Dw_T[mask] cluster_dict['EPSILON'] = (E/massflux)[mask] cluster_dict['Q_EPSILON'] = (Eq/massflux)[mask] cluster_dict['T_EPSILON'] = (Et/massflux)[mask] cluster_dict['W_EPSILON'] = (Ew/massflux)[mask] cluster_dict['Q_EPSILON_T'] = (Eq_T/massflux)[mask] cluster_dict['T_EPSILON_T'] = (Et_T/massflux)[mask] cluster_dict['W_EPSILON_T'] = (Ew_T/massflux)[mask] cluster_dict['DELTA'] = (D/massflux)[mask] cluster_dict['Q_DELTA'] = (Dq/massflux)[mask] cluster_dict['T_DELTA'] = (Dt/massflux)[mask] cluster_dict['W_DELTA'] = (Dw/massflux)[mask] cluster_dict['Q_DELTA_T'] = (Dq_T/massflux)[mask] cluster_dict['T_DELTA_T'] = (Dt_T/massflux)[mask] cluster_dict['W_DELTA_T'] = (Dw_T/massflux)[mask] for var in ('DWDZ', 'DPDZ', 'THETAV_LAPSE'): temp = nc_files['CORE'].variables[var][:] cluster_dict[var + '_CORE'] = temp[mask] ww_reyn = nc_files['CORE'].variables['WWREYN'][:] wq_reyn = nc_files['CORE'].variables['WQREYN'][:] ww_reyn = ww_reyn*rho*area wq_reyn = wq_reyn*rho*area ww_reyn[~mask] = 0. wq_reyn[~mask] = 0. qt_core = nc_files['CORE'].variables['QT'][:] qt_core[~mask] = 0. mask_top = mask.copy() mask_top[:, 1:-1] = mask[:, 1:-1] & ~mask[:, 2:] & mask[:, :-2] mask_bottom = mask.copy() mask_bottom[:, 1:-1] = mask[:, 1:-1] & mask[:, 2:] & ~mask[:, :-2] for var in (('MF', mf), ('AREA', area), ('WW', ww_reyn), ('WQ', wq_reyn), ('Q', qt_core),): temp = var[1] temp_result = (temp[:, 2:] - temp[:, :-2])/mc.dz/2. temp_top = (temp[:, 2:] - temp[:, 1:-1])/mc.dz temp_bottom = (temp[:, 1:-1] - temp[:, :-2])/mc.dz temp_result[mask_top] = temp_top[mask_top] temp_result[mask_bottom] = temp_bottom[mask_bottom] cluster_dict['D' + var[0] + 'DZ_CORE'] = temp_result[mask] cluster_dict['TIME'] = ones_like(z[mask])*l*mc.dt ids = nc_files['CORE'].variables['ids'][:] cluster_dict['ID'] = (ones_like(z)*ids[:, np.newaxis])[mask] for item in cluster_dict: if item in stats_dict: stats_dict[item].append(cluster_dict[item]) else: stats_dict[item] = [cluster_dict[item]] for type in sample_types: nc_files[type].close() entrain_file.close() chi_file.close() for item in stats_dict: stats_dict[item] = np.hstack(stats_dict[item]) pickle.dump(stats_dict, open('pkl/core_time_stats.pkl', 'wb'))
def main(filename): vars = { 'ETETCLD': var_calcs.etetcld, 'DTETCLD': var_calcs.dtetcld, 'EQTETCLD': var_calcs.eqtetcld, 'DQTETCLD': var_calcs.dqtetcld, 'ETTETCLD': var_calcs.ettetcld, 'DTTETCLD': var_calcs.dttetcld, 'EWTETCLD': var_calcs.ewtetcld, 'DWTETCLD': var_calcs.dwtetcld, 'VTETCLD': var_calcs.vtetcld, 'MFTETCLD': var_calcs.mftetcld, } # Automatically load time step from output file name time = mc.time_picker(filename) # Load CDF Files nc_file = Dataset(filename) stat_file = Dataset(mc.get_stat()) data = {'z': stat_file.variables['z'][:].astype(double), 'RHO' : stat_file.variables['RHO'][time,:].astype(double), 'PRES' : stat_file.variables['PRES'][time,:].astype(double)*100.} stat_file.close() # For each cloud, iterate over all times cloud_filename = '../cloudtracker/pkl/cloud_data_%08d.pkl' % time # Load the cloud data at that timestep clouds = cPickle.load(open(cloud_filename, 'rb')) ids = clouds.keys() ids.sort() data['ids'] = numpy.array(ids) for name in ('ETETCLD', 'DTETCLD', 'EQTETCLD', 'DQTETCLD', 'ETTETCLD', 'DTTETCLD', 'EWTETCLD', 'DWTETCLD', 'VTETCLD', 'MFTETCLD'): data[name] = nc_file.variables[name][0, :].astype(numpy.double) # For each cloud, create a savefile for each profile savefiles = {} profiles = {} for item in ('condensed_entrain',): savefile, variables = create_savefile(time, data, vars, item) savefiles[item] = savefile profiles[item] = variables for n, id in enumerate(ids): print "time: ", time, " id: ", id # Select the current cloud id cloud = clouds[id] cloud['condensed_entrain'] = numpy.hstack([cloud['condensed'], cloud['condensed_shell']]) make_profiles(profiles, cloud, vars, data, n) for savefile in savefiles.values(): savefile.close() nc_file.close()
def makechi(filename): key = int(filename.split("/")[-1].split("_")[-1].split(".")[0]) print "chi_core_profile", key corefile = Dataset("cdf/core_profile_%08d.nc" % key) envfile = Dataset("cdf/core_env_profile_%08d.nc" % key) shellfile = Dataset("cdf/core_shell_profile_%08d.nc" % key) statfile = Dataset(mc.get_stat()) t = numpy.atleast_1d(corefile.variables["ids"][:]) cloud_duration = len(t) n = len(t) z = envfile.variables["z"][:] p = statfile.variables["PRES"][0, :] * 100.0 thetav_mean = statfile.variables["THETAV"][int(key), :] area_core = numpy.atleast_2d(corefile.variables["AREA"][:]) thetal_core = numpy.atleast_2d(corefile.variables["THETAL"][:]) thetav_core = numpy.atleast_2d(corefile.variables["THETAV"][:]) qt_core = numpy.atleast_2d(corefile.variables["QT"][:]) ql_core = numpy.atleast_2d(corefile.variables["QN"][:]) T_core = numpy.atleast_2d(corefile.variables["TABS"][:]) p = numpy.atleast_2d(corefile.variables["PRES"][:]) thetal_env = numpy.atleast_2d(envfile.variables["THETAL"][:]) qt_env = numpy.atleast_2d(envfile.variables["QT"][:]) thetal_shell = numpy.atleast_2d(shellfile.variables["THETAL"][:]) qt_shell = numpy.atleast_2d(shellfile.variables["QT"][:]) mask = ~(area_core > 0.0) thetal_core_mask = numpy.ma.array(thetal_core, mask=mask) thetav_core_mask = numpy.ma.array(thetav_core, mask=mask) qt_core_mask = numpy.ma.array(qt_core, mask=mask) ql_core_mask = numpy.ma.array(ql_core, mask=mask) T_core_mask = numpy.ma.array(T_core, mask=mask) thetal_env_mask = numpy.ma.array(thetal_env, mask=mask) qt_env_mask = numpy.ma.array(qt_env, mask=mask) thetal_shell_mask = numpy.ma.array(thetal_shell, mask=mask) qt_shell_mask = numpy.ma.array(qt_shell, mask=mask) chi_theta = SAM.find_chi_theta(thetal_core, thetal_env, thetav_core, thetav_mean, qt_core, qt_env, T_core, p) chi_theta_mean = SAM.find_chi_theta( thetal_core_mask.mean(0), thetal_env_mask.mean(0), thetav_core_mask.mean(0), thetav_mean, qt_core_mask.mean(0), qt_env_mask.mean(0), T_core_mask.mean(0), p, ) chi_theta_mean_core = SAM.find_chi_theta( thetal_core_mask.mean(0), thetal_env, thetav_core_mask.mean(0), thetav_mean, qt_core_mask.mean(0), qt_env, T_core_mask.mean(0), p, ) chi_theta_mean_env = SAM.find_chi_theta( thetal_core, thetal_env_mask.mean(0), thetav_core, thetav_mean, qt_core, qt_env_mask.mean(0), T_core, p ) chi_ql = SAM.find_chi_ql(ql_core, thetal_core, thetal_env, qt_core, qt_env, T_core, p) chi_ql_mean = SAM.find_chi_ql( ql_core_mask.mean(0), thetal_core_mask.mean(0), thetal_env_mask.mean(0), qt_core_mask.mean(0), qt_env_mask.mean(0), T_core_mask.mean(0), p, ) chi_ql_mean_core = SAM.find_chi_ql( ql_core_mask.mean(0), thetal_core_mask.mean(0), thetal_env, qt_core_mask.mean(0), qt_env, T_core_mask.mean(0), p ) chi_ql_mean_env = SAM.find_chi_ql( ql_core, thetal_core, thetal_env_mask.mean(0), qt_core, qt_env_mask.mean(0), T_core, p ) # chi[isnan(chi)] = 0. savefile = Dataset("cdf/core_chi_profile_%08d.nc" % key, "w", format="NETCDF3_64BIT") savefile.createDimension("id", cloud_duration) savefile.createDimension("z", len(z)) var_t = savefile.createVariable("id", "d", ("id",)) var_z = savefile.createVariable("z", "d", ("z",)) var_chi_theta = savefile.createVariable("chi_theta", "d", ("id", "z")) var_chi_theta_mean = savefile.createVariable("chi_theta_mean", "d", ("id", "z")) var_chi_theta_mean_env = savefile.createVariable("chi_theta_mean_env", "d", ("id", "z")) var_chi_theta_mean_core = savefile.createVariable("chi_theta_mean_core", "d", ("id", "z")) var_chi_ql = savefile.createVariable("chi_ql", "d", ("id", "z")) var_chi_ql_mean = savefile.createVariable("chi_ql_mean", "d", ("id", "z")) var_chi_ql_mean_env = savefile.createVariable("chi_ql_mean_env", "d", ("id", "z")) var_chi_ql_mean_core = savefile.createVariable("chi_ql_mean_core", "d", ("id", "z")) var_t[:] = t var_z[:] = z var_chi_theta[:] = chi_theta var_chi_theta_mean[:] = chi_theta_mean * (~mask) var_chi_theta_mean_core[:] = chi_theta_mean_core * (~mask) var_chi_theta_mean_env[:] = chi_theta_mean_env * (~mask) var_chi_ql[:] = chi_ql var_chi_ql_mean[:] = chi_ql_mean * (~mask) var_chi_ql_mean_core[:] = chi_ql_mean_core * (~mask) var_chi_ql_mean_env[:] = chi_ql_mean_env * (~mask) corefile.close() envfile.close() shellfile.close() statfile.close() savefile.close()
def main(filename): vars = { 'AREA': var_calcs.area, 'TABS': var_calcs.tabs, 'QN': var_calcs.qn, 'QV': var_calcs.qv, 'QT': var_calcs.qt, 'U': var_calcs.u, 'V': var_calcs.v, 'W': var_calcs.w, 'THETAV': var_calcs.thetav, 'THETAV_LAPSE': var_calcs.thetav_lapse, 'THETAL': var_calcs.thetal, 'MSE': var_calcs.mse, 'RHO': var_calcs.rho, 'PRES': var_calcs.press, 'WQREYN': var_calcs.wqreyn, 'WWREYN': var_calcs.wwreyn, 'DWDZ': var_calcs.dw_dz, 'DPDZ': var_calcs.dp_dz, 'TR01': var_calcs.tr01, } # Automatically load time step from output file name time = mc.time_picker(filename) # Load CDF Files nc_file = Dataset(filename) stat_file = Dataset(mc.get_stat()) data = {'z': nc_file.variables['z'][:].astype(double), 'p': nc_file.variables['p'][:].astype(double), 'RHO' : stat_file.variables['RHO'][time,:].astype(double), } stat_file.close() # For each cloud, iterate over all times cloud_filename = '../cloudtracker/pkl/cloud_data_%08d.pkl' % time # Load the cloud data at that timestep clouds = cPickle.load(open(cloud_filename, 'rb')) ids = clouds.keys() ids.sort() data['ids'] = numpy.array(ids) for name in ('QV', 'QN', 'TABS', 'PP', 'U', 'V', 'W', 'TR01'): data[name] = nc_file.variables[name][0, :].astype(numpy.double) # For each cloud, create a savefile for each profile savefiles = {} profiles = {} for item in ('core', 'condensed', 'condensed_shell', 'condensed_edge', 'condensed_env', 'core_shell', 'core_edge', 'core_env', 'plume'): savefile, variables = create_savefile(time, data, vars, item) savefiles[item] = savefile profiles[item] = variables for n, id in enumerate(ids): print "time: ", time, " id: ", id # Select the current cloud id cloud = clouds[id] make_profiles(profiles, cloud, vars, data, n) for savefile in savefiles.values(): savefile.close() nc_file.close()