def process_mc(simtelfile, dl2_file, mc_type):
"""
Process the MC simulated and reconstructed to extract the relevant
parameters to compute the sensitivity
Paramenters
---------
simtel: simtelarray file
dl2_file: `pandas.DataFrame` dl2 parameters
mc_type: 'string' type of particle
Returns
---------
gammaness: `numpy.ndarray`
angdist2: `numpy.ndarray` angular distance squared
e_reco: `numpy.ndarray` reconstructed energies
n_reco: `int` number of reconstructed events
mc_par: `dict` with simulated parameters
"""
source = SimTelFile(simtelfile)
sim_par = read_sim_par(source)
events = pd.read_hdf(dl2_file)
e_reco = 10**events.mc_energy.to_numpy() * u.GeV
gammaness = events.gammaness
#Get source position in radians
focal_length = source.telescope_descriptions[1]['camera_settings']['focal_length'] * u.m
# If the particle is a gamma ray, it returns the squared angular distance
# from the reconstructed gamma-ray position and the simulated incoming position
if mc_type=='gamma':
events = events[events.mc_type==0]
alt2 = events.mc_alt
az2 = np.arctan(np.tan(events.mc_az))
# If the particle is not a gamma-ray (diffuse protons/electrons), it returns
# the squared angular distance of the reconstructed position w.r.t. the
# center of the camera
else:
events = events[events.mc_type!=0]
alt2 = events.mc_alt_tel
az2 = np.arctan(np.tan(events.mc_az_tel))
src_pos_reco = reco_source_position_sky(events.x.values * u.m,
events.y.values * u.m,
events.disp_dx_rec.values * u.m,
events.disp_dy_rec.values * u.m,
focal_length,
events.mc_alt_tel.values * u.rad,
events.mc_az_tel.values * u.rad)
alt1 = src_pos_reco.alt.rad
az1 = np.arctan(np.tan(src_pos_reco.az.rad))
angdist2 = (angular_separation(az1, alt1, az2, alt2).to_numpy() * u.rad)**2
return gammaness, angdist2.to(u.deg**2), e_reco, sim_par
def test_reco_source_position_sky():
cog_x = np.array([2, 1]) * u.m
cog_y = np.array([-1, 1]) * u.m
disp_dx = np.array([-2, -1]) * u.m
disp_dy = np.array([1, -1]) * u.m
focal_length = 28 *u.m
pointing_alt = np.array([1.0, 1.0]) * u.rad
pointing_az = np.array([0.2, 0.5]) * u.rad
sky_coords = utils.reco_source_position_sky(cog_x, cog_y, disp_dx, disp_dy, focal_length, pointing_alt, pointing_az)
np.testing.assert_allclose(sky_coords.alt, pointing_alt, rtol=1e-4)
np.testing.assert_allclose(sky_coords.az, pointing_az, rtol=1e-4)
def main():
custom_config = {}
if args.config_file is not None:
try:
custom_config = read_configuration_file(args.config_file)
except ("Custom configuration could not be loaded !!!"):
pass
config = replace_config(standard_config, custom_config)
reg_energy, reg_disp_vector, cls_gh = dl1_to_dl2.build_models(
args.gammafile,
args.protonfile,
save_models=args.storerf,
path_models=args.path_models,
custom_config=config,
)
gammas = filter_events(
pd.read_hdf(args.gammatest, key=dl1_params_lstcam_key),
config["events_filters"],
)
proton = filter_events(
pd.read_hdf(args.protontest, key=dl1_params_lstcam_key),
config["events_filters"],
)
data = pd.concat([gammas, proton], ignore_index=True)
dl2 = dl1_to_dl2.apply_models(data,
cls_gh,
reg_energy,
reg_disp_vector,
custom_config=config)
####PLOT SOME RESULTS#####
gammas = dl2[dl2.gammaness >= 0.5]
protons = dl2[dl2.gammaness < 0.5]
gammas.reco_type = 0
protons.reco_type = 1
focal_length = 28 * u.m
src_pos_reco = utils.reco_source_position_sky(
gammas.x.values * u.m, gammas.y.values * u.m,
gammas.reco_disp_dx.values * u.m, gammas.reco_disp_dy.values * u.m,
focal_length, gammas.mc_alt_tel.values * u.rad,
gammas.mc_az_tel.values * u.rad)
plot_dl2.plot_features(dl2)
plt.show()
plot_dl2.plot_e(gammas, 10, 1.5, 3.5)
plt.show()
plot_dl2.calc_resolution(gammas)
plt.show()
plot_dl2.plot_e_resolution(gammas, 10, 1.5, 3.5)
plt.show()
plot_dl2.plot_disp_vector(gammas)
plt.show()
try:
ctaplot.plot_theta2(
gammas.mc_alt,
np.arctan(np.tan(gammas.mc_az)),
src_pos_reco.alt.rad,
np.arctan(np.tan(src_pos_reco.az.rad)),
bins=50,
range=(0, 1),
)
plt.show()
ctaplot.plot_angular_res_per_energy(
src_pos_reco.alt.rad, np.arctan(np.tan(src_pos_reco.az.rad)),
gammas.mc_alt, np.arctan(np.tan(gammas.mc_az)), gammas.mc_energy)
plt.show()
except:
pass
regression_features = config["regression_features"]
classification_features = config["classification_features"]
plt.show()
plot_dl2.plot_pos(dl2)
plt.show()
plot_dl2.plot_ROC(cls_gh, dl2, classification_features, -1)
plt.show()
plot_dl2.plot_importances(cls_gh, classification_features)
plt.show()
plot_dl2.plot_importances(reg_energy, regression_features)
plt.show()
plot_dl2.plot_importances(reg_disp_vector, regression_features)
plt.show()
plt.hist(dl2[dl2['mc_type'] == 101]['gammaness'], bins=100)
plt.hist(dl2[dl2['mc_type'] == 0]['gammaness'], bins=100)
plt.show()
def process_mc(dl1_file, dl2_file, mc_type):
"""
Process the MC simulated and reconstructed to extract the relevant
parameters to compute the sensitivity
Paramenters
---------
dl1_file: `pandas.DataFrame` dl1 parameters
dl2_file: `pandas.DataFrame` dl2 parameters
mc_type: 'string' type of particle
Returns
---------
gammaness: `numpy.ndarray`
angdist2: `numpy.ndarray` angular distance squared
e_reco: `numpy.ndarray` reconstructed energies
n_reco: `int` number of reconstructed events
mc_par: `dict` with simulated parameters
"""
sim_par = read_sim_par(dl1_file)
events = pd.read_hdf(dl2_file, key=dl2_params_lstcam_key)
# Filters:
# TO DO: These cuts must be given in a configuration file
# By now: only cut in leakage and intensity
# we use all telescopes (number of events needs to be multiplied
# by the number of LSTs in the simulation)
filter_good_events = ((events.leakage_intensity_width_2 < 0.2)
& (events.intensity > 50))
events = events[filter_good_events]
e_reco = events.reco_energy.to_numpy() * u.TeV
e_true = events.mc_energy.to_numpy() * u.TeV
gammaness = events.gammaness
# TO DO: Focal length should be read from file
#focal_length = source.telescope_descriptions[1]['camera_settings']['focal_length'] * u.m
focal_length = 28 * u.m
# If the particle is a gamma ray, it returns the squared angular distance
# from the reconstructed gamma-ray position and the simulated incoming position
if mc_type == 'gamma':
events = events[events.mc_type == 0]
alt2 = events.mc_alt
az2 = np.arctan(np.tan(events.mc_az))
# If the particle is not a gamma-ray (diffuse protons/electrons), it returns
# the squared angular distance of the reconstructed position w.r.t. the
# center of the camera
else:
events = events[events.mc_type != 0]
alt2 = events.mc_alt_tel
az2 = np.arctan(np.tan(events.mc_az_tel))
# Remember events['src_x'] and events['src_x_rec'] are in meters
src_pos_reco = reco_source_position_sky(
events.x.values * u.m, events.y.values * u.m,
events.reco_disp_dx.values * u.m, events.reco_disp_dy.values * u.m,
focal_length, events.mc_alt_tel.values * u.rad,
events.mc_az_tel.values * u.rad)
alt1 = src_pos_reco.alt.rad
az1 = np.arctan(np.tan(src_pos_reco.az.rad))
angdist2 = (angular_separation(az1, alt1, az2, alt2).to_numpy() * u.rad)**2
events['theta2'] = angdist2
return gammaness, angdist2.to(u.deg**2), e_reco, e_true, sim_par, events
data = pd.concat([gammas, proton], ignore_index=True)
dl2 = dl1_to_dl2.apply_models(data, features, cls_gh, reg_energy,
reg_disp_vector)
####PLOT SOME RESULTS#####
gammas = dl2[dl2.gammaness >= 0.5]
protons = dl2[dl2.gammaness < 0.5]
gammas.reco_type = 0
protons.reco_type = 1
focal_length = 28 * u.m
src_pos_reco = utils.reco_source_position_sky(
gammas.x.values * u.m, gammas.y.values * u.m,
gammas.disp_dx_rec.values * u.m, gammas.disp_dy_rec.values * u.m,
focal_length, gammas.mc_alt_tel.values * u.rad,
gammas.mc_az_tel.values * u.rad)
plot_dl2.plot_features(dl2)
plt.show()
plot_dl2.plot_e(gammas, 10, 1.5, 3.5)
plt.show()
plot_dl2.calc_resolution(gammas)
plt.show()
plot_dl2.plot_e_resolution(gammas, 10, 1.5, 3.5)
plt.show()