def execute(self): print '[INFO] Saving events data to dictionary...' energy_calculator = self.get_store().get(self._energy_key) tod_data = self.get_store().get(self._tod_key) cuts = self.get_store().get(self._cosig_key) peaks = cuts['peaks'] cs = cuts['coincident_signals'] #Initialize and fill empty dictionary events = [] for peak in peaks: all_pixels = pixels_affected_in_event(cs, peak) start = peak[0] end = peak[1] duration = peak[2] number_of_pixels = peak[3] ref_index = int((start + end)/2) energy_per_detector = [] for pid in all_pixels: """ Uncomment this if you are analyzing energy per event, also, change the return statement of energy calculator to return the sum of 4 det """ """ pix_energy = energy_calculator(pid,start,end) energy_per_detector.append(pix_energy) """ e1,e2,e3,e4 = energy_calculator(pid,start,end) energy_dict ={str(pid): [e1,e2,e3,e4]} energy_per_detector.append(energy_dict) """Uncomment this if you are analyzing energy per detector""" #energy = np.sum(energy_per_detector) id = "%d.%d" % (self.get_id(), start) event = { 'id': id, 'start': start, 'end': end, 'duration': duration, 'ctime': tod_data.ctime[ref_index], 'peak': [int(start),int(end),int(duration),int(number_of_pixels)], 'alt': tod_data.alt[ref_index], 'az': tod_data.az[ref_index], 'number_of_pixels': float(number_of_pixels), 'pixels_affected': all_pixels, 'energy': energy_per_detector, } events.append(event) self.get_store().set(self._output_key,events)
def execute(self, store): print '[INFO] Plotting all glitches affecting detector ...' taus = store.get(self._time_constants) for tc in taus: if tc['det_uid'] == self._detuid: tau = tc['tau'] tod_data = store.get(self._tod_key) # retrieve tod_data cuts = store.get(self._cosig_key) # retrieve tod_data array_name = self.get_array() peaks = cuts['peaks'] self._pr = PixelReader() def cs_cuts(): cuts = store.get(self._cosig_key) return cuts['coincident_signals'] timeseries = store.get(self._timeseries_key) def plotter(pid, tau, start_time, end_time): x = timeseries(pid, start_time, end_time)[0] y1 = timeseries(pid, start_time, end_time)[1] y2 = timeseries(pid, start_time, end_time)[2] y3 = timeseries(pid, start_time, end_time)[3] y4 = timeseries(pid, start_time, end_time)[4] plt.title('Pixel affected from ' + str(start_time) + '-' + str(end_time) + ', Pixel ' + str(pid)) plt.xlabel('TOD track:' + str(self._tag) + ' Tau:' + str(tau)) plt.plot(x, y1, '.-', label='90 GHz') plt.plot(x, y2, '.-', label='90 GHz') plt.plot(x, y3, '.-', label='150 GHz') plt.plot(x, y4, '.-', label='150 GHz') plt.legend() plt.show() cs = cuts['coincident_signals'] for peak in peaks: stime = peak[0] etime = peak[1] pixels = pixels_affected_in_event(cs, peak) for pixel in pixels: if pixel == self._detuid: plotter(pixel, tau, stime, etime)
def execute(self): # Retrieve cut data cuts = self.get_store().get(self._input_key) cosig = cuts['coincident_signals'] peaks = cuts['peaks'] events = [] for peak in peaks: event_id = "%d.%d" % (self.get_id(), peak[0]) event = { 'id': event_id, 'start': peak[0], # start index 'end': peak[1], # end index 'duration': peak[2], 'number_of_pixels': peak[3], 'pixels_affected': pixels_affected_in_event(cosig, peak), 'tag': self._tag } events.append(event) print '[INFO] Events generated: %d' % len(events) self.get_store().set(self._output_key, events)
def execute(self): print '[INFO] Saving events data to dictionary...' energy_calculator = self.get_store().get(self._energy_key) tod_data = self.get_store().get(self._tod_key) cuts = self.get_store().get(self._cosig_key) peaks = cuts['peaks'] cs = cuts['coincident_signals'] #Initialize and fill empty dictionary events = [] for peak in peaks: all_pixels = pixels_affected_in_event(cs, peak) start = peak[0] end = peak[1] duration = peak[2] number_of_pixels = peak[3] ref_index = int((start + end)/2) energy_per_detector = [] for pid in all_pixels: pix_energy = energy_calculator(pid,start,end) energy_per_detector.append(pix_energy) energy = np.sum(energy_per_detector) id = "%d.%d" % (self.get_id(), start) event = { 'id': id, 'start': start, 'end': end, 'duration': duration, 'ctime': tod_data.ctime[ref_index], 'alt': tod_data.alt[ref_index], 'az': tod_data.az[ref_index], 'number_of_pixels': float(number_of_pixels), 'pixels_affected': all_pixels, 'energy': energy, } events.append(event) self.get_store().set(self._output_key,events)
def execute(self, store): print '[INFO] Checking for correlation ...' self._pr = PixelReader() #self._pr = PixelReader(season = '2017', array=self.get_context().get_array()) tod_data = store.get(self._tod_key) # retrieve tod_data cuts = store.get(self._cosig_key) # retrieve tod_data peaks = cuts['peaks'] timeseries = store.get(self._timeseries_key) cs = cuts['coincident_signals'] def avg_signal(pixels, start_time, end_time): for pid in pixels: x, y1, y2, y3, y4 = timeseries(pid, start_time, end_time) avg_y1, avg_y2, avg_y3, avg_y4 = np.zeros(len(y1)), np.zeros( len(y2)), np.zeros(len(y3)), np.zeros(len(y4)) avg_x = x avg_y1 += y1 avg_y2 += y2 avg_y3 += y3 avg_y4 += y4 x = avg_x y1 = avg_y1 / len(avg_y1) y2 = avg_y2 / len(avg_y2) y3 = avg_y3 / len(avg_y3) y4 = avg_y4 / len(avg_y4) return x, y1, y2, y3, y4 def correlation(x1, x2, y1, y2): ts1 = y1 ts2 = y2 l1 = len(ts1) l2 = len(ts2) if l1 < l2: n = l1 return max([ np.corrcoef(ts1, ts2[i:n + i])[0][1] for i in range(0, l2 - l1) ]) elif l2 < l1: n = l2 return max([ np.corrcoef(ts1[i:n + i], ts2)[0][1] for i in range(0, l1 - l2) ]) else: return np.corrcoef(ts1, ts2)[0][1] avg_x1, avg_y1 = self._template[0], self._template[1] possible_events = [] highlylikely_events = [] lower_threshold = 0.6 upper_threshold = self._coeff for peak in peaks: all_pixels = pixels_affected_in_event(cs, peak) avg_x2, avg_y2_1, avg_y2_2, avg_y2_3, avg_y2_4 = avg_signal( all_pixels, peak[0], peak[1]) coeff1 = correlation(avg_x1, avg_x2, avg_y1, avg_y2_1) coeff2 = correlation(avg_x1, avg_x2, avg_y1, avg_y2_2) coeff3 = correlation(avg_x1, avg_x2, avg_y1, avg_y2_3) coeff4 = correlation(avg_x1, avg_x2, avg_y1, avg_y2_4) if (lower_threshold <= coeff1) & (lower_threshold <= coeff2) & ( lower_threshold <= coeff3 ) & (lower_threshold <= coeff4) & (coeff1 < upper_threshold) & ( coeff2 < upper_threshold) & (coeff3 < upper_threshold) & ( coeff4 < upper_threshold): possible_events.append(peak) elif (coeff1 >= upper_threshold) & (coeff2 >= upper_threshold) & ( coeff3 >= upper_threshold) & (coeff4 >= upper_threshold): highlylikely_events.append(peak) print highlylikely_events print '[INFO] Events passed: %d / %d' % (len(highlylikely_events), len(peaks)) cuts['peaks'] = highlylikely_events store.set(self._output_key, cuts)
def execute(self, store): print '[INFO] Loading Glitch Data ...' tod_data = store.get(self._tod_key) # retrieve tod_data cuts = store.get(self._cosig_key) # retrieve tod_data array_name = self.get_array() peaks = cuts['peaks'] #print('[INFO] All glitches, unfiltered...') #print('[INFO] peaks: ', peaks) #self._pr = PixelReader(season= '2017', array=self.get_context().get_array()) #for covered self._pr = PixelReader() #for uncovered #self._pr = PixelReader(season='2017',array = str(array_name)) #self._pr = PixelReader(season='2017', array=self.get_context().get_array()) plot = raw_input("Do you want to plot an event? Enter y/n: ") if plot == "y": tod_data = store.get(self._tod_key) # retrieve tod_data cuts = store.get(self._cosig_key) # retrieve tod_data peaks = cuts['peaks'] def cs_cuts(): cuts = store.get(self._cosig_key) return cuts['coincident_signals'] timeseries = store.get(self._timeseries_key) """ PLOTTING FUNCTION Plot all pixels affected given an array of pixel ids and a starting time and ending time """ def plotter(pixels, start_time, end_time): for pid in pixels: x = timeseries(pid, start_time, end_time)[0] y1 = timeseries(pid, start_time, end_time)[1] y2 = timeseries(pid, start_time, end_time)[2] y3 = timeseries(pid, start_time, end_time)[3] y4 = timeseries(pid, start_time, end_time)[4] plt.title('Pixel affected from ' + str(start_time) + '-' + str(end_time) + ', Pixel ' + str(pid)) plt.xlabel('TOD track:' + str(self._tag)) plt.plot(x, y1, '.-', label='90 GHz') plt.plot(x, y2, '.-', label='90 GHz') plt.plot(x, y3, '.-', label='150 GHz') plt.plot(x, y4, '.-', label='150 GHz') plt.legend() plt.show() """ SPECIFIC EVENT To plot specific event, this interface will ask you to supply the event list, make sure you manually convert the last string to a float or integer """ cs = cuts['coincident_signals'] e = raw_input( 'Please copy the event list to plot 4 freq channels:') event = json.loads(e) stime = event[0] etime = event[1] pixels = pixels_affected_in_event(cs, event) plotter(pixels, stime, etime) self._pr.plot(pixels) plt.show() y_n = ' ' while y_n != 'n': y_n = raw_input( "Would you like to plot another event? Enter y/n...") if y_n == 'y': e = raw_input( 'Please copy the event list to plot 4 freq channels:') event = json.loads(e) stime = event[0] etime = event[1] pixels = pixels_affected_in_event(cs, event) print '[INFO] Plotting Glitch...' plotter(pixels, stime, etime) self._pr.plot(pixels) plt.show() else: print 'No plot will be displayed!'
def execute(self): cuts = self.get_store().get(self._cosig_key) peaks = cuts['peaks'] cosig = cuts['coincident_signals'] tod_data = self.get_store().get(self._tod_key) def energyseries(pixel, s_time, e_time, buffer=0): start_time = s_time - buffer end_time = e_time + buffer a1, a2 = self._pr.get_f1(pixel) b1, b2 = self._pr.get_f2(pixel) d1, d2 = tod_data.data[a1], tod_data.data[a2] d3, d4 = tod_data.data[b1], tod_data.data[b2] d1 -= np.mean(d1[start_time:end_time]) d2 -= np.mean(d2[start_time:end_time]) d3 -= np.mean(d3[start_time:end_time]) d4 -= np.mean(d4[start_time:end_time]) time = tod_data.ctime - tod_data.ctime[0] time = time[start_time:end_time] d_1 = d1[start_time:end_time] d_2 = d2[start_time:end_time] d_3 = d3[start_time:end_time] d_4 = d4[start_time:end_time] return time, d_1, d_2, d_3, d_4 def total_energy(pid, start_time, end_time): pix_all_amps = [] pix_all_amps.append( energyseries(pid, start_time, end_time, buffer=0)[1]) pix_all_amps.append( energyseries(pid, start_time, end_time, buffer=0)[2]) pix_all_amps.append( energyseries(pid, start_time, end_time, buffer=0)[3]) pix_all_amps.append( energyseries(pid, start_time, end_time, buffer=0)[4]) Det_pWatts_90_a = [] Det_pWatts_90_b = [] Det_pWatts_150_a = [] Det_pWatts_150_b = [] Det_pJoules_90_a = [] Det_pJoules_90_b = [] Det_pJoules_150_a = [] Det_pJoules_150_b = [] for i in range(0, len(pix_all_amps), 4): ampid_1 = pix_all_amps[i] array_min_1 = np.amin(ampid_1) new_pix_amps_1 = ampid_1 - array_min_1 pWatts_1 = np.sum(new_pix_amps_1) * 10**(12) / (400.) Det_pWatts_90_a.append(pWatts_1) Det_pJoules_90_a.append(pWatts_1 * (end_time - start_time)) ampid_2 = pix_all_amps[i + 1] array_min_2 = np.amin(ampid_2) new_pix_amps_2 = ampid_2 - array_min_2 pWatts_2 = np.sum(new_pix_amps_2) * 10**(12) / (400.) Det_pWatts_90_b.append(pWatts_2) Det_pJoules_90_b.append(pWatts_2 * (end_time - start_time)) ampid_3 = pix_all_amps[i + 2] array_min_3 = np.amin(ampid_3) new_pix_amps_3 = ampid_3 - array_min_3 pWatts_3 = np.sum(new_pix_amps_3) * 10**(12) / (400.) Det_pWatts_150_a.append(pWatts_3) Det_pJoules_150_a.append(pWatts_3 * (end_time - start_time)) ampid_4 = pix_all_amps[i + 3] array_min_4 = np.amin(ampid_4) new_pix_amps_4 = ampid_4 - array_min_4 pWatts_4 = np.sum(new_pix_amps_4) * 10**(12) / (400.) Det_pWatts_150_b.append(pWatts_4) Tot_pW_90a = np.sum(Det_pWatts_90_a) Tot_pW_90b = np.sum(Det_pWatts_90_b) Tot_pW_150a = np.sum(Det_pWatts_150_a) Tot_pW_150b = np.sum(Det_pWatts_150_b) Tot_pJ_90a = np.sum(Det_pJoules_90_a) Tot_pJ_90b = np.sum(Det_pJoules_90_b) Tot_pJ_150a = np.sum(Det_pJoules_150_a) Tot_pJ_150b = np.sum(Det_pJoules_150_b) values = [Tot_pJ_90a, Tot_pJ_90b, Tot_pJ_150a, Tot_pJ_150b] val_sum = np.sum(values) min_value = np.amin(values) max_value = np.amax(values) return val_sum #,values event_list = [] for event in peaks: pixels = pixels_affected_in_event(cosig, event) s_time = event[0] e_time = event[1] event_total_energy = 0 for pixel in pixels: event_total_energy += total_energy( pixel, s_time, e_time ) # * 6.241509 *10**6 # used if you need to convert from pJ to eV self._hist.fill(event_total_energy) event_list.append(event_total_energy) e_min = np.min(event_list) e_max = np.max(event_list) print "Min energy of event:", e_min, 'pJoules. Max energy of event:', e_max, 'pJoules'
def execute(self): print '[INFO] Checking for correlation ...' tod_data = self.get_store().get(self._tod_key) # retrieve tod_data cuts = self.get_store().get(self._cosig_key) # retrieve tod_data peaks = cuts['peaks'] def timeseries(pixel_id, s_time, e_time, buffer=10): start_time = s_time - buffer end_time = e_time + buffer a1, a2 = self._pr.get_f1(pixel_id) b1, b2 = self._pr.get_f2(pixel_id) d1, d2 = tod_data.data[a1], tod_data.data[a2] d3, d4 = tod_data.data[b1], tod_data.data[b2] # try to remove the mean from start_time to end_time d1 -= np.mean(d1[start_time:end_time]) d2 -= np.mean(d2[start_time:end_time]) d3 -= np.mean(d3[start_time:end_time]) d4 -= np.mean(d4[start_time:end_time]) time = tod_data.ctime - tod_data.ctime[0] time = time[start_time:end_time] d_1 = d1[start_time:end_time] d_2 = d2[start_time:end_time] d_3 = d3[start_time:end_time] d_4 = d4[start_time:end_time] return time, d_1, d_2, d_3, d_4 def avg_signal(pixels, start_time, end_time): for pid in pixels: # x = timeseries(pid,start_time,end_time)[0] # y = timeseries(pid,start_time,end_time)[1] x, y1, y2, y3, y4 = timeseries(pid, start_time, end_time) avg_y1, avg_y2, avg_y3, avg_y4 = np.zeros(len(y1)), np.zeros( len(y2)), np.zeros(len(y3)), np.zeros(len(y4)) avg_x = x avg_y1 += y1 avg_y2 += y2 avg_y3 += y3 avg_y4 += y4 x = avg_x y1 = avg_y1 / len(avg_y1) y2 = avg_y2 / len(avg_y2) y3 = avg_y3 / len(avg_y3) y4 = avg_y4 / len(avg_y4) return x, y1, y2, y3, y4 def correlation(x1, x2, y1, y2): """ f1 = interp1d(x1,y1) f2 = interp1d(x2,y2) points = 100 # points = 2*max(len(x1), len(x2)) # double precision x1new = np.linspace(min(x1), max(x1), points) x2new = np.linspace(min(x2), max(x2), points) y1new = f1(x1new) y2new = f2(x2new) """ """ NUMPY CORRELATION ROUTINE """ #m_coeff = np.corrcoef(y1new,y2new)[0][1] """ a = y1new b = y2new a = (a - np.mean(a)) / (np.std(a) * len(a)) b = (b - np.mean(b)) / (np.std(b)) c = np.correlate(a, b, 'full') m_coeff = np.max(abs(c)) return m_coeff """ ts1 = y1 ts2 = y2 l1 = len(ts1) l2 = len(ts2) if l1 < l2: n = l1 return max([ np.corrcoef(ts1, ts2[i:n + i])[0][1] for i in range(0, l2 - l1) ]) elif l2 < l1: n = l2 return max([ np.corrcoef(ts1[i:n + i], ts2)[0][1] for i in range(0, l1 - l2) ]) else: # l1 == l2 return np.corrcoef(ts1, ts2)[0][1] """ plt.subplot(211) plt.plot( x1new,y1new,'g--') plt.title('Two Signals to Check for Correlation') plt.subplot(212) plt.plot(x2new,y2new,'r--') plt.xlabel('Cor. Matrix Coeff: ' + str(m_coeff)) plt.show() """ """ CHECK CORRELATION BETWEEN SIGNALS FROM TWO EVENTS Find avgerage signal from an peak, copy events from peaks data below To check correlation, call correlation function with peak data """ cs = cuts['coincident_signals'] """ FOR TWO SPECIFIC EVENTS """ """ event1 = [133034,133273,239,8] stime1 = event1[0] etime1 = event1[1] pixels1 = pixels_affected_in_event(cs, event1) avg_x1, avg_y1 = avg_signal(pixels1, stime1, etime1) np.savetxt('newslow_template.txt',(avg_x1,avg_y1)) # event2 = [205344, 205375, 31, 35] event2 = [9300,9303,3,2] stime2 = event2[0] etime2 = event2[1] pixels2 = pixels_affected_in_event(cs, event2) avg_x2, avg_y2 = avg_signal(pixels2, stime2, etime2) correlation(avg_x1,avg_x2, avg_y1, avg_y2) """ """ TEMPLATE FRB or CR AS EVENT 1 change name of .txt file to frb_template or cr_template to check correlation for either signal """ avg_x1, avg_y1 = self._template[0], self._template[1] """ ALL EVENTS To compare all events in track to template, initiate this loop """ # Save outputs to a dictionary, here we initialize an empty dictionary events = [] all_coeffs = [] lower_threshold = 0.6 upper_threshold = self._coeff for peak in peaks: all_pixels = pixels_affected_in_event(cs, peak) avg_x2, avg_y2_1, avg_y2_2, avg_y2_3, avg_y2_4 = avg_signal( all_pixels, peak[0], peak[1]) coeff1 = correlation(avg_x1, avg_x2, avg_y1, avg_y2_1) coeff2 = correlation(avg_x1, avg_x2, avg_y1, avg_y2_2) coeff3 = correlation(avg_x1, avg_x2, avg_y1, avg_y2_3) coeff4 = correlation(avg_x1, avg_x2, avg_y1, avg_y2_4) all_coeffs.append(coeff1) if (lower_threshold <= coeff1) & (lower_threshold <= coeff2) & ( lower_threshold <= coeff3 ) & (lower_threshold <= coeff4) & (coeff1 < upper_threshold) & ( coeff2 < upper_threshold) & (coeff3 < upper_threshold) & ( coeff4 < upper_threshold): print '[INFO] Possible %s' % self._tag, peak, 'Coeff = ', coeff1, coeff2, coeff3, coeff4 #all_coeffs.append(coeff) elif (coeff1 >= upper_threshold) & (coeff2 >= upper_threshold) & ( coeff3 >= upper_threshold) & (coeff4 >= upper_threshold): print '[INFO] Highly Likely %s' % self._tag, peak, 'Coeff = ', coeff1, coeff2, coeff3, coeff4 #all_coeffs.append(coeff) start = peak[0] end = peak[1] duration = peak[2] number_of_pixels = peak[3] ref_index = int((start + end) / 2) # use as reference point id = "%d.%d" % (self.get_id(), start) event = { 'id': id, 'start': start, # start index 'end': end, # end index 'duration': duration, 'ctime': tod_data.ctime[ref_index], # ref time 'alt': tod_data.alt[ref_index], # ref alt 'az': tod_data.az[ref_index], # ref az 'number_of_pixels': number_of_pixels, 'pixels_affected': all_pixels, 'coefficients': [coeff1, coeff2, coeff3, coeff4], 'tag': self._tag } events.append(event) print '[INFO] Events passed: %d / %d' % (len(events), len(peaks)) self.get_store().set(self._output_key, events) self.get_store().set(self._all_coeff_output_key, all_coeffs)
def execute(self): print '[INFO] Checking for correlation ...' tod_data = self.get_store().get(self._tod_key) # retrieve tod_data cuts = self.get_store().get(self._cosig_key) # retrieve tod_data peaks = cuts['peaks'] def timeseries(pixel_id, s_time, e_time, buffer=10): start_time = s_time - buffer end_time = e_time + buffer a1, a2 = self._pr.get_f1(pixel_id) b1, b2 = self._pr.get_f2(pixel_id) d1, d2 = tod_data.data[a1], tod_data.data[a2] d3, d4 = tod_data.data[b1], tod_data.data[b2] # try to remove the mean from start_time to end_time d1 -= np.mean(d1[start_time:end_time]) d2 -= np.mean(d2[start_time:end_time]) d3 -= np.mean(d3[start_time:end_time]) d4 -= np.mean(d4[start_time:end_time]) time = tod_data.ctime - tod_data.ctime[0] time = time[start_time:end_time] d_1 = d1[start_time:end_time] d_2 = d2[start_time:end_time] d_3 = d3[start_time:end_time] d_4 = d4[start_time:end_time] return time, d_1 """ TEMPLATE FRB or CR AS EVENT 1 change name of .txt file to frb_template or cr_template to check correlation for either signal """ avg_x1, avg_y1 = self._template[0], self._template[1] temp_time = len(avg_x1) def avg_signal(pixels, start_time, end_time): for pid in pixels: x = timeseries(pid,start_time,end_time)[0] y = timeseries(pid,start_time,end_time)[1] if len(x) < temp_time: buff = int(temp_time - len(x))/2 x, y = timeseries(pid,start_time,end_time,buff) avg_y = np.zeros(len(y)) avg_x = x avg_y += y x1 = avg_x1 y1 = avg_y1 else: buff = int(len(x)-temp_time)/2 pad = [0]*buff x, y = timeseries(pid,start_time,end_time) avg_y = np.zeros(len(y)) avg_x = x avg_y += y x1,y1 =[],[] x1.extend(pad) x1.extend(avg_x1) x1.extend(pad) y1.extend(pad) y1.extend(avg_y1) y1.extend(pad) x2 = avg_x y2 = avg_y/len(avg_y) return x1,y1,x2,y2 def correlation(x1,x2,y1,y2): """ #NORMALIZE THE SIGNAL BEFORE CORRELATING min_y1,max_y1= np.min(y1), np.max(y1) min_y2,max_y2 = np.min(y2), np.max(y2) norm_y1 = (y1 - min_y1)/(max_y1 - min_y1) norm_y2 = (y2 - min_y2)/(max_y2 - min_y2) """ f1 = interp1d(x1,norm_y1) f2 = interp1d(x2,norm_y2) points = 100 # points = 2*max(len(x1), len(x2)) # double precision x1new = np.linspace(min(x1), max(x1), points) x2new = np.linspace(min(x2), max(x2), points) y1new = f1(x1new) y2new = f2(x2new) py1 = pd.DataFrame(y1new) py2 = pd.DataFrame(y2new) cor = pd.rolling_cor(py1,py2,5,center=True) coeff = np.array(cor) coeff = coeff[np.logical_not(np.isnan(coeff))] coeff = abs(coeff) max_coeff = max(coeff) return max_coeff """ plt.subplot(211) plt.plot( x1new,y1new,'g--') plt.title('Two Signals to Check for Correlation') plt.subplot(212) plt.plot(x2new,y2new,'r--') plt.xlabel('Cor. Matrix Coeff: ' + str(m_coeff)) plt.show() """ """ CHECK CORRELATION BETWEEN SIGNALS FROM TWO EVENTS Find avgerage signal from an peak, copy events from peaks data below To check correlation, call correlation function with peak data """ cs = cuts['coincident_signals'] """ FOR TWO SPECIFIC EVENTS """ """ event1 = [101980, 101985, 5, 2] stime1 = event1[0] etime1 = event1[1] pixels1 = pixels_affected_in_event(cs, event1) avg_x1, avg_y1 = avg_signal(pixels1, stime1, etime1) np.savetxt('frb_template.txt',(avg_x1,avg_y1)) # event2 = [205344, 205375, 31, 35] event2 = [9300,9303,3,2] stime2 = event2[0] etime2 = event2[1] pixels2 = pixels_affected_in_event(cs, event2) avg_x2, avg_y2 = avg_signal(pixels2, stime2, etime2) correlation(avg_x1,avg_x2, avg_y1, avg_y2) """ """ ALL EVENTS To compare all events in track to template, initiate this loop """ # Save outputs to a dictionary, here we initialize an empty dictionary events = [] all_coeffs = [] lower_threshold = 0.6 upper_threshold = self._coeff for peak in peaks: all_pixels = pixels_affected_in_event(cs, peak) avg_x1,avg_y1,avg_x2, avg_y2 = avg_signal(all_pixels, peak[0], peak[1]) coeff = correlation(avg_x1, avg_x2, avg_y1, avg_y2) if lower_threshold <= coeff < upper_threshold: print '[INFO] Possible %s' % self._tag, peak, 'Coeff = ', coeff all_coeffs.append(coeff) elif coeff >= upper_threshold: all_coeffs.append(coeff) print '[INFO] Highly Likely %s' % self._tag, peak, 'Coeff = ', coeff start = peak[0] end = peak[1] duration = peak[2] number_of_pixels = peak[3] ref_index = int((start + end)/2) # use as reference point id = "%d.%d" % (self.get_id(), start) event = { 'id': id, 'start': start, # start index 'end': end, # end index 'duration': duration, 'ctime': tod_data.ctime[ref_index], # ref time 'alt': tod_data.alt[ref_index], # ref alt 'az': tod_data.az[ref_index], # ref az 'number_of_pixels': number_of_pixels, 'pixels_affected': all_pixels, 'coefficient': coeff, 'tag': self._tag } events.append(event) print '[INFO] Events passed: %d / %d' % (len(events), len(peaks)) self.get_store().set(self._output_key, events) self.get_store().set(self._all_coeff_output_key,all_coeffs)
def execute(self): print '[INFO] Loading Glitch Data ...' tod_data = self.get_store().get(self._tod_key) # retrieve tod_data cuts = self.get_store().get(self._cosig_key) # retrieve tod_data # print('[INFO] pixels affected: ',pixels) peaks = cuts['peaks'] #print('[INFO] peaks: ', peaks) def cs_cuts(): cuts = self.get_store().get(self._cosig_key) return cuts['coincident_signals'] def timeseries(pixel_id, s_time, e_time, buffer=10): start_time = s_time - buffer end_time = e_time + buffer a1, a2 = self._pr.get_f1(pixel_id) b1, b2 = self._pr.get_f2(pixel_id) d1, d2 = tod_data.data[a1], tod_data.data[a2] d3, d4 = tod_data.data[b1], tod_data.data[b2] # try to remove the mean from start_time to end_time d1 -= np.mean(d1[start_time:end_time]) d2 -= np.mean(d2[start_time:end_time]) d3 -= np.mean(d3[start_time:end_time]) d4 -= np.mean(d4[start_time:end_time]) time = tod_data.ctime - tod_data.ctime[0] time = time[start_time:end_time] d_1 = d1[start_time:end_time] d_2 = d2[start_time:end_time] d_3 = d3[start_time:end_time] d_4 = d4[start_time:end_time] """ UNCOMMENT TO PLOT FOUR CORRESPONDING PIXELS WITH HI-LO FREQ plt.plot(time,d_1, '.-', label=str(a1) + ' 90 GHz') plt.plot(time, d_2, '.-', label=str(a2) + ' 90 GHz') plt.plot(time, d_3, '.-', label=str(b1) + ' 150 GHz') plt.plot(time, d_4, '.-', label=str(b2) + ' 150 GHz') plt.legend(title='Detector UID') plt.show() """ return time, d_1, d_2, d_3, d_4 """ PLOTTING FUNCTION Plot all pixels affected given an array of pixel ids and a starting time and ending time """ def plotter(pixels,start_time,end_time): for pid in pixels: x = timeseries(pid,start_time,end_time)[0] y1 = timeseries(pid,start_time,end_time)[1] y2 = timeseries(pid,start_time,end_time)[2] y3 = timeseries(pid,start_time,end_time)[3] y4 = timeseries(pid,start_time,end_time)[4] plt.title('Pixel affected from ' +str(start_time)+ '-' + str(end_time)+ ', Pixel ' + str(pid)) plt.xlabel('TOD track:' + str(self._tag)) # CHANGE TOD TRACK NAME plt.plot(x,y1,'.-',label='90 GHz') plt.plot(x,y2,'.-',label='90 GHz') plt.plot(x,y3,'.-',label='150 GHz') plt.plot(x,y4,'.-',label='150 GHz') plt.legend() plt.show() """ ALL EVENTS From peaks, find cs, then use cs to find all pixels affected then plot all pixels affected in all events in peak one by one """ cs = cuts['coincident_signals'] """ for event in peaks: all_pixels = pixels_affected_in_event(cs,event) plotter(all_pixels, event[0], event[1]) """ """ SPECIFIC EVENT To plot specific event, copy event from peaks below """ e = raw_input('Please copy the event list to plot 4 freq channels:') event = json.loads(e) stime = event[0] etime = event[1] pixels = pixels_affected_in_event(cs, event) print 'Pixels Affected:', pixels plotter(pixels, stime, etime) self._pr.plot(pixels) plt.show() y_n = ' ' while y_n != 'n': y_n = raw_input ("Would you like to plot another event? Enter y/n...") if y_n == 'y': e= raw_input('Please copy the event list to plot 4 freq channels:') event = json.loads(e) stime = event[0] etime = event[1] pixels = pixels_affected_in_event(cs, event) print '[INFO] Plotting Glitch...' plotter(pixels, stime, etime) self._pr.plot(pixels) plt.show() else: print 'No plot will be displayed!' """