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 dom_simulation(frame, time_shift=10, nhits=n_hits):
global hit_times
random_service = phys_services.I3GSLRandomService(2)
geo = frame["I3Geometry"].omgeo
cal = frame["I3Calibration"].dom_cal
stat = frame["I3DetectorStatus"].dom_status
#DOMLauncher.I3DOM.merge_pulses = True
#DOMLauncher.I3DOM.use_tabulation(True)
omKey1 = icetray.OMKey(47, 2)
dom1 = DOMLauncher.I3InIceDOM(random_service, omKey1)
dom1.configure(cal[omKey1], stat[omKey1])
omKey2 = icetray.OMKey(47, 3)
dom2 = DOMLauncher.I3InIceDOM(random_service, omKey2)
dom2.configure(cal[omKey2], stat[omKey2])
dom1.rapcal_time_shift = 0
dom2.rapcal_time_shift = time_shift
#making the doms neigbors
dom2.get_neighbors().append(dom1)
dom1.get_neighbors().append(dom2)
pulses = simclasses.I3MCPulseSeries()
pulse = simclasses.I3MCPulse()
pulse.charge = 1
pulse.time = 0
for i in range(nhits):
pulses.append(pulse)
hit_times += [pulse.time]
pulse.time += 29e3
triggers = DOMLauncher.DCStream()
print("simulating discriminator")
dom1.discriminator(pulses, triggers)
dom2.discriminator(pulses, triggers)
triggers = sorted(triggers, key=lambda t: t.time)
i = 0
for trigg in triggers:
if (i % 100 == 0):
print(trigg.DOM, trigg.time)
i += 1
if (trigg.DOM == omKey1):
dom1.add_trigger(trigg)
elif (trigg.DOM == omKey2):
dom2.add_trigger(trigg)
print("ending simulation")
dom1.trigger_launch(False)
dom2.trigger_launch(False)
launch_map = dataclasses.I3DOMLaunchSeriesMap()
launch_map[dom1.get_omkey()] = dom1.get_domlaunches()
launch_map[dom2.get_omkey()] = dom2.get_domlaunches()
frame["InIceRawData"] = launch_map
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 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 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)
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)
calib.start_time = the_time - 100 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 MissingITCheck(frame):
#print "Fixing IceTop RO"
if "IceTopRawData" not in frame:
itrd = dataclasses.I3DOMLaunchSeriesMap()
frame["IceTopRawData"] = itrd
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 SmushLaunches(frame, Launches, Output):
dlsm = dataclasses.I3DOMLaunchSeriesMap()
for label in Launches:
for om, launches in frame[label].items():
dlsm[om] = launches
frame[Output] = dlsm
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
def DAQ(self, frame):
if not frame.Has(self.i3TriggName):
print("No IceCube triggers found ('%s')." % self.i3TriggName)
self.PushFrame(frame)
return
i3Triggers = frame.Get(self.i3TriggName)
if not i3Triggers:
print("Zero triggers found ('%s')." % self.i3TriggName)
return
#triggers = dataclasses.I3TriggerHierarchy();
triggers = []
triggertimes = []
# build a semaphore queue to keep track of open triggers
for i in i3Triggers:
print(i)
triggertimes.append(Trig(i.time, 1))
triggertimes.append(Trig(i.time + i.length, -1))
triggers.append(i)
triggertimes.sort(key=lambda t: t.time)
triggers.sort(key=lambda t: t.time)
mindthegap = []
# Set the first gap at the beggining of the event
mindthegap.append(triggertimes[0].time)
semaphore = 0
for t in triggertimes:
semaphore += t.semaphore
print(semaphore, t.time)
if semaphore == 0: # This is true iff there are not active triggers
mindthegap.append(t.time)
"""
* Now that earliest and latest are set we can set the start and stop times
* of the events accordingly.
"""
dt = dataclasses.I3Time()
if frame.Has("I3EventHeader"):
eh = frame.Get(
"I3EventHeader"
) #NOTE <mzoll> this has changed from DrivingTime to I3EventHeader.start_time
dt = eh.start_time
else:
eh = dataclasses.I3EventHeader()
dt.set_mod_julian_time(55697, 43200, 0.0)
tend, tstart = 0.0, 0.0
tstart = mindthegap[0]
from icecube import trigger_sim
for k in mindthegap[1:]:
tend = k
newhierarchy = dataclasses.I3TriggerHierarchy()
drivingtime = dataclasses.I3Time(dt + tstart)
size = 0
for j in triggers:
if (j.time < tstart): continue
if (j.time >= tend): break
newhierarchy.insert(j)
size += 1
t = dataclasses.I3Double(tstart)
count = dataclasses.I3Double(size)
eh.start_time = drivingtime
newframe = icetray.I3Frame(icetray.I3Frame.DAQ)
newframe.Delete(
"I3EventHeader"
) #NOTE <mzoll> this has changed from DrivingTime to I3EventHeader.start_time
newframe.Put("I3EventHeader", eh)
newframe.Put("triggertime", t)
newframe.Put("trigersize", count)
newframe.Put("triggers", newhierarchy)
# split launches
for mapname in self.domLaunchSeriesMapNames:
if frame.Has(mapname):
fullMap = frame.Get(mapname)
InIceResponseMap = dataclasses.I3DOMLaunchSeriesMap()
self.SplitLaunches(fullMap, InIceResponseMap,
tstart - self.ReadoutWindowBefore,
tend + self.ReadoutWindowAfter)
newframe.Delete(mapname)
newframe.Put(mapname, InIceResponseMap)
# split hits
fullMap = frame.Get(self.hitSeriesMapName)
newmchitmap = dataclasses.I3MCHitSeriesMap()
self.SplitMCHits(fullMap, newmchitmap,
tstart - self.ReadoutWindowBefore,
tend + self.ReadoutWindowAfter)
newframe.Delete(mapname)
newframe.Put(mapname, newmchitmap)
if not newframe.Has(self.mctreename):
oldtree = frame.Get(self.mctreename)
newtree = self.PruneTree(oldtree, newmchitmap)
newframe.Put(self.mctreename, newtree)
weights = frame.Get(self.weights_name)
weights["multiplicity"] = len(newtree.primaries)
newframe.Put(self.weights_name, weights)
self.eventID += 1
self.PushFrame(newframe)
tstart = tend