def splitPulses(frame): ''' Count number of times a particular station is hit. HLC has two hits on a station and SLC has only one. Form a dictionary with station number and number of time its hit. If the count is 2 or more put that pulse in HLC, if the number of hit is only one then put that pulse in SLC pulse. ''' hlc_pulses = dataclasses.I3RecoPulseSeriesMap() slc_pulses = dataclasses.I3RecoPulseSeriesMap() seededRTpulses = dataclasses.I3RecoPulseSeriesMap.from_frame( frame, 'IT_RT_180m_450ns') stations = {} keepomkeys = [] removeomkeys = [] for omkey, pulse in seededRTpulses: if omkey.string not in stations: stations[omkey.string] = 1 else: stations[omkey.string] += 1 for omkey, pulse in seededRTpulses: if stations[ omkey.string] >= 2: # HLC has hit on two tanks of a station. hlc_pulses[omkey] = pulse else: slc_pulses[omkey] = pulse # SLC has hit on one tank of a station. # Now save them in a container. frame["SeededRTHLCPulses"] = hlc_pulses frame["SeededRTSLCPulses"] = slc_pulses
def combine_pulse(frame): if (HLCPulse in frame) and (SLCPulse in frame): combined_pulse = dataclasses.I3RecoPulseSeriesMap() removedSLCQcut = dataclasses.I3RecoPulseSeriesMap() cleanhlcpulse = dataclasses.I3RecoPulseSeriesMap.from_frame( frame, HLCPulse) offlineslcpulse = frame[SLCPulse] for omkey, pulse in cleanhlcpulse: if omkey not in combined_pulse: combined_pulse[omkey] = pulse else: pulselist = combined_pulse[omkey] for pul in pulse: pulselist.append(pul) #for slcomkey, slcpulse in offlineslcpulse: # if slcomkey not in combined_pulse: # combined_pulse[slcomkey]=slcpulse # else: # pulselistslc = combined_pulse[slcomkey] # for pulslc in slcpulse: # pulselistslc.append(pulslc) #frame['CombinedHLCSLCPulse'] = combined_pulse for slcomkey, slcpulse in offlineslcpulse: for pul in slcpulse: if pul.charge > 0.8: if slcomkey not in combined_pulse: #combined_pulse[slcomkey]=slcpulse combined_pulse[slcomkey] = [pul] else: pulselistslc = combined_pulse[slcomkey] #for pulslc in slcpulse: pulselistslc.append(pul) frame['CombinedHLCSLCPulse'] = combined_pulse
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 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 make_rpsmap(): rpsmap = dataclasses.I3RecoPulseSeriesMap() for omkey in doms: rpsmap[omkey] = dataclasses.I3RecoPulseSeries() # time, width, and charge rp_properties = [(1650, 100, 0), (1850, 100, 1), (0, 100, 2), (550, 0, 3), (800, 0, 4), (3500, 100, 5), (3500, 100, 6), (3500, 100, 7), (3500, 100, 8), (8000, 3000, 9), (9000, 100, 10), (9500, 100, 11)] rp_list = [dataclasses.I3RecoPulse() for i in range(len(rp_properties))] for idx, prop in enumerate(rp_properties): rp_list[idx].time = prop[0] rp_list[idx].width = prop[1] rp_list[idx].charge = prop[2] rpsmap[doms[0]].append(rp_list[0]) rpsmap[doms[0]].append(rp_list[1]) rpsmap[doms[0]].append(rp_list[2]) rpsmap[doms[1]].append(rp_list[3]) rpsmap[doms[2]].append(rp_list[4]) rpsmap[doms[2]].append(rp_list[5]) rpsmap[doms[3]].append(rp_list[6]) rpsmap[doms[3]].append(rp_list[7]) rpsmap[doms[4]].append(rp_list[8]) rpsmap[doms[4]].append(rp_list[9]) rpsmap[doms[4]].append(rp_list[10]) rpsmap[doms[4]].append(rp_list[11]) return rpsmap
def discard_random_doms(self, pulses, discard_probability, *args, **kwargs): """Discard DOMs randomly based on the discard_probability. Parameters ---------- pulses : I3RecoPulseSeriesMap Pulses to modify. discard_probability : float The probabilty a DOM is discarded. Must be a value between 0 and 1. *args Variable length argument list. **kwargs Arbitrary keyword arguments. Returns ------- I3RecoPulseSeriesMap The modified pulses. """ assert discard_probability >= 0 and discard_probability <= 1, \ 'discard_probability {!r} not in [0, 1]'.format(discard_probability) modified_pulses = {} for key, dom_pulses in pulses.items(): # draw random variable and decide if DOM is discarded discard_dom = self._random_generator.uniform() < discard_probability # add DOM if not discard_dom: modified_pulses[key] = \ dataclasses.vector_I3RecoPulse(dom_pulses) return dataclasses.I3RecoPulseSeriesMap(modified_pulses)
def _add_mc_pulses(self, frame, mcpe_series_map): '''Create MC reco pulses from I3MCPESeriesMap This is a dirty hack, so that other modules can be used without changing them. However, this will use up unecessary space, because I3RecoPulses have more data fields, which are not required by an MC hit (width, ATWD, ...) . Parameters ---------- frame : I3Frame The I3Frame to which the MC Pulses will be added to. mcpe_series_map : I3MCPESeriesMap The I3MCPESeriesMap which will be converted. ''' mc_pulse_map = dataclasses.I3RecoPulseSeriesMap() for omkey, mcpe_series in mcpe_series_map.items(): mc_pulses = [] for mcpe in mcpe_series: # create I3RecoPulse with corresponding time and 'charge' # The charge is set to the number of photo electrons (npe) mc_pulse = dataclasses.I3RecoPulse() mc_pulse.time = mcpe.time mc_pulse.charge = mcpe.npe # append pulse mc_pulses.append(mc_pulse) mc_pulse_map[omkey] = dataclasses.vector_I3RecoPulse(mc_pulses) # write to frame frame[self._output_key] = mc_pulse_map
def gaussian_smear_pulse_times(self, pulses, scale, *args, **kwargs): """Smear the pulse times with a Gaussian centered at the original value. Parameters ---------- pulses : I3RecoPulseSeriesMap Pulses to modify. scale : float The scale parameter of the Gaussian that is used to smear the pulse times. *args Variable length argument list. **kwargs Arbitrary keyword arguments. Returns ------- I3RecoPulseSeriesMap The modified pulses. """ assert scale >= 0, 'scale {!r} must be >= zero'.format(scale) modified_pulses = {} for key, dom_pulses in pulses.items(): # smear times times = self._random_generator.normal(loc=[p.time for p in dom_pulses], scale=scale) charges = np.array([p.charge for p in dom_pulses]) widths = np.array([p.width for p in dom_pulses]) flags = np.array([p.flags for p in dom_pulses]) # sort pulses in time sorted_indices = np.argsort(times) charges = charges[sorted_indices] times = times[sorted_indices] widths = widths[sorted_indices] flags = flags[sorted_indices] modified_dom_pulses = [] for charge, time, flag, width in zip(charges, times, flags, widths): # create pulse modified_pulse = dataclasses.I3RecoPulse() modified_pulse.charge = charge modified_pulse.time = time modified_pulse.flags = int(flag) modified_pulse.width = width # append pulse modified_dom_pulses.append(modified_pulse) modified_pulses[key] = dataclasses.vector_I3RecoPulse( fix_time_overlap(modified_dom_pulses)) return dataclasses.I3RecoPulseSeriesMap(modified_pulses)
def I3SuperDSTPacker(frame, Pulses='Pulses', Output='I3SuperDST'): """ Create a compressed representation of the reco pulses, using I3SuperDST. """ if Pulses not in frame: pulses_ = dataclasses.I3RecoPulseSeriesMap() else: pulses_ = dataclasses.I3RecoPulseSeriesMap.from_frame( frame, Pulses) frame[Output] = dataclasses.I3SuperDST(pulses_)
def Physics(self, frame): rpsmap = dataclasses.I3RecoPulseSeriesMap() doms = [icetray.OMKey(0, i) for i in range(4)] for omkey, time in zip(doms, self.times): rp = dataclasses.I3RecoPulse() rp.time = time rps = dataclasses.I3RecoPulseSeries() rps.append(rp) rpsmap[omkey] = rps frame[self.output_map_name] = rpsmap self.PushFrame(frame)
def I3MapKeyVectorDouble_to_I3RecoPulseSeriesMap(f): i3MapKeyVectorDouble = f['splittedDOMMap'] i3RecoPulseSeriesMap = dataclasses.I3RecoPulseSeriesMap() for (k, l) in i3MapKeyVectorDouble.items(): pulses = dataclasses.I3RecoPulseSeries() for d in l: p = dataclasses.I3RecoPulse() p.time = d pulses.append(p) i3RecoPulseSeriesMap[k] = pulses f['splittedDOMMap_pulses'] = i3RecoPulseSeriesMap
def FramePacket(self, frames): mctree = dataclasses.I3MCTree() mask = dataclasses.I3RecoPulseSeriesMapMask( frames[0], self.pulseSourceName, dataclasses.I3RecoPulseSeriesMap()) for frame in frames: if (frame.Stop == icetray.I3Frame.Physics): if (frame["I3EventHeader"].sub_event_stream == self.splitName): smallmctree = dataclasses.I3MCTree() #need to have the time range if (not frame.Has(self.recoMapName + "TimeRange")): time_pulses = [] pulses = dataclasses.I3RecoPulseSeriesMap.from_frame( frame, self.recoMapName) for item in pulses: for pulse in item[1]: time_pulses.append(pulse.time) time_pulses = numpy.array(time_pulses) frame.Put( self.recoMapName + "TimeRange", dataclasses.I3TimeWindow(time_pulses.min(), time_pulses.max())) #now do the composition work tr = frame[self.recoMapName + "TimeRange"] part = frame[self.fitName] primary = deepcopy(frame[self.fitName]) inparticle = deepcopy(frame[self.fitName]) outparticle = deepcopy(frame[self.fitName]) #primary.pos = part.shift_along_track((tr.start-part.time)*part.speed) primary.type = dataclasses.I3Particle.NuMuBar #NuMuBar primary.shape = dataclasses.I3Particle.Primary #InfiniteTrack #ContainedTrack #StoppingTrack #primary.time = tr.start primary.energy = 1 #primary.length = part.speed*(tr.start-tr.stop) mctree.add_primary(primary) smallmctree.add_primary(primary) inparticle.type = dataclasses.I3Particle.MuMinus inparticle.shape = dataclasses.I3Particle.ContainedTrack inparticle.energy = 1 inparticle.length = part.speed * (tr.start - tr.stop) inparticle.time = tr.start #inparticle.pos = part.shift_along_track((tr.start-part.time)*part.speed) mctree.append_child(primary, inparticle) smallmctree.append_child(primary, inparticle) mask = mask | frame[self.recoMapName] frame.Put("smallTree" + self.fitName, smallmctree) frames[0].Put("coll" + self.recoMapName, mask) frames[0].Put("coll" + self.fitName, mctree) for frame in frames: self.PushFrame(frame)
def shift_pulses(self, pulses, charge_shift=None, time_shift=None, first_k_pulses=float('inf'), *args, **kwargs): """Shift the charges and times of the provided pulses. There is an option to ony shift the first k number of pulses by providing a value to first_k_pulses. Parameters ---------- pulses : I3RecoPulseSeriesMap Pulses to modify. charge_shift : float, optional The amount to shift the pulse charges. time_shift : float, optional The amount to shift the pulse times. first_k_pulses : int, optional If specified, only shift the first_k_pulses of a DOM. *args Variable length argument list. **kwargs Arbitrary keyword arguments. Returns ------- I3RecoPulseSeriesMap The modified pulses. """ modified_pulses = {} for key, dom_pulses in pulses.items(): modified_dom_pulses = [] pulse_counter = 0 for pulse in dom_pulses: modified_pulse = dataclasses.I3RecoPulse(pulse) pulse_counter += 1 # modify pulse if pulse_counter <= first_k_pulses: if time_shift is not None: modified_pulse.time += time_shift if charge_shift is not None: modified_pulse.charge = np.clip( modified_pulse.charge + charge_shift, 0., float('inf')) # append pulse modified_dom_pulses.append(modified_pulse) modified_pulses[key] = \ dataclasses.vector_I3RecoPulse(modified_dom_pulses) return dataclasses.I3RecoPulseSeriesMap(modified_pulses)
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 _get_pulses(self, frame): """Get the I3RecoPulseSeriesMap from the frame. Parameters ---------- frame : I3Frame The current I3Frame. """ pulses = frame[self.pulse_key] if isinstance(pulses, dataclasses.I3RecoPulseSeriesMapMask) or \ isinstance(pulses, dataclasses.I3RecoPulseSeriesMapUnion): pulses = pulses.apply(frame) return dataclasses.I3RecoPulseSeriesMap(pulses)
def fixDST(fr, pulseMaskName, newPulseMapName): if pulseMaskName in fr: pulsemap = fr[pulseMaskName].apply(fr) newMap = dataclasses.I3RecoPulseSeriesMap() for (omkey, pulses) in pulsemap: series = dataclasses.I3RecoPulseSeries() for p in pulses: if p.width <= 0.: p.time -= 0.51 * I3Units.ns p.width = 0.5 * I3Units.ns series.append(p) newMap[omkey] = series fr[newPulseMapName] = newMap
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 Physics(self, frame): pulse_map = dataclasses.I3RecoPulseSeriesMap() for string in range(1, n_strings + 1): for om in range(1, n_doms + 1): om_key = icetray.OMKey(string, om) n_hits = np.random.poisson(lam=self.lambda_poisson) times = (np.random.random(n_hits) * self.event_length).round(1) pulse_series = dataclasses.I3RecoPulseSeries() for time in sorted(times): pulse = dataclasses.I3RecoPulse() pulse.time = time pulse.charge = 1.0 pulse_series.append(pulse) pulse_map[om_key] = pulse_series frame["SLOPPOZELA_Pulses"] = pulse_map self.PushFrame(frame)
def setUp(self): super(I3RecoPulseSeriesMapMaskTest2, self).setUp() # create a pulse series map with a known bad # 0 width case. only two pulses. self.pulses = dataclasses.I3RecoPulseSeriesMap() key1 = icetray.OMKey(42, 7) vec = dataclasses.I3RecoPulseSeries() pulse = dataclasses.I3RecoPulse() pulse.time = 10226.6 pulse.charge = 28.1466 pulse.width = 0.833585 vec.append(pulse) pulse.time = 10227.4 pulse.charge = 18.5683 pulse.width = 0.833585 vec.append(pulse) self.pulses[key1] = vec
def Physics(self, frame): """Modifies pulses as specified in modification. Parameters ---------- frame : I3Frame Current i3 frame. """ # get pulses pulses = frame[self._pulse_key] if isinstance(pulses, dataclasses.I3RecoPulseSeriesMapMask) or \ isinstance(pulses, dataclasses.I3RecoPulseSeriesMapUnion): pulses = pulses.apply(frame) # make copy of pulses pulses = copy.copy(dataclasses.I3RecoPulseSeriesMap(pulses)) # get modification function modification_func = getattr(pulse_modification_functions, self._modification) # apply modification to pulses modified_pulses = modification_func( self, pulses, dom_noise_rate_dict=self._dom_noise_rate, frame=frame, **self._modification_settings) # write to frame if self._out_key is None: frame[self._pulse_key + '_mod'] = modified_pulses frame[self._pulse_key + '_modTimeRange'] = dataclasses.I3TimeWindow( frame[self._pulse_key + 'TimeRange']) else: frame[self._out_key] = copy.copy(modified_pulses) if self._pulse_key + 'TimeRange' in frame.keys(): frame[self._out_key + '_modTimeRange'] = dataclasses.I3TimeWindow( frame[self._pulse_key + 'TimeRange']) # push frame self.PushFrame(frame)
def mcpulse_to_recopulse(frame, mapname = "I3MCPulseSeriesMap", outputmap = "I3RecoPulseSeriesMap"): ''' A module that does a direct conversion of I3MCPulses to I3RecoPulses. It is intended to be used with PMTResponseSimulator output when one wants to avoid the DOM simulation for some reason (no DOM electronic simulation. ie no launches but PMT effects such as saturation is present). ''' recopulsemap = dataclasses.I3RecoPulseSeriesMap() mcpulsemap = frame[mapname] for omkey, pulses in mcpulsemap: recopulsemap[omkey] = dataclasses.I3RecoPulseSeries() for pulse in pulses: rpulse = dataclasses.I3RecoPulse() rpulse.time = pulse.time rpulse.charge = pulse.charge rpulse.flags = dataclasses.I3RecoPulse.PulseFlags.LC recopulsemap[omkey].append(rpulse) frame[outputmap] = recopulsemap
def discard_k_highest_charge_doms(self, pulses, k, *args, **kwargs): """Discard the top k DOMs that have the most charge. Parameters ---------- pulses : I3RecoPulseSeriesMap Pulses to modify. k : int The number of DOMs to discard. *args Variable length argument list. **kwargs Arbitrary keyword arguments. Returns ------- I3RecoPulseSeriesMap The modified pulses. """ assert k >= 0, 'k {!r} must be >= zero'.format(k) # calculate total charge for each DOM dom_charges = [] keys = [] for key, dom_pulses in pulses.items(): dom_charge = np.sum([p.charge for p in dom_pulses]) dom_charges.append(dom_charge) keys.append(key) sorted_indices = np.argsort(dom_charges) sorted_keys = [keys[i] for i in sorted_indices] top_k = np.clip(k, 0, len(keys)) modified_pulses = {} for key in sorted_keys[:-top_k]: # add DOM modified_pulses[key] = \ dataclasses.vector_I3RecoPulse(pulses[key]) return dataclasses.I3RecoPulseSeriesMap(modified_pulses)
def Create_PulseSeriesMap(frame): pulsesmap = dc.I3RecoPulseSeriesMap() p1 = dc.I3RecoPulse() p1.charge = 2.3 p1.time = 5.1 p2 = dc.I3RecoPulse() p2.charge = 1.5 p2.time = 9.1 pulsesmap[icetray.OMKey(10, 4)] = dc.I3RecoPulseSeries([p1, p2]) p1 = dc.I3RecoPulse() p1.charge = 4.5 p1.time = 43.1 p2 = dc.I3RecoPulse() p2.charge = 0.9 p2.time = 1.2 pulsesmap[icetray.OMKey(25, 13)] = dc.I3RecoPulseSeries([p1, p2]) frame.Put("TestRecoPulseSeriesMap", pulsesmap)
def Physics(self, frame): pulse_map = dataclasses.I3RecoPulseSeriesMap() for string in range(51, 60): track_time = self.event_length / 9 * (string - 50) for om in range(40, 45): om_key = icetray.OMKey(string, om) n_hits = np.random.poisson(lam=3) times = (np.random.random(n_hits) * 50000 - 25000 + track_time).round(1) pulse_series = dataclasses.I3RecoPulseSeries() for time in sorted(times): pulse = dataclasses.I3RecoPulse() pulse.time = time pulse.charge = 1.0 pulse.flags = 7 pulse_series.append(pulse) pulse_map[om_key] = pulse_series frame["SLOPPORATOR_Pulses"] = pulse_map self.PushFrame(frame)
def scramble_charges(self, pulses, *args, **kwargs): """Scramble the charges of the pulses. Parameters ---------- pulses : I3RecoPulseSeriesMap Pulses to modify. *args Variable length argument list. **kwargs Arbitrary keyword arguments. Returns ------- I3RecoPulseSeriesMap The modified pulses. """ modified_pulses = {} for key, dom_pulses in pulses.items(): charges = [p.charge for p in dom_pulses] # scramble pulse charges self._random_generator.shuffle(charges) modified_dom_pulses = [] for pulse, charge in zip(dom_pulses, charges): modified_pulse = dataclasses.I3RecoPulse(pulse) # modify pulse modified_pulse.charge = charge # append pulse modified_dom_pulses.append(modified_pulse) modified_pulses[key] = \ dataclasses.vector_I3RecoPulse(modified_dom_pulses) return dataclasses.I3RecoPulseSeriesMap(modified_pulses)
def effective_domsim(frame, mapname = "I3MCPulseSeriesMap", outputmap = "I3RecoPulseSeriesMap"): ''' A module similar to mcpulse_to_recopulse above. It does an effective DOM electronics simulation by adding jitter to the time and charge to the pulse while converting the MCPulse to a reco pulse. The values for the spread of the gaussian jitter were found by studying the spread of 1PE extracted pulses. The module is intended to be use with the PMTResponseSimulator output in situations when one wants to avoid the actual DOM simulation for some reason. ''' from icecube.icetray import I3Units recopulsemap = dataclasses.I3RecoPulseSeriesMap() mcpulsemap = frame[mapname] for omkey, pulses in mcpulsemap: recopulsemap[omkey] = dataclasses.I3RecoPulseSeries() for pulse in pulses: rpulse = dataclasses.I3RecoPulse() rpulse.time = random_service.gaus(pulse.time,2.0*I3Units.ns) rpulse.charge = random_service.gaus(pulse.charge,0.012)#PE rpulse.flags = dataclasses.I3RecoPulse.PulseFlags.LC recopulsemap[omkey].append(rpulse) frame[outputmap] = recopulsemap
def FramePacket(self, frames): partvec = dataclasses.I3VectorI3Particle() mask = dataclasses.I3RecoPulseSeriesMapMask( frames[0], self.pulseSourceName, dataclasses.I3RecoPulseSeriesMap()) for frame in frames: if (frame.Stop == icetray.I3Frame.Physics): if (frame["I3EventHeader"].sub_event_stream == self.splitName): primary = deepcopy(frame[self.fitName]) primary.type = dataclasses.I3Particle.MuMinus primary.shape = dataclasses.I3Particle.ContainedTrack primary.length = 500 #part.speed*(tr.start-tr.stop) partvec.append(frame[self.fitName]) mask = mask | frame[self.recoMapName] frame.Put("Primary", primary) frames[0].Put(self.outputPrefix + self.recoMapName, mask) frames[0].Put(self.outputPrefix + self.fitName, partvec) for frame in frames: self.PushFrame(frame)
def Create_PulseSeriesMap(frame): pulsesmap= dc.I3RecoPulseSeriesMap() p1=dc.I3RecoPulse() p1.charge=2.3 p1.time=1.0*icetray.I3Units.ns p1.width=.0*icetray.I3Units.ns p2=dc.I3RecoPulse() p2.charge=1.5 p2.time=2.*icetray.I3Units.ns p2.width=.0*icetray.I3Units.ns pulsesmap[icetray.OMKey(10,4)]= dc.I3RecoPulseSeries([p1,p2]) p1=dc.I3RecoPulse() p1.charge=4.5 p1.time=3.0*icetray.I3Units.ns p1.width=.0*icetray.I3Units.ns p2=dc.I3RecoPulse() p2.charge=0.9 p2.time=802.*icetray.I3Units.ns #will find two pulses (in OMKey(10,4)) that are not in the window of 800 ns p2.width=.0*icetray.I3Units.ns pulsesmap[icetray.OMKey(10,5)]= dc.I3RecoPulseSeries([p1,p2]) frame.Put("TestRecoPulseSeriesMap",pulsesmap)
def Physics(self, frame): source = frame[self.pulses] if type(source) != dataclasses.I3RecoPulseSeriesMap: source = dataclasses.I3RecoPulseSeriesMap.from_frame( frame, self.pulses) vetopulses = dataclasses.I3RecoPulseSeriesMap() for key, pulses in source.iteritems(): if key.string > 86 and key.om <= self.nRows: #key.om starts in 1 if self.omgeomap[key].omtype == 120: #degg if key.pmt == 0: vetopulses[key] = pulses elif self.omgeomap[key].omtype == 130: #mdom if key.pmt < 12: # from 0 to 11 vetopulses[key] = pulses nvetohits = 0 chargevetohits = 0. ndiffmodules_vetohits_set = set() for key, pulses in vetopulses.iteritems(): for pulse in pulses: nvetohits += 1 chargevetohits += pulse.charge ndiffmodules_vetohits_set.add("" + str(key.string) + "," + str(key.om)) ndiffmodules_vetohits = len(ndiffmodules_vetohits_set) ndiffpmts_vetohits = len(vetopulses) #now we write the stuff frame.Put("MyVetoHits_" + str(self.nRows) + "rows_" + self.pulses, vetopulses) i3map = dataclasses.I3MapStringDouble() i3map["nVetoHits"] = nvetohits i3map["chargeVetoHits"] = chargevetohits i3map["nModules_VetoHits"] = ndiffmodules_vetohits i3map["nPMTs_VetoHits"] = ndiffpmts_vetohits frame.Put("InfoMyVetoHits_" + str(self.nRows) + "rows_" + self.pulses, i3map) self.PushFrame(frame)
def test_PulseChargeShifting(self): frame = icetray.I3Frame() omkey = icetray.OMKey(1, 1) # create a calibration object calibration = dataclasses.I3Calibration() calibration.dom_cal[omkey] = dataclasses.I3DOMCalibration() calibration.dom_cal[omkey].mean_atwd_charge = 1.2 calibration.dom_cal[omkey].mean_fadc_charge = 1.8 frame["I3Calibration"] = calibration # create some pulses on our fake DOM pulse1 = dataclasses.I3RecoPulse() pulse1.flags = dataclasses.I3RecoPulse.PulseFlags.ATWD pulse1.time = 1. * I3Units.nanosecond pulse1.charge = 10. pulse1.width = 1. pulse2 = dataclasses.I3RecoPulse() pulse2.flags = dataclasses.I3RecoPulse.PulseFlags.FADC pulse2.time = 10. * I3Units.nanosecond pulse2.charge = 5. pulse2.width = 1. pulse_series = dataclasses.I3RecoPulseSeriesMap() pulse_series[omkey] = dataclasses.I3RecoPulseSeries() pulse_series[omkey].append(pulse1) pulse_series[omkey].append(pulse2) # add these pulses to our new frame frame["UnshiftedPulses"] = pulse_series # create a shifter object frame[ "ShiftedPulses"] = dataclasses.I3RecoPulseSeriesMapApplySPECorrection( pulses_key="UnshiftedPulses", calibration_key="I3Calibration") # retrieve the shifted pulses shifted_pulses = dataclasses.I3RecoPulseSeriesMap.from_frame( frame, "ShiftedPulses") # make sure everything is as expected self.assertEqual(pulse_series[omkey][0].time, shifted_pulses[omkey][0].time, "these should be the same.") self.assertEqual(pulse_series[omkey][0].width, shifted_pulses[omkey][0].width, "these should be the same.") self.assertEqual(pulse_series[omkey][0].flags, shifted_pulses[omkey][0].flags, "these should be the same.") self.assertAlmostEqual(pulse_series[omkey][0].charge / calibration.dom_cal[omkey].mean_atwd_charge, shifted_pulses[omkey][0].charge, places=4, msg="these should be the same.") self.assertEqual(pulse_series[omkey][1].time, shifted_pulses[omkey][1].time, "these should be the same.") self.assertEqual(pulse_series[omkey][1].width, shifted_pulses[omkey][1].width, "these should be the same.") self.assertEqual(pulse_series[omkey][1].flags, shifted_pulses[omkey][1].flags, "these should be the same.") self.assertAlmostEqual(pulse_series[omkey][1].charge / calibration.dom_cal[omkey].mean_fadc_charge, shifted_pulses[omkey][1].charge, places=4, msg="these should be the same.")