def apply_xs(self, flux, key):
neut = get_neut(key)
curr = get_curr(key)
flav = get_flavor(key)
for i_e in range(len(self.e_reco)):
xs = get_xs(self.e_reco[i_e], flav, neut, curr)
flux[i_e] *= xs
return (flux)
null = SterileParams(0., 0., 0., 0.)
ster = SterileParams(0., 0.1609, 0.2205, 4.47)
#ster = SterileParams(0., 0.1609, 0.0, 4.47)
print("Loading files from {}".format(config['datapath']))
e_true, a_true, flux_null = _load_flux(null, False)
e_true, a_true, flux_sterile = _load_flux(ster, False)
keys = flux_null.keys()
centers = bhist([e_true]).centers
for key in keys:
flav = get_flavor(key)
neut = get_neut(key)
curr = get_curr(key)
for i_energy in range(len(centers)):
xs = get_xs(centers[i_energy], flav, neut, curr)
pcent = 1.0
if False: #("Tau" in key) and ("CC" in key):
pcent = 0.51
flux_null[key][i_energy] *= xs*pcent
flux_sterile[key][i_energy] *= xs*pcent
def get_ratio(nubar):
cascade_rate = np.zeros(shape=np.shape(flux[keys[0]])[0])
track_rate = np.zeros(shape=np.shape(flux[keys[0]])[0])
eff_width = (max(a_reco) - min(a_reco)) / (2 * len(a_reco))
widths_rad = [
abs(np.arccos(ang + eff_width) - np.arccos(ang - eff_width))
for ang in np.linspace(min(a_reco), max(a_reco), len(a_reco))
]
sterr = widths_rad * np.sin(np.arccos(a_reco)) * 2 * pi
for key in keys:
flav = get_flavor(key)
neut = get_neut(key)
curr = get_curr(key)
for i_energy in range(len(energies)):
xs = get_xs(energies[i_energy], flav, neut, curr)
amount = sum(flux[key][i_energy] * sterr * xs)
if is_track(key):
track_rate[i_energy] += amount
else:
cascade_rate[i_energy] += amount
for i_energy in range(len(energies)):
flav = get_flavor("Mu_nu_CC")
curr = get_curr("Mu_nu_CC")
neut_nu = get_neut("Mu_nu_CC")
def do_for_key(event_edges,e_deposited_edges, key,data, angles):
"""
This function takes the desired bin edges for the event energies and deposited energies along with the dictionary key corresponding to a specific combination of falvor, current, and neutrino type.
It builds up the 2D flux array (singly differential), which it then returns along with a similar array but for flux uncertainties
"""
evt = bhist([event_edges])
cas = bhist([e_deposited_edges])
event_energies = evt.centers
event_widths = evt.widths
deposited_energies = cas.centers
e_deposited_widths = cas.widths
flav = key.split("_")[0]
curr = key.split("_")[2]
neut = key.split("_")[1]
ang_list = bhist([angles]).centers
#flux = bhist((e_deposited_edges, event_edges, angles))
#err = bhist((e_deposited_edges, event_edges, angles))
flux = np.zeros( shape=(len(e_deposited_edges)-1, len(event_edges)-1, len(angles)-1))
err = np.zeros( shape=(len(e_deposited_edges)-1, len(event_edges)-1, len(angles)-1))
for i_a in range(len(ang_list)):
angle = ang_list[i_a]
# in this case, knowing the cascade doesn't tell us anything about the event energy.
# so we loop over both, get the flux*differential_xs at each bin combination, and multiply by the widths of deposited-energy-bin to get the same units as in the CC case
for evt_bin in range(len(event_energies)):
for dep_bin in range(len(deposited_energies)):
deposited_energy = deposited_energies[dep_bin] #in hadronic shower
lepton_energy = event_energies[evt_bin] - deposited_energies[dep_bin]
if deposited_energy>event_energies[evt_bin]:
continue
if curr=="CC":
if flav=="E":
scale = 1.0
elif flav=="Tau":
scale = 0.51 # this was manually calculated as the best value, regardless of the actual tau energy
else:
continue
# in the charge current, some of the lepton's energy gets deposited too
# All of the electrons, and about half the tau's
deposited_energy += scale*lepton_energy
try:
adj_dep_bin = get_loc( deposited_energy, e_deposited_edges )[0]
except ValueError:
continue
else:
adj_dep_bin = dep_bin
# we'll have nowhere to put these, so let's just skip this
if deposited_energy < min(e_deposited_edges):
continue
if deposited_energy > max(e_deposited_edges):
continue
xs = get_diff_xs(event_energies[evt_bin], get_flavor(key), get_neut(key), get_curr(key), lepton_energy,0.0)*e_deposited_widths[dep_bin]*event_widths[evt_bin]
amount =data.get_flux(event_energies[evt_bin],key, angle=angle)*xs*event_widths[evt_bin]
amount_err = data.get_err(event_energies[evt_bin],key, angle=angle)*xs
flux[adj_dep_bin][evt_bin][i_a] += amount/(e_deposited_widths[adj_dep_bin]*event_widths[evt_bin])
err[adj_dep_bin][evt_bin][i_a] += amount_err/(e_deposited_widths[adj_dep_bin]*event_widths[evt_bin])
#flux.register(amount, deposited_energy, event_energies[evt_bin], angle)
#err.register(amount_err, deposited_energy, event_energies[evt_bin], angle)
# build a new bhist in reconstruction space (Still with event energy too)
# then scan through deposited-true angle space
# and use the PDFS to smear the true values into reconstructed values, depositing them into the reconstruction bhist
return(flux, err)