def subband(self, nsub, subdm=None, padval=0): """Reduce the number of channels to 'nsub' by subbanding. The channels within a subband are combined using the DM 'subdm'. 'padval' is passed to the call to 'Spectra.shift_channels'. Inputs: nsub: Number of subbands. Must be a factor of the number of channels. subdm: The DM with which to combine channels within each subband (Default: don't shift channels within each subband) padval: The padding value to use when shifting channels during dedispersion. See documentation of Spectra.shift_channels. (Default: 0) Outputs: None *** Subbanding happens in-place *** """ assert (self.numchans % nsub) == 0 assert (subdm is None) or (subdm >= 0) nchan_per_sub = self.numchans // nsub sub_hifreqs = self.freqs[np.arange(nsub) * nchan_per_sub] sub_lofreqs = self.freqs[(1 + np.arange(nsub)) * nchan_per_sub - 1] sub_ctrfreqs = 0.5 * (sub_hifreqs + sub_lofreqs) if subdm is not None: # Compute delays ref_delays = psr_utils.delay_from_DM(subdm - self.dm, sub_ctrfreqs) delays = psr_utils.delay_from_DM(subdm - self.dm, self.freqs) rel_delays = delays - ref_delays.repeat( nchan_per_sub) # Relative delay rel_bindelays = np.round(rel_delays / self.dt).astype('int') # Shift channels self.shift_channels(rel_bindelays, padval) # Subband self.data = np.array([np.sum(sub, axis=0) for sub in \ np.vsplit(self.data, nsub)]) self.freqs = sub_ctrfreqs self.numchans = nsub
def getDMcurve( M): # return the normalized DM curve downsampled to M points feature = '%s:%s' % ('DMbins', M) if M == 0: return np.array([]) if not feature in self.extracted_feature: ddm = (self.dms.max() - self.dms.min()) / 2. loDM, hiDM = (self.bestdm - ddm, self.bestdm + ddm) loDM = max((0, loDM)) #make sure cut off at 0 DM hiDM = max((ddm, hiDM)) #make sure cut off at 0 DM N = 100 interp = False sumprofs = self.profs.sum(0) if not interp: profs = sumprofs else: profs = np.zeros(np.shape(sumprofs), dtype='d') DMs = psr_utils.span(loDM, hiDM, N) chis = np.zeros(N, dtype='f') subdelays_bins = self.subdelays_bins.copy() for ii, DM in enumerate(DMs): subdelays = psr_utils.delay_from_DM(DM, self.barysubfreqs) hifreqdelay = subdelays[-1] subdelays = subdelays - hifreqdelay delaybins = subdelays * self.binspersec - subdelays_bins if interp: interp_factor = 16 for jj in range(self.nsub): profs[jj] = psr_utils.interp_rotate( sumprofs[jj], delaybins[jj], zoomfact=interp_factor) # Note: Since the interpolation process slightly changes the values of the # profs, we need to re-calculate the average profile value avgprof = (profs / self.proflen).sum() else: new_subdelays_bins = np.floor(delaybins + 0.5) for jj in range(self.nsub): #profs[jj] = psr_utils.rotate(profs[jj], new_subdelays_bins[jj]) delay_bins = int(new_subdelays_bins[jj] % len(profs[jj])) if not delay_bins == 0: profs[jj] = np.concatenate( (profs[jj][delay_bins:], profs[jj][:delay_bins])) subdelays_bins += new_subdelays_bins avgprof = self.avgprof sumprof = profs.sum(0) chis[ii] = self.calc_redchi2(prof=sumprof, avg=avgprof) DMcurve = normalize(downsample(chis, M)) self.extracted_feature[feature] = DMcurve return self.extracted_feature[feature]
def dedisperse(self, dm=0, padval=0): """Shift channels according to the delays predicted by the given DM. Inputs: dm: The DM (in pc/cm^3) to use. padval: The padding value to use when shifting channels during dedispersion. See documentation of Spectra.shift_channels. (Default: 0) Outputs: None *** Dedispersion happens in place *** """ assert dm >= 0 ref_delay = psr_utils.delay_from_DM(dm - self.dm, np.max(self.freqs)) delays = psr_utils.delay_from_DM(dm - self.dm, self.freqs) rel_delays = delays - ref_delay # Relative delay rel_bindelays = np.round(rel_delays / self.dt).astype('int') # Shift channels self.shift_channels(rel_bindelays, padval) self.dm = dm
def plot_chi2_vs_DM(self, loDM, hiDM, N=100, interp=0, device='/xwin'): """ plot_chi2_vs_DM(self, loDM, hiDM, N=100, interp=0, device='/xwin'): Plot (and return) an array showing the reduced-chi^2 versus DM (N DMs spanning loDM-hiDM). Use sinc_interpolation if 'interp' is non-zero. """ # Sum the profiles in time sumprofs = self.profs.sum(0) if not interp: profs = sumprofs else: profs = Num.zeros(Num.shape(sumprofs), dtype='d') DMs = psr_utils.span(loDM, hiDM, N) chis = Num.zeros(N, dtype='f') subdelays_bins = self.subdelays_bins.copy() for ii, DM in enumerate(DMs): subdelays = psr_utils.delay_from_DM(DM, self.barysubfreqs) hifreqdelay = subdelays[-1] subdelays = subdelays - hifreqdelay delaybins = subdelays * self.binspersec - subdelays_bins if interp: interp_factor = 16 for jj in range(self.nsub): profs[jj] = psr_utils.interp_rotate(sumprofs[jj], delaybins[jj], zoomfact=interp_factor) # Note: Since the interpolation process slightly changes the values of the # profs, we need to re-calculate the average profile value avgprof = (profs / self.proflen).sum() else: new_subdelays_bins = Num.floor(delaybins + 0.5) for jj in range(self.nsub): profs[jj] = psr_utils.rotate(profs[jj], int(new_subdelays_bins[jj])) subdelays_bins += new_subdelays_bins avgprof = self.avgprof sumprof = profs.sum(0) chis[ii] = self.calc_redchi2(prof=sumprof, avg=avgprof) # Now plot it Pgplot.plotxy(chis, DMs, labx="DM", laby=r"Reduced-\gx\u2\d", device=device) return (chis, DMs)
def dedisperse(self, DM=None, interp=0, doppler=0): """ dedisperse(DM=self.bestdm, interp=0, doppler=0): Rotate (internally) the profiles so that they are de-dispersed at a dispersion measure of DM. Use FFT-based interpolation if 'interp' is non-zero (NOTE: It is off by default!). Doppler shift subband frequencies if doppler is non-zero. (NOTE: It is also off by default.) """ if DM is None: DM = self.bestdm # Note: Since TEMPO Doppler corrects observing frequencies, for # TOAs, at least, we need to de-disperse using topocentric # observing frequencies. if doppler: freqs = psr_utils.doppler(self.subfreqs, self.avgvoverc) else: freqs = self.subfreqs self.subdelays = psr_utils.delay_from_DM(DM, freqs) self.hifreqdelay = self.subdelays[-1] self.subdelays = self.subdelays - self.hifreqdelay delaybins = self.subdelays * self.binspersec - self.subdelays_bins if interp: new_subdelays_bins = delaybins for ii in range(self.npart): for jj in range(self.nsub): tmp_prof = self.profs[ii, jj, :] self.profs[ii, jj] = psr_utils.fft_rotate( tmp_prof, delaybins[jj]) # Note: Since the rotation process slightly changes the values of the # profs, we need to re-calculate the average profile value self.avgprof = (self.profs / self.proflen).sum() else: new_subdelays_bins = Num.floor(delaybins + 0.5) for ii in range(self.nsub): rotbins = int(new_subdelays_bins[ii]) % self.proflen if rotbins: # i.e. if not zero subdata = self.profs[:, ii, :] self.profs[:, ii] = Num.concatenate( (subdata[:, rotbins:], subdata[:, :rotbins]), 1) self.subdelays_bins += new_subdelays_bins self.sumprof = self.profs.sum(0).sum(0) if Num.fabs((self.sumprof / self.proflen).sum() - self.avgprof) > 1.0: print("self.avgprof is not the correct value!") self.currdm = DM
def get_phasedelays(dm, freqs, period): """Return phase delays corresponding to a particular DM. Inputs: dm: DM (in pc cm-3) freqs: The list of frequencies (in MHz) period: The profiles period (in seconds) Outputs: phasedelays: The corresponding phase delays. """ # Prepare delays timedelays = psr_utils.delay_from_DM(dm, freqs) # Reference all delays to highest frequency channel, which remains # unchanged # TODO: Do we really want to refer to high freq? timedelays -= timedelays[np.argmax(freqs)] phasedelays = timedelays/period return phasedelays
def make_spd_from_file(spdcand, rawdatafile, \ txtfile, maskfile, \ min_rank, group_rank, \ plot, just_waterfall, \ integrate_ts, integrate_spec, disp_pulse, \ loc_pulse, nsub, \ maxnumcands, \ basename, \ mask=False, bandpass_corr=True, barytime=True, \ man_params=None): """ Makes spd files from output files of rratrap. Inputs: spdcand: spcand parameters instance (read in spcand.params) rawdatafile: psrfits file instance txtfile: rratrap output file (groups.txt file) maskfile: rfifind mask file. need this file if you want to remove the bandpass or use rfifind mask information. min_rank: plot all groups with rank more than this. min 1, max 6 group_rank: plot groups ranked whatever you specify plot: do you want to produce the plots as well? just_waterfall: Do you just want to make the waterfall plots. integrate_ts: Do you want to display the dedispersed time series in the plot? integrate_spec: Do you want to display the pulse spectrum in the plot? disp_pulse: Do you want to see the inset dispersed pulse in the plot? loc_pulse: Fraction of the window length where the pulse is located.(eg. 0.25 = 1/4th of the way in. 0.5 = middle of the plot) maxnumcands: What is the maximum number of candidates you would like to generate? basename: output basename of the file. Appended with _DM_TIME(s)_RANK.spd Optional arguments: mask: Do you want to mask out rfi contaminated channels? bandpass_corr: Do you want to remove the bandpass? barytime: Is the given time(s) barycentric? man_params: Do you want to specify the parameters for waterfalling manually? If yes, I suggest using the function make_spd_from_man_params(). (I suggest giving it the rratrap output file) Outputs: Binary npz file containing the necessary arrays and header information to generate the spd plots. """ numcands=0 # counter for max number of candidates loop_must_break = False # dont break the loop unless num of cands >100. files = spio.get_textfile(options.txtfile) if group_rank: groups=[group_rank-1] else: groups = [i for i in range(6) if(i>=min_rank)][::-1] for group in groups: rank = group+1 if files[group] != "Number of rank %i groups: 0 "%rank: values = spio.split_parameters(rank, txtfile) lis = np.where(files == '\tRank: %i.000000'%rank)[0] for ii in range(len(values)): #### Arrays for Plotting DM vs SNR dm_list, time_list, dm_arr, sigma_arr, width_arr = spio.read_RRATrap_info(txtfile, lis[ii], rank) # Array for Plotting Dedispersed waterfall plot - zerodm - OFF spdcand.read_from_file(values[ii], rawdatafile.tsamp, rawdatafile.specinfo.N, \ rawdatafile.frequencies[0], rawdatafile.frequencies[-1], \ rawdatafile, loc_pulse=loc_pulse, dedisp = True, \ scaleindep = None, zerodm = None, mask = mask, \ barytime=barytime, \ nsub = nsub, bandpass_corr = bandpass_corr) #make an array to store header information for the spd files temp_filename = basename+"_DM%.1f_%.1fs_rank_%i"%(spdcand.subdm, \ spdcand.topo_start_time, rank) print_debug("Running waterfaller with Zero-DM OFF...") # Add additional information to the header information array data, Data_dedisp_nozerodm = waterfall_array(rawdatafile, spdcand.start, \ spdcand.duration, spdcand.dm, spdcand.nbins, spdcand.nsub, \ spdcand.subdm, spdcand.zerodm, spdcand.downsamp, \ spdcand.scaleindep, spdcand.width_bins, \ spdcand.mask, maskfile, spdcand.bandpass_corr) text_array = np.array([args[0], rawdatafile.specinfo.telescope, \ rawdatafile.specinfo.ra_str, rawdatafile.specinfo.dec_str, \ rawdatafile.specinfo.start_MJD[0], \ rank, spdcand.nsub, spdcand.nbins, spdcand.subdm, \ spdcand.sigma, spdcand.sample_number, spdcand.duration, \ spdcand.width_bins, spdcand.pulse_width, rawdatafile.tsamp,\ rawdatafile.specinfo.T, spdcand.topo_start_time, data.starttime, \ data.dt,data.numspectra, data.freqs.min(), data.freqs.max()]) #### Array for plotting Dedispersed waterfall plot zerodm - ON print_debug("Running Waterfaller with Zero-DM ON...") zerodm=True data, Data_dedisp_zerodm = waterfall_array(rawdatafile, spdcand.start, \ spdcand.duration, spdcand.dm, spdcand.nbins, spdcand.nsub, \ spdcand.subdm, zerodm, spdcand.downsamp, \ spdcand.scaleindep, spdcand.width_bins, \ spdcand.mask, maskfile, spdcand.bandpass_corr) ####Sweeped without zerodm spdcand.read_from_file(values[ii], rawdatafile.tsamp, rawdatafile.specinfo.N, \ rawdatafile.frequencies[0], rawdatafile.frequencies[-1], \ rawdatafile, loc_pulse=loc_pulse, dedisp = None, \ scaleindep = None, zerodm = None, mask = mask, \ barytime=barytime, \ nsub = nsub, bandpass_corr = bandpass_corr) data, Data_nozerodm = waterfall_array(rawdatafile, spdcand.start, \ spdcand.duration, spdcand.dm, spdcand.nbins, spdcand.nsub, \ spdcand.subdm, spdcand.zerodm, spdcand.downsamp, \ spdcand.scaleindep, spdcand.width_bins, \ spdcand.mask, maskfile, spdcand.bandpass_corr) text_array = np.append(text_array, spdcand.sweep_duration) text_array = np.append(text_array, data.starttime) text_array = np.append(text_array, spdcand.bary_start_time) text_array = np.append(text_array, man_params) # Array to Construct the sweep if spdcand.sweep_dm is not None: ddm = spdcand.sweep_dm-data.dm delays = psr_utils.delay_from_DM(ddm, data.freqs) delays -= delays.min() delays_nozerodm = delays freqs_nozerodm = data.freqs # Sweeped with zerodm-on zerodm = True #downsamp_temp = 1 data, Data_zerodm = waterfall_array(rawdatafile, spdcand.start, \ spdcand.duration, spdcand.dm, spdcand.nbins, spdcand.nsub, \ spdcand.subdm, zerodm, spdcand.downsamp, \ spdcand.scaleindep, spdcand.width_bins, \ spdcand.mask, maskfile, spdcand.bandpass_corr) # Saving the arrays into the .spd file. with open(temp_filename+".spd", 'wb') as f: np.savez_compressed(f, \ Data_dedisp_nozerodm = Data_dedisp_nozerodm.astype(np.float16),\ Data_dedisp_zerodm = Data_dedisp_zerodm.astype(np.float16),\ Data_nozerodm = Data_nozerodm.astype(np.float16),\ delays_nozerodm = delays_nozerodm, \ freqs_nozerodm = freqs_nozerodm,\ Data_zerodm = Data_zerodm.astype(np.float16), \ dm_arr= list(map(np.float16, dm_arr)),\ sigma_arr = list(map(np.float16, sigma_arr)), \ width_arr =list(map(np.uint8, width_arr)),\ dm_list= list(map(np.float16, dm_list)), \ time_list = list(map(np.float16, time_list)), \ text_array = text_array) #### Arrays for Plotting DM vs Time is in plot_spd.plot(...) if plot: print_debug("Now plotting...") plot_spd.plot(temp_filename+".spd", args[1:], \ spec_width=1.5, loc_pulse=loc_pulse, \ xwin=False, outfile=basename, \ just_waterfall=just_waterfall, \ integrate_spec=integrate_spec, \ integrate_ts=integrate_ts, \ disp_pulse=disp_pulse, tar = None) print_debug("Finished plot %i " %ii+strftime("%Y-%m-%d %H:%M:%S")) numcands+= 1 print_debug('Finished sp_candidate : %i'%numcands) if numcands >= maxnumcands: # Max number of candidates to plot 100. loop_must_break = True break if loop_must_break: break print_debug("Finished group %i... "%rank+strftime("%Y-%m-%d %H:%M:%S")) print_debug("Finished running waterfaller... "+strftime("%Y-%m-%d %H:%M:%S"))
def make_spd_from_man_params(spdcand, rawdatafile, \ txtfile, maskfile, \ plot, just_waterfall, \ subdm, dm, sweep_dm, \ sigma, \ start_time, duration, \ width_bins, nbins, downsamp, \ nsub, \ scaleindep, \ spec_width, loc_pulse, \ integrate_ts, integrate_spec, disp_pulse, \ basename, \ mask, bandpass_corr, barytime, man_params): """ Makes spd files from output files of rratrap. Inputs: spdcand: spcand parameters instance (read in spcand.params) rawdatafile: psrfits file instance txtfile: rratrap output file (groups.txt file) maskfile: rfifind mask file. need this file if you want to remove the bandpass or use rfifind mask information. plot: do you want to produce the plots as well? just_waterfall: Do you just want to make the waterfall plots. subdm: DM to use when subbanding. dm: DM to use when dedispersing data for plot. sweep_dm: Show the frequency sweep using this DM. sigma: signal-to-noise of the pulse start_time: start time of the data to be read in for waterfalling. duration: duration of data to be waterfalled. width_bins: Smooth each channel/subband with a boxcar width_bins wide. nbins: Number of time bins to plot. This option overrides the duration argument. downsamp: Factor to downsample in time by. Default: Don't downsample. nsub: Number of subbands to use. Must be a factor of number of channels. scaleindep:Do you want to scale each subband independently?(Type: Boolean) spec_width: Twice this number times the pulse_width around the pulse to consider for the spectrum loc_pulse: Fraction of the window length where the pulse is located.(eg. 0.25 = 1/4th of the way in. 0.5 = middle of the plot) integrate_ts: Do you want to display the dedispersed time series in the plot? integrate_spec: Do you want to display the pulse spectrum in the plot? disp_pulse: Do you want to see the inset dispersed pulse in the plot? basename: output basename of the file. Appended with _DM_TIME(s)_RANK.spd mask: Do you want to mask out rfi contaminated channels? bandpass_corr: Do you want to remove the bandpass? barytime: Is the given time(s) barycentric? man_params: Do you want to specify the parameters for waterfalling manually? If yes, I suggest using the function make_spd_from_man_params(). (I suggest giving it the rratrap output file) Outputs: Binary npz file containing the necessary arrays and header information to generate the spd plots. """ rank = None if not nsub: nsub = rawdatafile.nchan # Array for Plotting Dedispersed waterfall plot - zerodm - OFF spdcand.manual_params(subdm, dm, sweep_dm, sigma, start_time, \ width_bins, downsamp, duration, nbins, nsub, rawdatafile.tsamp, \ rawdatafile.specinfo.N, \ rawdatafile.frequencies[0], rawdatafile.frequencies[-1], rawdatafile, \ loc_pulse=loc_pulse, dedisp=True, scaleindep=False, zerodm=False, \ mask=mask, barytime=barytime, bandpass_corr=bandpass_corr) #make an array to store header information for the spd files temp_filename = basename+"_DM%.1f_%.1fs"%(spdcand.subdm, spdcand.topo_start_time) print_debug("Running waterfaller with Zero-DM OFF...") data, Data_dedisp_nozerodm = waterfall_array(rawdatafile, spdcand.start, \ spdcand.duration, spdcand.dm, spdcand.nbins, spdcand.nsub, \ spdcand.subdm, spdcand.zerodm, spdcand.downsamp, \ spdcand.scaleindep, spdcand.width_bins, \ spdcand.mask, maskfile, spdcand.bandpass_corr) # Add additional information to the header information array text_array = np.array([args[0], rawdatafile.specinfo.telescope, \ rawdatafile.specinfo.ra_str, rawdatafile.specinfo.dec_str, \ rawdatafile.specinfo.start_MJD[0], rank, \ spdcand.nsub, spdcand.nbins, \ spdcand.subdm, spdcand.sigma, spdcand.sample_number, \ spdcand.duration, spdcand.width_bins, spdcand.pulse_width, \ rawdatafile.tsamp, rawdatafile.specinfo.T, spdcand.topo_start_time, \ data.starttime, data.dt,data.numspectra, data.freqs.min(), \ data.freqs.max()]) #### Array for plotting Dedispersed waterfall plot zerodm - ON print_debug("Running Waterfaller with Zero-DM ON...") zerodm=True data, Data_dedisp_zerodm = waterfall_array(rawdatafile, spdcand.start, \ spdcand.duration, spdcand.dm, spdcand.nbins, spdcand.nsub, \ spdcand.subdm, zerodm, spdcand.downsamp, \ spdcand.scaleindep, spdcand.width_bins, \ spdcand.mask, maskfile, spdcand.bandpass_corr) ####Sweeped without zerodm spdcand.manual_params(subdm, dm, sweep_dm, sigma, start_time, \ width_bins, downsamp, duration, nbins, nsub, rawdatafile.tsamp, \ rawdatafile.specinfo.N, \ rawdatafile.frequencies[0], rawdatafile.frequencies[-1], rawdatafile, \ loc_pulse=loc_pulse, dedisp=None, scaleindep=None, zerodm=None, mask=mask, \ barytime=barytime, bandpass_corr=bandpass_corr) data, Data_nozerodm = waterfall_array(rawdatafile, spdcand.start, \ spdcand.duration, spdcand.dm, spdcand.nbins, spdcand.nsub, \ spdcand.subdm, spdcand.zerodm, spdcand.downsamp, \ spdcand.scaleindep, spdcand.width_bins, \ spdcand.mask, maskfile, spdcand.bandpass_corr) text_array = np.append(text_array, spdcand.sweep_duration) text_array = np.append(text_array, data.starttime) text_array = np.append(text_array, spdcand.bary_start_time) text_array = np.append(text_array, man_params) # Array to Construct the sweep if spdcand.sweep_dm is not None: ddm = spdcand.sweep_dm-data.dm delays = psr_utils.delay_from_DM(ddm, data.freqs) delays -= delays.min() delays_nozerodm = delays freqs_nozerodm = data.freqs # Sweeped with zerodm-on zerodm = True #downsamp_temp = 1 data, Data_zerodm = waterfall_array(rawdatafile, spdcand.start, \ spdcand.duration, spdcand.dm, spdcand.nbins, spdcand.nsub, \ spdcand.subdm, zerodm, spdcand.downsamp, \ spdcand.scaleindep, spdcand.width_bins, \ spdcand.mask, maskfile, spdcand.bandpass_corr) with open(temp_filename+".spd", 'wb') as f: np.savez_compressed(f, \ Data_dedisp_nozerodm = Data_dedisp_nozerodm.astype(np.float16),\ Data_dedisp_zerodm = Data_dedisp_zerodm.astype(np.float16),\ Data_nozerodm = Data_nozerodm.astype(np.float16),\ delays_nozerodm = delays_nozerodm, \ freqs_nozerodm = freqs_nozerodm,\ Data_zerodm = Data_zerodm.astype(np.float16), \ text_array = text_array) #### Arrays for Plotting DM vs Time is in plot_spd.plot(...) if plot: print_debug("Now plotting...") plot_spd.plot(temp_filename+".spd", args[1:], \ spec_width=spec_width, loc_pulse=loc_pulse, xwin=False, \ outfile = basename, just_waterfall=just_waterfall, \ integrate_spec=integrate_spec, integrate_ts=integrate_ts, \ disp_pulse=disp_pulse, tar = None)
def inject(infile, outfn, prof, period, dm, nbitsout=None, block_size=BLOCKSIZE, pulsar_only=False, inplace=False): if isinstance(infile, filterbank.FilterbankFile): fil = infile elif inplace: fil = filterbank.FilterbankFile(infile, 'readwrite') else: fil = filterbank.FilterbankFile(infile, 'read') print("Injecting pulsar signal into: %s" % fil.filename) if False: delays = psr_utils.delay_from_DM(dm, fil.frequencies) delays -= delays[np.argmax(fil.frequencies)] get_phases = lambda times: (times-delays)/period % 1 else: get_phases = lambda times: times/period % 1 # Create the output filterbank file if nbitsout is None: nbitsout = fil.nbits if inplace: warnings.warn("Injecting pulsar signal *in-place*") outfil = fil else: # Start an output file print("Creating out file: %s" % outfn) outfil = filterbank.create_filterbank_file(outfn, fil.header, \ nbits=nbitsout, mode='append') if outfil.nbits == 8: raise NotImplementedError("This code is out of date. 'delays' is not " \ "done in this way anymore..") # Read the first second of data to get the global scaling to use onesec = fil.get_timeslice(0, 1).copy() onesec_nspec = onesec.shape[0] times = np.atleast_2d(np.arange(onesec_nspec)*fil.tsamp).T+delays phases = times/period % 1 onesec += prof(phases) minimum = np.min(onesec) median = np.median(onesec) # Set median to 1/3 of dynamic range global_scale = (256.0/3.0) / median del onesec else: # No scaling to be performed # These values will cause scaling to keep data unchanged minimum = 0 global_scale = 1 sys.stdout.write(" %3.0f %%\r" % 0) sys.stdout.flush() oldprogress = -1 # Loop over data lobin = 0 spectra = fil.get_spectra(0, block_size) numread = spectra.shape[0] while numread: if pulsar_only: # Do not write out data from input file # zero it out spectra *= 0 hibin = lobin+numread # Sample at middle of time bin times = (np.arange(lobin, hibin, 1.0/NINTEG_PER_BIN)+0.5/NINTEG_PER_BIN)*fil.dt #times = (np.arange(lobin, hibin)+0.5)*fil.dt phases = get_phases(times) profvals = prof(phases) shape = list(profvals.shape) shape[1:1] = [NINTEG_PER_BIN] shape[0] /= NINTEG_PER_BIN profvals.shape = shape toinject = profvals.mean(axis=1) #toinject = profvals if np.ndim(toinject) > 1: injected = spectra+toinject else: injected = spectra+toinject[:,np.newaxis] scaled = (injected-minimum)*global_scale if inplace: outfil.write_spectra(scaled, lobin) else: outfil.append_spectra(scaled) # Print progress to screen progress = int(100.0*hibin/fil.nspec) if progress > oldprogress: sys.stdout.write(" %3.0f %%\r" % progress) sys.stdout.flush() oldprogress = progress # Prepare for next iteration lobin = hibin spectra = fil.get_spectra(lobin, block_size) numread = spectra.shape[0] sys.stdout.write("Done \n") sys.stdout.flush()
# Combine the profiles as required profs = fold_pfd.combine_profs(numtoas, numsubbands) # PRESTO de-disperses at the high frequency channel so determine a # correction to the middle of the band if not events: subpersumsub = fold_pfd.nsub/numsubbands # Calculate the center of the summed subband freqs and delays sumsubfreqs = (Num.arange(numsubbands)+0.5)*subpersumsub*fold_pfd.subdeltafreq + \ (fold_pfd.lofreq-0.5*fold_pfd.chan_wid) # Note: In the following, we cannot use fold_pfd.hifreqdelay since that # is based on the _barycentric_ high frequency (if the barycentric # conversion was available). For TOAs, we need a topocentric # delay, which is based on the topocentric frequency fold_pfd.hifreq sumsubdelays = (psr_utils.delay_from_DM(fold_pfd.bestdm, sumsubfreqs) - psr_utils.delay_from_DM(fold_pfd.bestdm, fold_pfd.hifreq)) sumsubdelays_phs = Num.fmod(sumsubdelays / p_dedisp, 1.0) # Save the "higest channel within a subband" freqs/delays for use in # later DM/timing correction. PBD 2011/11/03 sumsubfreqs_hi = sumsubfreqs + \ fold_pfd.subdeltafreq/2.0 - fold_pfd.chan_wid/2.0 subdelays2 = psr_utils.delay_from_DM(fold_pfd.bestdm, sumsubfreqs) - \ psr_utils.delay_from_DM(fold_pfd.bestdm, sumsubfreqs_hi) else: fold_pfd.subfreqs = Num.asarray([0.0]) sumsubfreqs = Num.asarray([0.0]) sumsubdelays = Num.asarray([0.0]) subdelays2 = Num.asarray([0.0]) sumsubdelays_phs = Num.asarray([0.0])
def dspsr(fits_file, puls=None, par_file=False, profile_bins=4096, parallel=False, DM=560.5, Downfact=False, SMJD=False, width=0.04194304): #Read puls if isinstance(puls, pd.Series): DM = puls.DM SMJD = puls.SMJD Downfact = puls.Downfact else: if not SMJD: print "Either a valid pulse pandas instance or seconds from beginning of day (SMJD) required. Exiting" return 1 if SMJD > 86400: SMJD = SMJD - 86400 #Deal with observations taken over midnight #Read par_file if not par_file: obs_id = os.path.splitext(os.path.basename(fits_file))[0] par_file = '/dev/shm/{}_ephemeris'.format(obs_id) with open(par_file, 'w') as f: f.write(ephemeris.format(width, DM)) archive_name = os.path.splitext(fits_file)[0] puls_folder = os.path.split(archive_name)[0] if not os.path.isfile(archive_name + '.ar'): readfile = read_fits(fits_file) period = width #readfile['time_resolution'] * profile_bins #Delay between maximum and central frequencies DM_delay = psr_utils.delay_from_DM( DM, readfile['freq_c']) - psr_utils.delay_from_DM( DM, readfile['freq_c'] + readfile['bandwidth'] / 2.) n_puls = int(DM_delay / period) temp_folder = os.path.join('/dev/shm', os.path.basename(archive_name)) def archive_creation(phase_start=0): if os.path.exists(temp_folder): shutil.rmtree(temp_folder) os.makedirs(temp_folder) #Fold the fits file to create single-pulse archives if phase_start: start = period / 2. else: start = 0 with open(os.devnull, 'w') as FNULL: _ = subprocess.call([ 'dspsr', '-S', str(start), '-K', '-b', str(profile_bins), '-s', '-E', par_file, fits_file ], cwd=temp_folder, stdout=FNULL) #Lists of archive names and starting times (s) archive_list = np.array( glob(os.path.join(temp_folder, 'pulse_*.ar'))) archive_time_list = np.array([ psrchive.Archive_load(ar).start_time().get_secs() + psrchive.Archive_load(ar).start_time().get_fracsec() for ar in archive_list ]) idx_sorted = np.argsort(archive_list) archive_list = archive_list[idx_sorted] archive_time_list = archive_time_list[idx_sorted] #Find archive where dispersed pulse would start start_dispersed_puls = SMJD - archive_time_list idx_puls = np.where((start_dispersed_puls > 0) & (start_dispersed_puls < period))[0][0] #Check that puls is centered phase = start_dispersed_puls[idx_puls] / period - start / period idx_puls += n_puls if phase_start > 0.75: idx_puls += 1 return phase, archive_list[idx_puls] phase, archive = archive_creation() if abs(phase - 0.5) > 0.25: phase, archive = archive_creation(phase_start=phase) shutil.copyfile(os.path.join(temp_folder, archive), archive_name + '.ar') shutil.rmtree(temp_folder) if os.path.isfile('/dev/shm/{}_ephemeris'.format(obs_id)): os.remove('/dev/shm/{}_ephemeris'.format(obs_id)) #Clean the archive if not os.path.isfile(archive_name + '.ar.paz'): subprocess.call(['paz', '-e', 'ar.paz', '-r', archive_name + '.ar'], cwd=puls_folder) #Create downsampled archive at the closest factor scrunched in polarisation if Downfact: downfact = int(Downfact) while profile_bins % downfact != 0: downfact -= 1 if not os.path.isfile(archive_name + '.ar.paz.pb' + str(downfact)): subprocess.call([ 'pam', '-e', 'paz.pb' + str(downfact), '-p', '-b', str(downfact), archive_name + '.ar.paz' ], cwd=puls_folder) #Plot the archive psrchive_plots( os.path.join(puls_folder, archive_name + '.ar.paz.pb' + str(downfact))) #Create compressed archive if not os.path.isfile(archive_name + '.ar.paz.Fpb' + str(downfact)): subprocess.call([ 'pam', '-e', 'Fpb' + str(downfact), '-F', archive_name + '.ar.paz.pb' + str(downfact) ], cwd=puls_folder) return
def plot_waterfall(data, start, duration, integrate_ts=False, integrate_spec=False, show_cb=False, cmap_str="gist_yarg", sweep_dms=[], sweep_posns=[], ax_im=None, ax_ts=None, ax_spec=None, interactive=True): """ I want a docstring too! """ # Set up axes if interactive: fig = plt.figure() fig.canvas.set_window_title("Frequency vs. Time") im_width = 0.6 if integrate_spec else 0.8 im_height = 0.6 if integrate_ts else 0.8 if not ax_im: ax_im = plt.axes((0.15, 0.15, im_width, im_height)) if integrate_ts and not ax_ts: ax_ts = plt.axes((0.15, 0.75, im_width, 0.2), sharex=ax_im) if integrate_spec and not ax_spec: ax_spec = plt.axes((0.75, 0.15, 0.2, im_height), sharey=ax_im) # Ploting it up nbinlim = np.int64(duration / data.dt) img = ax_im.imshow(data.data[..., :nbinlim], aspect='auto', cmap=matplotlib.cm.cmap_d[cmap_str], interpolation='nearest', origin='upper', extent=(data.starttime, data.starttime + nbinlim * data.dt, data.freqs.min(), data.freqs.max())) if show_cb: cb = ax_im.get_figure().colorbar(img) cb.set_label("Scaled signal intensity (arbitrary units)") #plt.axis('tight') # Sweeping it up for ii, sweep_dm in enumerate(sweep_dms): ddm = sweep_dm - data.dm delays = psr_utils.delay_from_DM(ddm, data.freqs) delays -= delays.min() if sweep_posns is None: sweep_posn = 0.0 elif len(sweep_posns) == 1: sweep_posn = sweep_posns[0] else: sweep_posn = sweep_posns[ii] sweepstart = data.dt * data.numspectra * sweep_posn + data.starttime sty = SWEEP_STYLES[ii % len(SWEEP_STYLES)] ax_im.plot(delays + sweepstart, data.freqs, sty, lw=4, alpha=0.5) # Dressing it up ax_im.xaxis.get_major_formatter().set_useOffset(False) ax_im.set_xlabel("Time") ax_im.set_ylabel("Observing frequency (MHz)") # Plot Time series if integrate_ts: Data = np.array(data.data[..., :nbinlim]) Dedisp_ts = Data.sum(axis=0) times = (np.arange(data.numspectra) * data.dt + start)[..., :nbinlim] ax_ts.plot(times, Dedisp_ts, "k") ax_ts.set_xlim([times.min(), times.max()]) plt.setp(ax_ts.get_xticklabels(), visible=False) plt.setp(ax_ts.get_yticklabels(), visible=False) # Plot Spectrum if integrate_spec: spectrum_window = 0.05 * duration window_width = int(spectrum_window / data.dt) # bins burst_bin = nbinlim // 2 on_spec = np.array(data.data[..., burst_bin - window_width:burst_bin + window_width]) Dedisp_spec = on_spec.sum(axis=1)[::-1] freqs = np.linspace(data.freqs.min(), data.freqs.max(), len(Dedisp_spec)) ax_spec.plot(Dedisp_spec, freqs, "k") plt.setp(ax_spec.get_xticklabels(), visible=False) plt.setp(ax_spec.get_yticklabels(), visible=False) ax_spec.set_ylim([data.freqs.min(), data.freqs.max()]) if integrate_ts: ax_ts.axvline(times[burst_bin] - spectrum_window, ls="--", c="grey") ax_ts.axvline(times[burst_bin] + spectrum_window, ls="--", c="grey") if interactive: fig.suptitle("Frequency vs. Time") fig.canvas.mpl_connect( 'key_press_event', lambda ev: (ev.key in ('q', 'Q') and plt.close(fig))) plt.show()
def plot_waterfall(data, start, source_name, duration, dm, ofile, integrate_ts=False, integrate_spec=False, show_cb=False, cmap_str="gist_yarg", sweep_dms=[], sweep_posns=[], ax_im=None, ax_ts=None, ax_spec=None, interactive=True, downsamp=1, nsub=None, subdm=None, width=None, snr=None, csv_file=None, prob=None): """ I want a docstring too! """ if source_name is None: source_name = "Unknown" #Output file if ofile is "unknown_cand": title = "%s_" + ofile + "_%.3f_%s" % (source_name, start, str(dm)) else: title = source_name + "_" + ofile # Set up axes fig = plt.figure(figsize=(10, 14)) #fig.canvas.set_window_title("Frequency vs. Time") ''' im_width = 0.6 if integrate_spec else 0.8 im_height = 0.6 if integrate_ts else 0.8 if not ax_im: ax_im = plt.axes((0.15, 0.15, im_width, im_height)) if integrate_ts and not ax_ts: ax_ts = plt.axes((0.15, 0.75, im_width, 0.2),sharex=ax_im) if integrate_spec and not ax_spec: ax_spec = plt.axes((0.75, 0.15, 0.2, im_height),sharey=ax_im) ''' ax_ts = plt.axes((0.1, 0.835, 0.71, 0.145)) ax_im = plt.axes((0.1, 0.59, 0.71, 0.24), sharex=ax_ts) ax_dmvstm = plt.axes((0.1, 0.345, 0.71, 0.24), sharex=ax_ts) ax_spec = plt.axes((0.815, 0.59, 0.16, 0.24), sharey=ax_im) ax_dmsnr = plt.axes((0.815, 0.345, 0.16, 0.24), sharey=ax_dmvstm) ax_orig = plt.axes((0.1, 0.1, 0.71, 0.21)) data.downsample(downsamp) nbinlim = np.int(duration / data.dt) #Get window spectrum_window = 0.02 * duration window_width = int(spectrum_window / data.dt) # bins burst_bin = nbinlim // 2 #Zap all channels which have more than half bins zero (drop packets) zerochan = 1 arrmedian = np.ones(data.numchans) if zerochan: for ii in range(data.numchans): chan = data.get_chan(ii) #if 50% are zero if len(chan) - np.count_nonzero(chan) > 0.5 * len(chan): arrmedian[ii] = 0.0 #arrmedian=np.array(arrmedian) #Additional zapping from off-pulse spectra extrazap = 1 zapthresh = 4 if extrazap: off_spec1 = np.array(data.data[..., 0:burst_bin - window_width]) # off-pulse from left off_spec2 = np.array( data.data[..., burst_bin + window_width:nbinlim]) # off-pulse from right off_spec = (np.mean(off_spec1, axis=1) + np.mean(off_spec2, axis=1)) / 2.0 # Total off-pulse mask = np.zeros(data.data.shape, dtype=bool) masked_val = np.ones(data.data.shape[1], dtype=bool) masked_chan = np.array( np.where(off_spec > zapthresh * np.std(off_spec)))[0] mask[masked_chan] = masked_val masked_chan1 = np.array(np.where(arrmedian == 0))[0] mask[masked_chan1] = masked_val data = data.masked(mask, maskval=0) for i in masked_chan: ax_spec.axhline(data.freqs[i], alpha=0.4, color='grey') for i in masked_chan1: ax_spec.axhline(data.freqs[i], alpha=0.4, color='grey') # DM-vs-time plot dmvstm_array = [] #Old way ''' lodm = int(dm-(dm*0.15)) if lodm < 0: lodm = 0 hidm = int(dm+(dm*0.15)) ''' band = (data.freqs.max() - data.freqs.min()) centFreq = (data.freqs.min() + band / 2.0) / (10**3) # To get it in GHz print(width, centFreq, band) #This comes from Cordes and McLaughlin (2003) Equation 13. FWHM_DM = 506 * float(width) * pow(centFreq, 3) / band #The candidate DM might not be exact so using a longer range FWHM_DM = 3.0 * FWHM_DM lodm = dm - FWHM_DM if lodm < 0: lodm = 0 hidm = 2 * dm # If low DM is zero then range should be 0 to 2*DM else: hidm = dm + FWHM_DM print(FWHM_DM, dm, lodm, hidm) dmstep = (hidm - lodm) / 48.0 datacopy = copy.deepcopy(data) #print lodm,hidm for ii in np.arange(lodm, hidm, dmstep): #for ii in range(400,600,10): #Without this, dispersion delay with smaller DM step does not produce delay close to bin width data.dedisperse(0, padval='rotate') data.dedisperse(ii, padval='rotate') Data = np.array(data.data[..., :nbinlim]) Dedisp_ts = Data.sum(axis=0) dmvstm_array.append(Dedisp_ts) dmvstm_array = np.array(dmvstm_array) #print np.shape(dmvstm_array) #np.save('dmvstm_1step.npz',dmvstm_array) ax_dmvstm.set_xlabel("Time (sec) ") ax_dmvstm.set_ylabel("DM") #ax_dmvstm.imshow(dmvstm_array, aspect='auto', cmap=matplotlib.cm.cmap_d[cmap_str], origin='lower',extent=(data.starttime, data.starttime+ nbinlim*data.dt, lodm, hidm)) ax_dmvstm.imshow(dmvstm_array, aspect='auto', origin='lower', extent=(data.starttime, data.starttime + nbinlim * data.dt, lodm, hidm)) #cmap=matplotlib.cm.cmap_d[cmap_str]) #interpolation='nearest', origin='upper') plt.setp(ax_im.get_xticklabels(), visible=False) plt.setp(ax_ts.get_xticklabels(), visible=False) ax_dmvstm.set_ylim(lodm, hidm) #extent=(data.starttime, data.starttime+ nbinlim*data.dt, 500, 700) #plt.show() #fig2 = plt.figure(2) #plt.imshow(dmvstm_array,aspect='auto') #Plot Freq-vs-time data = copy.deepcopy(datacopy) #data.downsample(downsamp) data.dedisperse(dm, padval='rotate') nbinlim = np.int(duration / data.dt) #orig img = ax_im.imshow(data.data[..., :nbinlim], aspect='auto', \ cmap=matplotlib.cm.cmap_d[cmap_str], \ interpolation='nearest', origin='upper', \ extent=(data.starttime, data.starttime+ nbinlim*data.dt, \ data.freqs.min(), data.freqs.max())) #ax_im.axvline(x=(data.starttime + nbinlim*data.dt)/2.0,ymin=data.freqs.min(),ymax=data.freqs.max(),lw=3,color='b') if show_cb: cb = ax_im.get_figure().colorbar(img) cb.set_label("Scaled signal intensity (arbitrary units)") # Dressing it up ax_im.xaxis.get_major_formatter().set_useOffset(False) #ax_im.set_xlabel("Time") ax_im.set_ylabel("Frequency (MHz)") # Plot Time series #Data = np.array(data.data[..., :nbinlim]) Data = np.array(data.data[..., :nbinlim]) Dedisp_ts = Data.sum(axis=0) times = (np.arange(data.numspectra) * data.dt + start)[..., :nbinlim] ax_ts.plot(times, Dedisp_ts, "k") ax_ts.set_xlim([times.min(), times.max()]) text1 = "DM: " + "%.2f" % float(data.dm) plt.text(1.1, 0.9, text1, fontsize=15, ha='center', va='center', transform=ax_ts.transAxes) text2 = "Width: " + "%.2f" % float(width) plt.text(1.1, 0.75, text2, fontsize=15, ha='center', va='center', transform=ax_ts.transAxes) text3 = "SNR: " + "%.2f" % float(snr) plt.text(1.1, 0.6, text3, fontsize=15, ha='center', va='center', transform=ax_ts.transAxes) ax_ts.set_title(title, fontsize=14) plt.setp(ax_ts.get_xticklabels(), visible=False) plt.setp(ax_ts.get_yticklabels(), visible=False) #Spectrum and DM-vs-SNR plot ax_ts.axvline(times[burst_bin] - spectrum_window, ls="--", c="grey") ax_ts.axvline(times[burst_bin] + spectrum_window, ls="--", c="grey") #Get spectrum and DM-vs-SNR for the on-pulse window on_spec = np.array(data.data[..., burst_bin - window_width:burst_bin + window_width]) on_dmsnr = np.array(dmvstm_array[..., burst_bin - window_width:burst_bin + window_width]) Dedisp_spec = np.mean(on_spec, axis=1) Dedisp_dmsnr = np.mean(on_dmsnr, axis=1) #Get off-pulse and DM-vs-SNR for range outside on-pulse window off_spec1 = np.array(data.data[..., 0:burst_bin - window_width]) # off-pulse from left off_spec2 = np.array( data.data[..., burst_bin + window_width:nbinlim]) # off-pulse from right off_spec = (np.mean(off_spec1, axis=1) + np.mean(off_spec2, axis=1)) / 2.0 # Total off-pulse off_dmsnr1 = np.array(dmvstm_array[..., 0:burst_bin - window_width]) off_dmsnr2 = np.array(dmvstm_array[..., burst_bin + window_width:nbinlim]) off_dmsnr = (np.mean(off_dmsnr1, axis=1) + np.mean(off_dmsnr2, axis=1)) / 2.0 #Get Y-axis for both plots dms = np.linspace(lodm, hidm, len(Dedisp_dmsnr)) freqs = np.linspace(data.freqs.max(), data.freqs.min(), len(Dedisp_spec)) #Spectrum plot ax_spec.plot(Dedisp_spec, freqs, color="red", lw=2) ax_spec.plot(off_spec, freqs, color="blue", alpha=0.5, lw=1) ttest = float(stats.ttest_ind(Dedisp_spec, off_spec)[0].tolist()) ttestprob = float(stats.ttest_ind(Dedisp_spec, off_spec)[1].tolist()) text3 = "t-test" plt.text(1.1, 0.45, text3, fontsize=12, ha='center', va='center', transform=ax_ts.transAxes) text4 = " %.2f" % (ttest) + "(%.2f" % ((1 - ttestprob) * 100) + "%)" plt.text(1.1, 0.3, text4, fontsize=12, ha='center', va='center', transform=ax_ts.transAxes) if prob: text5 = "ML prob: " + "%.2f" % (float(prob)) print(text5) plt.text(1.1, 0.1, text5, fontsize=12, ha='center', va='center', transform=ax_ts.transAxes) #DMvsSNR plot ax_dmsnr.plot(Dedisp_dmsnr, dms, color="red", lw=2) ax_dmsnr.plot(off_dmsnr, dms, color="grey", alpha=0.5, lw=1) Dedisp_dmsnr_split = np.array_split(Dedisp_dmsnr, 5) #Sub-array could be different sizes that's why Dedisp_dmsnr_split[0] = Dedisp_dmsnr_split[0].sum() Dedisp_dmsnr_split[1] = Dedisp_dmsnr_split[1].sum() Dedisp_dmsnr_split[2] = Dedisp_dmsnr_split[2].sum() Dedisp_dmsnr_split[3] = Dedisp_dmsnr_split[3].sum() Dedisp_dmsnr_split[4] = Dedisp_dmsnr_split[4].sum() #Plot settings plt.setp(ax_spec.get_xticklabels(), visible=True) plt.setp(ax_dmsnr.get_xticklabels(), visible=False) plt.setp(ax_spec.get_yticklabels(), visible=False) plt.setp(ax_dmsnr.get_yticklabels(), visible=False) ax_spec.set_ylim([data.freqs.min(), data.freqs.max()]) ax_dmsnr.set_ylim(lodm, hidm) #Plot original data data.dedisperse(0, padval='rotate') ax_im.set_ylabel("Frequency (MHz)") ax_orig.set_ylabel("Frequency (MHz)") ax_orig.set_xlabel("Time (sec)") FTdirection = source_name.split("_")[0] if FTdirection == 'nT': ndata = data.data[..., ::-1] print("Will be flipped in Time") elif FTdirection == 'nF': ndata = data.data[::-1, ...] print("Will be flipped in freq") elif FTdirection == 'nTnF': ndata = data.data[::-1, ::-1] print("Will be flipped in time and freq") else: ndata = data.data print("No flip") # Sweeping it up for ii, sweep_dm in enumerate(sweep_dms): ddm = sweep_dm - data.dm #delays = psr_utils.delay_from_DM(ddm, data.freqs) #delays -= delays.min() if sweep_posns is None: sweep_posn = 0.0 elif len(sweep_posns) == 1: sweep_posn = sweep_posns[0] else: sweep_posn = sweep_posns[ii] sweepstart = data.dt * data.numspectra * sweep_posn + data.starttime #sweepstart = data.dt*data.numspectra + data.starttime sty = "b-" if FTdirection == 'nT': ddm = (-1) * ddm # Negative DM nfreqs = data.freqs elif FTdirection == 'nF': nfreqs = data.freqs[::-1] elif FTdirection == 'nTnF': ddm = (-1) * ddm # Negative DM nfreqs = data.freqs[::-1] else: nfreqs = data.freqs delays = psr_utils.delay_from_DM(ddm, data.freqs) delays -= delays.min() ndelay = (delays + sweepstart) ndelay2 = (delays + sweepstart + duration) ax_orig.set_xlim(data.starttime, data.starttime + len(data.data[0]) * data.dt) ax_orig.set_ylim(data.freqs.min(), data.freqs.max()) ax_orig.plot(ndelay, nfreqs, "b-", lw=2, alpha=0.7) ax_orig.plot(ndelay2, nfreqs, "b-", lw=2, alpha=0.7) #Orig ax_orig.imshow(ndata, aspect='auto', \ cmap=matplotlib.cm.cmap_d[cmap_str], \ interpolation='nearest', origin='upper', \ extent=(data.starttime, data.starttime + len(data.data[0])*data.dt, \ data.freqs.min(), data.freqs.max())) ''' ax_orig.imshow(ndata, aspect='auto', \ cmap=matplotlib.cm.cmap_d[cmap_str], \ interpolation='nearest', origin='lower', \ extent=(data.starttime, data.starttime + len(data.data[0])*data.dt, \ data.freqs.min(), data.freqs.max())) ''' #if interactive: # fig.suptitle("Frequency vs. Time") # fig.canvas.mpl_connect('key_press_event', \ # lambda ev: (ev.key in ('q','Q') and plt.close(fig))) #oname = "%.3f_%s.png" % (start,str(dm)) if ofile is "unknown_cand": ofile = ofile + "_%.3f_%s.png" % (start, str(dm)) ttestTrsh1 = 3 ttestTrsh2 = 1 probTrsh1 = 0.5 probTrsh2 = 0.05 DMleft = Dedisp_dmsnr_split[0] DMcent = Dedisp_dmsnr_split[2] DMright = Dedisp_dmsnr_split[4] prob = 0.0 if prob is None else prob # Set to 0 if None if prob >= probTrsh2: ofile = "A_" + ofile plt.text(1.1, 0.2, "cat: A", fontsize=12, ha='center', va='center', transform=ax_ts.transAxes) elif ttest > ttestTrsh1 and DMcent > DMleft and DMcent > DMright: ofile = "B_" + ofile plt.text(1.1, 0.2, "cat: B", fontsize=12, ha='center', va='center', transform=ax_ts.transAxes) elif ttest > ttestTrsh2 and DMcent > DMleft and DMcent > DMright: plt.text(1.1, 0.2, "cat: C", fontsize=12, ha='center', va='center', transform=ax_ts.transAxes) ofile = "C_" + ofile plt.savefig(ofile) #plt.show() return ofile, ttest, ttestprob
def calc_features_from_pfd(pfd_filepath): pfd_data = prepfold.pfd(str(pfd_filepath)) if pfd_filepath.parent.name == 'positive': label = 1 elif pfd_filepath.parent.name == 'negative': label = 0 else: label = -1 # return (label, 0, 0, 0, 0, 0, 0, 0, 0, 0, # np.empty(shape=(0,)), np.empty(shape=(0,0)), # np.empty(shape=(0,0)), np.empty(shape=(0,))) pfd_data.dedisperse() #### As done in: prepfold.pfd.plot_sumprofs profile = pfd_data.sumprof profile = normalise_1d(profile) #### profiles_sum_axis0 = pfd_data.profs.sum(0) #### As done in: prepfold.pfd.plot_chi2_vs_DM loDM = 0 hiDM = pfd_data.numdms N = pfd_data.numdms profs = profiles_sum_axis0.copy() # = pfd_data.profs.sum(0) DMs = psr_utils.span(loDM, hiDM, N) chis = np.zeros(N, dtype='f') subdelays_bins = pfd_data.subdelays_bins.copy() for ii, DM in enumerate(DMs): subdelays = psr_utils.delay_from_DM(DM, pfd_data.barysubfreqs) hifreqdelay = subdelays[-1] subdelays = subdelays - hifreqdelay delaybins = subdelays * pfd_data.binspersec - subdelays_bins new_subdelays_bins = np.floor(delaybins + 0.5) for jj in range(pfd_data.nsub): profs[jj] = psr_utils.rotate(profs[jj], int(new_subdelays_bins[jj])) subdelays_bins += new_subdelays_bins sumprof = profs.sum(0) chis[ii] = pfd_data.calc_redchi2(prof=sumprof, avg=pfd_data.avgprof) #### # best_dm = pfd_data.bestdm # crop_radius = 100 # best_dm_index = np.searchsorted(DMs, best_dm) # Not accurate, but close. # bloated_chis = np.insert(chis, N, np.full(crop_radius, chis[-1])) # bloated_chis = np.insert(bloated_chis, 0, np.full(crop_radius, chis[0])) # cropped_chis = bloated_chis[ best_dm_index : best_dm_index+2*crop_radius ] # chis = cropped_chis #### As done in: prepfold.pfd.plot_intervals intervals = pfd_data.profs.sum(1) intervals = normalise_2d_rowwise(intervals) #### #### As done in: prepfold.pfd.plot_subbands subbands = profiles_sum_axis0.copy() # = pfd_data.profs.sum(0) subbands = normalise_2d_rowwise(subbands) #### return label, profile, intervals, subbands, chis