def convert_tim_to_dat(tim):
"""Convert a SIGPROC time series .tim file to a
PRESTO .dat time series
Input:
tim: The SIGPROC .tim time series file to convert.
Output:
datfn: The PRESTO .dat time series file
"""
if not tim.endswith(".tim"):
raise ValueError("Was expecting a file name ending with '.tim'. "
"Got: %s" % tim)
path, fn = os.path.split(tim)
basenm = fn[:-4]
outfn = os.path.join(path, basenm+".dat")
hdr, hdrlen = sigproc.read_header(tim)
N = sigproc.samples_per_file(tim, hdr, hdrlen)
Ndone = 0
status = -1
with open(tim, 'rb') as inff, open(outfn, 'wb') as outff:
inff.seek(hdrlen)
data = np.fromfile(inff, dtype='float32', count=BLOCKSIZE)
while data.size:
data.tofile(outff)
Ndone += data.size
data = np.fromfile(inff, dtype='float32', count=BLOCKSIZE)
newstatus = int(100.0*Ndone/N)
if newstatus > status:
sys.stdout.write(" %d %%\r" % newstatus)
sys.stdout.flush()
status = newstatus
return outfn
def read_jobs_queue(jobs):
nb_jobs_sub=0
try:
file = open("%s/queue.dat"%basedir, "r")
for line in file.readlines():
#
(job,box) = line.split()
print job,box
box=box.replace("\n","")
jobs_list.append(job)
jobs_wlist.append(job)
jobs[job]=Job()
jobs[job].box=box
# Determine size
fil_filenm = "/data5/%s"%job.replace(".fbk","_p00.fbk")
filhdr, hdrlen = sigproc.read_header(fil_filenm)
orig_N = sigproc.samples_per_file(fil_filenm, filhdr, hdrlen)
if orig_N > 4194304:
logfile.write('Job %s detected L'%job);logfile.flush()
jobs[job].long=1
###################
nb_jobs_sub += 1
file.close()
return nb_jobs_sub
except:
return 0
def __init__(self, fil_filenm, box):
self.fil_filenm = fil_filenm
self.basefilenm = fil_filenm.rstrip(".sig")
#self.beam = int(self.basefilenm[-1])
self.beam = int(self.basefilenm)
filhdr, self.hdrlen = sigproc.read_header(fil_filenm)
self.orig_filenm = filhdr['rawdatafile']
self.MJD = filhdr['tstart']
self.nchans = filhdr['nchans']
self.ra_rad = sigproc.ra2radians(filhdr['src_raj'])
self.ra_string = psr_utils.coord_to_string(\
*psr_utils.rad_to_hms(self.ra_rad))
self.dec_rad = sigproc.dec2radians(filhdr['src_dej'])
self.dec_string = psr_utils.coord_to_string(\
*psr_utils.rad_to_dms(self.dec_rad))
self.az = filhdr['az_start']
self.el = 90.0-filhdr['za_start']
self.BW = abs(filhdr['foff']) * filhdr['nchans']
self.dt = filhdr['tsamp']
self.orig_N = sigproc.samples_per_file(fil_filenm, filhdr, self.hdrlen)
self.orig_T = self.orig_N * self.dt
self.N = choose_N(self.orig_N)
#self.N = 2097152
self.T = self.N * self.dt
# Update the RA and DEC from the database file if required
#newposn = read_db_posn(self.orig_filenm, self.beam)
#if newposn is not None:
# self.ra_string, self.dec_string = newposn
# ... and use them to update the filterbank file
# fix_fil_posn(fil_filenm, self.hdrlen,
# self.ra_string, self.dec_string)
# Determine the average barycentric velocity of the observation
#self.baryv = get_baryv(self.ra_string, self.dec_string,
# self.MJD, self.T, obs="NC")
# Where to dump all the results
# Directory structure is under the base_output_directory
# according to base/MJD/filenmbase/beam
self.outputdir = os.path.join(base_output_directory,box,
self.basefilenm)
# Figure out which host we are processing on
self.hostname = socket.gethostname()
# The fraction of the data recommended to be masked by rfifind
self.masked_fraction = 0.0
# Initialize our timers
self.rfifind_time = 0.0
self.downsample_time = 0.0
self.subbanding_time = 0.0
self.dedispersing_time = 0.0
self.FFT_time = 0.0
self.lo_accelsearch_time = 0.0
self.hi_accelsearch_time = 0.0
self.singlepulse_time = 0.0
self.sifting_time = 0.0
self.folding_time = 0.0
self.total_time = 0.0
# Inialize some candidate counters
self.num_sifted_cands = 0
self.num_folded_cands = 0
self.num_single_cands = 0
self.nb_sp = 0
def convert_tim_to_dat(tim):
"""Convert a SIGPROC time series .tim file to a
PRESTO .dat time series
Input:
tim: The SIGPROC .tim time series file to convert.
Output:
datfn: The PRESTO .dat time series file
"""
if not tim.endswith(".tim"):
raise ValueError("Was expecting a file name ending with '.tim'. "
"Got: %s" % tim)
path, fn = os.path.split(tim)
basenm = fn[:-4]
outfn = os.path.join(path, basenm + ".dat")
hdr, hdrlen = sigproc.read_header(tim)
N = sigproc.samples_per_file(tim, hdr, hdrlen)
Ndone = 0
status = -1
with open(tim, 'rb') as inff, open(outfn, 'wb') as outff:
inff.seek(hdrlen)
data = np.fromfile(inff, dtype='float32', count=BLOCKSIZE)
while data.size:
data.tofile(outff)
Ndone += data.size
data = np.fromfile(inff, dtype='float32', count=BLOCKSIZE)
newstatus = int(100.0 * Ndone / N)
if newstatus > status:
sys.stdout.write(" %d %%\r" % newstatus)
sys.stdout.flush()
status = newstatus
return outfn
def __init__(self, fil_filenm):
self.fil_filenm = fil_filenm
self.basefilenm = fil_filenm[:fil_filenm.find(".fil")]
filhdr, hdrlen = sigproc.read_header(fil_filenm)
self.MJD = filhdr['tstart']
self.nchans = filhdr['nchans']
self.ra_rad = sigproc.ra2radians(filhdr['src_raj'])
self.ra_string = pu.coord_to_string(*pu.rad_to_hms(self.ra_rad))
self.dec_rad = sigproc.dec2radians(filhdr['src_dej'])
self.dec_string = pu.coord_to_string(*pu.rad_to_dms(self.dec_rad))
self.str_coords = "J" + "".join(self.ra_string.split(":")[:2])
if self.dec_rad >= 0.0: self.str_coords += "+"
self.str_coords += "".join(self.dec_string.split(":")[:2])
self.az = filhdr['az_start']
self.el = 90.0 - filhdr['za_start']
fillen = os.stat(fil_filenm)[6]
self.raw_N = (fillen - hdrlen) / (filhdr['nbits'] /
8) / filhdr['nchans']
self.dt = filhdr['tsamp']
self.raw_T = self.raw_N * self.dt
self.N = orig_N
self.T = self.N * self.dt
# Determine the average barycentric velocity of the observation
self.baryv = get_baryv(self.ra_string,
self.dec_string,
self.MJD,
self.T,
obs="GB")
# Where to dump all the results
# Directory structure is under the base_output_directory
# according to base/MJD/filenmbase/beam
self.outputdir = os.path.join(base_output_dir, str(int(self.MJD)),
self.str_coords)
# Figure out which host we are processing on
self.hostname = socket.gethostname()
# The fraction of the data recommended to be masked by rfifind
self.masked_fraction = 0.0
# Initialize our timers
self.rfifind_time = 0.0
self.downsample_time = 0.0
self.dedispersing_time = 0.0
self.FFT_time = 0.0
self.lo_accelsearch_time = 0.0
self.hi_accelsearch_time = 0.0
self.singlepulse_time = 0.0
self.sifting_time = 0.0
self.folding_time = 0.0
self.total_time = 0.0
# Inialize some candidate counters
self.num_sifted_cands = 0
self.num_folded_cands = 0
self.num_single_cands = 0
def get_pulsar_parameters(self):
# select .fil file
fils = glob.glob(self.dir_path + '/*.fil')
fil = fils[0]
# grab name of pulsar from the .fil with sigproc function read_header (dictionary)
fil_dic = sigproc.read_header(fil)[0]
pname = fil_dic['source_name'][:-3]
antenna = fil_dic['source_name'][-2:]
mjd = fil_dic['tstart']
nchans = fil_dic['nchans']
return pname, antenna, mjd, nchans
def __init__(self, fil_filenm):
self.fil_filenm = fil_filenm
self.basefilenm = fil_filenm[:fil_filenm.find(".fil")]
filhdr, hdrlen = sigproc.read_header(fil_filenm)
self.MJD = filhdr['tstart']
self.nchans = filhdr['nchans']
self.ra_rad = sigproc.ra2radians(filhdr['src_raj'])
self.ra_string = pu.coord_to_string(*pu.rad_to_hms(self.ra_rad))
self.dec_rad = sigproc.dec2radians(filhdr['src_dej'])
self.dec_string = pu.coord_to_string(*pu.rad_to_dms(self.dec_rad))
self.str_coords = "J"+"".join(self.ra_string.split(":")[:2])
if self.dec_rad >= 0.0: self.str_coords += "+"
self.str_coords += "".join(self.dec_string.split(":")[:2])
self.az = filhdr['az_start']
self.el = 90.0-filhdr['za_start']
fillen = os.stat(fil_filenm)[6]
self.raw_N = (fillen-hdrlen)/(filhdr['nbits']/8)/filhdr['nchans']
self.dt = filhdr['tsamp']
self.raw_T = self.raw_N * self.dt
self.N = orig_N
self.T = self.N * self.dt
# Determine the average barycentric velocity of the observation
self.baryv = get_baryv(self.ra_string, self.dec_string,
self.MJD, self.T, obs="GB")
# Where to dump all the results
# Directory structure is under the base_output_directory
# according to base/MJD/filenmbase/beam
self.outputdir = os.path.join(base_output_dir,
str(int(self.MJD)),
self.str_coords)
# Figure out which host we are processing on
self.hostname = socket.gethostname()
# The fraction of the data recommended to be masked by rfifind
self.masked_fraction = 0.0
# Initialize our timers
self.rfifind_time = 0.0
self.downsample_time = 0.0
self.dedispersing_time = 0.0
self.FFT_time = 0.0
self.lo_accelsearch_time = 0.0
self.hi_accelsearch_time = 0.0
self.singlepulse_time = 0.0
self.sifting_time = 0.0
self.folding_time = 0.0
self.total_time = 0.0
# Inialize some candidate counters
self.num_sifted_cands = 0
self.num_folded_cands = 0
self.num_single_cands = 0
def main():
for tim in args.timfiles:
print "Working on %s" % tim
if args.write_dat:
try:
datfn = convert_tim_to_dat(tim)
print " Wrote PRESTO time series: %s" % datfn
except ValueError, e:
sys.stderr.write("Error encountered when converting on %s" % tim)
sys.stderr.write(str(e))
else:
datfn = tim[-3:]+"dat"
hdr, hdrlen = sigproc.read_header(tim)
inffn = write_inf_file(datfn, hdr, hdrlen)
print " Wrote info data: %s" % inffn
def read_header(self, return_idxs=False):
""" Read blimpy header and return a Python dictionary of key:value pairs
Args:
filename (str): name of file to open
Optional args:
return_idxs (bool): Default False. If true, returns the file offset indexes
for values
Returns:
Python dict of key:value pairs, OR returns file offset indexes for values.
"""
self.header = sigproc.read_header(self.filename, return_idxs=return_idxs)
return self.header
def main():
for tim in args.timfiles:
print "Working on %s" % tim
if args.write_dat:
try:
datfn = convert_tim_to_dat(tim)
print " Wrote PRESTO time series: %s" % datfn
except ValueError, e:
sys.stderr.write("Error encountered when converting on %s" %
tim)
sys.stderr.write(str(e))
else:
datfn = tim[-3:] + "dat"
hdr, hdrlen = sigproc.read_header(tim)
inffn = write_inf_file(datfn, hdr, hdrlen)
print " Wrote info data: %s" % inffn
def read_header(self, return_idxs=False):
""" Read blimpy header and return a Python dictionary of key:value pairs
Args:
filename (str): name of file to open
Optional args:
return_idxs (bool): Default False. If true, returns the file offset indexes
for values
Returns:
Python dict of key:value pairs, OR returns file offset indexes for values.
"""
self.header = sigproc.read_header(self.filename, return_idxs=return_idxs)
return self.header
def fb_samp(flist):
"""
Count the number of samples in a SIGPROC filterbank file.
Currently only handles one file, but would not be too hard
to update for multifile.
"""
fillist = flist
if len(fillist) > 1:
print "Currently can handle only one .fil file"
sys.exit(0)
fil_filenm = fillist[0]
filhdr, hdrlen = sigproc.read_header(fil_filenm)
n_samp = sigproc.samples_per_file(fil_filenm, filhdr, hdrlen)
return n_samp
def submit_jobs(filename):
"""
To Submit a Job :
jobs_list(job_id)
jobs_wlist(job_id)
jobs[job_id]=Job()
jobs[job_id].box_id
"""
nb_jobs=0
try:
print "Try to open %s"%filename
file = open(filename, "r")
for job in file.readlines():
job=job.replace("\n","")
jobs_list.append(job)
jobs_wlist.append(job)
jobs[job]=Job()
# Determine size
fil_filenm = "/data5/%s"%job.replace(".fbk","_p00.fbk")
filhdr, hdrlen = sigproc.read_header(fil_filenm)
orig_N = sigproc.samples_per_file(fil_filenm, filhdr, hdrlen)
if orig_N > 4194304:
logfile.write('Job %s detected L\n'%job);logfile.flush()
jobs[job].long=1
###################
c=filename.index("/")
jobs[job].box=filename[c+1:]
nb_jobs += 1
file.close()
write_jobs_queue()
return nb_jobs
except: return 0
def submit_a_job(job,box):
"""
To resubmit a job after deletion by 'remove_a_job'
"""
jobs_list.append(job)
jobs_wlist.append(job)
jobs[job]=Job()
jobs[job].box=box
# Determine size
fil_filenm = "/data5/%s"%job.replace(".fbk","_p00.fbk")
filhdr, hdrlen = sigproc.read_header(fil_filenm)
orig_N = sigproc.samples_per_file(fil_filenm, filhdr, hdrlen)
if orig_N > 4194304:
logfile.write('Job %s detected L'%job);logfile.flush()
jobs[job].long=1
else:
jobs[job].long=0
###################
write_jobs_queue()
print "skip = ", skip
print "1st_file_samps = ", first_file_samples
print "numfiles = ", numfiles
break
else:
accum_samples += samples_per_file[ii]
# Now make a command line option for spigot2filterbank
tmpfilenm = "tmp%d.fil" % random.randint(0, 2**30)
cmd = "spigot2filterbank -skip %d -numout %d -o %s " % \
(skip, raw_N, tmpfilenm)
for goodfile in infilenms[ii:ii + numfiles]:
cmd += "%s " % goodfile
os.system(cmd)
# Now read the header to determine what the correct filename
# should be. Use that to rename the fil file.
filhdr, hdrlen = sigproc.read_header(tmpfilenm)
MJDi = int(filhdr['tstart'])
ra_rad = sigproc.ra2radians(filhdr['src_raj'])
ra_string = pu.coord_to_string(*pu.rad_to_hms(ra_rad))
dec_rad = sigproc.dec2radians(filhdr['src_dej'])
dec_string = pu.coord_to_string(*pu.rad_to_dms(dec_rad))
str_coords = "".join(ra_string.split(":")[:2])
if dec_rad >= 0.0: str_coords += "+"
str_coords += "".join(dec_string.split(":")[:2])
filfilenm = "GBT350drift_%d_%s.fil" % (MJDi, str_coords)
os.rename(tmpfilenm, filfilenm)
print "Renamed '%s' to '%s'." % (tmpfilenm, filfilenm)
pngname = datfile.split(".dat")[0] + "." + opts.imageext
else:
import matplotlib
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import matplotlib.cm as cm
import matplotlib.collections as collections
import matplotlib.patches as patches
import matplotlib.font_manager as fm
headersize = 0 # size in bytes of the header
# if input file is Sigproc-style tim-file
if opts.is_timfile:
try:
filhdr, headersize = sigproc.read_header(datfile)
startmjd = filhdr['tstart']
tsamp = filhdr['tsamp']
source = filhdr['source_name']
except:
print("Error: Can't open the tim-file '%s'!" % (datfile,))
sys.exit(1)
elif opts.is_events:
opts.is_no_detrend = True # we don't do detrending for events
if opts.mjd == '' and not opts.is_chandra:
print("Error: for events' file start MJD _must_ be given with --mjd option or --chandra option!")
sys.exit(1)
if opts.nbins == -1:
print("Error: number of bins _must_ be given with --nbins option!")
sys.exit(1)
# Check the name of the pulsar and fils
# Grab name of .fils
fils = glob.glob('*.fil')
# Count how many fils are in the folder
nfils = len(fils)
#Warning if there are more than one fil
if nfils > 1:
print ('WARNING: more than one fil in this folder. I will fold them all.')
# Grab name of pulsar from the .fil with sigproc function read_header (dictionary)
fil_dic= sigproc.read_header(fils[0])[0]
pulsarname = fil_dic['source_name'][:-3]
date= fil_dic['rawdatafile'][-19:-4]
# Grab configuration file with same name than the pulsar
configdest = '/opt/pulsar/puma/config/'
configfile = SafeConfigParser()
configfile.read(configdest+pulsarname+'.ini')
# If we are not using manual mode, take all parameters in the config file
# RFI parameters
rfitime = configfile.get('rfi','nint')
checkmask = configfile.getboolean('main','rfimask')
checkreuse = configfile.getboolean('rfi','reuse')
break
else:
accum_samples += samples_per_file[ii]
# Now make a command line option for spigot2filterbank
tmpfilenm = "tmp%d.fil"%random.randint(0,2**30)
cmd = "spigot2filterbank -skip %d -numout %d -o %s " % \
(skip, raw_N, tmpfilenm)
for goodfile in infilenms[ii:ii+numfiles]:
cmd += "%s "%goodfile
os.system(cmd)
# Now read the header to determine what the correct filename
# should be. Use that to rename the fil file.
filhdr, hdrlen = sigproc.read_header(tmpfilenm)
MJDi = int(filhdr['tstart'])
ra_rad = sigproc.ra2radians(filhdr['src_raj'])
ra_string = pu.coord_to_string(*pu.rad_to_hms(ra_rad))
dec_rad = sigproc.dec2radians(filhdr['src_dej'])
dec_string = pu.coord_to_string(*pu.rad_to_dms(dec_rad))
str_coords = "".join(ra_string.split(":")[:2])
if dec_rad >= 0.0: str_coords += "+"
str_coords += "".join(dec_string.split(":")[:2])
filfilenm = "GBT350drift_%d_%s.fil" % (MJDi, str_coords)
os.rename(tmpfilenm, filfilenm)
print("Renamed '%s' to '%s'." % (tmpfilenm, filfilenm))
def __init__(self, fil_filenm):
self.fil_filenm = fil_filenm
self.basefilenm = fil_filenm.rstrip(".fil")
self.beam = int(self.basefilenm[-1])
filhdr, self.hdrlen = sigproc.read_header(fil_filenm)
self.orig_filenm = filhdr['rawdatafile']
self.MJD = filhdr['tstart']
self.nchans = filhdr['nchans']
self.ra_rad = sigproc.ra2radians(filhdr['src_raj'])
self.ra_string = psr_utils.coord_to_string(\
*psr_utils.rad_to_hms(self.ra_rad))
self.dec_rad = sigproc.dec2radians(filhdr['src_dej'])
self.dec_string = psr_utils.coord_to_string(\
*psr_utils.rad_to_dms(self.dec_rad))
self.az = filhdr['az_start']
self.el = 90.0 - filhdr['za_start']
self.BW = abs(filhdr['foff']) * filhdr['nchans']
self.dt = filhdr['tsamp']
self.orig_N = sigproc.samples_per_file(fil_filenm, filhdr, self.hdrlen)
self.orig_T = self.orig_N * self.dt
self.N = psr_utils.choose_N(self.orig_N)
self.T = self.N * self.dt
# Update the RA and DEC from the database file if required
newposn = read_db_posn(self.orig_filenm, self.beam)
if newposn is not None:
self.ra_string, self.dec_string = newposn
# ... and use them to update the filterbank file
fix_fil_posn(fil_filenm, self.hdrlen, self.ra_string,
self.dec_string)
# Determine the average barycentric velocity of the observation
self.baryv = presto.get_baryv(self.ra_string,
self.dec_string,
self.MJD,
self.T,
obs="AO")
# Where to dump all the results
# Directory structure is under the base_output_directory
# according to base/MJD/filenmbase/beam
self.outputdir = os.path.join(base_output_directory,
str(int(self.MJD)), self.basefilenm[:-2],
str(self.beam))
# Figure out which host we are processing on
self.hostname = socket.gethostname()
# The fraction of the data recommended to be masked by rfifind
self.masked_fraction = 0.0
# Initialize our timers
self.rfifind_time = 0.0
self.downsample_time = 0.0
self.subbanding_time = 0.0
self.dedispersing_time = 0.0
self.FFT_time = 0.0
self.lo_accelsearch_time = 0.0
self.hi_accelsearch_time = 0.0
self.singlepulse_time = 0.0
self.sifting_time = 0.0
self.folding_time = 0.0
self.total_time = 0.0
# Inialize some candidate counters
self.num_sifted_cands = 0
self.num_folded_cands = 0
self.num_single_cands = 0
parser.add_argument('-cl', type=int, dest='cl', help="channel low", default = 0);
parser.add_argument("-cu", type=int, dest='cu', help="channel high", default = 1023);
parser.add_argument('-il', type=int, dest='il', help="integration low", default = 0);
parser.add_argument("-iu", type=int, dest='iu', help="integration high", default = 4095);
parser.add_argument('-bl', type=int, dest='bl', help="beam low", default = 0);
parser.add_argument("-bu", type=int, dest='bu', help="beam high", default = 63);
args = parser.parse_args();
cl = args.cl;
cu = args.cu;
bl = args.bl;
bu = args.bu;
il = args.il;
iu = args.iu;
header = sigproc.read_header(args.infile);
nBeams = header['nbeams'];
nChans = header['nchans'];
nInts = header['nsamples'];
print("\nfile contains:");
print(str(nBeams) + " beams");
print(str(nChans) + " channels");
print(str(nInts) + " time samples\n");
if cl > cu:
cl , cu = cu , cl;
if bl > bu:
bl , bu = bu , bl;
if il > iu:
il , iu = iu , il;
def ordenMJD(filename, opcion, base, orden):
#filename = nombre del .fil
#opcion = 1 es potencia, 0 es espectro
#base = 1 es quitar linea de base y 0 es no quitarla
#orden para ordenar por: RA = ascención recta, DEC = por declinación, MJD = por tiempo.
import numpy as np
import os
from astropy.time import Time
import struct
import sigproc
from BaselineRemoval import BaselineRemoval
from peakutils import baseline
header = sigproc.read_header(filename) # leemos el header del .fil
f = open(filename, "rb")
nchans = int(header[0].get("nchans")) # numero de canales
f.seek(
header[1]
) # le dice a la estructura f que ubique al puntero en una cierta posicion
# abrimos el archivo con los valores de tiempo ltf.
time_name = filename[0:len(filename) -
4] + '.ltf' # nombre del archivo .ltf
time_file = open(time_name, "r") # abre el archivo .ltf
# abrimos el archivo con las posiciones de apuntamiento
pos_name = filename[0:len(filename) - 4] + '.txt'
MJD_pos = np.loadtxt(pos_name,
usecols=0) # guardamos los valores de MJD de .txt
RA_pos = np.loadtxt(pos_name,
usecols=5) # guardamos los valores de RA de .txt
DEC_pos = np.loadtxt(pos_name,
usecols=7) # guardamos los valores de DEC de .txt
t_i = MJD_pos[0] # primer valor de tiempo del .txt
t_f = MJD_pos[-1:][0] # último valor de tiempo del .txt
b = os.path.getsize(filename)
size = int(header[0].get("nbits")) # del header saca el tamaño en bits
pack = size / 8
n_espectros = (
((b - header[1]) / pack) /
nchans) - 1 # Calculo del total de espectos disponibles en el .fil
tiempos = np.empty(
n_espectros) # Array que va a guardar los tiempos de .lrf
n_real = 0 # Número de espectros correspondiente a una posición bien apuntada
for i in range(n_espectros): # recorremos todos los espectros del .fil
t_aux = str(time_file.readline())[
0:26] # sacamos el valor de tiempo del .ltf (dd/mm/yyyy)
tiempos[i] = Time(t_aux, format='isot').mjd # y lo pasamos a MJD
if tiempos[i] >= t_i and tiempos[
i] <= t_f: # si el tiempo del .fil está dentro del intervalo en que la antena estaba apuntada
n_real += 1 # aumentamos en 1 el número de espectros bien apuntados
espectros = np.empty(
[n_real, nchans + 3]
) # archivo de salida. Las columnas son: MJD, RA, DEC, y luego vienen los canales
potencias = np.empty([n_real, 4]) # archivo de salida si piden potencia
temp = np.empty(nchans) # archivo temporal para guardar cada espectro
j = 0 # para recorrer las filas de espectros y potencias
for i in range(
n_espectros): # para cada instante de tiempo en la observación
for k in range(nchans):
temp[k] = struct.unpack(
'f', f.read(pack)
)[0] # leemos la medición en cada canal de frecuencia para ese instante
if t_i <= tiempos[i] <= t_f:
if t_pos < tiempos[
i]: # si el tiempo del .fil está dentro del intervalo en que la antena estaba apuntada
m = find_nearest(
MJD_pos, tiempos[i]
) # buscamos el tiempo del .txt más cercano a ese tiempo
t_pos = MJD_pos[m]
espectros[j, 0] = tiempos[
i] # en la primera columna guardamos el t del .fil
espectros[j, 1] = RA_pos[
m] # en la segunda columna guardamos el RA del .txt
espectros[j, 2] = DEC_pos[
m] # en la tercera columna guardamos el DEC del .txt
espectros[
j, 3:] = temp # guardamos las mediciones en todos los canales
if opcion == 1: # si piden calcular potencia
potencias[j, 0] = tiempos[
i] # en la primera columna guardamos el t del .fil
potencias[j, 1] = RA_pos[
m] # en la segunda columna guardamos el RA del .txt
potencias[j, 2] = DEC_pos[
m] # en la tercera columna guardamos el DEC del .txt
potencias[j,
3] = np.mean(espectros[j,
3:]) # calculamos la potencia
j += 1
if base == 1:
potencias[:,
3] -= baseline(potencias[:, 3],
1) # calculamos la base y luego se la sacamos
if orden == "RA":
potencias = potencias[np.argsort(potencias[:, 1])]
elif orden == "DEC":
potencias = potencias[np.argsort(potencias[:, 2])]
elif orden == "MJD":
pass
if opcion == 0:
np.save(filename[0:len(filename) - 4] + "_espectro.npy", espectros)
return espectros
elif opcion == 1:
np.save(filename[0:len(filename) - 4] + "_potencia.npy", potencias)
return potencias
from scipy import stats
import numpy.matlib as npm
import sys
dSNR = 20
# fake signal strength
threshold = 5
filtsize = 21
# seems to work, can be increased if needed
nBeam = 0
nBlock = 0
#infile = '/home/user/vikram/scratch/bsfil_B0531_1.fil';
infile = '/home/user/vikram/scratch/bsfil_TEST_2.fil'
header = sigproc.read_header(infile)
nBeams = 64
#header['nbeams'];
nChans = 1024
#header['nchans'];
nInts = 4096
#header['nsamples'];
nBlockSize = nBeams * nChans * nInts
FilSize = Path(infile).stat().st_size
nTotBlocks = round(FilSize / nBlockSize)
fh = open(infile, 'rb')
while True:
keyword, value, idx = sigproc.read_next_header_keyword(fh)
if keyword == 'HEADER_END':
#://github.com/UCBerkeleySETI/blimpy/blob/master/blimpy/io/fil_reader.py
# plots filterbank file and extracts candidates
import matplotlib.pyplot as plt
import numpy as np
import scipy.signal
from scipy import stats
from pathlib import Path
import sigproc
import sys
#fname = '/datax2/devfil/beam_data/20201110104110_HAT-P-44C.fil';
fname = sys.argv[1];
fhead = sigproc.read_header(fname);
headlen = sigproc.len_header(fname);
nSpec = int((Path(fname).stat().st_size - headlen)/fhead['nchans']/4);
spec = np.zeros((fhead['nchans']));
for k in range(nSpec):
print(str(k+1) + ' / ' + str(nSpec));
spec += np.fromfile(fname, dtype=np.uint32, count=int(fhead['nchans']), offset=headlen+int(4*k*fhead['nchans']));
plt.figure();
plt.plot(np.linspace(fhead['fch1'],fhead['fch1']+fhead['foff']*fhead['nchans'],fhead['nchans']),10.*np.log10(spec));
plt.grid();
plt.xlabel('frequency [MHz]');
plt.ylabel('power [dB]');
plt.suptitle(fhead['source_name']);
plt.show();
def get_pulsar_info(path, dotpar_path):
# stuff to return
ierr = 0
Main, Parameters, Rfi = {}, {}, {}
# check the name of the pulsar and fils
# - grab name of .fils
fils = glob.glob(path + '/*.fil')
fils.sort()
# - count how many fils are in the folder
nfils = len(fils)
# warning if there are more than one fil
if nfils <= 0:
print('\n ERROR: no *.fil(s) found in ' + args.folder + '\n')
ierr = -1
return Main, Parameters, Rfi, ierr
elif nfils > 1:
print(
'\n WARNING: more than one fil in this folder. I will fold them all.\n'
)
# grab name of pulsar from the .fil with sigproc function read_header (dictionary)
fil_dic = sigproc.read_header(fils[0])[0]
pulsarname = fil_dic['source_name'][:-3]
# grab configuration file with same name than the pulsar
configdest = '/opt/pulsar/puma/config/'
configfile = SafeConfigParser()
configfile.read(configdest + pulsarname + '.ini')
# if we are not using manual mode, take all parameters in the config file,
# this file contains 3 sections: main, parameters and rfi. Each of them will
# be stored in different dictionaries, Main, Parameters and Rfi such that
# this will be returned by get_pulsar_info function
# Main information
Main['timing'] = configfile.getboolean('main', 'timing')
Main['dmsearch'] = configfile.getboolean('main', 'dmsearch')
Main['rfimask'] = configfile.getboolean('main', 'rfimask')
Main['gvoutput'] = configfile.getboolean('main', 'gvoutput')
Main['movephase'] = configfile.getboolean('main', 'movephase')
Main['name'] = pulsarname
Main['date'] = fil_dic['rawdatafile'][-19:-4]
Main['fils'] = fils
# Parameters information
Parameters['nbins'] = configfile.get('parameters', 'nbins')
Parameters['nchan'] = str(fil_dic['nchans'])
Parameters['phase'] = configfile.get('parameters', 'phase')
Parameters['npart'] = configfile.get('parameters', 'npart')
Parameters['pstep'] = configfile.get('parameters', 'pstep')
# Rfi information
Rfi['nint'] = configfile.get('rfi', 'nint')
Rfi['reuse'] = configfile.getboolean('rfi', 'reuse')
# path to .par file
dotpar = dotpar_path + '/' + pulsarname + '.par'
if os.path.isfile(dotpar) is False:
print('\n ERROR: no .par file found in ' + pardest + '\n')
ierr = -1
return Main, Parameters, Rfi, ierr
else:
Main['dotpar'] = dotpar
return Main, Parameters, Rfi, ierr
