def test_read_container(temp_h5_file):
r0tel1 = R0CameraContainer()
r0tel2 = R0CameraContainer()
sim_shower = SimulatedShowerContainer()
with HDF5TableReader(temp_h5_file) as reader:
# get the generators for each table
# test supplying a single container as well as an
# iterable with one entry only
simtab = reader.read("/R0/sim_shower", (sim_shower, ))
r0tab1 = reader.read("/R0/tel_001", r0tel1)
r0tab2 = reader.read("/R0/tel_002", r0tel2)
# read all 3 tables in sync
for ii in range(3):
m = next(simtab)[0]
r0_1 = next(r0tab1)
r0_2 = next(r0tab2)
print("sim_shower:", m)
print("t0:", r0_1.waveform)
print("t1:", r0_2.waveform)
print("---------------------------")
assert "test_attribute" in r0_1.meta
assert r0_1.meta["date"] == "2020-10-10"
def test_read_container(temp_h5_file):
r0tel1 = R0CameraContainer()
r0tel2 = R0CameraContainer()
mc = MCEventContainer()
with HDF5TableReader(temp_h5_file) as reader:
# get the generators for each table
mctab = reader.read("/R0/MC", mc)
r0tab1 = reader.read("/R0/tel_001", r0tel1)
r0tab2 = reader.read("/R0/tel_002", r0tel2)
# read all 3 tables in sync
for ii in range(3):
m = next(mctab)
r0_1 = next(r0tab1)
r0_2 = next(r0tab2)
print("MC:", m)
print("t0:", r0_1.waveform)
print("t1:", r0_2.waveform)
print("---------------------------")
assert "test_attribute" in r0_1.meta
assert r0_1.meta["date"] == "2020-10-10"
def test_h5_file(tmp_path_factory):
"""Test hdf5 file with some tables for the reader tests"""
path = tmp_path_factory.mktemp("hdf5") / "test.h5"
r0 = R0CameraContainer()
shower = SimulatedShowerContainer()
r0.waveform = np.random.uniform(size=(50, 10))
r0.meta["test_attribute"] = 3.14159
r0.meta["date"] = "2020-10-10"
with HDF5TableWriter(path,
group_name="R0",
filters=tables.Filters(complevel=7)) as writer:
for _ in range(100):
r0.waveform[:] = np.random.uniform(size=(50, 10))
shower.energy = 10**np.random.uniform(1, 2) * u.TeV
shower.core_x = np.random.uniform(-1, 1) * u.m
shower.core_y = np.random.uniform(-1, 1) * u.m
writer.write("tel_001", r0)
writer.write("tel_002", r0) # write a second table too
writer.write("sim_shower", shower)
return path
def test_write_container(temp_h5_file):
r0tel = R0CameraContainer()
simshower = SimulatedShowerContainer()
simshower.reset()
r0tel.waveform = np.random.uniform(size=(50, 10))
r0tel.meta["test_attribute"] = 3.14159
r0tel.meta["date"] = "2020-10-10"
with HDF5TableWriter(temp_h5_file,
group_name="R0",
filters=tables.Filters(complevel=7)) as writer:
for ii in range(100):
r0tel.waveform[:] = np.random.uniform(size=(50, 10))
simshower.energy = 10**np.random.uniform(1, 2) * u.TeV
simshower.core_x = np.random.uniform(-1, 1) * u.m
simshower.core_y = np.random.uniform(-1, 1) * u.m
writer.write("tel_001", r0tel)
writer.write("tel_002", r0tel) # write a second table too
writer.write("sim_shower", simshower)
def test_write_container(temp_h5_file):
r0tel = R0CameraContainer()
mc = MCEventContainer()
mc.reset()
r0tel.waveform = np.random.uniform(size=(50, 10))
r0tel.meta["test_attribute"] = 3.14159
r0tel.meta["date"] = "2020-10-10"
with HDF5TableWriter(temp_h5_file,
group_name="R0",
filters=tables.Filters(complevel=7)) as writer:
writer.exclude("tel_002", ".*samples") # test exclusion of columns
for ii in range(100):
r0tel.waveform[:] = np.random.uniform(size=(50, 10))
mc.energy = 10**np.random.uniform(1, 2) * u.TeV
mc.core_x = np.random.uniform(-1, 1) * u.m
mc.core_y = np.random.uniform(-1, 1) * u.m
writer.write("tel_001", r0tel)
writer.write("tel_002", r0tel) # write a second table too
writer.write("MC", mc)
def fill_r0r1_camera_container(self, zfits_event):
"""
Fill the r0 or r1 container, depending on whether gain
selection has already happened (r1) or not (r0)
This will create waveforms of shape (N_GAINS, N_PIXELS, N_SAMPLES),
or (N_PIXELS, N_SAMPLES) respectively regardless of the n_pixels, n_samples
in the file.
Missing or broken pixels are filled using maxval of the waveform dtype.
"""
n_pixels = self.camera_config.num_pixels
n_samples = self.camera_config.num_samples
expected_pixels = self.camera_config.expected_pixels_id
has_low_gain = (zfits_event.pixel_status
& PixelStatus.LOW_GAIN_STORED).astype(bool)
has_high_gain = (zfits_event.pixel_status
& PixelStatus.HIGH_GAIN_STORED).astype(bool)
not_broken = (has_low_gain | has_high_gain).astype(bool)
# broken pixels have both false, so gain selected means checking
# if there are any pixels where exactly one of high or low gain is stored
gain_selected = np.any(has_low_gain != has_high_gain)
# fill value for broken pixels
dtype = zfits_event.waveform.dtype
fill = np.iinfo(dtype).max
# we assume that either all pixels are gain selected or none
# only broken pixels are allowed to be missing completely
if gain_selected:
selected_gain = np.where(has_high_gain, 0, 1)
waveform = np.full((n_pixels, n_samples), fill, dtype=dtype)
waveform[not_broken] = zfits_event.waveform.reshape(
(-1, n_samples))
reordered_waveform = np.full((N_PIXELS, N_SAMPLES),
fill,
dtype=dtype)
reordered_waveform[expected_pixels] = waveform
reordered_selected_gain = np.full(N_PIXELS, -1, dtype=np.int8)
reordered_selected_gain[expected_pixels] = selected_gain
r0 = R0CameraContainer()
r1 = R1CameraContainer(
waveform=reordered_waveform,
selected_gain_channel=reordered_selected_gain,
)
else:
reshaped_waveform = zfits_event.waveform.reshape(
N_GAINS, n_pixels, n_samples)
# re-order the waveform following the expected_pixels_id values
# could also just do waveform = reshaped_waveform[np.argsort(expected_ids)]
reordered_waveform = np.full((N_GAINS, N_PIXELS, N_SAMPLES),
fill,
dtype=dtype)
reordered_waveform[:, expected_pixels, :] = reshaped_waveform
r0 = R0CameraContainer(waveform=reordered_waveform)
r1 = R1CameraContainer()
return r0, r1