Beispiel #1
0
def avg_data(
    files
):  #Finds mean and median power spectrum profiles given a list of files of same frequency range
    data = []
    for file in files:
        fil = Filterbank(file)
        power_vals = fil.data[0][0]
        data.append(power_vals)

    data = np.array(data)
    stacked_data = np.dstack(
        data
    )[0]  #Turns data into array of length equal to # of chans, each of size equal to number of data points

    mean_data = []
    median_data = []
    for channel in stacked_data:
        mean_data.append(np.mean(channel))
        median_data.append(np.median(channel))

    mean_data = np.array(mean_data)
    median_data = np.array(median_data)
    freqs = np.array(Filterbank(files[0]).freqs)
    dict = {'freqs': freqs, 'mean_data': mean_data, 'median_data': median_data}
    return dict
def test_voyager_fix_header():
    filename = '/workdata/bl/data/voyager_f1032192_t300_v2.fil'
    new_filename = 'voyager_ext.fil'

    fb = Filterbank(filename, f_start=8420.1, f_stop=8420.3)
    fb.write_to_filterbank(new_filename)
    fb = Filterbank(new_filename)

    filename = new_filename
    assert read_header(filename)['ibeam'] == 1

    fix_header(filename, 'ibeam', 7)
    assert read_header(filename)['ibeam'] == 7

    fix_header(filename, 'ibeam', 1)
    assert read_header(filename)['ibeam'] == 1

    fix_header(filename, 'ibeam', 13)
    assert read_header(filename)['ibeam'] == 13

    pprint(read_header(filename))

    fix_header(filename, 'rawdatafile', './blc3_9bit_guppi_57386_VOYAGER1_0004.0000.raw')
    assert read_header(filename)['rawdatafile'] == './blc3_9bit_guppi_57386_VOYAGER1_0004.0000.raw'
    fix_header(filename, 'rawdatafile', './blc3_2bit_guppi_57386_VOYAGER1_0004.0000.raw')
    assert read_header(filename)['rawdatafile'] == './blc3_2bit_guppi_57386_VOYAGER1_0004.0000.raw'

    os.remove(new_filename)
 def test_select_frequency_range_reversed(self):
     """
         Initialize 16 bits filterbank
         and test if values are in frequency range
     """
     filename = './pspm16.fil'
     fil = Filterbank(filename)
     data = fil.select_data(freq_start=432, freq_stop=431)
     self.assertTrue(all(430.5 < i < 432.4 for i in data[0]))
 def test_filterbank_time_range(self):
     """
         Initialize 8 bits filterbank
         and test if values are in time range
     """
     filename = './pspm8.fil'
     time_range = (10, 30)
     time_delt = abs(time_range[0] - time_range[1])
     fil = Filterbank(filename)
     data = fil.select_data(time_start=time_range[0],
                            time_stop=time_range[1])
     self.assertEqual(len(data[1]), time_delt)
def test_voyager():
    filename = '/workdata/bl/data/voyager_f1032192_t300_v2.fil'

    fb = Filterbank(filename)
    fb.info()
    fb.plot_spectrum()
    plt.show()

    fb = Filterbank(filename, f_start=8420, f_stop=8420.5)
    fb.info()
    fb.plot_spectrum()
    plt.show()
Beispiel #6
0
 def __init__(self, source, b, a):
     # Automatically duplicate mono input to fit the desired output shape
     if b.shape[0]!=source.nchannels:
         if source.nchannels!=1:
             raise ValueError('Can only automatically duplicate source channels for mono sources, use RestructureFilterbank.')
         source = RestructureFilterbank(source, b.shape[0])
     Filterbank.__init__(self, source)
     # Weave version of filtering requires Fortran ordering of filter params
     if len(b.shape)==2 and len(a.shape)==2:
         b = reshape(b, b.shape+(1,))
         a = reshape(a, a.shape+(1,))
     self.filt_b = array(b, order='F')
     self.filt_a = array(a, order='F')
     self.filt_state = zeros((b.shape[0], b.shape[1]-1, b.shape[2]), order='F')
 def test_filterbank_parameters(self):
     """
         Initialize 32 bits filterbank
         and test if all parameters work
     """
     filename = './pspm32.fil'
     freq_range = (433, 435)
     time_range = (10, 20)
     time_delt = abs(time_range[0] - time_range[1])
     fil = Filterbank(filename,
                      freq_range=freq_range,
                      time_range=time_range)
     data = fil.select_data()
     self.assertTrue(all(432.5 < i < 435.4 for i in data[0]))
     self.assertEqual(len(data[1]), time_delt)
 def test_wrong_filename_raises_error(self):
     """
         Initialize filterbank with an incorrect filename
     """
     filename = './thispathdoesnotexist'
     with self.assertRaises(FileNotFoundError):
         Filterbank(filename)
