def setUp(self):
self.frame = icetray.I3Frame(icetray.I3Frame.Physics)
pulses = dataclasses.I3RecoPulseSeriesMap()
key1 = icetray.OMKey(42, 7)
vec = dataclasses.I3RecoPulseSeries()
pulse = dataclasses.I3RecoPulse()
pulse.time = 1.0
pulse.charge = 2.3
vec.append(pulse)
pulse.time = 2.0
vec.append(pulse)
pulse.time = 15.0
vec.append(pulse)
pulses[key1] = vec
key2 = icetray.OMKey(7, 7)
vec = dataclasses.I3RecoPulseSeries()
pulse.time = 1.0
pulse.charge = 2.3
vec.append(pulse)
pulse.time = 2.0
vec.append(pulse)
pulse.time = 15.0
vec.append(pulse)
pulses[key2] = vec
self.frame['Pulses'] = pulses
mask1 = dataclasses.I3RecoPulseSeriesMapMask(self.frame, 'Pulses')
mask1.set(key1, 1, False)
self.frame['Mask1'] = mask1
mask2 = dataclasses.I3RecoPulseSeriesMapMask(self.frame, 'Pulses')
mask2.set(key2, 1, False)
self.frame['Mask2'] = mask2
def make_rpsmap():
rpsmap = dataclasses.I3RecoPulseSeriesMap()
for omkey in doms:
rpsmap[omkey] = dataclasses.I3RecoPulseSeries()
# time, width, and charge
rp_properties = [(1650, 100, 0), (1850, 100, 1), (0, 100, 2), (550, 0, 3),
(800, 0, 4), (3500, 100, 5), (3500, 100, 6),
(3500, 100, 7), (3500, 100, 8), (8000, 3000, 9),
(9000, 100, 10), (9500, 100, 11)]
rp_list = [dataclasses.I3RecoPulse() for i in range(len(rp_properties))]
for idx, prop in enumerate(rp_properties):
rp_list[idx].time = prop[0]
rp_list[idx].width = prop[1]
rp_list[idx].charge = prop[2]
rpsmap[doms[0]].append(rp_list[0])
rpsmap[doms[0]].append(rp_list[1])
rpsmap[doms[0]].append(rp_list[2])
rpsmap[doms[1]].append(rp_list[3])
rpsmap[doms[2]].append(rp_list[4])
rpsmap[doms[2]].append(rp_list[5])
rpsmap[doms[3]].append(rp_list[6])
rpsmap[doms[3]].append(rp_list[7])
rpsmap[doms[4]].append(rp_list[8])
rpsmap[doms[4]].append(rp_list[9])
rpsmap[doms[4]].append(rp_list[10])
rpsmap[doms[4]].append(rp_list[11])
return rpsmap
def Process(self):
if not self.geometry:
self.geometry = True
geometry = dc.I3Geometry()
for string in self.strings:
for dom in self.doms:
omkey= icetray.OMKey(string,dom)
geometry.omgeo[omkey] = dc.I3OMGeo()
x=random.uniform(-500,500)
y=random.uniform(-500,500)
z=random.uniform(-300,300)
geometry.omgeo[omkey].position = dc.I3Position(x,y,z)
frame = icetray.I3Frame(icetray.I3Frame.Geometry);
frame.Put('I3Geometry',geometry)
self.PushFrame(frame)
pulsesmap= dc.I3RecoPulseSeriesMap()
for string in self.strings:
for dom in self.doms:
omkey= icetray.OMKey(string,dom)
pulse= dc.I3RecoPulse()
pulse.charge= random.uniform(0.3,6.)#pulses are not used in the algorithm of this module,
#just put a single pulse with any value of the charge
pulsesmap[omkey]= dc.I3RecoPulseSeries([pulse])
frame = icetray.I3Frame(icetray.I3Frame.Physics);
frame.Put("TestPulseSeriesMap",pulsesmap)
self.PushFrame(frame)
def Create_PulseSeriesMap(frame):
pulsesmap = dc.I3RecoPulseSeriesMap()
p1 = dc.I3RecoPulse()
p1.charge = 2.3
p1.time = 5.1
p2 = dc.I3RecoPulse()
p2.charge = 1.5
p2.time = 9.1
pulsesmap[icetray.OMKey(10, 4)] = dc.I3RecoPulseSeries([p1, p2])
p1 = dc.I3RecoPulse()
p1.charge = 4.5
p1.time = 43.1
p2 = dc.I3RecoPulse()
p2.charge = 0.9
p2.time = 1.2
pulsesmap[icetray.OMKey(25, 13)] = dc.I3RecoPulseSeries([p1, p2])
frame.Put("TestRecoPulseSeriesMap", pulsesmap)
def Physics(self, frame):
rpsmap = dataclasses.I3RecoPulseSeriesMap()
doms = [icetray.OMKey(0, i) for i in range(4)]
for omkey, time in zip(doms, self.times):
rp = dataclasses.I3RecoPulse()
rp.time = time
rps = dataclasses.I3RecoPulseSeries()
rps.append(rp)
rpsmap[omkey] = rps
frame[self.output_map_name] = rpsmap
self.PushFrame(frame)
def I3MapKeyVectorDouble_to_I3RecoPulseSeriesMap(f):
i3MapKeyVectorDouble = f['splittedDOMMap']
i3RecoPulseSeriesMap = dataclasses.I3RecoPulseSeriesMap()
for (k, l) in i3MapKeyVectorDouble.items():
pulses = dataclasses.I3RecoPulseSeries()
for d in l:
p = dataclasses.I3RecoPulse()
p.time = d
pulses.append(p)
i3RecoPulseSeriesMap[k] = pulses
f['splittedDOMMap_pulses'] = i3RecoPulseSeriesMap
def fakeit(frame): header = dataclasses.I3EventHeader() frame['I3EventHeader'] = header pulsemap = dataclasses.I3RecoPulseSeriesMap() pulses = dataclasses.I3RecoPulseSeries() pulse = dataclasses.I3RecoPulse() pulses.append(pulse) pulsemap[icetray.OMKey(7,42)] = pulses pulsemap[icetray.OMKey(9,42)] = pulses frame['Pulses'] = pulsemap mask = dataclasses.I3RecoPulseSeriesMapMask(frame, 'Pulses') frame['PulseMask'] = mask
def fixDST(fr, pulseMaskName, newPulseMapName):
if pulseMaskName in fr:
pulsemap = fr[pulseMaskName].apply(fr)
newMap = dataclasses.I3RecoPulseSeriesMap()
for (omkey, pulses) in pulsemap:
series = dataclasses.I3RecoPulseSeries()
for p in pulses:
if p.width <= 0.:
p.time -= 0.51 * I3Units.ns
p.width = 0.5 * I3Units.ns
series.append(p)
newMap[omkey] = series
fr[newPulseMapName] = newMap
def Create_PulseSeriesMap(frame):
pulsesmap= dc.I3RecoPulseSeriesMap()
p1=dc.I3RecoPulse()
p1.charge=2.3
p1.time=1.0*icetray.I3Units.ns
p1.width=.0*icetray.I3Units.ns
p2=dc.I3RecoPulse()
p2.charge=1.5
p2.time=2.*icetray.I3Units.ns
p2.width=.0*icetray.I3Units.ns
pulsesmap[icetray.OMKey(10,4)]= dc.I3RecoPulseSeries([p1,p2])
p1=dc.I3RecoPulse()
p1.charge=4.5
p1.time=3.0*icetray.I3Units.ns
p1.width=.0*icetray.I3Units.ns
p2=dc.I3RecoPulse()
p2.charge=0.9
p2.time=802.*icetray.I3Units.ns #will find two pulses (in OMKey(10,4)) that are not in the window of 800 ns
p2.width=.0*icetray.I3Units.ns
pulsesmap[icetray.OMKey(10,5)]= dc.I3RecoPulseSeries([p1,p2])
frame.Put("TestRecoPulseSeriesMap",pulsesmap)
def Physics(self, frame):
pulse_map = dataclasses.I3RecoPulseSeriesMap()
for string in range(1, n_strings + 1):
for om in range(1, n_doms + 1):
om_key = icetray.OMKey(string, om)
n_hits = np.random.poisson(lam=self.lambda_poisson)
times = (np.random.random(n_hits) * self.event_length).round(1)
pulse_series = dataclasses.I3RecoPulseSeries()
for time in sorted(times):
pulse = dataclasses.I3RecoPulse()
pulse.time = time
pulse.charge = 1.0
pulse_series.append(pulse)
pulse_map[om_key] = pulse_series
frame["SLOPPOZELA_Pulses"] = pulse_map
self.PushFrame(frame)
def setUp(self):
super(I3RecoPulseSeriesMapMaskTest2, self).setUp()
# create a pulse series map with a known bad
# 0 width case. only two pulses.
self.pulses = dataclasses.I3RecoPulseSeriesMap()
key1 = icetray.OMKey(42, 7)
vec = dataclasses.I3RecoPulseSeries()
pulse = dataclasses.I3RecoPulse()
pulse.time = 10226.6
pulse.charge = 28.1466
pulse.width = 0.833585
vec.append(pulse)
pulse.time = 10227.4
pulse.charge = 18.5683
pulse.width = 0.833585
vec.append(pulse)
self.pulses[key1] = vec
def mcpulse_to_recopulse(frame, mapname = "I3MCPulseSeriesMap", outputmap = "I3RecoPulseSeriesMap"):
'''
A module that does a direct conversion of I3MCPulses to I3RecoPulses.
It is intended to be used with PMTResponseSimulator output when one
wants to avoid the DOM simulation for some reason (no DOM electronic simulation. ie no launches but
PMT effects such as saturation is present).
'''
recopulsemap = dataclasses.I3RecoPulseSeriesMap()
mcpulsemap = frame[mapname]
for omkey, pulses in mcpulsemap:
recopulsemap[omkey] = dataclasses.I3RecoPulseSeries()
for pulse in pulses:
rpulse = dataclasses.I3RecoPulse()
rpulse.time = pulse.time
rpulse.charge = pulse.charge
rpulse.flags = dataclasses.I3RecoPulse.PulseFlags.LC
recopulsemap[omkey].append(rpulse)
frame[outputmap] = recopulsemap
def Physics(self, frame):
pulse_map = dataclasses.I3RecoPulseSeriesMap()
for string in range(51, 60):
track_time = self.event_length / 9 * (string - 50)
for om in range(40, 45):
om_key = icetray.OMKey(string, om)
n_hits = np.random.poisson(lam=3)
times = (np.random.random(n_hits) * 50000 - 25000 +
track_time).round(1)
pulse_series = dataclasses.I3RecoPulseSeries()
for time in sorted(times):
pulse = dataclasses.I3RecoPulse()
pulse.time = time
pulse.charge = 1.0
pulse.flags = 7
pulse_series.append(pulse)
pulse_map[om_key] = pulse_series
frame["SLOPPORATOR_Pulses"] = pulse_map
self.PushFrame(frame)
def effective_domsim(frame, mapname = "I3MCPulseSeriesMap", outputmap = "I3RecoPulseSeriesMap"):
'''
A module similar to mcpulse_to_recopulse above. It does an effective DOM
electronics simulation by adding jitter to the time and charge to the pulse
while converting the MCPulse to a reco pulse. The values for the spread of the gaussian
jitter were found by studying the spread of 1PE extracted pulses.
The module is intended to be use with the PMTResponseSimulator output in situations
when one wants to avoid the actual DOM simulation for some reason.
'''
from icecube.icetray import I3Units
recopulsemap = dataclasses.I3RecoPulseSeriesMap()
mcpulsemap = frame[mapname]
for omkey, pulses in mcpulsemap:
recopulsemap[omkey] = dataclasses.I3RecoPulseSeries()
for pulse in pulses:
rpulse = dataclasses.I3RecoPulse()
rpulse.time = random_service.gaus(pulse.time,2.0*I3Units.ns)
rpulse.charge = random_service.gaus(pulse.charge,0.012)#PE
rpulse.flags = dataclasses.I3RecoPulse.PulseFlags.LC
recopulsemap[omkey].append(rpulse)
frame[outputmap] = recopulsemap
def test_PulseChargeShifting(self):
frame = icetray.I3Frame()
omkey = icetray.OMKey(1, 1)
# create a calibration object
calibration = dataclasses.I3Calibration()
calibration.dom_cal[omkey] = dataclasses.I3DOMCalibration()
calibration.dom_cal[omkey].mean_atwd_charge = 1.2
calibration.dom_cal[omkey].mean_fadc_charge = 1.8
frame["I3Calibration"] = calibration
# create some pulses on our fake DOM
pulse1 = dataclasses.I3RecoPulse()
pulse1.flags = dataclasses.I3RecoPulse.PulseFlags.ATWD
pulse1.time = 1. * I3Units.nanosecond
pulse1.charge = 10.
pulse1.width = 1.
pulse2 = dataclasses.I3RecoPulse()
pulse2.flags = dataclasses.I3RecoPulse.PulseFlags.FADC
pulse2.time = 10. * I3Units.nanosecond
pulse2.charge = 5.
pulse2.width = 1.
pulse_series = dataclasses.I3RecoPulseSeriesMap()
pulse_series[omkey] = dataclasses.I3RecoPulseSeries()
pulse_series[omkey].append(pulse1)
pulse_series[omkey].append(pulse2)
# add these pulses to our new frame
frame["UnshiftedPulses"] = pulse_series
# create a shifter object
frame[
"ShiftedPulses"] = dataclasses.I3RecoPulseSeriesMapApplySPECorrection(
pulses_key="UnshiftedPulses", calibration_key="I3Calibration")
# retrieve the shifted pulses
shifted_pulses = dataclasses.I3RecoPulseSeriesMap.from_frame(
frame, "ShiftedPulses")
# make sure everything is as expected
self.assertEqual(pulse_series[omkey][0].time,
shifted_pulses[omkey][0].time,
"these should be the same.")
self.assertEqual(pulse_series[omkey][0].width,
shifted_pulses[omkey][0].width,
"these should be the same.")
self.assertEqual(pulse_series[omkey][0].flags,
shifted_pulses[omkey][0].flags,
"these should be the same.")
self.assertAlmostEqual(pulse_series[omkey][0].charge /
calibration.dom_cal[omkey].mean_atwd_charge,
shifted_pulses[omkey][0].charge,
places=4,
msg="these should be the same.")
self.assertEqual(pulse_series[omkey][1].time,
shifted_pulses[omkey][1].time,
"these should be the same.")
self.assertEqual(pulse_series[omkey][1].width,
shifted_pulses[omkey][1].width,
"these should be the same.")
self.assertEqual(pulse_series[omkey][1].flags,
shifted_pulses[omkey][1].flags,
"these should be the same.")
self.assertAlmostEqual(pulse_series[omkey][1].charge /
calibration.dom_cal[omkey].mean_fadc_charge,
shifted_pulses[omkey][1].charge,
places=4,
msg="these should be the same.")
if not fr.Has(wf_name):
continue
calib = fr['I3Calibration']
status = fr['I3DetectorStatus']
wfmap = fr[wf_name]
pulsemap = fr[pulseseries]
if pulsemap.__class__ == dataclasses.I3RecoPulseSeriesMapMask:
pulsemap = pulsemap.apply(fr)
for dom in wfmap.keys():
print(dom)
wfs = wfmap[dom]
try:
pulses = pulsemap[dom]
except:
pulses = dataclasses.I3RecoPulseSeries()
if len(pulses) == 0:
continue
qtot = numpy.sum([pulse.charge for pulse in pulses])
gp.title('Frame %d, %s - %lf PE, %d pulses' % \
(i, dom, qtot, len(pulses)))
spe_charge = dataclasses.spe_mean(status.dom_status[dom],
calib.dom_cal[dom])
spe_charge *= calib.dom_cal[dom].front_end_impedance
spe_charge *= 1e12
times = numpy.linspace(
numpy.min([wf.time for wf in wfs]) - 100,
numpy.max([wf.time + wf.bin_width * len(wf.waveform)]), 5000)
def Physics(self, frame):
a = 4.823 * 10.0**(-4.0) #ns/m^2
b = 19.41 #ns
sigma = 83.5 #m
t_cog = frame['ShowerCOG'].time
zenith_core = frame['Laputop'].dir.zenith
azimuth_core = frame['Laputop'].dir.azimuth
unit_core = np.array([
np.sin(zenith_core) * np.cos(azimuth_core),
np.sin(zenith_core) * np.sin(azimuth_core),
np.cos(zenith_core)
])
output_map = dataclasses.I3RecoPulseSeriesMap()
Laputop = frame['Laputop']
x_core = np.array([Laputop.pos.x, Laputop.pos.y, Laputop.pos.z])
t_core = Laputop.time
theta = Laputop.dir.theta
phi = Laputop.dir.phi
n = np.array([
np.sin(theta) * np.cos(phi),
np.sin(theta) * np.sin(phi),
np.cos(theta)
])
radius = dataclasses.I3MapKeyVectorDouble()
radius_old = dataclasses.I3MapKeyVectorDouble()
m = dataclasses.I3MapKeyVectorDouble()
s = dataclasses.I3MapKeyVectorDouble()
chi2 = dataclasses.I3MapKeyVectorDouble()
sigma_m = dataclasses.I3MapKeyVectorDouble()
sigma_s = dataclasses.I3MapKeyVectorDouble()
for i in frame['LaputopHLCVEM'].keys():
output_map[i] = dataclasses.I3RecoPulseSeries()
pulse = dataclasses.I3RecoPulse()
vec = []
vec_old = []
vec_m = []
vec_s = []
vec_chi2 = []
vec_sigma_m = []
vec_sigma_s = []
for j in frame['LaputopHLCVEM'][i]:
pulse.charge = j.charge
time = j.time
position_dom = frame['I3Geometry'].omgeo[i].position
x_dom = np.array(
[position_dom.x, position_dom.y, position_dom.z])
Radius = np.dot(x_dom - x_core, x_dom - x_core)**0.5
unit_dom = (x_dom - x_core) / Radius
true_radius = np.dot(unit_dom - unit_core, x_dom - x_core)
time_signal = time
vec.append(true_radius)
vec_old.append(Radius)
key = str(i)
pulse.time = frame['LaputopHLCVEM'][i][0].time
vec_m.append(frame['WaveformInfo'][key]['m'])
vec_s.append(frame['WaveformInfo'][key]['s'])
vec_chi2.append(frame['WaveformInfo'][key]['chi2'])
vec_sigma_m.append(frame['WaveformInfo'][key]['sigma_m'])
vec_sigma_s.append(frame['WaveformInfo'][key]['sigma_s'])
output_map[i].append(pulse)
radius[i] = np.array(vec)
radius_old[i] = np.array(vec_old)
m[i] = np.array(vec_m)
s[i] = np.array(vec_s)
chi2[i] = np.array(vec_chi2)
sigma_m[i] = np.array(vec_sigma_m)
sigma_s[i] = np.array(vec_sigma_s)
frame['All_radius'] = radius
frame['All_radius_old'] = radius_old
frame['All_pulses'] = output_map
frame['m'] = m
frame['s'] = s
frame['chi2'] = chi2
frame['sigma_m'] = sigma_m
frame['sigma_s'] = sigma_s
self.PushFrame(frame)
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)
