def AddBadDOMLists(frame, listHLC, listSLC): if "BadDomsList" in frame: dynamicList = set(frame["BadDomsList"]) identicalHLC = isOldListSubsetOfNewList(dynamicList, set(listHLC)) if not identicalHLC: print( "*** REPLACING EXISTING BAD DOM LIST in D-frame (HLC)! ***" ) del frame["BadDomsList"] newList = set(listHLC).union(dynamicList) print(" -> new DOM entries in updated list are:", newList.difference(dynamicList)) frame["BadDomsList"] = dataclasses.I3VectorOMKey(newList) else: frame["BadDomsList"] = dataclasses.I3VectorOMKey(listHLC) if "BadDomsListSLC" in frame: dynamicList = set(frame["BadDomsListSLC"]) identicalSLC = isOldListSubsetOfNewList(dynamicList, set(listSLC)) if not identicalSLC: print( "*** REPLACING EXISTING BAD DOM LIST in D-frame (SLC)! ***" ) del frame["BadDomsListSLC"] newList = set(listSLC).union(dynamicList) print(" -> new DOM entries in updated list are:", newList.difference(dynamicList)) frame["BadDomsListSLC"] = dataclasses.I3VectorOMKey(newList) else: frame["BadDomsListSLC"] = dataclasses.I3VectorOMKey(listSLC)
def DetectorStatus(self, frame): """ Adds a list of bad iceTop doms to the D frame. The source is usually the already created BadDomsList (see BadDomListModule). It just filters the IceTop doms out and stores them in this list. Args: frame (icecube.icetray.I3Frame): The detector status frame """ if not frame.Has(self.input_list): icetray.logging.log_warn( '{0} not in frame. Not generating {1}.'.format( self.input_list, self.output_list)) self.PushFrame(frame) return bd_all = frame[self.input_list] bd_it = dataclasses.I3VectorOMKey() for key in bd_all: if is_ice_top(key): bd_it.append(key) frame.Put(self.output_list, bd_it) self.PushFrame(frame)
def find_specials(frame, Output): if "SpecialHits" in frame: specials = frame["SpecialHits"] spec_oms = dataclasses.I3VectorOMKey() for omk in specials.keys(): spec_oms.append(omk) frame[Output] = spec_oms
def convertToVectorOMKey(frame, inputName, outputName): if inputName not in frame: return keys = [] origErrata = frame[inputName] for key, window in origErrata: keys.append(key) newObject = dataclasses.I3VectorOMKey(keys) frame[outputName] = newObject
def DetectorStatus(self, frame): """ Adds the bad dom list with name `self.listName` to the D frame. Which sources are used for the list is specified by the options (see method `Configure` or `__init__`). Args: frame (icecube.icetray.I3Frame): The detector status frame """ # Make frame accessible for all methods self.frame = frame badDomList = [] # Add requested sources if self.temporaryBadDomsOnly: badDomList = badDomList + self._GetTemporarilyBadDoms() elif self.disabledKeysOnly: badDomList = badDomList + self._GetUnconfiguredDoms() else: badDomList = badDomList + self._GetUnconfiguredDoms() \ + self._GetNoHVDoms() \ + self._GetDroppedDoms() \ + self._GetTemporarilyBadDoms() # Add good good SLC keys ("dark noise") if self.addGoodSlcOnlyKeys: badDomList = badDomList + self._GetDarkNoiseModeDoms() # Custom keys are always added badDomList = badDomList + self.customKeys # Sort the list and remove duplicates badDomList = set(sorted(badDomList)) # Convert list i3bdl = dataclasses.I3VectorOMKey() for om in badDomList: i3bdl.append(om) # Write list to frame frame[self.listName] = i3bdl self.PushFrame(frame)
def flag_borked_slc(frame): # Find SLC launches affected by DOMsimulator off-by-one bug, # and tell Millipede to ignore them bad_keys = set() import numpy for om, dls in frame['InIceRawData'].iteritems(): for dl in dls: if dl.lc_bit == False and dl.charge_stamp_highest_sample == 0: print '%s, she is the bad!' % om bad_keys.add(om) if len(bad_keys) > 0: frame['BorkedSLC'] = dataclasses.I3VectorOMKey(bad_keys) frame[ 'OfflinePulses_NoBorkedSLC'] = dataclasses.I3RecoPulseSeriesMapMask( frame, 'OfflinePulses', lambda om, idx, pulse: om not in bad_keys) else: frame[ 'OfflinePulses_NoBorkedSLC'] = dataclasses.I3RecoPulseSeriesMapMask( frame, 'OfflinePulses')
def Detector(self, frame): frame['IceTopBadDOMs'] = dataclasses.I3VectorOMKey() frame['IceTopBadTanks'] = dataclasses.TankKey.I3VectorTankKey() self.PushFrame(frame)
def createEmptyDOMLists(frame, ListNames=[]): for name in ListNames: if name in frame: continue frame[name] = dataclasses.I3VectorOMKey()
newI3Calibration = dataclasses.I3Calibration() newI3DetectorStatus = dataclasses.I3DetectorStatus() newSPEScalingFactors = dataclasses.I3MapKeyDouble() newSPEAbove = dataclasses.I3MapKeyDouble() newI3Calibration.dom_cal = dataclasses.Map_OMKey_I3DOMCalibration() newI3DetectorStatus.dom_status = dataclasses.Map_OMKey_I3DOMStatus() newI3Calibration.dom_cal[dummyOMKey] = newDOMCalib newI3Calibration.start_time = start_time newI3Calibration.end_time = end_time newI3Calibration.vem_cal = dataclasses.I3VEMCalibrationMap() newI3DetectorStatus.daq_configuration_name = "P-ONE_Estimate" newI3DetectorStatus.dom_status[dummyOMKey] = newDOMStatus newI3DetectorStatus.start_time = start_time newI3DetectorStatus.end_time = end_time newI3DetectorStatus.trigger_status = trigger_status newSPEAbove[dummyOMKey] = newAbove newSPEScalingFactors[dummyOMKey] = newScalingFactor frame = icetray.I3Frame(icetray.I3Frame.DetectorStatus) frame["I3Calibration"] = newI3Calibration frame["I3DetectorStatus"] = newI3DetectorStatus frame["SPEAbove"] = newSPEAbove frame["SPEScalingFactors"] = newSPEScalingFactors frame["BadDomsList"] = dataclasses.I3VectorOMKey() frame["BadDomsListSLC"] = dataclasses.I3VectorOMKey() outfile.push(frame) outfile.close()
def WaveformDerivatives(frame): frame["DoublePulseWaveforms"] = dataclasses.I3WaveformSeriesMap() frame["BinsToT1"] = dataclasses.I3VectorDouble( ) # bins with time over threshold (ToT) for the first pulse of a derivative waveform frame["BinsToT2"] = dataclasses.I3VectorDouble( ) # bins with time over threshold (ToT) for the second pulse of a derivative waveform frame["BinsTbT"] = dataclasses.I3VectorDouble( ) # bins with time below threshold (TbT) for the first trailing edge of a derivative waveform frame["Amp1"] = dataclasses.I3VectorDouble( ) # cumulative derivative amplitude of time over threshold (ToT) for the first pulse frame["Amp2"] = dataclasses.I3VectorDouble( ) # cumulative derivative amplitude of time over threshold (ToT) for the second pulse frame["AmpTrailing"] = dataclasses.I3VectorDouble( ) # cumulative derivative amplitude of time below threshold (ToT) for the trailing edge frame["DPWaveformQTot"] = dataclasses.I3VectorDouble() frame["DP_T1"] = dataclasses.I3VectorDouble() frame["DP_T2"] = dataclasses.I3VectorDouble() frame["DPWaveformPulse1Amp"] = dataclasses.I3VectorDouble() frame["DPWaveformPulse2Amp"] = dataclasses.I3VectorDouble() frame["DP_OMs"] = dataclasses.I3VectorOMKey() SDtag = False LCtag = False if frame.Has("CalibratedWaveformsHLCATWD"): wf_map = frame["CalibratedWaveformsHLCATWD"] dp_count = 0 #count number of dp waveforms from this event dp_om_keys = [] for om, wf_series in wf_map: for wf in wf_series: wf_vect = wf.waveform wf_status = wf.status wf_binwidth = wf.bin_width start_time = wf.time if wf_status == 0: wf_qtot = 0.0 for i in range(128): wf_vect[i] = wf_vect[ i] / I3Units.mV #transform wf unit to mV wf_qtot += wf_vect[ i] #individual wf integrated charge in mV #Calculate Sliding Time Window (STW) derivatives for waveforms stw_vect = [] stepsize = 2 for i in range(1, 127): stw_vect += [(wf_vect[i + 1] - wf_vect[i - 1]) / (wf_binwidth * stepsize)] der_wf_bins = len(stw_vect) der_flag = 0 for i in range(1, der_wf_bins - 6): # 3, 4, 5, 6 bins tried. With 6 bins required, all the manually-selected nice double pulse waveforms picked up by the algorithm. if (stw_vect[i - 1] > 0 and stw_vect[i] > 0 and stw_vect[i + 1] > 0 and stw_vect[i + 2] > 0 and stw_vect[i + 3] > 0 and stw_vect[i + 4] > 0): der_flag = i - 1 #Finding point where waveform first sees light. break #sum up the amplitude of the rising edge amp_rising = 0. for i1 in range(der_flag, der_flag + 6): amp_rising += stw_vect[i1] wf_diff = [] for i in range(der_flag, 128 - der_step, der_step): wf_diff += [(wf_vect[i + der_step] - wf_vect[i]) / (wf_binwidth * der_step)] diff_wf_bins = len(wf_diff) #search for the first and second pulses! pulse1 = False pulse2 = False trailing = False i_flag = 0 j_flag = 0 k_flag = 0 amp_p1 = 0 #amplitude of first rising edge in the derivative waveform amp_p2 = 0 #amplitude of second rising edge in the derivative waveform amp_trailing = 0 #amplitude of first trailing edge in the derivative waveform binsToT1 = 0 binsToT2 = 0 binsTbT = 0 j1_flag = 0 j2_flag = 0 j3_flag = 0 bins_p21 = 0 bins_p22 = 0 dp_t1 = 0 dp_t2 = 0 dp_amp1 = 0 # amplitude of first pulse dp_amp2 = 0 # amplitude of second pulse #first pulse search for i in range(diff_wf_bins - bins_p2 - bins_trailing): #if wf_diff[i]>0: #and wf_diff[i+1]>0: if np.prod([ True if wf_diff[n] > 0.0 else False for n in range(i, i + bins_p1) ]): pulse1 = True i_flag = i break #trailing edge search if pulse1: # firstly move the index out of the positive region for k in range(i_flag + bins_p1, diff_wf_bins - bins_trailing): # if np.prod([ True if wf_diff[n] < 0.0 else False for n in range(k, k + bins_trailing) ]): k_flag = k trailing = True l_flag = k_flag + bins_trailing break dp_t1 = start_time + der_flag * 422.4 / 128 #beginning time of the first pulse #second pulse search if pulse1 and trailing: for j in range(l_flag, (diff_wf_bins - bins_p2)): if np.prod([ True if wf_diff[n] > 0.0 else False for n in range(j, j + bins_p2) ]): pulse2 = True j_flag = j break for q in range( der_flag, der_flag + j_flag * der_step ): # transform the derivative waveform index back to the waveform vector basis dp_amp1 += wf_vect[ q] #calculate amplitude of first pulse #move the index out of the positive region, and do another round of big pulse search. #If the later pulse is bigger than the earlier one, point the index to the bigger one. #Having more than (including) two pulses with ToT of 3 derivetive waveform bins, which is #duration of 3*4*3.3 ns, is quite rare. Therefore, another round of searching should be sufficient enough. if j_flag and j_flag < (diff_wf_bins - bins_p2): for j1 in range(j_flag, (diff_wf_bins - bins_p2)): if wf_diff[j1] < 0: j1_flag = j1 break if j1_flag and j1_flag < (diff_wf_bins - bins_p2): for j2 in range(j1_flag, (diff_wf_bins - bins_p2)): if np.prod([ True if wf_diff[n] > 0.0 else False for n in range(j2, j2 + bins_p2) ]): j2_flag = j2 break #move the index out of the positive region if j2_flag and j2_flag < (diff_wf_bins - bins_p2): j3_flag = 0 for g in range(j2_flag + bins_p2, diff_wf_bins): if wf_diff[g] < 0: j3_flag = g break if j3_flag == 0: j3_flag = diff_wf_bins bins_p21 = j1_flag - j_flag bins_p22 = j3_flag - j2_flag pulse3 = True if bins_p22 > bins_p21: j_flag = j2_flag dp_t2 = start_time + ( der_flag + j_flag * der_step ) * 422.4 / 128 #starting time of second pulse for q in range( der_flag + j_flag * der_step, 128 ): # transform the derivative waveform index back to the waveform vector basis dp_amp2 += wf_vect[ q] #calculate amplitude of second pulse if pulse1 and trailing and pulse2: # calculate the cumulative derivative amplitude for potential first pulse for s in range(i_flag, k_flag): amp_p1 += wf_diff[s] binsToT1 = k_flag - i_flag #move the index out of the first trailing edge region r_flag = 0 for r in range(l_flag, (diff_wf_bins - bins_p2)): if wf_diff[r] > 0: r_flag = r break for q in range(k_flag, r_flag): amp_trailing += wf_diff[q] binsTbT = r_flag - k_flag # move the index out of the second positive region h_flag = 0 for h in range(j_flag + bins_p2, diff_wf_bins): if wf_diff[h] < 0: h_flag = h break if h_flag == 0: h_flag = diff_wf_bins # calculate the cumulative derivative amplitude for second pulse for t in range(j_flag, h_flag): amp_p2 += wf_diff[t] binsToT2 = h_flag - j_flag if wf_qtot > WfQtot and pulse1 and trailing and pulse2 and amp_p1 > Amp1LC and amp_p2 > Amp2LC and amp_trailing < AmpTrailingLC: # if this waveform has double peak feature. if amp_p1 > Amp1SD and amp_p2 > Amp2SD and amp_trailing < AmpTrailingSD and binsToT1 > 1: #if this waveform passes single dom double peak: SDtag = True dp_count += 1 dp_om_keys.append(om) frame["Amp1"].append(amp_p1) frame["Amp2"].append(amp_p2) frame["AmpTrailing"].append(amp_trailing) frame["BinsToT1"].append(binsToT1) frame["BinsTbT"].append(binsTbT) frame["BinsToT2"].append(binsToT2) frame["DPWaveformQTot"].append(wf_qtot) frame["DP_OMs"].append(om) frame["DoublePulseWaveforms"].update( {om: wf_series}) frame["DPWaveformPulse1Amp"].append(dp_amp1) frame["DPWaveformPulse2Amp"].append(dp_amp2) frame["DP_T1"].append(dp_t1) frame["DP_T2"].append(dp_t2) #end if #end for #end for #Finding waveforms that have neighboring DOMs that also see double pulses. If they do, use a lower threshold. for i in dp_om_keys: for j in dp_om_keys: if i[0] == j[0]: if 0 < np.abs(np.int(j[1]) - np.int(i[1])) < 3: LCtag = True break if LCtag: break frame["DPFlagSD"] = icetray.I3Int(SDtag) frame["DPFlagLC"] = icetray.I3Int(LCtag) else: return False #Keeping the double pulse events only if DiscardEvents: if LCtag or SDtag: return True return False
def createEmptyDOMLists(frame, ListNames=[]): print("Making list of DOMs") for name in ListNames: if name in frame: continue frame[name] = dataclasses.I3VectorOMKey()
def createEmptyDOMLists(frame, ListNames=[]): # I like having frame objects in there even if they are empty for some frames for name in ListNames: if name in frame: continue frame[name] = dataclasses.I3VectorOMKey()