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 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 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): 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 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 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 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): 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 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 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 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 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.")
if not fr.Has(wf_name): continue calib = fr['I3Calibration'] status = fr['I3DetectorStatus'] wfmap = fr[wf_name] pulsemap = fr[pulseseries] if pulsemap.__class__ == dataclasses.I3RecoPulseSeriesMapMask: pulsemap = pulsemap.apply(fr) for dom in wfmap.keys(): print(dom) wfs = wfmap[dom] try: pulses = pulsemap[dom] except: pulses = dataclasses.I3RecoPulseSeries() if len(pulses) == 0: continue qtot = numpy.sum([pulse.charge for pulse in pulses]) gp.title('Frame %d, %s - %lf PE, %d pulses' % \ (i, dom, qtot, len(pulses))) spe_charge = dataclasses.spe_mean(status.dom_status[dom], calib.dom_cal[dom]) spe_charge *= calib.dom_cal[dom].front_end_impedance spe_charge *= 1e12 times = numpy.linspace( numpy.min([wf.time for wf in wfs]) - 100, numpy.max([wf.time + wf.bin_width * len(wf.waveform)]), 5000)
def Physics(self, frame): a = 4.823 * 10.0**(-4.0) #ns/m^2 b = 19.41 #ns sigma = 83.5 #m t_cog = frame['ShowerCOG'].time zenith_core = frame['Laputop'].dir.zenith azimuth_core = frame['Laputop'].dir.azimuth unit_core = np.array([ np.sin(zenith_core) * np.cos(azimuth_core), np.sin(zenith_core) * np.sin(azimuth_core), np.cos(zenith_core) ]) output_map = dataclasses.I3RecoPulseSeriesMap() Laputop = frame['Laputop'] x_core = np.array([Laputop.pos.x, Laputop.pos.y, Laputop.pos.z]) t_core = Laputop.time theta = Laputop.dir.theta phi = Laputop.dir.phi n = np.array([ np.sin(theta) * np.cos(phi), np.sin(theta) * np.sin(phi), np.cos(theta) ]) radius = dataclasses.I3MapKeyVectorDouble() radius_old = dataclasses.I3MapKeyVectorDouble() m = dataclasses.I3MapKeyVectorDouble() s = dataclasses.I3MapKeyVectorDouble() chi2 = dataclasses.I3MapKeyVectorDouble() sigma_m = dataclasses.I3MapKeyVectorDouble() sigma_s = dataclasses.I3MapKeyVectorDouble() for i in frame['LaputopHLCVEM'].keys(): output_map[i] = dataclasses.I3RecoPulseSeries() pulse = dataclasses.I3RecoPulse() vec = [] vec_old = [] vec_m = [] vec_s = [] vec_chi2 = [] vec_sigma_m = [] vec_sigma_s = [] for j in frame['LaputopHLCVEM'][i]: pulse.charge = j.charge time = j.time position_dom = frame['I3Geometry'].omgeo[i].position x_dom = np.array( [position_dom.x, position_dom.y, position_dom.z]) Radius = np.dot(x_dom - x_core, x_dom - x_core)**0.5 unit_dom = (x_dom - x_core) / Radius true_radius = np.dot(unit_dom - unit_core, x_dom - x_core) time_signal = time vec.append(true_radius) vec_old.append(Radius) key = str(i) pulse.time = frame['LaputopHLCVEM'][i][0].time vec_m.append(frame['WaveformInfo'][key]['m']) vec_s.append(frame['WaveformInfo'][key]['s']) vec_chi2.append(frame['WaveformInfo'][key]['chi2']) vec_sigma_m.append(frame['WaveformInfo'][key]['sigma_m']) vec_sigma_s.append(frame['WaveformInfo'][key]['sigma_s']) output_map[i].append(pulse) radius[i] = np.array(vec) radius_old[i] = np.array(vec_old) m[i] = np.array(vec_m) s[i] = np.array(vec_s) chi2[i] = np.array(vec_chi2) sigma_m[i] = np.array(vec_sigma_m) sigma_s[i] = np.array(vec_sigma_s) frame['All_radius'] = radius frame['All_radius_old'] = radius_old frame['All_pulses'] = output_map frame['m'] = m frame['s'] = s frame['chi2'] = chi2 frame['sigma_m'] = sigma_m frame['sigma_s'] = sigma_s self.PushFrame(frame)
def RandomWaveforms(fr): calib = fr['I3Calibration'] status = fr['I3DetectorStatus'] pulsemap = dataclasses.I3RecoPulseSeriesMap() wfmap = dataclasses.I3WaveformSeriesMap() for om in calib.dom_cal.keys(): pulses = dataclasses.I3RecoPulseSeries() waveforms = dataclasses.I3WaveformSeries() fadc_templ = calib.dom_cal[om].fadc_pulse_template(False) atwd0_templ = calib.dom_cal[om].atwd_pulse_template(0, False) spe_charge = dataclasses.spe_mean(status.dom_status[om], calib.dom_cal[om]) if spe_charge < I3Units.pC: continue spe_charge *= calib.dom_cal[om].front_end_impedance for launch in range(0, random.randint(0, 4)): npulses = random.randint(0, 5) launchtime = launch * 10000 # Make 30% of SPE launches SLC slc = (npulses == 1 and random.uniform(0, 1) < 0.3) # ATWD Waveform atwd0_wf = dataclasses.I3Waveform() atwd0_wf.waveform = [ \ random.normalvariate(0, 0.3)*I3Units.mV for \ i in range(0, 128)] atwd0_wf.digitizer = dataclasses.I3Waveform.ATWD atwd0_wf.bin_width = 3.3 atwd0_wf.hlc = not slc atwd0_wf.time = launchtime # FADC Waveform if slc: fadc_nbins = 3 else: fadc_nbins = 256 fadc_wf = dataclasses.I3Waveform() fadc_wf.waveform = [ \ random.normalvariate(0, 0.1)*I3Units.mV for \ i in range(0, fadc_nbins)] fadc_wf.digitizer = dataclasses.I3Waveform.FADC fadc_wf.bin_width = 25 fadc_wf.hlc = not slc fadc_wf.time = launchtime for p in range(0, npulses): pulse = dataclasses.I3RecoPulse() pulse.charge = random.randint(1, 3) if not slc: pulse.time = launchtime + \ random.gammavariate(2.5, 80) pulse.flags = pulse.PulseFlags.LC else: pulse.time = launchtime + \ random.uniform(-25, 25) pulses.append(pulse) norm = spe_charge * pulse.charge for i in range(0, len(fadc_wf.waveform)): fadc_wf.waveform[i] += norm * \ fadc_templ((i+1)*fadc_wf.bin_width - \ (pulse.time - launchtime)) for i in range(0, len(atwd0_wf.waveform)): atwd0_wf.waveform[i] += norm * \ atwd0_templ((i+1)*atwd0_wf.bin_width - \ (pulse.time - launchtime)) waveforms.append(fadc_wf) if not slc: waveforms.append(atwd0_wf) wfmap[om] = waveforms pulsemap[om] = dataclasses.I3RecoPulseSeries( sorted(pulses, key=lambda pulse: pulse.time)) fr['RandomPulses'] = pulsemap fr['CalibratedWaveforms'] = wfmap fr['CalibratedWaveformRange'] = dataclasses.I3TimeWindow(0, 10000)