def main():
script = os.path.splitext(os.path.basename(__file__))[0]
log.info("[SCRIPT] {}".format(script))
parser = argparse.ArgumentParser(
description='Display each event in the file')
parser.add_argument('-f', '--file', dest='input_path', action='store',
default=get_path('gamma_test.simtel.gz'),
help='path to the input file. '
'Default = gamma_test.simtel.gz')
parser.add_argument('-O', '--origin', dest='origin', action='store',
default='hessio',
help='origin of the file: {}. Default = hessio'
.format(origin_list()))
parser.add_argument('-D', dest='display', action='store_true',
default=False, help='display the camera events')
parser.add_argument('--pdf', dest='output_path', action='store',
default=None,
help='path to store a pdf output of the plots')
parser.add_argument('-t', '--telescope', dest='tel', action='store',
type=int, default=None, help='telecope to view. '
'Default = All')
calibration_arguments(parser)
logger_detail = parser.add_mutually_exclusive_group()
logger_detail.add_argument('-q', '--quiet', dest='quiet',
action='store_true', default=False,
help='Quiet mode')
logger_detail.add_argument('-v', '--verbose', dest='verbose',
action='store_true', default=False,
help='Verbose mode')
logger_detail.add_argument('-d', '--debug', dest='debug',
action='store_true', default=False,
help='Debug mode')
args = parser.parse_args()
params = calibration_parameters(args)
if args.quiet:
log.setLevel(40)
if args.verbose:
log.setLevel(20)
if args.debug:
log.setLevel(10)
log.debug("[file] Reading file")
input_file = InputFile(args.input_path, args.origin)
source = input_file.read()
# geom_dict is a dictionary of CameraGeometry, with keys of
# (num_pixels, focal_length), the parameters that are used to guess the
# geometry of the telescope. By using these keys, the geometry is
# calculated only once per telescope type as needed, reducing computation
# time.
# Creating a geom_dict at this point is optional, but is recommended, as
# the same geom_dict can then be shared between the calibration and
# CameraPlotter, again reducing computation time.
# The dictionary becomes filled as a result of a dictionary's mutable
# nature.
geom_dict = {}
# Calibrate events and fill geom_dict
calibrated_source = calibrate_source(source, params, geom_dict)
fig = plt.figure(figsize=(16, 7))
if args.display:
plt.show(block=False)
pp = PdfPages(args.output_path) if args.output_path is not None else None
for event in calibrated_source:
tels = list(event.dl0.tels_with_data)
if args.tel is None:
tel_loop = tels
else:
if args.tel not in tels:
continue
tel_loop = [args.tel]
log.debug(tels)
for tel_id in tel_loop:
display_telescope(event, tel_id, args.display, geom_dict, pp, fig)
if pp is not None:
pp.close()
log.info("[COMPLETE]")
def argparsing():
parser = argparse.ArgumentParser(
description='Display each event in the file')
parser.add_argument('-f', '--file', dest='input_paths',
default=[get_path('gamma_test.simtel.gz')], nargs='*',
help='path to the input files to be combined for a '
'single charge resolution. '
'Default = gamma_test.simtel.gz')
parser.add_argument('-O', '--origin', dest='origin', action='store',
default='hessio', help='origin of the file: {}'
.format(origin_list()))
parser.add_argument('-t', '--telescope', dest='tel', action='store',
type=int, default=None, nargs='*',
help='list of telecopes to be included. '
'Default = All')
parser.add_argument('-o', '--output', dest='output_path', action='store',
default=None,
help='path to store a pdf output of the plots. '
'default = display on screen instead')
parser.add_argument('--comparison', dest='comparison', action='store',
default=None,
help='output path for a True Charge versus Measured'
'Charge graph. Default = do not plot graph')
parser.add_argument('-M', '--maxpe', dest='maxpe', action='store',
default=None, type=float,
help='maximum pe to calculate the charge resolution'
' up to. Default = maximum pe in file')
parser.add_argument('--maxpeplot', dest='maxpeplot', action='store',
default=None, type=float,
help='maximum pe to plot up to. Default = maxpe')
parser.add_argument('-B', '--binning', dest='binning', action='store',
default="log",
help='binning of the charge resoltion graph: '
'"none" = no binning, "normal" = bin, '
'"log" = bin in log space. Default = log')
parser.add_argument('--normalx', dest='normalx', action='store_true',
default=False,
help='Use a normal x axis instead of the defualt log'
'axis')
parser.add_argument('--normaly', dest='normaly', action='store_true',
default=False,
help='Use a normal y axis instead of the defualt log'
'axis')
parser.add_argument('-E', '--example', dest='example', action='store_true',
default=False,
help='print an example runcard')
parser.add_argument('-R', '--runcard', dest='runcard', action='store',
default=None,
help='path to a runcard text file with arguments that '
'override command line arguments. This run card '
'can allow complex combinations of files and '
'calibrations to compare the charge resolution '
'against each other.')
calibration_arguments(parser)
logger_detail = parser.add_mutually_exclusive_group()
logger_detail.add_argument('-q', '--quiet', dest='quiet',
action='store_true', default=False,
help='Quiet mode')
logger_detail.add_argument('-v', '--verbose', dest='verbose',
action='store_true', default=False,
help='Verbose mode')
logger_detail.add_argument('-d', '--debug', dest='debug',
action='store_true', default=False,
help='Debug mode')
args = parser.parse_args()
if args.quiet:
log.setLevel(40)
if args.verbose:
log.setLevel(20)
if args.debug:
log.setLevel(10)
if args.example:
print("""
# Each charge resolution block starts with [chargeres] and the names for
# this charge resolution.
# The options in each block are equivalent to the scripts help message.
# Options that seem to apply to plotting will only have effect in a
# plotting block.
[chargeres] test_file_local
#-f gamma_test.simtel.gz
-f ~/Software/outputs/sim_telarray/simtel_run4_gcts_hnsb.gz
-O hessio
--integrator 4
--integration-window 7 3
--integration-sigamp 2 4
--integration-lwt 0
--integration-calib_scale 1.05
--comparison ~/Downloads/test_file_local.pdf
# A second charge resolution block to also calculate the resolution with
# a different integrator so the two resolutions can be plotted against
# each other.
[chargeres] test_file_nei
#-f gamma_test.simtel.gz
-f ~/Software/outputs/sim_telarray/simtel_run4_gcts_hnsb.gz
-O hessio
--integrator 5
--integration-window 7 3
--integration-sigamp 2 4
--integration-lwt 0
--integration-calib_scale 1.05
--comparison ~/Downloads/test_file_nei.pdf
# A plotting block configures an output plot
[plot] normal_plot
[chargeres_names] test_file_local test_file_nei
-o ~/Downloads/normal_plot.pdf
--binning normal
--normalx
--normaly
[plot] log_plot
[chargeres_names] test_file_local test_file_nei
-o ~/Downloads/log_plot.pdf""")
exit()
if args.runcard is None:
name = splitext(basename(args.input_paths[0]))[0]
args.chargeres_names = [name]
chargeres_args = {name: args}
plot_args = {name: args}
else:
chargeres_args = {}
plot_args = {}
chargeres_cmdline = {}
plot_cmdline = {}
plot_chargeres_names = {}
current = None
name = ''
runcard = open(args.runcard)
for line in runcard:
if line.strip() and not line.startswith('#'):
argument = line.split()[0]
if argument == '[chargeres]':
name = line.split()[1:][0]
chargeres_cmdline[name] = []
current = chargeres_cmdline[name]
continue
elif argument == '[plot]':
name = line.split()[1:][0]
plot_cmdline[name] = []
current = plot_cmdline[name]
continue
elif argument == '[chargeres_names]':
plot_chargeres_names[name] = line.split()[1:]
continue
current.extend(line.split())
for name, cmdline in chargeres_cmdline.items():
chargeres_args[name] = parser.parse_args(cmdline)
for name, cmdline in plot_cmdline.items():
plot_args[name] = parser.parse_args(cmdline)
plot_args[name].chargeres_names = plot_chargeres_names[name]
# Check all chargeres_names exist
for plot_name, args in plot_args.items():
for name in args.chargeres_names:
try:
if name not in chargeres_args:
raise IndexError
except IndexError:
log.exception("[chargeres_names] For plot: {}, no chargeres "
"has the name: {}".format(plot_name, name))
# Check all binning is valid
possible = ['none', 'normal', 'log']
test = [args.binning in possible for args in plot_args.values()]
try:
if not all(test):
raise IndexError
except IndexError:
log.exception("[binning] Only options are: {}".format(possible))
raise
return chargeres_args, plot_args
def main():
script = os.path.splitext(os.path.basename(__file__))[0]
log.info("[SCRIPT] {}".format(script))
parser = argparse.ArgumentParser(description='Create a gif of an event')
parser.add_argument('-f', '--file', dest='input_path', action='store',
required=True, help='path to the input file')
parser.add_argument('-O', '--origin', dest='origin', action='store',
required=True, help='origin of the file: {}'
.format(origin_list()))
parser.add_argument('-o', '--output', dest='output_dir', action='store',
default=None,
help='path of the output directory to store the '
'images (default = input file directory)')
parser.add_argument('-e', '--event', dest='event_req', action='store',
required=True, type=int,
help='event index to plot (not id!)')
parser.add_argument('--id', dest='event_id_f', action='store_true',
default=False, help='-e will specify event_id instead '
'of index')
parser.add_argument('-t', '--telescope', dest='tel', action='store',
type=int, default=None, help='telecope to view')
parser.add_argument('-c', '--channel', dest='chan', action='store',
type=int, default=0,
help='channel to view (default = 0 (HG))')
calibration_arguments(parser)
logger_detail = parser.add_mutually_exclusive_group()
logger_detail.add_argument('-q', '--quiet', dest='quiet',
action='store_true', default=False,
help='Quiet mode')
logger_detail.add_argument('-v', '--verbose', dest='verbose',
action='store_true', default=False,
help='Verbose mode')
logger_detail.add_argument('-d', '--debug', dest='debug',
action='store_true', default=False,
help='Debug mode')
args = parser.parse_args()
if args.quiet:
log.setLevel(40)
if args.verbose:
log.setLevel(20)
if args.debug:
log.setLevel(10)
telid = args.tel
chan = args.chan
log.debug("[file] Reading file")
input_file = InputFile(args.input_path, args.origin)
event = input_file.get_event(args.event_req, args.event_id_f)
# Print event/args values
log.info("[event_index] {}".format(event.count))
log.info("[event_id] {}".format(event.dl0.event_id))
log.info("[telescope] {}".format(telid))
log.info("[channel] {}".format(chan))
params = calibration_parameters(args)
# Create a dictionary to store any geoms in
geom = CameraGeometry.guess(*event.meta.pixel_pos[telid],
event.meta.optical_foclen[telid])
geom_dict = {telid: geom}
calibrated_event = calibrate_event(event, params, geom_dict)
# Select telescope
tels = list(calibrated_event.dl0.tels_with_data)
if telid is None or telid not in tels:
log.error("[event] please specify one of the following telescopes "
"for this event: {}".format(tels))
exit()
# Extract required images
data_ped = calibrated_event.dl1.tel[telid].pedestal_subtracted_adc[chan]
true_pe = calibrated_event.mc.tel[telid].photo_electrons
measured_pe = calibrated_event.dl1.tel[telid].pe_charge
max_time = np.unravel_index(np.argmax(data_ped), data_ped.shape)[1]
max_charges = np.max(data_ped, axis=1)
max_pixel = int(np.argmax(max_charges))
min_pixel = int(np.argmin(max_charges))
# Get Neighbours
max_pixel_nei = geom.neighbors[max_pixel]
min_pixel_nei = geom.neighbors[min_pixel]
# Get Windows
windows = calibrated_event.dl1.tel[telid].integration_window[chan]
length = np.sum(windows, axis=1)
start = np.argmax(windows, axis=1)
end = start + length - 1
# Draw figures
ax_max_nei = {}
ax_min_nei = {}
fig_waveforms = plt.figure(figsize=(24, 10))
fig_waveforms.subplots_adjust(hspace=.5)
fig_camera = plt.figure(figsize=(30, 24))
ax_max_pix = fig_waveforms.add_subplot(4, 2, 1)
ax_min_pix = fig_waveforms.add_subplot(4, 2, 2)
ax_max_nei[0] = fig_waveforms.add_subplot(4, 2, 3)
ax_min_nei[0] = fig_waveforms.add_subplot(4, 2, 4)
ax_max_nei[1] = fig_waveforms.add_subplot(4, 2, 5)
ax_min_nei[1] = fig_waveforms.add_subplot(4, 2, 6)
ax_max_nei[2] = fig_waveforms.add_subplot(4, 2, 7)
ax_min_nei[2] = fig_waveforms.add_subplot(4, 2, 8)
ax_img_nei = fig_camera.add_subplot(2, 2, 1)
ax_img_max = fig_camera.add_subplot(2, 2, 2)
ax_img_true = fig_camera.add_subplot(2, 2, 3)
ax_img_cal = fig_camera.add_subplot(2, 2, 4)
plotter = CameraPlotter(event, geom_dict)
# Draw max pixel traces
plotter.draw_waveform(data_ped[max_pixel], ax_max_pix)
ax_max_pix.set_title("(Max) Pixel: {}, "
"True: {}, "
"Measured = {}".format(max_pixel, true_pe[max_pixel],
measured_pe[max_pixel]))
ax_max_pix.set_ylabel("Amplitude-Ped (ADC)")
max_ylim = ax_max_pix.get_ylim()
plotter.draw_waveform_positionline(start[max_pixel], ax_max_pix)
plotter.draw_waveform_positionline(end[max_pixel], ax_max_pix)
for i, ax in ax_max_nei.items():
if len(max_pixel_nei) > i:
pix = max_pixel_nei[i]
plotter.draw_waveform(data_ped[pix], ax)
ax.set_title("(Max Nei) Pixel: {}, "
"True: {}, "
"Measured = {}".format(pix, true_pe[pix],
measured_pe[pix]))
ax.set_ylabel("Amplitude-Ped (ADC)")
ax.set_ylim(max_ylim)
plotter.draw_waveform_positionline(start[pix], ax)
plotter.draw_waveform_positionline(end[pix], ax)
# Draw min pixel traces
plotter.draw_waveform(data_ped[min_pixel], ax_min_pix)
ax_min_pix.set_title("(Min) Pixel: {}, "
"True: {}, "
"Measured = {}".format(min_pixel, true_pe[min_pixel],
measured_pe[min_pixel]))
ax_min_pix.set_ylabel("Amplitude-Ped (ADC)")
ax_min_pix.set_ylim(max_ylim)
plotter.draw_waveform_positionline(start[min_pixel], ax_min_pix)
plotter.draw_waveform_positionline(end[min_pixel], ax_min_pix)
for i, ax in ax_min_nei.items():
if len(min_pixel_nei) > i:
pix = min_pixel_nei[i]
plotter.draw_waveform(data_ped[pix], ax)
ax.set_title("(Min Nei) Pixel: {}, "
"True: {}, "
"Measured = {}".format(pix, true_pe[pix],
measured_pe[pix]))
ax.set_ylabel("Amplitude-Ped (ADC)")
ax.set_ylim(max_ylim)
plotter.draw_waveform_positionline(start[pix], ax)
plotter.draw_waveform_positionline(end[pix], ax)
# Draw cameras
nei_camera = np.zeros_like(max_charges, dtype=np.int)
nei_camera[min_pixel_nei] = 2
nei_camera[min_pixel] = 1
nei_camera[max_pixel_nei] = 3
nei_camera[max_pixel] = 4
camera = plotter.draw_camera(telid, nei_camera, ax_img_nei)
camera.cmap = plt.cm.viridis
ax_img_nei.set_title("Neighbour Map")
plotter.draw_camera_pixel_annotation(telid, max_pixel, min_pixel,
ax_img_nei)
camera = plotter.draw_camera(telid, data_ped[:, max_time], ax_img_max)
camera.add_colorbar(ax=ax_img_max, label="Amplitude-Ped (ADC)")
ax_img_max.set_title("Max Timeslice (T = {})".format(max_time))
plotter.draw_camera_pixel_annotation(telid, max_pixel, min_pixel,
ax_img_max)
camera = plotter.draw_camera(telid, true_pe, ax_img_true)
camera.add_colorbar(ax=ax_img_true, label="True Charge (Photo-electrons)")
ax_img_true.set_title("True Charge")
plotter.draw_camera_pixel_annotation(telid, max_pixel, min_pixel,
ax_img_true)
camera = plotter.draw_camera(telid, measured_pe, ax_img_cal)
camera.add_colorbar(ax=ax_img_cal, label="Calib Charge (Photo-electrons)")
ax_img_cal.set_title("Charge (integrator={})".format(params['integrator']))
plotter.draw_camera_pixel_annotation(telid, max_pixel, min_pixel,
ax_img_cal)
fig_waveforms.suptitle("Integrator = {}".format(params['integrator']))
fig_camera.suptitle("Camera = {}".format(geom.cam_id))
# TODO: another figure of all waveforms that have non-zero true charge
waveform_output_name = "{}_e{}_t{}_c{}_integrator{}_waveform.pdf"\
.format(input_file.filename, event.count, telid, chan, args.integrator)
camera_output_name = "{}_e{}_t{}_c{}_integrator{}_camera.pdf"\
.format(input_file.filename, event.count, telid, chan, args.integrator)
output_dir = args.output_dir if args.output_dir is not None else \
input_file.output_directory
output_dir = os.path.join(output_dir, script)
if not os.path.exists(output_dir):
log.info("[output] Creating directory: {}".format(output_dir))
os.makedirs(output_dir)
waveform_output_path = os.path.join(output_dir, waveform_output_name)
log.info("[output] {}".format(waveform_output_path))
fig_waveforms.savefig(waveform_output_path, format='pdf')
camera_output_path = os.path.join(output_dir, camera_output_name)
log.info("[output] {}".format(camera_output_path))
fig_camera.savefig(camera_output_path, format='pdf')
log.info("[COMPLETE]")
def initialize(self, argv=None):
self.log.info("Initializing the calibration pipeline...")
# Declare and parse command line option
parser = argparse.ArgumentParser(
description='Display each event in the file')
parser.add_argument('-f', '--file', dest='input_path',
action='store',
default=get_path('gamma_test.simtel.gz'),
help='path to the input file. '
' Default = gamma_test.simtel.gz')
parser.add_argument('-O', '--origin', dest='origin',
action='store',
default='hessio',
help='origin of the file: {}. '
'Default = hessio'
.format(origin_list()))
parser.add_argument('-D', dest='display', action='store_true',
default=False,
help='display the camera events')
parser.add_argument('--pdf', dest='output_path', action='store',
default=None,
help='path to store a pdf output of the plots')
parser.add_argument('-t', '--telescope', dest='tel',
action='store',
type=int, default=None,
help='telecope to view. Default = All')
calibration_arguments(parser)
logger_detail = parser.add_mutually_exclusive_group()
logger_detail.add_argument('-q', '--quiet', dest='quiet',
action='store_true', default=False,
help='Quiet mode')
logger_detail.add_argument('-v', '--verbose', dest='verbose',
action='store_true', default=False,
help='Verbose mode')
logger_detail.add_argument('-d', '--debug', dest='debug',
action='store_true', default=False,
help='Debug mode')
self.args = parser.parse_args()
self.params = calibration_parameters(self.args)
if self.args.quiet:
self.log.setLevel(40)
if self.args.verbose:
self.log.setLevel(20)
if self.args.debug:
self.log.setLevel(10)
self.log.debug("[file] Reading file")
input_file = InputFile(self.args.input_path, self.args.origin)
self.source = input_file.read()
# geom_dict is a dictionary of CameraGeometry, with keys of
# (num_pixels, focal_length), the parameters that are used to guess the
# geometry of the telescope. By using these keys, the geometry is
# calculated only once per telescope type as needed, reducing
# computation time.
# Creating a geom_dict at this point is optional, but is recommended,
# as the same geom_dict can then be shared between the calibration and
# CameraPlotter, again reducing computation time.
# The dictionary becomes filled as a result of a dictionary's mutable
# nature.def display_telescope(event, tel_id, display,
# geom_dict, pp, fig):
self.geom_dict = {}
