def test_FitGammaHillas(): ''' a test of the complete fit procedure on one event including: • tailcut cleaning • hillas parametrisation • GreatCircle creation • direction fit • position fit in the end, proper units in the output are asserted ''' filename = get_path("gamma_test.simtel.gz") fit = FitGammaHillas() cam_geom = {} tel_phi = {} tel_theta = {} source = hessio_event_source(filename) for event in source: hillas_dict = {} for tel_id in event.dl0.tels_with_data: if tel_id not in cam_geom: cam_geom[tel_id] = CameraGeometry.guess( event.inst.pixel_pos[tel_id][0], event.inst.pixel_pos[tel_id][1], event.inst.optical_foclen[tel_id]) tel_phi[tel_id] = 0.*u.deg tel_theta[tel_id] = 20.*u.deg pmt_signal = event.dl0.tel[tel_id].adc_sums[0] mask = tailcuts_clean(cam_geom[tel_id], pmt_signal, 1, picture_thresh=10., boundary_thresh=5.) pmt_signal[mask == 0] = 0 try: moments = hillas_parameters(event.inst.pixel_pos[tel_id][0], event.inst.pixel_pos[tel_id][1], pmt_signal) hillas_dict[tel_id] = moments except HillasParameterizationError as e: print(e) continue if len(hillas_dict) < 2: continue fit_result = fit.predict(hillas_dict, event.inst, tel_phi, tel_theta) print(fit_result) fit_result.alt.to(u.deg) fit_result.az.to(u.deg) fit_result.core_x.to(u.m) assert fit_result.is_valid return
def get_test_event(): filename = get_path('gamma_test.simtel.gz') source = hessio_event_source(filename, requested_event=409, use_event_id=True) event = next(source) return event
def test_FitGammaHillas(): ''' a test on one event of the complete fit procedure including: • tailcut cleaning • hillas parametrisation • GreatCircle creation • direction fit • position fit in the end, proper units in the output are asserted ''' filename = get_path("gamma_test.simtel.gz") fit = FitGammaHillas() cam_geom = {} tel_phi = {} tel_theta = {} source = hessio_event_source(filename) for event in source: hillas_dict = {} for tel_id in event.dl0.tels_with_data: if tel_id not in cam_geom: cam_geom[tel_id] = CameraGeometry.guess( event.inst.pixel_pos[tel_id][0], event.inst.pixel_pos[tel_id][1], event.inst.optical_foclen[tel_id]) tel_phi[tel_id] = 180.*u.deg tel_theta[tel_id] = 20.*u.deg pmt_signal = event.dl0.tel[tel_id].adc_sums[0] mask = tailcuts_clean(cam_geom[tel_id], pmt_signal, 1, picture_thresh=10., boundary_thresh=5.) pmt_signal[mask == 0] = 0 try: moments = hillas_parameters(event.inst.pixel_pos[tel_id][0], event.inst.pixel_pos[tel_id][1], pmt_signal) hillas_dict[tel_id] = moments except HillasParameterizationError as e: print(e) continue if len(hillas_dict) < 2: continue fit_result = fit.predict(hillas_dict, event.inst, tel_phi, tel_theta) print(fit_result) fit_result.alt.to(u.deg) fit_result.az.to(u.deg) fit_result.core_x.to(u.m) assert fit_result.is_valid return
def read(self, allowed_tels=None, requested_event=None, use_event_id=False): """ Read the file using the appropriate method depending on the file origin Parameters ---------- allowed_tels : list[int] select only a subset of telescope, if None, all are read. This can be used for example emulate the final CTA data format, where there would be 1 telescope per file (whereas in current monte-carlo, they are all interleaved into one file) requested_event : int Seek to a paricular event index use_event_id : bool If True ,'requested_event' now seeks for a particular event id instead of index Returns ------- source : generator A generator that can be iterated over to obtain events """ # Obtain relevent source self.log.debug("Reading file...") if self.max_events: self.log.info("Max events being read = {}".format(self.max_events)) source = hessio_event_source(get_path(self.input_path), max_events=self.max_events, allowed_tels=allowed_tels, requested_event=requested_event, use_event_id=use_event_id) self.log.debug("File reading complete") return source
def test_camera_dl1_calibrator(): event = get_test_event() telid = 11 calibrator = CameraDL1Calibrator(None, None) calibrator.get_neighbours(event, telid) assert (calibrator.neighbour_dict[telid][0][0] == 5) calibrator.get_correction(event, telid) assert_almost_equal(calibrator.correction_dict[telid][0], 2.154, 3) dl0 = calibrator.obtain_dl0(event, telid) assert_almost_equal(dl0[0, 0, 0], -0.091, 3) calibrator.calibrate(event) image = event.dl1.tel[telid].image assert_almost_equal(image[0, 0], -4.431, 3) filename = get_path('gamma_test.simtel.gz') source = hessio_event_source(filename, requested_event=409, use_event_id=True) calibrator.calibrate_source(source) event = next(source) assert_almost_equal(event.dl1.tel[21].image[0, 0], -3.410, 3)
def test_showermaxestimator(en=5 * u.TeV, h_first_int=10 * u.km, az=70 * u.deg): estim = ShowerMaxEstimator(get_path("atmprof_paranal.dat")) h_max = estim.find_shower_max_height(en, h_first_int, az) assert h_max.unit.is_equivalent(u.m), "return value has not proper unit" return h_max
def read(self, max_events=None): """ Read the file using the appropriate method depending on the file origin Parameters ---------- max_events : int Maximum number of events to read Returns ------- source : generator A generator that can be iterated over to obtain events """ # Obtain relevent source switch = { 'hessio': lambda: hessio_event_source(get_path(self.input_path), max_events=max_events), 'targetio': lambda: oxpytools_source(self.input_path, max_events=max_events), } try: source = switch[self.origin]() except KeyError: log.exception("unknown file origin '{}'".format(self.origin)) raise return source
def read(self, max_events=None): """ Read the file using the appropriate method depending on the file origin Parameters ---------- max_events : int Maximum number of events to read Returns ------- source : generator A generator that can be iterated over to obtain events """ # Obtain relevent source log.debug("[file] Reading file...") if max_events: log.info("[file] Max events being read = {}".format(max_events)) switch = { 'hessio': lambda: hessio_event_source(get_path(self.input_path), max_events=max_events), 'targetio': lambda: oxpytools_source(self.input_path, max_events=max_events), } try: source = switch[self.origin]() except KeyError: log.exception("unknown file origin '{}'".format(self.origin)) raise log.debug("[file] Reading complete") return source
def get_array_layout(instrument_name): """ Returns the array layout for the given instrument as an `astropy.table.Table` object. """ name = instrument_name.lower() layoutfile = glob(get_path('{}_arraylayout.fits*'.format(name)))[0] return load_array_layout_from_file(layoutfile)
def test_jsonToFits(): backup = sys.argv full_config_name = get_path('config.json') sys.argv = ['test_json_2_fits.py', '--config_file='+full_config_name] app = MyApp() app.initialize() app.start() app.jsonToFits() sys.argv = backup
def test_jsonToFits(): backup = sys.argv full_config_name = get_path('config.json') sys.argv = ['test_json_2_fits.py', '--config_file=' + full_config_name] app = MyApp() app.initialize() app.start() assert (app.jsonToFits() == True) sys.argv = backup
def init(self): self.log.debug("--- SimTelArrayReader init {}---".format(self.filename)) try: in_file = get_path(self.filename) self.source = hessio_event_source(in_file,max_events=100) self.log.debug('{} successfully opened {}'.format(self.filename,self.source)) except: self.log.error('could not open ' + in_file) return False return True
def test_calibrate_source(): telid = 38 filename = get_path('gamma_test.simtel.gz') source = hessio_event_source(filename) c_source = calibrate_source(source, get_test_parameters()) for event in c_source: if event.dl0.event_id == 408: pe = event.dl1.tel[telid].calibrated_image assert round(pe[0], 5) == 1.86419 break
def test_jsonToFits(): backup = sys.argv full_config_name = get_path('config.json') sys.argv = ['test_json_2_fits.py', '--config_file=' + full_config_name] app = MyApp() app.initialize() app.start() tmp = tempfile.NamedTemporaryFile() app.jsonToFits(tmp) sys.argv = backup
def event_id_list(self): self.log.info("Retrieving list of event ids...") if self._event_id_list: pass else: self.log.info("Building new list of event ids...") ids = hessio_get_list_event_ids(get_path(self.input_path), max_events=self.max_events) self._event_id_list = ids self.log.info("List of event ids retrieved.") return self._event_id_list
def test_traitlets_config_to_fits(): backup = sys.argv full_config_name = get_path('config.json') sys.argv = ['test_json_2_fits.py', '--config_file=' + full_config_name] app = MyApp() app.initialize() app.start() tmp = tempfile.NamedTemporaryFile() app.traitlets_config_to_fits(tmp.name) sys.argv = backup
def init(self): self.log.debug("--- SimTelArrayReader init {}---".format( self.filename)) try: in_file = get_path(self.filename) self.source = hessio_event_source(in_file, max_events=100) self.log.debug('{} successfully opened {}'.format( self.filename, self.source)) except: self.log.error('could not open ' + in_file) return False return True
def get_camera_geometry(instrument_name, cam_id, recalc_neighbors=True): """Helper function to provide the camera geometry definition for a camera by name. Parameters ---------- instrument_name : {'hess'} name of instrument cam_id : int identifier of camera, in case of multiple versions recalc_neighbors : bool if True, recalculate the neighbor pixel list, otherwise use what is in the file Returns ------- a `CameraGeometry` object Examples -------- >>> geom_ct1 = get_camera_geometry( "hess", 1 ) >>> neighbors_pix_1 = geom_ct1.pix_id[geom_ct1.neighbors[1]] """ # let's assume the instrument name is encoded in the # filename name = instrument_name.lower() geomfile = get_path('{}_camgeom.fits.gz'.format(name)) geom = _load_camera_table_from_file(cam_id, geomfile=geomfile) neigh_list = geom['PIX_NEIG'].data neigh = np.ma.masked_array(neigh_list, neigh_list < 0), # put them all in units of M (conversions are automatic) xx = u.Quantity(geom['PIX_POSX'], u.m) yy = u.Quantity(geom['PIX_POSY'], u.m) dd = u.Quantity(geom['PIX_DIAM'], u.m) aa = u.Quantity(geom['PIX_AREA'], u.m ** 2) if recalc_neighbors is True: neigh = find_neighbor_pixels(xx.value, yy.value, (dd.mean() + 0.01 * u.m).value) return CameraGeometry( cam_id=cam_id, pix_id=np.array(geom['PIX_ID']), pix_x=xx, pix_y=yy, pix_area=aa, neighbors=neigh, pix_type='hexagonal' )
def read(self, allowed_tels=None, requested_event=None, use_event_id=False): """ Read the file using the appropriate method depending on the file origin Parameters ---------- allowed_tels : list[int] select only a subset of telescope, if None, all are read. This can be used for example emulate the final CTA data format, where there would be 1 telescope per file (whereas in current monte-carlo, they are all interleaved into one file) requested_event : int Seek to a paricular event index use_event_id : bool If True ,'requested_event' now seeks for a particular event id instead of index Returns ------- source : generator A generator that can be iterated over to obtain events """ # Obtain relevent source log.debug("[file] Reading file...") if self._max_events: log.info("[file] Max events being read = {}".format( self._max_events)) switch = { 'hessio': lambda: hessio_event_source(get_path(self.input_path), max_events=self._max_events, allowed_tels=allowed_tels, requested_event=requested_event, use_event_id=use_event_id), 'targetio': lambda: targetio_source(self.input_path, max_events=self._max_events, allowed_tels=allowed_tels, requested_event=requested_event, use_event_id=use_event_id), } try: source = switch[self.origin]() except KeyError: log.exception("unknown file origin '{}'".format(self.origin)) raise log.debug("[file] Reading complete") return source
def init(self): print("--- HessioReader init ---") if self.configuration == None: self.configuration = Configuration() self.raw_data = self.configuration.get('source', section='HESSIO_READER') try: self.source = hessio_event_source(get_path(self.raw_data), max_events=9) return True except(RuntimeError): print("could not open",self.raw_data, file=stderr) return False
def read(self, allowed_tels=None, requested_event=None, use_event_id=False): """ Read the file using the appropriate method depending on the file origin Parameters ---------- allowed_tels : list[int] select only a subset of telescope, if None, all are read. This can be used for example emulate the final CTA data format, where there would be 1 telescope per file (whereas in current monte-carlo, they are all interleaved into one file) requested_event : int Seek to a paricular event index use_event_id : bool If True ,'requested_event' now seeks for a particular event id instead of index Returns ------- source : generator A generator that can be iterated over to obtain events """ # Obtain relevent source log.debug("[file] Reading file...") if self._max_events: log.info("[file] Max events being read = {}" .format(self._max_events)) switch = { 'hessio': lambda: hessio_event_source(get_path(self.input_path), max_events=self._max_events, allowed_tels=allowed_tels, requested_event=requested_event, use_event_id=use_event_id), 'targetio': lambda: targetio_source(self.input_path, max_events=self._max_events, allowed_tels=allowed_tels, requested_event=requested_event, use_event_id=use_event_id), } try: source = switch[self.origin]() except KeyError: log.exception("unknown file origin '{}'".format(self.origin)) raise log.debug("[file] Reading complete") return source
def test_FitGammaHillas(): filename = get_path("gamma_test.simtel.gz") fit = FitGammaHillas() fit.setup_geometry(*load_hessio(filename), phi=180 * u.deg, theta=20 * u.deg) tel_geom = {} source = hessio_event_source(filename) for event in source: hillas_dict = {} for tel_id in set(event.trig.tels_with_trigger) & set( event.dl0.tels_with_data): if tel_id not in tel_geom: tel_geom[tel_id] = CameraGeometry.guess( fit.cameras(tel_id)['PixX'].to(u.m), fit.cameras(tel_id)['PixY'].to(u.m), fit.telescopes['FL'][tel_id - 1] * u.m) pmt_signal = event.dl0.tel[tel_id].adc_sums[0] mask = tailcuts_clean(tel_geom[tel_id], pmt_signal, 1, picture_thresh=10., boundary_thresh=5.) pmt_signal[mask is False] = 0 try: moments, moms2 = hillas_parameters( fit.cameras(tel_id)['PixX'], fit.cameras(tel_id)['PixY'], pmt_signal) hillas_dict[tel_id] = moments except HillasParameterizationError as e: print(e) continue if len(hillas_dict) < 2: continue fit_result = fit.predict(hillas_dict) print(fit_result) assert fit_result return
def init(self): print("--- HessioReader init ---") if self.configuration == None: self.configuration = Configuration() self.raw_data = self.configuration.get('source', section='HESSIO_READER') try: self.source = hessio_event_source(get_path(self.raw_data), max_events=9) return True except (RuntimeError): print("could not open", self.raw_data, file=stderr) return False
class EventFileReaderFactory(Factory): name = "EventFileReaderFactory" description = "Obtain EventFileReader based on file type" subclasses = Factory.child_subclasses(EventFileReader) subclass_names = [c.__name__ for c in subclasses] reader = CaselessStrEnum(subclass_names, None, allow_none=True, help='Event file reader to use. If None then ' 'a reader will be chosen based on file ' 'extension').tag(config=True) # Product classes traits # Would be nice to have these automatically set...! input_path = Unicode(get_path('gamma_test.simtel.gz'), allow_none=True, help='Path to the input file containing ' 'events.').tag(config=True) max_events = Int(None, allow_none=True, help='Maximum number of events that will be read from' 'the file').tag(config=True) def get_factory_name(self): return self.name def get_product_name(self): if self.reader is not None: return self.reader else: if self.input_path is None: raise ValueError("Please specify an input_path for event file") try: for subclass in self.subclasses: if subclass.check_file_compatibility(self.input_path): return subclass.__name__ raise ValueError except ValueError: self.log.exception("Cannot find compatible EventFileReader " "for: {}".format(self.input_path)) raise
def test_FitGammaHillas(): filename = get_path("gamma_test.simtel.gz") fit = FitGammaHillas() fit.setup_geometry(*load_hessio(filename), phi=180 * u.deg, theta=20 * u.deg) tel_geom = {} source = hessio_event_source(filename) for event in source: hillas_dict = {} for tel_id in set(event.trig.tels_with_trigger) & set(event.dl0.tels_with_data): if tel_id not in tel_geom: tel_geom[tel_id] = CameraGeometry.guess( fit.cameras(tel_id)["PixX"].to(u.m), fit.cameras(tel_id)["PixY"].to(u.m), fit.telescopes["FL"][tel_id - 1] * u.m, ) pmt_signal = event.dl0.tel[tel_id].adc_sums[0] mask = tailcuts_clean(tel_geom[tel_id], pmt_signal, 1, picture_thresh=10.0, boundary_thresh=5.0) pmt_signal[mask is False] = 0 try: moments, moms2 = hillas_parameters(fit.cameras(tel_id)["PixX"], fit.cameras(tel_id)["PixY"], pmt_signal) hillas_dict[tel_id] = moments except HillasParameterizationError as e: print(e) continue if len(hillas_dict) < 2: continue fit_result = fit.predict(hillas_dict) print(fit_result) assert fit_result return
def test_camera_dl1_calibrator(): event = get_test_event() telid = 11 calibrator = CameraDL1Calibrator(None, None) calibrator.get_neighbours(event, telid) assert(calibrator.neighbour_dict[telid][0][0] == 5) calibrator.get_correction(event, telid) assert_almost_equal(calibrator.correction_dict[telid][0], 2.154, 3) dl0 = calibrator.obtain_dl0(event, telid) assert_almost_equal(dl0[0, 0, 0], -0.091, 3) calibrator.calibrate(event) image = event.dl1.tel[telid].image assert_almost_equal(image[0, 0], -4.431, 3) filename = get_path('gamma_test.simtel.gz') source = hessio_event_source(filename, requested_event=409, use_event_id=True) calibrator.calibrate_source(source) event = next(source) assert_almost_equal(event.dl1.tel[21].image[0, 0], -3.410, 3)
def argparsing(): parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('-f', '--file', dest='input_paths', default=[get_path('gamma_test.simtel.gz')], nargs='*', help='path to the input files to be combined for a ' 'single charge resolution.') parser.add_argument('-O', '--origin', dest='origin', action='store', choices=InputFile.origin_list(), default='hessio', help='origin of the file') parser.add_argument('-t', '--telescope', dest='tel', action='store', type=int, default=None, nargs='*', help='list of telecopes to be included. ' 'Default = All') parser.add_argument('-o', '--output', dest='output_path', action='store', default=None, help='path to store a pdf output of the plots. ' 'default = display on screen instead') parser.add_argument('--comparison', dest='comparison', action='store', default=None, help='output path for a True Charge versus Measured' 'Charge graph. Default = do not plot graph') parser.add_argument('-M', '--maxpe', dest='maxpe', action='store', default=None, type=float, help='maximum pe to calculate the charge resolution' ' up to. Default = maximum pe in file') parser.add_argument('--maxpeplot', dest='maxpeplot', action='store', default=None, type=float, help='maximum pe to plot up to. Default = maxpe') parser.add_argument('-B', '--binning', dest='binning', action='store', default="log", choices=['none', 'normal', 'log'], help='binning of the charge resoltion graph: ' '"none" = no binning, "normal" = bin, ' '"log" = bin in log space.') parser.add_argument('--normalx', dest='normalx', action='store_true', default=False, help='Use a normal x axis instead of the defualt log' 'axis') parser.add_argument('--normaly', dest='normaly', action='store_true', default=False, help='Use a normal y axis instead of the defualt log' 'axis') parser.add_argument('-E', '--example', dest='example', action='store_true', default=False, help='print an example runcard') parser.add_argument('-R', '--runcard', dest='runcard', action='store', default=None, help='path to a runcard text file with arguments that ' 'override command line arguments. This run card ' 'can allow complex combinations of files and ' 'calibrations to compare the charge resolution ' 'against each other.') parser.add_argument('--chargeres-names', dest='chargeres_names', default=['default'], nargs='*', help='chargres calculation to include in plot. ' 'Only used for runcards.') parser.add_argument('--calib-help', dest='calib_help', action='store_true', default=False, help='display the arguments used for the camera ' 'calibration') logger_detail = parser.add_mutually_exclusive_group() logger_detail.add_argument('-q', '--quiet', dest='quiet', action='store_true', default=False, help='Quiet mode') logger_detail.add_argument('-v', '--verbose', dest='verbose', action='store_true', default=False, help='Verbose mode') logger_detail.add_argument('-d', '--debug', dest='debug', action='store_true', default=False, help='Debug mode') args, excess_args = parser.parse_known_args() if args.quiet: log.setLevel(40) if args.verbose: log.setLevel(20) if args.debug: log.setLevel(10) if args.calib_help: params, unknown_args = calibration_parameters(excess_args, args.origin, args.calib_help) if args.example: print(""" # Each charge resolution block starts with [chargeres] and the names for # this charge resolution. # The options in each block are equivalent to the scripts help message. # Options that seem to apply to plotting will only have effect in a # plotting block. [chargeres] test_file_local #-f gamma_test.simtel.gz -f ~/Software/outputs/sim_telarray/simtel_run4_gcts_hnsb.gz -O hessio --integrator 4 --integration-window 7 3 --integration-sigamp 2 4 --integration-lwt 0 --integration-calib_scale 1.05 --comparison ~/Downloads/test_file_local.pdf # A second charge resolution block to also calculate the resolution with # a different integrator so the two resolutions can be plotted against # each other. [chargeres] test_file_nei #-f gamma_test.simtel.gz -f ~/Software/outputs/sim_telarray/simtel_run4_gcts_hnsb.gz -O hessio --integrator 5 --integration-window 7 3 --integration-sigamp 2 4 --integration-lwt 0 --integration-calib_scale 1.05 --comparison ~/Downloads/test_file_nei.pdf # A plotting block configures an output plot [plot] normal_plot --chargeres-names test_file_local test_file_nei -o ~/Downloads/normal_plot.pdf --binning normal --normalx --normaly [plot] log_plot --chargeres-names test_file_local test_file_nei -o ~/Downloads/log_plot.pdf""") exit() chargeres_cmdlines = {} plot_cmdlines = {} if args.runcard is None: name = args.chargeres_names[0] chargeres_cmdlines[name] = sys.argv[1:] plot_cmdlines[name] = sys.argv[1:] chargeres_args = {name: args} plot_args = {name: args} else: chargeres_args = {} plot_args = {} current = None runcard = open(args.runcard) for line in runcard: if line.strip() and not line.startswith('#'): argument = line.split()[0] if argument == '[chargeres]': name = line.split()[1:][0] chargeres_cmdlines[name] = [] current = chargeres_cmdlines[name] continue elif argument == '[plot]': name = line.split()[1:][0] plot_cmdlines[name] = [] current = plot_cmdlines[name] continue current.extend(line.split()) # Temp fill for checks for name, cmdline in chargeres_cmdlines.items(): chargeres_args[name], unknown = parser.parse_known_args(cmdline) for name, cmdline in plot_cmdlines.items(): plot_args[name], unknown = parser.parse_known_args(cmdline) # Check all chargeres_names exist for plot_name, args in plot_args.items(): for name in args.chargeres_names: try: if name not in chargeres_args: raise IndexError except IndexError: log.exception("[chargeres_names] For plot: {}, no chargeres " "has the name: {}".format(plot_name, name)) raise return parser, chargeres_cmdlines, plot_cmdlines
@author: zornju Example of using the instrument module and reading data from a hessio, a fits, and a sim_telarray-config file. """ from ctapipe.instrument import InstrumentDescription as ID,util_functions as uf from ctapipe.instrument.telescope.camera import CameraDescription as CD from ctapipe.utils.datasets import get_path from astropy import units as u import matplotlib.pyplot as plt if __name__ == '__main__': filename1 = get_path('PROD2_telconfig.fits.gz') filename2 = get_path('gamma_test.simtel.gz') filename3 ='/afs/ifh.de/group/cta/MC_Production/d20150828_GM/mrg/sim_telarray/cfg/CTA/CTA-ULTRA6-SCT.cfg' #open both files: item1 = uf.load(filename1) item2 = uf.load(filename2) item3 = uf.load(filename3) #initialize the whole telescope, i.e. read all data from the files which #concerns the whole telescope (including camera and optics) instr1 = ID.Telescope.initialize(filename1,item1) instr2 = ID.Telescope.initialize(filename2,item2) instr3 = ID.Telescope.initialize(filename3,item3) #The ID.telescope.initializ-function returns 3 objects as a list. The
def get_test_event(): filename = get_path( 'gamma_20deg_0deg_run31964___cta-prod2_desert-1640m-Aar.simtel.gz') for event in hessio_event_source(filename): if event.dl0.event_id == 409: return event
Created on Thu Nov 19 11:43:50 2015 @author: zornju Example of using the instrument module and reading data from a hessio, a fits, and a sim_telarray-config file. """ from ctapipe.instrument import InstrumentDescription as ID from ctapipe.utils.datasets import get_path import matplotlib.pyplot as plt import os if __name__ == '__main__': filename1 = get_path('PROD2_telconfig.fits.gz') filename2 = get_path('gamma_test.simtel.gz') filename3 = get_path('CTA-ULTRA6-SCT.cfg') tel1,cam1,opt1 = ID.load(filename1) tel2,cam2,opt2 = ID.load(filename2) tel3,cam3,opt3 = ID.load(filename3) tel4,cam4,opt4 = ID.load() #To check which tables are in the dictionaries, do: print('Print the name of the tables present in the dictionaries taken',\ 'from the fits file:') print(tel1.keys(),cam1.keys(),opt1.keys()) print('As you can see, in the fits file, only the first dictionary is',\ 'filled with tables.') print('------------------------------------------------------------------')
disp[-1].add_colorbar(label=" [{} ADC cts]".format(gain_label[i])) plt.pause(0.1) pp.savefig(fig) pp.close() if __name__ == '__main__': # Declare and parse command line option parser = argparse.ArgumentParser( description='Tel_id, pixel id and number of event to compute.') parser.add_argument('--f', dest='filename', required=False, default=get_path('gamma_test.simtel.gz'), help='filename <MC file name>') parser.add_argument('--d', dest='display', action='store_true', required=False,help='display the camera events') parser.add_argument('--tel', dest='tel_id', action='store', required=False, default=None, help='Telescope ID to display') parser.add_argument('--pdf', dest='pdffilename', action='store', required=False, default="./tmp.pdf", help='PDF output filename') args = parser.parse_args() if args.display: plt.show(block=False)
Created on Thu Nov 19 11:43:50 2015 @author: zornju Example of using the instrument module and reading data from a hessio, a fits, and a sim_telarray-config file. """ from ctapipe.instrument import InstrumentDescription as ID, CameraDescription as CD from ctapipe.utils.datasets import get_path from astropy import units as u import matplotlib.pyplot as plt if __name__ == '__main__': filename1 = get_path('PROD2_telconfig.fits.gz') filename2 = get_path('gamma_test.simtel.gz') #filename3 = get_path('CTA-ULTRA6-SCT.cfg') filename3 = '/afs/ifh.de/group/cta/MC_Production/d20150828_GM/mrg/sim_telarray/cfg/CTA/CTA-ULTRA6-SCT.cfg' instr1 = ID.Telescope.from_file(filename1) instr2 = ID.Telescope.from_file(filename2) instr3 = ID.Telescope.from_file(filename3) #The ID.telescope.initializ-function returns 3 objects as a list. The #first entry of the list is the object containing the telescope #configuration whithout the camera and optics, thus: tel1 = instr1[0] tel2 = instr2[0] tel3 = instr3[0]
import numpy as np from matplotlib import pyplot as plt from os.path import realpath, join, dirname from ctapipe.utils.datasets import get_path from ctapipe.io.hessio import hessio_event_source from ctapipe.instrument import CameraGeometry from ctapipe.visualization import CameraDisplay from targetpipe.io.pixels import checm_pixel_id filepath = get_path("/Users/Jason/Software/outputs/sim_telarray/meudon_gamma/" "simtel_runmeudon_gamma_30tel_30deg_19.gz") # filepath = get_path(sys.argv[1]) source = hessio_event_source(filepath, max_events=1) event = next(source) tel = list(event.dl0.tels_with_data)[0] pos_arr = np.array(event.inst.pixel_pos[tel]) n_pix = pos_arr.shape[1] pos_arr = pos_arr[:, checm_pixel_id] pos_arr[1] = -pos_arr[1] fig = plt.figure(figsize=(13, 13)) ax = fig.add_subplot(111) geom = CameraGeometry.guess(*event.inst.pixel_pos[tel], event.inst.optical_foclen[tel]) camera = CameraDisplay(geom, ax=ax, image=np.zeros(2048)) for pix in range(n_pix):
def test_showermaxestimator(en=5*u.TeV, h_first_int=10*u.km, az=70*u.deg): estim = ShowerMaxEstimator(get_path("atmprof_paranal.dat")) h_max = estim.find_shower_max_height(en, h_first_int, az) assert h_max.unit.is_equivalent(u.m), "return value has not proper unit" return h_max
def test_convert_geometry(): filename = get_path("gamma_test.simtel.gz") cam_geom = {} source = hessio_event_source(filename) # testing a few images just for the sake of being thorough counter = 5 for event in source: for tel_id in event.dl0.tels_with_data: if tel_id not in cam_geom: cam_geom[tel_id] = CameraGeometry.guess( event.inst.pixel_pos[tel_id][0], event.inst.pixel_pos[tel_id][1], event.inst.optical_foclen[tel_id]) # we want to test conversion of hex to rectangular pixel grid if cam_geom[tel_id].pix_type is not "hexagonal": continue print(tel_id, cam_geom[tel_id].pix_type) pmt_signal = apply_mc_calibration( #event.dl0.tel[tel_id].adc_samples[0], event.dl0.tel[tel_id].adc_sums[0], event.mc.tel[tel_id].dc_to_pe[0], event.mc.tel[tel_id].pedestal[0]) new_geom, new_signal = convert_geometry_1d_to_2d( cam_geom[tel_id], pmt_signal, cam_geom[tel_id].cam_id, add_rot=-2) unrot_geom, unrot_signal = convert_geometry_back( new_geom, new_signal, cam_geom[tel_id].cam_id, event.inst.optical_foclen[tel_id], add_rot=4) # if run as main, do some plotting if __name__ == "__main__": fig = plt.figure() plt.style.use('seaborn-talk') ax1 = fig.add_subplot(131) disp1 = CameraDisplay(cam_geom[tel_id], image=np.sum(pmt_signal, axis=1) if pmt_signal.shape[-1] == 25 else pmt_signal, ax=ax1) disp1.cmap = plt.cm.hot disp1.add_colorbar() plt.title("original geometry") ax2 = fig.add_subplot(132) disp2 = CameraDisplay(new_geom, image=np.sum(new_signal, axis=2) if new_signal.shape[-1] == 25 else new_signal, ax=ax2) disp2.cmap = plt.cm.hot disp2.add_colorbar() plt.title("slanted geometry") ax3 = fig.add_subplot(133) disp3 = CameraDisplay(unrot_geom, image=np.sum(unrot_signal, axis=1) if unrot_signal.shape[-1] == 25 else unrot_signal, ax=ax3) disp3.cmap = plt.cm.hot disp3.add_colorbar() plt.title("geometry converted back to hex") plt.show() # do some tailcuts cleaning mask1 = tailcuts_clean(cam_geom[tel_id], pmt_signal, 1, picture_thresh=10., boundary_thresh=5.) mask2 = tailcuts_clean(unrot_geom, unrot_signal, 1, picture_thresh=10., boundary_thresh=5.) pmt_signal[mask1==False] = 0 unrot_signal[mask2==False] = 0 ''' testing back and forth conversion on hillas parameters... ''' try: moments1 = hillas_parameters(cam_geom[tel_id].pix_x, cam_geom[tel_id].pix_y, pmt_signal) moments2 = hillas_parameters(unrot_geom.pix_x, unrot_geom.pix_y, unrot_signal) except (HillasParameterizationError, AssertionError) as e: ''' we don't want this test to fail because the hillas code threw an error ''' print(e) counter -= 1 if counter < 0: return else: continue ''' test if the hillas parameters from the original geometry and the forth-and-back rotated geometry are close ''' assert np.allclose( [moments1.length.value, moments1.width.value, moments1.phi.value], [moments2.length.value, moments2.width.value, moments2.phi.value], rtol=1e-2, atol=1e-2) counter -= 1 if counter < 0: return
def main(): script = os.path.splitext(os.path.basename(__file__))[0] log.info("[SCRIPT] {}".format(script)) parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('-f', '--file', dest='input_path', action='store', default=get_path('gamma_test.simtel.gz'), help='path to the input file') parser.add_argument('-O', '--origin', dest='origin', action='store', choices=InputFile.origin_list(), default='hessio', help='origin of the file') parser.add_argument('-o', '--output', dest='output_dir', action='store', default=None, help='path of the output directory to store the ' 'images (default = input file directory)') parser.add_argument('-e', '--event', dest='event_req', action='store', default=0, type=int, help='event index to plot (not id!)') parser.add_argument('--id', dest='event_id_f', action='store_true', default=False, help='-e will specify event_id instead ' 'of index') parser.add_argument('-t', '--telescope', dest='tel', action='store', type=int, default=None, help='telecope to view') parser.add_argument('-c', '--channel', dest='chan', action='store', type=int, default=0, help='channel to view (default = 0 (HG))') parser.add_argument('--calib-help', dest='calib_help', action='store_true', default=False, help='display the arguments used for the camera ' 'calibration') logger_detail = parser.add_mutually_exclusive_group() logger_detail.add_argument('-q', '--quiet', dest='quiet', action='store_true', default=False, help='Quiet mode') logger_detail.add_argument('-v', '--verbose', dest='verbose', action='store_true', default=False, help='Verbose mode') logger_detail.add_argument('-d', '--debug', dest='debug', action='store_true', default=False, help='Debug mode') args, excess_args = parser.parse_known_args() if args.quiet: log.setLevel(40) if args.verbose: log.setLevel(20) if args.debug: log.setLevel(10) telid = args.tel chan = args.chan log.debug("[file] Reading file") input_file = InputFile(args.input_path, args.origin) event = input_file.get_event(args.event_req, args.event_id_f) # Print event/args values log.info("[event_index] {}".format(event.count)) log.info("[event_id] {}".format(event.dl0.event_id)) log.info("[telescope] {}".format(telid)) log.info("[channel] {}".format(chan)) params, unknown_args = calibration_parameters(excess_args, args.origin, args.calib_help) if unknown_args: parser.print_help() calibration_parameters(unknown_args, args.origin, True) msg = 'unrecognized arguments: %s' parser.error(msg % ' '.join(unknown_args)) # Create a dictionary to store any geoms in geom = CameraGeometry.guess(*event.meta.pixel_pos[telid], event.meta.optical_foclen[telid]) geom_dict = {telid: geom} calibrated_event = calibrate_event(event, params, geom_dict) # Select telescope tels = list(calibrated_event.dl0.tels_with_data) if telid is None or telid not in tels: log.error("[event] please specify one of the following telescopes " "for this event: {}".format(tels)) exit() # Extract required images data_ped = calibrated_event.dl1.tel[telid].pedestal_subtracted_adc[chan] true_pe = calibrated_event.mc.tel[telid].photo_electrons measured_pe = calibrated_event.dl1.tel[telid].pe_charge max_time = np.unravel_index(np.argmax(data_ped), data_ped.shape)[1] max_charges = np.max(data_ped, axis=1) max_pixel = int(np.argmax(max_charges)) min_pixel = int(np.argmin(max_charges)) # Get Neighbours max_pixel_nei = geom.neighbors[max_pixel] min_pixel_nei = geom.neighbors[min_pixel] # Get Windows windows = calibrated_event.dl1.tel[telid].integration_window[chan] length = np.sum(windows, axis=1) start = np.argmax(windows, axis=1) end = start + length - 1 # Draw figures ax_max_nei = {} ax_min_nei = {} fig_waveforms = plt.figure(figsize=(18, 9)) fig_waveforms.subplots_adjust(hspace=.5) fig_camera = plt.figure(figsize=(15, 12)) ax_max_pix = fig_waveforms.add_subplot(4, 2, 1) ax_min_pix = fig_waveforms.add_subplot(4, 2, 2) ax_max_nei[0] = fig_waveforms.add_subplot(4, 2, 3) ax_min_nei[0] = fig_waveforms.add_subplot(4, 2, 4) ax_max_nei[1] = fig_waveforms.add_subplot(4, 2, 5) ax_min_nei[1] = fig_waveforms.add_subplot(4, 2, 6) ax_max_nei[2] = fig_waveforms.add_subplot(4, 2, 7) ax_min_nei[2] = fig_waveforms.add_subplot(4, 2, 8) ax_img_nei = fig_camera.add_subplot(2, 2, 1) ax_img_max = fig_camera.add_subplot(2, 2, 2) ax_img_true = fig_camera.add_subplot(2, 2, 3) ax_img_cal = fig_camera.add_subplot(2, 2, 4) plotter = CameraPlotter(event, geom_dict) # Draw max pixel traces plotter.draw_waveform(data_ped[max_pixel], ax_max_pix) ax_max_pix.set_title("(Max) Pixel: {}, " "True: {}, " "Measured = {:.3f}".format(max_pixel, true_pe[max_pixel], measured_pe[max_pixel])) ax_max_pix.set_ylabel("Amplitude-Ped (ADC)") max_ylim = ax_max_pix.get_ylim() plotter.draw_waveform_positionline(start[max_pixel], ax_max_pix) plotter.draw_waveform_positionline(end[max_pixel], ax_max_pix) for i, ax in ax_max_nei.items(): if len(max_pixel_nei) > i: pix = max_pixel_nei[i] plotter.draw_waveform(data_ped[pix], ax) ax.set_title("(Max Nei) Pixel: {}, " "True: {}, " "Measured = {:.3f}".format(pix, true_pe[pix], measured_pe[pix])) ax.set_ylabel("Amplitude-Ped (ADC)") ax.set_ylim(max_ylim) plotter.draw_waveform_positionline(start[pix], ax) plotter.draw_waveform_positionline(end[pix], ax) # Draw min pixel traces plotter.draw_waveform(data_ped[min_pixel], ax_min_pix) ax_min_pix.set_title("(Min) Pixel: {}, " "True: {}, " "Measured = {:.3f}".format(min_pixel, true_pe[min_pixel], measured_pe[min_pixel])) ax_min_pix.set_ylabel("Amplitude-Ped (ADC)") ax_min_pix.set_ylim(max_ylim) plotter.draw_waveform_positionline(start[min_pixel], ax_min_pix) plotter.draw_waveform_positionline(end[min_pixel], ax_min_pix) for i, ax in ax_min_nei.items(): if len(min_pixel_nei) > i: pix = min_pixel_nei[i] plotter.draw_waveform(data_ped[pix], ax) ax.set_title("(Min Nei) Pixel: {}, " "True: {}, " "Measured = {:.3f}".format(pix, true_pe[pix], measured_pe[pix])) ax.set_ylabel("Amplitude-Ped (ADC)") ax.set_ylim(max_ylim) plotter.draw_waveform_positionline(start[pix], ax) plotter.draw_waveform_positionline(end[pix], ax) # Draw cameras nei_camera = np.zeros_like(max_charges, dtype=np.int) nei_camera[min_pixel_nei] = 2 nei_camera[min_pixel] = 1 nei_camera[max_pixel_nei] = 3 nei_camera[max_pixel] = 4 camera = plotter.draw_camera(telid, nei_camera, ax_img_nei) camera.cmap = plt.cm.viridis ax_img_nei.set_title("Neighbour Map") plotter.draw_camera_pixel_annotation(telid, max_pixel, min_pixel, ax_img_nei) camera = plotter.draw_camera(telid, data_ped[:, max_time], ax_img_max) camera.add_colorbar(ax=ax_img_max, label="Amplitude-Ped (ADC)") ax_img_max.set_title("Max Timeslice (T = {})".format(max_time)) plotter.draw_camera_pixel_annotation(telid, max_pixel, min_pixel, ax_img_max) camera = plotter.draw_camera(telid, true_pe, ax_img_true) camera.add_colorbar(ax=ax_img_true, label="True Charge (Photo-electrons)") ax_img_true.set_title("True Charge") plotter.draw_camera_pixel_annotation(telid, max_pixel, min_pixel, ax_img_true) int_dict, inverted = integrator_dict() integrator_name = '' if 'integrator' not in params else \ params['integrator'] camera = plotter.draw_camera(telid, measured_pe, ax_img_cal) camera.add_colorbar(ax=ax_img_cal, label="Calib Charge (Photo-electrons)") ax_img_cal.set_title("Charge (integrator={})".format(integrator_name)) plotter.draw_camera_pixel_annotation(telid, max_pixel, min_pixel, ax_img_cal) fig_waveforms.suptitle("Integrator = {}".format(integrator_name)) fig_camera.suptitle("Camera = {}".format(geom.cam_id)) waveform_output_name = "{}_e{}_t{}_c{}_integrator{}_waveform.pdf"\ .format(input_file.filename, event.count, telid, chan, inverted[params['integrator']]) camera_output_name = "{}_e{}_t{}_c{}_integrator{}_camera.pdf"\ .format(input_file.filename, event.count, telid, chan, inverted[params['integrator']]) output_dir = args.output_dir if args.output_dir is not None else \ input_file.output_directory output_dir = os.path.join(output_dir, script) if not os.path.exists(output_dir): log.info("[output] Creating directory: {}".format(output_dir)) os.makedirs(output_dir) waveform_output_path = os.path.join(output_dir, waveform_output_name) log.info("[output] {}".format(waveform_output_path)) fig_waveforms.savefig(waveform_output_path, format='pdf', bbox_inches='tight') camera_output_path = os.path.join(output_dir, camera_output_name) log.info("[output] {}".format(camera_output_path)) fig_camera.savefig(camera_output_path, format='pdf', bbox_inches='tight') log.info("[COMPLETE]")
# -*- coding: utf-8 -*- """ Created on Wed Nov 18 17:37:19 2015 @author: zornju """ import ctapipe.instrument.InstrumentDescription as ID from ctapipe.utils.datasets import get_path filename1 = get_path('PROD2_telconfig.fits.gz') filename2 = get_path('gamma_test.simtel.gz') filename3 = get_path('CTA-ULTRA6-SCT.cfg') def test_read_telescope_data(): instr1 = ID.Telescope.from_file(filename1) instr2 = ID.Telescope.from_file(filename2) instr3 = ID.Telescope.from_file(filename3) instr4 = ID.Telescope.from_file() tel1 = instr1[0] tel2 = instr2[0] tel3 = instr3[0] tel4 = instr4[0] assert(len(tel1.tel_id)>0) assert(len(tel2.tel_id)>0) assert(len(tel3.tel_id)>0) assert(len(tel4.tel_id)>0) opt1 = instr1[1] opt2 = instr2[1] opt3 = instr3[1] opt4 = instr4[1]
from ctapipe.io.hessio import hessio_event_source from ctapipe.utils.datasets import get_path # input_filepath = "/Users/Jason/Software/outputs/sim_telarray/simtel_run4_gcts_hnsb.gz" # input_filepath = "/Users/Jason/Software/outputs/sim_telarray/gamma_20deg_0deg_run10251___cta-prod3-merged_desert-2150m-Paranal-subarray-3_cone10.simtel.gz" # input_filepath = "/Users/Jason/Software/outputs/sim_telarray/simtel_runmeudon_gamma_30tel_30deg_1.gz" input_filepath = "/Users/Jason/Software/outputs/sim_telarray/simtel_runmeudon_proton_30tel_30deg_1.gz" source = hessio_event_source(get_path(input_filepath), max_events=100) event = next(source) tels = list(event.dl0.tels_with_data) Qt = event.mc.tel[tels[0]].photo_electrons if Qt.any() > 0: print("File has true pe") else: print("No true pe data")
def get_test_event(): filename = get_path('gamma_test.simtel.gz') for event in hessio_event_source(filename): if event.dl0.event_id == 409: return event
class EventFileReader(Component): """ Parent class for specific FileReaders Attributes ---------- input_path : str directory : str Automatically set from `input_path`. filename : str Name of the file without the extension. Automatically set from `input_path`. extension : str Automatically set from `input_path`. output_directory : str Directory to save outputs for this file """ name = 'EventFileReader' origin = None input_path = Unicode(get_path('gamma_test.simtel.gz'), allow_none=True, help='Path to the input file containing ' 'events.').tag(config=True) max_events = Int(None, allow_none=True, help='Maximum number of events that will be read from' 'the file').tag(config=True) def __init__(self, config, tool, **kwargs): """ Class to handle generic input files. Enables obtaining the "source" generator, regardless of the type of file (either hessio or camera file). Parameters ---------- config : traitlets.loader.Config Configuration specified by config file or cmdline arguments. Used to set traitlet values. Set to None if no configuration to pass. tool : ctapipe.core.Tool Tool executable that is calling this component. Passes the correct logger to the component. Set to None if no Tool to pass. kwargs """ super().__init__(config=config, parent=tool, **kwargs) if self.origin is None: raise ValueError("Subclass of EventFileReader should specify " "an origin") self._num_events = None self._event_id_list = [] if self.input_path is None: raise ValueError("Please specify an input_path for event file") self._init_path(self.input_path) def _init_path(self, input_path): if not exists(input_path): raise FileNotFoundError( "file path does not exist: '{}'".format(input_path)) self.input_path = input_path self.directory = dirname(input_path) self.filename = splitext(basename(input_path))[0] self.extension = splitext(input_path)[1] self.output_directory = join(self.directory, self.filename) if self.log: self.log.info("INPUT PATH = {}".format(self.input_path)) @observe('input_path') def on_input_path_changed(self, change): new = change['new'] try: self.log.warning("Change: input_path={}".format(new)) self._num_events = None self._event_id_list = [] self._init_path(new) except AttributeError: pass @observe('origin') def on_origin_changed(self, change): new = change['new'] try: self.log.warning("Change: origin={}".format(new)) except AttributeError: pass @observe('max_events') def on_max_events_changed(self, change): new = change['new'] try: self.log.warning("Change: max_events={}".format(new)) self._num_events = None self._event_id_list = [] except AttributeError: pass @property @abstractmethod def origin(self): """ Abstract property to be defined in child class. Get the name for the origin of the file. E.g. 'hessio'. Returns ------- origin : str """ @staticmethod @abstractmethod def check_file_compatibility(file_path): """ Abstract method to be defined in child class. Perform a set of checks to see if the input file is compatible with this file reader. Parameters ---------- file_path : str File path to the event file. Returns ------- compatible : bool True if file is compatible, False if it is incompatible """ @property @abstractmethod def num_events(self): """ Abstract property to be defined in child class. Obtain the number of events from the file, store it inside self._num_events, and return the value. Returns ------- self._num_events : int """ @property @abstractmethod def event_id_list(self): """ Abstract property to be defined in child class. Obtain the number of events from the file, store it as self._event_id_list, and return the value. Returns ------- self._event_id_list : list[self._num_events] """ @abstractmethod def read(self, allowed_tels=None, requested_event=None, use_event_id=False): """ Abstract method to be defined in child class. Read the file using the processes required by the readers file-type. Parameters ---------- allowed_tels : list[int] select only a subset of telescope, if None, all are read. This can be used for example emulate the final CTA data format, where there would be 1 telescope per file (whereas in current monte-carlo, they are all interleaved into one file) requested_event : int Seek to a paricular event index use_event_id : bool If True ,'requested_event' now seeks for a particular event id instead of index Returns ------- source : generator A generator that can be iterated over to obtain events """ def get_event(self, requested_event, use_event_id=False): """ Loop through events until the requested event is found Parameters ---------- requested_event : int Seek to a paricular event index use_event_id : bool If True ,'requested_event' now seeks for a particular event id instead of index Returns ------- event : `ctapipe` event-container """ source = self.read(requested_event=requested_event, use_event_id=use_event_id) event = next(source) return deepcopy(event) def find_max_true_npe(self, telescopes=None): """ Loop through events to find the maximum true npe Parameters ---------- telescopes : list List of telecopes to include. If None, then all telescopes are included. Returns ------- max_pe : int """ # TODO: Find an alternate method so this can be removed self.log.info("Finding maximum true npe inside file...") source = self.read() max_pe = 0 for event in source: tels = list(event.dl0.tels_with_data) if telescopes is not None: tels = [] for tel in telescopes: if tel in event.dl0.tels_with_data: tels.append(tel) if event.count == 0: # Check events have true charge included try: if np.all(event.mc.tel[tels[0]].photo_electron_image == 0): raise KeyError except KeyError: self.log.exception('[chargeres] Source does not contain ' 'true charge') raise for telid in tels: pe = event.mc.tel[telid].photo_electron_image this_max = np.max(pe) if this_max > max_pe: max_pe = this_max self.log.info("Maximum true npe inside file = {}".format(max_pe)) return max_pe
def get_input(): print("============================================") print("n or [enter] - go to Next event") print("d - Display the event") print("p - Print all event data") print("i - event Info") print("q - Quit") return input("Choice: ") if __name__ == '__main__': if len(sys.argv) > 1: filename = sys.argv.pop(1) else: filename = get_path("gamma_test.simtel.gz") plt.style.use("ggplot") plt.show(block=False) # loop over events and display menu at each event: source = hessio_event_source(filename, max_events=1000000) for event in source: print("EVENT_ID: ", event.dl0.event_id, "TELS: ", event.dl0.tels_with_data) while True: response = get_input() if response.startswith("d"):
from ctapipe.visualization import ArrayDisplay from ctapipe.utils import datasets from astropy.table import Table from numpy import ones_like import matplotlib.pylab as plt if __name__ == '__main__': plt.style.use("ggplot") plt.figure(figsize=(9.5, 8.5)) # load up an example table that has the telescope positions and # mirror areas in it: arrayfile = datasets.get_path("PROD2_telconfig.fits.gz") tels = Table.read(arrayfile, hdu="TELESCOPE_LEVEL0") X = tels['TelX'] Y = tels['TelY'] A = tels['MirrorArea'] * 2 # exaggerate scale a bit # display the array, and set the color value to 50 ad = ArrayDisplay(X, Y, A, title="Prod 2 Full Array") ad.values = ones_like(X) * 50 # label them for tel in tels: name = "CT{tid}".format(tid=tel['TelID']) plt.text(tel['TelX'], tel['TelY'], name, fontsize=8) ad.axes.set_xlim(-1000, 1000)
def test_convert_geometry(): filename = get_path("gamma_test.simtel.gz") cam_geom = {} source = hessio_event_source(filename) # testing a few images just for the sake of being thorough counter = 5 for event in source: for tel_id in event.dl0.tels_with_data: if tel_id not in cam_geom: cam_geom[tel_id] = CameraGeometry.guess( event.inst.pixel_pos[tel_id][0], event.inst.pixel_pos[tel_id][1], event.inst.optical_foclen[tel_id]) # we want to test conversion of hex to rectangular pixel grid if cam_geom[tel_id].pix_type is not "hexagonal": continue print(tel_id, cam_geom[tel_id].pix_type) pmt_signal = apply_mc_calibration( #event.dl0.tel[tel_id].adc_samples[0], event.dl0.tel[tel_id].adc_sums[0], event.mc.tel[tel_id].dc_to_pe[0], event.mc.tel[tel_id].pedestal[0]) new_geom, new_signal = convert_geometry_1d_to_2d( cam_geom[tel_id], pmt_signal, cam_geom[tel_id].cam_id, add_rot=-2) unrot_geom, unrot_signal = convert_geometry_back( new_geom, new_signal, cam_geom[tel_id].cam_id, event.inst.optical_foclen[tel_id], add_rot=4) # if run as main, do some plotting if __name__ == "__main__": fig = plt.figure() plt.style.use('seaborn-talk') ax1 = fig.add_subplot(131) disp1 = CameraDisplay( cam_geom[tel_id], image=np.sum(pmt_signal, axis=1) if pmt_signal.shape[-1] == 25 else pmt_signal, ax=ax1) disp1.cmap = plt.cm.hot disp1.add_colorbar() plt.title("original geometry") ax2 = fig.add_subplot(132) disp2 = CameraDisplay( new_geom, image=np.sum(new_signal, axis=2) if new_signal.shape[-1] == 25 else new_signal, ax=ax2) disp2.cmap = plt.cm.hot disp2.add_colorbar() plt.title("slanted geometry") ax3 = fig.add_subplot(133) disp3 = CameraDisplay( unrot_geom, image=np.sum(unrot_signal, axis=1) if unrot_signal.shape[-1] == 25 else unrot_signal, ax=ax3) disp3.cmap = plt.cm.hot disp3.add_colorbar() plt.title("geometry converted back to hex") plt.show() # do some tailcuts cleaning mask1 = tailcuts_clean(cam_geom[tel_id], pmt_signal, 1, picture_thresh=10., boundary_thresh=5.) mask2 = tailcuts_clean(unrot_geom, unrot_signal, 1, picture_thresh=10., boundary_thresh=5.) pmt_signal[mask1 == False] = 0 unrot_signal[mask2 == False] = 0 ''' testing back and forth conversion on hillas parameters... ''' try: moments1 = hillas_parameters(cam_geom[tel_id].pix_x, cam_geom[tel_id].pix_y, pmt_signal) moments2 = hillas_parameters(unrot_geom.pix_x, unrot_geom.pix_y, unrot_signal) except (HillasParameterizationError, AssertionError) as e: ''' we don't want this test to fail because the hillas code threw an error ''' print(e) counter -= 1 if counter < 0: return else: continue ''' test if the hillas parameters from the original geometry and the forth-and-back rotated geometry are close ''' assert np.allclose([ moments1.length.value, moments1.width.value, moments1.phi.value ], [ moments2.length.value, moments2.width.value, moments2.phi.value ], rtol=1e-2, atol=1e-2) counter -= 1 if counter < 0: return
import numpy as np from astropy.io import fits from tqdm import tqdm from ctapipe.utils.datasets import get_path from ctapipe.io.hessio import hessio_event_source import os.path import math import sys filepath = get_path("/Users/Jason/Software/outputs/sim_telarray/meudon_gamma/simtel_runmeudon_gamma_30tel_30deg_19.gz") # filepath = get_path(sys.argv[1]) events_per_byte = 16673/2150294565 est_events = os.path.getsize(filepath) * events_per_byte source = hessio_event_source(filepath, max_events=1) event = next(source) tel = list(event.dl0.tels_with_data)[0] pos_arr = np.array(event.inst.pixel_pos[tel]) n_pix = pos_arr.shape[1] for pix in range(n_pix): pos_x = pos_arr[0,pix] pos_y = pos_arr[1,pix] print("[{0:.5g}, {1:.5g}], # {2}".format(pos_x,-pos_y,pix))
import numpy as np from astropy.table import Table from ctapipe.utils import datasets from ctapipe.visualization import ArrayDisplay from matplotlib import pyplot as plt if __name__ == '__main__': plt.style.use("ggplot") plt.figure(figsize=(10, 8)) arrayfile = datasets.get_path("PROD2_telconfig.fits.gz") tels = Table.read(arrayfile, hdu="TELESCOPE_LEVEL0") adisp = ArrayDisplay(tels['TelX'], tels['TelY'], tels['MirrorArea'] * 2, title='PROD2 telescopes', autoupdate=True) plt.tight_layout() values = np.zeros(len(tels)) # do a small animation to show various trigger patterns: for ii in range(20): # generate a random trigger pattern and integrated intensity: ntrig = np.random.poisson(10) trigmask = np.random.random_integers(len(tels) - 1, size=ntrig) values[:] = 0 values[trigmask] = np.random.uniform(0, 100, size=ntrig)
def main(): script = os.path.splitext(os.path.basename(__file__))[0] log.info("[SCRIPT] {}".format(script)) parser = argparse.ArgumentParser( description='Display each event in the file') parser.add_argument('-f', '--file', dest='input_path', action='store', default=get_path('gamma_test.simtel.gz'), help='path to the input file. ' 'Default = gamma_test.simtel.gz') parser.add_argument('-O', '--origin', dest='origin', action='store', default='hessio', help='origin of the file: {}. Default = hessio' .format(origin_list())) parser.add_argument('-D', dest='display', action='store_true', default=False, help='display the camera events') parser.add_argument('--pdf', dest='output_path', action='store', default=None, help='path to store a pdf output of the plots') parser.add_argument('-t', '--telescope', dest='tel', action='store', type=int, default=None, help='telecope to view. ' 'Default = All') calibration_arguments(parser) logger_detail = parser.add_mutually_exclusive_group() logger_detail.add_argument('-q', '--quiet', dest='quiet', action='store_true', default=False, help='Quiet mode') logger_detail.add_argument('-v', '--verbose', dest='verbose', action='store_true', default=False, help='Verbose mode') logger_detail.add_argument('-d', '--debug', dest='debug', action='store_true', default=False, help='Debug mode') args = parser.parse_args() params = calibration_parameters(args) if args.quiet: log.setLevel(40) if args.verbose: log.setLevel(20) if args.debug: log.setLevel(10) log.debug("[file] Reading file") input_file = InputFile(args.input_path, args.origin) source = input_file.read() # geom_dict is a dictionary of CameraGeometry, with keys of # (num_pixels, focal_length), the parameters that are used to guess the # geometry of the telescope. By using these keys, the geometry is # calculated only once per telescope type as needed, reducing computation # time. # Creating a geom_dict at this point is optional, but is recommended, as # the same geom_dict can then be shared between the calibration and # CameraPlotter, again reducing computation time. # The dictionary becomes filled as a result of a dictionary's mutable # nature. geom_dict = {} # Calibrate events and fill geom_dict calibrated_source = calibrate_source(source, params, geom_dict) fig = plt.figure(figsize=(16, 7)) if args.display: plt.show(block=False) pp = PdfPages(args.output_path) if args.output_path is not None else None for event in calibrated_source: tels = list(event.dl0.tels_with_data) if args.tel is None: tel_loop = tels else: if args.tel not in tels: continue tel_loop = [args.tel] log.debug(tels) for tel_id in tel_loop: display_telescope(event, tel_id, args.display, geom_dict, pp, fig) if pp is not None: pp.close() log.info("[COMPLETE]")
def main(): script = os.path.splitext(os.path.basename(__file__))[0] log.info("[SCRIPT] {}".format(script)) parser = argparse.ArgumentParser( description='Display each event in the file') parser.add_argument('-f', '--file', dest='input_path', action='store', default=get_path('gamma_test.simtel.gz'), help='path to the input file. ' 'Default = gamma_test.simtel.gz') parser.add_argument('-O', '--origin', dest='origin', action='store', default='hessio', help='origin of the file: {}. Default = hessio'.format( InputFile.origin_list())) parser.add_argument('-D', dest='display', action='store_true', default=False, help='display the camera events') parser.add_argument('--pdf', dest='output_path', action='store', default=None, help='path to store a pdf output of the plots') parser.add_argument('-t', '--telescope', dest='tel', action='store', type=int, default=None, help='telecope to view. ' 'Default = All') calibration_arguments(parser) logger_detail = parser.add_mutually_exclusive_group() logger_detail.add_argument('-q', '--quiet', dest='quiet', action='store_true', default=False, help='Quiet mode') logger_detail.add_argument('-v', '--verbose', dest='verbose', action='store_true', default=False, help='Verbose mode') logger_detail.add_argument('-d', '--debug', dest='debug', action='store_true', default=False, help='Debug mode') args = parser.parse_args() print('DEBUG type(args) {}'.format(type(args))) print('DEBUG args {}'.format(args)) params = calibration_parameters(args) if args.quiet: log.setLevel(40) if args.verbose: log.setLevel(20) if args.debug: log.setLevel(10) log.debug("[file] Reading file") input_file = InputFile(args.input_path, args.origin) source = input_file.read() # geom_dict is a dictionary of CameraGeometry, with keys of # (num_pixels, focal_length), the parameters that are used to guess the # geometry of the telescope. By using these keys, the geometry is # calculated only once per telescope type as needed, reducing computation # time. # Creating a geom_dict at this point is optional, but is recommended, as # the same geom_dict can then be shared between the calibration and # CameraPlotter, again reducing computation time. # The dictionary becomes filled as a result of a dictionary's mutable # nature. geom_dict = {} # Calibrate events and fill geom_dict calibrated_source = calibrate_source(source, params, geom_dict) fig = plt.figure(figsize=(16, 7)) if args.display: plt.show(block=False) pp = PdfPages(args.output_path) if args.output_path is not None else None for event in calibrated_source: tels = list(event.dl0.tels_with_data) if args.tel is None: tel_loop = tels else: if args.tel not in tels: continue tel_loop = [args.tel] log.debug(tels) for tel_id in tel_loop: display_telescope(event, tel_id, args.display, geom_dict, pp, fig) if pp is not None: pp.close() log.info("[COMPLETE]")
else: continue else: plt.pause(0.1) elif ello == 'q': return None print("Total NEVT", nt) if __name__ == '__main__': # Declare and parse command line option parser = argparse.ArgumentParser( description='Tel_id, pixel id and number of event to compute.') parser.add_argument('--f', dest='filename', default=get_path('gamma_test.simtel.gz'), required=False, help='filename <MC file name>') parser.add_argument('--d', dest='display', action='store_true', required=False, help='display the camera events') args = parser.parse_args() if args.display: plt.show(block=False) # Function description of camera_calibration options, given here # Integrator: samples integration algorithm (equivalent to hessioxxx # option --integration-sheme) # -options: full_integration, # simple_integration, # global_peak_integration, # local_peak_integration,
from astropy.io import fits from scipy.interpolate import RegularGridInterpolator from ctapipe.utils.datasets import get_path from ctapipe.utils import Histogram if __name__ == '__main__': # Load an example datacube (an energy table generated for a # small subset of HESS simulations) to use as a lookup table. Here # we will use the Histogram class, which automatically loads both # the data cube and creates arrays for the coordinates of each # axis. testfile = get_path("hess_ct001_energylut.fits.gz") energy_hdu = fits.open(testfile)['MEAN'] energy_table = Histogram(initFromFITS=energy_hdu) print(energy_table) # Now, construct an interpolator that we can use to get values at # any point: centers = [energy_table.binCenters(ii) for ii in range(energy_table.ndims)] energy_lookup = RegularGridInterpolator(centers, energy_table.hist, bounds_error=False,fill_value=-100) # energy_lookup is now just a continuous function of log(SIZE), # DISTANCE in m. We can now plot some curves from the # interpolator. # # Note that the LUT we used is does not have very high statistics,
def initialize(self, argv=None): self.log.info("Initializing the calibration pipeline...") # Declare and parse command line option parser = argparse.ArgumentParser( description='Display each event in the file') parser.add_argument('-f', '--file', dest='input_path', action='store', default=get_path('gamma_test.simtel.gz'), help='path to the input file. ' ' Default = gamma_test.simtel.gz') parser.add_argument('-O', '--origin', dest='origin', action='store', default='hessio', help='origin of the file: {}. ' 'Default = hessio' .format(origin_list())) parser.add_argument('-D', dest='display', action='store_true', default=False, help='display the camera events') parser.add_argument('--pdf', dest='output_path', action='store', default=None, help='path to store a pdf output of the plots') parser.add_argument('-t', '--telescope', dest='tel', action='store', type=int, default=None, help='telecope to view. Default = All') calibration_arguments(parser) logger_detail = parser.add_mutually_exclusive_group() logger_detail.add_argument('-q', '--quiet', dest='quiet', action='store_true', default=False, help='Quiet mode') logger_detail.add_argument('-v', '--verbose', dest='verbose', action='store_true', default=False, help='Verbose mode') logger_detail.add_argument('-d', '--debug', dest='debug', action='store_true', default=False, help='Debug mode') self.args = parser.parse_args() self.params = calibration_parameters(self.args) if self.args.quiet: self.log.setLevel(40) if self.args.verbose: self.log.setLevel(20) if self.args.debug: self.log.setLevel(10) self.log.debug("[file] Reading file") input_file = InputFile(self.args.input_path, self.args.origin) self.source = input_file.read() # geom_dict is a dictionary of CameraGeometry, with keys of # (num_pixels, focal_length), the parameters that are used to guess the # geometry of the telescope. By using these keys, the geometry is # calculated only once per telescope type as needed, reducing # computation time. # Creating a geom_dict at this point is optional, but is recommended, # as the same geom_dict can then be shared between the calibration and # CameraPlotter, again reducing computation time. # The dictionary becomes filled as a result of a dictionary's mutable # nature.def display_telescope(event, tel_id, display, # geom_dict, pp, fig): self.geom_dict = {}