def AA(file):  #Returns AltAz coords for given observation

    fil = Filterbank(file)
    MJD = fil.header['tstart']
    ra = fil.header['src_raj']
    dec = fil.header['src_dej']

    target = SkyCoord(ra, dec)
    altaz = target.transform_to(
        AltAz(location=GreenBank, obstime=Time(MJD, format='mjd')))
    dict = {'alt': altaz.alt.degree, 'az': altaz.az.degree}
    return dict
Beispiel #10
0
 def __init__(self, source, b, a):
     # Automatically duplicate mono input to fit the desired output shape
     if b.shape[0]!=source.nchannels:
         if source.nchannels!=1:
             raise ValueError('Can only automatically duplicate source channels for mono sources, use RestructureFilterbank.')
         source = RestructureFilterbank(source, b.shape[0])
     Filterbank.__init__(self, source)
     # Weave version of filtering requires Fortran ordering of filter params
     if len(b.shape)==2 and len(a.shape)==2:
         b = reshape(b, b.shape+(1,))
         a = reshape(a, a.shape+(1,))
     self.filt_b = array(b, order='F')
     self.filt_a = array(a, order='F')
     self.filt_state = zeros((b.shape[0], b.shape[1], b.shape[2]), order='F')
     self.use_weave = get_global_preference('useweave')
     if self.use_weave:
         log_info('brian.hears.filtering.linearfilterbank', 'Using weave')
         self.cpp_compiler = get_global_preference('weavecompiler')
         self.extra_compile_args = ['-O3']
         if self.cpp_compiler=='gcc':
             self.extra_compile_args += get_global_preference('gcc_options')
 def __init__(self, source, b, a):
     # Automatically duplicate mono input to fit the desired output shape
     if b.shape[0] != source.nchannels:
         if source.nchannels != 1:
             raise ValueError(
                 'Can only automatically duplicate source channels for mono sources, use RestructureFilterbank.'
             )
         source = RestructureFilterbank(source, b.shape[0])
     Filterbank.__init__(self, source)
     # Weave version of filtering requires Fortran ordering of filter params
     if len(b.shape) == 2 and len(a.shape) == 2:
         b = reshape(b, b.shape + (1, ))
         a = reshape(a, a.shape + (1, ))
     self.filt_b = array(b, order='F')
     self.filt_a = array(a, order='F')
     self.filt_state = zeros((b.shape[0], b.shape[1], b.shape[2]),
                             order='F')
     self.use_weave = get_global_preference('useweave')
     if self.use_weave:
         log_info('brian.hears.filtering.linearfilterbank', 'Using weave')
         self.cpp_compiler = get_global_preference('weavecompiler')
         self.extra_compile_args = ['-O3']
         if self.cpp_compiler == 'gcc':
             self.extra_compile_args += get_global_preference('gcc_options')
Beispiel #12
0
def band_finder(
    filename
):  #Classifies filterbank file into a band according to its middle freq
    fil = Filterbank(filename)
    fmax = fil.header['fch1']
    nchans = fil.header['nchans']
    ch_bandwidth = fil.header['foff']
    fmid = fmax + (nchans * ch_bandwidth) / 2.0
    if 1000 <= fmid < 2000:
        return 'L'
    elif 2000 <= fmid < 4000:
        return 'S'
    elif 4000 <= fmid < 8000:
        return 'C'
    elif 8000 <= fmid < 12000:
        return 'X'
def totalpower(file, fmin, fmax):
    fil = Filterbank(file)
    maxfreq = fil.header['fch1']
    nchans = fil.header['nchans']
    ch_bandwidth = fil.header['foff']
    minfreq = maxfreq + nchans * ch_bandwidth

    if fmin < minfreq or fmax > maxfreq:
        raise ValueError(
            "One of the freq constraints is out of the freq range of this filterbank file."
        )

    freqs = np.array(fil.freqs)
    data = np.array(fil.data[0][0])

    newfreqs = np.array([x for x in freqs if x >= fmin and x <= fmax])
    idx = np.where(np.in1d(
        freqs, newfreqs))[0]  #Indices of where newfreqs values occur in freqs
    newdata = data[idx]

    totalpower = simps(x=newfreqs, y=newdata)
    return totalpower
Beispiel #14
0
 def buffer_init(self):
     Filterbank.buffer_init(self)
     self.filt_state.set(
         zeros(self.filt_state.shape, dtype=self.filt_state.dtype))
