def make_header(self, i, name):
newheader = dataclasses.I3EventHeader()
newheader.sub_event_id = i
newheader.sub_event_stream = name
newheader.state = dataclasses.I3EventHeader.OK
# the rest of the event header we don't care about in this test
return newheader
def Process(self):
if self.counter % 20 == 0:
sframe = icetray.I3Frame('S')
info = simclasses.I3CorsikaInfo()
sframe['I3CorsikaInfo'] = info
self.PushFrame(sframe)
qframe = icetray.I3Frame('Q')
eh = dataclasses.I3EventHeader()
eh.run_id = 1
eh.event_id = self.counter
qframe['I3EventHeader'] = eh
tree = dataclasses.I3MCTree()
p1 = dataclasses.I3Particle()
tree.insert(p1)
if self.counter % 2 == 0:
qframe['I3MCTree'] = tree
qframe['I3MCPrimary'] = p1
self.PushFrame(qframe)
self.counter += 1
if self.counter >= 100:
self.RequestSuspension()
def inject_header(frame):
time = dc.I3Time()
time.set_mod_julian_time(options.MJD, 0, 0.0)
eh = dc.I3EventHeader()
eh.start_time = time
eh.end_time = time
frame["I3EventHeader"] = eh
def Process(self):
try:
c = next(self.lines)
except StopIteration:
self.RequestSuspension()
return
eq = astro.I3Equatorial(c[0] * I3Units.degree, c[1] * I3Units.degree)
time = dataclasses.I3Time(2015, 0)
direction = astro.I3GetDirectionFromEquatorial(eq, time)
eqq = astro.I3GetEquatorialFromDirection(direction, time)
particle = dataclasses.I3Particle()
particle.dir = direction
header = dataclasses.I3EventHeader()
header.start_time = time
frame = icetray.I3Frame("P")
if self.evthdr:
frame["I3EventHeader"] = header
frame["Particle"] = particle
self.PushFrame(frame)
def get_header(frame):
global event_id
header = dataclasses.I3EventHeader()
header.event_id = event_id
header.run_id = seed
event_id += 1
frame["I3EventHeader"] = header
def FinalStream(frame):
if frame.Has("I3EventHeader"):
if frame["I3EventHeader"].sub_event_stream == "HiveSplitter":
eh = dataclasses.I3EventHeader(frame["I3EventHeader"])
eh.sub_event_stream = "Final"
frame.Delete("I3EventHeader")
frame.Put("I3EventHeader", eh)
def DAQ(self, frame):
"""
Check if we need to move on to the next injector, and check then if we've reached the end of the file.
"""
while self.event_no>=len(self.datafile[self.keys[self.keyno]]['final_1']):
self.keyno+=1
self.event_no=0
if self.keyno >= len(self.keys):
print("Requesting Suspension")
self.RequestSuspension()
return
else:
print("Moving to key {}".format(self.keys[self.keyno]))
active = self.datafile[self.keys[self.keyno]]
frame['I3MCTree'] = dataclasses.I3MCTree()
dataclasses.I3MCTree.add_primary( frame['I3MCTree'], make_i3_particle( active['initial'][self.event_no]))
dataclasses.I3MCTree.append_child( frame['I3MCTree'], frame['I3MCTree'][0].id, make_i3_particle( active['final_1'][self.event_no]))
dataclasses.I3MCTree.append_child( frame['I3MCTree'], frame['I3MCTree'][0].id, make_i3_particle( active['final_2'][self.event_no]))
frame['I3EventHeader'] = dataclasses.I3EventHeader()
frame['EventProperties'] = get_prop_dict(active['properties'][self.event_no], 'Ranged' in self.keys[self.keyno])
self.event_no += 1
self.PushFrame(frame)
def DAQ(self, daq):
from icecube import dataclasses
physics = icetray.I3Frame(icetray.I3Frame.Physics)
header = dataclasses.I3EventHeader(daq['I3EventHeader'])
header.sub_event_stream = 'IceTop'
physics.Put('I3EventHeader', header)
self.PushFrame(daq)
self.PushFrame(physics)
def test_01(self):
uint_max = 2**(ctypes.sizeof(ctypes.c_uint(0)) * 8) - 1
for _ in range(1000):
h = dataclasses.I3EventHeader()
self.assertEqual(h.run_id, uint_max)
self.assertEqual(h.sub_run_id, uint_max)
self.assertEqual(h.event_id, uint_max)
self.assertEqual(h.sub_event_id, 0)
self.assertEqual(h.sub_event_stream, "")
self.assertEqual(h.state, h.StateType.OK)
def GenRandomTime(frame, StartTime, EndTime, RandomService): header = dataclasses.I3EventHeader() mjdStart = StartTime.mod_julian_day_double mjdEnd = EndTime.mod_julian_day_double mjd = mjdStart + (RandomService.uniform(0.,1.)*(mjdEnd-mjdStart)) eventTime = dataclasses.I3Time() eventTime.set_mod_julian_time_double(mjd) header.start_time = eventTime frame["I3EventHeader"] = header
def CreatePFrame(self, nside, pixel):
dec, ra = healpy.pix2ang(nside, pixel)
dec = dec - numpy.pi / 2.
zenith, azimuth = astro.equa_to_dir(ra, dec, self.event_mjd)
zenith = float(zenith)
azimuth = float(azimuth)
direction = dataclasses.I3Direction(zenith, azimuth)
position = self.seed_position
time = self.seed_time
energy = self.seed_energy
variationDistance = 20. * I3Units.m
posVariations = [
dataclasses.I3Position(0., 0., 0.),
dataclasses.I3Position(-variationDistance, 0., 0.),
dataclasses.I3Position(variationDistance, 0., 0.),
dataclasses.I3Position(0., -variationDistance, 0.),
dataclasses.I3Position(0., variationDistance, 0.),
dataclasses.I3Position(0., 0., -variationDistance),
dataclasses.I3Position(0., 0., variationDistance)
]
for i in range(0, len(posVariations)):
posVariation = posVariations[i]
p_frame = icetray.I3Frame(icetray.I3Frame.Physics)
thisPosition = dataclasses.I3Position(position.x + posVariation.x,
position.y + posVariation.y,
position.z + posVariation.z)
# generate the particle from scratch
particle = dataclasses.I3Particle()
particle.shape = dataclasses.I3Particle.ParticleShape.InfiniteTrack
particle.fit_status = dataclasses.I3Particle.FitStatus.OK
particle.pos = thisPosition
particle.dir = direction
particle.time = time
particle.energy = energy
p_frame[self.output_particle_name] = particle
# generate a new event header
eventHeader = dataclasses.I3EventHeader(self.event_header)
eventHeader.sub_event_stream = "SCAN_nside%04u_pixel%04u_posvar%04u" % (
nside, pixel, i)
eventHeader.sub_event_id = pixel
p_frame["I3EventHeader"] = eventHeader
p_frame["SCAN_HealpixPixel"] = icetray.I3Int(int(pixel))
p_frame["SCAN_HealpixNSide"] = icetray.I3Int(int(nside))
p_frame["SCAN_PositionVariationIndex"] = icetray.I3Int(int(i))
for frame in self.GCDQpFrames[0:-1]:
self.PushFrame(frame)
self.PushFrame(p_frame)
def RFrame(self, frame):
position = frame[self.input_pos_name]
time = frame[self.input_time_name].value
energy = float('NaN')
self.PushFrame(frame)
for pixel in self.pixels:
p_frame = icetray.I3Frame(icetray.I3Frame.Physics)
zenith, azimuth = healpy.pix2ang(self.nside, pixel)
direction = dataclasses.I3Direction(zenith,azimuth)
#print "reconstructing with fixed direction", direction, "(npixels=", self.npix, ", pixel=", pixel, ")"
variationDistance = 20.*I3Units.m
posVariations = [dataclasses.I3Position(0.,0.,0.),
dataclasses.I3Position(-variationDistance,0.,0.),
dataclasses.I3Position( variationDistance,0.,0.),
dataclasses.I3Position(0.,-variationDistance,0.),
dataclasses.I3Position(0., variationDistance,0.),
dataclasses.I3Position(0.,0.,-variationDistance),
dataclasses.I3Position(0.,0., variationDistance)]
for i in range(len(posVariations)):
thisPosition = dataclasses.I3Position(position.x + posVariations[i].x,position.y + posVariations[i].y,position.z + posVariations[i].z)
# generate the particle from scratch
particle = dataclasses.I3Particle()
particle.shape = dataclasses.I3Particle.ParticleShape.Cascade
particle.fit_status = dataclasses.I3Particle.FitStatus.OK
particle.pos = thisPosition
particle.dir = direction
particle.time = time
particle.energy = energy
thisParticleName = self.output_particle_name
if i>0: thisParticleName = thisParticleName+"_%i"%i
p_frame[thisParticleName] = particle
p_frame["HealpixPixel"] = icetray.I3Int(int(pixel))
p_frame["HealpixNSide"] = icetray.I3Int(int(self.nside))
# generate a new event header
eventHeader = dataclasses.I3EventHeader(frame["I3EventHeader"])
eventHeader.sub_event_stream = "millipede_scan_nside%04u" % self.nside
eventHeader.sub_event_id = pixel
p_frame["I3EventHeader"] = eventHeader
self.PushFrame(p_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 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 Process(self):
try:
t = self.times.next()
except StopIteration:
self.RequestSuspension()
return
header = dataclasses.I3EventHeader()
header.start_time = dataclasses.make_I3Time(t)
frame = icetray.I3Frame("P")
frame["I3EventHeader"] = header
self.PushFrame(frame)
def makeHits(frame):
hits = simclasses.I3MCPESeriesMap()
geo = frame["I3Geometry"]
dom = list(geo.omgeo.keys())[2]
hits[dom] = simclasses.I3MCPESeries()
for i in range(0, 10):
hit = simclasses.I3MCPE()
hit.npe = 10
hit.time = 10 * i
hits[dom].append(hit)
dom = list(geo.omgeo.keys())[3]
hits[dom] = simclasses.I3MCPESeries()
for i in range(0, 10):
hit = simclasses.I3MCPE()
hit.npe = 10
hit.time = 10 * i
hits[dom].append(hit)
frame["MCPESeriesMap"] = hits
frame["I3EventHeader"] = dataclasses.I3EventHeader()
def CreatePFrame(self, nside, pixel, pixel_index):
dec, ra = healpy.pix2ang(nside, pixel)
dec = numpy.pi/2. - dec
zenith, azimuth = astro.equa_to_dir(ra, dec, self.event_mjd)
zenith = float(zenith)
azimuth = float(azimuth)
direction = dataclasses.I3Direction(zenith,azimuth)
position = self.seed_position
time = self.seed_time
energy = self.seed_energy
for i in range(0,len(self.posVariations)):
posVariation = self.posVariations[i]
p_frame = icetray.I3Frame(icetray.I3Frame.Physics)
thisPosition = dataclasses.I3Position(position.x + posVariation.x, position.y + posVariation.y, position.z + posVariation.z)
# generate the particle from scratch
particle = dataclasses.I3Particle()
particle.shape = dataclasses.I3Particle.ParticleShape.InfiniteTrack
particle.fit_status = dataclasses.I3Particle.FitStatus.OK
particle.pos = thisPosition
particle.dir = direction
particle.time = time
particle.energy = energy
p_frame[self.output_particle_name] = particle
# generate a new event header
eventHeader = dataclasses.I3EventHeader(self.event_header)
eventHeader.sub_event_stream = "SCAN_nside%04u_pixel%04u_posvar%04u" % (nside, pixel, i)
eventHeader.sub_event_id = pixel
p_frame["I3EventHeader"] = eventHeader
p_frame["SCAN_HealpixPixel"] = icetray.I3Int(int(pixel))
p_frame["SCAN_HealpixNSide"] = icetray.I3Int(int(nside))
p_frame["SCAN_PositionVariationIndex"] = icetray.I3Int(int(i))
# an overall sequence index, 0-based, in case we need to re-start
p_frame["SCAN_EventOverallIndex"] = icetray.I3Int( int(i) + pixel_index*len(self.posVariations))
if self.inject_event_name is not None:
p_frame["SCAN_EventName"] = dataclasses.I3String(self.inject_event_name)
self.PushFrame(p_frame)
tray = I3Tray()
#tray.AddService("I3GSLRandomServiceFactory","Random",
#Seed = 1
#)
tray.AddModule(
"I3InfiniteSource",
"streams",
Stream=icetray.I3Frame.DAQ,
prefix=GCDFN,
)
tray.AddModule(
lambda frame: frame.Put("I3EventHeader", dataclasses.I3EventHeader()),
"eventheader-gen",
Streams=[icetray.I3Frame.DAQ])
n_hits = 1000
N = 1
hit_times = []
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
def testTypes(self):
#try to access all keys of the params
WimpParams = self.frame[self.WimpParamsName]
self.assert_(
isinstance(WimpParams, simclasses.I3WimpParams)
and WimpParams != simclasses.I3WimpParams(),
"WimpParams exists and not the default constructor")
self.assert_(
isinstance(WimpParams.mass, float) and WimpParams.mass != 0.,
"WimpParams.mass exists and is set")
self.assert_(
isinstance(WimpParams.channel,
simclasses.I3WimpParams.DecayChannel) and
WimpParams.channel != simclasses.I3WimpParams.DecayChannel.unknown,
"WimpParams.channel exists and is set")
self.assert_(
isinstance(WimpParams.source, simclasses.I3WimpParams.SourceType)
and
WimpParams.source != simclasses.I3WimpParams.SourceType.UNKNOWN,
"WimpParams.time exists and is set")
self.assert_(
isinstance(WimpParams.nu_weight, float)
and WimpParams.nu_weight != 0.,
"WimpParams.nu_weight exists and is set")
self.assert_(
isinstance(WimpParams.lep_weight, float)
and WimpParams.lep_weight != 0.,
"WimpParams.lep_weight exists and is set")
self.assert_(
isinstance(WimpParams.had_weight, float)
and WimpParams.had_weight != 0.,
"WimpParams.had_weight exists and is set")
self.assert_(
isinstance(WimpParams.vgen, float) and WimpParams.vgen != 0.,
"WimpParams.vgen exists and is set")
self.assert_(isinstance(WimpParams.time, dataclasses.I3Time),
"WimpParams.time exists")
#try to access all the particles in the mctree
WimpMCTree = self.frame[self.WimpMCTreeName]
self.assert_(
isinstance(WimpMCTree, dataclasses.I3MCTree)
and WimpMCTree != dataclasses.I3MCTree(),
"WimpMCTree exists and is not the default constructor")
#try to access all set parameters in the I3EventHeader
EventHeader = self.frame[self.EventHeaderName]
self.assert_(
isinstance(EventHeader, dataclasses.I3EventHeader)
and EventHeader != dataclasses.I3EventHeader(),
"EventHeader exists and is not the default constructor")
#try to access all set parameters in the I3EventHeader
#test values
self.assert_(WimpParams.mass == 1000, "The wimpMass is correctly 1000")
self.assert_(WimpParams.channel == 5,
"WIMPs have corectly annihilated trough the 5(w) channel"
) #simclasses.I3WimpParams.w
self.assert_(WimpParams.source == simclasses.I3WimpParams.EARTH,
"it is the EARTH")
#test the values: MCTree
self.assert_(
len(WimpMCTree.primaries) == 1, "found exactly one primary")
self.assert_(
len(WimpMCTree.get_daughters(WimpMCTree.primaries[0])) == 2,
"found my two daughter particles and they are asserted")
#test the values EentHeader:
self.assert_(EventHeader.start_time != dataclasses.I3Time(),
"EventHeader.start_time is set")
self.assert_(EventHeader.run_id == 0,
"EventHeader.run_id is correctly set")
self.assert_(EventHeader.event_id == self.count_up,
"EventHeader.event_id is correctly set")
self.count_up += 1
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
def change_stream(frame, initialStream, finalStream):
if frame["I3EventHeader"].sub_event_stream == initialStream:
eh = dataclasses.I3EventHeader(frame["I3EventHeader"])
del frame["I3EventHeader"]
eh.sub_event_stream = finalStream
frame.Put("I3EventHeader", eh)
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()
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()
class FrameSplitter(icetray.I3Module, phys_services.I3Splitter):
def __init__(self, context):
icetray.I3Module.__init__(self, context)
phys_services.I3Splitter.__init__(self, self.configuration)
self.AddOutBox('OutBox')
def header(frame):
frame['I3EventHeader'] = dataclasses.I3EventHeader()
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 headerfaker(frame):
header = dataclasses.I3EventHeader()
header.run_id = 0
header.event_id = headerfaker.event
headerfaker.event += 1
frame['I3EventHeader'] = header
def fake_event_header(frame):
header = dataclasses.I3EventHeader()
header.run_id = RunNumber
header.event_id = fake_event_header.event_id
fake_event_header.event_id += 1
frame['I3EventHeader'] = header
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 add_eventheader(frame):
eh = dataclasses.I3EventHeader()
eh.run_id = 1
eh.event_id = add_eventheader.event_id
add_eventheader.event_id += 1
frame['I3EventHeader'] = eh
