def test_invertFreq(self, filfile): myFil = FilReader(filfile) data = myFil.readBlock(0, 100) outfile = myFil.invertFreq() mynewFil = FilReader(outfile) newdata = mynewFil.readBlock(0, 100) np.testing.assert_equal(mynewFil.header.dtype, myFil.header.dtype) np.testing.assert_equal(mynewFil.header.nsamples, myFil.header.nsamples) np.testing.assert_equal(mynewFil.header.foff, -1 * myFil.header.foff) np.testing.assert_array_equal(data, np.flip(newdata, axis=0)) os.remove(outfile)
def get_spectral_stats(fname, chunksize=10000, show=False): log.info("Getting spectral statistics...") fil = FilReader(fname) header = fil.header nsamples = header['nsamples'] spectrum = 0. spectrsq = 0. for istart in tqdm.tqdm(range(0, nsamples, chunksize)): size = min(chunksize, nsamples - istart) array = fil.readBlock(istart, size, as_filterbankBlock=False) local_spec = array.astype(float).sum(1) local_sq = ((array).astype(float)**2).sum(1) spectrum += local_spec spectrsq += local_sq if show: plt.figure("Spectrum") plt.plot(local_spec, lw=0.5, alpha=0.5, color='k') plt.figure("Var spectrum") plt.plot(np.sqrt(local_sq / size - (local_spec / size)**2), lw=0.5, alpha=0.5, color='k') mean_spec = spectrum / nsamples mean_spectrsq = spectrsq / nsamples std_spec = np.sqrt(mean_spectrsq - mean_spec**2) if show: plt.show() return mean_spec, std_spec
def openfile(filename): files = FilReader(filename) nsamples = files.header['nsamples'] data_arr = files.readBlock(0, nsamples) chans = np.array(range(files.header['nchans'])) bandwidth = files.header['fch1'] - files.header['fbottom'] freqs = files.header['fbottom'] + chans / float( files.header['nchans']) * bandwidth
def plot_sigproc(cand): utc = utc_input.value beam_str = str(int(cand['beam'])).zfill(BeamZfill) fil_path = DataPathTemplate.substitute(BEAM=beam_str, UTC=utc) #fil_path = os.path.join(data_path,".fil") sys.stderr.write("%s\n" % fil_path) fil = FilReader(fil_path) disp = fil.readBlock(int(cand['sample']), 5000) dedisp = disp.dedisperse(cand['dm']) sigproc_source.data = dict(disp=[disp], dedisp=[dedisp], conv=[dedisp])
def get_power(utc, ant): filfile = glob.glob(os.path.join(OBSDIR, utc, ant, "*x.fil"))[0] fil = FilReader(filfile) chans = np.linspace(fil.header.ftop, fil.header.fbottom, fil.header.nchans) block = fil.readBlock(0, fil.header.nsamples) bp = block.mean(axis=1) args = (chans > 1678) & (chans < 1696) power_inband = (bp[args]).sum() return power_inband
def process_candidate(in_queue,out_queue): print "%s Initiated" %os.getpid() while True: candidate = in_queue.get() if len(candidate) == 2: utc = candidate[1] candidate = candidate[0] H_sn , H_w, H_dm = candidate[0],candidate[3],candidate[5] sample_bin, H_t, beam = int(candidate[1]), float(candidate[2]), int(candidate[12]) direc="/data/mopsr/archives/"+utc+"/BEAM_"+str(int(beam)).zfill(3)+"/"+utc+".fil" fil_file=FilReader(direc) dispersion_delay=(31.25*8.3*H_dm)/(0.840)**3 dispersion_delay=np.ceil(dispersion_delay/655.36) w=2**H_w min_afterEvent=300 time_extract=np.max([min_afterEvent,(dispersion_delay+w)*2]) fil_block=fil_file.readBlock(sample_bin-backstep,int(backstep+time_extract))
import numpy as np import scipy as sp import sys from sigpyproc.Readers import FilReader import matplotlib.pyplot as plt if __name__ == "__main__": if (len(sys.argv) < 4): print "USAGE : <.fil file> <Start samp> <Total samp> " print "Plot Filterbank file starting from the Start samples with total samples." sys.exit(0) f = FilReader(sys.argv[1]) f_top = f.header['ftop'] f_bott = f.header['fbottom'] t_rsl = f.header['tsamp'] d = f.readBlock(int(sys.argv[2]), int(sys.argv[3])) freq = np.linspace(f_top, f_bott, len(d)) np.save(sys.argv[1][:-4], d) np.save(sys.argv[1][:-4] + '_freq', freq) plt.pcolormesh(d) plt.colorbar() # plt.imshow(d,aspect='auto') plt.savefig('DM_sweep.png') plt.show()
from scipy import fftpack from sigpyproc.Readers import FilReader import matplotlib.pyplot as plt import numpy as np import sys fil = FilReader(sys.argv[1]) nsamps2read = min(100000, fil.header.nsamples) block = fil.readBlock(0, nsamps2read) ts = np.flipud(block)[700:1800].sum(axis=0) f_s = 1/fil.header.tsamp X = fftpack.fft(ts) freqs = fftpack.fftfreq(len(ts))*f_s plt.figure() plt.imshow(10*np.log10(block), interpolation='nearest', aspect='auto') plt.figure() plt.plot(10*np.log10(block.sum(axis=1)), label="Mean") plt.plot(10*np.log10(block.std(axis=1)), label="STD") plt.legend() plt.figure() plt.plot(np.linspace(0, nsamps2read*fil.header.tsamp, nsamps2read), 10*np.log10(ts)) plt.xlabel("time (seconds)") plt.ylabel("dB") plt.figure() plt.plot(freqs, np.abs(X)/np.max(np.abs(X)))
cand_idx = int(args.f[0]) hd_cands = np.genfromtxt('/home/cbochenek/heimdall.cand', dtype=str) hd_cand = hd_cands[np.where(hd_cands[:, 1].astype(int) == cand_idx)[0][0]] print hd_cand boxcar_filters = np.array([1, 2, 3, 5, 10]) SNR = float(hd_cand[0]) ind = int(hd_cand[1]) cand_time_s = float(hd_cand[2]) cand_sample_width = boxcar_filters[int(hd_cand[3])] cand_DM_trial_n = int(hd_cand[4]) cand_DM = float(hd_cand[5]) cand_members = int(hd_cand[6]) cand_data = hd_cand[7] files = FilReader("%s" % (cand_data)) nsamples = files.header['nsamples'] data_arr = files.readBlock(ind - 400, 800) tsamp = files.header['tsamp'] chans = np.array(range(files.header['nchans'])) bandwidth = files.header['fch1'] - files.header['fbottom'] freqs = files.header['fbottom'] + chans / float( files.header['nchans']) * bandwidth #integrations = np.array(range(nsamples)) #plot the average spectrum if the -s flag is seen if args.s: spec_raw = data_arr.mean(axis=1) spec = process_spec(spec_raw) #print spec.min() plt.figure(0) plt.plot(freqs[:-5], spec[5:], 'k-') #plt.ylim(10.,14.) plt.xlabel('Frequency [MHz]')
boxcar_filters = np.array([1, 2, 3, 5, 10]) SNR = hd_cands[:, 0].astype(float) inds = hd_cands[:, 1].astype(int) cand_time = hd_cands[:, 2].astype(float) cand_sample_width = boxcar_filters[hd_cands[:, 3].astype(int)] cand_DM_trial_n = hd_cands[:, 4].astype(int) cand_DM = hd_cands[:, 5].astype(float) cand_members = hd_cands[:, 6].astype(int) cand_data = hd_cands[:, 7] good_inds = np.where(SNR >= 8.7)[0] with PdfPages("candidates.pdf") as pdf: for ind in good_inds: files = FilReader("%s" % (cand_data[ind])) nsamples = files.header['nsamples'] data_arr = files.readBlock(inds[ind] - 150, 300) tsamp = files.header['tsamp'] chans = np.array(range(files.header['nchans'])) bandwidth = files.header['fch1'] - files.header['fbottom'] freqs = files.header['fbottom'] + chans / float( files.header['nchans']) * bandwidth smooth_bins = int(0.066 / tsamp) plt.figure(ind, figsize=(20, 10)) gs = gridspec.GridSpec(nrows=6, ncols=1) ax0 = plt.subplot(gs[0]) ax1 = plt.subplot(gs[1]) ax2 = plt.subplot(gs[2]) ax3 = plt.subplot(gs[3]) ax4 = plt.subplot(gs[4]) ax5 = plt.subplot(gs[5]) data_arr_good = data_arr[:, 100:200]
def main(): parser = argparse.ArgumentParser(description='Sum filterbank'\ 'files') parser.add_argument('-c', dest='candfile', type=str, help="heimdall's candidate file") parser.add_argument('-f', dest='filfile', type=str, help="filterbank file") parser.add_argument('-s', dest='show', action='store_true', help='iteratively show, rather than save, plots') parser.add_argument('-u', dest='utc', type=str, default="", help='utc name (to append to png name') parser.add_argument( '-n', dest='maxcand', type=int, help='Maximum number of candidates to plot [default: %i]' % (MAXN), default=MAXN) parser.add_argument('-z', '--zap_chans', dest='zap_chans', action='append', nargs=2, type=int, help='channels to zap') args = parser.parse_args() all_candidates = pd.read_table(args.candfile, index_col=False, names=COL_NAMES) # hack to get the sampling time tsamp = (all_candidates.tsec / all_candidates.tsample).mean() box_thresh = int(np.log2(W_THRESH / tsamp)) all_candidates = all_candidates[(all_candidates.SNR > SNR_THRESH) & (all_candidates.boxcar <= box_thresh) & (all_candidates.DM > DM_THRESH)] basedir = os.path.dirname(args.candfile) candsdir = os.path.join(basedir, "candidates") if not args.show: if not os.path.isdir(candsdir): os.mkdir(candsdir) fil = FilReader(args.filfile) nskip = int(0.3 / fil.header.tsamp) print("ncands: %i" % all_candidates.shape[0]) pbar = tqdm(total=all_candidates.shape[0]) if all_candidates.shape[0] > args.maxcand: print ("WARNING: number of candidates (%i) is greater than"\ "the maximum allowed (%i)" %(all_candidates.shape[0], args.maxcand)) if not os.path.exists("cands.warning"): open("cands.warning", 'a').close() icand = 0 for ind, cand in all_candidates.iterrows(): dm_smear_sec = (8.3 * fil.header.bandwidth*1e-3 *\ cand.DM * (fil.header.fcenter*1e-3)**(-3))*1e-3 dm_smear_nsamp = int(dm_smear_sec / fil.header.tsamp) istart = int(cand.tsample) - nskip istart = 0 if istart < 0 else istart block = fil.readBlock(istart, dm_smear_nsamp + 2 * nskip) # zap unwanted channels if args.zap_chans: for low_freq, high_freq in args.zap_chans: block[low_freq:high_freq] = 0. #np.nan disp_org = block.dedisperse(cand.DM) if cand.SNR < 10: ffactor = 32 elif cand.SNR < 15: ffactor = 16 elif cand.SNR < 20: ffactor = 8 else: ffactor = 1 tfactor = min(8, int(2**cand.boxcar)) disp = block_reduce(disp_org, (ffactor, tfactor), func=np.sum, cval=np.mean(disp_org)) matplotlib.use("Agg") fig = plt.figure(0) fig.suptitle("SNR = %.2f, DM = %.2f, boxcar width = %i" % (cand.SNR, cand.DM, cand.boxcar)) gs = gridspec.GridSpec(2, 1) gs.update(hspace=0) ax1 = fig.add_subplot(gs[0]) ax2 = fig.add_subplot(gs[1], sharex=ax1) ts = disp.sum(axis=0) x = np.arange( int(cand.tsample) - nskip, int(cand.tsample) - nskip + len(ts) * tfactor, tfactor) ax1.plot(x * fil.header.tsamp, ts) ax1.get_xaxis().set_visible(False) ylim = ax1.get_ylim() ax1.vlines(np.array([cand.tsample - (2**cand.boxcar/2), cand.tsample + (2**cand.boxcar/2)])*fil.header.tsamp -\ tfactor/2*fil.header.tsamp, ymin=ylim[0], ymax=ylim[1], lw=1, ls='--') if args.zap_chans: for low_freq, high_freq in args.zap_chans: disp_org[low_freq:high_freq] = np.nan disp_org = block_reduce(disp_org, (ffactor, tfactor), func=np.sum, cval=np.mean(disp_org)) ax2.imshow(disp_org, interpolation='nearest', aspect='auto', extent=[ x[0] * fil.header.tsamp, x[-1] * fil.header.tsamp, fil.header.fbottom, fil.header.ftop ]) ax2.set_ylabel("Frequency (MHz)") ax2.set_xlabel("Time since obs_start") if args.show: plt.show() else: basefigname = "tsamp_%i_dm_%.2f.png" % (cand.tsample, cand.DM) if args.utc: basefigname = args.utc + "_" + basefigname figname = os.path.join(candsdir, basefigname) plt.savefig(figname, fmt='png', bbox_inches='tight') plt.close(fig) pbar.update(1) if icand > args.maxcand: sys.exit(-1) icand += 1 pbar.close()
PWR = [10] BASEDIR = "/mnt/buf0/obs" outdir = "/home/sonata/RF_signal_generator/june24/same_RF_freq/" for iutc, utc in enumerate(UTCs): print (utc) for ant in os.listdir(os.path.join(BASEDIR, utc)): if len(ant) != 2: continue print(ant) filx = glob.glob(os.path.join(BASEDIR, utc, ant, "*_x.fil"))[0] fil = FilReader(filx) block = fil.readBlock(0, fil.header.nsamples) N = 200000 fig, ax = plt.subplots(nrows=3, sharex=True, figsize=(13,10)) tsx = 10*np.log10(block[:-1].sum(axis=0)) m = np.median(tsx) up = np.median(tsx[tsx > m]) down = np.median(tsx[tsx < m]) ax[0].plot(np.arange(block.shape[1])*fil.header.tsamp, tsx, label="XX") ax[0].hlines([up,down], 0, (block.shape[1])*fil.header.tsamp, ls="--", label="XX compression: %.1f dB" %(up - down)) ax[0].set_ylabel("dB") ax[1].imshow(10*np.log10(block[:, :N]), interpolation='nearest', aspect='auto',
cands_ind = cands[:, 1] cands_width = cands[:, 3] cands2 = np.genfromtxt("/home/user/cand_times_sync_od/heimdall_2.cand") cands2_snr = cands2[:, 0] cands2_dm = cands2[:, 5] cands2_ind = cands2[:, 1] cands2_width = cands2[:, 3] #ovro_int = 20355632#112793376 #gdscc_int = 103012504 #20355632 #ovro = FilReader("/home/user/coincidences/candidate_%s.fil" %ovro_int) #gdscc = FilReader("/home/user/coincidences/candidate_%s.fil" %gdscc_int) ovro = FilReader("candidate_ovro_200428.fil") gdscc = FilReader("candidate_gdscc_200428.fil") gdscc_arr = gdscc.readBlock(0, gdscc.header['nsamples']) ovro_arr = ovro.readBlock(0, ovro.header['nsamples']) ovro_ind = np.where(cands_ind == ovro_int)[0][0].astype(int) gdscc_ind = np.where(cands2_ind == gdscc_int)[0][0].astype(int) av_window = int(np.min([2**cands2_width[gdscc_ind], 2**cands_width[ovro_ind]])) #av_window = 26 dm = 333.3 #cands_dm[ovro_ind]/2. + cands2_dm[gdscc_ind]/2. gdscc_arr_conv = snd.uniform_filter1d(gdscc_arr, av_window, axis=1) ovro_arr_conv = snd.uniform_filter1d(ovro_arr, av_window, axis=1) fs = np.linspace(1280, 1530, 2048) gdscc_dedisp = dedisperse(gdscc_arr_conv, dm, 0.000065536, fs) ovro_dedisp = dedisperse(ovro_arr_conv, dm, 0.000065536, fs) #low = np.where(gdscc_dedisp.mean(axis=0) == np.max(gdscc_dedisp.mean(axis=0)))[0]-2**cands2_width[gdscc_ind]-128 #high = np.where(gdscc_dedisp.mean(axis=0) == np.max(gdscc_dedisp.mean(axis=0)))[0]+2**cands2_width[gdscc_ind]+128
from sigpyproc.Readers import FilReader listx = [] listy = [] obsdir = "2021*" #for i, filename in enumerate(sys.argv[1:]): for filename in glob.glob(obsdir): #print(filename) filx = FilReader(filename + "/" + "2kB/" + filename + "_x.fil") #print(filename+"/"+"2kB/"+filename+"_x.fil") blockx = filx.readBlock(0, filx.header.nsamples)[1660:1740] fily = FilReader(filename + "/" + "2kB/" + filename + "_y.fil") blocky = fily.readBlock(0, filx.header.nsamples)[1660:1740] xmean = blockx.mean() ymean = blocky.mean() #print(xmean) listx.append(xmean) listy.append(ymean) arrx = np.array(listx) arry = np.array(listy)
from sigpyproc.Readers import FilReader import numpy as np import matplotlib.pyplot as plt f = FilReader('../data/2011-02-20-01:52:19.fil') data = f.readBlock(2 * 1024 * 20, 1024 * 20) d_l = [] fft_l = [] for i in range(10): d_l.append(data[:, i * 2048:(i + 1) * 2048]) d_l = np.array(d_l) for i in range(10): fft = np.fft.fft2(d_l[i]) fft = np.fft.fftshift(fft) / fft.size fft = fft[1:fft.shape[0] / 2 + 1, fft.shape[1] / 2:fft.shape[1] / 2 + fft.shape[0] / 2] fft[-1, :] = 0 fft[:, 0] = 0 fft_l.append(abs(fft)) for i in range(10): plt.pcolormesh(fft_l[i]) plt.colorbar() plt.show()
def search_by_chunks(fname, chunk_length=None, new_sample_time=None, tmin=0, dmmin=200, dmmax=800, surelybad=[]): log.info(f"Opening file {fname}") fname_root = os.path.basename(fname).split('.')[0] mask = get_bad_chans(fname) for bad_chan in surelybad: mask[bad_chan] = True fil = FilReader(fname) header = fil.header nsamples = header['nsamples'] sample_time = header['tsamp'] start_freq = header['fbottom'] stop_freq = header['ftop'] bandwidth = header['bandwidth'] sample_time = header['tsamp'] nchan = header['nchans'] foff = header['foff'] date = header['tstart'] delta = delta_delay(dmmax, start_freq, stop_freq) log.info(f"Expected delay at DM {dmmax} between {start_freq}--{stop_freq} MHz: {delta:2} s") if chunk_length is None: chunk_length = delta step = max(int(chunk_length / sample_time) * 2, 128) # Get the _minimum_ DM broadening to set the automatic rebinning dm_dt = dm_broadening(dmmin, start_freq, np.abs(foff)) if new_sample_time is None: new_sample_time = max(dm_dt / 10, sample_time) log.info(f"Expected broadening in spectral bin at DM {dmmin} at {start_freq} MHz: {dm_dt * 1e6:2} us") sampl_ratio = new_sample_time / sample_time N = 1 if sampl_ratio >= 2: N = int(np.rint(sampl_ratio)) new_sample_time = N * sample_time log.info(f"Data will be resampled to {new_sample_time} s") for istart in tqdm.tqdm(range(0, nsamples, step // 2)): chunk_size = min(step, nsamples - istart) t0 = istart * sample_time if t0 < tmin: continue info = PulseInfo() if chunk_size < step // 2: continue iend = istart + chunk_size array = fil.readBlock(istart, chunk_size, as_filterbankBlock=False) array = renormalize_data(array, badchans_mask=mask) print(not np.any(array[mask, :])) # array = (array - array.min()) / np.std(array) if foff < 0: array = array[::-1] if N > 1: array = quick_resample(array, N) info.allprofs = array info.start_freq = start_freq info.bandwidth = bandwidth info.nbin = array.shape[1] info.nchan = array.shape[0] info.date = date info.pulse_freq = 1 / (info.nbin * new_sample_time) table = fast_dedispersion_search(info.allprofs, dmmin, dmmax, start_freq, bandwidth, new_sample_time) plot_diagnostics(info, outname=f'{fname_root}_{istart}-{iend}.jpg', dmmin=dmmin, dmmax=dmmax, t0=t0, show=True) if np.any(table['snr'] > 6): plot_diagnostics(info, outname=f'{fname_root}_{istart}-{iend}.jpg', dmmin=dmmin, dmmax=dmmax, t0=t0) pickle.dump(info, open(f'{fname_root}_{istart}-{iend}.pkl', 'wb'))
#if cand_now in plot_flag: sample_ID = 81232 DM = 1229.82 BeamID = 2 snr_heim = 9.73 #print row,candidates.shape,len_file filename = 'Dec-1124_arcdrift+23.4-M02_0400.fil' print "File Path:", fil_path + project + date_f + filename f = FilReader(fil_path + project + date_f + '/' + filename) MJD_Start = f.header.tstart t_rsl = f.header.tsamp mjd_burst = sample_ID * t_rsl / 3600 / 24. + MJD_Start data = f.readBlock(sample_ID - 5000, 20000) #print data.dtype,data.shape,data[2000:2100] #d = np.float32(data) #np.save("frbcandidate_DM1229_82.npy",data) #print 'Save Done!' #exit() #data = RFI_clean(data) dedata = data.dedisperse(DM) if snr_heim < 12: fdown = 128 tdown = 40 elif 20 > snr_heim > 12: fdown = 64 tdown = 20
((f_bot**-2 - f_top**-2) * C * DM) / (t_rsl * 1000)) if sample_delay <= 15000: sample_delay = 15000 filterbank_new_dir = "../Data/Pick_Filterbank_Data/" + project + date_f + cand_f.split( '/')[-1][:-5] + '/' # filterbank_new_dir = cand_f[:-5]+"/Pick_Filterbank_Data/" if not os.path.exists(filterbank_new_dir): os.makedirs(filterbank_new_dir) f_new = f.header.prepOutfile(filterbank_new_dir + str(int(row)) + '.fil', nbits=32) if sample_ID + sample_delay < f.header[ 'nsamples'] and sample_ID - 5000 > 0: data = f.readBlock(sample_ID - 5000, 5000 + sample_delay) f_new.write(data) elif sample_ID + sample_delay > f.header[ 'nsamples'] and sample_ID - 5000 > 0 and os.path.exists( fil_path + project + date_f + '/' + filename_next): f_next = FilReader(fil_path + project + date_f + '/' + filename_next) data_stack = f_next.readBlock( 0, sample_delay - (f.header.nsamples - sample_ID)) data = f.readBlock(sample_ID - 5000, f.header['nsamples'] - sample_ID + 5000) f_new.write(data) f_new.write(data_stack) elif sample_ID - 5000 < 0 and os.path.exists( fil_path + project + date_f + '/' + filename_last): data = f.readBlock(0, sample_delay + sample_ID)
tephems = eph_fil[0] / 1e9 #print(tephems) tdiff = tephems - tstart tephemend = eph_fil[5] / 1e9 #print(tephemend) ephem_time = tephemend - tephems #print(ephem_time) ep_end = (filx.header.nsamples * (ephem_time + tdiff)) / obs_time_s ep_st = (filx.header.nsamples * tdiff) / obs_time_s nsmp = ep_end - ep_st blockx = filx.readBlock(int(ep_st), int(nsmp)) bpx = np.array(blockx[1660:1740]) fily = FilReader(glob.glob(filename + "/" + ant + "/*_y.fil")[0]) blocky = fily.readBlock(int(ep_st), int(nsmp)) bpy = np.array(blocky[1660:1740]) step = 60 // 5 #az_list = np.linspace(0, 20, step) n_int = int(math.floor(nsmp / (step)) * (step)) block_x = np.sum(bpx, axis=0) block_y = np.sum(bpy, axis=0)
def main(): parser = argparse.ArgumentParser( description='Raster Scan plot for multiple antennas') # parser.add_argument('in_files', nargs = '+', type=str, # help = 'Input files') parser.add_argument('-d', dest='plot_basedir', type=str, default=PLOT_BASEDIR, required=False, help='Base directory for output plots [default=%s]' % PLOT_BASEDIR) parser.add_argument('-s', '--save_plot', dest='save_plot', action='store_true', help='Save plots rather than display to screen') parser.add_argument('-f', dest='plot_format', type=str, default=FMT, required=False, help='Image format for output plots [default=%s]' % FMT) parser.add_argument( '-n', dest='n_pts', type=float, default=NRANGE, required=False, help='Range of the raster scan (degrees) [default=%i]' % NRANGE) parser.add_argument('-p', dest='step_size', type=float, default=STEP, required=False, help='Step size for each increment [default=%i]' % STEP) args = parser.parse_args() plot_basedir = args.plot_basedir plot_format = args.plot_format n_range = args.n_pts #.astype('int') n_steps = args.step_size #.astype('int') for i, ant in enumerate(ant_list): listx = [] listy = [] for filename in sorted(glob.glob(obsdir)): filx = FilReader(glob.glob(filename + "/" + ant + "/*_x.fil")[0]) blockx = filx.readBlock(0, filx.header.nsamples)[1660:1740] fily = FilReader(glob.glob(filename + "/" + ant + "/*_y.fil")[0]) blocky = fily.readBlock(0, filx.header.nsamples)[1660:1740] xmean = blockx.mean() ymean = blocky.mean() listx.append(xmean) listy.append(ymean) arrx = np.array(listx) arry = np.array(listy) steps = n_steps imgx = arrx.reshape(int(2 * n_range / steps), int(2 * n_range / steps)) imgy = arry.reshape(int(2 * n_range / steps), int(2 * n_range / steps)) az_list = np.arange(-1 * (n_range), n_range, steps) el_list = np.arange(-1 * (n_range), n_range, steps) centers = [ -1 * (n_range), n_range - steps, -1 * (n_range), n_range - steps ] dx, = np.diff(centers[:2]) / (imgx.shape[1] - 1) dy, = -np.diff(centers[2:]) / (imgx.shape[0] - 1) extent = [ centers[0] - dx / 2, centers[1] + dx / 2, centers[2] + dy / 2, centers[3] - dy / 2 ] plt.figure(i * 2, figsize=[12, 8]) plt.imshow(10 * np.log10(imgx.T), interpolation='none', extent=[ -1 * (n_range), n_range - steps, -1 * (n_range), n_range - steps ], origin='lower') plt.xticks(np.arange(centers[0], centers[1] + dx, dx)) plt.yticks(np.arange(centers[3], centers[2] + dy, dy)) plt.axhline(y=0, color='red', linestyle='-') plt.axvline(x=0, color='red', linestyle='-') plt.ylabel("Elevation (deg)") plt.xlabel("Azimuth (deg)") plt.title("Antenna " + str(ant) + " X-Polarization") plt.colorbar() plt.figure(i * 2 + 1, figsize=[12, 8]) plt.imshow(10 * np.log10(imgy.T), interpolation='none', extent=[ -1 * (n_range), n_range - steps, -1 * (n_range), n_range - steps ], origin='lower') plt.title("Antenna " + str(ant) + " Y-Polarization") plt.xticks(np.arange(centers[0], centers[1] + dx, dx)) plt.yticks(np.arange(centers[3], centers[2] + dy, dy)) plt.axhline(y=0, color='red', linestyle='-') plt.axvline(x=0, color='red', linestyle='-') plt.ylabel("Elevation (deg)") plt.xlabel("Azimuth (deg)") plt.colorbar() print("Done with ant: %s" % ant) if args.save_plot: pname = os.path.splitext(ant) + '.' + args.plot_format #plot_name #pname = os.path.join(plot_basedir, pname) plt.savefig(pname, format=plot_format, bbox_inches='tight') if not args.save_plot: plt.show()
(opts.spectrum and opts.timeseries) or\ (opts.dynamic and opts.block) or\ (opts.dynamic and opts.bandpass) or\ (opts.dynamic and opts.timeseries) or\ (opts.block and opts.bandpass) or\ (opts.block and opts.timeseries): print "Only one option allowed." sys.exit(0) print "File %s has %d channels and %d samples/spectra." % (filterbankFilename, numberChannels, numberSpectra) if opts.spectrum: spectrum = opts.spectrum if (spectrum >= numberSpectra): spectrum = numberSpectra-1 print "Selected spectrum exceeds available number of spectra!" singleSpectrum = filterbankFile.readBlock(spectrum, 1) # read specific spectrum from the data plt.plot(singleSpectrum) plt.xlabel("Channel") plt.ylabel("Intensity (a.u.)") if not opts.savePlot: plt.show() else: baseFilterbankFilename, extFilterbankFilename = os.path.splitext(filterbankFilename) plt.savefig(baseFilterbankFilename + "_spectrum_" + str(spectrum) + ".png") sys.exit(0) elif opts.block: block = opts.block.split() block = np.arange(int(block[0]), int(block[1])) #print block[0], block[-1] if (block[-1] >= numberSpectra): block[-1] = numberSpectra-1