def plot_perc_err():
(figure, axes) = mpl_helper.make_fig(figure_width=(12 / 2.54), left_margin=0.7, bottom_margin=0.42, right_margin=0.2, top_margin=0.2)
num_edges = np.genfromtxt('./data2/Mean_perc_err_100_workers_num_edges.txt')
err_w_r = np.genfromtxt('./data2/Mean_perc_err_100_workers_perc_err_w_r.txt')
err_wo_r = np.genfromtxt('./data2/Mean_perc_err_100_workers_perc_err_wo_r.txt')
err_w = np.genfromtxt('./data2/Mean_perc_err_100_workers_perc_err_w.txt')
err_wo = np.genfromtxt('./data2/Mean_perc_err_100_workers_perc_err_wo.txt')
axes.plot(num_edges, err_w_r, 'k-', label='random with prior')
axes.plot(num_edges, err_wo_r, 'b-', label='random without prior')
axes.plot(num_edges, err_w, 'r-', label='adaptive with prior')
axes.plot(num_edges, err_wo, 'g-', label='adaptive without prior')
axes.set_yscale('log')
axes.set_xlabel('number of edges')
axes.set_ylabel('assignment error + std dev (percent)')
axes.grid(b=1, which='major', linestyle='-')
axes.grid(b=1, which='minor', linestyle=':')
axes.legend(loc=0)
return(figure,axes)
#!/usr/bin/env python
import sys, os
sys.path.append("../../tool")
import mpl_helper
import matplotlib
import scipy.io, numpy
for (filename, index) in mpl_helper.get_filename_list(
'out/', r'urban_plume_([0-9]+)_process\.nc'):
(figure, axes, cbar_axes) = mpl_helper.make_fig(left_margin=0.7,
right_margin=1,
colorbar=True)
ncf = scipy.io.netcdf_file(filename)
diam_edges = ncf.variables["diam_edges"].data.copy() * 1e6
bc_frac_edges = ncf.variables["bc_frac_edges"].data.copy() * 100
diam_bc_dist = ncf.variables["diam_bc_dist"].data.copy() * 1e-6
p = axes.pcolor(diam_edges,
bc_frac_edges,
diam_bc_dist,
norm=matplotlib.colors.LogNorm(vmin=1e3, vmax=1e5),
linewidths=0.1)
axes.set_xscale("log")
axes.set_xlabel(r"dry diameter $D_{\rm dry}$ / $\rm \mu m$")
axes.set_xlim(1e-2, 1e0)
axes.set_yscale("linear")
axes.set_ylabel(r"BC mass fraction $w_{\rm BC}$ / \%")
#!/usr/bin/env python
import sys, os
sys.path.append("../../tool")
import mpl_helper
import scipy.io, numpy
(figure, axes) = mpl_helper.make_fig(right_margin=0.8)
axes2 = axes.twinx()
ncf = scipy.io.netcdf_file("out/urban_plume_process.nc")
time = ncf.variables["time"].data / 3600
num_conc = ncf.variables["tot_num_conc"].data / 1e6
num_conc_err = ncf.variables["tot_num_conc_ci_offset"].data / 1e6
mass_conc = ncf.variables["tot_mass_conc"].data * 1e9
mass_conc_err = ncf.variables["tot_mass_conc_ci_offset"].data * 1e9
axes.errorbar(time, num_conc, num_conc_err, fmt="b-")
axes2.errorbar(time, mass_conc, mass_conc_err, fmt="r-")
axes.set_xlabel(r"time / h")
axes.set_ylabel(r"num. conc. / $\rm cm^{-3}$")
axes2.set_ylabel(r"mass conc. / $\rm \mu g\ m^{-3}$")
axes.grid(True)
figure.savefig("out/urban_plume_total.pdf")
#!/usr/bin/env python
import sys, os
sys.path.append("../../tool")
import mpl_helper
import matplotlib
import partmc
import scipy.io, numpy
for (filename, index) in partmc.get_filename_list('out/', r'urban_plume_([0-9]+)_process\.nc'):
(figure, axes, cbar_axes) = mpl_helper.make_fig(left_margin=0.6, right_margin=1, colorbar=True)
ncf = scipy.io.netcdf_file(filename)
diam_edges = ncf.variables["diam_edges"].data * 1e6
sc_edges = ncf.variables["sc_edges"].data * 100
diam_sc_dist = ncf.variables["diam_sc_dist"].data * 1e-6
p = axes.pcolor(diam_edges, sc_edges, diam_sc_dist,
norm = matplotlib.colors.LogNorm(vmin=1e3, vmax=1e5), linewidths = 0.1)
axes.set_xscale("log")
axes.set_xlabel(r"dry diameter $D_{\rm dry}$ / $\rm \mu m$")
axes.set_xlim(1e-2, 1e0)
axes.set_yscale("log")
axes.set_ylabel(r"critical supersaturation $S_{\rm c}$ / \%")
axes.set_ylim(1e-2, 1e2)
axes.grid(True)
cbar = figure.colorbar(p, cax=cbar_axes, format=matplotlib.ticker.LogFormatterMathtext(),
orientation='vertical')
#!/usr/bin/env python
import sys, os
sys.path.append("../../../aq_partmc/tool/")
import mpl_helper
import scipy.io, numpy
import matplotlib.pyplot as plt
import matplotlib.lines as mlines
import numpy as np
import pylab
import csv
(figure, axes) = mpl_helper.make_fig(right_margin=0.8)
#axes2 = axes.twinx()
# input the file
#f1 = scipy.io.netcdf_file("out_right_low/cloud_parcel_process.nc",'r',mmap=False)
f1 = scipy.io.netcdf_file(
"../urban-plume/out_5h/urban_plume_aq_chem_b_process.nc", 'r', mmap=False)
f2 = scipy.io.netcdf_file(
"../urban-plume/out_5h_avcomp_onebin/urban_plume_aq_chem_b_process.nc",
'r',
mmap=False)
# get the variables
time = f1.variables["time"].data / 60
dens1 = f1.variables["density"].data # unit: kg/m3
dens2 = f2.variables["density"].data # unit: kg/m3
sul1 = f1.variables["tot_so4_conc"].data * 29 / 96 * 1e9 / dens1 + f1.variables[
"tot_HSO4m_conc"].data * 29 / 97 * 1e9 / dens1
sul2 = f2.variables["tot_so4_conc"].data * 29 / 96 * 1e9 / dens2 + f2.variables[
"tot_HSO4m_conc"].data * 29 / 97 * 1e9 / dens2
i_weight = 0
for weight in ["wei+1", "flat", "wei-1", "wei-2", "wei-3", "wei-4", "mfa"]:
index_1K = 3*i_weight
index_10K = 3*i_weight + 1
error_ratio_1K_num[i_weight] = abs(num_avg_overall[index_1K+1, 99] - num_avg_overall[index_1K, 99])/(r*num_std_overall[index_1K,99])
error_ratio_10K_num[i_weight] = abs(num_avg_overall[index_10K+1, 99] - num_avg_overall[index_10K, 99])/(r*num_std_overall[index_10K,99])
error_ratio_1K_mass[i_weight] = abs(mass_avg_overall[index_1K+1, 99] - mass_avg_overall[index_1K, 99])/(r*mass_std_overall[index_1K,99])
error_ratio_10K_mass[i_weight] = abs(mass_avg_overall[index_10K+1, 99] - mass_avg_overall[index_10K, 99])/(r*mass_std_overall[index_10K,99])
i_weight += 1
weight_array = [1, 0, -1, -2, -3, -4]
(figure, axes) = mpl_helper.make_fig(figure_width = 0.7*config.figure_width_double, top_margin=0.2, bottom_margin=0.4,left_margin=0.6, right_margin=1.3)
l_n_1e3 = axes.plot(weight_array, error_ratio_1K_num[0:6], label = r"${\rm ER_N}(10^3,10^4)$")
l_n_1e4 = axes.plot(weight_array, error_ratio_10K_num[0:6], label = r"${\rm ER_N}(10^4,10^5)$")
l_m_1e3 = axes.plot(weight_array, error_ratio_1K_mass[0:6], label = r"${\rm ER_M}(10^3,10^4)$")
l_m_1e4 = axes.plot(weight_array, error_ratio_10K_mass[0:6], label = r"${\rm ER_M}(10^4,10^5)$")
axes.grid(True)
#axes.legend()
axes.set_ylim(0, 0.8)
axes.set_xlabel(r"weighting exponent $\alpha$ ")
axes.set_ylabel(r"error ratio $\rm ER$")
axes.legend((l_n_1e3,l_n_1e4,l_m_1e3,l_m_1e4),
(r"${\rm ER_N}(10^3,10^4)$", r"${\rm ER_N}(10^4,10^5)$",
r"${\rm ER_M}(10^3,10^4)$", r"${\rm ER_M}(10^4,10^5)$"), loc='center left', bbox_to_anchor = (1.0,0.5),ncol=1)
figure.savefig("figs/er_alpha.pdf")
"equilib_rhs_evaporation_grid_130.txt")
equilibrium_rhs_deactivation_grid_130 = np.loadtxt(
"equilib_rhs_deactivation_grid_130.txt")
equilibrium_rhs_inertial_grid_130 = np.loadtxt(
"equilib_rhs_inertial_grid_130.txt")
equilibrium_rhs_not_activate_grid_150 = np.loadtxt(
"equilib_rhs_not_activate_grid_150.txt")
equilibrium_rhs_evaporation_grid_150 = np.loadtxt(
"equilib_rhs_evaporation_grid_150.txt")
equilibrium_rhs_deactivation_grid_150 = np.loadtxt(
"equilib_rhs_deactivation_grid_150.txt")
equilibrium_rhs_inertial_grid_150 = np.loadtxt(
"equilib_rhs_inertial_grid_150.txt")
(figure, axes) = mpl_helper.make_fig()
l1 = axes.plot(seconds, diam_not_activate)
l2 = axes.plot(seconds, diam_evaporation)
l3 = axes.plot(seconds, diam_deactivation)
l4 = axes.plot(seconds, diam_inertial)
axes.grid(True)
axes.set_yscale("log")
axes.set_xlabel(r"time in seconds ")
axes.set_ylabel(r"wet diameter")
axes.legend((l1, l2, l3, l4),
("not activate", "evaporation", "deactivation", "inertial"))
figure.savefig("figs/diameters.pdf")
(figure, axes) = mpl_helper.make_fig()
axes.plot(seconds, rh_eq_not_activate)
axes.plot(seconds, rh_eq_evaporation)
def grid_box_histogram(time):
# filename prefix
dir = config.data_dir
prefix = config.file_prefix
filename = '%s_%08i.nc' %(prefix,time)
# make grids
diam_axis = partmc.log_grid(min=1e-9,max=1e-6,n_bin=60)
bc_axis = partmc.linear_grid(min=0,max=1.,n_bin=50)
# load the file
ncf = scipy.io.netcdf.netcdf_file(config.data_dir+'/'+filename, 'r')
particles = partmc.aero_particle_array_t(ncf)
ncf.close()
# compute the values
bc = particles.masses(include = ["BC"])
dry_mass = particles.masses(exclude = ["H2O"])
bc_frac = bc / dry_mass
dry_diameters = particles.dry_diameters()
# 2D histogram
hist_2d_bc = partmc.histogram_2d(dry_diameters, bc_frac, diam_axis, bc_axis,
weights = 1 / particles.comp_vols)
# convert
hist_2d_bc /= 1e6
# create the figure
width_in = 4.0
(figure, axes, cbar_axes) = mpl_helper.make_fig(figure_width=width_in,
colorbar=True,left_margin=.7,right_margin=1.1, top_margin=0.3,
bottom_margin=.65, colorbar_height_fraction=0.8)
# Data min and max
# we want this to be fixed for all time
data_min = 10**2 #min(data_mins)
data_max = 10**6 #max(data_maxes)
norm = matplotlib.colors.LogNorm(vmin=data_min, vmax=data_max)
p = axes.pcolormesh(diam_axis.edges()/1e-6, bc_axis.edges()*100,
hist_2d_bc.transpose(),norm = norm, linewidths = 0.1, edgecolors='None')
# make the plot pretty
axes.set_xscale('log')
axes.set_yscale('linear')
xlabel = r'diameter $(\mu \rm m)$'
ylabel = r'BC mass fraction'
axes.set_xlabel(xlabel)
axes.set_ylabel(ylabel)
axes.set_xlim(.005,1)
axes.set_ylim(0,80)
axes.set_yticks([0,20,40,60,80])
axes.grid(True)
# colorbar
cbar = figure.colorbar(p, cax=cbar_axes,
format=matplotlib.ticker.LogFormatterMathtext(),
orientation='vertical')
kwargs = {}
kwargs["format"] = matplotlib.ticker.LogFormatterMathtext()
cmappable = matplotlib.cm.ScalarMappable(norm=norm)
cmappable.set_array(numpy.array([hist_2d_bc.min(), hist_2d_bc.max()]))
cbar_label = r"num. conc. $(\rm cm^{-3})$"
cbar.set_label(cbar_label)
cbar.solids.set_edgecolor("face")
# Save figure and print name
fig_name = '%s/bc_plot_%08i.pdf' % \
(config.fig_dir, time)
figure.savefig(fig_name)
# print name in case we need it
print fig_name
return
# average std over time
array_num_std_avg[i_counter_p,i_counter] = np.average(num_std[i_counter_p,i_counter,:] /
num_avg[i_counter_p,i_counter,:])
array_mass_std_avg[i_counter_p,i_counter] = np.average(mass_std[i_counter_p, i_counter,:] /
mass_avg[i_counter_p, i_counter,:])
i_counter = i_counter + 1
i_counter_p = i_counter_p + 1
x_array = [1, 0, -1, -2, -3, -4]
print "array_num_std_avg[1,0:6] ", array_num_std_avg[1,0:6]
print "array_num_std_avg[2,0:6] ", array_num_std_avg[2,0:6]
(figure, axes) = mpl_helper.make_fig(figure_width=config.figure_width_single, axis_ratio=1)
axes.set_xscale("log")
axes.set_yscale("log")
axes.plot(array_num_std_avg[0,0:6], array_mass_std_avg[0,0:6], 'xr-')
axes.plot(array_num_std_avg[0,6], array_mass_std_avg[0,6], 'or', label = '1K mfa')
axes.plot(array_num_std_avg[1,0:6], array_mass_std_avg[1,0:6], 'xg-')
axes.plot(array_num_std_avg[1,6], array_mass_std_avg[1,6], 'og', label = '10K mfa')
axes.plot(array_num_std_avg[2,0:6], array_mass_std_avg[2,0:6], 'xb-')
axes.plot(array_num_std_avg[2,6], array_mass_std_avg[2,6], 'ob', label = '100K mfa')
axes.grid()
axes.set_xlabel(r"average number coeff. var. $\overline{{\rm CV}(N(t))}$")
axes.set_ylabel(r"average mass coeff. var. $\overline{{\rm CV}(M(t))}$")
axes.annotate(r"$N_{\rm p} = 10^3$", (array_num_std_avg[0,0], array_mass_std_avg[0,0]),
verticalalignment="bottom", horizontalalignment="center",
def plot_kernel(prefix):
kernel_data = numpy.loadtxt("data/" + prefix + "_kernel.txt")
counts_data = numpy.loadtxt("data/" + prefix + "_count.txt")
n_bin = counts_data.shape[0]
k_min = kernel_data[:, 2].reshape((n_bin, n_bin))
k_max = kernel_data[:, 3].reshape((n_bin, n_bin))
n_possible = kernel_data[:, 4].reshape((n_bin, n_bin))
r_samp = kernel_data[:, 5].reshape((n_bin, n_bin))
n_samp_mean = kernel_data[:, 6].reshape((n_bin, n_bin))
r_samp_rate = kernel_data[:, 7].reshape((n_bin, n_bin))
n_samp_mean_rate = kernel_data[:, 8].reshape((n_bin, n_bin))
diam_centers = counts_data[:, 1] * 1e6
diam_edges = numpy.concatenate(
(counts_data[:, 2], counts_data[-1:, 3])) * 1e6
n_parts = counts_data[:, 4]
min_bin = numpy.flatnonzero(n_parts).min()
max_bin = numpy.flatnonzero(n_parts).max()
diam_edges_nonzero = diam_edges[min_bin:(max_bin + 2)]
diam_centers_nonzero = diam_centers[min_bin:(max_bin + 1)]
n_parts_nonzero = n_parts[min_bin:(max_bin + 1)]
k_min = numpy.ma.masked_less_equal(k_min, 0)
k_max = numpy.ma.masked_less_equal(k_max, 0)
n_possible = numpy.ma.masked_less_equal(n_possible, 0)
r_samp = numpy.ma.masked_less_equal(r_samp, 0)
n_samp_mean = numpy.ma.masked_less_equal(n_samp_mean, 0)
r_samp_rate = numpy.ma.masked_less_equal(r_samp_rate, 0)
n_samp_mean_rate = numpy.ma.masked_less_equal(n_samp_mean_rate, 0)
k_ratio = k_max / k_min
k_min_nonzero = k_min[min_bin:(max_bin + 1), min_bin:(max_bin + 1)]
k_max_nonzero = k_max[min_bin:(max_bin + 1), min_bin:(max_bin + 1)]
k_ratio_nonzero = k_ratio[min_bin:(max_bin + 1), min_bin:(max_bin + 1)]
n_possible_nonzero = n_possible[min_bin:(max_bin + 1),
min_bin:(max_bin + 1)]
r_samp_nonzero = r_samp[min_bin:(max_bin + 1), min_bin:(max_bin + 1)]
n_samp_mean_nonzero = n_samp_mean[min_bin:(max_bin + 1),
min_bin:(max_bin + 1)]
r_samp_rate_nonzero = r_samp_rate[min_bin:(max_bin + 1),
min_bin:(max_bin + 1)]
n_samp_mean_rate_nonzero = n_samp_mean_rate[min_bin:(max_bin + 1),
min_bin:(max_bin + 1)]
n_parts_x = []
n_parts_y = []
for i in range(len(n_parts)):
n_parts_x.append(diam_edges[i])
n_parts_y.append(n_parts[i])
n_parts_x.append(diam_edges[i + 1])
n_parts_y.append(n_parts[i])
(figure, axes) = mpl_helper.make_fig()
axes.loglog(n_parts_x, n_parts_y)
axes.set_xlim(min(diam_edges), max(diam_edges))
axes.set_ylim(bottom=1e-1)
axes.set_xlabel(r"diameter / $\rm \mu m$")
axes.set_ylabel(r"number of particles")
figure.savefig("figs/" + prefix + "_count.pdf")
(figure, axes, cbar_axes) = mpl_helper.make_fig(axis_ratio=1,
colorbar=True,
right_margin=1.2)
p = axes.pcolor(diam_edges,
diam_edges,
n_possible,
norm=matplotlib.colors.LogNorm(),
linewidths=0.1)
axes.set_xscale("log")
axes.set_yscale("log")
axes.set_xlim(min(diam_edges), max(diam_edges))
axes.set_ylim(min(diam_edges), max(diam_edges))
axes.set_xlabel(r"diameter $D_1$ / $\rm \mu m$")
axes.set_ylabel(r"diameter $D_2$ / $\rm \mu m$")
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 of reaction pairs $n_i(n_j - \delta_{ij})$")
figure.savefig("figs/" + prefix + "_n_possible.pdf")
(figure, axes, cbar_axes) = mpl_helper.make_fig(axis_ratio=1,
colorbar=True,
right_margin=1.2)
p = axes.pcolor(diam_edges,
diam_edges,
r_samp,
norm=matplotlib.colors.LogNorm(),
linewidths=0.1)
axes.set_xscale("log")
axes.set_yscale("log")
axes.set_xlim(min(diam_edges), max(diam_edges))
axes.set_ylim(min(diam_edges), max(diam_edges))
axes.set_xlabel(r"diameter $D_1$ / $\rm \mu m$")
axes.set_ylabel(r"diameter $D_2$ / $\rm \mu m$")
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 of samples per pair $K_{ij} \Delta t / V_{\rm comp}$")
figure.savefig("figs/" + prefix + "_r_samp.pdf")
(figure, axes, cbar_axes) = mpl_helper.make_fig(axis_ratio=1,
colorbar=True,
right_margin=1.2)
p = axes.pcolor(diam_edges,
diam_edges,
r_samp_rate,
norm=matplotlib.colors.LogNorm(),
linewidths=0.1)
axes.set_xscale("log")
axes.set_yscale("log")
axes.set_xlim(min(diam_edges), max(diam_edges))
axes.set_ylim(min(diam_edges), max(diam_edges))
axes.set_xlabel(r"diameter $D_1$ / $\rm \mu m$")
axes.set_ylabel(r"diameter $D_2$ / $\rm \mu m$")
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 of samples per pair rate $K_{ij} / V_{\rm comp}$")
figure.savefig("figs/" + prefix + "_r_samp_rate.pdf")
(figure, axes, cbar_axes) = mpl_helper.make_fig(axis_ratio=1,
colorbar=True,
right_margin=1.2)
p = axes.pcolor(diam_edges,
diam_edges,
n_samp_mean,
norm=matplotlib.colors.LogNorm(),
linewidths=0.1)
axes.set_xscale("log")
axes.set_yscale("log")
axes.set_xlim(min(diam_edges), max(diam_edges))
axes.set_ylim(min(diam_edges), max(diam_edges))
axes.set_xlabel(r"diameter $D_1$ / $\rm \mu m$")
axes.set_ylabel(r"diameter $D_2$ / $\rm \mu m$")
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 of events $(K_{ij} \Delta t / V) n_i(n_j - \delta_{ij})$")
figure.savefig("figs/" + prefix + "_n_samp_mean.pdf")
(figure, axes, cbar_axes) = mpl_helper.make_fig(axis_ratio=1,
colorbar=True,
right_margin=1.2)
p = axes.pcolor(diam_edges,
diam_edges,
n_samp_mean_rate,
norm=matplotlib.colors.LogNorm(),
linewidths=0.1)
axes.set_xscale("log")
axes.set_yscale("log")
axes.set_xlim(min(diam_edges), max(diam_edges))
axes.set_ylim(min(diam_edges), max(diam_edges))
axes.set_xlabel(r"diameter $D_1$ / $\rm \mu m$")
axes.set_ylabel(r"diameter $D_2$ / $\rm \mu m$")
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 of events rate $(K_{ij} / V) n_i(n_j - \delta_{ij})$")
figure.savefig("figs/" + prefix + "_n_samp_mean_rate.pdf")
(figure, axes, cbar_axes) = mpl_helper.make_fig(axis_ratio=1,
colorbar=True,
right_margin=1.2)
p = axes.pcolor(diam_edges,
diam_edges,
k_max,
norm=matplotlib.colors.LogNorm(),
linewidths=0.1)
axes.set_xscale("log")
axes.set_yscale("log")
axes.set_xlim(min(diam_edges), max(diam_edges))
axes.set_ylim(min(diam_edges), max(diam_edges))
axes.set_xlabel(r"diameter $D_1$ / $\rm \mu m$")
axes.set_ylabel(r"diameter $D_2$ / $\rm \mu m$")
cbar = figure.colorbar(p,
cax=cbar_axes,
format=matplotlib.ticker.LogFormatterMathtext(),
orientation='vertical')
cbar_axes.xaxis.set_label_position('top')
cbar.set_label(r"kernel $K_{ij}^{\rm max}$ / $(\rm m^3\ s^{-1})$")
figure.savefig("figs/" + prefix + "_kernel_max.pdf")
(figure, axes, cbar_axes) = mpl_helper.make_fig(axis_ratio=1,
colorbar=True,
right_margin=1.2)
p = axes.pcolor(diam_edges, diam_edges, k_ratio, linewidths=0.1)
axes.set_xscale("log")
axes.set_yscale("log")
axes.set_xlim(min(diam_edges), max(diam_edges))
axes.set_ylim(min(diam_edges), max(diam_edges))
axes.set_xlabel(r"diameter $D_1$ / $\rm \mu m$")
axes.set_ylabel(r"diameter $D_2$ / $\rm \mu m$")
cbar = figure.colorbar(p, cax=cbar_axes, orientation='vertical')
cbar_axes.xaxis.set_label_position('top')
cbar.set_label(r"kernel ratio $K_{ij}^{\rm max} / K_{ij}^{\rm min}$")
figure.savefig("figs/" + prefix + "_kernel_ratio.pdf")
(figure, axes) = mpl_helper.make_fig()
axes.loglog(n_parts_x, n_parts_y)
axes.set_xlim(min(diam_edges_nonzero), max(diam_edges_nonzero))
axes.set_ylim(bottom=1e-1)
axes.set_xlabel(r"diameter / $\rm \mu m$")
axes.set_ylabel(r"number of particles")
figure.savefig("figs/" + prefix + "_count_nonzero.pdf")
(figure, axes, cbar_axes) = mpl_helper.make_fig(axis_ratio=1,
colorbar=True,
right_margin=1.2)
p = axes.pcolor(diam_edges_nonzero,
diam_edges_nonzero,
n_possible_nonzero,
norm=matplotlib.colors.LogNorm(),
linewidths=0.1)
axes.set_xscale("log")
axes.set_yscale("log")
axes.set_xlim(min(diam_edges_nonzero), max(diam_edges_nonzero))
axes.set_ylim(min(diam_edges_nonzero), max(diam_edges_nonzero))
axes.set_xlabel(r"diameter $D_1$ / $\rm \mu m$")
axes.set_ylabel(r"diameter $D_2$ / $\rm \mu m$")
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 of reaction pairs $n_i(n_j - \delta_{ij})$")
figure.savefig("figs/" + prefix + "_n_possible_nonzero.pdf")
(figure, axes, cbar_axes) = mpl_helper.make_fig(axis_ratio=1,
colorbar=True,
right_margin=1.2)
p = axes.pcolor(diam_edges_nonzero,
diam_edges_nonzero,
r_samp_nonzero,
norm=matplotlib.colors.LogNorm(),
linewidths=0.1)
axes.set_xscale("log")
axes.set_yscale("log")
axes.set_xlim(min(diam_edges_nonzero), max(diam_edges_nonzero))
axes.set_ylim(min(diam_edges_nonzero), max(diam_edges_nonzero))
axes.set_xlabel(r"diameter $D_1$ / $\rm \mu m$")
axes.set_ylabel(r"diameter $D_2$ / $\rm \mu m$")
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 of samples per pair $K_{ij} \Delta t / V_{\rm comp}$")
figure.savefig("figs/" + prefix + "_r_samp_nonzero.pdf")
(figure, axes, cbar_axes) = mpl_helper.make_fig(axis_ratio=1,
colorbar=True,
right_margin=1.2)
p = axes.pcolor(diam_edges_nonzero,
diam_edges_nonzero,
r_samp_rate_nonzero,
norm=matplotlib.colors.LogNorm(),
linewidths=0.1)
axes.set_xscale("log")
axes.set_yscale("log")
axes.set_xlim(min(diam_edges_nonzero), max(diam_edges_nonzero))
axes.set_ylim(min(diam_edges_nonzero), max(diam_edges_nonzero))
axes.set_xlabel(r"diameter $D_1$ / $\rm \mu m$")
axes.set_ylabel(r"diameter $D_2$ / $\rm \mu m$")
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 of samples per pair rate $K_{ij} / V_{\rm comp}$")
figure.savefig("figs/" + prefix + "_r_samp_rate_nonzero.pdf")
(figure, axes, cbar_axes) = mpl_helper.make_fig(axis_ratio=1,
colorbar=True,
right_margin=1.2)
p = axes.pcolor(diam_edges_nonzero,
diam_edges_nonzero,
n_samp_mean_nonzero,
norm=matplotlib.colors.LogNorm(),
linewidths=0.1)
axes.set_xscale("log")
axes.set_yscale("log")
axes.set_xlim(min(diam_edges_nonzero), max(diam_edges_nonzero))
axes.set_ylim(min(diam_edges_nonzero), max(diam_edges_nonzero))
axes.set_xlabel(r"diameter $D_1$ / $\rm \mu m$")
axes.set_ylabel(r"diameter $D_2$ / $\rm \mu m$")
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 of events $(K_{ij} \Delta t / V) n_i(n_j - \delta_{ij})$")
figure.savefig("figs/" + prefix + "_n_samp_mean_nonzero.pdf")
(figure, axes, cbar_axes) = mpl_helper.make_fig(axis_ratio=1,
colorbar=True,
right_margin=1.2)
p = axes.pcolor(diam_edges_nonzero,
diam_edges_nonzero,
n_samp_mean_rate_nonzero,
norm=matplotlib.colors.LogNorm(),
linewidths=0.1)
axes.set_xscale("log")
axes.set_yscale("log")
axes.set_xlim(min(diam_edges_nonzero), max(diam_edges_nonzero))
axes.set_ylim(min(diam_edges_nonzero), max(diam_edges_nonzero))
axes.set_xlabel(r"diameter $D_1$ / $\rm \mu m$")
axes.set_ylabel(r"diameter $D_2$ / $\rm \mu m$")
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 of events rate $(K_{ij} / V) n_i(n_j - \delta_{ij})$")
figure.savefig("figs/" + prefix + "_n_samp_mean_rate_nonzero.pdf")
(figure, axes, cbar_axes) = mpl_helper.make_fig(axis_ratio=1,
colorbar=True,
right_margin=1.2)
p = axes.pcolor(diam_edges_nonzero,
diam_edges_nonzero,
k_max_nonzero,
norm=matplotlib.colors.LogNorm(),
linewidths=0.1)
axes.set_xscale("log")
axes.set_yscale("log")
axes.set_xlim(min(diam_edges_nonzero), max(diam_edges_nonzero))
axes.set_ylim(min(diam_edges_nonzero), max(diam_edges_nonzero))
axes.set_xlabel(r"diameter $D_1$ / $\rm \mu m$")
axes.set_ylabel(r"diameter $D_2$ / $\rm \mu m$")
cbar = figure.colorbar(p,
cax=cbar_axes,
format=matplotlib.ticker.LogFormatterMathtext(),
orientation='vertical')
cbar_axes.xaxis.set_label_position('top')
cbar.set_label(r"kernel $K_{ij}^{\rm max}$ / $(\rm m^3\ s^{-1})$")
figure.savefig("figs/" + prefix + "_kernel_max_nonzero.pdf")
(figure, axes, cbar_axes) = mpl_helper.make_fig(axis_ratio=1,
colorbar=True,
right_margin=1.2)
p = axes.pcolor(diam_edges_nonzero,
diam_edges_nonzero,
k_ratio_nonzero,
linewidths=0.1)
axes.set_xscale("log")
axes.set_yscale("log")
axes.set_xlim(min(diam_edges_nonzero), max(diam_edges_nonzero))
axes.set_ylim(min(diam_edges_nonzero), max(diam_edges_nonzero))
axes.set_xlabel(r"diameter $D_1$ / $\rm \mu m$")
axes.set_ylabel(r"diameter $D_2$ / $\rm \mu m$")
cbar = figure.colorbar(p, cax=cbar_axes, orientation='vertical')
cbar_axes.xaxis.set_label_position('top')
cbar.set_label(r"kernel ratio $K_{ij}^{\rm max} / K_{ij}^{\rm min}$")
figure.savefig("figs/" + prefix + "_kernel_ratio_nonzero.pdf")
sys.path.append("../../tool")
import mpl_helper
import matplotlib
matplotlib.use("PDF")
import matplotlib.pyplot as plt
import partmc
size_dist_array = np.loadtxt("data/banana_size_dist_wc_wei-1_lowbg2.txt")
times = np.loadtxt("data/banana_times_wc_wei-1_lowbg2.txt")
diam = np.loadtxt("data/banana_diam_wc_wei-1_lowbg2.txt")
mask = np.ma.make_mask(size_dist_array <= 0.0)
size_dist_array = np.ma.array(size_dist_array, mask = mask)
times = times / 3600.
(fig, axis) = mpl_helper.make_fig(figure_width = 4)
plt.pcolor(times, diam, size_dist_array.transpose(),norm = matplotlib.colors.LogNorm(vmin=1e1, vmax=1e6), linewidths = 0.1)
a = plt.gca()
a.set_xscale("linear")
a.set_yscale("log")
plt.axis([times.min(), times.max(), 1e-3, diam.max()])
plt.xlabel("time / h")
plt.ylabel(r"dry diameter / $\rm \mu m$")
plt.grid(True)
cbar = plt.colorbar(format=matplotlib.ticker.LogFormatterMathtext())
cbar.set_label(r"number concentration / $\rm cm^{-3}$")
fig = plt.gcf()
fig.savefig("figs/banana_wc_wei-1_lowbg2.pdf")