def test_apply_simtel_r1_calibration_2_channel():
n_channels = 2
n_pixels = 2048
n_samples = 128
r0_waveforms = np.zeros((n_channels, n_pixels, n_samples))
r0_waveforms[0, 0, :] = 100
r0_waveforms[1, :, :] = 1
pedestal = np.zeros((n_channels, n_pixels))
pedestal[0] = 90
pedestal[1] = 0.9
dc_to_pe = np.zeros((n_channels, n_pixels))
dc_to_pe[0] = 0.01
dc_to_pe[1] = 0.1
gain_selector = ThresholdGainSelector(threshold=90)
r1_waveforms, selected_gain_channel = apply_simtel_r1_calibration(
r0_waveforms, pedestal, dc_to_pe, gain_selector)
assert selected_gain_channel[0] == 1
assert (selected_gain_channel[np.arange(1, 2048)] == 0).all()
assert r1_waveforms.ndim == 2
assert r1_waveforms.shape == (n_pixels, n_samples)
ped = pedestal
assert r1_waveforms[0,
0] == (r0_waveforms[1, 0, 0] - ped[1, 0]) * dc_to_pe[1,
0]
assert r1_waveforms[1,
0] == (r0_waveforms[0, 1, 0] - ped[0, 1]) * dc_to_pe[0,
1]
def test_apply_simtel_r1_calibration_1_channel():
n_channels = 1
n_pixels = 2048
n_samples = 128
r0_waveforms = np.zeros((n_channels, n_pixels, n_samples))
pedestal = np.full((n_channels, n_pixels), 20)
dc_to_pe = np.full((n_channels, n_pixels), 0.5)
gain_selector = ThresholdGainSelector(threshold=90)
r1_waveforms, selected_gain_channel = apply_simtel_r1_calibration(
r0_waveforms, pedestal, dc_to_pe, gain_selector
)
assert (selected_gain_channel == 0).all()
assert r1_waveforms.ndim == 2
assert r1_waveforms.shape == (n_pixels, n_samples)
ped = pedestal
assert r1_waveforms[0, 0] == (r0_waveforms[0, 0, 0] - ped[0, 0]) * dc_to_pe[0, 0]
assert r1_waveforms[1, 0] == (r0_waveforms[0, 1, 0] - ped[0, 1]) * dc_to_pe[0, 1]
def _generator(self):
with self.pyhessio.open_hessio(self.input_url) as file:
# the container is initialized once, and data is replaced within
# it after each yield
counter = 0
eventstream = file.move_to_next_event()
data = DataContainer()
data.meta['origin'] = "hessio"
# some hessio_event_source specific parameters
data.meta['input_url'] = self.input_url
data.meta['max_events'] = self.max_events
for event_id in eventstream:
if counter == 0:
# subarray info is only available when an event is loaded,
# so load it on the first event.
data.inst.subarray = self._build_subarray_info(file)
obs_id = file.get_run_number()
tels_with_data = set(file.get_teldata_list())
data.count = counter
data.r0.obs_id = obs_id
data.r0.event_id = event_id
data.r0.tels_with_data = tels_with_data
data.r1.obs_id = obs_id
data.r1.event_id = event_id
data.r1.tels_with_data = tels_with_data
data.dl0.obs_id = obs_id
data.dl0.event_id = event_id
data.dl0.tels_with_data = tels_with_data
# handle telescope filtering by taking the intersection of
# tels_with_data and allowed_tels
if len(self.allowed_tels) > 0:
selected = tels_with_data & self.allowed_tels
if len(selected) == 0:
continue # skip event
data.r0.tels_with_data = selected
data.r1.tels_with_data = selected
data.dl0.tels_with_data = selected
data.trig.tels_with_trigger = (
file.get_central_event_teltrg_list())
time_s, time_ns = file.get_central_event_gps_time()
data.trig.gps_time = Time(time_s * u.s,
time_ns * u.ns,
format='unix',
scale='utc')
data.mc.energy = file.get_mc_shower_energy() * u.TeV
data.mc.alt = Angle(file.get_mc_shower_altitude(), u.rad)
data.mc.az = Angle(file.get_mc_shower_azimuth(), u.rad)
data.mc.core_x = file.get_mc_event_xcore() * u.m
data.mc.core_y = file.get_mc_event_ycore() * u.m
first_int = file.get_mc_shower_h_first_int() * u.m
data.mc.h_first_int = first_int
data.mc.x_max = file.get_mc_shower_xmax() * u.g / (u.cm**2)
data.mc.shower_primary_id = file.get_mc_shower_primary_id()
# mc run header data
data.mcheader.run_array_direction = Angle(
file.get_mc_run_array_direction() * u.rad)
# this should be done in a nicer way to not re-allocate the
# data each time (right now it's just deleted and garbage
# collected)
data.r0.tel.clear()
data.r1.tel.clear()
data.dl0.tel.clear()
data.dl1.tel.clear()
data.mc.tel.clear() # clear the previous telescopes
for tel_id in tels_with_data:
mc = data.mc.tel[tel_id]
r0 = data.r0.tel[tel_id]
r1 = data.r1.tel[tel_id]
pointing = data.pointing[tel_id]
adc_samples = file.get_adc_sample(tel_id)
if adc_samples.size == 0:
adc_samples = file.get_adc_sum(tel_id)[..., None]
dc_to_pe = file.get_calibration(tel_id)
pedestal = file.get_pedestal(tel_id)
r0.waveform = adc_samples
r1.waveform, r1.selected_gain_channel = apply_simtel_r1_calibration(
adc_samples, pedestal, dc_to_pe, self.gain_selector)
mc.dc_to_pe = dc_to_pe
mc.pedestal = pedestal
r0.num_trig_pix = file.get_num_trig_pixels(tel_id)
r0.trig_pix_id = file.get_trig_pixels(tel_id)
mc.reference_pulse_shape = file.get_ref_shapes(tel_id)
# load the data per telescope/pixel
hessio_mc_npe = file.get_mc_number_photon_electron(tel_id)
mc.photo_electron_image = hessio_mc_npe
mc.meta['refstep'] = file.get_ref_step(tel_id)
mc.time_slice = file.get_time_slice(tel_id)
mc.azimuth_raw = file.get_azimuth_raw(tel_id)
mc.altitude_raw = file.get_altitude_raw(tel_id)
azimuth_cor = file.get_azimuth_cor(tel_id)
altitude_cor = file.get_altitude_cor(tel_id)
# hessioeventsource pass 0 if there is no altitude/azimuth correction
if azimuth_cor == 0 and mc.azimuth_raw != 0:
mc.azimuth_cor = np.nan
pointing.azimuth = u.Quantity(mc.azimuth_raw, u.rad)
else:
mc.azimuth_cor = azimuth_cor
pointing.azimuth = u.Quantity(azimuth_cor, u.rad)
if altitude_cor == 0 and mc.altitude_raw != 0:
mc.altitude_cor = np.nan
pointing.altitude = u.Quantity(mc.altitude_raw, u.rad)
else:
mc.altitude_cor = altitude_cor
pointing.altitude = u.Quantity(mc.altitude_cor, u.rad)
yield data
counter += 1
return
