def __init__(self, filename, center_freq=850e6, sample_rate=5e5, file_datatype = np.complex64):

self.filename = filename;

self.freq = center_freq;

self.samp_rate = sample_rate

self.cmplx_data = scipy.fromfile(open(filename), dtype = file_datatype)

self.n = len(self.cmplx_data)

self.samp_spacing = 1.0/self.samp_rate

#Return the complex data from the provided file

def raw_dataSegment(self, strt_cut = 0, end_cut = 0):

return self.cmplx_data[strt_cut:self.n-end_cut];

#Return the fft of a segment of the data

def fftSegment(self, strt_cut = 0, end_cut = 0):

cmplx_samples = self.cmplx_data[strt_cut:self.n-end_cut];

return np.fft.ftt(cmplx_samples)

#time series of the window sampling scans

def time_segments(self):

remains = self.n%self.samp_rate

num_segments = self.n/self.samp_rate

return self.cmplx_data[remains:].reshape(num_segments,self.samp_rate)

#FFTs of the time series of the window sampling scans

def time_segments_fft(self):

segments = self.time_segments()

return np.apply_along_axis(np.fft.fft, 1, segments)

#Complex number to dB

def complex_to_db(self,cmplx):

return 20*np.log(np.absolute(cmplx))

#Map Q,I to dB

def segments_to_db(self, fft=False):

segments = self.time_segments()

if fft:

segments = self.time_segments_fft()

return np.apply_along_axis(self.complex_to_db, 0,segments)

#Plots a segment of data using the specified file sample rate and center freq

#Inputs:

#segment-> 1d numpy array to be plotted

#fft -> if True: calculates the corresponding frequencies using the sample rate and center frequency

#otherwise uses the length of the segment to time index the data

#indices: if not None use them as the x-coordinates

#title: The title of the figugre to be plotted

#save_plot: if True saves the plot to save_to_as

#save_to_as: expected: path/filename. defualts to current directory

#output:

#plots the segment provided

#saves the plots to the specified file

def plot(self, segment, fft = False, indices = None, title = 'data segment', save_plot = False, save_to_as = 'segment'):

samp_spacing = 1.0/self.samp_rate

n = len(segment)

h_data = indices

if indices==None:

if fft:

h_data = np.add(np.fft.fftfreq(len(segment), d = samp_spacing), self.freq)

else:

h_data = np.arange(n)

fig, ax = plt.subplots(figsize = (12,8))

ax.plot(h_data, segment)

ax.set_title(title)

if save_to_as=='segment':

save_to_as = save_to_as+'_'+str(int(time.time()))+'.jpg'

if save_plot:

fig.savefig(save_to_as)

plt.show()

#Converts from segment to frequency,power pairs

def freq_to_power(self, segment):

freq = np.add(np.fft.fftfreq(len(segment), d = self.samp_spacing),self.freq)

pairs = np.vstack((segment.T,freq.T)).T

return pd.DataFrame(pairs, columns=['Power(dB)','Freq'])

#Map the windows of sample scans to dataframes

def freq_pow_pairs_map(self, fft = True):

segs = self.segments_to_db(fft=fft)

dfs = pd.concat([self.freq_to_power(seg) for seg in segs])

return dfs

#Write the paired frequency, power components to a csv file

def freq_pow_pair_to_csv(self,filename=None, fft=True):

if filename==None:

filename = self.filename.split('.')[0].strip()+"freq_pow_pairs"+'.csv'

df = self.freq_pow_pairs_map(fft = fft)

image_names = ['imaginaries', 'reals','magnitudes']):

#Plotting fft results of the samples

#reading indexes

freq_dist= np.arange(len(complex_samples))

#plotting the imaginary components

f_imag, ax_imag = plt.subplots(figsize = (14,7))

ax_imag.plot(freq_dist, cmplx_samples_fft.imag)

image_title = 'Imaginary parts'

image_name = 'imaginaries'

if fft:

image_title = 'fft imaginary parts'

image_name = 'fft_imaginaries'

ax_imag.set_title('fft imaginary parts')

#save images

f_imag.savefig('images/fft_imaginaries.png')

f_imag.savefig('images/fft_imaginaries.jpg')

#Plotting the real components

f_real, ax_real = plt.subplots(figsize = (14,7))

ax_real.plot(freq_dist,cmplx_samples_fft.real, label = "real parts")

ax_real.set_title('fft Real parts')

image_title = 'Real Parts'

image_name = 'reals'

if fft:

image_title = 'ftt Real Parts'

image_name = 'fft_reals'

#save plots

f_real.savefig('images/fft_reals.png')

f_real.savefig('images/fft_reals.jpg')

#Plotting magnitudes

f, ax = plt.subplots(figsize = (14,7))

ax.plot(freq_dist, np.absolute(cmplx_samples_fft))

ax.set_title('fft magnitudes')

image_title = 'magnitudes'

image_name = 'magnitudes'

if fft:

image_title = 'fft magnitudes'

image_name = 'fft_magnitudes'

#save images

f.savefig('images/fft_magnitudes.png')

f.savefig('images/fft_magnitudes.jpg')