def SplitLaunches(self, fullMap, submap, tstart, tend): for omKey, fullSeries in fullMap.items(): for fullSeriesIter in fullSeries: if fullSeriesIter.time > tstart and fullSeriesIter.time <= tend: if not submap.has_key(omKey): submap[omKey] = dataclasses.I3DOMLaunchSeries() submap[omKey].append(fullSeriesIter)
def make_launch_map(): launchmap = dataclasses.I3DOMLaunchSeriesMap() for omkey in doms: launch_series = dataclasses.I3DOMLaunchSeries() launch_series.append(dataclasses.I3DOMLaunch()) launchmap[omkey] = launch_series launchmap[icetray.OMKey(0, 3)].append(dataclasses.I3DOMLaunch()) return launchmap
def launch_splitter(frame, mapname = "I3DOMLaunchSeriesMap"): ''' A one-off moudule to split the output DOMLaunchSeriesMap from DOMLauncher into an InIce part, IceTop part and a BeaconLaunch part. ''' geo = frame["I3Geometry"] launch_map = frame[mapname] inice = dataclasses.I3DOMLaunchSeriesMap() icetop = dataclasses.I3DOMLaunchSeriesMap() beacon = dataclasses.I3DOMLaunchSeriesMap() for omkey,launch_series in launch_map : g = geo.omgeo[omkey] #First we find the beacon launches and remove them #from the launch series index = 0 spetriggered = dataclasses.I3DOMLaunchSeries() for l in launch_series: if(l.trigger_type == dataclasses.I3DOMLaunch.CPU_REQUESTED): if(omkey in beacon): beacon[omkey].append(l) else: beacon[omkey] = dataclasses.I3DOMLaunchSeries([l]) else: spetriggered.append(l) index += 1 launch_series = spetriggered if (len(launch_series) == 0): continue if (g.omtype == dataclasses.I3OMGeo.IceCube): inice[omkey] = launch_series elif (g.omtype == dataclasses.I3OMGeo.IceTop) : icetop[omkey] = launch_series else : icetray.logging.log_fatal("Unknown DOM type %s at %s in the launch map" \ % (str(g.omtype), str(omkey))) frame["InIceRawData"] = inice frame["IceTopRawData"] = icetop frame["BeaconLaunches"] = beacon del frame[mapname]
def Create_LaunchesSeriesMap(frame): launchesmap = dc.I3DOMLaunchSeriesMap() l1 = dc.I3DOMLaunch() l1.time = 5.1 l1.lc_bit = True l2 = dc.I3DOMLaunch() l2.time = 34.7 l2.lc_bit = False launchesmap[icetray.OMKey(10, 4)] = dc.I3DOMLaunchSeries([l1, l2]) l1 = dc.I3DOMLaunch() l1.time = 6.0 l1.lc_bit = False l2 = dc.I3DOMLaunch() l2.time = 11.3 l2.lc_bit = False launchesmap[icetray.OMKey(25, 13)] = dc.I3DOMLaunchSeries([l1, l2]) frame.Put("TestLauncheSeriesMap", launchesmap)
def AppendLaunches(self, launchmap, hit): newLaunch = dataclasses.I3DOMLaunch() newLaunch.time = hit.Time newLaunch.lc_bit = True if hit.OMKey not in launchmap.keys(): newLaunchSeries = dataclasses.I3DOMLaunchSeries() newLaunchSeries.append(newLaunch) launchmap[hit.OMKey] = newLaunchSeries else: for launch in launchmap[hit.OMKey]: if launch.time == hit.Time: return launchmap[hit.OMKey].append(newLaunch)
def frame_setup(frame): frame["I3Triggers"] = dataclasses.I3TriggerHierarchy() dom_launch = dataclasses.I3DOMLaunch() dom_launch.time = 42*I3Units.ns dom_launch_series = dataclasses.I3DOMLaunchSeries() dom_launch_series.append(dom_launch) launch_map = dataclasses.I3DOMLaunchSeriesMap() launch_map[icetray.OMKey(21,30)] = dom_launch_series frame["InIceRawData"] = launch_map
def DAQ(self, frame): print("DAQ!!!") geo = frame.Get("I3Geometry") if self.domSetsName in frame: domSets = frame.Get(self.domSetsName) else: domSets = None # InDOMSet() will use the default table if there is no frame object omlist_l = list() for omkey, omgeo in geo.omgeo: if omgeo.omtype == dataclasses.I3OMGeo.IceCube and \ ( ( self.generateInDOMSet and trigger_sim.InDOMSet(omkey,4,domSets) ) or \ ( not self.generateInDOMSet and not trigger_sim.InDOMSet(omkey,4,domSets) ) ): omlist_l.append(omkey) launchmap = dataclasses.I3DOMLaunchSeriesMap() launch_counter = 0 for i in range(self.nDOMs): launch = dataclasses.I3DOMLaunch() launch.lc_bit = True # set start times according to uniform distribution time = random.uniform(0, self.timeWindow) if not self.generateInTimeWindow: time += launch_counter * self.timeWindow launch.time = time ## select from the available list omkey = random.sample(omlist_l, 1)[0] if not omkey in launchmap: launchmap[omkey] = dataclasses.I3DOMLaunchSeries() launchmap[omkey].append(launch) launch_counter += 1 frame["InIceRawData"] = launchmap self.PushFrame(frame)
def DAQ(self, frame): print("DAQ!!!") geo = frame.Get("I3Geometry") omlist_l = list() for omkey, omgeo in geo.omgeo: if omgeo.omtype == self.domType: omlist_l.append(omkey) launchmap = dataclasses.I3DOMLaunchSeriesMap() launch_counter = 0 for i in range(self.nDOMs): launch = dataclasses.I3DOMLaunch() launch.lc_bit = True # set start times according to uniform distribution time = random.uniform(0, self.timeWindow) if not self.generateInTimeWindow: time += launch_counter * self.timeWindow launch.time = time ## select from the available list omkey = random.sample(omlist_l, 1)[0] if not omkey in launchmap: launchmap[omkey] = dataclasses.I3DOMLaunchSeries() launchmap[omkey].append(launch) launch_counter += 1 if self.domType == dataclasses.I3OMGeo.IceCube: frame["InIceRawData"] = launchmap if self.domType == dataclasses.I3OMGeo.IceTop: frame["IceTopRawData"] = launchmap self.PushFrame(frame)
calib.end_time = the_time + 100 status = dataclasses.I3DetectorStatus() status.start_time = the_time - 100 status.end_time = the_time + 100 frame = icetray.I3Frame(icetray.I3Frame.Geometry) frame['I3Geometry'] = geo f.push(frame) frame = icetray.I3Frame(icetray.I3Frame.Calibration) frame['I3Calibration'] = calib f.push(frame) frame = icetray.I3Frame(icetray.I3Frame.DetectorStatus) frame['I3DetectorStatus'] = status f.push(frame) frame = icetray.I3Frame(icetray.I3Frame.DAQ) dlsm = dataclasses.I3DOMLaunchSeriesMap() dlsm[icetray.OMKey(7, 42)] = dataclasses.I3DOMLaunchSeries() frame['InIceRawData'] = dlsm t = dataclasses.I3Time() t.set_utc_cal_date(1919, 1, 15, 0, 0, 0, 0) frame['DrivingTime'] = t header = dataclasses.I3EventHeader() header.run_id = 7 header.event_id = 42 header.sub_event_id = 0 header.start_time = t header.end_time = t + 10 * I3Units.microsecond frame['I3EventHeader'] = header f.push(frame) f.close()
def Physics(self, frame): if not frame.Has(self.inputMapName): self.PushFrame(frame) return if type(frame[self.inputMapName]) == dataclasses.I3RecoPulseSeriesMapMask or \ type(frame[self.inputMapName]) == dataclasses.I3RecoPulseSeriesMap: workingOnPulses = True else: workingOnPulses = False if frame.Has(self.inputTrack): seed = frame[self.inputTrack] if type(frame[self.inputTrack]) == dataclasses.I3MCTree: seed = frame[self.inputTrack][0] initialPos = [seed.pos.x, seed.pos.y, seed.pos.z] initialDir = [ seed.speed * seed.dir.x, seed.speed * seed.dir.y, seed.speed * seed.dir.z ] initialState = initialPos + initialDir else: print("Kalman - Error: InputTrack not found") self.PushFrame(frame) return ## timewise sorted Pulses/DomLaunches - [(OMkey, Time, Pulse/DomLaunch)] hitlist = hitfilter(frame, self.inputMapName, self.IgnoreDC) if self.useAcceleration: stateDim = 9 else: stateDim = 6 ## Initialize Kalman filter kalman = Kalman(stateDim, 3, initialState, self.noiseQ, self.noiseR) for i in range(self.iterations): ## create variables for results prediction = dataclasses.I3VectorI3Particle() if self.useAcceleration: acceleration = dataclasses.I3VectorI3Particle() varianceVector = dataclasses.I3VectorDouble() if workingOnPulses: recoPulseSeriesMapMask = dataclasses.I3RecoPulseSeriesMapMask( frame, self.inputMapName) recoPulseSeriesMapMask.set_none() else: domLaunchSeriesMap = dataclasses.I3DOMLaunchSeriesMap() ## write seed to predictionlist seed = dataclasses.I3Particle() seed.pos = dataclasses.I3Position(initialState[0], initialState[1], initialState[2]) seed.dir = dataclasses.I3Direction(initialState[3], initialState[4], initialState[5]) seed.speed = np.linalg.norm(initialState[3:6]) seed.time = 0 prediction.append(seed) ## Write acceleration seed if self.useAcceleration: accel = dataclasses.I3Particle() accel.pos = dataclasses.I3Position(0, 0, 0) acceleration.append(accel) ## clean variables hitList = [] predList = [] time = [] chi2 = 0 lastTime = 0 p = kalman.Predict() ## loop over all hits in given map for hit in hitlist: ## extrapolate Kalman-Prediction pos = p[0:3] + p[3:6] * (hit.time - lastTime) om = np.array(self.geo.omgeo[hit.omkey].position) ## Distance to next hit d = np.linalg.norm(om - pos) if d <= self.cutRadius: dt = hit.time - lastTime lastTime = hit.time ## Update Kalman filter with new hit kalman.Update(om, dt) p = kalman.Predict() ## Uncomment to activate debug mode #kalman.Debug() ## Add Kalman-step to predictionlist pred = dataclasses.I3Particle() pred.pos = dataclasses.I3Position(p[0], p[1], p[2]) pred.dir = dataclasses.I3Direction(p[3], p[4], p[5]) pred.speed = np.linalg.norm(p[3:6]) pred.time = hit.time prediction.append(pred) if self.useAcceleration: accel = dataclasses.I3Particle() accel.pos = dataclasses.I3Position(p[6], p[7], p[8]) acceleration.append(accel) varianceVector.append(kalman.GetVariance()[0]) chi2 += d**2 ## write PulseMapMask/DOMLaunchMap if workingOnPulses: recoPulseSeriesMapMask.set(hit.omkey, hit.info, True) else: if hit.omkey in domLaunchSeriesMap: domLaunchSeriesMap[hit.omkey].append(hit.info) else: domLaunchSeries = dataclasses.I3DOMLaunchSeries() domLaunchSeries.append(hit.info) domLaunchSeriesMap[hit.omkey] = domLaunchSeries hitList += [om] predList += [p[0:3]] time += [hit.time] ## new initialization for the next global iteration if len(hitList) > 0: ## use last iteration as LineFit if self.iterationMethod == 1: x0 = p[0] - p[3] * hit.time y0 = p[1] - p[4] * hit.time z0 = p[2] - p[5] * hit.time particle = dataclasses.I3Particle() particle.pos = dataclasses.I3Position(x0, y0, z0) particle.dir = dataclasses.I3Direction(p[3], p[4], p[5]) particle.speed = np.linalg.norm([p[3:6]]) particle.time = 0 elif self.iterationMethod == 2: ## calculate the LineFit on selected pulses particle = LineFitCallKalman(hitList, time) elif self.iterationMethod == 3: ## calculate the LineFit on iteration steps particle = LineFitCallKalman(predList, time) else: raise NotImplementedError( "No IterationMethod with number %s" % str(self.IterationMethod)) ## Last Iteration ? if i < self.iterations - 1: initialPos = [ particle.pos.x, particle.pos.y, particle.pos.z ] initialDir = [ particle.speed * particle.dir.x, particle.speed * particle.dir.y, particle.speed * particle.dir.z ] initialState = initialPos + initialDir initialP = kalman.GetVarianceVector() kalman = Kalman(stateDim, 3, initialState, self.noiseQ, self.noiseR, initialP) else: ## Write everything to the frame frame["%s_LineFit" % (self.outputTrack)] = particle frame["%s_NHits" % (self.outputTrack)] = dataclasses.I3Double( len(hitList)) frame["%s_P" % (self.outputTrack)] = varianceVector frame["%s_Chi2Pred" % (self.outputTrack)] = dataclasses.I3Double( Chi2CallKalman(predList, time, particle)) if workingOnPulses: frame["%s_Map" % (self.outputTrack)] = recoPulseSeriesMapMask else: frame["%s_Map" % (self.outputTrack)] = domLaunchSeriesMap if self.additionalInformation: frame["%s_Pred" % (self.outputTrack)] = prediction if self.useAcceleration: frame["%s_Accel" % (self.outputTrack)] = acceleration self.PushFrame(frame)
def DAQ(self, frame): print("DAQ!!!") geo = frame.Get("I3Geometry") omlist_l = list() for omkey, omgeo in geo.omgeo: if omkey.GetString() == self.stringN: if omgeo.omtype == dataclasses.I3OMGeo.IceCube: omlist_l.append(omkey) time = 100. * I3Units.ns if not self.trigTest: print("You are TESTING <<THE NON-EXISTENSE>> of a STRING TRIGGER") #Get non adjacent (self.threshold) OMs along a string noms = [ random.randrange(1, 58, 7) for x in range(self.threshold - 2) ] #make sure that they are not adjacent noms.extend([0, 59]) #create a list of DOMLaunches which do fulfill a string trigger condition launchmap = dataclasses.I3DOMLaunchSeriesMap() for i in range(self.threshold): launch = dataclasses.I3DOMLaunch() launch.SetLCBit(True) time += i * 100 * I3Units.ns launch.SetStartTime(time) #choose randomly 5/3 oms from doms between 50 and 56 in string number 1 omkey = omlist_l[noms[i]] print(omkey) if not omkey in launchmap: launchmap[omkey] = dataclasses.I3DOMLaunchSeries() launchmap[omkey].append(launch) frame["InIceRawData"] = launchmap else: print("You are TESTING <<THE- EXISTENSE>> of a STRING TRIGGER") #create a list of DOMLaunches which "DO NOT" fulfill a string trigger condition launchmap = dataclasses.I3DOMLaunchSeriesMap() for i in range(self.threshold): launch = dataclasses.I3DOMLaunch() launch.SetLCBit(True) time += i * 100. * I3Units.ns launch.SetStartTime(time) #choose randomly 5 oms from doms between 30 and 37 in string number 1 omkey = random.sample(omlist_l[30:36], 1)[0] if not omkey in launchmap: launchmap[omkey] = dataclasses.I3DOMLaunchSeries() launchmap[omkey].append(launch) frame["InIceRawData"] = launchmap self.PushFrame(frame)
def DAQ(self, frame): print("DAQ!!!") geo = frame.Get("I3Geometry") omlist_l = list() for omkey, omgeo in geo.omgeo: if omkey.GetString() == self.stringN: if omgeo.omtype == dataclasses.I3OMGeo.IceCube: omlist_l.append(omkey) oms_l = list() noms = [random.randint(0, 59) for r in range(self.nDOMs)] noms.sort() ajcent = True while (ajcent): k = random.randint(0, len(noms) - 1) if (k + 7) < len(noms): if (noms[k + 7] - noms[k] <= 7 and noms[k + 7] - noms[k] >= 0): for i in range(k, k + 7, 1): oms_l.append(noms[i]) ajcent = False else: continue noTimeCorr = True while (noTimeCorr): time_l = [ random.random() * self.timeWindow * I3Units.ns for x in range(self.threshold) ] time_l.sort() if ((time_l[-1] - time_l[0]) <= self.timeWindow * I3Units.ns): noTimeCorr = False else: continue TriggerLengthExpectation = time_l[-1] - time_l[0] trigLength = dataclasses.I3Double(TriggerLengthExpectation * I3Units.ns) frame.Put(self.where, trigLength) time = 100. * I3Units.ns if self.trigTest: print("You are TESTING <<THE EXISTENSE>> of a STRING TRIGGER") #create a list of DOMLaunches which do fulfill a string trigger condition launchmap = dataclasses.I3DOMLaunchSeriesMap() for i in range(self.threshold): omkey = omlist_l[random.sample(oms_l, 1)[0]] # for the slow monopole case we had about 60 launches per OM launch = dataclasses.I3DOMLaunch() launch.SetLCBit(True) launch.SetStartTime(time_l[i]) if not omkey in launchmap: launchmap[omkey] = dataclasses.I3DOMLaunchSeries() launchmap[omkey].append(launch) frame["InIceRawData"] = launchmap else: print("You are TESTING <<NON-EXISTENSE>> of a STRING TRIGGER") #create a list of DOMLaunches which "DO NOT" fulfill a string trigger condition launchmap = dataclasses.I3DOMLaunchSeriesMap() for i in range(self.threshold): launch = dataclasses.I3DOMLaunch() launch.SetLCBit(True) time += i * 1000. * I3Units.ns launch.SetStartTime(time) #choose randomly 5 oms from doms between 30 and 37 in string number 1 omkey = random.sample(omlist_l[50:56], 1)[0] if not omkey in launchmap: launchmap[omkey] = dataclasses.I3DOMLaunchSeries() launchmap[omkey].append(launch) frame["InIceRawData"] = launchmap self.PushFrame(frame)
def TestSetup(frame, add_empty_trigger=False, add_mchits=True): p = dataclasses.I3Particle() p.time = TIME frame["MCPrimary"] = p mctree = dataclasses.I3MCTree() mctree.add_primary(p) frame["MCTree"] = mctree # I3MMCTrack mmctrack = simclasses.I3MMCTrack() mmctrack.SetParticle(p) mmctrack.ti = TIME mmctrack.tc = TIME mmctrack.tf = TIME mmctracklist = simclasses.I3MMCTrackList() mmctracklist.append(mmctrack) frame["MMCTracks"] = mmctracklist # I3TriggerHierarchy t = dataclasses.I3Trigger() t.time = TIME t.fired = True trigger_h = dataclasses.I3TriggerHierarchy() if not add_empty_trigger: trigger_h.insert(t) frame["Trigger"] = trigger_h # I3VectorI3Trigger t1 = dataclasses.I3Trigger() t1.time = TIME t1.fired = True trigger_v = dataclasses.I3VectorI3Trigger() trigger_v.append(t1) frame["TriggerVector"] = trigger_v # I3FlasherInfoVector fi = dataclasses.I3FlasherInfo() fi.flash_time = TIME fi_v = dataclasses.I3FlasherInfoVect() fi_v.append(fi) frame["FlasherInfos"] = fi_v # I3DOMLaunchSeriesMap d = dataclasses.I3DOMLaunch() d.time = TIME launchseries = dataclasses.I3DOMLaunchSeries() launchseries.append(d) launchmap = dataclasses.I3DOMLaunchSeriesMap() launchmap[icetray.OMKey(21, 30)] = launchseries frame["DOMLaunchMap"] = launchmap # I3MCHit mchit = dataclasses.I3MCHit() mchit.time = TIME mchitseries = dataclasses.I3MCHitSeries() mchitseries.append(mchit) mchitmap = dataclasses.I3MCHitSeriesMap() mchitmap[icetray.OMKey(21, 30)] = mchitseries if add_mchits: frame["MCHitMap"] = mchitmap # I3MCPE mcpe = simclasses.I3MCPE() mcpe.time = TIME mcpeseries = simclasses.I3MCPESeries() mcpeseries.append(mcpe) mcpemap = simclasses.I3MCPESeriesMap() mcpemap[icetray.OMKey(21, 30)] = mcpeseries frame["MCPEMap"] = mcpemap # I3MCPulse mcpulse = simclasses.I3MCPulse() mcpulse.time = TIME mcpulseseries = simclasses.I3MCPulseSeries() mcpulseseries.append(mcpulse) mcpulsemap = simclasses.I3MCPulseSeriesMap() mcpulsemap[icetray.OMKey(21, 30)] = mcpulseseries frame["MCPulseMap"] = mcpulsemap # I3Double sometime = dataclasses.I3Double(TIME) frame["SomeTime"] = sometime nottime = dataclasses.I3Double(TIME) frame["NotTime"] = nottime