diff --git a/Likelihood/Full_likelihood.py b/Likelihood/Full_likelihood.py new file mode 100644 index 0000000..2d96e48 --- /dev/null +++ b/Likelihood/Full_likelihood.py @@ -0,0 +1,106 @@ +from Prob_dist_astro import * +from Prob_dist_atm import * + + + +Initialize_All_Cross_Sections(prefix_dsdy_nu_nucleon='dsdy_ct14nn', + prefix_dsdy_nu_electron='dsdy_electron', + prefix_cs_nu_electron='cs_electron', kx=1, ky=1, k=1, s=0, + verbose=0) + + +def Partial_likelihood_showers(N_a, N_conv, N_pr, N_mu, g, M, z_min, z_max, E_min, E_max, E_npts, gamma, nu_energy_min, nu_energy_max, nu_energy_num_nodes, + costhz_val, costhz_npts, energy_dep, log10_energy_dep_int_min, log10_energy_dep_int_max, log10_energy_dep_min, log10_energy_dep_max, log10_energy_dep_npts, + time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose): + + pdastro_sh = Prob_dist_astro(g, M, z_min, z_max, E_min, E_max, E_npts, gamma, nu_energy_min, nu_energy_max, nu_energy_num_nodes, costhz_val, costhz_npts, energy_dep, + log10_energy_dep_int_min, log10_energy_dep_int_max, log10_energy_dep_min, log10_energy_dep_max, log10_energy_dep_npts, + time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose, flag_compute_shower_rate = True, flag_compute_track_rate = False) + + pdatm_conv_sh = Prob_dist_atm_conv_pr(nu_energy_min, nu_energy_max, nu_energy_num_nodes, costhz_val, costhz_npts, energy_dep,log10_energy_dep_int_min, log10_energy_dep_int_max, + log10_energy_dep_min, log10_energy_dep_max, log10_energy_dep_npts, time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose, + flag_use_atm_fluxes_conv = True, flag_use_atm_fluxes_pr = False, flag_apply_self_veto = True, flag_compute_shower_rate = True, flag_compute_track_rate = False) + + + pdatm_pr_sh = Prob_dist_atm_conv_pr(nu_energy_min, nu_energy_max, nu_energy_num_nodes, costhz_val, costhz_npts, energy_dep,log10_energy_dep_int_min, log10_energy_dep_int_max, + log10_energy_dep_min, log10_energy_dep_max, log10_energy_dep_npts, time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose, + flag_use_atm_fluxes_conv = False, flag_use_atm_fluxes_pr = True, flag_apply_self_veto = True, flag_compute_shower_rate = True, flag_compute_track_rate = False) + + + pdatm_muon_sh = 0 #Probabillity distribution of atmospheric muons (showers) + + likelihood = N_a * pdastro_sh + N_conv * pdatm_conv_sh + N_pr * pdatm_pr_sh + N_mu * pdatm_muon_sh + + return likelihood + + + +def Partial_likelihood_tracks(N_a, N_conv, N_pr, N_mu, g, M, z_min, z_max, E_min, E_max, E_npts, gamma, nu_energy_min, nu_energy_max, nu_energy_num_nodes, + costhz_val, costhz_npts, energy_dep, log10_energy_dep_int_min, log10_energy_dep_int_max, log10_energy_dep_min, log10_energy_dep_max, log10_energy_dep_npts, + time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose): + + pdastro_tr = Prob_dist_astro(g, M, z_min, z_max, E_min, E_max, E_npts, gamma, nu_energy_min, nu_energy_max, nu_energy_num_nodes, costhz_val, costhz_npts, energy_dep, + log10_energy_dep_int_min, log10_energy_dep_int_max, log10_energy_dep_min, log10_energy_dep_max, log10_energy_dep_npts, + time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose, flag_compute_shower_rate = False, flag_compute_track_rate = True) + + pdatm_conv_tr = Prob_dist_atm_conv_pr(nu_energy_min, nu_energy_max, nu_energy_num_nodes, costhz_val, costhz_npts, energy_dep,log10_energy_dep_int_min, log10_energy_dep_int_max, + log10_energy_dep_min, log10_energy_dep_max, log10_energy_dep_npts, time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose, + flag_use_atm_fluxes_conv = True, flag_use_atm_fluxes_pr = False, flag_apply_self_veto = True, flag_compute_shower_rate = False, flag_compute_track_rate = True) + + + pdatm_pr_tr = Prob_dist_atm_conv_pr(nu_energy_min, nu_energy_max, nu_energy_num_nodes, costhz_val, costhz_npts, energy_dep,log10_energy_dep_int_min, log10_energy_dep_int_max, + log10_energy_dep_min, log10_energy_dep_max, log10_energy_dep_npts, time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose, + flag_use_atm_fluxes_conv = False, flag_use_atm_fluxes_pr = True, flag_apply_self_veto = True, flag_compute_shower_rate = False, flag_compute_track_rate = True) + + + pdatm_muon_tr = Prob_dist_atm_muon(energy_dep, log10_energy_dep_int_min, log10_energy_dep_int_max, log10_energy_dep_min, log10_energy_dep_max, log10_energy_dep_npts, epsabs, epsrel, verbose) + + likelihood = N_a * pdastro_tr + N_conv * pdatm_conv_tr + N_pr * pdatm_pr_tr + N_mu * pdatm_muon_tr + + return likelihood + + +def Full_likelihood(N_a, N_conv, N_pr, N_mu, g, M, gamma, nu_energy_min, nu_energy_max, z_min, z_max, E_min, E_max, E_npts, nu_energy_num_nodes, + costhz_npts, log10_energy_dep_int_min, log10_energy_dep_int_max, log10_energy_dep_min, log10_energy_dep_max, log10_energy_dep_npts, + time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose): + + + ID_sh, lst_energy_sh, uncertainty_minus_sh, uncertainty_plus_sh, time_sh, declination_sh, RA_sh, Med_sh = Read_Data_File(os.getcwd()+'/'+'data_shower.txt') + + ID_tr, lst_energy_tr, uncertainty_minus_tr, uncertainty_plus_tr, time_tr, declination_tr, RA_tr, Med_tr = Read_Data_File(os.getcwd()+'/'+'data_track.txt') + + FL_sh = 1 + for i in range(3): #len(lst_energy_sh)): + costhz_val = np.cos((declination_sh[i] + 90)*np.pi/180) + energy_dep = lst_energy_sh[i]*1000 + + FL_sh = FL_sh * Partial_likelihood_showers(N_a, N_conv, N_pr, N_mu, g, M, z_min, z_max, E_min, E_max, E_npts, gamma, nu_energy_min, nu_energy_max, nu_energy_num_nodes, + costhz_val, costhz_npts, energy_dep, log10_energy_dep_int_min, log10_energy_dep_int_max, log10_energy_dep_min, log10_energy_dep_max, log10_energy_dep_npts, + time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose) + + + FL_tr = 1 + + for i in range(3): #len(lst_energy_tr)): + costhz_val = np.cos((declination_tr[i] + 90)*np.pi/180) + energy_dep = lst_energy_tr[i]*1000 + + FL_tr = FL_tr * Partial_likelihood_tracks(N_a, N_conv, N_pr, N_mu, g, M, z_min, z_max, E_min, E_max, E_npts, gamma, nu_energy_min, nu_energy_max, nu_energy_num_nodes, + costhz_val, costhz_npts, energy_dep, log10_energy_dep_int_min, log10_energy_dep_int_max, log10_energy_dep_min, log10_energy_dep_max, log10_energy_dep_npts, + time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose) + + FL = np.exp(- N_a - N_conv - N_pr - N_mu) * FL_sh * FL_tr + + return FL + +""" +log10_nu_energy_min = 2.8 +log10_nu_energy_max = 9.2 + +test = Full_likelihood(20, 20, 20, 20, 0.03, 0.01, 2, nu_energy_min = 10**log10_nu_energy_min, nu_energy_max = 10**log10_nu_energy_max, + z_min = 0, z_max = 4, E_min = 3, E_max = 8, E_npts = 10, nu_energy_num_nodes = 150, + costhz_npts = 2, log10_energy_dep_int_min = 4, log10_energy_dep_int_max = 7, log10_energy_dep_min = 3.8, log10_energy_dep_max = 7.2, log10_energy_dep_npts = 50, + time_det_yr = 8, volume_total = 6.44e14, energy_nu_max = 1e8, epsabs =1e-3, epsrel = 1e-3, verbose=1) +print(test) + +""" \ No newline at end of file diff --git a/Likelihood/Likelihood_analysis.sh b/Likelihood/Likelihood_analysis.sh new file mode 100644 index 0000000..b8d21c8 --- /dev/null +++ b/Likelihood/Likelihood_analysis.sh @@ -0,0 +1,23 @@ +#!/bin/bash + +#SBATCH --job-name=likelihood # shows up in the output of 'squeue' +#SBATCH --time=4-23:59:59 # specify the requested wall-time +#SBATCH --partition=astro_long # specify the partition to run on +#SBATCH --nodes=4 # number of nodes allocated for this job +#SBATCH --ntasks-per-node=20 # number of MPI ranks per node +#SBATCH --cpus-per-task=1 # number of OpenMP threads per MPI rank +#SBATCH --mail-type=ALL,TIME_LIMIT_90,TIME_LIMIT,ARRAY_TASKS +#SBATCH --mail-user=vkc652@alumni.ku.dk +#SBATCH -o %A_%a.out # Standard output +#SBATCH -e %A_%a.err # Standard error +##SBATCH --exclude= # avoid nodes (e.g. --exclude=node786) + + +# Move to directory job was submitted from +cd $SLURM_SUBMIT_DIR + +# Command to run +mpiexec -n 4 python Likelihood_analysis_parser.py --E_npts=2 --nu_energy_num_nodes=10 --costhz_npts=2 --log10_energy_dep_npts=5 --epsabs=1.e-1 --epsrel=1.e-1 --n_live_points=5 --evidence_tolerance=0.5 + + + diff --git a/Likelihood/Likelihood_analysis_parser.py b/Likelihood/Likelihood_analysis_parser.py new file mode 100644 index 0000000..1422886 --- /dev/null +++ b/Likelihood/Likelihood_analysis_parser.py @@ -0,0 +1,146 @@ +import json +import numpy +from numpy import * +import scipy.stats, scipy +import pymultinest +from Full_likelihood import * +import argparse + +parser = argparse.ArgumentParser(description='Likelihood Analysis') + +parser.add_argument("--z_min", help="Redshift at which flux is generated", type=int, default=0) + +parser.add_argument("--z_max", help="Initial value redshift", type=int, default=4) + +parser.add_argument("--E_min", help="Minimum energy in array", type=int, default=3) + +parser.add_argument("--E_max", help="Maximum energy in array", type=int, default=8) + +parser.add_argument("--E_npts", help="Number of energy bins in array", type=int, default=200) + +parser.add_argument("--log10_nu_energy_min", help="Default: 2.8", type=float, default=2.8) + +parser.add_argument("--log10_nu_energy_max", help="Default: 9.2", type=float, default=9.2) + +parser.add_argument("--nu_energy_num_nodes", help="Default: 150", type=int, default=150) + +parser.add_argument("--costhz_npts", help="Default: 50", type=int, default=50) + +parser.add_argument("--log10_energy_dep_min", help="Default: 3.8", type=float, default=3.8) + +parser.add_argument("--log10_energy_dep_max", help="Default: 7.2", type=float, default=7.2) + +parser.add_argument("--log10_energy_dep_npts", help="Default: 50", type=int, default=50) + +parser.add_argument("--log10_energy_dep_int_min", help="Default: 4.0", type=float, default=4.0) + +parser.add_argument("--log10_energy_dep_int_max", help="Default: 7.0", type=float, default=7.0) + +parser.add_argument("--time_det_yr", help="Default: 8.0", type=float, default=8.0) + +parser.add_argument("--volume_total", help="Default: 6.440e14", type=float, default=6.440e14) + +parser.add_argument("--energy_nu_max", help="Default: 1.e8", type=float, default=1.e8) + +parser.add_argument("--epsabs", help="Default: 1.e-3", type=float, default=1.e-3) + +parser.add_argument("--epsrel", help="Default: 1.e-3", type=float, default=1.e-3) + +parser.add_argument("--verbose", help="Default: 0", type=int, default=0) + +parser.add_argument("--n_live_points", help="Default: 100", type=int, default=100) + +parser.add_argument("--evidence_tolerance", help="Default: 0.1", type=float, default=0.1) + + +args = parser.parse_args() + +z_min = args.z_min +z_max = args.z_max +E_min = args.E_min +E_max = args.E_max +E_npts = args.E_npts +log10_nu_energy_min = args.log10_nu_energy_min +log10_nu_energy_max = args.log10_nu_energy_max +nu_energy_num_nodes = args.nu_energy_num_nodes +costhz_npts = args.costhz_npts +log10_energy_dep_min = args.log10_energy_dep_min +log10_energy_dep_max = args.log10_energy_dep_max +log10_energy_dep_npts = args.log10_energy_dep_npts +log10_energy_dep_int_min = args.log10_energy_dep_int_min +log10_energy_dep_int_max = args.log10_energy_dep_int_max +time_det_yr = args.time_det_yr +volume_total = args.volume_total +energy_nu_max = args.energy_nu_max +epsabs = args.epsabs +epsrel = args.epsrel +verbose = args.verbose +n_live_points = args.n_live_points +evidence_tolerance = args.evidence_tolerance + + + +def Prior(cube, ndim, nparams): + + #Spectral index. Uniform prior between 2 and 3. + cube[0] = cube[0] + 2 + + """ + #Mass of mediator. Log uniform prior between 10^-5 and 10^2 + cube[1] = 10**(cube[1]*7 - 5) + + #Coupling constant. Log uniform prior between 10^-3 and 1. + cube[2] = 10**(cube[2]*3 -3) + + #Expected number of astrophysical neutrinos. Uniform distribution between 0 and 80. + cube[3] = cube[3] * 80 + + #Expected number of conv. atm. neutrinos. Uniform distribution between 0 and 80. + cube[4] = cube[4] * 80 + + #Expected number of prompt atm. neutrinos. Uniform distribution between 0 and 80. + cube[5] = cube[5] * 80 + + #Expected number of atm. muons. Uniform distribution between 0 and 80. + cube[6] = cube[6] * 80 + """ + return 0 + + +def Log_Like(cube, ndim, nparams): + + gamma = cube[0] + M = 0.01 #cube[1] + g = 0.03 #cube[2] + N_a = 20 #cube[3] + N_conv = 20 #cube[4] + N_pr = 20 #cube[5] + N_mu = 20 #cube[6] + + nu_energy_min = 10**log10_nu_energy_min + nu_energy_max = 10**log10_nu_energy_max + + likelihood = Full_likelihood(N_a, N_conv, N_pr, N_mu, g, M, gamma, nu_energy_min, nu_energy_max, z_min=z_min, z_max=z_max, E_min=E_min, E_max=E_max, E_npts=E_npts, + nu_energy_num_nodes=nu_energy_num_nodes, costhz_npts=costhz_npts, log10_energy_dep_int_min=log10_energy_dep_int_min, log10_energy_dep_int_max=log10_energy_dep_int_max, + log10_energy_dep_min=log10_energy_dep_min, log10_energy_dep_max=log10_energy_dep_max, log10_energy_dep_npts=log10_energy_dep_npts, + time_det_yr=time_det_yr, volume_total=volume_total, energy_nu_max=energy_nu_max, epsabs=epsabs, epsrel=epsrel, verbose=verbose) + + log_l = np.log10(likelihood) + + return log_l + + + + +parameters = ["gamma"]#, "M", "g", "N_a", "N_conv", "N_pr", "N_mu"] +n_params = len(parameters) + + + + +# Run MultiNest +pymultinest.run(Log_Like, Prior, n_params, outputfiles_basename='Likelihood_out_1D/', + resume=True, verbose=True, n_live_points=n_live_points, seed=1, + evidence_tolerance=evidence_tolerance, importance_nested_sampling=True) + +json.dump(parameters, open('Likelihood_out_1D/params.json', 'w')) # Save parameter names \ No newline at end of file diff --git a/Likelihood/Neutrino_Flux_Earth.py b/Likelihood/Neutrino_Flux_Earth.py new file mode 100644 index 0000000..66c219d --- /dev/null +++ b/Likelihood/Neutrino_Flux_Earth.py @@ -0,0 +1,99 @@ +from __future__ import division +import numpy as np +from scipy.integrate import ode + +c=299792458*100 + +def nt(z): + return 56*(1+z)**3 + +def L0(energy_nu, z, gamma, k=1, E_max=1.0e7): + return k*np.power(energy_nu,-gamma)*np.exp(-energy_nu/E_max) + + +def W(z, a=3.4 , b=-0.3 , c1=-3.5 , B=5000 , C=9 , eta=-10): + return ((1+z)**(a*eta)+((1+z)/B)**(b*eta)+((1+z)/C)**(c1*eta))**(1/eta) + +def L(z, energy_nu, gamma): + return W(z)*L0(energy_nu, z, gamma) + +def H(z, H0=0.678/(9.777752*3.16*1e16), OM=0.308, OL=0.692): + return H0*np.sqrt(OM*(1.+z)**3. + OL) + + +def sigma(energy_nu, g, M, m=1.e-10): + return (g**4/(16*np.pi))*(2*energy_nu*m)/((2*energy_nu*m-M**2)**2+((M**4*g**4)/(16*np.pi**2)))* 0.389379e-27 + + +def Adiabatic_Energy_Losses(z, energy_nu, nu_density, lst_energy_nu, lst_nu_density): + index = list(lst_energy_nu).index(energy_nu) + + if index < len(lst_energy_nu)-1: + diff = (lst_nu_density[index+1]-lst_nu_density[index])/(lst_energy_nu[index+1]-lst_energy_nu[index]) + else: + diff = 0 + return H(z)*(nu_density + energy_nu*diff) + +def Attenuation(z, energy_nu, nu_density, g, M, m=1.e-10): + return -c*nt(z)*sigma(energy_nu, g, M, m)*nu_density + +def Regeneration(z, energy_nu, lst_energy_nu, lst_nu_density, g, M, m=1.e-10): + regen = 0 + index = list(lst_energy_nu).index(energy_nu) + + for j in range (index, len(lst_energy_nu)-1): + regen += sigma(lst_energy_nu[j], g, M, m)*lst_nu_density[j]*(lst_energy_nu[j+1]-lst_energy_nu[j]) + + regen=c*nt(z)*regen/(energy_nu) + + return regen + +def Propagation_Eq(z, nu_density, energy_nu, lst_energy_nu, lst_nu_density, g, M, gamma, m=1.e-10): + rhs = 0 + + rhs += Adiabatic_Energy_Losses(z, energy_nu, nu_density, lst_energy_nu, lst_nu_density) + rhs += L(z, energy_nu, gamma) + rhs += Attenuation(z, energy_nu, nu_density, g, M, m=1.e-10) + rhs += Regeneration(z, energy_nu, lst_energy_nu, lst_nu_density, g, M, m=1.e-10) + + rhs = rhs/(-(1+z)*H(z)) + + return rhs + +def Neutrino_Flux(g, M, z_min, z_max, E_min, E_max, E_npts, gamma, m=1.e-10): + + def Integrand(z, nu_density, energy_nu): + return Propagation_Eq(z, nu_density, energy_nu, lst_energy_nu, lst_nu_density, g, M, gamma, m=1.e-10) + + solver = ode(Integrand, jac=None).set_integrator('dop853', atol=1.e-4, rtol=1.e-4, nsteps=500, max_step=1.e-3, verbosity=1) + + lst_energy_nu=np.power(10, np.linspace(E_min, E_max, E_npts)) + + lst_nu_density = [0.0]*len(lst_energy_nu) + + dz = 1.e-1 + + z = z_max + + while (z > z_min): + lst_nu_density_new = np.zeros(lst_energy_nu.size) + + for i in range(len(lst_energy_nu)): + + solver.set_initial_value(lst_nu_density[i], z) + solver.set_f_params(lst_energy_nu[i]) + sol = solver.integrate(solver.t-dz) + + lst_nu_density_new[i]=sol + + lst_nu_density = [x for x in lst_nu_density_new] + + z = z-dz + + save_array = np.zeros([E_npts, 2]) + save_array[:,0] = lst_energy_nu + save_array[:,1] = lst_nu_density + + #np.savetxt(external_flux_filename, save_array) + + return save_array diff --git a/Likelihood/Prob_dist_astro.py b/Likelihood/Prob_dist_astro.py new file mode 100644 index 0000000..e6a3760 --- /dev/null +++ b/Likelihood/Prob_dist_astro.py @@ -0,0 +1,256 @@ +from __future__ import division +import numpy as np +import os + +from Neutrino_Flux_Earth import * +from global_defs import * +from global_tools import * +from event_rate import * + +""" +Parameters: + N_{a, nu, p, mu}: + Total number of expected events from astrophysical, + conv. atmospheric, prompt atmospheric and atmospheric muon neutrinos. + N_obs_{sh, tr}: + Total number of observed showers and tracks. + E_dep: + Deposited energy in IceCube. + DNDE_dep: + Event rate spectra. + g: + Coupling constant. + M: + Mass of mediator. + gamma: + Spectral index (E^-gamma). +""" + + +def Prob_dist_astro_den(nu_energy_min, nu_energy_max, nu_energy_num_nodes, costhz_npts, Nu_Fluxes_Initial, log10_energy_dep_int_min, + log10_energy_dep_int_max, log10_energy_dep_min, log10_energy_dep_max, log10_energy_dep_npts, time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose): + + mix_params_data_set ='nufit_4_0_with_sk' + mix_params_mass_ordering ='no' + + # lst_mix_params is passed to NuSQuIDS and contains the mixing parameters + # [s12sq_bf, s23sq_bf, s13sq_bf, deltaCP_bf, Delta_m2_21_bf, Delta_m2_31_bf, Delta_m2_32_bf] + lst_mix_params = Mixing_Parameters(mix_params_data_set, mix_params_mass_ordering)[0] + + # Array of cos(theta_z) to compute + lst_costhz = np.linspace(-1.0, 1.0, costhz_npts) + + lst_flux_det, lst_flux_earth = \ + Nu_Fluxes_At_Detector(nu_energy_min, nu_energy_max, nu_energy_num_nodes, lst_costhz, Nu_Fluxes_Initial, + error_rel=1.e-7, error_abs=1.e-7, h_max=500., verbose_level=verbose, lst_mix_params=lst_mix_params, epsabs=1.e-8, epsrel=1.e-8, flag_return_nusquids_format=True) + + log10_energy_dep_int_step = log10_energy_dep_int_max - log10_energy_dep_int_min + + Event_spec = \ + Generate_Event_Spectrum_All_Sky(lst_flux_det, lst_costhz, filename_data_out_suffix='', + flag_save_data=False, flag_plot_histogram=False, flag_initialize_cross_sections=False, + flag_compute_shower_rate=True, flag_compute_track_rate=True, + flag_sh_nux_nc=True, flag_sh_nue_cc=True, flag_sh_nutau_cc=True, flag_sh_nul_electron_to_electron=True, + flag_sh_nuebar_electron_to_tau=False, lag_sh_nuebar_electron_to_hadrons=True, flag_sh_nutau_electron_to_tau=False, + flag_tr_numu_cc=True, flag_tr_nutau_cc=True, flag_tr_nuebar_electron_to_tau=False, + flag_tr_nutau_electron_to_tau=False, flag_tr_nuebar_electron_to_muon=False, flag_tr_numu_electron_to_muon=False, + log10_energy_dep_min=log10_energy_dep_min, log10_energy_dep_max=log10_energy_dep_max, log10_energy_dep_npts=log10_energy_dep_npts, + log10_energy_dep_int_min=log10_energy_dep_int_min, log10_energy_dep_int_max=log10_energy_dep_int_max, log10_energy_dep_int_step=log10_energy_dep_int_step, + time_det_yr=time_det_yr, volume_total=volume_total, energy_nu_max=energy_nu_max, integration_method='quad', + miniter=1, maxiter=500, epsabs=epsabs, epsrel=epsrel, s=0, lst_headers_argparse=None, verbose=verbose) + + print("Event=", Event_spec[0][2][:]) + + Denominator = np.sum(Event_spec[0][2][:] + Event_spec[1][2][:] + Event_spec[2][2][:] + Event_spec[3][2][:] + Event_spec[4][2][:] + Event_spec[5][2][:]) + + print("Denominator=", Denominator) + + return Denominator + + +def Prob_dist_astro_num(nu_energy_min, nu_energy_max, nu_energy_num_nodes, costhz_val, Nu_Fluxes_Initial, energy_dep, + time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose, flag_compute_shower_rate, flag_compute_track_rate): + + mix_params_data_set ='nufit_4_0_with_sk' + mix_params_mass_ordering ='no' + + lst_mix_params = Mixing_Parameters(mix_params_data_set, mix_params_mass_ordering)[0] + + lst_costhz = np.array([costhz_val]) + + lst_flux_det, lst_flux_earth = \ + Nu_Fluxes_At_Detector(nu_energy_min, nu_energy_max, nu_energy_num_nodes, lst_costhz, Nu_Fluxes_Initial, + error_rel=1.e-7, error_abs=1.e-7, h_max=500., verbose_level=verbose, lst_mix_params=lst_mix_params, epsabs=1.e-8, epsrel=1.e-8, flag_return_nusquids_format=True) + + + if (verbose > 0): print("costhz = "+str(costhz_val)) + + if (verbose > 0): print(" Building flux splines... ", end='') + + lst_energy_nu = lst_flux_det[0][0] # [GeV] + + lst_flux_det_nue = lst_flux_det[0][1] # nu_e [GeV^{-1} cm^{-2} s^{-1} sr^{-1}] + + lst_flux_det_nuebar = lst_flux_det[0][2] # nu_e-bar + + lst_flux_det_numu = lst_flux_det[0][3] # nu_mu + + lst_flux_det_numubar = lst_flux_det[0][4] # nu_mu-bar + + lst_flux_det_nutau = lst_flux_det[0][5] # nu_tau + + lst_flux_det_nutaubar = lst_flux_det[0][6] # nu_tau-bar + + + # Interpolating functions [GeV^{-1} cm^{-2} s^{-1} sr^{-1}] + interp_flux_det_nue = interp1d(lst_energy_nu, lst_flux_det_nue, + kind='linear', bounds_error=False, fill_value='extrapolate') + interp_flux_det_nuebar = interp1d(lst_energy_nu, lst_flux_det_nuebar, + kind='linear', bounds_error=False, fill_value='extrapolate') + interp_flux_det_numu = interp1d(lst_energy_nu, lst_flux_det_numu, + kind='linear', bounds_error=False, fill_value='extrapolate') + interp_flux_det_numubar = interp1d(lst_energy_nu, lst_flux_det_numubar, + kind='linear', bounds_error=False, fill_value='extrapolate') + interp_flux_det_nutau = interp1d(lst_energy_nu, lst_flux_det_nutau, + kind='linear', bounds_error=False, fill_value='extrapolate') + interp_flux_det_nutaubar = interp1d(lst_energy_nu, lst_flux_det_nutaubar, + kind='linear', bounds_error=False, fill_value='extrapolate') + + # Flux functions to integrate in E_dep [GeV^{-1} cm^{-2} s^{-1} sr^{-1}] + Flux_NuE_At_Detector = lambda energy_nu: \ + interp_flux_det_nue(energy_nu) + Flux_NuEBar_At_Detector = lambda energy_nu: \ + interp_flux_det_nuebar(energy_nu) + Flux_NuMu_At_Detector = lambda energy_nu: \ + interp_flux_det_numu(energy_nu) + Flux_NuMuBar_At_Detector = lambda energy_nu: \ + interp_flux_det_numubar(energy_nu) + Flux_NuTau_At_Detector = lambda energy_nu: \ + interp_flux_det_nutau(energy_nu) + Flux_NuTauBar_At_Detector = lambda energy_nu: \ + interp_flux_det_nutaubar(energy_nu) + lst_Flux_Nu_At_Detector = [Flux_NuE_At_Detector, Flux_NuMu_At_Detector, + Flux_NuTau_At_Detector, Flux_NuEBar_At_Detector, + Flux_NuMuBar_At_Detector, Flux_NuTauBar_At_Detector] + + if (verbose > 0): print("Done") + + # Detection time + time_det = time_det_yr*365.*24.*60.*60. # [s] + + # === Shower rate === + + if (flag_compute_shower_rate == True): + + # Calculate the shower rate + if (verbose > 0): print(" Calculating the shower rate... ", \ + end='') + # For each value of energy_dep, Diff_Shower_Rate_Dep_Energy_Total returns + # [diff_shower_rate_nue_nuebar, diff_shower_rate_numu_numubar, + # diff_shower_rate_nutau_nutaubar] + lst_diff_rate = \ + Diff_Shower_Rate_Dep_Energy_Total(energy_dep, time_det, lst_Flux_Nu_At_Detector, volume_total=volume_total, + energy_nu_max=energy_nu_max, integration_method='quad', + miniter=1, maxiter=500, epsabs=epsabs, epsrel=epsrel, + flag_nux_nc=True, flag_nue_cc=True, flag_nutau_cc=True, + flag_nul_electron_to_electron= True, flag_nuebar_electron_to_tau= False, + flag_nuebar_electron_to_hadrons= True, flag_nutau_electron_to_tau= False) + + # === Track rate === + + elif (flag_compute_track_rate == True): + + # Calculate the track rate + if (verbose > 0): print(" Calculating the track rate... ", end='') + # For each value of energy_dep, Diff_Track_Rate_Dep_Energy_Total returns + # [diff_track_rate_nue_nuebar, diff_track_rate_numu_numubar, + # diff_track_rate_nutau_nutaubar] + lst_diff_rate = \ + Diff_Track_Rate_Dep_Energy_Total(energy_dep, time_det, lst_Flux_Nu_At_Detector, volume_total=volume_total, + energy_nu_max=energy_nu_max, integration_method='quad', + miniter=1, maxiter=500, epsabs=epsabs, epsrel=epsrel, + flag_numu_cc=True, flag_nutau_cc=True, flag_nuebar_electron_to_tau=False, + flag_nutau_electron_to_tau=False, flag_nuebar_electron_to_muon= False, flag_numu_electron_to_muon= False) + + Numerator = np.array([lst_diff_rate[0] + lst_diff_rate[1] + lst_diff_rate[2]]) + + return Numerator + + +def Prob_dist_astro(g, M, z_min, z_max, E_min, E_max, E_npts, gamma, nu_energy_min, nu_energy_max, nu_energy_num_nodes, costhz_val, costhz_npts, energy_dep, + log10_energy_dep_int_min, log10_energy_dep_int_max, log10_energy_dep_min, log10_energy_dep_max, log10_energy_dep_npts, + time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose, flag_compute_shower_rate, flag_compute_track_rate): + + flux_array = Neutrino_Flux(g, M, z_min, z_max, E_min, E_max, E_npts, gamma, m=1.e-10) + + lst_energy_nu = flux_array[:,0] + + lst_nu_flux = flux_array[:,1] + + interp_nu_flux = interp1d(lst_energy_nu, lst_nu_flux, kind='linear', bounds_error=False, fill_value='extrapolate') + + Nu_Fluxes_Initial = lambda lst_energy_nu, **kwargs: Nu_Fluxes_Initial_Format_NuSQuIDS(lst_energy_nu, interp_nu_flux, **kwargs) + + num = \ + Prob_dist_astro_num(nu_energy_min, nu_energy_max, nu_energy_num_nodes, costhz_val, Nu_Fluxes_Initial, energy_dep, + time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose, flag_compute_shower_rate = flag_compute_shower_rate, flag_compute_track_rate = flag_compute_track_rate) + + den = \ + Prob_dist_astro_den(nu_energy_min, nu_energy_max, nu_energy_num_nodes, costhz_npts, Nu_Fluxes_Initial, log10_energy_dep_int_min, + log10_energy_dep_int_max, log10_energy_dep_min, log10_energy_dep_max, log10_energy_dep_npts, time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose) + + prob = num/den + + print("Prob_astro=", prob) + + return prob + + + + +""" +external_flux_filename='in/fluxes/Freestreaming200.txt' + +lst_energy_nu, lst_nu_flux = Read_Data_File(os.getcwd()+'/'+external_flux_filename) + +interp_nu_flux = interp1d(lst_energy_nu, lst_nu_flux, kind='linear', bounds_error=False, fill_value='extrapolate') + +test_flux_initial = Nu_Fluxes_Initial = lambda lst_energy_nu, **kwargs: Nu_Fluxes_Initial_Format_NuSQuIDS(lst_energy_nu, interp_nu_flux, **kwargs) + +Initialize_All_Cross_Sections(prefix_dsdy_nu_nucleon='dsdy_ct14nn', + prefix_dsdy_nu_electron='dsdy_electron', + prefix_cs_nu_electron='cs_electron', kx=1, ky=1, k=1, s=0, + verbose=0) + +log10_nu_energy_min = 2.8 +log10_nu_energy_max = 9.2 + +test = Prob_dist_astro(nu_energy_min = 10**log10_nu_energy_min, nu_energy_max = 10**log10_nu_energy_max, nu_energy_num_nodes = 150, costhz = 0.5, costhz_npts = 2, Nu_Fluxes_Initial = test_flux_initial, + energy_dep = 1e5, log10_energy_dep_int_min = 4, log10_energy_dep_int_max = 7, log10_energy_dep_min = 3.8, log10_energy_dep_max = 7.2, log10_energy_dep_npts = 50, + time_det_yr = 8, volume_total = 6.44e14, energy_nu_max = 1e8, epsabs =1e-3, epsrel = 1e-3, verbose=1, flag_compute_shower_rate = True, flag_compute_track_rate = False) + +np.savetxt('test_prob.txt', test) + + +def Full_likelihood(g, M, external_flux_filename, z_min, z_max, E_min, E_max, E_npts, gamma): + + flux_array = Neutrino_Flux(g, M, external_flux_filename, z_min, z_max, E_min, E_max, E_npts, gamma, m=1.e-10) + + lst_energy_nu, lst_nu_flux = Read_Data_File(os.getcwd()+'/'+external_flux_filename) + + interp_nu_flux = interp1d(lst_energy_nu, lst_nu_flux, kind='linear', bounds_error=False, fill_value='extrapolate') + + Nu_Fluxes_Initial = lambda lst_energy_nu, **kwargs: Nu_Fluxes_Initial_Format_NuSQuIDS(lst_energy_nu, interp_nu_flux, **kwargs) + + # Initialize all ds/dy and cs cross sections. These are loaded as global + # interpolating functions + + Initialize_All_Cross_Sections(prefix_dsdy_nu_nucleon='dsdy_ct14nn', + prefix_dsdy_nu_electron='dsdy_electron', + prefix_cs_nu_electron='cs_electron', kx=kx, ky=ky, k=k, s=s, + verbose=verbose) + + # Detection time + time_det_yr = 8 + +""" diff --git a/Likelihood/Prob_dist_atm.py b/Likelihood/Prob_dist_atm.py new file mode 100644 index 0000000..bef2be2 --- /dev/null +++ b/Likelihood/Prob_dist_atm.py @@ -0,0 +1,596 @@ +from __future__ import division +import numpy as np +import os + +from flux_atm import * +from global_defs import * +from global_tools import * +from event_rate import * + +""" +Parameters: + N_{a, nu, p, mu}: + Total number of expected events from astrophysical, + conv. atmospheric, prompt atmospheric and atmospheric muon neutrinos. + N_obs_{sh, tr}: + Total number of observed showers and tracks. + E_dep: + Deposited energy in IceCube. + DNDE_dep: + Event rate spectra. + g: + Coupling constant. + M: + Mass of mediator. + gamma: + Spectral index (E^-gamma). +""" + + +def Prob_dist_atm_conv_pr_den(nu_energy_min, nu_energy_max, nu_energy_num_nodes, costhz_npts, log10_energy_dep_int_min, log10_energy_dep_int_max, log10_energy_dep_min, + log10_energy_dep_max, log10_energy_dep_npts, time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose, flag_use_atm_fluxes_conv, flag_use_atm_fluxes_pr, flag_apply_self_veto): + + log10_energy_dep_int_step = log10_energy_dep_int_max - log10_energy_dep_int_min + + mix_params_data_set ='nufit_4_0_with_sk' + mix_params_mass_ordering ='no' + + # lst_mix_params is passed to NuSQuIDS and contains the mixing parameters + # [s12sq_bf, s23sq_bf, s13sq_bf, deltaCP_bf, Delta_m2_21_bf, Delta_m2_31_bf, Delta_m2_32_bf] + lst_mix_params = Mixing_Parameters(mix_params_data_set, mix_params_mass_ordering)[0] + + # Array of cos(theta_z) to compute + lst_costhz = np.linspace(-1.0, 1.0, costhz_npts) + + # [Adim], [GeV], [GeV cm^{-2} s^{-1} sr^{-1}], ... + lst_costhz_sel, lst_energy_sel, flux_mum_conv, flux_mup_conv, \ + flux_mum_pr, flux_mup_pr, flux_nue_conv, flux_nuebar_conv, \ + flux_nue_pr, flux_nuebar_pr, flux_numu_conv, flux_numubar_conv, \ + flux_numu_pr, flux_numubar_pr, flux_nutau_pr, flux_nutaubar_pr = \ + Initialize_Atm_Fluxes(flux_set='avg', flag_return_total=False, + flag_return_plus_minus=False, kx=1, ky=1, s=0, verbose=verbose) + + lst_flux_earth = [] + lst_flux_det = [] + + for costhz in lst_costhz: + + # Build interpolating functions + + if (flag_use_atm_fluxes_conv == True and \ + flag_use_atm_fluxes_pr == False): + + # Use the conventional flux only + # [GeV cm^{-2} s^{-1} sr^{-1}] + + nue_flux = lambda energy_nu: \ + flux_nue_conv(costhz, energy_nu)[0][0] + nuebar_flux = lambda energy_nu: \ + flux_nuebar_conv(costhz, energy_nu)[0][0] + numu_flux = lambda energy_nu: \ + flux_numu_conv(costhz, energy_nu)[0][0] + numubar_flux = lambda energy_nu: \ + flux_numubar_conv(costhz, energy_nu)[0][0] + nutau_flux = lambda energy_nu: 0.0 + nutaubar_flux = lambda energy_nu: 0.0 + + elif (flag_use_atm_fluxes_conv == False and \ + flag_use_atm_fluxes_pr == True): + + # Use the prompt flux only + # [GeV cm^{-2} s^{-1} sr^{-1}] + + nue_flux = lambda energy_nu: \ + flux_nue_pr(costhz, energy_nu)[0][0] + nuebar_flux = lambda energy_nu: \ + flux_nuebar_pr(costhz, energy_nu)[0][0] + numu_flux = lambda energy_nu: \ + flux_numu_pr(costhz, energy_nu)[0][0] + numubar_flux = lambda energy_nu: \ + flux_numubar_pr(costhz, energy_nu)[0][0] + nutau_flux = lambda energy_nu: \ + flux_nutau_pr(costhz, energy_nu)[0][0] + nutaubar_flux = lambda energy_nu: \ + flux_nutaubar_pr(costhz, energy_nu)[0][0] + + elif (flag_use_atm_fluxes_conv == True and \ + flag_use_atm_fluxes_pr == True): + + print("flag_use_atm_fluxes_conv and flag_use_atm_fluxes_pr cannot "+ \ + "both be True") + quit() + + # Nu_Fluxes_Initial is fed to NuSQuIDS + # [GeV^{-1} cm^{-2} s^{-1} sr^{-1}] + Nu_Fluxes_Initial = lambda lst_energy, **kwargs: \ + Nu_Fluxes_Initial_Individual_Species_Format_NuSQuIDS(lst_energy, + nue_flux, nuebar_flux, numu_flux, numubar_flux, nutau_flux, + nutaubar_flux, flag_divide_by_energy_sq=True, **kwargs) + + # Compute the fluxes at the detector for the current value of costhz + # [GeV^{-1} cm^{-2} s^{-1} sr^{-1}] + # lst_flux_det and lst_flux_earth are: + # [[lst_nu_energy_out, flux_nu_e, flux_nu_e_bar, flux_nu_m, flux_nu_m_bar, + # flux_nu_t, flux_nu_t_bar]_costhz0, + # [lst_nu_energy_out, flux_nu_e, flux_nu_e_bar, flux_nu_m, flux_nu_m_bar, + # flux_nu_t, flux_nu_t_bar]_costhz1, + # ... + # [lst_nu_energy_out, flux_nu_e, flux_nu_e_bar, flux_nu_m, flux_nu_m_bar, + # flux_nu_t, flux_nu_t_bar]_costhzN, + flux_det, flux_earth = \ + Nu_Fluxes_At_Detector(nu_energy_min, nu_energy_max, + nu_energy_num_nodes, [costhz], Nu_Fluxes_Initial, + error_rel=1.e-7, error_abs=1.e-7, h_max=500., + verbose_level=verbose, lst_mix_params=lst_mix_params) + + # Concatenate the fluxes for the current costhz into the global list + lst_flux_det.append(flux_det[0]) + lst_flux_earth.append(np.array(flux_earth[0])) + + + ############################################################################### + # Apply the atmospheric self-veto after propagating the fluxes to the detector + ############################################################################### + + if (((flag_use_atm_fluxes_conv == True or flag_use_atm_fluxes_pr == True)) and \ + flag_apply_self_veto == True): + + # Passing fractions + # Call the interpolating functions as pf_spl(energy, costhz) + lst_energy_pf, lst_costhz_pf, pf_nue_conv, pf_nuebar_conv, pf_numu_conv, \ + pf_numubar_conv, pf_nue_pr, pf_nuebar_pr, pf_numu_pr, pf_numubar_pr = \ + Initialize_Passing_Fractions(kx=1, ky=1, s=0, verbose=verbose) + + tmp = [] + + # Apply the veto only to lst_flux_det + for i, costhz in enumerate(lst_costhz): + + lst_nu_energy_out = lst_flux_det[i][0] + flux_nu_e = lst_flux_det[i][1] + flux_nu_e_bar = lst_flux_det[i][2] + flux_nu_m = lst_flux_det[i][3] + flux_nu_m_bar = lst_flux_det[i][4] + flux_nu_t = lst_flux_det[i][5] + flux_nu_t_bar = lst_flux_det[i][6] + + flux_nu_e_tmp = [] + flux_nu_e_bar_tmp = [] + flux_nu_m_tmp = [] + flux_nu_m_bar_tmp = [] + flux_nu_t_tmp = [] + flux_nu_t_bar_tmp = [] + + if (flag_use_atm_fluxes_conv == True): + + flux_nu_e_tmp = \ + [pf_nue_conv(lst_nu_energy_out[j], costhz)[0][0] * \ + flux_nu_e[j] for j in range(len(lst_nu_energy_out))] + flux_nu_e_bar_tmp = \ + [pf_nuebar_conv(lst_nu_energy_out[j], costhz)[0][0] * \ + flux_nu_e_bar[j] for j in range(len(lst_nu_energy_out))] + flux_nu_m_tmp = \ + [pf_numu_conv(lst_nu_energy_out[j], costhz)[0][0] * \ + flux_nu_m[j] for j in range(len(lst_nu_energy_out))] + flux_nu_m_bar_tmp = \ + [pf_numubar_conv(lst_nu_energy_out[j], costhz)[0][0] * \ + flux_nu_m_bar[j] for j in range(len(lst_nu_energy_out))] + flux_nu_t_tmp = [0.0 for j in range(len(lst_nu_energy_out))] + flux_nu_t_bar_tmp = [0.0 for j in range(len(lst_nu_energy_out))] + + elif (flag_use_atm_fluxes_pr == True): + + flux_nu_e_tmp = \ + [pf_nue_pr(lst_nu_energy_out[j], costhz)[0][0] * \ + flux_nu_e[j] for j in range(len(lst_nu_energy_out))] + flux_nu_e_bar_tmp = \ + [pf_nuebar_pr(lst_nu_energy_out[j], costhz)[0][0] * \ + flux_nu_e_bar[j] for j in range(len(lst_nu_energy_out))] + flux_nu_m_tmp = \ + [pf_numu_pr(lst_nu_energy_out[j], costhz)[0][0] * \ + flux_nu_m[j] for j in range(len(lst_nu_energy_out))] + flux_nu_m_bar_tmp = \ + [pf_numubar_pr(lst_nu_energy_out[j], costhz)[0][0] * \ + flux_nu_m_bar[j] for j in range(len(lst_nu_energy_out))] + # We do not self-veto on prompt nu_tau (IceCube does not either) + flux_nu_t_tmp = [x for x in flux_nu_t] + flux_nu_t_bar_tmp = [x for x in flux_nu_t_bar] + + tmp.append([lst_nu_energy_out, flux_nu_e_tmp, flux_nu_e_bar_tmp, + flux_nu_m_tmp, flux_nu_m_bar_tmp, flux_nu_t_tmp, + flux_nu_t_bar_tmp]) + + lst_flux_det = [x for x in tmp] + + + Event_spec = \ + Generate_Event_Spectrum_All_Sky(lst_flux_det, lst_costhz, filename_data_out_suffix='', + flag_save_data=False, flag_plot_histogram=False, flag_initialize_cross_sections=False, + flag_compute_shower_rate=True, flag_compute_track_rate=True, + flag_sh_nux_nc=True, flag_sh_nue_cc=True, flag_sh_nutau_cc=True, flag_sh_nul_electron_to_electron=True, + flag_sh_nuebar_electron_to_tau=False, lag_sh_nuebar_electron_to_hadrons=True, flag_sh_nutau_electron_to_tau=False, + flag_tr_numu_cc=True, flag_tr_nutau_cc=True, flag_tr_nuebar_electron_to_tau=False, + flag_tr_nutau_electron_to_tau=False, flag_tr_nuebar_electron_to_muon=False, flag_tr_numu_electron_to_muon=False, + log10_energy_dep_min=log10_energy_dep_min, log10_energy_dep_max=log10_energy_dep_max, log10_energy_dep_npts=log10_energy_dep_npts, + log10_energy_dep_int_min=log10_energy_dep_int_min, log10_energy_dep_int_max=log10_energy_dep_int_max, log10_energy_dep_int_step=log10_energy_dep_int_step, + time_det_yr=time_det_yr, volume_total=volume_total, energy_nu_max=energy_nu_max, integration_method='quad', + miniter=1, maxiter=500, epsabs=epsabs, epsrel=epsrel, s=0, lst_headers_argparse=None, verbose=verbose) + + Denominator = np.sum(Event_spec[0][2] + Event_spec[1][2] + Event_spec[2][2] + Event_spec[3][2] + Event_spec[4][2] + Event_spec[5][2]) + + print("Denominator_atm=", Denominator) + + return Denominator + + +def Prob_dist_atm_conv_pr_num(nu_energy_min, nu_energy_max, nu_energy_num_nodes, costhz_val, energy_dep, time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose, + flag_compute_shower_rate, flag_compute_track_rate, flag_use_atm_fluxes_conv, flag_use_atm_fluxes_pr, flag_apply_self_veto): + + + mix_params_data_set ='nufit_4_0_with_sk' + mix_params_mass_ordering ='no' + + # lst_mix_params is passed to NuSQuIDS and contains the mixing parameters + # [s12sq_bf, s23sq_bf, s13sq_bf, deltaCP_bf, Delta_m2_21_bf, Delta_m2_31_bf, Delta_m2_32_bf] + lst_mix_params = Mixing_Parameters(mix_params_data_set, mix_params_mass_ordering)[0] + + lst_costhz = np.array([costhz_val]) + + + # [Adim], [GeV], [GeV cm^{-2} s^{-1} sr^{-1}], ... + lst_costhz_sel, lst_energy_sel, flux_mum_conv, flux_mup_conv, \ + flux_mum_pr, flux_mup_pr, flux_nue_conv, flux_nuebar_conv, \ + flux_nue_pr, flux_nuebar_pr, flux_numu_conv, flux_numubar_conv, \ + flux_numu_pr, flux_numubar_pr, flux_nutau_pr, flux_nutaubar_pr = \ + Initialize_Atm_Fluxes(flux_set='avg', flag_return_total=False, + flag_return_plus_minus=False, kx=1, ky=1, s=0, verbose=verbose) + + lst_flux_earth = [] + lst_flux_det = [] + + for costhz in lst_costhz: + + # Build interpolating functions + + if (flag_use_atm_fluxes_conv == True and \ + flag_use_atm_fluxes_pr == False): + + # Use the conventional flux only + # [GeV cm^{-2} s^{-1} sr^{-1}] + + nue_flux = lambda energy_nu: \ + flux_nue_conv(costhz, energy_nu)[0][0] + nuebar_flux = lambda energy_nu: \ + flux_nuebar_conv(costhz, energy_nu)[0][0] + numu_flux = lambda energy_nu: \ + flux_numu_conv(costhz, energy_nu)[0][0] + numubar_flux = lambda energy_nu: \ + flux_numubar_conv(costhz, energy_nu)[0][0] + nutau_flux = lambda energy_nu: 0.0 + nutaubar_flux = lambda energy_nu: 0.0 + + elif (flag_use_atm_fluxes_conv == False and \ + flag_use_atm_fluxes_pr == True): + + # Use the prompt flux only + # [GeV cm^{-2} s^{-1} sr^{-1}] + + nue_flux = lambda energy_nu: \ + flux_nue_pr(costhz, energy_nu)[0][0] + nuebar_flux = lambda energy_nu: \ + flux_nuebar_pr(costhz, energy_nu)[0][0] + numu_flux = lambda energy_nu: \ + flux_numu_pr(costhz, energy_nu)[0][0] + numubar_flux = lambda energy_nu: \ + flux_numubar_pr(costhz, energy_nu)[0][0] + nutau_flux = lambda energy_nu: \ + flux_nutau_pr(costhz, energy_nu)[0][0] + nutaubar_flux = lambda energy_nu: \ + flux_nutaubar_pr(costhz, energy_nu)[0][0] + + elif (flag_use_atm_fluxes_conv == True and \ + flag_use_atm_fluxes_pr == True): + + print("flag_use_atm_fluxes_conv and flag_use_atm_fluxes_pr cannot "+ \ + "both be True") + quit() + + # Nu_Fluxes_Initial is fed to NuSQuIDS + # [GeV^{-1} cm^{-2} s^{-1} sr^{-1}] + Nu_Fluxes_Initial = lambda lst_energy, **kwargs: \ + Nu_Fluxes_Initial_Individual_Species_Format_NuSQuIDS(lst_energy, + nue_flux, nuebar_flux, numu_flux, numubar_flux, nutau_flux, + nutaubar_flux, flag_divide_by_energy_sq=True, **kwargs) + + # Compute the fluxes at the detector for the current value of costhz + # [GeV^{-1} cm^{-2} s^{-1} sr^{-1}] + # lst_flux_det and lst_flux_earth are: + # [[lst_nu_energy_out, flux_nu_e, flux_nu_e_bar, flux_nu_m, flux_nu_m_bar, + # flux_nu_t, flux_nu_t_bar]_costhz0, + # [lst_nu_energy_out, flux_nu_e, flux_nu_e_bar, flux_nu_m, flux_nu_m_bar, + # flux_nu_t, flux_nu_t_bar]_costhz1, + # ... + # [lst_nu_energy_out, flux_nu_e, flux_nu_e_bar, flux_nu_m, flux_nu_m_bar, + # flux_nu_t, flux_nu_t_bar]_costhzN, + flux_det, flux_earth = \ + Nu_Fluxes_At_Detector(nu_energy_min, nu_energy_max, + nu_energy_num_nodes, [costhz], Nu_Fluxes_Initial, + error_rel=1.e-7, error_abs=1.e-7, h_max=500., + verbose_level=verbose, lst_mix_params=lst_mix_params) + + # Concatenate the fluxes for the current costhz into the global list + lst_flux_det.append(flux_det[0]) + lst_flux_earth.append(np.array(flux_earth[0])) + + + ############################################################################### + # Apply the atmospheric self-veto after propagating the fluxes to the detector + ############################################################################### + + if (((flag_use_atm_fluxes_conv == True or flag_use_atm_fluxes_pr == True)) and \ + flag_apply_self_veto == True): + + # Passing fractions + # Call the interpolating functions as pf_spl(energy, costhz) + lst_energy_pf, lst_costhz_pf, pf_nue_conv, pf_nuebar_conv, pf_numu_conv, \ + pf_numubar_conv, pf_nue_pr, pf_nuebar_pr, pf_numu_pr, pf_numubar_pr = \ + Initialize_Passing_Fractions(kx=1, ky=1, s=0, verbose=verbose) + + tmp = [] + + # Apply the veto only to lst_flux_det + for i, costhz in enumerate(lst_costhz): + + lst_nu_energy_out = lst_flux_det[i][0] + flux_nu_e = lst_flux_det[i][1] + flux_nu_e_bar = lst_flux_det[i][2] + flux_nu_m = lst_flux_det[i][3] + flux_nu_m_bar = lst_flux_det[i][4] + flux_nu_t = lst_flux_det[i][5] + flux_nu_t_bar = lst_flux_det[i][6] + + flux_nu_e_tmp = [] + flux_nu_e_bar_tmp = [] + flux_nu_m_tmp = [] + flux_nu_m_bar_tmp = [] + flux_nu_t_tmp = [] + flux_nu_t_bar_tmp = [] + + if (flag_use_atm_fluxes_conv == True): + + flux_nu_e_tmp = \ + [pf_nue_conv(lst_nu_energy_out[j], costhz)[0][0] * \ + flux_nu_e[j] for j in range(len(lst_nu_energy_out))] + flux_nu_e_bar_tmp = \ + [pf_nuebar_conv(lst_nu_energy_out[j], costhz)[0][0] * \ + flux_nu_e_bar[j] for j in range(len(lst_nu_energy_out))] + flux_nu_m_tmp = \ + [pf_numu_conv(lst_nu_energy_out[j], costhz)[0][0] * \ + flux_nu_m[j] for j in range(len(lst_nu_energy_out))] + flux_nu_m_bar_tmp = \ + [pf_numubar_conv(lst_nu_energy_out[j], costhz)[0][0] * \ + flux_nu_m_bar[j] for j in range(len(lst_nu_energy_out))] + flux_nu_t_tmp = [0.0 for j in range(len(lst_nu_energy_out))] + flux_nu_t_bar_tmp = [0.0 for j in range(len(lst_nu_energy_out))] + + elif (flag_use_atm_fluxes_pr == True): + + flux_nu_e_tmp = \ + [pf_nue_pr(lst_nu_energy_out[j], costhz)[0][0] * \ + flux_nu_e[j] for j in range(len(lst_nu_energy_out))] + flux_nu_e_bar_tmp = \ + [pf_nuebar_pr(lst_nu_energy_out[j], costhz)[0][0] * \ + flux_nu_e_bar[j] for j in range(len(lst_nu_energy_out))] + flux_nu_m_tmp = \ + [pf_numu_pr(lst_nu_energy_out[j], costhz)[0][0] * \ + flux_nu_m[j] for j in range(len(lst_nu_energy_out))] + flux_nu_m_bar_tmp = \ + [pf_numubar_pr(lst_nu_energy_out[j], costhz)[0][0] * \ + flux_nu_m_bar[j] for j in range(len(lst_nu_energy_out))] + # We do not self-veto on prompt nu_tau (IceCube does not either) + flux_nu_t_tmp = [x for x in flux_nu_t] + flux_nu_t_bar_tmp = [x for x in flux_nu_t_bar] + + tmp.append([lst_nu_energy_out, flux_nu_e_tmp, flux_nu_e_bar_tmp, + flux_nu_m_tmp, flux_nu_m_bar_tmp, flux_nu_t_tmp, + flux_nu_t_bar_tmp]) + + lst_flux_det = [x for x in tmp] + + + + if (verbose > 0): print("costhz = "+str(costhz_val)) + + if (verbose > 0): print(" Building flux splines... ", end='') + + lst_energy_nu = lst_flux_det[0][0] # [GeV] + + lst_flux_det_nue = lst_flux_det[0][1] # nu_e [GeV^{-1} cm^{-2} s^{-1} sr^{-1}] + + lst_flux_det_nuebar = lst_flux_det[0][2] # nu_e-bar + + lst_flux_det_numu = lst_flux_det[0][3] # nu_mu + + lst_flux_det_numubar = lst_flux_det[0][4] # nu_mu-bar + + lst_flux_det_nutau = lst_flux_det[0][5] # nu_tau + + lst_flux_det_nutaubar = lst_flux_det[0][6] # nu_tau-bar + + + # Interpolating functions [GeV^{-1} cm^{-2} s^{-1} sr^{-1}] + interp_flux_det_nue = interp1d(lst_energy_nu, lst_flux_det_nue, + kind='linear', bounds_error=False, fill_value='extrapolate') + interp_flux_det_nuebar = interp1d(lst_energy_nu, lst_flux_det_nuebar, + kind='linear', bounds_error=False, fill_value='extrapolate') + interp_flux_det_numu = interp1d(lst_energy_nu, lst_flux_det_numu, + kind='linear', bounds_error=False, fill_value='extrapolate') + interp_flux_det_numubar = interp1d(lst_energy_nu, lst_flux_det_numubar, + kind='linear', bounds_error=False, fill_value='extrapolate') + interp_flux_det_nutau = interp1d(lst_energy_nu, lst_flux_det_nutau, + kind='linear', bounds_error=False, fill_value='extrapolate') + interp_flux_det_nutaubar = interp1d(lst_energy_nu, lst_flux_det_nutaubar, + kind='linear', bounds_error=False, fill_value='extrapolate') + + # Flux functions to integrate in E_dep [GeV^{-1} cm^{-2} s^{-1} sr^{-1}] + Flux_NuE_At_Detector = lambda energy_nu: \ + interp_flux_det_nue(energy_nu) + Flux_NuEBar_At_Detector = lambda energy_nu: \ + interp_flux_det_nuebar(energy_nu) + Flux_NuMu_At_Detector = lambda energy_nu: \ + interp_flux_det_numu(energy_nu) + Flux_NuMuBar_At_Detector = lambda energy_nu: \ + interp_flux_det_numubar(energy_nu) + Flux_NuTau_At_Detector = lambda energy_nu: \ + interp_flux_det_nutau(energy_nu) + Flux_NuTauBar_At_Detector = lambda energy_nu: \ + interp_flux_det_nutaubar(energy_nu) + lst_Flux_Nu_At_Detector = [Flux_NuE_At_Detector, Flux_NuMu_At_Detector, + Flux_NuTau_At_Detector, Flux_NuEBar_At_Detector, + Flux_NuMuBar_At_Detector, Flux_NuTauBar_At_Detector] + + if (verbose > 0): print("Done") + + # Detection time + time_det = time_det_yr*365.*24.*60.*60. # [s] + + # === Shower rate === + + if (flag_compute_shower_rate == True): + + # Calculate the shower rate + if (verbose > 0): print(" Calculating the shower rate... ", \ + end='') + # For each value of energy_dep, Diff_Shower_Rate_Dep_Energy_Total returns + # [diff_shower_rate_nue_nuebar, diff_shower_rate_numu_numubar, + # diff_shower_rate_nutau_nutaubar] + lst_diff_rate = \ + Diff_Shower_Rate_Dep_Energy_Total(energy_dep, time_det, lst_Flux_Nu_At_Detector, volume_total=volume_total, + energy_nu_max=energy_nu_max, integration_method='quad', + miniter=1, maxiter=500, epsabs=epsabs, epsrel=epsrel, + flag_nux_nc=True, flag_nue_cc=True, flag_nutau_cc=True, + flag_nul_electron_to_electron= True, flag_nuebar_electron_to_tau= False, + flag_nuebar_electron_to_hadrons= True, flag_nutau_electron_to_tau= False) + + # === Track rate === + + elif (flag_compute_track_rate == True): + + # Calculate the track rate + if (verbose > 0): print(" Calculating the track rate... ", end='') + # For each value of energy_dep, Diff_Track_Rate_Dep_Energy_Total returns + # [diff_track_rate_nue_nuebar, diff_track_rate_numu_numubar, + # diff_track_rate_nutau_nutaubar] + lst_diff_rate = \ + Diff_Track_Rate_Dep_Energy_Total(energy_dep, time_det, lst_Flux_Nu_At_Detector, volume_total=volume_total, + energy_nu_max=energy_nu_max, integration_method='quad', + miniter=1, maxiter=500, epsabs=epsabs, epsrel=epsrel, + flag_numu_cc=True, flag_nutau_cc=True, flag_nuebar_electron_to_tau=False, + flag_nutau_electron_to_tau=False, flag_nuebar_electron_to_muon= False, flag_numu_electron_to_muon= False) + + Numerator = np.array([lst_diff_rate[0] + lst_diff_rate[1] + lst_diff_rate[2]]) + + return Numerator + + + +def Prob_dist_atm_conv_pr(nu_energy_min, nu_energy_max, nu_energy_num_nodes, costhz_val, costhz_npts, energy_dep, log10_energy_dep_int_min, log10_energy_dep_int_max, log10_energy_dep_min, log10_energy_dep_max, log10_energy_dep_npts, + time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose, flag_use_atm_fluxes_conv, flag_use_atm_fluxes_pr, flag_apply_self_veto, flag_compute_shower_rate, flag_compute_track_rate): + + num = \ + Prob_dist_atm_conv_pr_num(nu_energy_min, nu_energy_max, nu_energy_num_nodes, costhz_val, energy_dep, time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose, + flag_compute_shower_rate = flag_compute_shower_rate, flag_compute_track_rate = flag_compute_track_rate, + flag_use_atm_fluxes_conv = flag_use_atm_fluxes_conv, flag_use_atm_fluxes_pr = flag_use_atm_fluxes_pr, flag_apply_self_veto = flag_apply_self_veto) + + den = \ + Prob_dist_atm_conv_pr_den(nu_energy_min, nu_energy_max, nu_energy_num_nodes, costhz_npts, log10_energy_dep_int_min, log10_energy_dep_int_max, + log10_energy_dep_min, log10_energy_dep_max, log10_energy_dep_npts, time_det_yr, volume_total, energy_nu_max, epsabs, epsrel, verbose, + flag_use_atm_fluxes_conv = flag_use_atm_fluxes_conv, flag_use_atm_fluxes_pr = flag_use_atm_fluxes_pr, flag_apply_self_veto = flag_apply_self_veto) + + prob = num/den + + print("Prob_atm=", prob) + + return prob + + +def Prob_dist_atm_muon_den(log10_energy_dep_int_min, log10_energy_dep_int_max, log10_energy_dep_min, log10_energy_dep_max, log10_energy_dep_npts, epsabs, epsrel, verbose): + + mix_params_data_set ='nufit_4_0_with_sk' + mix_params_mass_ordering ='no' + + # lst_mix_params is passed to NuSQuIDS and contains the mixing parameters + # [s12sq_bf, s23sq_bf, s13sq_bf, deltaCP_bf, Delta_m2_21_bf, Delta_m2_31_bf, Delta_m2_32_bf] + lst_mix_params = Mixing_Parameters(mix_params_data_set, mix_params_mass_ordering)[0] + + # Array of values of E_dep used to build the interpolation function of + # dN/dE_dep that is later integrated in E_dep + lst_log10_energy_dep = np.linspace(log10_energy_dep_min, + log10_energy_dep_max, log10_energy_dep_npts) + lst_energy_dep = [10.**x for x in lst_log10_energy_dep] # [GeV] + + # Arrays defining the bins of E_dep in which to integrate + log10_energy_dep_int_step = log10_energy_dep_int_max - log10_energy_dep_int_min + log10_energy_dep_int_npts = \ + int((log10_energy_dep_int_max-log10_energy_dep_int_min) / \ + log10_energy_dep_int_step) + lst_log10_energy_dep_int_min = \ + np.linspace(log10_energy_dep_int_min, + log10_energy_dep_int_max-log10_energy_dep_int_step, + log10_energy_dep_int_npts) + lst_log10_energy_dep_int_max = \ + np.linspace(log10_energy_dep_int_min+log10_energy_dep_int_step, + log10_energy_dep_int_max, log10_energy_dep_int_npts) + lst_energy_dep_int_min = [10.**x for x in lst_log10_energy_dep_int_min] + lst_energy_dep_int_max = [10.**x for x in lst_log10_energy_dep_int_max] + + lst_int_rate = [] + + gamma_mu = np.log10(21)/np.log10(60/28) + 1 + + lst_diff_rate = np.power(lst_energy_dep, -gamma_mu) + + # Build the interpolating function dN/dE_dep for each flavor + if (verbose > 0): + print(" Building interpolating functions of dN/dE_dep... ", \ + end='') + interp_diff_rate = interp1d(lst_energy_dep, + lst_diff_rate, kind='linear', bounds_error=False, + fill_value='extrapolate') + if (verbose > 0): print("Done") + + # Integrate dN/dE_dep in each bin of E_dep, for each flavor + if (verbose > 0): + print(" Integrating dN/dE_dep in each E_dep bin... ", end='') + res = [Energy_Integrated_Event_Rate(interp_diff_rate, + lst_energy_dep_int_min[j], lst_energy_dep_int_max[j], + flag_input_is_interpolating_function=True, + integration_method='quad', + miniter=1, maxiter=500, + epsabs=epsabs, epsrel=epsrel) \ + for j in range(len(lst_energy_dep_int_min))] + lst_int_rate.append(res) + + if (verbose > 0): print("Done") + + Denominator = lst_int_rate + + return Denominator + + + +def Prob_dist_atm_muon(energy_dep, log10_energy_dep_int_min, log10_energy_dep_int_max, log10_energy_dep_min, log10_energy_dep_max, log10_energy_dep_npts, epsabs, epsrel, verbose): + + gamma_mu = np.log10(21)/np.log10(60/28) + 1 + + num = np.power(energy_dep, -gamma_mu) + + den = Prob_dist_atm_muon_den(log10_energy_dep_int_min, log10_energy_dep_int_max, log10_energy_dep_min, log10_energy_dep_max, log10_energy_dep_npts, epsabs, epsrel, verbose) + + prob = num/den + + print(prob) + + return prob + + diff --git a/Likelihood/data_shower.txt b/Likelihood/data_shower.txt new file mode 100644 index 0000000..05be1b6 --- /dev/null +++ b/Likelihood/data_shower.txt @@ -0,0 +1,58 @@ + 1 47.6 -5.4 +6.5 55351.3222143 -1.8 35.2 16.3 + 2 117.0 -14.6 +15.4 55351.4659661 -28.0 282.6 25.4 + 4 165.4 -14.9 +19.8 55477.3930984 -51.2 169.5 7.1 + 6 28.4 -2.5 +2.7 55567.6388127 -27.2 133.9 9.8 + 7 34.3 -4.3 +3.5 55571.2585362 -45.1 15.6 24.1 + 9 63.2 -8.0 +7.1 55685.6629713 33.6 151.3 16.5 + 10 97.2 -12.4 +10.4 55695.2730461 -29.4 5.0 8.1 + 11 88.4 -10.7 +12.5 55714.5909345 -8.9 155.3 16.7 + 12 104.1 -13.2 +12.5 55739.4411232 -52.8 296.1 9.8 + 14 1040.7 -144.4 +131.6 55782.5161911 -27.9 265.6 13.2 + 15 57.5 -7.8 +8.3 55783.1854223 -49.7 287.3 19.7 + 16 30.6 -3.5 +3.6 55798.6271285 -22.6 192.1 19.4 + 17 199.7 -26.8 +27.2 55800.3755483 14.5 247.4 11.6 + 19 71.5 -7.2 +7.0 55925.7958619 -59.7 76.9 9.7 + 20 1140.8 -132.8 +142.8 55929.3986279 -67.2 38.3 10.7 + 21 30.2 -3.3 +3.5 55936.5416484 -24.0 9.0 20.9 + 22 219.5 -24.4 +21.2 55941.9757813 -22.1 293.7 12.1 + 24 30.5 -2.6 +3.2 55950.8474912 -15.1 282.2 15.5 + 25 33.5 -5.0 +4.9 55966.7422488 -14.5 286.0 46.3 + 26 210.0 -25.8 +29.0 55979.2551750 22.7 143.4 11.8 + 27 60.2 -5.6 +5.6 56008.6845644 -12.6 121.7 6.6 + 29 32.7 -2.9 +3.2 56108.2572046 41.0 298.1 7.4 + 30 128.7 -12.5 +13.8 56115.7283574 -82.7 103.2 8.0 + 31 42.5 -5.7 +5.4 56176.3914143 78.3 146.1 26.0 + 33 384.7 -48.6 +46.4 56221.3424023 7.8 292.5 13.5 + 34 42.1 -6.3 +6.5 56228.6055226 31.3 323.4 42.7 + 35 2003.7 -261.5 +236.2 56265.1338677 -55.8 208.4 15.9 + 36 28.9 -2.6 +3.0 56308.1642740 -3.0 257.7 11.7 + 39 101.3 -11.6 +13.3 56480.6617877 -17.9 106.2 14.2 + 40 157.3 -16.7 +15.9 56501.1641008 -48.5 143.9 11.7 + 41 87.6 -10.0 +8.4 56603.1116854 3.3 66.1 11.1 + 42 76.3 -11.6 +10.3 56613.2566890 -25.3 42.5 20.7 + 46 158.0 -16.6 +15.3 56688.0702948 -22.3 150.5 7.6 + 48 104.7 -10.2 +13.5 56705.9419933 -33.2 213.0 8.1 + 49 59.9 -7.9 +8.3 56722.4083554 -26.3 203.2 21.8 + 50 22.2 -2.0 +2.3 56737.2004652 59.3 168.6 8.2 + 51 66.2 -6.1 +6.7 56759.2159560 54.0 88.6 6.5 + 52 158.1 -18.4 +16.3 56763.5448147 -54.0 252.8 7.8 + 54 54.5 -6.3 +5.1 56769.0295975 6.0 170.5 11.6 + 56 104.2 -10.0 +9.7 56817.3895800 -50.1 280.5 6.5 + 57 132.1 -16.8 +18.1 56830.5266500 -42.2 123.0 14.4 + 59 124.6 -11.7 +11.6 56922.5853000 -3.9 63.3 8.8 + 60 93.0 -11.7 +12.9 56931.9311000 -37.9 32.7 13.3 + 64 70.8 -7.7 +8.1 57036.7437800 -27.3 144.5 10.6 + 65 43.3 -5.2 +5.9 57051.6637800 -33.5 72.8 17.5 + 66 84.2 -9.9 +10.7 57053.1272700 38.3 128.7 18.3 + 67 165.7 -15.5 +16.5 57079.9653200 3.0 335.7 7.0 + 68 59.1 -6.0 +8.0 57081.5352600 -15.7 294.3 11.7 + 69 18.0 -2.0 +2.2 57133.7900700 0.3 236.2 15.7 + 70 98.8 -11.1 +12.0 57134.3981200 -33.5 93.9 12.3 + 72 35.3 -4.1 +4.6 57144.2960700 28.3 203.2 19.5 + 73 26.2 -2.3 +2.6 57154.8367900 11.1 278.4 6.9 + 74 71.3 -8.1 +9.1 57157.0007700 -0.9 341.0 12.7 + 75 164.0 -21.4 +20.7 57168.4045000 70.5 259.0 13.1 + 77 49.5 -3.7 +3.8 57285.0173200 2.1 278.4 7.2 + 79 158.2 -19.8 +20.3 57365.7524900 -11.1 24.6 14.6 + 80 85.6 -10.6 +11.1 57386.3587700 -3.6 146.6 16.1 + 81 151.8 -21.6 +13.9 57480.6473600 -79.4 45.0 13.5 \ No newline at end of file diff --git a/Likelihood/data_track.txt b/Likelihood/data_track.txt new file mode 100644 index 0000000..22e4d0e --- /dev/null +++ b/Likelihood/data_track.txt @@ -0,0 +1,22 @@ + 3 78.7 -8.7 +10.8 55451.0707482 -31.2 127.9 1.4 + 5 71.4 -9.0 +9.0 55512.5516311 -0.4 110.6 1.2 + 8 32.6 -11.1 +10.3 55608.8201315 -21.2 182.4 1.3 + 13 252.7 -21.6 +25.9 55756.1129844 40.3 67.9 1.2 + 18 31.5 -3.3 +4.6 55923.5318204 -24.8 345.6 1.3 + 23 82.2 -8.4 +8.6 55949.5693228 -13.2 208.7 1.9 + 28 46.1 -4.4 +5.7 56048.5704209 -71.5 164.8 1.3 + 37 30.8 -3.5 +3.3 56390.1887627 20.7 167.3 1.2 + 38 200.5 -16.4 +16.4 56470.1103795 14.0 93.3 1.2 + 43 46.5 -4.5 +5.9 56628.5688531 -22.0 206.6 1.3 + 44 84.6 -7.9 +7.4 56671.8778763 0.0 336.7 1.2 + 45 429.9 -49.1 +57.4 56679.2044683 -86.3 219.0 1.2 + 47 74.3 -7.2 +8.3 56704.6001074 67.4 209.4 1.2 + 53 27.6 -2.2 +2.6 56767.0663034 -37.7 239.0 1.2 + 58 52.6 -5.7 +5.2 56859.7588200 -32.4 102.1 1.3 + 61 53.8 -6.3 +7.2 56970.2073600 -16.5 55.6 1.2 + 62 75.8 -7.1 +6.7 56987.7721900 13.3 187.9 1.3 + 63 97.4 -9.6 +9.6 57000.1431100 6.5 160.0 1.2 + 71 73.5 -10.5 +10.0 57140.4727600 -20.8 80.7 1.2 + 76 126.3 -12.7 +12.0 57276.5653000 -0.4 240.2 1.2 + 78 56.7 -6.9 +7.0 57363.4423300 7.5 0.4 1.2 + 82 159.3 -15.3 +15.5 57505.2448200 9.4 240.9 1.2 \ No newline at end of file