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