Beispiel #15
0
def test_voyager_extract():
    filename = '/workdata/bl/data/voyager_f1032192_t300_v2.fil'
    new_filename = 'voyager_ext.fil'

    fb = Filterbank(filename, f_start=8420.1, f_stop=8420.3)
    fb.info()
    fb.plot_spectrum()
    plt.show()

    fb.write_to_filterbank(new_filename)

    fb2 = Filterbank(new_filename)
    fb2.info()
    fb2.plot_spectrum()
    plt.show()

    os.remove(new_filename)
 def buffer_init(self):
     Filterbank.buffer_init(self)
     self.filt_state[:] = 0
Beispiel #17
0
from __future__ import print_function
import sys

sys.path.append('breakthrough/GBT/filterbank_tools/')

import numpy as np
from filterbank import Filterbank as FB, db

extrema = lambda a: (a.min(), a.max())
scalef = lambda a, ex: (a - ex[0]) / (ex[1] - ex[0])
iscalef = lambda a, ex: ex[0] + (a * (ex[1] - ex[0]))

if __name__ == '__main__':
    infilf = '../data/blc3_2bit_guppi_57386_VOYAGER1_0002.gpuspec.0002.fil'
    synf = '../data/test_data'
    outf = 'synandskysig.fits'
    mixcoef = 0.5
    fbin = FB(infilf)
    f, data = fbin.grab_data()
    data = db(data)
    imgshape = [32, 1]  #plot_data.shape
    datext = extrema(data)
    with open(synf, 'rb') as fid:
        syndata = np.fromfile(fid, count=np.prod(imgshape), dtype='<f4')
    # scale syn data into range of data, mix
    syndata = iscalef(scalef(syndata, extrema(syndata)), datext)
    data = (1.0 - mixcoef) * data + mixcoef * syndata.reshape(imgshape)

    fits.writeto(outf, data)
Beispiel #18
0
 def __init__(self,
              source,
              b,
              a,
              samplerate=None,
              precision='double',
              forcesync=True,
              pagelocked_mem=True,
              unroll_filterorder=None):
     # Automatically duplicate mono input to fit the desired output shape
     if b.shape[0] != source.nchannels:
         if source.nchannels != 1:
             raise ValueError(
                 'Can only automatically duplicate source channels for mono sources, use RestructureFilterbank.'
             )
         source = RestructureFilterbank(source, b.shape[0])
     Filterbank.__init__(self, source)
     if pycuda.context is None:
         set_gpu_device(0)
     self.precision = precision
     if self.precision == 'double':
         self.precision_dtype = float64
     else:
         self.precision_dtype = float32
     self.forcesync = forcesync
     self.pagelocked_mem = pagelocked_mem
     n, m, p = b.shape
     self.filt_b = b
     self.filt_a = a
     filt_b_gpu = array(b, dtype=self.precision_dtype)
     filt_a_gpu = array(a, dtype=self.precision_dtype)
     filt_state = zeros((n, m - 1, p), dtype=self.precision_dtype)
     if pagelocked_mem:
         filt_y = drv.pagelocked_zeros((n, ), dtype=self.precision_dtype)
         self.pre_x = drv.pagelocked_zeros((n, ),
                                           dtype=self.precision_dtype)
     else:
         filt_y = zeros(n, dtype=self.precision_dtype)
         self.pre_x = zeros(n, dtype=self.precision_dtype)
     self.filt_b_gpu = gpuarray.to_gpu(filt_b_gpu.T.flatten(
     ))  # transform to Fortran order for better GPU mem
     self.filt_a_gpu = gpuarray.to_gpu(
         filt_a_gpu.T.flatten())  # access speeds
     self.filt_state = gpuarray.to_gpu(filt_state.T.flatten())
     self.unroll_filterorder = unroll_filterorder
     if unroll_filterorder is None:
         if m <= 32:
             unroll_filterorder = True
         else:
             unroll_filterorder = False
     # TODO: improve code, check memory access patterns, maybe use local memory
     code = '''
     #define x(s,i) _x[(s)*n+(i)]
     #define y(s,i) _y[(s)*n+(i)]
     #define a(i,j,k) _a[(i)+(j)*n+(k)*n*m]
     #define b(i,j,k) _b[(i)+(j)*n+(k)*n*m]
     #define zi(i,j,k) _zi[(i)+(j)*n+(k)*n*(m-1)]
     __global__ void filt(SCALAR *_b, SCALAR *_a, SCALAR *_x, SCALAR *_zi, SCALAR *_y, int numsamples)
     {
         int j = blockIdx.x * blockDim.x + threadIdx.x;
         if(j>=n) return;
         for(int s=0; s<numsamples; s++)
         {
     '''
     for k in range(p):
         loopcode = '''
         y(s,j) = b(j,0,k)*x(s,j) + zi(j,0,k);
         '''
         if unroll_filterorder:
             for i in range(m - 2):
                 loopcode += re.sub(
                     '\\bi\\b', str(i), '''
                 zi(j,i,k) = b(j,i+1,k)*x(s,j) + zi(j,i+1,k) - a(j,i+1,k)*y(s,j);
                 ''')
         else:
             loopcode += '''
             for(int i=0;i<m-2;i++)
                 zi(j,i,k) = b(j,i+1,k)*x(s,j) + zi(j,i+1,k) - a(j,i+1,k)*y(s,j);
             '''
         loopcode += '''
         zi(j,m-2,k) = b(j,m-1,k)*x(s,j) - a(j,m-1,k)*y(s,j);
         '''
         if k < p - 1:
             loopcode += '''
             x(s,j) = y(s,j);
             '''
         loopcode = re.sub('\\bk\\b', str(k), loopcode)
         code += loopcode
     code += '''
         }
     }
     '''
     code = code.replace('SCALAR', self.precision)
     code = re.sub("\\bp\\b", str(p),
                   code)  #replace the variable by their values
     code = re.sub("\\bm\\b", str(m), code)
     code = re.sub("\\bn\\b", str(n), code)
     #print code
     self.gpu_mod = pycuda.compiler.SourceModule(code)
     self.gpu_filt_func = self.gpu_mod.get_function("filt")
     blocksize = 256
     if n < blocksize:
         blocksize = n
     if n % blocksize == 0:
         gridsize = n / blocksize
     else:
         gridsize = n / blocksize + 1
     self.block = (blocksize, 1, 1)
     self.grid = (gridsize, 1)
     self.gpu_filt_func.prepare((intp, intp, intp, intp, intp, int32),
                                self.block)
     self._has_run_once = False
