def test_get_specific_event():
dataset = get_datasets_path("gamma_test.simtel.gz")
source = hessio_event_source(dataset, requested_event=2)
event = next(source)
assert event.count == 2
assert event.dl0.event_id == 803
source = hessio_event_source(dataset, requested_event=803, use_event_id=True)
event = next(source)
assert event.count == 2
assert event.dl0.event_id == 803
def list_telescopes_geometry(simtel_file_path):
"""Print the list of triggered telescopes ID and geometry of the
'simtel_file_path' file.
Parameters
----------
simtel_file_path : str
The path of the simtel file to process.
"""
source = hessio_event_source(simtel_file_path)
tel_id_set = set()
for event in source:
for tel_id in event.dl0.tels_with_data:
tel_id_set.add(int(tel_id))
tel_geometry_dict = {}
for tel_id in tel_id_set:
x, y = event.meta.pixel_pos[tel_id]
foclen = event.meta.optical_foclen[tel_id]
geom = ctapipe.io.CameraGeometry.guess(x, y, foclen)
tel_geometry_dict[tel_id] = [geom.cam_id, geom.pix_type]
print("Telescope {:03d}: {} ({} pixels)".format(tel_id, geom.cam_id, geom.pix_type))
return tel_geometry_dict
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_dataset("gamma_test.simtel.gz")
fit = HillasReconstructor()
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] = event.mc.tel[tel_id].azimuth_raw * u.rad
tel_theta[tel_id] = (np.pi/2-event.mc.tel[tel_id].altitude_raw)*u.rad
pmt_signal = event.r0.tel[tel_id].adc_sums[0]
mask = tailcuts_clean(cam_geom[tel_id], pmt_signal,
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, 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 list_simtel_events_per_telescope(simtel_file_path):
"""Make a dictionary of triggered events per telescope of the
'simtel_file_path' file.
Parameters
----------
simtel_file_path : str
The path of the simtel file to process.
Returns
-------
Dictionary of triggered events per telescope of the 'simtel_file_path'
file (for each item: key=telescope id, value=the list of triggered events).
"""
source = hessio_event_source(simtel_file_path, allowed_tels=None, max_events=None)
events_per_tel_dict = {} # List of events per telescope
for event in source:
triggered_telescopes_list = [int(tel_id) for tel_id in event.trig.tels_with_trigger]
for telescope_id in triggered_telescopes_list:
if telescope_id not in events_per_tel_dict:
events_per_tel_dict[telescope_id] = []
events_per_tel_dict[telescope_id].append(int(event.dl0.event_id))
return events_per_tel_dict
def list_simtel_content(simtel_file_path):
# GET EVENT #############################################################
# hessio_event_source returns a Python generator that streams data from an
# EventIO/HESSIO MC data file (e.g. a standard CTA data file).
# This generator contains ctapipe.core.Container instances ("event").
#
# Parameters:
# - max_events: maximum number of events to read
# - allowed_tels: select only a subset of telescope, if None, all are read.
source = hessio_event_source(simtel_file_path,
allowed_tels=[1],
max_events=1)
for event in source:
print("Count:", event["count"])
print("Trigger data:", event["trig"])
print("Monte-Carlo shower data:", event["mc"])
print("Raw data:", event["dl0"])
#print("Simtel file path:", event.meta["hessio__input"])
print("Pixel pos:", event.meta["pixel_pos"])
#print("Max events:", event.meta["hessio__max_events"])
print()
def show_image(simtel_file_path, output_file_path, tel_num, event_id, channel=0, quiet=False):
# GET EVENT #############################################################
# hessio_event_source returns a Python generator that streams data from an
# EventIO/HESSIO MC data file (e.g. a standard CTA data file).
# This generator contains ctapipe.core.Container instances ("event").
#
# Parameters:
# - max_events: maximum number of events to read
# - allowed_tels: select only a subset of telescope, if None, all are read.
source = hessio_event_source(simtel_file_path, allowed_tels=[tel_num])
event = None
for ev in source:
if int(ev.dl0.event_id) == event_id:
event = ev
break
if event is None:
raise Exception("Error: event '{}' not found for telescope '{}'.".format(event_id, tel_num))
# INIT PLOT #############################################################
x, y = event.meta.pixel_pos[tel_num]
foclen = event.meta.optical_foclen[tel_num]
geom = ctapipe.io.CameraGeometry.guess(x, y, foclen)
disp = ctapipe.visualization.CameraDisplay(geom, title='CT%d' % tel_num)
disp.enable_pixel_picker()
disp.add_colorbar()
disp.axes.set_title('Telescope {:03d}, Event {:05d}'.format(tel_num, event_id))
# DISPLAY TIME-VARYING EVENT ############################################
#data = event.dl0.tel[tel_num].adc_samples[channel]
#for ii in range(data.shape[1]):
# disp.image = data[:, ii]
# disp.set_limits_percent(70) # TODO
# plt.savefig('CT{:03d}_EV{:05d}_S{:02d}.png'.format(tel_num, event_id, ii), bbox_inches='tight')
# DISPLAY INTEGRATED EVENT ##############################################
uncalibrated_image = event.dl0.tel[tel_num].adc_sums[channel]
calibrated_image = apply_mc_calibration(uncalibrated_image, tel_num)
# The image "event.dl0.tel[tel_num].adc_sums[channel]" is a 1D numpy array (dtype=int32)
disp.image = calibrated_image
#disp.set_limits_minmax(0, 9000)
disp.set_limits_percent(70) # TODO
# PLOT ##################################################################
plt.savefig(output_file_path, bbox_inches='tight')
if not quiet:
plt.show()
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(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 list_simtel_content(simtel_file_path, tel_num, event_id):
# GET EVENT #############################################################
# hessio_event_source returns a Python generator that streams data from an
# EventIO/HESSIO MC data file (e.g. a standard CTA data file).
# This generator contains ctapipe.core.Container instances ("event").
#
# Parameters:
# - max_events: maximum number of events to read
# - allowed_tels: select only a subset of telescope, if None, all are read.
source = hessio_event_source(simtel_file_path, allowed_tels=[tel_num])
event = None
for ev in source:
if int(ev.dl0.event_id) == event_id:
event = ev
break
if event is None:
print("Error: event '{}' not found for telescope '{}'.".format(event_id, tel_num))
sys.exit(1)
# DISPLAY EVENT INFORMATIONS ##############################################
print("- event:")
recursive_print(event, level=1)
print("- event.meta:")
recursive_print(event.meta, level=1)
def test_geom_json_file_astri_ex1(self):
tel_id = 1
output_json_file = "/tmp/astri.geom.json"
source = hessio_event_source(ASTRI_SIMTEL_FILE_PATH, allowed_tels=[tel_id])
for ev in source:
event = ev
# Get the geometry object with the "guess()" method
pix_x = event.inst.pixel_pos[tel_id][0]
pix_y = event.inst.pixel_pos[tel_id][1]
optical_foclen = event.inst.optical_foclen[tel_id]
geom = camera.CameraGeometry.guess(pix_x, pix_y, optical_foclen)
# Convert and write the geom object
geometry_converter.geom_to_json_file(geom, output_json_file)
geom2 = geometry_converter.json_file_to_geom(output_json_file)
# Check whether the input image has changed
self.assertEqual(geom2.cam_id, geom.cam_id)
np.testing.assert_array_equal(geom2.pix_id, geom.pix_id)
np.testing.assert_array_equal(geom2.pix_x.value, geom.pix_x.value)
np.testing.assert_array_equal(geom2.pix_y.value, geom.pix_y.value)
np.testing.assert_array_equal(geom2.pix_area.value, geom.pix_area.value)
self.assertEqual(geom2.neighbors, geom.neighbors)
self.assertEqual(geom2.pix_type, geom.pix_type)
def count_simtel_events(simtel_file_path):
"""
Count the number of events per telescope in a simtel file.
Returns the number of events per telescope and the total number of events.
"""
# GET EVENT #############################################################
# hessio_event_source returns a Python generator that streams data from an
# EventIO/HESSIO MC data file (e.g. a standard CTA data file).
# This generator contains ctapipe.core.Container instances ("event").
#
# Parameters:
# - max_events: maximum number of events to read
# - allowed_tels: select only a subset of telescope, if None, all are read.
source = hessio_event_source(simtel_file_path,
allowed_tels=None,
max_events=None)
num_event_dict = {} # Number of events per telescope
total_num_events = 0 # Total number of events
for event in source:
total_num_events += 1
for telescope_id in event["trig"]["tels_with_trigger"]:
if telescope_id not in num_event_dict:
num_event_dict[telescope_id] = 0
num_event_dict[telescope_id] += 1
return num_event_dict, total_num_events
def test_get_run_id():
filename = get_datasets_path("gamma_test.simtel.gz")
print(filename)
gen = hessio_event_source(filename)
event = next(gen)
tels = event.dl0.tels_with_data
print(tels)
assert tels == {38, 47}
def generate_input_containers():
# Get event from hessio file, append them into input_containers
input_filename = get_datasets_path("gamma_test.simtel.gz")
gen = hessio_event_source(input_filename, max_events=3)
input_containers = []
for event in gen:
input_containers.append(deepcopy(event))
return input_containers
def show_image(simtel_file_path, output_file_path, tel_num, event_id, channel=0, quiet=False):
# GET EVENT #############################################################
# hessio_event_source returns a Python generator that streams data from an
# EventIO/HESSIO MC data file (e.g. a standard CTA data file).
# This generator contains ctapipe.core.Container instances ("event").
#
# Parameters:
# - max_events: maximum number of events to read
# - allowed_tels: select only a subset of telescope, if None, all are read.
source = hessio_event_source(simtel_file_path, allowed_tels=[tel_num])
event = None
for ev in source:
if int(ev.dl0.event_id) == event_id:
event = ev
break
if event is None:
raise Exception("Error: event '{}' not found for telescope '{}'.".format(event_id, tel_num))
# INIT PLOT #############################################################
x, y = event.meta.pixel_pos[tel_num]
foclen = event.meta.optical_foclen[tel_num]
geom = ctapipe.io.CameraGeometry.guess(x, y, foclen)
disp = ctapipe.visualization.CameraDisplay(geom, title='CT%d' % tel_num)
disp.enable_pixel_picker()
disp.add_colorbar()
disp.axes.set_title('Telescope {:03d}, Event {:05d}'.format(tel_num, event_id))
# GET PHOTOELECTRON IMAGE (CLEAN IMAGE) #################################
disp.image = event.mc.tel[tel_num].photo_electrons
# COMPUTE hILLAS PARAMETERS #############################################
image = disp.image.copy()
#hillas = hillas_parameters(geom.pix_x.value, geom.pix_y.value, image)
hillas = hillas_parameters(geom.pix_x, geom.pix_y, image)
print("Hillas parameters:", hillas)
# PLOT ##################################################################
#disp.set_limits_minmax(0, 9000)
disp.set_limits_percent(70) # TODO
# Plot Hillas parameters
disp.overlay_moments(hillas, linewidth=3, color='yellow')
plt.savefig(output_file_path, bbox_inches='tight')
if not quiet:
plt.show()
def show_pe_image(simtel_file_path, tel_num=1, channel=0, event_index=0):
# GET EVENT #############################################################
# hessio_event_source returns a Python generator that streams data from an
# EventIO/HESSIO MC data file (e.g. a standard CTA data file).
# This generator contains ctapipe.core.Container instances ("event").
#
# Parameters:
# - max_events: maximum number of events to read
# - allowed_tels: select only a subset of telescope, if None, all are read.
source = hessio_event_source(simtel_file_path,
allowed_tels=[tel_num],
max_events=event_index+1)
event_list = list(source) # TODO
event = event_list[event_index] # TODO
# INIT PLOT #############################################################
x, y = event.meta.pixel_pos[tel_num]
geom = ctapipe.io.CameraGeometry.guess(x, y)
disp = ctapipe.visualization.CameraDisplay(geom, title='CT%d' % tel_num)
disp.enable_pixel_picker()
disp.add_colorbar()
disp.axes.set_title('CT{:03d}, event {:010d}'.format(tel_num, event.dl0.event_id))
# DISPLAY TIME-VARYING EVENT ############################################
#data = event.dl0.tel[tel_num].adc_samples[channel]
#for ii in range(data.shape[1]):
# disp.image = data[:, ii]
# #disp.set_limits_percent(70) # TODO help(disp.set_limits_percent)
# disp.set_limits_minmax(0, 400)
# plt.savefig('CT{:03d}_EV{:010d}_S{:02d}.png'.format(tel_num, event.dl0.event_id, ii))
# DISPLAY INTEGRATED EVENT ##############################################
#disp.image = event.dl0.tel[tel_num].adc_sums[channel]
#disp.set_limits_percent(70) # TODO help(disp.set_limits_percent)
# TODO: check that (taken from https://github.com/tino-michael/tino_cta/blob/e6cc6db3e64135c9ac92bce2dae6e6f81a36096a/sandbox/show_ADC_and_PE_per_event.py)
for jj in range(len(event.mc.tel[tel_num].photo_electrons)):
#event.dl0.tel[tel_num].adc_sums[channel][jj] = event.mc.tel[tel_num].photo_electrons[jj]
event.r0.tel[tel_num].adc_sums[channel][jj] = event.mc.tel[tel_num].photo_electrons[jj]
signals2 = event.dl0.tel[tel_num].adc_sums[channel].astype(float)
disp.image = signals2
disp.set_limits_minmax(0, 9000)
plt.savefig('CT{:03d}_EV{:010d}.png'.format(tel_num, event.dl0.event_id))
# PLOT ##################################################################
plt.show()
def extract_image(simtel_file_path, tel_num, event_id, channel=0):
# GET EVENT #############################################################
# hessio_event_source returns a Python generator that streams data from an
# EventIO/HESSIO MC data file (e.g. a standard CTA data file).
# This generator contains ctapipe.core.Container instances ("event").
#
# Parameters:
# - max_events: maximum number of events to read
# - allowed_tels: select only a subset of telescope, if None, all are read.
source = hessio_event_source(simtel_file_path, allowed_tels=[tel_num])
event = None
for ev in source:
if int(ev.dl0.event_id) == event_id:
event = ev
break
if event is None:
raise Exception("Error: event '{}' not found for telescope '{}'.".format(event_id, tel_num))
# CHECK THE IMAGE GEOMETRY (ASTRI AND SCTCAM ONLY) ######################
x, y = event.meta.pixel_pos[tel_num]
foclen = event.meta.optical_foclen[tel_num]
geom = ctapipe.io.CameraGeometry.guess(x, y, foclen)
if geom.pix_type != "rectangular":
raise ValueError("The input image is not a valide ASTRI or SCTCam telescope image.")
# GET AND CROP THE IMAGE ################################################
uncalibrated_image = event.dl0.tel[tel_num].adc_sums[channel] # 1D numpy array
calibrated_image = apply_mc_calibration(uncalibrated_image, tel_num)
if geom.cam_id == "ASTRI":
cropped_img = crop_astri_image(calibrated_image)
elif geom.cam_id == "SCTCam":
cropped_img = crop_sctcam_image(calibrated_image)
else:
raise ValueError("The input image is not a valide ASTRI or SCTCam telescope image.")
# GET AND CROP THE PHOTOELECTRON IMAGE ##################################
pe_image = event.mc.tel[tel_num].photo_electrons # 1D numpy array
if geom.cam_id == "ASTRI":
cropped_pe_img = crop_astri_image(pe_image)
elif geom.cam_id == "SCTCam":
cropped_pe_img = crop_sctcam_image(pe_image)
else:
raise ValueError("The input image is not a valide ASTRI or SCTCam telescope image.")
return (cropped_img, cropped_pe_img)
def test_array_draw():
filename = get_dataset("gamma_test.simtel.gz")
cam_geom = {}
source = hessio_event_source(filename, max_events=2)
r1 = HessioR1Calibrator(None, None)
dl0 = CameraDL0Reducer(None, None)
calibrator = CameraDL1Calibrator(None, None)
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 = event.inst.subarray.tel[tel_id].camera
fl = event.inst.subarray.tel[tel_id].optics.effective_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))
mask = tailcuts_clean(geom, pmt_signal,
picture_thresh=10., boundary_thresh=5.)
try:
moments = hillas_parameters(nom_coord.x,
nom_coord.y,
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 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 show_image_histogram(simtel_file_path, output_file_path, tel_num, event_id, channel=0, quiet=False):
# GET EVENT #############################################################
# hessio_event_source returns a Python generator that streams data from an
# EventIO/HESSIO MC data file (e.g. a standard CTA data file).
# This generator contains ctapipe.core.Container instances ("event").
#
# Parameters:
# - max_events: maximum number of events to read
# - allowed_tels: select only a subset of telescope, if None, all are read.
source = hessio_event_source(simtel_file_path, allowed_tels=[tel_num])
event = None
for ev in source:
if int(ev.dl0.event_id) == event_id:
event = ev
break
if event is None:
print("Error: event '{}' not found for telescope '{}'.".format(event_id, tel_num))
sys.exit(1)
# GET TIME-VARYING EVENT ##################################################
#data = event.dl0.tel[tel_num].adc_samples[channel]
#for ii in range(data.shape[1]):
# image_array = data[:, ii]
# GET INTEGRATED EVENT ####################################################
# The image "event.dl0.tel[tel_num].adc_sums[channel]" is a 1D numpy array (dtype=int32)
image_array = event.dl0.tel[tel_num].adc_sums[channel]
# INIT PLOT ###############################################################
fig = plt.figure(figsize=(8.0, 8.0))
ax = fig.add_subplot(111)
values, bins, patches = ax.hist(image_array.ravel(),
histtype=HISTOGRAM_TYPE,
#bins=image_array.max() - image_array.min(),
bins=100,
fc='gray',
ec='k')
ax.set_xlim([image_array.min(), image_array.max()])
# PLOT ####################################################################
plt.savefig(output_file_path, bbox_inches='tight')
if not quiet:
plt.show()
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 export_cameras_geometry(simtel_file_path, tel_id):
source = hessio_event_source(simtel_file_path)
for event in source:
#######################################################################
# CAUTION: #
# event.meta.optical_foclen and event.meta.tel_pos are only filled #
# when source is traversed ! #
# The current value of these two variables is not the actual value #
# for the current event but the cumulated value of past events ! #
#######################################################################
print("Event", event.dl0.event_id)
#print("tels_with_trigger", event.trig.tels_with_trigger)
#print("tels_with_data", event.dl0.tels_with_data)
#print("optical_foclen", event.meta.optical_foclen)
#print("tel_pos", event.meta.tel_pos)
# GET CAMERAS GEOMETRY ################################
x, y = event.meta.pixel_pos[tel_id]
foclen = event.meta.optical_foclen[tel_id]
geom = ctapipe.io.CameraGeometry.guess(x, y, foclen)
foclen = float(foclen.value)
x = [float(v.value) for v in x]
y = [float(v.value) for v in y]
cam_id = geom.cam_id
pix_type = geom.pix_type
camera_dict = {
"camera_id": cam_id,
"pixel_type": pix_type,
"pixel_pos_x": x,
"pixel_pos_y": y,
"foclen": foclen,
"tel_id": tel_id
}
# PRINT CAMERAS GEOMETRY ##############################
for k, v in camera_dict.items():
print("- ", k, v)
# EXPORT CAMERAS GEOMETRY #############################
with open("cameras_geometry_tel{:03d}.json".format(tel_id), "w") as fd:
#json.dump(camera_dict, fd) # no pretty print
json.dump(camera_dict, fd, sort_keys=True, indent=4) # pretty print format
def plot_data(simtel_file_path_list, output_file_path, tel_num, pmt_id, channel=0, quiet=False):
adc_list = []
pe_list = []
for simtel_file_path in simtel_file_path_list:
print(simtel_file_path)
# GET EVENT #############################################################
# hessio_event_source returns a Python generator that streams data from an
# EventIO/HESSIO MC data file (e.g. a standard CTA data file).
# This generator contains ctapipe.core.Container instances ("event").
#
# Parameters:
# - max_events: maximum number of events to read
# - allowed_tels: select only a subset of telescope, if None, all are read.
source = hessio_event_source(simtel_file_path, allowed_tels=[tel_num])
for event in source:
# Get ADC image
adc_list.append(event.dl0.tel[tel_num].adc_sums[channel][pmt_id])
# Get photoelectron image
pe_list.append(event.mc.tel[tel_num].photo_electrons[pmt_id])
# INIT PLOT ###############################################################
fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(8, 8))
ax.plot(pe_list, adc_list, '.')
#H = ax.hist2d(pe_list, adc_list, bins=1000, norm=LogNorm())
#fig.colorbar(H[3], ax=ax)
#ax.set_xlim([0, 60])
ax.set_title("Telescope {:03d} - PMT {} - Channel {}".format(tel_num, pmt_id, channel))
ax.set_xlabel("PE", fontsize=24)
ax.set_ylabel("ADC", fontsize=24)
# PLOT ####################################################################
#plt.savefig(output_file_path, bbox_inches='tight')
plt.savefig(output_file_path)
if not quiet:
plt.show()
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 show_photoelectron_image(simtel_file_path, output_file_path, tel_num, event_id, channel=0, quiet=False):
# GET EVENT #############################################################
# hessio_event_source returns a Python generator that streams data from an
# EventIO/HESSIO MC data file (e.g. a standard CTA data file).
# This generator contains ctapipe.core.Container instances ("event").
#
# Parameters:
# - max_events: maximum number of events to read
# - allowed_tels: select only a subset of telescope, if None, all are read.
source = hessio_event_source(simtel_file_path, allowed_tels=[tel_num])
event = None
for ev in source:
if int(ev.dl0.event_id) == event_id:
event = ev
break
if event is None:
raise Exception("Error: event '{}' not found for telescope '{}'.".format(event_id, tel_num))
# INIT PLOT #############################################################
x, y = event.meta.pixel_pos[tel_num]
foclen = event.meta.optical_foclen[tel_num]
geom = ctapipe.io.CameraGeometry.guess(x, y, foclen)
disp = ctapipe.visualization.CameraDisplay(geom, title='CT%d' % tel_num)
disp.enable_pixel_picker()
disp.add_colorbar()
disp.axes.set_title('Telescope {:03d}, Event {:05d}'.format(tel_num, event_id))
# GET PHOTOELECTRON IMAGE (CLEAN IMAGE) #################################
# The photoelectron image "event.mc.tel[tel_num].photo_electrons" is a 1D numpy array with the same shape (dtype=int32)
# Inspired by https://github.com/tino-michael/tino_cta/blob/e6cc6db3e64135c9ac92bce2dae6e6f81a36096a/sandbox/show_ADC_and_PE_per_event.py
disp.image = event.mc.tel[tel_num].photo_electrons
# PLOT ##################################################################
#disp.set_limits_minmax(0, 9000)
disp.set_limits_percent(70) # TODO
plt.savefig(output_file_path, bbox_inches='tight')
if not quiet:
plt.show()
def setup(self):
# load up the telescope types table (need to first open a file, a bit of
# a hack until a proper insturment module exists) and select only the
# telescopes with the same camera type
data = next(hessio_event_source(self.infile, max_events=1))
camtypes = get_camera_types(data.inst)
print_camera_types(data.inst, printer=self.log.info)
group = camtypes.groups[self.telgroup]
self._selected_tels = group['tel_id'].data
self._base_tel = self._selected_tels[0]
self.log.info("Telescope group %d: %s with %s camera", self.telgroup,
group[0]['tel_type'], group[0]['cam_type'])
self.log.info("SELECTED TELESCOPES:{}".format(self._selected_tels))
self.calibrator = CameraCalibrator(self.config, self)
def show_pedestal_image(simtel_file_path, output_file_path, tel_num, quiet=False):
# GET EVENT #############################################################
# hessio_event_source returns a Python generator that streams data from an
# EventIO/HESSIO MC data file (e.g. a standard CTA data file).
# This generator contains ctapipe.core.Container instances ("event").
#
# Parameters:
# - max_events: maximum number of events to read
# - allowed_tels: select only a subset of telescope, if None, all are read.
source = hessio_event_source(simtel_file_path, allowed_tels=[tel_num])
# TODO
for ev in source:
event = ev
# INIT PLOT #############################################################
x, y = event.meta.pixel_pos[tel_num]
foclen = event.meta.optical_foclen[tel_num]
geom = ctapipe.io.CameraGeometry.guess(x, y, foclen)
disp = ctapipe.visualization.CameraDisplay(geom, title="CT%d" % tel_num)
disp.enable_pixel_picker()
disp.add_colorbar()
disp.axes.set_title("Telescope {:03d}".format(tel_num))
# DISPLAY INTEGRATED EVENT ##############################################
pedestal, gains = get_mc_calibration_coeffs(tel_num)
disp.image = pedestal
# print("pedestal: ndim={} shape={} dtype={}".format(pedestal.ndim, pedestal.shape, pedestal.dtype))
# print("gains: ndim={} shape={} dtype={}".format(gains.ndim, gains.shape, gains.dtype))
# print("pedestal:", pedestal)
# print("gains:", gains)
# disp.set_limits_minmax(0, 9000)
disp.set_limits_percent(70) # TODO
# PLOT ##################################################################
plt.savefig(output_file_path, bbox_inches="tight")
if not quiet:
plt.show()
def show_image(simtel_file_path, tel_num=1, channel=0, event_index=0):
# GET EVENT #############################################################
# hessio_event_source returns a Python generator that streams data from an
# EventIO/HESSIO MC data file (e.g. a standard CTA data file).
# This generator contains ctapipe.core.Container instances ("event").
#
# Parameters:
# - max_events: maximum number of events to read
# - allowed_tels: select only a subset of telescope, if None, all are read.
source = hessio_event_source(simtel_file_path,
allowed_tels=[tel_num],
max_events=event_index+1)
event_list = list(source) # TODO
event = event_list[event_index] # TODO
# INIT PLOT #############################################################
x, y = event.meta.pixel_pos[tel_num]
geom = ctapipe.io.CameraGeometry.guess(x, y)
disp = ctapipe.visualization.CameraDisplay(geom, title='CT%d' % tel_num)
disp.enable_pixel_picker()
disp.add_colorbar()
disp.axes.set_title('CT{:03d}, event {:010d}'.format(tel_num, event.dl0.event_id))
# DISPLAY TIME-VARYING EVENT ############################################
#data = event.dl0.tel[tel_num].adc_samples[channel]
#for ii in range(data.shape[1]):
# disp.image = data[:, ii]
# #disp.set_limits_percent(70) # TODO help(disp.set_limits_percent)
# disp.set_limits_minmax(0, 400)
# plt.savefig('CT{:03d}_EV{:010d}_S{:02d}.png'.format(tel_num, event.dl0.event_id, ii))
# DISPLAY INTEGRATED EVENT ##############################################
#disp.image = event.dl0.tel[tel_num].adc_sums[channel] # ctapipe 0.3.0
disp.image = event.r0.tel[tel_num].adc_sums[channel] # ctapipe 0.4.0
#disp.set_limits_percent(70) # TODO help(disp.set_limits_percent)
disp.set_limits_minmax(0, 9000)
plt.savefig('CT{:03d}_EV{:010d}.png'.format(tel_num, event.dl0.event_id))
# PLOT ##################################################################
plt.show()
def plot_pixels_layout(simtel_file_path, tel_id):
source = hessio_event_source(simtel_file_path, allowed_tels=[tel_id])
for event in source:
#######################################################################
# CAUTION: #
# event.meta.optical_foclen and event.meta.tel_pos are only filled #
# when source is traversed ! #
# The current value of these two variables is not the actual value #
# for the current event but the cumulated value of past events ! #
#######################################################################
print("Event", event.dl0.event_id)
(pos_x_list, pos_y_list) = event.meta.pixel_pos[tel_id]
pos_x_list = [float(pos.value) for pos in pos_x_list]
pos_y_list = [float(pos.value) for pos in pos_y_list]
assert len(pos_x_list) == len(pos_y_list)
# PLOT ####################################################################
fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(10, 10))
# Scatter method ##################
ax.scatter(pos_x_list, # x
pos_y_list, # y
s=0.2, # radius
c="black", # color
alpha=0.75)
ax.plot(pos_x_list, # x
pos_y_list, # y
"k-",
alpha=0.25)
for pixel_index in range(len(pos_x_list)):
ax.text(pos_x_list[pixel_index], pos_y_list[pixel_index], str(pixel_index), fontsize=9)
ax.set_title("Pixels position (telescope {})".format(tel_id), fontsize=16)
ax.set_xlabel("x position (m)", fontsize=16)
ax.set_ylabel("y position (m)", fontsize=16)
plt.show()
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 get_num_events(Filename, right_tel):
try:
source = hessio_event_source(Filename, allowed_tels=right_tel)
except:
os.exit(1)
num_events = 0
anzahl_gesamt = 0
image1 = 0
image2 = 0
for event in source:
num_events += 1
for tel_id in event.r0.tels_with_data:
anzahl_gesamt += 1
camera_art = str(event.inst.subarray.tel[tel_id].camera)
if camera_art == "FlashCam":
image1 += 1
else:
image2 += 1
print(num_events)
print(anzahl_gesamt)
print(image1)
print(image2)
return num_events, image1, image2
def list_telescopes_geometry(simtel_file_path):
"""Print the list of triggered telescopes ID and geometry of the
'simtel_file_path' file.
Parameters
----------
simtel_file_path : str
The path of the simtel file to process.
"""
source = hessio_event_source(simtel_file_path)
tel_id_set = set()
for event in source:
for tel_id in event.r0.tels_with_data:
tel_id_set.add(tel_id)
for tel_id in tel_id_set:
x, y = event.inst.pixel_pos[tel_id]
foclen = event.inst.optical_foclen[tel_id]
geom = ctapipe.io.CameraGeometry.guess(x, y, foclen)
print("Telescope {:03d}: {} ({} pixels)".format(
tel_id, geom.cam_id, geom.pix_type))
def event_set_operations(simtel_file_path_list):
event_set_dict = {}
# For each simtel file...
for simtel_file_path in simtel_file_path_list:
event_set = set(
) # Set of events (or more exactly pairs (event_id, telescope_id))
source = hessio_event_source(simtel_file_path,
allowed_tels=None,
max_events=None)
for event in source:
event_id = event.dl0.event_id
for telescope_id in event.trig.tels_with_trigger:
event_set.add((int(event_id), int(telescope_id)))
if len(event_set) > 0:
# Ignore empty simtel files
event_set_dict[simtel_file_path] = event_set
return event_set_dict
def test_eventplotter():
dataset = get_dataset("gamma_test.simtel.gz")
source = hessio_event_source(dataset, max_events=1)
event = next(source)
del source
telid = list(event.r0.tels_with_data)[0]
data = event.r0.tel[telid].adc_samples[0]
plotter = CameraPlotter(event)
camera = plotter.draw_camera(telid, data[:, 0])
assert camera is not None
np.testing.assert_array_equal(camera.image, data[:, 0])
plotter.draw_camera_pixel_ids(telid, [0, 1, 2])
waveform = plotter.draw_waveform(data[0, :])
assert waveform is not None
np.testing.assert_array_equal(waveform.get_ydata(), data[0, :])
line = plotter.draw_waveform_positionline(0)
assert line is not None
np.testing.assert_array_equal(line.get_xdata(), [0, 0])
def plot_telarray_layout(simtel_file_path, show_labels=False):
# GET EVENT ###############################################################
source = hessio_event_source(simtel_file_path)
for event in source:
#######################################################################
# WARNING: #
# event.meta.optical_foclen and event.meta.tel_pos are only filled #
# when source is traversed ! #
# The current value of these two variables is not the actual value #
# for the current event but the cumulated value of past events ! #
#######################################################################
pass
#print("Event", event.dl0.event_id)
#print("tels_with_trigger", event.trig.tels_with_trigger)
#print("tels_with_data", event.dl0.tels_with_data)
#print("optical_foclen", event.meta.optical_foclen)
#print("tel_pos", event.meta.tel_pos)
# Print values
print()
print("optical_foclen:")
for telid, foclen in event.meta.optical_foclen.items():
print(" - TEL {:03d}: {}".format(telid, foclen))
print()
print("tel_pos:")
for telid, position in event.meta.tel_pos.items():
print(" - TEL {:03d}: {}".format(telid, position))
# Make a numpy array of telescopes position
tel_list = []
for tel_id, tel_pos in event.meta.tel_pos.items():
tel_id = int(tel_id)
tel_pos = [float(v.value) for v in tel_pos]
tel_foclen = float(event.meta.optical_foclen[tel_id].value)
tel_list.append([tel_id, *tel_pos, tel_foclen])
tel_array = np.array(tel_list)
#print(len(tel_array))
# PLOT ####################################################################
fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(10, 10))
# Patches method ##################
#for tel_id, pos_x, pos_y, pos_z, tel_foclen in tel_list:
# ax.add_patch(plt.Circle((pos_x, pos_y), radius=tel_foclen, color='red'))
#max_foclen = float(np.max(tel_array[:,4]))
#margin = 2. * max_foclen
#ax.set_xlim([np.min(tel_array[:,1]) - margin, np.max(tel_array[:,1]) + margin])
#ax.set_ylim([np.min(tel_array[:,2]) - margin, np.max(tel_array[:,2]) + margin])
# Scatter method ##################
ax.scatter(
tel_array[:, 1], # x
tel_array[:, 2], # y
s=tel_array[:, 4], # radius
c=tel_array[:, 4], # color
alpha=0.75)
## Highlight some telescopes
#ax.scatter(tel_array[:,1], # x
# tel_array[:,2], # y
# s=tel_array[:,4], # radius
# c="gray", # color
# alpha=0.25)
#for n in range(1-1, 4):
# ax.scatter(tel_array[n,1], # x
# tel_array[n,2], # y
# s=32, # radius
# c="red") # color
if show_labels:
for tel_id, pos_x, pos_y, pos_z, tel_foclen in tel_list:
ax.text(pos_x + tel_foclen / 2., pos_y, str(tel_id), fontsize=9)
#ax.set_title("Telescopes position for " + simtel_file_path)
ax.set_title("Telescopes position", fontsize=16)
ax.set_xlabel("x position (m)", fontsize=16)
ax.set_ylabel("y position (m)", fontsize=16)
plt.savefig("telarray.pdf", bbox_inches='tight')
plt.show()
def extract_images(simtel_file_path,
tel_id_filter_list=None,
event_id_filter_list=None,
output_directory=None):
# EXTRACT IMAGES ##########################################################
# hessio_event_source returns a Python generator that streams data from an
# EventIO/HESSIO MC data file (e.g. a standard CTA data file).
# This generator contains ctapipe.core.Container instances ("event").
#
# Parameters:
# - max_events: maximum number of events to read
# - allowed_tels: select only a subset of telescope, if None, all are read.
source = hessio_event_source(simtel_file_path,
allowed_tels=tel_id_filter_list)
# ITERATE OVER EVENTS #####################################################
calib = CameraCalibrator(None, None)
for event in source:
calib.calibrate(event) # calibrate the event
event_id = int(event.dl0.event_id)
if (event_id_filter_list is None) or (event_id
in event_id_filter_list):
#print("event", event_id)
# ITERATE OVER IMAGES #############################################
for tel_id in event.trig.tels_with_trigger:
tel_id = int(tel_id)
if tel_id in tel_id_filter_list:
#print("telescope", tel_id)
# CHECK THE IMAGE GEOMETRY ################################
#print("checking geometry")
x, y = event.inst.subarray.tel[
tel_id].camera.pix_x, event.inst.subarray.tel[
tel_id].camera.pix_y
foclen = event.inst.subarray.tel[
tel_id].optics.equivalent_focal_length
geom = CameraGeometry.guess(x, y, foclen)
if (geom.pix_type != "hexagonal") or (geom.cam_id !=
"DigiCam"):
raise ValueError(
"Telescope {}: error (the input image is not a valide DigiCam telescope image) -> {} ({})"
.format(tel_id, geom.pix_type, geom.cam_id))
# GET IMAGES ##############################################
pe_image = event.mc.tel[
tel_id].photo_electron_image # 1D np array
#uncalibrated_image = event.dl0.tel[tel_id].adc_sums # ctapipe 0.3.0
uncalibrated_image = event.r0.tel[
tel_id].adc_sums # ctapipe 0.4.0
pedestal = event.mc.tel[tel_id].pedestal
gain = event.mc.tel[tel_id].dc_to_pe
pixel_pos = (event.inst.subarray.tel[tel_id].camera.pix_x,
event.inst.subarray.tel[tel_id].camera.pix_y)
calibrated_image = event.dl1.tel[tel_id].image
#print(pe_image.shape)
#print(calibrated_image.shape)
#print(uncalibrated_image.shape)
#print(pedestal.shape)
#print(gain.shape)
#print(pixel_pos.shape)
#print(pixel_pos[0])
#print(pixel_pos[1])
# CONVERTING GEOMETRY (1D TO 2D) ##########################
buffer_id_str = geom.cam_id + "0"
geom2d, pe_image_2d = ctapipe_geom_converter.convert_geometry_1d_to_2d(
geom, pe_image, buffer_id_str, add_rot=0)
geom2d, calibrated_image_2d = ctapipe_geom_converter.convert_geometry_1d_to_2d(
geom, calibrated_image[0], buffer_id_str, add_rot=0)
geom2d, uncalibrated_image_2d = ctapipe_geom_converter.convert_geometry_1d_to_2d(
geom, uncalibrated_image[0], buffer_id_str, add_rot=0)
geom2d, pedestal_2d = ctapipe_geom_converter.convert_geometry_1d_to_2d(
geom, pedestal[0], buffer_id_str, add_rot=0)
geom2d, gains_2d = ctapipe_geom_converter.convert_geometry_1d_to_2d(
geom, gain[0], buffer_id_str, add_rot=0)
# Make a mock pixel position array...
pixel_pos_2d = np.array(
np.meshgrid(
np.linspace(pixel_pos[0].min(), pixel_pos[0].max(),
pe_image_2d.shape[0]),
np.linspace(pixel_pos[1].min(), pixel_pos[1].max(),
pe_image_2d.shape[1])))
# PUT NAN IN BLANK PIXELS #################################
calibrated_image_2d[np.logical_not(geom2d.mask)] = np.nan
pe_image_2d[np.logical_not(geom2d.mask)] = np.nan
uncalibrated_image_2d[np.logical_not(geom2d.mask)] = np.nan
pedestal_2d[np.logical_not(geom2d.mask)] = np.nan
gains_2d[np.logical_not(geom2d.mask)] = np.nan
pixel_pos_2d[0, np.logical_not(geom2d.mask)] = np.nan
pixel_pos_2d[1, np.logical_not(geom2d.mask)] = np.nan
###########################################################
# The ctapipe geometry converter operate on one channel
# only and then takes and return a 2D array but pywicta
# fits files keep all channels and thus takes 3D arrays...
uncalibrated_image_2d = np.array([uncalibrated_image_2d])
pedestal_2d = np.array([pedestal_2d])
gains_2d = np.array([gains_2d])
###########################################################
#print(pe_image_2d.shape)
#print(calibrated_image_2d.shape)
#print(uncalibrated_image_2d.shape)
#print(pedestal_2d.shape)
#print(gains_2d.shape)
#img = pixel_pos_2d
#print(img[1])
#import matplotlib.pyplot as plt
#im = plt.imshow(img[1])
#plt.colorbar(im)
#plt.show()
#sys.exit(0)
# GET PIXEL MASK ##########################################
pixel_mask = geom2d.mask.astype(
int
) # 1 for pixels with actual data, 0 for virtual (blank) pixels
# MAKE METADATA ###########################################
metadata = {}
metadata[
'version'] = 1 # Version of the pywicta fits format
metadata['cam_id'] = "DigiCam"
metadata['tel_id'] = tel_id
metadata['event_id'] = event_id
metadata['simtel'] = simtel_file_path
metadata['tel_trig'] = len(event.trig.tels_with_trigger)
metadata['energy'] = quantity_to_tuple(
event.mc.energy, 'TeV')
metadata['mc_az'] = quantity_to_tuple(event.mc.az, 'rad')
metadata['mc_alt'] = quantity_to_tuple(event.mc.alt, 'rad')
metadata['mc_corex'] = quantity_to_tuple(
event.mc.core_x, 'm')
metadata['mc_corey'] = quantity_to_tuple(
event.mc.core_y, 'm')
metadata['mc_hfi'] = quantity_to_tuple(
event.mc.h_first_int, 'm')
metadata['count'] = int(event.count)
metadata['run_id'] = int(event.dl0.obs_id)
metadata['tel_data'] = len(event.dl0.tels_with_data)
metadata['foclen'] = quantity_to_tuple(
event.inst.subarray.tel[tel_id].optics.
equivalent_focal_length, 'm')
metadata['tel_posx'] = quantity_to_tuple(
event.inst.subarray.tel_coords[tel_id].x, 'm')
metadata['tel_posy'] = quantity_to_tuple(
event.inst.subarray.tel_coords[tel_id].y, 'm')
metadata['tel_posz'] = quantity_to_tuple(
event.inst.subarray.tel_coords[tel_id].z, 'm')
# TODO: Astropy fails to store the following data in FITS files
#metadata['uid'] = os.getuid()
#metadata['datetime'] = str(datetime.datetime.now())
#metadata['version'] = VERSION
#metadata['argv'] = " ".join(sys.argv).encode('ascii', errors='ignore').decode('ascii')
#metadata['python'] = " ".join(sys.version.splitlines()).encode('ascii', errors='ignore').decode('ascii')
#metadata['system'] = " ".join(os.uname())
# SAVE THE IMAGE ##########################################
output_file_path_template = "{}_TEL{:03d}_EV{:05d}.fits"
if output_directory is not None:
simtel_basename = os.path.basename(simtel_file_path)
prefix = os.path.join(output_directory,
simtel_basename)
else:
prefix = simtel_file_path
output_file_path = output_file_path_template.format(
prefix, tel_id, event_id)
print("saving", output_file_path)
images.save_benchmark_images(
img=calibrated_image_2d,
pe_img=pe_image_2d,
adc_sums_img=uncalibrated_image_2d,
pedestal_img=pedestal_2d,
gains_img=gains_2d,
pixel_pos=pixel_pos_2d,
pixel_mask=pixel_mask,
metadata=metadata,
output_file_path=output_file_path)
image.save("test_images/test_" + str(GLOBAL_COUNT) + ".png")
global GLOBAL_COUNT
GLOBAL_COUNT += 1
return im_array
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description='Reads event parameters directly from simtel files.')
parser.add_argument('data_file', help='path to input .simtel file')
args = parser.parse_args()
# load camera types from first event, take note of
source = hessio_event_source(args.data_file, max_events=1)
LST_list = []
SCT_list = []
SST_list = []
for event in source:
for i in event.inst.telescope_ids:
if event.inst.num_pixels[i] == 11328:
SCT_list.append(i)
elif event.inst.num_pixels[i] == 1855:
LST_list.append(i)
# elif event.inst.num_pixels[i] ==
# camera calibrator
cal = CameraCalibrator(None, None)
default=get_example_simtelarray_file())
parser.add_argument('-m', '--max-events', type=int, default=10)
parser.add_argument('-c', '--channel', type=int, default=0)
parser.add_argument('-w',
'--write',
action='store_true',
help='write images to files')
parser.add_argument('-s',
'--show-samples',
action='store_true',
help='show time-variablity, one frame at a time')
args = parser.parse_args()
source = hessio_event_source(args.filename,
allowed_tels=[
args.tel,
],
max_events=args.max_events)
disp = None
print('SELECTING EVENTS FROM TELESCOPE {}'.format(args.tel))
print('=' * 70)
for event in source:
print('Scanning input file... count = {}'.format(event.count))
print(event.trig)
print(event.mc)
print(event.dl0)
if disp is None:
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)
tel, cam, opt = ID.load(args.filename)
# Load the DL0 events into the generator source
source = hessio_event_source(args.filename)
print(args.tel_id)
# Display the calibrated results into camera displays
if args.display:
if args.tel_id is not None:
display_telescope(source,cam,int(args.tel_id),args.pdffilename)
else:
logger.error("[event] please specify one telescope "
"(given in the file name) ")
exit()
logger.info("[COMPLETE]")
sys.stdout.flush()
filenamelist = glob( "{}*run{}*gz".format(args.indir,args.runnr ))
if len(filenamelist) == 0:
print("no files found; check indir: {}".format(args.indir))
exit(-1)
fit = FitGammaLikelihood()
fit.set_atmosphere("atmprof_paranal.dat")
fit.set_instrument_description( *load_hessio(filenamelist[0]) )
signal.signal(signal.SIGINT, signal_handler)
for filename in sorted(filenamelist):
print("filename = {}".format(filename))
source = hessio_event_source(filename,
# for now use only identical telescopes...
allowed_tels=[1,2,3,4],
#allowed_tels=TelDict[args.teltype],
max_events=args.max_events)
for event in source:
## TODO replace with actual pixel direction when they become available
#for tel_id in event.dl0.tels_with_data:
#if tel_id not in fit.pix_dirs:
#geom = 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)
#fit.pix_dirs[tel_id] = guessPixDirectionFocLength(geom.pix_x, geom.pix_y, tel_phi, tel_theta, fit.telescopes['FL'][tel_id-1] * u.m)
print('Scanning input file... count = {}'.format(event.count))
print('available telscopes: {}'.format(event.dl0.tels_with_data))
fit.fill_pdf(event=event)
def main():
# your favourite units here
energy_unit = u.TeV
angle_unit = u.deg
dist_unit = u.m
parser = make_argparser()
parser.add_argument(
'-o',
'--outfile',
type=str,
help="if given, write output file with reconstruction results")
parser.add_argument('--plot_c',
action='store_true',
help="plot camera-wise displays")
group = parser.add_mutually_exclusive_group()
group.add_argument('--proton',
action='store_true',
help="do protons instead of gammas")
group.add_argument('--electron',
action='store_true',
help="do electrons instead of gammas")
args = parser.parse_args()
if args.infile_list:
filenamelist = []
for f in args.infile_list:
filenamelist += glob("{}/{}".format(args.indir, f))
elif args.proton:
filenamelist = glob("{}/proton/*gz".format(args.indir))
channel = "proton"
elif args.electron:
filenamelist = glob("{}/electron/*gz".format(args.indir))
channel = "electron"
elif args.gamma:
filenamelist = glob("{}/gamma/*gz".format(args.indir))
channel = "gamma"
else:
raise ValueError("don't know which input to use...")
filenamelist.sort()
if not filenamelist:
print("no files found; check indir: {}".format(args.indir))
exit(-1)
else:
print("found {} files".format(len(filenamelist)))
tel_phi = {}
tel_theta = {}
# keeping track of events and where they were rejected
Eventcutflow = CutFlow("EventCutFlow")
Imagecutflow = CutFlow("ImageCutFlow")
# takes care of image cleaning
cleaner = ImageCleaner(mode=args.mode,
cutflow=Imagecutflow,
wavelet_options=args.raw,
skip_edge_events=args.skip_edge_events,
island_cleaning=True)
# the class that does the shower reconstruction
shower_reco = HillasReconstructor()
shower_max_estimator = ShowerMaxEstimator("paranal")
preper = EventPreparer(
cleaner=cleaner,
hillas_parameters=hillas_parameters,
shower_reco=shower_reco,
event_cutflow=Eventcutflow,
image_cutflow=Imagecutflow,
# event/image cuts:
allowed_cam_ids=[], # means: all
min_ntel=3,
min_charge=args.min_charge,
min_pixel=3)
# a signal handler to abort the event loop but still do the post-processing
signal_handler = SignalHandler()
signal.signal(signal.SIGINT, signal_handler)
try:
# this class defines the reconstruction parameters to keep track of
class RecoEvent(tb.IsDescription):
NTels_trigg = tb.Int16Col(dflt=1, pos=0)
NTels_clean = tb.Int16Col(dflt=1, pos=1)
EnMC = tb.Float32Col(dflt=1, pos=2)
xi = tb.Float32Col(dflt=1, pos=3)
DeltaR = tb.Float32Col(dflt=1, pos=4)
ErrEstPos = tb.Float32Col(dflt=1, pos=5)
ErrEstDir = tb.Float32Col(dflt=1, pos=6)
h_max = tb.Float32Col(dflt=1, pos=7)
reco_outfile = tb.open_file(
args.outfile,
mode="w",
# if we don't want to write the event list to disk, need to add more arguments
**({} if args.store else {
"driver": "H5FD_CORE",
"driver_core_backing_store": False
}))
reco_table = reco_outfile.create_table("/", "reco_event", RecoEvent)
reco_event = reco_table.row
except:
reco_event = RecoEvent()
print("no pytables installed?")
# ## ####### ####### ########
# ## ## ## ## ## ## ##
# ## ## ## ## ## ## ##
# ## ## ## ## ## ########
# ## ## ## ## ## ##
# ## ## ## ## ## ##
# ######## ####### ####### ##
cam_id_map = {}
# define here which telescopes to loop over
allowed_tels = None
# allowed_tels = prod3b_tel_ids("L+F+D")
for i, filename in enumerate(filenamelist[:args.last]):
print("file: {i} filename = {filename}".format(i=i, filename=filename))
source = hessio_event_source(filename,
allowed_tels=allowed_tels,
max_events=args.max_events)
# loop that cleans and parametrises the images and performs the reconstruction
for (event, hillas_dict, n_tels, tot_signal, max_signal, pos_fit,
dir_fit, h_max, err_est_pos,
err_est_dir) in preper.prepare_event(source):
shower = event.mc
org_alt = u.Quantity(shower.alt).to(u.deg)
org_az = u.Quantity(shower.az).to(u.deg)
if org_az > 180 * u.deg:
org_az -= 360 * u.deg
org_the = alt_to_theta(org_alt)
org_phi = az_to_phi(org_az)
if org_phi > 180 * u.deg:
org_phi -= 360 * u.deg
if org_phi < -180 * u.deg:
org_phi += 360 * u.deg
shower_org = linalg.set_phi_theta(org_phi, org_the)
shower_core = convert_astropy_array([shower.core_x, shower.core_y])
xi = linalg.angle(dir_fit, shower_org).to(angle_unit)
diff = linalg.length(pos_fit[:2] - shower_core)
# print some performance
print()
print("xi = {:4.3f}".format(xi))
print("pos = {:4.3f}".format(diff))
print("h_max reco: {:4.3f}".format(h_max.to(u.km)))
print("err_est_dir: {:4.3f}".format(err_est_dir.to(angle_unit)))
print("err_est_pos: {:4.3f}".format(err_est_pos))
try:
# store the reconstruction data in the PyTable
reco_event["NTels_trigg"] = n_tels["tot"]
reco_event["NTels_clean"] = len(shower_reco.circles)
reco_event["EnMC"] = event.mc.energy / energy_unit
reco_event["xi"] = xi / angle_unit
reco_event["DeltaR"] = diff / dist_unit
reco_event["ErrEstPos"] = err_est_pos / dist_unit
reco_event["ErrEstDir"] = err_est_dir / angle_unit
reco_event["h_max"] = h_max / dist_unit
reco_event.append()
reco_table.flush()
print()
print("xi res (68-percentile) = {:4.3f} {}".format(
np.percentile(reco_table.cols.xi, 68), angle_unit))
print("core res (68-percentile) = {:4.3f} {}".format(
np.percentile(reco_table.cols.DeltaR, 68), dist_unit))
print("h_max (median) = {:4.3f} {}".format(
np.percentile(reco_table.cols.h_max, 50), dist_unit))
except NoPyTables:
pass
if args.plot_c:
from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure()
ax = fig.gca(projection='3d')
for c in shower_reco.circles.values():
points = [
c.pos + t * c.a * u.km for t in np.linspace(0, 15, 3)
]
ax.plot(*np.array(points).T,
linewidth=np.sqrt(c.weight) / 10)
ax.scatter(*c.pos[:, None].value, s=np.sqrt(c.weight))
plt.xlabel("x")
plt.ylabel("y")
plt.pause(.1)
# this plots
# • the MC shower core
# • the reconstructed shower core
# • the used telescopes
# • and the trace of the Hillas plane on the ground
plt.figure()
for tel_id, c in shower_reco.circles.items():
plt.scatter(c.pos[0], c.pos[1], s=np.sqrt(c.weight))
plt.gca().annotate(tel_id,
(c.pos[0].value, c.pos[1].value))
plt.plot([
c.pos[0].value - 500 * c.norm[1],
c.pos[0].value + 500 * c.norm[1]
], [
c.pos[1].value + 500 * c.norm[0],
c.pos[1].value - 500 * c.norm[0]
],
linewidth=np.sqrt(c.weight) / 10)
plt.scatter(*pos_fit[:2],
c="black",
marker="*",
label="fitted")
plt.scatter(*shower_core[:2],
c="black",
marker="P",
label="MC")
plt.legend()
plt.xlabel("x")
plt.ylabel("y")
plt.xlim(-1400, 1400)
plt.ylim(-1400, 1400)
plt.show()
if signal_handler.stop: break
if signal_handler.stop: break
print("\n" + "=" * 35 + "\n")
print("xi res (68-percentile) = {:4.3f} {}".format(
np.percentile(reco_table.cols.xi, 68), angle_unit))
print("core res (68-percentile) = {:4.3f} {}".format(
np.percentile(reco_table.cols.DeltaR, 68), dist_unit))
print("h_max (median) = {:4.3f} {}".format(
np.percentile(reco_table.cols.h_max, 50), dist_unit))
# print the cutflows for telescopes and camera images
print("\n\n")
Eventcutflow("min2Tels trig")
print()
Imagecutflow(sort_column=1)
# if we don't want to plot anything, we can exit now
if not args.plot:
return
# ######## ## ####### ######## ######
# ## ## ## ## ## ## ## ##
# ## ## ## ## ## ## ##
# ######## ## ## ## ## ######
# ## ## ## ## ## ##
# ## ## ## ## ## ## ##
# ## ######## ####### ## ######
plt.figure()
plt.hist(reco_table.cols.h_max, bins=np.linspace(000, 15000, 51, True))
plt.title(channel)
plt.xlabel("h_max reco")
plt.pause(.1)
figure = plt.figure()
xi_edges = np.linspace(0, 5, 20)
plt.hist(reco_table.cols.xi, bins=xi_edges, log=True)
plt.xlabel(r"$\xi$ / deg")
if args.write:
save_fig('{}/reco_xi_{}'.format(args.plots_dir, args.mode))
plt.pause(.1)
plt.figure()
plt.hist(reco_table.cols.ErrEstDir[:], bins=np.linspace(0, 20, 50))
plt.title(channel)
plt.xlabel("beta")
plt.pause(.1)
plt.figure()
plt.hist(np.log10(reco_table.cols.xi[:] / reco_table.cols.ErrEstDir[:]),
bins=50)
plt.title(channel)
plt.xlabel("log_10(xi / beta)")
plt.pause(.1)
# convert the xi-list into a dict with the number of used telescopes as keys
xi_vs_tel = {}
for xi, ntel in zip(reco_table.cols.xi, reco_table.cols.NTels_clean):
if ntel not in xi_vs_tel:
xi_vs_tel[ntel] = [xi]
else:
xi_vs_tel[ntel].append(xi)
print(args.mode)
for ntel, xis in sorted(xi_vs_tel.items()):
print("NTel: {} -- median xi: {}".format(ntel, np.median(xis)))
# print("histogram:", np.histogram(xis, bins=xi_edges))
# create a list of energy bin-edges and -centres for violin plots
Energy_edges = np.linspace(2, 8, 13)
Energy_centres = (Energy_edges[1:] + Energy_edges[:-1]) / 2.
# convert the xi-list in to an energy-binned dict with the bin centre as keys
xi_vs_energy = {}
for en, xi in zip(reco_table.cols.EnMC, reco_table.cols.xi):
# get the bin number this event belongs into
sbin = np.digitize(np.log10(en), Energy_edges) - 1
# the central value of the bin is the key for the dictionary
if Energy_centres[sbin] not in xi_vs_energy:
xi_vs_energy[Energy_centres[sbin]] = [xi]
else:
xi_vs_energy[Energy_centres[sbin]] += [xi]
# plotting the angular error as violin plots with binning in
# number of telescopes and shower energy
figure = plt.figure()
plt.subplot(211)
plt.violinplot([np.log10(a) for a in xi_vs_tel.values()],
[a for a in xi_vs_tel.keys()],
points=60,
widths=.75,
showextrema=False,
showmedians=True)
plt.xlabel("Number of Telescopes")
plt.ylabel(r"log($\xi$ / deg)")
plt.ylim(-3, 2)
plt.grid()
plt.subplot(212)
plt.violinplot([np.log10(a) for a in xi_vs_energy.values()],
[a for a in xi_vs_energy.keys()],
points=60,
widths=(Energy_edges[1] - Energy_edges[0]) / 1.5,
showextrema=False,
showmedians=True)
plt.xlabel(r"log(Energy / GeV)")
plt.ylabel(r"log($\xi$ / deg)")
plt.ylim(-3, 2)
plt.grid()
plt.tight_layout()
if args.write:
save_fig('{}/reco_xi_vs_E_NTel_{}'.format(args.plots_dir, args.mode))
plt.pause(.1)
# convert the diffs-list into a dict with the number of used telescopes as keys
diff_vs_tel = {}
for diff, ntel in zip(reco_table.cols.DeltaR, reco_table.cols.NTels_clean):
if ntel not in diff_vs_tel:
diff_vs_tel[ntel] = [diff]
else:
diff_vs_tel[ntel].append(diff)
# convert the diffs-list in to an energy-binned dict with the bin centre as keys
diff_vs_energy = {}
for en, diff in zip(reco_table.cols.EnMC, reco_table.cols.DeltaR):
# get the bin number this event belongs into
sbin = np.digitize(np.log10(en), Energy_edges) - 1
# the central value of the bin is the key for the dictionary
if Energy_centres[sbin] not in diff_vs_energy:
diff_vs_energy[Energy_centres[sbin]] = [diff]
else:
diff_vs_energy[Energy_centres[sbin]] += [diff]
# plotting the core position error as violin plots with binning in
# number of telescopes an shower energy
plt.figure()
plt.subplot(211)
plt.violinplot([np.log10(a) for a in diff_vs_tel.values()],
[a for a in diff_vs_tel.keys()],
points=60,
widths=.75,
showextrema=False,
showmedians=True)
plt.xlabel("Number of Telescopes")
plt.ylabel(r"log($\Delta R$ / m)")
plt.grid()
plt.subplot(212)
plt.violinplot([np.log10(a) for a in diff_vs_energy.values()],
[a for a in diff_vs_energy.keys()],
points=60,
widths=(Energy_edges[1] - Energy_edges[0]) / 1.5,
showextrema=False,
showmedians=True)
plt.xlabel(r"log(Energy / GeV)")
plt.ylabel(r"log($\Delta R$ / m)")
plt.grid()
plt.tight_layout()
if args.write:
save_fig('{}/reco_dist_vs_E_NTel_{}'.format(args.plots_dir, args.mode))
plt.show()
"""
The most basic pipeline, using no special features of the framework other
than a for-loop. This is useful for debugging and profiling of speed.
"""
import sys
import numpy as np
from ctapipe.calib import CameraCalibrator
from ctapipe.io.hessio import hessio_event_source
if __name__ == '__main__':
filename = sys.argv[1]
source = hessio_event_source(filename, max_events=None)
cal = CameraCalibrator(None, None)
for data in source:
print("EVENT: {}, ENERGY: {:.2f}, TELS:{}".format(
data.r0.event_id, data.mc.energy, len(data.dl0.tels_with_data)))
cal.calibrate(data)
# now the calibrated images are in data.dl1.tel[x].image
disp = None
dirpath = '/Users/armstrongt/Workspace/CTA/CHEC-S-ASTRI/sicily_analysis/scripts/'
filelist = np.loadtxt(sys.argv[1], dtype=str)
# for ep in eps:
if write is True:
outfile = open('%shillas_parameters_gamma_mc.dat' % (dirpath), 'w')
outfile.write(
'#ID[0],size[1],cenX[2],cenY[3],l[4],w[5],r[6],phi[7],psi[8],miss[9],skewness[10],kurtosis[11], '
'recox[12], recoy[13], maxpe [14] || MC: ||, energy[15], alt[16], az[17], core_x[18], core_y[19],'
'hfirstint[20\n')
for filename in filelist:
source = hessio_event_source(filename, max_events=1000)
for event in source:
try:
calib.calibrate(event)
if display_each is True:
if disp is None:
geom = event.inst.subarray.tel[1].camera
disp = CameraDisplay(geom)
disp.add_colorbar()
plt.show(block=False)
else:
geom = event.inst.subarray.tel[1].camera
im = event.dl1.tel[1].image[0]
mask = tailcuts_clean(geom,
im,
picture_thresh=10,
if len(sys.argv) > 1:
filename = sys.argv.pop(1)
else:
filename = get_dataset("gamma_test.simtel.gz")
# set a fixed window (for now from samples 20 to the end), which may not
# be appropriate for all telescopes (this should eventually be
# chosen based on the telescope type, since some have shorter
# sample windows:
start = 15
end = None # None means through sample
# loop over all events, all telescopes and all channels and call
# the calc_peds function defined above to do some work:
for event in hessio_event_source(filename):
for telid in event.r0.tels_with_data:
for chan in range(event.r0.tel[telid].adc_samples.shape[0]):
print("CT{} chan {}:".format(telid, chan))
traces = event.r0.tel[telid].adc_samples[chan, ...]
peds, pedvars = pedestals.calc_pedestals_from_traces(
traces, start, end)
print("Number of samples: {}".format(traces.shape[1]))
print("Calculate over window:({},{})".format(start, end))
print("PEDS:", peds)
print("VARS:", pedvars)
print("-----")
from pyspark import SparkContext
from pyspark.streaming import StreamingContext
from pyspark.streaming.kafka import KafkaUtils
from ctapipe.image.cleaning import tailcuts_clean
from ctapipe.io import CameraGeometry
from ctapipe.image.hillas import hillas_parameters, HillasParameterizationError
from astropy import units as u
import msgpack
import msgpack_numpy as m
from ctapipe.reco.FitGammaHillas import FitGammaHillas
from ctapipe.io.hessio import hessio_event_source
# we read the instrument configuration from an arbitrary simtel file
# instrument info does not change per event. (except for pointing maybe)
source = hessio_event_source('gamma_test.simtel.gz', max_events=7)
instrument = next(source).inst
# Create a local StreamingContext with three working threads and batch
# interval of 5 seconds
sc = SparkContext('local[3]', 'test app')
broadcastInst = sc.broadcast(instrument)
ssc = StreamingContext(sc, 5)
def reco(single_telescope_data):
fit = FitGammaHillas()
inst = broadcastInst.value
hillas_dict, tel_phi, tel_theta = single_telescope_data
fit_result = fit.predict(hillas_dict, inst, tel_phi, tel_theta)
def extract_images(simtel_file_path,
tel_id_filter_list=None,
event_id_filter_list=None,
output_directory=None):
# EXTRACT IMAGES ##########################################################
# hessio_event_source returns a Python generator that streams data from an
# EventIO/HESSIO MC data file (e.g. a standard CTA data file).
# This generator contains ctapipe.core.Container instances ("event").
#
# Parameters:
# - max_events: maximum number of events to read
# - allowed_tels: select only a subset of telescope, if None, all are read.
source = hessio_event_source(simtel_file_path,
allowed_tels=tel_id_filter_list)
# ITERATE OVER EVENTS #####################################################
for event in source:
event_id = int(event.dl0.event_id)
if (event_id_filter_list is None) or (event_id
in event_id_filter_list):
print("event", event_id)
# ITERATE OVER IMAGES #############################################
for tel_id in event.trig.tels_with_trigger:
tel_id = int(tel_id)
if tel_id in tel_id_filter_list:
print("telescope", tel_id)
# CHECK THE IMAGE GEOMETRY (ASTRI ONLY) ###################
# TODO
print("checking geometry")
x, y = event.meta.pixel_pos[tel_id]
foclen = event.meta.optical_foclen[tel_id]
geom = ctapipe.io.CameraGeometry.guess(x, y, foclen)
if (geom.pix_type != "rectangular") or (geom.cam_id !=
"ASTRI"):
raise ValueError(
"Telescope {}: error (the input image is not a valide ASTRI telescope image)"
.format(tel_id))
# GET AND CROP THE IMAGE ##################################
# uncalibrated_image = [1D numpy array of channel1, 1D numpy array of channel2]
# calibrated_image = 1D numpy array
print("calibrating")
adc_channel_0 = event.dl0.tel[tel_id].adc_sums[0] # TODO
adc_channel_1 = event.dl0.tel[tel_id].adc_sums[1] # TODO
uncalibrated_image = np.array(
[adc_channel_0, adc_channel_1])
calibrated_image = apply_mc_calibration(
uncalibrated_image, tel_id)
print("cropping ADC image")
cropped_img = crop_astri_image(calibrated_image)
# GET AND CROP THE PHOTOELECTRON IMAGE ####################
pe_image = event.mc.tel[
tel_id].photo_electrons # 1D np array
print("cropping PE image")
cropped_pe_img = crop_astri_image(pe_image)
# SAVE THE IMAGE ##########################################
output_file_path_template = "{}_EV{:05d}_TEL{:03d}.fits"
if output_directory is not None:
simtel_basename = os.path.basename(simtel_file_path)
prefix = os.path.join(output_directory,
simtel_basename)
else:
prefix = simtel_file_path
output_file_path = output_file_path_template.format(
prefix, event_id, tel_id)
print("saving", output_file_path)
metadata = {}
metadata['tel_id'] = tel_id
metadata['foclen'] = quantity_to_tuple(
event.meta.optical_foclen[tel_id], 'm')
metadata['event_id'] = event_id
metadata['energy'] = quantity_to_tuple(
event.mc.energy, 'TeV')
metadata['mc_az'] = quantity_to_tuple(event.mc.az, 'rad')
metadata['mc_alt'] = quantity_to_tuple(event.mc.alt, 'rad')
metadata['mc_corex'] = quantity_to_tuple(
event.mc.core_x, 'm')
metadata['mc_corey'] = quantity_to_tuple(
event.mc.core_y, 'm')
save_fits(cropped_img, cropped_pe_img, output_file_path,
metadata)
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 get_charge(self):
fig = plt.figure(1)
ax = fig.add_subplot(111)
calculator = ChargeResolutionCalculator(config=None, tool=None)
calculator2 = ChargeResolutionCalculator(config=None, tool=None)
pevals = [
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 20,
21, 23, 24, 26, 28, 30, 32, 35, 37, 40, 43, 46, 49, 53, 57, 61, 65,
70, 75, 81, 86, 93, 100, 107, 114, 123, 132, 141, 151, 162, 174,
187, 200, 215, 231, 247, 265, 284, 305, 327, 351, 376, 403, 432,
464, 497, 533, 572, 613, 657, 705, 756, 811, 869, 932, 1000
]
for n, i in enumerate(pevals):
self.filename = '/Users/armstrongt/Workspace/CTA/MCValidation/data/bypass2_enoise_pe_e%s.simtel.gz' % n
ntrig = 0
source = hessio_event_source(self.filename,
allowed_tels=None,
max_events=None)
for event in source:
self.calib.calibrate(event)
true_charge = event.mc.tel[
1].photo_electron_image * self.pixel_mask
measured_charge = event.dl1.tel[1].image[0] * self.pixel_mask
true_charge2 = np.asarray(
[int(i)] * len(measured_charge)) * self.pixel_mask
calculator.add_charges(true_charge, measured_charge)
calculator2.add_charges(true_charge2, measured_charge)
ntrig = ntrig + 1
x, res, res_error, scaled_res, scaled_res_error = calculator.get_charge_resolution(
)
x2, res2, res_error2, scaled_res2, scaled_res_error2 = calculator2.get_charge_resolution(
)
ax.errorbar(x,
res,
yerr=res_error,
marker='x',
linestyle="None",
label='MC Charge Res')
ax.errorbar(x2,
res2,
yerr=res_error2,
marker='x',
color='C1',
linestyle="None",
label='\'Lab\' Charge Res')
x = np.logspace(np.log10(0.9), np.log10(1000 * 1.1), 100)
requirement = ChargeResolutionCalculator.requirement(x)
goal = ChargeResolutionCalculator.goal(x)
poisson = ChargeResolutionCalculator.poisson(x)
r_p = ax.plot(x, requirement, 'r', ls='--', label='Requirement')
g_p = ax.plot(x, goal, 'g', ls='--', label='Goal')
p_p = ax.plot(x, poisson, c='0.75', ls='--', label='Poisson')
plt.legend()
plt.yscale('log')
plt.xscale('log')
plt.xlabel('true charge')
plt.ylabel('charge resolution')
plt.show()
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
Imagecutflow.add_cut("features nan", lambda x: np.isnan(x).any())
energy_mc = []
energy_rec = []
filenamelist_gamma = sorted(glob("{}/gamma/*gz".format(args.indir)))
filenamelist_gamma = sorted(
glob(expandvars("$CTA_DATA/Prod3b/Paranal/*simtel.gz")))
allowed_tels = prod3b_tel_ids("L+N+D")
for filename in filenamelist_gamma[:5][:args.last]:
print("filename = {}".format(filename))
source = hessio_event_source(filename,
allowed_tels=allowed_tels,
max_events=args.max_events)
# loop that cleans and parametrises the images and performs the reconstruction
for (event, hillas_dict, n_tels, tot_signal, max_signals, pos_fit,
dir_fit, h_max, err_est_pos,
err_est_dir) in preper.prepare_event(source):
# now prepare the features for the classifier
cls_features_evt = {}
reg_features_evt = {}
for tel_id in hillas_dict.keys():
Imagecutflow.count("pre-features")
tel_pos = np.array(event.inst.tel_pos[tel_id][:2]) * u.m
def test_array_draw():
filename = get_dataset("gamma_test.simtel.gz")
cam_geom = {}
source = hessio_event_source(filename, max_events=2)
r1 = HessioR1Calibrator(None, None)
dl0 = CameraDL0Reducer(None, None)
calibrator = CameraDL1Calibrator(None, None)
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]
x, y = event.inst.pixel_pos[tel_id]
fl = event.inst.optical_foclen[tel_id]
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])
# Transform the pixels positions into nominal coordinates
camera_coord = CameraFrame(x=x,
y=y,
z=np.zeros(x.shape) * u.m,
focal_length=fl,
rotation=90 * u.deg -
cam_geom[tel_id].cam_rotation)
nom_coord = camera_coord.transform_to(
NominalFrame(array_direction=array_pointing,
pointing_direction=array_pointing))
mask = tailcuts_clean(cam_geom[tel_id],
pmt_signal,
picture_thresh=10.,
boundary_thresh=5.)
try:
moments = hillas_parameters(nom_coord.x, nom_coord.y,
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 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
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 main():
# your favourite units here
energy_unit = u.TeV
angle_unit = u.deg
dist_unit = u.m
agree_threshold = .5
min_tel = 3
parser = make_argparser()
parser.add_argument('--classifier',
type=str,
default=expandvars(
"$CTA_SOFT/tino_cta/data/classifier_pickle/"
"classifier_{mode}_{cam_id}_{classifier}.pkl"))
parser.add_argument('--regressor',
type=str,
default=expandvars(
"$CTA_SOFT/tino_cta/data/classifier_pickle/"
"regressor_{mode}_{cam_id}_{regressor}.pkl"))
parser.add_argument('-o',
'--outfile',
type=str,
default="",
help="location to write the classified events to.")
parser.add_argument('--wave_dir',
type=str,
default=None,
help="directory where to find mr_filter. "
"if not set look in $PATH")
parser.add_argument(
'--wave_temp_dir',
type=str,
default='/dev/shm/',
help="directory where mr_filter to store the temporary fits "
"files")
group = parser.add_mutually_exclusive_group()
group.add_argument('--proton',
action='store_true',
help="do protons instead of gammas")
group.add_argument('--electron',
action='store_true',
help="do electrons instead of gammas")
args = parser.parse_args()
if args.infile_list:
filenamelist = []
for f in args.infile_list:
filenamelist += glob("{}/{}".format(args.indir, f))
filenamelist.sort()
elif args.proton:
filenamelist = sorted(glob("{}/proton/*gz".format(args.indir)))
elif args.electron:
filenamelist = glob("{}/electron/*gz".format(args.indir))
channel = "electron"
else:
filenamelist = sorted(glob("{}/gamma/*gz".format(args.indir)))
if not filenamelist:
print("no files found; check indir: {}".format(args.indir))
exit(-1)
# keeping track of events and where they were rejected
Eventcutflow = CutFlow("EventCutFlow")
Imagecutflow = CutFlow("ImageCutFlow")
# takes care of image cleaning
cleaner = ImageCleaner(mode=args.mode,
cutflow=Imagecutflow,
wavelet_options=args.raw,
tmp_files_directory=args.wave_temp_dir,
skip_edge_events=False,
island_cleaning=True)
# the class that does the shower reconstruction
shower_reco = HillasReconstructor()
preper = EventPreparer(
cleaner=cleaner,
hillas_parameters=hillas_parameters,
shower_reco=shower_reco,
event_cutflow=Eventcutflow,
image_cutflow=Imagecutflow,
# event/image cuts:
allowed_cam_ids=[],
min_ntel=2,
min_charge=args.min_charge,
min_pixel=3)
# wrapper for the scikit-learn classifier
classifier = EventClassifier.load(args.classifier.format(
**{
"mode": args.mode,
"wave_args": "mixed",
"classifier": 'RandomForestClassifier',
"cam_id": "{cam_id}"
}),
cam_id_list=args.cam_ids)
# wrapper for the scikit-learn regressor
regressor = EnergyRegressor.load(args.regressor.format(
**{
"mode": args.mode,
"wave_args": "mixed",
"regressor": "RandomForestRegressor",
"cam_id": "{cam_id}"
}),
cam_id_list=args.cam_ids)
ClassifierFeatures = namedtuple(
"ClassifierFeatures",
("impact_dist", "sum_signal_evt", "max_signal_cam", "sum_signal_cam",
"N_LST", "N_MST", "N_SST", "width", "length", "skewness", "kurtosis",
"h_max", "err_est_pos", "err_est_dir"))
EnergyFeatures = namedtuple(
"EnergyFeatures",
("impact_dist", "sum_signal_evt", "max_signal_cam", "sum_signal_cam",
"N_LST", "N_MST", "N_SST", "width", "length", "skewness", "kurtosis",
"h_max", "err_est_pos", "err_est_dir"))
# catch ctr-c signal to exit current loop and still display results
signal_handler = SignalHandler()
signal.signal(signal.SIGINT, signal_handler)
# this class defines the reconstruction parameters to keep track of
class RecoEvent(tb.IsDescription):
Run_ID = tb.Int16Col(dflt=-1, pos=0)
Event_ID = tb.Int16Col(dflt=-1, pos=1)
NTels_trig = tb.Int16Col(dflt=0, pos=0)
NTels_reco = tb.Int16Col(dflt=0, pos=1)
NTels_reco_lst = tb.Int16Col(dflt=0, pos=2)
NTels_reco_mst = tb.Int16Col(dflt=0, pos=3)
NTels_reco_sst = tb.Int16Col(dflt=0, pos=4)
MC_Energy = tb.Float32Col(dflt=np.nan, pos=5)
reco_Energy = tb.Float32Col(dflt=np.nan, pos=6)
reco_phi = tb.Float32Col(dflt=np.nan, pos=7)
reco_theta = tb.Float32Col(dflt=np.nan, pos=8)
off_angle = tb.Float32Col(dflt=np.nan, pos=9)
xi = tb.Float32Col(dflt=np.nan, pos=10)
DeltaR = tb.Float32Col(dflt=np.nan, pos=11)
ErrEstPos = tb.Float32Col(dflt=np.nan, pos=12)
ErrEstDir = tb.Float32Col(dflt=np.nan, pos=13)
gammaness = tb.Float32Col(dflt=np.nan, pos=14)
success = tb.BoolCol(dflt=False, pos=15)
channel = "gamma" if "gamma" in " ".join(filenamelist) else "proton"
reco_outfile = tb.open_file(
mode="w",
# if no outfile name is given (i.e. don't to write the event list to disk),
# need specify two "driver" arguments
**({
"filename": args.outfile
} if args.outfile else {
"filename": "no_outfile.h5",
"driver": "H5FD_CORE",
"driver_core_backing_store": False
}))
reco_table = reco_outfile.create_table("/", "reco_events", RecoEvent)
reco_event = reco_table.row
allowed_tels = None # all telescopes
allowed_tels = prod3b_tel_ids("L+N+D")
for i, filename in enumerate(filenamelist[:args.last]):
# print(f"file: {i} filename = {filename}")
source = hessio_event_source(filename,
allowed_tels=allowed_tels,
max_events=args.max_events)
# loop that cleans and parametrises the images and performs the reconstruction
for (event, hillas_dict, n_tels, tot_signal, max_signals, pos_fit,
dir_fit, h_max, err_est_pos,
err_est_dir) in preper.prepare_event(source, True):
# now prepare the features for the classifier
cls_features_evt = {}
reg_features_evt = {}
if hillas_dict is not None:
for tel_id in hillas_dict.keys():
Imagecutflow.count("pre-features")
tel_pos = np.array(event.inst.tel_pos[tel_id][:2]) * u.m
moments = hillas_dict[tel_id]
impact_dist = linalg.length(tel_pos - pos_fit)
cls_features_tel = ClassifierFeatures(
impact_dist=impact_dist / u.m,
sum_signal_evt=tot_signal,
max_signal_cam=max_signals[tel_id],
sum_signal_cam=moments.size,
N_LST=n_tels["LST"],
N_MST=n_tels["MST"],
N_SST=n_tels["SST"],
width=moments.width / u.m,
length=moments.length / u.m,
skewness=moments.skewness,
kurtosis=moments.kurtosis,
h_max=h_max / u.m,
err_est_pos=err_est_pos / u.m,
err_est_dir=err_est_dir / u.deg)
reg_features_tel = EnergyFeatures(
impact_dist=impact_dist / u.m,
sum_signal_evt=tot_signal,
max_signal_cam=max_signals[tel_id],
sum_signal_cam=moments.size,
N_LST=n_tels["LST"],
N_MST=n_tels["MST"],
N_SST=n_tels["SST"],
width=moments.width / u.m,
length=moments.length / u.m,
skewness=moments.skewness,
kurtosis=moments.kurtosis,
h_max=h_max / u.m,
err_est_pos=err_est_pos / u.m,
err_est_dir=err_est_dir / u.deg)
if np.isnan(cls_features_tel).any() or np.isnan(
reg_features_tel).any():
continue
Imagecutflow.count("features nan")
cam_id = event.inst.subarray.tel[tel_id].camera.cam_id
try:
reg_features_evt[cam_id] += [reg_features_tel]
cls_features_evt[cam_id] += [cls_features_tel]
except KeyError:
reg_features_evt[cam_id] = [reg_features_tel]
cls_features_evt[cam_id] = [cls_features_tel]
if cls_features_evt and reg_features_evt:
predict_energ = regressor.predict_by_event([reg_features_evt
])["mean"][0]
predict_proba = classifier.predict_proba_by_event(
[cls_features_evt])
gammaness = predict_proba[0, 0]
try:
# the MC direction of origin of the simulated particle
shower = event.mc
shower_core = np.array(
[shower.core_x / u.m, shower.core_y / u.m]) * u.m
shower_org = linalg.set_phi_theta(az_to_phi(shower.az),
alt_to_theta(shower.alt))
# and how the reconstructed direction compares to that
xi = linalg.angle(dir_fit, shower_org)
DeltaR = linalg.length(pos_fit[:2] - shower_core)
except Exception:
# naked exception catch, because I'm not sure where
# it would break in non-MC files
xi = np.nan
DeltaR = np.nan
phi, theta = linalg.get_phi_theta(dir_fit)
phi = (phi if phi > 0 else phi + 360 * u.deg)
# TODO: replace with actual array pointing direction
array_pointing = linalg.set_phi_theta(0 * u.deg, 20. * u.deg)
# angular offset between the reconstructed direction and the array
# pointing
off_angle = linalg.angle(dir_fit, array_pointing)
reco_event["NTels_trig"] = len(event.dl0.tels_with_data)
reco_event["NTels_reco"] = len(hillas_dict)
reco_event["NTels_reco_lst"] = n_tels["LST"]
reco_event["NTels_reco_mst"] = n_tels["MST"]
reco_event["NTels_reco_sst"] = n_tels["SST"]
reco_event["reco_Energy"] = predict_energ.to(energy_unit).value
reco_event["reco_phi"] = phi / angle_unit
reco_event["reco_theta"] = theta / angle_unit
reco_event["off_angle"] = off_angle / angle_unit
reco_event["xi"] = xi / angle_unit
reco_event["DeltaR"] = DeltaR / dist_unit
reco_event["ErrEstPos"] = err_est_pos / dist_unit
reco_event["ErrEstDir"] = err_est_dir / angle_unit
reco_event["gammaness"] = gammaness
reco_event["success"] = True
else:
reco_event["success"] = False
# save basic event infos
reco_event["MC_Energy"] = event.mc.energy.to(energy_unit).value
reco_event["Event_ID"] = event.r1.event_id
reco_event["Run_ID"] = event.r1.run_id
reco_table.flush()
reco_event.append()
if signal_handler.stop:
break
if signal_handler.stop:
break
# make sure everything gets written out nicely
reco_table.flush()
try:
print()
Eventcutflow()
print()
Imagecutflow()
# do some simple event selection
# and print the corresponding selection efficiency
N_selected = len([
x for x in reco_table.where(
"""(NTels_reco > min_tel) & (gammaness > agree_threshold)""")
])
N_total = len(reco_table)
print("\nfraction selected events:")
print("{} / {} = {} %".format(N_selected, N_total,
N_selected / N_total * 100))
except ZeroDivisionError:
pass
print("\nlength filenamelist:", len(filenamelist[:args.last]))
# do some plotting if so desired
if args.plot:
gammaness = [x['gammaness'] for x in reco_table]
NTels_rec = [x['NTels_reco'] for x in reco_table]
NTel_bins = np.arange(np.min(NTels_rec), np.max(NTels_rec) + 2) - .5
NTels_rec_lst = [x['NTels_reco_lst'] for x in reco_table]
NTels_rec_mst = [x['NTels_reco_mst'] for x in reco_table]
NTels_rec_sst = [x['NTels_reco_sst'] for x in reco_table]
reco_energy = np.array([x['reco_Energy'] for x in reco_table])
mc_energy = np.array([x['MC_Energy'] for x in reco_table])
fig = plt.figure(figsize=(15, 5))
plt.suptitle(" ** ".join(
[args.mode, "protons" if args.proton else "gamma"]))
plt.subplots_adjust(left=0.05, right=0.97, hspace=0.39, wspace=0.2)
ax = plt.subplot(131)
histo = np.histogram2d(NTels_rec,
gammaness,
bins=(NTel_bins, np.linspace(0, 1, 11)))[0].T
histo_normed = histo / histo.max(axis=0)
im = ax.imshow(
histo_normed,
interpolation='none',
origin='lower',
aspect='auto',
# extent=(*NTel_bins[[0, -1]], 0, 1),
cmap=plt.cm.inferno)
ax.set_xlabel("NTels")
ax.set_ylabel("drifted gammaness")
plt.title("Total Number of Telescopes")
# next subplot
ax = plt.subplot(132)
histo = np.histogram2d(NTels_rec_sst,
gammaness,
bins=(NTel_bins, np.linspace(0, 1, 11)))[0].T
histo_normed = histo / histo.max(axis=0)
im = ax.imshow(
histo_normed,
interpolation='none',
origin='lower',
aspect='auto',
# extent=(*NTel_bins[[0, -1]], 0, 1),
cmap=plt.cm.inferno)
ax.set_xlabel("NTels")
plt.setp(ax.get_yticklabels(), visible=False)
plt.title("Number of SSTs")
# next subplot
ax = plt.subplot(133)
histo = np.histogram2d(NTels_rec_mst,
gammaness,
bins=(NTel_bins, np.linspace(0, 1, 11)))[0].T
histo_normed = histo / histo.max(axis=0)
im = ax.imshow(
histo_normed,
interpolation='none',
origin='lower',
aspect='auto',
# extent=(*NTel_bins[[0, -1]], 0, 1),
cmap=plt.cm.inferno)
cb = fig.colorbar(im, ax=ax)
ax.set_xlabel("NTels")
plt.setp(ax.get_yticklabels(), visible=False)
plt.title("Number of MSTs")
plt.subplots_adjust(wspace=0.05)
# plot the energy migration matrix
plt.figure()
plt.hist2d(np.log10(reco_energy),
np.log10(mc_energy),
bins=20,
cmap=plt.cm.inferno)
plt.xlabel("E_MC / TeV")
plt.ylabel("E_rec / TeV")
plt.colorbar()
plt.show()
print("q - Quit")
return input("Choice: ")
if __name__ == '__main__':
if len(sys.argv) > 1:
filename = sys.argv.pop(1)
else:
filename = get_example_simtelarray_file()
plt.style.use("ggplot")
plt.show(block=False)
# loop over events and display menu at each event:
source = hessio_event_source(filename)
for event in source:
print("EVENT_ID: ", event.dl0.event_id, "TELS: ",
event.dl0.tels_with_data, "MC Energy:", event.mc.energy)
while True:
response = get_input()
if response.startswith("d"):
disps = display_event(event)
plt.pause(0.1)
elif response.startswith("p"):
print("--event-------------------")
print(event)
print("--event.dl0---------------")
def show_photoelectron_image_histogram(simtel_file_path,
output_file_path,
tel_num,
event_id,
channel=0,
quiet=False):
# GET EVENT #############################################################
# hessio_event_source returns a Python generator that streams data from an
# EventIO/HESSIO MC data file (e.g. a standard CTA data file).
# This generator contains ctapipe.core.Container instances ("event").
#
# Parameters:
# - max_events: maximum number of events to read
# - allowed_tels: select only a subset of telescope, if None, all are read.
source = hessio_event_source(simtel_file_path, allowed_tels=[tel_num])
event = None
for ev in source:
if int(ev.dl0.event_id) == event_id:
event = ev
break
if event is None:
print("Error: event '{}' not found for telescope '{}'.".format(
event_id, tel_num))
sys.exit(1)
# GET TIME-VARYING EVENT ##################################################
#data = event.dl0.tel[tel_num].adc_samples[channel]
#for ii in range(data.shape[1]):
# image_array = data[:, ii]
# GET INTEGRATED EVENT ####################################################
# The photoelectron image "event.mc.tel[tel_num].photo_electrons" is a 1D numpy array with the same shape (dtype=int32)
image_array = event.mc.tel[tel_num].photo_electrons
# INIT PLOT ###############################################################
fig = plt.figure(figsize=(8.0, 8.0))
ax = fig.add_subplot(111)
values, bins, patches = ax.hist(
image_array.ravel(),
histtype=HISTOGRAM_TYPE,
#bins=image_array.max() - image_array.min(),
bins=100,
fc='gray',
ec='k')
ax.set_xlim([image_array.min(), image_array.max()])
# PLOT ####################################################################
plt.savefig(output_file_path, bbox_inches='tight')
if not quiet:
plt.show()
from ctapipe.visualization import CameraDisplay
from ctapipe.instrument.camera import CameraGeometry
from ctapipe.calib import CameraCalibrator
from ctapipe.reco.HillasReconstructor import HillasReconstructor
from ctapipe.image.hillas import hillas_parameters
from ctapipe.image.cleaning import tailcuts_clean
from ctapipe.utils import linalg
from ctapipe.utils import datasets
#importing data from avaiable datasets in ctapipe
filename = datasets.get_dataset("gamma_test_large.simtel.gz")
#filename
# reading the Monte Carlo file for LST
source = hessio_event_source(filename, allowed_tels={1, 2, 3, 4})
#pointing direction of the telescopes
point_azimuth = {}
point_altitude = {}
reco = HillasReconstructor()
calib = CameraCalibrator(None, None)
off_angles = []
for event in source:
# The direction the incident particle.
# Converting Monte Carlo Shower parameter theta and phi to
# corresponding to 3 components (x,y,z) of a vector
shower_azimuth = event.mc.az # same as in Monte Carlo file i.e. phi
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_dataset("gamma_test.simtel.gz")
fit = HillasReconstructor()
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] = event.mc.tel[tel_id].azimuth_raw * u.rad
tel_theta[tel_id] = (np.pi / 2 -
event.mc.tel[tel_id].altitude_raw) * u.rad
pmt_signal = event.r0.tel[tel_id].adc_sums[0]
mask = tailcuts_clean(cam_geom[tel_id],
pmt_signal,
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
"""
Example of showing some information about the instrumental description
"""
from ctapipe.io.hessio import hessio_event_source
if __name__ == '__main__':
# load up one event so that we get the instrument info
source = hessio_event_source(
"/Users/kosack/Data/CTA/Prod3/gamma.simtel.gz")
event = next(source)
del source # close the file
subarray = event.inst.subarray
subarray.info()
print(subarray.to_table())
print(subarray.tel[1].optics.mirror_area)
def setup(self):
source = hessio_event_source(self.infile)
data = next(source) # get one event, so the instrument table is there
del source
self.inst = data.inst # keep a pointer to the instrument stuff
pass
