class Comparer(Tool):
name = "Comparer"
description = "Compare between two files to check the " \
"waveforms are identical."
path1 = Unicode("", help="Path to a first file.").tag(config=True)
path2 = Unicode("", help="Path to a second file.").tag(config=True)
aliases = Dict(
dict(
p1='Comparer.path1',
p2='Comparer.path2',
max_events='TargetioFileReader.max_events',
))
classes = List([
TargetioFileReader,
TargetioR1Calibrator,
])
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.reader1 = None
self.reader2 = None
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
kwargs = dict(config=self.config, tool=self)
if not self.path1 or not self.path2:
raise FileNotFoundError("Both paths need to be set")
self.reader1 = TargetioFileReader(**kwargs, input_path=self.path1)
self.reader2 = TargetioFileReader(**kwargs, input_path=self.path2)
assert self.reader1.num_events == self.reader2.num_events
def start(self):
n_events = self.reader1.num_events
source1 = self.reader1.read()
source2 = self.reader2.read()
desc = "Looping through both files"
for ev in trange(n_events, desc=desc):
event1 = self.reader1.get_event(ev)
event2 = self.reader2.get_event(ev)
samples1 = event1.r1.tel[0].pe_samples
samples2 = event2.r1.tel[0].pe_samples
if (samples1 == 0).all():
samples1 = event1.r0.tel[0].adc_samples
if (samples2 == 0).all():
samples2 = event1.r0.tel[0].adc_samples
np.testing.assert_almost_equal(samples1, samples2, 1)
self.log.info("All events match!")
def finish(self):
pass
class FWInvestigator(Tool):
name = "FWInvestigator"
description = "Investigate the FW"
aliases = Dict(dict())
classes = List([])
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.reader = None
self.dl0 = None
self.dl1 = None
self.fitter = None
self.dead = None
self.fw_calibrator = None
directory = join(realpath(dirname(__file__)), "../targetpipe/io")
self.fw_txt_path = join(directory, "FW.txt")
self.fw_storage_path = join(directory, "FW.h5")
self.fw_storage_path_spe = join(directory, "FW_spe_LS62.h5")
self.spe_fw = 1210
self.p_attenuation = None
self.p_pe = None
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
kwargs = dict(config=self.config, tool=self)
filepath = '/Volumes/gct-jason/data/170314/spe/Run00073_r1_adc.tio'
self.reader = TargetioFileReader(input_path=filepath, **kwargs)
cleaner = CHECMWaveformCleanerAverage(**kwargs)
extractor = AverageWfPeakIntegrator(**kwargs)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(extractor=extractor,
cleaner=cleaner,
**kwargs)
self.fitter = CHECMSPEFitter(**kwargs)
self.fitter.range = [-30, 160]
self.dead = Dead()
self.fw_calibrator = FWCalibrator(**kwargs)
script = "filter_wheel"
self.p_attenuation = Scatter(**kwargs, script=script, figure_name="attenuation")
self.p_pe = Scatter(**kwargs, script=script, figure_name="pe")
# self.p_tmspe = TMSPEFitPlotter(**kwargs, script=script, figure_name="spe_fit_tm24")
# self.p_tmspe_pe = TMSPEFitPlotter(**kwargs, script=script, figure_name="spe_fit_tm24_pe")
# self.p_adc2pe = ADC2PEPlotter(**kwargs, script=script, figure_name="adc2pe", shape='wide')
# self.p_adc2pe_1100tm = ADC2PE1100VTMPlotter(**kwargs, script=script, figure_name="adc2pe_1100V_tms", shape='wide')
# self.p_adc2pe_1100tm_stats = ADC2PE1100VTMStatsPlotter(**kwargs, script=script, figure_name="adc2pe_1100V_tms_stats", shape='wide')
def start(self):
n_events = self.reader.num_events
first_event = self.reader.get_event(0)
telid = list(first_event.r0.tels_with_data)[0]
n_pixels, n_samples = first_event.r1.tel[telid].pe_samples[0].shape
dl1 = np.zeros((n_events, n_pixels))
lambda_ = np.zeros(n_pixels)
source = self.reader.read()
desc = "Looping through file"
for event in tqdm(source, total=n_events, desc=desc):
index = event.count
self.dl0.reduce(event)
self.dl1.calibrate(event)
dl1[index] = event.dl1.tel[telid].image
desc = "Fitting pixels"
for pix in trange(n_pixels, desc=desc):
if not self.fitter.apply(dl1[:, pix]):
self.log.warning("Pixel {} couldn't be fit".format(pix))
continue
lambda_[pix] = self.fitter.coeff['lambda_']
lambda_ = self.dead.mask1d(lambda_)
avg_lamda = np.mean(lambda_)
columns = ['position', 'attenuation_mean', 'attenuation_rms']
df = pd.read_table(self.fw_txt_path, sep=' ', names=columns, usecols=[0, 1, 2], skiprows=1)
df = df.groupby('position').apply(np.mean)
self.fw_calibrator.df = df
self.fw_calibrator.save(self.fw_storage_path)
self.fw_calibrator.set_calibration(self.spe_fw, avg_lamda)
df = self.fw_calibrator.df
x = df['position']
y = df['attenuation_mean']
y_err = df['attenuation_rms']
self.p_attenuation.create(x, y, y_err, '', "Postion", "Attenuation", "Filter Wheel Attenuation")
x = df['position']
y = df['pe']
y_err = df['pe_err']
self.p_pe.create(x, y, y_err, '', "Postion", "Illumination (p.e.)", "Filter Wheel Calibrated")
self.p_pe.ax.set_yscale('log')
self.p_pe.ax.get_yaxis().set_major_formatter(FuncFormatter(lambda y, _: '{:g}'.format(y)))
def finish(self):
# Save figures
self.p_attenuation.save()
self.p_pe.save()
self.fw_calibrator.save(self.fw_storage_path_spe)
class ADC2PEPlots(Tool):
name = "ADC2PEPlots"
description = "Create plots related to adc2pe"
aliases = Dict(dict(max_events='TargetioFileReader.max_events'))
classes = List([
TargetioFileReader,
TargetioR1Calibrator,
])
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.reader = None
self.reader_pe = None
self.dl0 = None
self.dl1 = None
self.fitter = None
self.fitter_pe = None
self.dead = None
self.n_pixels = None
self.n_samples = None
self.spe_path = "/Volumes/gct-jason/data/170314/spe/Run00073_r0/extract_spe/spe.npy"
self.gm_path = "/Volumes/gct-jason/data/170310/hv/gain_matching_coeff.npz"
self.p_pixelspe = None
self.p_tmspe = None
self.p_tmspe_pe = None
self.p_adc2pe = None
self.p_adc2pe_1100tm = None
self.p_adc2pe_1100tm_stats = None
self.p_eped = None
self.p_eped_sigma = None
self.p_spe = None
self.p_spe_sigma = None
self.p_lambda = None
self.p_enf = None
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
kwargs = dict(config=self.config, tool=self)
filepath = '/Volumes/gct-jason/data/170314/spe/Run00073_r1_adc.tio'
self.reader = TargetioFileReader(input_path=filepath, **kwargs)
filepath = '/Volumes/gct-jason/data/170314/spe/Run00073_r1.tio'
self.reader_pe = TargetioFileReader(input_path=filepath, **kwargs)
cleaner = CHECMWaveformCleanerAverage(**kwargs)
extractor = AverageWfPeakIntegrator(**kwargs)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(extractor=extractor,
cleaner=cleaner,
**kwargs)
self.fitter = CHECMSPEFitter(**kwargs)
self.fitter.range = [-30, 160]
self.fitter_pe = CHECMSPEFitter(**kwargs)
self.fitter_pe.range = [-1, 6]
self.fitter_pe.initial = dict(norm=None,
eped=0,
eped_sigma=0.2,
spe=1,
spe_sigma=0.5,
lambda_=0.2)
self.dead = Dead()
script = "checm_paper_adc2pe"
self.p_pixelspe = PixelSPEFitPlotter(**kwargs,
script=script,
figure_name="spe_fit_pixel1559")
self.p_tmspe = TMSPEFitPlotter(**kwargs,
script=script,
figure_name="spe_fit_tm24")
self.p_tmspe_pe = TMSPEFitPlotter(**kwargs,
script=script,
figure_name="spe_fit_tm24_pe")
self.p_adc2pe = ADC2PEPlotter(**kwargs,
script=script,
figure_name="adc2pe",
shape='square')
self.p_adc2pe_1100tm = ADC2PE1100VTMPlotter(
**kwargs,
script=script,
figure_name="adc2pe_1100V_tms",
shape='wide')
self.p_adc2pe_1100tm_stats = ADC2PE1100VTMStatsPlotter(
**kwargs,
script=script,
figure_name="adc2pe_1100V_tms_stats",
shape='wide')
self.p_eped = Hist(**kwargs,
script=script,
figure_name="f_eped",
shape='square')
self.p_eped_sigma = Hist(**kwargs,
script=script,
figure_name="f_eped_sigma",
shape='square')
self.p_spe = Hist(**kwargs,
script=script,
figure_name="f_spe",
shape='square')
self.p_spe_sigma = Hist(**kwargs,
script=script,
figure_name="f_spe_sigma",
shape='square')
self.p_lambda = Hist(**kwargs,
script=script,
figure_name="f_lambda",
shape='square')
self.p_enf = Hist(**kwargs,
script=script,
figure_name="f_enf",
shape='square')
def start(self):
n_events = self.reader.num_events
first_event = self.reader.get_event(0)
telid = list(first_event.r0.tels_with_data)[0]
n_pixels, n_samples = first_event.r1.tel[telid].pe_samples[0].shape
### SPE values from fit _______________________________________________
# Prepare storage array
dl1 = np.zeros((n_events, n_pixels))
dl1_pe = np.zeros((n_events, n_pixels))
hist_pix1559 = None
edges_pix1559 = None
between_pix1559 = None
fit_pix1559 = None
fitx_pix1559 = None
hist_tm24 = np.zeros((64, self.fitter.nbins))
edges_tm24 = np.zeros((64, self.fitter.nbins + 1))
between_tm24 = np.zeros((64, self.fitter.nbins))
hist_tm24_pe = np.zeros((64, self.fitter.nbins))
edges_tm24_pe = np.zeros((64, self.fitter.nbins + 1))
between_tm24_pe = np.zeros((64, self.fitter.nbins))
f_eped = np.zeros(n_pixels)
f_eped_sigma = np.zeros(n_pixels)
f_spe = np.zeros(n_pixels)
f_spe_sigma = np.zeros(n_pixels)
f_lambda = np.zeros(n_pixels)
source = self.reader.read()
desc = "Looping through file"
for event in tqdm(source, total=n_events, desc=desc):
index = event.count
self.dl0.reduce(event)
self.dl1.calibrate(event)
dl1[index] = event.dl1.tel[telid].image
source = self.reader_pe.read()
desc = "Looping through file (pe)"
for event in tqdm(source, total=n_events, desc=desc):
index = event.count
self.dl0.reduce(event)
self.dl1.calibrate(event)
dl1_pe[index] = event.dl1.tel[telid].image
desc = "Fitting pixels"
for pix in trange(n_pixels, desc=desc):
tm = pix // 64
tmpix = pix % 64
if not self.fitter.apply(dl1[:, pix]):
self.log.warning("Pixel {} couldn't be fit".format(pix))
continue
if pix == 1559:
hist_pix1559 = self.fitter.hist
edges_pix1559 = self.fitter.edges
between_pix1559 = self.fitter.between
fit_pix1559 = self.fitter.fit
fitx_pix1559 = self.fitter.fit_x
if tm == 24:
hist_tm24[tmpix] = self.fitter.hist
edges_tm24[tmpix] = self.fitter.edges
between_tm24[tmpix] = self.fitter.between
f_eped[pix] = self.fitter.coeff['eped']
f_eped_sigma[pix] = self.fitter.coeff['eped_sigma']
f_spe[pix] = self.fitter.coeff['spe']
f_spe_sigma[pix] = self.fitter.coeff['spe_sigma']
f_lambda[pix] = self.fitter.coeff['lambda_']
f_eped = checm_dac_to_volts(f_eped)
f_eped_sigma = checm_dac_to_volts(f_eped_sigma)
f_spe = checm_dac_to_volts(f_spe)
f_spe_sigma = checm_dac_to_volts(f_spe_sigma)
f_eped = self.dead.mask1d(f_eped).compressed()
f_eped_sigma = self.dead.mask1d(f_eped_sigma).compressed()
f_spe = self.dead.mask1d(f_spe).compressed()
f_spe_sigma = self.dead.mask1d(f_spe_sigma).compressed()
f_lambda = self.dead.mask1d(f_lambda).compressed()
edges_pix1559 = checm_dac_to_volts(edges_pix1559)
between_pix1559 = checm_dac_to_volts(between_pix1559)
fitx_pix1559 = checm_dac_to_volts(fitx_pix1559)
edges_tm24 = checm_dac_to_volts(edges_tm24)
between_tm24 = checm_dac_to_volts(edges_tm24)
desc = "Fitting pixels (pe)"
for pix in trange(n_pixels, desc=desc):
tm = pix // 64
tmpix = pix % 64
if tm != 24:
continue
if not self.fitter_pe.apply(dl1_pe[:, pix]):
self.log.warning("Pixel {} couldn't be fit".format(pix))
continue
hist_tm24_pe[tmpix] = self.fitter_pe.hist
edges_tm24_pe[tmpix] = self.fitter_pe.edges
between_tm24_pe[tmpix] = self.fitter_pe.between
### SPE values for each hv setting ____________________________________
kwargs = dict(config=self.config,
tool=self,
spe_path=self.spe_path,
gain_matching_path=self.gm_path)
a2p = TargetioADC2PECalibrator(**kwargs)
hv_dict = dict()
hv_dict['800'] = [800] * 2048
hv_dict['900'] = [900] * 2048
hv_dict['1000'] = [1000] * 2048
hv_dict['1100'] = [1100] * 2048
hv_dict['800gm'] = [a2p.gm800[i // 64] for i in range(2048)]
hv_dict['900gm'] = [a2p.gm900[i // 64] for i in range(2048)]
hv_dict['1000gm'] = [a2p.gm1000[i // 64] for i in range(2048)]
df_list = []
for key, l in hv_dict.items():
hv = int(key.replace("gm", ""))
gm = 'gm' in key
gm_t = 'Gain-matched' if 'gm' in key else 'Non-gain-matched'
for pix in range(n_pixels):
if pix in self.dead.dead_pixels:
continue
adc2pe = a2p.get_adc2pe_at_hv(l[pix], pix)
df_list.append(
dict(key=key,
hv=hv,
gm=gm,
gm_t=gm_t,
pixel=pix,
tm=pix // 64,
spe=1 / adc2pe))
df = pd.DataFrame(df_list)
df = df.sort_values(by='gm', ascending=True)
df = df.assign(spe_mv=checm_dac_to_volts(df['spe']))
# Create figures
self.p_pixelspe.create(hist_pix1559, edges_pix1559, between_pix1559,
fit_pix1559, fitx_pix1559)
self.p_tmspe.create(hist_tm24, edges_tm24, between_tm24, "V ns")
self.p_tmspe_pe.create(hist_tm24_pe, edges_tm24_pe, between_tm24_pe,
"p.e.", 1)
self.p_adc2pe.create(df)
self.p_adc2pe_1100tm.create(df)
self.p_adc2pe_1100tm_stats.create(df)
self.p_eped.create(f_eped, "Pedestal (V ns)")
self.p_eped_sigma.create(f_eped_sigma, "Pedestal Sigma (V ns)")
self.p_spe.create(f_spe, "SPE (V ns)")
self.p_spe_sigma.create(f_spe_sigma, "SPE Sigma (V ns)")
self.p_lambda.create(f_lambda, "Illumination (Photoelectrons)")
enf = np.sqrt(f_spe_sigma**2 - f_eped_sigma**2) / f_spe
self.p_enf.create(enf, "Relative SPE Width")
def finish(self):
# Save figures
self.p_pixelspe.save()
self.p_tmspe.save()
self.p_tmspe_pe.save()
self.p_adc2pe.save()
self.p_adc2pe_1100tm.save()
self.p_adc2pe_1100tm_stats.save()
self.p_eped.save()
self.p_eped_sigma.save()
self.p_spe.save()
self.p_spe_sigma.save()
self.p_lambda.save()
self.p_enf.save()
class R0R1Comparer(Tool):
name = "R0R1Comparer"
description = "Compare between an r0 and r1 file to check the " \
"calibration applied is identical."
r0_path = Unicode("", help="Path to an r0 file.").tag(config=True)
r1_path = Unicode("", help="Path to an r1 file.").tag(config=True)
aliases = Dict(
dict(
r0='R0R1Comparer.r0_path',
r1='R0R1Comparer.r1_path',
max_events='TargetioFileReader.max_events',
ped='TargetioR1Calibrator.pedestal_path',
tf='TargetioR1Calibrator.tf_path',
pe='TargetioR1Calibrator.pe_path',
))
classes = List([
TargetioFileReader,
TargetioR1Calibrator,
])
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.reader_r0 = None
self.reader_r1 = None
self.r1 = None
self.dl0 = None
self.dl1 = None
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
kwargs = dict(config=self.config, tool=self)
if not self.r0_path or not self.r1_path:
raise FileNotFoundError("Both r0 and r1 paths need to be set")
self.reader_r0 = TargetioFileReader(**kwargs, input_path=self.r0_path)
self.reader_r1 = TargetioFileReader(**kwargs, input_path=self.r1_path)
self.r1 = TargetioR1Calibrator(**kwargs)
assert self.reader_r0.num_events == self.reader_r1.num_events
def start(self):
n_events = self.reader_r0.num_events
source_r0 = self.reader_r0.read()
source_r1 = self.reader_r1.read()
desc = "Looping through both files"
for ev in trange(n_events, desc=desc):
event_r0 = self.reader_r0.get_event(ev)
event_r1 = self.reader_r1.get_event(ev)
self.r1.calibrate(event_r0)
self.r1.calibrate(event_r1)
samples_r0 = event_r0.r1.tel[0].pe_samples
samples_r1 = event_r1.r1.tel[0].pe_samples
np.testing.assert_almost_equal(samples_r0, samples_r1, 1)
self.log.info("All events match!")
def finish(self):
pass
class FitComparer(Tool):
name = "ADC2PEPlots"
description = "Create plots related to adc2pe"
aliases = Dict(dict(max_events='TargetioFileReader.max_events'))
classes = List([
TargetioFileReader,
])
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.reader_uncal = None
self.reader_cal = None
self.dl0 = None
self.dl1 = None
self.dead = None
self.fitter_uncal = None
self.fitter_cal = None
self.n_pixels = None
self.n_samples = None
self.path_uncal = "/Volumes/gct-jason/data/170314/spe/Run00073_r1_adc.tio"
self.path_cal = "/Volumes/gct-jason/data/170314/spe/Run00073_r1.tio"
self.p_comparison = None
self.p_tmspread = None
self.p_dist = None
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 start(self):
n_events = self.reader_uncal.num_events
dl1_uncal = np.zeros((n_events, self.n_pixels))
dl1_cal = np.zeros((n_events, self.n_pixels))
source_uncal = self.reader_uncal.read()
desc = 'Looping through events: uncal'
for event in tqdm(source_uncal, total=n_events, desc=desc):
ev = event.count
self.dl0.reduce(event)
self.dl1.calibrate(event)
dl1_uncal[ev] = event.dl1.tel[0].image[0]
source_cal = self.reader_cal.read()
desc = 'Looping through events: cal'
for event in tqdm(source_cal, total=n_events, desc=desc):
ev = event.count
self.dl0.reduce(event)
self.dl1.calibrate(event)
dl1_cal[ev] = event.dl1.tel[0].image[0]
# np.save("/Users/Jason/Downloads/dl1_uncal.npy", dl1_uncal)
# np.save("/Users/Jason/Downloads/dl1_cal.npy", dl1_cal)
#
# dl1_uncal = np.load("/Users/Jason/Downloads/dl1_uncal.npy")
# dl1_cal = np.load("/Users/Jason/Downloads/dl1_cal.npy")
for pix in range(self.n_pixels):
if not self.fitter_uncal.apply(dl1_uncal[:, pix]):
self.log.warning("Pixel {} couldn't be fit".format(pix))
continue
if not self.fitter_cal.apply(dl1_cal[:, pix]):
self.log.warning("Pixel {} couldn't be fit".format(pix))
continue
gain_uncal = self.fitter_uncal.coeff['spe']
gain_cal = self.fitter_cal.coeff['spe']
lambda_uncal = self.fitter_uncal.coeff['lambda_']
lambda_cal = self.fitter_cal.coeff['lambda_']
print("Pixel {}: Gain Uncal {:.3} Gain Cal {:.3} "
"Lambda Uncal {:.3} Lambda Cal {:.3}".format(
pix, gain_uncal, gain_cal, lambda_uncal, lambda_cal))
def finish(self):
pass
class TargetCalibPedestalExplorer(Tool):
name = "TargetCalibPedestalExplorer"
description = "Plot the TargetCalib pedestal using bokeh"
input_path = Unicode(None,
allow_none=True,
help='Path to the input file containing '
'events.').tag(config=True)
ped_stddev_path = Unicode(None,
allow_none=True,
help='Path to the stddev numpy file created by '
'generate_pedestal.py').tag(config=True)
aliases = Dict(
dict(f='TargetCalibPedestalExplorer.input_path',
max_events='TargetioFileReader.max_events',
P='PedestalSubtractor.pedestal_path',
stddev='TargetCalibPedestalExplorer.ped_stddev_path'))
classes = List([TargetioFileReader, PedestalSubtractor])
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.file_reader = None
self.extractor = None
self.calibrator = None
self.plotter = None
self.ped = None
self.p_cellspread = None
self.p_pixelspread = None
self.p_pedselect = None
self.p_devcellspread = None
self.p_devpixelspread = None
self.p_respixelspread = None
self.p_rescameraspread = None
self.p_reseventspread = None
self.p_resselect = None
self.layout = None
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
kwargs = dict(config=self.config, tool=self)
# Bypass error message when input_path is None
if self.input_path is not None:
self.file_reader = TargetioFileReader(**kwargs,
input_path=self.input_path)
self.ped = PedestalSubtractor(**kwargs)
self.p_cellspread = PedCellSpread(**kwargs)
self.p_pixelspread = PedPixelSpread(**kwargs)
self.p_pedselect = PedSelector(**kwargs)
self.p_devcellspread = StddevCellSpread(**kwargs)
self.p_devpixelspread = StddevPixelSpread(**kwargs)
self.p_respixelspread = ResidualPixelSpread(**kwargs)
self.p_rescameraspread = ResidualCameraSpread(**kwargs)
self.p_reseventspread = ResidualEventSpread(**kwargs)
self.p_resselect = ResidualSelector(**kwargs)
def start(self):
# Get Ped
ped = self.ped.get_ped()
# Get Ped Stddev
ped_stddev = None
if self.ped_stddev_path:
self.log.info("Loading pedestal stddev file: {}".format(
self.ped_stddev_path))
ped_stddev = np.load(self.ped_stddev_path)
# Get Events
residuals = None
cells = None
n_modules = None
n_cells = None
pixel_pos = None
foclen = None
if self.file_reader:
n_events = self.file_reader.num_events
first_event = self.file_reader.get_event(0)
first_wf = first_event.r0.tel[0].adc_samples[0]
n_pix, n_samples = first_wf.shape
n_modules = first_event.meta['n_modules']
n_cells = first_event.meta['n_cells']
pixel_pos = first_event.inst.pixel_pos[0]
foclen = first_event.inst.optical_foclen[0]
residuals = np.zeros((n_events, n_pix, n_samples),
dtype=np.float32)
cells = np.zeros((n_events, n_pix, n_samples))
source = self.file_reader.read()
for event in source:
index = event.count
self.ped.apply(event, residuals[index])
fci = event.r0.tel[0].first_cell_ids
cells[index] = (np.arange(n_samples)[None, :] +
fci[:, None]) % n_cells
# TEMP!!!!!!!! Remove channel 4
# ped[0, 4] = 0
# # Mask zero values
# ped = np.ma.masked_where(ped == 0, ped)
# mask_3d = ped.mask
# if mask_3d:
# mask_3d = np.zeros(ped.shape, dtype=bool)
# shape_2d = [mask_3d.shape[0] * mask_3d.shape[1], mask_3d.shape[2]]
# mask_2d = mask_3d.reshape(shape_2d)
# if ped_stddev is not None:
# ped_stddev = np.ma.masked_array(ped_stddev, mask_2d)
# Create bokeh figures
self.p_cellspread.create(ped)
self.p_pixelspread.create(ped)
self.p_pedselect.create(ped, ped_stddev)
if ped_stddev is not None:
self.p_devcellspread.create(ped_stddev)
self.p_devpixelspread.create(ped_stddev)
if residuals is not None:
self.p_respixelspread.create(residuals)
self.p_rescameraspread.create(residuals, pixel_pos, foclen)
self.p_reseventspread.create(residuals)
self.p_resselect.create(residuals, cells, n_modules, n_cells)
# Get bokeh layouts
l_cellspread = self.p_cellspread.layout
l_pixelspread = self.p_pixelspread.layout
l_pedselect = self.p_pedselect.layout
l_devcellspread = self.p_devcellspread.layout
l_devpixelspread = self.p_devpixelspread.layout
l_respixelspread = self.p_respixelspread.layout
l_rescameraspread = self.p_rescameraspread.layout
l_reseventspread = self.p_reseventspread.layout
l_resselect = self.p_resselect.layout
# Get widgets
# Layout
layout_list = [[l_cellspread], [l_pixelspread], [l_pedselect]]
if ped_stddev is not None:
layout_list.append([l_devcellspread])
layout_list.append([l_devpixelspread])
if residuals is not None:
layout_list.append([l_respixelspread])
layout_list.append([l_rescameraspread])
layout_list.append([l_reseventspread])
layout_list.append([l_resselect])
self.layout = layout(layout_list, sizing_mode="scale_width")
def finish(self):
curdoc().add_root(self.layout)
curdoc().title = "Pedestal"
class FFGenerator(Tool):
name = "FFGenerator"
description = "Generate Flat Fielding file"
aliases = Dict(dict())
classes = List([])
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.reader = None
self.dl0 = None
self.dl1 = None
self.fitter = None
self.dead = None
self.fw_calibrator = None
self.cfmaker = None
self.fw_pos = 2250
directory = join(realpath(dirname(__file__)), "../adc2pe")
self.output_path = join(directory, "ff.tcal")
if not exists(directory):
self.log.info("Creating directory: {}".format(directory))
makedirs(directory)
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
kwargs = dict(config=self.config, tool=self)
filepath = '/Volumes/gct-jason/data/170319/linearity/linearity/Run03991_r1_pe.tio'
# filepath = '/Volumes/gct-jason/data/170320/linearity/Run04164_r1_pe.tio'
self.reader = TargetioFileReader(input_path=filepath, **kwargs)
cleaner = CHECMWaveformCleanerAverage(**kwargs)
extractor = AverageWfPeakIntegrator(**kwargs)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(extractor=extractor,
cleaner=cleaner,
**kwargs)
self.dead = Dead()
self.fw_calibrator = FWCalibrator(**kwargs)
self.cfmaker = CfMaker(32)
def start(self):
n_events = self.reader.num_events
first_event = self.reader.get_event(0)
telid = list(first_event.r0.tels_with_data)[0]
n_pixels, n_samples = first_event.r1.tel[telid].pe_samples[0].shape
dl1 = np.zeros((n_events, n_pixels))
ff = np.zeros(n_pixels)
fw_illumination = self.fw_calibrator.get_illumination(self.fw_pos)
source = self.reader.read()
desc = "Looping through file"
for event in tqdm(source, total=n_events, desc=desc):
index = event.count
self.dl0.reduce(event)
self.dl1.calibrate(event)
dl1[index] = event.dl1.tel[telid].image
desc = "Fitting pixels"
for pix in trange(n_pixels, desc=desc):
if pix in self.dead.dead_pixels:
continue
charge = np.mean(dl1[:, pix])
ff[pix] = fw_illumination / charge
self.cfmaker.SetAll(ff.astype(np.float32))
self.cfmaker.Save(self.output_path, False)
self.log.info("FF tcal created: {}".format(self.output_path))
self.cfmaker.Clear()
def finish(self):
pass