Beispiel #19
0
 def buffer_init(self):
     Filterbank.buffer_init(self)
     self.filt_state.set(zeros(self.filt_state.shape, dtype=self.filt_state.dtype))
Beispiel #20
0
 def buffer_init(self):
     Filterbank.buffer_init(self)
     self.filt_state[:] = 0
Beispiel #21
0
def maxfreq(file): #Returns max frequency in a .fil file
    fil = Filterbank(file)
    return fil.header['fch1']
Beispiel #22
0
import numpy as np
import pylab as pl

from filterbank import Filterbank as FB, db

#from astropy.io import fits

if __name__ == '__main__':
    argv = sys.argv
    if len(argv) not in (2,3):
        print("usage: %s input.fil [output.fits]")

    infilf = argv[1]
    outf = argv[2] if len(argv) == 3 else splitext(infilf)[0]+'.fits'

    fbin = FB(infilf)
    f, data = fbin.grab_data()
    data = db(data)

    # dump to fits for fun
    #fits.writeto(outf,data,clobber=True)
    #infits = fits.open(outf,memmap=True)
    #data = infits[0].data
    
    print(data.shape)
    print(f.shape)
    pl.imshow(data)
    f_step = int(f.shape[0]/25)
    t_step = int(data.shape[0]/3)
    xt =  (f[::f_step]*10).astype(int)/10.0
    pl.xticks(np.arange(len(xt)),xt,rotation=90)
def maxfreq(file):
    fil = Filterbank(file)
    maxfreq = float(fil.header['fch1'])
    return maxfreq
