def make_plot(netcdf_dir, netcdf_pattern, out_filename): time_filename_list = partmc.get_time_filename_list(netcdf_dir, netcdf_pattern) ccn_array = np.zeros([len(time_filename_list), 4]) i_counter = 0 for [time, filename, key] in time_filename_list: print time, filename, key ncf = scipy.io.netcdf.netcdf_file(filename, 'r') particles = partmc.aero_particle_array_t(ncf) env_state = partmc.env_state_t(ncf) ncf.close() s_crit = (particles.critical_rel_humids(env_state) - 1) * 100 activated_1 = (s_crit < config.s_crit_1) number_act_1 = sum(1 / particles.comp_vols[activated_1]) activated_2 = (s_crit < config.s_crit_2) number_act_2 = sum(1 / particles.comp_vols[activated_2]) activated_3 = (s_crit < config.s_crit_3) number_act_3 = sum(1 / particles.comp_vols[activated_3]) ccn_array[i_counter, 0] = time ccn_array[i_counter, 1] = number_act_1 ccn_array[i_counter, 2] = number_act_2 ccn_array[i_counter, 3] = number_act_3 i_counter += 1 print ccn_array np.savetxt(out_filename, ccn_array)
def check_num(in_dir, in_filename, in_file_pattern, out_filename, counter): time_filename_list = partmc.get_time_filename_list(in_dir, in_file_pattern) id_p_array = np.array([16388, 10, 33311, 9212, 451, 11769]) d = np.zeros((len(id_p_array),len(time_filename_list))) seconds = np.zeros(len(time_filename_list)) i_count = 0 for [time, filename, key] in time_filename_list: print time, filename, key ncf = scipy.io.netcdf.netcdf_file(filename, 'r') particles = partmc.aero_particle_array_t(ncf) ncf.close() wet_diameters = particles.diameters() id_list = list(particles.ids) for i in range(0,6): i_index = id_list.index(id_p_array[i]) d[i,i_count] = wet_diameters[i_index] seconds[i_count] = i_count i_count = i_count + 1 plt.figure() plt.semilogy(seconds, d[0,:], 'b-', label = 'act1_2') plt.semilogy(seconds, d[1,:], 'g-', label = 'not_1_2') plt.semilogy(seconds, d[2,:], 'r-', label = 'act2_not_act1') plt.semilogy(seconds, d[3,:], 'b-', label = 'act1_2') plt.semilogy(seconds, d[4,:], 'g-', label = 'not_1_2') plt.semilogy(seconds, d[5,:], 'r-', label = 'act2_not_act1') plt.xlabel("time (s)") plt.ylabel("diameter (m)") plt.legend(loc = 'upper left') fig = plt.gcf() fig.savefig(out_filename)
def make_plot(netcdf_pattern, aging_ss, output_pkl): particle_set = {} netcdf_dir = "/Users/nriemer/subversion/partmc/trunk/scenarios/1_urban_plume/out" time_filename_list = partmc.get_time_filename_list(netcdf_dir, netcdf_pattern) for [time, filename, key] in time_filename_list: print time, filename, key ncf = scipy.io.netcdf.netcdf_file(filename, 'r') particles = partmc.aero_particle_array_t(ncf) removed_info = partmc.aero_removed_info_t(ncf) env_state = partmc.env_state_t(ncf) ncf.close() dry_diameters = particles.dry_diameters() s_crit = (particles.critical_rel_humids(env_state) - 1) * 100 bc = particles.masses(include=["BC"]) no3 = particles.masses(include=["NO3"]) so4 = particles.masses(include=["SO4"]) nh4 = particles.masses(include=["NH4"]) dry_mass = particles.masses(exclude=["H2O"]) bc_frac = bc / dry_mass no3_frac = no3 / dry_mass so4_frac = so4 / dry_mass nh4_frac = nh4 / dry_mass solute_frac = (no3 + so4 + nh4) / dry_mass kappas = particles.kappas() comp_vols = particles.comp_vols h2o = particles.masses(include=["H2O"]) for id in particle_set.keys(): while particle_set[id].current_id in removed_info.ids: i = np.nonzero( removed_info.ids == particle_set[id].current_id)[0][0] if removed_info.actions[i] != removed_info.AERO_INFO_COAG: particle_set[id].remove_time = time particle_set[id].current_id = 0 else: particle_set[id].current_id = removed_info.other_ids[i] for i in range(len(particles.ids)): id = particles.ids[i] if id not in particle_set: particle_set[id] = Struct() particle_set[id].current_id = id particle_set[id].emit_time = time particle_set[id].emit_diam = dry_diameters[i] particle_set[id].emit_s_crit = s_crit[i] particle_set[id].emit_kappa = kappas[i] particle_set[id].remove_time = -1 particle_set[id].aged_flag = False particle_set[id].aging_time = -1 particle_set[id].min_s_crit = s_crit[i] particle_set[id].emit_bc_fraction = bc_frac[i] particle_set[id].emit_comp_vols = comp_vols[i] particle_set[id].aging_kappa = -1 particle_set[id].aging_h2o = -1 particle_set[id].aging_no3_fraction = -1 particle_set[id].aging_so4_fraction = -1 particle_set[id].aging_nh4_fraction = -1 particle_set[id].aging_solute_fraction = -1 particle_set[id].aging_diameter = -1 for id in particle_set.keys(): if particle_set[id].current_id in particles.ids: i = np.nonzero( particles.ids == particle_set[id].current_id)[0][0] if s_crit[i] <= particle_set[id].min_s_crit: particle_set[id].min_s_crit = s_crit[i] if (s_crit[i] <= aging_ss) and (particle_set[id].aged_flag == False): particle_set[id].aging_time = time particle_set[id].aged_flag = True particle_set[id].aging_kappa = kappas[i] particle_set[id].aging_diameter = dry_diameters[i] particle_set[id].aging_h2o = h2o[i] particle_set[id].aging_no3_fraction = no3_frac[i] particle_set[id].aging_so4_fraction = so4_frac[i] particle_set[id].aging_nh4_fraction = nh4_frac[i] particle_set[id].aging_solute_fraction = solute_frac[i] output = open(output_pkl, 'wb') pickle.dump(particle_set, output) output.close()
#!/usr/bin/env python2.5 import scipy.io import sys import numpy as np import matplotlib matplotlib.use("PDF") import matplotlib.pyplot as plt sys.path.append("../../tool") import partmc import config netcdf_dir = "../../scenarios/2_urban_plume2/out/" netcdf_pattern = "urban_plume_nc_0001_(.*).nc" time_filename_list = partmc.get_time_filename_list(netcdf_dir, netcdf_pattern) ccn_cn_array = np.zeros([len(time_filename_list), 4]) i_counter = 0 age_by_id = {} for [time, filename, key] in time_filename_list: print time, filename, key ncf = scipy.io.netcdf.netcdf_file(filename, 'r') particles = partmc.aero_particle_array_t(ncf) env_state = partmc.env_state_t(ncf) ncf.close() s_crit = (particles.critical_rel_humids(env_state) - 1) * 100 activated_1 = (s_crit < config.s_crit_1) activated_id_set = set(particles.ids[activated_1])
def make_plot(filename_in_080, filename_in_100, filename_in_130, filename_in_150, dir_cloud, in_file_pattern): ## calculate critical supersaturation for each particle print filename_in_100 ncf = scipy.io.netcdf.netcdf_file(filename_in_080, 'r') particles = partmc.aero_particle_array_t(ncf) particles.sort_by_id() env_state_080s = partmc.env_state_t(ncf) ncf.close() ncf = scipy.io.netcdf.netcdf_file(filename_in_100, 'r') particles = partmc.aero_particle_array_t(ncf) particles.sort_by_id() env_state_100s = partmc.env_state_t(ncf) ncf.close() dry_diameters = particles.dry_diameters() ncf = scipy.io.netcdf.netcdf_file(filename_in_130, 'r') particles = partmc.aero_particle_array_t(ncf) particles.sort_by_id() env_state_130s = partmc.env_state_t(ncf) ncf.close() ncf = scipy.io.netcdf.netcdf_file(filename_in_150, 'r') particles = partmc.aero_particle_array_t(ncf) particles.sort_by_id() env_state_150s = partmc.env_state_t(ncf) ncf.close() dry_diameters = particles.dry_diameters() ## calculate time series for RH and maximum RH that occurs print dir_cloud, in_file_pattern env_state_history = partmc.read_history(partmc.env_state_t, dir_cloud, in_file_pattern) env_state_init = env_state_history[0][1] time = [env_state_history[i][0] for i in range(len(env_state_history))] rh = [ env_state_history[i][1].relative_humidity for i in range(len(env_state_history)) ] temp = [ env_state_history[i][1].temperature for i in range(len(env_state_history)) ] maximum_ss = (max(rh) - 1) * 100. print 'maximum ss ', maximum_ss rh_final = rh[-1] ## calculate time series for each particle print dir_cloud, in_file_pattern time_filename_list = partmc.get_time_filename_list(dir_cloud, in_file_pattern) rh_c = np.zeros((len(dry_diameters), len(time_filename_list))) rh_c_final = np.zeros(len(dry_diameters)) d_c = np.zeros((len(dry_diameters), len(time_filename_list))) d = np.zeros((len(dry_diameters), len(time_filename_list))) rh_eq = np.zeros((len(dry_diameters), len(time_filename_list))) kappas = np.zeros((len(dry_diameters), len(time_filename_list))) dry_diam = np.zeros((len(dry_diameters), len(time_filename_list))) ids = np.zeros((len(dry_diameters), len(time_filename_list)), dtype=int) seconds = np.zeros(len(time_filename_list)) i_count = 0 for [time, filename, key] in time_filename_list: print time, filename, key ncf = scipy.io.netcdf.netcdf_file(filename, 'r') particles = partmc.aero_particle_array_t(ncf) particles.sort_by_id() env_state = partmc.env_state_t(ncf) ncf.close() rh_c[:, i_count] = particles.critical_rel_humids(env_state) d_c[:, i_count] = particles.critical_diameters(env_state) d[:, i_count] = particles.diameters() rh_eq[:, i_count] = particles.equilib_rel_humids(env_state) kappas[:, i_count] = particles.kappas() dry_diam[:, i_count] = particles.dry_diameters() ids[:, i_count] = particles.ids seconds[i_count] = i_count i_count = i_count + 1 d_max = d.max(axis=1) rh_c_final = rh_c[:, -1] d_final = d[:, -1] d_c_final = d_c[:, -1] ## find the particles in the four categories ## 1. particles that do not activate not_activate = np.logical_and(np.all(rh < rh_c, axis=1), np.all(d < d_c, axis=1)) id_list_not_activate = particles.ids[not_activate] print "id_list_not_activate ", id_list_not_activate plot_id = id_list_not_activate[0] plot_index = partmc.find_nearest_index(particles.ids, plot_id) diam_not_activate = d[plot_index, :] rh_eq_not_activate = rh_eq[plot_index, :] ids_not_activate = ids[plot_index, :] rh_c_not_activate = rh_c[plot_index, :] d_c_not_activate = d_c[plot_index, :] dry_diam_not_activate = dry_diam[plot_index, 0] kappa_not_activate = kappas[plot_index, 0] wet_diameters_not_activate = partmc.log_grid( min=1.1 * dry_diam_not_activate, max=100 * dry_diam_not_activate, n_bin=100).edges() equilib_rhs_not_activate_grid_080 = partmc.equilib_rel_humids( env_state_080s, kappa_not_activate, dry_diam_not_activate, wet_diameters_not_activate) equilib_rhs_not_activate_grid_100 = partmc.equilib_rel_humids( env_state_100s, kappa_not_activate, dry_diam_not_activate, wet_diameters_not_activate) equilib_rhs_not_activate_grid_130 = partmc.equilib_rel_humids( env_state_130s, kappa_not_activate, dry_diam_not_activate, wet_diameters_not_activate) equilib_rhs_not_activate_grid_150 = partmc.equilib_rel_humids( env_state_150s, kappa_not_activate, dry_diam_not_activate, wet_diameters_not_activate) ## 2. evaporation type evaporation = np.logical_and( np.logical_and(np.any(rh > rh_c, axis=1), np.all(d < d_c, axis=1)), (rh_final < rh_c_final)) id_list_evaporation = particles.ids[evaporation] print "id_list_evaporation ", id_list_evaporation # plot_id = id_list_evaporation[0] rh_c_init = rh_c[:, 0] rh_c_init_evaporation = np.ma.masked_where(np.logical_not(evaporation), rh_c_init) plot_index = rh_c_init_evaporation.argmin() # plot_index = partmc.find_nearest_index(particles.ids, plot_id) diam_evaporation = d[plot_index, :] ids_evaporation = ids[plot_index, :] rh_eq_evaporation = rh_eq[plot_index, :] rh_c_evaporation = rh_c[plot_index, :] d_c_evaporation = d_c[plot_index, :] dry_diam_evaporation = dry_diam[plot_index, 0] kappa_evaporation = kappas[plot_index, 0] wet_diameters_evaporation = partmc.log_grid(min=1.1 * dry_diam_evaporation, max=100 * dry_diam_evaporation, n_bin=100).edges() equilib_rhs_evaporation_grid_080 = partmc.equilib_rel_humids( env_state_080s, kappa_evaporation, dry_diam_evaporation, wet_diameters_evaporation) equilib_rhs_evaporation_grid_100 = partmc.equilib_rel_humids( env_state_100s, kappa_evaporation, dry_diam_evaporation, wet_diameters_evaporation) equilib_rhs_evaporation_grid_130 = partmc.equilib_rel_humids( env_state_130s, kappa_evaporation, dry_diam_evaporation, wet_diameters_evaporation) equilib_rhs_evaporation_grid_150 = partmc.equilib_rel_humids( env_state_150s, kappa_evaporation, dry_diam_evaporation, wet_diameters_evaporation) ## 3. deactivation type deactivation = np.logical_and( np.logical_and(np.any(rh > rh_c, axis=1), np.any(d > d_c, axis=1)), (d_final < d_c_final)) id_list_deactivation = particles.ids[deactivation] print "id_list_deactivation ", id_list_deactivation # plot_id = id_list_deactivation[0] rh_c_init = rh_c[:, 0] rh_c_init_deactivation = np.ma.masked_where(np.logical_not(deactivation), rh_c_init) plot_index = rh_c_init_deactivation.argmin() # plot_index = partmc.find_nearest_index(particles.ids, plot_id) diam_deactivation = d[plot_index, :] ids_deactivation = ids[plot_index, :] rh_eq_deactivation = rh_eq[plot_index, :] rh_c_deactivation = rh_c[plot_index, :] d_c_deactivation = d_c[plot_index, :] dry_diam_deactivation = dry_diam[plot_index, 0] kappa_deactivation = kappas[plot_index, 0] wet_diameters_deactivation = partmc.log_grid( min=1.1 * dry_diam_deactivation, max=100 * dry_diam_deactivation, n_bin=100).edges() equilib_rhs_deactivation_grid_080 = partmc.equilib_rel_humids( env_state_080s, kappa_deactivation, dry_diam_deactivation, wet_diameters_deactivation) equilib_rhs_deactivation_grid_100 = partmc.equilib_rel_humids( env_state_100s, kappa_deactivation, dry_diam_deactivation, wet_diameters_deactivation) equilib_rhs_deactivation_grid_130 = partmc.equilib_rel_humids( env_state_130s, kappa_deactivation, dry_diam_deactivation, wet_diameters_deactivation) equilib_rhs_deactivation_grid_150 = partmc.equilib_rel_humids( env_state_150s, kappa_deactivation, dry_diam_deactivation, wet_diameters_deactivation) ## 4. inertial type inertial = np.logical_and( np.logical_and(np.any(rh > rh_c, axis=1), np.all(d < d_c, axis=1)), (rh_final > rh_c_final)) id_list_inertial = particles.ids[inertial] print "id_list_inertial ", id_list_inertial plot_id = id_list_inertial[0] plot_index = partmc.find_nearest_index(particles.ids, plot_id) diam_inertial = d[plot_index, :] ids_inertial = ids[plot_index, :] rh_eq_inertial = rh_eq[plot_index, :] rh_c_inertial = rh_c[plot_index, :] d_c_inertial = d_c[plot_index, :] dry_diam_inertial = dry_diam[plot_index, 0] kappa_inertial = kappas[plot_index, 0] wet_diameters_inertial = partmc.log_grid(min=1.1 * dry_diam_inertial, max=100 * dry_diam_inertial, n_bin=100).edges() equilib_rhs_inertial_grid_080 = partmc.equilib_rel_humids( env_state_080s, kappa_inertial, dry_diam_inertial, wet_diameters_inertial) equilib_rhs_inertial_grid_100 = partmc.equilib_rel_humids( env_state_100s, kappa_inertial, dry_diam_inertial, wet_diameters_inertial) equilib_rhs_inertial_grid_130 = partmc.equilib_rel_humids( env_state_130s, kappa_inertial, dry_diam_inertial, wet_diameters_inertial) equilib_rhs_inertial_grid_150 = partmc.equilib_rel_humids( env_state_150s, kappa_inertial, dry_diam_inertial, wet_diameters_inertial) np.savetxt("seconds.txt", seconds) np.savetxt("rh.txt", rh) np.savetxt("diam_not_activate.txt", diam_not_activate) np.savetxt("diam_evaporation.txt", diam_evaporation) np.savetxt("diam_deactivation.txt", diam_deactivation) np.savetxt("diam_inertial.txt", diam_inertial) np.savetxt("rh_eq_not_activate.txt", rh_eq_not_activate) np.savetxt("rh_eq_evaporation.txt", rh_eq_evaporation) np.savetxt("rh_eq_deactivation.txt", rh_eq_deactivation) np.savetxt("rh_eq_inertial.txt", rh_eq_inertial) np.savetxt("ids_not_activate.txt", ids_not_activate) np.savetxt("ids_evaporation.txt", ids_evaporation) np.savetxt("ids_deactivation.txt", ids_deactivation) np.savetxt("ids_inertial.txt", ids_inertial) np.savetxt("rh_c_not_activate.txt", rh_c_not_activate) np.savetxt("rh_c_evaporation.txt", rh_c_evaporation) np.savetxt("rh_c_deactivation.txt", rh_c_deactivation) np.savetxt("rh_c_inertial.txt", rh_c_inertial) np.savetxt("d_c_not_activate.txt", d_c_not_activate) np.savetxt("d_c_evaporation.txt", d_c_evaporation) np.savetxt("d_c_deactivation.txt", d_c_deactivation) np.savetxt("d_c_inertial.txt", d_c_inertial) np.savetxt("wet_diameters_not_activate.txt", wet_diameters_not_activate) np.savetxt("wet_diameters_evaporation.txt", wet_diameters_evaporation) np.savetxt("wet_diameters_deactivation.txt", wet_diameters_deactivation) np.savetxt("wet_diameters_inertial.txt", wet_diameters_inertial) np.savetxt("equilib_rhs_not_activate_grid_080.txt", equilib_rhs_not_activate_grid_080) np.savetxt("equilib_rhs_evaporation_grid_080.txt", equilib_rhs_evaporation_grid_080) np.savetxt("equilib_rhs_deactivation_grid_080.txt", equilib_rhs_deactivation_grid_080) np.savetxt("equilib_rhs_inertial_grid_080.txt", equilib_rhs_inertial_grid_080) np.savetxt("equilib_rhs_not_activate_grid_100.txt", equilib_rhs_not_activate_grid_100) np.savetxt("equilib_rhs_evaporation_grid_100.txt", equilib_rhs_evaporation_grid_100) np.savetxt("equilib_rhs_deactivation_grid_100.txt", equilib_rhs_deactivation_grid_100) np.savetxt("equilib_rhs_inertial_grid_100.txt", equilib_rhs_inertial_grid_100) np.savetxt("equilib_rhs_not_activate_grid_130.txt", equilib_rhs_not_activate_grid_130) np.savetxt("equilib_rhs_evaporation_grid_130.txt", equilib_rhs_evaporation_grid_130) np.savetxt("equilib_rhs_deactivation_grid_130.txt", equilib_rhs_deactivation_grid_130) np.savetxt("equilib_rhs_inertial_grid_130.txt", equilib_rhs_inertial_grid_130) np.savetxt("equilib_rhs_not_activate_grid_150.txt", equilib_rhs_not_activate_grid_150) np.savetxt("equilib_rhs_evaporation_grid_150.txt", equilib_rhs_evaporation_grid_150) np.savetxt("equilib_rhs_deactivation_grid_150.txt", equilib_rhs_deactivation_grid_150) np.savetxt("equilib_rhs_inertial_grid_150.txt", equilib_rhs_inertial_grid_150)
import sys import numpy as np import matplotlib matplotlib.use("PDF") import matplotlib.pyplot as plt sys.path.append("../../tool") import partmc import config i_loop_max = config.i_loop_max #for counter in ["10K_wei\\+1", "10K_flat", "10K_wei-1", "10K_wei-2", "10K_wei-3", "10K_wei-4","1K_wei\\+1", "1K_flat", "1K_wei-1", "1K_wei-2", "1K_wei-3", "1K_wei-4"]: #for counter in ["10K_mfa", "1K_mfa"]: for counter in ["100K_wei\\+1", "100K_flat", "100K_wei-1", "100K_wei-2", "100K_wei-3", "100K_wei-4", "100K_mfa"]: netcdf_pattern = "urban_plume_wc_%s_0001_(.*).nc" % counter time_filename_list = partmc.get_time_filename_list(config.netcdf_dir, netcdf_pattern) time_array = np.zeros([len(time_filename_list)]) num_avg = np.zeros([len(time_filename_list), i_loop_max]) mass_avg = np.zeros([len(time_filename_list), i_loop_max]) num_std = np.zeros([len(time_filename_list), i_loop_max]) mass_std = np.zeros([len(time_filename_list), i_loop_max]) array_num = np.zeros([len(time_filename_list), i_loop_max]) array_mass = np.zeros([len(time_filename_list), i_loop_max]) num_avg_overall = np.zeros([i_loop_max]) mass_avg_overall = np.zeros([i_loop_max]) num_std_overall = np.zeros([i_loop_max])
def check_num(in_dir1, in_filename1, in_file_pattern, indir2, in_filename2, out_filename1, out_filename2, out_filename3, counter): ncf = scipy.io.netcdf.netcdf_file(in_dir1 + in_filename1, 'r') particles1 = partmc.aero_particle_array_t(ncf) ncf.close() ncf = scipy.io.netcdf.netcdf_file(in_dir2 + in_filename2, 'r') particles2 = partmc.aero_particle_array_t(ncf) particles2.aero_data.kappa[17] = 0.1 particles2.aero_data = particles1.aero_data ncf.close() final_wet_diameters = particles1.diameters() is_activated1 = (final_wet_diameters > 3e-6) sum_tot1 = sum(1 / particles1.comp_vols) * particles1.comp_vols[0] num_act1 = sum( 1 / particles1.comp_vols[is_activated1]) * particles1.comp_vols[0] id_list_act1 = particles1.ids[is_activated1] is_not_activated1 = np.logical_not(is_activated1) id_list_not_act1 = particles1.ids[is_not_activated1] ccn_cn_ratio1 = num_act1 / sum_tot1 env_state_history = partmc.read_history(partmc.env_state_t, in_dir1, in_file_pattern) time = [env_state_history[i][0] for i in range(len(env_state_history))] rh = [ env_state_history[i][1].relative_humidity for i in range(len(env_state_history)) ] maximum_ss = (max(rh) - 1) * 100. max_index = np.argmax(np.array(rh)) time_index = time[max_index] time_filename_list = partmc.get_time_filename_list(in_dir1, in_file_pattern) max_filename = partmc.find_filename_at_time(time_filename_list, time_index) ncf = scipy.io.netcdf.netcdf_file(max_filename, 'r') max_env_state = partmc.env_state_t(ncf) ncf.close() max_wet_diameters = np.zeros_like(final_wet_diameters) max_critical_ratio = np.zeros_like(final_wet_diameters) for [time, filename, key] in time_filename_list: print 'time filename key ', time, filename, key ncf = scipy.io.netcdf.netcdf_file(filename, 'r') particles = partmc.aero_particle_array_t(ncf) env_state = partmc.env_state_t(ncf) ncf.close() wet_diameters = particles.diameters() max_wet_diameters = np.maximum(max_wet_diameters, wet_diameters) critical_diameters = particles.critical_diameters(env_state) critical_ratio = wet_diameters / critical_diameters max_critical_ratio = np.maximum(max_critical_ratio, critical_ratio) max_wet_ratio = max_wet_diameters / final_wet_diameters s_crit = (particles2.critical_rel_humids(max_env_state) - 1) * 100 is_activated2 = (s_crit <= maximum_ss) id_list_act2 = particles2.ids[is_activated2] is_not_activated2 = np.logical_not(is_activated2) id_list_not_act2 = particles2.ids[is_not_activated2] sum_tot2 = sum(1 / particles2.comp_vols) * particles2.comp_vols[0] num_act2 = sum( 1 / particles2.comp_vols[is_activated2]) * particles2.comp_vols[0] ccn_cn_ratio2 = num_act2 / sum_tot2 set_act1 = set(id_list_act1) set_not_act1 = set(id_list_not_act1) set_act2 = set(id_list_act2) set_not_act2 = set(id_list_not_act2) act_1_2 = (set_act1 & set_act2) not_1_2 = (set_not_act1 & set_not_act2) act1_not_act2 = (set_act1 & set_not_act2) act2_not_act1 = (set_act2 & set_not_act1) print 'act_1_2 ', act_1_2 print 'not_1_2 ', not_1_2 print 'act1_not_act2 ', act1_not_act2 print 'act2_not_act1 ', act2_not_act1 diam_by_id1 = dict(zip(particles1.ids, particles1.dry_diameters())) diam_by_id2 = dict(zip(particles2.ids, particles2.dry_diameters())) scrit_by_id1 = dict( zip(particles1.ids, (particles1.critical_rel_humids(max_env_state) - 1) * 100)) scrit_by_id2 = dict( zip(particles2.ids, (particles2.critical_rel_humids(max_env_state) - 1) * 100)) oc_by_id1 = dict( zip( particles1.ids, particles1.masses(include=["BC"]) / particles1.masses(exclude=["H2O"]))) oc_by_id2 = dict( zip( particles2.ids, particles2.masses(include=["BC"]) / particles2.masses(exclude=["H2O"]))) wet_ratio_by_id1 = dict(zip(particles1.ids, max_wet_ratio)) critical_ratio_by_id1 = dict(zip(particles1.ids, max_critical_ratio)) diam_act_1_2 = [diam_by_id2[id] for id in act_1_2] scrit_act_1_2 = [scrit_by_id2[id] for id in act_1_2] oc_act_1_2 = [oc_by_id2[id] for id in act_1_2] wet_ratio_act_1_2 = [wet_ratio_by_id1[id] for id in act_1_2] critical_ratio_act_1_2 = [critical_ratio_by_id1[id] for id in act_1_2] diam_not_1_2 = [diam_by_id2[id] for id in not_1_2] scrit_not_1_2 = [scrit_by_id2[id] for id in not_1_2] oc_not_1_2 = [oc_by_id2[id] for id in not_1_2] wet_ratio_not_1_2 = [wet_ratio_by_id1[id] for id in not_1_2] critical_ratio_not_1_2 = [critical_ratio_by_id1[id] for id in not_1_2] diam_act1_not_act2 = [diam_by_id2[id] for id in act1_not_act2] scrit_act1_not_act2 = [scrit_by_id2[id] for id in act1_not_act2] oc_act1_not_act2 = [oc_by_id2[id] for id in act1_not_act2] wet_ratio_act1_not_act2 = [wet_ratio_by_id1[id] for id in act1_not_act2] critical_ratio_act1_not_act2 = [ critical_ratio_by_id1[id] for id in act1_not_act2 ] diam_act2_not_act1 = [diam_by_id2[id] for id in act2_not_act1] scrit_act2_not_act1 = [scrit_by_id2[id] for id in act2_not_act1] oc_act2_not_act1 = [oc_by_id2[id] for id in act2_not_act1] wet_ratio_act2_not_act1 = [wet_ratio_by_id1[id] for id in act2_not_act1] critical_ratio_act2_not_act1 = [ critical_ratio_by_id1[id] for id in act2_not_act1 ] plt.figure() plt.semilogy(seconds, d[0, :], 'b-', label='act1_2') plt.semilogy(seconds, d[1, :], 'g-', label='not_1_2') plt.semilogy(seconds, d[2, :], 'r-', label='act2_not_act1') plt.semilogy(seconds, d[3, :], 'b-', label='act1_2') plt.semilogy(seconds, d[4, :], 'g-', label='not_1_2') plt.semilogy(seconds, d[5, :], 'r-', label='act2_not_act1') plt.xlabel("time (s)") plt.ylabel("diameter (m)") plt.legend(loc='upper left') fig = plt.gcf() fig.savefig('diameters.pdf') plt.figure() plt.loglog(diam_act_1_2, scrit_act_1_2, 'bx') plt.loglog(diam_not_1_2, scrit_not_1_2, 'gx') plt.loglog(diam_act1_not_act2, scrit_act1_not_act2, 'kx') plt.loglog(diam_act2_not_act1, scrit_act2_not_act1, 'rx') plt.axhline(y=maximum_ss) plt.xlabel("diameter (m)") plt.ylabel("critical supersaturation (%)") fig = plt.gcf() fig.savefig(out_filename1) plt.figure() plt.semilogx(diam_act_1_2, wet_ratio_act_1_2, 'bx') plt.semilogx(diam_not_1_2, wet_ratio_not_1_2, 'gx') plt.semilogx(diam_act1_not_act2, wet_ratio_act1_not_act2, 'kx') plt.semilogx(diam_act2_not_act1, wet_ratio_act2_not_act1, 'rx') plt.xlabel("diameter (m)") plt.ylabel("wet ratio") fig = plt.gcf() fig.savefig(out_filename2) plt.figure() plt.loglog(diam_act_1_2, critical_ratio_act_1_2, 'bx') plt.loglog(diam_not_1_2, critical_ratio_not_1_2, 'gx') plt.loglog(diam_act1_not_act2, critical_ratio_act1_not_act2, 'kx') plt.loglog(diam_act2_not_act1, critical_ratio_act2_not_act1, 'rx') plt.xlabel("diameter (m)") plt.ylabel("critial ratio") fig = plt.gcf() fig.savefig(out_filename3)
def make_plot(netcdf_pattern, aging_ss, output_file_data, output_file_count): global error_detect netcdf_dir = "/Users/nriemer/subversion/partmc/trunk/local_scenarios/aging_comp/run_100K_60min/out" time_filename_list = partmc.get_time_filename_list(netcdf_dir, netcdf_pattern) data_array = np.zeros([len(time_filename_list), 18]) count_array = np.zeros([len(time_filename_list), 18], dtype=int) fresh_bc_ids_prev = set() aged_bc_ids_prev = set() all_bc_ids_prev = set() all_ids_prev = set() small_ids_prev = set() comp_vol_prev = 0 for (i_counter, [time, filename, key]) in enumerate(time_filename_list): print time, filename, key ncf = scipy.io.netcdf.netcdf_file(filename, 'r') particles = partmc.aero_particle_array_t(ncf) removed_info = partmc.aero_removed_info_t(ncf) env_state = partmc.env_state_t(ncf) ncf.close() dry_diameters = particles.dry_diameters() s_crit = (particles.critical_rel_humids(env_state) - 1) * 100 comp_vol = particles.comp_vols[0] bc = particles.masses(include=["BC"]) is_bc = (bc > 0) total_number_bc = sum(1 / particles.comp_vols[is_bc]) is_fresh_bc = ((bc > 0) & (s_crit > aging_ss)) is_aged_bc = ((bc > 0) & (s_crit <= aging_ss)) is_small = (dry_diameters < 5e-8) number_fresh_bc = sum(1 / particles.comp_vols[is_fresh_bc]) number_aged_bc = sum(1 / particles.comp_vols[is_aged_bc]) fresh_bc_ids = set(particles.ids[is_fresh_bc]) aged_bc_ids = set(particles.ids[is_aged_bc]) all_bc_ids = set(particles.ids[is_bc]) all_ids = set(particles.ids) small_ids = set(particles.ids[is_small]) # calculate things here n_f_emit_ids = fresh_bc_ids - all_ids_prev # get the emitted that are fresh n_a_emit_ids = aged_bc_ids - all_ids_prev # get the emitted that are aged n_f_dilute_ids = set() n_f_f_cond_ids = set() n_f_a_cond_ids = set() n_f_f_coag_ids = set() n_f_a_coag_ids = set() n_f_coag_ids = set() n_a_dilute_ids = set() n_a_f_cond_ids = set() n_a_a_cond_ids = set() n_a_f_coag_ids = set() n_a_a_coag_ids = set() n_a_coag_ids = set() other_ids_set = set(removed_info.other_ids) for id_prev in all_bc_ids_prev: # where did everybody go? coag_happened = False id_current = id_prev while id_current in removed_info.ids: i = np.nonzero(removed_info.ids == id_current)[0][0] action = removed_info.actions[i] other_id = removed_info.other_ids[i] if action == removed_info.AERO_INFO_DILUTION: id_current = 0 if action == removed_info.AERO_INFO_HALVED: id_current = 0 if action == removed_info.AERO_INFO_COAG: id_current = other_id coag_happened = True if id_current in other_ids_set: coag_happened = True if id_current == 0: if id_prev in fresh_bc_ids_prev: n_f_dilute_ids.add(id_prev) if id_prev in aged_bc_ids_prev: n_a_dilute_ids.add(id_prev) else: if id_prev in fresh_bc_ids_prev: if id_current in fresh_bc_ids: if coag_happened: n_f_f_coag_ids.add(id_prev) else: n_f_f_cond_ids.add(id_prev) elif id_current in aged_bc_ids: if coag_happened: n_f_a_coag_ids.add(id_prev) else: n_f_a_cond_ids.add(id_prev) else: raise Exception("Current not fresh or aged") if id_prev in aged_bc_ids_prev: if id_current in fresh_bc_ids: if coag_happened: n_a_f_coag_ids.add(id_prev) else: n_a_f_cond_ids.add(id_prev) elif id_current in aged_bc_ids: if coag_happened: n_a_a_coag_ids.add(id_prev) else: n_a_a_cond_ids.add(id_prev) else: raise Exception("Current not fresh or aged") for id_current in all_bc_ids: if id_current in all_ids_prev: # check if it wasn't emitted if id_current in other_ids_set: if id_current in fresh_bc_ids: n_f_coag_ids.add(id_current) if id_current in aged_bc_ids: n_a_coag_ids.add(id_current) n_f_emit = len(n_f_emit_ids) n_f_dilute = len(n_f_dilute_ids) n_f_f_cond = len(n_f_f_cond_ids) n_f_a_cond = len(n_f_a_cond_ids) n_f_f_coag = len(n_f_f_coag_ids) n_f_a_coag = len(n_f_a_coag_ids) n_f_coag = len(n_f_coag_ids) n_f_a_cond_small = len(n_f_a_cond_ids & small_ids_prev) n_f_a_coag_small = len(n_f_a_coag_ids & small_ids_prev) n_a_emit = len(n_a_emit_ids) n_a_dilute = len(n_a_dilute_ids) n_a_f_cond = len(n_a_f_cond_ids) n_a_a_cond = len(n_a_a_cond_ids) n_a_f_coag = len(n_a_f_coag_ids) n_a_a_coag = len(n_a_a_coag_ids) n_a_coag = len(n_a_coag_ids) n_f = len(fresh_bc_ids) n_a = len(aged_bc_ids) n_f_prev = len(fresh_bc_ids_prev) n_a_prev = len(aged_bc_ids_prev) n_f_small = len(fresh_bc_ids & small_ids) n_aging = n_f_a_cond + n_f_a_coag n_aging_small = n_f_a_cond_small + n_f_a_coag_small data_array[i_counter, 0] = time data_array[i_counter, 1] = total_number_bc data_array[i_counter, 2] = number_fresh_bc data_array[i_counter, 3] = number_aged_bc data_array[i_counter, 4] = n_f_emit / comp_vol data_array[i_counter, 5] = n_a_emit / comp_vol if (comp_vol_prev != 0): data_array[i_counter, 6] = n_f_dilute / comp_vol_prev data_array[i_counter, 7] = n_f_f_cond / comp_vol data_array[i_counter, 8] = n_f_a_cond / comp_vol data_array[i_counter, 9] = n_f_f_coag / comp_vol data_array[i_counter, 10] = n_f_a_coag / comp_vol data_array[i_counter, 11] = n_f_coag / comp_vol if (comp_vol_prev != 0): data_array[i_counter, 12] = n_a_dilute / comp_vol_prev data_array[i_counter, 13] = n_a_f_cond / comp_vol data_array[i_counter, 14] = n_a_a_cond / comp_vol data_array[i_counter, 15] = n_a_f_coag / comp_vol data_array[i_counter, 16] = n_a_a_coag / comp_vol data_array[i_counter, 17] = n_a_coag / comp_vol count_array[i_counter, 0] = time count_array[i_counter, 1] = len(all_bc_ids) count_array[i_counter, 2] = n_f #len(fresh_bc_ids) count_array[i_counter, 3] = n_a #len(aged_bc_ids) count_array[i_counter, 4] = n_f_emit #len(n_f_emit_ids) count_array[i_counter, 5] = n_a_emit #len(n_a_emit_ids) count_array[i_counter, 6] = n_f_dilute #len(n_f_dilute_ids) count_array[i_counter, 7] = n_f_f_cond #len(n_f_f_cond_ids) count_array[i_counter, 8] = n_f_a_cond #len(n_f_a_cond_ids) count_array[i_counter, 9] = n_f_f_coag #len(n_f_f_coag_ids) count_array[i_counter, 10] = n_f_a_coag #len(n_f_a_coag_ids) count_array[i_counter, 11] = n_f_coag #len(n_f_coag_ids) count_array[i_counter, 12] = n_a_dilute #len(n_a_dilute_ids) count_array[i_counter, 13] = n_a_f_cond #len(n_a_f_cond_ids) count_array[i_counter, 14] = n_a_a_cond #len(n_a_a_cond_ids) count_array[i_counter, 15] = n_a_f_coag #len(n_a_f_coag_ids) count_array[i_counter, 16] = n_a_a_coag #len(n_a_a_coag_ids) count_array[i_counter, 17] = n_a_coag #len(n_a_coag_ids) # The following is checking code # lhs_f = n_f - n_f_prev rhs_f = n_f_emit - n_f_dilute + n_a_f_cond + n_f_coag - n_f_f_coag - n_f_a_cond - n_f_a_coag lhs_a = n_a - n_a_prev rhs_a = n_a_emit - n_a_dilute + n_f_a_cond + n_a_coag - n_a_a_coag - n_a_f_cond - n_a_f_coag loss_f = n_f_dilute + n_f_f_coag + n_f_a_coag + n_f_f_cond + n_f_a_cond loss_f_ids = n_f_dilute_ids | n_f_f_coag_ids | n_f_a_coag_ids | n_f_f_cond_ids | n_f_a_cond_ids gain_f = n_f_emit + n_f_coag + n_f_f_cond + n_a_f_cond gain_f_ids = n_f_emit_ids | n_f_coag_ids | n_f_f_cond_ids | n_a_f_cond_ids loss_a = n_a_dilute + n_a_f_coag + n_a_a_coag + n_a_f_cond + n_a_a_cond loss_a_ids = n_a_dilute_ids | n_a_f_coag_ids | n_a_a_coag_ids | n_a_f_cond_ids | n_a_a_cond_ids gain_a = n_a_emit + n_a_coag + n_f_a_cond + n_a_a_cond gain_a_ids = n_a_emit_ids | n_a_coag_ids | n_f_a_cond_ids | n_a_a_cond_ids coag_loss_f = n_f_f_coag + n_a_f_coag coag_loss_f_ids = n_f_f_coag_ids | n_a_f_coag_ids coag_loss_a = n_a_a_coag + n_f_a_coag coag_loss_a_ids = n_a_a_coag_ids | n_f_a_coag_ids print "budget f %8d %8d %8d" % (lhs_f, rhs_f, lhs_f - rhs_f) if (lhs_f - rhs_f) != 0: set_error() print "budget a %8d %8d %8d" % (lhs_a, rhs_a, lhs_a - rhs_a) if (lhs_a - rhs_a) != 0: set_error() print "loss f %8d %8d %8d" % (loss_f, n_f_prev, loss_f - n_f_prev) if (loss_f - n_f_prev) != 0: set_error() print "gain f %8d %8d %8d" % (gain_f, n_f, gain_f - n_f) if (gain_f - n_f) != 0: set_error() print "loss a %8d %8d %8d" % (loss_a, n_a_prev, loss_a - n_a_prev) if (loss_a - n_a_prev) != 0: set_error() print "gain a %8d %8d %8d" % (gain_a, n_a, gain_a - n_a) if (gain_a - n_a) != 0: set_error() # We don't check equation (12) in Riemer et al., 2010, Aerosol Sci. because it can # happen that we emit a BC particle and it coagulates before we detect it. print "loss f ids ", loss_f_ids - fresh_bc_ids_prev, fresh_bc_ids_prev - loss_f_ids if (len(loss_f_ids - fresh_bc_ids_prev)) != 0: set_error() if (len(fresh_bc_ids_prev - loss_f_ids)) != 0: set_error() print "gain f ids ", gain_f_ids - fresh_bc_ids, fresh_bc_ids - gain_f_ids if (len(gain_f_ids - fresh_bc_ids)) != 0: set_error() if (len(fresh_bc_ids - gain_f_ids)) != 0: set_error() print "loss a ids ", loss_a_ids - aged_bc_ids_prev, aged_bc_ids_prev - loss_a_ids if (len(loss_a_ids - aged_bc_ids_prev)) != 0: set_error() if (len(aged_bc_ids_prev - loss_a_ids)) != 0: set_error() print "gain a ids ", gain_a_ids - aged_bc_ids, aged_bc_ids - gain_a_ids if (len(gain_a_ids - aged_bc_ids)) != 0: set_error() if (len(aged_bc_ids - gain_a_ids)) != 0: set_error() print "gain f intersection ", n_f_emit_ids & n_f_coag_ids, n_f_emit_ids & n_f_f_cond_ids, \ n_f_emit_ids & n_a_f_cond_ids, n_f_coag_ids & n_f_f_cond_ids, \ n_f_coag_ids & n_a_f_cond_ids, n_f_f_cond_ids & n_a_f_cond_ids if (len(n_f_emit_ids & n_f_coag_ids) !=0 or len(n_f_emit_ids & n_f_f_cond_ids) !=0 or \ len(n_f_emit_ids & n_a_f_cond_ids) !=0 or len(n_f_coag_ids & n_f_f_cond_ids) !=0 or \ len(n_f_coag_ids & n_a_f_cond_ids) !=0 or len( n_f_f_cond_ids & n_a_f_cond_ids)): set_error() print "gain a intersection ", n_a_emit_ids & n_a_coag_ids, n_a_emit_ids & n_f_a_cond_ids, \ n_a_emit_ids & n_a_a_cond_ids, n_a_coag_ids & n_f_a_cond_ids, n_a_coag_ids & n_a_a_cond_ids, \ n_f_a_cond_ids & n_a_a_cond_ids if (len(n_a_emit_ids & n_a_coag_ids) !=0 or len(n_a_emit_ids & n_f_a_cond_ids) !=0 or \ len(n_a_emit_ids & n_a_a_cond_ids) !=0 or len(n_a_coag_ids & n_f_a_cond_ids) !=0 or len(n_a_coag_ids & n_a_a_cond_ids) !=0 or \ len(n_f_a_cond_ids & n_a_a_cond_ids)!=0): set_error() print "loss f intersection ", n_f_dilute_ids & n_f_f_coag_ids, n_f_dilute_ids & n_f_a_coag_ids, \ n_f_dilute_ids & n_f_f_cond_ids, n_f_dilute_ids & n_f_a_cond_ids, \ n_f_f_coag_ids & n_f_a_coag_ids, n_f_f_coag_ids & n_f_f_cond_ids, n_f_f_coag_ids & n_f_a_cond_ids, \ n_f_a_coag_ids & n_f_f_cond_ids, n_f_a_coag_ids & n_f_a_cond_ids, \ n_f_f_cond_ids & n_f_a_cond_ids if (len(n_f_dilute_ids & n_f_f_coag_ids) !=0 or len(n_f_dilute_ids & n_f_a_coag_ids) !=0 or \ len(n_f_dilute_ids & n_f_f_cond_ids) !=0 or len(n_f_dilute_ids & n_f_a_cond_ids) !=0 or \ len(n_f_f_coag_ids & n_f_a_coag_ids) !=0 or len(n_f_f_coag_ids & n_f_f_cond_ids) !=0 or len(n_f_f_coag_ids & n_f_a_cond_ids) !=0 or \ len(n_f_a_coag_ids & n_f_f_cond_ids) !=0 or len(n_f_a_coag_ids & n_f_a_cond_ids) !=0 or \ len(n_f_f_cond_ids & n_f_a_cond_ids) !=0): set_error() print "loss a intersection ", n_a_dilute_ids & n_a_f_coag_ids, n_a_dilute_ids & n_a_a_coag_ids, \ n_a_dilute_ids & n_a_f_cond_ids, n_a_dilute_ids & n_a_a_cond_ids, \ n_a_f_coag_ids & n_a_a_coag_ids, n_a_f_coag_ids & n_a_f_cond_ids, n_a_f_coag_ids & n_a_a_cond_ids, \ n_a_a_coag_ids & n_a_f_cond_ids, n_a_a_coag_ids & n_a_a_cond_ids, \ n_a_f_cond_ids & n_a_a_cond_ids if (len(n_a_dilute_ids & n_a_f_coag_ids) !=0 or len(n_a_dilute_ids & n_a_a_coag_ids) !=0 or \ len(n_a_dilute_ids & n_a_f_cond_ids) !=0 or len(n_a_dilute_ids & n_a_a_cond_ids) !=0 or \ len(n_a_f_coag_ids & n_a_a_coag_ids) !=0 or len(n_a_f_coag_ids & n_a_f_cond_ids) !=0 or len(n_a_f_coag_ids & n_a_a_cond_ids) !=0 or \ len(n_a_a_coag_ids & n_a_f_cond_ids) !=0 or len(n_a_a_coag_ids & n_a_a_cond_ids) !=0 or \ len(n_a_f_cond_ids & n_a_a_cond_ids) !=0): set_error() print "gain f/ gain a intersection ", gain_f_ids & gain_a_ids if (len(gain_f_ids & gain_a_ids) != 0): set_error() print "loss f/ loss a intersection ", loss_f_ids & loss_a_ids if (len(loss_f_ids & loss_a_ids) != 0): set_error() fresh_bc_ids_prev = fresh_bc_ids aged_bc_ids_prev = aged_bc_ids all_bc_ids_prev = all_bc_ids all_ids_prev = all_ids small_ids_prev = small_ids comp_vol_prev = comp_vol # Checking code ends # np.savetxt(output_file_data, data_array) np.savetxt(output_file_count, count_array, fmt='%d')