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
