def bary_to_topo(infofilenm, rawdatafile=False, ephem="DE200"):
"""
bary_to_topo(infofilenm, ephem="DE200"):
Returns the barycentric and topocentric times evert 10 seconds.
The data for the observation must be found in the info file.
"""
if infofilenm[-4:] == ".inf":
infofilenm = infofilenm[:-4]
filetype = 'inf'
elif infofilenm[-5:] == ".fits":
infofilenm = infofilenm
filetype = 'PSRFITS'
else:
raise ValueError("file type not recognized. Must be .inf, or .fits")
if filetype == "inf":
obs = read_inffile(infofilenm)
T = obs.N * obs.dt
dt = 10.0
tto = obs.mjd_i + obs.mjd_f
tts = Num.arange(tto, tto + (T + dt) / psr_utils.SECPERDAY,
dt / psr_utils.SECPERDAY)
nn = len(tts)
bts = Num.zeros(nn, 'd')
vel = Num.zeros(nn, 'd')
ra = psr_utils.coord_to_string(obs.ra_h, obs.ra_m, obs.ra_s)
dec = psr_utils.coord_to_string(obs.dec_d, obs.dec_m, obs.dec_s)
if (obs.telescope == 'Parkes'): tel = 'PK'
elif (obs.telescope == 'Effelsberg'): tel = 'EB'
elif (obs.telescope == 'Arecibo'): tel = 'AO'
elif (obs.telescope == 'MMT'): tel = 'MT'
elif (obs.telescope == 'GBT'): tel = 'GB'
else:
print("Telescope not recognized.")
return 0
elif filetype == "PSRFITS":
if not rawdatafile:
rawdatafile = psrfits.PsrfitsFile(infofilenm)
T = rawdatafile.specinfo.T
dt = 10.0
tto = rawdatafile.specinfo.start_MJD[0]
tts = Num.arange(tto, tto + (T + dt) / psr_utils.SECPERDAY,
dt / psr_utils.SECPERDAY)
nn = len(tts)
bts = Num.zeros(nn, 'd')
vel = Num.zeros(nn, 'd')
ra = rawdatafile.specinfo.ra_str
dec = rawdatafile.specinfo.dec_str
if (rawdatafile.specinfo.telescope == 'Parkes'): tel = 'PK'
elif (rawdatafile.specinfo.telescope == 'Effelsberg'): tel = 'EB'
elif (rawdatafile.specinfo.telescope == 'Arecibo'): tel = 'AO'
elif (rawdatafile.specinfo.telescope == 'MMT'): tel = 'MT'
elif (rawdatafile.specinfo.telescope == 'GBT'): tel = 'GB'
else:
print("Telescope not recognized.")
return 0
barycenter(tts, bts, vel, nn, ra, dec, tel, ephem)
avgvel = Num.add.reduce(vel) / nn
tts = Num.arange(nn, dtype='d') * dt
bts = (bts - bts[0]) * psr_utils.SECPERDAY
return tts, bts
def main():
fn = args[0]
if fn.endswith(".fil"):
# Filterbank file
filetype = "filterbank"
rawdatafile = filterbank.FilterbankFile(fn)
elif fn.endswith(".fits"):
# PSRFITS file
filetype = "psrfits"
rawdatafile = psrfits.PsrfitsFile(fn)
else:
raise ValueError("Cannot recognize data file type from "
"extension. (Only '.fits' and '.fil' "
"are supported.)")
data, bins, nbins, start = waterfall(rawdatafile, options.start,
options.duration, dm=options.dm,
nbins=options.nbins, nsub=options.nsub,
subdm=options.subdm, zerodm=options.zerodm,
downsamp=options.downsamp,
scaleindep=options.scaleindep,
width_bins=options.width_bins, mask=options.mask,
maskfn=options.maskfile,
bandpass_corr=options.bandpass_corr)
plot_waterfall(data, start, options.duration, integrate_ts=options.integrate_ts,
integrate_spec=options.integrate_spec, show_cb=options.show_cb,
cmap_str=options.cmap, sweep_dms=options.sweep_dms,
sweep_posns=options.sweep_posns)
def main():
parser = OptionParser(usage)
parser.add_option("-x", "--xwin", action="store_true", dest="xwin",
default=False, help="Show the bandpass in an x-window as well")
parser.add_option("-p", "--plot", action="store_true", dest="plot",
default=False, help="Show the bandpass in a .png plot as well")
parser.add_option("-n", "--nomods", action="store_true", dest="nomods",
default=False, help="Do not apply offsets/scales (default applies)")
parser.add_option("-w", "--weights", action="store_true", dest="weights",
default=False, help="Apply weights (default doesn't apply_")
parser.add_option("-f", "--first", type="int", dest="subfirst", default=0,
help="First subint to compute stats for")
parser.add_option("-s", "--skip", type="int", dest="subskip", default=10,
help="Number of subints to skip during stats calculations")
parser.add_option("-o", "--outfile", type="string", dest="outfile", default=None,
help="Output filename (default will be INFILE.bandpass")
(opts, args) = parser.parse_args()
if len(args)==0:
print(full_usage)
sys.exit(0)
for infile in args:
print("Processing '%s'" % (infile))
pf = psrfits.PsrfitsFile(infile)
if opts.nomods:
# for a bandpass histogram of raw bits
htot = np.zeros(1<<pf.nbits)
subints = np.arange(opts.subfirst, pf.specinfo.num_subint,
opts.subskip).astype(np.int)
means = np.zeros((len(subints), pf.nchan))
stdevs = np.zeros((len(subints), pf.nchan))
for ii, subint in enumerate(subints):
print("%.0f%%.." % (100.0 * float(subint) / pf.specinfo.num_subint), end=' ')
sys.stdout.flush()
specs = pf.read_subint(subint, apply_weights=opts.weights,
apply_scales=not opts.nomods,
apply_offsets=not opts.nomods,
apply_zero_off=not opts.nomods)
if opts.nomods:
h, b = np.histogram(specs.flatten(),
bins=np.arange((1<<pf.nbits)+1))
htot += h
means[ii] = specs.mean(axis=0)
stdevs[ii] = specs.std(axis=0)
print("%.0f%%" % (100.0))
med_mean = np.median(means, axis=0)
med_stdev = np.median(stdevs, axis=0)
outfilenm = infile+".bandpass" if opts.outfile is None else opts.outfile
plotfilenm = outfilenm+".png" if opts.plot else None
if opts.xwin or opts.plot:
plot_bandpass(pf.freqs, med_mean, med_stdev, outfile=plotfilenm)
if opts.nomods:
htot = htot / htot.sum()
print("# Bits histogram")
print("# val fract")
print("#---------------")
for b, h in zip(b, htot):
print("%3d %6.4f" % (b, h))
write_bandpass(outfilenm, pf.freqs, med_mean, med_stdev)
def main():
fn = args[0]
if fn.endswith(".fil"):
# Filterbank file
filetype = "filterbank"
print_debug("Reading filterbank file..")
rawdatafile = filterbank.filterbank(fn)
basename = fn[:-4]
if fn.endswith(".fits"):
# PSRFITS file
filetype = "psrfits"
print_debug("Reading PSRFITS file..")
rawdatafile = psrfits.PsrfitsFile(fn)
basename = fn[:-5]
else:
raise ValueError("Cannot recognize data file type from "
"extension. (Only '.fits' and '.fil' "
"are supported.)")
if options.outbasenm:
basename = options.outbasenm
spdcand = spcand.params()
if not options.man_params:
print_debug('Maximum number of candidates to plot: %i' %
options.maxnumcands)
make_spd_from_file(spdcand,
rawdatafile,
options.txtfile,
options.maskfile,
options.min_rank,
options.group_rank,
options.plot,
options.just_waterfall,
options.integrate_ts,
options.integrate_spec,
options.disp_pulse,
options.loc_pulse,
options.nsub,
options.maxnumcands,
basename,
mask=options.mask,
barytime=options.barytime,
bandpass_corr=options.bandpass_corr)
else:
print_debug("Making spd files based on mannual parameters. I suggest"
"reading in parameters from the groups.txt file.")
make_spd_from_man_params(
spdcand, rawdatafile, options.txtfile, options.maskfile,
options.plot, options.just_waterfall, options.subdm, options.dm,
options.sweep_dms, options.sigma, options.start, options.duration,
options.width_bins, options.nbins, options.downsamp, options.nsub,
options.scaleindep, options.spec_width, options.loc_pulse,
options.integrate_ts, options.integrate_spec, options.disp_pulse,
basename, options.mask, options.bandpass_corr, options.barytime,
options.man_params)
blocklen = 2400 # from $PRESTO/src/sigproc_fb.c (spectra_per_subint)
print("""
Using:
dt = %g s
numchan = %d
blocklen = %d
BW = %g MHz
fctr = %g MHz
from '%s'
""" % (dt, numchan, blocklen, BW, fctr, args[0]))
except:
print("Cannot read '%s' as SIGPROC filterbank. Ignoring." %
args[0])
else: # Assume it is PSRFITS
try:
pf = pfits.PsrfitsFile(args[0])
dt = pf.tsamp
numchan = pf.nchan
fctr = pf.header["OBSFREQ"]
BW = numchan * np.fabs(pf.specinfo.df)
blocklen = pf.specinfo.spectra_per_subint
print("""
Using:
dt = %g s
numchan = %d
blocklen = %d
BW = %g MHz
fctr = %g MHz
from '%s'
""" % (dt, numchan, blocklen, BW, fctr, args[0]))
if "CHAN_DM" in pf.header:
def main():
fn = args[0]
if fn.endswith(".fil"):
# Filterbank file
filetype = "filterbank"
rawdatafile = filterbank.FilterbankFile(fn)
elif fn.endswith(".fits"):
# PSRFITS file
filetype = "psrfits"
rawdatafile = psrfits.PsrfitsFile(fn)
else:
raise ValueError("Cannot recognize data file type from "
"extension. (Only '.fits' and '.fil' "
"are supported.)")
data, bins, nbins, start, source_name = waterfall(rawdatafile, options.start, \
options.duration, dm=options.dm,\
nbins=options.nbins, nsub=options.nsub,\
subdm=options.subdm, zerodm=options.zerodm, \
downsamp=options.downsamp, \
scaleindep=options.scaleindep, \
width_bins=options.width_bins, mask=options.mask, \
maskfn=options.maskfile, \
csv_file=options.csv_file,\
bandpass_corr=options.bandpass_corr)
ofile,ttest,ttestprob = plot_waterfall(data, start, source_name, options.duration, \
dm=options.dm,ofile=options.ofile, integrate_ts=options.integrate_ts, \
integrate_spec=options.integrate_spec, show_cb=options.show_cb,
cmap_str=options.cmap, sweep_dms=options.sweep_dms, \
sweep_posns=options.sweep_posns, downsamp=options.downsamp,width=options.width,snr=options.snr,csv_file=options.csv_file,prob=options.prob)
ttestprob = "%.2f" % ((1 - ttestprob) * 100)
ttest = "%.2f" % (ttest)
# Update CSV file if file is provided
if csv_file:
sourcename = rawdatafile.header['source_name']
src_ra = rawdatafile.header['src_raj']
src_dec = rawdatafile.header['src_dej']
tstart = rawdatafile.header['tstart']
fch1 = rawdatafile.header['fch1']
nchans = rawdatafile.header['nchans']
bw = int(rawdatafile.header['nchans']) * rawdatafile.header['foff']
cat = ofile.split("_")[0]
snr = options.snr
width = options.width
dm = options.dm
if options.prob: prob = options.prob
else: prob = "*"
df = pd.DataFrame({
'PNGFILE': [ofile],
'Category': [cat],
'Prob': [prob],
'T-test': [ttest],
'T-test_prob': [ttestprob],
'SNR': [snr],
'WIDTH': [width],
'DM': [dm],
'SourceName': [sourcename],
'RA': [src_ra],
'DEC': [src_dec],
'MJD': [tstart],
'Hfreq': [fch1],
'NCHANS': [nchans],
'BANDWIDTH': [bw],
'filename': [fn]
})
#Column order coming out irregular, so fixing it here
col = [
'PNGFILE', 'Category', 'Prob', 'T-test', 'T-test_prob', 'SNR',
'WIDTH', 'DM', 'SourceName', 'RA', 'DEC', 'MJD', 'Hfreq', 'NCHANS',
'BANDWIDTH', 'filename'
]
df = df.reindex(columns=col)
if os.path.exists(csv_file) is False:
with open(csv_file, 'w') as f:
df.to_csv(f, header=True, index=False)
else:
with open(csv_file, 'a') as f:
df.to_csv(f, header=False, index=False)
def main(fits_fn, outfn, nbits, \
apply_weights, apply_scales, apply_offsets):
start = time.time()
psrfits_file = psrfits.PsrfitsFile(fits_fn)
fil_header = translate_header(psrfits_file)
fil_header['nbits'] = nbits
outfil = filterbank.create_filterbank_file(outfn, fil_header, \
nbits=nbits)
# if frequency channels are in ascending order
# band will need to be flipped
if psrfits_file.fits['SUBINT'].header['CHAN_BW'] > 0:
flip_band=True
print("\nFits file frequencies in ascending order.")
print("\tFlipping frequency band.\n")
else:
flip_band=False
# check nbits for input
if psrfits_file.nbits < 4:
raise ValueError('Does not support %d-bit data' % \
psrfits_file.nbits)
if nbits != 32:
print("\nCalculating statistics on first subintegration...")
subint0 = psrfits_file.read_subint(0, \
apply_weights, apply_scales, apply_offsets)
#new_max = np.mean(subint0) + 3*np.std(subint0)
new_max = 3 * np.median(subint0)
print("\t3*median =",new_max)
if new_max > 2.0**nbits:
scale = True
scale_fac = new_max / ( 2.0**nbits )
print("\tScaling data by",1/scale_fac)
print("\tValues larger than",new_max,"(pre-scaling) "\
"will be set to",2.0**nbits - 1,"\n")
else:
scale = False
scale_fac = 1
print("\tNo scaling necessary")
print("\tValues larger than",2.0**nbits-1,"(2^nbits) will "\
"be set to ",2.0**nbits-1,"\n")
else:
scale_fac = 1
print("\nNo scaling necessary for 32-bit float output file.")
print("Writing data...")
sys.stdout.flush()
oldpcnt = ""
for isub in range(int(psrfits_file.nsubints)):
subint = psrfits_file.read_subint(isub, apply_weights, apply_scales, apply_offsets)
if flip_band:
subint = np.fliplr(subint)
subint /= scale_fac
outfil.append_spectra(subint)
pcnt = "%d" % (isub*100.0/psrfits_file.nsubints)
if pcnt != oldpcnt:
sys.stdout.write("% 4s%% complete\r" % pcnt)
sys.stdout.flush()
print("Done ")
outfil.close()
print("Runtime:",time.time() - start)
