def SplitLaunches(self, fullMap, submap, tstart, tend):
for omKey, fullSeries in fullMap.items():
for fullSeriesIter in fullSeries:
if fullSeriesIter.time > tstart and fullSeriesIter.time <= tend:
if not submap.has_key(omKey):
submap[omKey] = dataclasses.I3DOMLaunchSeries()
submap[omKey].append(fullSeriesIter)
def make_launch_map():
launchmap = dataclasses.I3DOMLaunchSeriesMap()
for omkey in doms:
launch_series = dataclasses.I3DOMLaunchSeries()
launch_series.append(dataclasses.I3DOMLaunch())
launchmap[omkey] = launch_series
launchmap[icetray.OMKey(0, 3)].append(dataclasses.I3DOMLaunch())
return launchmap
def launch_splitter(frame, mapname = "I3DOMLaunchSeriesMap"):
'''
A one-off moudule to split the output DOMLaunchSeriesMap from DOMLauncher into an
InIce part, IceTop part and a BeaconLaunch part.
'''
geo = frame["I3Geometry"]
launch_map = frame[mapname]
inice = dataclasses.I3DOMLaunchSeriesMap()
icetop = dataclasses.I3DOMLaunchSeriesMap()
beacon = dataclasses.I3DOMLaunchSeriesMap()
for omkey,launch_series in launch_map :
g = geo.omgeo[omkey]
#First we find the beacon launches and remove them
#from the launch series
index = 0
spetriggered = dataclasses.I3DOMLaunchSeries()
for l in launch_series:
if(l.trigger_type == dataclasses.I3DOMLaunch.CPU_REQUESTED):
if(omkey in beacon):
beacon[omkey].append(l)
else:
beacon[omkey] = dataclasses.I3DOMLaunchSeries([l])
else:
spetriggered.append(l)
index += 1
launch_series = spetriggered
if (len(launch_series) == 0):
continue
if (g.omtype == dataclasses.I3OMGeo.IceCube):
inice[omkey] = launch_series
elif (g.omtype == dataclasses.I3OMGeo.IceTop) :
icetop[omkey] = launch_series
else :
icetray.logging.log_fatal("Unknown DOM type %s at %s in the launch map" \
% (str(g.omtype), str(omkey)))
frame["InIceRawData"] = inice
frame["IceTopRawData"] = icetop
frame["BeaconLaunches"] = beacon
del frame[mapname]
def Create_LaunchesSeriesMap(frame):
launchesmap = dc.I3DOMLaunchSeriesMap()
l1 = dc.I3DOMLaunch()
l1.time = 5.1
l1.lc_bit = True
l2 = dc.I3DOMLaunch()
l2.time = 34.7
l2.lc_bit = False
launchesmap[icetray.OMKey(10, 4)] = dc.I3DOMLaunchSeries([l1, l2])
l1 = dc.I3DOMLaunch()
l1.time = 6.0
l1.lc_bit = False
l2 = dc.I3DOMLaunch()
l2.time = 11.3
l2.lc_bit = False
launchesmap[icetray.OMKey(25, 13)] = dc.I3DOMLaunchSeries([l1, l2])
frame.Put("TestLauncheSeriesMap", launchesmap)
def AppendLaunches(self, launchmap, hit):
newLaunch = dataclasses.I3DOMLaunch()
newLaunch.time = hit.Time
newLaunch.lc_bit = True
if hit.OMKey not in launchmap.keys():
newLaunchSeries = dataclasses.I3DOMLaunchSeries()
newLaunchSeries.append(newLaunch)
launchmap[hit.OMKey] = newLaunchSeries
else:
for launch in launchmap[hit.OMKey]:
if launch.time == hit.Time: return
launchmap[hit.OMKey].append(newLaunch)
def frame_setup(frame):
frame["I3Triggers"] = dataclasses.I3TriggerHierarchy()
dom_launch = dataclasses.I3DOMLaunch()
dom_launch.time = 42*I3Units.ns
dom_launch_series = dataclasses.I3DOMLaunchSeries()
dom_launch_series.append(dom_launch)
launch_map = dataclasses.I3DOMLaunchSeriesMap()
launch_map[icetray.OMKey(21,30)] = dom_launch_series
frame["InIceRawData"] = launch_map
def DAQ(self, frame):
print("DAQ!!!")
geo = frame.Get("I3Geometry")
if self.domSetsName in frame:
domSets = frame.Get(self.domSetsName)
else:
domSets = None # InDOMSet() will use the default table if there is no frame object
omlist_l = list()
for omkey, omgeo in geo.omgeo:
if omgeo.omtype == dataclasses.I3OMGeo.IceCube and \
( ( self.generateInDOMSet and trigger_sim.InDOMSet(omkey,4,domSets) ) or \
( not self.generateInDOMSet and not trigger_sim.InDOMSet(omkey,4,domSets) ) ):
omlist_l.append(omkey)
launchmap = dataclasses.I3DOMLaunchSeriesMap()
launch_counter = 0
for i in range(self.nDOMs):
launch = dataclasses.I3DOMLaunch()
launch.lc_bit = True
# set start times according to uniform distribution
time = random.uniform(0, self.timeWindow)
if not self.generateInTimeWindow:
time += launch_counter * self.timeWindow
launch.time = time
## select from the available list
omkey = random.sample(omlist_l, 1)[0]
if not omkey in launchmap:
launchmap[omkey] = dataclasses.I3DOMLaunchSeries()
launchmap[omkey].append(launch)
launch_counter += 1
frame["InIceRawData"] = launchmap
self.PushFrame(frame)
def DAQ(self, frame):
print("DAQ!!!")
geo = frame.Get("I3Geometry")
omlist_l = list()
for omkey, omgeo in geo.omgeo:
if omgeo.omtype == self.domType:
omlist_l.append(omkey)
launchmap = dataclasses.I3DOMLaunchSeriesMap()
launch_counter = 0
for i in range(self.nDOMs):
launch = dataclasses.I3DOMLaunch()
launch.lc_bit = True
# set start times according to uniform distribution
time = random.uniform(0, self.timeWindow)
if not self.generateInTimeWindow:
time += launch_counter * self.timeWindow
launch.time = time
## select from the available list
omkey = random.sample(omlist_l, 1)[0]
if not omkey in launchmap:
launchmap[omkey] = dataclasses.I3DOMLaunchSeries()
launchmap[omkey].append(launch)
launch_counter += 1
if self.domType == dataclasses.I3OMGeo.IceCube:
frame["InIceRawData"] = launchmap
if self.domType == dataclasses.I3OMGeo.IceTop:
frame["IceTopRawData"] = launchmap
self.PushFrame(frame)
calib.end_time = the_time + 100 status = dataclasses.I3DetectorStatus() status.start_time = the_time - 100 status.end_time = the_time + 100 frame = icetray.I3Frame(icetray.I3Frame.Geometry) frame['I3Geometry'] = geo f.push(frame) frame = icetray.I3Frame(icetray.I3Frame.Calibration) frame['I3Calibration'] = calib f.push(frame) frame = icetray.I3Frame(icetray.I3Frame.DetectorStatus) frame['I3DetectorStatus'] = status f.push(frame) frame = icetray.I3Frame(icetray.I3Frame.DAQ) dlsm = dataclasses.I3DOMLaunchSeriesMap() dlsm[icetray.OMKey(7, 42)] = dataclasses.I3DOMLaunchSeries() frame['InIceRawData'] = dlsm t = dataclasses.I3Time() t.set_utc_cal_date(1919, 1, 15, 0, 0, 0, 0) frame['DrivingTime'] = t header = dataclasses.I3EventHeader() header.run_id = 7 header.event_id = 42 header.sub_event_id = 0 header.start_time = t header.end_time = t + 10 * I3Units.microsecond frame['I3EventHeader'] = header f.push(frame) f.close()
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 DAQ(self, frame):
print("DAQ!!!")
geo = frame.Get("I3Geometry")
omlist_l = list()
for omkey, omgeo in geo.omgeo:
if omkey.GetString() == self.stringN:
if omgeo.omtype == dataclasses.I3OMGeo.IceCube:
omlist_l.append(omkey)
time = 100. * I3Units.ns
if not self.trigTest:
print("You are TESTING <<THE NON-EXISTENSE>> of a STRING TRIGGER")
#Get non adjacent (self.threshold) OMs along a string
noms = [
random.randrange(1, 58, 7) for x in range(self.threshold - 2)
]
#make sure that they are not adjacent
noms.extend([0, 59])
#create a list of DOMLaunches which do fulfill a string trigger condition
launchmap = dataclasses.I3DOMLaunchSeriesMap()
for i in range(self.threshold):
launch = dataclasses.I3DOMLaunch()
launch.SetLCBit(True)
time += i * 100 * I3Units.ns
launch.SetStartTime(time)
#choose randomly 5/3 oms from doms between 50 and 56 in string number 1
omkey = omlist_l[noms[i]]
print(omkey)
if not omkey in launchmap:
launchmap[omkey] = dataclasses.I3DOMLaunchSeries()
launchmap[omkey].append(launch)
frame["InIceRawData"] = launchmap
else:
print("You are TESTING <<THE- EXISTENSE>> of a STRING TRIGGER")
#create a list of DOMLaunches which "DO NOT" fulfill a string trigger condition
launchmap = dataclasses.I3DOMLaunchSeriesMap()
for i in range(self.threshold):
launch = dataclasses.I3DOMLaunch()
launch.SetLCBit(True)
time += i * 100. * I3Units.ns
launch.SetStartTime(time)
#choose randomly 5 oms from doms between 30 and 37 in string number 1
omkey = random.sample(omlist_l[30:36], 1)[0]
if not omkey in launchmap:
launchmap[omkey] = dataclasses.I3DOMLaunchSeries()
launchmap[omkey].append(launch)
frame["InIceRawData"] = launchmap
self.PushFrame(frame)
def DAQ(self, frame):
print("DAQ!!!")
geo = frame.Get("I3Geometry")
omlist_l = list()
for omkey, omgeo in geo.omgeo:
if omkey.GetString() == self.stringN:
if omgeo.omtype == dataclasses.I3OMGeo.IceCube:
omlist_l.append(omkey)
oms_l = list()
noms = [random.randint(0, 59) for r in range(self.nDOMs)]
noms.sort()
ajcent = True
while (ajcent):
k = random.randint(0, len(noms) - 1)
if (k + 7) < len(noms):
if (noms[k + 7] - noms[k] <= 7 and noms[k + 7] - noms[k] >= 0):
for i in range(k, k + 7, 1):
oms_l.append(noms[i])
ajcent = False
else:
continue
noTimeCorr = True
while (noTimeCorr):
time_l = [
random.random() * self.timeWindow * I3Units.ns
for x in range(self.threshold)
]
time_l.sort()
if ((time_l[-1] - time_l[0]) <= self.timeWindow * I3Units.ns):
noTimeCorr = False
else:
continue
TriggerLengthExpectation = time_l[-1] - time_l[0]
trigLength = dataclasses.I3Double(TriggerLengthExpectation *
I3Units.ns)
frame.Put(self.where, trigLength)
time = 100. * I3Units.ns
if self.trigTest:
print("You are TESTING <<THE EXISTENSE>> of a STRING TRIGGER")
#create a list of DOMLaunches which do fulfill a string trigger condition
launchmap = dataclasses.I3DOMLaunchSeriesMap()
for i in range(self.threshold):
omkey = omlist_l[random.sample(oms_l, 1)[0]]
# for the slow monopole case we had about 60 launches per OM
launch = dataclasses.I3DOMLaunch()
launch.SetLCBit(True)
launch.SetStartTime(time_l[i])
if not omkey in launchmap:
launchmap[omkey] = dataclasses.I3DOMLaunchSeries()
launchmap[omkey].append(launch)
frame["InIceRawData"] = launchmap
else:
print("You are TESTING <<NON-EXISTENSE>> of a STRING TRIGGER")
#create a list of DOMLaunches which "DO NOT" fulfill a string trigger condition
launchmap = dataclasses.I3DOMLaunchSeriesMap()
for i in range(self.threshold):
launch = dataclasses.I3DOMLaunch()
launch.SetLCBit(True)
time += i * 1000. * I3Units.ns
launch.SetStartTime(time)
#choose randomly 5 oms from doms between 30 and 37 in string number 1
omkey = random.sample(omlist_l[50:56], 1)[0]
if not omkey in launchmap:
launchmap[omkey] = dataclasses.I3DOMLaunchSeries()
launchmap[omkey].append(launch)
frame["InIceRawData"] = launchmap
self.PushFrame(frame)
def TestSetup(frame, add_empty_trigger=False, add_mchits=True):
p = dataclasses.I3Particle()
p.time = TIME
frame["MCPrimary"] = p
mctree = dataclasses.I3MCTree()
mctree.add_primary(p)
frame["MCTree"] = mctree
# I3MMCTrack
mmctrack = simclasses.I3MMCTrack()
mmctrack.SetParticle(p)
mmctrack.ti = TIME
mmctrack.tc = TIME
mmctrack.tf = TIME
mmctracklist = simclasses.I3MMCTrackList()
mmctracklist.append(mmctrack)
frame["MMCTracks"] = mmctracklist
# I3TriggerHierarchy
t = dataclasses.I3Trigger()
t.time = TIME
t.fired = True
trigger_h = dataclasses.I3TriggerHierarchy()
if not add_empty_trigger:
trigger_h.insert(t)
frame["Trigger"] = trigger_h
# I3VectorI3Trigger
t1 = dataclasses.I3Trigger()
t1.time = TIME
t1.fired = True
trigger_v = dataclasses.I3VectorI3Trigger()
trigger_v.append(t1)
frame["TriggerVector"] = trigger_v
# I3FlasherInfoVector
fi = dataclasses.I3FlasherInfo()
fi.flash_time = TIME
fi_v = dataclasses.I3FlasherInfoVect()
fi_v.append(fi)
frame["FlasherInfos"] = fi_v
# I3DOMLaunchSeriesMap
d = dataclasses.I3DOMLaunch()
d.time = TIME
launchseries = dataclasses.I3DOMLaunchSeries()
launchseries.append(d)
launchmap = dataclasses.I3DOMLaunchSeriesMap()
launchmap[icetray.OMKey(21, 30)] = launchseries
frame["DOMLaunchMap"] = launchmap
# I3MCHit
mchit = dataclasses.I3MCHit()
mchit.time = TIME
mchitseries = dataclasses.I3MCHitSeries()
mchitseries.append(mchit)
mchitmap = dataclasses.I3MCHitSeriesMap()
mchitmap[icetray.OMKey(21, 30)] = mchitseries
if add_mchits:
frame["MCHitMap"] = mchitmap
# I3MCPE
mcpe = simclasses.I3MCPE()
mcpe.time = TIME
mcpeseries = simclasses.I3MCPESeries()
mcpeseries.append(mcpe)
mcpemap = simclasses.I3MCPESeriesMap()
mcpemap[icetray.OMKey(21, 30)] = mcpeseries
frame["MCPEMap"] = mcpemap
# I3MCPulse
mcpulse = simclasses.I3MCPulse()
mcpulse.time = TIME
mcpulseseries = simclasses.I3MCPulseSeries()
mcpulseseries.append(mcpulse)
mcpulsemap = simclasses.I3MCPulseSeriesMap()
mcpulsemap[icetray.OMKey(21, 30)] = mcpulseseries
frame["MCPulseMap"] = mcpulsemap
# I3Double
sometime = dataclasses.I3Double(TIME)
frame["SomeTime"] = sometime
nottime = dataclasses.I3Double(TIME)
frame["NotTime"] = nottime
