From 7d189f899575741b4e69f6c7fb606bc82974ae40 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 20:27:20 +1000 Subject: [PATCH 01/66] Consolidated blank_dc function This function was in both Filterbank and Waterfall classes, but was slightly different. The waterfall invocation was marginally better, albeit pretty much identical. This has been moved to Filterbank only, the Waterfall class will still have access through inheritance. --- blimpy/filterbank.py | 9 ++++----- blimpy/waterfall.py | 23 ----------------------- 2 files changed, 4 insertions(+), 28 deletions(-) diff --git a/blimpy/filterbank.py b/blimpy/filterbank.py index 8d21541e..62d35a26 100755 --- a/blimpy/filterbank.py +++ b/blimpy/filterbank.py @@ -397,7 +397,7 @@ def compute_lsrk(self): def blank_dc(self, n_coarse_chan): """ Blank DC bins in coarse channels. - Note: currently only works if entire blimpy file is read + Note: currently only works if entire file is read """ if n_coarse_chan < 1: @@ -410,14 +410,13 @@ def blank_dc(self, n_coarse_chan): n_coarse_chan = int(n_coarse_chan) - n_chan = self.data.shape[2] + n_chan = self.data.shape[-1] n_chan_per_coarse = n_chan / n_coarse_chan - mid_chan = n_chan_per_coarse / 2 + mid_chan = (n_chan_per_coarse / 2) - for ii in range(0, n_coarse_chan-1): + for ii in range(n_coarse_chan): ss = ii*n_chan_per_coarse -# self.data[..., ss+mid_chan-1] = self.data[..., ss+mid_chan] self.data[..., ss+mid_chan] = np.median(self.data[..., ss+mid_chan+5:ss+mid_chan+10]) def info(self): diff --git a/blimpy/waterfall.py b/blimpy/waterfall.py index d9e7b5a3..1e49f12c 100755 --- a/blimpy/waterfall.py +++ b/blimpy/waterfall.py @@ -496,30 +496,7 @@ def calc_n_coarse_chan(self): return n_coarse_chan - def blank_dc(self, n_coarse_chan): - """ Blank DC bins in coarse channels. - Note: currently only works if entire waterfall file is read - """ - - if n_coarse_chan < 1: - logger.warning('Coarse channel number < 1, unable to blank DC bin.') - return None - - if not n_coarse_chan % int(n_coarse_chan) == 0: - logger.warning('Selection does not contain an interger number of coarse channels, unable to blank DC bin.') - return None - - n_coarse_chan = int(n_coarse_chan) - - n_chan = self.data.shape[-1] - n_chan_per_coarse = n_chan / n_coarse_chan - - mid_chan = (n_chan_per_coarse / 2) - - for ii in range(n_coarse_chan): - ss = ii*n_chan_per_coarse - self.data[..., ss+mid_chan] = np.median(self.data[..., ss+mid_chan+5:ss+mid_chan+10]) def grab_data(self, f_start=None, f_stop=None,t_start=None, t_stop=None, if_id=0): """ Extract a portion of data by frequency range. From 2bdf80cc174664c901f9d662d265ff0ca859f89a Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 20:31:56 +1000 Subject: [PATCH 02/66] Removed unneccesary _flat_file_dimension This functionality can be done simply with np.array.size, or np.prod(np.array.shape) --- blimpy/file_wrapper.py | 21 ++++++--------------- 1 file changed, 6 insertions(+), 15 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index d488b02d..888c59c3 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -11,6 +11,8 @@ from astropy import units as u from astropy.coordinates import Angle +from . import sigproc + #import pdb;# pdb.set_trace() import logging @@ -241,25 +243,14 @@ def calc_n_coarse_chan(self): n_coarse_chan = bandwidth / coarse_chan_bw return n_coarse_chan - def calc_n_blobs(self,blob_dim): + def calc_n_blobs(self, blob_dim): """ Given the blob dimensions, calculate how many fit in the data selection. """ - n_blobs = int(np.ceil(self._flat_array_dimension(self.selection_shape) / float(self._flat_array_dimension(blob_dim)))) + n_blobs = int(np.ceil(np.prod(selection_shape)) / float(np.prod(blob_dim))) return n_blobs - def _flat_array_dimension(self, array_dim): - """Multiplies all the dimentions of an array. - """ - - array_flat_size = 1 - - for a_dim in array_dim: - array_flat_size*=a_dim - - return array_flat_size - class H5_reader(Reader): """ This class handles .h5 files. """ @@ -759,8 +750,8 @@ def read_blob(self,blob_dim,n_blob=0): #Assuming the blob will loop over the whole frequency range. if self.f_start == self.f_begin and self.f_stop == self.f_end: - blob_flat_size = self._flat_array_dimension(blob_dim) - updated_blob_flat_size = self._flat_array_dimension(updated_blob_dim) + blob_flat_size = np.prod(blob_dim) + updated_blob_flat_size = np.prod(updated_blob_dim) #Load binary data with open(self.filename, 'rb') as f: From c51574baaf17710ea42e7bc129328a3ce5fd5946 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 20:40:56 +1000 Subject: [PATCH 03/66] Modified calc_n_coarse_channels to support GBT and Parkes EE: Please check this does what you think it should. --- blimpy/file_wrapper.py | 34 ++++++++++++++++++---------------- 1 file changed, 18 insertions(+), 16 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index 888c59c3..8ba902ab 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -223,25 +223,27 @@ def populate_freqs(self): def calc_n_coarse_chan(self): """ This makes an attempt to calculate the number of coarse channels in a given file. - It assumes for now that a single coarse channel is 2.9296875 MHz - """ - # Could add a telescope based coarse channel bandwidth, or other discriminative. - # if telescope_id == 'GBT': - # or actually as is currently - # if self.header['telescope_id'] == 6: + Note: + This is unlikely to work on non-Breakthrough Listen data, as a-priori knowledge of + the digitizer system is required. + For Parkes, it assumes 2^20 point FFTs. + For GBT, it assumes channel bandwidth 2.9296875 MHz + """ + nchans = int(self.header['nchans']) + if self.header['telescope_id'] == 6: + coarse_chan_bw = 2.9296875 + bandwidth = abs(self.f_stop - self.f_start) + n_coarse_chan = int(bandwidth / coarse_chan_bw) + return n_coarse_chan - nchans = int(self.header['nchans']) - # For 3 Hz channels we are using 2^20 length FFTs -#EE: not all 3Hz data has 2^20 FFT length... -# if nchans >= 1048576: -# return int(nchans / 1048576) -# else: - coarse_chan_bw = 2.9296875 - bandwidth = abs(self.f_stop - self.f_start) - n_coarse_chan = bandwidth / coarse_chan_bw - return n_coarse_chan + elif self.header['telescope_id'] == 4: + # For 3 Hz channels we are using 2^20 length FFTs + if nchans >= 2**20: + return int(nchans / 2**20) + else: + raise RuntimeError("This function currently only works for BL Parkes or GBT data.") def calc_n_blobs(self, blob_dim): """ Given the blob dimensions, calculate how many fit in the data selection. From 6259aba09d80b15e6073405aff1e00255a4caee3 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 20:45:14 +1000 Subject: [PATCH 04/66] Updated calc_n_blobs for readability --- blimpy/file_wrapper.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index 8ba902ab..81c70fa7 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -249,7 +249,7 @@ def calc_n_blobs(self, blob_dim): """ Given the blob dimensions, calculate how many fit in the data selection. """ - n_blobs = int(np.ceil(np.prod(selection_shape)) / float(np.prod(blob_dim))) + n_blobs = int(np.ceil(1.0 * np.prod(self.selection_shape) / np.prod(blob_dim))) return n_blobs From 7fe834c96bfb6cf548208ebdca5feba399f5119e Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 21:07:27 +1000 Subject: [PATCH 05/66] PEP8: Classes FIL_reader and H5_reader -> FilReader and H5Reader (CamelCase for classes in PEP8) --- blimpy/file_wrapper.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index 81c70fa7..35578c03 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -253,7 +253,7 @@ def calc_n_blobs(self, blob_dim): return n_blobs -class H5_reader(Reader): +class H5Reader(Reader): """ This class handles .h5 files. """ @@ -267,6 +267,7 @@ def __init__(self, filename, f_start=None, f_stop=None, t_start=None, t_stop=Non t_start (int): start time bin t_stop (int): stop time bin """ + super(H5Reader, self).__init__() if filename and os.path.isfile(filename) and h5py.is_hdf5(filename): @@ -421,7 +422,7 @@ def read_blob(self,blob_dim,n_blob=0): -class FIL_reader(Reader): +class FilReader(Reader): """ This class handles .fil files. """ @@ -435,6 +436,7 @@ def __init__(self, filename,f_start=None, f_stop=None,t_start=None, t_stop=None, t_start (int): start time bin t_stop (int): stop time bin """ + super(FilReader, self).__init__() self._set_header_keywords_types() @@ -848,10 +850,10 @@ def open_file(filename, f_start=None, f_stop=None,t_start=None, t_stop=None,load if ext == 'h5': # Open HDF5 file - return H5_reader(filename,f_start=f_start, f_stop=f_stop,t_start=t_start, t_stop=t_stop,load_data=load_data,max_load=max_load) + return H5Reader(filename, f_start=f_start, f_stop=f_stop, t_start=t_start, t_stop=t_stop, load_data=load_data, max_load=max_load) elif ext == 'fil': # Open FIL file - return FIL_reader(filename,f_start=f_start, f_stop=f_stop,t_start=t_start, t_stop=t_stop,load_data=load_data,max_load=max_load) + return FilReader(filename, f_start=f_start, f_stop=f_stop, t_start=t_start, t_stop=t_stop, load_data=load_data, max_load=max_load) else: # Fall back to regular Python `open` function return open(filename, *args, **kwargs) From c414291b5a77d59b7c548171f51d25ef2f1713a7 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 21:11:47 +1000 Subject: [PATCH 06/66] Removing duplicated code from sigproc.py: header_keyword_types --- blimpy/file_wrapper.py | 33 +-------------------------------- 1 file changed, 1 insertion(+), 32 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index 35578c03..6ea5a558 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -418,10 +418,6 @@ def read_blob(self,blob_dim,n_blob=0): return blob - - - - class FilReader(Reader): """ This class handles .fil files. """ @@ -438,7 +434,7 @@ def __init__(self, filename,f_start=None, f_stop=None,t_start=None, t_stop=None, """ super(FilReader, self).__init__() - self._set_header_keywords_types() + self.header_keywords_types = sigproc.header_keyword_types if filename and os.path.isfile(filename): self.filename = filename @@ -514,33 +510,6 @@ def __init__(self, filename,f_start=None, f_stop=None,t_start=None, t_stop=None, else: raise IOError("Need a file to open, please give me one!") - def _set_header_keywords_types(self): - self._header_keyword_types = { - 'telescope_id' : ' Date: Sun, 3 Jun 2018 21:13:16 +1000 Subject: [PATCH 07/66] Removing duplicated code from sigproc.py: fil_double_to_angle --- blimpy/file_wrapper.py | 21 +-------------------- 1 file changed, 1 insertion(+), 20 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index 6ea5a558..7c64eab9 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -573,7 +573,7 @@ def _read_next_header_keyword(self,fh): val = fh.read(str_len) if dtype == 'angle': val = struct.unpack(' Date: Sun, 3 Jun 2018 21:14:37 +1000 Subject: [PATCH 08/66] Removing duplicated code from sigproc.py: read_next_header_keyword --- blimpy/file_wrapper.py | 42 ++---------------------------------------- 1 file changed, 2 insertions(+), 40 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index 7c64eab9..d5086643 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -542,44 +542,6 @@ def _len_header(self): idx_end = (header_sub_count -1) * 512 + idx_end return idx_end - def _read_next_header_keyword(self,fh): - """ - - Args: - fh (file): file handler - - Returns: - """ - n_bytes = np.fromstring(fh.read(4), dtype='uint32')[0] - - if n_bytes > 255: - n_bytes = 16 - - keyword = fh.read(n_bytes) - - #print keyword - - if keyword == 'HEADER_START' or keyword == 'HEADER_END': - return keyword, 0, fh.tell() - else: - dtype = self._header_keyword_types[keyword] - idx = fh.tell() - if dtype == ' Date: Sun, 3 Jun 2018 21:18:28 +1000 Subject: [PATCH 09/66] Removing duplicated code from sigproc.py: read_header --- blimpy/file_wrapper.py | 32 +++++--------------------------- 1 file changed, 5 insertions(+), 27 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index d5086643..69cb5532 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -439,7 +439,7 @@ def __init__(self, filename,f_start=None, f_stop=None,t_start=None, t_stop=None, if filename and os.path.isfile(filename): self.filename = filename self.load_data = load_data - self.header = self._read_header() + self.header = self.read_header() self.file_size_bytes = os.path.getsize(self.filename) self.idx_data = self._len_header() self.n_channels_in_file = self.header['nchans'] @@ -542,7 +542,7 @@ def _len_header(self): idx_end = (header_sub_count -1) * 512 + idx_end return idx_end - def _read_header(self, return_idxs=False): + def read_header(self, return_idxs=False): """ Read blimpy header and return a Python dictionary of key:value pairs Args: @@ -552,33 +552,11 @@ def _read_header(self, return_idxs=False): return_idxs (bool): Default False. If true, returns the file offset indexes for values - returns + Returns: + Python dict of key:value pairs, OR returns file offset indexes for values. """ - with open(self.filename, 'rb') as fh: - header_dict = {} - header_idxs = {} - - # Check this is a blimpy file - keyword, value, idx = sigproc.read_next_header_keyword(fh) - - try: - assert keyword == 'HEADER_START' - except AssertionError: - raise RuntimeError("Not a valid blimpy file.") - - while True: - keyword, value, idx = sigproc.read_next_header_keyword(fh) - if keyword == 'HEADER_END': - break - else: - header_dict[keyword] = value - header_idxs[keyword] = idx - - if return_idxs: - return header_idxs - else: - return header_dict + return sigproc.read_header(self.filename, return_idxs=False) def read_data(self, f_start=None, f_stop=None,t_start=None, t_stop=None): """ Read data. From 2f23a4ec92748bf8fcabd70ac440f95321a1e0e8 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 21:20:38 +1000 Subject: [PATCH 10/66] Removing duplicated code from sigproc.py: len_header --- blimpy/file_wrapper.py | 25 +------------------------ 1 file changed, 1 insertion(+), 24 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index 69cb5532..d894ee45 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -441,7 +441,7 @@ def __init__(self, filename,f_start=None, f_stop=None,t_start=None, t_stop=None, self.load_data = load_data self.header = self.read_header() self.file_size_bytes = os.path.getsize(self.filename) - self.idx_data = self._len_header() + self.idx_data = sigproc.len_header(self.filename) self.n_channels_in_file = self.header['nchans'] self.n_beams_in_file = self.header['nifs'] #Placeholder for future development. self.n_pols_in_file = 1 #Placeholder for future development. @@ -519,29 +519,6 @@ def _get_n_ints_in_file(self): n_bytes_data = self.file_size_bytes - self.idx_data self.n_ints_in_file = n_bytes_data / (n_bytes * n_chans * n_ifs) - def _len_header(self): - """ Return the length of the blimpy header, in bytes - - Args: - filename (str): name of file to open - - Returns: - idx_end (int): length of header, in bytes - """ - with open(self.filename, 'rb') as f: - header_sub_count = 0 - eoh_found = False - while not eoh_found: - header_sub = f.read(512) - header_sub_count += 1 - if 'HEADER_END' in header_sub: - idx_end = header_sub.index('HEADER_END') + len('HEADER_END') - eoh_found = True - break - - idx_end = (header_sub_count -1) * 512 + idx_end - return idx_end - def read_header(self, return_idxs=False): """ Read blimpy header and return a Python dictionary of key:value pairs From 79d628b5c1d4eebe37fc153b0bd5fea2a8cf2d9f Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 21:24:25 +1000 Subject: [PATCH 11/66] Removed _ from read_header in H5 and Fil Readers Also made read_header return the parsed dictionary, for consistency with FilReader.read_header() Now both H5 and Fil readers return a dictionary, which is useful. --- blimpy/file_wrapper.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index d894ee45..8d763159 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -282,7 +282,7 @@ def __init__(self, filename, f_start=None, f_stop=None, t_start=None, t_stop=Non self.filesize = self.filestat.st_size/(1024.0**2) self.load_data = load_data self.h5 = h5py.File(self.filename) - self._read_header() + self.read_header() self.file_size_bytes = os.path.getsize(self.filename) # In bytes self.n_ints_in_file = self.h5["data"].shape[self.time_axis] # self.n_channels_in_file = self.h5["data"].shape[self.freq_axis] # @@ -344,7 +344,7 @@ def __init__(self, filename, f_start=None, f_stop=None, t_start=None, t_stop=Non else: raise IOError("Need a file to open, please give me one!") - def _read_header(self): + def read_header(self): """ Read header and return a Python dictionary of key:value pairs """ @@ -358,6 +358,8 @@ def _read_header(self): else: self.header[key] = val + return self.header + def _find_blob_start(self,blob_dim,n_blob): """Find first blob from selection. """ From 11bdc7a05469dd61f759968fea53ed5a95422874 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 21:29:07 +1000 Subject: [PATCH 12/66] Shuffled order of methods so _methods first, then populate, etc --- blimpy/file_wrapper.py | 67 ++++++++++++++++++++++-------------------- 1 file changed, 35 insertions(+), 32 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index 8d763159..c5535492 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -106,28 +106,7 @@ def _setup_dtype(self): elif self._n_bytes == 1: return 'int8' - def populate_timestamps(self,update_header=False): - """ Populate time axis. - IF update_header then only return tstart - """ - - #Check to see how many integrations requested - ii_start, ii_stop = 0, self.n_ints_in_file - if self.t_start: - ii_start = self.t_start - if self.t_stop: - ii_stop = self.t_stop - - ## Setup time axis - t0 = self.header['tstart'] - t_delt = self.header['tsamp'] - - if update_header: - timestamps = ii_start * t_delt / 24./60./60 + t0 - else: - timestamps = np.arange(ii_start, ii_stop) * t_delt / 24./60./60 + t0 - return timestamps def _calc_selection_size(self): """Calculate size of data of interest. @@ -143,17 +122,6 @@ def _calc_selection_size(self): return selection_size - def isheavy(self): - """ Check if the current selection is too large. - """ - - selection_size_bytes = self._calc_selection_size() - - if selection_size_bytes > self.MAX_DATA_ARRAY_SIZE: - return True - else: - return False - def _calc_selection_shape(self): """Calculate shape of data of interest. """ @@ -203,6 +171,29 @@ def _setup_freqs(self): self.f_start = self.f_end - self.chan_stop_idx*abs(self.header['foff']) self.f_stop = self.f_end - self.chan_start_idx*abs(self.header['foff']) + def populate_timestamps(self,update_header=False): + """ Populate time axis. + IF update_header then only return tstart + """ + + #Check to see how many integrations requested + ii_start, ii_stop = 0, self.n_ints_in_file + if self.t_start: + ii_start = self.t_start + if self.t_stop: + ii_stop = self.t_stop + + ## Setup time axis + t0 = self.header['tstart'] + t_delt = self.header['tsamp'] + + if update_header: + timestamps = ii_start * t_delt / 24./60./60 + t0 + else: + timestamps = np.arange(ii_start, ii_stop) * t_delt / 24./60./60 + t0 + + return timestamps + def populate_freqs(self): """ Populate frequency axis @@ -253,6 +244,18 @@ def calc_n_blobs(self, blob_dim): return n_blobs + def isheavy(self): + """ Check if the current selection is too large. + """ + + selection_size_bytes = self._calc_selection_size() + + if selection_size_bytes > self.MAX_DATA_ARRAY_SIZE: + return True + else: + return False + + class H5Reader(Reader): """ This class handles .h5 files. """ From 2e63830b91fe09eb5b88d3993e6b9f6344aa3193 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 21:30:09 +1000 Subject: [PATCH 13/66] Renamed _get_n_ints_in_file to _setup_n_ints_in_file for consistency Other methods such as _setup_freqs and _setup_chans --- blimpy/file_wrapper.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index c5535492..6ea19ac8 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -452,7 +452,7 @@ def __init__(self, filename,f_start=None, f_stop=None,t_start=None, t_stop=None, self.n_pols_in_file = 1 #Placeholder for future development. self._n_bytes = self.header['nbits'] / 8 #number of bytes per digit. self._d_type = self._setup_dtype() - self._get_n_ints_in_file() + self._setup_n_ints_in_file() self.file_shape = (self.n_ints_in_file,self.n_beams_in_file,self.n_channels_in_file) if self.header['foff'] < 0: @@ -515,7 +515,7 @@ def __init__(self, filename,f_start=None, f_stop=None,t_start=None, t_stop=None, else: raise IOError("Need a file to open, please give me one!") - def _get_n_ints_in_file(self): + def _setup_n_ints_in_file(self): n_bytes = self._n_bytes n_chans = self.n_channels_in_file From d83f7a2b5e544d07b3b595b2e7a961b412d17d96 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 21:31:31 +1000 Subject: [PATCH 14/66] Added a docstring and propagate return_idxs in read_header --- blimpy/file_wrapper.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index 6ea19ac8..b45cb9c4 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -516,7 +516,7 @@ def __init__(self, filename,f_start=None, f_stop=None,t_start=None, t_stop=None, raise IOError("Need a file to open, please give me one!") def _setup_n_ints_in_file(self): - + """ Calculate the number of integrations in the file. """ n_bytes = self._n_bytes n_chans = self.n_channels_in_file n_ifs = self.n_beams_in_file @@ -538,7 +538,7 @@ def read_header(self, return_idxs=False): Python dict of key:value pairs, OR returns file offset indexes for values. """ - return sigproc.read_header(self.filename, return_idxs=False) + return sigproc.read_header(self.filename, return_idxs=return_idxs) def read_data(self, f_start=None, f_stop=None,t_start=None, t_stop=None): """ Read data. From 2a3721eb4e81636fb441e16aab05b1d8fbeeded7 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 21:32:12 +1000 Subject: [PATCH 15/66] Delete unused struct import --- blimpy/file_wrapper.py | 1 - 1 file changed, 1 deletion(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index b45cb9c4..b9ac9dbc 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -4,7 +4,6 @@ import os import sys -import struct import numpy as np import h5py From 5ec6a058eaa3fe5e3909d8f9ff22d395929014ca Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 21:32:36 +1000 Subject: [PATCH 16/66] Remove unused astropy units import --- blimpy/file_wrapper.py | 1 - 1 file changed, 1 deletion(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index b9ac9dbc..f994b48c 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -7,7 +7,6 @@ import numpy as np import h5py -from astropy import units as u from astropy.coordinates import Angle from . import sigproc From 55909fd255326a9b03e9143a131e40c8fffd4239 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 21:36:10 +1000 Subject: [PATCH 17/66] Typo and sanity check on read_header --- blimpy/file_wrapper.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index f994b48c..6dd2efc7 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -11,7 +11,7 @@ from . import sigproc -#import pdb;# pdb.set_trace() +# import pdb;# pdb.set_trace() import logging logger = logging.getLogger(__name__) @@ -27,6 +27,7 @@ logging.basicConfig(format=format,stream=stream,level = level_log) + class Reader(object): """ Basic reader object """ @@ -37,7 +38,7 @@ def _setup_selection_range(self, f_start=None, f_stop=None, t_start=None, t_stop init (bool): If call during __init__ """ - #This avoids reseting values + # This avoids resetting values if not init: if not f_start: f_start = self.f_start @@ -536,7 +537,8 @@ def read_header(self, return_idxs=False): Python dict of key:value pairs, OR returns file offset indexes for values. """ - return sigproc.read_header(self.filename, return_idxs=return_idxs) + self.header = sigproc.read_header(self.filename, return_idxs=return_idxs) + return self.header def read_data(self, f_start=None, f_stop=None,t_start=None, t_stop=None): """ Read data. From e5c068421fa1e4e211436c0874f668c4fd84a8bd Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 21:48:27 +1000 Subject: [PATCH 18/66] Adding basic test of Waterfall() reader --- tests/test_compare_voyager.py | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 tests/test_compare_voyager.py diff --git a/tests/test_compare_voyager.py b/tests/test_compare_voyager.py new file mode 100644 index 00000000..e5a58c4e --- /dev/null +++ b/tests/test_compare_voyager.py @@ -0,0 +1,35 @@ +import blimpy as bl +import numpy as np +from pprint import pprint + +def compare_waterfall_fil_to_h5(): + """ Load Voyager dataset and test that both fil and hdf5 readers return same headers and data """ + + print("Loading FIL and HDF5 data with Waterfall()..."), + a = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.h5') + b = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.fil') + print("OK") + + print("Reading headers..") + print("\nHDF5 file header:") + pprint(a.header) + print("\nFIL file header:") + pprint(b.header) + print("Headers are loading OK") + + print("\nChecking header values match..."), + for key in b.header.keys(): + assert b.header[key] == a.header[key] + print("OK") + + print("Checking datatype matches..."), + assert a.data.dtype == b.data.dtype + print("OK") + + print("Checking data matches..."), + assert np.allclose(a.data, b.data) + assert a.data.dtype == b.data.dtype + print("OK") + +if __name__ == "__main__": + compare_waterfall_fil_to_h5() \ No newline at end of file From df5e05a415d2b3bb1c215bcddc55d2cbf2523c3d Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 22:22:23 +1000 Subject: [PATCH 19/66] set_useOffset raised an error (matplotlib version issue?), use rcParams At top setting plt.rcParams['axes.formatter.useoffset'] = False instead of calling ax.get_xaxis().get_major_formatter().set_useOffset(False) This means fewer lines of code, but should be more resilient to matplotlib versions that don't support this API. --- blimpy/filterbank.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/blimpy/filterbank.py b/blimpy/filterbank.py index 62d35a26..6df6f121 100755 --- a/blimpy/filterbank.py +++ b/blimpy/filterbank.py @@ -64,6 +64,8 @@ matplotlib.use('Agg') import pylab as plt +plt.rcParams['axes.formatter.useoffset'] = False + ### # Config values @@ -581,7 +583,6 @@ def plot_spectrum(self, t=0, f_start=None, f_stop=None, logged=False, if_id=0, c except KeyError: plt.title(self.filename) - ax.get_xaxis().get_major_formatter().set_useOffset(False) plt.xlim(plot_f[0], plot_f[-1]) def plot_spectrum_min_max(self, t=0, f_start=None, f_stop=None, logged=False, if_id=0, c=None, **kwargs): @@ -646,7 +647,6 @@ def plot_spectrum_min_max(self, t=0, f_start=None, f_stop=None, logged=False, if except KeyError: plt.title(self.filename) - ax.get_xaxis().get_major_formatter().set_useOffset(False) plt.xlim(plot_f[0], plot_f[-1]) if logged: plt.ylim(db(fig_min),db(fig_max)) @@ -744,7 +744,6 @@ def plot_time_series(self, f_start=None, f_stop=None, if_id=0, logged=True, orie plt.xlabel(xlabel) ax.autoscale(axis='both',tight=True) - ax.get_xaxis().get_major_formatter().set_useOffset(False) def plot_kurtosis(self, f_start=None, f_stop=None, if_id=0, **kwargs): """ Plot kurtosis @@ -772,7 +771,6 @@ def plot_kurtosis(self, f_start=None, f_stop=None, if_id=0, **kwargs): plt.ylabel("Kurtosis") plt.xlabel("Frequency [MHz]") - ax.get_xaxis().get_major_formatter().set_useOffset(False) plt.xlim(plot_f[0], plot_f[-1]) def plot_all(self, t=0, f_start=None, f_stop=None, logged=False, if_id=0, kutosis=True, **kwargs): From 6f5281dae36847be36a6cad914c57ff01dc98bc1 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 22:27:35 +1000 Subject: [PATCH 20/66] Modify plot_time_series so unit test passes. plot_time_series was failing if orientation=None --- blimpy/filterbank.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/blimpy/filterbank.py b/blimpy/filterbank.py index 6df6f121..6c56d0fa 100755 --- a/blimpy/filterbank.py +++ b/blimpy/filterbank.py @@ -705,7 +705,7 @@ def plot_waterfall(self, f_start=None, f_stop=None, if_id=0, logged=True,cb=True else: plt.ylabel("Time [s]") - def plot_time_series(self, f_start=None, f_stop=None, if_id=0, logged=True, orientation=None,MJD_time=False, **kwargs): + def plot_time_series(self, f_start=None, f_stop=None, if_id=0, logged=True, orientation=None, MJD_time=False, **kwargs): """ Plot the time series. Args: @@ -736,9 +736,13 @@ def plot_time_series(self, f_start=None, f_stop=None, if_id=0, logged=True, orie else: xlabel = "Time [s]" - #Reverse oder if vertical orientation. - if 'v' in orientation: - plt.plot(plot_data, plot_t[::-1], **kwargs) + # Reverse oder if vertical orientation. + if orientation is not None: + if 'v' in orientation: + plt.plot(plot_data, plot_t[::-1], **kwargs) + else: + plt.plot(plot_t, plot_data, **kwargs) + plt.xlabel(xlabel) else: plt.plot(plot_t, plot_data, **kwargs) plt.xlabel(xlabel) From 0f756840c2c204c8902efc2bec6caef30dd4bf0a Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 22:32:35 +1000 Subject: [PATCH 21/66] Minor tidy-up for PEP8 We are not strictly following PEP8 but fixing some simple things --- blimpy/file_wrapper.py | 28 ++++++++++++++++------------ 1 file changed, 16 insertions(+), 12 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index 6dd2efc7..68006fb4 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -20,17 +20,22 @@ if level_log == logging.INFO: stream = sys.stdout - format = '%(name)-15s %(levelname)-8s %(message)s' + lformat = '%(name)-15s %(levelname)-8s %(message)s' else: stream = sys.stderr - format = '%%(relativeCreated)5d (name)-15s %(levelname)-8s %(message)s' + lformat = '%%(relativeCreated)5d (name)-15s %(levelname)-8s %(message)s' -logging.basicConfig(format=format,stream=stream,level = level_log) +logging.basicConfig(format=lformat, stream=stream, level=level_log) class Reader(object): """ Basic reader object """ + def __init__(self): + + self.t_begin = 0 + self.t_end = 0 + def _setup_selection_range(self, f_start=None, f_stop=None, t_start=None, t_stop=None, init=False): """Making sure the selection if time and frequency are within the file limits. @@ -255,7 +260,7 @@ def isheavy(self): return False -class H5Reader(Reader): +class H5Reader(Reader): """ This class handles .h5 files. """ @@ -286,8 +291,8 @@ def __init__(self, filename, f_start=None, f_stop=None, t_start=None, t_stop=Non self.h5 = h5py.File(self.filename) self.read_header() self.file_size_bytes = os.path.getsize(self.filename) # In bytes - self.n_ints_in_file = self.h5["data"].shape[self.time_axis] # - self.n_channels_in_file = self.h5["data"].shape[self.freq_axis] # + self.n_ints_in_file = self.h5["data"].shape[self.time_axis] # + self.n_channels_in_file = self.h5["data"].shape[self.freq_axis] # self.n_beams_in_file = self.header['nifs'] #Placeholder for future development. self.n_pols_in_file = 1 #Placeholder for future development. self._n_bytes = self.header['nbits'] / 8 #number of bytes per digit. @@ -295,11 +300,11 @@ def __init__(self, filename, f_start=None, f_stop=None, t_start=None, t_stop=Non self.file_shape = (self.n_ints_in_file,self.n_beams_in_file,self.n_channels_in_file) if self.header['foff'] < 0: - self.f_end = self.header['fch1'] - self.f_begin = self.f_end + self.n_channels_in_file*self.header['foff'] + self.f_end = self.header['fch1'] + self.f_begin = self.f_end + self.n_channels_in_file*self.header['foff'] else: - self.f_begin = self.header['fch1'] - self.f_end = self.f_begin + self.n_channels_in_file*self.header['foff'] + self.f_begin = self.header['fch1'] + self.f_end = self.f_begin + self.n_channels_in_file*self.header['foff'] self.t_begin = 0 self.t_end = self.n_ints_in_file @@ -422,7 +427,7 @@ def read_blob(self,blob_dim,n_blob=0): return blob -class FilReader(Reader): +class FilReader(Reader): """ This class handles .fil files. """ @@ -729,4 +734,3 @@ def open_file(filename, f_start=None, f_stop=None,t_start=None, t_stop=None,load else: # Fall back to regular Python `open` function return open(filename, *args, **kwargs) - From eac357ba82296c0a85ca5c51a0aed7bd52fce352 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 22:34:03 +1000 Subject: [PATCH 22/66] Removing unused imports and adding fail-over for non-package usage --- blimpy/file_wrapper.py | 5 ++++- blimpy/filterbank.py | 7 +------ 2 files changed, 5 insertions(+), 7 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index 68006fb4..a7a48659 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -9,7 +9,10 @@ from astropy.coordinates import Angle -from . import sigproc +try: + from . import sigproc +except: + import sigproc # import pdb;# pdb.set_trace() diff --git a/blimpy/filterbank.py b/blimpy/filterbank.py index 6c56d0fa..4a8dbfbd 100755 --- a/blimpy/filterbank.py +++ b/blimpy/filterbank.py @@ -21,14 +21,9 @@ """ -import os + import sys -import struct -import numpy as np -from pprint import pprint -from astropy import units as u -from astropy.coordinates import Angle from astropy.time import Time import scipy.stats from matplotlib.ticker import NullFormatter From 848e19ca2c28a052d167074f3a93730b92394abb Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 22:37:46 +1000 Subject: [PATCH 23/66] Removed gen_from_header function in filterbank.py This function was a helper, that was never used and confusing. No functionality has been lost. --- blimpy/filterbank.py | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-) diff --git a/blimpy/filterbank.py b/blimpy/filterbank.py index 4a8dbfbd..e9fe3a3d 100755 --- a/blimpy/filterbank.py +++ b/blimpy/filterbank.py @@ -120,7 +120,13 @@ def __init__(self, filename=None, f_start=None, f_stop=None, else: self.read_filterbank(filename, f_start, f_stop, t_start, t_stop, load_data) elif header_dict is not None and data_array is not None: - self.gen_from_header(header_dict, data_array) + self.filename = b'' + self.header = header_dict + self.data = data_array + self.n_ints_in_file = 0 + + self._setup_freqs() + else: pass @@ -133,16 +139,6 @@ def __init__(self, filename=None, f_start=None, f_stop=None, print("Calibrating the band pass.") self.calibrate_band_pass_N1() - - def gen_from_header(self, header_dict, data_array, f_start=None, f_stop=None, - t_start=None, t_stop=None, load_data=True): - self.filename = b'' - self.header = header_dict - self.data = data_array - self.n_ints_in_file = 0 - - self._setup_freqs() - def read_hdf5(self, filename, f_start=None, f_stop=None, t_start=None, t_stop=None, load_data=True): From 789cafe2a3ae130647a70ef3bbf70022f2e0ea5e Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 22:39:34 +1000 Subject: [PATCH 24/66] Removed unsupported keyword arguments in read_hdf5 --- blimpy/filterbank.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/blimpy/filterbank.py b/blimpy/filterbank.py index e9fe3a3d..fc9cbf3d 100755 --- a/blimpy/filterbank.py +++ b/blimpy/filterbank.py @@ -139,8 +139,7 @@ def __init__(self, filename=None, f_start=None, f_stop=None, print("Calibrating the band pass.") self.calibrate_band_pass_N1() - def read_hdf5(self, filename, f_start=None, f_stop=None, - t_start=None, t_stop=None, load_data=True): + def read_hdf5(self, filename, load_data=True): print("Warning: this function will be deprecated in the future. Please use Waterfall to open HDF5 files.") # raise DeprecationWarning('Please use Waterfall to open HDF5 files.') From 602ee313d6cf5646e96cea9d8d863e9c0ff04e79 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 23:04:10 +1000 Subject: [PATCH 25/66] _find_blob_start tidy: doesn't actually use blob_dim in fil reader although blob_dim is a keyword argument, it isn't actually used. --- blimpy/file_wrapper.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index a7a48659..f65aa826 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -370,7 +370,7 @@ def read_header(self): return self.header - def _find_blob_start(self,blob_dim,n_blob): + def _find_blob_start(self, blob_dim, n_blob): """Find first blob from selection. """ @@ -383,7 +383,7 @@ def _find_blob_start(self,blob_dim,n_blob): #Check which is the blob frequency offset (in channels) blob_freq_start = self.chan_start_idx + (blob_dim[self.freq_axis]*n_blob)%self.selection_shape[self.freq_axis] - blob_start = np.array([blob_time_start,0,blob_freq_start]) + blob_start = np.array([blob_time_start, 0, blob_freq_start]) return blob_start @@ -595,20 +595,20 @@ def read_data(self, f_start=None, f_stop=None,t_start=None, t_stop=None): f.seek(self._n_bytes * (n_chans - self.chan_stop_idx), 1) # Seek to start of next block - def _find_blob_start(self,blob_dim): + def _find_blob_start(self): """Find first blob from selection. """ - #Convert input frequencies into what their corresponding channel number would be. + # Convert input frequencies into what their corresponding channel number would be. self._setup_chans() - #Check which is the blob time offset + # Check which is the blob time offset blob_time_start = self.t_start - #Check which is the blob frequency offset (in channels) + # Check which is the blob frequency offset (in channels) blob_freq_start = self.chan_start_idx - blob_start = blob_time_start*self.n_channels_in_file + blob_freq_start + blob_start = blob_time_start * self.n_channels_in_file + blob_freq_start return blob_start From fd82448d76955948a6816e07597ee8dbc4b0191e Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 23:19:35 +1000 Subject: [PATCH 26/66] Added new tests in test_compare_voyager --- tests/test_compare_voyager.py | 99 ++++++++++++++++++++++++++++++++++- 1 file changed, 98 insertions(+), 1 deletion(-) diff --git a/tests/test_compare_voyager.py b/tests/test_compare_voyager.py index e5a58c4e..1ada212e 100644 --- a/tests/test_compare_voyager.py +++ b/tests/test_compare_voyager.py @@ -31,5 +31,102 @@ def compare_waterfall_fil_to_h5(): assert a.data.dtype == b.data.dtype print("OK") +def compare_waterfall_fil_to_h5_methods_and_attributes(): + """ Compare attributes and check methods """ + a = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.h5') + b = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.fil') + + print("Comparing attributes of classes match where expected") + assert a.beam_axis == b.beam_axis + assert a.freq_axis == b.freq_axis + assert a.time_axis == b.time_axis + #assert a.stokes_axis == b.stokes_axis # Fil shouldn't have stokes axis ... + + assert a.calc_n_coarse_chan() == b.calc_n_coarse_chan() + assert a.file_shape == b.file_shape + + assert a.n_channels_in_file == b.n_channels_in_file + assert a.n_ints_in_file == b.n_ints_in_file + assert a.selection_shape == b.selection_shape + + print("Checking if basic methods run without raising Exceptions") + # Check they can be run + a.populate_freqs() + a.populate_timestamps() + a.info() + a.blank_dc(1) + a.calibrate_band_pass_N1() + + b.populate_freqs() + b.populate_timestamps() + b.info() + b.blank_dc(1) + b.calibrate_band_pass_N1() + + # TODO: 'compute_lsrk' -- need PYSLALIB + # TODO: 'compute_lst' -- need PYSLALIB + + # Expected to differ between: 'ext', 'file_size_bytes', 'filename', 'container' + # Unused? Inherited from Filterbank.py 'gen_from_header', 'generate_freqs', 'read_filterbank', 'read_hdf5' + + # TODO: 'grab_data', + # TODO: 'read_data', + # TODO: 'write_to_fil', + # TODO: 'write_to_filterbank', + # TODO: 'write_to_hdf5'] + + dir_a = dir(a) + dir_b = dir(b) + + print("Attr/methods in HDF5 but not in FIL:") + for item in dir_a: + if item not in dir_b: + print(item) + + print("Attr/methods in FIL but not in HDF5:") + for item in dir_b: + if item not in dir_a: + print(item) + +def compare_waterfall_fil_h5_conatiners(): + """ Compare the two containers for fil.container and h5.container """ + a = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.h5') + b = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.fil') + + dir_a = dir(a.container) + dir_b = dir(b.container) + + print("Attr/methods in HDF5 container but not in FIL:") + for item in dir_a: + if item not in dir_b: + print(item) + + print("Attr/methods in FIL container but not in HDF5:") + for item in dir_b: + if item not in dir_a: + print(item) + +def test_plotting_doesnt_cause_exceptions(): + """ Try running the plotting routines. They should not raise expections even without X windows """ + a = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.h5') + b = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.fil') + + a.plot_all() + a.plot_kurtosis() + a.plot_spectrum() + a.plot_spectrum_min_max() + a.plot_waterfall() + a.plot_time_series() + + b.plot_all() + b.plot_kurtosis() + b.plot_spectrum() + b.plot_spectrum_min_max() + b.plot_waterfall() + b.plot_time_series() + if __name__ == "__main__": - compare_waterfall_fil_to_h5() \ No newline at end of file + compare_waterfall_fil_to_h5() + compare_waterfall_fil_to_h5_methods_and_attributes() + compare_waterfall_fil_h5_conatiners() + test_plotting_doesnt_cause_exceptions() \ No newline at end of file From a38b45d7bc4c8ae78196987ac4c9b58c7ffa71bf Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 23:21:00 +1000 Subject: [PATCH 27/66] Follow-up on removal of gen_from_header. Not sure we still need / use this functionality (generation of a filterbank file from a header and data blob), perhaps it could be removed in the future. --- blimpy/waterfall.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/blimpy/waterfall.py b/blimpy/waterfall.py index 1e49f12c..0a9de22c 100755 --- a/blimpy/waterfall.py +++ b/blimpy/waterfall.py @@ -138,13 +138,17 @@ def __init__(self, filename=None, f_start=None, f_stop=None,t_start=None, t_stop self.__load_data() elif header_dict is not None and data_array is not None: - self.gen_from_header(header_dict, data_array) + self.filename = b'' + self.header = header_dict + self.data = data_array + self.n_ints_in_file = 0 + self._setup_freqs() + else: - pass + self.filename = b'' def __load_data(self): - """ - """ + """ Helper for loading data form a container. Should not be called manually. """ self.data = self.container.data From 944555818ef8daa7532638dd47d4cbd8ba13b063 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 23:21:42 +1000 Subject: [PATCH 28/66] Added deprecation notes in docstrings. --- blimpy/filterbank.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/blimpy/filterbank.py b/blimpy/filterbank.py index fc9cbf3d..a11df8a8 100755 --- a/blimpy/filterbank.py +++ b/blimpy/filterbank.py @@ -140,7 +140,11 @@ def __init__(self, filename=None, f_start=None, f_stop=None, self.calibrate_band_pass_N1() def read_hdf5(self, filename, load_data=True): + """ Populate Filterbank instance with data from HDF5 file + Note: + This is to be deprecated in future, please use Waterfall() to open files. + """ print("Warning: this function will be deprecated in the future. Please use Waterfall to open HDF5 files.") # raise DeprecationWarning('Please use Waterfall to open HDF5 files.') @@ -173,6 +177,7 @@ def read_hdf5(self, filename, load_data=True): self._setup_time_axis() def _setup_freqs(self, f_start=None, f_stop=None): + """ Setup frequency axis """ ## Setup frequency axis f0 = self.header[b'fch1'] f_delt = self.header[b'foff'] @@ -204,8 +209,7 @@ def _setup_freqs(self, f_start=None, f_stop=None): return i_start, i_stop, chan_start_idx, chan_stop_idx def _setup_time_axis(self, t_start=None, t_stop=None): - """ Setup time axis. - """ + """ Setup time axis. """ # now check to see how many integrations requested ii_start, ii_stop = 0, self.n_ints_in_file @@ -225,7 +229,11 @@ def _setup_time_axis(self, t_start=None, t_stop=None): def read_filterbank(self, filename=None, f_start=None, f_stop=None, t_start=None, t_stop=None, load_data=True): + """ Populate Filterbank instance with data from Filterbank file + Note: + This is to be deprecated in future, please use Waterfall() to open files. + """ if filename is None: filename = self.filename else: From b96409944e90b3e4a68c4d2a0aa3d835cac8efe6 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 3 Jun 2018 23:23:11 +1000 Subject: [PATCH 29/66] Bumped version number --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 9127284c..e4e28d69 100644 --- a/setup.py +++ b/setup.py @@ -3,7 +3,7 @@ """ from setuptools import setup, find_packages -__version__ = '1.1.9' +__version__ = '1.2.0' # create entry points # see http://astropy.readthedocs.org/en/latest/development/scripts.html From c2f6330418a573e854f06294386f8fba0c9bf4ca Mon Sep 17 00:00:00 2001 From: Danny Price Date: Mon, 4 Jun 2018 16:55:50 +1000 Subject: [PATCH 30/66] Adding test_filterbank_voyager.py --- tests/test_filterbank_voyager.py | 55 ++++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 tests/test_filterbank_voyager.py diff --git a/tests/test_filterbank_voyager.py b/tests/test_filterbank_voyager.py new file mode 100644 index 00000000..673c7b72 --- /dev/null +++ b/tests/test_filterbank_voyager.py @@ -0,0 +1,55 @@ +import blimpy as bl +import numpy as np +from pprint import pprint + +def compare_filterbank_fil_to_h5(): + """ Load Voyager dataset and test that both fil and hdf5 readers return same headers and data """ + + print("Loading FIL and HDF5 data with Waterfall()..."), + a = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.h5') + b = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.fil') + print("OK") + + print("Reading headers..") + print("\nHDF5 file header:") + pprint(a.header) + print("\nFIL file header:") + pprint(b.header) + print("Headers are loading OK") + + print("\nChecking header values match..."), + for key in b.header.keys(): + assert b.header[key] == a.header[key] + print("OK") + + print("Checking datatype matches..."), + assert a.data.dtype == b.data.dtype + print("OK") + + print("Checking data matches..."), + assert np.allclose(a.data, b.data) + assert a.data.dtype == b.data.dtype + print("OK") + +def test_plotting_doesnt_cause_exceptions(): + """ Try running the plotting routines. They should not raise expections even without X windows """ + a = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.h5') + b = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.fil') + + a.plot_all() + a.plot_kurtosis() + a.plot_spectrum() + a.plot_spectrum_min_max() + a.plot_waterfall() + a.plot_time_series() + + b.plot_all() + b.plot_kurtosis() + b.plot_spectrum() + b.plot_spectrum_min_max() + b.plot_waterfall() + b.plot_time_series() + +if __name__ == "__main__": + compare_filterbank_fil_to_h5() + test_plotting_doesnt_cause_exceptions() \ No newline at end of file From da1e15bbc2ed1dde4c322cc45c9546b364277289 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Mon, 4 Jun 2018 17:09:23 +1000 Subject: [PATCH 31/66] Updating unit tests --- tests/run_tests.sh | 4 ++++ tests/test_unpack.py | 19 ++++++++++++------- 2 files changed, 16 insertions(+), 7 deletions(-) create mode 100755 tests/run_tests.sh diff --git a/tests/run_tests.sh b/tests/run_tests.sh new file mode 100755 index 00000000..f8379fc2 --- /dev/null +++ b/tests/run_tests.sh @@ -0,0 +1,4 @@ +#!/usr/bin/env bash +cd ..; python setup.py install; cd tests +coverage run --source=blimpy -m py.test +coverage report diff --git a/tests/test_unpack.py b/tests/test_unpack.py index 51ba8ef9..a22c8709 100644 --- a/tests/test_unpack.py +++ b/tests/test_unpack.py @@ -1,13 +1,18 @@ from blimpy.utils import unpack_2to8 import numpy as np -# Create an array that should come out as [0, 1, 2, 3, 3, 2, 1, 0] -# In binary, this is [00, 01, 10, 11, 11, 10, 01, 00] -# Convert to 8-bit, this is [0b00011011, 0b11100100] -a = np.array([0b00011011, 0b11100100], dtype=np.uint8) -b = np.array([0, 1, 2, 3, 3, 2, 1, 0], dtype=np.uint8) +def test_2to8(): + # Create an array that should come out as [0, 1, 2, 3, 3, 2, 1, 0] + # In binary, this is [00, 01, 10, 11, 11, 10, 01, 00] + # Convert to 8-bit, this is [0b00011011, 0b11100100] -c = unpack_2to8(a) + a = np.array([0b00011011, 0b11100100], dtype=np.uint8) + b = np.array([0, 1, 2, 3, 3, 2, 1, 0], dtype=np.uint8) -assert np.allclose(b, c) \ No newline at end of file + c = unpack_2to8(a) + + assert np.allclose(b, c) + +if __name__ == "__main__": + test_2to8() \ No newline at end of file From f43c4891e28b0785d2716f5e37ad3b78bc378b28 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Tue, 5 Jun 2018 14:12:58 +1000 Subject: [PATCH 32/66] Fixes for Py3 support: division now in int() if integer output reqd --- blimpy/filterbank.py | 29 +++++++++++++++-------------- 1 file changed, 15 insertions(+), 14 deletions(-) diff --git a/blimpy/filterbank.py b/blimpy/filterbank.py index a11df8a8..488651fe 100755 --- a/blimpy/filterbank.py +++ b/blimpy/filterbank.py @@ -114,7 +114,8 @@ def __init__(self, filename=None, f_start=None, f_stop=None, self.filename = filename if HAS_HDF5: if h5py.is_hdf5(filename): - self.read_hdf5(filename, f_start, f_stop, t_start, t_stop, load_data) + # TODO: self.read_hdf5(filename, f_start, f_stop, t_start, t_stop, load_data) + self.read_hdf5(filename, load_data) else: self.read_filterbank(filename, f_start, f_stop, t_start, t_stop, load_data) else: @@ -184,9 +185,9 @@ def _setup_freqs(self, f_start=None, f_stop=None): i_start, i_stop = 0, self.header[b'nchans'] if f_start: - i_start = (f_start - f0) / f_delt + i_start = int((f_start - f0) / f_delt) if f_stop: - i_stop = (f_stop - f0) / f_delt + i_stop = int((f_stop - f0) / f_delt) #calculate closest true index value chan_start_idx = np.int(i_start) @@ -270,7 +271,7 @@ def read_filterbank(self, filename=None, f_start=None, f_stop=None, ii_start, ii_stop, n_ints = self._setup_time_axis(t_start=t_start, t_stop=t_stop) # Seek to first integration - f.seek(ii_start * n_bits * n_ifs * n_chans / 8, 1) + f.seek(int(ii_start * n_bits * n_ifs * n_chans / 8), 1) # Set up indexes used in file read (taken out of loop for speed) i0 = np.min((chan_start_idx, chan_stop_idx)) @@ -411,9 +412,9 @@ def blank_dc(self, n_coarse_chan): n_coarse_chan = int(n_coarse_chan) n_chan = self.data.shape[-1] - n_chan_per_coarse = n_chan / n_coarse_chan + n_chan_per_coarse = int(n_chan / n_coarse_chan) - mid_chan = (n_chan_per_coarse / 2) + mid_chan = int(n_chan_per_coarse / 2) for ii in range(n_coarse_chan): ss = ii*n_chan_per_coarse @@ -450,8 +451,8 @@ def generate_freqs(self, f_start, f_stop): foff = self.header[b'foff'] #convert input frequencies into what their corresponding index would be - i_start = (f_start - fch1) / foff - i_stop = (f_stop - fch1) / foff + i_start = int((f_start - fch1) / foff) + i_stop = int((f_stop - fch1) / foff) #calculate closest true index value chan_start_idx = np.int(i_start) @@ -499,7 +500,7 @@ def calc_n_coarse_chan(self): coarse_chan_bw = 2.9296875 bandwidth = abs(self.header[b'nchans']*self.header[b'foff']) - n_coarse_chan = bandwidth / coarse_chan_bw + n_coarse_chan = int(bandwidth / coarse_chan_bw) return n_coarse_chan @@ -558,7 +559,7 @@ def plot_spectrum(self, t=0, f_start=None, f_stop=None, logged=False, if_id=0, c # Rebin to max number of points dec_fac_x = 1 if plot_data.shape[0] > MAX_PLT_POINTS: - dec_fac_x = plot_data.shape[0] / MAX_PLT_POINTS + dec_fac_x = int(plot_data.shape[0] / MAX_PLT_POINTS) plot_data = rebin(plot_data, dec_fac_x, 1) plot_f = rebin(plot_f, dec_fac_x, 1) @@ -620,7 +621,7 @@ def plot_spectrum_min_max(self, t=0, f_start=None, f_stop=None, logged=False, if dec_fac_x = 1 MAX_PLT_POINTS = 8*64 # Low resoluition to see the difference. if plot_data.shape[0] > MAX_PLT_POINTS: - dec_fac_x = plot_data.shape[0] / MAX_PLT_POINTS + dec_fac_x = int(plot_data.shape[0] / MAX_PLT_POINTS) plot_data = rebin(plot_data, dec_fac_x, 1) plot_min = rebin(plot_min, dec_fac_x, 1) @@ -673,10 +674,10 @@ def plot_waterfall(self, f_start=None, f_stop=None, if_id=0, logged=True,cb=True # Make sure waterfall plot is under 4k*4k dec_fac_x, dec_fac_y = 1, 1 if plot_data.shape[0] > MAX_IMSHOW_POINTS[0]: - dec_fac_x = plot_data.shape[0] / MAX_IMSHOW_POINTS[0] + dec_fac_x = int(plot_data.shape[0] / MAX_IMSHOW_POINTS[0]) if plot_data.shape[1] > MAX_IMSHOW_POINTS[1]: - dec_fac_y = plot_data.shape[1] / MAX_IMSHOW_POINTS[1] + dec_fac_y = int(plot_data.shape[1] / MAX_IMSHOW_POINTS[1]) plot_data = rebin(plot_data, dec_fac_x, dec_fac_y) @@ -918,7 +919,7 @@ def write_to_filterbank(self, filename_out): print("[Filterbank] Warning: Non-standard function to write in filterbank (.fil) format. Please use Waterfall.") - n_bytes = self.header[b'nbits'] / 8 + n_bytes = int(self.header[b'nbits'] / 8) with open(filename_out, "w") as fileh: fileh.write(generate_sigproc_header(self)) j = self.data From 93aeed7b5777d2905c15e25714fea32e90941c77 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Tue, 5 Jun 2018 14:14:19 +1000 Subject: [PATCH 33/66] Putting guppi test as TODO until test data is sourced --- tests/test_guppi.py | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/tests/test_guppi.py b/tests/test_guppi.py index b120044e..3eeaab61 100644 --- a/tests/test_guppi.py +++ b/tests/test_guppi.py @@ -1,27 +1,27 @@ from blimpy import GuppiRaw from pprint import pprint -def test_guppi(): - filename = 'blc1_guppi_57388_HIP113357_0010.0002.raw' +def todo_test_guppi(): + filename = 'blc1_guppi_57388_HIP113357_0010.0002.raw' - guppi = GuppiRaw(filename) + guppi = GuppiRaw(filename) - print guppi + print guppi - header = guppi.read_first_header() - - pprint(header) + header = guppi.read_first_header() - guppi.read_header() - guppi.find_n_data_blocks() - header, idx = guppi.read_header() - header, data = guppi.read_next_data_block() - header, data = guppi.read_next_data_block() - header, data = guppi.read_next_data_block() - guppi.reset_index() + pprint(header) + + guppi.read_header() + guppi.find_n_data_blocks() + header, idx = guppi.read_header() + header, data = guppi.read_next_data_block() + header, data = guppi.read_next_data_block() + header, data = guppi.read_next_data_block() + guppi.reset_index() if __name__ == "__main__": - #test_guppi() - print("OK") + # test_guppi() + print("OK") From cb4f0ce00e4de8a47f52dd6b34148a8a56bc7c06 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Tue, 5 Jun 2018 14:15:33 +1000 Subject: [PATCH 34/66] Change tests to pytest --- .travis.yml | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index 43a40caa..853bafdd 100644 --- a/.travis.yml +++ b/.travis.yml @@ -15,9 +15,7 @@ install: # command to install dependencies script: - - python tests/test_filterbank.py - - python tests/test_unpack.py -# - python tests/test_guppi.py + - cd tests; pytest branches: only: From 75329776261ab3dd876d3d53a3300b8939685103 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Tue, 5 Jun 2018 14:22:10 +1000 Subject: [PATCH 35/66] Delete test_filterbank.py --- tests/test_filterbank.py | 96 ---------------------------------------- 1 file changed, 96 deletions(-) delete mode 100644 tests/test_filterbank.py diff --git a/tests/test_filterbank.py b/tests/test_filterbank.py deleted file mode 100644 index 4bde5e49..00000000 --- a/tests/test_filterbank.py +++ /dev/null @@ -1,96 +0,0 @@ -from blimpy import Filterbank, read_header, fix_header -import pylab as plt -import numpy as np -import os -from pprint import pprint - -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() - -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 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_filterbank_gen(): - """ Generate a blimpy from nothing """ - filename = '/bldata/gbt_data/voyager_f1032192_t300_v2.fil' - fb0 = Filterbank(filename) - fb0.info() - - fb = Filterbank(header_dict=fb0.header, data_array=fb0.data) - fb.info() - - print("Writing to blimpy...") - fb.write_to_filterbank('test.fil') - - print("Writing to hdf5...") - fb.write_to_hdf5('test.h5') - - fb2 = Filterbank('test.h5') - fb2.info() - - fb2.plot_spectrum() - plt.show() - os.remove('test.h5') - - -if __name__ == "__main__": - #test_voyager() - #test_voyager_extract() - #test_voyager_fix_header() - #test_filterbank_gen() - print("OK") - From 31c20a04fe26ba3b33a4f2f7b7c40bfaba00ca3e Mon Sep 17 00:00:00 2001 From: Danny Price Date: Tue, 5 Jun 2018 15:06:55 +1000 Subject: [PATCH 36/66] Updated to build h5py better --- .travis.yml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 853bafdd..e167dc3d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -10,7 +10,8 @@ install: - pip install --upgrade pip setuptools wheel - pip install --only-binary=numpy,scipy numpy scipy - pip install matplotlib - - pip install git+https://github.com/kiyo-masui/bitshuffle + - CFLAGS=-I/usr/include/hdf5/serial pip install git+https://github.com/h5py/h5py + - CFLAGS=-I/usr/include/hdf5/serial pip install git+https://github.com/kiyo-masui/bitshuffle - pip install . # command to install dependencies From 1f65b7d339bc6cb9aeda0f95150cd5c03ffbf410 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Tue, 5 Jun 2018 15:14:32 +1000 Subject: [PATCH 37/66] pesky () for Py3 --- tests/test_guppi.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_guppi.py b/tests/test_guppi.py index 3eeaab61..c7796229 100644 --- a/tests/test_guppi.py +++ b/tests/test_guppi.py @@ -7,7 +7,7 @@ def todo_test_guppi(): guppi = GuppiRaw(filename) - print guppi + print(guppi) header = guppi.read_first_header() From c1c30d685f4ad39ffd06e033e414656c0331c3e4 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Tue, 5 Jun 2018 15:25:51 +1000 Subject: [PATCH 38/66] pesky b"bytestrung" for Py3 --- blimpy/waterfall.py | 52 ++++++++++++++++++++++----------------------- 1 file changed, 26 insertions(+), 26 deletions(-) diff --git a/blimpy/waterfall.py b/blimpy/waterfall.py index 0a9de22c..64a7ea63 100755 --- a/blimpy/waterfall.py +++ b/blimpy/waterfall.py @@ -165,16 +165,16 @@ def __update_header(self): """ #Updating frequency of first channel from selection - if self.header['foff'] < 0: - self.header['fch1'] = self.container.f_stop + if self.header[b'foff'] < 0: + self.header[b'fch1'] = self.container.f_stop else: - self.header['fch1'] = self.container.f_start + self.header[b'fch1'] = self.container.f_start #Updating number of coarse channels. - self.header['nchans'] = self.container.selection_shape[self.freq_axis] + self.header[b'nchans'] = self.container.selection_shape[self.freq_axis] #Updating time stamp for first time bin from selection - self.header['tstart'] = self.container.populate_timestamps(update_header=True) + self.header[b'tstart'] = self.container.populate_timestamps(update_header=True) def populate_freqs(self): """ @@ -242,7 +242,7 @@ def __write_to_fil_heavy(self, filename_out, *args, **kwargs): n_blobs = self.container.calc_n_blobs(blob_dim) #Write header of .fil file - n_bytes = self.header['nbits'] / 8 + n_bytes = self.header[b'nbits'] / 8 with open(filename_out, "w") as fileh: fileh.write(generate_sigproc_header(self)) #generate_sigproc_header comes from sigproc.py @@ -269,7 +269,7 @@ def __write_to_fil_light(self, filename_out, *args, **kwargs): filename_out (str): Name of output file """ - n_bytes = self.header['nbits'] / 8 + n_bytes = self.header[b'nbits'] / 8 with open(filename_out, "w") as fileh: fileh.write(generate_sigproc_header(self)) #generate_sigproc_header comes from sigproc.py j = self.data @@ -318,8 +318,8 @@ def __write_to_hdf5_heavy(self, filename_out, *args, **kwargs): with h5py.File(filename_out, 'w') as h5: - h5.attrs['CLASS'] = 'FILTERBANK' - h5.attrs['VERSION'] = '1.0' + h5.attrs[b'CLASS'] = b'FILTERBANK' + h5.attrs[b'VERSION'] = b'1.0' if HAS_BITSHUFFLE: bs_compression = bitshuffle.h5.H5FILTER @@ -343,13 +343,13 @@ def __write_to_hdf5_heavy(self, filename_out, *args, **kwargs): compression_opts=bs_compression_opts, dtype='uint8') - dset.dims[0].label = "frequency" - dset.dims[1].label = "feed_id" - dset.dims[2].label = "time" + dset.dims[0].label = b"frequency" + dset.dims[1].label = b"feed_id" + dset.dims[2].label = b"time" - dset_mask.dims[0].label = "frequency" - dset_mask.dims[1].label = "feed_id" - dset_mask.dims[2].label = "time" + dset_mask.dims[0].label = b"frequency" + dset_mask.dims[1].label = b"feed_id" + dset_mask.dims[2].label = b"time" # Copy over header information as attributes for key, value in self.header.items(): @@ -410,8 +410,8 @@ def __write_to_hdf5_light(self, filename_out, *args, **kwargs): with h5py.File(filename_out, 'w') as h5: - h5.attrs['CLASS'] = 'FILTERBANK' - h5.attrs['VERSION'] = '1.0' + h5.attrs[b'CLASS'] = b'FILTERBANK' + h5.attrs[b'VERSION'] = b'1.0' if HAS_BITSHUFFLE: bs_compression = bitshuffle.h5.H5FILTER @@ -435,13 +435,13 @@ def __write_to_hdf5_light(self, filename_out, *args, **kwargs): compression_opts=bs_compression_opts, dtype='uint8') - dset.dims[0].label = "frequency" - dset.dims[1].label = "feed_id" - dset.dims[2].label = "time" + dset.dims[0].label = b"frequency" + dset.dims[1].label = b"feed_id" + dset.dims[2].label = b"time" - dset_mask.dims[0].label = "frequency" - dset_mask.dims[1].label = "feed_id" - dset_mask.dims[2].label = "time" + dset_mask.dims[0].label = b"frequency" + dset_mask.dims[1].label = b"feed_id" + dset_mask.dims[2].label = b"time" # Copy over header information as attributes for key, value in self.header.items(): @@ -471,17 +471,17 @@ def __get_chunk_dimensions(self): """ #Usually '.0000.' is in self.filename - if np.abs(self.header['foff']) < 1e-5: + if np.abs(self.header[b'foff']) < 1e-5: logger.info('Detecting high frequency resolution data.') chunk_dim = (1,1,1048576) #1048576 is the number of channels in a coarse channel. return chunk_dim #Usually '.0001.' is in self.filename - elif np.abs(self.header['tsamp']) < 1e-3: + elif np.abs(self.header[b'tsamp']) < 1e-3: logger.info('Detecting high time resolution data.') chunk_dim = (2048,1,512) #512 is the total number of channels per single band (ie. blc00) return chunk_dim #Usually '.0002.' is in self.filename - elif np.abs(self.header['foff']) < 1e-2 and np.abs(self.header['foff']) >= 1e-5: + elif np.abs(self.header[b'foff']) < 1e-2 and np.abs(self.header[b'foff']) >= 1e-5: logger.info('Detecting intermediate frequency and time resolution data.') chunk_dim = (10,1,65536) #65536 is the total number of channels per single band (ie. blc00) # chunk_dim = (1,1,65536/4) From bb2e9d5bba21f15fb82f64ab3ee64e3df2b290e5 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Tue, 5 Jun 2018 16:23:21 +1000 Subject: [PATCH 39/66] More bytestring Py3 shennanigans --- blimpy/file_wrapper.py | 96 ++++++++++++++++++++++-------------------- blimpy/filterbank.py | 3 ++ 2 files changed, 54 insertions(+), 45 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index f65aa826..75c313a1 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -6,6 +6,7 @@ import sys import numpy as np import h5py +import six from astropy.coordinates import Angle @@ -107,11 +108,11 @@ def _setup_dtype(self): #Set up the data type if self._n_bytes == 4: - return 'float32' + return b'float32' elif self._n_bytes == 2: - return 'int16' + return b'int16' elif self._n_bytes == 1: - return 'int8' + return b'int8' @@ -122,7 +123,7 @@ def _calc_selection_size(self): #Check to see how many integrations requested n_ints = self.t_stop - self.t_start #Check to see how many frequency channels requested - n_chan = (self.f_stop - self.f_start) / abs(self.header['foff']) + n_chan = (self.f_stop - self.f_start) / abs(self.header[b'foff']) n_bytes = self._n_bytes selection_size = int(n_ints*n_chan*n_bytes) @@ -136,9 +137,9 @@ def _calc_selection_shape(self): #Check how many integrations requested n_ints = self.t_stop - self.t_start #Check how many frequency channels requested - n_chan = int(np.round((self.f_stop - self.f_start) / abs(self.header['foff']))) + n_chan = int(np.round((self.f_stop - self.f_start) / abs(self.header[b'foff']))) - selection_shape = (n_ints,self.header['nifs'],n_chan) + selection_shape = (n_ints,self.header[b'nifs'],n_chan) return selection_shape @@ -146,16 +147,16 @@ def _setup_chans(self): """Setup channel borders """ - if self.header['foff'] < 0: + if self.header[b'foff'] < 0: f0 = self.f_end else: f0 = self.f_begin i_start, i_stop = 0, self.n_channels_in_file if self.f_start: - i_start = np.round((self.f_start - f0) / self.header['foff']) + i_start = np.round((self.f_start - f0) / self.header[b'foff']) if self.f_stop: - i_stop = np.round((self.f_stop - f0) / self.header['foff']) + i_stop = np.round((self.f_stop - f0) / self.header[b'foff']) #calculate closest true index value chan_start_idx = np.int(i_start) @@ -171,12 +172,12 @@ def _setup_freqs(self): """Updating frequency borders from channel values """ - if self.header['foff'] > 0: - self.f_start = self.f_begin + self.chan_start_idx*abs(self.header['foff']) - self.f_stop = self.f_begin + self.chan_stop_idx*abs(self.header['foff']) + if self.header[b'foff'] > 0: + self.f_start = self.f_begin + self.chan_start_idx*abs(self.header[b'foff']) + self.f_stop = self.f_begin + self.chan_stop_idx*abs(self.header[b'foff']) else: - self.f_start = self.f_end - self.chan_stop_idx*abs(self.header['foff']) - self.f_stop = self.f_end - self.chan_start_idx*abs(self.header['foff']) + self.f_start = self.f_end - self.chan_stop_idx*abs(self.header[b'foff']) + self.f_stop = self.f_end - self.chan_start_idx*abs(self.header[b'foff']) def populate_timestamps(self,update_header=False): """ Populate time axis. @@ -191,8 +192,8 @@ def populate_timestamps(self,update_header=False): ii_stop = self.t_stop ## Setup time axis - t0 = self.header['tstart'] - t_delt = self.header['tsamp'] + t0 = self.header[b'tstart'] + t_delt = self.header[b'tsamp'] if update_header: timestamps = ii_start * t_delt / 24./60./60 + t0 @@ -206,7 +207,7 @@ def populate_freqs(self): Populate frequency axis """ - if self.header['foff'] < 0: + if self.header[b'foff'] < 0: f0 = self.f_end else: f0 = self.f_begin @@ -215,7 +216,7 @@ def populate_freqs(self): #create freq array i_vals = np.arange(self.chan_start_idx, self.chan_stop_idx) - freqs = self.header['foff'] * i_vals + f0 + freqs = self.header[b'foff'] * i_vals + f0 return freqs @@ -228,15 +229,15 @@ def calc_n_coarse_chan(self): For Parkes, it assumes 2^20 point FFTs. For GBT, it assumes channel bandwidth 2.9296875 MHz """ - nchans = int(self.header['nchans']) + nchans = int(self.header[b'nchans']) - if self.header['telescope_id'] == 6: + if self.header[b'telescope_id'] == 6: coarse_chan_bw = 2.9296875 bandwidth = abs(self.f_stop - self.f_start) n_coarse_chan = int(bandwidth / coarse_chan_bw) return n_coarse_chan - elif self.header['telescope_id'] == 4: + elif self.header[b'telescope_id'] == 4: # For 3 Hz channels we are using 2^20 length FFTs if nchans >= 2**20: return int(nchans / 2**20) @@ -296,18 +297,18 @@ def __init__(self, filename, f_start=None, f_stop=None, t_start=None, t_stop=Non self.file_size_bytes = os.path.getsize(self.filename) # In bytes self.n_ints_in_file = self.h5["data"].shape[self.time_axis] # self.n_channels_in_file = self.h5["data"].shape[self.freq_axis] # - self.n_beams_in_file = self.header['nifs'] #Placeholder for future development. + self.n_beams_in_file = self.header[b'nifs'] #Placeholder for future development. self.n_pols_in_file = 1 #Placeholder for future development. - self._n_bytes = self.header['nbits'] / 8 #number of bytes per digit. + self._n_bytes = self.header[b'nbits'] / 8 #number of bytes per digit. self._d_type = self._setup_dtype() self.file_shape = (self.n_ints_in_file,self.n_beams_in_file,self.n_channels_in_file) - if self.header['foff'] < 0: - self.f_end = self.header['fch1'] - self.f_begin = self.f_end + self.n_channels_in_file*self.header['foff'] + if self.header[b'foff'] < 0: + self.f_end = self.header[b'fch1'] + self.f_begin = self.f_end + self.n_channels_in_file*self.header[b'foff'] else: - self.f_begin = self.header['fch1'] - self.f_end = self.f_begin + self.n_channels_in_file*self.header['foff'] + self.f_begin = self.header[b'fch1'] + self.f_end = self.f_begin + self.n_channels_in_file*self.header[b'foff'] self.t_begin = 0 self.t_end = self.n_ints_in_file @@ -361,9 +362,11 @@ def read_header(self): self.header = {} for key, val in self.h5['data'].attrs.items(): - if key == 'src_raj': + if six.PY3: + key = bytes(key, 'ascii') + if key == b'src_raj': self.header[key] = Angle(val, unit='hr') - elif key == 'src_dej': + elif key == b'src_dej': self.header[key] = Angle(val, unit='deg') else: self.header[key] = val @@ -425,7 +428,7 @@ def read_blob(self,blob_dim,n_blob=0): blob = self.h5["data"][blob_start[self.time_axis]:blob_end[self.time_axis],:,blob_start[self.freq_axis]:blob_end[self.freq_axis]] -# if self.header['foff'] < 0: +# if self.header[b'foff'] < 0: # blob = blob[:,:,::-1] return blob @@ -454,20 +457,20 @@ def __init__(self, filename,f_start=None, f_stop=None,t_start=None, t_stop=None, self.header = self.read_header() self.file_size_bytes = os.path.getsize(self.filename) self.idx_data = sigproc.len_header(self.filename) - self.n_channels_in_file = self.header['nchans'] - self.n_beams_in_file = self.header['nifs'] #Placeholder for future development. + self.n_channels_in_file = self.header[b'nchans'] + self.n_beams_in_file = self.header[b'nifs'] #Placeholder for future development. self.n_pols_in_file = 1 #Placeholder for future development. - self._n_bytes = self.header['nbits'] / 8 #number of bytes per digit. + self._n_bytes = self.header[b'nbits'] / 8 #number of bytes per digit. self._d_type = self._setup_dtype() self._setup_n_ints_in_file() self.file_shape = (self.n_ints_in_file,self.n_beams_in_file,self.n_channels_in_file) - if self.header['foff'] < 0: - self.f_end = self.header['fch1'] - self.f_begin = self.f_end + self.n_channels_in_file*self.header['foff'] + if self.header[b'foff'] < 0: + self.f_end = self.header[b'fch1'] + self.f_begin = self.f_end + self.n_channels_in_file*self.header[b'foff'] else: - self.f_begin = self.header['fch1'] - self.f_end = self.f_begin + self.n_channels_in_file*self.header['foff'] + self.f_begin = self.header[b'fch1'] + self.f_end = self.f_begin + self.n_channels_in_file*self.header[b'foff'] self.t_begin = 0 self.t_end = self.n_ints_in_file @@ -565,9 +568,9 @@ def read_data(self, f_start=None, f_stop=None,t_start=None, t_stop=None): #Update frequencies ranges from channel number. self._setup_freqs() - n_chans = self.header['nchans'] + n_chans = self.header[b'nchans'] n_chans_selected = self.selection_shape[self.freq_axis] - n_ifs = self.header['nifs'] + n_ifs = self.header[b'nifs'] # Load binary data f = open(self.filename, 'rb') @@ -588,7 +591,7 @@ def read_data(self, f_start=None, f_stop=None,t_start=None, t_stop=None): dd = np.fromfile(f, count=n_chans_selected, dtype=self._d_type) # Reverse array if frequency axis is flipped -# if self.header['foff'] < 0: +# if self.header[b'foff'] < 0: # dd = dd[::-1] self.data[ii, jj] = dd @@ -658,7 +661,7 @@ def read_blob(self,blob_dim,n_blob=0): blob[blobt] = dd -# if self.header['foff'] < 0: +# if self.header[b'foff'] < 0: # blob = blob[:,:,::-1] return blob @@ -728,10 +731,13 @@ def open_file(filename, f_start=None, f_stop=None,t_start=None, t_stop=None,load # Get file extension to determine type ext = filename.split(".")[-1].strip().lower() - if ext == 'h5': + if six.PY3: + ext = bytes(ext, 'ascii') + + if ext == b'h5': # Open HDF5 file return H5Reader(filename, f_start=f_start, f_stop=f_stop, t_start=t_start, t_stop=t_stop, load_data=load_data, max_load=max_load) - elif ext == 'fil': + elif ext == b'fil': # Open FIL file return FilReader(filename, f_start=f_start, f_stop=f_stop, t_start=t_start, t_stop=t_stop, load_data=load_data, max_load=max_load) else: diff --git a/blimpy/filterbank.py b/blimpy/filterbank.py index 488651fe..3ff1109a 100755 --- a/blimpy/filterbank.py +++ b/blimpy/filterbank.py @@ -23,6 +23,7 @@ import sys +import six from astropy.time import Time import scipy.stats @@ -153,6 +154,8 @@ def read_hdf5(self, filename, load_data=True): self.filename = filename self.h5 = h5py.File(filename) for key, val in self.h5[b'data'].attrs.items(): + if six.PY3: + key = bytes(key, 'ascii') if key == b'src_raj': self.header[key] = Angle(val, unit='hr') elif key == b'src_dej': From 0a43a857326eddc4246b74951ea5ecd792f0f594 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Tue, 5 Jun 2018 16:28:45 +1000 Subject: [PATCH 40/66] Even more bytestring Py3 shennanigans --- blimpy/filterbank.py | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/blimpy/filterbank.py b/blimpy/filterbank.py index 3ff1109a..6ef59361 100755 --- a/blimpy/filterbank.py +++ b/blimpy/filterbank.py @@ -168,7 +168,7 @@ def read_hdf5(self, filename, load_data=True): self.n_ints_in_file = self.data.shape[0] self.file_size_bytes = os.path.getsize(self.filename) -# if self.header['foff'] < 0: +# if self.header[b'foff'] < 0: # self.data = self.data[..., ::-1] # Reverse data else: @@ -329,16 +329,16 @@ def read_filterbank(self, filename=None, f_start=None, f_stop=None, def compute_lst(self): """ Compute LST for observation """ - if self.header['telescope_id'] == 6: + if self.header[b'telescope_id'] == 6: self.coords = gbt_coords - elif self.header['telescope_id'] == 4: + elif self.header[b'telescope_id'] == 4: self.coords = parkes_coords else: raise RuntimeError("Currently only Parkes and GBT supported") if HAS_SLALIB: # dut1 = (0.2 /3600.0) * np.pi/12.0 dut1 = 0.0 - mjd = self.header['tstart'] + mjd = self.header[b'tstart'] tellong = np.deg2rad(self.coords[1]) last = s.sla_gmst(mjd) - tellong + s.sla_eqeqx(mjd) + dut1 # lmst = s.sla_gmst(mjd) - tellong @@ -353,9 +353,9 @@ def compute_lsrk(self): uses the MJD, RA and DEC of observation to compute along with the telescope location. Requires pyslalib """ - ra = Angle(self.header['src_raj'], unit='hourangle') - dec = Angle(self.header['src_dej'], unit='degree') - mjdd = self.header['tstart'] + ra = Angle(self.header[b'src_raj'], unit='hourangle') + dec = Angle(self.header[b'src_dej'], unit='degree') + mjdd = self.header[b'tstart'] rarad = ra.to('radian').value dcrad = dec.to('radian').value last = self.compute_lst() @@ -498,7 +498,7 @@ def calc_n_coarse_chan(self): # Could add a telescope based coarse channel bandwidth, or other discriminative. # if telescope_id == 'GBT': # or actually as is currently - # if self.header['telescope_id'] == 6: + # if self.header[b'telescope_id'] == 6: coarse_chan_bw = 2.9296875 @@ -534,7 +534,7 @@ def plot_spectrum(self, t=0, f_start=None, f_stop=None, logged=False, if_id=0, c c: color for line kwargs: keyword args to be passed to matplotlib plot() """ - if self.header['nbits'] <=2: + if self.header[b'nbits'] <=2: logged = False t='all' ax = plt.gca() @@ -720,7 +720,7 @@ def plot_time_series(self, f_start=None, f_stop=None, if_id=0, logged=True, orie ax = plt.gca() plot_f, plot_data = self.grab_data(f_start, f_stop, if_id) - if logged and self.header['nbits'] >= 8: + if logged and self.header[b'nbits'] >= 8: plot_data = db(plot_data) #Since the data has been squeezed, the axis for time goes away if only one bin, causing a bug with axis=1 @@ -791,7 +791,7 @@ def plot_all(self, t=0, f_start=None, f_stop=None, logged=False, if_id=0, kutosi if_id (int): IF identification (if multiple IF signals in file) kwargs: keyword args to be passed to matplotlib plot() and imshow() """ - if self.header['nbits'] <=2: + if self.header[b'nbits'] <=2: logged = False nullfmt = NullFormatter() # no labels From ecfc6af899d29544861f0baaf6c4e4354ba8cfce Mon Sep 17 00:00:00 2001 From: Danny Price Date: Tue, 5 Jun 2018 16:35:18 +1000 Subject: [PATCH 41/66] Py3 throws a hissy fit with None comparisons, making these more robust --- blimpy/file_wrapper.py | 75 ++++++++++++++++++++++-------------------- 1 file changed, 40 insertions(+), 35 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index 75c313a1..4d7a1829 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -49,49 +49,54 @@ def _setup_selection_range(self, f_start=None, f_stop=None, t_start=None, t_stop # This avoids resetting values if not init: - if not f_start: + if f_start is None: f_start = self.f_start - if not f_stop: + if f_stop is None: f_stop = self.f_stop - if not t_start: + if t_start is None: t_start = self.t_start - if not t_stop: + if t_stop is None: t_stop = self.t_stop - if t_stop >= 0 and t_start >= 0 and t_stop < t_start: - t_stop, t_start = t_start,t_stop - logger.warning('Given t_stop < t_start, assuming reversed values.') - if f_stop and f_start and f_stop < f_start: - f_stop, f_start = f_start,f_stop - logger.warning('Given f_stop < f_start, assuming reversed values.') - - if t_start != None and t_start >= self.t_begin and t_start < self.t_end: - self.t_start = int(t_start) - else: - if not init or t_start != None: - logger.warning('Setting t_start = %f, since t_start not given or not valid.'%self.t_begin) - self.t_start = self.t_begin + if t_stop is not None and t_start is not None: + if t_stop >= 0 and t_start >= 0 and t_stop < t_start: + t_stop, t_start = t_start,t_stop + logger.warning('Given t_stop < t_start, assuming reversed values.') + if f_stop and f_start and f_stop < f_start: + f_stop, f_start = f_start,f_stop + logger.warning('Given f_stop < f_start, assuming reversed values.') + + if t_start is not None: + if t_start >= self.t_begin and t_start < self.t_end: + self.t_start = int(t_start) + else: + if not init or t_start != None: + logger.warning('Setting t_start = %f, since t_start not given or not valid.'%self.t_begin) + self.t_start = self.t_begin - if t_stop and t_stop <= self.t_end and t_stop > self.t_begin: - self.t_stop = int(t_stop) - else: - if not init or t_stop: - logger.warning('Setting t_stop = %f, since t_stop not given or not valid.'%self.t_end) - self.t_stop = self.t_end + if t_stop is not None: + if t_stop and t_stop <= self.t_end and t_stop > self.t_begin: + self.t_stop = int(t_stop) + else: + if not init or t_stop: + logger.warning('Setting t_stop = %f, since t_stop not given or not valid.'%self.t_end) + self.t_stop = self.t_end - if f_start and f_start >= self.f_begin and f_start < self.f_end: - self.f_start = f_start - else: - if not init or f_start: - logger.warning('Setting f_start = %f, since f_start not given or not valid.'%self.f_begin) - self.f_start = self.f_begin + if f_start is not None: + if f_start and f_start >= self.f_begin and f_start < self.f_end: + self.f_start = f_start + else: + if not init or f_start: + logger.warning('Setting f_start = %f, since f_start not given or not valid.'%self.f_begin) + self.f_start = self.f_begin - if f_stop and f_stop <= self.f_end and f_stop > self.f_begin: - self.f_stop = f_stop - else: - if not init or f_stop: - logger.warning('Setting f_stop = %f, since f_stop not given or not valid.'%self.f_end) - self.f_stop = self.f_end + if f_stop is not None: + if f_stop and f_stop <= self.f_end and f_stop > self.f_begin: + self.f_stop = f_stop + else: + if not init or f_stop: + logger.warning('Setting f_stop = %f, since f_stop not given or not valid.'%self.f_end) + self.f_stop = self.f_end #calculate shape of selection self.selection_shape = self._calc_selection_shape() From c98d11f62bb5ff3d29609224840e8e5786dc1d09 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Tue, 5 Jun 2018 16:57:30 +1000 Subject: [PATCH 42/66] Py3 freaks with None comparisons, making these more robust take 2 --- blimpy/file_wrapper.py | 82 ++++++++++++++++++++++-------------------- 1 file changed, 44 insertions(+), 38 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index 4d7a1829..7b7d480f 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -48,7 +48,16 @@ def _setup_selection_range(self, f_start=None, f_stop=None, t_start=None, t_stop """ # This avoids resetting values - if not init: + if init is True: + if t_start is None: + self.t_start = self.t_begin + if t_stop is None: + self.t_stop = self.t_end + if f_start is None: + self.f_start = self.f_begin + if f_stop is None: + self.f_stop = self.f_end + else: if f_start is None: f_start = self.f_start if f_stop is None: @@ -58,47 +67,44 @@ def _setup_selection_range(self, f_start=None, f_stop=None, t_start=None, t_stop if t_stop is None: t_stop = self.t_stop - if t_stop is not None and t_start is not None: - if t_stop >= 0 and t_start >= 0 and t_stop < t_start: - t_stop, t_start = t_start,t_stop - logger.warning('Given t_stop < t_start, assuming reversed values.') - if f_stop and f_start and f_stop < f_start: - f_stop, f_start = f_start,f_stop - logger.warning('Given f_stop < f_start, assuming reversed values.') - - if t_start is not None: - if t_start >= self.t_begin and t_start < self.t_end: - self.t_start = int(t_start) - else: - if not init or t_start != None: - logger.warning('Setting t_start = %f, since t_start not given or not valid.'%self.t_begin) - self.t_start = self.t_begin + # By now, all values start/stop are populated. - if t_stop is not None: - if t_stop and t_stop <= self.t_end and t_stop > self.t_begin: - self.t_stop = int(t_stop) - else: - if not init or t_stop: - logger.warning('Setting t_stop = %f, since t_stop not given or not valid.'%self.t_end) - self.t_stop = self.t_end + if t_stop >= 0 and t_start >= 0 and t_stop < t_start: + t_stop, t_start = t_start,t_stop + logger.warning('Given t_stop < t_start, assuming reversed values.') + if f_stop and f_start and f_stop < f_start: + f_stop, f_start = f_start,f_stop + logger.warning('Given f_stop < f_start, assuming reversed values.') - if f_start is not None: - if f_start and f_start >= self.f_begin and f_start < self.f_end: - self.f_start = f_start - else: - if not init or f_start: - logger.warning('Setting f_start = %f, since f_start not given or not valid.'%self.f_begin) - self.f_start = self.f_begin + if t_start >= self.t_begin and t_start < self.t_end: + self.t_start = int(t_start) + else: + if not init or t_start != None: + logger.warning('Setting t_start = %f, since t_start not given or not valid.'%self.t_begin) + self.t_start = self.t_begin - if f_stop is not None: - if f_stop and f_stop <= self.f_end and f_stop > self.f_begin: - self.f_stop = f_stop - else: - if not init or f_stop: - logger.warning('Setting f_stop = %f, since f_stop not given or not valid.'%self.f_end) - self.f_stop = self.f_end + if t_stop <= self.t_end and t_stop > self.t_begin: + self.t_stop = int(t_stop) + else: + if not init or t_stop: + logger.warning('Setting t_stop = %f, since t_stop not given or not valid.'%self.t_end) + self.t_stop = self.t_end + + if f_start >= self.f_begin and f_start < self.f_end: + self.f_start = f_start + else: + if not init or f_start: + logger.warning('Setting f_start = %f, since f_start not given or not valid.'%self.f_begin) + self.f_start = self.f_begin + + if f_stop <= self.f_end and f_stop > self.f_begin: + self.f_stop = f_stop + else: + if not init or f_stop: + logger.warning('Setting f_stop = %f, since f_stop not given or not valid.'%self.f_end) + self.f_stop = self.f_end - #calculate shape of selection + # Now we have setup bounds, we can calculate shape of selection self.selection_shape = self._calc_selection_shape() def _init_empty_selection(self): From 63d7ace22cb415ce1d6aa4bdadba9bc4ce735c73 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Tue, 5 Jun 2018 17:06:11 +1000 Subject: [PATCH 43/66] Py3 freaks with None comparisons, making these more robust take 3 --- blimpy/file_wrapper.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index 7b7d480f..1480a1e1 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -50,13 +50,13 @@ def _setup_selection_range(self, f_start=None, f_stop=None, t_start=None, t_stop # This avoids resetting values if init is True: if t_start is None: - self.t_start = self.t_begin + t_start = self.t_begin if t_stop is None: - self.t_stop = self.t_end + t_stop = self.t_end if f_start is None: - self.f_start = self.f_begin + f_start = self.f_begin if f_stop is None: - self.f_stop = self.f_end + f_stop = self.f_end else: if f_start is None: f_start = self.f_start From bb4b9ce4a1309c38cb4838d5c0fd66d3d570005e Mon Sep 17 00:00:00 2001 From: Danny Price Date: Tue, 5 Jun 2018 17:15:11 +1000 Subject: [PATCH 44/66] Py3: Change to integer division --- blimpy/utils.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/blimpy/utils.py b/blimpy/utils.py index ce1eb07c..01a1c2ed 100644 --- a/blimpy/utils.py +++ b/blimpy/utils.py @@ -30,13 +30,13 @@ def rebin(d, n_x, n_y=None): """ if d.ndim == 2: - d = d[:int(d.shape[0] / n_x) * n_x, :int(d.shape[1] / n_y) * n_y] - d = d.reshape((d.shape[0] / n_x, n_x, d.shape[1] / n_y, n_y)) + d = d[:int(d.shape[0] // n_x) * n_x, :int(d.shape[1] // n_y) * n_y] + d = d.reshape((d.shape[0] // n_x, n_x, d.shape[1] // n_y, n_y)) d = d.mean(axis=3) d = d.mean(axis=1) elif d.ndim == 1: - d = d[:int(d.shape[0] / n_x) * n_x] - d = d.reshape((d.shape[0] / n_x, n_x)) + d = d[:int(d.shape[0] // n_x) * n_x] + d = d.reshape((d.shape[0] // n_x, n_x)) d = d.mean(axis=1) else: raise RuntimeError("Only NDIM <= 2 supported") From 0c3c042c7f080ede03ce8c05a172f8afea20a218 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Tue, 5 Jun 2018 17:16:38 +1000 Subject: [PATCH 45/66] Py3: Catch nonetype comparison --- blimpy/file_wrapper.py | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index 1480a1e1..25fa22ae 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -335,9 +335,10 @@ def __init__(self, filename, f_start=None, f_stop=None, t_start=None, t_stop=Non MAX_DATA_ARRAY_SIZE_UNIT = 1024 * 1024 * 1024. #Applying data size limit to load. - if max_load > 1: - logger.warning('Setting data limit > 1GB, please handle with care!') - self.MAX_DATA_ARRAY_SIZE = max_load * MAX_DATA_ARRAY_SIZE_UNIT + if max_load is not None: + if max_load > 1: + logger.warning('Setting data limit > 1GB, please handle with care!') + self.MAX_DATA_ARRAY_SIZE = max_load * MAX_DATA_ARRAY_SIZE_UNIT else: self.MAX_DATA_ARRAY_SIZE = MAX_DATA_ARRAY_SIZE_UNIT @@ -506,9 +507,10 @@ def __init__(self, filename,f_start=None, f_stop=None,t_start=None, t_stop=None, self.MAX_DATA_ARRAY_SIZE_UNIT = 1024 * 1024 * 1024. #Applying data size limit to load. - if max_load > 1: - logger.warning('Setting data limit > 1GB, please handle with care!') - self.MAX_DATA_ARRAY_SIZE = max_load * self.MAX_DATA_ARRAY_SIZE_UNIT + if max_load is not None: + if max_load > 1: + logger.warning('Setting data limit > 1GB, please handle with care!') + self.MAX_DATA_ARRAY_SIZE = max_load * MAX_DATA_ARRAY_SIZE_UNIT else: self.MAX_DATA_ARRAY_SIZE = self.MAX_DATA_ARRAY_SIZE_UNIT From 9a9fdff42b6e6f63f9a3f1e08be1873f2da05564 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Tue, 5 Jun 2018 17:22:44 +1000 Subject: [PATCH 46/66] Py3: ensure computed f.seek indexes are integers --- blimpy/file_wrapper.py | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index 25fa22ae..421c44d8 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -587,20 +587,20 @@ def read_data(self, f_start=None, f_stop=None,t_start=None, t_stop=None): # Load binary data f = open(self.filename, 'rb') - f.seek(self.idx_data) + f.seek(int(self.idx_data)) # now check to see how many integrations requested n_ints = self.t_stop - self.t_start # Seek to first integration - f.seek(self.t_start * self._n_bytes * n_ifs * n_chans, 1) + f.seek(int(self.t_start * self._n_bytes * n_ifs * n_chans), 1) #Loading data self.data = np.zeros((n_ints, n_ifs, n_chans_selected), dtype=self._d_type) for ii in range(n_ints): for jj in range(n_ifs): - f.seek(self._n_bytes * self.chan_start_idx, 1) # 1 = from current location + f.seek(int(self._n_bytes * self.chan_start_idx), 1) # 1 = from current location dd = np.fromfile(f, count=n_chans_selected, dtype=self._d_type) # Reverse array if frequency axis is flipped @@ -609,7 +609,7 @@ def read_data(self, f_start=None, f_stop=None,t_start=None, t_stop=None): self.data[ii, jj] = dd - f.seek(self._n_bytes * (n_chans - self.chan_stop_idx), 1) # Seek to start of next block + f.seek(int(self._n_bytes * (n_chans - self.chan_stop_idx)), 1) # Seek to start of next block def _find_blob_start(self): """Find first blob from selection. @@ -655,7 +655,7 @@ def read_blob(self,blob_dim,n_blob=0): #Load binary data with open(self.filename, 'rb') as f: - f.seek(self.idx_data + self._n_bytes * (blob_start + n_blob*blob_flat_size)) + f.seek(int(self.idx_data + self._n_bytes * (blob_start + n_blob*blob_flat_size))) dd = np.fromfile(f, count=updated_blob_flat_size, dtype=self._d_type) if dd.shape[0] == updated_blob_flat_size: @@ -669,7 +669,7 @@ def read_blob(self,blob_dim,n_blob=0): #Load binary data with open(self.filename, 'rb') as f: - f.seek(self.idx_data + self._n_bytes * (blob_start + n_blob*blob_dim[self.time_axis]*self.n_channels_in_file + blobt*self.n_channels_in_file)) + f.seek(int(self.idx_data + self._n_bytes * (blob_start + n_blob*blob_dim[self.time_axis]*self.n_channels_in_file + blobt*self.n_channels_in_file))) dd = np.fromfile(f, count=blob_dim[self.freq_axis], dtype=self._d_type) blob[blobt] = dd @@ -686,7 +686,7 @@ def read_all(self,reverse=True): raise NotImplementedError('To be implemented') # go to start of the data - self.filfile.seek(self.datastart) + self.filfile.seek(int(self.datastart)) # read data into 2-D numpy array # data=np.fromfile(self.filfile,dtype=self.dtype).reshape(self.channels,self.blocksize,order='F') data=np.fromfile(self.filfile,dtype=self.dtype).reshape(self.blocksize, self.channels) @@ -701,7 +701,7 @@ def read_row(self,rownumber,reverse=True): raise NotImplementedError('To be implemented') # go to start of the row - self.filfile.seek(self.datastart+self.channels*rownumber*(self.nbits/8)) + self.filfile.seek(int(self.datastart+self.channels*rownumber*(self.nbits/8))) # read data into 2-D numpy array data=np.fromfile(self.filfile,count=self.channels,dtype=self.dtype).reshape(1, self.channels) if reverse: @@ -715,7 +715,7 @@ def read_rows(self,rownumber,n_rows,reverse=True): raise NotImplementedError('To be implemented') # go to start of the row - self.filfile.seek(self.datastart+self.channels*rownumber*(self.nbits/8)) + self.filfile.seek(int(self.datastart+self.channels*rownumber*(self.nbits/8))) # read data into 2-D numpy array data=np.fromfile(self.filfile,count=self.channels*n_rows,dtype=self.dtype).reshape(n_rows, self.channels) if reverse: From efc99420fe0cf60c389993010d91099ef3d74f83 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Tue, 5 Jun 2018 23:45:17 +1000 Subject: [PATCH 47/66] Updates for #31 #32 #33 #34 plotting issues --- blimpy/filterbank.py | 40 +++++++++++++++++++++++++--------------- 1 file changed, 25 insertions(+), 15 deletions(-) diff --git a/blimpy/filterbank.py b/blimpy/filterbank.py index 6ef59361..4eb53414 100755 --- a/blimpy/filterbank.py +++ b/blimpy/filterbank.py @@ -116,7 +116,7 @@ def __init__(self, filename=None, f_start=None, f_stop=None, if HAS_HDF5: if h5py.is_hdf5(filename): # TODO: self.read_hdf5(filename, f_start, f_stop, t_start, t_stop, load_data) - self.read_hdf5(filename, load_data) + self.read_hdf5(filename, f_start, f_stop, t_start, t_stop, load_data) else: self.read_filterbank(filename, f_start, f_stop, t_start, t_stop, load_data) else: @@ -141,7 +141,8 @@ def __init__(self, filename=None, f_start=None, f_stop=None, print("Calibrating the band pass.") self.calibrate_band_pass_N1() - def read_hdf5(self, filename, load_data=True): + def read_hdf5(self, filename, f_start=None, f_stop=None, + t_start=None, t_stop=None, load_data=True): """ Populate Filterbank instance with data from HDF5 file Note: @@ -163,9 +164,13 @@ def read_hdf5(self, filename, load_data=True): else: self.header[key] = val + self.n_ints_in_file = self.h5[b"data"].shape[0] + i_start, i_stop, chan_start_idx, chan_stop_idx = self._setup_freqs(f_start=f_start, f_stop=f_stop) + ii_start, ii_stop, n_ints = self._setup_time_axis(t_start=t_start, t_stop=t_stop) + if load_data: - self.data = self.h5[b"data"][:] - self.n_ints_in_file = self.data.shape[0] + self.data = self.h5[b"data"][ii_start:ii_stop, :, chan_start_idx:chan_stop_idx] + self.file_size_bytes = os.path.getsize(self.filename) # if self.header[b'foff'] < 0: @@ -177,8 +182,6 @@ def read_hdf5(self, filename, load_data=True): self.n_ints_in_file = 0 self.file_size_bytes = os.path.getsize(self.filename) - self._setup_freqs() - self._setup_time_axis() def _setup_freqs(self, f_start=None, f_stop=None): """ Setup frequency axis """ @@ -270,7 +273,7 @@ def read_filterbank(self, filename=None, f_start=None, f_stop=None, self.n_ints_in_file = n_ints_in_file self.file_size_bytes = filesize - ## Setup frequency axis + ## Setup time axis ii_start, ii_stop, n_ints = self._setup_time_axis(t_start=t_start, t_stop=t_stop) # Seek to first integration @@ -468,7 +471,7 @@ def generate_freqs(self, f_start, f_stop): return freqs - def grab_data(self, f_start=None, f_stop=None,t_start=None, t_stop=None, if_id=0): + def grab_data(self, f_start=None, f_stop=None, t_start=None, t_stop=None, if_id=0): """ Extract a portion of data by frequency range. Args: @@ -480,13 +483,20 @@ def grab_data(self, f_start=None, f_stop=None,t_start=None, t_stop=None, if_id=0 (freqs, data) (np.arrays): frequency axis in MHz and data subset """ - i_start, i_stop, chan_start_idx, chan_stop_idx = self._setup_freqs(f_start=f_start, f_stop=f_stop) + if f_start is None: + f_start = self.freqs[0] + if f_stop is None: + f_stop = self.freqs[-1] - # TODO: FIX THIS. CURRENTLY UNUSED - #ii_start, ii_stop, n_ints = self._setup_time_axis(t_start=t_start, t_stop=t_stop) + i0 = np.argmin(np.abs(self.freqs - f_start)) + i1 = np.argmin(np.abs(self.freqs - f_stop)) - plot_f = self.freqs - plot_data = np.squeeze(self.data)#[ii_start:ii_stop, if_id, chan_start_idx:chan_stop_idx] + if i0 < i1: + plot_f = self.freqs[i0:i1 + 1] + plot_data = np.squeeze(self.data[t_start:t_stop, ..., i0:i1 + 1]) + else: + plot_f = self.freqs[i1:i0 + 1] + plot_data = np.squeeze(self.data[t_start:t_stop, ..., i1:i0 + 1]) return plot_f, plot_data @@ -494,7 +504,7 @@ def calc_n_coarse_chan(self): """ This makes an attempt to calculate the number of coarse channels in a given file. It assumes for now that a single coarse channel is 2.9296875 MHz """ - + print("Warning: this is deprecated in Filterbank(). Please use equivalent in Waterfall()") # Could add a telescope based coarse channel bandwidth, or other discriminative. # if telescope_id == 'GBT': # or actually as is currently @@ -653,7 +663,7 @@ def plot_spectrum_min_max(self, t=0, f_start=None, f_stop=None, logged=False, if if logged: plt.ylim(db(fig_min),db(fig_max)) - def plot_waterfall(self, f_start=None, f_stop=None, if_id=0, logged=True,cb=True,MJD_time=False, **kwargs): + def plot_waterfall(self, f_start=None, f_stop=None, if_id=0, logged=True, cb=True, MJD_time=False, **kwargs): """ Plot waterfall of data Args: From b70ac1e7a0bc9d62000db7ff5e1d707c68988ffe Mon Sep 17 00:00:00 2001 From: Danny Price Date: Tue, 5 Jun 2018 23:45:43 +1000 Subject: [PATCH 48/66] Adding ipython notebook for quick voyager tests --- tests/voyager_test_setup.ipynb | 389 +++++++++++++++++++++++++++++++++ 1 file changed, 389 insertions(+) create mode 100644 tests/voyager_test_setup.ipynb diff --git a/tests/voyager_test_setup.ipynb b/tests/voyager_test_setup.ipynb new file mode 100644 index 00000000..ae998d15 --- /dev/null +++ b/tests/voyager_test_setup.ipynb @@ -0,0 +1,389 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Voyager test setup stuff\n", + "\n", + "Sanity checks and grabbing a few key values to pin data to in test routines.\n", + "\n", + "We know there should be Voyager telemetry at around 8419 MHz, let's extract it and make sure we're doing it right," + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import blimpy as bl\n", + "import numpy as np\n", + "import pylab as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load Fil data using Filterbank (FF) and HDF data using Filterbank (HF)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning: this function will be deprecated in the future. Please use Waterfall to open HDF5 files.\n", + "(16, 1, 39371)\n", + "(16, 1, 39371)\n", + "(39371,)\n", + "(39371,)\n", + "3.09333e+11 18960\n", + "3.09333e+11 18960\n", + "2.74257e+11 18997\n", + "2.74257e+11 18997\n", + "extracting integration 0...\n", + "extracting integration 0...\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ff = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.fil', f_start=8419.24, f_stop=8419.35)\n", + "hf = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.h5', f_start=8419.24, f_stop=8419.35)\n", + "\n", + "print ff.data.shape\n", + "print hf.data.shape\n", + "print ff.freqs.shape\n", + "print hf.freqs.shape\n", + "\n", + "print ff.data[0].max(), ff.data[0].argmax()\n", + "print hf.data[0].max(), hf.data[0].argmax()\n", + "print ff.data[-1].max(), ff.data[-1].argmax()\n", + "print hf.data[-1].max(), hf.data[-1].argmax()\n", + "\n", + "# Assert data is loaded to the same shape and has same values\n", + "assert ff.data.shape == hf.data.shape == (16, 1, 39371)\n", + "assert np.allclose(ff.data, hf.data)\n", + "\n", + "# Check the Voyager carrier has the known amplitudes at first and last integration\n", + "assert np.allclose(ff.data[0].max(), hf.data[0].max(), 3.09333e+11)\n", + "assert np.allclose(ff.data[-1].max(), hf.data[-1].max(), 2.74257e+11)\n", + "\n", + "# Check the tone is in the same bin for both\n", + "assert ff.data[0].argmax() == hf.data[0].argmax() == 18960\n", + "assert ff.data[-1].argmax() == hf.data[-1].argmax() == 18997\n", + "\n", + "plt.subplot(2,1,1)\n", + "ff.plot_spectrum()\n", + "\n", + "plt.subplot(2,1,2)\n", + "hf.plot_spectrum()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Find the max and min values, and visual confirmation" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(16, 1, 39370)\n", + "(16, 1, 39370)\n", + "3.09333e+11 18959\n", + "3.09333e+11 18959\n", + "2.74257e+11 18996\n", + "2.74257e+11 18996\n", + "extracting integration 0...\n", + "extracting integration 0...\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fw = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.fil', f_start=8419.24, f_stop=8419.35)\n", + "hw = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.h5', f_start=8419.24, f_stop=8419.35)\n", + "\n", + "print fw.data.shape\n", + "print hw.data.shape\n", + "print hw.data[0].max(), hw.data[0].argmax()\n", + "print fw.data[0].max(), fw.data[0].argmax()\n", + "print hw.data[-1].max(), hw.data[-1].argmax()\n", + "print fw.data[-1].max(), fw.data[-1].argmax()\n", + "\n", + "# Assert data is loaded to the same shape and has same values\n", + "assert hw.data.shape == fw.data.shape == (16, 1, 39370)\n", + "assert np.allclose(hw.data, fw.data)\n", + "\n", + "# Check the Voyager carrier has the known amplitudes at first and last integration\n", + "assert np.allclose(hw.data[0].max(), fw.data[0].max(), 3.09333e+11)\n", + "assert np.allclose(hw.data[-1].max(), fw.data[-1].max(), 2.74257e+11)\n", + "\n", + "# Check the tone is in the same bin for both\n", + "assert hw.data[0].argmax() == fw.data[0].argmax() == 18959\n", + "assert hw.data[-1].argmax() == fw.data[-1].argmax() == 18996\n", + "\n", + "# And plot\n", + "plt.subplot(2,1,1)\n", + "fw.plot_spectrum()\n", + "\n", + "plt.subplot(2,1,2)\n", + "hw.plot_spectrum()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Sanity check: all spectra are the same" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "extracting integration 0...\n", + "extracting integration 0...\n", + "extracting integration 0...\n", + "extracting integration 0...\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "all_readers = [ff, hf, ff, hf]\n", + "\n", + "plt.figure(figsize=(8, 8))\n", + "for ii, rr in enumerate(all_readers):\n", + " plt.subplot(4, 1, ii+1)\n", + " rr.plot_spectrum()\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Loading full file and _then_ plotting extracted portions" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning: this function will be deprecated in the future. Please use Waterfall to open HDF5 files.\n" + ] + } + ], + "source": [ + "ff = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.fil')\n", + "hf = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.h5')\n", + "fw = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.fil')\n", + "hw = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.h5')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "extracting integration 0...\n", + "extracting integration 0...\n", + "extracting integration 0...\n", + "extracting integration 0...\n", + "extracting integration 0...\n", + "extracting integration 0...\n", + "extracting integration 0...\n", + "extracting integration 0...\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "all_readers = [ff, hf, ff, hf]\n", + "\n", + "plt.figure(figsize=(8, 8))\n", + "for ii, rr in enumerate(all_readers):\n", + " plt.subplot(4, 1, ii+1)\n", + " rr.plot_spectrum(f_start=8419.24, f_stop=8419.35)\n", + "plt.tight_layout()\n", + "\n", + "plt.figure(figsize=(8, 8))\n", + "for ii, rr in enumerate(all_readers):\n", + " plt.subplot(4, 1, ii+1)\n", + " rr.plot_spectrum(f_start=8419.29685, f_stop=8419.2972)\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8, 8))\n", + "for ii, rr in enumerate(all_readers):\n", + " plt.subplot(4, 1, ii+1)\n", + " rr.plot_waterfall(f_start=8419.29685, f_stop=8419.2971)\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(91,) (16, 91)\n", + "(91,) (16, 91)\n", + "(91,) (16, 91)\n", + "(91,) (16, 91)\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for ii, rr in enumerate(all_readers):\n", + " #plt.subplot(4, 1, ii+1)\n", + " #rr.plot_waterfall(f_start=8419.29685, f_stop=8419.2971)\n", + " print f.shape, d.shape\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.14" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 2e6b778cc15b046475484a755ceaad85d8e24ff4 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Wed, 6 Jun 2018 00:10:18 +1000 Subject: [PATCH 49/66] Updates for #31 #32 #33 #34 plotting issues -- not all fixed. --- tests/test_voyager_data_load.py | 100 ++++++++++++++++++++++++++++++++ 1 file changed, 100 insertions(+) create mode 100644 tests/test_voyager_data_load.py diff --git a/tests/test_voyager_data_load.py b/tests/test_voyager_data_load.py new file mode 100644 index 00000000..6ffb7659 --- /dev/null +++ b/tests/test_voyager_data_load.py @@ -0,0 +1,100 @@ +""" +# test_voyager_data_load.py + +The hard-coded numbers in these tests can be found in the voyager_test_setup.ipynb + +""" + +import blimpy as bl +import numpy as np +import pylab as plt + +def test_filterbank_data_load_range_freq(): + ff = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.fil', f_start=8419.24, f_stop=8419.35) + hf = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.h5', f_start=8419.24, f_stop=8419.35) + + print ff.data.shape + print hf.data.shape + print ff.freqs.shape + print hf.freqs.shape + + print ff.data[0].max(), ff.data[0].argmax() + print hf.data[0].max(), hf.data[0].argmax() + print ff.data[-1].max(), ff.data[-1].argmax() + print hf.data[-1].max(), hf.data[-1].argmax() + + # Assert data is loaded to the same shape and has same values + assert ff.data.shape == hf.data.shape == (16, 1, 39371) + assert np.allclose(ff.data, hf.data) + + # Check the Voyager carrier has the known amplitudes at first and last integration + assert np.allclose(ff.data[0].max(), hf.data[0].max(), 3.09333e+11) + assert np.allclose(ff.data[-1].max(), hf.data[-1].max(), 2.74257e+11) + + # Check the tone is in the same bin for both + assert ff.data[0].argmax() == hf.data[0].argmax() == 18960 + assert ff.data[-1].argmax() == hf.data[-1].argmax() == 18997 + + plt.subplot(2,1,1) + ff.plot_spectrum() + + plt.subplot(2,1,2) + hf.plot_spectrum() + plt.tight_layout() + + +def test_waterfall_data_load_range_freq(): + fw = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.fil', f_start=8419.24, f_stop=8419.35) + hw = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.h5', f_start=8419.24, f_stop=8419.35) + + print fw.data.shape + print hw.data.shape + print hw.data[0].max(), hw.data[0].argmax() + print fw.data[0].max(), fw.data[0].argmax() + print hw.data[-1].max(), hw.data[-1].argmax() + print fw.data[-1].max(), fw.data[-1].argmax() + + # Assert data is loaded to the same shape and has same values + assert hw.data.shape == fw.data.shape == (16, 1, 39370) + assert np.allclose(hw.data, fw.data) + + # Check the Voyager carrier has the known amplitudes at first and last integration + assert np.allclose(hw.data[0].max(), fw.data[0].max(), 3.09333e+11) + assert np.allclose(hw.data[-1].max(), fw.data[-1].max(), 2.74257e+11) + + # Check the tone is in the same bin for both + assert hw.data[0].argmax() == fw.data[0].argmax() == 18959 + assert hw.data[-1].argmax() == fw.data[-1].argmax() == 18996 + + # And plot + plt.subplot(2,1,1) + fw.plot_spectrum() + + plt.subplot(2,1,2) + hw.plot_spectrum() + plt.tight_layout() + +def test_grab_data_works_across_all_fil_h5(): + + ff = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.fil') + hf = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.h5') + fw = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.fil') + hw = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.h5') + all_readers = [ff, hf, fw, hw] + + for ii, rr in enumerate(all_readers): + f, d = rr.grab_data(f_start=8419.29, f_stop=8419.30) + print f.shape, d.shape + assert f.shape == (3580,) + assert d.shape == (16, 3580) + + for ii, rr in enumerate(all_readers): + f, d = rr.grab_data(f_start=8419.29685, f_stop=8419.2971) + print f.shape, d.shape + assert f.shape == (91,) + assert d.shape == (16, 91) + +if __name__ == "__main__": + test_filterbank_data_load_range_freq() + test_waterfall_data_load_range_freq() + test_grab_data_works_across_all_fil_h5() From ed252c479c01016dd388c94286fe7cfe349bb0f0 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Wed, 6 Jun 2018 00:18:17 +1000 Subject: [PATCH 50/66] Py3 Print parenthesis. --- tests/test_voyager_data_load.py | 30 +++---- tests/voyager_test_setup.ipynb | 139 +++++++++++++++++--------------- 2 files changed, 87 insertions(+), 82 deletions(-) diff --git a/tests/test_voyager_data_load.py b/tests/test_voyager_data_load.py index 6ffb7659..74ea42b8 100644 --- a/tests/test_voyager_data_load.py +++ b/tests/test_voyager_data_load.py @@ -13,15 +13,15 @@ def test_filterbank_data_load_range_freq(): ff = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.fil', f_start=8419.24, f_stop=8419.35) hf = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.h5', f_start=8419.24, f_stop=8419.35) - print ff.data.shape - print hf.data.shape - print ff.freqs.shape - print hf.freqs.shape + print(ff.data.shape) + print(hf.data.shape) + print(ff.freqs.shape) + print(hf.freqs.shape)() - print ff.data[0].max(), ff.data[0].argmax() - print hf.data[0].max(), hf.data[0].argmax() - print ff.data[-1].max(), ff.data[-1].argmax() - print hf.data[-1].max(), hf.data[-1].argmax() + print(ff.data[0].max(), ff.data[0].argmax()) + print(hf.data[0].max(), hf.data[0].argmax()) + print(ff.data[-1].max(), ff.data[-1].argmax()) + print(hf.data[-1].max(), hf.data[-1].argmax())() # Assert data is loaded to the same shape and has same values assert ff.data.shape == hf.data.shape == (16, 1, 39371) @@ -47,12 +47,12 @@ def test_waterfall_data_load_range_freq(): fw = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.fil', f_start=8419.24, f_stop=8419.35) hw = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.h5', f_start=8419.24, f_stop=8419.35) - print fw.data.shape - print hw.data.shape - print hw.data[0].max(), hw.data[0].argmax() - print fw.data[0].max(), fw.data[0].argmax() - print hw.data[-1].max(), hw.data[-1].argmax() - print fw.data[-1].max(), fw.data[-1].argmax() + print(fw.data.shape) + print(hw.data.shape) + print(hw.data[0].max(), hw.data[0].argmax()) + print(fw.data[0].max(), fw.data[0].argmax()) + print(hw.data[-1].max(), hw.data[-1].argmax()) + print(fw.data[-1].max(), fw.data[-1].argmax()) # Assert data is loaded to the same shape and has same values assert hw.data.shape == fw.data.shape == (16, 1, 39370) @@ -66,7 +66,7 @@ def test_waterfall_data_load_range_freq(): assert hw.data[0].argmax() == fw.data[0].argmax() == 18959 assert hw.data[-1].argmax() == fw.data[-1].argmax() == 18996 - # And plot + # And plot( plt.subplot(2,1,1) fw.plot_spectrum() diff --git a/tests/voyager_test_setup.ipynb b/tests/voyager_test_setup.ipynb index ae998d15..00c9099c 100644 --- a/tests/voyager_test_setup.ipynb +++ b/tests/voyager_test_setup.ipynb @@ -40,7 +40,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -48,32 +48,31 @@ "output_type": "stream", "text": [ "Warning: this function will be deprecated in the future. Please use Waterfall to open HDF5 files.\n", - "(16, 1, 39371)\n", - "(16, 1, 39371)\n", - "(39371,)\n", - "(39371,)\n", - "3.09333e+11 18960\n", - "3.09333e+11 18960\n", - "2.74257e+11 18997\n", - "2.74257e+11 18997\n", - "extracting integration 0...\n", - "extracting integration 0...\n" + "(16, 1, 39729)\n", + "(16, 1, 39729)\n", + "(39729,)\n", + "(39729,)\n", + "3.09333e+11 19318\n", + "3.09333e+11 19318\n", + "2.74257e+11 19355\n", + "2.74257e+11 19355\n" ] }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0;31m# Assert data is loaded to the same shape and has same values\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mff\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mhf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m16\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m39371\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 16\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mallclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mff\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAssertionError\u001b[0m: " + ] } ], "source": [ - "ff = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.fil', f_start=8419.24, f_stop=8419.35)\n", - "hf = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.h5', f_start=8419.24, f_stop=8419.35)\n", + "ff = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.fil', f_start=8419.24, f_stop=8419.351)\n", + "hf = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.h5', f_start=8419.24, f_stop=8419.351)\n", "\n", "print ff.data.shape\n", "print hf.data.shape\n", @@ -114,37 +113,36 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "(16, 1, 39370)\n", - "(16, 1, 39370)\n", - "3.09333e+11 18959\n", - "3.09333e+11 18959\n", - "2.74257e+11 18996\n", - "2.74257e+11 18996\n", - "extracting integration 0...\n", - "extracting integration 0...\n" + "(16, 1, 39728)\n", + "(16, 1, 39728)\n", + "3.09333e+11 19317\n", + "3.09333e+11 19317\n", + "2.74257e+11 19354\n", + "2.74257e+11 19354\n" ] }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0;31m# Assert data is loaded to the same shape and has same values\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mhw\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mfw\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m16\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m39370\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 13\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mallclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhw\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfw\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAssertionError\u001b[0m: " + ] } ], "source": [ - "fw = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.fil', f_start=8419.24, f_stop=8419.35)\n", - "hw = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.h5', f_start=8419.24, f_stop=8419.35)\n", + "fw = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.fil', f_start=8419.24, f_stop=8419.351)\n", + "hw = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.h5', f_start=8419.24, f_stop=8419.351)\n", "\n", "print fw.data.shape\n", "print hw.data.shape\n", @@ -183,7 +181,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -200,7 +198,7 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -226,7 +224,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -246,7 +244,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -265,9 +263,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -275,9 +273,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -285,7 +283,7 @@ } ], "source": [ - "all_readers = [ff, hf, ff, hf]\n", + "all_readers = [ff, hf, fw, hw]\n", "\n", "plt.figure(figsize=(8, 8))\n", "for ii, rr in enumerate(all_readers):\n", @@ -302,14 +300,14 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -326,35 +324,42 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "(91,) (16, 91)\n", - "(91,) (16, 91)\n", - "(91,) (16, 91)\n", - "(91,) (16, 91)\n" + "(3580,) (16, 3580)\n", + "(3580,) (16, 3580)\n", + "(1048576,) (16, 1048576)\n" ] }, { - "data": { - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" + "ename": "AssertionError", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrab_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf_start\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m8419.29\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mf_stop\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m8419.30\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;32mprint\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m3580\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m16\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3580\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mAssertionError\u001b[0m: " + ] } ], "source": [ "for ii, rr in enumerate(all_readers):\n", - " #plt.subplot(4, 1, ii+1)\n", - " #rr.plot_waterfall(f_start=8419.29685, f_stop=8419.2971)\n", + " f, d = rr.grab_data(f_start=8419.29, f_stop=8419.30)\n", " print f.shape, d.shape\n", - "plt.tight_layout()" + " assert f.shape == (3580,)\n", + " assert d.shape == (16, 3580)\n", + "\n", + "for ii, rr in enumerate(all_readers):\n", + " f, d = rr.grab_data(f_start=8419.29685, f_stop=8419.2971)\n", + " print f.shape, d.shape\n", + " assert f.shape == (91,)\n", + " assert d.shape == (16, 91)" ] }, { From 09e244b3a97b0f4e0b611994095b473a972eccec Mon Sep 17 00:00:00 2001 From: Danny Price Date: Wed, 6 Jun 2018 13:31:23 +1000 Subject: [PATCH 51/66] Added unit tests for utils --- blimpy/utils.py | 7 +++++-- tests/test_utils.py | 28 ++++++++++++++++++++++++++++ 2 files changed, 33 insertions(+), 2 deletions(-) create mode 100644 tests/test_utils.py diff --git a/blimpy/utils.py b/blimpy/utils.py index 01a1c2ed..546b486c 100644 --- a/blimpy/utils.py +++ b/blimpy/utils.py @@ -14,7 +14,7 @@ def lin(x): def closest(xarr, val): """ Return the index of the closest in xarr to value val """ - idx_closest = np.argmin(np.abs(xarr - val)) + idx_closest = np.argmin(np.abs(np.array(xarr) - val)) return idx_closest def rebin(d, n_x, n_y=None): @@ -30,6 +30,10 @@ def rebin(d, n_x, n_y=None): """ if d.ndim == 2: + if n_y is None: + n_y = 1 + if n_x is None: + n_x = 1 d = d[:int(d.shape[0] // n_x) * n_x, :int(d.shape[1] // n_y) * n_y] d = d.reshape((d.shape[0] // n_x, n_x, d.shape[1] // n_y, n_y)) d = d.mean(axis=3) @@ -84,7 +88,6 @@ def unpack(data, nbit): return updata.view(data.dtype) - def unpack_2to8(data): """ Promote 2-bit unisgned data into 8-bit unsigned data. diff --git a/tests/test_utils.py b/tests/test_utils.py new file mode 100644 index 00000000..0152ad97 --- /dev/null +++ b/tests/test_utils.py @@ -0,0 +1,28 @@ +from blimpy import utils +import numpy as np + +def test_utils(): + assert utils.db(100) == 20.0 + assert utils.lin(20) == 100.0 + assert utils.closest(np.array([0,1,2,3,4,5]), 2.2) == 2 + +def test_rebin(): + # 1D + a = np.array([1, 1, 1, 1]) + aR = utils.rebin(a, 2) + assert np.allclose(aR, np.array([1, 1])) + + # 2D + b = np.array([[1,1,1,1], [2,2,2,2]]) + bR = utils.rebin(b, 1, 2) + assert np.allclose(bR, [[1,1], [2,2]]) + bR = utils.rebin(b, None, 2) + assert np.allclose(bR, [[1,1], [2,2]]) + bR = utils.rebin(b, 2, 1) + assert np.allclose(bR, [1.5, 1.5, 1.5, 1.5]) + bR = utils.rebin(b, 2, None) + assert np.allclose(bR, [1.5, 1.5, 1.5, 1.5]) + +if __name__ == "__main__": + test_utils() + test_rebin() \ No newline at end of file From 269f060d7b8b64c35e715daa5a66ca36abe83bcd Mon Sep 17 00:00:00 2001 From: Danny Price Date: Wed, 6 Jun 2018 13:32:06 +1000 Subject: [PATCH 52/66] Unit tests now passing for Waterfall --- tests/test_voyager_data_load.py | 8 +-- tests/voyager_test_setup.ipynb | 120 +++++++++++++++----------------- 2 files changed, 62 insertions(+), 66 deletions(-) diff --git a/tests/test_voyager_data_load.py b/tests/test_voyager_data_load.py index 74ea42b8..b664460a 100644 --- a/tests/test_voyager_data_load.py +++ b/tests/test_voyager_data_load.py @@ -16,12 +16,12 @@ def test_filterbank_data_load_range_freq(): print(ff.data.shape) print(hf.data.shape) print(ff.freqs.shape) - print(hf.freqs.shape)() + print(hf.freqs.shape) print(ff.data[0].max(), ff.data[0].argmax()) print(hf.data[0].max(), hf.data[0].argmax()) print(ff.data[-1].max(), ff.data[-1].argmax()) - print(hf.data[-1].max(), hf.data[-1].argmax())() + print(hf.data[-1].max(), hf.data[-1].argmax()) # Assert data is loaded to the same shape and has same values assert ff.data.shape == hf.data.shape == (16, 1, 39371) @@ -84,13 +84,13 @@ def test_grab_data_works_across_all_fil_h5(): for ii, rr in enumerate(all_readers): f, d = rr.grab_data(f_start=8419.29, f_stop=8419.30) - print f.shape, d.shape + print(f.shape, d.shape) assert f.shape == (3580,) assert d.shape == (16, 3580) for ii, rr in enumerate(all_readers): f, d = rr.grab_data(f_start=8419.29685, f_stop=8419.2971) - print f.shape, d.shape + print(f.shape, d.shape) assert f.shape == (91,) assert d.shape == (16, 91) diff --git a/tests/voyager_test_setup.ipynb b/tests/voyager_test_setup.ipynb index 00c9099c..7d3b2b5c 100644 --- a/tests/voyager_test_setup.ipynb +++ b/tests/voyager_test_setup.ipynb @@ -40,7 +40,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -48,31 +48,32 @@ "output_type": "stream", "text": [ "Warning: this function will be deprecated in the future. Please use Waterfall to open HDF5 files.\n", - "(16, 1, 39729)\n", - "(16, 1, 39729)\n", - "(39729,)\n", - "(39729,)\n", - "3.09333e+11 19318\n", - "3.09333e+11 19318\n", - "2.74257e+11 19355\n", - "2.74257e+11 19355\n" + "(16, 1, 39371)\n", + "(16, 1, 39371)\n", + "(39371,)\n", + "(39371,)\n", + "3.09333e+11 18960\n", + "3.09333e+11 18960\n", + "2.74257e+11 18997\n", + "2.74257e+11 18997\n", + "extracting integration 0...\n", + "extracting integration 0...\n" ] }, { - "ename": "AssertionError", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 13\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0;31m# Assert data is loaded to the same shape and has same values\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mff\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mhf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m16\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m39371\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 16\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mallclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mff\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mhf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mAssertionError\u001b[0m: " - ] + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "ff = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.fil', f_start=8419.24, f_stop=8419.351)\n", - "hf = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.h5', f_start=8419.24, f_stop=8419.351)\n", + "ff = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.fil', f_start=8419.24, f_stop=8419.35)\n", + "hf = bl.Filterbank('Voyager_data/Voyager1.single_coarse.fine_res.h5', f_start=8419.24, f_stop=8419.35)\n", "\n", "print ff.data.shape\n", "print hf.data.shape\n", @@ -113,36 +114,37 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "(16, 1, 39728)\n", - "(16, 1, 39728)\n", - "3.09333e+11 19317\n", - "3.09333e+11 19317\n", - "2.74257e+11 19354\n", - "2.74257e+11 19354\n" + "(16, 1, 39370)\n", + "(16, 1, 39370)\n", + "3.09333e+11 18959\n", + "3.09333e+11 18959\n", + "2.74257e+11 18996\n", + "2.74257e+11 18996\n", + "extracting integration 0...\n", + "extracting integration 0...\n" ] }, { - "ename": "AssertionError", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0;31m# Assert data is loaded to the same shape and has same values\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mhw\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mfw\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m16\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m39370\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 13\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mallclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhw\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfw\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mAssertionError\u001b[0m: " - ] + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "fw = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.fil', f_start=8419.24, f_stop=8419.351)\n", - "hw = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.h5', f_start=8419.24, f_stop=8419.351)\n", + "fw = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.fil', f_start=8419.24, f_stop=8419.35)\n", + "hw = bl.Waterfall('Voyager_data/Voyager1.single_coarse.fine_res.h5', f_start=8419.24, f_stop=8419.35)\n", "\n", "print fw.data.shape\n", "print hw.data.shape\n", @@ -181,7 +183,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -198,7 +200,7 @@ "data": { "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -224,7 +226,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -244,7 +246,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -263,9 +265,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -273,9 +275,9 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -300,14 +302,14 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -324,7 +326,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -333,18 +335,12 @@ "text": [ "(3580,) (16, 3580)\n", "(3580,) (16, 3580)\n", - "(1048576,) (16, 1048576)\n" - ] - }, - { - "ename": "AssertionError", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAssertionError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrab_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf_start\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m8419.29\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mf_stop\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m8419.30\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;32mprint\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0;32massert\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m3580\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0;32massert\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m16\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3580\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mAssertionError\u001b[0m: " + "(3580,) (16, 3580)\n", + "(3580,) (16, 3580)\n", + "(91,) (16, 91)\n", + "(91,) (16, 91)\n", + "(91,) (16, 91)\n", + "(91,) (16, 91)\n" ] } ], From f3412997d176f2b83734d3deca3f3c1df1eef1a7 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Wed, 6 Jun 2018 14:14:57 +1000 Subject: [PATCH 53/66] Added unpack unit tests --- tests/test_unpack.py | 59 ++++++++++++++++++++++++++++++++++++++++++-- tests/test_utils.py | 5 ++++ 2 files changed, 62 insertions(+), 2 deletions(-) diff --git a/tests/test_unpack.py b/tests/test_unpack.py index a22c8709..3d1dd64e 100644 --- a/tests/test_unpack.py +++ b/tests/test_unpack.py @@ -1,6 +1,14 @@ -from blimpy.utils import unpack_2to8 +from blimpy.utils import unpack_1to8, unpack_2to8, unpack_4to8, unpack import numpy as np +import pytest +def test_1to8(): + a = np.array([0b01010101, 0b10101010], dtype=np.uint8) + b = np.array([0,1,0,1,0,1,0,1,1,0,1,0,1,0,1,0]) + c = unpack_1to8(a) + assert np.allclose(b, c) + print b + print c def test_2to8(): # Create an array that should come out as [0, 1, 2, 3, 3, 2, 1, 0] @@ -14,5 +22,52 @@ def test_2to8(): assert np.allclose(b, c) +def test_4to8(): + # Create an array that should come out as [0, 1, 2, 3, 3, 2, 1, 0] + # In binary, this is [00, 01, 10, 11, 11, 10, 01, 00] + # Convert to 8-bit, this is [0b00011011, 0b11100100] + + # Test 4-bit unpack + a = np.array([0b00000001, 0b00100011], dtype=np.uint8) + b = np.array([0, 1, 2, 3], dtype=np.uint8) + c = unpack_4to8(a) + assert np.allclose(b, c) + +def test_unpack(): + + # Test 2-bit unpack + a = np.array([0b00011011, 0b11100100], dtype=np.uint8) + b = np.array([0, 1, 2, 3, 3, 2, 1, 0], dtype=np.uint8) + c = unpack(a, 2) + assert np.allclose(b, c) + + # Catch exceptions + with pytest.raises(ValueError): + unpack(a, 16) # nbit <= 8 is reqd + with pytest.raises(ValueError): + unpack(a, 3) # nbit must divide 8 (1,2,4 or 8) + z = np.array([1,2,3], dtype='float32') + with pytest.raises(TypeError): + unpack(z, 2) # input data must be 8-bit + + # Test 4-bit unpack + a = np.array([0b00000001, 0b00100011], dtype=np.uint8) + b = np.array([0, 1, 2, 3], dtype=np.uint8) + c = unpack(a, 4) + print b + print c + assert np.allclose(b, c) + + # Test 1-bit unpack + a = np.array([0b01010101, 0b10101010], dtype=np.uint8) + b = np.array([0,1,0,1,0,1,0,1,1,0,1,0,1,0,1,0]) + c = unpack(a, 1) + print b + print c + assert np.allclose(b, c) + if __name__ == "__main__": - test_2to8() \ No newline at end of file + test_1to8() + test_2to8() + test_4to8() + test_unpack() \ No newline at end of file diff --git a/tests/test_utils.py b/tests/test_utils.py index 0152ad97..63201646 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -1,5 +1,6 @@ from blimpy import utils import numpy as np +import pytest def test_utils(): assert utils.db(100) == 20.0 @@ -23,6 +24,10 @@ def test_rebin(): bR = utils.rebin(b, 2, None) assert np.allclose(bR, [1.5, 1.5, 1.5, 1.5]) + c = np.zeros([10, 10, 10]) + with pytest.raises(RuntimeError): + utils.rebin(c, 2, 2) + if __name__ == "__main__": test_utils() test_rebin() \ No newline at end of file From 1ef38cf12739e1d6636841a29ebea41952f54c35 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Wed, 6 Jun 2018 14:15:21 +1000 Subject: [PATCH 54/66] Fixed up unpack code and added unittests --- blimpy/utils.py | 58 ++++++++++++++++++++++++++++++------------------- 1 file changed, 36 insertions(+), 22 deletions(-) diff --git a/blimpy/utils.py b/blimpy/utils.py index 546b486c..4ac0374d 100644 --- a/blimpy/utils.py +++ b/blimpy/utils.py @@ -60,33 +60,22 @@ def unpack(data, nbit): if nbit == 8: return data elif nbit == 4: - #The process is this: - #ABCDEFGH [Bits of one 4+4-bit value] - #00000000ABCDEFGH [astype(uint16)] - #0000ABCDEFGH0000 [<< 4] - #0000ABCDXXXXEFGH [bitwise 'or' of previous two lines] - #0000111100001111 [0x0F0F] - #0000ABCD0000EFGH [bitwise 'and' of previous two lines] - #ABCD0000EFGH0000 [<< 4] - #which effectively pads the two 4-bit values with zeros on the right - # Note: This technique assumes LSB-first ordering - tmpdata = data.astype(np.int16)#np.empty(upshape, dtype=np.int16) - tmpdata = (tmpdata | (tmpdata << 8)) & 0x0F0F - tmpdata = tmpdata << 4 # Shift into high bits to avoid needing to sign extend - updata = tmpdata - return updata.view(data.dtype) + data = unpack_4to8(data) + return data elif nbit == 2: data = unpack_2to8(data) return data elif nbit == 1: - tmpdata = data.astype(np.int64)#np.empty(upshape, dtype=np.int16) - tmpdata = (tmpdata | (tmpdata << 32)) & 0x0000000F0000000F - tmpdata = (tmpdata | (tmpdata << 16)) & 0x0003000300030003 - tmpdata = (tmpdata | (tmpdata << 8)) & 0x0101010101010101 - tmpdata = tmpdata << 7 # Shift into high bits to avoid needing to sign extend - updata = tmpdata - return updata.view(data.dtype) + data = unpack_1to8(data) + return data +def unpack_1to8(data): + """ Promote 1-bit unisgned data into 8-bit unsigned data. + + Args: + data: Numpy array with dtype == uint8 + """ + return np.unpackbits(data) def unpack_2to8(data): """ Promote 2-bit unisgned data into 8-bit unsigned data. @@ -119,3 +108,28 @@ def unpack_2to8(data): tmp = (tmp | (tmp << 6)) & 0x3030303 tmp = tmp.byteswap() return tmp.view('uint8') + +def unpack_4to8(data): + """ Promote 2-bit unisgned data into 8-bit unsigned data. + + Args: + data: Numpy array with dtype == uint8 + + Notes: + # The process is this: + # ABCDEFGH [Bits of one 4+4-bit value] + # 00000000ABCDEFGH [astype(uint16)] + # 0000ABCDEFGH0000 [<< 4] + # 0000ABCDXXXXEFGH [bitwise 'or' of previous two lines] + # 0000111100001111 [0x0F0F] + # 0000ABCD0000EFGH [bitwise 'and' of previous two lines] + # ABCD0000EFGH0000 [<< 4] + # which effectively pads the two 4-bit values with zeros on the right + # Note: This technique assumes LSB-first ordering + """ + + tmpdata = data.astype(np.int16) # np.empty(upshape, dtype=np.int16) + tmpdata = (tmpdata | (tmpdata << 4)) & 0x0F0F + # tmpdata = tmpdata << 4 # Shift into high bits to avoid needing to sign extend + updata = tmpdata.byteswap() + return updata.view(data.dtype) From 9a969f18966234eb09f777ef59f4df03da444198 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Wed, 6 Jun 2018 14:15:50 +1000 Subject: [PATCH 55/66] Updated waterfall.py grab_data to fix #31 #32 #33 #34 --- blimpy/waterfall.py | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/blimpy/waterfall.py b/blimpy/waterfall.py index 64a7ea63..d68bec41 100755 --- a/blimpy/waterfall.py +++ b/blimpy/waterfall.py @@ -517,8 +517,20 @@ def grab_data(self, f_start=None, f_stop=None,t_start=None, t_stop=None, if_id=0 self.freqs = self.populate_freqs() self.timestamps = self.populate_timestamps() - plot_f = self.freqs - plot_data = np.squeeze(self.data) + if f_start is None: + f_start = self.freqs[0] + if f_stop is None: + f_stop = self.freqs[-1] + + i0 = np.argmin(np.abs(self.freqs - f_start)) + i1 = np.argmin(np.abs(self.freqs - f_stop)) + + if i0 < i1: + plot_f = self.freqs[i0:i1 + 1] + plot_data = np.squeeze(self.data[t_start:t_stop, ..., i0:i1 + 1]) + else: + plot_f = self.freqs[i1:i0 + 1] + plot_data = np.squeeze(self.data[t_start:t_stop, ..., i1:i0 + 1]) return plot_f, plot_data From 49285f29bebe28988b1e3ad03e98da0c484add82 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Wed, 6 Jun 2018 14:18:13 +1000 Subject: [PATCH 56/66] utils.py coverage now at 100% --- tests/test_unpack.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tests/test_unpack.py b/tests/test_unpack.py index 3d1dd64e..30068a2d 100644 --- a/tests/test_unpack.py +++ b/tests/test_unpack.py @@ -66,6 +66,10 @@ def test_unpack(): print c assert np.allclose(b, c) + # Test 8-bit! + c = unpack(a, 8) + assert np.allclose(a, c) + if __name__ == "__main__": test_1to8() test_2to8() From f006d5c0ac5273e7b36b483bf94bb9548676d2ef Mon Sep 17 00:00:00 2001 From: Danny Price Date: Wed, 6 Jun 2018 14:24:07 +1000 Subject: [PATCH 57/66] More Py3 parentheses --- tests/test_unpack.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/tests/test_unpack.py b/tests/test_unpack.py index 30068a2d..efd4871a 100644 --- a/tests/test_unpack.py +++ b/tests/test_unpack.py @@ -7,8 +7,8 @@ def test_1to8(): b = np.array([0,1,0,1,0,1,0,1,1,0,1,0,1,0,1,0]) c = unpack_1to8(a) assert np.allclose(b, c) - print b - print c + print(b) + print(c) def test_2to8(): # Create an array that should come out as [0, 1, 2, 3, 3, 2, 1, 0] @@ -54,16 +54,16 @@ def test_unpack(): a = np.array([0b00000001, 0b00100011], dtype=np.uint8) b = np.array([0, 1, 2, 3], dtype=np.uint8) c = unpack(a, 4) - print b - print c + print(b) + print(c) assert np.allclose(b, c) # Test 1-bit unpack a = np.array([0b01010101, 0b10101010], dtype=np.uint8) b = np.array([0,1,0,1,0,1,0,1,1,0,1,0,1,0,1,0]) c = unpack(a, 1) - print b - print c + print(b) + print(c) assert np.allclose(b, c) # Test 8-bit! From 5b81eb3670791a450b4c27e4a4cfd921c4e867bd Mon Sep 17 00:00:00 2001 From: Danny Price Date: Wed, 6 Jun 2018 20:20:54 +1000 Subject: [PATCH 58/66] First attempt to add code coverage --- .travis.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index e167dc3d..49d9b8c2 100644 --- a/.travis.yml +++ b/.travis.yml @@ -16,7 +16,9 @@ install: # command to install dependencies script: - - cd tests; pytest + - cd tests; coverage run --source=blimpy -m py.test + +after_success: coveralls branches: only: From 7a687e71308813bc1dcbeaf91dc41ca7f9e73fd8 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Wed, 6 Jun 2018 20:53:02 +1000 Subject: [PATCH 59/66] First attempt to add code coverage --- .travis.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.travis.yml b/.travis.yml index 49d9b8c2..1a1fef1f 100644 --- a/.travis.yml +++ b/.travis.yml @@ -9,6 +9,7 @@ install: - sudo apt-get install -qq libhdf5-serial-dev - pip install --upgrade pip setuptools wheel - pip install --only-binary=numpy,scipy numpy scipy + - pip install coverage - pip install matplotlib - CFLAGS=-I/usr/include/hdf5/serial pip install git+https://github.com/h5py/h5py - CFLAGS=-I/usr/include/hdf5/serial pip install git+https://github.com/kiyo-masui/bitshuffle From acd7003fa76ac18772b8ed90a34598e2ee78e01c Mon Sep 17 00:00:00 2001 From: Danny Price Date: Wed, 6 Jun 2018 21:11:56 +1000 Subject: [PATCH 60/66] First attempt to add code coverage --- .travis.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.travis.yml b/.travis.yml index 1a1fef1f..94a93f97 100644 --- a/.travis.yml +++ b/.travis.yml @@ -10,6 +10,7 @@ install: - pip install --upgrade pip setuptools wheel - pip install --only-binary=numpy,scipy numpy scipy - pip install coverage + - pin install coveralls - pip install matplotlib - CFLAGS=-I/usr/include/hdf5/serial pip install git+https://github.com/h5py/h5py - CFLAGS=-I/usr/include/hdf5/serial pip install git+https://github.com/kiyo-masui/bitshuffle From 4a1caec245ba86055b09f4fd34164edeb36c2396 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Wed, 6 Jun 2018 21:19:04 +1000 Subject: [PATCH 61/66] Typo fix pin -> pip --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 94a93f97..30398e37 100644 --- a/.travis.yml +++ b/.travis.yml @@ -10,7 +10,7 @@ install: - pip install --upgrade pip setuptools wheel - pip install --only-binary=numpy,scipy numpy scipy - pip install coverage - - pin install coveralls + - pip install coveralls - pip install matplotlib - CFLAGS=-I/usr/include/hdf5/serial pip install git+https://github.com/h5py/h5py - CFLAGS=-I/usr/include/hdf5/serial pip install git+https://github.com/kiyo-masui/bitshuffle From fcec275b92e4fb3c8222a08eb4968a8ad9283108 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Wed, 6 Jun 2018 21:29:00 +1000 Subject: [PATCH 62/66] Adding coveralls.io badge --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index ed4942ed..8d74ba24 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,5 @@ [![Build Status](https://travis-ci.org/UCBerkeleySETI/blimpy.svg?branch=master)](https://travis-ci.org/UCBerkeleySETI/blimpy) +[![Coverage Status](https://coveralls.io/repos/github/telegraphic/blimpy/badge.svg?branch=master)](https://coveralls.io/github/telegraphic/blimpy?branch=master) ## Breakthrough Listen I/O Methods for Python. From ee284c8fce7c2d07c8262916f44771b474d54c4e Mon Sep 17 00:00:00 2001 From: Danny Price Date: Fri, 8 Jun 2018 21:42:21 +1000 Subject: [PATCH 63/66] calc_n_coarse_channels not working at Parkes, changing logic to fix --- blimpy/file_wrapper.py | 30 +++++++++++++++++------------- 1 file changed, 17 insertions(+), 13 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index 421c44d8..11581ba0 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -237,23 +237,27 @@ def calc_n_coarse_chan(self): Note: This is unlikely to work on non-Breakthrough Listen data, as a-priori knowledge of the digitizer system is required. - For Parkes, it assumes 2^20 point FFTs. - For GBT, it assumes channel bandwidth 2.9296875 MHz + """ nchans = int(self.header[b'nchans']) - if self.header[b'telescope_id'] == 6: - coarse_chan_bw = 2.9296875 - bandwidth = abs(self.f_stop - self.f_start) - n_coarse_chan = int(bandwidth / coarse_chan_bw) - return n_coarse_chan - - elif self.header[b'telescope_id'] == 4: - # For 3 Hz channels we are using 2^20 length FFTs - if nchans >= 2**20: - return int(nchans / 2**20) + # Do we have a file with enough channels that it has coarse channelization? + if nchans >= 2**20: + # Does the common FFT length of 2^20 divide through without a remainder? + # This should work for most GBT and all Parkes hires data + if nchans % 2**20 == 0: + n_coarse_chan = nchans // 2**20 + return n_coarse_chan + # Early GBT data has non-2^N FFT length, check if it is GBT data + elif self.header[b'telescope_id'] == 6: + coarse_chan_bw = 2.9296875 + bandwidth = abs(self.f_stop - self.f_start) + n_coarse_chan = int(bandwidth / coarse_chan_bw) + return n_coarse_chan + else: + raise RuntimeError("Couldn't figure out n_coarse_chan") else: - raise RuntimeError("This function currently only works for BL Parkes or GBT data.") + raise RuntimeError("This function currently only works for hires BL Parkes or GBT data.") def calc_n_blobs(self, blob_dim): """ Given the blob dimensions, calculate how many fit in the data selection. From 16591fc9aca60c392ceaec2c53abc44f0c0ea831 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Fri, 8 Jun 2018 21:43:17 +1000 Subject: [PATCH 64/66] Removing calc_n_coarse_chan from filterbank No need for this in filterbank -- use waterfall if you need this functionality. --- blimpy/filterbank.py | 17 ----------------- 1 file changed, 17 deletions(-) diff --git a/blimpy/filterbank.py b/blimpy/filterbank.py index 4eb53414..070805d2 100755 --- a/blimpy/filterbank.py +++ b/blimpy/filterbank.py @@ -500,23 +500,6 @@ def grab_data(self, f_start=None, f_stop=None, t_start=None, t_stop=None, if_id= return plot_f, plot_data - def calc_n_coarse_chan(self): - """ This makes an attempt to calculate the number of coarse channels in a given file. - It assumes for now that a single coarse channel is 2.9296875 MHz - """ - print("Warning: this is deprecated in Filterbank(). Please use equivalent in Waterfall()") - # Could add a telescope based coarse channel bandwidth, or other discriminative. - # if telescope_id == 'GBT': - # or actually as is currently - # if self.header[b'telescope_id'] == 6: - - coarse_chan_bw = 2.9296875 - - bandwidth = abs(self.header[b'nchans']*self.header[b'foff']) - n_coarse_chan = int(bandwidth / coarse_chan_bw) - - return n_coarse_chan - def _calc_extent(self,plot_f=None,plot_t=None,MJD_time=False): """ Setup ploting edges. """ From 07dfc19782fa155373528b22aedccced8419b925 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Sun, 10 Jun 2018 10:13:20 +1000 Subject: [PATCH 65/66] Removing unused arg from blob_start call --- blimpy/file_wrapper.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index 11581ba0..9378f765 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -646,7 +646,7 @@ def read_blob(self,blob_dim,n_blob=0): else: updated_blob_dim = blob_dim - blob_start = self._find_blob_start(blob_dim) + blob_start = self._find_blob_start() blob = np.zeros(updated_blob_dim,dtype=self._d_type) #EE: For now; also assuming one polarization and one beam. From a2d668ad9570f4001bd4c415d7c4af3b2e6fde23 Mon Sep 17 00:00:00 2001 From: Danny Price Date: Mon, 11 Jun 2018 11:50:15 +1000 Subject: [PATCH 66/66] None comparison edit in response to jeenriquez code review --- blimpy/file_wrapper.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/blimpy/file_wrapper.py b/blimpy/file_wrapper.py index 9378f765..40c42c14 100644 --- a/blimpy/file_wrapper.py +++ b/blimpy/file_wrapper.py @@ -79,28 +79,28 @@ def _setup_selection_range(self, f_start=None, f_stop=None, t_start=None, t_stop if t_start >= self.t_begin and t_start < self.t_end: self.t_start = int(t_start) else: - if not init or t_start != None: + if init is False or t_start != None: logger.warning('Setting t_start = %f, since t_start not given or not valid.'%self.t_begin) self.t_start = self.t_begin if t_stop <= self.t_end and t_stop > self.t_begin: self.t_stop = int(t_stop) else: - if not init or t_stop: + if init is False or t_stop: logger.warning('Setting t_stop = %f, since t_stop not given or not valid.'%self.t_end) self.t_stop = self.t_end if f_start >= self.f_begin and f_start < self.f_end: self.f_start = f_start else: - if not init or f_start: + if init is False or f_start: logger.warning('Setting f_start = %f, since f_start not given or not valid.'%self.f_begin) self.f_start = self.f_begin if f_stop <= self.f_end and f_stop > self.f_begin: self.f_stop = f_stop else: - if not init or f_stop: + if init is False or f_stop: logger.warning('Setting f_stop = %f, since f_stop not given or not valid.'%self.f_end) self.f_stop = self.f_end