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): 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()