Beispiel #24
0
 def __init__(self, source, b, a, samplerate=None,
              precision='double', forcesync=True, pagelocked_mem=True, unroll_filterorder=None):
     # Automatically duplicate mono input to fit the desired output shape
     if b.shape[0]!=source.nchannels:
         if source.nchannels!=1:
             raise ValueError('Can only automatically duplicate source channels for mono sources, use RestructureFilterbank.')
         source = RestructureFilterbank(source, b.shape[0])
     Filterbank.__init__(self, source)
     if pycuda.context is None:
         set_gpu_device(0)
     self.precision=precision
     if self.precision=='double':
         self.precision_dtype=float64
     else:
         self.precision_dtype=float32
     self.forcesync=forcesync
     self.pagelocked_mem=pagelocked_mem
     n, m, p=b.shape
     self.filt_b=b
     self.filt_a=a
     filt_b_gpu=array(b, dtype=self.precision_dtype)
     filt_a_gpu=array(a, dtype=self.precision_dtype)
     filt_state=zeros((n, m-1, p), dtype=self.precision_dtype)
     if pagelocked_mem:
         filt_y=drv.pagelocked_zeros((n,), dtype=self.precision_dtype)
         self.pre_x=drv.pagelocked_zeros((n,), dtype=self.precision_dtype)
     else:
         filt_y=zeros(n, dtype=self.precision_dtype)
         self.pre_x=zeros(n, dtype=self.precision_dtype)
     self.filt_b_gpu=gpuarray.to_gpu(filt_b_gpu.T.flatten()) # transform to Fortran order for better GPU mem
     self.filt_a_gpu=gpuarray.to_gpu(filt_a_gpu.T.flatten()) # access speeds
     self.filt_state=gpuarray.to_gpu(filt_state.T.flatten())
     self.unroll_filterorder = unroll_filterorder
     if unroll_filterorder is None:
         if m<=32:
             unroll_filterorder = True
         else:
             unroll_filterorder = False
     # TODO: improve code, check memory access patterns, maybe use local memory
     code='''
     #define x(s,i) _x[(s)*n+(i)]
     #define y(s,i) _y[(s)*n+(i)]
     #define a(i,j,k) _a[(i)+(j)*n+(k)*n*m]
     #define b(i,j,k) _b[(i)+(j)*n+(k)*n*m]
     #define zi(i,j,k) _zi[(i)+(j)*n+(k)*n*(m-1)]
     __global__ void filt(SCALAR *_b, SCALAR *_a, SCALAR *_x, SCALAR *_zi, SCALAR *_y, int numsamples)
     {
         int j = blockIdx.x * blockDim.x + threadIdx.x;
         if(j>=n) return;
         for(int s=0; s<numsamples; s++)
         {
     '''
     for k in range(p):
         loopcode='''
         y(s,j) = b(j,0,k)*x(s,j) + zi(j,0,k);
         '''
         if unroll_filterorder:
             for i in range(m-2):
                 loopcode+=re.sub('\\bi\\b', str(i), '''
                 zi(j,i,k) = b(j,i+1,k)*x(s,j) + zi(j,i+1,k) - a(j,i+1,k)*y(s,j);
                 ''')
         else:
             loopcode+='''
             for(int i=0;i<m-2;i++)
                 zi(j,i,k) = b(j,i+1,k)*x(s,j) + zi(j,i+1,k) - a(j,i+1,k)*y(s,j);
             '''
         loopcode+='''
         zi(j,m-2,k) = b(j,m-1,k)*x(s,j) - a(j,m-1,k)*y(s,j);
         '''
         if k<p-1:
             loopcode+='''
             x(s,j) = y(s,j);
             '''
         loopcode=re.sub('\\bk\\b', str(k), loopcode)
         code+=loopcode
     code+='''
         }
     }
     '''
     code=code.replace('SCALAR', self.precision)
     code=re.sub("\\bp\\b", str(p), code) #replace the variable by their values
     code=re.sub("\\bm\\b", str(m), code)
     code=re.sub("\\bn\\b", str(n), code)
     #print code
     self.gpu_mod=pycuda.compiler.SourceModule(code)
     self.gpu_filt_func=self.gpu_mod.get_function("filt")
     blocksize=256
     if n<blocksize:
         blocksize=n
     if n%blocksize==0:
         gridsize=n/blocksize
     else:
         gridsize=n/blocksize+1
     self.block=(blocksize, 1, 1)
     self.grid=(gridsize, 1)
     self.gpu_filt_func.prepare((intp, intp, intp, intp, intp, int32), self.block)
     self._has_run_once=False
Beispiel #25
0
from filterbank import Filterbank
import numpy as np
import matplotlib.pyplot as plt
import os, fnmatch, random, re, csv, argparse

parser = argparse.ArgumentParser(description='Extract params from fils')
parser.add_argument('filename', type=str, help='Path to fil file')
args = parser.parse_args()
filename = args.filename

fil = Filterbank(filename)
source = fil.header['source_name']
file_data = fil.data[0][0]

#~~~~~~~~~~Functions~~~~~~~~~~


def band_finder(
    filename
):  #Classifies filterbank file into a band according to its middle freq
    fil = Filterbank(filename)
    fmax = fil.header['fch1']
    nchans = fil.header['nchans']
    ch_bandwidth = fil.header['foff']
    fmid = fmax + (nchans * ch_bandwidth) / 2.0
    if 1000 <= fmid < 2000:
        return 'L'
    elif 2000 <= fmid < 4000:
        return 'S'
    elif 4000 <= fmid < 8000:
        return 'C'