def lst_calibration(event, telescope_id):
"""
Custom lst calibration.
Update event.dl1.tel[telescope_id] with calibrated image and peakpos
Parameters
----------
event: ctapipe event container
telescope_id: int
"""
data = event.r0.tel[telescope_id].waveform
ped = event.mc.tel[telescope_id].pedestal # the pedestal is the
# average (for pedestal events) of the *sum* of all samples,
# from sim_telarray
nsamples = data.shape[2] # total number of samples
# Subtract pedestal baseline. atleast_3d converts 2D to 3D matrix
pedcorrectedsamples = data - np.atleast_3d(ped) / nsamples
integrator = LocalPeakIntegrator(None, None)
integration, peakpos, window = integrator.extract_charge(
pedcorrectedsamples) # these are 2D matrices num_gains * num_pixels
signals = integration.astype(float)
dc2pe = event.mc.tel[telescope_id].dc_to_pe # numgains * numpixels
signals *= dc2pe
event.dl1.tel[telescope_id].image = signals
event.dl1.tel[telescope_id].peakpos = peakpos
def test_local_peak_integration(camera_waveforms):
waveforms, _ = camera_waveforms
integrator = LocalPeakIntegrator()
charge, _, _ = integrator.extract_charge(waveforms)
assert_allclose(charge[0][0], 240.3, rtol=1e-3)
assert_allclose(charge[1][0], 427.158, rtol=1e-3)
def test_local_peak_integration(example_event):
telid = list(example_event.r0.tel)[0]
data = example_event.r0.tel[telid].waveform
nsamples = data.shape[2]
ped = example_event.mc.tel[telid].pedestal
data_ped = data - np.atleast_3d(ped / nsamples)
data_ped = np.array([data_ped[0], data_ped[0]]) # Test LG functionality
integrator = LocalPeakIntegrator()
integration, peakpos, window = integrator.extract_charge(data_ped)
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 test_local_peak_integration(example_event):
telid = 11
data = example_event.r0.tel[telid].waveform
nsamples = data.shape[2]
ped = example_event.mc.tel[telid].pedestal
data_ped = data - np.atleast_3d(ped / nsamples)
data_ped = np.array([data_ped[0], data_ped[0]]) # Test LG functionality
integrator = LocalPeakIntegrator()
integration, peakpos, window = integrator.extract_charge(data_ped)
assert_almost_equal(integration[0][0], 76, 0)
assert_almost_equal(integration[1][0], 76, 0)
assert peakpos[0][0] == 13
assert peakpos[1][0] == 13
def test_local_peak_integration():
telid = 11
event = get_test_event()
data = event.r0.tel[telid].adc_samples
nsamples = data.shape[2]
ped = event.mc.tel[telid].pedestal
data_ped = data - np.atleast_3d(ped/nsamples)
data_ped = np.array([data_ped[0], data_ped[0]]) # Test LG functionality
integrator = LocalPeakIntegrator(None, None)
integration, peakpos, window = integrator.extract_charge(data_ped)
assert_almost_equal(integration[0][0], 76, 0)
assert_almost_equal(integration[1][0], 76, 0)
assert peakpos[0][0] == 13
assert peakpos[1][0] == 13
def get_extractor(self):
return LocalPeakIntegrator(None, self.parent,
window_width=self.window_width,
window_shift=self.window_shift)
from argparse import ArgumentParser
from ctapipe_fact import fact_event_generator
from ctapipe.visualization import CameraDisplay
from ctapipe.instrument import CameraGeometry
from ctapipe.calib.camera import CameraDL1Calibrator
from ctapipe.image.charge_extractors import LocalPeakIntegrator
from ctapipe.image.hillas import hillas_parameters_5 as hillas_parameters
from ctapipe.image.cleaning import tailcuts_clean
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import make_axes_locatable
integrator = LocalPeakIntegrator(config=None, tool=None)
integrator.window_shift = 5
integrator.window_width = 30
dl1_calibrator = CameraDL1Calibrator(
config=None,
tool=None,
extractor=integrator,
)
parser = ArgumentParser()
parser.add_argument('inputfile')
parser.add_argument('drsfile')
def main():
args = parser.parse_args()
event_generator = fact_event_generator(
def get_events(filename,
storedata=False,
concatenate=False,
storeimg=False,
outdir='./results/'):
"""
Read a Simtelarray file, extract pixels charge, calculate image parameters and timing
parameters and store the result in an hdf5 file.
Parameters:
filename: str
Name of the simtelarray file.
storedata: boolean
True: store extracted data in a hdf5 file
concatenate: boolean
True: store the extracted data at the end of an existing file
storeimg: boolean
True: store also pixel data
outdir: srt
Output directory
"""
#Particle type:
particle_type = guess_type(filename)
#Create data frame where DL2 data will be stored:
features = [
'ObsID', 'EvID', 'mcEnergy', 'mcAlt', 'mcAz', 'mcCore_x', 'mcCore_y',
'mcHfirst', 'mcType', 'GPStime', 'width', 'length', 'w/l', 'phi',
'psi', 'r', 'x', 'y', 'intensity', 'skewness', 'kurtosis', 'mcAlttel',
'mcAztel', 'impact', 'mcXmax', 'time_gradient', 'intercept', 'SrcX',
'SrcY', 'disp', 'hadroness'
]
output = pd.DataFrame(columns=features)
#Read LST1 events:
source = EventSourceFactory.produce(
input_url=filename, allowed_tels={1}) #Open Simtelarray file
#Cleaning levels:
level1 = {'LSTCam': 6.}
level2 = level1.copy()
# We use as second cleaning level just half of the first cleaning level
for key in level2:
level2[key] *= 0.5
log10pixelHGsignal = {}
survived = {}
imagedata = np.array([])
for key in level1:
log10pixelHGsignal[key] = []
survived[key] = []
i = 0
for event in source:
if i % 100 == 0:
print("EVENT_ID: ", event.r0.event_id, "TELS: ",
event.r0.tels_with_data, "MC Energy:", event.mc.energy)
i = i + 1
ntels = len(event.r0.tels_with_data)
'''
if i > 100: # for quick tests
break
'''
for ii, tel_id in enumerate(event.r0.tels_with_data):
geom = event.inst.subarray.tel[tel_id].camera #Camera geometry
tel_coords = event.inst.subarray.tel_coords[
event.inst.subarray.tel_indices[tel_id]]
data = event.r0.tel[tel_id].waveform
ped = event.mc.tel[tel_id].pedestal
# the pedestal is the average (for pedestal events) of the *sum* of all samples, from sim_telarray
nsamples = data.shape[2] # total number of samples
pedcorrectedsamples = data - np.atleast_3d(
ped
) / nsamples # Subtract pedestal baseline. atleast_3d converts 2D to 3D matrix
integrator = LocalPeakIntegrator(None, None)
integration, peakpos, window = integrator.extract_charge(
pedcorrectedsamples
) # these are 2D matrices num_gains * num_pixels
chan = 0 # high gain used for now...
signals = integration[chan].astype(float)
dc2pe = event.mc.tel[tel_id].dc_to_pe # numgains * numpixels
signals *= dc2pe[chan]
# Add all individual pixel signals to the numpy array of the corresponding camera inside the log10pixelsignal dictionary
log10pixelHGsignal[str(geom)].extend(
np.log10(signals)
) # This seems to be faster like this, with normal python lists
# Apply image cleaning
cleanmask = tailcuts_clean(geom,
signals,
picture_thresh=level1[str(geom)],
boundary_thresh=level2[str(geom)],
keep_isolated_pixels=False,
min_number_picture_neighbors=1)
survived[str(geom)].extend(
cleanmask
) # This seems to be faster like this, with normal python lists
clean = signals.copy()
clean[
~cleanmask] = 0.0 # set to 0 pixels which did not survive cleaning
if np.max(clean) < 1.e-6: # skip images with no pixels
continue
# Calculate image parameters
hillas = hillas_parameters(
geom,
clean) # this one gives some warnings invalid value in sqrt
foclen = event.inst.subarray.tel[
tel_id].optics.equivalent_focal_length
w = np.rad2deg(np.arctan2(hillas.width, foclen))
l = np.rad2deg(np.arctan2(hillas.length, foclen))
#Calculate Timing parameters
peak_time = units.Quantity(peakpos[chan]) * units.Unit("ns")
timepars = time.timing_parameters(geom.pix_x, geom.pix_y, clean,
peak_time, hillas.psi)
if w >= 0:
if storeimg == True:
if imagedata.size == 0:
imagedata = clean
else:
imagedata = np.vstack([imagedata,
clean]) #Pixel content
width = w.value
length = l.value
phi = hillas.phi.value
psi = hillas.psi.value
r = hillas.r.value
x = hillas.x.value
y = hillas.y.value
intensity = np.log10(hillas.intensity)
skewness = hillas.skewness
kurtosis = hillas.kurtosis
#Store parameters from event and MC:
ObsID = event.r0.obs_id
EvID = event.r0.event_id
mcEnergy = np.log10(event.mc.energy.value *
1e3) #Log10(Energy) in GeV
mcAlt = event.mc.alt.value
mcAz = event.mc.az.value
mcCore_x = event.mc.core_x.value
mcCore_y = event.mc.core_y.value
mcHfirst = event.mc.h_first_int.value
mcType = event.mc.shower_primary_id
mcAztel = event.mcheader.run_array_direction[0].value
mcAlttel = event.mcheader.run_array_direction[1].value
mcXmax = event.mc.x_max.value
GPStime = event.trig.gps_time.value
impact = np.sqrt(
(tel_coords.x.value - event.mc.core_x.value)**2 +
(tel_coords.y.value - event.mc.core_y.value)**2)
time_gradient = timepars[0].value
intercept = timepars[1].value
#Calculate Disp and Source position in camera coordinates
tel = OpticsDescription.from_name(
'LST') #Telescope description
focal_length = tel.equivalent_focal_length.value
sourcepos = transformations.calc_CamSourcePos(
mcAlt, mcAz, mcAlttel, mcAztel, focal_length)
SrcX = sourcepos[0]
SrcY = sourcepos[1]
disp = transformations.calc_DISP(sourcepos[0], sourcepos[1], x,
y)
hadroness = 0
if particle_type == 'proton':
hadroness = 1
eventdf = pd.DataFrame([[
ObsID, EvID, mcEnergy, mcAlt, mcAz, mcCore_x, mcCore_y,
mcHfirst, mcType, GPStime, width, length, width / length,
phi, psi, r, x, y, intensity, skewness, kurtosis, mcAlttel,
mcAztel, impact, mcXmax, time_gradient, intercept, SrcX,
SrcY, disp, hadroness
]],
columns=features)
output = output.append(eventdf, ignore_index=True)
outfile = outdir + particle_type + '_events.hdf5'
if storedata == True:
if concatenate == False or (concatenate == True and
np.DataSource().exists(outfile) == False):
output.to_hdf(outfile, key=particle_type + "_events", mode="w")
if storeimg == True:
f = h5py.File(outfile, 'r+')
f.create_dataset('images', data=imagedata)
f.close()
else:
if storeimg == True:
f = h5py.File(outfile, 'r')
images = f['images']
del f['images']
images = np.vstack([images, imagedata])
f.close()
saved = pd.read_hdf(outfile, key=particle_type + '_events')
output = saved.append(output, ignore_index=True)
output.to_hdf(outfile, key=particle_type + "_events", mode="w")
f = h5py.File(outfile, 'r+')
f.create_dataset('images', data=images)
f.close()
else:
saved = pd.read_hdf(outfile, key=particle_type + '_events')
output = saved.append(output, ignore_index=True)
output.to_hdf(outfile, key=particle_type + "_events", mode="w")
del source
return output
class SPEGenerator(Tool):
name = "SPEGenerator"
description = "Generate the a pickle file of single photo electron spectrum for " \
"either MC or data files."
telescopes = Int(1,help='Telescopes to include from the event file. '
'Default = 1').tag(config=True)
output_name = Unicode('single_photoelectron_spectum',
help='Name of the output SPE hdf5 file '
'file').tag(config=True)
input_path = Unicode(help='Path to input file containing data').tag(config=True)
max_events = Int(1000, help='Maximum number of events to use').tag(config=True)
pixel = Int(1000, allow_none=True, help='Pixel to generate SPE data for').tag(config=True)
aliases = Dict(dict(input_path='SPEGenerator.input_path',
output_name='SPEGenerator.output_name',
max_events='SPEGenerator.max_events',
clip_amplitude='CameraDL1Calibrator.clip_amplitude',
radius='CameraDL1Calibrator.radius',
T='SPEGenerator.telescopes',
p='SPEGenerator.pixel'
))
classes = List([EventSourceFactory,
CameraDL1Calibrator,
CameraCalibrator
])
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.eventsource = None
self.r1 = None
self.dl0 = None
self.dl1 = None
self.cal = None
self.recope12 = np.array([])
self.recope22 = np.array([])
self.recope32 = np.array([])
self.recope42 = np.array([])
self.recope52 = np.array([])
def setup(self):
kwargs = dict(config=self.config, tool=self)
self.r1 = HESSIOR1Calibrator(**kwargs)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(**kwargs)
self.cal = CameraCalibrator()
self.cross = CrossCorrelation()
self.glob_peak = GlobalPeakIntegrator()
self.local_peak = LocalPeakIntegrator()
self.neighbour = NeighbourPeakIntegrator()
self.aver = AverageWfPeakIntegrator()
def start(self):
file_name = "%s" % (self.input_path)
print('opening ', file_name)
try:
print('trying to open file')
source = EventSourceFactory.produce(input_url=file_name, max_events=self.max_events)
for event in tqdm(source):
self.r1.calibrate(event)
self.dl0.reduce(event)
self.dl1.calibrate(event)
# measured_charge = event.dl1.tel[self.telescopes].image[0][self.pixel]
# print(self.glob_peak.extract_charge(event.r1.tel[self.telescopes].waveform)[0][0])
# print(self.glob_peak.extract_charge(event.r1.tel[self.telescopes].waveform)[0][0].shape)
# exit()
# self.recope12 = np.append(self.recope12, max(self.cross._apply_cc(event.r1.tel[self.telescopes].waveform[0][self.pixel])))
# self.recope22 = np.append(self.recope22, self.glob_peak.extract_charge(event.r1.tel[self.telescopes].waveform)[0][0][self.pixel])
self.recope32 = np.append(self.recope32, self.local_peak.extract_charge(event.r1.tel[self.telescopes].waveform)[0][0][self.pixel])
# self.recope42 = np.append(self.recope32, self.aver.extract_charge(event.r1.tel[self.telescopes].waveform)[0][0][self.pixel])
# self.recope52 = np.append(self.recope52, self.neighbour.extract_charge(event.r1.tel[self.telescopes].waveform)[0][0][self.pixel])
except FileNotFoundError:
print('file_not_found')
exit()
def finish(self):
bins2 = np.arange(-0.5, 4, 0.055)
bins = np.arange(-0.5, 4, 0.055)
center = (bins[:-1] + bins[1:]) / 2
fig0 = plt.figure(0)
# ax1 = fig0.add_subplot(141)
# ax2 = fig0.add_subplot(142)
ax3 = fig0.add_subplot(111)
# ax4 = fig0.add_subplot(144)
# ax1.hist(self.recope12, bins=bins2, color='C0', alpha =0.6, label='cross correlation')
# ax1.set_title('cross correlation')
# ax2.hist(self.recope22, bins=bins, color='C1', alpha =0.6, label='global peak')
# ax2.set_title('global peak')
histout = ax3.hist(self.recope32, bins=bins, color='C2', alpha =0.6, label='local peak')
ax3.set_title('local peak')
out_file = open(self.output_name, 'w')
for i in range(len(center)):
out_file.write('%s\t%s\n' % (center[i], histout[0][i]))
out_file.close()
# ax4.hist(self.recope42, bins=bins, color='C3', alpha =0.6, label='average waveform')
# ax4.set_title('average waveform')
plt.show()
# out_file = open(self.output_name, 'w')
# for n,i in enumerate(self.trig_eff_array):
# out_file.write('%s\t%s\n' % (self.disc_array[n], i))
# out_file.close()
print('done')
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/170322/led/Run04345_r0.tio'
self.reader_led = TargetioFileReader(input_path=filepath, **kwargs)
filepath = '/Volumes/gct-jason/data/170320/linearity/Run04167_r0.tio'
self.reader_laser = TargetioFileReader(input_path=filepath, **kwargs)
extractor = LocalPeakIntegrator(**kwargs)
self.r1_led = TargetioR1Calibrator(
pedestal_path=
'/Volumes/gct-jason/data/170322/pedestal/Run04240_ped.tcal',
tf_path='/Volumes/gct-jason/data/170322/tf/Run04277-04327_tf.tcal',
pe_path=
'/Users/Jason/Software/CHECAnalysis/targetpipe/adc2pe/adc2pe_800gm_c1.tcal',
**kwargs,
)
self.r1_laser = 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,
)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(extractor=extractor, **kwargs)
self.dead = Dead()
self.n_events_led = self.reader_led.num_events
first_event = self.reader_led.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
p_kwargs = kwargs
p_kwargs['script'] = "checm_paper_timing"
p_kwargs['figure_name'] = "led_eid_vs_fci"
self.p_led_eidvsfci = Scatter(**p_kwargs, shape='wide')
p_kwargs['figure_name'] = "led_time_vs_tack"
self.p_led_timevstack = Scatter(**p_kwargs, shape='wide')
p_kwargs['figure_name'] = "led_bp_vs_tack"
self.p_led_bpvstack = Hist2D(**p_kwargs, shape='wide')
p_kwargs['figure_name'] = "led_eid_vs_t"
self.p_led_eidvst = Hist2D(**p_kwargs, shape='wide')
p_kwargs['figure_name'] = "led_eid_vs_tgrad"
self.p_led_eidvstgrad = Hist2D(**p_kwargs, shape='wide')
p_kwargs['figure_name'] = "led_t_vs_tgrad"
self.p_led_tvstgrad = Hist2D(**p_kwargs, shape='wide')
p_kwargs['figure_name'] = "led_t_vs_charge"
self.p_led_tvscharge = Hist2D(**p_kwargs, shape='wide')
p_kwargs['figure_name'] = "led_tgrad_vs_charge"
self.p_led_tgradvscharge = Hist2D(**p_kwargs, shape='wide')
p_kwargs['figure_name'] = "led_1D_comparison_eid{}_wavg".format(
self.eoi)
self.p_led_1deoicomp_wavg = WaveformHist1D(**p_kwargs, shape='wide')
p_kwargs['figure_name'] = "led_1D_comparison_allevents_wavg".format(
self.eoi)
self.p_led_1dcomp_wavg = WaveformHist1D(**p_kwargs, shape='wide')
p_kwargs['figure_name'] = "led_1D_comparison_eid{}".format(self.eoi)
self.p_led_1deoicomp = WaveformHist1DInt(**p_kwargs, shape='wide')
p_kwargs['figure_name'] = "led_1D_comparison_allevents".format(
self.eoi)
self.p_led_1dcomp = WaveformHist1D(**p_kwargs, shape='wide')
p_kwargs['figure_name'] = "led_image_tgrad_eid{}".format(self.eoi)
self.p_led_imageeoitgrad = ImagePlotter(**p_kwargs)
p_kwargs['figure_name'] = "laser_1D_comparison_eid{}_wavg".format(
self.eoi)
self.p_laser_1deoicomp_wavg = WaveformHist1D(**p_kwargs, shape='wide')
p_kwargs['figure_name'] = "laser_1D_comparison_allevents_wavg".format(
self.eoi)
self.p_laser_1dcomp_wavg = WaveformHist1D(**p_kwargs, shape='wide')
p_kwargs['figure_name'] = "laser_1D_comparison_eid{}".format(self.eoi)
self.p_laser_1deoicomp = WaveformHist1DInt(**p_kwargs, shape='wide')
p_kwargs['figure_name'] = "laser_1D_comparison_allevents".format(
self.eoi)
self.p_laser_1dcomp = WaveformHist1D(**p_kwargs, shape='wide')
p_kwargs['figure_name'] = "laser_1D_finalmethod"
self.p_laser_1d_final = WaveformHist1D(**p_kwargs, shape='square')
p_kwargs['figure_name'] = "laser_1D_finalmethod_pix"
self.p_laser_1d_final_pix = WaveformHist1D(**p_kwargs, shape='square')
p_kwargs['figure_name'] = "laser_image_tgrad_eid{}".format(self.eoi)
self.p_laser_imageeoitgrad = ImagePlotter(**p_kwargs)
p_kwargs['figure_name'] = "laser_fwhm_allevents"
self.p_laser_fwhm = WaveformHist1DInt(**p_kwargs, shape='wide')
def corr_time(input_file_1, input_file_2, gain, nr, pix):
n_combine = 8
n_harm = 16
n_cap = 1024
timeCorr = TimeCalCorr(n_combine, n_harm, n_cap)
# compute curve to calib time
reader = event_source(input_url=input_file_1, max_events=4000)
for ev in reader:
expected_pixel_id = ev.lst.tel[0].svc.pixel_ids
fc = get_first_capacitor(ev, nr)
pixel = expected_pixel_id[nr * 7 + pix]
integrator = LocalPeakIntegrator(None, None)
integration, peakpos, window = integrator.extract_charge(
ev.r0.tel[0].waveform[:, :, :])
print("pekpos = {}, charge = {}".format(peakpos[gain, pixel],
integration[gain, pixel]))
if integration[0, pixel] > 4000:
timeCorr.fill(fc[gain, pix] % 1024, peakpos[gain, pixel])
timeCorr.finalize()
fc = np.arange(0, 1024, 8)
an = timeCorr.fan
bn = timeCorr.fbn
y = np.zeros(128)
for i in range(0, len(y)):
temp_cos = 0
temp_sin = 0
for j in range(0, len(an)):
temp_cos += an[j] * np.cos(2 * j * np.pi * (fc[i] / 1024.))
temp_sin += bn[j] * np.sin(2 * j * np.pi * (fc[i] / 1024.))
y[i] = (temp_cos + temp_sin)
fig, ax = plt.subplots(1, 2, figsize=(16, 9))
ax[0].plot(np.arange(0, 1024, 8), timeCorr.fMeanVal, 'bo', markersize=4)
offset = y[0] - timeCorr.fMeanVal[0]
ax[0].plot(fc, y - offset, 'r--')
ax[0].set_ylabel("Mean arrival time")
ax[0].set_xlabel("Position in the DRS ring")
ax[0].set_title("n_harm = {}, pixel = {}".format(n_harm, pixel))
# Apply time corr on second file
reader = event_source(input_url=input_file_2, max_events=4000)
arrival_time_list = []
arrival_time_corr_list = []
for ev in reader:
expected_pixel_id = ev.lst.tel[0].svc.pixel_ids
pixel = expected_pixel_id[nr * 7 + pix]
fc = get_first_capacitor(ev, nr)
integrator = LocalPeakIntegrator(None, None)
integration, peakpos, window = integrator.extract_charge(
ev.r0.tel[0].waveform[:, :, :])
print("pekpos = {}, charge = {}".format(peakpos[gain, pixel],
integration[gain, pixel]))
if integration[0, pixel] > 4000:
arrival_time_list.append(peakpos[gain, pixel])
arrival_time_corr_list.append(
timeCorr.get_corr_time(fc[gain, pix] % 1024))
binwidth = 1
ax[1].hist(arrival_time_list,
histtype='step',
lw=3,
linestyle='--',
range=(20, 30),
bins=np.arange(min(arrival_time_list),
max(arrival_time_list) + binwidth, binwidth),
label="before time corr")
ax[1].hist(arrival_time_corr_list,
histtype='step',
lw=3,
linestyle='--',
color='red',
range=(20, 30),
bins=np.arange(min(arrival_time_corr_list),
max(arrival_time_corr_list) + binwidth,
binwidth),
label="after time corr")
ax[1].set_ylabel("Number of events")
ax[1].set_xlabel("Arrival time [time samples 1 ns]")
ax[1].legend()
plt.tight_layout()
plt.show()
# corr_time("/media/pawel1/ADATA HD330/20190312/LST-1.1.Run00250.0000.fits.fz", "/media/pawel1/ADATA HD330/20190312/LST-1.2.Run00250.0000.fits.fz", 1, 25, 1)
break
'''
for ii, tel_id in enumerate(event.r0.tels_with_data):
geom = event.inst.subarray.tel[tel_id].camera #Camera geometry
data = event.r0.tel[tel_id].waveform
ped = event.mc.tel[tel_id].pedestal
# the pedestal is the average (for pedestal events) of the *sum* of all samples, from sim_telarray
nsamples = data.shape[2] # total number of samples
pedcorrectedsamples = data - np.atleast_3d(
ped
) / nsamples # Subtract pedestal baseline. atleast_3d converts 2D to 3D matrix
integrator = LocalPeakIntegrator(None, None)
integration, peakpos, window = integrator.extract_charge(
pedcorrectedsamples
) # these are 2D matrices num_gains * num_pixels
chan = 0 # high gain used for now...
signals = integration[chan].astype(float)
dc2pe = event.mc.tel[tel_id].dc_to_pe # numgains * numpixels
signals *= dc2pe[chan]
# Add all individual pixel signals to the numpy array of the corresponding camera inside the log10pixelsignal dictionary
log10pixelHGsignal[str(geom)].extend(
np.log10(signals)
) # This seems to be faster like this, with normal python lists
class FlatFieldGenerator(Tool):
name = "FlatFieldGenerator"
description = "Generate the a pickle file of FlatField for " \
"either MC or data files."
telescopes = Int(1,
help='Telescopes to include from the event file. '
'Default = 1').tag(config=True)
output_name = Unicode('extracted_flatfield',
help='Name of the output extracted flat field hdf5 '
'file').tag(config=True)
infile = Unicode(help='Path to file containing data').tag(config=True)
max_events = Int(1,
help='Maximum number of events to use').tag(config=True)
plot_cam = Bool(False,
"enable plotting of individual camera").tag(config=True)
use_true_pe = Bool(False, "Use true mc p.e.").tag(config=True)
calibrator = Unicode(
'HESSIOR1Calibrator',
help='which calibrator to use, default = HESSIOR1Calibrator').tag(
config=True)
debug = Bool(False, "plot resulting histograms").tag(config=True)
aliases = Dict(
dict(infile='FlatFieldGenerator.infile',
calibrator='FlatFieldGenerator.calibrator',
max_events='FlatFieldGenerator.max_events',
extractor='ChargeExtractorFactory.product',
window_width='ChargeExtractorFactory.window_width',
t0='ChargeExtractorFactory.t0',
window_shift='ChargeExtractorFactory.window_shift',
sig_amp_cut_HG='ChargeExtractorFactory.sig_amp_cut_HG',
sig_amp_cut_LG='ChargeExtractorFactory.sig_amp_cut_LG',
lwt='ChargeExtractorFactory.lwt',
clip_amplitude='CameraDL1Calibrator.clip_amplitude',
radius='CameraDL1Calibrator.radius',
T='FlatFieldGenerator.telescopes',
o='FlatFieldGenerator.output_name',
plot_cam='FlatFieldGenerator.plot_cam',
use_true_pe='FlatFieldGenerator.use_true_pe',
dd='FlatFieldGenerator.debug'))
classes = List([
EventSourceFactory, HESSIOEventSource, TargetIOEventSource,
ChargeExtractorFactory, CameraDL1Calibrator, CameraCalibrator
])
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.eventsource = None
self.r1 = None
self.dl0 = None
self.dl1 = None
self.calculator = None
self.cal = None
self.aver = None
self.cross = None
self.glob_peak = None
self.local_peak = None
self.neighbour = None
self.reconstructed_image_array = []
self.mean_reconstructed_image_array = None
self.mean_true_image_array = None
self.event_count = 0
self.geom = None
self.disp = 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 start(self):
fig1 = plt.figure(3)
ax1 = fig1.add_subplot(111, aspect='equal')
try:
source = EventSourceFactory.produce(input_url=self.infile,
max_events=self.max_events)
for event in tqdm(source):
self.cal.calibrate(event)
self.dl0.reduce(event)
self.dl1.calibrate(event)
if self.disp is None:
self.geom = event.inst.subarray.tel[self.telescopes].camera
self.mean_reconstructed_image_array = np.zeros(
len(self.geom.pix_id))
self.mean_true_image_array = np.zeros(len(
self.geom.pix_id))
self.disp = 1
if self.debug:
self.disp = CameraDisplay(self.geom)
self.disp.add_colorbar()
# reco_array = self.cross.get_charge(event.r1.tel[self.telescopes].waveform[0])['charge']
# reco_array = self.glob_peak.extract_charge(event.r1.tel[self.telescopes].waveform)[0][0]
reco_array = self.local_peak.extract_charge(
event.r1.tel[self.telescopes].waveform
)[0][
0] #/ np.mean(self.local_peak.extract_charge(event.r1.tel[self.telescopes].waveform)[0][0])
true_array = event.mc.tel[
self.
telescopes].photo_electron_image #/ np.mean(event.mc.tel[self.telescopes].photo_electron_image)
# print(true_array)
# print(reco_array)
# exit()
# plt.scatter(event.mc.tel[self.telescopes].photo_electron_image,reco_array)
# plt.show()
#
# exit()
# reco_array = self.aver.extract_charge(event.r1.tel[self.telescopes].waveform)[0][0]
# reco_array = self.neighbour.extract_charge(event.r1.tel[self.telescopes].waveform)[0][0]
# print(reco_array)
# exit()
# print(event.mc.tel[self.telescopes].photo_electron_image)
self.mean_true_image_array = np.add(self.mean_true_image_array,
true_array)
self.mean_reconstructed_image_array = np.add(
self.mean_reconstructed_image_array, reco_array)
# print(self.mean_true_image_array)
# print(self.mean_reconstructed_image_array)
# dist = np.sqrt(self.geom.pix_x.value**2 + self.geom.pix_y.value**2)
# plt.scatter( self.mean_true_image_array/np.mean(self.mean_true_image_array), self.mean_reconstructed_image_array/np.mean(self.mean_reconstructed_image_array), c = dist, alpha=0.4)
# ax1.set_ylim(0,2)
# ax1.set_xlim(0,2)
# plt.draw()
# plt.pause(0.4)
# plt.cla()
# self.reconstructed_image_array.append(event.dl1.tel[self.telescopes].image[0])
self.event_count += 1
except FileNotFoundError:
print('file_not_found')
def finish(self):
# out_file = open(self.output_name)
# out_file.write('#PixID meanIllum\n')
# for i in range(len(self.reconstructed_image_array)):
# out_file.write('%s\t%s\n' % (self.geom.pix_id, self.reconstructed_image_array))
# out_file.close()
self.mean_reconstructed_image_array = self.mean_reconstructed_image_array / self.event_count
self.mean_true_image_array = self.mean_true_image_array / self.event_count
if self.debug:
# mean_image = np.mean(self.reconstructed_image_array,axis=0)/np.mean(np.mean(self.reconstructed_image_array))
mean_image = self.mean_reconstructed_image_array
self.disp.image = self.mean_true_image_array
# fig = plt.figure(3)
# plt.hist(self.mean_true_image_array/self.mean_true_image_array.mean(), alpha = 0.5, label='true')
# plt.hist( self.mean_reconstructed_image_array/self.mean_reconstructed_image_array.mean(), alpha = 0.5, label='reco')
# plt.legend()
# from IPython import embed
# embed()
# self.disp.norm = 'log'
# self.disp.set_limits_minmax(40.5,44.5)
plt.show()
