def main():
print("input file: {}".format(args.input_file))
print("output file: {}".format(args.output_file))
print("pedestal file: {}".format(args.pedestal_file))
print("calibration file: {}".format(args.calibration_file))
print("max events: {}".format(args.max_events))
# Camera geometry
geom = CameraGeometry.from_name("LSTCam-002")
# Definition of the output parameters for the table
output_parameters = {
'event_id': [],
'ring_size': [],
'size_outside': [],
'ring_radius': [],
'ring_width': [],
'good_ring': [],
'muon_efficiency': [],
'ring_containment': [],
'ring_completeness': [],
'ring_pixel_completeness': [],
'impact_parameter': [],
'impact_x_array': [],
'impact_y_array': [],
}
# Calibration related quantities
r0calib = LSTR0Corrections(pedestal_path=args.pedestal_file,
r1_sample_start=2,
r1_sample_end=38)
ff_data = FlatFieldContainer()
cal_data = WaveformCalibrationContainer()
ped_data = PedestalContainer()
dc_to_pe = []
ped_median = []
if (args.run_number >
500): # Not sure where did the tel definition change
with HDF5TableReader(args.calibration_file) as h5_table:
assert h5_table._h5file.isopen == True
for cont in h5_table.read('/tel_1/pedestal', ped_data):
ped_median = cont.charge_median
for calib in h5_table.read('/tel_1/calibration', cal_data):
dc_to_pe = calib['dc_to_pe']
h5_table.close()
else:
with HDF5TableReader(args.calibration_file) as h5_table:
assert h5_table._h5file.isopen == True
for cont in h5_table.read('/tel_0/pedestal', ped_data):
ped_median = cont.charge_median
for calib in h5_table.read('/tel_0/calibration', cal_data):
dc_to_pe = calib['dc_to_pe']
h5_table.close()
# Maximum number of events
if (args.max_events):
max_events = args.max_events
else:
max_events = None
# File open
num_muons = 0
source = event_source(input_url=args.input_file, max_events=max_events)
for event in source:
r0calib.calibrate(event)
# Not sure where did the tel definition change
# but we moved to tel[0] to tel[1] at some point
# of the commissioning period
if (args.run_number > 500):
event_id = event.lst.tel[1].evt.event_id
telescope_description = event.inst.subarray.tel[1]
pedcorrectedsamples = event.r1.tel[1].waveform
else:
event_id = event.lst.tel[0].evt.event_id
telescope_description = event.inst.subarray.tel[0]
pedcorrectedsamples = event.r1.tel[0].waveform
integrator = LocalPeakWindowSum(window_shift=4, window_width=9)
integration, pulse_time = integrator(pedcorrectedsamples)
image = (integration - ped_median) * dc_to_pe
# WARNING!!!
# The current analysis is not performed using gain selection
# image[0] is the extracted image from low gain.
print("Event {}. Number of pixels above 10 phe: {}".format(
event_id, np.size(image[0][image[0] > 10.])))
if not tag_pix_thr(
image[0]): #default skipps pedestal and calibration events
continue
if not muon_filter(image[0]): #default values apply no filtering
continue
equivalent_focal_length = telescope_description.optics.equivalent_focal_length
mirror_area = telescope_description.optics.mirror_area.to("m2")
muonintensityparam, size_outside_ring, muonringparam, good_ring = \
analyze_muon_event(event_id, image[0], geom, equivalent_focal_length,
mirror_area, args.plot_rings, args.plots_path)
#if not (good_ring):
# continue
print("Number of muons found {}, EventID {}".format(
num_muons, event_id))
num_muons = num_muons + 1
output_parameters['event_id'].append(event_id)
output_parameters['ring_size'].append(muonintensityparam.ring_size)
output_parameters['size_outside'].append(size_outside_ring)
output_parameters['ring_radius'].append(
muonringparam.ring_radius.value)
output_parameters['ring_width'].append(
muonintensityparam.ring_width.value)
output_parameters['good_ring'].append(good_ring)
output_parameters['muon_efficiency'].append(
muonintensityparam.optical_efficiency_muon)
output_parameters['ring_containment'].append(
muonringparam.ring_containment)
output_parameters['ring_completeness'].append(
muonintensityparam.ring_completeness)
output_parameters['ring_pixel_completeness'].append(
muonintensityparam.ring_pix_completeness)
output_parameters['impact_parameter'].append(
muonintensityparam.impact_parameter.value)
output_parameters['impact_x_array'].append(
muonintensityparam.impact_parameter_pos_x.value)
output_parameters['impact_y_array'].append(
muonintensityparam.impact_parameter_pos_y.value)
table = Table(output_parameters)
if os.path.exists(args.output_file):
os.remove(args.output_file)
table.write(args.output_file, format='fits')
def main():
print("input files: {}".format(args.input_file))
print("calib file: {}".format(args.calib_file))
print("output file: {}".format(args.output_file))
max_muons = args.max_muons
# Definition of the output parameters for the table
output_parameters = create_muon_table()
if args.calib_file is not None:
plot_calib.read_file(args.calib_file)
bad_pixels = plot_calib.calib_data.unusable_pixels[0]
print(f"Found a total of {np.sum(bad_pixels)} bad pixels.")
# image = pd.read_hdf(args.input_file, key = dl1_image_lstcam_key)
# The call above does not work, because of the file's vector columns (pixel-wise charges & times)
# So we use tables for the time being.
print(glob.glob(args.input_file))
filenames = glob.glob(args.input_file)
filenames.sort()
lst1_tel_id = 1
num_muons = 0
for filename in filenames:
print('Opening file', filename)
cam_description_table = Table.read(
filename, path="instrument/telescope/camera/LSTCam")
geom = CameraGeometry.from_table(cam_description_table)
subarray = read_subarray_description(filename, subarray_name='LST-1')
images = Table.read(filename, path=dl1_images_lstcam_key)['image']
parameters = pd.read_hdf(filename, key=dl1_params_lstcam_key)
telescope_description = read_telescopes_descriptions(
filename)[lst1_tel_id]
equivalent_focal_length = telescope_description.optics.equivalent_focal_length
mirror_area = telescope_description.optics.mirror_area
# fill dummy event times with NaNs in case they do not exist (like in MC):
if 'dragon_time' not in parameters.keys():
dummy_times = np.empty(len(parameters['event_id']))
dummy_times[:] = np.nan
parameters['dragon_time'] = dummy_times
for full_image, event_id, dragon_time in zip(
images, parameters['event_id'], parameters['dragon_time']):
if args.calib_file is not None:
image = full_image * (~bad_pixels)
else:
image = full_image
# print("Event {}. Number of pixels above 10 phe: {}".format(event_id,
# np.size(image[image > 10.])))
# if((np.size(image[image > 10.]) > 300) or (np.size(image[image > 10.]) < 50)):
# continue
if not tag_pix_thr(
image): # default skips pedestal and calibration events
continue
# default values apply no filtering.
# This filter is rather useless for biased extractors anyway
# if not muon_filter(image)
# continue
(muonintensityparam, dist_mask, size, size_outside_ring,
muonringparam, good_ring, radial_distribution,
mean_pixel_charge_around_ring,
muonparameters) = analyze_muon_event(subarray, event_id, image,
geom,
equivalent_focal_length,
mirror_area, args.plot_rings,
args.plots_path)
if good_ring:
num_muons += 1
print("Number of good muon rings found {}, EventID {}".format(
num_muons, event_id))
# write ring data, including also "not-so-good" rings
# in case we want to reconsider ring selections!:
fill_muon_event(parameters, output_parameters, good_ring, event_id,
dragon_time, muonintensityparam, dist_mask,
muonringparam, radial_distribution, size,
size_outside_ring, mean_pixel_charge_around_ring,
muonparameters)
if max_muons is not None and num_muons == max_muons:
break
if max_muons is not None and num_muons == max_muons:
break
table = Table(output_parameters)
table.write(args.output_file, format='fits', overwrite=True)
def main():
print("input file: {}".format(args.input_file))
print("output file: {}".format(args.output_file))
print("pedestal file: {}".format(args.pedestal_file))
print("calibration file: {}".format(args.calibration_file))
print("time calibration file: {}".format(args.time_calibration_file))
print("max events: {}".format(args.max_events))
# Camera geometry
#geom = CameraGeometry.from_name("LSTCam-003")
# Definition of the output parameters for the table
output_parameters = {
'event_id': [],
'ring_size': [],
'size_outside': [],
'ring_radius': [],
'ring_width': [],
'good_ring': [],
'muon_efficiency': [],
'ring_containment': [],
'ring_completeness': [],
'ring_pixel_completeness': [],
'impact_parameter': [],
'impact_x_array': [],
'impact_y_array': [],
}
tel_id = args.tel_id
# Low level calibration
r0calib = LSTR0Corrections(pedestal_path=args.pedestal_file, tel_id=tel_id)
# high level calibration and gain selection
charge_config = Config(
{"LocalPeakWindowSum": {
"window_shift": 4,
"window_width": 8
}})
r1_dl1_calibrator = LSTCameraCalibrator(
calibration_path=args.calibration_file,
time_calibration_path=args.time_calibration_file,
image_extractor="LocalPeakWindowSum",
config=charge_config,
gain_threshold=args.gain_threshold,
allowed_tels=[tel_id])
# Maximum number of events
if args.max_events:
max_events = args.max_events
else:
max_events = None
# File open
num_muons = 0
source = event_source(input_url=args.input_file, max_events=max_events)
# geometry
subarray = source.subarray(tel_id)
telescope_description = subarray.tel[tel_id]
equivalent_focal_length = telescope_description.optics.equivalent_focal_length
mirror_area = telescope_description.optics.mirror_area.to("m2")
geom = telescope_description.camera
for event in source:
event_id = event.lst.tel[tel_id].evt.event_id
# drs4 calibration
r0calib.calibrate(event)
# r1 calibration
r1_dl1_calibrator(event)
image = event.dl1.tel[tel_id].image
if not tag_pix_thr(
image): #default skipps pedestal and calibration events
continue
if not muon_filter(image, 800,
5000): #default values apply no filtering
continue
print("--> Event {}. Number of pixels above 10 phe: {}".format(
event_id, np.size(image[image > 10.])))
muonintensityparam, size_outside_ring, muonringparam, good_ring = \
analyze_muon_event(event_id, image, geom, equivalent_focal_length,
mirror_area, args.plot_rings, args.plots_path)
#if not (good_ring):
# continue
print("Number of muons found {}, EventID {}".format(
num_muons, event_id))
num_muons = num_muons + 1
output_parameters['event_id'].append(event_id)
output_parameters['ring_size'].append(muonintensityparam.ring_size)
output_parameters['size_outside'].append(size_outside_ring)
output_parameters['ring_radius'].append(
muonringparam.ring_radius.value)
output_parameters['ring_width'].append(
muonintensityparam.ring_width.value)
output_parameters['good_ring'].append(good_ring)
output_parameters['muon_efficiency'].append(
muonintensityparam.optical_efficiency_muon)
output_parameters['ring_containment'].append(
muonringparam.ring_containment)
output_parameters['ring_completeness'].append(
muonintensityparam.ring_completeness)
output_parameters['ring_pixel_completeness'].append(
muonintensityparam.ring_pix_completeness)
output_parameters['impact_parameter'].append(
muonintensityparam.impact_parameter.value)
output_parameters['impact_x_array'].append(
muonintensityparam.impact_parameter_pos_x.value)
output_parameters['impact_y_array'].append(
muonintensityparam.impact_parameter_pos_y.value)
table = Table(output_parameters)
if os.path.exists(args.output_file):
os.remove(args.output_file)
table.write(args.output_file, format='fits')
