def create_table_propagate(dir_name):
pp.RandomGenerator.get().set_seed(1234)
with open(dir_name + "Sector_Propagate.txt", "w") as file:
for particle_def in particle_defs:
for medium in mediums:
for cut in cuts:
sector_def = pp.SectorDefinition()
sector_def.cut_settings = cut
sector_def.medium = medium
sector = pp.Sector(particle_def, sector_def, interpoldef)
for energy in energies:
buf = [""]
buf.append(str(particle_def.name))
buf.append(str(medium.name))
buf.append(str(cut.ecut))
buf.append(str(cut.vcut))
buf.append(str(energy))
p_condition = pp.particle.DynamicData(0)
p_condition.position = pp.Vector3D(0, 0, 0)
p_condition.direction = pp.Vector3D(0, 0, -1)
p_condition.propagated_distance = 0
p_condition.energy = energy
sec = sector.propagate(p_condition, 1000, 0)
buf.append(str(sec.number_of_particles))
if (sec.particles[-1].propagated_distance < 999.99):
buf.append(
str(-sec.particles[-1].propagated_distance))
else:
buf.append(str(sec.particles[-1].energy))
buf.append("\n")
file.write("\t".join(buf))
def propagate_particle(propagator,
position=[-1e5, 0, 1e4],
direction=[1, 0, 0],
energy=1e9):
mu_data = pp.particle.DynamicData(propagator.particle_def.particle_type)
mu_data.position = pp.Vector3D(position[0], position[1], position[2])
tmp_dir = pp.Vector3D(direction[0], direction[1], direction[2])
tmp_dir.spherical_from_cartesian()
mu_data.direction = tmp_dir
mu_data.energy = energy
mu_data.propagated_distance = 0
mu_data.time = 0
return propagator.propagate(mu_data)
def propagate_particle(propagator,
position=[-1e5, 0, 1e4],
direction=[1, 0, 0],
energy=1e9):
propagator.particle.position = pp.Vector3D(position[0], position[1],
position[2])
tmp_dir = pp.Vector3D(direction[0], direction[1], direction[2])
tmp_dir.spherical_from_cartesian()
propagator.particle.direction = tmp_dir
propagator.particle.energy = energy
propagator.particle.propagated_distance = 0
propagator.particle.time = 0
return propagator.propagate()
def propagate(prop, energy, oversampling):
propagation_length = 1e9 # cm
muon_ranges = np.empty(oversampling)
for idx in tqdm(range(oversampling)):
prop.particle.position = pp.Vector3D(0, 0, 0)
prop.particle.direction = pp.Vector3D(1, 0, 0)
prop.particle.propagated_distance = 0
prop.particle.energy = energy
prop.particle.time = 0
secondarys = prop.propagate(propagation_length)
muon_ranges[idx] = prop.particle.propagated_distance
return muon_ranges
def create_propagator(
path_to_inerpolation_tables='~/.local/share/PROPOSAL/tables',
brems_param_name='BremsKelnerKokoulinPetrukhin',
epair_param_name='EpairKelnerKokoulinPetrukhin',
photo_param_name='PhotoAbramowiczLevinLevyMaor97'):
mu_def = pp.particle.MuMinusDef.get()
geometry = pp.geometry.Sphere(pp.Vector3D(), 1.e20, 0.0)
ecut = 500
vcut = -1
sector_def = pp.SectorDefinition()
sector_def.cut_settings = pp.EnergyCutSettings(ecut, vcut)
sector_def.medium = pp.medium.Ice(1.0)
sector_def.geometry = geometry
sector_def.scattering_model = pp.scattering.ScatteringModel.NoScattering
sector_def.crosssection_defs.brems_def.lpm_effect = True
sector_def.crosssection_defs.epair_def.lpm_effect = True
sector_def.do_continuous_randomization = False
sector_def.do_exact_time_calculation = False
sector_def.crosssection_defs.brems_def.parametrization = pp.parametrization.bremsstrahlung.BremsFactory.get(
).get_enum_from_str(brems_param_name)
sector_def.crosssection_defs.epair_def.parametrization = pp.parametrization.pairproduction.EpairFactory.get(
).get_enum_from_str(epair_param_name)
sector_def.crosssection_defs.photo_def.parametrization = pp.parametrization.photonuclear.PhotoFactory.get(
).get_enum_from_str(photo_param_name)
detector = geometry
interpolation_def = pp.InterpolationDef()
interpolation_def.path_to_tables = path_to_inerpolation_tables
interpolation_def.path_to_tables_readonly = path_to_inerpolation_tables
return pp.Propagator(mu_def, [sector_def], detector, interpolation_def)
def muons(energy, statistics, vcut, do_continuous_randomization, dist):
sec_def = pp.SectorDefinition()
sec_def.medium = pp.medium.StandardRock(1.0)
sec_def.geometry = pp.geometry.Sphere(pp.Vector3D(), 1e20, 0)
sec_def.particle_location = pp.ParticleLocation.inside_detector
sec_def.scattering_model = pp.scattering.ScatteringModel.Highland
sec_def.do_continuous_randomization = do_continuous_randomization
sec_def.cut_settings.ecut = 0
sec_def.cut_settings.vcut = vcut
interpolation_def = pp.InterpolationDef()
interpolation_def.path_to_tables = "~/.local/share/PROPOSAL/tables"
interpolation_def.path_to_tables_readonly = "~/.local/share/PROPOSAL/tables"
mu_def = pp.particle.MuMinusDef.get()
prop = pp.Propagator(
particle_def=mu_def,
sector_defs=[sec_def],
detector=pp.geometry.Sphere(pp.Vector3D(), 1e20, 0),
interpolation_def=interpolation_def
)
mu = pp.particle.DynamicData(mu_def.particle_type)
mu.position = pp.Vector3D(0, 0, 0)
mu.direction = pp.Vector3D(0, 0, -1)
mu.energy = energy
mu.propagated_distance = 0.
mu.time = 0.
mu_energies = []
pp.RandomGenerator.get().set_seed(1234)
for i in tqdm(range(statistics)):
secondaries = prop.propagate(mu, dist * 100)
mu_energies.append(secondaries.energy[-1])
# del secondaries
return mu_energies
def muons(energy, statistics, vcut, do_continuous_randomization, dist):
sec_def = pp.SectorDefinition()
sec_def.medium = pp.medium.StandardRock(1.0)
sec_def.geometry = pp.geometry.Sphere(pp.Vector3D(), 1e20, 0)
sec_def.particle_location = pp.ParticleLocation.inside_detector
sec_def.scattering_model = pp.scattering.ScatteringModel.Moliere
sec_def.do_continuous_randomization = do_continuous_randomization
sec_def.cut_settings.ecut = 0
sec_def.cut_settings.vcut = vcut
interpolation_def = pp.InterpolationDef()
interpolation_def.path_to_tables = "tables/"
prop = pp.Propagator(particle_def=pp.particle.MuMinusDef.get(),
sector_defs=[sec_def],
detector=pp.geometry.Sphere(pp.Vector3D(), 1e20, 0),
interpolation_def=interpolation_def)
mu = prop.particle
mu_energies = []
start = timer()
for i in range(statistics):
mu.position = pp.Vector3D(0, 0, 0)
mu.direction = pp.Vector3D(0, 0, -1)
mu.energy = energy
mu.propagated_distance = 0
d = prop.propagate(dist * 100)
mu_energies.append(mu.energy)
end = timer()
return (mu_energies, statistics / (end - start))
pp.particle.EMinusDef.get()
]
mediums = [pp.medium.Ice(1.0), pp.medium.Hydrogen(1.0), pp.medium.Uranium(1.0)]
cuts = [
pp.EnergyCutSettings(-1, -1),
pp.EnergyCutSettings(500, -1),
pp.EnergyCutSettings(-1, 0.05),
pp.EnergyCutSettings(500, 0.05)
]
energies = np.logspace(4, 13, num=10) # MeV
energies_out = np.logspace(3, 12, num=10)
distance = 1000 # cm
position_init = pp.Vector3D(0, 0, 0)
direction_init = pp.Vector3D(1, 0, 0)
direction_init.spherical_from_cartesian()
interpoldef = pp.InterpolationDef()
pp.RandomGenerator.get().set_seed(1234)
def create_table_scatter(dir_name):
with open(dir_name + "Scattering_scatter.txt", "a") as file:
for particle_def in particle_defs:
for medium in mediums:
for cut in cuts:
for idx, parametrization in enumerate(parametrizations):
def propagate_muons():
# start_time = time.time()
mu_def = pp.particle.EPlusDef.get()
geometry = pp.geometry.Sphere(pp.Vector3D(), 1.e20, 0.0)
ecut = 500
vcut = -1
sector_def = pp.SectorDefinition()
sector_def.do_continuous_randomization = False
sector_def.cut_settings = pp.EnergyCutSettings(ecut, vcut)
sector_def.medium = pp.medium.StandardRock(1.0)
sector_def.geometry = geometry
sector_def.scattering_model = pp.scattering.ScatteringModel.NoScattering
#sector_def.crosssection_defs.brems_def.lpm_effect = True
#sector_def.crosssection_defs.epair_def.lpm_effect = False
sector_def.crosssection_defs.annihilation_def.parametrization = pp.parametrization.annihilation.AnnihilationParametrization.Heitler
sector_def.crosssection_defs.ioniz_def.parametrization = pp.parametrization.ionization.IonizParametrization.IonizBergerSeltzerBhabha
sector_def.crosssection_defs.brems_def.parametrization = pp.parametrization.bremsstrahlung.BremsParametrization.ElectronScreening
# sector_def.do_stochastic_loss_weighting = True
# sector_def.stochastic_loss_weighting = -0.1
detector = geometry
interpolation_def = pp.InterpolationDef()
interpolation_def.path_to_tables = "~/.local/share/PROPOSAL/tables"
prop = pp.Propagator(mu_def, [sector_def], detector, interpolation_def)
statistics_log = 5
statistics = int(10**statistics_log)
propagation_length = 1e10 # cm
E_min_log = 8.0
E_max_log = 8.0
spectral_index = 1
pp.RandomGenerator.get().set_seed(1000)
#muon_energies = np.logspace(E_min_log, E_max_log, statistics)
muon_energies = power_law_sampler(spectral_index, 10**E_min_log,
10**E_max_log, statistics)
#muon_energies = np.ones(statistics)*10**10
epair_secondary_energy = []
brems_secondary_energy = []
ioniz_secondary_energy = []
photo_secondary_energy = []
annihilation_secondary_energy = []
plot_energy_histogram(
np.log10(muon_energies), 'energyhist_{}_{}_Emin_{}_Emax_{}.pdf'.format(
prop.particle.particle_def.name, sector_def.medium.name.lower(),
E_min_log, E_max_log, ecut, vcut))
progress = ProgressBar(statistics, pacman=True)
progress.start()
for mu_energy in muon_energies:
progress.update()
prop.particle.position = pp.Vector3D(0, 0, 0)
prop.particle.direction = pp.Vector3D(0, 0, -1)
prop.particle.propagated_distance = 0
prop.particle.energy = mu_energy
secondarys = prop.propagate(propagation_length)
skip_next = False
for sec in secondarys:
if (skip_next):
skip_next = False
continue
if (sec.energy > 0):
log_sec_energy = math.log10(sec.energy)
else:
print(sec.energy)
print(sec.id)
if sec.id == pp.particle.Data.Epair:
epair_secondary_energy.append(log_sec_energy)
elif sec.id == pp.particle.Data.Brems:
brems_secondary_energy.append(log_sec_energy)
elif sec.id == pp.particle.Data.DeltaE:
ioniz_secondary_energy.append(log_sec_energy)
elif sec.id == pp.particle.Data.NuclInt:
photo_secondary_energy.append(log_sec_energy)
else:
annihilation_secondary_energy.append(
math.log10(sec.parent_particle_energy))
skip_next = True # do not include the second photon as well...
# =========================================================
# Write
# =========================================================
dir_prefix = ""
np.savez(os.path.join(
dir_prefix, 'data_sec_dist_{}_{}_Emin_{}_Emax_{}'.format(
prop.particle.particle_def.name, sector_def.medium.name.lower(),
E_min_log, E_max_log, ecut, vcut)),
brems=brems_secondary_energy,
epair=epair_secondary_energy,
photo=photo_secondary_energy,
ioniz=ioniz_secondary_energy,
annihilation=annihilation_secondary_energy,
statistics=[statistics],
statistics_log=[statistics_log],
E_min=[E_min_log],
E_max=[E_max_log],
spectral_index=[spectral_index],
distance=[prop.particle.propagated_distance / 100],
medium_name=[sector_def.medium.name.lower()],
particle_name=[prop.particle.particle_def.name],
ecut=[ecut],
vcut=[vcut])
#statistics:
sum_all = np.sum(brems_secondary_energy) + np.sum(
epair_secondary_energy) + np.sum(photo_secondary_energy) + np.sum(
ioniz_secondary_energy)
num_all = len(brems_secondary_energy) + len(epair_secondary_energy) + len(
photo_secondary_energy) + len(ioniz_secondary_energy)
print(num_all)
print("Brem: ", len(brems_secondary_energy),
len(brems_secondary_energy) / num_all)
print("Epair: ", len(epair_secondary_energy),
len(epair_secondary_energy) / num_all)
print("photo: ", len(photo_secondary_energy),
len(photo_secondary_energy) / num_all)
print("Ioniz: ", len(ioniz_secondary_energy),
len(ioniz_secondary_energy) / num_all)
plot_secondary_spectrum('data_sec_dist_{}_{}_Emin_{}_Emax_{}.npz'.format(
prop.particle.particle_def.name, sector_def.medium.name.lower(),
E_min_log, E_max_log, ecut, vcut))
particle_def_builder = pp.particle.ParticleDefBuilder()
particle_def_builder.SetParticleDef(pp.particle.GammaDef.get())
particle_def_builder.SetLow(0.1) # switch this line to change the e_low parameter
photon_def = particle_def_builder.build()
#photon_def = pp.particle.GammaDef.get()
#photon_def = pp.particle.EMinusDef.get()
photon_def = pp.particle.GammaDef.get()
prop = pp.Propagator(particle_def=photon_def, config_file="config_rad_length.json")
particle_to_prop = prop.particle
particle_backup = pp.particle.Particle(particle_to_prop)
statistics = 1e5
particle_backup.direction = pp.Vector3D(0, 0, -1)
particle_backup.position = pp.Vector3D(0, 0, 1000000)
particle_backup.propagated_distance = 0
particle_backup.energy = 1e5
X_0 = 36.62 # g/cm^2, PDG 2014 .
rho = 1.205e-3 # g / cm^3
L_theorie = X_0 / rho * (9./7.)
energies = np.logspace(1, 8, 12)
L_mc_list = []
for E in energies:
particle_backup.energy = E
prop_length = []
def create_table(dir_name,
particle_def,
init_energy,
decay_products,
filename,
statistics=int(1e6),
NUM_bins=50):
pp.RandomGenerator.get().set_seed(1234)
init_particle = pp.particle.DynamicData(particle_def.particle_type)
init_particle.energy = init_energy
products = decay_products
decay_channels = [
pp.decay.LeptonicDecayChannelApprox(*products),
pp.decay.LeptonicDecayChannel(*products),
pp.decay.ManyBodyPhaseSpace(products, matrix_element_evaluate)
]
decay_names = [
"LeptonicDecayChannelApprox", "LeptonicDecayChannel", "ManyBody"
]
histrogram_list = []
v_max = (particle_def.mass**2 + products[0].mass**2) / (2 *
particle_def.mass)
gamma = init_particle.energy / particle_def.mass
betagamma = init_particle.momentum / particle_def.mass
E_max = gamma * v_max + betagamma * np.sqrt(v_max**2 - products[0].mass**2)
for channel in decay_channels:
# print(particle_def.name, init_energy, channel)
prod_0_energies = []
prod_1_energies = []
prod_2_energies = []
for i in range(statistics):
init_particle.position = pp.Vector3D(0, 0, 0)
init_particle.direction = pp.Vector3D(0, 0, -1)
init_particle.energy = init_energy
init_particle.propagated_distance = 0
decay_products = channel.decay(particle_def, init_particle)
for p in decay_products.particles:
if p.id == products[0].particle_type:
prod_0_energies.append(p.energy)
elif p.id == products[1].particle_type:
prod_1_energies.append(p.energy)
elif p.id == products[2].particle_type:
prod_2_energies.append(p.energy)
else:
assert ("This should never happen")
histogram = []
histogram.append(
np.histogram(prod_0_energies, bins=NUM_bins, range=(0, E_max))[0])
histogram.append(
np.histogram(prod_1_energies, bins=NUM_bins, range=(0, E_max))[0])
histogram.append(
np.histogram(prod_2_energies, bins=NUM_bins, range=(0, E_max))[0])
histrogram_list.append(histogram)
with open(dir_name + filename, "w") as file:
buf = [""]
buf.append(str(statistics))
buf.append(str(NUM_bins))
buf.append(str(particle_def.name))
buf.append(str(init_particle.energy))
buf.append(str(products[0].name))
buf.append(str(products[1].name))
buf.append(str(products[2].name))
buf.append("\n")
file.write("\t".join(buf))
for name, hist in zip(decay_names, histrogram_list):
buf = [""]
buf.append(name)
buf.append("\n")
for prod in hist:
for bin_value in prod:
buf.append(str(bin_value))
buf.append("\n")
file.write("\t".join(buf))
pp.particle.EMinusDef.get()
]
mediums = [pp.medium.Ice(1.0), pp.medium.Hydrogen(1.0), pp.medium.Uranium(1.0)]
cuts = [
pp.EnergyCutSettings(-1, -1),
pp.EnergyCutSettings(500, -1),
pp.EnergyCutSettings(-1, 0.05),
pp.EnergyCutSettings(500, 0.05)
]
energies = np.logspace(4, 13, num=10) # MeV
distance = 1000 # cm
position = pp.Vector3D(0, 0, 0)
direction = pp.Vector3D(1, 0, 0)
# stopping_decay = True
# do_continuous_randomization = True
# do_exact_time_calculation = True
interpoldef = pp.InterpolationDef()
def create_table_propagate(dir_name):
pp.RandomGenerator.get().set_seed(1234)
with open(dir_name + "Sector_propagate.txt", "a") as file:
for particle_def in particle_defs:
def propagate_muons():
# start_time = time.time()
mu_def = pp.particle.MuMinusDef.get()
geometry = pp.geometry.Sphere(pp.Vector3D(), 1.e20, 0.0)
ecut = 500
vcut = 5e-2
sector_def = pp.SectorDefinition()
sector_def.cut_settings = pp.EnergyCutSettings(ecut, vcut)
sector_def.medium = pp.medium.StandardRock(1.0)
sector_def.geometry = geometry
sector_def.scattering_model = pp.scattering.ScatteringModel.NoScattering
sector_def.crosssection_defs.brems_def.lpm_effect = False
sector_def.crosssection_defs.epair_def.lpm_effect = False
# sector_def.crosssection_defs.photo_def.parametrization = pp.parametrization.photonuclear.PhotoParametrization.BezrukovBugaev
# sector_def.do_stochastic_loss_weighting = True
# sector_def.stochastic_loss_weighting = -0.1
detector = geometry
interpolation_def = pp.InterpolationDef()
interpolation_def.path_to_tables = "~/.local/share/PROPOSAL/tables"
prop = pp.Propagator(mu_def, [sector_def], detector, interpolation_def)
statistics_log = 4
statistics = int(10**statistics_log)
propagation_length = 1e4 # cm
E_min_log = 10.0
E_max_log = 10.0
spectral_index = 1.0
pp.RandomGenerator.get().set_seed(1234)
# muon_energies = np.logspace(E_min_log, E_max_log, statistics)
# muon_energies = power_law_sampler(spectral_index, 10**E_min_log, 10**E_max_log, statistics)
muon_energies = np.ones(statistics) * 10**10
epair_secondary_energy = []
brems_secondary_energy = []
ioniz_secondary_energy = []
photo_secondary_energy = []
progress = ProgressBar(statistics, pacman=True)
progress.start()
for mu_energy in muon_energies:
progress.update()
prop.particle.position = pp.Vector3D(0, 0, 0)
prop.particle.direction = pp.Vector3D(0, 0, -1)
prop.particle.propagated_distance = 0
prop.particle.energy = mu_energy
secondarys = prop.propagate(propagation_length)
for sec in secondarys:
log_sec_energy = math.log10(sec.energy)
if sec.id == pp.particle.Data.Epair:
epair_secondary_energy.append(log_sec_energy)
if sec.id == pp.particle.Data.Brems:
brems_secondary_energy.append(log_sec_energy)
if sec.id == pp.particle.Data.DeltaE:
ioniz_secondary_energy.append(log_sec_energy)
if sec.id == pp.particle.Data.NuclInt:
photo_secondary_energy.append(log_sec_energy)
# =========================================================
# Write
# =========================================================
dir_prefix = ""
np.savez(os.path.join(
dir_prefix, 'data_sec_dist_{}_{}_Emin_{}_Emax_{}'.format(
prop.particle.particle_def.name, sector_def.medium.name.lower(),
E_min_log, E_max_log, ecut, vcut)),
brems=brems_secondary_energy,
epair=epair_secondary_energy,
photo=photo_secondary_energy,
ioniz=ioniz_secondary_energy,
statistics=[statistics],
E_min=[E_min_log],
E_max=[E_max_log],
spectral_index=[spectral_index],
distance=[prop.particle.propagated_distance / 100],
medium_name=[sector_def.medium.name.lower()],
particle_name=[prop.particle.particle_def.name],
ecut=[ecut],
vcut=[vcut])
ioniz_primary_energy = []
ioniz_secondary_energy = []
photo_primary_energy = []
photo_secondary_energy = []
length = []
n_secondarys = []
progress = ProgressBar(statistics, pacman=True)
progress.start()
for i in range(statistics):
progress.update()
mu.position = pyPROPOSAL.Vector3D(0, 0, 0)
mu.direction = pyPROPOSAL.Vector3D(0, 0, -1)
mu.energy = math.pow(10, E_max_log)
mu.propagated_distance = 0
secondarys = prop.propagate()
length.append(mu.propagated_distance / 100)
n_secondarys.append(len(secondarys))
for sec in secondarys:
log_sec_energy = math.log10(sec.energy)
log_energy = math.log10(sec.parent_particle_energy)
if sec.id == pyPROPOSAL.particle.Data.Epair:
epair_primary_energy.append(log_energy)
Y = 2. * term1 * term2 - term3
return 4. * (G_F * V_ud * form_factor(q2))**2 * Y
if __name__ == "__main__":
# =========================================================
# Save energies
# =========================================================
statistics = int(1e5)
binning = 50
tau = pp.particle.Particle(pp.particle.TauMinusDef.get())
tau.direction = pp.Vector3D(0, 0, -1)
products = [
pp.particle.Pi0Def.get(),
pp.particle.PiMinusDef.get(),
pp.particle.NuTauDef.get()
]
products_particles = [pp.particle.Particle(p) for p in products]
for p in products_particles:
p.direction = pp.Vector3D(0, 0, -1)
p.energy = 1e2
print(evaluate(tau, products_particles))
ME = pp.decay.ManyBodyPhaseSpace(products, evaluate)
def create_table(dir_name):
"""TODO: Docstring for create_table.
Returns: TODO
"""
statistics = int(1e6)
NUM_bins = 50
pp.RandomGenerator.get().set_seed(1234)
mu = pp.particle.Particle(pp.particle.MuMinusDef.get())
products = [
pp.particle.EMinusDef.get(),
pp.particle.NuMuDef.get(),
pp.particle.NuEBarDef.get()
]
decay_channels = [
pp.decay.LeptonicDecayChannelApprox(*products),
pp.decay.LeptonicDecayChannel(*products)
]
decay_names = ["LeptonicDecayChannelApprox", "LeptonicDecayChannel"]
histrogram_list = []
for channel in decay_channels:
prod_0_energies = []
prod_1_energies = []
prod_2_energies = []
for i in range(statistics):
mu.position = pp.Vector3D(0, 0, 0)
mu.direction = pp.Vector3D(0, 0, -1)
mu.energy = mu.particle_def.mass
mu.propagated_distance = 0
decay_products = channel.decay(mu)
for p in decay_products:
if p.particle_def == products[0]:
prod_0_energies.append(p.energy)
elif p.particle_def == products[1]:
prod_1_energies.append(p.energy)
elif p.particle_def == products[2]:
prod_2_energies.append(p.energy)
else:
assert ("This should never happen")
histogram = []
histogram.append(
np.histogram(prod_0_energies,
bins=NUM_bins,
range=(0, mu.particle_def.mass / 2))[0])
histogram.append(
np.histogram(prod_1_energies,
bins=NUM_bins,
range=(0, mu.particle_def.mass / 2))[0])
histogram.append(
np.histogram(prod_2_energies,
bins=NUM_bins,
range=(0, mu.particle_def.mass / 2))[0])
histrogram_list.append(histogram)
with open(dir_name + "Decay_Leptonic.txt", "a") as file:
buf = [""]
buf.append(str(statistics))
buf.append(str(NUM_bins))
buf.append("\n")
file.write("\t".join(buf))
for name, hist in zip(decay_names, histrogram_list):
buf = [""]
buf.append(name)
buf.append("\n")
for prod in hist:
for bin_value in prod:
buf.append(str(bin_value))
buf.append("\n")
file.write("\t".join(buf))
" particles have been propagated")
return (list_position_i, list_position_f, list_ID, list_energy_i)
if (len(sys.argv) != 3 and len(sys.argv) != 4):
print(
"Invalid arguments! First argument must be energy, second argument shower depth. Third argument optional filename"
)
sys.exit()
print("Start shower propagation with initial energy " +
str(sys.argv[1] + " MeV and maximal depth of " + str(sys.argv[2]) +
" generations."))
list_position_i, list_position_f, list_ID, list_energy_i = start_shower(
float(sys.argv[1]),
int(sys.argv[2]),
direction=pp.Vector3D(0, 0, -1),
position=pp.Vector3D(0, 0, 1000000))
x_list_i = []
y_list_i = []
z_list_i = []
x_list_f = []
y_list_f = []
z_list_f = []
for positions in list_position_i:
x_list_i.append(positions.x)
y_list_i.append(positions.y)
z_list_i.append(positions.z)
def propagate():
""" Propagte muon in ice threw a cylindric detector
Returns:
(Particle) Particle representing the start position
(Geometry) Geometry of the detector
(list) List of secondarys particles represeint interactions
"""
medium = pp.medium.Ice(1.0)
geo_detector = pp.geometry.Cylinder(pp.Vector3D(), 800, 0, 1600)
geo_outside = pp.geometry.Box(pp.Vector3D(), 500000, 500000, 500000)
# Infront
sec_def_infront = pp.SectorDefinition()
sec_def_infront.medium = medium
sec_def_infront.geometry = geo_outside
sec_def_infront.particle_location = pp.ParticleLocation.infront_detector
sec_def_infront.scattering_model = pp.scattering.ScatteringModel.Moliere
sec_def_infront.cut_settings.ecut = -1
sec_def_infront.cut_settings.vcut = 0.05
# Inside
sec_def_inside = pp.SectorDefinition()
sec_def_inside.medium = medium
sec_def_inside.geometry = geo_outside
sec_def_inside.particle_location = pp.ParticleLocation.inside_detector
sec_def_inside.scattering_model = pp.scattering.ScatteringModel.Moliere
sec_def_inside.cut_settings.ecut = 500
sec_def_inside.cut_settings.vcut = -1
# Behind
sec_def_behind = pp.SectorDefinition()
sec_def_behind.medium = medium
sec_def_behind.geometry = geo_outside
sec_def_behind.particle_location = pp.ParticleLocation.behind_detector
sec_def_behind.scattering_model = pp.scattering.ScatteringModel.Moliere
sec_def_behind.cut_settings.ecut = -1
sec_def_behind.cut_settings.vcut = 0.05
# Interpolation defintion
interpolation_def = pp.InterpolationDef()
interpolation_def.path_to_tables = "~/.local/share/PROPOSAL/tables"
# Propagator
prop = pp.Propagator(
particle_def=pp.particle.MuMinusDef.get(),
sector_defs=[sec_def_infront, sec_def_inside, sec_def_behind],
detector=geo_detector,
interpolation_def=interpolation_def)
mu = prop.particle
# Set energy and position of the particle
mu.energy = 9e6
mu.direction = pp.Vector3D(0, 0, 1)
pos = mu.position
pos.set_cartesian_coordinates(0, 0, -1e5)
mu.position = pos
mu_start = pp.particle.Particle(mu)
secondarys = prop.propagate()
return mu_start, geo_detector, secondarys
def propagate_muons():
mu_def = pp.particle.MuMinusDef.get()
geometry = pp.geometry.Sphere(pp.Vector3D(), 1.e20, 0.0)
ecut = 500
vcut = 5e-2
sector_def = pp.SectorDefinition()
sector_def.cut_settings = pp.EnergyCutSettings(ecut, vcut)
sector_def.medium = pp.medium.Ice(1.0)
sector_def.geometry = geometry
sector_def.scattering_model = pp.scattering.ScatteringModel.NoScattering
sector_def.crosssection_defs.brems_def.lpm_effect = True
sector_def.crosssection_defs.epair_def.lpm_effect = True
detector = geometry
interpolation_def = pp.InterpolationDef()
interpolation_def.path_to_tables = "tables/"
prop = pp.Propagator(mu_def, [sector_def], detector, interpolation_def)
statistics = int(1e4)
propagation_length = 1e20 # cm
E_log = 8.0
pp.RandomGenerator.get().set_seed(1234)
muon_energies = np.ones(statistics) * 10**E_log
epair_secondary_energy = []
brems_secondary_energy = []
ioniz_secondary_energy = []
photo_secondary_energy = []
progress = ProgressBar(statistics, pacman=True)
progress.start()
for mu_energy in muon_energies:
progress.update()
prop.particle.position = pp.Vector3D(0, 0, 0)
prop.particle.direction = pp.Vector3D(0, 0, -1)
prop.particle.propagated_distance = 0
prop.particle.energy = mu_energy
secondarys = prop.propagate(propagation_length)
for sec in secondarys:
sec_energy = sec.energy
if sec.id == pp.particle.Data.Epair:
epair_secondary_energy.append(sec_energy)
elif sec.id == pp.particle.Data.Brems:
brems_secondary_energy.append(sec_energy)
elif sec.id == pp.particle.Data.DeltaE:
ioniz_secondary_energy.append(sec_energy)
elif sec.id == pp.particle.Data.NuclInt:
photo_secondary_energy.append(sec_energy)
#statistics:
num_all = len(brems_secondary_energy) + len(epair_secondary_energy) + len(
photo_secondary_energy) + len(ioniz_secondary_energy)
ene_all = sum(brems_secondary_energy) + sum(epair_secondary_energy) + sum(
photo_secondary_energy) + sum(ioniz_secondary_energy)
print("Anzahl:")
print("Brems: ", len(brems_secondary_energy),
len(brems_secondary_energy) / num_all)
print("Epair: ", len(epair_secondary_energy),
len(epair_secondary_energy) / num_all)
print("photo: ", len(photo_secondary_energy),
len(photo_secondary_energy) / num_all)
print("Ioniz: ", len(ioniz_secondary_energy),
len(ioniz_secondary_energy) / num_all)
print("Energie:")
print("Brems ", sum(brems_secondary_energy),
sum(brems_secondary_energy) / ene_all)
print("Epair: ", sum(epair_secondary_energy),
sum(epair_secondary_energy) / ene_all)
print("photo: ", sum(photo_secondary_energy),
sum(photo_secondary_energy) / ene_all)
print("Ioniz: ", sum(ioniz_secondary_energy),
sum(ioniz_secondary_energy) / ene_all)
plt.rcParams.update(params)
fig_all = plt.figure(figsize=(width, 4))
tmp = np.concatenate((ioniz_secondary_energy, brems_secondary_energy,
photo_secondary_energy, epair_secondary_energy))
tmp = tmp[tmp > 0] # remove zero elements
x_space = np.logspace(min(np.log10(tmp)), E_log, 100)
ax_all = fig_all.add_subplot(111)
ax_all.hist([
ioniz_secondary_energy, photo_secondary_energy, brems_secondary_energy,
epair_secondary_energy,
np.concatenate((ioniz_secondary_energy, brems_secondary_energy,
photo_secondary_energy, epair_secondary_energy))
],
histtype='step',
log=True,
bins=x_space,
label=[
'Ionization', 'Photonuclear', 'Bremsstrahlung',
r'$e$ pair production', 'Sum'
],
color=['C3', 'C2', 'C1', 'C0', 'C7'],
zorder=3)
plt.xscale('log')
#minor_locator = AutoMinorLocator()
#ax_all.xaxis.set_minor_locator(minor_locator)
ax_all.legend(loc='best')
ax_all.set_xlabel(r'$ E \cdot v \,/\, \mathrm{MeV} $')
ax_all.set_ylabel(r'Frequency')
#plt.xlim(left=2.5)
plt.grid(grid_conf)
fig_all.tight_layout()
fig_all.savefig("build/spectrum.pdf", bbox_inches='tight')
def main():
prop = pp.Propagator(particle_def=pp.particle.MuMinusDef.get(),
config_file="resources/config.json")
# print('losses inside: ', prop.sector_list[0].sector_def.only_loss_inside_detector)
pp.RandomGenerator.get().set_seed(1234)
fig = plt.figure(figsize=(8, 10))
gs = gridspec.GridSpec(3, 1)
ax1 = fig.add_subplot(gs[:-1])
ax2 = fig.add_subplot(gs[-1], sharex=ax1)
# ax1 = fig.add_subplot(111)
ax1.plot(
np.array([
-prop.detector.radius, prop.detector.radius, prop.detector.radius,
-prop.detector.radius, -prop.detector.radius
]),
np.array([
-prop.detector.height, -prop.detector.height, prop.detector.height,
prop.detector.height, -prop.detector.height
]) / 2,
color='k',
label='detector')
ax1.set_xlabel('x coord. / cm')
ax1.set_ylabel('z coord. / cm')
ax1.set_xlim([-1e5, 1e5])
ax1.set_ylim([-1e5, 1e5])
labels = ['EPair', 'Brems', 'Ioniz', 'NuclInt', r'$e_{\mathrm{decay}}$']
start_positions = np.array([
# [-1e5,0,1e4],
[-1e5, 0, 2e4],
# [-3e4,0,3e4],
# [1e4,0,4e4],
[74428.7, 29332., 69745.]
])
tmp_dir = pp.Vector3D()
tmp_dir.set_spherical_coordinates(1, 0.181678, 1.94055)
tmp_dir.cartesian_from_spherical()
tmp_dir = -tmp_dir
# print(tmp_dir)
start_directions = [
# [1, 0, 0],
[1, 0, 0],
# [1, 0, 0],
# [1, 0, 0],
[tmp_dir.x, tmp_dir.y, tmp_dir.z]
]
start_energies = [
# 1e9,
3e5,
# 1e5,
# 1e5,
158816
]
for jdx in range(len(start_energies)):
secondarys = propagate_particle(prop,
position=start_positions[jdx],
direction=start_directions[jdx],
energy=start_energies[jdx])
# print(prop.particle)
nsecs = len(secondarys) # to get rid of the decay neutrinos
positions = np.empty((nsecs, 3))
secs_energy = np.empty(nsecs)
mu_energies = np.empty(nsecs)
secs_ids = np.empty(nsecs)
for idx in range(nsecs):
positions[idx] = np.array([
secondarys[idx].position.x, secondarys[idx].position.y,
secondarys[idx].position.z
])
secs_energy[idx] = secondarys[idx].energy
mu_energies[idx] = secondarys[idx].parent_particle_energy
if secondarys[idx].id == pp.particle.Data.Epair:
secs_ids[idx] = 0
elif secondarys[idx].id == pp.particle.Data.Brems:
secs_ids[idx] = 1
elif secondarys[idx].id == pp.particle.Data.DeltaE:
secs_ids[idx] = 2
elif secondarys[idx].id == pp.particle.Data.NuclInt:
secs_ids[idx] = 3
elif secondarys[idx].id == pp.particle.Data.Particle:
# decay
if secondarys[idx].particle_def == pp.particle.EMinusDef.get():
secs_ids[idx] = 4
else:
secs_ids[idx] = 5 # Neutrinos
for idx in range(len(labels)):
ax2.plot(positions[:, 0][secs_ids == idx],
secs_energy[secs_ids == idx] / 1e3,
ls='None',
marker='.',
label=labels[idx])
end_position = np.array([[
prop.particle.position.x, prop.particle.position.y,
prop.particle.position.z
]])
# now after ploting the losss, one can add the start position/energy of the muon to plot it
positions = np.concatenate(
([start_positions[jdx]], positions, end_position), axis=0)
mu_energies = np.concatenate(
([start_energies[jdx]], mu_energies, [prop.particle.energy]))
ax2.plot(positions[:, 0], mu_energies / 1e3, label=r'$E_{\mu}$')
ax2.axhline(0.5, color='r', label='ecut')
ax2.axvline(prop.particle.entry_point.x,
color='g',
ls='-',
label='entry/exit')
ax2.axvline(prop.particle.exit_point.x, color='g', ls='-')
ax2.axvline(prop.particle.closet_approach_point.x,
color='b',
ls='dotted',
label='closest approach')
ax2.set_yscale('log')
ax2.set_ylabel('Energy / GeV')
ax2.set_xlabel('x coord. / cm')
# ax2.legend()
plt.subplots_adjust(hspace=.0)
plt.setp(ax1.get_xticklabels(), visible=False)
ax1.plot(positions[:, 0], positions[:, 2],
label='muon') # {}'.format(jdx))
ax1.plot([prop.particle.entry_point.x, prop.particle.exit_point.x],
[prop.particle.entry_point.z, prop.particle.exit_point.z],
ls='None',
marker='x',
label='entry/exit') # {}'.format(jdx))
ax1.plot(prop.particle.closet_approach_point.x,
prop.particle.closet_approach_point.z,
ls='None',
marker='+',
label='closet approach') # {}'.format(jdx))
# ax1.plot([prop.particle.entry_point.x, prop.particle.closet_approach_point.x, prop.particle.exit_point.x],
# [prop.particle.entry_point.z, prop.particle.closet_approach_point.z, prop.particle.exit_point.z],
# ls='dotted', label='approx line')# {}'.format(jdx))
ax1.legend()
fig.savefig('entry_exit_points.png')
plt.show()
import matplotlib.pyplot as plt
except ImportError:
raise ImportError("Matplotlib not installed!")
if __name__ == "__main__":
# =========================================================
# Propagate
# =========================================================
energy = 1e7 # MeV
statistics = 10000
sec_def = pp.SectorDefinition()
sec_def.medium = pp.medium.Ice(1.0)
sec_def.geometry = pp.geometry.Sphere(pp.Vector3D(), 1e20, 0)
sec_def.particle_location = pp.ParticleLocation.inside_detector
sec_def.scattering_model = pp.scattering.ScatteringModel.Moliere
sec_def.crosssection_defs.brems_def.lpm_effect = False
sec_def.crosssection_defs.epair_def.lpm_effect = False
sec_def.cut_settings.ecut = 500
sec_def.cut_settings.vcut = 0.05
interpolation_def = pp.InterpolationDef()
interpolation_def.path_to_tables = "~/.local/share/PROPOSAL/tables"
prop = pp.Propagator(particle_def=pp.particle.MuMinusDef.get(),
sector_defs=[sec_def],
detector=pp.geometry.Sphere(pp.Vector3D(), 1e20, 0),
def create_table(dir_name):
"""TODO: Docstring for create_table.
Returns: TODO
"""
statistics = 10
prop = pp.Propagator(
pp.particle.MuMinusDef.get(),
"resources/config_ice.json"
)
mu = prop.particle
mu.energy = 1e8
mu.propagated_distance = 0
mu.position = pp.Vector3D(0, 0, 0)
mu.direction = pp.Vector3D(0, 0, -1)
pp.RandomGenerator.get().set_seed(1234)
with open(dir_name + "Propagator_propagation.txt", "a") as file:
buf = [""]
buf.append("name")
buf.append("lenght")
buf.append("energy")
buf.append("x")
buf.append("y")
buf.append("z")
buf.append("dx")
buf.append("dy")
buf.append("dz")
buf.append("\n")
buf.append(str(statistics))
buf.append(str(mu.energy))
buf.append("\n")
file.write("\t".join(buf))
for i in range(statistics):
mu.energy = 1e8
mu.propagated_distance = 0
mu.position = pp.Vector3D(0, 0, 0)
mu.direction = pp.Vector3D(0, 0, -1)
daughters = prop.propagate()
buf = [""]
for d in daughters:
if d.id == pp.particle.Data.Particle:
buf.append(d.particle_def.name)
else:
buf.append(str(d.id).split(".")[1])
buf.append(str(d.propagated_distance))
buf.append(str(d.energy))
buf.append(str(d.position.x))
buf.append(str(d.position.y))
buf.append(str(d.position.z))
buf.append(str(d.direction.x))
buf.append(str(d.direction.y))
buf.append(str(d.direction.z))
buf.append("\n")
file.write("\t".join(buf))
return 64 * G_F**2 * p1 * p2
if __name__ == "__main__":
# =========================================================
# Save energies
# =========================================================
statistics = int(1e5)
binning = np.linspace(0, 0.5, 50)
pdef = pp.particle.MuMinusDef.get()
mu = pp.particle.DynamicData(pdef.particle_type)
mu.direction = pp.Vector3D(0, 0, -1)
products = [pp.particle.EMinusDef.get(), pp.particle.NuMuDef.get(), pp.particle.NuEBarDef.get()]
lep_ME = pp.decay.ManyBodyPhaseSpace(products, evaluate)
lep = pp.decay.LeptonicDecayChannelApprox(*products)
E_lep_ME = []
E_lep = []
passed_time = 0.0
for i in tqdm(range(statistics)):
mu.position = pp.Vector3D(0, 0, 0)
mu.direction = pp.Vector3D(0, 0, -1)
mu.energy = pdef.mass
def propagate_muons():
mu_def = pp.particle.MuMinusDef.get()
geometry = pp.geometry.Sphere(pp.Vector3D(), 1.e20, 0.0)
ecut = 500
vcut = -1
sector_def = pp.SectorDefinition()
sector_def.cut_settings = pp.EnergyCutSettings(ecut, vcut)
sector_def.medium = pp.medium.Ice(1.0)
sector_def.geometry = geometry
sector_def.scattering_model = pp.scattering.ScatteringModel.NoScattering
sector_def.crosssection_defs.brems_def.lpm_effect = True
sector_def.crosssection_defs.epair_def.lpm_effect = True
detector = geometry
interpolation_def = pp.InterpolationDef()
interpolation_def.path_to_tables = "tables/"
#initialize propagator without mupairproduction
prop_nomupair = pp.Propagator(mu_def, [sector_def], detector, interpolation_def)
#initialize propagator with mupairproduction
sector_def.crosssection_defs.mupair_def.parametrization = pp.parametrization.mupairproduction.MupairParametrization.KelnerKokoulinPetrukhin
sector_def.crosssection_defs.mupair_def.particle_output = False
prop = pp.Propagator(mu_def, [sector_def], detector, interpolation_def)
# for rho sampling
param_defs_mupair = [mu_def, sector_def.medium, sector_def.cut_settings, 1.0, True, interpolation_def]
param_mupair = pp.parametrization.mupairproduction.KelnerKokoulinPetrukhinInterpolant(*param_defs_mupair)
statistics_log = 5
statistics = int(10**statistics_log)
propagation_length = 1e20 # cm
E_log = 8.0
pp.RandomGenerator.get().set_seed(1234)
### PRIMARY MUON PROPAGATION ###
muon_energies = np.ones(statistics)*10**E_log
epair_secondary_energy = []
brems_secondary_energy = []
ioniz_secondary_energy = []
photo_secondary_energy = []
mpair_secondary_energy = []
mpair_primary_energy = []
print("Propagate primary muons...")
progress = ProgressBar(statistics, pacman=True)
progress.start()
for mu_energy in muon_energies:
progress.update()
prop.particle.position = pp.Vector3D(0, 0, 0)
prop.particle.direction = pp.Vector3D(0, 0, -1)
prop.particle.propagated_distance = 0
prop.particle.energy = mu_energy
secondarys = prop.propagate(propagation_length)
for sec in secondarys:
sec_energy = sec.energy
if sec.id == pp.particle.Data.Epair:
epair_secondary_energy.append(sec_energy)
elif sec.id == pp.particle.Data.Brems:
brems_secondary_energy.append(sec_energy)
elif sec.id == pp.particle.Data.DeltaE:
ioniz_secondary_energy.append(sec_energy)
elif sec.id == pp.particle.Data.NuclInt:
photo_secondary_energy.append(sec_energy)
elif sec.id == pp.particle.Data.MuPair:
mpair_secondary_energy.append(sec_energy)
mpair_primary_energy.append(sec.parent_particle_energy)
#statistics:
num_all = len(brems_secondary_energy) + len(epair_secondary_energy) + len(photo_secondary_energy) + len(ioniz_secondary_energy) + len(mpair_secondary_energy)
ene_all = sum(brems_secondary_energy) + sum(epair_secondary_energy) + sum(photo_secondary_energy) + sum(ioniz_secondary_energy) + sum(mpair_secondary_energy)
print("Number:")
print("Brems: ", len(brems_secondary_energy), len(brems_secondary_energy)/num_all)
print("Epair: ", len(epair_secondary_energy), len(epair_secondary_energy)/num_all)
print("photo: ", len(photo_secondary_energy), len(photo_secondary_energy)/num_all)
print("Ioniz: ", len(ioniz_secondary_energy), len(ioniz_secondary_energy)/num_all)
print("MPair: ", len(mpair_secondary_energy), len(mpair_secondary_energy)/num_all)
print("Energies:")
print("Brems ", sum(brems_secondary_energy), sum(brems_secondary_energy)/ene_all)
print("Epair: ", sum(epair_secondary_energy), sum(epair_secondary_energy)/ene_all)
print("photo: ", sum(photo_secondary_energy), sum(photo_secondary_energy)/ene_all)
print("Ioniz: ", sum(ioniz_secondary_energy), sum(ioniz_secondary_energy)/ene_all)
print("MPair: ", sum(mpair_secondary_energy), sum(mpair_secondary_energy)/ene_all)
plt.rcParams.update(params)
fig_all = plt.figure(
figsize=(width, 4)
)
x_space = np.logspace(min(np.log10(np.concatenate((ioniz_secondary_energy,brems_secondary_energy,photo_secondary_energy,epair_secondary_energy,mpair_secondary_energy)))), E_log, 100)
ax_all = fig_all.add_subplot(111)
ax_all.hist(
[
ioniz_secondary_energy,
photo_secondary_energy,
brems_secondary_energy,
epair_secondary_energy,
mpair_secondary_energy,
np.concatenate((
ioniz_secondary_energy,
brems_secondary_energy,
photo_secondary_energy,
epair_secondary_energy,
mpair_secondary_energy)
)
],
histtype='step',
log=True,
bins=x_space,
label=['Ionization', 'Photonuclear', 'Bremsstrahlung', r'$e$ pair production', r'$\mu$ pair production', 'Sum'],
color = ['C3', 'C2', 'C1', 'C0', 'C4', 'C7'],
zorder = 3
)
plt.xscale('log')
#minor_locator = AutoMinorLocator()
#ax_all.xaxis.set_minor_locator(minor_locator)
ax_all.legend(loc='best')
ax_all.set_xlabel(r'$ E \cdot v \,/\, \mathrm{MeV} $')
ax_all.set_ylabel(r'Frequency')
#plt.xlim(left=2.5)
plt.grid(grid_conf)
fig_all.tight_layout()
fig_all.savefig("build/spectrum_mupair.pdf",bbox_inches='tight')
plt.clf()
epair_old = epair_secondary_energy
brems_old = brems_secondary_energy
ioniz_old = ioniz_secondary_energy
photo_old = photo_secondary_energy
mpair_old = mpair_secondary_energy
### SECONDARY MUON PROPAGATION ###
secondary_muon_energy = []
for E, nu in zip(mpair_primary_energy, mpair_secondary_energy):
rho = param_mupair.Calculaterho(E, nu/E, np.random.rand(), np.random.rand())
secondary_muon_energy.append( 0.5 * nu * (1. + rho) )
secondary_muon_energy.append( 0.5 * nu * (1. - rho) )
epair_secondary_energy = []
brems_secondary_energy = []
ioniz_secondary_energy = []
photo_secondary_energy = []
mpair_secondary_energy = []
print("Propagate secondary muons...")
progress = ProgressBar(len(secondary_muon_energy), pacman=True)
progress.start()
for mu_energy in secondary_muon_energy:
progress.update()
prop.particle.position = pp.Vector3D(0, 0, 0)
prop.particle.direction = pp.Vector3D(0, 0, -1)
prop.particle.propagated_distance = 0
prop.particle.energy = mu_energy
secondarys = prop.propagate(propagation_length)
for sec in secondarys:
sec_energy = sec.energy
if sec.id == pp.particle.Data.Epair:
epair_secondary_energy.append(sec_energy)
elif sec.id == pp.particle.Data.Brems:
brems_secondary_energy.append(sec_energy)
elif sec.id == pp.particle.Data.DeltaE:
ioniz_secondary_energy.append(sec_energy)
elif sec.id == pp.particle.Data.NuclInt:
photo_secondary_energy.append(sec_energy)
elif sec.id == pp.particle.Data.MuPair:
mpair_secondary_energy.append(sec_energy)
print("Number:")
print("Brems: ", len(brems_secondary_energy), len(brems_secondary_energy)/num_all)
print("Epair: ", len(epair_secondary_energy), len(epair_secondary_energy)/num_all)
print("photo: ", len(photo_secondary_energy), len(photo_secondary_energy)/num_all)
print("Ioniz: ", len(ioniz_secondary_energy), len(ioniz_secondary_energy)/num_all)
print("MPair: ", len(mpair_secondary_energy), len(mpair_secondary_energy)/num_all)
print("Energies:")
print("Brems ", sum(brems_secondary_energy), sum(brems_secondary_energy)/ene_all)
print("Epair: ", sum(epair_secondary_energy), sum(epair_secondary_energy)/ene_all)
print("photo: ", sum(photo_secondary_energy), sum(photo_secondary_energy)/ene_all)
print("Ioniz: ", sum(ioniz_secondary_energy), sum(ioniz_secondary_energy)/ene_all)
print("MPair: ", sum(mpair_secondary_energy), sum(mpair_secondary_energy)/ene_all)
### PROPAGATION WITHOUT MUPAIRPRODUCTION
muon_energies = np.ones(statistics)*10**E_log
epair_secondary_energy_nomupair = []
brems_secondary_energy_nomupair = []
ioniz_secondary_energy_nomupair = []
photo_secondary_energy_nomupair = []
print("Propagate muons without MuPairProduction...")
progress = ProgressBar(statistics, pacman=True)
progress.start()
for mu_energy in muon_energies:
progress.update()
prop_nomupair.particle.position = pp.Vector3D(0, 0, 0)
prop_nomupair.particle.direction = pp.Vector3D(0, 0, -1)
prop_nomupair.particle.propagated_distance = 0
prop_nomupair.particle.energy = mu_energy
secondarys = prop_nomupair.propagate(propagation_length)
for sec in secondarys:
sec_energy = sec.energy
if sec.id == pp.particle.Data.Epair:
epair_secondary_energy_nomupair.append(sec_energy)
elif sec.id == pp.particle.Data.Brems:
brems_secondary_energy_nomupair.append(sec_energy)
elif sec.id == pp.particle.Data.DeltaE:
ioniz_secondary_energy_nomupair.append(sec_energy)
elif sec.id == pp.particle.Data.NuclInt:
photo_secondary_energy_nomupair.append(sec_energy)
elif sec.id == pp.particle.Data.MuPair:
print("Something went wrong")
# Comparison plot
plt.rcParams.update(params)
fig_all = plt.figure(
figsize=(width, 4)
)
gs = matplotlib.gridspec.GridSpec(2, 1, height_ratios=[4, 1], hspace=0.1)
x_space = np.logspace(min(np.log10(np.concatenate((ioniz_secondary_energy_nomupair,photo_secondary_energy_nomupair,brems_secondary_energy_nomupair,epair_secondary_energy_nomupair)))), E_log, 100)
ax_all = fig_all.add_subplot(gs[0])
ax_all.hist(
[
ioniz_secondary_energy,
photo_secondary_energy,
brems_secondary_energy,
epair_secondary_energy,
mpair_secondary_energy
],
histtype='step',
color = ['C3', 'C2', 'C1', 'C0', 'C4'],
log=True,
bins=x_space,
zorder = 3,
linestyle = 'dashed',
)
ax_all.hist(
[
ioniz_secondary_energy_nomupair,
photo_secondary_energy_nomupair,
brems_secondary_energy_nomupair,
epair_secondary_energy_nomupair,
np.concatenate((
ioniz_secondary_energy_nomupair,
brems_secondary_energy_nomupair,
photo_secondary_energy_nomupair,
epair_secondary_energy_nomupair)
)
],
color = ['C3', 'C2', 'C1', 'C0', 'C7'],
label=['Ionization', 'Photonuclear', 'Bremsstrahlung', r'$e$ pair production', 'Sum'],
histtype='step',
log=True,
bins=x_space,
zorder = 4,
)
ax_all.hist(
[
np.array([0])
],
color = ['C4'],
label=[r'$\mu$ pair production'],
histtype='step',
log=True,
bins=x_space,
zorder = 0,
)
plt.xscale('log')
#minor_locator = AutoMinorLocator()
#ax_all.xaxis.set_minor_locator(minor_locator)
ax_all.legend(loc='best')
ax_all.set_ylabel(r'Frequency')
#plt.xlim(left=2.5)
plt.grid(grid_conf)
plt.setp(ax_all.get_xticklabels(), visible=False)
plt.tick_params(
axis='x', # changes apply to the x-axis
which='both', # both major and minor ticks are affected
bottom=False, # ticks along the bottom edge are off
top=False, # ticks along the top edge are off
labelbottom=False
) # labels along the bottom edge are off
ax_all = fig_all.add_subplot(gs[1], sharex=ax_all)
hist_1, bin_edges_1 = np.histogram(np.concatenate((ioniz_secondary_energy_nomupair,brems_secondary_energy_nomupair,photo_secondary_energy_nomupair,epair_secondary_energy_nomupair)),
bins = x_space)
hist_2, bin_edges_2 = np.histogram(np.concatenate((epair_old, ioniz_old, brems_old, photo_old, ioniz_secondary_energy,photo_secondary_energy,brems_secondary_energy,epair_secondary_energy,mpair_secondary_energy)),
bins = x_space)
print(np.shape(x_space))
print(np.shape(hist_1))
ax_all.step(x_space[1:], hist_1/hist_2, where='pre', color='C4')
#ax_all.bar(x_space[:-1], hist_1/hist_2, width=np.diff(x_space), align='edge', fill=False)
ax_all.set_xlabel(r'$ E \cdot v \,/\, \mathrm{MeV} $')
ax_all.set_ylabel(r'ratio')
plt.ylim(0.9, 1.1)
plt.grid(grid_conf)
ax_all.axhline(y=1, linewidth=0.5, zorder=0, C = 'C7')
fig_all.tight_layout()
fig_all.savefig("build/spectrum_mupair_secondary_comparison.pdf",bbox_inches='tight')
plt.clf()
# Plot particles from secondary spectrum
plt.rcParams.update(params)
fig_all = plt.figure(
figsize=(width, 4)
)
x_space = np.logspace(min(np.log10(np.concatenate((ioniz_secondary_energy,brems_secondary_energy,photo_secondary_energy,epair_secondary_energy,mpair_secondary_energy)))), E_log, 100)
ax_all = fig_all.add_subplot(111)
ax_all.hist(
[
ioniz_secondary_energy,
photo_secondary_energy,
brems_secondary_energy,
epair_secondary_energy,
mpair_secondary_energy,
np.concatenate((
ioniz_secondary_energy,
brems_secondary_energy,
photo_secondary_energy,
epair_secondary_energy,
mpair_secondary_energy)
)
],
histtype='step',
log=True,
bins=x_space,
label=['Ionization', 'Photonuclear', 'Bremsstrahlung', r'$e$ pair production', r'$\mu$ pair production', 'Sum'],
color = ['C3', 'C2', 'C1', 'C0', 'C4', 'C7'],
zorder = 3
)
plt.xscale('log')
#minor_locator = AutoMinorLocator()
#ax_all.xaxis.set_minor_locator(minor_locator)
ax_all.legend(loc='best')
ax_all.set_xlabel(r'$ E \cdot v \,/\, \mathrm{MeV} $')
ax_all.set_ylabel(r'Frequency')
#plt.xlim(left=2.5)
plt.grid(grid_conf)
fig_all.tight_layout()
fig_all.savefig("build/spectrum_mupair_secondary.pdf",bbox_inches='tight')
plt.clf()
