def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
self.reader = EventSource.from_config(parent=self)
self.seeker = EventSeeker(self.reader, parent=self)
self.extractor = ImageExtractor.from_name(
self.extractor_product,
parent=self,
subarray=self.reader.subarray,
)
self.calibrator = CameraCalibrator(
subarray=self.reader.subarray,
parent=self,
image_extractor=self.extractor,
)
self.viewer = BokehEventViewer(parent=self,
subarray=self.reader.subarray)
# Setup widgets
self.viewer.create()
self.viewer.enable_automatic_index_increment()
self.create_previous_event_widget()
self.create_next_event_widget()
self.create_event_index_widget()
self.create_goto_event_index_widget()
self.create_event_id_widget()
self.create_goto_event_id_widget()
self.create_telid_widget()
self.create_channel_widget()
self.create_dl1_widgets()
self.update_dl1_widget_values()
# Setup layout
self.layout = layout([
[self.viewer.layout],
[
self.w_previous_event,
self.w_next_event,
self.w_goto_event_index,
self.w_goto_event_id,
],
[self.w_event_index, self.w_event_id],
[self.w_telid, self.w_channel],
[self.wb_extractor],
])
def test_eventseeker():
dataset = get_dataset("gamma_test.simtel.gz")
kwargs = dict(config=None, tool=None, input_url=dataset)
with HESSIOEventSource(**kwargs) as reader:
seeker = EventSeeker(reader=reader)
event = seeker[1]
assert event.r0.tels_with_data == {11, 21, 24, 26, 61, 63, 118, 119}
event = seeker[0]
assert event.r0.tels_with_data == {38, 47}
event = seeker['409']
assert event.r0.tels_with_data == {11, 21, 24, 26, 61, 63, 118, 119}
tel_list = [{38, 47}, {11, 21, 24, 26, 61, 63, 118, 119}]
events = seeker[0:2]
events_tels = [e.r0.tels_with_data for e in events]
assert events_tels == tel_list
events = seeker[[0, 1]]
events_tels = [e.r0.tels_with_data for e in events]
assert events_tels == tel_list
events = seeker[['408', '409']]
events_tels = [e.r0.tels_with_data for e in events]
assert events_tels == tel_list
assert len(seeker) == 9
with pytest.raises(IndexError):
event = seeker[200]
assert event is not None
with pytest.raises(ValueError):
event = seeker['t']
assert event is not None
with pytest.raises(TypeError):
event = seeker[dict()]
assert event is not None
with HESSIOEventSource(**kwargs, max_events=5) as reader:
seeker = EventSeeker(reader=reader)
with pytest.raises(IndexError):
event = seeker[5]
assert event is not None
class StreamFileReader(HESSIOEventSource):
def is_stream(self):
return True
with StreamFileReader(**kwargs) as reader:
with pytest.raises(IOError):
seeker = EventSeeker(reader=reader)
assert seeker is not None
def test_event():
""" an example event for algorithm testing"""
filename = get_dataset_path('gamma_test.simtel.gz')
with HESSIOEventSource(input_url=filename) as reader:
seeker = EventSeeker(reader)
event = seeker['409']
yield event
def test_eventseeker_simtel():
# Ensure the EventSeeker can forward seek even if back-seeking is not possible
with SimTelEventSource(input_url=dataset, back_seekable=False) as reader:
seeker = EventSeeker(event_source=reader)
event = seeker.get_event_index(1)
assert event.count == 1
event = seeker.get_event_index(1)
assert event.count == 1
event = seeker.get_event_index(2)
assert event.count == 2
event = seeker.get_event_index(2)
assert event.count == 2
event = seeker.get_event_index(4)
assert event.count == 4
with pytest.raises(IOError):
seeker.get_event_index(1)
event = seeker.get_event_index(5)
assert event.count == 5
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
event_source = self.add_component(EventSource.from_config(parent=self))
self.eventseeker = self.add_component(
EventSeeker(event_source, parent=self))
self.extractor = self.add_component(
ImageExtractor.from_name(self.extractor_product, parent=self))
self.calibrate = self.add_component(
CameraCalibrator(parent=self, image_extractor=self.extractor))
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
kwargs = dict(config=self.config, tool=self)
self.reader = EventSource.from_config(**kwargs)
self.seeker = EventSeeker(self.reader, **kwargs)
self.extractor = ChargeExtractor.from_name(
self.extractor_product,
**kwargs
)
self.cleaner = WaveformCleaner.from_name(
self.cleaner_product,
**kwargs
)
self.r1 = CameraR1Calibrator.from_eventsource(
eventsource=self.reader,
**kwargs
)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(
extractor=self.extractor,
cleaner=self.cleaner,
**kwargs
)
self.viewer = BokehEventViewer(**kwargs)
# Setup widgets
self.viewer.create()
self.viewer.enable_automatic_index_increment()
self.create_previous_event_widget()
self.create_next_event_widget()
self.create_event_index_widget()
self.create_goto_event_index_widget()
self.create_event_id_widget()
self.create_goto_event_id_widget()
self.create_telid_widget()
self.create_channel_widget()
self.create_dl1_widgets()
self.update_dl1_widget_values()
# Setup layout
self.layout = layout([
[self.viewer.layout],
[
self.w_previous_event,
self.w_next_event,
self.w_goto_event_index,
self.w_goto_event_id
],
[self.w_event_index, self.w_event_id],
[self.w_telid, self.w_channel],
[self.wb_extractor]
])
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
event_source = EventSource.from_config(parent=self)
self.eventseeker = EventSeeker(event_source, parent=self)
self.extractor = ImageExtractor.from_name(
self.extractor_product,
parent=self,
)
self.dl0 = CameraDL0Reducer(parent=self)
self.dl1 = CameraDL1Calibrator(extractor=self.extractor, parent=self)
def test_eventcontent():
dataset = get_dataset_path(
"20131004_M1_05029747.003_Y_MagicCrab-W0.40+035.root")
dataset = dataset.replace('_M1_', '_M*_')
with MAGICEventSource(input_url=dataset) as source:
seeker = EventSeeker(source)
event = seeker[0]
assert event.dl1.tel[1].image[0] == -0.53125
assert event.dl1.tel[2].image[0] == 2.2265625
assert event.dl1.tel[1].pulse_time[0] == 49.125
assert event.dl1.tel[2].pulse_time[0] == 23.5625
def _global_example_event():
"""
helper to get a single event from a MC file. Don't use this fixture
directly, rather use `test_event`
"""
filename = get_dataset_path('gamma_test.simtel.gz')
print("******************** LOAD TEST EVENT ***********************")
with SimTelEventSource(input_url=filename) as reader:
seeker = EventSeeker(reader)
event = seeker['409']
return event
def test_eventseeker():
dataset = get_dataset_path(
"20131004_M1_05029747.003_Y_MagicCrab-W0.40+035.root")
dataset = dataset.replace('_M1_', '_M*_')
with MAGICEventSourceROOT(input_url=dataset) as source:
seeker = EventSeeker(source)
event = seeker[0]
assert event.count == 0
assert event.dl0.event_id == 29795.0
event = seeker[2]
assert event.count == 2
assert event.r1.event_id == 29798.0
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
kwargs = dict(config=self.config, tool=self)
event_source = EventSource.from_config(**kwargs)
self.eventseeker = EventSeeker(event_source, **kwargs)
self.extractor = ChargeExtractor.from_name(self.extractor_product,
**kwargs)
self.r1 = CameraR1Calibrator.from_eventsource(eventsource=event_source,
**kwargs)
self.dl0 = CameraDL0Reducer(**kwargs)
self.dl1 = CameraDL1Calibrator(extractor=self.extractor, **kwargs)
class BokehFileViewer(Tool):
name = "BokehFileViewer"
description = ("Interactively explore an event file using the bokeh "
"visualisation package")
port = Int(5006, help="Port to open bokeh server onto").tag(config=True)
disable_server = Bool(False,
help="Do not start the bokeh server "
"(useful for testing)").tag(config=True)
default_url = get_dataset_path("gamma_test_large.simtel.gz")
EventSource.input_url.default_value = default_url
extractor_product = traits.create_class_enum_trait(
ImageExtractor, default_value="NeighborPeakWindowSum")
aliases = Dict(
dict(
port="BokehFileViewer.port",
disable_server="BokehFileViewer.disable_server",
f="EventSource.input_url",
max_events="EventSource.max_events",
extractor="BokehFileViewer.extractor_product",
))
classes = [EventSource] + traits.classes_with_traits(ImageExtractor)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self._event = None
self._event_index = None
self._event_id = None
self._telid = None
self._channel = None
self.w_next_event = None
self.w_previous_event = None
self.w_event_index = None
self.w_event_id = None
self.w_goto_event_index = None
self.w_goto_event_id = None
self.w_telid = None
self.w_channel = None
self.w_dl1_dict = None
self.wb_extractor = None
self.layout = None
self.reader = None
self.seeker = None
self.extractor = None
self.calibrator = None
self.viewer = None
self._updating_dl1 = False
# make sure, gzip files are seekable
self.config.SimTelEventSource.back_seekable = True
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
self.reader = EventSource(parent=self)
self.seeker = EventSeeker(self.reader, parent=self)
self.extractor = ImageExtractor.from_name(
self.extractor_product, parent=self, subarray=self.reader.subarray)
self.calibrator = CameraCalibrator(subarray=self.reader.subarray,
parent=self,
image_extractor=self.extractor)
self.viewer = BokehEventViewer(parent=self,
subarray=self.reader.subarray)
# Setup widgets
self.viewer.create()
self.viewer.enable_automatic_index_increment()
self.create_previous_event_widget()
self.create_next_event_widget()
self.create_event_index_widget()
self.create_goto_event_index_widget()
self.create_event_id_widget()
self.create_goto_event_id_widget()
self.create_telid_widget()
self.create_channel_widget()
self.create_dl1_widgets()
self.update_dl1_widget_values()
# Setup layout
self.layout = layout([
[self.viewer.layout],
[
self.w_previous_event,
self.w_next_event,
self.w_goto_event_index,
self.w_goto_event_id,
],
[self.w_event_index, self.w_event_id],
[self.w_telid, self.w_channel],
[self.wb_extractor],
])
def start(self):
self.event_index = 0
def finish(self):
if not self.disable_server:
def modify_doc(doc):
doc.add_root(self.layout)
doc.title = self.name
directory = os.path.abspath(os.path.dirname(__file__))
theme_path = os.path.join(directory, "theme.yaml")
template_path = os.path.join(directory, "templates")
doc.theme = Theme(filename=theme_path)
env = jinja2.Environment(
loader=jinja2.FileSystemLoader(template_path))
doc.template = env.get_template("index.html")
self.log.info("Opening Bokeh application on "
"http://localhost:{}/".format(self.port))
server = Server({"/": modify_doc}, num_procs=1, port=self.port)
server.start()
server.io_loop.add_callback(server.show, "/")
server.io_loop.start()
@property
def event_index(self):
return self._event_index
@event_index.setter
def event_index(self, val):
try:
self.event = self.seeker.get_event_index(val)
except IndexError:
self.log.warning(f"Event Index {val} does not exist")
@property
def event_id(self):
return self._event_id
@event_id.setter
def event_id(self, val):
try:
self.event = self.seeker.get_event_id(val)
except IndexError:
self.log.warning(f"Event ID {val} does not exist")
@property
def telid(self):
return self._telid
@telid.setter
def telid(self, val):
self.channel = 0
tels = list(self.event.r0.tel.keys())
if val not in tels:
val = tels[0]
self._telid = val
self.viewer.telid = val
self.update_telid_widget()
@property
def channel(self):
return self._channel
@channel.setter
def channel(self, val):
self._channel = val
self.viewer.channel = val
self.update_channel_widget()
@property
def event(self):
return self._event
@event.setter
def event(self, val):
self.calibrator(val)
self._event = val
self.viewer.event = val
self._event_index = val.count
self._event_id = val.index.event_id
self.update_event_index_widget()
self.update_event_id_widget()
self._telid = self.viewer.telid
self.update_telid_widget()
self._channel = self.viewer.channel
self.update_channel_widget()
def update_dl1_calibrator(self, extractor=None):
"""
Recreate the dl1 calibrator with the specified extractor and cleaner
Parameters
----------
extractor : ctapipe.image.extractor.ImageExtractor
"""
if extractor is None:
extractor = self.calibrator.image_extractor
self.extractor = extractor
self.calibrator = CameraCalibrator(subarray=self.reader.subarray,
parent=self,
image_extractor=self.extractor)
self.viewer.refresh()
def create_next_event_widget(self):
self.w_next_event = Button(label=">", button_type="default", width=50)
self.w_next_event.on_click(self.on_next_event_widget_click)
def on_next_event_widget_click(self):
self.event_index += 1
def create_previous_event_widget(self):
self.w_previous_event = Button(label="<",
button_type="default",
width=50)
self.w_previous_event.on_click(self.on_previous_event_widget_click)
def on_previous_event_widget_click(self):
self.event_index -= 1
def create_event_index_widget(self):
self.w_event_index = TextInput(title="Event Index:", value="")
def update_event_index_widget(self):
if self.w_event_index:
self.w_event_index.value = str(self.event_index)
def create_event_id_widget(self):
self.w_event_id = TextInput(title="Event ID:", value="")
def update_event_id_widget(self):
if self.w_event_id:
self.w_event_id.value = str(self.event_id)
def create_goto_event_index_widget(self):
self.w_goto_event_index = Button(label="GOTO Index",
button_type="default",
width=100)
self.w_goto_event_index.on_click(self.on_goto_event_index_widget_click)
def on_goto_event_index_widget_click(self):
self.event_index = int(self.w_event_index.value)
def create_goto_event_id_widget(self):
self.w_goto_event_id = Button(label="GOTO ID",
button_type="default",
width=70)
self.w_goto_event_id.on_click(self.on_goto_event_id_widget_click)
def on_goto_event_id_widget_click(self):
self.event_id = int(self.w_event_id.value)
def create_telid_widget(self):
self.w_telid = Select(title="Telescope:", value="", options=[])
self.w_telid.on_change("value", self.on_telid_widget_change)
def update_telid_widget(self):
if self.w_telid:
tels = [str(t) for t in self.event.r0.tel.keys()]
self.w_telid.options = tels
self.w_telid.value = str(self.telid)
def on_telid_widget_change(self, _, __, ___):
if self.telid != int(self.w_telid.value):
self.telid = int(self.w_telid.value)
def create_channel_widget(self):
self.w_channel = Select(title="Channel:", value="", options=[])
self.w_channel.on_change("value", self.on_channel_widget_change)
def update_channel_widget(self):
if self.w_channel:
try:
n_chan = self.event.r0.tel[self.telid].waveform.shape[0]
except AttributeError:
n_chan = 1
channels = [str(c) for c in range(n_chan)]
self.w_channel.options = channels
self.w_channel.value = str(self.channel)
def on_channel_widget_change(self, _, __, ___):
if self.channel != int(self.w_channel.value):
self.channel = int(self.w_channel.value)
def create_dl1_widgets(self):
self.w_dl1_dict = dict(
extractor=Select(
title="Extractor:",
value="",
width=5,
options=BokehFileViewer.extractor_product.values,
),
extractor_window_start=TextInput(title="Window Start:", value=""),
extractor_window_width=TextInput(title="Window Width:", value=""),
extractor_window_shift=TextInput(title="Window Shift:", value=""),
extractor_lwt=TextInput(title="Local Pixel Weight:", value=""),
)
for val in self.w_dl1_dict.values():
val.on_change("value", self.on_dl1_widget_change)
self.wb_extractor = widgetbox(
PreText(text="Charge Extractor Configuration"),
self.w_dl1_dict["extractor"],
self.w_dl1_dict["extractor_window_start"],
self.w_dl1_dict["extractor_window_width"],
self.w_dl1_dict["extractor_window_shift"],
self.w_dl1_dict["extractor_lwt"],
)
def update_dl1_widget_values(self):
if self.w_dl1_dict:
for key, val in self.w_dl1_dict.items():
if "extractor" in key:
if key == "extractor":
val.value = self.extractor.__class__.__name__
else:
key = key.replace("extractor_", "")
try:
val.value = str(getattr(self.extractor, key))
except AttributeError:
val.value = ""
def on_dl1_widget_change(self, _, __, ___):
if self.event:
if not self._updating_dl1:
self._updating_dl1 = True
cmdline = []
for key, val in self.w_dl1_dict.items():
k = key.replace("extractor_", "ImageExtractor.")
if val.value:
cmdline.append(f"--{k}={val.value}")
self.parse_command_line(cmdline)
extractor = ImageExtractor.from_name(self.extractor_product,
parent=self)
self.update_dl1_calibrator(extractor)
self.update_dl1_widget_values()
self._updating_dl1 = False
class DisplayIntegrator(Tool):
name = "ctapipe-display-integration"
description = __doc__
event_index = Int(0, help="Event index to view.").tag(config=True)
use_event_id = Bool(
False, help="event_index will obtain an event using event_id instead of index."
).tag(config=True)
telescope = Int(
None,
allow_none=True,
help="Telescope to view. Set to None to display the first"
"telescope with data.",
).tag(config=True)
channel = Enum([0, 1], 0, help="Channel to view").tag(config=True)
aliases = Dict(
dict(
f="EventSource.input_url",
max_events="EventSource.max_events",
E="DisplayIntegrator.event_index",
T="DisplayIntegrator.telescope",
C="DisplayIntegrator.channel",
)
)
flags = Dict(
dict(
id=(
{"DisplayDL1Calib": {"use_event_index": True}},
"event_index will obtain an event using event_id instead of index.",
)
)
)
classes = [EventSource] + traits.classes_with_traits(ImageExtractor)
def __init__(self, **kwargs):
super().__init__(**kwargs)
# make sure gzip files are seekable
self.config.SimTelEventSource.back_seekable = True
self.eventseeker = None
self.calibrator = None
def setup(self):
self.log_format = "%(levelname)s: %(message)s [%(name)s.%(funcName)s]"
event_source = EventSource(parent=self)
self.subarray = event_source.subarray
self.eventseeker = EventSeeker(event_source, parent=self)
self.calibrate = CameraCalibrator(parent=self, subarray=self.subarray)
def start(self):
if self.use_event_id:
event = self.eventseeker.get_event_id(self.event_index)
else:
event = self.eventseeker.get_event_index(self.event_index)
# Calibrate
self.calibrate(event)
# Select telescope
tels = list(event.r0.tel.keys())
telid = self.telescope
if telid is None:
telid = tels[0]
if telid not in tels:
self.log.error(
"[event] please specify one of the following "
"telescopes for this event: {}".format(tels)
)
exit()
extractor_name = self.calibrate.image_extractor_type.tel[telid]
plot(self.subarray, event, telid, self.channel, extractor_name)
def finish(self):
pass
def test_eventseeker():
with SimTelEventSource(input_url=dataset, back_seekable=True) as reader:
seeker = EventSeeker(event_source=reader)
event = seeker.get_event_index(1)
assert event.count == 1
event = seeker.get_event_index(0)
assert event.count == 0
event = seeker.get_event_id(31007)
assert event.index.event_id == 31007
with pytest.raises(IndexError):
seeker.get_event_index(200)
with pytest.raises(TypeError):
seeker.get_event_index("1")
with pytest.raises(TypeError):
seeker.get_event_index("t")
with pytest.raises(TypeError):
seeker.get_event_index(dict())
with SimTelEventSource(input_url=dataset, max_events=5,
back_seekable=True) as reader:
seeker = EventSeeker(event_source=reader)
with pytest.raises(IndexError):
event = seeker.get_event_index(5)
assert event is not None
