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)
r1_factory = CameraR1CalibratorFactory(origin=self.reader.origin,
**kwargs)
r1_class = r1_factory.get_class()
self.r1 = r1_class(**kwargs)
self.dl0 = CameraDL0Reducer(**kwargs)
self.cleaner = CHECMWaveformCleanerAverage(**kwargs)
self.extractor = AverageWfPeakIntegrator(**kwargs)
self.extractor_height = SimpleIntegrator(window_shift=0,
window_width=1,
**kwargs)
self.dl1 = CameraDL1Calibrator(extractor=self.extractor,
cleaner=self.cleaner,
**kwargs)
self.dl1_height = CameraDL1Calibrator(extractor=self.extractor_height,
cleaner=self.cleaner,
**kwargs)
self.dead = Dead()
fitter_factory = ChargeFitterFactory(**kwargs)
fitter_class = fitter_factory.get_class()
self.fitter = fitter_class(**kwargs)
self.n_events = self.reader.num_events
first_event = self.reader.get_event(0)
self.n_pixels = first_event.inst.num_pixels[0]
self.n_samples = first_event.r0.tel[0].num_samples
geom = CameraGeometry.guess(*first_event.inst.pixel_pos[0],
first_event.inst.optical_foclen[0])
self.neighbours2d = get_neighbours_2d(geom.pix_x, geom.pix_y)
# Get stage names
self.stage_names = [
'0: raw', '1: baseline_sub', '2: no_pulse', '3: smooth_baseline',
'4: smooth_wf', '5: cleaned'
]
# Init Plots
self.p_camera_area = Camera(self, self.neighbours2d, "Area", geom)
self.p_camera_fit_gain = Camera(self, self.neighbours2d, "Gain", geom)
self.p_camera_fit_brightness = Camera(self, self.neighbours2d,
"Brightness", geom)
self.p_fitter = FitterWidget(fitter=self.fitter, **kwargs)
self.p_stage_viewer = StageViewer(**kwargs)
self.p_fit_viewer = FitViewer(**kwargs)
self.p_fit_table = FitTable(**kwargs)
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
kwargs = dict(config=self.config, tool=self)
self.reader_uncal = TargetioFileReader(input_path=self.path_uncal,
**kwargs)
self.reader_cal = TargetioFileReader(input_path=self.path_cal,
**kwargs)
cleaner = CHECMWaveformCleanerAverage(**kwargs)
extractor = AverageWfPeakIntegrator(**kwargs)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(extractor=extractor,
cleaner=cleaner,
**kwargs)
self.dead = Dead()
self.fitter_uncal = CHECMSPEFitter(**kwargs)
self.fitter_cal = CHECMSPEFitter(**kwargs)
self.fitter_cal.range = [-3, 6]
self.fitter_cal.initial = dict(norm=None,
eped=0,
eped_sigma=0.2,
spe=1,
spe_sigma=0.5,
lambda_=0.2)
first_event = self.reader_uncal.get_event(0)
telid = list(first_event.r0.tels_with_data)[0]
r1 = first_event.r1.tel[telid].pe_samples[0]
self.n_pixels, self.n_samples = r1.shape
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
kwargs = dict(config=self.config, tool=self)
self.file_looper = TargetioFileLooper(**kwargs)
r1_factory = CameraR1CalibratorFactory(origin='targetio', **kwargs)
r1_class = r1_factory.get_class()
self.r1 = r1_class(**kwargs)
self.cleaner = CHECMWaveformCleanerAverage(**kwargs)
self.extractor = AverageWfPeakIntegrator(**kwargs)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(extractor=self.extractor,
cleaner=self.cleaner,
**kwargs)
self.dead = Dead()
self.fitter_bright = CHECBrightFitter(**kwargs)
fitter_factory = SPEFitterFactory(**kwargs)
fitter_class = fitter_factory.get_class()
self.fitter_spe = fitter_class(**kwargs)
file_reader_list = self.file_looper.file_reader_list
self.n_runs = len(file_reader_list)
first_event = file_reader_list[0].get_event(0)
self.n_pixels = first_event.inst.num_pixels[0]
self.n_samples = first_event.r0.tel[0].num_samples
self.fw_list = self.fw_list[:self.file_looper.num_readers]
assert (self.n_runs == len(self.fw_list))
def test_array_draw():
filename = get_dataset("gamma_test.simtel.gz")
cam_geom = {}
source = hessio_event_source(filename, max_events=2)
r1 = HESSIOR1Calibrator()
dl0 = CameraDL0Reducer()
calibrator = CameraDL1Calibrator()
for event in source:
array_pointing = SkyCoord(
event.mcheader.run_array_direction[1] * u.rad,
event.mcheader.run_array_direction[0] * u.rad,
frame=AltAz)
# array_view = ArrayPlotter(instrument=event.inst,
# system=TiltedGroundFrame(
# pointing_direction=array_pointing))
hillas_dict = {}
r1.calibrate(event)
dl0.reduce(event)
calibrator.calibrate(event) # calibrate the events
# store MC pointing direction for the array
for tel_id in event.dl0.tels_with_data:
pmt_signal = event.dl1.tel[tel_id].image[0]
geom = deepcopy(event.inst.subarray.tel[tel_id].camera)
fl = event.inst.subarray.tel[tel_id].optics.equivalent_focal_length
# Transform the pixels positions into nominal coordinates
camera_coord = CameraFrame(x=geom.pix_x,
y=geom.pix_y,
z=np.zeros(geom.pix_x.shape) * u.m,
focal_length=fl,
rotation=90 * u.deg - geom.cam_rotation)
nom_coord = camera_coord.transform_to(
NominalFrame(array_direction=array_pointing,
pointing_direction=array_pointing))
geom.pix_x = nom_coord.x
geom.pix_y = nom_coord.y
mask = tailcuts_clean(geom,
pmt_signal,
picture_thresh=10.,
boundary_thresh=5.)
try:
moments = hillas_parameters(geom, pmt_signal * mask)
hillas_dict[tel_id] = moments
nom_coord = NominalPlotter(hillas_parameters=hillas_dict,
draw_axes=True)
nom_coord.draw_array()
except HillasParameterizationError as e:
print(e)
continue
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
self.reader = EventSource.from_config(parent=self)
self.seeker = EventSeeker(self.reader, parent=self)
self.extractor = ImageExtractor.from_name(self.extractor_product,
parent=self)
self.dl0 = CameraDL0Reducer(parent=self)
self.dl1 = CameraDL1Calibrator(extractor=self.extractor, parent=self)
self.viewer = BokehEventViewer(parent=self)
# Setup widgets
self.viewer.create()
self.viewer.enable_automatic_index_increment()
self.create_previous_event_widget()
self.create_next_event_widget()
self.create_event_index_widget()
self.create_goto_event_index_widget()
self.create_event_id_widget()
self.create_goto_event_id_widget()
self.create_telid_widget()
self.create_channel_widget()
self.create_dl1_widgets()
self.update_dl1_widget_values()
# Setup layout
self.layout = layout([[self.viewer.layout],
[
self.w_previous_event, self.w_next_event,
self.w_goto_event_index, self.w_goto_event_id
], [self.w_event_index, self.w_event_id],
[self.w_telid, self.w_channel],
[self.wb_extractor]])
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]"
kwargs = dict(config=self.config, tool=self)
reader_factory = EventFileReaderFactory(**kwargs)
reader_class = reader_factory.get_class()
self.reader = reader_class(**kwargs)
extractor_factory = ChargeExtractorFactory(**kwargs)
extractor_class = extractor_factory.get_class()
extractor = extractor_class(**kwargs)
cleaner_factory = WaveformCleanerFactory(**kwargs)
cleaner_class = cleaner_factory.get_class()
cleaner = cleaner_class(**kwargs)
r1_factory = CameraR1CalibratorFactory(origin=self.reader.origin,
**kwargs)
r1_class = r1_factory.get_class()
self.r1 = r1_class(**kwargs)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(extractor=extractor,
cleaner=cleaner,
**kwargs)
def test_integration_correction_no_ref_pulse(example_event):
previous_calibration(example_event)
telid = list(example_event.dl0.tel.keys())[0]
delattr(example_event, 'mc')
calibrator = CameraDL1Calibrator()
correction = calibrator.get_correction(example_event, telid)
assert correction[0] == 1
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
kwargs = dict(config=self.config, tool=self)
for key, path in self.event_path_dict.items():
self.reader_dict[key] = TargetioFileReader(input_path=path,
**kwargs)
cleaner = CHECMWaveformCleanerAverage(**kwargs)
extractor = AverageWfPeakIntegrator(**kwargs)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(extractor=extractor,
cleaner=cleaner,
**kwargs)
self.fitter = CHECBrightFitter(**kwargs)
self.dead = Dead()
first_event = list(self.reader_dict.values())[0].get_event(0)
telid = list(first_event.r0.tels_with_data)[0]
r1 = first_event.r1.tel[telid].pe_samples[0]
self.n_pixels, self.n_samples = r1.shape
script = "checm_paper_adc2pe_application"
self.p_comparison = ADC2PEPlotter(**kwargs,
script=script,
figure_name="adc2pe_comparison",
shape='wide')
self.p_tmspread = TMSpreadPlotter(**kwargs,
script=script,
figure_name="tmspread",
shape='wide')
self.p_dist = GMDistributionPlotter(**kwargs,
script=script,
figure_name="gm_distribution",
shape='wide')
def update_dl1_calibrator(self, extractor=None, cleaner=None):
"""
Recreate the dl1 calibrator with the specified extractor and cleaner
Parameters
----------
extractor : ctapipe.image.charge_extractors.ChargeExtractor
cleaner : ctapipe.image.waveform_cleaning.WaveformCleaner
"""
if extractor is None:
extractor = self.dl1.extractor
if cleaner is None:
cleaner = self.dl1.cleaner
self.extractor = extractor
self.cleaner = cleaner
kwargs = dict(config=self.config, tool=self)
self.dl1 = CameraDL1Calibrator(
extractor=self.extractor,
cleaner=self.cleaner,
**kwargs
)
self.dl1.calibrate(self.event)
self.viewer.refresh()
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)
r1_factory = CameraR1CalibratorFactory(origin=self.reader.origin,
**kwargs)
r1_class = r1_factory.get_class()
self.r1 = r1_class(**kwargs)
self.cleaner = CHECMWaveformCleanerAverage(**kwargs)
self.extractor = AverageWfPeakIntegrator(**kwargs)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(extractor=self.extractor,
cleaner=self.cleaner,
**kwargs)
self.dead = Dead()
fitter_factory = SPEFitterFactory(**kwargs)
fitter_class = fitter_factory.get_class()
self.fitter = fitter_class(**kwargs)
self.output_dir = join(self.reader.output_directory, "extract_spe")
if not exists(self.output_dir):
self.log.info("Creating directory: {}".format(self.output_dir))
makedirs(self.output_dir)
def test_check_dl0_exists(example_event):
telid = 11
previous_calibration(example_event)
calibrator = CameraDL1Calibrator()
assert(calibrator.check_dl0_exists(example_event, telid) is True)
example_event.dl0.tel[telid].waveform = None
assert(calibrator.check_dl0_exists(example_event, telid) is False)
def test_check_dl0_exists():
telid = 11
event = get_test_event()
previous_calibration(event)
calibrator = CameraDL1Calibrator(None, None)
assert(calibrator.check_dl0_exists(event, telid) is True)
event.dl0.tel[telid].pe_samples = None
assert(calibrator.check_dl0_exists(event, telid) is False)
def test_check_dl0_exists(test_event):
event = deepcopy(test_event)
telid = 11
previous_calibration(event)
calibrator = CameraDL1Calibrator()
assert(calibrator.check_dl0_exists(event, telid) is True)
event.dl0.tel[telid].pe_samples = None
assert(calibrator.check_dl0_exists(event, telid) is False)
def cleaner(self, val):
self._cleaner = val
kwargs = dict(config=self.config, tool=self)
self.dl1 = CameraDL1Calibrator(extractor=self.extractor,
cleaner=val,
**kwargs)
self.dl1.calibrate(self.event)
self.viewer.refresh()
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
kwargs = dict(config=self.config, tool=self)
self.fw_calibrator = FWCalibrator(**kwargs)
r1_0320 = TargetioR1Calibrator(pedestal_path='/Volumes/gct-jason/data/170320/pedestal/Run04109_ped.tcal',
tf_path='/Volumes/gct-jason/data/170320/tf/Run04110-04159_tf.tcal',
pe_path='/Users/Jason/Software/CHECAnalysis/targetpipe/adc2pe/adc2pe_1100.tcal',
**kwargs)
r1_0319 = TargetioR1Calibrator(pedestal_path='/Volumes/gct-jason/data/170319/linearity/pedestal/Run04051_ped.tcal',
tf_path='/Volumes/gct-jason/data/170319/linearity/tf/Run04001-04050_tf.tcal',
pe_path='/Users/Jason/Software/CHECAnalysis/targetpipe/adc2pe/adc2pe_1100.tcal',
**kwargs)
dfl = []
base_path = "/Volumes/gct-jason/data/170320/linearity/Run{:05}_r0.tio"
dfl.append(dict(path=base_path.format(4160), type="LS64", cal=True, level=1250, r1=r1_0320))
dfl.append(dict(path=base_path.format(4161), type="LS64", cal=True, level=1450, r1=r1_0320))
dfl.append(dict(path=base_path.format(4162), type="LS64", cal=True, level=1650, r1=r1_0320))
dfl.append(dict(path=base_path.format(4163), type="LS64", cal=True, level=1850, r1=r1_0320))
dfl.append(dict(path=base_path.format(4164), type="LS64", cal=True, level=2050, r1=r1_0320))
dfl.append(dict(path=base_path.format(4165), type="LS64", cal=True, level=2250, r1=r1_0320))
dfl.append(dict(path=base_path.format(4166), type="LS64", cal=True, level=2450, r1=r1_0320))
dfl.append(dict(path=base_path.format(4167), type="LS64", cal=True, level=2650, r1=r1_0320))
dfl.append(dict(path=base_path.format(4168), type="LS64", cal=True, level=2850, r1=r1_0320))
dfl.append(dict(path=base_path.format(4169), type="LS64", cal=True, level=3050, r1=r1_0320))
base_path = "/Volumes/gct-jason/data/170319/linearity/linearity/Run{:05}_r0.tio"
dfl.append(dict(path=base_path.format(3986), type="LS62", cal=True, level=1250, r1=r1_0319))
dfl.append(dict(path=base_path.format(3987), type="LS62", cal=True, level=1450, r1=r1_0319))
dfl.append(dict(path=base_path.format(3988), type="LS62", cal=True, level=1650, r1=r1_0319))
dfl.append(dict(path=base_path.format(3989), type="LS62", cal=True, level=1850, r1=r1_0319))
dfl.append(dict(path=base_path.format(3990), type="LS62", cal=True, level=2050, r1=r1_0319))
dfl.append(dict(path=base_path.format(3991), type="LS62", cal=True, level=2250, r1=r1_0319))
dfl.append(dict(path=base_path.format(3992), type="LS62", cal=True, level=2450, r1=r1_0319))
dfl.append(dict(path=base_path.format(3993), type="LS62", cal=True, level=2650, r1=r1_0319))
dfl.append(dict(path=base_path.format(3994), type="LS62", cal=True, level=2850, r1=r1_0319))
dfl.append(dict(path=base_path.format(3995), type="LS62", cal=True, level=3050, r1=r1_0319))
for d in dfl:
d['reader'] = TargetioFileReader(input_path=d['path'], **kwargs)
self.df_file = pd.DataFrame(dfl)
cleaner = CHECMWaveformCleanerAverage(**kwargs)
extractor = AverageWfPeakIntegrator(**kwargs)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(extractor=extractor,
cleaner=cleaner,
**kwargs)
self.dead = Dead()
self.dummy_event = dfl[0]['reader'].get_event(0)
telid = list(self.dummy_event.r0.tels_with_data)[0]
r1 = self.dummy_event.r1.tel[telid].pe_samples[0]
self.n_pixels, self.n_samples = r1.shape
script = "checm_paper_recovery"
self.p_scatter_pix = Scatter(**kwargs, script=script, figure_name="recovery_lookup")
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):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
kwargs = dict(config=self.config, tool=self)
self.path_dict[
'800'] = '/Volumes/gct-jason/data/170310/hv/Run00904_r1_adc.tio'
self.path_dict[
'900'] = '/Volumes/gct-jason/data/170310/hv/Run00914_r1_adc.tio'
self.path_dict[
'1000'] = '/Volumes/gct-jason/data/170310/hv/Run00924_r1_adc.tio'
self.path_dict[
'1100'] = '/Volumes/gct-jason/data/170310/hv/Run00934_r1_adc.tio'
self.path_dict[
'800gm'] = '/Volumes/gct-jason/data/170319/gainmatching/gainmatched/Run03983_r1_adc.tio'
self.path_dict[
'900gm'] = '/Volumes/gct-jason/data/170319/gainmatching/gainmatched/Run03984_r1_adc.tio'
self.path_dict[
'1000gm'] = '/Volumes/gct-jason/data/170320/linearity/Run04174_r1_adc.tio' #'/Volumes/gct-jason/data/170319/gainmatching/gainmatched/Run03985_r1_adc.tio'
# self.path_dict['800'] = '/Volumes/gct-jason/data/170310/hv/Run00904_r1.tio'
# self.path_dict['900'] = '/Volumes/gct-jason/data/170310/hv/Run00914_r1.tio'
# self.path_dict['1000'] = '/Volumes/gct-jason/data/170310/hv/Run00924_r1.tio'
# self.path_dict['1100'] = '/Volumes/gct-jason/data/170310/hv/Run00934_r1.tio'
# self.path_dict['800gm'] = '/Volumes/gct-jason/data/170319/gainmatching/gainmatched/Run03983_r1.tio'
# self.path_dict['900gm'] = '/Volumes/gct-jason/data/170319/gainmatching/gainmatched/Run03984_r1.tio'
# self.path_dict['1000gm'] = '/Volumes/gct-jason/data/170320/linearity/Run04174_r1.tio'
ped = '/Volumes/gct-jason/data/170310/pedestal/Run00843_ped.tcal'
pedgm = '/Volumes/gct-jason/data/170319/gainmatching/pedestal/Run03932_ped.tcal'
tf = '/Volumes/gct-jason/data/170310/tf/Run00844-00893_tf.tcal'
for key, val in self.path_dict.items():
# p = ped
# if 'gm' in key:
# p = pedgm
# adc2pe = '/Users/Jason/Software/CHECAnalysis/targetpipe/adc2pe/adc2pe_{}.tcal'.format(key)
# self.r1_dict[key] = TargetioR1Calibrator(pedestal_path=p,
# tf_path=tf,
# pe_path='',
# **kwargs)
self.reader_dict[key] = TargetioFileReader(input_path=val,
**kwargs)
cleaner = CHECMWaveformCleanerAverage(**kwargs)
extractor = AverageWfPeakIntegrator(**kwargs)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(extractor=extractor,
cleaner=cleaner,
**kwargs)
self.fitter = CHECBrightFitter(**kwargs)
self.dead = Dead()
first_event = list(self.reader_dict.values())[0].get_event(0)
telid = list(first_event.r0.tels_with_data)[0]
r1 = first_event.r1.tel[telid].pe_samples[0]
self.n_pixels, self.n_samples = r1.shape
def test_camera_dl1_calibrator(example_event):
telid = list(example_event.r0.tel)[0]
previous_calibration(example_event)
calibrator = CameraDL1Calibrator()
assert calibrator.get_correction(example_event, telid) is not None
calibrator.calibrate(example_event)
assert example_event.dl1.tel[telid].image is not None
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):
self.geoms = dict()
if len(self.amp_cut) == 0:
self.amp_cut = {"LSTCam": 92.7,
"NectarCam": 90.6,
"FlashCam": 90.6,
"CHEC": 29.3}
if len(self.dist_cut) == 0:
self.dist_cut = {"LSTCam": 1.74 * u.deg,
"NectarCam": 3. * u.deg,
"FlashCam": 3. * u.deg,
"CHEC": 3.55 * u.deg}
if len(self.tail_cut) == 0:
self.tail_cut = {"LSTCam": (8, 16),
"NectarCam": (7, 14),
"FlashCam": (7, 14),
"CHEC": (3, 6)}
if len(self.pix_cut) == 0:
self.pix_cut = {"LSTCam": 5,
"NectarCam": 4,
"FlashCam": 4,
"CHEC": 4}
# Calibrators set to default for now
self.r1 = HessioR1Calibrator(None, None)
self.dl0 = CameraDL0Reducer(None, None)
self.calibrator = CameraDL1Calibrator(None, None,
extractor=FullIntegrator(None, None))
# If we don't set this just use everything
if len(self.telescopes) < 2:
self.telescopes = None
self.source = hessio_event_source(self.infile,
allowed_tels=self.telescopes,
max_events=self.max_events)
self.fit = HillasIntersection()
self.energy_reco = EnergyRegressor.load("./Aux/{cam_id}.pkl",
["CHEC", "LSTCam", "NectarCam"])
self.ImPACT=ImPACTReconstructor()
self.viewer = EventViewer(draw_hillas_planes=True)
self.output = Table(names=['EVENT_ID', 'RECO_ALT', 'RECO_AZ',
'RECO_EN', 'RECO_ALT_HILLAS',
'RECO_AZ_HILLAS','RECO_EN_HILLAS', 'GOF',
'SIM_ALT', 'SIM_AZ', 'SIM_EN',
'NTELS', 'DIST_CORE'],
dtype=[np.int64, np.float64, np.float64,
np.float64, np.float64, np.float64,
np.float64, np.float64, np.float64,
np.float64, np.float64, np.int16,
np.float64])
def start(self):
n_rundesc = len(self.rundesc_list)
# Prepare storage array
self.charge = np.ma.zeros((n_rundesc, self.n_pixels))
self.charge.mask = np.zeros(self.charge.shape, dtype=np.bool)
self.charge.fill_value = 0
self.charge_err = np.ma.zeros((n_rundesc, self.n_pixels))
self.charge_err.mask = np.zeros(self.charge_err.shape, dtype=np.bool)
self.charge_err.fill_value = 0
telid = 0
desc1 = "Looping over runs"
iterable = enumerate(self.get_next_file())
for fn, fr in tqdm(iterable, total=n_rundesc, desc=desc1):
source = fr.read()
n_events = fr.num_events
area = np.zeros((n_events, self.n_pixels))
desc2 = "Extracting area from events"
for event in tqdm(source, total=n_events, desc=desc2):
ev = event.count
self.r1.calibrate(event)
self.dl0.reduce(event)
kwargs = dict(config=self.config,
tool=self,
extractor=self.extractor,
cleaner=self.cleaner)
dl1 = CameraDL1Calibrator(**kwargs)
dl1.calibrate(event)
# Perform CHECM Charge Extraction
area[ev] = event.dl1.tel[telid].image
desc2 = "Fitting pixels"
for pix in trange(self.n_pixels, desc=desc2):
pixel_area = area[:, pix]
if pix in self.dead.dead_pixels:
continue
if self.calc_mean:
self.charge[fn, pix] = np.mean(pixel_area)
self.charge_err[fn, pix] = np.std(pixel_area)
else:
if not self.fitter.apply(pixel_area):
self.log.warning(
"FN {} Pixel {} could not be fitted".format(
fn, pix))
self.charge.mask[fn, pix] = True
self.charge_err.mask[fn, pix] = True
continue
self.charge[fn, pix] = self.fitter.coeff['mean']
self.charge_err[fn, pix] = self.fitter.coeff['stddev']
self.charge = np.ma.filled(self.dead.mask2d(self.charge))
self.charge_err = np.ma.filled(self.dead.mask2d(self.charge_err))
def test_camera_dl1_calibrator(example_event):
previous_calibration(example_event)
telid = 11
calibrator = CameraDL1Calibrator()
correction = calibrator.get_correction(example_event, telid)
assert_allclose(correction[0], 1.077, 1e-3)
calibrator.calibrate(example_event)
image = example_event.dl1.tel[telid].image
assert_allclose(image[0, 0], -2.216, 1e-3)
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
kwargs = dict(config=self.config, tool=self)
cleaner_factory = WaveformCleanerFactory(**kwargs)
cleaner_class = cleaner_factory.get_class()
self.cleaner = cleaner_class(**kwargs)
reader_factory = EventFileReaderFactory(**kwargs)
reader_class = reader_factory.get_class()
self.reader = reader_class(**kwargs)
extractor_factory = ChargeExtractorFactory(**kwargs)
extractor_class = extractor_factory.get_class()
self.extractor = extractor_class(**kwargs)
r1_factory = CameraR1CalibratorFactory(origin=self.reader.origin,
**kwargs)
r1_class = r1_factory.get_class()
self.r1 = r1_class(**kwargs)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(extractor=self.extractor,
cleaner=self.cleaner,
**kwargs)
self.dead = Dead()
n_events = self.reader.num_events
first_event = self.reader.get_event(0)
r1 = first_event.r1.tel[0].pe_samples[0]
n_pixels, n_samples = r1.shape
self.tack = np.zeros(n_events)
self.sec = np.zeros(n_events)
self.ns = np.zeros(n_events)
self.fci = np.zeros((n_events, n_pixels))
self.charge = np.zeros((n_events, n_pixels))
self.t0 = np.zeros((n_events, n_pixels))
self.baseline_mean_start = np.zeros((n_events, n_pixels))
self.baseline_mean_end = np.zeros((n_events, n_pixels))
self.baseline_mean_full = np.zeros((n_events, n_pixels))
self.baseline_rms_start = np.zeros((n_events, n_pixels))
self.baseline_rms_end = np.zeros((n_events, n_pixels))
self.baseline_rms_full = np.zeros((n_events, n_pixels))
self.peak_time = np.zeros((n_events, n_pixels))
self.fwhm = np.zeros((n_events, n_pixels))
self.rise_time = np.zeros((n_events, n_pixels))
self.n_saturated = np.zeros((n_events, n_pixels))
# Justus:
self.n_1pe = np.zeros((n_events, n_pixels))
self.peak_height = np.zeros((n_events, n_pixels))
def setup(self):
self.geoms = dict()
if len(self.amp_cut) == 0:
self.amp_cut = {
"LSTCam": 92.7,
"NectarCam": 90.6,
"FlashCam": 90.6,
"GATE": 29.3
}
if len(self.dist_cut) == 0:
self.dist_cut = {
"LSTCam": 1.74 * u.deg,
"NectarCam": 3. * u.deg,
"FlashCam": 3. * u.deg,
"GATE": 3.55 * u.deg
}
if len(self.tail_cut) == 0:
self.tail_cut = {
"LSTCam": (8, 16),
"NectarCam": (7, 14),
"FlashCam": (7, 14),
"GATE": (3, 6)
}
if len(self.pix_cut) == 0:
self.pix_cut = {
"LSTCam": 5,
"NectarCam": 4,
"FlashCam": 4,
"GATE": 4
}
# Calibrators set to default for now
self.r1 = HessioR1Calibrator(None, None)
self.dl0 = CameraDL0Reducer(None, None)
self.calibrator = CameraDL1Calibrator(None,
None,
extractor=FullIntegrator(
None, None))
# If we don't set this just use everything
if len(self.telescopes) < 2:
self.telescopes = None
self.source = hessio_event_source(self.infile,
allowed_tels=self.telescopes,
max_events=self.max_events)
self.fit = HillasIntersection()
self.viewer = EventViewer(draw_hillas_planes=True)
self.output = fits.HDUList()
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
self.eventsource = SimTelEventSource(parent=self)
extractor = ImageExtractor.from_name(self.extractor_product,
parent=self)
self.dl0 = CameraDL0Reducer(parent=self)
self.dl1 = CameraDL1Calibrator(extractor=extractor, parent=self)
self.calculator = ChargeResolutionCalculator()
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)
extractor_factory = ChargeExtractorFactory(**kwargs)
extractor_class = extractor_factory.get_class()
self._extractor = extractor_class(**kwargs)
cleaner_factory = WaveformCleanerFactory(**kwargs)
cleaner_class = cleaner_factory.get_class()
self._cleaner = cleaner_class(**kwargs)
r1_factory = CameraR1CalibratorFactory(origin=self.reader.origin,
**kwargs)
r1_class = r1_factory.get_class()
self.r1 = r1_class(**kwargs)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(extractor=self.extractor,
cleaner=self.cleaner,
**kwargs)
self.viewer = EventViewer(**kwargs)
# Setup widgets
self.viewer.create()
self.viewer.enable_automatic_index_increment()
self.create_previous_event_widget()
self.create_next_event_widget()
self.create_event_index_widget()
self.create_goto_event_index_widget()
self.create_event_id_widget()
self.create_goto_event_id_widget()
self.create_telid_widget()
self.create_channel_widget()
self.create_dl1_widgets()
self.update_dl1_widget_values()
# Setup layout
self.layout = layout([[self.viewer.layout],
[
self.w_previous_event, self.w_next_event,
self.w_goto_event_index, self.w_goto_event_id
], [self.w_event_index, self.w_event_id],
[self.w_telid, self.w_channel],
[self.wb_extractor]])
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
kwargs = dict(config=self.config, tool=self)
self.eventsource = SimTelEventSource(**kwargs)
extractor = ChargeExtractorFactory.produce(**kwargs)
self.r1 = HESSIOR1Calibrator(**kwargs)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(extractor=extractor, **kwargs)
self.calculator = ChargeResolutionCalculator(**kwargs)
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 setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
kwargs = dict(config=self.config, tool=self)
eventsource = EventSourceFactory.produce(**kwargs)
self.eventseeker = EventSeeker(eventsource, **kwargs)
self.extractor = ChargeExtractorFactory.produce(**kwargs)
self.r1 = CameraR1CalibratorFactory.produce(eventsource=eventsource,
**kwargs)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(extractor=self.extractor, **kwargs)
