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 Process(self): if not self.geometry: self.geometry = True geometry = dc.I3Geometry() for string in self.strings: for dom in self.doms: omkey= icetray.OMKey(string,dom) geometry.omgeo[omkey] = dc.I3OMGeo() x=random.uniform(-500,500) y=random.uniform(-500,500) z=random.uniform(-300,300) geometry.omgeo[omkey].position = dc.I3Position(x,y,z) frame = icetray.I3Frame(icetray.I3Frame.Geometry); frame.Put('I3Geometry',geometry) self.PushFrame(frame) pulsesmap= dc.I3RecoPulseSeriesMap() for string in self.strings: for dom in self.doms: omkey= icetray.OMKey(string,dom) pulse= dc.I3RecoPulse() pulse.charge= random.uniform(0.3,6.)#pulses are not used in the algorithm of this module, #just put a single pulse with any value of the charge pulsesmap[omkey]= dc.I3RecoPulseSeries([pulse]) frame = icetray.I3Frame(icetray.I3Frame.Physics); frame.Put("TestPulseSeriesMap",pulsesmap) self.PushFrame(frame)
def DAQ(self, frame): # only inject it once if self.has_been_injected: self.PushFrame(frame) return self.has_been_injected = True geometry = dataclasses.I3Geometry() calibration = dataclasses.I3Calibration() detectorStatus = dataclasses.I3DetectorStatus() # fill the geometry map omgeomap = geometry.omgeo domcalmap = calibration.dom_cal domstatusmap = detectorStatus.dom_status for i, pos in enumerate(omPositions): shiftedPos = pos shiftedPos[0] += self.xCoord * I3Units.m shiftedPos[1] += self.yCoord * I3Units.m shiftedPos[2] += self.zCoord * I3Units.m omkey = omKeys[i] newomgeo = dataclasses.I3OMGeo() newomgeo.omtype = dataclasses.I3OMGeo.OMType.IceCube newomgeo.orientation = dataclasses.I3Orientation( dataclasses.I3Direction(0., 0., -1.)) newomgeo.position = dataclasses.I3Position(shiftedPos[0], shiftedPos[1], shiftedPos[2]) omgeomap[omkey] = newomgeo newdomcal = dataclasses.I3DOMCalibration() newdomcal.relative_dom_eff = 1.0 domcalmap[omkey] = newdomcal newdomstatus = dataclasses.I3DOMStatus() newdomstatus.pmt_hv = 1345. * I3Units.V # some arbitrary setting: >0 and not NaN domstatusmap[omkey] = newdomstatus # make GCD frames and fill them with objects Gframe = icetray.I3Frame(icetray.I3Frame.Geometry) Cframe = icetray.I3Frame(icetray.I3Frame.Calibration) Dframe = icetray.I3Frame(icetray.I3Frame.DetectorStatus) Gframe["I3Geometry"] = geometry Cframe["I3Calibration"] = calibration Dframe["I3DetectorStatus"] = detectorStatus # push the new GCD frames self.PushFrame(Gframe) self.PushFrame(Cframe) self.PushFrame(Dframe) # push the original Q-frame self.PushFrame(frame)
def select_frame(self, frame): ''' Attempt to access the frame'th I3Frame in the file. If 'frame' is negative, access in reverse order. If 'frame' is invalid, do nothing. ''' if frame is None or frame < 0 or frame == self.active_view: return if frame == 'end': frame = -1 # rather than checking against the maximum length of the list, # which is slow for sequential files, just try to access the frame try: self.framelist[frame] except IndexError: return if frame < 0: # reverse direction frame = len(self.framelist) + frame # iterate through the framelist to determine the frame hierarchy if frame < self.active_view: self.active_view = 0 self.frame_hierarchy.reset() if isinstance(self.framelist[self.active_view], fileadaptor.FrameWrapper): frame_obj = self.framelist[self.active_view].frame else: frame_obj = self.framelist[self.active_view] f = icetray.I3Frame(frame_obj) f.purge() self.frame_hierarchy.mix(f) while (self.active_view < frame): self.active_view += 1 if isinstance(self.framelist[self.active_view], fileadaptor.FrameWrapper): frame_obj = self.framelist[self.active_view].frame else: frame_obj = self.framelist[self.active_view] f = icetray.I3Frame(frame_obj) f.purge() self.frame_hierarchy.mix(f) old_widget = self.body self.maxkeylen = len(self.framelist[self.active_view]) if self.key >= self.maxkeylen: self.key = self.maxkeylen - 1 self.frame_viewer.set_view(self.framelist[self.active_view], self.active_view, key=self.key) self.footer.set_view(self.active_view, key=self.key) del old_widget self.drop_focus()
def FramePacket(self,frames): originalFrame = icetray.I3Frame() #keep this pointer alive targetFrame = icetray.I3Frame() for oframe in frames: if oframe.Has("I3EventHeader") and oframe["I3EventHeader"].sub_event_stream==self.originalStream: originalFrame=oframe for tframe in frames: if tframe.Has("I3EventHeader") and tframe["I3EventHeader"].sub_event_stream==self.targetStream and tframe["I3EventHeader"].sub_event_id==oframe["I3EventHeader"].sub_event_id: targetFrame=tframe for key in self.moveObjects: targetFrame[key]=originalFrame[key] targetFrame.Put(self.flagName, icetray.I3Bool(True)) for frame in frames: self.PushFrame(frame)
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 Process(self): # get next frame frame = self.PopFrame() if not self._frame_has_been_pushed: # create settings frame and push it settings_frame = icetray.I3Frame('m') # add meta data on ranges settings_data = {} for key, value_range in self.proposal_storm.uniform_ranges.items(): settings_data[key+'RangeMin'] = value_range[0] settings_data[key+'RangeMax'] = value_range[1] # write to frame settings_frame[self._output_key+'UniformRanges'] = ( dataclasses.I3MapStringDouble(settings_data) ) settings_frame[self._output_key] = dataclasses.I3MapStringDouble( self.proposal_storm.sampled_settings) self.PushFrame(settings_frame) self._frame_has_been_pushed = True self.PushFrame(frame)
def __init__(self, framelist, header, footer, ascii_only=False): self.framelist = framelist self.active_view = 0 self.frame_hierarchy = icetray.I3FrameMixer(True) try: if isinstance(self.framelist[self.active_view], fileadaptor.FrameWrapper): frame_obj = self.framelist[self.active_view].frame else: frame_obj = self.framelist[self.active_view] f = icetray.I3Frame(frame_obj) f.purge() self.frame_hierarchy.mix(f) except Exception: raise Exception('No frames in file!') self.key = 0 self.maxkeylen = len(self.framelist[self.active_view]) urwid.connect_signal(footer, 'select_frame', self.select_frame) urwid.connect_signal(footer, 'drop_focus', self.drop_focus) self.frame_viewer = FrameViewer(framelist[0], 0, ascii_only=ascii_only) urwid.Frame.__init__(self, self.frame_viewer, header=header, footer=footer) urwid.connect_signal(self.frame_viewer, 'select_key', self.select_key) urwid.connect_signal(self.frame_viewer, 'update_status', footer.update_status) urwid.connect_signal(self.frame_viewer, 'goto_matching_frame', self.goto_matching_frame) self.popup = None self._ipy_namespace = dict()
def DAQ(self, frame): """Inject casacdes into I3MCtree. Parameters ---------- frame : icetray.I3Frame.DAQ An I3 q-frame. """ trees = [frame[t] for t in self.mctree_keys] # oversampling for i in range(self.oversampling_factor): if i > 0: # create a new frame frame = icetray.I3Frame(frame) del frame['oversampling'] for key, tree in zip(self.mctree_keys, trees): del frame[key] frame[key] = dataclasses.I3MCTree(tree) if self.oversampling_factor > 1: frame['oversampling'] = dataclasses.I3MapStringInt({ 'event_num_in_run': self.events_done, 'oversampling_num': i, }) self.PushFrame(frame) self.events_done += 1
def do_one(Type, name, gen, checksum): print("Writing %s" % Type) global is_fail name += '.i3' i3f = dataio.I3File(name, dataio.I3File.Mode.Writing) tinst = Type() i = 0 for value in gen: tinst.append(value) i += 1 print("%d entries" % i) frame = icetray.I3Frame() frame[name] = tinst i3f.push(frame) i3f.close() f = open(name, 'rb') data = f.read() hsh = hashlib.md5() hsh.update(data) hd = hsh.hexdigest() if (hd != checksum): print("****************** ERRORZ ERRORZ ***********************") print("%s != %s (file %s, %u bytes)" % (hd, checksum, name, len(data))) is_fail = True
def setUp(self): self.frame = icetray.I3Frame(icetray.I3Frame.Physics) pulses = dataclasses.I3RecoPulseSeriesMap() key1 = icetray.OMKey(42, 7) vec = dataclasses.I3RecoPulseSeries() pulse = dataclasses.I3RecoPulse() pulse.time = 1.0 pulse.charge = 2.3 vec.append(pulse) pulse.time = 2.0 vec.append(pulse) pulse.time = 15.0 vec.append(pulse) pulses[key1] = vec key2 = icetray.OMKey(7, 7) vec = dataclasses.I3RecoPulseSeries() pulse.time = 1.0 pulse.charge = 2.3 vec.append(pulse) pulse.time = 2.0 vec.append(pulse) pulse.time = 15.0 vec.append(pulse) pulses[key2] = vec self.frame['Pulses'] = pulses mask1 = dataclasses.I3RecoPulseSeriesMapMask(self.frame, 'Pulses') mask1.set(key1, 1, False) self.frame['Mask1'] = mask1 mask2 = dataclasses.I3RecoPulseSeriesMapMask(self.frame, 'Pulses') mask2.set(key2, 1, False) self.frame['Mask2'] = mask2
def export_frame(frame, frame_list, mctree_name, keys_to_export, rename_dict): """Export frames and append them to the provided frame list. Parameters ---------- frame : I3Frame The current I3Frame. frame_list : list The list to which to append the exported frames. mctree_name : str The name of the I3MCTree key. keys_to_export : list of str The keys to extract save to the exported frame rename_dict : dict A dictionary that defines the renaming of the keys. Signature: rename_dict[old_name] = new_name """ # create a new DAQ frame fr = icetray.I3Frame(icetray.I3Frame.DAQ) # extract I3MCTree fr[mctree_name] = dataclasses.I3MCTree(frame[mctree_name]) # extract specified keys for key in keys_to_export: if key in frame: new_name = rename_dict.get(key, key) fr[new_name] = frame[key] # append frame to list frame_list.append(fr)
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 write(fname='muongun_serialization_test.i3'): frame = icetray.I3Frame() frame['Generator'] = generator f = dataio.I3File(fname, 'w') f.push(frame) f.close()
def test_fill(self): hm = DerivedHistogramModule() for i in range(10): hm.DAQ(icetray.I3Frame()) h = hm.histograms["DilbertRNG"] self.assertEqual(h.bin_values[9], 10) self.assertEqual(len(h.bin_values), 10)
def Process(self): frame = icetray.I3Frame(icetray.I3Frame.DAQ) mcpes = simclasses.I3MCPESeries() for i in range(1000) : mcpes.append(simclasses.I3MCPE(1)) mcpemap = simclasses.I3MCPESeriesMap() mcpemap[icetray.OMKey(21,30)] = mcpes frame["I3MCPESeriesMap"] = mcpemap self.PushFrame(frame)
def generateCFrame(geometry): # intialize frame as a C frame frame = icetray.I3Frame(icetray.I3Frame.Calibration) # add key-value pairs frame["I3Geometry"] = geometry frame["I3Calibration"] = makeCalibrationObject(geometry) frame["SPEAbove"] = cdframe["SPEAbove"] frame["SPEScalingFactors"] = cdframe["SPEScalingFactors"] return frame
def Physics(self, frame): frame.purge() # deletes all non-native items for name in frame.keys(): frame.change_stream(name, self.new_stream) new_frame = icetray.I3Frame(self.new_stream) new_frame.merge(frame) del frame self.PushFrame(new_frame)
def rewrite_frame_stop(input_frame, new_stream): input_frame.purge() # deletes all non-native items for key in input_frame.keys(): input_frame.change_stream(key, new_stream) new_frame = icetray.I3Frame(new_stream) new_frame.merge(input_frame) del input_frame return new_frame
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 setUpModule(): """ Generate .i3 file (borrowed from dataio test_randomaccess_file) """ i3f = dataio.I3File(test_filename, dataio.I3File.Mode.Writing) frames = test_frames for pr in frames: frame = icetray.I3Frame(icetray.I3Frame.Stream(pr[0])) frame[pr[0]] = icetray.I3Int(pr[1]) i3f.push(frame) i3f.close()
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 test_default(self): h = PhysicsHistogram(0, 10, 10, "DerivedHistogram", expression="frame['integer'].value") for i in range(10): frame = icetray.I3Frame() frame["integer"] = icetray.I3Int(i) h.Physics(frame) for bin_value in h.bin_values: self.assertEqual(bin_value, 1)
def generateDFrame(geometry): # intialize frame as a D frame frame = icetray.I3Frame(icetray.I3Frame.DetectorStatus) # add key-value pairs frame["I3Geometry"] = geometry frame["I3Calibration"] = makeCalibrationObject(geometry) frame["SPEAbove"] = cdframe["SPEAbove"] frame["SPEScalingFactors"] = cdframe["SPEScalingFactors"] frame["I3DetectorStatus"] = makeDSObject(geometry) frame["BadDomsList"] = cdframe["BadDomsList"] frame["BadDomsListSLC"] = cdframe["BadDomsListSLC"] return frame
def Process(self): frame = icetray.I3Frame(icetray.I3Frame.DAQ) mctree = dataclasses.I3MCTree() cascade = dataclasses.I3Particle(dataclasses.I3Particle.Primary, dataclasses.I3Particle.EPlus) muon = dataclasses.I3Particle(dataclasses.I3Particle.Primary, dataclasses.I3Particle.MuPlus) mctree.add_primary(cascade) mctree.add_primary(muon) frame["I3MCTree"] = mctree self.PushFrame(frame)
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 test_fill(self): h = DerivedHistogram(0, 10, 10, "DerivedHistogram") for i in range(10): frame = icetray.I3Frame() frame["integer"] = icetray.I3Int(i) h.DAQ(frame) frame = icetray.I3Frame() frame["integer"] = icetray.I3Int(-1) h.DAQ(frame) frame = icetray.I3Frame() frame["integer"] = icetray.I3Int(10) h.DAQ(frame) self.assertEqual(len(h.bin_values), 10) self.assertEqual(h.name, "DerivedHistogram") for bin_value in h.bin_values: self.assertEqual(bin_value, 1) self.assertEqual(h.overflow, 1) self.assertEqual(h.underflow, 1)
def retrieve_metadata_frame_from_pulsar(self, topic): metadata_reader = None retries = 10 while True: msg = None try: icetray.logging.log_debug("Need to (re-)subscribe to metadata stream: {}".format(topic), unit=__name__) # (re-)subscribe through Pulsar if metadata_reader is None: metadata_reader = self.receiver_service.client().create_reader( topic=topic, start_message_id=pulsar.MessageId.earliest, receiver_queue_size=1) if not metadata_reader.has_message_available(): raise RuntimeError("No metadata message available") icetray.logging.log_debug("Reading metadata frame from topic {}..".format(topic), unit=__name__) msg = metadata_reader.read_next() icetray.logging.log_debug("Metadata frame read from topic {}.".format(topic), unit=__name__) except: if retries > 0: icetray.logging.log_warn("Metadata read failed! Retrying. {}".format(topic), unit=__name__) retries -= 1 time.sleep(0.5) else: icetray.logging.log_warn("Metadata read failed! Throwing exception. {}".format(topic), unit=__name__) raise if msg is not None: break frame = icetray.I3Frame() frame.loads(msg.data()) icetray.logging.log_debug("Loaded {} frame from pulsar".format(frame.Stop), unit=__name__) # add a I3String items to the frame to mark where we got it from frame['__msgtopic'] = dataclasses.I3String( topic ) if metadata_reader is not None: metadata_reader.close() del metadata_reader return frame
def testRoundTrip(self): """ I3Matrix serializes and deserializes properly. """ fname = 'i3matrix_test.i3' orig = numpy.pi * numpy.ones((3, 3)) frame = icetray.I3Frame() frame['foo'] = I3Matrix(orig) f = dataio.I3File(fname, 'w') f.push(frame) f.close() frame = dataio.I3File(fname).pop_frame() view = numpy.asarray(frame['foo']) self.assertEquals(view.shape, orig.shape) self.assert_((view == orig).all()) os.unlink(fname)