def process_irrad_calibration(folder, path_to, calibration_image_size_px,
calibration_image_size_um, camera_px_length,
window, deg, repetitions, mode, factor,
meas_pow_bfp, start_notch, end_notch,
start_power, end_power, start_spr, lower_londa,
upper_londa, exp_time_fast, w0):
# plot limits
y_min_spec_cal = 8000
y_max_spec_cal = 238000
NP = folder.split('Spectrum_')[-1]
save_folder = os.path.join(path_to, NP)
common_path = os.path.join(path_to, 'common_plots')
if not os.path.exists(save_folder):
os.makedirs(save_folder)
list_of_files = os.listdir(folder)
wavelength_filename = [
f for f in list_of_files if re.search('wavelength', f)
]
list_of_files.sort()
list_of_files = [f for f in list_of_files if not os.path.isdir(folder + f)]
list_of_files = [f for f in list_of_files if ((not os.path.isdir(folder+f)) \
and (re.search('_i\d\d\d\d_j\d\d\d\d.txt',f)))]
L = len(list_of_files)
data_spectrum = []
name_spectrum = []
specs = []
print(L, 'calibration spectra were acquired.')
for k in range(L):
name = os.path.join(folder, list_of_files[k])
data_spectrum = np.loadtxt(name)
name_spectrum.append(list_of_files[k])
specs.append(data_spectrum)
wavelength_filepath = os.path.join(folder, wavelength_filename[0])
londa = np.loadtxt(wavelength_filepath)
start_notch = closer(londa, start_notch)
end_notch = closer(londa, end_notch)
start_power = closer(londa, start_power)
end_power = closer(londa, end_power)
lower_londa_index = closer(londa, lower_londa)
upper_londa_index = closer(londa, upper_londa)
# ALLOCATING
line_spec_raw = np.zeros((calibration_image_size_px, camera_px_length))
line_spec_smooth = np.zeros((calibration_image_size_px, camera_px_length))
line_spec = np.zeros((calibration_image_size_px, camera_px_length))
for i in range(calibration_image_size_px):
line_spec_raw[i, :] = np.array(specs[i])
del specs
######################## SMOOTH ############################
######################## SMOOTH ############################
######################## SMOOTH ############################
# SPLIT SIGNALS INTO STOKES AND ANTI-STOKES, longer range for smoothing
line_stokes_raw = line_spec_raw[:, end_notch:]
londa_stokes = londa[end_notch:]
line_antistokes_raw = line_spec_raw[:, :start_notch]
londa_antistokes = londa[:start_notch]
# SMOOTHING
print('Smoothing signals...')
aux_line_stokes_smooth = sig.savgol_filter(line_stokes_raw,
window,
deg,
axis=1,
mode=mode)
aux_line_antistokes_smooth = sig.savgol_filter(line_antistokes_raw,
window,
deg,
axis=1,
mode=mode)
for i in range(repetitions - 1):
aux_line_stokes_smooth = sig.savgol_filter(aux_line_stokes_smooth,
window,
deg,
axis=1,
mode=mode)
aux_line_antistokes_smooth = sig.savgol_filter(
aux_line_antistokes_smooth, window, deg, axis=1, mode=mode)
# Merge
line_stokes_smooth = aux_line_stokes_smooth
line_antistokes_smooth = aux_line_antistokes_smooth
line_spec_smooth[:, end_notch:] = line_stokes_smooth
line_spec_smooth[:, :start_notch] = line_antistokes_smooth
print('Saving single plots of the calibration spectra as measured...')
for i in range(calibration_image_size_px):
plt.figure()
pixel_name = 'i%02d_j00' % (i)
plt.plot(londa,
line_spec_raw[i, :],
color='C0',
linestyle='-',
label='As measured')
plt.plot(londa_stokes,
line_stokes_smooth[i, :],
color='k',
linestyle='-',
label='Smoothed')
plt.plot(londa_antistokes,
line_antistokes_smooth[i, :],
color='k',
linestyle='-')
plt.legend()
ax = plt.gca()
ax.set_xlabel(r'Wavelength (nm)')
ax.set_ylabel('Intensity (a.u.)')
ax.axvline(londa[lower_londa_index],
ymin=0,
ymax=1,
color='k',
linestyle='--')
ax.axvline(londa[upper_londa_index],
ymin=0,
ymax=1,
color='k',
linestyle='--')
ax.axvline(londa[start_notch],
ymin=0,
ymax=1,
color='k',
linestyle='--')
ax.axvline(londa[end_notch], ymin=0, ymax=1, color='k', linestyle='--')
ax.axvline(londa[start_power],
ymin=0,
ymax=1,
color='k',
linestyle='--')
ax.axvline(londa[end_power], ymin=0, ymax=1, color='k', linestyle='--')
aux_folder = manage_save_directory(save_folder,
'calibration_spectra_as_measured')
figure_name = os.path.join(
aux_folder, 'calibration_spec_%s_%s.png' % (pixel_name, NP))
ax.set_ylim([y_min_spec_cal, y_max_spec_cal])
plt.savefig(figure_name)
plt.close()
######################## KILL NOTCH RANGE ############################
######################## KILL NOTCH RANGE ############################
######################## KILL NOTCH RANGE ############################
line_spec_smooth[:, start_notch:end_notch] = np.nan
######################## FIND BKG AND MAX ############################
######################## FIND BKG AND MAX ############################
######################## FIND BKG AND MAX ############################
# LOOK FOR MAX AND MIN IN STOKES RANGE
line_stokes_smooth = line_spec_smooth[:, start_power:end_power]
aux_sum = np.sum(line_stokes_smooth, axis=1)
print('Finding max and bkg (min) spectra of the calibration...')
imin = np.argmin(aux_sum)
bkg_smooth = line_spec_smooth[imin, :]
bkg_raw = line_spec_raw[imin, :]
noise_rms = np.sqrt(np.nansum(bkg_raw**2) / len(bkg_raw))
imax = np.argmax(aux_sum)
max_smooth = line_spec_smooth[imax, :]
max_raw = line_spec_raw[imax, :]
signal_rms = np.sqrt(np.nansum(max_smooth**2) / len(max_smooth))
signal_to_background_ratio = (signal_rms / noise_rms)**2
print('Signal RMS (max) to bkg RMS (min) ratio:',
signal_to_background_ratio)
# BACKGROUND SPECTRUM
plt.figure()
plt.plot(londa, bkg_raw)
plt.plot(londa, bkg_smooth, '-k')
ax = plt.gca()
ax.set_xlabel(r'Wavelength (nm)')
ax.set_ylabel('Intensity (a.u.)')
ax.set_ylim([y_min_spec_cal, y_max_spec_cal])
ax.axvline(londa[start_notch], ymin=0, ymax=1, color='k', linestyle='--')
ax.axvline(londa[end_notch], ymin=0, ymax=1, color='k', linestyle='--')
ax.axvline(londa[start_power], ymin=0, ymax=1, color='k', linestyle='--')
ax.axvline(londa[end_power], ymin=0, ymax=1, color='k', linestyle='--')
figure_name = os.path.join(save_folder, 'calibration_bkg_%s.png' % NP)
plt.savefig(figure_name)
aux_folder = manage_save_directory(common_path, 'calibration/bkg')
figure_name = os.path.join(aux_folder, 'calibration_bkg_%s.png' % NP)
plt.savefig(figure_name)
plt.close()
# MAX SPECTRUM
plt.figure()
plt.plot(londa, (max_raw - y_min_spec_cal) / 10000, label='Raw')
plt.plot(londa, (max_smooth - y_min_spec_cal) / 10000,
'-k',
label='Smooth')
ax = plt.gca()
ax.legend(loc='upper left', prop={'size': 13})
ax.set_xlabel(r'Wavelength (nm)', fontsize=20)
ax.set_ylabel('Photoluminescence (a.u.)', fontsize=20)
ax.tick_params(axis='both', which='major', labelsize=18)
# ax.set_ylim([y_min_spec_cal, y_max_spec_cal])
ax.set_ylim([0, (y_max_spec_cal - y_min_spec_cal) / 10000])
ax.text(582, 16, 'G', fontsize=16)
# ax.axvline(londa[start_notch], ymin = 0, ymax = 1, color='k', linestyle='--')
# ax.axvline(londa[end_notch], ymin = 0, ymax = 1, color='k', linestyle='--')
# ax.axvline(londa[start_power], ymin = 0, ymax = 1, color='k', linestyle='--')
# ax.axvline(londa[end_power], ymin = 0, ymax = 1, color='k', linestyle='--')
figure_name = os.path.join(save_folder, 'calibration_max_%s.png' % NP)
plt.savefig(figure_name)
aux_folder = manage_save_directory(common_path, 'calibration/max')
figure_name = os.path.join(aux_folder, 'calibration_max_%s.png' % NP)
plt.savefig(figure_name, dpi=300, bbox_plot='tight')
figure_name = os.path.join(aux_folder, 'calibration_max_%s.pdf' % NP)
plt.savefig(figure_name, dpi=300, bbox_plot='tight', format='pdf')
plt.close()
# BACKGROUND SUBSTRACTION
line_spec = line_spec_smooth - bkg_smooth
######################## DETERMINE COUNTS PER IRRADIANCE ############################
######################## DETERMINE COUNTS PER IRRADIANCE ############################
######################## DETERMINE COUNTS PER IRRADIANCE ############################
print('Calculating counts per unit of time...')
aux_sum_stokes_smooth_corrected = np.sum(line_spec[:,
start_power:end_power],
axis=1)
integrated_cts = np.max(aux_sum_stokes_smooth_corrected)
integrated_cts_per_sec = integrated_cts / exp_time_fast
print('Stokes-integrated signal (bkg corrected): %.0f +/- %.0f cts/s' %
(integrated_cts_per_sec, np.sqrt(integrated_cts_per_sec)))
meas_pow_sample = factor * meas_pow_bfp
err_meas_pow_sample = instrumental_err * meas_pow_sample
irrad_calc = 2 * meas_pow_sample / (np.pi * w0**2)
err_irrad_calc = np.sqrt((2 / (np.pi * w0**2) * err_meas_pow_sample)**2 +
(4 * meas_pow_sample * err_w0 /
(np.pi * w0**3))**2)
print('Irradiance max (calc): %.2f +/- %.2f mW/um2\n' %
(irrad_calc, err_irrad_calc))
#################### SAVE DATA ############################
#################### SAVE DATA ############################
#################### SAVE DATA ############################
print('Saving calibration data...')
aux_folder = manage_save_directory(save_folder, 'calibration')
to_save = [integrated_cts_per_sec, irrad_calc, err_irrad_calc]
path_to_save = os.path.join(aux_folder, 'integrated_counts_%s.dat' % NP)
np.savetxt(path_to_save, to_save, fmt='%.6e')
aux_folder = manage_save_directory(save_folder, 'calibration')
to_save = bkg_smooth
path_to_save = os.path.join(aux_folder, 'calibration_bkg_%s.dat' % NP)
np.savetxt(path_to_save, to_save, fmt='%.6e')
aux_folder = manage_save_directory(save_folder, 'calibration')
to_save = max_smooth
path_to_save = os.path.join(aux_folder, 'calibration_max_%s.dat' % NP)
np.savetxt(path_to_save, to_save, fmt='%.6e')
return
def gather_data(path_from, R2th, totalbins, monitor):
#################### SLOPE STATISTICS ############################
#################### SLOPE STATISTICS ############################
#################### SLOPE STATISTICS ############################
list_of_folders = os.listdir(path_from)
list_of_folders = [
f for f in list_of_folders if os.path.isdir(os.path.join(path_from, f))
]
list_of_folders = [f for f in list_of_folders if re.search('NP', f)]
list_of_folders.sort()
L = len(list_of_folders)
list_of_mean_beta = np.zeros((L))
list_of_mean_beta_err = np.zeros((L))
list_of_std_beta = np.zeros((L))
list_of_data_points = np.zeros((L))
list_of_mean_Tzero = np.zeros((L))
list_of_mean_Tzero_err = np.zeros((L))
list_of_std_Tzero = np.zeros((L))
list_of_londa_max = np.zeros((L))
list_of_width_pl = np.zeros((L))
list_of_r_sq_spr = np.zeros((L))
list_of_col = np.zeros((L))
list_of_nps = np.zeros((L))
list_of_avg_monitor = np.zeros((L))
list_of_std_monitor = np.zeros((L))
list_of_beta_good_array = []
list_of_beta_good_dict = {}
list_of_beta_good_err_dict = {}
list_of_Tzero_good_array = []
list_of_Tzero_good_dict = {}
list_of_Tzero_good_err_dict = {}
for i in range(L):
NP = list_of_folders[i]
list_of_col[i] = int(NP.split('_')[1])
list_of_nps[i] = int(NP.split('_')[3])
############################################ import beta
beta_folder = os.path.join(path_from, NP, 'matrix', 'beta_matrix')
filename = 'beta_R2th_%s_%s.dat' % (str(R2th), NP)
beta_filepath = os.path.join(beta_folder, filename)
data = np.loadtxt(beta_filepath, skiprows=1)
list_of_mean_beta[i] = data[0]
list_of_mean_beta_err[i] = data[1]
list_of_std_beta[i] = data[2]
list_of_data_points[i] = data[3]
list_of_mean_Tzero[i] = data[4]
list_of_mean_Tzero_err[i] = data[5]
list_of_std_Tzero[i] = data[6]
######################################## prepare for hist of all beta_matrix_good
filename = 'beta_good_array_%s.dat' % (NP)
beta_good_array_filepath = os.path.join(beta_folder, filename)
data = np.loadtxt(beta_good_array_filepath)
list_of_beta_good_array.append(data)
key = 'col_%02d_np_%02d' % (list_of_col[i], list_of_nps[i])
list_of_beta_good_dict[key] = data
filename = 'beta_good_err_array_%s.dat' % (NP)
beta_good_err_array_filepath = os.path.join(beta_folder, filename)
data = np.loadtxt(beta_good_err_array_filepath)
key = 'col_%02d_np_%02d' % (list_of_col[i], list_of_nps[i])
list_of_beta_good_err_dict[key] = data
############################################ import beta
Tzero_folder = os.path.join(path_from, NP, 'matrix', 'Tzero_matrix')
######################################## prepare for hist of all Tzero_matrix_good
filename = 'Tzero_good_array_%s.dat' % (NP)
Tzero_good_array_filepath = os.path.join(Tzero_folder, filename)
data = np.loadtxt(Tzero_good_array_filepath)
list_of_Tzero_good_array.append(data)
key = 'col_%02d_np_%02d' % (list_of_col[i], list_of_nps[i])
list_of_Tzero_good_dict[key] = data
filename = 'Tzero_good_err_array_%s.dat' % (NP)
Tzero_good_err_array_filepath = os.path.join(Tzero_folder, filename)
data = np.loadtxt(Tzero_good_err_array_filepath)
key = 'col_%02d_np_%02d' % (list_of_col[i], list_of_nps[i])
list_of_Tzero_good_err_dict[key] = data
############################################ import spr data
spr_folder = os.path.join(path_from, NP, 'spr')
filename = 'spr_fitted_parameters_%s.dat' % NP
spr_filepath = os.path.join(spr_folder, filename)
data = np.loadtxt(spr_filepath)
list_of_londa_max[i] = data[0]
list_of_width_pl[i] = data[1]
list_of_r_sq_spr[i] = data[2]
############################################ import power monitor data
if monitor:
monitor_folder = os.path.join(path_from, NP, 'power_monitor')
filename = 'power_monitor_%s.dat' % NP
monitor_filepath = os.path.join(monitor_folder, filename)
data = np.loadtxt(monitor_filepath)
list_of_avg_monitor[i] = data[0]
list_of_std_monitor[i] = data[1]
########## PLOT
########## PLOT
########## PLOT
plt.figure()
nbins = 20
range_tuple = [20, 120]
# print(list_of_beta_good_array)
plt.hist(list_of_beta_good_array, bins=nbins, range=range_tuple, rwidth = 1, \
align='mid', alpha = 1, edgecolor='k', normed = False,
histtype = 'barstacked', stacked=True)
plt.legend(loc=1, handlelength=0)
ax = plt.gca()
# ax.axvline(mu_slope, ymin = 0, ymax = 1, color='k', linestyle='--', linewidth=2)
# ax.fill_between([borders_slope[0], borders_slope[1]], [0,0], [100,100], facecolor='k', alpha=0.25)
ax.get_yaxis().set_ticks([])
ax.set_ylim([0, 200])
ax.set_xlim(range_tuple)
ax.set_xlabel(u'Photothermal coefficient (K µm$^{2}$/mW)')
ax.set_ylabel('Entries')
aux_folder = manage_save_directory(path_from, 'stats')
figure_name = os.path.join(aux_folder,'hist_of_all_betas_R2th_%s_%s_bines.png' % \
(str(R2th), str(totalbins)))
plt.savefig(figure_name)
plt.close()
plt.figure()
nbins = 20
range_tuple = [250, 350]
# print(list_of_beta_good_array)
plt.hist(list_of_Tzero_good_array, bins=nbins, range=range_tuple, rwidth = 1, \
align='mid', alpha = 1, edgecolor='k', normed = False,
histtype = 'barstacked', stacked=True)
plt.legend(loc=1, handlelength=0)
ax = plt.gca()
# ax.axvline(mu_slope, ymin = 0, ymax = 1, color='k', linestyle='--', linewidth=2)
# ax.fill_between([borders_slope[0], borders_slope[1]], [0,0], [100,100], facecolor='k', alpha=0.25)
ax.get_yaxis().set_ticks([])
ax.set_ylim([0, 200])
ax.set_xlim(range_tuple)
ax.set_xlabel(u'T$_{0}$ (K)')
ax.set_ylabel('Entries')
aux_folder = manage_save_directory(path_from, 'stats')
figure_name = os.path.join(aux_folder,'hist_of_all_Tzero_R2th_%s_%s_bines.png' % \
(str(R2th), str(totalbins)))
plt.savefig(figure_name)
plt.close()
#################### SAVE DATA ############################
#################### SAVE DATA ############################
#################### SAVE DATA ############################
aux_folder = manage_save_directory(path_from, 'stats')
to_save = np.array([
list_of_mean_beta, list_of_mean_beta_err, list_of_std_beta,
list_of_data_points, list_of_mean_Tzero, list_of_mean_Tzero_err,
list_of_std_Tzero, list_of_londa_max, list_of_width_pl,
list_of_r_sq_spr, list_of_avg_monitor, list_of_std_monitor,
list_of_col, list_of_nps
]).T
header_text = 'BETA_mW_um2_K ERR_BETA_mW_um2_K STD_BETA_mW_um2_K DATA_POINTS TZERO_K ERR_TZERO_K STD_TZERO_K LAMBDA_MAX_nm WIDTH_nm SPR_R_SQ MONITOR_AVG MONITOR_STD COL NP'
path_to_save = os.path.join(aux_folder, 'all_NP_data.dat')
np.savetxt(path_to_save,
to_save,
fmt='%.3e',
header=header_text,
comments='')
path_to_save = os.path.join(aux_folder, 'all_beta_good_data.pkl')
f = open(path_to_save, 'wb+')
pickle.dump(list_of_beta_good_dict, f)
f.close()
path_to_save = os.path.join(aux_folder, 'all_beta_good_err_data.pkl')
f = open(path_to_save, 'wb+')
pickle.dump(list_of_beta_good_err_dict, f)
f.close()
path_to_save = os.path.join(aux_folder, 'all_Tzero_good_data.pkl')
f = open(path_to_save, 'wb+')
pickle.dump(list_of_Tzero_good_dict, f)
f.close()
path_to_save = os.path.join(aux_folder, 'all_Tzero_good_err_data.pkl')
f = open(path_to_save, 'wb+')
pickle.dump(list_of_Tzero_good_err_dict, f)
f.close()
return
def calculate_quotient(folder, path_to, totalbins, lower_londa,
upper_londa, Tzero_guess, beta_guess,
last_bin_is_bkg_flag, find_beta, find_Tzero):
thermometry_using_scattering = True
NP = folder.split('Spectrum_')[-1]
common_path = os.path.join(path_to,'common_plots')
save_folder = os.path.join(path_to, NP)
bin_folder = os.path.join(save_folder, 'pl_in_bins')
londa_file = os.path.join(bin_folder,'londa_%s.dat' % NP)
londa = np.loadtxt(londa_file)
lower_londa_index = closer(londa, lower_londa)
upper_londa_index = closer(londa, upper_londa)
energy = lambda_to_energy(londa)
a = lower_londa_index
b = upper_londa_index
dof = b - a + 1 - 1 # número de datos (ver ajuste con energía) MENOS los parámetros del ajuste
frozen_distro = scipy.stats.chi2(dof)
bin_specs_file = os.path.join(bin_folder,'all_bins_%s.dat' % NP)
bin_specs = np.loadtxt(bin_specs_file)
bin_specs = bin_specs.T
corrected_mean_irrad_file = os.path.join(bin_folder,'bin_irradiance_%s.dat' % NP)
irrad = np.loadtxt(corrected_mean_irrad_file)
Irrad_array = irrad[:,0]
err_Irrad_array = irrad[:,1]
bin_distro_file = os.path.join(bin_folder,'bin_distro_%s.dat' % NP)
bin_data = np.loadtxt(bin_distro_file)
hist_bin = bin_data[:,2]
R2_matrix = np.zeros([totalbins, totalbins])
chi_squared_matrix = np.zeros([totalbins, totalbins])
p_value_matrix = np.zeros([totalbins, totalbins])
beta_matrix = np.zeros([totalbins, totalbins])
err_beta_matrix = np.zeros([totalbins, totalbins])
Tzero_matrix = np.zeros([totalbins, totalbins])
err_Tzero_matrix = np.zeros([totalbins, totalbins])
T_matrix = np.zeros([totalbins, totalbins])
err_T_matrix = np.zeros([totalbins, totalbins])
if last_bin_is_bkg_flag:
print('Last bin is considered a bkg correction, quotients calculated from bin 1.')
list_of_bins = list(range(1, totalbins))
else:
print('Last bin is NOT a bkg correction, quotients calculated from bin 0.')
list_of_bins = list(range(0, totalbins))
xdata_energy = energy[a:b]
xdata_londa = londa[a:b]
len_data = len(xdata_energy)
print('Allocating, calculating and plotting quotients')
# allocate arrays for experimental data
bin_A_array = np.zeros((totalbins, totalbins))
err_bin_A_array = np.zeros((totalbins, totalbins))
ydata_all = np.zeros((totalbins, totalbins, len_data))
for ref in list_of_bins:
if hist_bin[ref] == 0:
print('\nBin %d is empty.' % ref)
print('Skipping bin as reference.')
continue
# define reference irradiance
Irrad_ref = Irrad_array[ref]
err_Irrad_ref = err_Irrad_array[ref]
# define quotients of irradiance
for i in list_of_bins:
A = Irrad_array[i]/Irrad_ref
bin_A_array[i, ref] = A
err_bin_A_array[i, ref] = np.sqrt( (err_Irrad_array[i]/Irrad_ref)**2 + \
(err_Irrad_ref*Irrad_array[i]/(Irrad_ref**2))**2)
# load experimental data
quotient_exp = bin_specs[i][a:b]/bin_specs[ref][a:b]
ydata_all[i,ref,:] = quotient_exp
if thermometry_using_scattering:
print('\n Warning: Finding beta (also) using scattering spectrum!')
# load scattering spectrum
filepath_scattering_80 = '/home/mariano/datos_mariano/posdoc/experimentos_PL_arg/20190717_espectros_scattering_PL/grilla3_AuNPs_80SS/figures/averaged_scattering_spectra_80nm_glass_water.dat'
data = np.loadtxt(filepath_scattering_80)
londa_sca = data[:,0]
spec_sca = data[:,1]
energy_sca = lambda_to_energy(londa_sca)
# Interpolate
# note that inversion of arrays is needed to interpolate correctly
new_sca_spectrum = np.interp(xdata_energy, energy_sca[::-1], spec_sca[::-1])
# CHECK
plt.figure()
plt.plot(energy_sca, spec_sca,'C0-')
plt.plot(xdata_energy, new_sca_spectrum,'k-', linewidth=4, alpha=0.4)
ax = plt.gca()
ax.set_xlabel('Energy (eV)', fontsize=20)
ax.set_ylabel('Normalized scattering (a.u.)', fontsize=20)
ax.set_xlim([1.71, 2.59])
ax.set_ylim([0, 1.025])
plt.tick_params(axis='both', which='major', labelsize=18)
aux_folder = manage_save_directory(common_path,'antistokes_sca_and_pl')
figure_name = os.path.join(aux_folder,'sca_interpolation_%s.png' % (NP))
plt.savefig(figure_name, dpi = 300)
figure_name = os.path.join(aux_folder,'sca_interpolation_%s.pdf' % (NP))
plt.savefig(figure_name, dpi = 300, format='pdf')
plt.close()
x_long = np.arange(2.37, 2.47, 0.01)
rango = list(range(0, totalbins + 1))
norm = plt.Normalize()
colormap = plt.cm.plasma(norm(rango))
temp_array_with_sca = np.zeros((totalbins))
temp_array_with_sca[0] = Tzero_guess
err_temp_array_with_sca = np.zeros((totalbins))
err_temp_array_with_sca[0] = 1
plt.figure()
# plt.plot(xdata_energy, log_bose(xdata_energy, 1, 300),'r-')
# plt.plot(xdata_energy, new_sca_spectrum,'.-')
for i in list_of_bins:
if hist_bin[i] == 0:
print('\nBin %d is empty.' % i)
print('Skipping bin.')
continue
# find temp or beta
cte = 1
y = cte*bin_specs[i][a:b]/new_sca_spectrum
log_y = np.log10(y)
init_params = [1, Tzero_guess]
best_as, err = fit_log_bose(init_params, xdata_energy, log_y)
temp_array_with_sca[i] = best_as[1]
err_temp_array_with_sca[i] = np.sqrt(err[1,1])
fitted_log_y = 10**(log_bose(x_long, best_as[0], best_as[1]))/1000
plt.plot(x_long, fitted_log_y, 'k--')
color_iter = colormap[i]
plt.plot(xdata_energy, 10**(log_y)/1000, '-', linewidth = 2.0,
color = color_iter,
label='%d, T=%.0f K' % (i, best_as[1]))
plt.grid(True)
plt.legend(loc='upper right', prop={'size':12})
ax = plt.gca()
# ax.set_xlim([energy[b],energy[a]])
# ax.set_xlim([0.99*energy[b],1.01*energy[a]])
ax.set_xlim(2.37, 2.445)
# ax.axvline(energy[a], ymin=0, ymax=1, linestyle='--', color='k')
# ax.axvline(energy[b], ymin=0, ymax=1, linestyle='--', color='k')
ax.set_ylim([0.1, 20])
ax.set_xlabel('Energy (eV)', fontsize=20)
ax.set_ylabel('AS/scattering (a.u.)', fontsize=20)
plt.tick_params(axis='both', which='major', labelsize=18)
aux_folder = manage_save_directory(common_path,'antistokes_sca_and_pl')
figure_name = os.path.join(aux_folder,'pl_and_sca_comparison_%s.png' % (NP))
plt.savefig(figure_name, dpi = 300)
figure_name = os.path.join(aux_folder,'pl_and_sca_comparison_%s.pdf' % (NP))
plt.savefig(figure_name, dpi = 300, format='pdf')
plt.close()
# plot temp vs irrad
plt.figure()
plt.errorbar(Irrad_array, temp_array_with_sca,
xerr = err_Irrad_array,
yerr = err_temp_array_with_sca,
fmt = 'o', color = 'C0',
ms = 7, mfc = 'C0', ecolor = 'C0', lw = 1, capsize = 2.5,
barsabove = False)
plt.grid(True)
plt.legend(loc='upper right', prop={'size':12})
ax = plt.gca()
ax.set_xlim([-0.05, 1.75])
ax.set_ylim([285, 1125])
ax.set_xlabel(u'Irradiance (mW/µm$^{2}$)', fontsize=20)
ax.set_ylabel('Temperature (K)', fontsize=20)
plt.tick_params(axis='both', which='major', labelsize=18)
aux_folder = manage_save_directory(common_path,'antistokes_sca_and_pl')
figure_name = os.path.join(aux_folder,'temp_vs_irrad_%s.png' % (NP))
plt.savefig(figure_name, dpi = 300)
figure_name = os.path.join(aux_folder,'temp_vs_irrad_%s.pdf' % (NP))
plt.savefig(figure_name, dpi = 300, format='pdf')
plt.close()
##################### ANTI-STOKES vs LAMBDA ######################
##################### ANTI-STOKES vs LAMBDA ######################
##################### ANTI-STOKES vs LAMBDA ######################
for ref in list_of_bins:
plt.figure()
for i in list_of_bins:
plt.plot(xdata_londa, ydata_all[i,ref,:], '-', label='Bin %d/%d - A %.2f' % (i, ref, bin_A_array[i, ref]))
plt.grid(True)
plt.legend(loc='best')
ax = plt.gca()
ax.set_xlabel(r'Wavelength (nm)')
ax.set_ylabel('$Q^{AS}$')
ax.set_xlim([0.99*londa[a],1.01*londa[b]])
ax.axvline(londa[a], ymin=0, ymax=1, linestyle='--', color='k')
ax.axvline(londa[b], ymin=0, ymax=1, linestyle='--', color='k')
aux_folder = manage_save_directory(save_folder,'antistokes_quotient')
figure_name = os.path.join(aux_folder,'quotient_vs_lambda_ref_%02d_%s.png' % (ref, NP))
plt.savefig(figure_name)
plt.close()
##################### ANTI-STOKES FIT ######################
##################### ANTI-STOKES FIT ######################
##################### ANTI-STOKES FIT ######################
x = energy[a:b]
x_long = np.arange(2.37, 2.47, 0.01)
rango = list(range(0, totalbins + 1))
norm = plt.Normalize()
colormap = plt.cm.plasma(norm(rango))
for ref in list_of_bins:
print('\nFitting quotient Q using bin %d as reference...' % ref)
plt.figure()
list_of_bins_to_fit = list(range(ref + 1 + skip_neighbours, totalbins))
for i in list_of_bins_to_fit:
# m = ref
Irrad_n = Irrad_array[i]
Irrad_m = Irrad_array[ref]
err_Irrad_n = err_Irrad_array[i]
err_Irrad_m = err_Irrad_array[ref]
y = ydata_all[i, ref, :]
if find_beta and not find_Tzero:
print('\nTzero is known. Finding beta...')
Tzero = Tzero_guess
init_params = beta_guess # initial guess for beta
# Get the fitting parameters for the best quotient of photoluminiscence emission
best_as, err = fit_quotient_for_beta(init_params, x, Tzero, Irrad_n, Irrad_m, y)
# retrieve best fitted parameters
beta = best_as[0]
Tref = temp_with_slope(Tzero, beta, Irrad_m)
Tbin = temp_with_slope(Tzero, beta, Irrad_n)
# calculate the errors and goodes of the fit
err_beta = np.sqrt(err[0,0])
err_Tzero = 0.5
err_Tref = np.sqrt(err_Tzero**2 + (Irrad_m*err_beta)**2 + (err_Irrad_m*beta)**2)
err_Tbin = np.sqrt(err_Tzero**2 + (Irrad_n*err_beta)**2 + (err_Irrad_n*beta)**2)
yfit = quotient_with_slope(x, Tzero, beta, Irrad_n, Irrad_m)
r2_coef_pearson = calc_r2(y, yfit)
chi_squared_pearson = calc_chi_squared(y, yfit)
# Plotting
yfit_to_plot = quotient_with_slope(x_long, Tzero, beta, Irrad_n, Irrad_m)
plt.plot(x_long, yfit_to_plot, '--k', alpha = 0.8)
color_iter = colormap[i]
plt.plot(x, y, '-', linewidth = 2.0,
color = color_iter,
label='$Q_{%d/%d}$' % (i, ref))
# label='$Q^{AS}_{%d/%d}$' % (i, ref))
# label='Group %d/%d' % (i, ref))
# label='Bin %d/%d - A %.2f' % (i, ref, A))
# Asign matrix elements
beta_matrix[ref,i] = beta
err_beta_matrix[ref,i] = err_beta
Tzero_matrix[ref,i] = Tzero
err_Tzero_matrix[ref,i] = err_Tzero
T_matrix[ref,i] = Tref
T_matrix[i,ref] = Tbin
err_T_matrix[ref,i] = err_Tref
err_T_matrix[i,ref] = err_Tbin
R2_matrix[ref,i] = r2_coef_pearson
R2_matrix[i,ref] = r2_coef_pearson
chi_squared_matrix[ref,i] = chi_squared_pearson
chi_squared_matrix[i,ref] = chi_squared_pearson
p_value_matrix[ref,i] = 1 - frozen_distro.cdf(chi_squared_pearson)
p_value_matrix[i,ref] = 1 - frozen_distro.cdf(chi_squared_pearson)
print('---------- Bin', i, \
'\nR-sq: %.3f' % r2_coef_pearson, \
'\nTzero: %.1f' % Tzero, 'err Tzero: %.1f' % err_Tzero, \
'\nbeta: %.1f' % beta, 'error beta: %.2f' % err_beta, \
'\nT_ref: %.1f' % Tref, 'error T_ref: %.1f' % err_Tref, \
'\nT_bin: %.1f' % Tbin, 'error T_bin: %.1f' % err_Tbin)
elif not find_beta and find_Tzero:
print('\nBeta is known. Finding Tzero...')
beta = beta_guess
init_params = Tzero_guess # initial guess for Tzero
# Get the fitting parameters for the best quotient of photoluminiscence emission
best_as, err = fit_quotient_for_Tzero(init_params, x, beta, Irrad_n, Irrad_m, y)
# retrieve best fitted parameters
Tzero = best_as[0]
Tref = temp_with_slope(Tzero, beta, Irrad_m)
Tbin = temp_with_slope(Tzero, beta, Irrad_n)
# calculate the errors and goodes of the fit
err_beta = 0.05
err_Tzero = np.sqrt(err[0,0])
err_Tref = np.sqrt(err_Tzero**2 + (Irrad_m*err_beta)**2 + (err_Irrad_m*beta)**2)
err_Tbin = np.sqrt(err_Tzero**2 + (Irrad_n*err_beta)**2 + (err_Irrad_n*beta)**2)
yfit = quotient_with_slope(x, Tzero, beta, Irrad_n, Irrad_m)
r2_coef_pearson = calc_r2(y, yfit)
chi_squared_pearson = calc_chi_squared(y, yfit)
# Plotting
yfit_to_plot = quotient_with_slope(x_long, Tzero, beta, Irrad_n, Irrad_m)
plt.plot(x_long, yfit_to_plot, '--k', alpha = 0.8)
color_iter = colormap[i]
plt.plot(x, y, '-', linewidth = 2.0,
color = color_iter,
label='$Q_{%d/%d}$' % (i, ref))
# label='$Q^{AS}_{%d/%d}$' % (i, ref))
# label='Group %d/%d' % (i, ref))
# label='Bin %d/%d - A %.2f' % (i, ref, A))
# Asign matrix elements
beta_matrix[ref,i] = beta
err_beta_matrix[ref,i] = err_beta
Tzero_matrix[ref,i] = Tzero
err_Tzero_matrix[ref,i] = err_Tzero
T_matrix[ref,i] = Tref
T_matrix[i,ref] = Tbin
err_T_matrix[ref,i] = err_Tref
err_T_matrix[i,ref] = err_Tbin
R2_matrix[ref,i] = r2_coef_pearson
R2_matrix[i,ref] = r2_coef_pearson
chi_squared_matrix[ref,i] = chi_squared_pearson
chi_squared_matrix[i,ref] = chi_squared_pearson
p_value_matrix[ref,i] = 1 - frozen_distro.cdf(chi_squared_pearson)
p_value_matrix[i,ref] = 1 - frozen_distro.cdf(chi_squared_pearson)
print('---------- Bin', i, \
'\nR-sq: %.3f' % r2_coef_pearson, \
'\nTzero: %.1f' % Tzero, 'err Tzero: %.1f' % err_Tzero, \
'\nbeta: %.1f' % beta, 'error beta: %.2f' % err_beta, \
'\nT_ref: %.1f' % Tref, 'error T_ref: %.1f' % err_Tref, \
'\nT_bin: %.1f' % Tbin, 'error T_bin: %.1f' % err_Tbin)
else:
raise ValueError('Values of find_beta and find_Tzero must be complementary.')
plt.grid(True)
plt.legend(loc='upper left', prop={'size':12})
ax = plt.gca()
ax.set_xlim([energy[b],energy[a]])
# ax.set_xlim([0.99*energy[b],1.01*energy[a]])
ax.set_xlim(2.37, 2.445)
# ax.axvline(energy[a], ymin=0, ymax=1, linestyle='--', color='k')
# ax.axvline(energy[b], ymin=0, ymax=1, linestyle='--', color='k')
ax.set_ylim([1, 24])
ax.set_xlabel('Energy (eV)', fontsize=20)
ax.set_ylabel('$Q^{AS}$', fontsize=20)
plt.tick_params(axis='both', which='major', labelsize=18)
aux_folder = manage_save_directory(save_folder,'antistokes_quotient')
figure_name = os.path.join(aux_folder,'quotient_vs_energy_ref_%02d_%s.png' % (ref, NP))
plt.savefig(figure_name, dpi = 300)
figure_name = os.path.join(aux_folder,'quotient_vs_energy_ref_%02d_%s.pdf' % (ref, NP))
plt.savefig(figure_name, dpi = 300, format='pdf')
plt.close()
########################### PLOT Temp, R2, p-value matrix
########################### PLOT Temp, R2, p-value matrix
plt.figure()
plt.imshow(beta_matrix, interpolation='none', cmap='plasma')
ax = plt.gca()
for i in range(totalbins):
for j in range(totalbins):
ax.text(j, i, '%.0f' % beta_matrix[i, j],
ha="center", va="center", color=[0,0,0])
ax.set_xticks(range(totalbins))
ax.set_yticks(range(totalbins))
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
cbar = plt.colorbar()
cbar.ax.set_title(u'Temp. (K)', fontsize=13)
figure_name = os.path.join(folder,'beta_matrix_%s.png' % NP)
plt.savefig(figure_name)
aux_folder = manage_save_directory(common_path,'beta_matrix')
figure_name = os.path.join(aux_folder,'beta_matrix_%s.png' % NP)
plt.savefig(figure_name)
plt.close()
plt.figure()
plt.imshow(Tzero_matrix, interpolation='none', cmap='plasma')
ax = plt.gca()
for i in range(totalbins):
for j in range(totalbins):
ax.text(j, i, '%.0f' % Tzero_matrix[i, j],
ha="center", va="center", color=[0,0,0])
ax.set_xticks(range(totalbins))
ax.set_yticks(range(totalbins))
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
cbar = plt.colorbar()
cbar.ax.set_title(u'T$_{0}$ (K)', fontsize=13)
figure_name = os.path.join(folder,'Tzero_matrix_%s.png' % NP)
plt.savefig(figure_name)
aux_folder = manage_save_directory(common_path,'Tzero_matrix')
figure_name = os.path.join(aux_folder,'Tzero_matrix_%s.png' % NP)
plt.savefig(figure_name)
plt.close()
plt.figure()
plt.imshow(T_matrix, interpolation='none', cmap='plasma')
ax = plt.gca()
for i in range(totalbins):
for j in range(totalbins):
ax.text(j, i, '%.0f' % T_matrix[i, j],
ha="center", va="center", color=[0,0,0])
ax.set_xticks(range(totalbins))
ax.set_yticks(range(totalbins))
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
cbar = plt.colorbar()
cbar.ax.set_title(u'Temp. (K)', fontsize=13)
figure_name = os.path.join(folder,'temp_matrix_%s.png' % NP)
plt.savefig(figure_name)
aux_folder = manage_save_directory(common_path,'temp_matrix')
figure_name = os.path.join(aux_folder,'temp_matrix_%s.png' % NP)
plt.savefig(figure_name)
plt.close()
plt.figure()
plt.imshow(R2_matrix, interpolation='none', cmap='viridis')
ax = plt.gca()
for i in range(totalbins):
for j in range(totalbins):
ax.text(j, i, '%.2f' % R2_matrix[i, j],
ha="center", va="center", color=[0,0,0])
ax.set_xticks(range(totalbins))
ax.set_yticks(range(totalbins))
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
figure_name = os.path.join(folder,'R2_matrix_%s.png' % NP)
plt.savefig(figure_name)
aux_folder = manage_save_directory(common_path,'R2_matrix')
figure_name = os.path.join(aux_folder,'R2_matrix_%s.png' % NP)
plt.savefig(figure_name)
plt.close()
plt.figure()
plt.imshow(p_value_matrix, interpolation='none', cmap='viridis')
ax = plt.gca()
for i in range(totalbins):
for j in range(totalbins):
ax.text(j, i, '%.2f' % p_value_matrix[i, j],
ha="center", va="center", color=[0,0,0])
ax.set_xticks(range(totalbins))
ax.set_yticks(range(totalbins))
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
figure_name = os.path.join(folder,'p_value_matrix_%s.png' % NP)
plt.savefig(figure_name)
aux_folder = manage_save_directory(common_path,'p_value_matrix')
figure_name = os.path.join(aux_folder,'p_value_matrix_%s.png' % NP)
plt.savefig(figure_name)
plt.close()
#################### SAVE DATA ############################
#################### SAVE DATA ############################
#################### SAVE DATA ############################
# Writing/creating files
aux_folder = manage_save_directory(save_folder,'matrix')
beta_matrix_file = os.path.join(aux_folder,'beta_matrix_%s.dat' % NP)
err_beta_matrix_file = os.path.join(aux_folder,'err_beta_matrix_%s.dat' % NP)
np.savetxt(beta_matrix_file, beta_matrix, delimiter=',', fmt='%.3e')
np.savetxt(err_beta_matrix_file, err_beta_matrix, delimiter=',', fmt='%.3e')
Tzero_matrix_file = os.path.join(aux_folder,'Tzero_matrix_%s.dat' % NP)
err_Tzero_matrix_file = os.path.join(aux_folder,'err_Tzero_matrix_%s.dat' % NP)
np.savetxt(Tzero_matrix_file, Tzero_matrix, delimiter=',', fmt='%.3e')
np.savetxt(err_Tzero_matrix_file, err_Tzero_matrix, delimiter=',', fmt='%.3e')
T_matrix_file = os.path.join(aux_folder,'Temp_matrix_%s.dat' % NP)
err_T_matrix_file = os.path.join(aux_folder,'err_T_matrix_%s.dat' % NP)
np.savetxt(T_matrix_file, T_matrix, delimiter=',', fmt='%.3e')
np.savetxt(err_T_matrix_file, err_T_matrix, delimiter=',', fmt='%.3e')
R2_matrix_file = os.path.join(aux_folder,'R2_matrix_%s.dat' % NP)
np.savetxt(R2_matrix_file, R2_matrix, delimiter=',', fmt='%.3e')
p_value_matrix_file = os.path.join(aux_folder,'p_value_matrix_%s.dat' % NP)
np.savetxt(p_value_matrix_file, p_value_matrix, delimiter=',', fmt='%.3e')
irradiance_file = os.path.join(aux_folder,'irradiance_matrix_%s.dat' % NP)
np.savetxt(irradiance_file, Irrad_array, fmt='%.3e')
return
def statistics(path_from, R2th, totalbins, radius, sigma_abs, find_beta,
find_Tzero):
stats_file = os.path.join(path_from, 'stats', 'all_NP_data.dat')
data = np.loadtxt(stats_file, skiprows=1)
list_of_mean_beta = data[:, 0]
list_of_mean_beta_err = data[:, 1]
list_of_std_beta = data[:, 2]
list_of_data_points = data[:, 3]
list_of_mean_Tzero = data[:, 4]
list_of_mean_Tzero_err = data[:, 5]
list_of_std_Tzero = data[:, 6]
list_of_londa_max = data[:, 7]
list_of_width_pl = data[:, 8]
list_of_r_sq_spr = data[:, 9]
list_of_avg_monitor = data[:, 10]
list_of_std_monitor = data[:, 11]
list_of_col = data[:, 12]
list_of_nps = data[:, 13]
index_non_zero = list_of_mean_beta != 0
list_of_mean_beta = list_of_mean_beta[index_non_zero]
list_of_mean_beta_err = list_of_mean_beta_err[index_non_zero]
list_of_std_beta = list_of_std_beta[index_non_zero]
list_of_data_points = list_of_data_points[index_non_zero]
list_of_mean_Tzero = list_of_mean_Tzero[index_non_zero]
list_of_mean_Tzero_err = list_of_mean_Tzero_err[index_non_zero]
list_of_std_Tzero = list_of_std_Tzero[index_non_zero]
list_of_londa_max = list_of_londa_max[index_non_zero]
list_of_width_pl = list_of_width_pl[index_non_zero]
list_of_r_sq_spr = list_of_r_sq_spr[index_non_zero]
list_of_avg_monitor = list_of_avg_monitor[index_non_zero]
list_of_std_monitor = list_of_std_monitor[index_non_zero]
list_of_col = list_of_col[index_non_zero]
list_of_nps = list_of_nps[index_non_zero]
##########################################################################
##########################################################################
##########################################################################
######################################## slope with errors vs NP
plt.figure()
plt.errorbar(list_of_nps, list_of_mean_beta, yerr=list_of_mean_beta_err, \
elinewidth=1, fmt='s', alpha=0.5, label='All beta NPs')
plt.legend()
ax = plt.gca()
ax.set_ylim([0, 100])
ax.set_xlabel(r'Index')
ax.set_ylabel(r'Photothermal coefficient (K µm$^{2}$/mW)')
aux_folder = manage_save_directory(path_from, 'stats')
figure_name = 'beta_vs_index_R2th_%s_%s_bines.png' % \
(str(R2th), str(totalbins))
figure_name = os.path.join(aux_folder, figure_name)
plt.savefig(figure_name)
plt.close()
######################################## slope vs NP
plt.figure()
plt.plot(list_of_col,
list_of_mean_beta,
's',
color='C1',
label='All beta NPs')
plt.legend()
ax = plt.gca()
ax.set_ylim([0, 100])
ax.set_xlabel(r'NP')
ax.set_ylabel(r'Photothermal coefficient (K µm$^{2}$/mW)')
aux_folder = manage_save_directory(path_from, 'stats')
figure_name = 'beta_vs_NP_R2th_%s_%s_bines.png' % \
(str(R2th), str(totalbins))
figure_name = os.path.join(aux_folder, figure_name)
plt.savefig(figure_name)
plt.close()
######################################## hist BETA
######################################## hist BETA
######################################## hist BETA
unique_NPs = np.unique(list_of_col)
number_of_NPs = len(unique_NPs)
range_tuple = [15, 95]
nbins = 16
if find_beta and not find_Tzero:
####################################### hist BETA per NP
#### ALL NPs IN ONE PLOT (histogram of its repetition)
if number_of_NPs != 1:
fig, axs = plt.subplots(number_of_NPs,
1,
gridspec_kw={
'wspace': 0,
'hspace': 0
})
for i in range(number_of_NPs):
num_NP = int(unique_NPs[i])
grep_NPs = np.where(list_of_col == num_NP)[0]
grep_betas_NPs = list_of_mean_beta[grep_NPs]
beta_mean_per_NP = np.nanmean(grep_betas_NPs)
betas_std_per_NP = np.nanstd(grep_betas_NPs, ddof=1)
borders = [
beta_mean_per_NP + betas_std_per_NP,
beta_mean_per_NP - betas_std_per_NP
]
ax = axs[i]
out_hist = ax.hist(grep_betas_NPs, bins=nbins, range=range_tuple, rwidth = 1, \
align='mid', alpha = 1, color = 'C0', edgecolor='k', normed = False, zorder=2, \
label='NP %d' % i)
ax.axvline(beta_mean_per_NP,
ymin=0,
ymax=1,
color='C3',
linestyle='--',
linewidth=2,
zorder=3)
ax.fill_between([borders[0], borders[1]], [0, 0], [1, 1],
facecolor='k',
alpha=0.25,
zorder=1)
ax.set_xlim([41, 89])
plt.legend()
ax = plt.gca()
ax.set_ylim([0, 10])
ax.set_ylabel('Entries')
ax.set_xlabel(u'Photothermal coefficient (K µm$^{2}$/mW)')
aux_folder = manage_save_directory(path_from, 'stats')
figure_name = '0_beta_mean_hist_per_NP_R2th_%s_%s_bines.png' % \
(str(R2th), str(totalbins))
figure_name = os.path.join(aux_folder, figure_name)
plt.savefig(figure_name, dpi=300, bbox_layout='tight')
plt.close()
####################################### hist BETA MEAN per SIZE
#### ALL NPs IN ONE PLOT (histogram of its repetition)
if number_of_NPs != 1:
fig, axs = plt.subplots(number_of_NPs,
1,
gridspec_kw={
'wspace': 0,
'hspace': 0
})
for i in range(number_of_NPs):
num_NP = int(unique_NPs[i])
grep_NPs = np.where(list_of_col == num_NP)[0]
grep_betas_NPs = list_of_mean_beta[grep_NPs]
beta_mean_per_NP = np.nanmean(grep_betas_NPs)
betas_std_per_NP = np.nanstd(grep_betas_NPs, ddof=1)
borders = [
beta_mean_per_NP + betas_std_per_NP,
beta_mean_per_NP - betas_std_per_NP
]
ax = axs[i]
out_hist = ax.hist(grep_betas_NPs, bins=nbins, range=range_tuple, rwidth = 1, \
align='mid', alpha = 1, color = 'C0', edgecolor='k', normed = False, zorder=2, \
label='NP %d' % i)
ax.axvline(beta_mean_per_NP,
ymin=0,
ymax=1,
color='C3',
linestyle='--',
linewidth=2,
zorder=3)
ax.fill_between([borders[0], borders[1]], [0, 0], [1, 1],
facecolor='k',
alpha=0.25,
zorder=1)
ax.set_xlim([41, 89])
plt.legend()
ax = plt.gca()
ax.set_ylim([0, 10])
ax.set_ylabel('Entries')
ax.set_xlabel(u'Photothermal coefficient (K µm$^{2}$/mW)')
aux_folder = manage_save_directory(path_from, 'stats')
figure_name = '0_beta_mean_hist_per_NP_R2th_%s_%s_bines.png' % \
(str(R2th), str(totalbins))
figure_name = os.path.join(aux_folder, figure_name)
plt.savefig(figure_name, dpi=300, bbox_layout='tight')
plt.close()
####################################### hist BETA per NP
#### one NP per plot (histogram of its repetition)
print(
'\n-------- Stats using matrix betas of multiple scans of one NP (to find distributions parameters) --------'
)
dict_file = os.path.join(path_from, 'stats', 'all_beta_good_data.pkl')
with open(dict_file, 'rb') as f:
list_of_beta_good_dict = pickle.load(f)
dict_file = os.path.join(path_from, 'stats',
'all_beta_good_err_data.pkl')
with open(dict_file, 'rb') as f:
list_of_beta_good_err_dict = pickle.load(f)
for i in range(number_of_NPs):
list_of_beta_good_per_NP = np.array([])
list_of_beta_good_err_per_NP = np.array([])
num_NP = int(unique_NPs[i])
for key in list_of_beta_good_dict.keys():
col = int(key.split('_')[1])
# NP = int(key.split('_')[3])
if num_NP == col:
# print(num_NP, col, NP)
list_of_beta_good_per_NP = np.append(
list_of_beta_good_dict[key], list_of_beta_good_per_NP)
list_of_beta_good_err_per_NP = np.append(
list_of_beta_good_err_dict[key],
list_of_beta_good_err_per_NP)
# print(list_of_beta_good_per_NP)
# stats
data_points = len(list_of_beta_good_per_NP)
beta_mean_per_NP = np.nanmean(list_of_beta_good_per_NP)
betas_std_per_NP = np.nanstd(list_of_beta_good_per_NP, ddof=1)
# beta_mean_err_per_NP = np.sqrt(np.nansum(list_of_beta_good_err_per_NP**2))/data_points
beta_mean_err_per_NP = betas_std_per_NP / np.sqrt(data_points)
borders = [
beta_mean_per_NP - betas_std_per_NP,
beta_mean_per_NP + betas_std_per_NP
]
print('\nNP %02d' % num_NP)
print(
'Data points (all betas of same NP scanned multiple times): %d'
% data_points)
print('Mean beta: %.3f' % beta_mean_per_NP,
'Std dev beta: %.3f' % betas_std_per_NP)
print('Error in mean beta (same sigma for all): %.3f' %
beta_mean_err_per_NP)
plt.figure()
ax = plt.gca()
out_hist = plt.hist(list_of_beta_good_per_NP, bins=nbins, range=range_tuple, rwidth = 1, \
align='mid', alpha = 1, color = 'C0', edgecolor='k', normed = False, zorder=2, \
label='NP %d' % i)
ax.axvline(beta_mean_per_NP,
ymin=0,
ymax=1,
color='C3',
linestyle='--',
linewidth=2,
zorder=3)
ax.fill_between([borders[0], borders[1]], [0, 0], [100, 100],
facecolor='k',
alpha=0.25,
zorder=1)
plt.legend()
ax.set_ylim([0, 1.1 * np.max(out_hist[0])])
ax.set_xlim([25, 105])
ax.set_ylabel('Entries')
ax.set_xlabel(r'$\beta$ (K µm$^{2}$/mW)')
aux_folder = manage_save_directory(path_from, 'stats')
figure_name = '0_beta_hist_NP_%02d_R2th_%s_%s_bines.png' % \
(num_NP, str(R2th), str(totalbins))
figure_name = os.path.join(aux_folder, figure_name)
plt.savefig(figure_name, dpi=300, bbox_layout='tight')
plt.close()
print(
'\n-------- Stats using mean betas for one NP (repetition, to find beta for each NP) --------'
)
# range_tuple = [15,85]
# nbins = 15
list_of_beta_bb = []
list_of_beta_barra_std = []
list_of_beta_bb_err = []
for i in range(number_of_NPs):
num_NP = int(unique_NPs[i])
# keep NP data (usually is all daata from one Col)
grep_NPs = np.where(list_of_col == num_NP)[0]
grep_betas_NPs = list_of_mean_beta[grep_NPs]
grep_betas_err_NPs = list_of_mean_beta_err[grep_NPs]
# stats
data_points = len(grep_betas_NPs)
beta_barra_mean_per_NP = np.nanmean(grep_betas_NPs)
beta_barra_std_per_NP = np.nanstd(grep_betas_NPs, ddof=1)
beta_barra_mean_err_per_NP = np.sqrt(
np.nansum(grep_betas_err_NPs**2)) / data_points
borders = [
beta_barra_mean_per_NP - beta_barra_std_per_NP,
beta_barra_mean_per_NP + beta_barra_std_per_NP
]
print('\nNP %02d' % num_NP)
print('Data points (number of scans): %d' % data_points)
print('Mean beta barra (beta bb): %.3f' % beta_barra_mean_per_NP,
'Std dev beta barra: %.3f' % beta_barra_std_per_NP)
print('Error in mean beta barra (same sigma): %.3f' %
beta_barra_mean_err_per_NP)
list_of_beta_bb.append(beta_barra_mean_per_NP)
list_of_beta_barra_std.append(beta_barra_std_per_NP)
list_of_beta_bb_err.append(beta_barra_mean_err_per_NP)
plt.figure()
ax = plt.gca()
out_hist = plt.hist(grep_betas_NPs, bins=nbins, range=range_tuple, rwidth = 1, \
align='mid', alpha = 1, color = 'C0', edgecolor='k', normed = False, zorder=2, \
label='NP %d' % i)
ax.axvline(beta_barra_mean_per_NP,
ymin=0,
ymax=1,
color='C3',
linestyle='--',
linewidth=2,
zorder=3)
ax.fill_between([borders[0], borders[1]], [0, 0], [100, 100],
facecolor='k',
alpha=0.25,
zorder=1)
plt.legend()
ax.set_ylim([0, 1.1 * np.max(out_hist[0])])
ax.set_xlim([39, 91])
ax.set_ylabel('Entries')
ax.set_xlabel(r'$\bar{\beta}$ (K µm$^{2}$/mW)')
aux_folder = manage_save_directory(path_from, 'stats')
figure_name = '0_beta_mean_hist_NP_%02d_R2th_%s_%s_bines.png' % \
(num_NP, str(R2th), str(totalbins))
figure_name = os.path.join(aux_folder, figure_name)
plt.savefig(figure_name, dpi=300, bbox_layout='tight')
plt.close()
# # FOR INSET
## range_tuple = [15,85]
## nbins = 15
# for i in range(number_of_NPs):
# num_NP = int(unique_NPs[i])
# grep_NPs = np.where(list_of_col == num_NP)[0]
# grep_betas_NPs = list_of_mean_beta[grep_NPs]
# beta_mean_per_NP = np.nanmean(grep_betas_NPs)
# betas_std_per_NP = np.nanstd(grep_betas_NPs, ddof = 1)
# borders = [beta_mean_per_NP - betas_std_per_NP, beta_mean_per_NP + betas_std_per_NP]
# plt.figure()
# ax = plt.gca()
# out_hist = plt.hist(grep_betas_NPs, bins=nbins, range=range_tuple, rwidth = 1, \
# align='mid', alpha = 1, color = 'C0', edgecolor='k', normed = False, zorder=2, \
# label='NP %d' % i)
# ax.axvline(beta_mean_per_NP, ymin = 0, ymax = 1, color='C3', linestyle='--', linewidth=2, zorder=3)
# ax.fill_between([borders[0], borders[1]], [0,0], [100,100], facecolor='k', alpha=0.25, zorder=1)
# plt.legend()
# ax.set_ylim([0, 1.1*np.max(out_hist[0])])
# ax.set_xlim([49, 81])
# ax.tick_params(axis='both', which='major', labelsize=25)
# ax.set_ylabel('Entries', fontsize=24)
# ax.set_xlabel(r'$\bar{beta}$ (K µm$^{2}$/mW)', fontsize=24)
# aux_folder = manage_save_directory(path_from,'stats')
# fig_name = '0_beta_mean_hist_NP_%02d_R2th_%s_%s_bines_%s_Tzero_PAPER_INSET' % \
# (num_NP, str(R2th), str(totalbins), str(Tzero))
# figurefull_name = '%s.png' % fig_name
# figure_name = os.path.join(aux_folder, figurefull_name)
# plt.savefig(figure_name, dpi = 300, bbox_layout = 'tight')
# figurefull_name = '%s.pdf' % fig_name
# figure_name = os.path.join(aux_folder, figurefull_name)
# plt.savefig(figure_name, dpi = 300, bbox_layout = 'tight', format = 'pdf')
# plt.close()
######################################## slope vs max lambda
plt.figure()
plt.plot(list_of_londa_max,
list_of_mean_beta,
'o',
alpha=0.5,
label='All beta NPs')
plt.legend()
ax = plt.gca()
ax.set_ylim([0, 100])
ax.set_xlim([530, 600])
ax.set_xlabel(r'Max PL wavelength (nm)')
ax.set_ylabel(r'Photothermal coefficient (K µm$^{2}$/mW)')
aux_folder = manage_save_directory(path_from, 'stats')
figure_name = 'beta_vs_lambda_R2th_%s_%s_bines.png' % \
(str(R2th), str(totalbins))
figure_name = os.path.join(aux_folder, figure_name)
plt.savefig(figure_name)
plt.close()
######################################## power monitor vs slope, fake correlation
plt.figure()
plt.errorbar(list_of_avg_monitor, list_of_mean_beta, xerr = list_of_std_monitor, \
yerr = list_of_mean_beta_err, elinewidth=1, fmt='o', alpha=0.5, label='All NPs')
plt.legend()
ax = plt.gca()
ax.set_ylim([0, 110])
ax.set_ylabel(r'Photothermal coefficient (K µm$^{2}$/mW)')
ax.set_xlabel(r'Power monitor (a.u.)')
aux_folder = manage_save_directory(path_from, 'stats')
figure_name = os.path.join(aux_folder,'power_monitor_vs_slope_R2th_%s_%s_bines.png' % \
(str(R2th), str(totalbins)))
plt.savefig(figure_name)
plt.close()
print(
'\n-------- Stats using ALL beta barra bracket (one per NP, to find beta for a given system NP+medium) --------'
)
number_of_beta_bb = len(list_of_beta_bb)
print('Number of NPs measured: %d' % number_of_beta_bb)
mu_beta_bb = np.mean(list_of_beta_bb)
std_beta_bb = np.std(list_of_beta_bb, ddof=1)
print('\nMean beta bb: %.3f' % mu_beta_bb,
'Std dev beta bb: %.3f' % std_beta_bb)
# err_mu_beta_bb = np.sqrt(np.sum(beta_barra_mean_err_per_NP**2))/number_of_beta_bb
# err_mu_beta_bb = np.sqrt(number_of_beta_bb)
# beta_barra_std_per_NP
# print('Error in mean beta bb: %.3f' % err_mu_slope)
k_eff = sigma_abs / (4 * np.pi * radius * mu_beta_bb)
print('\nEffective thermal conductivity: %.3f' % k_eff, 'W/Km')
########################################################################################################################
########################################################################################################################
########################################################################################################################
########################################################################################################################
elif not find_beta and find_Tzero:
######################################## Tzero with errors vs NP
plt.figure()
plt.errorbar(list_of_nps, list_of_mean_beta, yerr=list_of_mean_beta_err, \
elinewidth=1, fmt='s', alpha=0.5, label='All Tzero NPs')
plt.legend()
ax = plt.gca()
ax.set_ylim([0, 100])
ax.set_xlabel(r'Index')
ax.set_ylabel(r'T$_{0}$ (K)')
aux_folder = manage_save_directory(path_from, 'stats')
figure_name = 'Tzero_vs_index_R2th_%s_%s_bines.png' % \
(str(R2th), str(totalbins))
figure_name = os.path.join(aux_folder, figure_name)
plt.savefig(figure_name)
plt.close()
######################################## Tzero vs NP
plt.figure()
plt.plot(list_of_col,
list_of_mean_Tzero,
's',
color='C1',
label='All Tzero NPs')
plt.legend()
ax = plt.gca()
ax.set_ylim([0, 100])
ax.set_xlabel(r'NP')
ax.set_ylabel(r'T$_{0}$ (K)')
aux_folder = manage_save_directory(path_from, 'stats')
figure_name = 'Tzero_vs_NP_R2th_%s_%s_bines.png' % \
(str(R2th), str(totalbins))
figure_name = os.path.join(aux_folder, figure_name)
plt.savefig(figure_name)
plt.close()
######################################## hist Tzero per NP
#### ALL NPs IN ONE (histogram of its repetition)
unique_NPs = np.unique(list_of_col)
number_of_NPs = len(unique_NPs)
range_tuple = [280, 380]
nbins = 16
if number_of_NPs != 1:
fig, axs = plt.subplots(number_of_NPs,
1,
gridspec_kw={
'wspace': 0,
'hspace': 0
})
for i in range(number_of_NPs):
num_NP = int(unique_NPs[i])
grep_NPs = np.where(list_of_col == num_NP)[0]
grep_Tzero_NPs = list_of_mean_Tzero[grep_NPs]
Tzero_mean_per_NP = np.mean(grep_Tzero_NPs)
Tzero_std_per_NP = np.std(grep_Tzero_NPs, ddof=1)
borders = [
Tzero_mean_per_NP + Tzero_std_per_NP,
Tzero_mean_per_NP - Tzero_std_per_NP
]
ax = axs[i]
out_hist = ax.hist(grep_Tzero_NPs, bins=nbins, range=range_tuple, rwidth = 1, \
align='mid', alpha = 1, color = 'C0', edgecolor='k', normed = False, zorder=2, \
label='NP %d' % i)
ax.axvline(Tzero_mean_per_NP,
ymin=0,
ymax=1,
color='C3',
linestyle='--',
linewidth=2,
zorder=3)
ax.fill_between([borders[0], borders[1]], [0, 0], [1, 1],
facecolor='k',
alpha=0.25,
zorder=1)
ax.set_xlim([280, 380])
plt.legend()
ax = plt.gca()
ax.set_ylim([0, 1.1 * np.max(out_hist[0])])
ax.set_ylabel('Entries')
ax.set_xlabel(u'T$_{0}$ (K)')
aux_folder = manage_save_directory(path_from, 'stats')
figure_name = 'Tzero_hist_per_NP_R2th_%s_%s_bines.png' % \
(str(R2th), str(totalbins))
figure_name = os.path.join(aux_folder, figure_name)
plt.savefig(figure_name, dpi=300, bbox_layout='tight')
plt.close()
####################################### hist BETA per NP
#### one NP per plot (histogram of its repetition)
print(
'\n-------- Stats using matrix Tzero (not mean) for one NP --------'
)
dict_file = os.path.join(path_from, 'stats', 'all_Tzero_good_data.pkl')
with open(dict_file, 'rb') as f:
list_of_Tzero_good_dict = pickle.load(f)
dict_file = os.path.join(path_from, 'stats',
'all_Tzero_good_err_data.pkl')
with open(dict_file, 'rb') as f:
list_of_Tzero_good_err_dict = pickle.load(f)
for i in range(number_of_NPs):
list_of_Tzero_good_per_NP = np.array([])
list_of_Tzero_good_err_per_NP = np.array([])
num_NP = int(unique_NPs[i])
for key in list_of_Tzero_good_dict.keys():
col = int(key.split('_')[1])
# NP = int(key.split('_')[3])
if num_NP == col:
# print(num_NP, col, NP)
list_of_Tzero_good_per_NP = np.append(
list_of_Tzero_good_dict[key],
list_of_Tzero_good_per_NP)
list_of_Tzero_good_err_per_NP = np.append(
list_of_Tzero_good_err_dict[key],
list_of_Tzero_good_err_per_NP)
# print(list_of_Tzero_good_per_NP)
# stats
data_points = len(list_of_Tzero_good_per_NP)
Tzero_mean_per_NP = np.mean(list_of_Tzero_good_per_NP)
Tzero_std_per_NP = np.std(list_of_Tzero_good_per_NP, ddof=1)
# Tzero_mean_err_per_NP = np.sqrt(np.sum(list_of_Tzero_good_err_per_NP**2))/data_points
Tzero_mean_err_per_NP = Tzero_std_per_NP / np.sqrt(data_points)
borders = [
Tzero_mean_per_NP - Tzero_std_per_NP,
Tzero_mean_per_NP + Tzero_std_per_NP
]
print('\nNP %02d' % num_NP)
print('Data points: %d' % data_points)
print('Mean Tzero: %.3f' % Tzero_mean_per_NP,
'Std dev Tzero: %.3f' % Tzero_std_per_NP)
print('Error in mean Tzero (same sigma for all): %.3f' %
Tzero_mean_err_per_NP)
plt.figure()
ax = plt.gca()
out_hist = plt.hist(list_of_Tzero_good_per_NP, bins=nbins, range=range_tuple, rwidth = 1, \
align='mid', alpha = 1, color = 'C0', edgecolor='k', normed = False, zorder=2, \
label='NP %d' % i)
ax.axvline(Tzero_mean_per_NP,
ymin=0,
ymax=1,
color='C3',
linestyle='--',
linewidth=2,
zorder=3)
ax.fill_between([borders[0], borders[1]], [0, 0], [100, 100],
facecolor='k',
alpha=0.25,
zorder=1)
plt.legend()
ax.set_ylim([0, 1.1 * np.max(out_hist[0])])
ax.set_xlim([280, 380])
ax.set_ylabel('Entries')
ax.set_xlabel(u'T$_{0}$ (K)')
aux_folder = manage_save_directory(path_from, 'stats')
figure_name = 'Tzero_hist_NP_%02d_R2th_%s_%s_bines.png' % \
(num_NP, str(R2th), str(totalbins))
figure_name = os.path.join(aux_folder, figure_name)
plt.savefig(figure_name, dpi=300, bbox_layout='tight')
plt.close()
print('\n-------- Stats using mean Tzero for one NP --------')
# range_tuple = [15,85]
# nbins = 15
list_of_Tzero_bb = []
list_of_Tzero_barra_std = []
list_of_Tzero_bb_err = []
for i in range(number_of_NPs):
num_NP = int(unique_NPs[i])
# keep NP data (usually is all daata from one Col)
grep_NPs = np.where(list_of_col == num_NP)[0]
grep_Tzero_NPs = list_of_mean_Tzero[grep_NPs]
grep_Tzero_err_NPs = list_of_mean_Tzero_err[grep_NPs]
# stats
data_points = len(grep_Tzero_NPs)
Tzero_barra_mean_per_NP = np.mean(grep_Tzero_NPs)
Tzero_barra_std_per_NP = np.std(grep_Tzero_NPs, ddof=1)
Tzero_barra_mean_err_per_NP = np.sqrt(np.sum(grep_Tzero_err_NPs**
2)) / data_points
borders = [
Tzero_barra_mean_per_NP - Tzero_barra_std_per_NP,
Tzero_barra_mean_per_NP + Tzero_barra_std_per_NP
]
print('\nNP %02d' % num_NP)
print('Data points: %d' % data_points)
print(
'Mean Tzero barra (Tzero bb): %.3f' % Tzero_barra_mean_per_NP,
'Std dev Tzero barra: %.3f' % Tzero_barra_std_per_NP)
print('Error in mean Tzero barra (not same sigma): %.3f' %
Tzero_barra_mean_err_per_NP)
list_of_Tzero_bb.append(Tzero_barra_mean_per_NP)
list_of_Tzero_barra_std.append(Tzero_barra_std_per_NP)
list_of_Tzero_bb_err.append(Tzero_barra_mean_err_per_NP)
plt.figure()
ax = plt.gca()
out_hist = plt.hist(grep_Tzero_NPs, bins=nbins, range=range_tuple, rwidth = 1, \
align='mid', alpha = 1, color = 'C0', edgecolor='k', normed = False, zorder=2, \
label='NP %d' % i)
ax.axvline(Tzero_barra_mean_per_NP,
ymin=0,
ymax=1,
color='C3',
linestyle='--',
linewidth=2,
zorder=3)
ax.fill_between([borders[0], borders[1]], [0, 0], [100, 100],
facecolor='k',
alpha=0.25,
zorder=1)
plt.legend()
ax.set_ylim([0, 1.1 * np.max(out_hist[0])])
ax.set_xlim([280, 380])
ax.set_ylabel('Entries')
ax.set_xlabel(u'T$_{0}$ (K)')
aux_folder = manage_save_directory(path_from, 'stats')
figure_name = 'Tzero_mean_hist_NP_%02d_R2th_%s_%s_bines.png' % \
(num_NP, str(R2th), str(totalbins))
figure_name = os.path.join(aux_folder, figure_name)
plt.savefig(figure_name, dpi=300, bbox_layout='tight')
plt.close()
######################################## Tzero vs max lambda
plt.figure()
plt.plot(list_of_londa_max,
list_of_mean_Tzero,
'o',
alpha=0.5,
label='All Tzero NPs')
plt.legend()
ax = plt.gca()
ax.set_ylim([250, 400])
ax.set_xlim([530, 600])
ax.set_xlabel(r'Max PL wavelength (nm)')
ax.set_ylabel(r'T$_{0}$ (K)')
aux_folder = manage_save_directory(path_from, 'stats')
figure_name = 'Tzero_vs_lambda_R2th_%s_%s_bines.png' % \
(str(R2th), str(totalbins))
figure_name = os.path.join(aux_folder, figure_name)
plt.savefig(figure_name)
plt.close()
######################################## power monitor vs Tzero, fake correlation
plt.figure()
plt.errorbar(list_of_avg_monitor, list_of_mean_Tzero, xerr = list_of_std_monitor, \
yerr = list_of_mean_Tzero_err, elinewidth=1, fmt='o', alpha=0.5, label='All NPs')
plt.legend()
ax = plt.gca()
ax.set_ylim([0, 110])
ax.set_ylabel(r'T$_{0}$ (K)')
ax.set_xlabel(r'Power monitor (a.u.)')
aux_folder = manage_save_directory(path_from, 'stats')
figure_name = os.path.join(aux_folder,'power_monitor_vs_Tzero_R2th_%s_%s_bines.png' % \
(str(R2th), str(totalbins)))
plt.savefig(figure_name)
plt.close()
print(
'\n-------- Stats using ALL Tzero barra bracket (one per NP, to find Tzero for a given system NP+medium) --------'
)
number_of_Tzero_bb = len(list_of_Tzero_bb)
print('Number of NPs measured: %d' % number_of_Tzero_bb)
mu_Tzero_bb = np.mean(list_of_Tzero_bb)
std_Tzero_bb = np.std(list_of_Tzero_bb, ddof=1)
print('\nMean Tzero bb: %.3f' % mu_Tzero_bb,
'Std dev Tzero bb: %.3f' % std_Tzero_bb)
# err_mu_beta_bb = np.sqrt(np.sum(beta_barra_mean_err_per_NP**2))/number_of_beta_bb
# err_mu_beta_bb = np.sqrt(number_of_beta_bb)
# beta_barra_std_per_NP
# print('Error in mean beta bb: %.3f' % err_mu_slope)
########################################################################################################################
########################################################################################################################
########################################################################################################################
########################################################################################################################
######################################## lambda max vs NP
plt.figure()
plt.plot(list_of_nps, list_of_londa_max, 'o')
plt.legend()
ax = plt.gca()
ax.set_ylim([530, 600])
ax.set_xlabel(r'Index')
ax.set_ylabel(r'Max PL wavelength (nm)')
ax.axvline(9.5, ymin=0, ymax=1, color='k', alpha=0.5, linestyle='--')
ax.axvline(19.5, ymin=0, ymax=1, color='k', alpha=0.5, linestyle='--')
ax.axvline(29.5, ymin=0, ymax=1, color='k', alpha=0.5, linestyle='--')
ax.axvline(39.5, ymin=0, ymax=1, color='k', alpha=0.5, linestyle='--')
ax.axvline(49.5, ymin=0, ymax=1, color='k', alpha=0.5, linestyle='--')
ax.axvline(59.5, ymin=0, ymax=1, color='k', alpha=0.5, linestyle='--')
ax.axvline(69.5, ymin=0, ymax=1, color='k', alpha=0.5, linestyle='--')
ax.axvline(79.5, ymin=0, ymax=1, color='k', alpha=0.5, linestyle='--')
ax.axvline(89.5, ymin=0, ymax=1, color='k', alpha=0.5, linestyle='--')
aux_folder = manage_save_directory(path_from, 'stats')
figure_name = os.path.join(aux_folder,'max_lambda_vs_index_R2th_%s_%s_bines.png' % \
(str(R2th), str(totalbins)))
plt.savefig(figure_name)
plt.close()
######################################## power monitor vs NP
plt.figure()
plt.errorbar(list_of_nps, list_of_avg_monitor, yerr = list_of_std_monitor, \
elinewidth=1, fmt='o', alpha=0.5, label='All NPs')
plt.legend()
ax = plt.gca()
ax.set_ylim([0.1, 0.2])
ax.set_xlabel(r'Index')
ax.set_ylabel(r'Power monitor (a.u.)')
ax.axvline(9.5, ymin=0, ymax=1, color='k', alpha=0.5, linestyle='--')
ax.axvline(19.5, ymin=0, ymax=1, color='k', alpha=0.5, linestyle='--')
ax.axvline(29.5, ymin=0, ymax=1, color='k', alpha=0.5, linestyle='--')
ax.axvline(39.5, ymin=0, ymax=1, color='k', alpha=0.5, linestyle='--')
ax.axvline(49.5, ymin=0, ymax=1, color='k', alpha=0.5, linestyle='--')
ax.axvline(59.5, ymin=0, ymax=1, color='k', alpha=0.5, linestyle='--')
ax.axvline(69.5, ymin=0, ymax=1, color='k', alpha=0.5, linestyle='--')
ax.axvline(79.5, ymin=0, ymax=1, color='k', alpha=0.5, linestyle='--')
ax.axvline(89.5, ymin=0, ymax=1, color='k', alpha=0.5, linestyle='--')
aux_folder = manage_save_directory(path_from, 'stats')
figure_name = os.path.join(aux_folder,'power_monitor_vs_index_R2th_%s_%s_bines.png' % \
(str(R2th), str(totalbins)))
plt.savefig(figure_name)
plt.close()
########################################
########################################
########################################
return