def main(input_file, output_file, limit):
'''
The INPUT_FILE argument specifies the path to a simtel file. This script reads the
camera definitions from there and puts them into a json file
specified by OUTPUT_FILE argument.
'''
event_source = EventSourceFactory.produce(
input_url=input_file,
max_events=limit if limit > 1 else None,
)
calibrator = CameraCalibrator(eventsource=event_source, )
data = []
for id, event in tqdm(enumerate(event_source)):
if len(valid_triggerd_cameras(event)) < 2:
continue
calibrator.calibrate(event)
c = {}
# import IPython; IPython.embed()
c['array'] = fill_array_dict(valid_triggerd_telescope_ids(event))
c['event_id'] = id
c['images'] = fill_images_dict(event)
c['mc'] = fill_mc_dict(event)
data.append(c)
with gzip.open(output_file, 'wt') as of:
json.dump(data, of, indent=2)
def setup(self):
# load up the telescope types table (need to first open a file, a bit of
# a hack until a proper insturment module exists) and select only the
# telescopes with the same camera type
self.reader = SimTelEventSource(
input_url=self.infile, max_events=self.max_events
)
for event in self.reader:
camtypes = event.inst.subarray.to_table().group_by('camera_type')
event.inst.subarray.info(printer=self.log.info)
break
group = camtypes.groups[self.telgroup]
self._selected_tels = list(group['id'].data)
self._base_tel = self._selected_tels[0]
self.log.info(
"Telescope group %d: %s", self.telgroup,
str(event.inst.subarray.tel[self._selected_tels[0]])
)
self.log.info(f"SELECTED TELESCOPES:{self._selected_tels}")
self.calibrator = CameraCalibrator(
parent=self, eventsource=self.reader
)
self.reader.allowed_tels = self._selected_tels
def setup(self):
self.log.info('Configure EventSourceFactory...')
self.event_source = EventSourceFactory.produce(
config=self.config, tool=self, product='HESSIOEventSource')
self.event_source.allowed_tels = self.config['Analysis'][
'allowed_tels']
self.calibrator = CameraCalibrator(config=self.config,
tool=self,
eventsource=self.event_source)
self.writer = HDF5TableWriter(filename=self.outfile,
group_name='image_infos',
overwrite=True)
# Define Pre-selection for images
preselcuts = self.config['Preselect']
self.image_cutflow = CutFlow('Image preselection')
self.image_cutflow.set_cuts(
dict(no_sel=None,
n_pixel=lambda s: np.count_nonzero(s) < preselcuts['n_pixel'][
'min'],
image_amplitude=lambda q: q < preselcuts['image_amplitude'][
'min']))
# Define Pre-selection for events
self.event_cutflow = CutFlow('Event preselection')
self.event_cutflow.set_cuts(dict(no_sel=None))
def __init__(self,
telescopes,
file_name_mask,
load_option,
calibrate=False,
use_cut_value=-1,
pedestals_only=False):
"""
:param particleID: ID of particle to save, deprecated
:param telescopes: set of telescopes to save events for
:param start_at_runnum: runnum to start at
:param end_at_runnum: runnum to stop at (file is included)
:param load_file_name_start: name of file to load after runnum
:param load_file_name_end: name of file to load after runnum
:param use_cut_value: use cut and remove all events lower, -1 for no cut
"""
self.pedestals_only = pedestals_only
self.calibrate = calibrate
self.eventList = []
self.load_option = load_option
CameraCalibrator()
# CameraCalibrator()
if calibrate:
config = traitlets.config.Config()
self.calibrator = CameraCalibrator(config=config)
# r1_product="HESSIOR1Calibrator",extractor_product="NeighbourPeakIntegrator",
self.telescopes = telescopes
#
# Mask run number with @
#
self.runnumset = set()
p = file_name_mask.split(sep="/")
path = ""
for k in range(len(p) - 1):
path += p[k] + "/"
filename_mask = p[-1]
p = None
self.masked_file_name = filename_mask
self.path = path
fl = glob.glob(path + filename_mask.replace('@', '*'))
mask = r"\w+_M\d{1}.*_(\d+).*_Y_.+.*"
for fp in fl:
s2 = fp.split(sep="/")[-1]
self.runnumset.add(re.findall(mask, s2)[0])
self.file_name_mask = filename_mask
self.cut_value = use_cut_value
self.use_cut = False if self.cut_value == -1 else True
if load_option == LoadOption.cal_at_once:
self.loadFilesWithMask()
class DisplayDL1Calib(Tool):
name = "ctapipe-display-dl1"
description = __doc__
telescope = Int(None,
allow_none=True,
help='Telescope to view. Set to None to display all '
'telescopes.').tag(config=True)
extractor_product = tool_utils.enum_trait(ImageExtractor,
default='NeighborPeakWindowSum')
aliases = Dict(
dict(max_events='EventSource.max_events',
extractor='DisplayDL1Calib.extractor_product',
T='DisplayDL1Calib.telescope',
O='ImagePlotter.output_path'))
flags = Dict(
dict(D=({
'ImagePlotter': {
'display': True
}
}, "Display the photoelectron images on-screen as they "
"are produced.")))
classes = List([EventSource, CameraDL1Calibrator, ImagePlotter] +
tool_utils.classes_with_traits(ImageExtractor))
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.eventsource = None
self.calibrator = None
self.plotter = None
def setup(self):
self.eventsource = EventSource.from_url(
get_dataset_path("gamma_test_large.simtel.gz"),
parent=self,
)
self.calibrator = CameraCalibrator(parent=self)
self.plotter = ImagePlotter(parent=self)
def start(self):
for event in self.eventsource:
self.calibrator.calibrate(event)
tel_list = event.r0.tels_with_data
if self.telescope:
if self.telescope not in tel_list:
continue
tel_list = [self.telescope]
for telid in tel_list:
self.plotter.plot(event, telid)
def finish(self):
self.plotter.finish()
def setup(self):
kwargs = dict(config=self.config, tool=self)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(**kwargs)
self.cal = CameraCalibrator(r1_product=self.calibrator)
self.calculator = ChargeResolutionCalculator(**kwargs)
def setup(self):
if self.events == '':
raise ToolConfigurationError("please specify --input <events file>")
self.log.debug("input: %s", self.events)
self.source = event_source(self.events)
self.calib = CameraCalibrator(
config=self.config, tool=self, eventsource=self.source
)
self.writer = HDF5TableWriter(self.outfile, "muons")
def setup(self):
self.eventsource = EventSource.from_url(
get_dataset_path("gamma_test_large.simtel.gz"),
parent=self,
)
self.calibrator = CameraCalibrator(parent=self)
self.plotter = ImagePlotter(parent=self)
def load_calibrate(filename):
# LOAD AND CALIBRATE
# pwd = "/home/thomas/Programs/astro/CTAPIPE_DAN/"
# filename = 'gamma_20deg_0deg_run100___cta-prod3-lapalma3-2147m-LaPalma_cone10.simtel.gz'
# filename = 'gamma_20deg_0deg_run100___cta-prod3_desert-2150m-Paranal-merged.simtel.gz'
# filename = 'gamma_20deg_0deg_run118___cta-prod3_desert-2150m-Paranal-merged_cone10.simtel.gz'
# filename = 'gamma_20deg_180deg_run11___cta-prod3_desert-2150m-Paranal-merged_cone10.simtel.gz'
# layout = np.loadtxt(pwd+'CTA.prod3Sb.3HB9-FG.lis', usecols=0, dtype=int)
if "Paranal" in filename:
layout = [4, 5, 6, 11]
print("PARANAL WITH {0}".format(layout))
elif "palma" in filename:
layout = [5, 6, 7, 8]
print("LAPALMA WITH {0}".format(layout))
print("Layout telescopes IDs:".format(layout))
# layout = [279, 280, 281, 282, 283, 284, 286, 287, 289, 297, 298, 299,
# 300, 301, 302, 303, 304, 305, 306, 307, 308, 315, 316, 317,
# 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329,
# 330, 331, 332, 333, 334, 335, 336, 337, 338, 345, 346, 347,
# 348, 349, 350, 375, 376, 377, 378, 379, 380, 393, 400, 402,
# 403, 404, 405, 406, 408, 410, 411, 412, 413, 414, 415, 416,
# 417]
layout = set(layout)
source = event_source(filename)
source.max_events = 50
source.allowed_tels = layout
events = [copy.deepcopy(event) for event in source]
cal = CameraCalibrator(None,
None,
r1_product='HESSIOR1Calibrator',
extractor_product='NeighbourPeakIntegrator')
for event in events:
cal.calibrate(event)
# Find "big" event (piece of code from T.V. notebook ...thanks :D )
events_amplitude = []
for event in events:
event_amplitude = 0
for tel_id in event.r0.tels_with_data:
if event.dl1.tel[tel_id].image is not None:
event_amplitude += event.dl1.tel[tel_id].image[0].sum()
events_amplitude.append(event_amplitude)
events_amplitude = np.array(events_amplitude)
mm = events_amplitude.argmax()
print("event: {0}".format(mm))
event = events[mm]
return event
def setup(self):
kwargs = dict(config=self.config, tool=self)
self.eventsource = EventSourceFactory.produce(
input_url=get_dataset("gamma_test.simtel.gz"), **kwargs)
self.calibrator = CameraCalibrator(eventsource=self.eventsource,
**kwargs)
self.plotter = ImagePlotter(**kwargs)
def setup(self):
kwargs = dict(config=self.config, tool=self)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(**kwargs)
self.cal = CameraCalibrator(r1_product=self.calibrator)
self.cross = CrossCorrelation()
self.glob_peak = GlobalPeakIntegrator()
self.local_peak = LocalPeakIntegrator()
self.neighbour = NeighbourPeakIntegrator()
self.aver = AverageWfPeakIntegrator()
def setup(self):
print('TOLLES INFILE', self.infile)
self.event_source = EventSource.from_url(self.infile, parent=self)
self.event_source.allowed_tels = {
self.tel,
}
self.calibrator = CameraCalibrator(parent=self)
self.log.info(f'SELECTING EVENTS FROM TELESCOPE {self.tel}')
def setup(self):
kwargs = dict(config=self.config, tool=self)
reader_factory = EventFileReaderFactory(**kwargs)
reader_class = reader_factory.get_class()
self.reader = reader_class(**kwargs)
self.calibrator = CameraCalibrator(origin=self.reader.origin, **kwargs)
self.plotter = ImagePlotter(**kwargs)
def setup(self):
reader_factory = EventFileReaderFactory(None, self)
reader_class = reader_factory.get_class()
self.reader = reader_class(None, self)
self.calibrator = CameraCalibrator(config=None, tool=self,
origin=self.reader.origin)
self.source = self.reader.read(allowed_tels=[self.tel, ])
self.log.info('SELECTING EVENTS FROM TELESCOPE {}'.format(self.tel))
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
kwargs = dict(config=self.config, tool=self)
reader_factory = EventFileReaderFactory(**kwargs)
reader_class = reader_factory.get_class()
self.reader = reader_class(**kwargs)
self.calibrator = CameraCalibrator(origin=self.reader.origin, **kwargs)
self.plotter = ImagePlotter(**kwargs)
def setup(self):
self.event_source = EventSource.from_config(config=self.config,
tool=self)
self.event_source.allowed_tels = [
self.tel,
]
self.calibrator = CameraCalibrator(config=self.config,
tool=self,
eventsource=self.event_source)
self.log.info(f'SELECTING EVENTS FROM TELESCOPE {self.tel}')
def setup(self):
self.event_source = EventSourceFactory.produce(config=self.config,
tool=self)
self.event_source.allowed_tels = [
self.tel,
]
self.calibrator = CameraCalibrator(config=self.config,
tool=self,
eventsource=self.event_source)
self.log.info('SELECTING EVENTS FROM TELESCOPE {}'.format(self.tel))
def setup(self):
# load up the telescope types table (need to first open a file, a bit of
# a hack until a proper insturment module exists) and select only the
# telescopes with the same camera type
data = next(hessio_event_source(self.infile, max_events=1))
camtypes = get_camera_types(data.inst)
group = camtypes.groups[self.telgroup]
self._selected_tels = group['tel_id'].data
self._base_tel = self._selected_tels[0]
self.log.info("Telescope group %d: %s with %s camera", self.telgroup,
group[0]['tel_type'], group[0]['cam_type'])
self.log.info("SELECTED TELESCOPES:{}".format(self._selected_tels))
self.calibrator = CameraCalibrator(self.config, self)
def setup(self):
kwargs = dict(config=self.config, tool=self)
self.eventsource = event_source(
get_dataset_path("gamma_test.simtel.gz"),
**kwargs
)
self.calibrator = CameraCalibrator(
eventsource=self.eventsource, **kwargs
)
self.plotter = ImagePlotter(**kwargs)
def setup(self):
# load up the telescope types table (need to first open a file, a bit of
# a hack until a proper insturment module exists) and select only the
# telescopes with the same camera type
data = next(hessio_event_source(self.infile, max_events=1))
data.inst.subarray.info(printer=self.log.info)
camtypes = data.inst.subarray.to_table().group_by('camera_type')
group = camtypes.groups[self.telgroup]
self._selected_tels = group['tel_id'].data
self._base_tel = self._selected_tels[0]
self.log.info("Telescope group %d: %s", self.telgroup,
str(data.inst.subarray.tel[self._selected_tels[0]]))
self.log.info("SELECTED TELESCOPES:{}".format(self._selected_tels))
self.calibrator = CameraCalibrator(self.config, self)
def main(simtel_file, output_pdf, num_events):
event_source = EventSourceFactory.produce(
input_url=simtel_file,
max_events=num_events,
)
calibrator = CameraCalibrator(eventsource=event_source, )
with PdfPages(output_pdf) as pdf:
for event in tqdm(event_source, total=num_events):
if event.mc.energy > 10 * u.TeV:
calibrator.calibrate(event)
reco = HillasReconstructor()
plt.figure(figsize=(20, 20))
plt.suptitle(
f'EVENT {event.r0.event_id} \n Energy: {event.mc.energy} \n Type: {event.mc.shower_primary_id}'
)
try:
result = plot_event(event, reco, pdf)
except TooFewTelescopesException:
pdf.savefig() # saves the current figure into a pdf page
plt.close()
continue
pdf.savefig() # saves the current figure into a pdf page
plt.close()
d = calculate_distance_theta(result.alt, result.az,
event.mc.alt, event.mc.az)
plt.figure(figsize=(18, 18))
plot_array_birdsview(event, result, reco)
plt.suptitle(
f'EVENT {event.r0.event_id} \n Energy: {event.mc.energy} \n Type: {event.mc.shower_primary_id} \n \
Alt: {event.mc.alt.to(u.deg)}, Az: {event.mc.az.to(u.deg)} \n \
Predicted Alt: {result.alt.to(u.deg)}, Predicted Az: {result.az.to(u.deg)} \n \
Distance {d}')
plt.legend()
pdf.savefig() # saves the current figure into a pdf page
plt.close()
plt.figure(figsize=(18, 18))
plot_array_sideview(event, result, reco)
plt.suptitle(
f'EVENT {event.r0.event_id} \n Energy: {event.mc.energy} \n Type: {event.mc.shower_primary_id} \n \
Alt: {event.mc.alt.to(u.deg)}, Az: {event.mc.az.to(u.deg)} \n \
Predicted Alt: {result.alt.to(u.deg)}, Predicted Az: {result.az.to(u.deg)} \n \
Distance: {d}')
plt.legend()
pdf.savefig() # saves the current figure into a pdf page
plt.close()
def setup(self):
kwargs = dict(config=self.config, tool=self)
self.run_list = np.loadtxt('%s/../runlist.txt' % self.input_path,
unpack=True)
self.file_list = listdir('%s' % self.input_path)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(**kwargs)
self.cal = CameraCalibrator(
eventsource=EventSourceFactory.produce(input_url="%s/%s" %
(self.input_path,
self.file_list[0]),
max_events=1))
def test_reconstructors(reconstructors):
"""
a test of the complete fit procedure on one event including:
• tailcut cleaning
• hillas parametrisation
• HillasPlane creation
• direction fit
• position fit
in the end, proper units in the output are asserted"""
filename = get_dataset_path(
"gamma_LaPalma_baseline_20Zd_180Az_prod3b_test.simtel.gz"
)
source = EventSource(filename, max_events=10, focal_length_choice="nominal")
subarray = source.subarray
calib = CameraCalibrator(source.subarray)
image_processor = ImageProcessor(source.subarray)
for event in source:
calib(event)
image_processor(event)
for ReconstructorType in reconstructors:
reconstructor = ReconstructorType(subarray)
reconstructor(event)
name = ReconstructorType.__name__
assert event.dl2.stereo.geometry[name].alt.unit.is_equivalent(u.deg)
assert event.dl2.stereo.geometry[name].az.unit.is_equivalent(u.deg)
assert event.dl2.stereo.geometry[name].core_x.unit.is_equivalent(u.m)
def setup(self):
self.log.info('Configure EventSourceFactory...')
self.event_source = EventSourceFactory.produce(
config=self.config, tool=self, product='SimTelEventSource'
)
self.event_source.allowed_tels = self.config['Analysis']['allowed_tels']
self.calibrator = CameraCalibrator(
config=self.config, tool=self, eventsource=self.event_source
)
self.writer = HDF5TableWriter(
filename=self.outfile, group_name='image_infos', overwrite=True
)
# Define Pre-selection for images
preselcuts = self.config['Preselect']
self.image_cutflow = CutFlow('Image preselection')
self.image_cutflow.set_cuts(dict(
no_sel=None,
n_pixel=lambda s: np.count_nonzero(s) < preselcuts['n_pixel']['min'],
image_amplitude=lambda q: q < preselcuts['image_amplitude']['min']
))
# Define Pre-selection for events
self.event_cutflow = CutFlow('Event preselection')
self.event_cutflow.set_cuts(dict(
no_sel=None
))
def __init__(self, load_option, file_path_mask, use_cut_value=-1):
"""
:param particleID: ID of particle to save, deprecated
:param telescopes: set of telescopes to save events for
:param start_at_runnum: runnum to start at
:param end_at_runnum: runnum to stop at (file is included)
:param load_file_name_start: name of file to load after runnum
:param load_file_name_end: name of file to load after runnum
:param use_cut_value: use cut and remove all events lower, -1 for no cut
"""
self.eventList = []
self.load_option = load_option
CameraCalibrator()
# CameraCalibrator()
self.cut_value = use_cut_value
self.use_cut = False if self.cut_value == -1 else True
self.currentFileID = 0
#if load_option == LoadOption.cal_at_once:
# self.loadFilesWithMask()
names_m1 = glob.glob(file_path_mask.replace('>', '1', 2))
names_m2 = glob.glob(file_path_mask.replace('>', '2', 2))
names_m1.sort()
names_m2.sort()
self.filename_list = list(zip(names_m1, names_m2))
self.max_files = len(self.filename_list)
print(self.filename_list[0])
def load_calibrator_from_config(custom_config, subarray):
"""
Return a CameraCalibrator class corresponding to the given configuration.
The passed custom_config superseeds the standard config.
Parameters
----------
custom_config: dictionnary. Should contain:
- image_extractor
- image_extractor_config
- gain_selector
- gain_selector_config
Returns
-------
calibrator: ctapipe.calib.CameraCalibrator
"""
config = replace_config(get_standard_config(), custom_config)
image_extractor = load_image_extractor_from_config(config, subarray)
cal = CameraCalibrator(
subarray=subarray,
image_extractor=image_extractor,
)
return cal
def setup(self):
# load up the telescope types table (need to first open a file, a bit of
# a hack until a proper instrument module exists) and select only the
# telescopes with the same camera type
# make sure gzip files are seekable
self.reader = SimTelEventSource(
input_url=self.infile, max_events=self.max_events, back_seekable=True
)
camtypes = self.reader.subarray.to_table().group_by("camera_type")
self.reader.subarray.info(printer=self.log.info)
group = camtypes.groups[self.telgroup]
self._selected_tels = list(group["tel_id"].data)
self._base_tel = self._selected_tels[0]
self.log.info(
"Telescope group %d: %s",
self.telgroup,
str(self.reader.subarray.tel[self._selected_tels[0]]),
)
self.log.info(f"SELECTED TELESCOPES:{self._selected_tels}")
self.calibrator = CameraCalibrator(parent=self, subarray=self.reader.subarray)
self.reader = SimTelEventSource(
input_url=self.infile,
max_events=self.max_events,
back_seekable=True,
allowed_tels=set(self._selected_tels),
)
def setup(self):
self.event_source = EventSource(parent=self)
self.event_source.allowed_tels = {self.tel}
self.calibrator = CameraCalibrator(parent=self,
subarray=self.event_source.subarray)
self.log.info(f"SELECTING EVENTS FROM TELESCOPE {self.tel}")
def setup(self):
kwargs = dict(config=self.config, tool=self)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(**kwargs)
self.cal = CameraCalibrator()
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
event_source = EventSource(parent=self)
self.subarray = event_source.subarray
self.eventseeker = EventSeeker(event_source, parent=self)
self.calibrate = CameraCalibrator(parent=self, subarray=self.subarray)
def setup(self):
self.log.info('Configure EventSource...')
self.event_source = self.add_component(
EventSource.from_config(config=self.config, parent=self))
self.calibrator = self.add_component(CameraCalibrator(parent=self))
self.writer = self.add_component(
HDF5TableWriter(filename=self.outfile,
group_name='image_infos',
overwrite=True))
# Define Pre-selection for images
preselcuts = self.config['Preselect']
self.image_cutflow = CutFlow('Image preselection')
self.image_cutflow.set_cuts(
dict(no_sel=None,
n_pixel=lambda s: np.count_nonzero(s) < preselcuts['n_pixel'][
'min'],
image_amplitude=lambda q: q < preselcuts['image_amplitude'][
'min']))
# Define Pre-selection for events
self.event_cutflow = CutFlow('Event preselection')
self.event_cutflow.set_cuts(dict(no_sel=None))
def test_basic_muon_reco(example_event):
"""
Really simplistic test: just run the analyze_muon_event code, to make
sure it doesn't crash. The input event is so far not a muon, so no output
is generated.
Parameters
----------
test_event - a sample event (fixture)
"""
calib = CameraCalibrator()
calib.calibrate(example_event)
muon_params = muon.analyze_muon_event(example_event)
assert muon_params is not None
def setup(self):
print('TOLLES INFILE', self.infile)
self.event_source = EventSource.from_url(self.infile, parent=self)
self.event_source.allowed_tels = {self.tel, }
self.calibrator = CameraCalibrator(parent=self)
self.log.info(f'SELECTING EVENTS FROM TELESCOPE {self.tel}')
def setup(self):
if self.events == '':
raise ToolConfigurationError("please specify --input <events file>")
self.log.debug("input: %s", self.events)
self.source = EventSourceFactory.produce(input_url=self.events)
self.calib = CameraCalibrator(
config=self.config, tool=self, eventsource=self.source
)
self.writer = HDF5TableWriter(self.outfile, "muons")
def setup(self):
self.eventsource = EventSource.from_url(
get_dataset_path("gamma_test_large.simtel.gz"),
parent=self,
)
self.calibrator = CameraCalibrator(parent=self)
self.plotter = ImagePlotter(parent=self)
def setup(self):
kwargs = dict(config=self.config, tool=self)
reader_factory = EventFileReaderFactory(**kwargs)
reader_class = reader_factory.get_class()
self.reader = reader_class(**kwargs)
self.calibrator = CameraCalibrator(origin=self.reader.origin, **kwargs)
self.plotter = ImagePlotter(**kwargs)
def setup(self):
reader_factory = EventFileReaderFactory(None, self)
reader_class = reader_factory.get_class()
self.reader = reader_class(None, self)
self.calibrator = CameraCalibrator(config=None, tool=self,
origin=self.reader.origin)
self.source = self.reader.read(allowed_tels=[self.tel, ])
self.log.info('SELECTING EVENTS FROM TELESCOPE {}'.format(self.tel))
def setup(self):
kwargs = dict(config=self.config, tool=self)
self.eventsource = EventSourceFactory.produce(
input_url=get_dataset_path("gamma_test.simtel.gz"), **kwargs
)
self.calibrator = CameraCalibrator(
eventsource=self.eventsource, **kwargs
)
self.plotter = ImagePlotter(**kwargs)
def setup(self):
self.event_source = EventSourceFactory.produce(
config=self.config, tool=self
)
self.event_source.allowed_tels = [
self.tel,
]
self.calibrator = CameraCalibrator(
config=self.config, tool=self, eventsource=self.event_source
)
self.log.info(f'SELECTING EVENTS FROM TELESCOPE {self.tel}')
def setup(self):
# load up the telescope types table (need to first open a file, a bit of
# a hack until a proper insturment module exists) and select only the
# telescopes with the same camera type
data = next(hessio_event_source(self.infile, max_events=1))
camtypes = get_camera_types(data.inst)
print_camera_types(data.inst, printer=self.log.info)
group = camtypes.groups[self.telgroup]
self._selected_tels = group['tel_id'].data
self._base_tel = self._selected_tels[0]
self.log.info("Telescope group %d: %s with %s camera", self.telgroup,
group[0]['tel_type'], group[0]['cam_type'])
self.log.info("SELECTED TELESCOPES:{}".format(self._selected_tels))
self.calibrator = CameraCalibrator(self.config, self)
class ImageSumDisplayerTool(Tool):
description = Unicode(__doc__)
name = "ctapipe-image-sum-display"
infile = Unicode(help='input simtelarray file',
default="/Users/kosack/Data/CTA/Prod3/gamma.simtel.gz"
).tag(config=True)
telgroup = Integer(help='telescope group number', default=1).tag(
config=True)
max_events = Integer(help='stop after this many events if non-zero',
default_value=0, min=0).tag(config=True)
output_suffix=Unicode(help='suffix (file extension) of output '
'filenames to write images '
'to (no writing is done if blank). '
'Images will be named [EVENTID][suffix]' ,
default_value="").tag(config=True)
aliases = Dict({'infile': 'ImageSumDisplayerTool.infile',
'telgroup': 'ImageSumDisplayerTool.telgroup',
'max-events': 'ImageSumDisplayerTool.max_events',
'output-suffix': 'ImageSumDisplayerTool.output_suffix'})
classes = List([CameraCalibrator,])
def setup(self):
# load up the telescope types table (need to first open a file, a bit of
# a hack until a proper insturment module exists) and select only the
# telescopes with the same camera type
data = next(hessio_event_source(self.infile, max_events=1))
camtypes = get_camera_types(data.inst)
print_camera_types(data.inst, printer=self.log.info)
group = camtypes.groups[self.telgroup]
self._selected_tels = group['tel_id'].data
self._base_tel = self._selected_tels[0]
self.log.info("Telescope group %d: %s with %s camera", self.telgroup,
group[0]['tel_type'], group[0]['cam_type'])
self.log.info("SELECTED TELESCOPES:{}".format(self._selected_tels))
self.calibrator = CameraCalibrator(self.config, self)
def start(self):
geom = None
imsum = None
disp = None
for data in hessio_event_source(self.infile,
allowed_tels=self._selected_tels,
max_events=self.max_events):
self.calibrator.calibrate(data)
if geom is None:
x, y = data.inst.pixel_pos[self._base_tel]
flen = data.inst.optical_foclen[self._base_tel]
geom = CameraGeometry.guess(x, y, flen)
imsum = np.zeros(shape=x.shape, dtype=np.float)
disp = CameraDisplay(geom, title=geom.cam_id)
disp.add_colorbar()
disp.cmap = 'viridis'
if len(data.dl0.tels_with_data) <= 2:
continue
imsum[:] = 0
for telid in data.dl0.tels_with_data:
imsum += data.dl1.tel[telid].image[0]
self.log.info("event={} ntels={} energy={}" \
.format(data.r0.event_id,
len(data.dl0.tels_with_data),
data.mc.energy))
disp.image = imsum
plt.pause(0.1)
if self.output_suffix is not "":
filename = "{:020d}{}".format(data.r0.event_id,
self.output_suffix)
self.log.info("saving: '{}'".format(filename))
plt.savefig(filename)
class DisplayDL1Calib(Tool):
name = "ctapipe-display-dl1"
description = __doc__
telescope = Int(
None,
allow_none=True,
help='Telescope to view. Set to None to display all '
'telescopes.'
).tag(config=True)
extractor_product = tool_utils.enum_trait(
ImageExtractor,
default='NeighborPeakWindowSum'
)
aliases = Dict(
dict(
max_events='EventSource.max_events',
extractor='DisplayDL1Calib.extractor_product',
T='DisplayDL1Calib.telescope',
O='ImagePlotter.output_path'
)
)
flags = Dict(
dict(
D=(
{
'ImagePlotter': {
'display': True
}
},
"Display the photoelectron images on-screen as they "
"are produced."
)
)
)
classes = List(
[
EventSource,
CameraDL1Calibrator,
ImagePlotter
] + tool_utils.classes_with_traits(ImageExtractor)
)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.eventsource = None
self.calibrator = None
self.plotter = None
def setup(self):
self.eventsource = EventSource.from_url(
get_dataset_path("gamma_test_large.simtel.gz"),
parent=self,
)
self.calibrator = CameraCalibrator(
eventsource=self.eventsource,
parent=self,
)
self.plotter = ImagePlotter(parent=self)
def start(self):
for event in self.eventsource:
self.calibrator.calibrate(event)
tel_list = event.r0.tels_with_data
if self.telescope:
if self.telescope not in tel_list:
continue
tel_list = [self.telescope]
for telid in tel_list:
self.plotter.plot(event, telid)
def finish(self):
self.plotter.finish()
class SingleTelEventDisplay(Tool):
name = "ctapipe-display-single-tel"
description = Unicode(__doc__)
infile = Unicode(help="input file to read", default='').tag(config=True)
tel = Int(help='Telescope ID to display', default=0).tag(config=True)
channel = Integer(help="channel number to display", min=0, max=1).tag(
config=True)
write = Bool(help="Write out images to PNG files", default=False).tag(
config=True)
clean = Bool(help="Apply image cleaning", default=False).tag(config=True)
hillas = Bool(help="Apply and display Hillas parametrization",
default=False).tag(config=True)
samples = Bool(help="Show each sample", default=False).tag(config=True)
display = Bool(help="Display results in interactive window",
default_value=True).tag(config=True)
delay = Float(help='delay between events in s', default_value=0.01,
min=0.001).tag(config=True)
progress = Bool(help='display progress bar', default_value=True).tag(
config=True)
aliases = Dict({'infile': 'EventFileReaderFactory.input_path',
'tel': 'SingleTelEventDisplay.tel',
'max-events': 'EventFileReaderFactory.max_events',
'channel': 'SingleTelEventDisplay.channel',
'write': 'SingleTelEventDisplay.write',
'clean': 'SingleTelEventDisplay.clean',
'hillas': 'SingleTelEventDisplay.hillas',
'samples': 'SingleTelEventDisplay.samples',
'display': 'SingleTelEventDisplay.display',
'delay': 'SingleTelEventDisplay.delay',
'progress': 'SingleTelEventDisplay.progress'
})
classes = List([EventFileReaderFactory, CameraCalibrator])
def setup(self):
reader_factory = EventFileReaderFactory(None, self)
reader_class = reader_factory.get_class()
self.reader = reader_class(None, self)
self.calibrator = CameraCalibrator(config=None, tool=self,
origin=self.reader.origin)
self.source = self.reader.read(allowed_tels=[self.tel, ])
self.log.info('SELECTING EVENTS FROM TELESCOPE {}'.format(self.tel))
def start(self):
disp = None
for event in tqdm(self.source,
desc='Tel{}'.format(self.tel),
total=self.reader.max_events,
disable=~self.progress):
self.log.debug(event.trig)
self.log.debug("Energy: {}".format(event.mc.energy))
self.calibrator.calibrate(event)
if disp is None:
x, y = event.inst.pixel_pos[self.tel]
focal_len = event.inst.optical_foclen[self.tel]
geom = CameraGeometry.guess(x, y, focal_len)
self.log.info(geom)
disp = CameraDisplay(geom)
# disp.enable_pixel_picker()
disp.add_colorbar()
if self.display:
plt.show(block=False)
# display the event
disp.axes.set_title('CT{:03d} ({}), event {:06d}'.format(
self.tel, geom.cam_id, event.r0.event_id)
)
if self.samples:
# display time-varying event
data = event.dl0.tel[self.tel].pe_samples[self.channel]
for ii in range(data.shape[1]):
disp.image = data[:, ii]
disp.set_limits_percent(70)
plt.suptitle("Sample {:03d}".format(ii))
if self.display:
plt.pause(self.delay)
if self.write:
plt.savefig('CT{:03d}_EV{:10d}_S{:02d}.png'
.format(self.tel, event.r0.event_id, ii))
else:
# display integrated event:
im = event.dl1.tel[self.tel].image[self.channel]
if self.clean:
mask = tailcuts_clean(geom, im, picture_thresh=10,
boundary_thresh=7)
im[~mask] = 0.0
disp.image = im
if self.hillas:
try:
ellipses = disp.axes.findobj(Ellipse)
if len(ellipses) > 0:
ellipses[0].remove()
params = hillas_parameters(pix_x=geom.pix_x,
pix_y=geom.pix_y, image=im)
disp.overlay_moments(params, color='pink', lw=3,
with_label=False)
except HillasParameterizationError:
pass
if self.display:
plt.pause(self.delay)
if self.write:
plt.savefig('CT{:03d}_EV{:010d}.png'
.format(self.tel, event.r0.event_id))
self.log.info("FINISHED READING DATA FILE")
if disp is None:
self.log.warning('No events for tel {} were found in {}. Try a '
'different EventIO file or another telescope'
.format(self.tel, self.infile),
)
pass
The most basic pipeline, using no special features of the framework other
than a for-loop. This is useful for debugging and profiling of speed.
"""
import sys
import numpy as np
from ctapipe.calib import CameraCalibrator
from ctapipe.io.hessio import hessio_event_source
if __name__ == '__main__':
filename = sys.argv[1]
source = hessio_event_source(filename, max_events=None)
cal = CameraCalibrator(None, None)
for data in source:
print("EVENT: {}, ENERGY: {:.2f}, TELS:{}"
.format(data.r0.event_id,
data.mc.energy,
len(data.dl0.tels_with_data))
)
cal.calibrate(data)
# now the calibrated images are in data.dl1.tel[x].image
class MuonDisplayerTool(Tool):
name = 'ctapipe-display-muons'
description = t.Unicode(__doc__)
events = t.Unicode("",
help="input event data file").tag(config=True)
outfile = t.Unicode("muons.hdf5", help='HDF5 output file name').tag(
config=True)
display = t.Bool(
help='display the camera events', default=False
).tag(config=True)
classes = t.List([
CameraCalibrator, EventSourceFactory
])
aliases = t.Dict({
'input': 'MuonDisplayerTool.events',
'outfile': 'MuonDisplayerTool.outfile',
'display': 'MuonDisplayerTool.display',
'max_events': 'EventSourceFactory.max_events',
'allowed_tels': 'EventSourceFactory.allowed_tels',
})
def setup(self):
if self.events == '':
raise ToolConfigurationError("please specify --input <events file>")
self.log.debug("input: %s", self.events)
self.source = EventSourceFactory.produce(input_url=self.events)
self.calib = CameraCalibrator(
config=self.config, tool=self, eventsource=self.source
)
self.writer = HDF5TableWriter(self.outfile, "muons")
def start(self):
numev = 0
self.num_muons_found = defaultdict(int)
for event in tqdm(self.source, desc='detecting muons'):
self.calib.calibrate(event)
muon_evt = analyze_muon_event(event)
if numev == 0:
_exclude_some_columns(event.inst.subarray, self.writer)
numev += 1
if not muon_evt['MuonIntensityParams']:
# No telescopes contained a good muon
continue
else:
if self.display:
plot_muon_event(event, muon_evt)
for tel_id in muon_evt['TelIds']:
idx = muon_evt['TelIds'].index(tel_id)
intens_params = muon_evt['MuonIntensityParams'][idx]
if intens_params is not None:
ring_params = muon_evt['MuonRingParams'][idx]
cam_id = str(event.inst.subarray.tel[tel_id].camera)
self.num_muons_found[cam_id] += 1
self.log.debug("INTENSITY: %s", intens_params)
self.log.debug("RING: %s", ring_params)
self.writer.write(table_name=cam_id,
containers=[intens_params,
ring_params])
self.log.info(
"Event Number: %d, found %s muons",
numev, dict(self.num_muons_found)
)
def finish(self):
Provenance().add_output_file(self.outfile,
role='dl1.tel.evt.muon')
self.writer.close()
def extract_images(simtel_file_path,
tel_id_filter_list=None,
event_id_filter_list=None,
output_directory=None,
crop=True):
# EXTRACT IMAGES ##########################################################
# hessio_event_source returns a Python generator that streams data from an
# EventIO/HESSIO MC data file (e.g. a standard CTA data file).
# This generator contains ctapipe.core.Container instances ("event").
#
# Parameters:
# - max_events: maximum number of events to read
# - allowed_tels: select only a subset of telescope, if None, all are read.
source = hessio_event_source(simtel_file_path, allowed_tels=tel_id_filter_list)
# ITERATE OVER EVENTS #####################################################
calib = CameraCalibrator(None, None)
for event in source:
calib.calibrate(event) # calibrate the event
event_id = int(event.dl0.event_id)
if (event_id_filter_list is None) or (event_id in event_id_filter_list):
#print("event", event_id)
# ITERATE OVER IMAGES #############################################
for tel_id in event.trig.tels_with_trigger:
tel_id = int(tel_id)
if tel_id in tel_id_filter_list:
#print("telescope", tel_id)
# CHECK THE IMAGE GEOMETRY (ASTRI ONLY) ###################
# TODO
#print("checking geometry")
x, y = event.inst.pixel_pos[tel_id]
foclen = event.inst.optical_foclen[tel_id]
geom = CameraGeometry.guess(x, y, foclen)
if (geom.pix_type != "rectangular") or (geom.cam_id not in ("ASTRICam", "ASTRI")):
raise ValueError("Telescope {}: error (the input image is not a valide ASTRI telescope image) -> {} ({})".format(tel_id, geom.pix_type, geom.cam_id))
# GET IMAGES ##############################################
pe_image = event.mc.tel[tel_id].photo_electron_image # 1D np array
#uncalibrated_image = event.dl0.tel[tel_id].adc_sums # ctapipe 0.3.0
uncalibrated_image = event.r0.tel[tel_id].adc_sums # ctapipe 0.4.0
pedestal = event.mc.tel[tel_id].pedestal
gain = event.mc.tel[tel_id].dc_to_pe
pixel_pos = event.inst.pixel_pos[tel_id]
calibrated_image = event.dl1.tel[tel_id].image
calibrated_image[1, calibrated_image[0,:] <= ASTRI_CAM_CHANNEL_THRESHOLD] = 0
calibrated_image[0, calibrated_image[0,:] > ASTRI_CAM_CHANNEL_THRESHOLD] = 0
calibrated_image = calibrated_image.sum(axis=0)
#print(pe_image.shape)
#print(calibrated_image.shape)
#print(uncalibrated_image.shape)
#print(pedestal.shape)
#print(gain.shape)
#print(pixel_pos.shape)
#print(pixel_pos[0])
#print(pixel_pos[1])
# CONVERTING GEOMETRY (1D TO 2D) ##########################
pe_image_2d = geometry_converter.astri_to_2d_array(pe_image, crop=crop)
calibrated_image_2d = geometry_converter.astri_to_2d_array(calibrated_image, crop=crop)
uncalibrated_image_2d = geometry_converter.astri_to_3d_array(uncalibrated_image, crop=crop)
pedestal_2d = geometry_converter.astri_to_3d_array(pedestal, crop=crop)
gains_2d = geometry_converter.astri_to_3d_array(gain, crop=crop)
pixel_pos_2d = geometry_converter.astri_to_3d_array(pixel_pos, crop=crop)
#print(pe_image_2d.shape)
#print(calibrated_image_2d.shape)
#print(uncalibrated_image_2d.shape)
#print(pedestal_2d.shape)
#print(gains_2d.shape)
#print(pixel_pos_2d.shape)
#sys.exit(0)
# GET PIXEL MASK ##########################################
pixel_mask = geometry_converter.astri_pixel_mask(crop) # 1 for pixels with actual data, 0 for virtual (blank) pixels
# MAKE METADATA ###########################################
metadata = {}
metadata['version'] = 1 # Version of the datapipe fits format
if crop:
metadata['cam_id'] = "ASTRI_CROPPED"
else:
metadata['cam_id'] = "ASTRI"
metadata['tel_id'] = tel_id
metadata['event_id'] = event_id
metadata['simtel'] = simtel_file_path
metadata['tel_trig'] = len(event.trig.tels_with_trigger)
metadata['energy'] = quantity_to_tuple(event.mc.energy, 'TeV')
metadata['mc_az'] = quantity_to_tuple(event.mc.az, 'rad')
metadata['mc_alt'] = quantity_to_tuple(event.mc.alt, 'rad')
metadata['mc_corex'] = quantity_to_tuple(event.mc.core_x, 'm')
metadata['mc_corey'] = quantity_to_tuple(event.mc.core_y, 'm')
metadata['mc_hfi'] = quantity_to_tuple(event.mc.h_first_int, 'm')
metadata['count'] = int(event.count)
metadata['run_id'] = int(event.dl0.run_id)
metadata['tel_data'] = len(event.dl0.tels_with_data)
metadata['foclen'] = quantity_to_tuple(event.inst.optical_foclen[tel_id], 'm')
metadata['tel_posx'] = quantity_to_tuple(event.inst.tel_pos[tel_id][0], 'm')
metadata['tel_posy'] = quantity_to_tuple(event.inst.tel_pos[tel_id][1], 'm')
metadata['tel_posz'] = quantity_to_tuple(event.inst.tel_pos[tel_id][2], 'm')
# TODO: Astropy fails to store the following data in FITS files
#metadata['uid'] = os.getuid()
#metadata['datetime'] = str(datetime.datetime.now())
#metadata['version'] = VERSION
#metadata['argv'] = " ".join(sys.argv).encode('ascii', errors='ignore').decode('ascii')
#metadata['python'] = " ".join(sys.version.splitlines()).encode('ascii', errors='ignore').decode('ascii')
#metadata['system'] = " ".join(os.uname())
# SAVE THE IMAGE ##########################################
output_file_path_template = "{}_TEL{:03d}_EV{:05d}.fits"
if output_directory is not None:
simtel_basename = os.path.basename(simtel_file_path)
prefix = os.path.join(output_directory, simtel_basename)
else:
prefix = simtel_file_path
output_file_path = output_file_path_template.format(prefix,
tel_id,
event_id)
print("saving", output_file_path)
images.save_benchmark_images(img = calibrated_image_2d,
pe_img = pe_image_2d,
adc_sums_img = uncalibrated_image_2d,
pedestal_img = pedestal_2d,
gains_img = gains_2d,
pixel_pos = pixel_pos_2d,
pixel_mask = pixel_mask,
metadata = metadata,
output_file_path = output_file_path)
# unoptimized cleaning levels, copied from
# https://github.com/tudo-astroparticlephysics/cta_preprocessing
cleaning_level = {
'LSTCam': (3.5, 7.5, 2), # ?? (3, 6) for Abelardo...
'FlashCam': (4, 8, 2), # there is some scaling missing?
'ASTRICam': (5, 7, 2),
}
input_url = get_dataset_path('gamma_test_large.simtel.gz')
event_source = EventSourceFactory.produce(input_url=input_url)
calibrator = CameraCalibrator(
eventsource=event_source,
)
reco = HillasReconstructor()
for event in event_source:
print('Event', event.count)
calibrator.calibrate(event)
# mapping of telescope_id to parameters for stereo reconstruction
hillas_containers = {}
pointing_azimuth = {}
pointing_altitude = {}
time_gradients = {}
for telescope_id, dl1 in event.dl1.tel.items():
def extract_images(simtel_file_path,
tel_id_filter_list=None,
event_id_filter_list=None,
output_directory=None):
# EXTRACT IMAGES ##########################################################
# hessio_event_source returns a Python generator that streams data from an
# EventIO/HESSIO MC data file (e.g. a standard CTA data file).
# This generator contains ctapipe.core.Container instances ("event").
#
# Parameters:
# - max_events: maximum number of events to read
# - allowed_tels: select only a subset of telescope, if None, all are read.
source = hessio_event_source(simtel_file_path, allowed_tels=tel_id_filter_list)
# ITERATE OVER EVENTS #####################################################
calib = CameraCalibrator(None, None)
for event in source:
calib.calibrate(event) # calibrate the event
event_id = int(event.dl0.event_id)
if (event_id_filter_list is None) or (event_id in event_id_filter_list):
#print("event", event_id)
# ITERATE OVER IMAGES #############################################
for tel_id in event.trig.tels_with_trigger:
tel_id = int(tel_id)
if tel_id in tel_id_filter_list:
#print("telescope", tel_id)
# CHECK THE IMAGE GEOMETRY ################################
#print("checking geometry")
x, y = event.inst.pixel_pos[tel_id]
foclen = event.inst.optical_foclen[tel_id]
geom = CameraGeometry.guess(x, y, foclen)
if (geom.pix_type != "hexagonal") or (geom.cam_id != "LSTCam"):
raise ValueError("Telescope {}: error (the input image is not a valide LSTCam telescope image) -> {} ({})".format(tel_id, geom.pix_type, geom.cam_id))
# GET IMAGES ##############################################
pe_image = event.mc.tel[tel_id].photo_electron_image # 1D np array
#uncalibrated_image = event.dl0.tel[tel_id].adc_sums # ctapipe 0.3.0
uncalibrated_image = event.r0.tel[tel_id].adc_sums # ctapipe 0.4.0
pedestal = event.mc.tel[tel_id].pedestal
gain = event.mc.tel[tel_id].dc_to_pe
pixel_pos = event.inst.pixel_pos[tel_id]
calibrated_image = event.dl1.tel[tel_id].image
calibrated_image[1, calibrated_image[0,:] <= LST_CAM_CHANNEL_THRESHOLD] = 0
calibrated_image[0, calibrated_image[0,:] > LST_CAM_CHANNEL_THRESHOLD] = 0
calibrated_image = calibrated_image.sum(axis=0)
#print(pe_image.shape)
#print(calibrated_image.shape)
#print(uncalibrated_image.shape)
#print(pedestal.shape)
#print(gain.shape)
#print(pixel_pos.shape)
#print(pixel_pos[0])
#print(pixel_pos[1])
# CONVERTING GEOMETRY (1D TO 2D) ##########################
buffer_id_str = geom.cam_id + "0"
geom2d, pe_image_2d = ctapipe_geom_converter.convert_geometry_1d_to_2d(geom, pe_image, buffer_id_str, add_rot=0)
geom2d, calibrated_image_2d = ctapipe_geom_converter.convert_geometry_1d_to_2d(geom, calibrated_image, buffer_id_str, add_rot=0)
geom2d, uncalibrated_image_2d_ch0 = ctapipe_geom_converter.convert_geometry_1d_to_2d(geom, uncalibrated_image[0], buffer_id_str, add_rot=0)
geom2d, uncalibrated_image_2d_ch1 = ctapipe_geom_converter.convert_geometry_1d_to_2d(geom, uncalibrated_image[1], buffer_id_str, add_rot=0)
geom2d, pedestal_2d_ch0 = ctapipe_geom_converter.convert_geometry_1d_to_2d(geom, pedestal[0], buffer_id_str, add_rot=0)
geom2d, pedestal_2d_ch1 = ctapipe_geom_converter.convert_geometry_1d_to_2d(geom, pedestal[1], buffer_id_str, add_rot=0)
geom2d, gains_2d_ch0 = ctapipe_geom_converter.convert_geometry_1d_to_2d(geom, gain[0], buffer_id_str, add_rot=0)
geom2d, gains_2d_ch1 = ctapipe_geom_converter.convert_geometry_1d_to_2d(geom, gain[1], buffer_id_str, add_rot=0)
# Make a mock pixel position array...
pixel_pos_2d = np.array(np.meshgrid(np.linspace(pixel_pos[0].min(), pixel_pos[0].max(), pe_image_2d.shape[0]),
np.linspace(pixel_pos[1].min(), pixel_pos[1].max(), pe_image_2d.shape[1])))
###########################################################
# The ctapipe geometry converter operate on one channel
# only and then takes and return a 2D array but datapipe
# fits files keep all channels and thus takes 3D arrays...
uncalibrated_image_2d = np.array([uncalibrated_image_2d_ch0, uncalibrated_image_2d_ch1])
pedestal_2d = np.array([pedestal_2d_ch0, pedestal_2d_ch1 ])
gains_2d = np.array([gains_2d_ch0, gains_2d_ch1])
# PUT NAN IN BLANK PIXELS #################################
calibrated_image_2d[np.logical_not(geom2d.mask)] = np.nan
pe_image_2d[np.logical_not(geom2d.mask)] = np.nan
uncalibrated_image_2d[0, np.logical_not(geom2d.mask)] = np.nan
uncalibrated_image_2d[1, np.logical_not(geom2d.mask)] = np.nan
pedestal_2d[0, np.logical_not(geom2d.mask)] = np.nan
pedestal_2d[1, np.logical_not(geom2d.mask)] = np.nan
gains_2d[0, np.logical_not(geom2d.mask)] = np.nan
gains_2d[1, np.logical_not(geom2d.mask)] = np.nan
pixel_pos_2d[0, np.logical_not(geom2d.mask)] = np.nan
pixel_pos_2d[1, np.logical_not(geom2d.mask)] = np.nan
###########################################################
#print(pe_image_2d.shape)
#print(calibrated_image_2d.shape)
#print(uncalibrated_image_2d.shape)
#print(pedestal_2d.shape)
#print(gains_2d.shape)
#img = pixel_pos_2d
#print(img[1])
#import matplotlib.pyplot as plt
#im = plt.imshow(img[1])
#plt.colorbar(im)
#plt.show()
#sys.exit(0)
# GET PIXEL MASK ##########################################
pixel_mask = geom2d.mask.astype(int) # 1 for pixels with actual data, 0 for virtual (blank) pixels
# MAKE METADATA ###########################################
metadata = {}
metadata['version'] = 1 # Version of the datapipe fits format
metadata['cam_id'] = "LSTCam"
metadata['tel_id'] = tel_id
metadata['event_id'] = event_id
metadata['simtel'] = simtel_file_path
metadata['tel_trig'] = len(event.trig.tels_with_trigger)
metadata['energy'] = quantity_to_tuple(event.mc.energy, 'TeV')
metadata['mc_az'] = quantity_to_tuple(event.mc.az, 'rad')
metadata['mc_alt'] = quantity_to_tuple(event.mc.alt, 'rad')
metadata['mc_corex'] = quantity_to_tuple(event.mc.core_x, 'm')
metadata['mc_corey'] = quantity_to_tuple(event.mc.core_y, 'm')
metadata['mc_hfi'] = quantity_to_tuple(event.mc.h_first_int, 'm')
metadata['count'] = int(event.count)
metadata['run_id'] = int(event.dl0.run_id)
metadata['tel_data'] = len(event.dl0.tels_with_data)
metadata['foclen'] = quantity_to_tuple(event.inst.optical_foclen[tel_id], 'm')
metadata['tel_posx'] = quantity_to_tuple(event.inst.tel_pos[tel_id][0], 'm')
metadata['tel_posy'] = quantity_to_tuple(event.inst.tel_pos[tel_id][1], 'm')
metadata['tel_posz'] = quantity_to_tuple(event.inst.tel_pos[tel_id][2], 'm')
# TODO: Astropy fails to store the following data in FITS files
#metadata['uid'] = os.getuid()
#metadata['datetime'] = str(datetime.datetime.now())
#metadata['version'] = VERSION
#metadata['argv'] = " ".join(sys.argv).encode('ascii', errors='ignore').decode('ascii')
#metadata['python'] = " ".join(sys.version.splitlines()).encode('ascii', errors='ignore').decode('ascii')
#metadata['system'] = " ".join(os.uname())
# SAVE THE IMAGE ##########################################
output_file_path_template = "{}_TEL{:03d}_EV{:05d}.fits"
if output_directory is not None:
simtel_basename = os.path.basename(simtel_file_path)
prefix = os.path.join(output_directory, simtel_basename)
else:
prefix = simtel_file_path
output_file_path = output_file_path_template.format(prefix,
tel_id,
event_id)
print("saving", output_file_path)
images.save_benchmark_images(img = calibrated_image_2d,
pe_img = pe_image_2d,
adc_sums_img = uncalibrated_image_2d,
pedestal_img = pedestal_2d,
gains_img = gains_2d,
pixel_pos = pixel_pos_2d,
pixel_mask = pixel_mask,
metadata = metadata,
output_file_path = output_file_path)
class SimpleEventWriter(Tool):
name = 'ctapipe-simple-event-writer'
description = Unicode(__doc__)
infile = Unicode(help='input file to read', default='').tag(config=True)
outfile = Unicode(help='output file name', default_value='output.h5').tag(config=True)
progress = Bool(help='display progress bar', default_value=True).tag(config=True)
aliases = Dict({
'infile': 'EventSourceFactory.input_url',
'outfile': 'SimpleEventWriter.outfile',
'max-events': 'EventSourceFactory.max_events',
'progress': 'SimpleEventWriter.progress'
})
classes = List([EventSourceFactory, CameraCalibrator, CutFlow])
def setup(self):
self.log.info('Configure EventSourceFactory...')
self.event_source = EventSourceFactory.produce(
config=self.config, tool=self, product='SimTelEventSource'
)
self.event_source.allowed_tels = self.config['Analysis']['allowed_tels']
self.calibrator = CameraCalibrator(
config=self.config, tool=self, eventsource=self.event_source
)
self.writer = HDF5TableWriter(
filename=self.outfile, group_name='image_infos', overwrite=True
)
# Define Pre-selection for images
preselcuts = self.config['Preselect']
self.image_cutflow = CutFlow('Image preselection')
self.image_cutflow.set_cuts(dict(
no_sel=None,
n_pixel=lambda s: np.count_nonzero(s) < preselcuts['n_pixel']['min'],
image_amplitude=lambda q: q < preselcuts['image_amplitude']['min']
))
# Define Pre-selection for events
self.event_cutflow = CutFlow('Event preselection')
self.event_cutflow.set_cuts(dict(
no_sel=None
))
def start(self):
self.log.info('Loop on events...')
for event in tqdm(
self.event_source,
desc='EventWriter',
total=self.event_source.max_events,
disable=~self.progress):
self.event_cutflow.count('no_sel')
self.calibrator.calibrate(event)
for tel_id in event.dl0.tels_with_data:
self.image_cutflow.count('no_sel')
camera = event.inst.subarray.tel[tel_id].camera
dl1_tel = event.dl1.tel[tel_id]
# Image cleaning
image = dl1_tel.image[0] # Waiting for automatic gain selection
mask = tailcuts_clean(camera, image, picture_thresh=10, boundary_thresh=5)
cleaned = image.copy()
cleaned[~mask] = 0
# Preselection cuts
if self.image_cutflow.cut('n_pixel', cleaned):
continue
if self.image_cutflow.cut('image_amplitude', np.sum(cleaned)):
continue
# Image parametrisation
params = hillas_parameters(camera, cleaned)
# Save Ids, MC infos and Hillas informations
self.writer.write(camera.cam_id, [event.r0, event.mc, params])
def finish(self):
self.log.info('End of job.')
self.image_cutflow()
self.event_cutflow()
self.writer.close()
class SingleTelEventDisplay(Tool):
name = "ctapipe-display-televents"
description = Unicode(__doc__)
infile = Unicode(help="input file to read", default='').tag(config=True)
tel = Int(help='Telescope ID to display', default=0).tag(config=True)
channel = Integer(
help="channel number to display", min=0, max=1
).tag(config=True)
write = Bool(
help="Write out images to PNG files", default=False
).tag(config=True)
clean = Bool(help="Apply image cleaning", default=False).tag(config=True)
hillas = Bool(
help="Apply and display Hillas parametrization", default=False
).tag(config=True)
samples = Bool(help="Show each sample", default=False).tag(config=True)
display = Bool(
help="Display results in interactive window", default_value=True
).tag(config=True)
delay = Float(
help='delay between events in s', default_value=0.01, min=0.001
).tag(config=True)
progress = Bool(
help='display progress bar', default_value=True
).tag(config=True)
aliases = Dict({
'infile': 'SingleTelEventDisplay.infile',
'tel': 'SingleTelEventDisplay.tel',
'max-events': 'EventSource.max_events',
'channel': 'SingleTelEventDisplay.channel',
'write': 'SingleTelEventDisplay.write',
'clean': 'SingleTelEventDisplay.clean',
'hillas': 'SingleTelEventDisplay.hillas',
'samples': 'SingleTelEventDisplay.samples',
'display': 'SingleTelEventDisplay.display',
'delay': 'SingleTelEventDisplay.delay',
'progress': 'SingleTelEventDisplay.progress'
})
classes = List([EventSource, CameraCalibrator])
def __init__(self, **kwargs):
super().__init__(**kwargs)
def setup(self):
print('TOLLES INFILE', self.infile)
self.event_source = EventSource.from_url(self.infile, parent=self)
self.event_source.allowed_tels = {self.tel, }
self.calibrator = CameraCalibrator(
parent=self, eventsource=self.event_source
)
self.log.info(f'SELECTING EVENTS FROM TELESCOPE {self.tel}')
def start(self):
disp = None
for event in tqdm(
self.event_source,
desc=f'Tel{self.tel}',
total=self.event_source.max_events,
disable=~self.progress
):
self.log.debug(event.trig)
self.log.debug(f"Energy: {event.mc.energy}")
self.calibrator.calibrate(event)
if disp is None:
geom = event.inst.subarray.tel[self.tel].camera
self.log.info(geom)
disp = CameraDisplay(geom)
# disp.enable_pixel_picker()
disp.add_colorbar()
if self.display:
plt.show(block=False)
# display the event
disp.axes.set_title(
'CT{:03d} ({}), event {:06d}'.format(
self.tel, geom.cam_id, event.r0.event_id
)
)
if self.samples:
# display time-varying event
data = event.dl0.tel[self.tel].waveform[self.channel]
for ii in range(data.shape[1]):
disp.image = data[:, ii]
disp.set_limits_percent(70)
plt.suptitle(f"Sample {ii:03d}")
if self.display:
plt.pause(self.delay)
if self.write:
plt.savefig(
f'CT{self.tel:03d}_EV{event.r0.event_id:10d}'
f'_S{ii:02d}.png'
)
else:
# display integrated event:
im = event.dl1.tel[self.tel].image[self.channel]
if self.clean:
mask = tailcuts_clean(
geom, im, picture_thresh=10, boundary_thresh=7
)
im[~mask] = 0.0
disp.image = im
if self.hillas:
try:
ellipses = disp.axes.findobj(Ellipse)
if len(ellipses) > 0:
ellipses[0].remove()
params = hillas_parameters(geom, image=im)
disp.overlay_moments(
params, color='pink', lw=3, with_label=False
)
except HillasParameterizationError:
pass
if self.display:
plt.pause(self.delay)
if self.write:
plt.savefig(
f'CT{self.tel:03d}_EV{event.r0.event_id:010d}.png'
)
self.log.info("FINISHED READING DATA FILE")
if disp is None:
self.log.warning(
'No events for tel {} were found in {}. Try a '
'different EventIO file or another telescope'
.format(self.tel, self.infile),
)
class ImageSumDisplayerTool(Tool):
description = Unicode(__doc__)
name = "ctapipe-display-imagesum"
infile = Unicode(
help='input simtelarray file',
default="/Users/kosack/Data/CTA/Prod3/gamma.simtel.gz"
).tag(config=True)
telgroup = Integer(
help='telescope group number', default=1
).tag(config=True)
max_events = Integer(
help='stop after this many events if non-zero', default_value=0, min=0
).tag(config=True)
output_suffix = Unicode(
help='suffix (file extension) of output '
'filenames to write images '
'to (no writing is done if blank). '
'Images will be named [EVENTID][suffix]',
default_value=""
).tag(config=True)
aliases = Dict({
'infile': 'ImageSumDisplayerTool.infile',
'telgroup': 'ImageSumDisplayerTool.telgroup',
'max-events': 'ImageSumDisplayerTool.max_events',
'output-suffix': 'ImageSumDisplayerTool.output_suffix'
})
classes = List([CameraCalibrator, SimTelEventSource])
def setup(self):
# load up the telescope types table (need to first open a file, a bit of
# a hack until a proper insturment module exists) and select only the
# telescopes with the same camera type
self.reader = SimTelEventSource(
input_url=self.infile, max_events=self.max_events
)
for event in self.reader:
camtypes = event.inst.subarray.to_table().group_by('camera_type')
event.inst.subarray.info(printer=self.log.info)
break
group = camtypes.groups[self.telgroup]
self._selected_tels = list(group['id'].data)
self._base_tel = self._selected_tels[0]
self.log.info(
"Telescope group %d: %s", self.telgroup,
str(event.inst.subarray.tel[self._selected_tels[0]])
)
self.log.info(f"SELECTED TELESCOPES:{self._selected_tels}")
self.calibrator = CameraCalibrator(
parent=self, eventsource=self.reader
)
self.reader.allowed_tels = self._selected_tels
def start(self):
geom = None
imsum = None
disp = None
for event in self.reader:
self.calibrator.calibrate(event)
if geom is None:
geom = event.inst.subarray.tel[self._base_tel].camera
imsum = np.zeros(shape=geom.pix_x.shape, dtype=np.float)
disp = CameraDisplay(geom, title=geom.cam_id)
disp.add_colorbar()
disp.cmap = 'viridis'
if len(event.dl0.tels_with_data) <= 2:
continue
imsum[:] = 0
for telid in event.dl0.tels_with_data:
imsum += event.dl1.tel[telid].image[0]
self.log.info(
"event={} ntels={} energy={}".format(
event.r0.event_id, len(event.dl0.tels_with_data),
event.mc.energy
)
)
disp.image = imsum
plt.pause(0.1)
if self.output_suffix is not "":
filename = "{:020d}{}".format(
event.r0.event_id, self.output_suffix
)
self.log.info(f"saving: '{filename}'")
plt.savefig(filename)
"""
very simple example that loads a single event into memory, for exploration
purposes
"""
import sys
from ctapipe.calib import CameraCalibrator
from ctapipe.io import event_source
from ctapipe.utils import get_dataset_path
if __name__ == '__main__':
calib = CameraCalibrator(r1_product="HESSIOR1Calibrator")
if len(sys.argv) >= 2:
filename = sys.argv[1]
else:
filename = get_dataset_path("gamma_test_large.simtel.gz")
with event_source(filename, max_events=1) as source:
for event in source:
calib.calibrate(event)
print(event)
class DisplayDL1Calib(Tool):
name = "DisplayDL1Calib"
description = "Calibrate dl0 data to dl1, and plot the photoelectron " \
"images."
telescope = Int(None, allow_none=True,
help='Telescope to view. Set to None to display all '
'telescopes.').tag(config=True)
aliases = Dict(dict(f='EventFileReaderFactory.input_path',
r='EventFileReaderFactory.reader',
max_events='EventFileReaderFactory.max_events',
extractor='ChargeExtractorFactory.extractor',
window_width='ChargeExtractorFactory.window_width',
t0='ChargeExtractorFactory.t0',
window_shift='ChargeExtractorFactory.window_shift',
sig_amp_cut_HG='ChargeExtractorFactory.sig_amp_cut_HG',
sig_amp_cut_LG='ChargeExtractorFactory.sig_amp_cut_LG',
lwt='ChargeExtractorFactory.lwt',
clip_amplitude='CameraDL1Calibrator.clip_amplitude',
T='DisplayDL1Calib.telescope',
O='ImagePlotter.output_path'
))
flags = Dict(dict(D=({'ImagePlotter': {'display': True}},
"Display the photoelectron images on-screen as they "
"are produced.")
))
classes = List([EventFileReaderFactory,
ChargeExtractorFactory,
CameraDL1Calibrator,
ImagePlotter
])
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.reader = None
self.calibrator = None
self.plotter = None
def setup(self):
kwargs = dict(config=self.config, tool=self)
reader_factory = EventFileReaderFactory(**kwargs)
reader_class = reader_factory.get_class()
self.reader = reader_class(**kwargs)
self.calibrator = CameraCalibrator(origin=self.reader.origin, **kwargs)
self.plotter = ImagePlotter(**kwargs)
def start(self):
source = self.reader.read()
for event in source:
self.calibrator.calibrate(event)
tel_list = event.r0.tels_with_data
if self.telescope:
if self.telescope not in tel_list:
continue
tel_list = [self.telescope]
for telid in tel_list:
self.plotter.plot(event, telid)
def finish(self):
self.plotter.finish()
