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 MaskPulses(frame):
frame['String3Pulses'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, 'OfflinePulses_sRT', selector3)
frame['StringC5Pulses'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, 'OfflinePulses_sRT', selectorC5)
frame['StringC6Pulses'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, 'OfflinePulses_sRT', selectorC6)
def MaskPulses(frame):
frame['String3Pulses'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, 'OfflinePulses', selector3)
frame['String4Pulses'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, 'OfflinePulses', selector4)
frame['String5Pulses'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, 'OfflinePulses', selector5)
frame['String6Pulses'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, 'OfflinePulses', selector6)
def MaskPulses(frame):
frame[ic86_cleaned_pulses] = dataclasses.I3RecoPulseSeriesMapMask(
frame, cleaned_pulses, selector)
frame[ic86_uncleaned_pulses] = dataclasses.I3RecoPulseSeriesMapMask(
frame, uncleaned_pulses, selector)
# utestpulse = dataclasses.I3RecoPulseSeriesMapMask(frame, uncleaned_pulses, selector)
# uIter = utestpulse.apply(frame)
# ctestpulse = dataclasses.I3RecoPulseSeriesMapMask(frame, cleaned_pulses, selector)
# cIter = ctestpulse.apply(frame)
# print 'Here',len(uIter),len(cIter)
if (not (ic86_cleaned_pulses) or not (ic86_uncleaned_pulses)):
return False
def MaskMaker(frame, Output):
pulses = dataclasses.I3RecoPulseSeriesMap.from_frame(frame, 'I3SuperDST')
ii_mask = dataclasses.I3RecoPulseSeriesMapMask(frame, 'I3SuperDST')
it_mask = dataclasses.I3RecoPulseSeriesMapMask(frame, 'I3SuperDST')
i3geometry = frame['I3Geometry']
for omkey in pulses.keys():
g = i3geometry.omgeo[omkey]
ii_mask.set(omkey, g.omtype == dataclasses.I3OMGeo.IceCube)
it_mask.set(omkey, g.omtype == dataclasses.I3OMGeo.IceTop)
frame['InIce' + Output] = ii_mask
frame['IceTop' + Output] = it_mask
def MaskMaker(frame):
if frame.Has('I3SuperDST') and frame.Has('DSTTriggers'): # save only filtered frames (traditional filter + SuperDST filter)
pulses = dataclasses.I3RecoPulseSeriesMap.from_frame(frame, 'I3SuperDST')
ii_mask = dataclasses.I3RecoPulseSeriesMapMask(frame, 'I3SuperDST')
it_mask = dataclasses.I3RecoPulseSeriesMapMask(frame, 'I3SuperDST')
for omkey in pulses.keys():
ii_mask.set(omkey, omkey.om <= 60)
it_mask.set(omkey, omkey.om > 60)
frame['InIceDSTPulses'] = ii_mask
frame['IceTopDSTPulses'] = it_mask
else:
return 0
def selectIceCubeOnly(frame, Pulses):
mask = copy(dataclasses.I3RecoPulseSeriesMapMask(frame, Pulses))
pulsemap = frame[Pulses].apply(frame)
for omkey in pulsemap.keys():
if omkey.string in [79, 80, 81, 82, 83, 84, 85, 86]:
mask.set(omkey, False)
frame[Pulses + "IC"] = mask
def pulse_pruner(frame, Input):
'''A simple re-implementation of the I3Pruner that works on pulses
Uses only InIce readout_settings for readout windows
'''
triggers = frame["I3Triggers"]
dstatus = frame["I3DetectorStatus"]
readoutStart = float('inf')
readoutStop = -float('inf')
#looping through all triggers to find
#the global start and stop time of the readout
for trig in triggers:
ts = dstatus.trigger_status[trig.key]
#For now we only care about InIce
rs = ts.readout_settings[ts.INICE]
rminus = rs.readout_time_minus
rplus = rs.readout_time_plus
triggerStart = trig.time
triggerStop = trig.time + trig.length
curr_readoutStart = triggerStart - rminus
curr_readoutStop = triggerStop + rplus
if(readoutStart > curr_readoutStart):
readoutStart = curr_readoutStart
if(readoutStop < curr_readoutStop):
readoutStop = curr_readoutStop
pulses = dataclasses.I3RecoPulseSeriesMapMask(frame, Input, lambda om, idx, pulse: pulse.time >= readoutStart and pulse.time < readoutStop).apply(frame)
del frame[Input]
frame[Input] = pulses
frame[Input+'TimeRange'] = dataclasses.I3TimeWindow(readoutStart,readoutStop)
def SuperDSTOnlyPulses(frame, launches, inpulses, outpulses):
mask = dataclasses.I3RecoPulseSeriesMapMask(frame,
inpulses, lambda omkey, index, pulse:
(not launches in frame or not omkey in frame[launches])
and not omkey in frame[BadDOMList])
if mask.any():
frame[outpulses] = mask
def LatePulseCleaning(frame, Pulses, Residual=3e3 * I3Units.ns):
pulses = dataclasses.I3RecoPulseSeriesMap.from_frame(frame, Pulses)
mask = dataclasses.I3RecoPulseSeriesMapMask(frame, Pulses)
counter, charge = 0, 0
qtot = 0
times = dataclasses.I3TimeWindowSeriesMap()
for omkey, ps in pulses.iteritems():
if len(ps) < 2:
if len(ps) == 1:
qtot += ps[0].charge
continue
ts = numpy.asarray([p.time for p in ps])
cs = numpy.asarray([p.charge for p in ps])
median = weighted_median(ts, cs)
qtot += cs.sum()
for p in ps:
if p.time >= (median + Residual):
if not times.has_key(omkey):
ts = dataclasses.I3TimeWindowSeries()
ts.append(
dataclasses.I3TimeWindow(median + Residual,
numpy.inf)
) # this defines the **excluded** time window
times[omkey] = ts
mask.set(omkey, p, False)
counter += 1
charge += p.charge
frame[nominalPulsesName + "LatePulseCleaned"] = mask
frame[nominalPulsesName + "LatePulseCleanedTimeWindows"] = times
frame[nominalPulsesName + "LatePulseCleanedTimeRange"] = copy.deepcopy(
frame[Pulses + "TimeRange"])
def copyPulseName(frame, old_name, new_name):
mask = dataclasses.I3RecoPulseSeriesMapMask(frame, old_name)
if new_name in frame:
print(
"** WARNING: {0} was already in frame. overwritten".format(
new_name))
del frame[new_name]
frame[new_name] = mask
frame[new_name + "TimeRange"] = copy.deepcopy(frame[old_name +
"TimeRange"])
def flag_borked_slc(frame):
# Find SLC launches affected by DOMsimulator off-by-one bug,
# and tell Millipede to ignore them
bad_keys = set()
import numpy
for om, dls in frame['InIceRawData'].iteritems():
for dl in dls:
if dl.lc_bit == False and dl.charge_stamp_highest_sample == 0:
print '%s, she is the bad!' % om
bad_keys.add(om)
if len(bad_keys) > 0:
frame['BorkedSLC'] = dataclasses.I3VectorOMKey(bad_keys)
frame[
'OfflinePulses_NoBorkedSLC'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, 'OfflinePulses',
lambda om, idx, pulse: om not in bad_keys)
else:
frame[
'OfflinePulses_NoBorkedSLC'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, 'OfflinePulses')
def testEqual(self):
mask1 = self.frame['Mask1']
mask2 = self.frame['Mask2']
mask3 = dataclasses.I3RecoPulseSeriesMapMask(mask1)
self.assertNotEquals(mask1, mask2)
self.assertEquals(mask1.source, mask3.source)
self.assertEquals(mask1.bits, mask3.bits)
self.assertEquals(mask1, mask3)
self.assertEquals(mask1 != mask3, False)
def splitpulses(frame, pulses):
hits = frame[pulses].apply(frame)
sub_hits1 = []
sub_hits2 = []
sub_hits3 = []
sub_hits4 = []
sub_hits5 = []
data1 = data2 = data3 = data4 = data5 = []
for i in range(len(hits.keys())):
if i % 5 != 0:
sub_hits1.append(hits.keys()[i])
if (i + 1) % 5 != 0:
sub_hits2.append(hits.keys()[i])
if (i + 2) % 5 != 0:
sub_hits3.append(hits.keys()[i])
if (i + 3) % 5 != 0:
sub_hits4.append(hits.keys()[i])
if (i + 4) % 5 != 0:
sub_hits5.append(hits.keys()[i])
frame['SubPulses0'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, pulses, lambda omkey, index, pulse: omkey in sub_hits1)
frame['SubPulses1'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, pulses, lambda omkey, index, pulse: omkey in sub_hits2)
frame['SubPulses2'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, pulses, lambda omkey, index, pulse: omkey in sub_hits3)
frame['SubPulses3'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, pulses, lambda omkey, index, pulse: omkey in sub_hits4)
frame['SubPulses4'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, pulses, lambda omkey, index, pulse: omkey in sub_hits5)
frame['DataPulses0'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, pulses, lambda omkey, index, pulse: omkey not in sub_hits1)
frame['DataPulses1'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, pulses, lambda omkey, index, pulse: omkey not in sub_hits2)
frame['DataPulses2'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, pulses, lambda omkey, index, pulse: omkey not in sub_hits3)
frame['DataPulses3'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, pulses, lambda omkey, index, pulse: omkey not in sub_hits4)
frame['DataPulses4'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, pulses, lambda omkey, index, pulse: omkey not in sub_hits5)
return True
def FramePacket(self, frames):
mctree = dataclasses.I3MCTree()
mask = dataclasses.I3RecoPulseSeriesMapMask(
frames[0], self.pulseSourceName,
dataclasses.I3RecoPulseSeriesMap())
for frame in frames:
if (frame.Stop == icetray.I3Frame.Physics):
if (frame["I3EventHeader"].sub_event_stream == self.splitName):
smallmctree = dataclasses.I3MCTree()
#need to have the time range
if (not frame.Has(self.recoMapName + "TimeRange")):
time_pulses = []
pulses = dataclasses.I3RecoPulseSeriesMap.from_frame(
frame, self.recoMapName)
for item in pulses:
for pulse in item[1]:
time_pulses.append(pulse.time)
time_pulses = numpy.array(time_pulses)
frame.Put(
self.recoMapName + "TimeRange",
dataclasses.I3TimeWindow(time_pulses.min(),
time_pulses.max()))
#now do the composition work
tr = frame[self.recoMapName + "TimeRange"]
part = frame[self.fitName]
primary = deepcopy(frame[self.fitName])
inparticle = deepcopy(frame[self.fitName])
outparticle = deepcopy(frame[self.fitName])
#primary.pos = part.shift_along_track((tr.start-part.time)*part.speed)
primary.type = dataclasses.I3Particle.NuMuBar #NuMuBar
primary.shape = dataclasses.I3Particle.Primary #InfiniteTrack #ContainedTrack #StoppingTrack
#primary.time = tr.start
primary.energy = 1
#primary.length = part.speed*(tr.start-tr.stop)
mctree.add_primary(primary)
smallmctree.add_primary(primary)
inparticle.type = dataclasses.I3Particle.MuMinus
inparticle.shape = dataclasses.I3Particle.ContainedTrack
inparticle.energy = 1
inparticle.length = part.speed * (tr.start - tr.stop)
inparticle.time = tr.start
#inparticle.pos = part.shift_along_track((tr.start-part.time)*part.speed)
mctree.append_child(primary, inparticle)
smallmctree.append_child(primary, inparticle)
mask = mask | frame[self.recoMapName]
frame.Put("smallTree" + self.fitName, smallmctree)
frames[0].Put("coll" + self.recoMapName, mask)
frames[0].Put("coll" + self.fitName, mctree)
for frame in frames:
self.PushFrame(frame)
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 Physics(self, frame):
fit, mask, fit_status = get_fit(frame, 0.5)
mask1 = dataclasses.I3RecoPulseSeriesMapMask(frame, 'All_pulses')
count = 0
for omkey in frame['WaveformInfo'].keys():
dom = int(omkey.split(',')[1])
string = int(omkey.split(',')[0].split('(')[1])
key = OMKey(string, dom)
mask1.set(key, bool(mask[count]))
count += 1
frame['NewMask'] = mask1
self.PushFrame(frame)
def Process(self):
""" deliver frames QP with only a bit of rudamentary information """
#make a Q-frame
Qframe = icetray.I3Frame(icetray.I3Frame.DAQ)
Qeh = dataclasses.I3EventHeader()
Qeh.start_time = (dataclasses.I3Time(2011, 0))
Qeh.end_time = (dataclasses.I3Time(2011, 2))
Qeh.run_id = 1
Qeh.event_id = 1
Qframe.Put("I3EventHeader", Qeh)
Qrecomap = dataclasses.I3RecoPulseSeriesMap()
recopulse1 = dataclasses.I3RecoPulse()
recopulse1.time = 0
recopulse1.charge = 1
recopulse2 = dataclasses.I3RecoPulse()
recopulse2.time = 1
recopulse2.charge = 2
Qrecomap[icetray.OMKey(1,1)] = [recopulse1]
Qrecomap[icetray.OMKey(2,2)] = [recopulse2]
Qframe.Put(OrgPulses, Qrecomap)
Qframe.Put(SplitName+"SplitCount", icetray.I3Int(1))
self.PushFrame(Qframe)
#now make the first p-frame containing one I3RecoPulse
P1frame = icetray.I3Frame(icetray.I3Frame.Physics)
P1eh = dataclasses.I3EventHeader()
P1eh.start_time = (dataclasses.I3Time(2011, 0))
P1eh.end_time = (dataclasses.I3Time(2011, 1))
P1eh.run_id = 1
P1eh.event_id = 1
P1eh.sub_event_stream = "split"
P1eh.sub_event_id = 0
P1frame.Put("I3EventHeader", P1eh)
P1recomap = dataclasses.I3RecoPulseSeriesMap()
P1recomap[icetray.OMKey(1,1)] = [recopulse1]
P1recomask = dataclasses.I3RecoPulseSeriesMapMask(Qframe, OrgPulses, Qrecomap)
P1frame.Put(SplitPulses, P1recomask)
self.PushFrame(P1frame)
self.RequestSuspension()
def FramePacket(self, frames):
partvec = dataclasses.I3VectorI3Particle()
mask = dataclasses.I3RecoPulseSeriesMapMask(
frames[0], self.pulseSourceName,
dataclasses.I3RecoPulseSeriesMap())
for frame in frames:
if (frame.Stop == icetray.I3Frame.Physics):
if (frame["I3EventHeader"].sub_event_stream == self.splitName):
primary = deepcopy(frame[self.fitName])
primary.type = dataclasses.I3Particle.MuMinus
primary.shape = dataclasses.I3Particle.ContainedTrack
primary.length = 500 #part.speed*(tr.start-tr.stop)
partvec.append(frame[self.fitName])
mask = mask | frame[self.recoMapName]
frame.Put("Primary", primary)
frames[0].Put(self.outputPrefix + self.recoMapName, mask)
frames[0].Put(self.outputPrefix + self.fitName, partvec)
for frame in frames:
self.PushFrame(frame)
def Remove1(frame):
if frame.Has("SRTInIcePulses_200_750_1"):
min0 = 100000
hits = dataclasses.I3RecoPulseSeriesMap.from_frame(
frame, 'SRTInIcePulses')
for item in hits:
for vals in item.data():
# print vals.time
if vals.time < min0:
min1 = vals.time
item0 = item
if frame.Has("SRTInIcePulses_rm1"):
return False
frame['STRInIcePulses_rm1'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, 'SRTInIcePulses',
lambda omkey, index, pulse: omkey != item.key())
return True
else:
return False
def Physics(self, frame):
if self.RunOnPulses:
if frame.Has(self.PulseMapName):
self.TuplePulseMask = dataclasses.I3RecoPulseSeriesMapMask(frame, self.PulseMapName)
self.TuplePulseMask.set_none()
else:
print(("Error, cannot find pulse mask %s") % self.PulseMapName)
return False
self.TupleCosAlphaVector_Pulses = dataclasses.I3VectorDouble()
self.TupleRelvVector_Pulses = dataclasses.I3VectorDouble()
self.RunTaggerOnPulses(frame)
frame['SLOPPulseMaskTuples'] = self.TuplePulseMask
frame['SLOPTuples_CosAlpha_Pulses'] = self.TupleCosAlphaVector_Pulses
frame['SLOPTuples_RelV_Pulses'] = self.TupleRelvVector_Pulses
if self.RunOnLaunches:
self.TupleLaunchMap = dataclasses.I3DOMLaunchSeriesMap()
self.TupleCosAlphaVector_Launches = dataclasses.I3VectorDouble()
self.TupleRelvVector_Launches = dataclasses.I3VectorDouble()
self.RunTaggerOnLaunches(frame)
frame['SLOPLaunchMapTuples'] = self.TupleLaunchMap
frame['SLOPTuples_CosAlpha_Launches'] = self.TupleCosAlphaVector_Launches
frame['SLOPTuples_RelV_Launches'] = self.TupleRelvVector_Launches
self.PushFrame(frame)
def CleanDeepCore(frame):
pulsemap = dataclasses.I3RecoPulseSeriesMap.from_frame(frame, 'SplitInIcePulsesHLC')
mask = dataclasses.I3RecoPulseSeriesMapMask(frame, 'SplitInIcePulsesHLC', lambda om, idx, pulse: om.string <= 78)
frame['SplitInIcePulsesHLC_NoDC'] = mask
def Process(self):
gcd = dataio.I3File(self.gcdfile, 'R')
while (gcd.more()):
frame = gcd.pop_frame()
self.PushFrame(frame)
gcd.close()
#now deliver artificial testcase
#make a Q-frame#make a Q-frame
Qframe = icetray.I3Frame(icetray.I3Frame.DAQ)
Qeh = dataclasses.I3EventHeader()
Qeh.start_time = (dataclasses.I3Time(2011, 0))
Qeh.end_time = (dataclasses.I3Time(2011, 2))
Qeh.run_id = 1
Qeh.event_id = 1
Qframe.Put("I3EventHeader", Qeh)
Qrecomap = dataclasses.I3RecoPulseSeriesMap()
recopulse1 = dataclasses.I3RecoPulse()
recopulse1.time = 0
recopulse1.charge = 1
recopulse2 = dataclasses.I3RecoPulse()
recopulse2.time = 1
recopulse2.charge = 2
Qrecomap[icetray.OMKey(1, 1)] = [recopulse1]
Qrecomap[icetray.OMKey(2, 2)] = [recopulse2]
Qframe.Put(OrgPulses, Qrecomap)
Qframe.Put(SplitName + "SplitCount", icetray.I3Int(2))
Qframe.Put(SplitName + "ReducedCount", icetray.I3Int(0))
self.PushFrame(Qframe)
#now make the first p-frame containing one I3RecoPulse
P1frame = icetray.I3Frame(icetray.I3Frame.Physics)
P1eh = dataclasses.I3EventHeader()
P1eh.start_time = (dataclasses.I3Time(2011, 0))
P1eh.end_time = (dataclasses.I3Time(2011, 1))
P1eh.run_id = 1
P1eh.event_id = 1
P1eh.sub_event_stream = SplitName
P1eh.sub_event_id = 0
P1frame.Put("I3EventHeader", P1eh)
P1recomap = dataclasses.I3RecoPulseSeriesMap()
P1recomap[icetray.OMKey(1, 1)] = [recopulse1]
P1recomask = dataclasses.I3RecoPulseSeriesMapMask(
Qframe, OrgPulses, Qrecomap)
P1frame.Put(SplitPulses, P1recomask)
self.PushFrame(P1frame)
#now make the second p-frame containing one I3RecoPulse
P2frame = icetray.I3Frame(icetray.I3Frame.Physics)
P2eh = dataclasses.I3EventHeader()
P2eh.start_time = (dataclasses.I3Time(2011, 1))
P2eh.end_time = (dataclasses.I3Time(2011, 2))
P2eh.run_id = 1
P2eh.event_id = 1
P2eh.sub_event_stream = SplitName
P2eh.sub_event_id = 1
P2frame.Put("I3EventHeader", P2eh)
P2recomap = dataclasses.I3RecoPulseSeriesMap()
P2recomap[icetray.OMKey(2, 2)] = [recopulse2]
P2recomask = dataclasses.I3RecoPulseSeriesMapMask(
Qframe, OrgPulses, P2recomap)
P2frame.Put(SplitPulses, P2recomask)
self.PushFrame(P2frame)
self.RequestSuspension()
def MaskPulses(frame):
frame['NoiselessPulses'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, 'OfflinePulses', selector)
def CleanDeepCore(frame):
mask = dataclasses.I3RecoPulseSeriesMapMask(
frame, "SplitPulses", lambda om, idx, pulse: om.string <= 78)
frame["SplitPulses_NoDC"] = mask
def MaskPulses(frame):
frame['Out1Pulses'] = dataclasses.I3RecoPulseSeriesMapMask(
frame, 'OfflinePulses_sRT', selector)
def Physics(self, frame):
if not frame.Has(self.inputMapName):
self.PushFrame(frame)
return
if type(frame[self.inputMapName]) == dataclasses.I3RecoPulseSeriesMapMask or \
type(frame[self.inputMapName]) == dataclasses.I3RecoPulseSeriesMap:
workingOnPulses = True
else:
workingOnPulses = False
if frame.Has(self.inputTrack):
seed = frame[self.inputTrack]
if type(frame[self.inputTrack]) == dataclasses.I3MCTree:
seed = frame[self.inputTrack][0]
initialPos = [seed.pos.x, seed.pos.y, seed.pos.z]
initialDir = [
seed.speed * seed.dir.x, seed.speed * seed.dir.y,
seed.speed * seed.dir.z
]
initialState = initialPos + initialDir
else:
print("Kalman - Error: InputTrack not found")
self.PushFrame(frame)
return
## timewise sorted Pulses/DomLaunches - [(OMkey, Time, Pulse/DomLaunch)]
hitlist = hitfilter(frame, self.inputMapName, self.IgnoreDC)
if self.useAcceleration:
stateDim = 9
else:
stateDim = 6
## Initialize Kalman filter
kalman = Kalman(stateDim, 3, initialState, self.noiseQ, self.noiseR)
for i in range(self.iterations):
## create variables for results
prediction = dataclasses.I3VectorI3Particle()
if self.useAcceleration:
acceleration = dataclasses.I3VectorI3Particle()
varianceVector = dataclasses.I3VectorDouble()
if workingOnPulses:
recoPulseSeriesMapMask = dataclasses.I3RecoPulseSeriesMapMask(
frame, self.inputMapName)
recoPulseSeriesMapMask.set_none()
else:
domLaunchSeriesMap = dataclasses.I3DOMLaunchSeriesMap()
## write seed to predictionlist
seed = dataclasses.I3Particle()
seed.pos = dataclasses.I3Position(initialState[0], initialState[1],
initialState[2])
seed.dir = dataclasses.I3Direction(initialState[3],
initialState[4],
initialState[5])
seed.speed = np.linalg.norm(initialState[3:6])
seed.time = 0
prediction.append(seed)
## Write acceleration seed
if self.useAcceleration:
accel = dataclasses.I3Particle()
accel.pos = dataclasses.I3Position(0, 0, 0)
acceleration.append(accel)
## clean variables
hitList = []
predList = []
time = []
chi2 = 0
lastTime = 0
p = kalman.Predict()
## loop over all hits in given map
for hit in hitlist:
## extrapolate Kalman-Prediction
pos = p[0:3] + p[3:6] * (hit.time - lastTime)
om = np.array(self.geo.omgeo[hit.omkey].position)
## Distance to next hit
d = np.linalg.norm(om - pos)
if d <= self.cutRadius:
dt = hit.time - lastTime
lastTime = hit.time
## Update Kalman filter with new hit
kalman.Update(om, dt)
p = kalman.Predict()
## Uncomment to activate debug mode
#kalman.Debug()
## Add Kalman-step to predictionlist
pred = dataclasses.I3Particle()
pred.pos = dataclasses.I3Position(p[0], p[1], p[2])
pred.dir = dataclasses.I3Direction(p[3], p[4], p[5])
pred.speed = np.linalg.norm(p[3:6])
pred.time = hit.time
prediction.append(pred)
if self.useAcceleration:
accel = dataclasses.I3Particle()
accel.pos = dataclasses.I3Position(p[6], p[7], p[8])
acceleration.append(accel)
varianceVector.append(kalman.GetVariance()[0])
chi2 += d**2
## write PulseMapMask/DOMLaunchMap
if workingOnPulses:
recoPulseSeriesMapMask.set(hit.omkey, hit.info, True)
else:
if hit.omkey in domLaunchSeriesMap:
domLaunchSeriesMap[hit.omkey].append(hit.info)
else:
domLaunchSeries = dataclasses.I3DOMLaunchSeries()
domLaunchSeries.append(hit.info)
domLaunchSeriesMap[hit.omkey] = domLaunchSeries
hitList += [om]
predList += [p[0:3]]
time += [hit.time]
## new initialization for the next global iteration
if len(hitList) > 0:
## use last iteration as LineFit
if self.iterationMethod == 1:
x0 = p[0] - p[3] * hit.time
y0 = p[1] - p[4] * hit.time
z0 = p[2] - p[5] * hit.time
particle = dataclasses.I3Particle()
particle.pos = dataclasses.I3Position(x0, y0, z0)
particle.dir = dataclasses.I3Direction(p[3], p[4], p[5])
particle.speed = np.linalg.norm([p[3:6]])
particle.time = 0
elif self.iterationMethod == 2:
## calculate the LineFit on selected pulses
particle = LineFitCallKalman(hitList, time)
elif self.iterationMethod == 3:
## calculate the LineFit on iteration steps
particle = LineFitCallKalman(predList, time)
else:
raise NotImplementedError(
"No IterationMethod with number %s" %
str(self.IterationMethod))
## Last Iteration ?
if i < self.iterations - 1:
initialPos = [
particle.pos.x, particle.pos.y, particle.pos.z
]
initialDir = [
particle.speed * particle.dir.x,
particle.speed * particle.dir.y,
particle.speed * particle.dir.z
]
initialState = initialPos + initialDir
initialP = kalman.GetVarianceVector()
kalman = Kalman(stateDim, 3, initialState, self.noiseQ,
self.noiseR, initialP)
else:
## Write everything to the frame
frame["%s_LineFit" % (self.outputTrack)] = particle
frame["%s_NHits" %
(self.outputTrack)] = dataclasses.I3Double(
len(hitList))
frame["%s_P" % (self.outputTrack)] = varianceVector
frame["%s_Chi2Pred" %
(self.outputTrack)] = dataclasses.I3Double(
Chi2CallKalman(predList, time, particle))
if workingOnPulses:
frame["%s_Map" %
(self.outputTrack)] = recoPulseSeriesMapMask
else:
frame["%s_Map" %
(self.outputTrack)] = domLaunchSeriesMap
if self.additionalInformation:
frame["%s_Pred" % (self.outputTrack)] = prediction
if self.useAcceleration:
frame["%s_Accel" %
(self.outputTrack)] = acceleration
self.PushFrame(frame)
def Process(self):
gcd = dataio.I3File(self.gcdfile, 'R')
while (gcd.more()):
frame = gcd.pop_frame()
if (frame.Stop == icetray.I3Frame.Geometry):
geo = frame["I3Geometry"]
self.PushFrame(frame)
gcd.close()
#now deliver artificial testcase
#make a Q-frame
Qrecomap = dataclasses.I3RecoPulseSeriesMap()
recopulse1 = dataclasses.I3RecoPulse()
recopulse1.time = 0.
recopulse1.charge = 1.
recopulse2 = dataclasses.I3RecoPulse()
recopulse2.time = 1000. / I3Constants.c #=3335.ns
recopulse2.charge = 2.
Qrecomap[icetray.OMKey(26, 1)] = [recopulse1]
Qrecomap[icetray.OMKey(27, 1)] = [recopulse1]
Qrecomap[icetray.OMKey(35, 1)] = [recopulse1]
Qrecomap[icetray.OMKey(37, 1)] = [recopulse1]
Qrecomap[icetray.OMKey(45, 1)] = [recopulse1]
Qrecomap[icetray.OMKey(46, 1)] = [recopulse1]
Qrecomap[icetray.OMKey(26, 60)] = [recopulse2]
Qrecomap[icetray.OMKey(27, 60)] = [recopulse2]
Qrecomap[icetray.OMKey(35, 60)] = [recopulse2]
Qrecomap[icetray.OMKey(37, 60)] = [recopulse2]
Qrecomap[icetray.OMKey(45, 60)] = [recopulse2]
Qrecomap[icetray.OMKey(46, 60)] = [recopulse2]
Qframe = icetray.I3Frame(icetray.I3Frame.DAQ)
Qeh = dataclasses.I3EventHeader()
Qeh.start_time = (dataclasses.I3Time(2011, 0))
Qeh.end_time = (dataclasses.I3Time(2011, 2))
Qeh.run_id = 1
Qeh.event_id = 1
Qframe.Put("I3EventHeader", Qeh)
Qframe.Put(OrgPulses, Qrecomap)
Qframe.Put(SplitName + "SplitCount", icetray.I3Int(2))
Qframe.Put(SplitName + "ReducedCount", icetray.I3Int(0))
self.PushFrame(Qframe)
#now make the first p-frame containing one I3RecoPulse
P1frame = icetray.I3Frame(icetray.I3Frame.Physics)
P1eh = dataclasses.I3EventHeader()
P1eh.start_time = (dataclasses.I3Time(2011, 0))
P1eh.end_time = (dataclasses.I3Time(2011, 1))
P1eh.run_id = 1
P1eh.event_id = 1
P1eh.sub_event_stream = "split"
P1eh.sub_event_id = 0
P1frame.Put("I3EventHeader", P1eh)
P1recomap = dataclasses.I3RecoPulseSeriesMap()
P1recomap[icetray.OMKey(26, 1)] = [recopulse1]
P1recomap[icetray.OMKey(27, 1)] = [recopulse1]
P1recomap[icetray.OMKey(35, 1)] = [recopulse1]
P1recomap[icetray.OMKey(37, 1)] = [recopulse1]
P1recomap[icetray.OMKey(45, 1)] = [recopulse1]
P1recomap[icetray.OMKey(46, 1)] = [recopulse1]
P1recomask = dataclasses.I3RecoPulseSeriesMapMask(
Qframe, OrgPulses, P1recomap)
P1frame.Put(SplitPulses, P1recomask)
P1fit = dataclasses.I3Particle(
dataclasses.I3Particle.ParticleShape.InfiniteTrack)
P1fit.time = -455. * I3Units.ns
P1fit.pos = geo.omgeo[icetray.OMKey(36, 1)].position
P1fit.dir = dataclasses.I3Direction(0., 0.) #straight down
P1fit.fit_status = dataclasses.I3Particle.OK
P1frame.Put("Fit", P1fit)
self.PushFrame(P1frame)
#now make the second p-frame containing one I3RecoPulse
P2frame = icetray.I3Frame(icetray.I3Frame.Physics)
P2eh = dataclasses.I3EventHeader()
P2eh.start_time = (dataclasses.I3Time(2011, 1))
P2eh.end_time = (dataclasses.I3Time(2011, 2))
P2eh.run_id = 1
P2eh.event_id = 1
P2eh.sub_event_stream = SplitName
P2eh.sub_event_id = 1
P2frame.Put("I3EventHeader", P2eh)
P2recomap = dataclasses.I3RecoPulseSeriesMap()
P2recomap[icetray.OMKey(26, 60)] = [recopulse2]
P2recomap[icetray.OMKey(27, 60)] = [recopulse2]
P2recomap[icetray.OMKey(35, 60)] = [recopulse2]
P2recomap[icetray.OMKey(37, 60)] = [recopulse2]
P2recomap[icetray.OMKey(45, 60)] = [recopulse2]
P2recomap[icetray.OMKey(46, 60)] = [recopulse2]
P2recomask = dataclasses.I3RecoPulseSeriesMapMask(
Qframe, OrgPulses, P2recomap)
P2frame.Put(SplitPulses, P2recomask)
P2fit = dataclasses.I3Particle(
dataclasses.I3Particle.ParticleShape.InfiniteTrack)
P2fit.time = 1000. / I3Constants.c - 454. * I3Units.ns
P2fit.pos = geo.omgeo[icetray.OMKey(36, 60)].position
P2fit.dir = dataclasses.I3Direction(0, 0.) #straight up
P2fit.fit_status = dataclasses.I3Particle.OK
P2frame.Put("Fit", P2fit)
self.PushFrame(P2frame)
Hframe = icetray.I3Frame(icetray.I3Frame.Physics)
Heh = dataclasses.I3EventHeader()
Heh.start_time = (dataclasses.I3Time(2011, 0))
Heh.end_time = (dataclasses.I3Time(2011, 2))
Heh.run_id = 1
Heh.event_id = 1
Heh.sub_event_stream = HypoName
Heh.sub_event_id = 0
Hframe.Put("I3EventHeader", Heh)
Hrecomap = dataclasses.I3RecoPulseSeriesMap()
Hrecomap[icetray.OMKey(26, 1)] = [recopulse1] #ring top
Hrecomap[icetray.OMKey(27, 1)] = [recopulse1]
Hrecomap[icetray.OMKey(35, 1)] = [recopulse1]
Hrecomap[icetray.OMKey(37, 1)] = [recopulse1]
Hrecomap[icetray.OMKey(45, 1)] = [recopulse1]
Hrecomap[icetray.OMKey(46, 1)] = [recopulse1]
Hrecomap[icetray.OMKey(26, 60)] = [recopulse2] #ring bottom
Hrecomap[icetray.OMKey(27, 60)] = [recopulse2]
Hrecomap[icetray.OMKey(35, 60)] = [recopulse2]
Hrecomap[icetray.OMKey(37, 60)] = [recopulse2]
Hrecomap[icetray.OMKey(45, 60)] = [recopulse2]
Hrecomap[icetray.OMKey(46, 60)] = [recopulse2]
Hrecomask = dataclasses.I3RecoPulseSeriesMapMask(
Qframe, OrgPulses, Hrecomap)
Hframe.Put(SplitPulses, Hrecomask)
Hcf = dataclasses.I3MapStringVectorDouble()
Hcf["split"] = [0, 1]
Hframe.Put("CS_CreatedFrom", Hcf)
Hfit = dataclasses.I3Particle(
dataclasses.I3Particle.ParticleShape.InfiniteTrack)
Hfit.time = -454. * I3Units.ns
Hfit.pos = geo.omgeo[icetray.OMKey(36, 1)].position
Hfit.dir = dataclasses.I3Direction(0., 0.)
Hfit.fit_status = dataclasses.I3Particle.OK
Hframe.Put("HFit", Hfit)
self.PushFrame(Hframe)
self.RequestSuspension()
def Process(self):
gcd = dataio.I3File(self.gcdfile, 'R')
while (gcd.more()):
frame = gcd.pop_frame()
self.PushFrame(frame)
gcd.close()
#now deliver artificial testcase
#make a Q-frame
Qframe = icetray.I3Frame(icetray.I3Frame.DAQ)
Qeh = dataclasses.I3EventHeader()
Qeh.start_time = (dataclasses.I3Time(2011, 0))
Qeh.end_time = (dataclasses.I3Time(2011, 2))
Qeh.run_id = 1
Qeh.event_id = 1
Qframe.Put("I3EventHeader", Qeh)
Qrecomap = dataclasses.I3RecoPulseSeriesMap()
recopulse1 = dataclasses.I3RecoPulse()
recopulse1.time = 0
recopulse1.charge = 1
recopulse2 = dataclasses.I3RecoPulse()
recopulse2.time = 1
recopulse2.charge = 2
Qrecomap[icetray.OMKey(1,1)] = [recopulse1]
Qrecomap[icetray.OMKey(2,2)] = [recopulse2]
Qframe.Put(OrgPulses, Qrecomap)
Qframe.Put(SplitName+"SplitCount", icetray.I3Int(2))
Qframe.Put(SplitName+"ReducedCount", icetray.I3Int(0))
self.PushFrame(Qframe)
#now make the first p-frame containing one I3RecoPulse
P1frame = icetray.I3Frame(icetray.I3Frame.Physics)
P1eh = dataclasses.I3EventHeader()
P1eh.start_time = (dataclasses.I3Time(2011, 0))
P1eh.end_time = (dataclasses.I3Time(2011, 1))
P1eh.run_id = 1
P1eh.event_id = 1
P1eh.sub_event_stream = "split"
P1eh.sub_event_id = 0
P1frame.Put("I3EventHeader", P1eh)
P1recomap = dataclasses.I3RecoPulseSeriesMap()
P1recomap[icetray.OMKey(1,1)] = [recopulse1]
P1recomask = dataclasses.I3RecoPulseSeriesMapMask(Qframe, OrgPulses, Qrecomap)
P1frame.Put(SplitPulses, P1recomask)
P1fit = dataclasses.I3Particle()
P1fit.pos= dataclasses.I3Position(0.,0., CriticalDistance)
P1fit.dir= dataclasses.I3Direction(0., CriticalAngle)
P1fit.fit_status = dataclasses.I3Particle.OK
P1frame.Put("Fit", P1fit)
self.PushFrame(P1frame)
#now make the second p-frame containing one I3RecoPulse
P2frame = icetray.I3Frame(icetray.I3Frame.Physics)
P2eh = dataclasses.I3EventHeader()
P2eh.start_time = (dataclasses.I3Time(2011, 1))
P2eh.end_time = (dataclasses.I3Time(2011, 2))
P2eh.run_id = 1
P2eh.event_id = 1
P2eh.sub_event_stream = "split"
P2eh.sub_event_id = 1
P2frame.Put("I3EventHeader", P2eh)
P2recomap = dataclasses.I3RecoPulseSeriesMap()
P2recomap[icetray.OMKey(2,2)] = [recopulse2]
P2recomask = dataclasses.I3RecoPulseSeriesMapMask(Qframe, OrgPulses, P2recomap)
P2frame.Put(SplitPulses, P2recomask)
P2fit = dataclasses.I3Particle()
P2fit.pos= dataclasses.I3Position(0.,0., CriticalDistance)
P2fit.dir= dataclasses.I3Direction(0., -CriticalAngle)
P2fit.fit_status = dataclasses.I3Particle.OK
P2frame.Put("Fit", P2fit)
self.PushFrame(P2frame)
Hframe = icetray.I3Frame(icetray.I3Frame.Physics)
Heh = dataclasses.I3EventHeader()
Heh.start_time = (dataclasses.I3Time(2011, 0))
Heh.end_time = (dataclasses.I3Time(2011, 2))
Heh.run_id = 1
Heh.event_id = 1
Heh.sub_event_stream = HypoName
Heh.sub_event_id = 0
Hframe.Put("I3EventHeader", Heh)
Hrecomap = dataclasses.I3RecoPulseSeriesMap()
Hrecomap[icetray.OMKey(1,1)] = [recopulse1]
Hrecomap[icetray.OMKey(2,2)] = [recopulse2]
Hrecomask = dataclasses.I3RecoPulseSeriesMapMask(Qframe, OrgPulses, Hrecomap)
Hframe.Put(SplitPulses, Hrecomask)
Hcf = dataclasses.I3MapStringVectorDouble()
Hcf["split"]=[0,1]
Hframe.Put("CS_CreatedFrom", Hcf)
Hfit = dataclasses.I3Particle()
Hfit.time= 0
Hfit.pos= dataclasses.I3Position(0.,0.,0.)
Hfit.dir= dataclasses.I3Direction(0., 0.)
Hfit.fit_status = dataclasses.I3Particle.OK
Hframe.Put("HFit", Hfit)
self.PushFrame(Hframe)
self.RequestSuspension()
def do(f):
om = f[omkey_name][0]
f[seed_name] = dataclasses.I3RecoPulseSeriesMapMask(
f, pulses_name, lambda omkey, p_idx, p: omkey == om and p_idx == 0)
