diff --git a/schainpy/model/__init__.py b/schainpy/model/__init__.py
index 3d76a6d..ae3ce46 100644
--- a/schainpy/model/__init__.py
+++ b/schainpy/model/__init__.py
@@ -5,8 +5,8 @@
 # from schainpy.model.utils.jroutils import *
 # from schainpy.serializer import *
 
+from graphics import *
 from data import *
 from io import *
 from proc import *
-from graphics import *
-from utils import *
\ No newline at end of file
+from utils import *
diff --git a/schainpy/model/graphics/mpldriver.py b/schainpy/model/graphics/mpldriver.py
index b84fb1c..c1e31ac 100644
--- a/schainpy/model/graphics/mpldriver.py
+++ b/schainpy/model/graphics/mpldriver.py
@@ -4,32 +4,36 @@ import sys
 import matplotlib
 
 if 'linux' in sys.platform:
-    matplotlib.use("TKAgg")
+    matplotlib.use("TkAgg")
 
 if 'darwin' in sys.platform:
     matplotlib.use('TKAgg')
-#Qt4Agg', 'GTK', 'GTKAgg', 'ps', 'agg', 'cairo', 'MacOSX', 'GTKCairo', 'WXAgg', 'template', 'TkAgg', 'GTK3Cairo', 'GTK3Agg', 'svg', 'WebAgg', 'CocoaAgg', 'emf', 'gdk', 'WX'
+# Qt4Agg', 'GTK', 'GTKAgg', 'ps', 'agg', 'cairo', 'MacOSX', 'GTKCairo', 'WXAgg', 'template', 'TkAgg', 'GTK3Cairo', 'GTK3Agg', 'svg', 'WebAgg', 'CocoaAgg', 'emf', 'gdk', 'WX'
 import matplotlib.pyplot
 
 from mpl_toolkits.axes_grid1 import make_axes_locatable
 from matplotlib.ticker import FuncFormatter, LinearLocator
 
 ###########################################
-#Actualizacion de las funciones del driver
+# Actualizacion de las funciones del driver
 ###########################################
 
 # create jro colormap
 
 jet_values = matplotlib.pyplot.get_cmap("jet", 100)(numpy.arange(100))[10:90]
-blu_values = matplotlib.pyplot.get_cmap("seismic_r", 20)(numpy.arange(20))[10:15]
-ncmap = matplotlib.colors.LinearSegmentedColormap.from_list("jro", numpy.vstack((blu_values, jet_values)))
+blu_values = matplotlib.pyplot.get_cmap(
+    "seismic_r", 20)(numpy.arange(20))[10:15]
+ncmap = matplotlib.colors.LinearSegmentedColormap.from_list(
+    "jro", numpy.vstack((blu_values, jet_values)))
 matplotlib.pyplot.register_cmap(cmap=ncmap)
 
-def createFigure(id, wintitle, width, height, facecolor="w", show=True, dpi = 80):
+
+def createFigure(id, wintitle, width, height, facecolor="w", show=True, dpi=80):
 
     matplotlib.pyplot.ioff()
 
-    fig = matplotlib.pyplot.figure(num=id, facecolor=facecolor, figsize=(1.0*width/dpi, 1.0*height/dpi))
+    fig = matplotlib.pyplot.figure(num=id, facecolor=facecolor, figsize=(
+        1.0 * width / dpi, 1.0 * height / dpi))
     fig.canvas.manager.set_window_title(wintitle)
 #     fig.canvas.manager.resize(width, height)
     matplotlib.pyplot.ion()
@@ -39,10 +43,11 @@ def createFigure(id, wintitle, width, height, facecolor="w", show=True, dpi = 80
 
     return fig
 
+
 def closeFigure(show=False, fig=None):
 
-#     matplotlib.pyplot.ioff()
-#     matplotlib.pyplot.pause(0)
+    #     matplotlib.pyplot.ioff()
+    #     matplotlib.pyplot.pause(0)
 
     if show:
         matplotlib.pyplot.show()
@@ -60,45 +65,52 @@ def closeFigure(show=False, fig=None):
 
     return
 
+
 def saveFigure(fig, filename):
 
-#     matplotlib.pyplot.ioff()
+    #     matplotlib.pyplot.ioff()
     fig.savefig(filename, dpi=matplotlib.pyplot.gcf().dpi)
 #     matplotlib.pyplot.ion()
 
+
 def clearFigure(fig):
 
     fig.clf()
 
+
 def setWinTitle(fig, title):
 
     fig.canvas.manager.set_window_title(title)
 
+
 def setTitle(fig, title):
 
     fig.suptitle(title)
 
+
 def createAxes(fig, nrow, ncol, xpos, ypos, colspan, rowspan, polar=False):
 
     matplotlib.pyplot.ioff()
     matplotlib.pyplot.figure(fig.number)
     axes = matplotlib.pyplot.subplot2grid((nrow, ncol),
-                                        (xpos, ypos),
-                                        colspan=colspan,
-                                        rowspan=rowspan,
-                                        polar=polar)
+                                          (xpos, ypos),
+                                          colspan=colspan,
+                                          rowspan=rowspan,
+                                          polar=polar)
 
     matplotlib.pyplot.ion()
     return axes
 
+
 def setAxesText(ax, text):
 
     ax.annotate(text,
-                xy = (.1, .99),
-                xycoords = 'figure fraction',
-                horizontalalignment = 'left',
-                verticalalignment = 'top',
-                fontsize = 10)
+                xy=(.1, .99),
+                xycoords='figure fraction',
+                horizontalalignment='left',
+                verticalalignment='top',
+                fontsize=10)
+
 
 def printLabels(ax, xlabel, ylabel, title):
 
@@ -106,11 +118,11 @@ def printLabels(ax, xlabel, ylabel, title):
     ax.set_ylabel(ylabel, size=11)
     ax.set_title(title, size=8)
 
+
 def createPline(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='',
                 ticksize=9, xtick_visible=True, ytick_visible=True,
                 nxticks=4, nyticks=10,
-                grid=None,color='blue'):
-
+                grid=None, color='blue'):
     """
 
     Input:
@@ -119,18 +131,19 @@ def createPline(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title=''
 
     matplotlib.pyplot.ioff()
 
-    ax.set_xlim([xmin,xmax])
-    ax.set_ylim([ymin,ymax])
+    ax.set_xlim([xmin, xmax])
+    ax.set_ylim([ymin, ymax])
 
     printLabels(ax, xlabel, ylabel, title)
 
     ######################################################
-    if (xmax-xmin)<=1:
-        xtickspos = numpy.linspace(xmin,xmax,nxticks)
-        xtickspos = numpy.array([float("%.1f"%i) for i in xtickspos])
+    if (xmax - xmin) <= 1:
+        xtickspos = numpy.linspace(xmin, xmax, nxticks)
+        xtickspos = numpy.array([float("%.1f" % i) for i in xtickspos])
         ax.set_xticks(xtickspos)
     else:
-        xtickspos = numpy.arange(nxticks)*int((xmax-xmin)/(nxticks)) + int(xmin)
+        xtickspos = numpy.arange(nxticks) * \
+            int((xmax - xmin) / (nxticks)) + int(xmin)
 #         xtickspos = numpy.arange(nxticks)*float(xmax-xmin)/float(nxticks) + int(xmin)
         ax.set_xticks(xtickspos)
 
@@ -168,9 +181,11 @@ def createPline(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title=''
 
     return iplot
 
+
 def set_linedata(ax, x, y, idline):
 
-    ax.lines[idline].set_data(x,y)
+    ax.lines[idline].set_data(x, y)
+
 
 def pline(iplot, x, y, xlabel='', ylabel='', title=''):
 
@@ -180,14 +195,15 @@ def pline(iplot, x, y, xlabel='', ylabel='', title=''):
 
     set_linedata(ax, x, y, idline=0)
 
+
 def addpline(ax, x, y, color, linestyle, lw):
 
-    ax.plot(x,y,color=color,linestyle=linestyle,lw=lw)
+    ax.plot(x, y, color=color, linestyle=linestyle, lw=lw)
 
 
 def createPcolor(ax, x, y, z, xmin, xmax, ymin, ymax, zmin, zmax,
-                 xlabel='', ylabel='', title='', ticksize = 9,
-                 colormap='jet',cblabel='', cbsize="5%",
+                 xlabel='', ylabel='', title='', ticksize=9,
+                 colormap='jet', cblabel='', cbsize="5%",
                  XAxisAsTime=False):
 
     matplotlib.pyplot.ioff()
@@ -197,16 +213,16 @@ def createPcolor(ax, x, y, z, xmin, xmax, ymin, ymax, zmin, zmax,
     fig = ax.get_figure()
     fig.add_axes(ax_cb)
 
-    ax.set_xlim([xmin,xmax])
-    ax.set_ylim([ymin,ymax])
+    ax.set_xlim([xmin, xmax])
+    ax.set_ylim([ymin, ymax])
 
     printLabels(ax, xlabel, ylabel, title)
 
     z = numpy.ma.masked_invalid(z)
-    cmap=matplotlib.pyplot.get_cmap(colormap)
+    cmap = matplotlib.pyplot.get_cmap(colormap)
     cmap.set_bad('black', 1.)
-    imesh = ax.pcolormesh(x,y,z.T, vmin=zmin, vmax=zmax, cmap=cmap)
-    cb =  matplotlib.pyplot.colorbar(imesh, cax=ax_cb)
+    imesh = ax.pcolormesh(x, y, z.T, vmin=zmin, vmax=zmax, cmap=cmap)
+    cb = matplotlib.pyplot.colorbar(imesh, cax=ax_cb)
     cb.set_label(cblabel)
 
 #    for tl in ax_cb.get_yticklabels():
@@ -235,13 +251,15 @@ def createPcolor(ax, x, y, z, xmin, xmax, ymin, ymax, zmin, zmax,
 
     if XAxisAsTime:
 
-        func = lambda x, pos: ('%s') %(datetime.datetime.utcfromtimestamp(x).strftime("%H:%M:%S"))
+        def func(x, pos): return ('%s') % (
+            datetime.datetime.utcfromtimestamp(x).strftime("%H:%M:%S"))
         ax.xaxis.set_major_formatter(FuncFormatter(func))
         ax.xaxis.set_major_locator(LinearLocator(7))
 
     matplotlib.pyplot.ion()
     return imesh
 
+
 def pcolor(imesh, z, xlabel='', ylabel='', title=''):
 
     z = z.T
@@ -249,11 +267,14 @@ def pcolor(imesh, z, xlabel='', ylabel='', title=''):
     printLabels(ax, xlabel, ylabel, title)
     imesh.set_array(z.ravel())
 
+
 def addpcolor(ax, x, y, z, zmin, zmax, xlabel='', ylabel='', title='', colormap='jet'):
 
     printLabels(ax, xlabel, ylabel, title)
 
-    ax.pcolormesh(x,y,z.T,vmin=zmin,vmax=zmax, cmap=matplotlib.pyplot.get_cmap(colormap))
+    ax.pcolormesh(x, y, z.T, vmin=zmin, vmax=zmax,
+                  cmap=matplotlib.pyplot.get_cmap(colormap))
+
 
 def addpcolorbuffer(ax, x, y, z, zmin, zmax, xlabel='', ylabel='', title='', colormap='jet'):
 
@@ -263,17 +284,16 @@ def addpcolorbuffer(ax, x, y, z, zmin, zmax, xlabel='', ylabel='', title='', col
 
     z = numpy.ma.masked_invalid(z)
 
-    cmap=matplotlib.pyplot.get_cmap(colormap)
+    cmap = matplotlib.pyplot.get_cmap(colormap)
     cmap.set_bad('black', 1.)
 
+    ax.pcolormesh(x, y, z.T, vmin=zmin, vmax=zmax, cmap=cmap)
 
-    ax.pcolormesh(x,y,z.T,vmin=zmin,vmax=zmax, cmap=cmap)
 
 def createPmultiline(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='', legendlabels=None,
-                ticksize=9, xtick_visible=True, ytick_visible=True,
-                nxticks=4, nyticks=10,
-                grid=None):
-
+                     ticksize=9, xtick_visible=True, ytick_visible=True,
+                     nxticks=4, nyticks=10,
+                     grid=None):
     """
 
     Input:
