def test_some_angles(): import mceq_config as config from MCEq.core import MCEqRun import crflux.models as pm import numpy as np config.debug_level = 5 config.kernel_config = 'numpy' config.cuda_gpu_id = 0 config.mkl_threads = 2 mceq = MCEqRun(interaction_model='SIBYLL23C', theta_deg=0., primary_model=(pm.HillasGaisser2012, 'H3a')) nmu = [] for theta in [0., 30., 60., 90]: mceq.set_theta_deg(theta) mceq.solve() nmu.append( np.sum( mceq.get_solution('mu+', 0, integrate=True) + mceq.get_solution('mu-', 0, integrate=True))) print(nmu) assert np.allclose(nmu, [ 59787.31805017808, 60908.05990627792, 66117.91267025097, 69664.26521920023 ])
def run_MCEq( primary_model, interaction_model="SIBYLL2.3c", density_profiles=[ ("MSIS00_IC", ("SouthPole", "January")), ("MSIS00_IC", ("SouthPole", "July")), ], particle_ids=["total_numu", "total_antinumu"], cosz_lim=[-1.0, 1.0], cosz_steps=50, emag=3, ): # define equidistant grid in cos(theta) with cosz_steps steps theta_grid = np.arccos(np.linspace(cosz_lim[0], cosz_lim[1], cosz_steps)) theta_grid *= 180.0 / np.pi # temporarily result dict flux_for_density = {} ## loop over all density profiles #for density in density_profiles: for density in tqdm(density_profiles, desc="Density"): print "=" * 60 print "Current atmosphere model:", density[0], "--", density[1][ 0], density[1][1] print "-" * 60 # set atmosphere model string for result dictionary if density[1][1] is not None: density_str = density[0] + density[1][0] + density[1][1] else: density_str = density[0] + density[1][0] # update mceq_config with the current atmosphere model config["density_model"] = density # create instance of MCEqRun class mceq_run = MCEqRun( interaction_model=interaction_model, primary_model=primary_model, theta_deg=0.0, # updated later **config) # obtain energy grid (fixed) of the solution for the x-axis of the plots e_grid = mceq_run.e_grid # update dictionary flux_for_density[density_str] = {} for flux_str in particle_ids: flux_for_density[density_str][flux_str] = np.zeros( (len(theta_grid), len(e_grid))) ## loop over all theta bins #for theta_id, theta in enumerate(theta_grid): for theta_id, theta in enumerate(tqdm(theta_grid, desc="Theta")): print "-" * 60 print "Current theta:", theta # Set/update the zenith angle mceq_run.set_theta_deg(theta) # Run the solver mceq_run.solve() # get fluxes flux_solutions = get_solutions(mceq_run, particle_ids, mag=emag) # store fluxes in result dictionary' for flux_str in particle_ids: flux_for_density[density_str][flux_str][ theta_id, :] = flux_solutions[flux_str] #print flux_for_density[density_str][flux_str][theta_id,:] # average density models: fluxes = {} for flux_str in particle_ids: fluxes[flux_str] = np.zeros((len(theta_grid), len(e_grid))) for flux_str in particle_ids: for density in flux_for_density.keys(): # loop over all density models fluxes[flux_str] += flux_for_density[density][flux_str] fluxes[flux_str] /= len(flux_for_density.keys()) * 1.0 # add e_grid and theta_grid #fluxes["e_grid"] = e_grid #fluxes["theta_grid"] = theta_grid return fluxes
data[:, 8]**2 + data[:, 9]**2) * j return ExperimentalData(e, f * 1E-04, df * 1E-04) bess = load_bess('BESS_TEV.txt') # Simulate the flux using MCEq mceq = MCEqRun(interaction_model='SIBYLL23C', primary_model=(crf.GlobalSplineFitBeta, None), density_model=('MSIS00', ('Tokyo', 'October')), theta_deg=0) cos_theta = 0.95 theta = numpy.arccos(cos_theta) * 180 / numpy.pi mceq.set_theta_deg(theta) altitude = numpy.array((30., )) X_grid = mceq.density_model.h2X(altitude * 1E+02) def weight(xmat, egrid, name, c): return (1 + c) * numpy.ones_like(xmat) mceq.set_mod_pprod(2212, 211, weight, ('a', 0.141)) # Coefficients taken mceq.set_mod_pprod(2212, -211, weight, ('a', 0.116)) # from table 2 of Yanez et mceq.set_mod_pprod(2212, 321, weight, ('a', 0.402)) # al. mceq.set_mod_pprod(2212, -321, weight, ('a', 0.583)) mceq.regenerate_matrices(skip_decay_matrix=True)
def _compute_outputs(self, inputs=None): """Compute histograms for output channels.""" logging.debug('Entering mceq._compute_outputs') primary_model = split(self.params['primary_model'].value, ',') if len(primary_model) != 2: raise ValueError('primary_model is not of length 2, instead is of ' 'length {0}'.format(len(primary_model))) primary_model[0] = eval('pm.' + primary_model[0]) density_model = (self.params['density_model'].value, (self.params['location'].value, self.params['season'].value)) mceq_run = MCEqRun( interaction_model=str(self.params['interaction_model'].value), primary_model=primary_model, theta_deg=0.0, density_model=density_model, **mceq_config.mceq_config_without(['density_model'])) # Power of energy to scale the flux (the results will be returned as E**mag * flux) mag = 0 # Obtain energy grid (fixed) of the solution for the x-axis of the plots e_grid = mceq_run.e_grid # Dictionary for results flux = OrderedDict() for nu in self.output_names: flux[nu] = [] binning = self.output_binning cz_binning = binning.dims[binning.index('coszen', use_basenames=True)] en_binning = binning.dims[binning.index('energy', use_basenames=True)] cz_centers = cz_binning.weighted_centers.m angles = (np.arccos(cz_centers) * ureg.radian).m_as('degrees') for theta in angles: mceq_run.set_theta_deg(theta) mceq_run.solve() flux['nue'].append(mceq_run.get_solution('total_nue', mag)) flux['nuebar'].append(mceq_run.get_solution('total_antinue', mag)) flux['numu'].append(mceq_run.get_solution('total_numu', mag)) flux['numubar'].append(mceq_run.get_solution( 'total_antinumu', mag)) for nu in flux.iterkeys(): flux[nu] = np.array(flux[nu]) smoothing = self.params['smoothing'].value.m en_centers = en_binning.weighted_centers.m_as('GeV') spline_flux = self.bivariate_spline(flux, cz_centers, e_grid, smooth=smoothing) ev_flux = self.bivariate_evaluate(spline_flux, cz_centers, en_centers) for nu in ev_flux: ev_flux[nu] = ev_flux[nu] * ureg('cm**-2 s**-1 sr**-1 GeV**-1') mapset = [] for nu in ev_flux.iterkeys(): mapset.append(Map(name=nu, hist=ev_flux[nu], binning=binning)) return MapSet(mapset)
def generate_table(interaction_model=None, primary_model=None, density_model=None): interaction_model = interaction_model or 'SIBYLL23C' primary_model = primary_model or 'H3a' density_model = density_model or 'USStd' tag = '-'.join((interaction_model.lower(), primary_model.lower(), density_model.lower())) weights = None if interaction_model == 'YFM': # Use weights from Yanez et al., 2019 (https://arxiv.org/abs/1909.08365) interaction_model = 'SIBYLL23C' weights = {211: 0.141, -211: 0.116, 321: 0.402, -321: 0.583} if primary_model == 'GSF': primary_model = (crf.GlobalSplineFitBeta, None) elif primary_model == 'H3a': primary_model = (crf.HillasGaisser2012, 'H3a') elif primary_model == 'PolyGonato': primary_model = (crf.PolyGonato, None) else: raise ValueError(f'Invalid primary model: {primary_model}') if density_model == 'USStd': density_model = ('CORSIKA', ('USStd', None)) elif density_model.startswith('MSIS00'): density_model = ('MSIS00', density_model.split('-')[1:]) else: raise ValueError(f'Invalid density model: {density_model}') config.e_min = 1E-01 config.enable_default_tracking = False config.enable_muon_energy_loss = True mceq = MCEqRun(interaction_model=interaction_model, primary_model=primary_model, density_model=density_model, theta_deg=0) if weights: def weight(xmat, egrid, name, c): return (1 + c) * numpy.ones_like(xmat) for pid, w in weights.items(): mceq.set_mod_pprod(2212, pid, weight, ('a', w)) mceq.regenerate_matrices(skip_decay_matrix=True) energy = mceq.e_grid cos_theta = numpy.linspace(0, 1, 51) altitude = numpy.linspace(0, 9E+03, 10) data = numpy.zeros((altitude.size, cos_theta.size, energy.size, 2)) for ic, ci in enumerate(cos_theta): print(f'processing {ci:.2f}') theta = numpy.arccos(ci) * 180 / numpy.pi mceq.set_theta_deg(theta) X_grid = mceq.density_model.h2X(altitude[::-1] * 1E+02) mceq.solve(int_grid=X_grid) for index, _ in enumerate(altitude): mu_m = mceq.get_solution('mu-', grid_idx=index) * 1E+04 mu_p = mceq.get_solution('mu+', grid_idx=index) * 1E+04 K = (mu_m > 0) & (mu_p > 0) data[altitude.size - 1 - index, ic, K, 0] = mu_m[K] data[altitude.size - 1 - index, ic, K, 1] = mu_p[K] # Dump the data grid to a litle endian binary file data = data.astype('f4').flatten() with open(f'data/simulated/flux-mceq-{tag}.table', 'wb') as f: numpy.array((energy.size, cos_theta.size, altitude.size), dtype='i8').astype('<i8').tofile(f) numpy.array((energy[0], energy[-1], cos_theta[0], cos_theta[-1], altitude[0], altitude[-1]), dtype='f8').astype('<f8').tofile(f) data.astype('<f4').tofile(f)
def get_initial_state(energies, zeniths, n_nu, kwargs): """ This either loads the initial state, or generates it. Loading it is waaaay quicker. Possible issue! If you run a bunch of jobs and don't already have this flux generated, bad stuff can happen. I'm imagining issues where a bunch of jobs waste time making this, and then all try to write to the same file Very bad. Big crash. Very Fail """ path = os.path.join(config["datapath"], config["mceq_flux"]) if os.path.exists(path): # print("Loading MCEq Flux") f = open(path, 'rb') inistate = pickle.load(f) f.close() else: # print("Generating MCEq Flux") inistate = np.zeros(shape=(angular_bins, energy_bins, 2, n_nu)) mceq = MCEqRun(interaction_model=config["interaction_model"], primary_model=(crf.HillasGaisser2012, 'H3a'), theta_deg=0.) r_e = 6.378e6 # meters ic_depth = 1.5e3 # meters mag = 0. # power energy is raised to and then used to scale the flux for angle_bin in range(angular_bins): # get the MCEq angle from the icecube zenith angle angle_deg = asin( sin(pi - acos(zeniths[angle_bin])) * (r_e - ic_depth) / r_e) angle_deg = angle_deg * 180. / pi if angle_deg > 180.: angle_deg = 180. print("Evaluating {} deg Flux".format(angle_deg)) # for what it's worth, if you try just making a new MCEqRun for each angle, you get a memory leak. # so you need to manually set the angle mceq.set_theta_deg(angle_deg) mceq.solve() flux = {} flux['e_grid'] = mceq.e_grid flux['nue_flux'] = mceq.get_solution( 'nue', mag) + mceq.get_solution('pr_nue', mag) flux['nue_bar_flux'] = mceq.get_solution( 'antinue', mag) + mceq.get_solution('pr_antinue', mag) flux['numu_flux'] = mceq.get_solution( 'numu', mag) + mceq.get_solution('pr_numu', mag) flux['numu_bar_flux'] = mceq.get_solution( 'antinumu', mag) + mceq.get_solution('pr_antinumu', mag) flux['nutau_flux'] = mceq.get_solution( 'nutau', mag) + mceq.get_solution('pr_nutau', mag) flux['nutau_bar_flux'] = mceq.get_solution( 'antinutau', mag) + mceq.get_solution('pr_antinutau', mag) for neut_type in range(2): for flavor in range(n_nu): flav_key = get_key(flavor, neut_type) if flav_key == "": continue for energy_bin in range(energy_bins): # (account for the difference in units between mceq and nusquids! ) inistate[angle_bin][energy_bin][neut_type][ flavor] = get_closest( energies[energy_bin] / un.GeV, flux['e_grid'], flux[flav_key]) if np.min(inistate) < 0: raise ValueError( "Found negative value in the input from MCEq {}".format( np.min(inistate))) # save it now f = open(path, 'wb') pickle.dump(inistate, f, -1) f.close() return (inistate)
def Solve_mceqs(): ### This function solves matrix cascade equations using MCEq. Please ### note that MCEq can do a lot more than what is currently used ### in this script. For more information and options, visit: ### https://github.com/afedynitch/MCEq import crflux.models as crf from MCEq.core import config, MCEqRun def Convert_name(particle): # MCEq can't handle "bar"s in particle names. It wants "anti"s instead. if 'bar' in particle[0]: pname = (particle[0].replace('_', '_anti') if '_' in particle[0] else 'anti' + particle[0]) pname = pname.replace('bar', '') else: pname = particle[0] return pname # Cosmic ray flux at the top of the atmosphere: primary_model = (HawkBPL, 0.) # High-energy hadronic interaction model: interaction_model = 'SIBYLL23C' # Zenith angles: zenith_deg = np.append(np.arange(0., 90., 10), 89) mceq = MCEqRun(interaction_model = interaction_model, primary_model = primary_model, theta_deg = 0.) mceq.pman.track_leptons_from([(130,0)], 'K0L_') mceq.pman.track_leptons_from([(310,0)], 'K0S_') # mceq.pman.print_particle_tables(0) mceq._resize_vectors_and_restore() mceq.regenerate_matrices() config.excpt_on_missing_particle = True energy = mceq.e_grid ## Solve the equation systems for all zenith angles: solutions = [[] for particle in particles] for angle in zenith_deg: print( '\n=== Solving MCEq for BPL ' + interaction_model + ' ' + str(angle) + ' deg' ) mceq.set_theta_deg(angle) mceq.solve() # Obtain solution for all chosen particles: print('Obtaining solution for:') for p, particle in enumerate(particles): print(particle[0]) solutions[p].append(mceq.get_solution(Convert_name(particle), mag=0)) # mag is a multiplication factor in order to stress steaper # parts of the spectrum. Don't store magnified fluxes in nuflux # (keep mag=0)! # Save solutions to file particle-wise: for p, particle in enumerate(particles): savename = name + '_' + particle[0] headr = ( savename.replace('_', '\t') + '\n' 'energy [GeV]\t' + ' '.join([str(z) + ' deg\t' for z in zenith_deg]) ) solutions[p].insert(0, energy) solutions[p] = np.array(solutions[p]) np.savetxt( dirname + '/data/' + savename + '.dat', np.transpose(solutions[p]), fmt='%.8e', header=headr, delimiter='\t' )