def test_I3Waveform_string(self):
wave1 = dataclasses.I3Waveform()
wave2 = dataclasses.I3Waveform()
wave1.time = 0.123
wave2.time = 0.123
wave1.hlc = True
wave2.hlc = True
self.assertEqual(wave1.__str__(), wave2.__str__(),
"these should be the same.")
def test_I3Waveform_Equality_Operator(self):
wave1 = dataclasses.I3Waveform()
wave1.time = 123
wave1.bin_width = 100
wave2 = dataclasses.I3Waveform()
wave2.time = 234
wave2.bin_width = 200
wave3 = dataclasses.I3Waveform()
wave3.time = 123
wave3.bin_width = 100
self.assertTrue(wave1==wave1,'these should be equal')
self.assertFalse(wave1==wave2,'these should not be equal!')
self.assertTrue(wave1==wave3,'these should be equal!')
def create_plot(self, frame, fig):
dkey = list(self.keys())[0]
pmap = dataclasses.I3RecoPulseSeriesMap.from_frame(frame, dkey)
calib = frame['I3Calibration']
status = frame['I3DetectorStatus']
keys = self.setting('OMKeys')
axes = fig.add_subplot(1, 1, 1)
# protect against missed clicks
keys = [k for k in keys if k in pmap]
# FIXME: think of a better way to pick colors and line styles
for color, k in colorize(keys):
pulses = pmap[k]
cal = calib.dom_cal[k]
stat = status.dom_status[k]
label = 'OM(%d,%d): %.1f PE' % (k.string, k.om,
sum(p.charge for p in pulses))
trange = (min(p.time for p in pulses), max(p.time for p in pulses))
wf = dataclasses.I3Waveform()
WaveformPlotter.plot_pulses(axes,
trange,
wf,
pulses,
cal,
stat,
color=color,
label=label)
if ('I3Geometry' in frame):
self.addOverlayLine(frame['I3Geometry'].omgeo[k].position,
mplcol.to_rgb(color))
axes.set_xlabel('Time [microseconds]', fontsize='smaller')
axes.set_ylabel('Toroid output voltage [mV]', fontsize='smaller')
if (self.setting('logscale')):
axes.set_yscale('log')
if (self.setting("Animated")):
mintime = min(pulses[0].time for pulses in pmap.values()) - 100
self.timeline = axes.axvline(mintime / 1e3, color='black')
if (self.setting('legend')):
axes.legend(loc='best', prop={'size': 'small'})
rps.append(rp)
for pulse in rps:
print(pulse)
rpsm = dataclasses.I3RecoPulseSeriesMap()
rpsm[icetray.OMKey(1, 1)] = rps
for key, pseries in rpsm:
print(key)
for pulse in pseries:
print(pulse)
#I3Waveform
print('Testing I3Waveform')
my_wf = dataclasses.I3Waveform()
my_wf.time = 100.0 * icetray.I3Units.ns
my_wf.bin_width = 3.3 * icetray.I3Units.ns
awave = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]
my_wf.waveform = awave
my_wf.digitizer = dataclasses.I3Waveform.Source.FADC
my_wf.hlc = True
wv_series = dataclasses.I3WaveformSeries()
wv_series.append(my_wf)
for wv in wv_series:
print(wv.time)
wv_ser_map = dataclasses.I3WaveformSeriesMap()
wv_ser_map[icetray.OMKey(2, 2)] = wv_series
def RandomWaveforms(fr):
calib = fr['I3Calibration']
status = fr['I3DetectorStatus']
pulsemap = dataclasses.I3RecoPulseSeriesMap()
wfmap = dataclasses.I3WaveformSeriesMap()
for om in calib.dom_cal.keys():
pulses = dataclasses.I3RecoPulseSeries()
waveforms = dataclasses.I3WaveformSeries()
fadc_templ = calib.dom_cal[om].fadc_pulse_template(False)
atwd0_templ = calib.dom_cal[om].atwd_pulse_template(0, False)
spe_charge = dataclasses.spe_mean(status.dom_status[om],
calib.dom_cal[om])
if spe_charge < I3Units.pC: continue
spe_charge *= calib.dom_cal[om].front_end_impedance
for launch in range(0, random.randint(0, 4)):
npulses = random.randint(0, 5)
launchtime = launch * 10000
# Make 30% of SPE launches SLC
slc = (npulses == 1 and random.uniform(0, 1) < 0.3)
# ATWD Waveform
atwd0_wf = dataclasses.I3Waveform()
atwd0_wf.waveform = [ \
random.normalvariate(0, 0.3)*I3Units.mV for \
i in range(0, 128)]
atwd0_wf.digitizer = dataclasses.I3Waveform.ATWD
atwd0_wf.bin_width = 3.3
atwd0_wf.hlc = not slc
atwd0_wf.time = launchtime
# FADC Waveform
if slc:
fadc_nbins = 3
else:
fadc_nbins = 256
fadc_wf = dataclasses.I3Waveform()
fadc_wf.waveform = [ \
random.normalvariate(0, 0.1)*I3Units.mV for \
i in range(0, fadc_nbins)]
fadc_wf.digitizer = dataclasses.I3Waveform.FADC
fadc_wf.bin_width = 25
fadc_wf.hlc = not slc
fadc_wf.time = launchtime
for p in range(0, npulses):
pulse = dataclasses.I3RecoPulse()
pulse.charge = random.randint(1, 3)
if not slc:
pulse.time = launchtime + \
random.gammavariate(2.5, 80)
pulse.flags = pulse.PulseFlags.LC
else:
pulse.time = launchtime + \
random.uniform(-25, 25)
pulses.append(pulse)
norm = spe_charge * pulse.charge
for i in range(0, len(fadc_wf.waveform)):
fadc_wf.waveform[i] += norm * \
fadc_templ((i+1)*fadc_wf.bin_width - \
(pulse.time - launchtime))
for i in range(0, len(atwd0_wf.waveform)):
atwd0_wf.waveform[i] += norm * \
atwd0_templ((i+1)*atwd0_wf.bin_width - \
(pulse.time - launchtime))
waveforms.append(fadc_wf)
if not slc:
waveforms.append(atwd0_wf)
wfmap[om] = waveforms
pulsemap[om] = dataclasses.I3RecoPulseSeries(
sorted(pulses, key=lambda pulse: pulse.time))
fr['RandomPulses'] = pulsemap
fr['CalibratedWaveforms'] = wfmap
fr['CalibratedWaveformRange'] = dataclasses.I3TimeWindow(0, 10000)