def _load_flux(params, tracks=False): name = gen_filename(config["datapath"], config["nu_flux"]+".dat", params) if False: f = open(name,'rb') all_data = pickle.load(f) f.close() else: kwargs ={"as_data":True} data = raw_flux(params, kwargs=kwargs) flux = {} for key in data.get_keys(just_casc=(not tracks),just_tracks=tracks): flux[key] = np.array(data.fluxes[key]) return (np.array(data.energies), np.array(data.angles), flux) return( all_data["e_true"], all_data["a_true"], all_data["flux"] )
def generate_astr_flux(params, **kwargs): """ This script generates an astrophysical flux at the given SterileParameters It saves the flux to the datapath that the configuration file is configured to """ print("Received {} point".format(params)) if "forced_filename" not in kwargs: kwargs["forced_filename"] = gen_filename(config["datapath"], config["prop_astro_flux"], params) if "flavor_ratio" not in kwargs: flavor_ratio = get_flavor_ratio(params) kwargs["flavor_ratio"] = flavor_ratio else: print("Using ratio: {}".format(kwargs["flavor_ratio"])) kwargs["state_setter"] = astro_initial_state kwargs["osc"] = False return raw_flux(params, kwargs)
def gen_flux(params): """ First we make a neutrino flux file at the detector (true flux binning) Then we get the fluxes, binned in energy deposited Then we incorporate the detector response """ if not isinstance(params, SterileParams): raise TypeError("Expected {} for params, not {}".format( SterileParams, type(params))) raw_flux_name = gen_filename(config["datapath"], config["nu_flux"] + ".dat", params) if os.path.exists(raw_flux_name) and config["use_pregen_mceq_flux"]: pass else: raw_flux_name = raw_flux(params) a, b, c, d, err = generate_singly_diff_fluxes(config["n_bins"], datafile=raw_flux_name) incorporate_recon(a, b, c, d, errors=err, params=params, just_flux=True)
def make_meta_flux(params, do_mc = False): """ This makes and saves """ # look for the atmospheric fluxes. These should all be pre-generated start = time() kwargs = {} kwargs["as_data"]=True atmo_data = raw_flux(params,kwargs=kwargs) astr_data = generate_astr_flux(params, as_data=True) print("Calculating Expected Binned Flux at {}".format(params)) if do_mc: print("In MC mode") # now we use these two to build the full expected flux if do_mc: full_flux = build_mc_flux(atmo_data, astr_data) else: full_flux = get_expectation(atmo_data, astr_data) #dict middle = time() # save the object filename = "expected_flux_from_mc_smearedwell.dat" if do_mc else "best_expected_flux.dat" suffix = "{}from_mc".format("_not_" if (not do_mc) else "_") new_filename = gen_filename(config["datapath"]+ "/expected_fluxes_reco/", filename, params) print("Saving to {}".format(new_filename)) f = open(new_filename ,'wb') pickle.dump(full_flux, f, -1) f.close() end = time() print("Flux Sim took {:.1f} seconds".format(middle-start)) print("Saving took {:.3f} seconds".format(end-middle)) return full_flux
def cr_perturb(dgamma=0.0, dnorm=0.0, use_mc=False, smearmode=False, special=False): """ Calculates the expected cosmic ray spectrum, then returns the expected gains/losses in each bin by perturbing the overall spectram index (dgamma) and normalization (dnorm) down/up Returns a tuple containing np.ndarrays The first is the event change from a negative perturbation The second is the event change from a positive perturbation """ perturb_gamma = dgamma != 0.0 perturb_norm = dnorm != 0.0 if perturb_gamma == perturb_norm: raise ValueError( "Cannot perturb both norm and gamma simultaneously. Also need to perturb at least one." ) filename = os.path.join(perturb_folder, "cr_central.dat") null = SterileParams() if special: flux_func = lambda *objs: build_flux_sad(*objs, good_angles=True) else: if smearmode: flux_func = build_flux_sad else: flux_func = build_mc_flux if use_mc else build_flux if True: #not os.path.exists(filename): kwargs = {'as_data': True} flux_data = flux_func(raw_flux(null, kwargs)) pickle_save(flux_data, filename) else: flux_data = pickle_load(filename) p_plus = np.zeros(shape=np.shape(flux_data["stat_err"])) p_minus = np.zeros(shape=np.shape(flux_data["stat_err"])) if perturb_norm: mean_norm = 1.19 return _flipper(flux_data["event_rate"], ((mean_norm - dnorm) * flux_data["event_rate"], (mean_norm + dnorm) * flux_data["event_rate"])) if perturb_gamma: # scale with #phi(e) * (E/(2.2TeV))^deltagamma e_edges = flux_data["e_edges"] for i_e in range(len(e_edges) - 1): for i_a in range(len(flux_data["a_edges"]) - 1): # we have the energies at the bin edges... # sooo mean_dgamma = 0.068 effective_e = 0.5 * (e_edges[i_e] + e_edges[i_e + 1]) p_plus[i_e][i_a] = flux_data["event_rate"][i_e][i_a] * pow( effective_e / (2.2e3), -mean_dgamma - dgamma) p_minus[i_e][i_a] = flux_data["event_rate"][i_e][i_a] * pow( effective_e / (2.2e3), -mean_dgamma + dgamma) return _flipper(flux_data["event_rate"], (p_minus, p_plus))
for i_a in range(a_bins): for neut_type in range(2): inistate[i_a][i_e][neut_type][1] = 1.0 return inistate # either generate the file or load it in! expected_fn = gen_filename(config["datapath"], "unitary_prob.dat", params) if os.path.exists(expected_fn): final_probs = Data(expected_fn) else: kwargs = {} kwargs["as_data"] = False kwargs["state_setter"] = state_setter kwargs["forced_filename"] = expected_fn final_probs = Data(raw_flux(params, kwargs=kwargs)) # now we need three keys curr = "CC" # doesn't matter neut = "nuBar" root_flav = "Mu" flavors = ['E', 'Mu', 'Tau'] # flavor neutrino current keys = ["_".join([flav, neut, curr]) for flav in flavors] core_b = -0.98 mantle_b = -0.83 energies = np.logspace(2, 7, 200) angles = np.linspace(-1, 0.2, 100)
from cascade.utils import get_color do_fudge = False flavors = ["e", "mu", "tau"] if do_fudge: core_b = -0.98 mantle_b = -0.83 # let's see how the new predicted event rate looks! null = SterileParams() not_null = SterileParams(theta13=0.1609, theta23=0.2249, msq2=4.47) kwargs = {} kwargs["as_data"] = True atmo_data = raw_flux(null, kwargs=kwargs) astr_data = generate_astr_flux(null, as_data=True) n_e = 20 n_a = 10 raw_data = get_expectation(atmo_data, astr_data) e_bins = raw_data["e_edges"] a_bins = raw_data["a_edges"] events = raw_data["event_rate"] plt.pcolormesh(a_bins, e_bins, events) plt.xlim([-1, 0.2]) plt.ylim([1e2, 1e6]) plt.yscale('log') plt.vlines(core_b, ymin=1e2, ymax=10**6, colors="white", ls="-")