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 make_plot(in_filename,out_filename,title):
print in_filename
ncf = scipy.io.netcdf.netcdf_file(in_filename, 'r')
particles = partmc.aero_particle_array_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
x_axis = partmc.log_grid(min=1e-8,max=1e-6,n_bin=70)
y_axis = partmc.log_grid(min=1e-3,max=1e2,n_bin=50)
hist2d = partmc.histogram_2d(dry_diameters, s_crit, x_axis, y_axis, weights = 1/particles.comp_vols)
plt.clf()
plt.pcolor(x_axis.edges(), y_axis.edges(), hist2d.transpose(),norm = matplotlib.colors.LogNorm(), linewidths = 0.1)
a = plt.gca()
a.set_xscale("log")
a.set_yscale("log")
plt.axis([x_axis.min, x_axis.max, y_axis.min, y_axis.max])
plt.xlabel("dry diameter (m)")
plt.ylabel("critical supersaturation (%)")
cbar = plt.colorbar()
cbar.set_label("number density (m^{-3})")
plt.title(title)
fig = plt.gcf()
fig.savefig(out_filename)
def process_data(in_filename_list, out_filename):
total_value = None
for in_filename in in_filename_list:
ncf = scipy.io.netcdf.netcdf_file(in_filename, 'r')
particles = partmc.aero_particle_array_t(ncf)
env_state = partmc.env_state_t(ncf)
ncf.close()
dry_diameters = particles.dry_diameters() * 1e6 # m to um
scrit = (particles.critical_rel_humids(env_state) - 1) * 100 # in %
value = partmc.histogram_2d(dry_diameters, scrit, x_axis, y_axis,
weights = 1 / particles.comp_vols,
only_positive=False)
# do not account for y_axis in % as it is a log-scale
value /= 1e6 # m^{-3} to cm^{-3}
if total_value is None:
total_value = value
else:
total_value += value
total_value /= len(in_filename_list)
np.savetxt(out_filename, total_value)
mask = np.ma.make_mask(total_value <= 0.0)
masked_total_value = np.ma.array(total_value, mask=mask)
return(masked_total_value.min(), masked_total_value.max())
def process_data(in_filename_list, out_filename):
total_value = None
for in_filename in in_filename_list:
ncf = scipy.io.netcdf.netcdf_file(in_filename, 'r')
particles = partmc.aero_particle_array_t(ncf)
env_state = partmc.env_state_t(ncf)
ncf.close()
dry_diameters = particles.dry_diameters() * 1e6 # m to um
comp_frac = particles.masses(include = ["BC"]) \
/ particles.masses(exclude = ["H2O"]) * 100 # in %
# hack to avoid landing just around the integer boundaries
comp_frac *= (1.0 + 1e-12)
value = partmc.histogram_2d(dry_diameters,
comp_frac,
x_axis,
y_axis,
weights=1 / particles.comp_vols,
only_positive=False)
value *= 100 # account for y_axis scaling in %
value /= 1e6 # m^{-3} to cm^{-3}
if total_value is None:
total_value = value
else:
total_value += value
total_value /= len(in_filename_list)
np.savetxt(out_filename, total_value)
mask = np.ma.make_mask(total_value <= 0.0)
masked_total_value = np.ma.array(total_value, mask=mask)
return (masked_total_value.min(), masked_total_value.max())
def process_data(in_filename_list, out_filename):
total_value = None
for in_filename in in_filename_list:
ncf = scipy.io.netcdf.netcdf_file(in_filename, 'r')
particles = partmc.aero_particle_array_t(ncf)
env_state = partmc.env_state_t(ncf)
ncf.close()
dry_diameters = particles.dry_diameters() * 1e6 # m to um
masses = particles.masses() * 1e9 # kg to ug
value = partmc.histogram_1d(dry_diameters,
x_axis,
weights=masses / particles.comp_vols)
value /= 1e6 # m^{-3} to cm^{-3}
if total_value is None:
total_value = value
else:
total_value += value
total_value /= len(in_filename_list)
np.savetxt(out_filename, total_value)
mask = np.ma.make_mask(total_value <= 0.0)
masked_total_value = np.ma.array(total_value, mask=mask)
return (masked_total_value.min(), masked_total_value.max())
def make_plot(in_filename, out_filename, time, title):
ncf = scipy.io.netcdf.netcdf_file(in_filename, 'r')
particles = partmc.aero_particle_array_t(ncf)
env_state = partmc.env_state_t(ncf)
ncf.close()
age = abs(particles.least_create_times / 3600. - time)
dry_diameters = particles.dry_diameters()
s_crit = (particles.critical_rel_humids(env_state) - 1) * 100
x_axis = partmc.log_grid(min=1e-8, max=1e-6, n_bin=140)
y_axis = partmc.linear_grid(min=0, max=48, n_bin=96)
vals2d = partmc.multival_2d(dry_diameters, age, s_crit, x_axis, y_axis)
plt.clf()
plt.pcolor(x_axis.edges(),
y_axis.edges(),
vals2d.transpose(),
norm=matplotlib.colors.LogNorm(),
linewidths=0.1)
a = plt.gca()
a.set_xscale("log")
a.set_yscale("linear")
plt.axis([x_axis.min, x_axis.max, y_axis.min, y_axis.max])
plt.xlabel("dry diameter (m)")
plt.ylabel("age (h)")
cbar = plt.colorbar()
cbar.set_label("S_crit (%)")
plt.title(title)
fig = plt.gcf()
fig.savefig(out_filename)
def get_plot_data_bc(filename, value_min=None, value_max=None):
ncf = scipy.io.netcdf.netcdf_file(filename, 'r')
particles = partmc.aero_particle_array_t(ncf)
env_state = partmc.env_state_t(ncf)
ncf.close()
diameters = particles.dry_diameters() * 1e6
comp_frac = particles.masses(include = ["BC"]) \
/ particles.masses(exclude = ["H2O"]) * 100
# hack to avoid landing just around the integer boundaries
comp_frac *= (1.0 + 1e-12)
h2o = particles.masses(include=["H2O"])
x_axis = partmc.log_grid(min=diameter_axis_min,
max=diameter_axis_max,
n_bin=num_diameter_bins * 2)
y_axis = partmc.linear_grid(min=bc_axis_min,
max=bc_axis_max,
n_bin=num_bc_bins * 2)
value = partmc.multival_2d(diameters, comp_frac, h2o, x_axis, y_axis)
if value_max == None:
value_max = value.max()
if value_min == None:
maxed_value = np.where(value > 0.0, value, value_max)
value_min = maxed_value.min()
#if value_max > 0.0:
# value = (log(value) - log(value_min)) \
# / (log(value_max) - log(value_min))
#value = value.clip(0.0, 1.0)
return (value, x_axis.edges(), y_axis.edges(), env_state, value_min,
value_max)
def make_plot(in_filename,out_filename):
ncf = scipy.io.netcdf.netcdf_file(in_filename, 'r')
particles = partmc.aero_particle_array_t(ncf)
env_state = partmc.env_state_t(ncf)
ncf.close()
bc = particles.masses(include = ["BC"])
dry_mass = particles.masses(exclude = ["H2O"])
bc_frac = bc / dry_mass
so4 = particles.masses(include = ["SO4"])
inorg = particles.masses(include = ["SO4", "NO3", "NH4"])
inorg_frac = inorg / dry_mass
kappas = particles.kappas()
wet_diameters = particles.diameters()
dry_diameters = particles.dry_diameters() * 1e6
x_axis = partmc.log_grid(min=1e-2,max=1e0,n_bin=90)
y_axis = partmc.linear_grid(min=0,max=0.8,n_bin=40)
vals = partmc.multival_2d(dry_diameters, bc_frac, kappas, x_axis, y_axis, rand_arrange=False)
vals_pos = np.ma.masked_less_equal(vals, 0)
vals_zero = np.ma.masked_not_equal(vals, 0)
plt.clf()
if vals_zero.count() > 0:
plt.pcolor(x_axis.edges(), y_axis.edges(), vals_zero.transpose(), cmap=matplotlib.cm.gray, linewidths = 0.1)
if vals_pos.count() > 0:
plt.pcolor(x_axis.edges(), y_axis.edges(), vals_pos.transpose(), linewidths = 0.1)
title = partmc.time_of_day_string(env_state)
a = plt.gca()
a.set_xscale("log")
a.set_yscale("linear")
plt.axis([x_axis.min, x_axis.max, y_axis.min, y_axis.max])
plt.xlabel("dry diameter (\mu m)")
plt.ylabel("BC dry mass fraction")
cbar = plt.colorbar()
plt.clim(0, 0.6)
cbar.set_label("kappa")
plt.title(title)
fig = plt.gcf()
fig.savefig(out_filename)
def get_plot_data_bc(filename, value_min=None, value_max=None):
ncf = scipy.io.netcdf.netcdf_file(filename, 'r')
particles = partmc.aero_particle_array_t(ncf)
env_state = partmc.env_state_t(ncf)
ncf.close()
diameters = particles.dry_diameters() * 1e6
x_axis = partmc.log_grid(min=diameter_axis_min,
max=diameter_axis_max,
n_bin=num_diameter_bins)
value = partmc.histogram_1d(diameters,
x_axis,
weights=1 / particles.comp_vols)
value /= 1e6
return (value, x_axis.centers())
def process_data(in_filename_list):
total_value = None
for in_filename in in_filename_list:
ncf = scipy.io.netcdf.netcdf_file(in_filename, 'r')
gas_state = partmc.gas_state_t(ncf)
env_state = partmc.env_state_t(ncf)
ncf.close()
time_since_midnight = env_state.start_time_of_day \
+ env_state.elapsed_time
value = gas_state.raw_mixing_ratios
if total_value is None:
total_value = np.array(value)
else:
total_value += value
total_value /= len(in_filename_list)
return np.concatenate((np.array([time_since_midnight]), total_value))
def make_plot(dir_name,in_filename,out_filename):
ncf = scipy.io.netcdf.netcdf_file(dir_name+in_filename, 'r')
particles = partmc.aero_particle_array_t(ncf)
env_state = partmc.env_state_t(ncf)
ncf.close()
dry_diameters = particles.dry_diameters() * 1e6
s_crit = (particles.critical_rel_humids(env_state) - 1)*100
x_axis = partmc.log_grid(min=1e-3,max=1e1,n_bin=100)
y_axis = partmc.log_grid(min=1e-3,max=1e2,n_bin=50)
hist2d = partmc.histogram_2d(dry_diameters, s_crit, x_axis, y_axis, weights = particles.num_concs)
hist2d = hist2d * 1e-6
(figure, axes_array, cbar_axes_array) = mpl_helper.make_fig_array(1,1, figure_width=5,
top_margin=0.5, bottom_margin=0.45,
left_margin=0.65, right_margin=1,
vert_sep=0.3, horiz_sep=0.3,
colorbar="shared", colorbar_location="right")
axes = axes_array[0][0]
cbar_axes = cbar_axes_array[0]
p = axes.pcolor(x_axis.edges(), y_axis.edges(), hist2d.transpose(),
norm = matplotlib.colors.LogNorm(vmin=1e3, vmax=1e5), linewidths = 0.1)
axes.set_xscale("log")
axes.set_yscale("log")
axes.set_ylabel(r"crit. supersat. $S_{\rm c}$")
axes.set_xlabel(r"dry diameter $D$/ $\rm \mu m$")
axes.set_ylim(1e-3,10)
axes.set_xlim(5e-3, 1e0)
axes.grid(True)
cbar = figure.colorbar(p, cax=cbar_axes, format=matplotlib.ticker.LogFormatterMathtext(),
orientation='vertical')
cbar_axes.xaxis.set_label_position('top')
cbar.set_label(r"number conc. $n(D,S_{\rm c})$ / $\rm cm^{-3}$")
mpl_helper.remove_fig_array_axes(axes_array)
figure.savefig(out_filename)
plt.close()
def process_data(in_filename_list):
total_value = None
for in_filename in in_filename_list:
ncf = scipy.io.netcdf.netcdf_file(in_filename, 'r')
particles = partmc.aero_particle_array_t(ncf)
env_state = partmc.env_state_t(ncf)
ncf.close()
time_since_midnight = env_state.start_time_of_day \
+ env_state.elapsed_time
value = (particles.raw_masses / particles.comp_vols).sum(1)
value *= 1e3 # kg m^{-3} to mg cm^{-3}
if total_value is None:
total_value = value
else:
total_value += value
total_value /= len(in_filename_list)
return np.concatenate((np.array([time_since_midnight]), total_value))
def process_data(in_filename_list):
total_value = None
for in_filename in in_filename_list:
ncf = scipy.io.netcdf.netcdf_file(in_filename, 'r')
particles = partmc.aero_particle_array_t(ncf)
env_state = partmc.env_state_t(ncf)
ncf.close()
time_since_midnight = env_state.start_time_of_day \
+ env_state.elapsed_time
value = (1 / particles.comp_vols).sum()
value /= 1e6 # m^{-3} to cm^{-3}
if total_value is None:
total_value = value
else:
total_value += value
total_value /= len(in_filename_list)
return [time_since_midnight, total_value]
def process_data(in_filename_list):
total_value = None
for in_filename in in_filename_list:
ncf = scipy.io.netcdf.netcdf_file(in_filename, 'r')
env_state = partmc.env_state_t(ncf)
ncf.close()
time_since_midnight = env_state.start_time_of_day \
+ env_state.elapsed_time
value = np.array([env_state.temperature,
env_state.relative_humidity,
env_state.pressure,
env_state.height,
])
if total_value is None:
total_value = np.array(value)
else:
total_value += value
total_value /= len(in_filename_list)
return np.concatenate((np.array([time_since_midnight]), total_value))
def get_plot_data(filename, value_min=None, value_max=None):
ncf = scipy.io.netcdf.netcdf_file(filename, 'r')
particles = partmc.aero_particle_array_t(ncf)
env_state = partmc.env_state_t(ncf)
ncf.close()
diameters = particles.dry_diameters() * 1e6
comp_frac = particles.masses(include = ["BC"]) \
/ particles.masses(exclude = ["H2O"]) * 100
# hack to avoid landing just around the integer boundaries
comp_frac *= (1.0 + 1e-12)
h2o = particles.masses(include=["H2O"]) * 1e18 # kg to fg
x_axis = partmc.log_grid(min=diameter_axis_min,
max=diameter_axis_max,
n_bin=num_diameter_bins * 2)
y_axis = partmc.linear_grid(min=bc_axis_min,
max=bc_axis_max,
n_bin=num_bc_bins * 2)
value = partmc.multival_2d(diameters, comp_frac, h2o, x_axis, y_axis)
return (value, x_axis.edges(), y_axis.edges(), env_state)
def make_plot(dir_name, hour, out_filename1):
x_axis = partmc.log_grid(min=1e-9, max=1e-5, n_bin=70)
y_axis = partmc.log_grid(min=1e-3, max=1e2, n_bin=50)
x_centers = x_axis.centers()
y_centers = y_axis.centers()
hist_array = np.zeros([
len(x_centers),
len(y_centers), config.i_weighting_schemes, config.i_loop_max
])
hist_average = np.zeros(
[len(x_centers),
len(y_centers), config.i_weighting_schemes])
hist_var = np.zeros(
[len(x_centers),
len(y_centers), config.i_weighting_schemes])
weighting_factor = np.zeros(
[len(x_centers),
len(y_centers), config.i_weighting_schemes])
for (counter_weighting, counter) in enumerate([
"10K_wei+1", "10K_flat", "10K_wei-1", "10K_wei-2", "10K_wei-3",
"10K_wei-4"
]):
print "I'm doing ", counter
files = []
for i_loop in range(0, config.i_loop_max):
filename_in = "urban_plume_wc_%s_0%03d_000000%02d.nc" % (
counter, i_loop + 1, hour)
files.append(filename_in)
for (counter_i_loop, file) in enumerate(files):
print "file ", file
ncf = Scientific.IO.NetCDF.NetCDFFile(dir_name + file)
particles = partmc.aero_particle_array_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
hist2d = partmc.histogram_2d(dry_diameters,
s_crit,
x_axis,
y_axis,
weights=1 / particles.comp_vols)
hist_array[:, :, counter_weighting, counter_i_loop] = hist2d
hist_array = np.ma.masked_less_equal(hist_array, 0)
hist_average = np.average(hist_array, axis=3)
hist_var = np.var(hist_array, axis=3)
print "Calculated average and variance", counter
weighting_factor = 1 / hist_var
weighting_factor_sum = np.sum(weighting_factor, axis=2)
hist_composite = np.zeros([len(x_centers), len(y_centers)])
for i in range(0, config.i_weighting_schemes):
increment = weighting_factor[:, :,
i] / weighting_factor_sum * hist_average[:, :,
i]
increment = increment.filled(0)
hist_composite += increment
hist_composite = np.ma.masked_less_equal(hist_composite, 0)
plt.clf()
plt.pcolor(x_axis.edges(),
y_axis.edges(),
hist_composite.transpose(),
norm=matplotlib.colors.LogNorm(),
linewidths=0.1)
a = plt.gca()
a.set_xscale("log")
a.set_yscale("log")
plt.grid()
plt.axis([x_axis.min, x_axis.max, y_axis.min, y_axis.max])
plt.xlabel("dry diameter (m)")
plt.ylabel("S_crit in %")
cbar = plt.colorbar()
cbar.set_label("number density (m^{-3})")
fig = plt.gcf()
fig.savefig(out_filename1)
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()
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')
def make_plot(in_filename, out_filename):
ncf = scipy.io.netcdf.netcdf_file(in_filename, 'r')
particles = partmc.aero_particle_array_t(ncf)
env_state = partmc.env_state_t(ncf)
ncf.close()
bc = particles.masses(include=["BC"])
dry_mass = particles.masses(exclude=["H2O"])
bc_frac = bc / dry_mass
wet_diameters = particles.diameters()
dry_diameters = particles.dry_diameters() * 1e6
x_axis = partmc.log_grid(min=1e-2, max=1e0, n_bin=90)
y_axis = partmc.linear_grid(min=0, max=0.8, n_bin=40)
(figure, axes, cbar_axes) = config_matplotlib.make_fig(colorbar=True,
right_margin=1,
top_margin=0.3)
axes.grid(True)
axes.grid(True, which='minor')
axes.minorticks_on()
axes.set_xscale('log')
axes.set_xbound(x_axis.min, x_axis.max)
axes.set_ybound(y_axis.min, y_axis.max)
xaxis = axes.get_xaxis()
yaxis = axes.get_yaxis()
xaxis.labelpad = 8
yaxis.labelpad = 8
#xaxis.set_major_formatter(matplotlib.ticker.LogFormatter())
#yaxis.set_major_locator(matplotlib.ticker.MaxNLocator(5))
#yaxis.set_minor_locator(matplotlib.ticker.MaxNLocator(8))
axes.set_xlabel(r"dry diameter $D\ (\rm\mu m)$")
axes.set_ylabel(r"BC dry mass frac. $w_{{\rm BC},{\rm dry}}$")
hist2d = partmc.histogram_2d(dry_diameters,
bc_frac,
x_axis,
y_axis,
weights=1 / particles.comp_vols)
# plt.clf()
axes.set_xbound(x_axis.min, x_axis.max)
axes.set_ybound(y_axis.min, y_axis.max)
p = axes.pcolor(x_axis.edges(),
y_axis.edges(),
hist2d.transpose(),
norm=matplotlib.colors.LogNorm(vmin=1e8, vmax=1e11),
linewidths=0.1)
title = partmc.time_of_day_string(env_state)
axes.set_xbound(x_axis.min, x_axis.max)
axes.set_ybound(y_axis.min, y_axis.max)
axes.set_title(title)
figure.colorbar(p,
cax=cbar_axes,
format=matplotlib.ticker.LogFormatterMathtext())
cbar_axes.set_ylabel(r"number conc. $(\rm m^{-3})$")
#cbar_axes.set_ylim([1e8, 1e11])
#plt.title(title)
axes.set_xbound(x_axis.min, x_axis.max)
axes.set_ybound(y_axis.min, y_axis.max)
fig = plt.gcf()
fig.savefig(out_filename)
i_ens_max = config.i_ens_max
netcdf_dir = "/home/nriemer/subversion/partmc/branches/nriemer/local_scenarios/brownian_test_paper2/out/"
array_num_init = np.zeros([i_loop_max*i_ens_max])
array_mass_init = np.zeros([i_loop_max*i_ens_max])
array_num_end = np.zeros([i_loop_max*i_ens_max])
array_mass_end = np.zeros([i_loop_max*i_ens_max])
for i_loop in range (0, i_ens_max*i_loop_max):
filename = "brownian_part_%05d_00000001.nc" % (i_loop+1)
print filename
ncf = scipy.io.netcdf.netcdf_file(netcdf_dir+filename, 'r')
particles = partmc.aero_particle_array_t(ncf)
env_state = partmc.env_state_t(ncf)
ncf.close()
total_number = sum(1/particles.comp_vols)
total_dry_mass = sum(particles.masses()/particles.comp_vols)
array_num_init[i_loop] = total_number
array_mass_init[i_loop]= total_dry_mass
filename = "brownian_part_%05d_00000002.nc" % (i_loop+1)
print filename
ncf = scipy.io.netcdf.netcdf_file(netcdf_dir+filename, 'r')
particles = partmc.aero_particle_array_t(ncf)
env_state = partmc.env_state_t(ncf)
ncf.close()
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(dir_name, in_files, out_filename1, out_filename2):
x_axis = partmc.log_grid(min=1e-9, max=1e-5, n_bin=70)
y_axis = partmc.log_grid(min=1e-3, max=1e2, n_bin=50)
x_centers = x_axis.centers()
y_centers = y_axis.centers()
counter = 0
hist_array = np.zeros([len(x_centers), len(y_centers), config.i_loop_max])
hist_average = np.zeros([len(x_centers), len(y_centers)])
hist_std = np.zeros([len(x_centers), len(y_centers)])
hist_std_norm = np.zeros([len(x_centers), len(y_centers)])
for file in in_files:
ncf = Scientific.IO.NetCDF.NetCDFFile(dir_name + file)
particles = partmc.aero_particle_array_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
hist2d = partmc.histogram_2d(dry_diameters,
s_crit,
x_axis,
y_axis,
weights=1 / particles.comp_vols)
hist_array[:, :, counter] = hist2d
counter = counter + 1
hist_average = np.average(hist_array, axis=2)
hist_std = np.std(hist_array, axis=2)
hist_std_norm = hist_std / hist_average
hist_std_norm = np.ma.masked_invalid(hist_std_norm)
print "min, max", hist_average.min(), hist_average.max()
# dry_diameters_line = np.array([1e-9, 1e-5])
# kappa_line1 = np.array([0.01, 0.01])
# crit_ss_line1 = (partmc.critical_rel_humids(env_state,kappa_line1, dry_diameters_line)-1)*100.
# kappa_line2 = np.array([0.1, 0.1])
# crit_ss_line2 = (partmc.critical_rel_humids(env_state,kappa_line2, dry_diameters_line)-1)*100.
# kappa_line3 = np.array([2,2])
# crit_ss_line3 = (partmc.critical_rel_humids(env_state,kappa_line3, dry_diameters_line)-1)*100.
# kappa_line4 = np.array([0.001,0.001])
# crit_ss_line4 = (partmc.critical_rel_humids(env_state,kappa_line4, dry_diameters_line)-1)*100.
# print 'line ', kappa_line1, dry_diameters_line, crit_ss_line1
plt.clf()
plt.pcolor(x_axis.edges(),
y_axis.edges(),
hist_average.transpose(),
norm=matplotlib.colors.LogNorm(vmin=1e3, vmax=1e11),
linewidths=0.1)
# plt.plot(dry_diameters_line, crit_ss_line1, 'k-')
# plt.plot(dry_diameters_line, crit_ss_line2, 'k-')
# plt.plot(dry_diameters_line, crit_ss_line3, 'k-')
# plt.plot(dry_diameters_line, crit_ss_line4, 'k-')
a = plt.gca()
a.set_xscale("log")
a.set_yscale("log")
plt.grid()
plt.axis([5e-9, 5e-6, y_axis.min, y_axis.max])
plt.xlabel("dry diameter (m)")
plt.ylabel("S_crit in %")
cbar = plt.colorbar()
cbar.set_label("number density (m^{-3})")
fig = plt.gcf()
fig.savefig(out_filename1)
plt.clf()
plt.pcolor(x_axis.edges(),
y_axis.edges(),
hist_std_norm.transpose(),
norm=matplotlib.colors.LogNorm(vmin=1e-2, vmax=10),
linewidths=0.1)
a = plt.gca()
a.set_xscale("log")
a.set_yscale("log")
plt.grid()
plt.axis([5e-9, 5e-6, y_axis.min, y_axis.max])
plt.xlabel("dry diameter (m)")
plt.ylabel("S_crit in %")
cbar = plt.colorbar()
cbar.set_label("CV")
fig = plt.gcf()
fig.savefig(out_filename2)
def make_plot(hour_counter, case_counter, dir_name, in_files):
x_axis = partmc.log_grid(min=1e-9,max=1e-5,n_bin=70)
y_axis = partmc.log_grid(min=1e-3,max=1e2,n_bin=50)
x_centers = x_axis.centers()
y_centers = y_axis.centers()
i_counter = 0
hist_array = np.zeros([len(x_centers), len(y_centers), config.i_loop_max])
hist_average = np.zeros([len(x_centers), len(y_centers)])
hist_std = np.zeros([len(x_centers), len(y_centers)])
hist_std_norm = np.zeros([len(x_centers), len(y_centers)])
ccn_array = np.zeros([4,config.i_loop_max]) # s_crit values x i_loop
bc_array = np.zeros([4,config.i_loop_max])
for file in in_files:
ncf = scipy.io.netcdf.netcdf_file(dir_name+file, 'r')
particles = partmc.aero_particle_array_t(ncf)
env_state = partmc.env_state_t(ncf)
ncf.close()
dry_diameters = particles.dry_diameters()
total_number = sum(1/particles.comp_vols)
bc = particles.masses(include = ["BC"])
total_bc = sum(bc/particles.comp_vols)
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])
bc_mass_act1 = sum(bc[activated_1]/particles.comp_vols[activated_1])
activated_2 = (s_crit < config.s_crit_2)
number_act_2 = sum(1/particles.comp_vols[activated_2])
bc_mass_act2 = sum(bc[activated_2]/particles.comp_vols[activated_2])
activated_3 = (s_crit < config.s_crit_3)
number_act_3 = sum(1/particles.comp_vols[activated_3])
bc_mass_act3 = sum(bc[activated_3]/particles.comp_vols[activated_3])
activated_4 = (s_crit < config.s_crit_4)
number_act_4 = sum(1/particles.comp_vols[activated_4])
bc_mass_act4 = sum(bc[activated_4]/particles.comp_vols[activated_4])
ccn_array[0,i_counter]= float(number_act_1)/total_number
ccn_array[1,i_counter]= float(number_act_2)/total_number
ccn_array[2,i_counter]= float(number_act_3)/total_number
ccn_array[3,i_counter]= float(number_act_4)/total_number
bc_array[0,i_counter]= float(bc_mass_act1)/total_bc
bc_array[1,i_counter]= float(bc_mass_act2)/total_bc
bc_array[2,i_counter]= float(bc_mass_act3)/total_bc
bc_array[3,i_counter]= float(bc_mass_act4)/total_bc
i_counter += 1
print 'counters 3 ', hour_counter, case_counter
ccn = np.average(ccn_array, axis = 1)
ccn_average[hour_counter,case_counter,:] = ccn
ccn_std[hour_counter,case_counter,:] = np.std(ccn_array, axis = 1)
bc_average[hour_counter,case_counter,:] = np.average(bc_array, axis = 1)
bc_std[hour_counter, case_counter, :] = np.std(bc_array, axis = 1)
def make_plot(hour, f1, f2, f3, f4):
x_axis = partmc.log_grid(
min=1e-9, max=1e-5,
n_bin=80) # n_bin changed to 80. was 70 for the submitted paper
y_axis = partmc.linear_grid(min=0, max=1., n_bin=50)
x_centers = x_axis.centers()
y_centers = y_axis.centers()
hist_array_num = np.zeros([
len(x_centers),
len(y_centers), config.i_weighting_schemes, config.i_loop_max
])
hist_array_mass = np.zeros([
len(x_centers),
len(y_centers), config.i_weighting_schemes, config.i_loop_max
])
hist_array_pnum = np.zeros([
len(x_centers),
len(y_centers), config.i_weighting_schemes, config.i_loop_max
])
hist_average_num = np.zeros(
[len(x_centers),
len(y_centers), config.i_weighting_schemes])
hist_average_mass = np.zeros(
[len(x_centers),
len(y_centers), config.i_weighting_schemes])
hist_average_pnum = np.zeros(
[len(x_centers),
len(y_centers), config.i_weighting_schemes])
hist_var_num = np.zeros(
[len(x_centers),
len(y_centers), config.i_weighting_schemes])
hist_var_mass = np.zeros(
[len(x_centers),
len(y_centers), config.i_weighting_schemes])
weighting_factor_num = np.zeros(
[len(x_centers),
len(y_centers), config.i_weighting_schemes])
weighting_factor_mass = np.zeros(
[len(x_centers),
len(y_centers), config.i_weighting_schemes])
for (counter_weighting, counter) in enumerate([
"1K_wei+1", "1K_flat", "1K_wei-1", "1K_wei-2", "1K_wei-3",
"1K_wei-4"
]):
print "I'm doing ", counter
files = []
for i_loop in range(0, config.i_loop_max):
filename_in = config.netcdf_dir + "/urban_plume_wc_%s_0%03d_000000%02d.nc" % (
counter, i_loop + 1, hour)
files.append(filename_in)
for (counter_i_loop, file) in enumerate(files):
print "file ", file
ncf = scipy.io.netcdf.netcdf_file(file, 'r')
particles = partmc.aero_particle_array_t(ncf)
env_state = partmc.env_state_t(ncf)
ncf.close()
dry_diameters = particles.dry_diameters()
bc = particles.masses(include=["BC"])
dry_mass = particles.masses(exclude=["H2O"])
bc_frac = bc / dry_mass
hist2d = partmc.histogram_2d(dry_diameters,
bc_frac,
x_axis,
y_axis,
weights=1 / particles.comp_vols)
hist_array_num[:, :, counter_weighting, counter_i_loop] = hist2d
hist2d = partmc.histogram_2d(
dry_diameters,
bc_frac,
x_axis,
y_axis,
weights=particles.masses(include=["BC"]) / particles.comp_vols)
hist_array_mass[:, :, counter_weighting, counter_i_loop] = hist2d
hist2d = partmc.histogram_2d(dry_diameters, bc_frac, x_axis,
y_axis)
hist_array_pnum[:, :, counter_weighting, counter_i_loop] = hist2d
hist_array_num = np.ma.masked_less_equal(hist_array_num, 0)
hist_array_mass = np.ma.masked_less_equal(hist_array_mass, 0)
hist_array_pnum = np.ma.masked_less_equal(hist_array_pnum, 0)
hist_average_num = np.average(hist_array_num, axis=3)
hist_average_mass = np.average(hist_array_mass, axis=3)
hist_average_pnum = np.average(hist_array_pnum, axis=3)
hist_var_num = np.var(hist_array_num, axis=3)
hist_var_mass = np.var(hist_array_mass, axis=3)
print "Calculated average and variance", counter
# weighting_factor_num = 1 / (hist_var_num / hist_average_pnum)
# weighting_factor_mass = 1 / (hist_var_mass / hist_average_pnum)
# new way of calculating weighting_factor after Matt discovered error, 6/25/2011
# weighting_factor_num = 1 / hist_var_num
# weighting_factor_mass = 1 / hist_var_mass
# TEST: weighting directly proportional to N_p
weighting_factor_num = hist_average_pnum
weighting_factor_mass = hist_average_pnum
weighting_factor_num_sum = np.sum(weighting_factor_num, axis=2)
weighting_factor_mass_sum = np.sum(weighting_factor_mass, axis=2)
hist_composite_num = np.zeros([len(x_centers), len(y_centers)])
hist_composite_mass = np.zeros([len(x_centers), len(y_centers)])
for i in range(0, config.i_weighting_schemes):
increment = weighting_factor_num[:, :,
i] / weighting_factor_num_sum * hist_average_num[:, :,
i]
# increment = increment.filled(0)
hist_composite_num += increment
print "hist_composite_num ", hist_composite_num
hist_composite_num = np.nan_to_num(hist_composite_num)
for i in range(0, config.i_weighting_schemes):
increment = weighting_factor_mass[:, :,
i] / weighting_factor_mass_sum * hist_average_mass[:, :,
i]
# increment = increment.filled(0)
hist_composite_mass += increment
hist_composite_mass = np.nan_to_num(hist_composite_mass)
np.savetxt(f1, x_axis.edges())
np.savetxt(f2, y_axis.edges())
np.savetxt(f3, hist_composite_num)
np.savetxt(f4, hist_composite_mass)
def make_plot(in_files, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10):
x_axis = partmc.log_grid(min=1e-9, max=1e-5, n_bin=70)
y_axis = partmc.log_grid(min=1e-3, max=1e2, n_bin=50)
x_centers = x_axis.centers()
y_centers = y_axis.centers()
counter = 0
hist_array_num = np.zeros(
[len(x_centers), len(y_centers), config.i_loop_max])
hist_average_num = np.zeros([len(x_centers), len(y_centers)])
hist_std_num = np.zeros([len(x_centers), len(y_centers)])
hist_std_norm_num = np.zeros([len(x_centers), len(y_centers)])
hist_array_mass = np.zeros(
[len(x_centers), len(y_centers), config.i_loop_max])
hist_average_mass = np.zeros([len(x_centers), len(y_centers)])
hist_std_mass = np.zeros([len(x_centers), len(y_centers)])
hist_std_norm_mass = np.zeros([len(x_centers), len(y_centers)])
hist_array_kappas = np.zeros(
[len(x_centers), len(y_centers), config.i_loop_max])
for file in in_files:
ncf = scipy.io.netcdf.netcdf_file(config.netcdf_dir + '/' + file, 'r')
particles = partmc.aero_particle_array_t(ncf)
env_state = partmc.env_state_t(ncf)
ncf.close()
dry_diameters = particles.dry_diameters()
kappas = particles.kappas()
print 'kappa max and min', kappas.max(), kappas.min()
kappa_const = np.ones([len(x_axis.edges())])
kappa_const1 = 1 * kappa_const
kappa_const2 = 0 * kappa_const
print "kappa_const ", kappa_const1, len(kappa_const1), len(
particles.dry_diameters())
crit_rhs1 = (partmc.critical_rel_humids(env_state, kappa_const1,
x_axis.edges()) - 1) * 100
crit_rhs2 = (partmc.critical_rel_humids(env_state, kappa_const2,
x_axis.edges()) - 1) * 100
print "crit_rhs ", crit_rhs1, crit_rhs2
s_crit = (particles.critical_rel_humids(env_state) - 1) * 100
dry_mass = particles.masses(exclude=["H2O"])
dry_diameters = particles.dry_diameters()
hist2d = partmc.histogram_2d(dry_diameters,
s_crit,
x_axis,
y_axis,
weights=1 / particles.comp_vols)
hist_array_num[:, :, counter] = hist2d
hist2d = partmc.histogram_2d(dry_diameters,
s_crit,
x_axis,
y_axis,
weights=particles.masses(include=["BC"]) /
particles.comp_vols)
hist_array_mass[:, :, counter] = hist2d
hist2d = partmc.histogram_2d(dry_diameters,
kappas,
x_axis,
y_axis,
weights=1 / particles.comp_vols)
hist_array_kappas[:, :, counter] = hist2d
counter = counter + 1
hist_average_num = np.average(hist_array_num, axis=2)
hist_std_num = np.std(hist_array_num, axis=2)
hist_std_norm_num = hist_std_num / hist_average_num
hist_std_norm_num = np.ma.masked_invalid(hist_std_norm_num)
hist_average_mass = np.average(hist_array_mass, axis=2)
hist_std_mass = np.std(hist_array_mass, axis=2)
hist_std_norm_mass = hist_std_mass / hist_average_mass
hist_std_norm_mass = np.ma.masked_invalid(hist_std_norm_mass)
hist_average_kappas = np.average(hist_array_kappas, axis=2)
hist_std_kappas = np.std(hist_array_kappas, axis=2)
hist_std_norm_kappas = hist_std_kappas / hist_average_kappas
hist_std_norm_kappas = np.ma.masked_invalid(hist_std_norm_kappas)
np.savetxt(f1, x_axis.edges())
np.savetxt(f2, y_axis.edges())
np.savetxt(f3, hist_average_num)
np.savetxt(f4, hist_std_norm_num)
np.savetxt(f5, hist_average_mass)
np.savetxt(f6, hist_std_norm_mass)
np.savetxt(f7, hist_average_kappas)
np.savetxt(f8, hist_std_norm_kappas)
np.savetxt(f9, crit_rhs1)
np.savetxt(f10, crit_rhs2)
def make_plot(dir_name, in_files, out_filename1, out_filename2):
x_axis = partmc.log_grid(min=1e-9, max=1e-5, n_bin=70)
y_axis = partmc.log_grid(min=1e-3, max=1e2, n_bin=50)
x_centers = x_axis.centers()
y_centers = y_axis.centers()
counter = 0
hist_array = np.zeros([len(x_centers), len(y_centers), config.i_loop_max])
hist_average = np.zeros([len(x_centers), len(y_centers)])
hist_std = np.zeros([len(x_centers), len(y_centers)])
hist_std_norm = np.zeros([len(x_centers), len(y_centers)])
for file in in_files:
ncf = Scientific.IO.NetCDF.NetCDFFile(dir_name + file)
particles = partmc.aero_particle_array_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
hist2d = partmc.histogram_2d(dry_diameters,
s_crit,
x_axis,
y_axis,
weights=particles.masses(include=["BC"]) /
particles.comp_vols)
hist_array[:, :, counter] = hist2d
counter = counter + 1
hist_average = np.average(hist_array, axis=2)
hist_std = np.std(hist_array, axis=2)
hist_std_norm = hist_std / hist_average
hist_std_norm = np.ma.masked_invalid(hist_std_norm)
print 'hist_array ', hist2d.shape, hist_array[35, :, 0]
print 'hist_std ', hist_average[35, :], hist_std[35, :], hist_std_norm[
35, :]
plt.clf()
plt.pcolor(x_axis.edges(),
y_axis.edges(),
hist_average.transpose(),
norm=matplotlib.colors.LogNorm(vmin=1e-11, vmax=1e-7),
linewidths=0.1)
a = plt.gca()
a.set_xscale("log")
a.set_yscale("log")
plt.grid()
plt.axis([5e-9, 5e-6, y_axis.min, y_axis.max])
plt.xlabel("dry diameter (m)")
plt.ylabel("S_crit in %")
cbar = plt.colorbar()
cbar.set_label("mass density (kg m^{-3})")
fig = plt.gcf()
fig.savefig(out_filename1)
plt.clf()
plt.pcolor(x_axis.edges(),
y_axis.edges(),
hist_std_norm.transpose(),
norm=matplotlib.colors.LogNorm(vmin=1e-2, vmax=10),
linewidths=0.1)
a = plt.gca()
a.set_xscale("log")
a.set_yscale("log")
plt.grid()
plt.axis([5e-9, 5e-6, y_axis.min, y_axis.max])
plt.xlabel("dry diameter (m)")
plt.ylabel("S_crit in %")
cbar = plt.colorbar()
cbar.set_label("std/avg")
fig = plt.gcf()
fig.savefig(out_filename2)
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)