@@ -285,11 +305,12 @@ def createPmultiline(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', tit
     lines = ax.plot(x.T, y)
     leg = ax.legend(lines, legendlabels, loc='upper right')
     leg.get_frame().set_alpha(0.5)
-    ax.set_xlim([xmin,xmax])
-    ax.set_ylim([ymin,ymax])
+    ax.set_xlim([xmin, xmax])
+    ax.set_ylim([ymin, ymax])
     printLabels(ax, xlabel, ylabel, title)
 
-    xtickspos = numpy.arange(nxticks)*int((xmax-xmin)/(nxticks)) + int(xmin)
+    xtickspos = numpy.arange(nxticks) * \
+        int((xmax - xmin) / (nxticks)) + int(xmin)
     ax.set_xticks(xtickspos)
 
     for tick in ax.get_xticklabels():
@@ -332,13 +353,13 @@ def pmultiline(iplot, x, y, xlabel='', ylabel='', title=''):
 
     for i in range(len(ax.lines)):
         line = ax.lines[i]
-        line.set_data(x[i,:],y)
+        line.set_data(x[i, :], y)
 
-def createPmultilineYAxis(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='', legendlabels=None,
-                ticksize=9, xtick_visible=True, ytick_visible=True,
-                nxticks=4, nyticks=10, marker='.', markersize=10, linestyle="None",
-                grid=None, XAxisAsTime=False):
 
+def createPmultilineYAxis(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel='', title='', legendlabels=None,
+                          ticksize=9, xtick_visible=True, ytick_visible=True,
+                          nxticks=4, nyticks=10, marker='.', markersize=10, linestyle="None",
+                          grid=None, XAxisAsTime=False):
     """
 
     Input:
@@ -355,10 +376,11 @@ def createPmultilineYAxis(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel=''
     leg = ax.legend(lines, legendlabels,
                     loc='upper right', bbox_to_anchor=(1.16, 1), borderaxespad=0)
 
-    for label in leg.get_texts(): label.set_fontsize(9)
+    for label in leg.get_texts():
+        label.set_fontsize(9)
 
-    ax.set_xlim([xmin,xmax])
-    ax.set_ylim([ymin,ymax])
+    ax.set_xlim([xmin, xmax])
+    ax.set_ylim([ymin, ymax])
     printLabels(ax, xlabel, ylabel, title)
 
 #    xtickspos = numpy.arange(nxticks)*int((xmax-xmin)/(nxticks)) + int(xmin)
@@ -393,7 +415,8 @@ def createPmultilineYAxis(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel=''
 
     if XAxisAsTime:
 
-        func = lambda x, pos: ('%s') %(datetime.datetime.utcfromtimestamp(x).strftime("%H:%M:%S"))
+        def func(x, pos): return ('%s') % (
+            datetime.datetime.utcfromtimestamp(x).strftime("%H:%M:%S"))
         ax.xaxis.set_major_formatter(FuncFormatter(func))
         ax.xaxis.set_major_locator(LinearLocator(7))
 
@@ -401,6 +424,7 @@ def createPmultilineYAxis(ax, x, y, xmin, xmax, ymin, ymax, xlabel='', ylabel=''
 
     return iplot
 
+
 def pmultilineyaxis(iplot, x, y, xlabel='', ylabel='', title=''):
 
     ax = iplot.axes
@@ -409,19 +433,20 @@ def pmultilineyaxis(iplot, x, y, xlabel='', ylabel='', title=''):
 
     for i in range(len(ax.lines)):
         line = ax.lines[i]
-        line.set_data(x,y[i,:])
+        line.set_data(x, y[i, :])
+
 
 def createPolar(ax, x, y,
-                xlabel='', ylabel='', title='', ticksize = 9,
-                 colormap='jet',cblabel='', cbsize="5%",
-                 XAxisAsTime=False):
+                xlabel='', ylabel='', title='', ticksize=9,
+                colormap='jet', cblabel='', cbsize="5%",
+                XAxisAsTime=False):
 
     matplotlib.pyplot.ioff()
 
-    ax.plot(x,y,'bo', markersize=5)
+    ax.plot(x, y, 'bo', markersize=5)
 #     ax.set_rmax(90)
-    ax.set_ylim(0,90)
-    ax.set_yticks(numpy.arange(0,90,20))
+    ax.set_ylim(0, 90)
+    ax.set_yticks(numpy.arange(0, 90, 20))
 #     ax.text(0, -110, ylabel, rotation='vertical', va ='center', ha = 'center' ,size='11')
 #     ax.text(0, 50, ylabel, rotation='vertical', va ='center', ha = 'left' ,size='11')
 #     ax.text(100, 100, 'example', ha='left', va='center', rotation='vertical')
@@ -444,9 +469,9 @@ def createPolar(ax, x, y,
 
     matplotlib.pyplot.ion()
 
-
     return iplot
 
+
 def polar(iplot, x, y, xlabel='', ylabel='', title=''):
 
     ax = iplot.axes
@@ -456,6 +481,7 @@ def polar(iplot, x, y, xlabel='', ylabel='', title=''):
 
     set_linedata(ax, x, y, idline=0)
 
+
 def draw(fig):
 
     if type(fig) == 'int':
@@ -463,6 +489,7 @@ def draw(fig):
 
     fig.canvas.draw()
 
+
 def pause(interval=0.000001):
 
     matplotlib.pyplot.pause(interval)
diff --git a/schainpy/model/io/MIRAtest.py b/schainpy/model/io/MIRAtest.py
index c48bc8b..ea8e94f 100644
--- a/schainpy/model/io/MIRAtest.py
+++ b/schainpy/model/io/MIRAtest.py
@@ -1,4 +1,5 @@
-import os, sys
+import os
+import sys
 import glob
 import fnmatch
 import datetime
@@ -6,11 +7,9 @@ import time
 import re
 import h5py
 import numpy
-import matplotlib.pyplot as plt
 
-import pylab as plb
 from scipy.optimize import curve_fit
-from scipy import asarray as ar,exp
+from scipy import asarray as ar, exp
 from scipy import stats
 
 from duplicity.path import Path
@@ -31,113 +30,130 @@ from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
 from numpy import imag, shape, NaN
 
 
-startFp = open('/home/erick/Documents/MIRA35C/20160117/20160117_0000.zspc',"rb") 
-
-
-FILE_HEADER = numpy.dtype([          #HEADER 1024bytes
-                          ('Hname',numpy.str_,32),      #Original file name
-                          ('Htime',numpy.str_,32),      #Date and time when the file was created
-                          ('Hoper',numpy.str_,64),      #Name of operator who created the file
-                          ('Hplace',numpy.str_,128),    #Place where the measurements was carried out
-                          ('Hdescr',numpy.str_,256),    #Description of measurements
-                          ('Hdummy',numpy.str_,512),    #Reserved space 
-                          #Main chunk
-                          ('Msign','<i4'),          #Main chunk signature FZKF or NUIG
-                          ('MsizeData','<i4'),      #Size of data block main chunk
-                          #Processing DSP parameters
-                          ('PPARsign','<i4'),       #PPAR signature
-                          ('PPARsize','<i4'),       #PPAR size of block
-                          ('PPARprf','<i4'),        #Pulse repetition frequency
-                          ('PPARpdr','<i4'),        #Pulse duration
-                          ('PPARsft','<i4'),        #FFT length
-                          ('PPARavc','<i4'),        #Number of spectral (in-coherent) averages
-                          ('PPARihp','<i4'),        #Number of lowest range gate for moment estimation
-                          ('PPARchg','<i4'),        #Count for gates for moment estimation
-                          ('PPARpol','<i4'),        #switch on/off polarimetric measurements. Should be 1.
-                          #Service DSP parameters
-                          ('SPARatt','<i4'),       #STC attenuation on the lowest ranges on/off
-                          ('SPARtx','<i4'),        #OBSOLETE
-                          ('SPARaddGain0','<f4'),  #OBSOLETE
-                          ('SPARaddGain1','<f4'),  #OBSOLETE
-                          ('SPARwnd','<i4'),     #Debug only. It normal mode it is 0.
-                          ('SPARpos','<i4'),     #Delay between sync pulse and tx pulse for phase corr, ns
-                          ('SPARadd','<i4'),     #"add to pulse" to compensate for delay between the leading edge of driver pulse and envelope of the RF signal.
-                          ('SPARlen','<i4'),     #Time for measuring txn pulse phase. OBSOLETE
-                          ('SPARcal','<i4'),     #OBSOLETE
-                          ('SPARnos','<i4'),     #OBSOLETE
-                          ('SPARof0','<i4'),     #detection threshold
-                          ('SPARof1','<i4'),     #OBSOLETE
-                          ('SPARswt','<i4'),     #2nd moment estimation threshold
-                          ('SPARsum','<i4'),     #OBSOLETE
-                          ('SPARosc','<i4'),     #flag Oscillosgram mode
-                          ('SPARtst','<i4'),     #OBSOLETE
-                          ('SPARcor','<i4'),     #OBSOLETE
-                          ('SPARofs','<i4'),     #OBSOLETE
-                          ('SPARhsn','<i4'),     #Hildebrand div noise detection on noise gate
-                          ('SPARhsa','<f4'),     #Hildebrand div noise detection on all gates
-                          ('SPARcalibPow_M','<f4'),   #OBSOLETE
-                          ('SPARcalibSNR_M','<f4'),   #OBSOLETE
-                          ('SPARcalibPow_S','<f4'),   #OBSOLETE
-                          ('SPARcalibSNR_S','<f4'),   #OBSOLETE
-                          ('SPARrawGate1','<i4'),     #Lowest range gate for spectra saving Raw_Gate1 >=5
-                          ('SPARrawGate2','<i4'),     #Number of range gates with atmospheric signal
-                          ('SPARraw','<i4'),          #flag - IQ or spectra saving on/off
-                          ('SPARprc','<i4'),])        #flag - Moment estimation switched on/off
-                        
-                        
-
-self.Hname= None     
-self.Htime= None
-self.Hoper= None
-self.Hplace= None
-self.Hdescr= None
-self.Hdummy= None
-
-self.Msign=None
-self.MsizeData=None
-                  
-self.PPARsign=None
-self.PPARsize=None
-self.PPARprf=None
-self.PPARpdr=None
-self.PPARsft=None
-self.PPARavc=None
-self.PPARihp=None
-self.PPARchg=None
-self.PPARpol=None
-#Service DSP parameters
-self.SPARatt=None
-self.SPARtx=None
-self.SPARaddGain0=None
-self.SPARaddGain1=None
-self.SPARwnd=None
-self.SPARpos=None
-self.SPARadd=None
-self.SPARlen=None
-self.SPARcal=None
-self.SPARnos=None
-self.SPARof0=None
-self.SPARof1=None
-self.SPARswt=None
-self.SPARsum=None
-self.SPARosc=None
-self.SPARtst=None
-self.SPARcor=None
-self.SPARofs=None
-self.SPARhsn=None
-self.SPARhsa=None
-self.SPARcalibPow_M=None
-self.SPARcalibSNR_M=None
-self.SPARcalibPow_S=None
-self.SPARcalibSNR_S=None
-self.SPARrawGate1=None
-self.SPARrawGate2=None
-self.SPARraw=None
-self.SPARprc=None 
-        
-    
-        
-header = numpy.fromfile(fp, FILE_HEADER,1)
+startFp = open(
+    '/home/erick/Documents/MIRA35C/20160117/20160117_0000.zspc', "rb")
+
+
+FILE_HEADER = numpy.dtype([  # HEADER 1024bytes
+                          ('Hname', numpy.str_, 32),  # Original file name
+                          # Date and time when the file was created
+                          ('Htime', numpy.str_, 32),
+                          # Name of operator who created the file
+                          ('Hoper', numpy.str_, 64),
+                          # Place where the measurements was carried out
+                          ('Hplace', numpy.str_, 128),
+                          # Description of measurements
+                          ('Hdescr', numpy.str_, 256),
+                          ('Hdummy', numpy.str_, 512),  # Reserved space
+                          # Main chunk
+                          ('Msign', '<i4'),  # Main chunk signature FZKF or NUIG
+                          ('MsizeData', '<i4'),  # Size of data block main chunk
+                          # Processing DSP parameters
+                          ('PPARsign', '<i4'),  # PPAR signature
+                          ('PPARsize', '<i4'),  # PPAR size of block
+                          ('PPARprf', '<i4'),  # Pulse repetition frequency
+                          ('PPARpdr', '<i4'),  # Pulse duration
+                          ('PPARsft', '<i4'),  # FFT length
+                          # Number of spectral (in-coherent) averages
+                          ('PPARavc', '<i4'),
+                          # Number of lowest range gate for moment estimation
+                          ('PPARihp', '<i4'),
+                          # Count for gates for moment estimation
+                          ('PPARchg', '<i4'),
+                          # switch on/off polarimetric measurements. Should be 1.
+                          ('PPARpol', '<i4'),
+                          # Service DSP parameters
+                          # STC attenuation on the lowest ranges on/off
+                          ('SPARatt', '<i4'),
+                          ('SPARtx', '<i4'),  # OBSOLETE
+                          ('SPARaddGain0', '<f4'),  # OBSOLETE
+                          ('SPARaddGain1', '<f4'),  # OBSOLETE
+                          # Debug only. It normal mode it is 0.
+                          ('SPARwnd', '<i4'),
+                          # Delay between sync pulse and tx pulse for phase corr, ns
+                          ('SPARpos', '<i4'),
+                          # "add to pulse" to compensate for delay between the leading edge of driver pulse and envelope of the RF signal.
+                          ('SPARadd', '<i4'),
+                          # Time for measuring txn pulse phase. OBSOLETE
+                          ('SPARlen', '<i4'),
+                          ('SPARcal', '<i4'),  # OBSOLETE
+                          ('SPARnos', '<i4'),  # OBSOLETE
+                          ('SPARof0', '<i4'),  # detection threshold
+                          ('SPARof1', '<i4'),  # OBSOLETE
+                          ('SPARswt', '<i4'),  # 2nd moment estimation threshold
+                          ('SPARsum', '<i4'),  # OBSOLETE
+                          ('SPARosc', '<i4'),  # flag Oscillosgram mode
+                          ('SPARtst', '<i4'),  # OBSOLETE
+                          ('SPARcor', '<i4'),  # OBSOLETE
+                          ('SPARofs', '<i4'),  # OBSOLETE
+                          # Hildebrand div noise detection on noise gate
+                          ('SPARhsn', '<i4'),
+                          # Hildebrand div noise detection on all gates
+                          ('SPARhsa', '<f4'),
+                          ('SPARcalibPow_M', '<f4'),  # OBSOLETE
+                          ('SPARcalibSNR_M', '<f4'),  # OBSOLETE
+                          ('SPARcalibPow_S', '<f4'),  # OBSOLETE
+                          ('SPARcalibSNR_S', '<f4'),  # OBSOLETE
+                          # Lowest range gate for spectra saving Raw_Gate1 >=5
+                          ('SPARrawGate1', '<i4'),
+                          # Number of range gates with atmospheric signal
+                          ('SPARrawGate2', '<i4'),
+                          # flag - IQ or spectra saving on/off
+                          ('SPARraw', '<i4'),
+                          ('SPARprc', '<i4'), ])  # flag - Moment estimation switched on/off
+
+
+self.Hname = None
+self.Htime = None
+self.Hoper = None
+self.Hplace = None
+self.Hdescr = None
+self.Hdummy = None
+
+self.Msign = None
+self.MsizeData = None
+
+self.PPARsign = None
+self.PPARsize = None
+self.PPARprf = None
+self.PPARpdr = None
+self.PPARsft = None
+self.PPARavc = None
+self.PPARihp = None
+self.PPARchg = None
+self.PPARpol = None
+# Service DSP parameters
+self.SPARatt = None
+self.SPARtx = None
+self.SPARaddGain0 = None
+self.SPARaddGain1 = None
+self.SPARwnd = None
+self.SPARpos = None
+self.SPARadd = None
+self.SPARlen = None
+self.SPARcal = None
+self.SPARnos = None
+self.SPARof0 = None
+self.SPARof1 = None
+self.SPARswt = None
+self.SPARsum = None
+self.SPARosc = None
+self.SPARtst = None
+self.SPARcor = None
+self.SPARofs = None
+self.SPARhsn = None
+self.SPARhsa = None
+self.SPARcalibPow_M = None
+self.SPARcalibSNR_M = None
+self.SPARcalibPow_S = None
+self.SPARcalibSNR_S = None
+self.SPARrawGate1 = None
+self.SPARrawGate2 = None
+self.SPARraw = None
+self.SPARprc = None
+
+
+header = numpy.fromfile(fp, FILE_HEADER, 1)
 '''      numpy.fromfile(file, dtype, count, sep='')
     file : file or str
     Open file object or filename.
@@ -157,95 +173,93 @@ header = numpy.fromfile(fp, FILE_HEADER,1)
     
 '''
 
-Hname= str(header['Hname'][0])     
-Htime= str(header['Htime'][0])
-Hoper= str(header['Hoper'][0])
-Hplace= str(header['Hplace'][0])
-Hdescr= str(header['Hdescr'][0])
-Hdummy= str(header['Hdummy'][0])
-
-Msign=header['Msign'][0]   
-MsizeData=header['MsizeData'][0]
-
-PPARsign=header['PPARsign'][0]
-PPARsize=header['PPARsize'][0]
-PPARprf=header['PPARprf'][0]
-PPARpdr=header['PPARpdr'][0]
-PPARsft=header['PPARsft'][0]
-PPARavc=header['PPARavc'][0]
-PPARihp=header['PPARihp'][0]
-PPARchg=header['PPARchg'][0]
-PPARpol=header['PPARpol'][0]
-#Service DSP parameters
-SPARatt=header['SPARatt'][0]
-SPARtx=header['SPARtx'][0]
-SPARaddGain0=header['SPARaddGain0'][0]
-SPARaddGain1=header['SPARaddGain1'][0]
-SPARwnd=header['SPARwnd'][0]
-SPARpos=header['SPARpos'][0]
-SPARadd=header['SPARadd'][0]
-SPARlen=header['SPARlen'][0]
-SPARcal=header['SPARcal'][0]
-SPARnos=header['SPARnos'][0]
-SPARof0=header['SPARof0'][0]
-SPARof1=header['SPARof1'][0]
-SPARswt=header['SPARswt'][0]
-SPARsum=header['SPARsum'][0]
-SPARosc=header['SPARosc'][0]
-SPARtst=header['SPARtst'][0]
-SPARcor=header['SPARcor'][0]
-SPARofs=header['SPARofs'][0]
-SPARhsn=header['SPARhsn'][0]
-SPARhsa=header['SPARhsa'][0]
-SPARcalibPow_M=header['SPARcalibPow_M'][0]
-SPARcalibSNR_M=header['SPARcalibSNR_M'][0]
-SPARcalibPow_S=header['SPARcalibPow_S'][0]
-SPARcalibSNR_S=header['SPARcalibSNR_S'][0]
-SPARrawGate1=header['SPARrawGate1'][0]
-SPARrawGate2=header['SPARrawGate2'][0]
-SPARraw=header['SPARraw'][0]
-SPARprc=header['SPARprc'][0]
-        
-        
-       
-SRVI_STRUCTURE = numpy.dtype([         
-                            ('frame_cnt','<u4'),#
-                            ('time_t','<u4'),   #
-                            ('tpow','<f4'),     #
-                            ('npw1','<f4'),     #
-                            ('npw2','<f4'),     #
-                            ('cpw1','<f4'),     #
-                            ('pcw2','<f4'),     #
-                            ('ps_err','<u4'),   #
-                            ('te_err','<u4'),   #
-                            ('rc_err','<u4'),   #
-                            ('grs1','<u4'),     #
-                            ('grs2','<u4'),     #
-                            ('azipos','<f4'),     #
-                            ('azivel','<f4'),     #
-                            ('elvpos','<f4'),     #
-                            ('elvvel','<f4'),     #
-                            ('northAngle','<f4'), #
-                            ('microsec','<u4'),   #
-                            ('azisetvel','<f4'),  #
-                            ('elvsetpos','<f4'),  #
-                            ('RadarConst','<f4'),])   # 
-
-JUMP_STRUCTURE = numpy.dtype([         
-                            ('jump','<u140'),#
-                            ('SizeOfDataBlock1',numpy.str_,32),#
-                            ('jump','<i4'),#
-                            ('DataBlockTitleSRVI1',numpy.str_,32),#
-                            ('SizeOfSRVI1','<i4'),])#
-
-
-
-#frame_cnt=0,  time_t= 0,  tpow=0,   npw1=0,   npw2=0,   
-#cpw1=0,   pcw2=0,       ps_err=0,   te_err=0,   rc_err=0,   grs1=0,   
-#grs2=0,   azipos=0,   azivel=0,   elvpos=0,   elvvel=0,   northangle=0,   
- #microsec=0,   azisetvel=0,   elvsetpos=0,   RadarConst=0 
-        
-        
+Hname = str(header['Hname'][0])
+Htime = str(header['Htime'][0])
+Hoper = str(header['Hoper'][0])
+Hplace = str(header['Hplace'][0])
+Hdescr = str(header['Hdescr'][0])
+Hdummy = str(header['Hdummy'][0])
+
+Msign = header['Msign'][0]
+MsizeData = header['MsizeData'][0]
+
+PPARsign = header['PPARsign'][0]
+PPARsize = header['PPARsize'][0]
+PPARprf = header['PPARprf'][0]
+PPARpdr = header['PPARpdr'][0]
+PPARsft = header['PPARsft'][0]
+PPARavc = header['PPARavc'][0]
+PPARihp = header['PPARihp'][0]
+PPARchg = header['PPARchg'][0]
+PPARpol = header['PPARpol'][0]
+# Service DSP parameters
+SPARatt = header['SPARatt'][0]
+SPARtx = header['SPARtx'][0]
+SPARaddGain0 = header['SPARaddGain0'][0]
+SPARaddGain1 = header['SPARaddGain1'][0]
+SPARwnd = header['SPARwnd'][0]
+SPARpos = header['SPARpos'][0]
+SPARadd = header['SPARadd'][0]
+SPARlen = header['SPARlen'][0]
+SPARcal = header['SPARcal'][0]
+SPARnos = header['SPARnos'][0]
+SPARof0 = header['SPARof0'][0]
+SPARof1 = header['SPARof1'][0]
+SPARswt = header['SPARswt'][0]
+SPARsum = header['SPARsum'][0]
+SPARosc = header['SPARosc'][0]
+SPARtst = header['SPARtst'][0]
+SPARcor = header['SPARcor'][0]
+SPARofs = header['SPARofs'][0]
+SPARhsn = header['SPARhsn'][0]
+SPARhsa = header['SPARhsa'][0]
+SPARcalibPow_M = header['SPARcalibPow_M'][0]
+SPARcalibSNR_M = header['SPARcalibSNR_M'][0]
+SPARcalibPow_S = header['SPARcalibPow_S'][0]
+SPARcalibSNR_S = header['SPARcalibSNR_S'][0]
+SPARrawGate1 = header['SPARrawGate1'][0]
+SPARrawGate2 = header['SPARrawGate2'][0]
+SPARraw = header['SPARraw'][0]
+SPARprc = header['SPARprc'][0]
+
+
+SRVI_STRUCTURE = numpy.dtype([
+                            ('frame_cnt', '<u4'),
+                            ('time_t', '<u4'),   #
+                            ('tpow', '<f4'),     #
+                            ('npw1', '<f4'),     #
+                            ('npw2', '<f4'),     #
+                            ('cpw1', '<f4'),     #
+                            ('pcw2', '<f4'),     #
+                            ('ps_err', '<u4'),   #
+                            ('te_err', '<u4'),   #
+                            ('rc_err', '<u4'),   #
+                            ('grs1', '<u4'),     #
+                            ('grs2', '<u4'),     #
+                            ('azipos', '<f4'),     #
+                            ('azivel', '<f4'),     #
+                            ('elvpos', '<f4'),     #
+                            ('elvvel', '<f4'),     #
+                            ('northAngle', '<f4'),
+                            ('microsec', '<u4'),   #
+                            ('azisetvel', '<f4'),  #
+                            ('elvsetpos', '<f4'),  #
+                            ('RadarConst', '<f4'), ])   #
+
+JUMP_STRUCTURE = numpy.dtype([
+                            ('jump', '<u140'),
+                            ('SizeOfDataBlock1', numpy.str_, 32),
+                            ('jump', '<i4'),
+                            ('DataBlockTitleSRVI1', numpy.str_, 32),
+                            ('SizeOfSRVI1', '<i4'), ])
+
+
+# frame_cnt=0,  time_t= 0,  tpow=0,   npw1=0,   npw2=0,
+# cpw1=0,   pcw2=0,       ps_err=0,   te_err=0,   rc_err=0,   grs1=0,
+# grs2=0,   azipos=0,   azivel=0,   elvpos=0,   elvvel=0,   northangle=0,
+# microsec=0,   azisetvel=0,   elvsetpos=0,   RadarConst=0
+
+
 frame_cnt = frame_cnt
 dwell = time_t
 tpow = tpow
@@ -267,23 +281,22 @@ microsec = microsec
 azisetvel = azisetvel
 elvsetpos = elvsetpos
 RadarConst5 = RadarConst
-        
 
 
-#print fp
-#startFp = open('/home/erick/Documents/Data/huancayo.20161019.22.fdt',"rb") #The method tell() returns the current position of the file read/write pointer within the file.
-#startFp = open(fp,"rb") #The method tell() returns the current position of the file read/write pointer within the file.
-#RecCounter=0
-#Off2StartNxtRec=811248
-#print 'OffsetStartHeader ',self.OffsetStartHeader,'RecCounter ', self.RecCounter, 'Off2StartNxtRec ' , self.Off2StartNxtRec
+# print fp
+# startFp = open('/home/erick/Documents/Data/huancayo.20161019.22.fdt',"rb") #The method tell() returns the current position of the file read/write pointer within the file.
+# startFp = open(fp,"rb") #The method tell() returns the current position of the file read/write pointer within the file.
+# RecCounter=0
+# Off2StartNxtRec=811248
+# print 'OffsetStartHeader ',self.OffsetStartHeader,'RecCounter ', self.RecCounter, 'Off2StartNxtRec ' , self.Off2StartNxtRec
 #OffRHeader= self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec
 #startFp.seek(OffRHeader, os.SEEK_SET)
-print 'debe ser 48, RecCounter*811248', self.OffsetStartHeader,self.RecCounter,self.Off2StartNxtRec
-print 'Posicion del bloque:        ',OffRHeader
+print 'debe ser 48, RecCounter*811248', self.OffsetStartHeader, self.RecCounter, self.Off2StartNxtRec
+print 'Posicion del bloque:        ', OffRHeader
 
-header = numpy.fromfile(startFp,SRVI_STRUCTURE,1)
+header = numpy.fromfile(startFp, SRVI_STRUCTURE, 1)
 
-self.frame_cnt = header['frame_cnt'][0]#
+self.frame_cnt = header['frame_cnt'][0]
 self.time_t = header['frame_cnt'][0]   #
 self.tpow = header['frame_cnt'][0]     #
 self.npw1 = header['frame_cnt'][0]     #
@@ -303,19 +316,16 @@ self.northAngle = header['frame_cnt'][0]    #
 self.microsec = header['frame_cnt'][0]      #
 self.azisetvel = header['frame_cnt'][0]     #
 self.elvsetpos = header['frame_cnt'][0]     #
-self.RadarConst = header['frame_cnt'][0]    # 
+self.RadarConst = header['frame_cnt'][0]    #
 
 
-self.ipp= 0.5*(SPEED_OF_LIGHT/self.PRFhz)
+self.ipp = 0.5 * (SPEED_OF_LIGHT / self.PRFhz)
 
-self.RHsize = 180+20*self.nChannels
-self.Datasize= self.nProfiles*self.nChannels*self.nHeights*2*4
-#print 'Datasize',self.Datasize
-endFp = self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec
+self.RHsize = 180 + 20 * self.nChannels
+self.Datasize = self.nProfiles * self.nChannels * self.nHeights * 2 * 4
+# print 'Datasize',self.Datasize
+endFp = self.OffsetStartHeader + self.RecCounter * self.Off2StartNxtRec
 
 print '=============================================='
 
 print '=============================================='
-        
-
-    
\ No newline at end of file
diff --git a/schainpy/model/io/jroIO_bltr.py b/schainpy/model/io/jroIO_bltr.py
index fe46699..4049dd2 100644
--- a/schainpy/model/io/jroIO_bltr.py
+++ b/schainpy/model/io/jroIO_bltr.py
@@ -1,4 +1,5 @@
-import os, sys
+import os
+import sys
 import glob
 import fnmatch
 import datetime
@@ -6,7 +7,6 @@ import time
 import re
 import h5py
 import numpy
-import matplotlib.pyplot as plt
 
 import pylab as plb
 from scipy.optimize import curve_fit
@@ -33,73 +33,71 @@ from jroIO_base import JRODataReader
 
 
 class Header(object):
-    
+
     def __init__(self):
         raise NotImplementedError
-    
-   
+
     def read(self):
-        
+
         raise NotImplementedError
-    
+
     def write(self):
-        
+
         raise NotImplementedError
-    
+
     def printInfo(self):
-        
-        message = "#"*50 + "\n"
+
+        message = "#" * 50 + "\n"
         message += self.__class__.__name__.upper() + "\n"
-        message += "#"*50 + "\n"
-        
+        message += "#" * 50 + "\n"
+
         keyList = self.__dict__.keys()
         keyList.sort()
-        
+
         for key in keyList:
-            message += "%s = %s" %(key, self.__dict__[key]) + "\n"
-        
+            message += "%s = %s" % (key, self.__dict__[key]) + "\n"
+
         if "size" not in keyList:
             attr = getattr(self, "size")
-            
-            if attr:
-                message += "%s = %s" %("size", attr) + "\n"
-        
-        #print message
 
+            if attr:
+                message += "%s = %s" % ("size", attr) + "\n"
 
+        # print message
 
 
+FILE_STRUCTURE = numpy.dtype([  # HEADER 48bytes
+    ('FileMgcNumber', '<u4'),  # 0x23020100
+    # No Of FDT data records in this file (0 or more)
+    ('nFDTdataRecors', '<u4'),
+    ('OffsetStartHeader', '<u4'),
+    ('RadarUnitId', '<u4'),
+    ('SiteName', numpy.str_, 32),  # Null terminated
+])
 
-FILE_STRUCTURE = numpy.dtype([          #HEADER 48bytes
-                          ('FileMgcNumber','<u4'),      #0x23020100
-                          ('nFDTdataRecors','<u4'),     #No Of FDT data records in this file (0 or more)
-                          ('OffsetStartHeader','<u4'),
-                          ('RadarUnitId','<u4'),
-                          ('SiteName',numpy.str_,32),          #Null terminated
-                          ])
 
 class FileHeaderBLTR(Header):
-    
+
     def __init__(self):
-        
-        self.FileMgcNumber= 0     #0x23020100
-        self.nFDTdataRecors=0     #No Of FDT data records in this file (0 or more)
-        self.RadarUnitId= 0
-        self.OffsetStartHeader=0
-        self.SiteName= ""
+
+        self.FileMgcNumber = 0  # 0x23020100
+        # No Of FDT data records in this file (0 or more)
+        self.nFDTdataRecors = 0
+        self.RadarUnitId = 0
+        self.OffsetStartHeader = 0
+        self.SiteName = ""
         self.size = 48
-        
+
     def FHread(self, fp):
-        #try:
-        startFp = open(fp,"rb")
-        
-        header = numpy.fromfile(startFp, FILE_STRUCTURE,1)
-        
+        # try:
+        startFp = open(fp, "rb")
+
+        header = numpy.fromfile(startFp, FILE_STRUCTURE, 1)
+
         print ' '
         print 'puntero file header', startFp.tell()
         print ' '
-        
-        
+
         '''      numpy.fromfile(file, dtype, count, sep='')
             file : file or str
             Open file object or filename.
@@ -119,32 +117,28 @@ class FileHeaderBLTR(Header):
 
     '''
 
+        self.FileMgcNumber = hex(header['FileMgcNumber'][0])
+        # No Of FDT data records in this file (0 or more)
+        self.nFDTdataRecors = int(header['nFDTdataRecors'][0])
+        self.RadarUnitId = int(header['RadarUnitId'][0])
+        self.OffsetStartHeader = int(header['OffsetStartHeader'][0])
+        self.SiteName = str(header['SiteName'][0])
+
+        # print 'Numero de bloques', self.nFDTdataRecors
 
-        
-        self.FileMgcNumber= hex(header['FileMgcNumber'][0])
-        self.nFDTdataRecors=int(header['nFDTdataRecors'][0])     #No Of FDT data records in this file (0 or more)
-        self.RadarUnitId= int(header['RadarUnitId'][0])
-        self.OffsetStartHeader= int(header['OffsetStartHeader'][0])
-        self.SiteName= str(header['SiteName'][0])
-        
-        #print 'Numero de bloques', self.nFDTdataRecors
-        
-        
-        if self.size <48:
+        if self.size < 48:
             return 0
-            
+
         return 1
-    
-    
+
     def write(self, fp):
-        
+
         headerTuple = (self.FileMgcNumber,
                        self.nFDTdataRecors,
                        self.RadarUnitId,
                        self.SiteName,
                        self.size)
-             
-                       
+
         header = numpy.array(headerTuple, FILE_STRUCTURE)
         #        numpy.array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)
         header.tofile(fp)
@@ -162,272 +156,308 @@ class FileHeaderBLTR(Header):
         first converting it to the closest Python type, and then using "format" % item.
 
         '''
-        
-        return 1
 
+        return 1
 
 
+RECORD_STRUCTURE = numpy.dtype([  # RECORD HEADER 180+20N bytes
+    ('RecMgcNumber', '<u4'),  # 0x23030001
+    ('RecCounter', '<u4'),  # Record counter(0,1, ...)
+    # Offset to start of next record form start of this record
+                            ('Off2StartNxtRec', '<u4'),
+                            # Offset to start of data from start of this record
+                            ('Off2StartData', '<u4'),
+                            # Epoch time stamp of start of acquisition (seconds)
+                            ('nUtime', '<i4'),
+                            # Millisecond component of time stamp (0,...,999)
+                            ('nMilisec', '<u4'),
+                            # Experiment tag name (null terminated)
+                            ('ExpTagName', numpy.str_, 32),
+                            # Experiment comment (null terminated)
+                            ('ExpComment', numpy.str_, 32),
+                            # Site latitude (from GPS) in degrees (positive implies North)
+                            ('SiteLatDegrees', '<f4'),
+                            # Site longitude (from GPS) in degrees (positive implies East)
+                            ('SiteLongDegrees', '<f4'),
+                            # RTC GPS engine status (0=SEEK, 1=LOCK, 2=NOT FITTED, 3=UNAVAILABLE)
+                            ('RTCgpsStatus', '<u4'),
+                            ('TransmitFrec', '<u4'),  # Transmit frequency (Hz)
+                            ('ReceiveFrec', '<u4'),  # Receive frequency
+                            # First local oscillator frequency (Hz)
+                            ('FirstOsciFrec', '<u4'),
+                            # (0="O", 1="E", 2="linear 1", 3="linear2")
+                            ('Polarisation', '<u4'),
+                            # Receiver filter settings (0,1,2,3)
+                            ('ReceiverFiltSett', '<u4'),
+                            # Number of modes in use (1 or 2)
+                            ('nModesInUse', '<u4'),
+                            # Dual Mode index number for these data (0 or 1)
+                            ('DualModeIndex', '<u4'),
+                            # Dual Mode range correction for these data (m)
+                            ('DualModeRange', '<u4'),
+                            # Number of digital channels acquired (2*N)
+                            ('nDigChannels', '<u4'),
+                            # Sampling resolution (meters)
+                            ('SampResolution', '<u4'),
+                            # Number of range gates sampled
+                            ('nHeights', '<u4'),
+                            # Start range of sampling (meters)
+                            ('StartRangeSamp', '<u4'),
+                            ('PRFhz', '<u4'),  # PRF (Hz)
+                            ('nCohInt', '<u4'),  # Integrations
+                            # Number of data points transformed
+                            ('nProfiles', '<u4'),
+                            # Number of receive beams stored in file (1 or N)
+                            ('nChannels', '<u4'),
+                            ('nIncohInt', '<u4'),  # Number of spectral averages
+                            # FFT windowing index (0 = no window)
+                            ('FFTwindowingInd', '<u4'),
+                            # Beam steer angle (azimuth) in degrees (clockwise from true North)
+                            ('BeamAngleAzim', '<f4'),
+                            # Beam steer angle (zenith) in degrees (0=> vertical)
+                            ('BeamAngleZen', '<f4'),
+                            # Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
+                            ('AntennaCoord0', '<f4'),
+                            # Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
+                            ('AntennaAngl0', '<f4'),
+                            # Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
+                            ('AntennaCoord1', '<f4'),
+                            # Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
+                            ('AntennaAngl1', '<f4'),
+                            # Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
+                            ('AntennaCoord2', '<f4'),
+                            # Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
+                            ('AntennaAngl2', '<f4'),
+                            # Receiver phase calibration (degrees) - N values
+                            ('RecPhaseCalibr0', '<f4'),
+                            # Receiver phase calibration (degrees) - N values
+                            ('RecPhaseCalibr1', '<f4'),
+                            # Receiver phase calibration (degrees) - N values
+                            ('RecPhaseCalibr2', '<f4'),
+                            # Receiver amplitude calibration (ratio relative to receiver one) - N values
+                            ('RecAmpCalibr0', '<f4'),
+                            # Receiver amplitude calibration (ratio relative to receiver one) - N values
+                            ('RecAmpCalibr1', '<f4'),
+                            # Receiver amplitude calibration (ratio relative to receiver one) - N values
+                            ('RecAmpCalibr2', '<f4'),
+                            # Receiver gains in dB - N values
+                            ('ReceiverGaindB0', '<i4'),
+                            # Receiver gains in dB - N values
+                            ('ReceiverGaindB1', '<i4'),
+                            # Receiver gains in dB - N values
+                            ('ReceiverGaindB2', '<i4'),
+])
 
 
-RECORD_STRUCTURE = numpy.dtype([         #RECORD HEADER 180+20N bytes
-                            ('RecMgcNumber','<u4'),     #0x23030001
-                            ('RecCounter','<u4'),       #Record counter(0,1, ...)
-                            ('Off2StartNxtRec','<u4'),  #Offset to start of next record form start of this record
-                            ('Off2StartData','<u4'),    #Offset to start of data from start of this record     
-                            ('nUtime','<i4'),      #Epoch time stamp of start of acquisition (seconds)   
-                            ('nMilisec','<u4'),      #Millisecond component of time stamp (0,...,999) 
-                            ('ExpTagName',numpy.str_,32),      #Experiment tag name (null terminated)
-                            ('ExpComment',numpy.str_,32),      #Experiment comment (null terminated)
-                            ('SiteLatDegrees','<f4'),   #Site latitude (from GPS) in degrees (positive implies North)
-                            ('SiteLongDegrees','<f4'),  #Site longitude (from GPS) in degrees (positive implies East)
-                            ('RTCgpsStatus','<u4'),     #RTC GPS engine status (0=SEEK, 1=LOCK, 2=NOT FITTED, 3=UNAVAILABLE)
-                            ('TransmitFrec','<u4'),     #Transmit frequency (Hz)
-                            ('ReceiveFrec','<u4'),      #Receive frequency
-                            ('FirstOsciFrec','<u4'),    #First local oscillator frequency (Hz) 
-                            ('Polarisation','<u4'),     #(0="O", 1="E", 2="linear 1", 3="linear2")
-                            ('ReceiverFiltSett','<u4'), #Receiver filter settings (0,1,2,3)
-                            ('nModesInUse','<u4'),      #Number of modes in use (1 or 2)
-                            ('DualModeIndex','<u4'),    #Dual Mode index number for these data (0 or 1)
-                            ('DualModeRange','<u4'),    #Dual Mode range correction for these data (m)
-                            ('nDigChannels','<u4'),     #Number of digital channels acquired (2*N)
-                            ('SampResolution','<u4'),   #Sampling resolution (meters)
-                            ('nHeights','<u4'),         #Number of range gates sampled
-                            ('StartRangeSamp','<u4'),   #Start range of sampling (meters)
-                            ('PRFhz','<u4'),            #PRF (Hz)
-                            ('nCohInt','<u4'),          #Integrations
-                            ('nProfiles','<u4'),        #Number of data points transformed
-                            ('nChannels','<u4'),        #Number of receive beams stored in file (1 or N)
-                            ('nIncohInt','<u4'),        #Number of spectral averages
-                            ('FFTwindowingInd','<u4'),  #FFT windowing index (0 = no window)
-                            ('BeamAngleAzim','<f4'),    #Beam steer angle (azimuth) in degrees (clockwise from true North)
-                            ('BeamAngleZen','<f4'),     #Beam steer angle (zenith) in degrees (0=> vertical)
-                            ('AntennaCoord0','<f4'),    #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
-                            ('AntennaAngl0','<f4'),     #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
-                            ('AntennaCoord1','<f4'),    #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
-                            ('AntennaAngl1','<f4'),     #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
-                            ('AntennaCoord2','<f4'),    #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
-                            ('AntennaAngl2','<f4'),     #Antenna coordinates (Range(meters), Bearing(degrees)) - N pairs
-                            ('RecPhaseCalibr0','<f4'),  #Receiver phase calibration (degrees) - N values
-                            ('RecPhaseCalibr1','<f4'),  #Receiver phase calibration (degrees) - N values
-                            ('RecPhaseCalibr2','<f4'),  #Receiver phase calibration (degrees) - N values
-                            ('RecAmpCalibr0','<f4'),    #Receiver amplitude calibration (ratio relative to receiver one) - N values
-                            ('RecAmpCalibr1','<f4'),    #Receiver amplitude calibration (ratio relative to receiver one) - N values
-                            ('RecAmpCalibr2','<f4'),    #Receiver amplitude calibration (ratio relative to receiver one) - N values
-                            ('ReceiverGaindB0','<i4'),  #Receiver gains in dB - N values
-                            ('ReceiverGaindB1','<i4'),  #Receiver gains in dB - N values
-                            ('ReceiverGaindB2','<i4'),  #Receiver gains in dB - N values
-                            ])
+class RecordHeaderBLTR(Header):
 
+    def __init__(self,      RecMgcNumber=None,   RecCounter=0,      Off2StartNxtRec=811248,
+                 nUtime=0,           nMilisec=0,        ExpTagName=None,
+                 ExpComment=None,     SiteLatDegrees=0,   SiteLongDegrees=0,
+                 RTCgpsStatus=0,     TransmitFrec=0,    ReceiveFrec=0,
+                 FirstOsciFrec=0,    Polarisation=0,    ReceiverFiltSett=0,
+                 nModesInUse=0,      DualModeIndex=0,   DualModeRange=0,
+                 nDigChannels=0,     SampResolution=0,  nHeights=0,
+                 StartRangeSamp=0,   PRFhz=0,           nCohInt=0,
+                 nProfiles=0,        nChannels=0,       nIncohInt=0,
+                 FFTwindowingInd=0,  BeamAngleAzim=0,   BeamAngleZen=0,
+                 AntennaCoord0=0,     AntennaCoord1=0,    AntennaCoord2=0,
+                 RecPhaseCalibr0=0,  RecPhaseCalibr1=0, RecPhaseCalibr2=0,
+                 RecAmpCalibr0=0,    RecAmpCalibr1=0,   RecAmpCalibr2=0,
+                 AntennaAngl0=0,      AntennaAngl1=0,     AntennaAngl2=0,
+                 ReceiverGaindB0=0,  ReceiverGaindB1=0, ReceiverGaindB2=0, Off2StartData=0,    OffsetStartHeader=0):
 
-class RecordHeaderBLTR(Header):
-    
-    def __init__(self,      RecMgcNumber=None,   RecCounter= 0,      Off2StartNxtRec= 811248,      
-                            nUtime= 0,           nMilisec= 0,        ExpTagName= None,      
-                            ExpComment=None,     SiteLatDegrees=0,   SiteLongDegrees= 0, 
-                            RTCgpsStatus= 0,     TransmitFrec= 0,    ReceiveFrec= 0,     
-                            FirstOsciFrec= 0,    Polarisation= 0,    ReceiverFiltSett= 0,
-                            nModesInUse= 0,      DualModeIndex= 0,   DualModeRange= 0,   
-                            nDigChannels= 0,     SampResolution= 0,  nHeights= 0,
-                            StartRangeSamp= 0,   PRFhz= 0,           nCohInt= 0,
-                            nProfiles= 0,        nChannels= 0,       nIncohInt= 0,
-                            FFTwindowingInd= 0,  BeamAngleAzim= 0,   BeamAngleZen= 0,
-                            AntennaCoord0= 0,     AntennaCoord1= 0,    AntennaCoord2= 0, 
-                            RecPhaseCalibr0= 0,  RecPhaseCalibr1= 0, RecPhaseCalibr2= 0,
-                            RecAmpCalibr0= 0,    RecAmpCalibr1= 0,   RecAmpCalibr2= 0,
-                            AntennaAngl0=0,      AntennaAngl1=0,     AntennaAngl2=0,
-                            ReceiverGaindB0= 0,  ReceiverGaindB1= 0, ReceiverGaindB2= 0, Off2StartData=0,    OffsetStartHeader=0):
-        
-        self.RecMgcNumber = RecMgcNumber     #0x23030001
-        self.RecCounter = RecCounter      
-        self.Off2StartNxtRec = Off2StartNxtRec       
+        self.RecMgcNumber = RecMgcNumber  # 0x23030001
+        self.RecCounter = RecCounter
+        self.Off2StartNxtRec = Off2StartNxtRec
         self.Off2StartData = Off2StartData
-        self.nUtime = nUtime        
-        self.nMilisec = nMilisec   
-        self.ExpTagName = ExpTagName       
-        self.ExpComment = ExpComment      
-        self.SiteLatDegrees = SiteLatDegrees  
-        self.SiteLongDegrees = SiteLongDegrees  
-        self.RTCgpsStatus = RTCgpsStatus     
-        self.TransmitFrec = TransmitFrec     
-        self.ReceiveFrec = ReceiveFrec      
-        self.FirstOsciFrec = FirstOsciFrec     
-        self.Polarisation = Polarisation     
-        self.ReceiverFiltSett = ReceiverFiltSett 
-        self.nModesInUse = nModesInUse      
-        self.DualModeIndex = DualModeIndex    
-        self.DualModeRange = DualModeRange    
+        self.nUtime = nUtime
+        self.nMilisec = nMilisec
+        self.ExpTagName = ExpTagName
+        self.ExpComment = ExpComment
+        self.SiteLatDegrees = SiteLatDegrees
+        self.SiteLongDegrees = SiteLongDegrees
+        self.RTCgpsStatus = RTCgpsStatus
+        self.TransmitFrec = TransmitFrec
+        self.ReceiveFrec = ReceiveFrec
+        self.FirstOsciFrec = FirstOsciFrec
+        self.Polarisation = Polarisation
+        self.ReceiverFiltSett = ReceiverFiltSett
+        self.nModesInUse = nModesInUse
+        self.DualModeIndex = DualModeIndex
+        self.DualModeRange = DualModeRange
         self.nDigChannels = nDigChannels
-        self.SampResolution = SampResolution 
-        self.nHeights = nHeights 
-        self.StartRangeSamp = StartRangeSamp 
-        self.PRFhz = PRFhz 
-        self.nCohInt = nCohInt 
-        self.nProfiles = nProfiles 
-        self.nChannels = nChannels 
-        self.nIncohInt = nIncohInt 
-        self.FFTwindowingInd = FFTwindowingInd 
-        self.BeamAngleAzim = BeamAngleAzim 
-        self.BeamAngleZen = BeamAngleZen 
+        self.SampResolution = SampResolution
+        self.nHeights = nHeights
+        self.StartRangeSamp = StartRangeSamp
+        self.PRFhz = PRFhz
+        self.nCohInt = nCohInt
+        self.nProfiles = nProfiles
+        self.nChannels = nChannels
+        self.nIncohInt = nIncohInt
+        self.FFTwindowingInd = FFTwindowingInd
+        self.BeamAngleAzim = BeamAngleAzim
+        self.BeamAngleZen = BeamAngleZen
         self.AntennaCoord0 = AntennaCoord0
         self.AntennaAngl0 = AntennaAngl0
         self.AntennaAngl1 = AntennaAngl1
         self.AntennaAngl2 = AntennaAngl2
         self.AntennaCoord1 = AntennaCoord1
-        self.AntennaCoord2 = AntennaCoord2  
+        self.AntennaCoord2 = AntennaCoord2
         self.RecPhaseCalibr0 = RecPhaseCalibr0
         self.RecPhaseCalibr1 = RecPhaseCalibr1
-        self.RecPhaseCalibr2 = RecPhaseCalibr2 
+        self.RecPhaseCalibr2 = RecPhaseCalibr2
         self.RecAmpCalibr0 = RecAmpCalibr0
         self.RecAmpCalibr1 = RecAmpCalibr1
-        self.RecAmpCalibr2 = RecAmpCalibr2 
+        self.RecAmpCalibr2 = RecAmpCalibr2
         self.ReceiverGaindB0 = ReceiverGaindB0
         self.ReceiverGaindB1 = ReceiverGaindB1
-        self.ReceiverGaindB2 = ReceiverGaindB2 
-        self.OffsetStartHeader =  48
-        
-        
-    
+        self.ReceiverGaindB2 = ReceiverGaindB2
+        self.OffsetStartHeader = 48
+
     def RHread(self, fp):
-        #print fp
-        #startFp = open('/home/erick/Documents/Data/huancayo.20161019.22.fdt',"rb") #The method tell() returns the current position of the file read/write pointer within the file.
-        startFp = open(fp,"rb") #The method tell() returns the current position of the file read/write pointer within the file.
-        #RecCounter=0
-        #Off2StartNxtRec=811248
-        OffRHeader= self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec
+        # print fp
+        # startFp = open('/home/erick/Documents/Data/huancayo.20161019.22.fdt',"rb") #The method tell() returns the current position of the file read/write pointer within the file.
+        # The method tell() returns the current position of the file read/write pointer within the file.
+        startFp = open(fp, "rb")
+        # RecCounter=0
+        # Off2StartNxtRec=811248
+        OffRHeader = self.OffsetStartHeader + self.RecCounter * self.Off2StartNxtRec
         print ' '
         print 'puntero Record Header', startFp.tell()
         print ' '
-        
-        
+
         startFp.seek(OffRHeader, os.SEEK_SET)
-        
+
         print ' '
         print 'puntero Record Header con seek', startFp.tell()
         print ' '
-        
-        #print 'Posicion del bloque:        ',OffRHeader
-        
-        header = numpy.fromfile(startFp,RECORD_STRUCTURE,1)
-        
+
+        # print 'Posicion del bloque:        ',OffRHeader
+
+        header = numpy.fromfile(startFp, RECORD_STRUCTURE, 1)
+
         print ' '
         print 'puntero Record Header con seek', startFp.tell()
         print ' '
-        
+
         print ' '
         #
-        #print 'puntero Record Header despues de seek', header.tell()
+        # print 'puntero Record Header despues de seek', header.tell()
         print ' '
-        
-        self.RecMgcNumber = hex(header['RecMgcNumber'][0])     #0x23030001
-        self.RecCounter = int(header['RecCounter'][0])      
-        self.Off2StartNxtRec = int(header['Off2StartNxtRec'][0])   
-        self.Off2StartData = int(header['Off2StartData'][0])    
-        self.nUtime = header['nUtime'][0]         
-        self.nMilisec = header['nMilisec'][0]   
-        self.ExpTagName = str(header['ExpTagName'][0])       
-        self.ExpComment = str(header['ExpComment'][0])      
-        self.SiteLatDegrees = header['SiteLatDegrees'][0]  
-        self.SiteLongDegrees = header['SiteLongDegrees'][0]  
-        self.RTCgpsStatus = header['RTCgpsStatus'][0]     
-        self.TransmitFrec = header['TransmitFrec'][0]     
-        self.ReceiveFrec = header['ReceiveFrec'][0]      
-        self.FirstOsciFrec = header['FirstOsciFrec'][0]     
-        self.Polarisation = header['Polarisation'][0]     
-        self.ReceiverFiltSett = header['ReceiverFiltSett'][0] 
-        self.nModesInUse = header['nModesInUse'][0]      
-        self.DualModeIndex = header['DualModeIndex'][0]    
-        self.DualModeRange = header['DualModeRange'][0]    
+
+        self.RecMgcNumber = hex(header['RecMgcNumber'][0])  # 0x23030001
+        self.RecCounter = int(header['RecCounter'][0])
+        self.Off2StartNxtRec = int(header['Off2StartNxtRec'][0])
+        self.Off2StartData = int(header['Off2StartData'][0])
+        self.nUtime = header['nUtime'][0]
+        self.nMilisec = header['nMilisec'][0]
+        self.ExpTagName = str(header['ExpTagName'][0])
+        self.ExpComment = str(header['ExpComment'][0])
+        self.SiteLatDegrees = header['SiteLatDegrees'][0]
+        self.SiteLongDegrees = header['SiteLongDegrees'][0]
+        self.RTCgpsStatus = header['RTCgpsStatus'][0]
+        self.TransmitFrec = header['TransmitFrec'][0]
+        self.ReceiveFrec = header['ReceiveFrec'][0]
+        self.FirstOsciFrec = header['FirstOsciFrec'][0]
+        self.Polarisation = header['Polarisation'][0]
+        self.ReceiverFiltSett = header['ReceiverFiltSett'][0]
+        self.nModesInUse = header['nModesInUse'][0]
+        self.DualModeIndex = header['DualModeIndex'][0]
+        self.DualModeRange = header['DualModeRange'][0]
         self.nDigChannels = header['nDigChannels'][0]
-        self.SampResolution = header['SampResolution'][0] 
-        self.nHeights = header['nHeights'][0] 
-        self.StartRangeSamp = header['StartRangeSamp'][0] 
-        self.PRFhz = header['PRFhz'][0] 
-        self.nCohInt = header['nCohInt'][0] 
-        self.nProfiles = header['nProfiles'][0] 
-        self.nChannels = header['nChannels'][0] 
-        self.nIncohInt = header['nIncohInt'][0] 
-        self.FFTwindowingInd = header['FFTwindowingInd'][0] 
-        self.BeamAngleAzim = header['BeamAngleAzim'][0] 
-        self.BeamAngleZen = header['BeamAngleZen'][0] 
+        self.SampResolution = header['SampResolution'][0]
+        self.nHeights = header['nHeights'][0]
+        self.StartRangeSamp = header['StartRangeSamp'][0]
+        self.PRFhz = header['PRFhz'][0]
+        self.nCohInt = header['nCohInt'][0]
+        self.nProfiles = header['nProfiles'][0]
+        self.nChannels = header['nChannels'][0]
+        self.nIncohInt = header['nIncohInt'][0]
+        self.FFTwindowingInd = header['FFTwindowingInd'][0]
+        self.BeamAngleAzim = header['BeamAngleAzim'][0]
+        self.BeamAngleZen = header['BeamAngleZen'][0]
         self.AntennaCoord0 = header['AntennaCoord0'][0]
         self.AntennaAngl0 = header['AntennaAngl0'][0]
         self.AntennaCoord1 = header['AntennaCoord1'][0]
-        self.AntennaAngl1 = header['AntennaAngl1'][0] 
+        self.AntennaAngl1 = header['AntennaAngl1'][0]
         self.AntennaCoord2 = header['AntennaCoord2'][0]
-        self.AntennaAngl2 = header['AntennaAngl2'][0]  
+        self.AntennaAngl2 = header['AntennaAngl2'][0]
         self.RecPhaseCalibr0 = header['RecPhaseCalibr0'][0]
         self.RecPhaseCalibr1 = header['RecPhaseCalibr1'][0]
-        self.RecPhaseCalibr2 = header['RecPhaseCalibr2'][0] 
+        self.RecPhaseCalibr2 = header['RecPhaseCalibr2'][0]
         self.RecAmpCalibr0 = header['RecAmpCalibr0'][0]
         self.RecAmpCalibr1 = header['RecAmpCalibr1'][0]
-        self.RecAmpCalibr2 = header['RecAmpCalibr2'][0] 
+        self.RecAmpCalibr2 = header['RecAmpCalibr2'][0]
         self.ReceiverGaindB0 = header['ReceiverGaindB0'][0]
         self.ReceiverGaindB1 = header['ReceiverGaindB1'][0]
         self.ReceiverGaindB2 = header['ReceiverGaindB2'][0]
 
-        self.ipp= 0.5*(SPEED_OF_LIGHT/self.PRFhz)
-        
-        self.RHsize = 180+20*self.nChannels
-        self.Datasize= self.nProfiles*self.nChannels*self.nHeights*2*4
-        #print 'Datasize',self.Datasize
-        endFp = self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec
-        
+        self.ipp = 0.5 * (SPEED_OF_LIGHT / self.PRFhz)
+
+        self.RHsize = 180 + 20 * self.nChannels
+        self.Datasize = self.nProfiles * self.nChannels * self.nHeights * 2 * 4
+        # print 'Datasize',self.Datasize
+        endFp = self.OffsetStartHeader + self.RecCounter * self.Off2StartNxtRec
+
         print '=============================================='
-        print 'RecMgcNumber         ',self.RecMgcNumber
-        print 'RecCounter           ',self.RecCounter
-        print 'Off2StartNxtRec      ',self.Off2StartNxtRec 
-        print 'Off2StartData        ',self.Off2StartData
-        print 'Range Resolution     ',self.SampResolution
-        print 'First Height         ',self.StartRangeSamp
-        print 'PRF (Hz)             ',self.PRFhz
-        print 'Heights (K)          ',self.nHeights
-        print 'Channels (N)         ',self.nChannels
-        print 'Profiles (J)         ',self.nProfiles
-        print 'iCoh                 ',self.nCohInt
-        print 'iInCoh               ',self.nIncohInt
-        print 'BeamAngleAzim        ',self.BeamAngleAzim
-        print 'BeamAngleZen         ',self.BeamAngleZen
-        
-        #print 'ModoEnUso            ',self.DualModeIndex
-        #print 'UtcTime              ',self.nUtime
-        #print 'MiliSec              ',self.nMilisec
-        #print 'Exp TagName          ',self.ExpTagName
-        #print 'Exp Comment          ',self.ExpComment
-        #print 'FFT Window Index     ',self.FFTwindowingInd
-        #print 'N Dig. Channels      ',self.nDigChannels
-        print 'Size de bloque       ',self.RHsize
-        print 'DataSize             ',self.Datasize
-        print 'BeamAngleAzim        ',self.BeamAngleAzim
-        #print 'AntennaCoord0        ',self.AntennaCoord0
-        #print 'AntennaAngl0         ',self.AntennaAngl0
-        #print 'AntennaCoord1        ',self.AntennaCoord1
-        #print 'AntennaAngl1         ',self.AntennaAngl1
-        #print 'AntennaCoord2        ',self.AntennaCoord2
-        #print 'AntennaAngl2         ',self.AntennaAngl2
-        print 'RecPhaseCalibr0      ',self.RecPhaseCalibr0
-        print 'RecPhaseCalibr1      ',self.RecPhaseCalibr1
-        print 'RecPhaseCalibr2      ',self.RecPhaseCalibr2
-        print 'RecAmpCalibr0        ',self.RecAmpCalibr0
-        print 'RecAmpCalibr1        ',self.RecAmpCalibr1
-        print 'RecAmpCalibr2        ',self.RecAmpCalibr2
-        print 'ReceiverGaindB0      ',self.ReceiverGaindB0
-        print 'ReceiverGaindB1      ',self.ReceiverGaindB1
-        print 'ReceiverGaindB2      ',self.ReceiverGaindB2
+        print 'RecMgcNumber         ', self.RecMgcNumber
+        print 'RecCounter           ', self.RecCounter
+        print 'Off2StartNxtRec      ', self.Off2StartNxtRec
+        print 'Off2StartData        ', self.Off2StartData
+        print 'Range Resolution     ', self.SampResolution
+        print 'First Height         ', self.StartRangeSamp
+        print 'PRF (Hz)             ', self.PRFhz
+        print 'Heights (K)          ', self.nHeights
+        print 'Channels (N)         ', self.nChannels
+        print 'Profiles (J)         ', self.nProfiles
+        print 'iCoh                 ', self.nCohInt
+        print 'iInCoh               ', self.nIncohInt
+        print 'BeamAngleAzim        ', self.BeamAngleAzim
+        print 'BeamAngleZen         ', self.BeamAngleZen
+
+        # print 'ModoEnUso            ',self.DualModeIndex
+        # print 'UtcTime              ',self.nUtime
+        # print 'MiliSec              ',self.nMilisec
+        # print 'Exp TagName          ',self.ExpTagName
+        # print 'Exp Comment          ',self.ExpComment
+        # print 'FFT Window Index     ',self.FFTwindowingInd
+        # print 'N Dig. Channels      ',self.nDigChannels
+        print 'Size de bloque       ', self.RHsize
+        print 'DataSize             ', self.Datasize
+        print 'BeamAngleAzim        ', self.BeamAngleAzim
+        # print 'AntennaCoord0        ',self.AntennaCoord0
+        # print 'AntennaAngl0         ',self.AntennaAngl0
+        # print 'AntennaCoord1        ',self.AntennaCoord1
+        # print 'AntennaAngl1         ',self.AntennaAngl1
+        # print 'AntennaCoord2        ',self.AntennaCoord2
+        # print 'AntennaAngl2         ',self.AntennaAngl2
+        print 'RecPhaseCalibr0      ', self.RecPhaseCalibr0
+        print 'RecPhaseCalibr1      ', self.RecPhaseCalibr1
+        print 'RecPhaseCalibr2      ', self.RecPhaseCalibr2
+        print 'RecAmpCalibr0        ', self.RecAmpCalibr0
+        print 'RecAmpCalibr1        ', self.RecAmpCalibr1
+        print 'RecAmpCalibr2        ', self.RecAmpCalibr2
+        print 'ReceiverGaindB0      ', self.ReceiverGaindB0
+        print 'ReceiverGaindB1      ', self.ReceiverGaindB1
+        print 'ReceiverGaindB2      ', self.ReceiverGaindB2
         print '=============================================='
-        
+
         if OffRHeader > endFp:
-            sys.stderr.write("Warning %s: Size value read from System Header is lower than it has to be\n" %fp)
+            sys.stderr.write(
+                "Warning %s: Size value read from System Header is lower than it has to be\n" % fp)
             return 0
-            
+
         if OffRHeader < endFp:
-            sys.stderr.write("Warning %s: Size value read from System Header size is greater than it has to be\n" %fp)
+            sys.stderr.write(
+                "Warning %s: Size value read from System Header size is greater than it has to be\n" % fp)
             return 0
-        
+
         return 1
 
-        
+
 class BLTRSpectraReader (ProcessingUnit, FileHeaderBLTR, RecordHeaderBLTR, JRODataReader):
-    
+
     path = None
     startDate = None
     endDate = None
@@ -435,28 +465,25 @@ class BLTRSpectraReader (ProcessingUnit, FileHeaderBLTR, RecordHeaderBLTR, JRODa
     endTime = None
     walk = None
     isConfig = False
-    
-    
-    fileList= None
-    
-    #metadata
-    TimeZone= None
-    Interval= None
-    heightList= None
-    
-    #data
-    data= None
-    utctime= None
-    
-    
-    
+
+    fileList = None
+
+    # metadata
+    TimeZone = None
+    Interval = None
+    heightList = None
+
+    # data
+    data = None
+    utctime = None
+
     def __init__(self, **kwargs):
-        
-        #Eliminar de la base la herencia
+
+        # Eliminar de la base la herencia
         ProcessingUnit.__init__(self, **kwargs)
-        
+
         #self.isConfig = False
-        
+
         #self.pts2read_SelfSpectra = 0
         #self.pts2read_CrossSpectra = 0
         #self.pts2read_DCchannels = 0
@@ -464,60 +491,59 @@ class BLTRSpectraReader (ProcessingUnit, FileHeaderBLTR, RecordHeaderBLTR, JRODa
         self.utc = None
         self.ext = ".fdt"
         self.optchar = "P"
-        self.fpFile=None
+        self.fpFile = None
         self.fp = None
-        self.BlockCounter=0
+        self.BlockCounter = 0
         self.dtype = None
         self.fileSizeByHeader = None
         self.filenameList = []
         self.fileSelector = 0
-        self.Off2StartNxtRec=0
-        self.RecCounter=0
+        self.Off2StartNxtRec = 0
+        self.RecCounter = 0
         self.flagNoMoreFiles = 0
-        self.data_spc=None
-        self.data_cspc=None
-        self.data_output=None
+        self.data_spc = None
+        self.data_cspc = None
+        self.data_output = None
         self.path = None
-        self.OffsetStartHeader=0
-        self.Off2StartData=0
+        self.OffsetStartHeader = 0
+        self.Off2StartData = 0
         self.ipp = 0
-        self.nFDTdataRecors=0
+        self.nFDTdataRecors = 0
         self.blocksize = 0
         self.dataOut = Spectra()
-        self.profileIndex = 1 #Always
-        self.dataOut.flagNoData=False
+        self.profileIndex = 1  # Always
+        self.dataOut.flagNoData = False
         self.dataOut.nRdPairs = 0
         self.dataOut.pairsList = []
-        self.dataOut.data_spc=None
-        self.dataOut.noise=[]
-        self.dataOut.velocityX=[]
-        self.dataOut.velocityY=[]
-        self.dataOut.velocityV=[]
-        
-
+        self.dataOut.data_spc = None
+        self.dataOut.noise = []
+        self.dataOut.velocityX = []
+        self.dataOut.velocityY = []
+        self.dataOut.velocityV = []
 
     def Files2Read(self, fp):
         ''' 
         Function that indicates the number of .fdt files that exist in the folder to be read.
         It also creates an organized list with the names of the files to read.
         '''
-        #self.__checkPath()
-        
-        ListaData=os.listdir(fp)    #Gets the list of files within the fp address
-        ListaData=sorted(ListaData) #Sort the list of files from least to largest by names
-        nFiles=0                    #File Counter
-        FileList=[]                 #A list is created that will contain the .fdt files
-        for IndexFile in ListaData :
-            if  '.fdt' in IndexFile:
+        # self.__checkPath()
+
+        # Gets the list of files within the fp address
+        ListaData = os.listdir(fp)
+        # Sort the list of files from least to largest by names
+        ListaData = sorted(ListaData)
+        nFiles = 0  # File Counter
+        FileList = []  # A list is created that will contain the .fdt files
+        for IndexFile in ListaData:
+            if '.fdt' in IndexFile:
                 FileList.append(IndexFile)
-                nFiles+=1
-        
-        #print 'Files2Read'
-        #print 'Existen '+str(nFiles)+' archivos .fdt' 
-        
-        self.filenameList=FileList #List of files from least to largest by names
-        
-    
+                nFiles += 1
+
+        # print 'Files2Read'
+        # print 'Existen '+str(nFiles)+' archivos .fdt'
+
+        self.filenameList = FileList  # List of files from least to largest by names
+
     def run(self, **kwargs):
         '''
         This method will be the one that will initiate the data entry, will be called constantly.
@@ -527,341 +553,350 @@ class BLTRSpectraReader (ProcessingUnit, FileHeaderBLTR, RecordHeaderBLTR, JRODa
         if not self.isConfig:
             self.setup(**kwargs)
             self.isConfig = True
-            
+
         self.getData()
-        #print 'running'
-        
-        
+        # print 'running'
+
     def setup(self, path=None,
-                    startDate=None, 
-                    endDate=None, 
-                    startTime=None, 
-                    endTime=None,
-                    walk=True,
-                    timezone='utc',
-                    code = None,
-                    online=False,
-                    ReadMode=None,
-                    **kwargs):
-        
+              startDate=None,
+              endDate=None,
+              startTime=None,
+              endTime=None,
+              walk=True,
+              timezone='utc',
+              code=None,
+              online=False,
+              ReadMode=None,
+              **kwargs):
+
         self.isConfig = True
-        
-        self.path=path 
-        self.startDate=startDate
-        self.endDate=endDate
-        self.startTime=startTime 
-        self.endTime=endTime
-        self.walk=walk 
-        self.ReadMode=int(ReadMode)
-        
+
+        self.path = path
+        self.startDate = startDate
+        self.endDate = endDate
+        self.startTime = startTime
+        self.endTime = endTime
+        self.walk = walk
+        self.ReadMode = int(ReadMode)
+
         pass
-        
-        
+
     def getData(self):
         '''
         Before starting this function, you should check that there is still an unread file,
         If there are still blocks to read or if the data block is empty.
-        
+
         You should call the file "read".
-        
+
         '''
-        
+
         if self.flagNoMoreFiles:
             self.dataOut.flagNoData = True
             print 'NoData se vuelve true'
             return 0
 
-        self.fp=self.path
+        self.fp = self.path
         self.Files2Read(self.fp)
         self.readFile(self.fp)
         self.dataOut.data_spc = self.data_spc
-        self.dataOut.data_cspc =self.data_cspc
-        self.dataOut.data_output=self.data_output
-        
+        self.dataOut.data_cspc = self.data_cspc
+        self.dataOut.data_output = self.data_output
+
         print 'self.dataOut.data_output', shape(self.dataOut.data_output)
-        
-        #self.removeDC()
-        return self.dataOut.data_spc  
-        
-    
-    def readFile(self,fp):
+
+        # self.removeDC()
+        return self.dataOut.data_spc
+
+    def readFile(self, fp):
         '''
         You must indicate if you are reading in Online or Offline mode and load the
         The parameters for this file reading mode.
-        
+
         Then you must do 2 actions:
-        
+
         1. Get the BLTR FileHeader.
         2. Start reading the first block.
         '''
-        
-        #The address of the folder is generated the name of the .fdt file that will be read
-        print "File:    ",self.fileSelector+1
-        
+
+        # The address of the folder is generated the name of the .fdt file that will be read
+        print "File:    ", self.fileSelector + 1
+
         if self.fileSelector < len(self.filenameList):
-            
-            self.fpFile=str(fp)+'/'+str(self.filenameList[self.fileSelector])
-            #print self.fpFile
+
+            self.fpFile = str(fp) + '/' + \
+                str(self.filenameList[self.fileSelector])
+            # print self.fpFile
             fheader = FileHeaderBLTR()
-            fheader.FHread(self.fpFile)   #Bltr FileHeader Reading
-            self.nFDTdataRecors=fheader.nFDTdataRecors
-            
-            self.readBlock()    #Block reading
+            fheader.FHread(self.fpFile)  # Bltr FileHeader Reading
+            self.nFDTdataRecors = fheader.nFDTdataRecors
+
+            self.readBlock()  # Block reading
         else:
             print 'readFile FlagNoData becomes true'
-            self.flagNoMoreFiles=True
+            self.flagNoMoreFiles = True
             self.dataOut.flagNoData = True
-            return 0 
-    
+            return 0
+
     def getVelRange(self, extrapoints=0):
-                    Lambda= SPEED_OF_LIGHT/50000000
-                    PRF = self.dataOut.PRF#1./(self.dataOut.ippSeconds * self.dataOut.nCohInt)
-                    Vmax=-Lambda/(4.*(1./PRF)*self.dataOut.nCohInt*2.)
-                    deltafreq = PRF / (self.nProfiles)
-                    deltavel = (Vmax*2) / (self.nProfiles)
-                    freqrange = deltafreq*(numpy.arange(self.nProfiles)-self.nProfiles/2.) - deltafreq/2
-                    velrange = deltavel*(numpy.arange(self.nProfiles)-self.nProfiles/2.) 
-                    return velrange
-    
-    def readBlock(self):  
+        Lambda = SPEED_OF_LIGHT / 50000000
+        # 1./(self.dataOut.ippSeconds * self.dataOut.nCohInt)
+        PRF = self.dataOut.PRF
+        Vmax = -Lambda / (4. * (1. / PRF) * self.dataOut.nCohInt * 2.)
+        deltafreq = PRF / (self.nProfiles)
+        deltavel = (Vmax * 2) / (self.nProfiles)
+        freqrange = deltafreq * \
+            (numpy.arange(self.nProfiles) - self.nProfiles / 2.) - deltafreq / 2
+        velrange = deltavel * \
+            (numpy.arange(self.nProfiles) - self.nProfiles / 2.)
+        return velrange
+
+    def readBlock(self):
         '''
         It should be checked if the block has data, if it is not passed to the next file.
-        
+
         Then the following is done:
-        
+
         1. Read the RecordHeader
         2. Fill the buffer with the current block number.
-        
+
         '''
-        
-        if self.BlockCounter < self.nFDTdataRecors-2:
+
+        if self.BlockCounter < self.nFDTdataRecors - 2:
             print self.nFDTdataRecors, 'CONDICION!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
-            if self.ReadMode==1:
-                rheader = RecordHeaderBLTR(RecCounter=self.BlockCounter+1)
-            elif self.ReadMode==0:
+            if self.ReadMode == 1:
+                rheader = RecordHeaderBLTR(RecCounter=self.BlockCounter + 1)
+            elif self.ReadMode == 0:
                 rheader = RecordHeaderBLTR(RecCounter=self.BlockCounter)
-            
-            rheader.RHread(self.fpFile)   #Bltr FileHeader Reading
-            
-            self.OffsetStartHeader=rheader.OffsetStartHeader
-            self.RecCounter=rheader.RecCounter
-            self.Off2StartNxtRec=rheader.Off2StartNxtRec
-            self.Off2StartData=rheader.Off2StartData
-            self.nProfiles=rheader.nProfiles
-            self.nChannels=rheader.nChannels
-            self.nHeights=rheader.nHeights
-            self.frequency=rheader.TransmitFrec
-            self.DualModeIndex=rheader.DualModeIndex
-            
-            self.pairsList =[(0,1),(0,2),(1,2)]
+
+            rheader.RHread(self.fpFile)  # Bltr FileHeader Reading
+
+            self.OffsetStartHeader = rheader.OffsetStartHeader
+            self.RecCounter = rheader.RecCounter
+            self.Off2StartNxtRec = rheader.Off2StartNxtRec
+            self.Off2StartData = rheader.Off2StartData
+            self.nProfiles = rheader.nProfiles
+            self.nChannels = rheader.nChannels
+            self.nHeights = rheader.nHeights
+            self.frequency = rheader.TransmitFrec
+            self.DualModeIndex = rheader.DualModeIndex
+
+            self.pairsList = [(0, 1), (0, 2), (1, 2)]
             self.dataOut.pairsList = self.pairsList
-            
-            self.nRdPairs=len(self.dataOut.pairsList)
+
+            self.nRdPairs = len(self.dataOut.pairsList)
             self.dataOut.nRdPairs = self.nRdPairs
-            
-            self.__firstHeigth=rheader.StartRangeSamp
-            self.__deltaHeigth=rheader.SampResolution
-            self.dataOut.heightList= self.__firstHeigth + numpy.array(range(self.nHeights))*self.__deltaHeigth
+
+            self.__firstHeigth = rheader.StartRangeSamp
+            self.__deltaHeigth = rheader.SampResolution
+            self.dataOut.heightList = self.__firstHeigth + \
+                numpy.array(range(self.nHeights)) * self.__deltaHeigth
             self.dataOut.channelList = range(self.nChannels)
-            self.dataOut.nProfiles=rheader.nProfiles
-            self.dataOut.nIncohInt=rheader.nIncohInt
-            self.dataOut.nCohInt=rheader.nCohInt
-            self.dataOut.ippSeconds= 1/float(rheader.PRFhz)
-            self.dataOut.PRF=rheader.PRFhz
-            self.dataOut.nFFTPoints=rheader.nProfiles
-            self.dataOut.utctime=rheader.nUtime
-            self.dataOut.timeZone=0
-            self.dataOut.normFactor= self.dataOut.nProfiles*self.dataOut.nIncohInt*self.dataOut.nCohInt
-            self.dataOut.outputInterval= self.dataOut.ippSeconds * self.dataOut.nCohInt * self.dataOut.nIncohInt * self.nProfiles
-            
-            self.data_output=numpy.ones([3,rheader.nHeights])*numpy.NaN
+            self.dataOut.nProfiles = rheader.nProfiles
+            self.dataOut.nIncohInt = rheader.nIncohInt
+            self.dataOut.nCohInt = rheader.nCohInt
+            self.dataOut.ippSeconds = 1 / float(rheader.PRFhz)
+            self.dataOut.PRF = rheader.PRFhz
+            self.dataOut.nFFTPoints = rheader.nProfiles
+            self.dataOut.utctime = rheader.nUtime
+            self.dataOut.timeZone = 0
+            self.dataOut.normFactor = self.dataOut.nProfiles * \
+                self.dataOut.nIncohInt * self.dataOut.nCohInt
+            self.dataOut.outputInterval = self.dataOut.ippSeconds * \
+                self.dataOut.nCohInt * self.dataOut.nIncohInt * self.nProfiles
+
+            self.data_output = numpy.ones([3, rheader.nHeights]) * numpy.NaN
             print 'self.data_output', shape(self.data_output)
-            self.dataOut.velocityX=[]
-            self.dataOut.velocityY=[]
-            self.dataOut.velocityV=[]
-            
+            self.dataOut.velocityX = []
+            self.dataOut.velocityY = []
+            self.dataOut.velocityV = []
+
             '''Block Reading, the Block Data is received and Reshape is used to give it
             shape.
-            '''    
-            
-            #Procedure to take the pointer to where the date block starts
-            startDATA = open(self.fpFile,"rb")
-            OffDATA= self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec+self.Off2StartData
+            '''
+
+            # Procedure to take the pointer to where the date block starts
+            startDATA = open(self.fpFile, "rb")
+            OffDATA = self.OffsetStartHeader + self.RecCounter * \
+                self.Off2StartNxtRec + self.Off2StartData
             startDATA.seek(OffDATA, os.SEEK_SET)
-            
+
             def moving_average(x, N=2):
-                return numpy.convolve(x, numpy.ones((N,))/N)[(N-1):]
-                
-            def gaus(xSamples,a,x0,sigma):
-                return a*exp(-(xSamples-x0)**2/(2*sigma**2))
-                
-            def Find(x,value):
+                return numpy.convolve(x, numpy.ones((N,)) / N)[(N - 1):]
+
+            def gaus(xSamples, a, x0, sigma):
+                return a * exp(-(xSamples - x0)**2 / (2 * sigma**2))
+
+            def Find(x, value):
                 for index in range(len(x)):
-                    if x[index]==value:
-                        return index     
-                            
+                    if x[index] == value:
+                        return index
+
             def pol2cart(rho, phi):
                 x = rho * numpy.cos(phi)
                 y = rho * numpy.sin(phi)
                 return(x, y)
-            
-            
-            
-            
-            if self.DualModeIndex==self.ReadMode:
-                
-                self.data_fft = numpy.fromfile( startDATA, [('complex','<c8')],self.nProfiles*self.nChannels*self.nHeights )
-                
-                self.data_fft=self.data_fft.astype(numpy.dtype('complex'))
-                
-                self.data_block=numpy.reshape(self.data_fft,(self.nHeights, self.nChannels, self.nProfiles ))
-                
-                self.data_block = numpy.transpose(self.data_block, (1,2,0))
-                
+
+            if self.DualModeIndex == self.ReadMode:
+
+                self.data_fft = numpy.fromfile(
+                    startDATA, [('complex', '<c8')], self.nProfiles * self.nChannels * self.nHeights)
+
+                self.data_fft = self.data_fft.astype(numpy.dtype('complex'))
+
+                self.data_block = numpy.reshape(
+                    self.data_fft, (self.nHeights, self.nChannels, self.nProfiles))
+
+                self.data_block = numpy.transpose(self.data_block, (1, 2, 0))
+
                 copy = self.data_block.copy()
-                spc = copy * numpy.conjugate(copy)   
-                
-                self.data_spc = numpy.absolute(spc) # valor absoluto o magnitud
-                
+                spc = copy * numpy.conjugate(copy)
+
+                self.data_spc = numpy.absolute(
+                    spc)  # valor absoluto o magnitud
+
                 factor = self.dataOut.normFactor
-                
-                
-                z = self.data_spc.copy()#/factor
+
+                z = self.data_spc.copy()  # /factor
                 z = numpy.where(numpy.isfinite(z), z, numpy.NAN)
                 #zdB = 10*numpy.log10(z)
                 print ' '
                 print 'Z: '
-                print shape(z) 
+                print shape(z)
                 print ' '
                 print ' '
-                
-                self.dataOut.data_spc=self.data_spc
-                
-                self.noise = self.dataOut.getNoise(ymin_index=80, ymax_index=132)#/factor
+
+                self.dataOut.data_spc = self.data_spc
+
+                self.noise = self.dataOut.getNoise(
+                    ymin_index=80, ymax_index=132)  # /factor
                 #noisedB = 10*numpy.log10(self.noise)
-                
-                
-                ySamples=numpy.ones([3,self.nProfiles])
-                phase=numpy.ones([3,self.nProfiles])
-                CSPCSamples=numpy.ones([3,self.nProfiles],dtype=numpy.complex_)
-                coherence=numpy.ones([3,self.nProfiles])
-                PhaseSlope=numpy.ones(3)
-                PhaseInter=numpy.ones(3)
-                
+
+                ySamples = numpy.ones([3, self.nProfiles])
+                phase = numpy.ones([3, self.nProfiles])
+                CSPCSamples = numpy.ones(
+                    [3, self.nProfiles], dtype=numpy.complex_)
+                coherence = numpy.ones([3, self.nProfiles])
+                PhaseSlope = numpy.ones(3)
+                PhaseInter = numpy.ones(3)
+
                 '''****** Getting CrossSpectra ******'''
-                cspc=self.data_block.copy()
-                self.data_cspc=self.data_block.copy()
-                
-                xFrec=self.getVelRange(1)
-                VelRange=self.getVelRange(1)
-                self.dataOut.VelRange=VelRange
-                #print ' '
-                #print ' '
-                #print 'xFrec',xFrec
-                #print ' '
-                #print ' '
-                #Height=35
-                for i in range(self.nRdPairs):    
-                    
+                cspc = self.data_block.copy()
+                self.data_cspc = self.data_block.copy()
+
+                xFrec = self.getVelRange(1)
+                VelRange = self.getVelRange(1)
+                self.dataOut.VelRange = VelRange
+                # print ' '
+                # print ' '
+                # print 'xFrec',xFrec
+                # print ' '
+                # print ' '
+                # Height=35
+                for i in range(self.nRdPairs):
+
                     chan_index0 = self.dataOut.pairsList[i][0]
                     chan_index1 = self.dataOut.pairsList[i][1]
-                    
-                    self.data_cspc[i,:,:]=cspc[chan_index0,:,:] * numpy.conjugate(cspc[chan_index1,:,:])
-                
-                
+
+                    self.data_cspc[i, :, :] = cspc[chan_index0, :,
+                                                   :] * numpy.conjugate(cspc[chan_index1, :, :])
+
                     '''Getting Eij and Nij'''
-                    (AntennaX0,AntennaY0)=pol2cart(rheader.AntennaCoord0, rheader.AntennaAngl0*numpy.pi/180)
-                    (AntennaX1,AntennaY1)=pol2cart(rheader.AntennaCoord1, rheader.AntennaAngl1*numpy.pi/180)
-                    (AntennaX2,AntennaY2)=pol2cart(rheader.AntennaCoord2, rheader.AntennaAngl2*numpy.pi/180)
-                    
-                    E01=AntennaX0-AntennaX1
-                    N01=AntennaY0-AntennaY1
-                    
-                    E02=AntennaX0-AntennaX2
-                    N02=AntennaY0-AntennaY2
-                    
-                    E12=AntennaX1-AntennaX2
-                    N12=AntennaY1-AntennaY2
-                    
-                    self.ChanDist= numpy.array([[E01, N01],[E02,N02],[E12,N12]])
-                    
+                    (AntennaX0, AntennaY0) = pol2cart(
+                        rheader.AntennaCoord0, rheader.AntennaAngl0 * numpy.pi / 180)
+                    (AntennaX1, AntennaY1) = pol2cart(
+                        rheader.AntennaCoord1, rheader.AntennaAngl1 * numpy.pi / 180)
+                    (AntennaX2, AntennaY2) = pol2cart(
+                        rheader.AntennaCoord2, rheader.AntennaAngl2 * numpy.pi / 180)
+
+                    E01 = AntennaX0 - AntennaX1
+                    N01 = AntennaY0 - AntennaY1
+
+                    E02 = AntennaX0 - AntennaX2
+                    N02 = AntennaY0 - AntennaY2
+
+                    E12 = AntennaX1 - AntennaX2
+                    N12 = AntennaY1 - AntennaY2
+
+                    self.ChanDist = numpy.array(
+                        [[E01, N01], [E02, N02], [E12, N12]])
+
                     self.dataOut.ChanDist = self.ChanDist
-                
-                
+
+
 #                 for Height in range(self.nHeights):
-#                       
+#
 #                     for i in range(self.nRdPairs):
-#                           
+#
 #                         '''****** Line of Data SPC ******'''
 #                         zline=z[i,:,Height]
-#                         
+#
 #                         '''****** DC is removed ******'''
 #                         DC=Find(zline,numpy.amax(zline))
 #                         zline[DC]=(zline[DC-1]+zline[DC+1])/2
-#                         
-#                         
+#
+#
 #                         '''****** SPC is normalized ******'''
 #                         FactNorm= zline.copy() / numpy.sum(zline.copy())
 #                         FactNorm= FactNorm/numpy.sum(FactNorm)
-#                           
+#
 #                         SmoothSPC=moving_average(FactNorm,N=3)
-#                           
+#
 #                         xSamples = ar(range(len(SmoothSPC)))
 #                         ySamples[i] = SmoothSPC-self.noise[i]
-#                         
+#
 #                     for i in range(self.nRdPairs):
-#                                
+#
 #                         '''****** Line of Data CSPC ******'''
 #                         cspcLine=self.data_cspc[i,:,Height].copy()
-#                         
-#                         
-#                           
+#
+#
+#
 #                         '''****** CSPC is normalized ******'''
 #                         chan_index0 = self.dataOut.pairsList[i][0]
-#                         chan_index1 = self.dataOut.pairsList[i][1]  
+#                         chan_index1 = self.dataOut.pairsList[i][1]
 #                         CSPCFactor= numpy.sum(ySamples[chan_index0]) * numpy.sum(ySamples[chan_index1])
-#                         
-#                         
+#
+#
 #                         CSPCNorm= cspcLine.copy() / numpy.sqrt(CSPCFactor)
-#                         
-#                         
+#
+#
 #                         CSPCSamples[i] = CSPCNorm-self.noise[i]
 #                         coherence[i] = numpy.abs(CSPCSamples[i]) / numpy.sqrt(CSPCFactor)
-#                           
+#
 #                         '''****** DC is removed ******'''
 #                         DC=Find(coherence[i],numpy.amax(coherence[i]))
 #                         coherence[i][DC]=(coherence[i][DC-1]+coherence[i][DC+1])/2
 #                         coherence[i]= moving_average(coherence[i],N=2)
-#                           
+#
 #                         phase[i] = moving_average( numpy.arctan2(CSPCSamples[i].imag, CSPCSamples[i].real),N=1)#*180/numpy.pi
-#                           
-#                       
+#
+#
 #                     '''****** Getting fij width ******'''
-#                        
+#
 #                     yMean=[]
-#                     yMean2=[]    
-#                   
+#                     yMean2=[]
+#
 #                     for j in range(len(ySamples[1])):
 #                         yMean=numpy.append(yMean,numpy.average([ySamples[0,j],ySamples[1,j],ySamples[2,j]]))
-#                       
+#
 #                     '''******* Getting fitting Gaussian ******'''
 #                     meanGauss=sum(xSamples*yMean) / len(xSamples)
 #                     sigma=sum(yMean*(xSamples-meanGauss)**2) / len(xSamples)
 #                     #print 'Height',Height,'SNR', meanGauss/sigma**2
-#                       
+#
 #                     if (abs(meanGauss/sigma**2) > 0.0001) :
-#                       
-#                         try:    
+#
+#                         try:
 #                             popt,pcov = curve_fit(gaus,xSamples,yMean,p0=[1,meanGauss,sigma])
-#                               
+#
 #                             if numpy.amax(popt)>numpy.amax(yMean)*0.3:
 #                                 FitGauss=gaus(xSamples,*popt)
-#                                   
-#                             else: 
+#
+#                             else:
 #                                 FitGauss=numpy.ones(len(xSamples))*numpy.mean(yMean)
 #                                 print 'Verificador:     Dentro', Height
 #                         except RuntimeError:
-#                               
+#
 #                             try:
 #                                 for j in range(len(ySamples[1])):
 #                                     yMean2=numpy.append(yMean2,numpy.average([ySamples[1,j],ySamples[2,j]]))
@@ -869,7 +904,7 @@ class BLTRSpectraReader (ProcessingUnit, FileHeaderBLTR, RecordHeaderBLTR, JRODa
 #                                 FitGauss=gaus(xSamples,*popt)
 #                                 print 'Verificador:     Exepcion1', Height
 #                             except RuntimeError:
-#                                   
+#
 #                                 try:
 #                                     popt,pcov = curve_fit(gaus,xSamples,ySamples[1],p0=[1,meanGauss,sigma])
 #                                     FitGauss=gaus(xSamples,*popt)
@@ -880,12 +915,12 @@ class BLTRSpectraReader (ProcessingUnit, FileHeaderBLTR, RecordHeaderBLTR, JRODa
 #                     else:
 #                         FitGauss=numpy.ones(len(xSamples))*numpy.mean(yMean)
 #                         #print 'Verificador:     Fuera', Height
-#                           
-#                                    
-#                                           
+#
+#
+#
 #                     Maximun=numpy.amax(yMean)
 #                     eMinus1=Maximun*numpy.exp(-1)
-#                       
+#
 #                     HWpos=Find(FitGauss,min(FitGauss, key=lambda value:abs(value-eMinus1)))
 #                     HalfWidth= xFrec[HWpos]
 #                     GCpos=Find(FitGauss, numpy.amax(FitGauss))
@@ -894,39 +929,39 @@ class BLTRSpectraReader (ProcessingUnit, FileHeaderBLTR, RecordHeaderBLTR, JRODa
 #                     #Vpos=Find(FactNorm, min(FactNorm, key=lambda value:abs(value- numpy.mean(FactNorm) )))
 #                     #print 'GCpos',GCpos, numpy.amax(FitGauss), 'HWpos',HWpos
 #                     '''****** Getting Fij ******'''
-#                       
+#
 #                     GaussCenter=xFrec[GCpos]
 #                     if (GaussCenter<0 and HalfWidth>0) or (GaussCenter>0 and HalfWidth<0):
 #                         Fij=abs(GaussCenter)+abs(HalfWidth)+0.0000001
 #                     else:
 #                         Fij=abs(GaussCenter-HalfWidth)+0.0000001
-#                       
+#
 #                     '''****** Getting Frecuency range of significant data ******'''
-#                       
+#
 #                     Rangpos=Find(FitGauss,min(FitGauss, key=lambda value:abs(value-Maximun*0.10)))
-#                       
+#
 #                     if Rangpos<GCpos:
 #                         Range=numpy.array([Rangpos,2*GCpos-Rangpos])
 #                     else:
 #                         Range=numpy.array([2*GCpos-Rangpos,Rangpos])
-#                       
+#
 #                     FrecRange=xFrec[Range[0]:Range[1]]
-#                       
+#
 #                     #print 'FrecRange', FrecRange
 #                     '''****** Getting SCPC Slope ******'''
-#                       
+#
 #                     for i in range(self.nRdPairs):
-#                           
+#
 #                         if len(FrecRange)>5 and len(FrecRange)<self.nProfiles*0.5:
-#                             PhaseRange=moving_average(phase[i,Range[0]:Range[1]],N=3) 
-#                           
+#                             PhaseRange=moving_average(phase[i,Range[0]:Range[1]],N=3)
+#
 #                             slope, intercept, r_value, p_value, std_err = stats.linregress(FrecRange,PhaseRange)
 #                             PhaseSlope[i]=slope
 #                             PhaseInter[i]=intercept
 #                         else:
 #                             PhaseSlope[i]=0
 #                             PhaseInter[i]=0
-#                           
+#
 #         #                     plt.figure(i+15)
 #         #                     plt.title('FASE ( CH%s*CH%s )' %(self.dataOut.pairsList[i][0],self.dataOut.pairsList[i][1]))
 #         #                     plt.xlabel('Frecuencia (KHz)')
@@ -934,76 +969,76 @@ class BLTRSpectraReader (ProcessingUnit, FileHeaderBLTR, RecordHeaderBLTR, JRODa
 #         #                     #plt.subplot(311+i)
 #         #                     plt.plot(FrecRange,PhaseRange,'b')
 #         #                     plt.plot(FrecRange,FrecRange*PhaseSlope[i]+PhaseInter[i],'r')
-#                           
+#
 #                         #plt.axis([-0.6, 0.2, -3.2, 3.2])
-#                            
-#                       
+#
+#
 #                     '''Getting constant C'''
 #                     cC=(Fij*numpy.pi)**2
-#                       
+#
 # #                     '''Getting Eij and Nij'''
 # #                     (AntennaX0,AntennaY0)=pol2cart(rheader.AntennaCoord0, rheader.AntennaAngl0*numpy.pi/180)
 # #                     (AntennaX1,AntennaY1)=pol2cart(rheader.AntennaCoord1, rheader.AntennaAngl1*numpy.pi/180)
 # #                     (AntennaX2,AntennaY2)=pol2cart(rheader.AntennaCoord2, rheader.AntennaAngl2*numpy.pi/180)
-# #                       
+# #
 # #                     E01=AntennaX0-AntennaX1
 # #                     N01=AntennaY0-AntennaY1
-# #                       
+# #
 # #                     E02=AntennaX0-AntennaX2
 # #                     N02=AntennaY0-AntennaY2
-# #                       
+# #
 # #                     E12=AntennaX1-AntennaX2
 # #                     N12=AntennaY1-AntennaY2
-#                       
+#
 #                     '''****** Getting constants F and G ******'''
 #                     MijEijNij=numpy.array([[E02,N02], [E12,N12]])
 #                     MijResult0=(-PhaseSlope[1]*cC) / (2*numpy.pi)
-#                     MijResult1=(-PhaseSlope[2]*cC) / (2*numpy.pi) 
+#                     MijResult1=(-PhaseSlope[2]*cC) / (2*numpy.pi)
 #                     MijResults=numpy.array([MijResult0,MijResult1])
 #                     (cF,cG) = numpy.linalg.solve(MijEijNij, MijResults)
-#                       
+#
 #                     '''****** Getting constants A, B and H ******'''
 #                     W01=numpy.amax(coherence[0])
 #                     W02=numpy.amax(coherence[1])
 #                     W12=numpy.amax(coherence[2])
-#                       
+#
 #                     WijResult0=((cF*E01+cG*N01)**2)/cC - numpy.log(W01 / numpy.sqrt(numpy.pi/cC))
 #                     WijResult1=((cF*E02+cG*N02)**2)/cC - numpy.log(W02 / numpy.sqrt(numpy.pi/cC))
 #                     WijResult2=((cF*E12+cG*N12)**2)/cC - numpy.log(W12 / numpy.sqrt(numpy.pi/cC))
-#                       
+#
 #                     WijResults=numpy.array([WijResult0, WijResult1, WijResult2])
-#                       
-#                     WijEijNij=numpy.array([ [E01**2, N01**2, 2*E01*N01] , [E02**2, N02**2, 2*E02*N02] , [E12**2, N12**2, 2*E12*N12] ])    
+#
+#                     WijEijNij=numpy.array([ [E01**2, N01**2, 2*E01*N01] , [E02**2, N02**2, 2*E02*N02] , [E12**2, N12**2, 2*E12*N12] ])
 #                     (cA,cB,cH) = numpy.linalg.solve(WijEijNij, WijResults)
-#                       
+#
 #                     VxVy=numpy.array([[cA,cH],[cH,cB]])
-#                       
+#
 #                     VxVyResults=numpy.array([-cF,-cG])
 #                     (Vx,Vy) = numpy.linalg.solve(VxVy, VxVyResults)
 #                     Vzon = Vy
 #                     Vmer = Vx
 #                     Vmag=numpy.sqrt(Vzon**2+Vmer**2)
 #                     Vang=numpy.arctan2(Vmer,Vzon)
-#                       
+#
 #                     if abs(Vy)<100 and abs(Vy)> 0.:
 #                         self.dataOut.velocityX=numpy.append(self.dataOut.velocityX, Vzon) #Vmag
 #                         #print 'Vmag',Vmag
 #                     else:
 #                         self.dataOut.velocityX=numpy.append(self.dataOut.velocityX, NaN)
-#                       
+#
 #                     if abs(Vx)<100 and abs(Vx) > 0.:
 #                         self.dataOut.velocityY=numpy.append(self.dataOut.velocityY, Vmer) #Vang
-#                         #print 'Vang',Vang 
+#                         #print 'Vang',Vang
 #                     else:
 #                         self.dataOut.velocityY=numpy.append(self.dataOut.velocityY, NaN)
-#                       
+#
 #                     if abs(GaussCenter)<2:
 #                         self.dataOut.velocityV=numpy.append(self.dataOut.velocityV, xFrec[Vpos])
-#                           
+#
 #                     else:
 #                         self.dataOut.velocityV=numpy.append(self.dataOut.velocityV, NaN)
-#                                   
-#                                   
+#
+#
 # #                 print '********************************************'
 # #                 print 'HalfWidth    ', HalfWidth
 # #                 print 'Maximun      ', Maximun
@@ -1033,25 +1068,25 @@ class BLTRSpectraReader (ProcessingUnit, FileHeaderBLTR, RecordHeaderBLTR, JRODa
 # #                 print 'PhaseSlope   ',PhaseSlope[2]
 # #                 print '********************************************'
 #                 #print 'data_output',shape(self.dataOut.velocityX), shape(self.dataOut.velocityY)
-#                   
+#
 #                 #print 'self.dataOut.velocityX', len(self.dataOut.velocityX)
 #                 #print 'self.dataOut.velocityY', len(self.dataOut.velocityY)
 #                 #print 'self.dataOut.velocityV', self.dataOut.velocityV
-#                   
+#
 #                 self.data_output[0]=numpy.array(self.dataOut.velocityX)
 #                 self.data_output[1]=numpy.array(self.dataOut.velocityY)
 #                 self.data_output[2]=numpy.array(self.dataOut.velocityV)
-#                   
+#
 #                 prin= self.data_output[0][~numpy.isnan(self.data_output[0])]
 #                 print ' '
-#                 print 'VmagAverage',numpy.mean(prin) 
+#                 print 'VmagAverage',numpy.mean(prin)
 #                 print ' '
 # #                 plt.figure(5)
 # #                 plt.subplot(211)
 # #                 plt.plot(self.dataOut.velocityX,'yo:')
 # #                 plt.subplot(212)
 # #                 plt.plot(self.dataOut.velocityY,'yo:')
-#   
+#
 # #                 plt.figure(1)
 # # #                 plt.subplot(121)
 # # #                plt.plot(xFrec,ySamples[0],'k',label='Ch0')
@@ -1060,7 +1095,7 @@ class BLTRSpectraReader (ProcessingUnit, FileHeaderBLTR, RecordHeaderBLTR, JRODa
 # # #                 plt.plot(xFrec,FitGauss,'yo:',label='fit')
 # # #                 plt.legend()
 # #                 plt.title('DATOS A ALTURA DE 2850 METROS')
-# #                 
+# #
 # #                 plt.xlabel('Frecuencia (KHz)')
 # #                 plt.ylabel('Magnitud')
 # # #                 plt.subplot(122)
@@ -1070,7 +1105,7 @@ class BLTRSpectraReader (ProcessingUnit, FileHeaderBLTR, RecordHeaderBLTR, JRODa
 # #                 plt.plot(xFrec,FactNorm)
 # #                 plt.axis([-4, 4, 0, 0.15])
 # # #                 plt.xlabel('SelfSpectra KHz')
-# # 
+# #
 # #                 plt.figure(10)
 # # #                 plt.subplot(121)
 # #                 plt.plot(xFrec,ySamples[0],'b',label='Ch0')
@@ -1079,7 +1114,7 @@ class BLTRSpectraReader (ProcessingUnit, FileHeaderBLTR, RecordHeaderBLTR, JRODa
 # # #                plt.plot(xFrec,FitGauss,'yo:',label='fit')
 # #                 plt.legend()
 # #                 plt.title('SELFSPECTRA EN CANALES')
-# #                 
+# #
 # #                 plt.xlabel('Frecuencia (KHz)')
 # #                 plt.ylabel('Magnitud')
 # # #                 plt.subplot(122)
@@ -1089,19 +1124,19 @@ class BLTRSpectraReader (ProcessingUnit, FileHeaderBLTR, RecordHeaderBLTR, JRODa
 # # #                plt.plot(xFrec,FactNorm)
 # # #                plt.axis([-4, 4, 0, 0.15])
 # # #                 plt.xlabel('SelfSpectra KHz')
-# # 
+# #
 # #                 plt.figure(9)
-# #                 
-# #                 
+# #
+# #
 # #                 plt.title('DATOS SUAVIZADOS')
 # #                 plt.xlabel('Frecuencia (KHz)')
 # #                 plt.ylabel('Magnitud')
 # #                 plt.plot(xFrec,SmoothSPC,'g')
-# #                 
+# #
 # #                 #plt.plot(xFrec,FactNorm)
 # #                 plt.axis([-4, 4, 0, 0.15])
 # # #                 plt.xlabel('SelfSpectra KHz')
-# # #                   
+# # #
 # #                 plt.figure(2)
 # # #                 #plt.subplot(121)
 # #                 plt.plot(xFrec,yMean,'r',label='Mean SelfSpectra')
@@ -1115,7 +1150,7 @@ class BLTRSpectraReader (ProcessingUnit, FileHeaderBLTR, RecordHeaderBLTR, JRODa
 # #                 plt.xlabel('Frecuencia (KHz)')
 # #                 plt.ylabel('Magnitud')
 # #                 plt.legend()
-# # #                   
+# # #
 # # #                 plt.figure(3)
 # # #                 plt.subplot(311)
 # # #                 #plt.plot(xFrec,phase[0])
@@ -1125,30 +1160,23 @@ class BLTRSpectraReader (ProcessingUnit, FileHeaderBLTR, RecordHeaderBLTR, JRODa
 # # #                 plt.subplot(313)
 # # #                 plt.plot(xFrec,phase[2],'g')
 # # #                 #plt.plot(xFrec,phase[2])
-# # #                   
+# # #
 # # #                 plt.figure(4)
-# # #                   
+# # #
 # # #                 plt.plot(xSamples,coherence[0],'b')
 # # #                 plt.plot(xSamples,coherence[1],'r')
 # # #                 plt.plot(xSamples,coherence[2],'g')
 # #                 plt.show()
-# # #                   
+# # #
 # # #                 plt.clf()
 # # #                 plt.cla()
-# # #                 plt.close()    
-#                   
-#                 print ' ' 
-                
-                
-                
-            self.BlockCounter+=2
-            
+# # #                 plt.close()
+#
+#                 print ' '
+
+            self.BlockCounter += 2
+
         else:
-            self.fileSelector+=1    
-            self.BlockCounter=0
+            self.fileSelector += 1
+            self.BlockCounter = 0
             print "Next File"
-        
-        
-        
-
-    
diff --git a/schainpy/model/io/jroIO_mira35c.py b/schainpy/model/io/jroIO_mira35c.py
index 632bc93..684b106 100644
--- a/schainpy/model/io/jroIO_mira35c.py
+++ b/schainpy/model/io/jroIO_mira35c.py
@@ -1,4 +1,5 @@
-import os, sys
+import os
+import sys
 import glob
 import fnmatch
 import datetime
@@ -6,11 +7,9 @@ import time
 import re
 import h5py
 import numpy
-import matplotlib.pyplot as plt
 
-import pylab as plb
 from scipy.optimize import curve_fit
-from scipy import asarray as ar,exp
+from scipy import asarray as ar, exp
 from scipy import stats
 
 from numpy.ma.core import getdata
@@ -30,152 +29,168 @@ from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
 from numpy import imag, shape, NaN, empty
 
 
-
 class Header(object):
-    
+
     def __init__(self):
         raise NotImplementedError
-    
-   
+
     def read(self):
-        
+
         raise NotImplementedError
-    
+
     def write(self):
-        
+
         raise NotImplementedError
-    
+
     def printInfo(self):
-        
-        message = "#"*50 + "\n"
+
+        message = "#" * 50 + "\n"
         message += self.__class__.__name__.upper() + "\n"
-        message += "#"*50 + "\n"
-        
+        message += "#" * 50 + "\n"
+
         keyList = self.__dict__.keys()
         keyList.sort()
-        
+
         for key in keyList:
-            message += "%s = %s" %(key, self.__dict__[key]) + "\n"
-        
+            message += "%s = %s" % (key, self.__dict__[key]) + "\n"
+
         if "size" not in keyList:
             attr = getattr(self, "size")
-            
+
             if attr:
-                message += "%s = %s" %("size", attr) + "\n"
-        
-        #print message
-
-
-FILE_HEADER = numpy.dtype([          #HEADER 1024bytes
-                          ('Hname','a32'),      #Original file name
-                          ('Htime',numpy.str_,32),      #Date and time when the file was created
-                          ('Hoper',numpy.str_,64),      #Name of operator who created the file
-                          ('Hplace',numpy.str_,128),    #Place where the measurements was carried out
-                          ('Hdescr',numpy.str_,256),    #Description of measurements
-                          ('Hdummy',numpy.str_,512),    #Reserved space 
-                          #Main chunk 8bytes
-                          ('Msign',numpy.str_,4),       #Main chunk signature FZKF or NUIG
-                          ('MsizeData','<i4'),      #Size of data block main chunk
-                          #Processing DSP parameters 36bytes
-                          ('PPARsign',numpy.str_,4),       #PPAR signature
-                          ('PPARsize','<i4'),       #PPAR size of block
-                          ('PPARprf','<i4'),        #Pulse repetition frequency
-                          ('PPARpdr','<i4'),        #Pulse duration
-                          ('PPARsft','<i4'),        #FFT length
-                          ('PPARavc','<i4'),        #Number of spectral (in-coherent) averages
-                          ('PPARihp','<i4'),        #Number of lowest range gate for moment estimation
-                          ('PPARchg','<i4'),        #Count for gates for moment estimation
-                          ('PPARpol','<i4'),        #switch on/off polarimetric measurements. Should be 1.
-                          #Service DSP parameters 112bytes
-                          ('SPARatt','<i4'),       #STC attenuation on the lowest ranges on/off
-                          ('SPARtx','<i4'),        #OBSOLETE
-                          ('SPARaddGain0','<f4'),  #OBSOLETE
-                          ('SPARaddGain1','<f4'),  #OBSOLETE
-                          ('SPARwnd','<i4'),     #Debug only. It normal mode it is 0.
-                          ('SPARpos','<i4'),     #Delay between sync pulse and tx pulse for phase corr, ns
-                          ('SPARadd','<i4'),     #"add to pulse" to compensate for delay between the leading edge of driver pulse and envelope of the RF signal.
-                          ('SPARlen','<i4'),     #Time for measuring txn pulse phase. OBSOLETE
-                          ('SPARcal','<i4'),     #OBSOLETE
-                          ('SPARnos','<i4'),     #OBSOLETE
-                          ('SPARof0','<i4'),     #detection threshold
-                          ('SPARof1','<i4'),     #OBSOLETE
-                          ('SPARswt','<i4'),     #2nd moment estimation threshold
-                          ('SPARsum','<i4'),     #OBSOLETE
-                          ('SPARosc','<i4'),     #flag Oscillosgram mode
-                          ('SPARtst','<i4'),     #OBSOLETE
-                          ('SPARcor','<i4'),     #OBSOLETE
-                          ('SPARofs','<i4'),     #OBSOLETE
-                          ('SPARhsn','<i4'),     #Hildebrand div noise detection on noise gate
-                          ('SPARhsa','<f4'),     #Hildebrand div noise detection on all gates
-                          ('SPARcalibPow_M','<f4'),   #OBSOLETE
-                          ('SPARcalibSNR_M','<f4'),   #OBSOLETE
-                          ('SPARcalibPow_S','<f4'),   #OBSOLETE
-                          ('SPARcalibSNR_S','<f4'),   #OBSOLETE
-                          ('SPARrawGate1','<i4'),     #Lowest range gate for spectra saving Raw_Gate1 >=5
-                          ('SPARrawGate2','<i4'),     #Number of range gates with atmospheric signal
-                          ('SPARraw','<i4'),          #flag - IQ or spectra saving on/off
-                          ('SPARprc','<i4'),])        #flag - Moment estimation switched on/off
-                            
-                          
-                          
+                message += "%s = %s" % ("size", attr) + "\n"
+
+        # print message
+
+
+FILE_HEADER = numpy.dtype([  # HEADER 1024bytes
+                          ('Hname', 'a32'),  # Original file name
+                          # Date and time when the file was created
+                          ('Htime', numpy.str_, 32),
+                          # Name of operator who created the file
+                          ('Hoper', numpy.str_, 64),
+                          # Place where the measurements was carried out
+                          ('Hplace', numpy.str_, 128),
+                          # Description of measurements
+                          ('Hdescr', numpy.str_, 256),
+                          ('Hdummy', numpy.str_, 512),  # Reserved space
+                          # Main chunk 8bytes
+                          # Main chunk signature FZKF or NUIG
+                          ('Msign', numpy.str_, 4),
+                          ('MsizeData', '<i4'),  # Size of data block main chunk
+                          # Processing DSP parameters 36bytes
+                          ('PPARsign', numpy.str_, 4),  # PPAR signature
+                          ('PPARsize', '<i4'),  # PPAR size of block
+                          ('PPARprf', '<i4'),  # Pulse repetition frequency
+                          ('PPARpdr', '<i4'),  # Pulse duration
+                          ('PPARsft', '<i4'),  # FFT length
+                          # Number of spectral (in-coherent) averages
+                          ('PPARavc', '<i4'),
+                          # Number of lowest range gate for moment estimation
+                          ('PPARihp', '<i4'),
+                          # Count for gates for moment estimation
+                          ('PPARchg', '<i4'),
+                          # switch on/off polarimetric measurements. Should be 1.
+                          ('PPARpol', '<i4'),
+                          # Service DSP parameters 112bytes
+                          # STC attenuation on the lowest ranges on/off
+                          ('SPARatt', '<i4'),
+                          ('SPARtx', '<i4'),  # OBSOLETE
+                          ('SPARaddGain0', '<f4'),  # OBSOLETE
+                          ('SPARaddGain1', '<f4'),  # OBSOLETE
+                          # Debug only. It normal mode it is 0.
+                          ('SPARwnd', '<i4'),
+                          # Delay between sync pulse and tx pulse for phase corr, ns
+                          ('SPARpos', '<i4'),
+                          # "add to pulse" to compensate for delay between the leading edge of driver pulse and envelope of the RF signal.
+                          ('SPARadd', '<i4'),
+                          # Time for measuring txn pulse phase. OBSOLETE
+                          ('SPARlen', '<i4'),
+                          ('SPARcal', '<i4'),  # OBSOLETE
+                          ('SPARnos', '<i4'),  # OBSOLETE
+                          ('SPARof0', '<i4'),  # detection threshold
+                          ('SPARof1', '<i4'),  # OBSOLETE
+                          ('SPARswt', '<i4'),  # 2nd moment estimation threshold
+                          ('SPARsum', '<i4'),  # OBSOLETE
+                          ('SPARosc', '<i4'),  # flag Oscillosgram mode
+                          ('SPARtst', '<i4'),  # OBSOLETE
+                          ('SPARcor', '<i4'),  # OBSOLETE
+                          ('SPARofs', '<i4'),  # OBSOLETE
+                          # Hildebrand div noise detection on noise gate
+                          ('SPARhsn', '<i4'),
+                          # Hildebrand div noise detection on all gates
+                          ('SPARhsa', '<f4'),
+                          ('SPARcalibPow_M', '<f4'),  # OBSOLETE
+                          ('SPARcalibSNR_M', '<f4'),  # OBSOLETE
+                          ('SPARcalibPow_S', '<f4'),  # OBSOLETE
+                          ('SPARcalibSNR_S', '<f4'),  # OBSOLETE
+                          # Lowest range gate for spectra saving Raw_Gate1 >=5
+                          ('SPARrawGate1', '<i4'),
+                          # Number of range gates with atmospheric signal
+                          ('SPARrawGate2', '<i4'),
+                          # flag - IQ or spectra saving on/off
+                          ('SPARraw', '<i4'),
+                          ('SPARprc', '<i4'), ])  # flag - Moment estimation switched on/off
+
+
 class FileHeaderMIRA35c(Header):
-    
+
     def __init__(self):
-        
-        self.Hname= None     
-        self.Htime= None
-        self.Hoper= None
-        self.Hplace= None
-        self.Hdescr= None
-        self.Hdummy= None
-        
-        self.Msign=None
-        self.MsizeData=None
-                          
-        self.PPARsign=None
-        self.PPARsize=None
-        self.PPARprf=None
-        self.PPARpdr=None
-        self.PPARsft=None
-        self.PPARavc=None
-        self.PPARihp=None
-        self.PPARchg=None
-        self.PPARpol=None
-        #Service DSP parameters
-        self.SPARatt=None
-        self.SPARtx=None
-        self.SPARaddGain0=None
-        self.SPARaddGain1=None
-        self.SPARwnd=None
-        self.SPARpos=None
-        self.SPARadd=None
-        self.SPARlen=None
-        self.SPARcal=None
-        self.SPARnos=None
-        self.SPARof0=None
-        self.SPARof1=None
-        self.SPARswt=None
-        self.SPARsum=None
-        self.SPARosc=None
-        self.SPARtst=None
-        self.SPARcor=None
-        self.SPARofs=None
-        self.SPARhsn=None
-        self.SPARhsa=None
-        self.SPARcalibPow_M=None
-        self.SPARcalibSNR_M=None
-        self.SPARcalibPow_S=None
-        self.SPARcalibSNR_S=None
-        self.SPARrawGate1=None
-        self.SPARrawGate2=None
-        self.SPARraw=None
-        self.SPARprc=None 
-        
-        self.FHsize=1180
-        
+
+        self.Hname = None
+        self.Htime = None
+        self.Hoper = None
+        self.Hplace = None
+        self.Hdescr = None
+        self.Hdummy = None
+
+        self.Msign = None
+        self.MsizeData = None
+
+        self.PPARsign = None
+        self.PPARsize = None
+        self.PPARprf = None
+        self.PPARpdr = None
+        self.PPARsft = None
+        self.PPARavc = None
+        self.PPARihp = None
+        self.PPARchg = None
+        self.PPARpol = None
+        # Service DSP parameters
+        self.SPARatt = None
+        self.SPARtx = None
+        self.SPARaddGain0 = None
+        self.SPARaddGain1 = None
+        self.SPARwnd = None
+        self.SPARpos = None
+        self.SPARadd = None
+        self.SPARlen = None
+        self.SPARcal = None
+        self.SPARnos = None
+        self.SPARof0 = None
+        self.SPARof1 = None
+        self.SPARswt = None
+        self.SPARsum = None
+        self.SPARosc = None
+        self.SPARtst = None
+        self.SPARcor = None
+        self.SPARofs = None
+        self.SPARhsn = None
+        self.SPARhsa = None
+        self.SPARcalibPow_M = None
+        self.SPARcalibSNR_M = None
+        self.SPARcalibPow_S = None
+        self.SPARcalibSNR_S = None
+        self.SPARrawGate1 = None
+        self.SPARrawGate2 = None
+        self.SPARraw = None
+        self.SPARprc = None
+
+        self.FHsize = 1180
+
     def FHread(self, fp):
-        
-        header = numpy.fromfile(fp, FILE_HEADER,1)
+
+        header = numpy.fromfile(fp, FILE_HEADER, 1)
         '''      numpy.fromfile(file, dtype, count, sep='')
             file : file or str
             Open file object or filename.
@@ -194,85 +209,83 @@ class FileHeaderMIRA35c(Header):
             at least one whitespace.
             
     '''
-        
-        
-        self.Hname= str(header['Hname'][0])     
-        self.Htime= str(header['Htime'][0])
-        self.Hoper= str(header['Hoper'][0])
-        self.Hplace= str(header['Hplace'][0])
-        self.Hdescr= str(header['Hdescr'][0])
-        self.Hdummy= str(header['Hdummy'][0])
-        #1024
-        
-        self.Msign=str(header['Msign'][0])  
-        self.MsizeData=header['MsizeData'][0]
-        #8
-        
-        self.PPARsign=str(header['PPARsign'][0])
-        self.PPARsize=header['PPARsize'][0]
-        self.PPARprf=header['PPARprf'][0]
-        self.PPARpdr=header['PPARpdr'][0]
-        self.PPARsft=header['PPARsft'][0]
-        self.PPARavc=header['PPARavc'][0]
-        self.PPARihp=header['PPARihp'][0]
-        self.PPARchg=header['PPARchg'][0]
-        self.PPARpol=header['PPARpol'][0]
-        #Service DSP parameters
-        #36
-        
-        self.SPARatt=header['SPARatt'][0]
-        self.SPARtx=header['SPARtx'][0]
-        self.SPARaddGain0=header['SPARaddGain0'][0]
-        self.SPARaddGain1=header['SPARaddGain1'][0]
-        self.SPARwnd=header['SPARwnd'][0]
-        self.SPARpos=header['SPARpos'][0]
-        self.SPARadd=header['SPARadd'][0]
-        self.SPARlen=header['SPARlen'][0]
-        self.SPARcal=header['SPARcal'][0]
-        self.SPARnos=header['SPARnos'][0]
-        self.SPARof0=header['SPARof0'][0]
-        self.SPARof1=header['SPARof1'][0]
-        self.SPARswt=header['SPARswt'][0]
-        self.SPARsum=header['SPARsum'][0]
-        self.SPARosc=header['SPARosc'][0]
-        self.SPARtst=header['SPARtst'][0]
-        self.SPARcor=header['SPARcor'][0]
-        self.SPARofs=header['SPARofs'][0]
-        self.SPARhsn=header['SPARhsn'][0]
-        self.SPARhsa=header['SPARhsa'][0]
-        self.SPARcalibPow_M=header['SPARcalibPow_M'][0]
-        self.SPARcalibSNR_M=header['SPARcalibSNR_M'][0]
-        self.SPARcalibPow_S=header['SPARcalibPow_S'][0]
-        self.SPARcalibSNR_S=header['SPARcalibSNR_S'][0]
-        self.SPARrawGate1=header['SPARrawGate1'][0]
-        self.SPARrawGate2=header['SPARrawGate2'][0]
-        self.SPARraw=header['SPARraw'][0]
-        self.SPARprc=header['SPARprc'][0]
-        #112
-        #1180
-        #print 'Pointer fp header', fp.tell()
-        #print ' '
-        #print 'SPARrawGate'
-        #print self.SPARrawGate2 - self.SPARrawGate1
-        
-        #print ' '
-        #print 'Hname'
-        #print self.Hname
-        
-        #print ' '
-        #print 'Msign'
-        #print self.Msign
-    
+
+        self.Hname = str(header['Hname'][0])
+        self.Htime = str(header['Htime'][0])
+        self.Hoper = str(header['Hoper'][0])
+        self.Hplace = str(header['Hplace'][0])
+        self.Hdescr = str(header['Hdescr'][0])
+        self.Hdummy = str(header['Hdummy'][0])
+        # 1024
+
+        self.Msign = str(header['Msign'][0])
+        self.MsizeData = header['MsizeData'][0]
+        # 8
+
+        self.PPARsign = str(header['PPARsign'][0])
+        self.PPARsize = header['PPARsize'][0]
+        self.PPARprf = header['PPARprf'][0]
+        self.PPARpdr = header['PPARpdr'][0]
+        self.PPARsft = header['PPARsft'][0]
+        self.PPARavc = header['PPARavc'][0]
+        self.PPARihp = header['PPARihp'][0]
+        self.PPARchg = header['PPARchg'][0]
+        self.PPARpol = header['PPARpol'][0]
+        # Service DSP parameters
+        # 36
+
+        self.SPARatt = header['SPARatt'][0]
+        self.SPARtx = header['SPARtx'][0]
+        self.SPARaddGain0 = header['SPARaddGain0'][0]
+        self.SPARaddGain1 = header['SPARaddGain1'][0]
+        self.SPARwnd = header['SPARwnd'][0]
+        self.SPARpos = header['SPARpos'][0]
+        self.SPARadd = header['SPARadd'][0]
+        self.SPARlen = header['SPARlen'][0]
+        self.SPARcal = header['SPARcal'][0]
+        self.SPARnos = header['SPARnos'][0]
+        self.SPARof0 = header['SPARof0'][0]
+        self.SPARof1 = header['SPARof1'][0]
+        self.SPARswt = header['SPARswt'][0]
+        self.SPARsum = header['SPARsum'][0]
+        self.SPARosc = header['SPARosc'][0]
+        self.SPARtst = header['SPARtst'][0]
+        self.SPARcor = header['SPARcor'][0]
+        self.SPARofs = header['SPARofs'][0]
+        self.SPARhsn = header['SPARhsn'][0]
+        self.SPARhsa = header['SPARhsa'][0]
+        self.SPARcalibPow_M = header['SPARcalibPow_M'][0]
+        self.SPARcalibSNR_M = header['SPARcalibSNR_M'][0]
+        self.SPARcalibPow_S = header['SPARcalibPow_S'][0]
+        self.SPARcalibSNR_S = header['SPARcalibSNR_S'][0]
+        self.SPARrawGate1 = header['SPARrawGate1'][0]
+        self.SPARrawGate2 = header['SPARrawGate2'][0]
+        self.SPARraw = header['SPARraw'][0]
+        self.SPARprc = header['SPARprc'][0]
+        # 112
+        # 1180
+        # print 'Pointer fp header', fp.tell()
+        # print ' '
+        # print 'SPARrawGate'
+        # print self.SPARrawGate2 - self.SPARrawGate1
+
+        # print ' '
+        # print 'Hname'
+        # print self.Hname
+
+        # print ' '
+        # print 'Msign'
+        # print self.Msign
+
     def write(self, fp):
-        
+
         headerTuple = (self.Hname,
                        self.Htime,
                        self.Hoper,
                        self.Hplace,
                        self.Hdescr,
                        self.Hdummy)
-             
-                       
+
         header = numpy.array(headerTuple, FILE_HEADER)
         #        numpy.array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)
         header.tofile(fp)
@@ -290,72 +303,70 @@ class FileHeaderMIRA35c(Header):
         first converting it to the closest Python type, and then using "format" % item.
 
         '''
-        
+
         return 1
 
-SRVI_HEADER = numpy.dtype([         
-                         ('SignatureSRVI1',numpy.str_,4),#
-                         ('SizeOfDataBlock1','<i4'),#
-                         ('DataBlockTitleSRVI1',numpy.str_,4),#
-                         ('SizeOfSRVI1','<i4'),])#
-    
-class SRVIHeader(Header):      
+
+SRVI_HEADER = numpy.dtype([
+                         ('SignatureSRVI1', numpy.str_, 4),
+                         ('SizeOfDataBlock1', '<i4'),
+                         ('DataBlockTitleSRVI1', numpy.str_, 4),
+                         ('SizeOfSRVI1', '<i4'), ])
+
+
+class SRVIHeader(Header):
     def __init__(self,     SignatureSRVI1=0,     SizeOfDataBlock1=0,     DataBlockTitleSRVI1=0,    SizeOfSRVI1=0):
-        
+
         self.SignatureSRVI1 = SignatureSRVI1
         self.SizeOfDataBlock1 = SizeOfDataBlock1
         self.DataBlockTitleSRVI1 = DataBlockTitleSRVI1
-        self.SizeOfSRVI1 = SizeOfSRVI1   
-        
-        self.SRVIHsize=16
-        
-    def SRVIread(self, fp): 
-        
-        header = numpy.fromfile(fp, SRVI_HEADER,1)
+        self.SizeOfSRVI1 = SizeOfSRVI1
+
+        self.SRVIHsize = 16
+
+    def SRVIread(self, fp):
+
+        header = numpy.fromfile(fp, SRVI_HEADER, 1)
 
         self.SignatureSRVI1 = str(header['SignatureSRVI1'][0])
         self.SizeOfDataBlock1 = header['SizeOfDataBlock1'][0]
         self.DataBlockTitleSRVI1 = str(header['DataBlockTitleSRVI1'][0])
         self.SizeOfSRVI1 = header['SizeOfSRVI1'][0]
-        #16
+        # 16
         print 'Pointer fp SRVIheader', fp.tell()
-        
-
-SRVI_STRUCTURE = numpy.dtype([         
-                            ('frame_cnt','<u4'),#
-                            ('time_t','<u4'),   #
-                            ('tpow','<f4'),     #
-                            ('npw1','<f4'),     #
-                            ('npw2','<f4'),     #
-                            ('cpw1','<f4'),     #
-                            ('pcw2','<f4'),     #
-                            ('ps_err','<u4'),   #
-                            ('te_err','<u4'),   #
-                            ('rc_err','<u4'),   #
-                            ('grs1','<u4'),     #
-                            ('grs2','<u4'),     #
-                            ('azipos','<f4'),     #
-                            ('azivel','<f4'),     #
-                            ('elvpos','<f4'),     #
-                            ('elvvel','<f4'),     #
-                            ('northAngle','<f4'), #
-                            ('microsec','<u4'),   #
-                            ('azisetvel','<f4'),  #
-                            ('elvsetpos','<f4'),  #
-                            ('RadarConst','<f4'),])   # 
 
 
+SRVI_STRUCTURE = numpy.dtype([
+                            ('frame_cnt', '<u4'),
+                            ('time_t', '<u4'),   #
+                            ('tpow', '<f4'),     #
+                            ('npw1', '<f4'),     #
+                            ('npw2', '<f4'),     #
+                            ('cpw1', '<f4'),     #
+                            ('pcw2', '<f4'),     #
+                            ('ps_err', '<u4'),   #
+                            ('te_err', '<u4'),   #
+                            ('rc_err', '<u4'),   #
+                            ('grs1', '<u4'),     #
+                            ('grs2', '<u4'),     #
+                            ('azipos', '<f4'),     #
+                            ('azivel', '<f4'),     #
+                            ('elvpos', '<f4'),     #
+                            ('elvvel', '<f4'),     #
+                            ('northAngle', '<f4'),
+                            ('microsec', '<u4'),   #
+                            ('azisetvel', '<f4'),  #
+                            ('elvsetpos', '<f4'),  #
+                            ('RadarConst', '<f4'), ])   #
 
 
 class RecordHeader(Header):
-    
-    
-    def __init__(self,     frame_cnt=0,  time_t= 0,  tpow=0,   npw1=0,   npw2=0,   
-                 cpw1=0,   pcw2=0,       ps_err=0,   te_err=0,   rc_err=0,   grs1=0,   
-                 grs2=0,   azipos=0,   azivel=0,   elvpos=0,   elvvel=0,   northangle=0,   
-                 microsec=0,   azisetvel=0,   elvsetpos=0,   RadarConst=0 , RecCounter=0, Off2StartNxtRec=0):
-        
-        
+
+    def __init__(self,     frame_cnt=0,  time_t=0,  tpow=0,   npw1=0,   npw2=0,
+                 cpw1=0,   pcw2=0,       ps_err=0,   te_err=0,   rc_err=0,   grs1=0,
+                 grs2=0,   azipos=0,   azivel=0,   elvpos=0,   elvvel=0,   northangle=0,
+                 microsec=0,   azisetvel=0,   elvsetpos=0,   RadarConst=0, RecCounter=0, Off2StartNxtRec=0):
+
         self.frame_cnt = frame_cnt
         self.dwell = time_t
         self.tpow = tpow
@@ -377,22 +388,22 @@ class RecordHeader(Header):
         self.azisetvel = azisetvel
         self.elvsetpos = elvsetpos
         self.RadarConst = RadarConst
-        self.RHsize=84
+        self.RHsize = 84
         self.RecCounter = RecCounter
-        self.Off2StartNxtRec=Off2StartNxtRec
-    
+        self.Off2StartNxtRec = Off2StartNxtRec
+
     def RHread(self, fp):
-        
-        #startFp = open(fp,"rb") #The method tell() returns the current position of the file read/write pointer within the file.
-        
+
+        # startFp = open(fp,"rb") #The method tell() returns the current position of the file read/write pointer within the file.
+
         #OffRHeader= 1180 + self.RecCounter*(self.Off2StartNxtRec)
         #startFp.seek(OffRHeader, os.SEEK_SET)
-        
-        #print 'Posicion del bloque:        ',OffRHeader
-        
-        header = numpy.fromfile(fp,SRVI_STRUCTURE,1)
-        
-        self.frame_cnt = header['frame_cnt'][0]#
+
+        # print 'Posicion del bloque:        ',OffRHeader
+
+        header = numpy.fromfile(fp, SRVI_STRUCTURE, 1)
+
+        self.frame_cnt = header['frame_cnt'][0]
         self.time_t = header['time_t'][0]   #
         self.tpow = header['tpow'][0]     #
         self.npw1 = header['npw1'][0]     #
@@ -413,26 +424,26 @@ class RecordHeader(Header):
         self.azisetvel = header['azisetvel'][0]     #
         self.elvsetpos = header['elvsetpos'][0]     #
         self.RadarConst = header['RadarConst'][0]    #
-        #84
-        
-        #print 'Pointer fp RECheader', fp.tell()
-        
+        # 84
+
+        # print 'Pointer fp RECheader', fp.tell()
+
         #self.ipp= 0.5*(SPEED_OF_LIGHT/self.PRFhz)
-        
+
         #self.RHsize = 180+20*self.nChannels
         #self.Datasize= self.nProfiles*self.nChannels*self.nHeights*2*4
-        #print 'Datasize',self.Datasize
+        # print 'Datasize',self.Datasize
         #endFp = self.OffsetStartHeader + self.RecCounter*self.Off2StartNxtRec
-        
+
         print '=============================================='
-        
+
         print '=============================================='
 
-        
         return 1
-    
-class MIRA35CReader (ProcessingUnit,FileHeaderMIRA35c,SRVIHeader,RecordHeader):
-    
+
+
+class MIRA35CReader (ProcessingUnit, FileHeaderMIRA35c, SRVIHeader, RecordHeader):
+
     path = None
     startDate = None
     endDate = None
@@ -440,87 +451,84 @@ class MIRA35CReader (ProcessingUnit,FileHeaderMIRA35c,SRVIHeader,RecordHeader):
     endTime = None
     walk = None
     isConfig = False
-    
-    
-    fileList= None
-    
-    #metadata
-    TimeZone= None
-    Interval= None
-    heightList= None
-    
-    #data
-    data= None
-    utctime= None
-    
-    
-    
-    def __init__(self, **kwargs):    
-        
-        #Eliminar de la base la herencia
+
+    fileList = None
+
+    # metadata
+    TimeZone = None
+    Interval = None
+    heightList = None
+
+    # data
+    data = None
+    utctime = None
+
+    def __init__(self, **kwargs):
+
+        # Eliminar de la base la herencia
         ProcessingUnit.__init__(self, **kwargs)
         self.PointerReader = 0
         self.FileHeaderFlag = False
         self.utc = None
         self.ext = ".zspca"
         self.optchar = "P"
-        self.fpFile=None
+        self.fpFile = None
         self.fp = None
-        self.BlockCounter=0
+        self.BlockCounter = 0
         self.dtype = None
         self.fileSizeByHeader = None
         self.filenameList = []
         self.fileSelector = 0
-        self.Off2StartNxtRec=0
-        self.RecCounter=0
+        self.Off2StartNxtRec = 0
+        self.RecCounter = 0
         self.flagNoMoreFiles = 0
-        self.data_spc=None
-        #self.data_cspc=None
-        self.data_output=None
+        self.data_spc = None
+        # self.data_cspc=None
+        self.data_output = None
         self.path = None
-        self.OffsetStartHeader=0
-        self.Off2StartData=0
+        self.OffsetStartHeader = 0
+        self.Off2StartData = 0
         self.ipp = 0
-        self.nFDTdataRecors=0
+        self.nFDTdataRecors = 0
         self.blocksize = 0
         self.dataOut = Spectra()
-        self.profileIndex = 1 #Always
-        self.dataOut.flagNoData=False
+        self.profileIndex = 1  # Always
+        self.dataOut.flagNoData = False
         self.dataOut.nRdPairs = 0
         self.dataOut.pairsList = []
-        self.dataOut.data_spc=None
-        
-        self.dataOut.normFactor=1
+        self.dataOut.data_spc = None
+
+        self.dataOut.normFactor = 1
         self.nextfileflag = True
         self.dataOut.RadarConst = 0
         self.dataOut.HSDV = []
         self.dataOut.NPW = []
         self.dataOut.COFA = []
         self.dataOut.noise = 0
-    
-    
+
     def Files2Read(self, fp):
         ''' 
         Function that indicates the number of .fdt files that exist in the folder to be read.
         It also creates an organized list with the names of the files to read.
         '''
-        #self.__checkPath()
-        
-        ListaData=os.listdir(fp)    #Gets the list of files within the fp address
-        ListaData=sorted(ListaData) #Sort the list of files from least to largest by names
-        nFiles=0                    #File Counter
-        FileList=[]                 #A list is created that will contain the .fdt files
-        for IndexFile in ListaData :
-            if  '.zspca' in IndexFile and '.gz' not in IndexFile:
+        # self.__checkPath()
+
+        # Gets the list of files within the fp address
+        ListaData = os.listdir(fp)
+        # Sort the list of files from least to largest by names
+        ListaData = sorted(ListaData)
+        nFiles = 0  # File Counter
+        FileList = []  # A list is created that will contain the .fdt files
+        for IndexFile in ListaData:
+            if '.zspca' in IndexFile and '.gz' not in IndexFile:
                 FileList.append(IndexFile)
-                nFiles+=1
-        
-        #print 'Files2Read'
-        #print 'Existen '+str(nFiles)+' archivos .fdt' 
-        
-        self.filenameList=FileList #List of files from least to largest by names
-        
-    
+                nFiles += 1
+
+        # print 'Files2Read'
+        # print 'Existen '+str(nFiles)+' archivos .fdt'
+
+        self.filenameList = FileList  # List of files from least to largest by names
+
     def run(self, **kwargs):
         '''
         This method will be the one that will initiate the data entry, will be called constantly.
@@ -530,274 +538,265 @@ class MIRA35CReader (ProcessingUnit,FileHeaderMIRA35c,SRVIHeader,RecordHeader):
         if not self.isConfig:
             self.setup(**kwargs)
             self.isConfig = True
-            
+
         self.getData()
-    
-    
+
     def setup(self, path=None,
-                    startDate=None, 
-                    endDate=None, 
-                    startTime=None, 
-                    endTime=None,
-                    walk=True,
-                    timezone='utc',
-                    code = None,
-                    online=False,
-                    ReadMode=None, **kwargs):
-        
+              startDate=None,
+              endDate=None,
+              startTime=None,
+              endTime=None,
+              walk=True,
+              timezone='utc',
+              code=None,
+              online=False,
+              ReadMode=None, **kwargs):
+
         self.isConfig = True
-        
-        self.path=path 
-        self.startDate=startDate
-        self.endDate=endDate
-        self.startTime=startTime 
-        self.endTime=endTime
-        self.walk=walk 
-        #self.ReadMode=int(ReadMode)
-        
+
+        self.path = path
+        self.startDate = startDate
+        self.endDate = endDate
+        self.startTime = startTime
+        self.endTime = endTime
+        self.walk = walk
+        # self.ReadMode=int(ReadMode)
+
         pass
-    
-    
+
     def getData(self):
         '''
         Before starting this function, you should check that there is still an unread file,
         If there are still blocks to read or if the data block is empty.
-        
+
         You should call the file "read".
-        
+
         '''
-        
+
         if self.flagNoMoreFiles:
             self.dataOut.flagNoData = True
             print 'NoData se vuelve true'
             return 0
-        
-        self.fp=self.path
+
+        self.fp = self.path
         self.Files2Read(self.fp)
         self.readFile(self.fp)
-        
-        self.dataOut.data_spc = self.dataOut_spc#self.data_spc.copy()
+
+        self.dataOut.data_spc = self.dataOut_spc  # self.data_spc.copy()
         self.dataOut.RadarConst = self.RadarConst
-        self.dataOut.data_output=self.data_output
+        self.dataOut.data_output = self.data_output
         self.dataOut.noise = self.dataOut.getNoise()
-        #print 'ACAAAAAA', self.dataOut.noise
-        self.dataOut.data_spc = self.dataOut.data_spc+self.dataOut.noise
-        #print 'self.dataOut.noise',self.dataOut.noise 
-        
-        
+        # print 'ACAAAAAA', self.dataOut.noise
+        self.dataOut.data_spc = self.dataOut.data_spc + self.dataOut.noise
+        # print 'self.dataOut.noise',self.dataOut.noise
+
         return self.dataOut.data_spc
-        
-        
-    def readFile(self,fp):
+
+    def readFile(self, fp):
         '''
         You must indicate if you are reading in Online or Offline mode and load the
         The parameters for this file reading mode.
-        
+
         Then you must do 2 actions:
-        
+
         1. Get the BLTR FileHeader.
         2. Start reading the first block.
         '''
-        
-        #The address of the folder is generated the name of the .fdt file that will be read
-        print "File:    ",self.fileSelector+1
-        
+
+        # The address of the folder is generated the name of the .fdt file that will be read
+        print "File:    ", self.fileSelector + 1
+
         if self.fileSelector < len(self.filenameList):
-            
-            self.fpFile=str(fp)+'/'+str(self.filenameList[self.fileSelector])
-            
-            if self.nextfileflag==True:
-                self.fp = open(self.fpFile,"rb")
-                self.nextfileflag==False
-            
+
+            self.fpFile = str(fp) + '/' + \
+                str(self.filenameList[self.fileSelector])
+
+            if self.nextfileflag == True:
+                self.fp = open(self.fpFile, "rb")
+                self.nextfileflag == False
+
             '''HERE STARTING THE FILE READING'''
-            
-            
+
             self.fheader = FileHeaderMIRA35c()
-            self.fheader.FHread(self.fp)   #Bltr FileHeader Reading
-            
+            self.fheader.FHread(self.fp)  # Bltr FileHeader Reading
 
             self.SPARrawGate1 = self.fheader.SPARrawGate1
             self.SPARrawGate2 = self.fheader.SPARrawGate2
             self.Num_Hei = self.SPARrawGate2 - self.SPARrawGate1
             self.Num_Bins = self.fheader.PPARsft
             self.dataOut.nFFTPoints = self.fheader.PPARsft
-            
-            
+
             self.Num_inCoh = self.fheader.PPARavc
             self.dataOut.PRF = self.fheader.PPARprf
-            self.dataOut.frequency = 34.85*10**9
-            self.Lambda = SPEED_OF_LIGHT/self.dataOut.frequency
-            self.dataOut.ippSeconds= 1./float(self.dataOut.PRF)
-            
-            pulse_width = self.fheader.PPARpdr * 10**-9 
+            self.dataOut.frequency = 34.85 * 10**9
+            self.Lambda = SPEED_OF_LIGHT / self.dataOut.frequency
+            self.dataOut.ippSeconds = 1. / float(self.dataOut.PRF)
+
+            pulse_width = self.fheader.PPARpdr * 10**-9
             self.__deltaHeigth = 0.5 * SPEED_OF_LIGHT * pulse_width
-            
-            self.data_spc = numpy.zeros((self.Num_Hei, self.Num_Bins,2))#
+
+            self.data_spc = numpy.zeros((self.Num_Hei, self.Num_Bins, 2))
             self.dataOut.HSDV = numpy.zeros((self.Num_Hei, 2))
-            
+
             self.Ze = numpy.zeros(self.Num_Hei)
-            self.ETA = numpy.zeros(([2,self.Num_Hei]))
-            
-            
-            
-            self.readBlock()    #Block reading
-            
+            self.ETA = numpy.zeros(([2, self.Num_Hei]))
+
+            self.readBlock()  # Block reading
+
         else:
             print 'readFile FlagNoData becomes true'
-            self.flagNoMoreFiles=True
+            self.flagNoMoreFiles = True
             self.dataOut.flagNoData = True
             self.FileHeaderFlag == True
-            return 0     
-        
-        
-        
-    def readBlock(self):  
+            return 0
+
+    def readBlock(self):
         '''
         It should be checked if the block has data, if it is not passed to the next file.
-        
+
         Then the following is done:
-        
+
         1. Read the RecordHeader
         2. Fill the buffer with the current block number.
-        
+
         '''
-        
+
         if self.PointerReader > 1180:
-            self.fp.seek(self.PointerReader , os.SEEK_SET)
+            self.fp.seek(self.PointerReader, os.SEEK_SET)
             self.FirstPoint = self.PointerReader
-            
-        else :
+
+        else:
             self.FirstPoint = 1180
-            
-        
-        
+
         self.srviHeader = SRVIHeader()
-        
-        self.srviHeader.SRVIread(self.fp) #Se obtiene la cabecera del SRVI
-        
-        self.blocksize = self.srviHeader.SizeOfDataBlock1 # Se obtiene el tamao del bloque
-        
+
+        self.srviHeader.SRVIread(self.fp)  # Se obtiene la cabecera del SRVI
+
+        self.blocksize = self.srviHeader.SizeOfDataBlock1  # Se obtiene el tamao del bloque
+
         if self.blocksize == 148:
             print 'blocksize == 148 bug'
-            jump = numpy.fromfile(self.fp,[('jump',numpy.str_,140)] ,1)
-            
-            self.srviHeader.SRVIread(self.fp) #Se obtiene la cabecera del SRVI
-            
+            jump = numpy.fromfile(self.fp, [('jump', numpy.str_, 140)], 1)
+
+            # Se obtiene la cabecera del SRVI
+            self.srviHeader.SRVIread(self.fp)
+
         if not self.srviHeader.SizeOfSRVI1:
-            self.fileSelector+=1 
-            self.nextfileflag==True
+            self.fileSelector += 1
+            self.nextfileflag == True
             self.FileHeaderFlag == True
-            
+
         self.recordheader = RecordHeader()
         self.recordheader.RHread(self.fp)
         self.RadarConst = self.recordheader.RadarConst
         dwell = self.recordheader.time_t
         npw1 = self.recordheader.npw1
         npw2 = self.recordheader.npw2
-        
-        
+
         self.dataOut.channelList = range(1)
-        self.dataOut.nIncohInt = self.Num_inCoh 
+        self.dataOut.nIncohInt = self.Num_inCoh
         self.dataOut.nProfiles = self.Num_Bins
         self.dataOut.nCohInt = 1
         self.dataOut.windowOfFilter = 1
         self.dataOut.utctime = dwell
-        self.dataOut.timeZone=0
-        
+        self.dataOut.timeZone = 0
+
         self.dataOut.outputInterval = self.dataOut.getTimeInterval()
-        self.dataOut.heightList = self.SPARrawGate1*self.__deltaHeigth + numpy.array(range(self.Num_Hei))*self.__deltaHeigth
-        
-        
-        
-        self.HSDVsign = numpy.fromfile( self.fp, [('HSDV',numpy.str_,4)],1) 
-        self.SizeHSDV = numpy.fromfile( self.fp, [('SizeHSDV','<i4')],1)
-        self.HSDV_Co = numpy.fromfile( self.fp, [('HSDV_Co','<f4')],self.Num_Hei)
-        self.HSDV_Cx = numpy.fromfile( self.fp, [('HSDV_Cx','<f4')],self.Num_Hei)
-        
-        self.COFAsign = numpy.fromfile( self.fp, [('COFA',numpy.str_,4)],1)
-        self.SizeCOFA = numpy.fromfile( self.fp, [('SizeCOFA','<i4')],1)
-        self.COFA_Co = numpy.fromfile( self.fp, [('COFA_Co','<f4')],self.Num_Hei)
-        self.COFA_Cx = numpy.fromfile( self.fp, [('COFA_Cx','<f4')],self.Num_Hei)
-        
-        self.ZSPCsign = numpy.fromfile(self.fp, [('ZSPCsign',numpy.str_,4)],1)
-        self.SizeZSPC = numpy.fromfile(self.fp, [('SizeZSPC','<i4')],1) 
-        
-        self.dataOut.HSDV[0]=self.HSDV_Co[:][0]
-        self.dataOut.HSDV[1]=self.HSDV_Cx[:][0]
-        
+        self.dataOut.heightList = self.SPARrawGate1 * self.__deltaHeigth + \
+            numpy.array(range(self.Num_Hei)) * self.__deltaHeigth
+
+        self.HSDVsign = numpy.fromfile(self.fp, [('HSDV', numpy.str_, 4)], 1)
+        self.SizeHSDV = numpy.fromfile(self.fp, [('SizeHSDV', '<i4')], 1)
+        self.HSDV_Co = numpy.fromfile(
+            self.fp, [('HSDV_Co', '<f4')], self.Num_Hei)
+        self.HSDV_Cx = numpy.fromfile(
+            self.fp, [('HSDV_Cx', '<f4')], self.Num_Hei)
+
+        self.COFAsign = numpy.fromfile(self.fp, [('COFA', numpy.str_, 4)], 1)
+        self.SizeCOFA = numpy.fromfile(self.fp, [('SizeCOFA', '<i4')], 1)
+        self.COFA_Co = numpy.fromfile(
+            self.fp, [('COFA_Co', '<f4')], self.Num_Hei)
+        self.COFA_Cx = numpy.fromfile(
+            self.fp, [('COFA_Cx', '<f4')], self.Num_Hei)
+
+        self.ZSPCsign = numpy.fromfile(
+            self.fp, [('ZSPCsign', numpy.str_, 4)], 1)
+        self.SizeZSPC = numpy.fromfile(self.fp, [('SizeZSPC', '<i4')], 1)
+
+        self.dataOut.HSDV[0] = self.HSDV_Co[:][0]
+        self.dataOut.HSDV[1] = self.HSDV_Cx[:][0]
+
         for irg in range(self.Num_Hei):
-            nspc = numpy.fromfile(self.fp, [('nspc','int16')],1)[0][0] #    Number of spectral sub pieces containing significant power
-            
+            # Number of spectral sub pieces containing significant power
+            nspc = numpy.fromfile(self.fp, [('nspc', 'int16')], 1)[0][0]
+
             for k in range(nspc):
-                binIndex = numpy.fromfile(self.fp, [('binIndex','int16')],1)[0][0] #    Index of the spectral bin where the piece is beginning
-                nbins = numpy.fromfile(self.fp, [('nbins','int16')],1)[0][0] #    Number of bins of the piece
-                
-                #Co_Channel
-                jbin = numpy.fromfile(self.fp, [('jbin','uint16')],nbins)[0][0] #  Spectrum piece to be normaliced
-                jmax = numpy.fromfile(self.fp, [('jmax','float32')],1)[0][0] #     Maximun piece to be normaliced
-                
-                
-                self.data_spc[irg,binIndex:binIndex+nbins,0] = self.data_spc[irg,binIndex:binIndex+nbins,0]+jbin/65530.*jmax
-                
-                #Cx_Channel
-                jbin = numpy.fromfile(self.fp, [('jbin','uint16')],nbins)[0][0]
-                jmax = numpy.fromfile(self.fp, [('jmax','float32')],1)[0][0]
-                
-                
-                self.data_spc[irg,binIndex:binIndex+nbins,1] = self.data_spc[irg,binIndex:binIndex+nbins,1]+jbin/65530.*jmax
-            
-        for bin in range(self.Num_Bins):    
-            
-            self.data_spc[:,bin,0] = self.data_spc[:,bin,0] - self.dataOut.HSDV[:,0]
-            
-            self.data_spc[:,bin,1] = self.data_spc[:,bin,1] - self.dataOut.HSDV[:,1]
-            
-        
+                # Index of the spectral bin where the piece is beginning
+                binIndex = numpy.fromfile(
+                    self.fp, [('binIndex', 'int16')], 1)[0][0]
+                nbins = numpy.fromfile(self.fp, [('nbins', 'int16')], 1)[
+                    0][0]  # Number of bins of the piece
+
+                # Co_Channel
+                jbin = numpy.fromfile(self.fp, [('jbin', 'uint16')], nbins)[
+                    0][0]  # Spectrum piece to be normaliced
+                jmax = numpy.fromfile(self.fp, [('jmax', 'float32')], 1)[
+                    0][0]  # Maximun piece to be normaliced
+
+                self.data_spc[irg, binIndex:binIndex + nbins, 0] = self.data_spc[irg,
+                                                                                 binIndex:binIndex + nbins, 0] + jbin / 65530. * jmax
+
+                # Cx_Channel
+                jbin = numpy.fromfile(
+                    self.fp, [('jbin', 'uint16')], nbins)[0][0]
+                jmax = numpy.fromfile(self.fp, [('jmax', 'float32')], 1)[0][0]
+
+                self.data_spc[irg, binIndex:binIndex + nbins, 1] = self.data_spc[irg,
+                                                                                 binIndex:binIndex + nbins, 1] + jbin / 65530. * jmax
+
+        for bin in range(self.Num_Bins):
+
+            self.data_spc[:, bin, 0] = self.data_spc[:,
+                                                     bin, 0] - self.dataOut.HSDV[:, 0]
+
+            self.data_spc[:, bin, 1] = self.data_spc[:,
+                                                     bin, 1] - self.dataOut.HSDV[:, 1]
+
         numpy.set_printoptions(threshold='nan')
-        
-        self.data_spc = numpy.where(self.data_spc > 0. , self.data_spc, 0)
-        
-        self.dataOut.COFA = numpy.array([self.COFA_Co , self.COFA_Cx])
-        
+
+        self.data_spc = numpy.where(self.data_spc > 0., self.data_spc, 0)
+
+        self.dataOut.COFA = numpy.array([self.COFA_Co, self.COFA_Cx])
+
         print ' '
-        print 'SPC',numpy.shape(self.dataOut.data_spc)
-        #print 'SPC',self.dataOut.data_spc
-        
+        print 'SPC', numpy.shape(self.dataOut.data_spc)
+        # print 'SPC',self.dataOut.data_spc
+
         noinor1 = 713031680
         noinor2 = 30
-        
-        npw1 = 1#0**(npw1/10) * noinor1 * noinor2
-        npw2 = 1#0**(npw2/10) * noinor1 * noinor2
+
+        npw1 = 1  # 0**(npw1/10) * noinor1 * noinor2
+        npw2 = 1  # 0**(npw2/10) * noinor1 * noinor2
         self.dataOut.NPW = numpy.array([npw1, npw2])
-        
+
         print ' '
-        
-        self.data_spc = numpy.transpose(self.data_spc, (2,1,0))
-        self.data_spc = numpy.fft.fftshift(self.data_spc, axes = 1) 
-        
+
+        self.data_spc = numpy.transpose(self.data_spc, (2, 1, 0))
+        self.data_spc = numpy.fft.fftshift(self.data_spc, axes=1)
+
         self.data_spc = numpy.fliplr(self.data_spc)
-        
-        self.data_spc = numpy.where(self.data_spc > 0. , self.data_spc, 0)
-        self.dataOut_spc= numpy.ones([1, self.Num_Bins , self.Num_Hei])
-        self.dataOut_spc[0,:,:] = self.data_spc[0,:,:]
-        #print 'SHAPE', self.dataOut_spc.shape
-        #For nyquist correction:
-        #fix = 20 # ~3m/s
+
+        self.data_spc = numpy.where(self.data_spc > 0., self.data_spc, 0)
+        self.dataOut_spc = numpy.ones([1, self.Num_Bins, self.Num_Hei])
+        self.dataOut_spc[0, :, :] = self.data_spc[0, :, :]
+        # print 'SHAPE', self.dataOut_spc.shape
+        # For nyquist correction:
+        # fix = 20 # ~3m/s
         #shift = self.Num_Bins/2 + fix
         #self.data_spc = numpy.array([ self.data_spc[: , self.Num_Bins-shift+1: , :] , self.data_spc[: , 0:self.Num_Bins-shift , :]])
-        
-        
-        
+
         '''Block Reading, the Block Data is received and Reshape is used to give it
         shape.
         '''
-        
+
         self.PointerReader = self.fp.tell()
-        
-        
-    
-    
-    
-    
-    
\ No newline at end of file
diff --git a/schainpy/model/proc/jroproc_parameters.py b/schainpy/model/proc/jroproc_parameters.py
index 8fe1cf2..704bdcd 100644
--- a/schainpy/model/proc/jroproc_parameters.py
+++ b/schainpy/model/proc/jroproc_parameters.py
@@ -17,7 +17,6 @@ from functools import partial
 import time
 #from sklearn.cluster import KMeans 
 
-import matplotlib.pyplot as plt
 
 from scipy.optimize import fmin_l_bfgs_b #optimize with bounds on state papameters
 from jroproc_base import ProcessingUnit, Operation