diff --git a/schainpy/model/data/jroheaderIO.py b/schainpy/model/data/jroheaderIO.py
index c85ae5d..8303525 100644
--- a/schainpy/model/data/jroheaderIO.py
+++ b/schainpy/model/data/jroheaderIO.py
@@ -13,75 +13,77 @@ SPEED_OF_LIGHT = 299792458
 SPEED_OF_LIGHT = 3e8
 
 BASIC_STRUCTURE = numpy.dtype([
-                          ('nSize','<u4'),
-                          ('nVersion','<u2'),
-                          ('nDataBlockId','<u4'),
-                          ('nUtime','<u4'),
-                          ('nMilsec','<u2'),     
-                          ('nTimezone','<i2'),
-                          ('nDstflag','<i2'),
-                          ('nErrorCount','<u4')
-                          ])
+    ('nSize', '<u4'),
+    ('nVersion', '<u2'),
+    ('nDataBlockId', '<u4'),
+    ('nUtime', '<u4'),
+    ('nMilsec', '<u2'),
+    ('nTimezone', '<i2'),
+    ('nDstflag', '<i2'),
+    ('nErrorCount', '<u4')
+])
 
 SYSTEM_STRUCTURE = numpy.dtype([
-                            ('nSize','<u4'),
-                            ('nNumSamples','<u4'),
-                            ('nNumProfiles','<u4'),
-                            ('nNumChannels','<u4'),
-                            ('nADCResolution','<u4'),
-                            ('nPCDIOBusWidth','<u4'),
-                            ])
+    ('nSize', '<u4'),
+    ('nNumSamples', '<u4'),
+    ('nNumProfiles', '<u4'),
+    ('nNumChannels', '<u4'),
+    ('nADCResolution', '<u4'),
+    ('nPCDIOBusWidth', '<u4'),
+])
 
 RADAR_STRUCTURE = numpy.dtype([
-                             ('nSize','<u4'),
-                             ('nExpType','<u4'),
-                             ('nNTx','<u4'),
-                             ('fIpp','<f4'),
-                             ('fTxA','<f4'),
-                             ('fTxB','<f4'),
-                             ('nNumWindows','<u4'),
-                             ('nNumTaus','<u4'),
-                             ('nCodeType','<u4'),
-                             ('nLine6Function','<u4'),
-                             ('nLine5Function','<u4'),
-                             ('fClock','<f4'),
-                             ('nPrePulseBefore','<u4'),
-                             ('nPrePulseAfter','<u4'),
-                             ('sRangeIPP','<a20'),
-                             ('sRangeTxA','<a20'),
-                             ('sRangeTxB','<a20'),
-                             ])
-
-SAMPLING_STRUCTURE = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
+                             ('nSize', '<u4'),
+                             ('nExpType', '<u4'),
+                             ('nNTx', '<u4'),
+                             ('fIpp', '<f4'),
+                             ('fTxA', '<f4'),
+                             ('fTxB', '<f4'),
+                             ('nNumWindows', '<u4'),
+                             ('nNumTaus', '<u4'),
+                             ('nCodeType', '<u4'),
+                             ('nLine6Function', '<u4'),
+                             ('nLine5Function', '<u4'),
+                             ('fClock', '<f4'),
+                             ('nPrePulseBefore', '<u4'),
+                             ('nPrePulseAfter', '<u4'),
+                             ('sRangeIPP', '<a20'),
+                             ('sRangeTxA', '<a20'),
+                             ('sRangeTxB', '<a20'),
+])
+
+SAMPLING_STRUCTURE = numpy.dtype(
+    [('h0', '<f4'), ('dh', '<f4'), ('nsa', '<u4')])
 
 
 PROCESSING_STRUCTURE = numpy.dtype([
-                               ('nSize','<u4'),
-                               ('nDataType','<u4'),
-                               ('nSizeOfDataBlock','<u4'),
-                               ('nProfilesperBlock','<u4'),
-                               ('nDataBlocksperFile','<u4'),
-                               ('nNumWindows','<u4'),
-                               ('nProcessFlags','<u4'),
-                               ('nCoherentIntegrations','<u4'),
-                               ('nIncoherentIntegrations','<u4'),
-                               ('nTotalSpectra','<u4')
-                               ])
+    ('nSize', '<u4'),
+    ('nDataType', '<u4'),
+    ('nSizeOfDataBlock', '<u4'),
+    ('nProfilesperBlock', '<u4'),
+    ('nDataBlocksperFile', '<u4'),
+    ('nNumWindows', '<u4'),
+    ('nProcessFlags', '<u4'),
+    ('nCoherentIntegrations', '<u4'),
+    ('nIncoherentIntegrations', '<u4'),
+    ('nTotalSpectra', '<u4')
+])
+
 
 class Header(object):
-    
+
     def __init__(self):
         raise NotImplementedError
-    
+
     def copy(self):
         return copy.deepcopy(self)
-    
+
     def read(self):
-        
+
         raise NotImplementedError
-    
+
     def write(self):
-        
+
         raise NotImplementedError
 
     def getAllowedArgs(self):
@@ -98,32 +100,33 @@ class Header(object):
         for x in args:
             asDict[x] = self[x]
         return asDict
-    
+
     def __getitem__(self, name):
         return getattr(self, name)
 
     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"
-        
+                message += "%s = %s" % ("size", attr) + "\n"
+
         print message
 
+
 class BasicHeader(Header):
-    
+
     size = None
     version = None
     dataBlock = None
@@ -136,9 +139,9 @@ class BasicHeader(Header):
     datatime = None
     structure = BASIC_STRUCTURE
     __LOCALTIME = None
-        
+
     def __init__(self, useLocalTime=True):
-        
+
         self.size = 24
         self.version = 0
         self.dataBlock = 0
@@ -147,17 +150,17 @@ class BasicHeader(Header):
         self.timeZone = 0
         self.dstFlag = 0
         self.errorCount = 0
-        
+
         self.useLocalTime = useLocalTime
-    
+
     def read(self, fp):
-        
+
         self.length = 0
         try:
             if hasattr(fp, 'read'):
-                header = numpy.fromfile(fp, BASIC_STRUCTURE,1)
+                header = numpy.fromfile(fp, BASIC_STRUCTURE, 1)
             else:
-                header = numpy.fromstring(fp, BASIC_STRUCTURE,1)
+                header = numpy.fromstring(fp, BASIC_STRUCTURE, 1)
         except Exception, e:
             print "BasicHeader: "
             print e
@@ -171,38 +174,40 @@ class BasicHeader(Header):
         self.timeZone = int(header['nTimezone'][0])
         self.dstFlag = int(header['nDstflag'][0])
         self.errorCount = int(header['nErrorCount'][0])
-        
+
         if self.size < 24:
             return 0
 
         self.length = header.nbytes
         return 1
-    
+
     def write(self, fp):
-        
-        headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount)
-        header = numpy.array(headerTuple, BASIC_STRUCTURE)        
+
+        headerTuple = (self.size, self.version, self.dataBlock, self.utc,
+                       self.miliSecond, self.timeZone, self.dstFlag, self.errorCount)
+        header = numpy.array(headerTuple, BASIC_STRUCTURE)
         header.tofile(fp)
-        
+
         return 1
-    
+
     def get_ltc(self):
-        
-        return self.utc - self.timeZone*60
-    
+
+        return self.utc - self.timeZone * 60
+
     def set_ltc(self, value):
-        
-        self.utc = value + self.timeZone*60
-    
+
+        self.utc = value + self.timeZone * 60
+
     def get_datatime(self):
-        
+
         return datetime.datetime.utcfromtimestamp(self.ltc)
-    
+
     ltc = property(get_ltc, set_ltc)
     datatime = property(get_datatime)
 
+
 class SystemHeader(Header):
-    
+
     size = None
     nSamples = None
     nProfiles = None
@@ -212,8 +217,8 @@ class SystemHeader(Header):
     structure = SYSTEM_STRUCTURE
 
     def __init__(self, nSamples=0, nProfiles=0, nChannels=0, adcResolution=14, pciDioBusWidth=0):
-        
-        self.size = 24 
+
+        self.size = 24
         self.nSamples = nSamples
         self.nProfiles = nProfiles
         self.nChannels = nChannels
@@ -230,45 +235,48 @@ class SystemHeader(Header):
 
         try:
             if hasattr(fp, 'read'):
-                header = numpy.fromfile(fp, SYSTEM_STRUCTURE,1)
+                header = numpy.fromfile(fp, SYSTEM_STRUCTURE, 1)
             else:
-                header = numpy.fromstring(fp, SYSTEM_STRUCTURE,1)
+                header = numpy.fromstring(fp, SYSTEM_STRUCTURE, 1)
         except Exception, e:
             print "System Header: " + str(e)
             return 0
-        
+
         self.size = header['nSize'][0]
         self.nSamples = header['nNumSamples'][0]
         self.nProfiles = header['nNumProfiles'][0]
         self.nChannels = header['nNumChannels'][0]
         self.adcResolution = header['nADCResolution'][0]
         self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
-        
-        
+
         if startFp is not None:
             endFp = self.size + startFp
-            
+
             if fp.tell() > endFp:
-                sys.stderr.write("Warning %s: Size value read from System Header is lower than it has to be\n" %fp.name)
+                sys.stderr.write(
+                    "Warning %s: Size value read from System Header is lower than it has to be\n" % fp.name)
                 return 0
-                
+
             if fp.tell() < endFp:
-                sys.stderr.write("Warning %s: Size value read from System Header size is greater than it has to be\n" %fp.name)
+                sys.stderr.write(
+                    "Warning %s: Size value read from System Header size is greater than it has to be\n" % fp.name)
                 return 0
-        
+
         self.length = header.nbytes
         return 1
-    
+
     def write(self, fp):
-        
-        headerTuple = (self.size,self.nSamples,self.nProfiles,self.nChannels,self.adcResolution,self.pciDioBusWidth)
-        header = numpy.array(headerTuple,SYSTEM_STRUCTURE)
+
+        headerTuple = (self.size, self.nSamples, self.nProfiles,
+                       self.nChannels, self.adcResolution, self.pciDioBusWidth)
+        header = numpy.array(headerTuple, SYSTEM_STRUCTURE)
         header.tofile(fp)
-        
+
         return 1
 
+
 class RadarControllerHeader(Header):
-    
+
     expType = None
     nTx = None
     ipp = None
@@ -287,7 +295,7 @@ class RadarControllerHeader(Header):
     rangeTxB = None
     structure = RADAR_STRUCTURE
     __size = None
-        
+
     def __init__(self, expType=2, nTx=1,
                  ipp=None, txA=0, txB=0,
                  nWindows=None, nHeights=None, firstHeight=None, deltaHeight=None,
@@ -295,8 +303,8 @@ class RadarControllerHeader(Header):
                  prePulseBefore=0, prePulseAfter=0,
                  codeType=0, nCode=0, nBaud=0, code=None,
                  flip1=0, flip2=0):
-        
-#         self.size = 116
+
+        #         self.size = 116
         self.expType = expType
         self.nTx = nTx
         self.ipp = ipp
@@ -305,7 +313,7 @@ class RadarControllerHeader(Header):
         self.rangeIpp = ipp
         self.rangeTxA = txA
         self.rangeTxB = txB
-        
+
         self.nWindows = nWindows
         self.numTaus = numTaus
         self.codeType = codeType
@@ -314,23 +322,23 @@ class RadarControllerHeader(Header):
         self.fClock = fClock
         self.prePulseBefore = prePulseBefore
         self.prePulseAfter = prePulseAfter
-        
+
         self.nHeights = nHeights
         self.firstHeight = firstHeight
         self.deltaHeight = deltaHeight
         self.samplesWin = nHeights
-        
+
         self.nCode = nCode
         self.nBaud = nBaud
         self.code = code
         self.flip1 = flip1
         self.flip2 = flip2
-        
-        self.code_size = int(numpy.ceil(self.nBaud/32.))*self.nCode*4
+
+        self.code_size = int(numpy.ceil(self.nBaud / 32.)) * self.nCode * 4
 #         self.dynamic = numpy.array([],numpy.dtype('byte'))
-        
+
         if self.fClock is None and self.deltaHeight is not None:
-            self.fClock = 0.15/(deltaHeight*1e-6)   #0.15Km / (height * 1u)
+            self.fClock = 0.15 / (deltaHeight * 1e-6)  # 0.15Km / (height * 1u)
 
     def read(self, fp):
         self.length = 0
@@ -342,14 +350,14 @@ class RadarControllerHeader(Header):
 
         try:
             if hasattr(fp, 'read'):
-                header = numpy.fromfile(fp, RADAR_STRUCTURE,1)
+                header = numpy.fromfile(fp, RADAR_STRUCTURE, 1)
             else:
-                header = numpy.fromstring(fp, RADAR_STRUCTURE,1)
+                header = numpy.fromstring(fp, RADAR_STRUCTURE, 1)
             self.length += header.nbytes
         except Exception, e:
             print "RadarControllerHeader: " + str(e)
             return 0
-        
+
         size = int(header['nSize'][0])
         self.expType = int(header['nExpType'][0])
         self.nTx = int(header['nNTx'][0])
@@ -367,12 +375,14 @@ class RadarControllerHeader(Header):
         self.rangeIpp = header['sRangeIPP'][0]
         self.rangeTxA = header['sRangeTxA'][0]
         self.rangeTxB = header['sRangeTxB'][0]
-        
+
         try:
             if hasattr(fp, 'read'):
-                samplingWindow = numpy.fromfile(fp, SAMPLING_STRUCTURE, self.nWindows)
+                samplingWindow = numpy.fromfile(
+                    fp, SAMPLING_STRUCTURE, self.nWindows)
             else:
-                samplingWindow = numpy.fromstring(fp[self.length:], SAMPLING_STRUCTURE, self.nWindows)
+                samplingWindow = numpy.fromstring(
+                    fp[self.length:], SAMPLING_STRUCTURE, self.nWindows)
             self.length += samplingWindow.nbytes
         except Exception, e:
             print "RadarControllerHeader: " + str(e)
@@ -381,24 +391,21 @@ class RadarControllerHeader(Header):
         self.firstHeight = samplingWindow['h0']
         self.deltaHeight = samplingWindow['dh']
         self.samplesWin = samplingWindow['nsa']
-    
-        
 
         try:
             if hasattr(fp, 'read'):
                 self.Taus = numpy.fromfile(fp, '<f4', self.numTaus)
             else:
-                self.Taus = numpy.fromstring(fp[self.length:], '<f4', self.numTaus)
+                self.Taus = numpy.fromstring(
+                    fp[self.length:], '<f4', self.numTaus)
             self.length += self.Taus.nbytes
         except Exception, e:
             print "RadarControllerHeader: " + str(e)
             return 0
-        
-        
-        
+
         self.code_size = 0
         if self.codeType != 0:
-            
+
             try:
                 if hasattr(fp, 'read'):
                     self.nCode = numpy.fromfile(fp, '<u4', 1)[0]
@@ -406,58 +413,63 @@ class RadarControllerHeader(Header):
                     self.nBaud = numpy.fromfile(fp, '<u4', 1)[0]
                     self.length += self.nBaud.nbytes
                 else:
-                    self.nCode = numpy.fromstring(fp[self.length:], '<u4', 1)[0]
+                    self.nCode = numpy.fromstring(
+                        fp[self.length:], '<u4', 1)[0]
                     self.length += self.nCode.nbytes
-                    self.nBaud = numpy.fromstring(fp[self.length:], '<u4', 1)[0]
+                    self.nBaud = numpy.fromstring(
+                        fp[self.length:], '<u4', 1)[0]
                     self.length += self.nBaud.nbytes
             except Exception, e:
                 print "RadarControllerHeader: " + str(e)
-                return 0            
-            code = numpy.empty([self.nCode,self.nBaud],dtype='i1')
-           
+                return 0
+            code = numpy.empty([self.nCode, self.nBaud], dtype='i1')
+
             for ic in range(self.nCode):
                 try:
                     if hasattr(fp, 'read'):
-                        temp = numpy.fromfile(fp,'u4', int(numpy.ceil(self.nBaud/32.)))
+                        temp = numpy.fromfile(fp, 'u4', int(
+                            numpy.ceil(self.nBaud / 32.)))
                     else:
-                        temp = numpy.fromstring(fp,'u4', int(numpy.ceil(self.nBaud/32.)))
+                        temp = numpy.fromstring(
+                            fp, 'u4', int(numpy.ceil(self.nBaud / 32.)))
                     self.length += temp.nbytes
                 except Exception, e:
                     print "RadarControllerHeader: " + str(e)
                     return 0
 
-                for ib in range(self.nBaud-1,-1,-1):
-                    code[ic,ib] = temp[ib/32]%2
-                    temp[ib/32] = temp[ib/32]/2
-                    
-            self.code = 2.0*code - 1.0
-            self.code_size = int(numpy.ceil(self.nBaud/32.))*self.nCode*4
-            
+                for ib in range(self.nBaud - 1, -1, -1):
+                    code[ic, ib] = temp[ib / 32] % 2
+                    temp[ib / 32] = temp[ib / 32] / 2
+
+            self.code = 2.0 * code - 1.0
+            self.code_size = int(numpy.ceil(self.nBaud / 32.)) * self.nCode * 4
+
 #             if self.line5Function == RCfunction.FLIP:
 #                 self.flip1 = numpy.fromfile(fp,'<u4',1)
-#  
+#
 #             if self.line6Function == RCfunction.FLIP:
 #                 self.flip2 = numpy.fromfile(fp,'<u4',1)
         if startFp is not None:
             endFp = size + startFp
-            
+
             if fp.tell() != endFp:
-    #             fp.seek(endFp)
-                print "%s: Radar Controller Header size is not consistent: from data [%d] != from header field [%d]" %(fp.name, fp.tell()-startFp, size)
+                #             fp.seek(endFp)
+                print "%s: Radar Controller Header size is not consistent: from data [%d] != from header field [%d]" % (fp.name, fp.tell() - startFp, size)
     #             return 0
 
             if fp.tell() > endFp:
-                sys.stderr.write("Warning %s: Size value read from Radar Controller header is lower than it has to be\n" %fp.name)
+                sys.stderr.write(
+                    "Warning %s: Size value read from Radar Controller header is lower than it has to be\n" % fp.name)
     #             return 0
-                
+
             if fp.tell() < endFp:
-                sys.stderr.write("Warning %s: Size value read from Radar Controller header is greater than it has to be\n" %fp.name)
-            
-        
+                sys.stderr.write(
+                    "Warning %s: Size value read from Radar Controller header is greater than it has to be\n" % fp.name)
+
         return 1
-    
+
     def write(self, fp):
-        
+
         headerTuple = (self.size,
                        self.expType,
                        self.nTx,
@@ -475,83 +487,87 @@ class RadarControllerHeader(Header):
                        self.rangeIpp,
                        self.rangeTxA,
                        self.rangeTxB)
-        
-        header = numpy.array(headerTuple,RADAR_STRUCTURE)
+
+        header = numpy.array(headerTuple, RADAR_STRUCTURE)
         header.tofile(fp)
-        
-        sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
-        samplingWindow = numpy.array(sampleWindowTuple,SAMPLING_STRUCTURE)
+
+        sampleWindowTuple = (
+            self.firstHeight, self.deltaHeight, self.samplesWin)
+        samplingWindow = numpy.array(sampleWindowTuple, SAMPLING_STRUCTURE)
         samplingWindow.tofile(fp)
-        
+
         if self.numTaus > 0:
             self.Taus.tofile(fp)
-        
-        if self.codeType !=0:
+
+        if self.codeType != 0:
             nCode = numpy.array(self.nCode, '<u4')
             nCode.tofile(fp)
             nBaud = numpy.array(self.nBaud, '<u4')
             nBaud.tofile(fp)
-            code1 = (self.code + 1.0)/2.
-            
+            code1 = (self.code + 1.0) / 2.
+
             for ic in range(self.nCode):
-                tempx = numpy.zeros(numpy.ceil(self.nBaud/32.))
+                tempx = numpy.zeros(numpy.ceil(self.nBaud / 32.))
                 start = 0
                 end = 32
                 for i in range(len(tempx)):
-                    code_selected = code1[ic,start:end]
-                    for j in range(len(code_selected)-1,-1,-1):
+                    code_selected = code1[ic, start:end]
+                    for j in range(len(code_selected) - 1, -1, -1):
                         if code_selected[j] == 1:
-                            tempx[i] = tempx[i] + 2**(len(code_selected)-1-j)
+                            tempx[i] = tempx[i] + \
+                                2**(len(code_selected) - 1 - j)
                     start = start + 32
                     end = end + 32
-                
+
                 tempx = tempx.astype('u4')
                 tempx.tofile(fp)
-            
+
 #         if self.line5Function == RCfunction.FLIP:
 #             self.flip1.tofile(fp)
-# 
+#
 #         if self.line6Function == RCfunction.FLIP:
 #             self.flip2.tofile(fp)
-        
+
         return 1
 
     def get_ippSeconds(self):
         '''
         '''
         ippSeconds = 2.0 * 1000 * self.ipp / SPEED_OF_LIGHT
-        
+
         return ippSeconds
-    
+
     def set_ippSeconds(self, ippSeconds):
         '''
         '''
-        
-        self.ipp = ippSeconds * SPEED_OF_LIGHT / (2.0*1000)
-        
+
+        self.ipp = ippSeconds * SPEED_OF_LIGHT / (2.0 * 1000)
+
         return
-    
+
     def get_size(self):
-        
-        self.__size = 116 + 12*self.nWindows + 4*self.numTaus
-        
+
+        self.__size = 116 + 12 * self.nWindows + 4 * self.numTaus
+
         if self.codeType != 0:
-            self.__size += 4 + 4 + 4*self.nCode*numpy.ceil(self.nBaud/32.)
-        
+            self.__size += 4 + 4 + 4 * self.nCode * \
+                numpy.ceil(self.nBaud / 32.)
+
         return self.__size
-    
+
     def set_size(self, value):
-        
+
         raise IOError, "size is a property and it cannot be set, just read"
-        
+
         return
-    
+
     ippSeconds = property(get_ippSeconds, set_ippSeconds)
     size = property(get_size, set_size)
 
+
 class ProcessingHeader(Header):
-    
-#     size = None
+
+    #     size = None
     dtype = None
     blockSize = None
     profilesPerBlock = None
@@ -564,13 +580,13 @@ class ProcessingHeader(Header):
     structure = PROCESSING_STRUCTURE
     flag_dc = None
     flag_cspc = None
-        
-    def __init__(self, dtype=0, blockSize=0, profilesPerBlock=0, dataBlocksPerFile=0, nWindows=0,processFlags=0, nCohInt=0,
-                nIncohInt=0, totalSpectra=0, nHeights=0, firstHeight=0, deltaHeight=0, samplesWin=0, spectraComb=0, nCode=0,
-                code=0, nBaud=None, shif_fft=False, flag_dc=False, flag_cspc=False, flag_decode=False, flag_deflip=False
-                ):
-        
-#         self.size = 0
+
+    def __init__(self, dtype=0, blockSize=0, profilesPerBlock=0, dataBlocksPerFile=0, nWindows=0, processFlags=0, nCohInt=0,
+                 nIncohInt=0, totalSpectra=0, nHeights=0, firstHeight=0, deltaHeight=0, samplesWin=0, spectraComb=0, nCode=0,
+                 code=0, nBaud=None, shif_fft=False, flag_dc=False, flag_cspc=False, flag_decode=False, flag_deflip=False
+                 ):
+
+        #         self.size = 0
         self.dtype = dtype
         self.blockSize = blockSize
         self.profilesPerBlock = 0
@@ -580,7 +596,7 @@ class ProcessingHeader(Header):
         self.nCohInt = 0
         self.nIncohInt = 0
         self.totalSpectra = 0
-        
+
         self.nHeights = 0
         self.firstHeight = 0
         self.deltaHeight = 0
@@ -589,7 +605,7 @@ class ProcessingHeader(Header):
         self.nCode = None
         self.code = None
         self.nBaud = None
-        
+
         self.shif_fft = False
         self.flag_dc = False
         self.flag_cspc = False
@@ -604,7 +620,7 @@ class ProcessingHeader(Header):
         except Exception, e:
             startFp = None
             pass
-        
+
         try:
             if hasattr(fp, 'read'):
                 header = numpy.fromfile(fp, PROCESSING_STRUCTURE, 1)
@@ -614,7 +630,7 @@ class ProcessingHeader(Header):
         except Exception, e:
             print "ProcessingHeader: " + str(e)
             return 0
-        
+
         size = int(header['nSize'][0])
         self.dtype = int(header['nDataType'][0])
         self.blockSize = int(header['nSizeOfDataBlock'][0])
@@ -625,94 +641,98 @@ class ProcessingHeader(Header):
         self.nCohInt = int(header['nCoherentIntegrations'][0])
         self.nIncohInt = int(header['nIncoherentIntegrations'][0])
         self.totalSpectra = int(header['nTotalSpectra'][0])
-        
+
         try:
             if hasattr(fp, 'read'):
-                samplingWindow = numpy.fromfile(fp, SAMPLING_STRUCTURE, self.nWindows)
+                samplingWindow = numpy.fromfile(
+                    fp, SAMPLING_STRUCTURE, self.nWindows)
             else:
-                samplingWindow = numpy.fromstring(fp[self.length:], SAMPLING_STRUCTURE, self.nWindows)
+                samplingWindow = numpy.fromstring(
+                    fp[self.length:], SAMPLING_STRUCTURE, self.nWindows)
             self.length += samplingWindow.nbytes
         except Exception, e:
             print "ProcessingHeader: " + str(e)
             return 0
-        
+
         self.nHeights = int(numpy.sum(samplingWindow['nsa']))
         self.firstHeight = float(samplingWindow['h0'][0])
         self.deltaHeight = float(samplingWindow['dh'][0])
         self.samplesWin = samplingWindow['nsa'][0]
-        
 
         try:
             if hasattr(fp, 'read'):
-                self.spectraComb = numpy.fromfile(fp, 'u1', 2*self.totalSpectra)
+                self.spectraComb = numpy.fromfile(
+                    fp, 'u1', 2 * self.totalSpectra)
             else:
-                self.spectraComb = numpy.fromstring(fp[self.length:], 'u1', 2*self.totalSpectra)
+                self.spectraComb = numpy.fromstring(
+                    fp[self.length:], 'u1', 2 * self.totalSpectra)
             self.length += self.spectraComb.nbytes
         except Exception, e:
             print "ProcessingHeader: " + str(e)
             return 0
-        
+
         if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
-            self.nCode = int(numpy.fromfile(fp,'<u4',1))
-            self.nBaud = int(numpy.fromfile(fp,'<u4',1))
-            self.code = numpy.fromfile(fp,'<f4',self.nCode*self.nBaud).reshape(self.nCode,self.nBaud)
-        
+            self.nCode = int(numpy.fromfile(fp, '<u4', 1))
+            self.nBaud = int(numpy.fromfile(fp, '<u4', 1))
+            self.code = numpy.fromfile(
+                fp, '<f4', self.nCode * self.nBaud).reshape(self.nCode, self.nBaud)
+
         if ((self.processFlags & PROCFLAG.EXP_NAME_ESP) == PROCFLAG.EXP_NAME_ESP):
-            exp_name_len = int(numpy.fromfile(fp,'<u4',1))
-            exp_name = numpy.fromfile(fp,'u1',exp_name_len+1)
-            
+            exp_name_len = int(numpy.fromfile(fp, '<u4', 1))
+            exp_name = numpy.fromfile(fp, 'u1', exp_name_len + 1)
+
         if ((self.processFlags & PROCFLAG.SHIFT_FFT_DATA) == PROCFLAG.SHIFT_FFT_DATA):
             self.shif_fft = True
         else:
             self.shif_fft = False
-        
+
         if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC):
             self.flag_dc = True
         else:
             self.flag_dc = False
-        
+
         if ((self.processFlags & PROCFLAG.DECODE_DATA) == PROCFLAG.DECODE_DATA):
             self.flag_decode = True
         else:
             self.flag_decode = False
-        
+
         if ((self.processFlags & PROCFLAG.DEFLIP_DATA) == PROCFLAG.DEFLIP_DATA):
             self.flag_deflip = True
         else:
             self.flag_deflip = False
-              
+
         nChannels = 0
         nPairs = 0
         pairList = []
-        
-        for i in range( 0, self.totalSpectra*2, 2 ):
-            if self.spectraComb[i] == self.spectraComb[i+1]:
-                nChannels = nChannels + 1   #par de canales iguales 
+
+        for i in range(0, self.totalSpectra * 2, 2):
+            if self.spectraComb[i] == self.spectraComb[i + 1]:
+                nChannels = nChannels + 1  # par de canales iguales
             else:
-                nPairs = nPairs + 1 #par de canales diferentes
-                pairList.append( (self.spectraComb[i], self.spectraComb[i+1]) )
-        
+                nPairs = nPairs + 1  # par de canales diferentes
+                pairList.append((self.spectraComb[i], self.spectraComb[i + 1]))
+
         self.flag_cspc = False
         if nPairs > 0:
             self.flag_cspc = True
-        
-        
-        
+
         if startFp is not None:
             endFp = size + startFp
             if fp.tell() > endFp:
-                sys.stderr.write("Warning: Processing header size is lower than it has to be")
+                sys.stderr.write(
+                    "Warning: Processing header size is lower than it has to be")
                 return 0
-                
+
             if fp.tell() < endFp:
-                sys.stderr.write("Warning: Processing header size is greater than it is considered")
-        
+                sys.stderr.write(
+                    "Warning: Processing header size is greater than it is considered")
+
         return 1
-    
+
     def write(self, fp):
-        #Clear DEFINE_PROCESS_CODE
+        # Clear DEFINE_PROCESS_CODE
         self.processFlags = self.processFlags & (~PROCFLAG.DEFINE_PROCESS_CODE)
-        
+
         headerTuple = (self.size,
                        self.dtype,
                        self.blockSize,
@@ -723,154 +743,163 @@ class ProcessingHeader(Header):
                        self.nCohInt,
                        self.nIncohInt,
                        self.totalSpectra)
-        
-        header = numpy.array(headerTuple,PROCESSING_STRUCTURE)  
+
+        header = numpy.array(headerTuple, PROCESSING_STRUCTURE)
         header.tofile(fp)
-        
+
         if self.nWindows != 0:
-            sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
-            samplingWindow = numpy.array(sampleWindowTuple,SAMPLING_STRUCTURE)
+            sampleWindowTuple = (
+                self.firstHeight, self.deltaHeight, self.samplesWin)
+            samplingWindow = numpy.array(sampleWindowTuple, SAMPLING_STRUCTURE)
             samplingWindow.tofile(fp)
-            
+
         if self.totalSpectra != 0:
-#             spectraComb = numpy.array([],numpy.dtype('u1'))
+            #             spectraComb = numpy.array([],numpy.dtype('u1'))
             spectraComb = self.spectraComb
             spectraComb.tofile(fp)
-        
+
 #         if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
 #             nCode = numpy.array([self.nCode], numpy.dtype('u4')) #Probar con un dato que almacene codigo, hasta el momento no se hizo la prueba
 #             nCode.tofile(fp)
-#  
+#
 #             nBaud = numpy.array([self.nBaud], numpy.dtype('u4'))
 #             nBaud.tofile(fp)
-#  
+#
 #             code = self.code.reshape(self.nCode*self.nBaud)
 #             code = code.astype(numpy.dtype('<f4'))
 #             code.tofile(fp)
-            
+
         return 1
 
     def get_size(self):
-        
-        self.__size = 40 + 12*self.nWindows + 2*self.totalSpectra
-        
+
+        self.__size = 40 + 12 * self.nWindows + 2 * self.totalSpectra
+
 #         if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
 #             self.__size += 4 + 4 + 4*self.nCode*numpy.ceil(self.nBaud/32.)
 #             self.__size += 4 + 4 + 4 * self.nCode * self.nBaud
-            
+
         return self.__size
-    
+
     def set_size(self, value):
-        
+
         raise IOError, "size is a property and it cannot be set, just read"
-        
+
         return
-    
+
     size = property(get_size, set_size)
-    
+
+
 class RCfunction:
-    NONE=0
-    FLIP=1
-    CODE=2
-    SAMPLING=3
-    LIN6DIV256=4
-    SYNCHRO=5
+    NONE = 0
+    FLIP = 1
+    CODE = 2
+    SAMPLING = 3
+    LIN6DIV256 = 4
+    SYNCHRO = 5
+
 
 class nCodeType:
-    NONE=0
-    USERDEFINE=1
-    BARKER2=2
-    BARKER3=3
-    BARKER4=4
-    BARKER5=5
-    BARKER7=6
-    BARKER11=7
-    BARKER13=8
-    AC128=9
-    COMPLEMENTARYCODE2=10
-    COMPLEMENTARYCODE4=11
-    COMPLEMENTARYCODE8=12
-    COMPLEMENTARYCODE16=13
-    COMPLEMENTARYCODE32=14
-    COMPLEMENTARYCODE64=15
-    COMPLEMENTARYCODE128=16
-    CODE_BINARY28=17
-
-class PROCFLAG:    
-    
+    NONE = 0
+    USERDEFINE = 1
+    BARKER2 = 2
+    BARKER3 = 3
+    BARKER4 = 4
+    BARKER5 = 5
+    BARKER7 = 6
+    BARKER11 = 7
+    BARKER13 = 8
+    AC128 = 9
+    COMPLEMENTARYCODE2 = 10
+    COMPLEMENTARYCODE4 = 11
+    COMPLEMENTARYCODE8 = 12
+    COMPLEMENTARYCODE16 = 13
+    COMPLEMENTARYCODE32 = 14
+    COMPLEMENTARYCODE64 = 15
+    COMPLEMENTARYCODE128 = 16
+    CODE_BINARY28 = 17
+
+
+class PROCFLAG:
+
     COHERENT_INTEGRATION = numpy.uint32(0x00000001)
-    DECODE_DATA = numpy.uint32(0x00000002) 
+    DECODE_DATA = numpy.uint32(0x00000002)
     SPECTRA_CALC = numpy.uint32(0x00000004)
-    INCOHERENT_INTEGRATION = numpy.uint32(0x00000008) 
+    INCOHERENT_INTEGRATION = numpy.uint32(0x00000008)
     POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
     SHIFT_FFT_DATA = numpy.uint32(0x00000020)
-    
+
     DATATYPE_CHAR = numpy.uint32(0x00000040)
     DATATYPE_SHORT = numpy.uint32(0x00000080)
     DATATYPE_LONG = numpy.uint32(0x00000100)
     DATATYPE_INT64 = numpy.uint32(0x00000200)
     DATATYPE_FLOAT = numpy.uint32(0x00000400)
     DATATYPE_DOUBLE = numpy.uint32(0x00000800)
-    
-    DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000) 
-    DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000) 
-    DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000) 
-    
+
+    DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000)
+    DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000)
+    DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000)
+
     SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
-    DEFLIP_DATA = numpy.uint32(0x00010000)    
-    DEFINE_PROCESS_CODE = numpy.uint32(0x00020000) 
-     
+    DEFLIP_DATA = numpy.uint32(0x00010000)
+    DEFINE_PROCESS_CODE = numpy.uint32(0x00020000)
+
     ACQ_SYS_NATALIA = numpy.uint32(0x00040000)
     ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000)
     ACQ_SYS_ADRXD = numpy.uint32(0x000C0000)
     ACQ_SYS_JULIA = numpy.uint32(0x00100000)
     ACQ_SYS_XXXXXX = numpy.uint32(0x00140000)
-    
+
     EXP_NAME_ESP = numpy.uint32(0x00200000)
     CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
-        
+
     OPERATION_MASK = numpy.uint32(0x0000003F)
     DATATYPE_MASK = numpy.uint32(0x00000FC0)
     DATAARRANGE_MASK = numpy.uint32(0x00007000)
     ACQ_SYS_MASK = numpy.uint32(0x001C0000)
-    
-dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
-dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
-dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
-dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
-dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
-dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
+
+
+dtype0 = numpy.dtype([('real', '<i1'), ('imag', '<i1')])
+dtype1 = numpy.dtype([('real', '<i2'), ('imag', '<i2')])
+dtype2 = numpy.dtype([('real', '<i4'), ('imag', '<i4')])
+dtype3 = numpy.dtype([('real', '<i8'), ('imag', '<i8')])
+dtype4 = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
+dtype5 = numpy.dtype([('real', '<f8'), ('imag', '<f8')])
 
 NUMPY_DTYPE_LIST = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
 
-PROCFLAG_DTYPE_LIST =  [PROCFLAG.DATATYPE_CHAR, 
-                       PROCFLAG.DATATYPE_SHORT, 
-                       PROCFLAG.DATATYPE_LONG, 
-                       PROCFLAG.DATATYPE_INT64, 
-                       PROCFLAG.DATATYPE_FLOAT, 
+PROCFLAG_DTYPE_LIST = [PROCFLAG.DATATYPE_CHAR,
+                       PROCFLAG.DATATYPE_SHORT,
+                       PROCFLAG.DATATYPE_LONG,
+                       PROCFLAG.DATATYPE_INT64,
+                       PROCFLAG.DATATYPE_FLOAT,
                        PROCFLAG.DATATYPE_DOUBLE]
 
 DTYPE_WIDTH = [1, 2, 4, 8, 4, 8]
 
+
 def get_dtype_index(numpy_dtype):
-    
+
     index = None
-    
+
     for i in range(len(NUMPY_DTYPE_LIST)):
         if numpy_dtype == NUMPY_DTYPE_LIST[i]:
             index = i
             break
-    
+
     return index
 
+
 def get_numpy_dtype(index):
-    
+
     return NUMPY_DTYPE_LIST[index]
 
+
 def get_procflag_dtype(index):
-    
+
     return PROCFLAG_DTYPE_LIST[index]
 
+
 def get_dtype_width(index):
-    
-    return DTYPE_WIDTH[index]
\ No newline at end of file
+
+    return DTYPE_WIDTH[index]
diff --git a/schainpy/model/io/jroIO_digitalRF.py b/schainpy/model/io/jroIO_digitalRF.py
index 7dd665a..d9e120f 100644
--- a/schainpy/model/io/jroIO_digitalRF.py
+++ b/schainpy/model/io/jroIO_digitalRF.py
@@ -657,11 +657,11 @@ class DigitalRFWriter(Operation):
         self.metadata_dict['flagDecodeData'] = self.dataOut.flagDecodeData
         self.metadata_dict['flagDeflipData'] = self.dataOut.flagDeflipData
         self.metadata_dict['flagShiftFFT'] = self.dataOut.flagShiftFFT
-        self.metadata_dict['flagDataAsBlock'] = self.dataOut.flagDataAsBlock
         self.metadata_dict['useLocalTime'] = self.dataOut.useLocalTime
         self.metadata_dict['nCohInt'] = self.dataOut.nCohInt
-
-        return
+        self.metadata_dict['type'] = self.dataOut.type
+        self.metadata_dict['flagDataAsBlock'] = getattr(
+            self.dataOut, 'flagDataAsBlock', None)  # chequear
 
     def setup(self, dataOut, path, frequency, fileCadence, dirCadence, metadataCadence, set=0, metadataFile='metadata', ext='.h5'):
         '''
@@ -678,10 +678,14 @@ class DigitalRFWriter(Operation):
             self.__dtype = dataOut.dtype[0]
         self.__nSamples = dataOut.systemHeaderObj.nSamples
         self.__nProfiles = dataOut.nProfiles
-        self.__blocks_per_file = dataOut.processingHeaderObj.dataBlocksPerFile
 
-        self.arr_data = arr_data = numpy.ones((self.__nSamples, len(
-            self.dataOut.channelList)), dtype=[('r', self.__dtype), ('i', self.__dtype)])
+        if self.dataOut.type != 'Voltage':
+            raise 'Digital RF cannot be used with this data type'
+            self.arr_data = numpy.ones((1, dataOut.nFFTPoints * len(
+                self.dataOut.channelList)), dtype=[('r', self.__dtype), ('i', self.__dtype)])
+        else:
+            self.arr_data = numpy.ones((self.__nSamples, len(
+                self.dataOut.channelList)), dtype=[('r', self.__dtype), ('i', self.__dtype)])
 
         file_cadence_millisecs = 1000
 
@@ -702,14 +706,11 @@ class DigitalRFWriter(Operation):
                                                           fileCadence, start_global_index,
                                                           sample_rate_numerator, sample_rate_denominator, uuid, compression_level, checksum,
                                                           is_complex, num_subchannels, is_continuous, marching_periods)
-
         metadata_dir = os.path.join(path, 'metadata')
         os.system('mkdir %s' % (metadata_dir))
-
         self.digitalMetadataWriteObj = digital_rf.DigitalMetadataWriter(metadata_dir, dirCadence, 1,  # 236, file_cadence_millisecs / 1000
                                                                         sample_rate_numerator, sample_rate_denominator,
                                                                         metadataFile)
-
         self.isConfig = True
         self.currentSample = 0
         self.oldAverage = 0
@@ -717,7 +718,6 @@ class DigitalRFWriter(Operation):
         return
 
     def writeMetadata(self):
-        print '[Writing] - Writing metadata'
         start_idx = self.__sample_rate * self.dataOut.utctime
 
         self.metadata_dict['processingHeader'] = self.dataOut.processingHeaderObj.getAsDict(
@@ -741,10 +741,19 @@ class DigitalRFWriter(Operation):
         return
 
     def writeData(self):
-        for i in range(self.dataOut.systemHeaderObj.nSamples):
+        if self.dataOut.type != 'Voltage':
+            raise 'Digital RF cannot be used with this data type'
             for channel in self.dataOut.channelList:
-                self.arr_data[i][channel]['r'] = self.dataOut.data[channel][i].real
-                self.arr_data[i][channel]['i'] = self.dataOut.data[channel][i].imag
+                for i in range(self.dataOut.nFFTPoints):
+                    self.arr_data[1][channel * self.dataOut.nFFTPoints +
+                                     i]['r'] = self.dataOut.data[channel][i].real
+                    self.arr_data[1][channel * self.dataOut.nFFTPoints +
+                                     i]['i'] = self.dataOut.data[channel][i].imag
+        else:
+            for i in range(self.dataOut.systemHeaderObj.nSamples):
+                for channel in self.dataOut.channelList:
+                    self.arr_data[i][channel]['r'] = self.dataOut.data[channel][i].real
+                    self.arr_data[i][channel]['i'] = self.dataOut.data[channel][i].imag
 
         def f(): return self.digitalWriteObj.rf_write(self.arr_data)
         self.timeit(f)
diff --git a/schainpy/model/proc/jroproc_spectra.py b/schainpy/model/proc/jroproc_spectra.py
index 3832045..dff41e9 100644
--- a/schainpy/model/proc/jroproc_spectra.py
+++ b/schainpy/model/proc/jroproc_spectra.py
@@ -6,6 +6,7 @@ from jroproc_base import ProcessingUnit, Operation
 from schainpy.model.data.jrodata import Spectra
 from schainpy.model.data.jrodata import hildebrand_sekhon
 
+
 class SpectraProc(ProcessingUnit):
 
     def __init__(self, **kwargs):
@@ -25,12 +26,15 @@ class SpectraProc(ProcessingUnit):
         self.dataOut.dstFlag = self.dataIn.dstFlag
         self.dataOut.errorCount = self.dataIn.errorCount
         self.dataOut.useLocalTime = self.dataIn.useLocalTime
-
+        try:
+            self.dataOut.processingHeaderObj = self.dataIn.processingHeaderObj.copy()
+        except:
+            pass
         self.dataOut.radarControllerHeaderObj = self.dataIn.radarControllerHeaderObj.copy()
         self.dataOut.systemHeaderObj = self.dataIn.systemHeaderObj.copy()
         self.dataOut.channelList = self.dataIn.channelList
         self.dataOut.heightList = self.dataIn.heightList
-        self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
+        self.dataOut.dtype = numpy.dtype([('real', '<f4'), ('imag', '<f4')])
 
         self.dataOut.nBaud = self.dataIn.nBaud
         self.dataOut.nCode = self.dataIn.nCode
@@ -39,8 +43,10 @@ class SpectraProc(ProcessingUnit):
 
         self.dataOut.flagDiscontinuousBlock = self.dataIn.flagDiscontinuousBlock
         self.dataOut.utctime = self.firstdatatime
-        self.dataOut.flagDecodeData = self.dataIn.flagDecodeData #asumo q la data esta decodificada
-        self.dataOut.flagDeflipData = self.dataIn.flagDeflipData #asumo q la data esta sin flip
+        # asumo q la data esta decodificada
+        self.dataOut.flagDecodeData = self.dataIn.flagDecodeData
+        # asumo q la data esta sin flip
+        self.dataOut.flagDeflipData = self.dataIn.flagDeflipData
         self.dataOut.flagShiftFFT = False
 
         self.dataOut.nCohInt = self.dataIn.nCohInt
@@ -71,12 +77,13 @@ class SpectraProc(ProcessingUnit):
             self.buffer
             self.dataOut.flagNoData
         """
-        fft_volt = numpy.fft.fft(self.buffer,n=self.dataOut.nFFTPoints,axis=1)
+        fft_volt = numpy.fft.fft(
+            self.buffer, n=self.dataOut.nFFTPoints, axis=1)
         fft_volt = fft_volt.astype(numpy.dtype('complex'))
-        dc = fft_volt[:,0,:]
+        dc = fft_volt[:, 0, :]
 
-        #calculo de self-spectra
-        fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
+        # calculo de self-spectra
+        fft_volt = numpy.fft.fftshift(fft_volt, axes=(1,))
         spc = fft_volt * numpy.conjugate(fft_volt)
         spc = spc.real
 
@@ -87,15 +94,19 @@ class SpectraProc(ProcessingUnit):
         cspc = None
         pairIndex = 0
         if self.dataOut.pairsList != None:
-            #calculo de cross-spectra
-            cspc = numpy.zeros((self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
+            # calculo de cross-spectra
+            cspc = numpy.zeros(
+                (self.dataOut.nPairs, self.dataOut.nFFTPoints, self.dataOut.nHeights), dtype='complex')
             for pair in self.dataOut.pairsList:
                 if pair[0] not in self.dataOut.channelList:
-                    raise ValueError, "Error getting CrossSpectra: pair 0 of %s is not in channelList = %s" %(str(pair), str(self.dataOut.channelList))
+                    raise ValueError, "Error getting CrossSpectra: pair 0 of %s is not in channelList = %s" % (
+                        str(pair), str(self.dataOut.channelList))
                 if pair[1] not in self.dataOut.channelList:
-                    raise ValueError, "Error getting CrossSpectra: pair 1 of %s is not in channelList = %s" %(str(pair), str(self.dataOut.channelList))
+                    raise ValueError, "Error getting CrossSpectra: pair 1 of %s is not in channelList = %s" % (
+                        str(pair), str(self.dataOut.channelList))
 
-                cspc[pairIndex,:,:] = fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:])
+                cspc[pairIndex, :, :] = fft_volt[pair[0], :, :] * \
+                    numpy.conjugate(fft_volt[pair[1], :, :])
                 pairIndex += 1
             blocksize += cspc.size
 
@@ -112,7 +123,7 @@ class SpectraProc(ProcessingUnit):
         if self.dataIn.type == "Spectra":
             self.dataOut.copy(self.dataIn)
             if not pairsList:
-                pairsList = itertools.combinations(self.dataOut.channelList, 2)            
+                pairsList = itertools.combinations(self.dataOut.channelList, 2)
             if self.dataOut.data_cspc is not None:
                 self.__selectPairs(pairsList)
             return True
@@ -134,13 +145,13 @@ class SpectraProc(ProcessingUnit):
             self.dataOut.pairsList = pairsList
 
             if self.buffer is None:
-                self.buffer = numpy.zeros( (self.dataIn.nChannels,
-                                            nProfiles,
-                                            self.dataIn.nHeights),
+                self.buffer = numpy.zeros((self.dataIn.nChannels,
+                                           nProfiles,
+                                           self.dataIn.nHeights),
                                           dtype='complex')
 
             if self.dataIn.flagDataAsBlock:
-                #data dimension: [nChannels, nProfiles, nSamples]
+                # data dimension: [nChannels, nProfiles, nSamples]
                 nVoltProfiles = self.dataIn.data.shape[1]
             #                 nVoltProfiles = self.dataIn.nProfiles
 
@@ -154,16 +165,18 @@ class SpectraProc(ProcessingUnit):
                         self.id_min = 0
                         self.id_max = nVoltProfiles
 
-                    self.buffer[:,self.id_min:self.id_max,:] = self.dataIn.data
+                    self.buffer[:, self.id_min:self.id_max,
+                                :] = self.dataIn.data
                     self.profIndex += nVoltProfiles
                     self.id_min += nVoltProfiles
                     self.id_max += nVoltProfiles
                 else:
-                    raise ValueError, "The type object %s has %d profiles, it should just has %d profiles"%(self.dataIn.type,self.dataIn.data.shape[1],nProfiles)
+                    raise ValueError, "The type object %s has %d profiles, it should just has %d profiles" % (
+                        self.dataIn.type, self.dataIn.data.shape[1], nProfiles)
                     self.dataOut.flagNoData = True
                     return 0
             else:
-                self.buffer[:,self.profIndex,:] = self.dataIn.data.copy()
+                self.buffer[:, self.profIndex, :] = self.dataIn.data.copy()
                 self.profIndex += 1
 
             if self.firstdatatime == None:
@@ -179,11 +192,12 @@ class SpectraProc(ProcessingUnit):
 
             return True
 
-        raise ValueError, "The type of input object '%s' is not valid"%(self.dataIn.type)
+        raise ValueError, "The type of input object '%s' is not valid" % (
+            self.dataIn.type)
 
     def __selectPairs(self, pairsList):
 
-        if not pairsList:            
+        if not pairsList:
             return
 
         pairs = []
@@ -194,7 +208,7 @@ class SpectraProc(ProcessingUnit):
                 continue
             pairs.append(pair)
             pairsIndex.append(pairs.index(pair))
-                
+
         self.dataOut.data_cspc = self.dataOut.data_cspc[pairsIndex]
         self.dataOut.pairsList = pairs
 
@@ -207,10 +221,10 @@ class SpectraProc(ProcessingUnit):
 
         pairsIndexListSelected = []
         for pairIndex in self.dataOut.pairsIndexList:
-            #First pair
+            # First pair
             if self.dataOut.pairsList[pairIndex][0] not in channelList:
                 continue
-            #Second pair
+            # Second pair
             if self.dataOut.pairsList[pairIndex][1] not in channelList:
                 continue
 
@@ -222,7 +236,8 @@ class SpectraProc(ProcessingUnit):
             return
 
         self.dataOut.data_cspc = self.dataOut.data_cspc[pairsIndexListSelected]
-        self.dataOut.pairsList = [self.dataOut.pairsList[i] for i in pairsIndexListSelected]
+        self.dataOut.pairsList = [self.dataOut.pairsList[i]
+                                  for i in pairsIndexListSelected]
 
         return
 
@@ -232,7 +247,8 @@ class SpectraProc(ProcessingUnit):
 
         for channel in channelList:
             if channel not in self.dataOut.channelList:
-                raise ValueError, "Error selecting channels, Channel %d is not valid.\nAvailable channels = %s" %(channel, str(self.dataOut.channelList))
+                raise ValueError, "Error selecting channels, Channel %d is not valid.\nAvailable channels = %s" % (
+                    channel, str(self.dataOut.channelList))
 
             index = self.dataOut.channelList.index(channel)
             channelIndexList.append(index)
@@ -257,17 +273,19 @@ class SpectraProc(ProcessingUnit):
 
         for channelIndex in channelIndexList:
             if channelIndex not in self.dataOut.channelIndexList:
-                raise ValueError, "Error selecting channels: The value %d in channelIndexList is not valid.\nAvailable channel indexes = " %(channelIndex, self.dataOut.channelIndexList)
+                raise ValueError, "Error selecting channels: The value %d in channelIndexList is not valid.\nAvailable channel indexes = " % (
+                    channelIndex, self.dataOut.channelIndexList)
 
 #         nChannels = len(channelIndexList)
 
-        data_spc = self.dataOut.data_spc[channelIndexList,:]
-        data_dc = self.dataOut.data_dc[channelIndexList,:]
+        data_spc = self.dataOut.data_spc[channelIndexList, :]
+        data_dc = self.dataOut.data_dc[channelIndexList, :]
 
         self.dataOut.data_spc = data_spc
         self.dataOut.data_dc = data_dc
 
-        self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
+        self.dataOut.channelList = [
+            self.dataOut.channelList[i] for i in channelIndexList]
 #        self.dataOut.nChannels = nChannels
 
         self.__selectPairsByChannel(self.dataOut.channelList)
@@ -291,7 +309,8 @@ class SpectraProc(ProcessingUnit):
         """
 
         if (minHei > maxHei):
-            raise ValueError, "Error selecting heights: Height range (%d,%d) is not valid" % (minHei, maxHei)
+            raise ValueError, "Error selecting heights: Height range (%d,%d) is not valid" % (
+                minHei, maxHei)
 
         if (minHei < self.dataOut.heightList[0]):
             minHei = self.dataOut.heightList[0]
@@ -320,20 +339,23 @@ class SpectraProc(ProcessingUnit):
 
         return 1
 
-    def getBeaconSignal(self, tauindex = 0, channelindex = 0, hei_ref=None):
-        newheis = numpy.where(self.dataOut.heightList>self.dataOut.radarControllerHeaderObj.Taus[tauindex])
+    def getBeaconSignal(self, tauindex=0, channelindex=0, hei_ref=None):
+        newheis = numpy.where(
+            self.dataOut.heightList > self.dataOut.radarControllerHeaderObj.Taus[tauindex])
 
         if hei_ref != None:
-            newheis = numpy.where(self.dataOut.heightList>hei_ref)
+            newheis = numpy.where(self.dataOut.heightList > hei_ref)
 
         minIndex = min(newheis[0])
         maxIndex = max(newheis[0])
-        data_spc = self.dataOut.data_spc[:,:,minIndex:maxIndex+1]
-        heightList = self.dataOut.heightList[minIndex:maxIndex+1]
+        data_spc = self.dataOut.data_spc[:, :, minIndex:maxIndex + 1]
+        heightList = self.dataOut.heightList[minIndex:maxIndex + 1]
 
         # determina indices
-        nheis = int(self.dataOut.radarControllerHeaderObj.txB/(self.dataOut.heightList[1]-self.dataOut.heightList[0]))
-        avg_dB = 10*numpy.log10(numpy.sum(data_spc[channelindex,:,:],axis=0))
+        nheis = int(self.dataOut.radarControllerHeaderObj.txB /
+                    (self.dataOut.heightList[1] - self.dataOut.heightList[0]))
+        avg_dB = 10 * \
+            numpy.log10(numpy.sum(data_spc[channelindex, :, :], axis=0))
         beacon_dB = numpy.sort(avg_dB)[-nheis:]
         beacon_heiIndexList = []
         for val in avg_dB.tolist():
@@ -343,12 +365,12 @@ class SpectraProc(ProcessingUnit):
         #data_spc = data_spc[:,:,beacon_heiIndexList]
         data_cspc = None
         if self.dataOut.data_cspc is not None:
-            data_cspc = self.dataOut.data_cspc[:,:,minIndex:maxIndex+1]
+            data_cspc = self.dataOut.data_cspc[:, :, minIndex:maxIndex + 1]
             #data_cspc = data_cspc[:,:,beacon_heiIndexList]
 
         data_dc = None
         if self.dataOut.data_dc is not None:
-            data_dc = self.dataOut.data_dc[:,minIndex:maxIndex+1]
+            data_dc = self.dataOut.data_dc[:, minIndex:maxIndex + 1]
             #data_dc = data_dc[:,beacon_heiIndexList]
 
         self.dataOut.data_spc = data_spc
@@ -359,7 +381,6 @@ class SpectraProc(ProcessingUnit):
 
         return 1
 
-
     def selectHeightsByIndex(self, minIndex, maxIndex):
         """
         Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
@@ -380,104 +401,107 @@ class SpectraProc(ProcessingUnit):
         """
 
         if (minIndex < 0) or (minIndex > maxIndex):
-            raise ValueError, "Error selecting heights: Index range (%d,%d) is not valid" % (minIndex, maxIndex)
+            raise ValueError, "Error selecting heights: Index range (%d,%d) is not valid" % (
+                minIndex, maxIndex)
 
         if (maxIndex >= self.dataOut.nHeights):
-            maxIndex = self.dataOut.nHeights-1
+            maxIndex = self.dataOut.nHeights - 1
 
-        #Spectra
-        data_spc = self.dataOut.data_spc[:,:,minIndex:maxIndex+1]
+        # Spectra
+        data_spc = self.dataOut.data_spc[:, :, minIndex:maxIndex + 1]
 
         data_cspc = None
         if self.dataOut.data_cspc is not None:
-            data_cspc = self.dataOut.data_cspc[:,:,minIndex:maxIndex+1]
+            data_cspc = self.dataOut.data_cspc[:, :, minIndex:maxIndex + 1]
 
         data_dc = None
         if self.dataOut.data_dc is not None:
-            data_dc = self.dataOut.data_dc[:,minIndex:maxIndex+1]
+            data_dc = self.dataOut.data_dc[:, minIndex:maxIndex + 1]
 
         self.dataOut.data_spc = data_spc
         self.dataOut.data_cspc = data_cspc
         self.dataOut.data_dc = data_dc
 
-        self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex+1]
+        self.dataOut.heightList = self.dataOut.heightList[minIndex:maxIndex + 1]
 
         return 1
 
-    def removeDC(self, mode = 2):
+    def removeDC(self, mode=2):
         jspectra = self.dataOut.data_spc
         jcspectra = self.dataOut.data_cspc
 
-
         num_chan = jspectra.shape[0]
         num_hei = jspectra.shape[2]
 
         if jcspectra is not None:
             jcspectraExist = True
             num_pairs = jcspectra.shape[0]
-        else:   jcspectraExist = False
+        else:
+            jcspectraExist = False
 
-        freq_dc = jspectra.shape[1]/2
-        ind_vel = numpy.array([-2,-1,1,2]) + freq_dc
+        freq_dc = jspectra.shape[1] / 2
+        ind_vel = numpy.array([-2, -1, 1, 2]) + freq_dc
 
-        if ind_vel[0]<0:
-            ind_vel[range(0,1)] = ind_vel[range(0,1)] + self.num_prof
+        if ind_vel[0] < 0:
+            ind_vel[range(0, 1)] = ind_vel[range(0, 1)] + self.num_prof
 
         if mode == 1:
-            jspectra[:,freq_dc,:] = (jspectra[:,ind_vel[1],:] + jspectra[:,ind_vel[2],:])/2 #CORRECCION
+            jspectra[:, freq_dc, :] = (
+                jspectra[:, ind_vel[1], :] + jspectra[:, ind_vel[2], :]) / 2  # CORRECCION
 
             if jcspectraExist:
-                jcspectra[:,freq_dc,:] = (jcspectra[:,ind_vel[1],:] + jcspectra[:,ind_vel[2],:])/2
+                jcspectra[:, freq_dc, :] = (
+                    jcspectra[:, ind_vel[1], :] + jcspectra[:, ind_vel[2], :]) / 2
 
         if mode == 2:
 
-            vel = numpy.array([-2,-1,1,2])
-            xx = numpy.zeros([4,4])
+            vel = numpy.array([-2, -1, 1, 2])
+            xx = numpy.zeros([4, 4])
 
             for fil in range(4):
-                xx[fil,:] = vel[fil]**numpy.asarray(range(4))
+                xx[fil, :] = vel[fil]**numpy.asarray(range(4))
 
             xx_inv = numpy.linalg.inv(xx)
-            xx_aux = xx_inv[0,:]
+            xx_aux = xx_inv[0, :]
 
             for ich in range(num_chan):
-                yy = jspectra[ich,ind_vel,:]
-                jspectra[ich,freq_dc,:] = numpy.dot(xx_aux,yy)
+                yy = jspectra[ich, ind_vel, :]
+                jspectra[ich, freq_dc, :] = numpy.dot(xx_aux, yy)
 
-                junkid = jspectra[ich,freq_dc,:]<=0
+                junkid = jspectra[ich, freq_dc, :] <= 0
                 cjunkid = sum(junkid)
 
                 if cjunkid.any():
-                    jspectra[ich,freq_dc,junkid.nonzero()] = (jspectra[ich,ind_vel[1],junkid] + jspectra[ich,ind_vel[2],junkid])/2
+                    jspectra[ich, freq_dc, junkid.nonzero()] = (
+                        jspectra[ich, ind_vel[1], junkid] + jspectra[ich, ind_vel[2], junkid]) / 2
 
             if jcspectraExist:
                 for ip in range(num_pairs):
-                    yy = jcspectra[ip,ind_vel,:]
-                    jcspectra[ip,freq_dc,:] = numpy.dot(xx_aux,yy)
-
+                    yy = jcspectra[ip, ind_vel, :]
+                    jcspectra[ip, freq_dc, :] = numpy.dot(xx_aux, yy)
 
         self.dataOut.data_spc = jspectra
         self.dataOut.data_cspc = jcspectra
 
         return 1
 
-    def removeInterference(self,  interf = 2,hei_interf = None, nhei_interf = None, offhei_interf = None):
+    def removeInterference(self,  interf=2, hei_interf=None, nhei_interf=None, offhei_interf=None):
 
         jspectra = self.dataOut.data_spc
         jcspectra = self.dataOut.data_cspc
         jnoise = self.dataOut.getNoise()
         num_incoh = self.dataOut.nIncohInt
 
-        num_channel  = jspectra.shape[0]
-        num_prof  = jspectra.shape[1]
-        num_hei   = jspectra.shape[2]
+        num_channel = jspectra.shape[0]
+        num_prof = jspectra.shape[1]
+        num_hei = jspectra.shape[2]
 
-        #hei_interf
+        # hei_interf
         if hei_interf is None:
-            count_hei = num_hei/2   #Como es entero no importa
+            count_hei = num_hei / 2  # Como es entero no importa
             hei_interf = numpy.asmatrix(range(count_hei)) + num_hei - count_hei
             hei_interf = numpy.asarray(hei_interf)[0]
-        #nhei_interf
+        # nhei_interf
         if (nhei_interf == None):
             nhei_interf = 5
         if (nhei_interf < 1):
@@ -492,136 +516,153 @@ class SpectraProc(ProcessingUnit):
 #         mask_prof[range(num_prof/2 - 1,len(mask_prof))] += 1
         mask_prof = numpy.asarray(range(num_prof))
         num_mask_prof = mask_prof.size
-        comp_mask_prof = [0, num_prof/2]
-
+        comp_mask_prof = [0, num_prof / 2]
 
-        #noise_exist:    Determina si la variable jnoise ha sido definida y contiene la informacion del ruido de cada canal
+        # noise_exist:    Determina si la variable jnoise ha sido definida y contiene la informacion del ruido de cada canal
         if (jnoise.size < num_channel or numpy.isnan(jnoise).any()):
             jnoise = numpy.nan
         noise_exist = jnoise[0] < numpy.Inf
 
-        #Subrutina de Remocion de la Interferencia
+        # Subrutina de Remocion de la Interferencia
         for ich in range(num_channel):
-            #Se ordena los espectros segun su potencia (menor a mayor)
-            power = jspectra[ich,mask_prof,:]
-            power = power[:,hei_interf]
-            power = power.sum(axis = 0)
+            # Se ordena los espectros segun su potencia (menor a mayor)
+            power = jspectra[ich, mask_prof, :]
+            power = power[:, hei_interf]
+            power = power.sum(axis=0)
             psort = power.ravel().argsort()
 
-            #Se estima la interferencia promedio en los Espectros de Potencia empleando
-            junkspc_interf = jspectra[ich,:,hei_interf[psort[range(offhei_interf, nhei_interf + offhei_interf)]]]
+            # Se estima la interferencia promedio en los Espectros de Potencia empleando
+            junkspc_interf = jspectra[ich, :, hei_interf[psort[range(
+                offhei_interf, nhei_interf + offhei_interf)]]]
 
             if noise_exist:
-            #    tmp_noise = jnoise[ich] / num_prof
+                #    tmp_noise = jnoise[ich] / num_prof
                 tmp_noise = jnoise[ich]
             junkspc_interf = junkspc_interf - tmp_noise
             #junkspc_interf[:,comp_mask_prof] = 0
 
-            jspc_interf = junkspc_interf.sum(axis = 0) / nhei_interf
+            jspc_interf = junkspc_interf.sum(axis=0) / nhei_interf
             jspc_interf = jspc_interf.transpose()
-            #Calculando el espectro de interferencia promedio
-            noiseid =  numpy.where(jspc_interf <= tmp_noise/ numpy.sqrt(num_incoh))
+            # Calculando el espectro de interferencia promedio
+            noiseid = numpy.where(
+                jspc_interf <= tmp_noise / numpy.sqrt(num_incoh))
             noiseid = noiseid[0]
             cnoiseid = noiseid.size
-            interfid = numpy.where(jspc_interf > tmp_noise/ numpy.sqrt(num_incoh))
+            interfid = numpy.where(
+                jspc_interf > tmp_noise / numpy.sqrt(num_incoh))
             interfid = interfid[0]
             cinterfid = interfid.size
 
-            if (cnoiseid > 0):   jspc_interf[noiseid] = 0
+            if (cnoiseid > 0):
+                jspc_interf[noiseid] = 0
 
-            #Expandiendo los perfiles a limpiar
+            # Expandiendo los perfiles a limpiar
             if (cinterfid > 0):
-                new_interfid = (numpy.r_[interfid - 1, interfid, interfid + 1] + num_prof)%num_prof
+                new_interfid = (
+                    numpy.r_[interfid - 1, interfid, interfid + 1] + num_prof) % num_prof
                 new_interfid = numpy.asarray(new_interfid)
                 new_interfid = {x for x in new_interfid}
                 new_interfid = numpy.array(list(new_interfid))
                 new_cinterfid = new_interfid.size
-            else: new_cinterfid = 0
+            else:
+                new_cinterfid = 0
 
             for ip in range(new_cinterfid):
-                ind = junkspc_interf[:,new_interfid[ip]].ravel().argsort()
-                jspc_interf[new_interfid[ip]] = junkspc_interf[ind[nhei_interf/2],new_interfid[ip]]
-
+                ind = junkspc_interf[:, new_interfid[ip]].ravel().argsort()
+                jspc_interf[new_interfid[ip]
+                            ] = junkspc_interf[ind[nhei_interf / 2], new_interfid[ip]]
 
-            jspectra[ich,:,ind_hei] = jspectra[ich,:,ind_hei] - jspc_interf #Corregir indices
+            jspectra[ich, :, ind_hei] = jspectra[ich, :,
+                                                 ind_hei] - jspc_interf  # Corregir indices
 
-            #Removiendo la interferencia del punto de mayor interferencia
+            # Removiendo la interferencia del punto de mayor interferencia
             ListAux = jspc_interf[mask_prof].tolist()
             maxid = ListAux.index(max(ListAux))
 
-
             if cinterfid > 0:
-                for ip in range(cinterfid*(interf == 2) - 1):
-                    ind = (jspectra[ich,interfid[ip],:] < tmp_noise*(1 + 1/numpy.sqrt(num_incoh))).nonzero()
+                for ip in range(cinterfid * (interf == 2) - 1):
+                    ind = (jspectra[ich, interfid[ip], :] < tmp_noise *
+                           (1 + 1 / numpy.sqrt(num_incoh))).nonzero()
                     cind = len(ind)
 
                     if (cind > 0):
-                        jspectra[ich,interfid[ip],ind] = tmp_noise*(1 + (numpy.random.uniform(cind) - 0.5)/numpy.sqrt(num_incoh))
+                        jspectra[ich, interfid[ip], ind] = tmp_noise * \
+                            (1 + (numpy.random.uniform(cind) - 0.5) /
+                             numpy.sqrt(num_incoh))
 
-                ind = numpy.array([-2,-1,1,2])
-                xx = numpy.zeros([4,4])
+                ind = numpy.array([-2, -1, 1, 2])
+                xx = numpy.zeros([4, 4])
 
                 for id1 in range(4):
-                    xx[:,id1] = ind[id1]**numpy.asarray(range(4))
+                    xx[:, id1] = ind[id1]**numpy.asarray(range(4))
 
                 xx_inv = numpy.linalg.inv(xx)
-                xx = xx_inv[:,0]
-                ind = (ind + maxid + num_mask_prof)%num_mask_prof
-                yy = jspectra[ich,mask_prof[ind],:]
-                jspectra[ich,mask_prof[maxid],:] = numpy.dot(yy.transpose(),xx)
-
-
-            indAux = (jspectra[ich,:,:] < tmp_noise*(1-1/numpy.sqrt(num_incoh))).nonzero()
-            jspectra[ich,indAux[0],indAux[1]] = tmp_noise * (1 - 1/numpy.sqrt(num_incoh))
-
-        #Remocion de Interferencia en el Cross Spectra
-        if jcspectra is None: return jspectra, jcspectra
-        num_pairs = jcspectra.size/(num_prof*num_hei)
+                xx = xx_inv[:, 0]
+                ind = (ind + maxid + num_mask_prof) % num_mask_prof
+                yy = jspectra[ich, mask_prof[ind], :]
+                jspectra[ich, mask_prof[maxid], :] = numpy.dot(
+                    yy.transpose(), xx)
+
+            indAux = (jspectra[ich, :, :] < tmp_noise *
+                      (1 - 1 / numpy.sqrt(num_incoh))).nonzero()
+            jspectra[ich, indAux[0], indAux[1]] = tmp_noise * \
+                (1 - 1 / numpy.sqrt(num_incoh))
+
+        # Remocion de Interferencia en el Cross Spectra
+        if jcspectra is None:
+            return jspectra, jcspectra
+        num_pairs = jcspectra.size / (num_prof * num_hei)
         jcspectra = jcspectra.reshape(num_pairs, num_prof, num_hei)
 
         for ip in range(num_pairs):
 
             #-------------------------------------------
 
-            cspower = numpy.abs(jcspectra[ip,mask_prof,:])
-            cspower = cspower[:,hei_interf]
-            cspower = cspower.sum(axis = 0)
+            cspower = numpy.abs(jcspectra[ip, mask_prof, :])
+            cspower = cspower[:, hei_interf]
+            cspower = cspower.sum(axis=0)
 
             cspsort = cspower.ravel().argsort()
-            junkcspc_interf = jcspectra[ip,:,hei_interf[cspsort[range(offhei_interf, nhei_interf + offhei_interf)]]]
+            junkcspc_interf = jcspectra[ip, :, hei_interf[cspsort[range(
+                offhei_interf, nhei_interf + offhei_interf)]]]
             junkcspc_interf = junkcspc_interf.transpose()
-            jcspc_interf = junkcspc_interf.sum(axis = 1)/nhei_interf
+            jcspc_interf = junkcspc_interf.sum(axis=1) / nhei_interf
 
             ind = numpy.abs(jcspc_interf[mask_prof]).ravel().argsort()
 
-            median_real = numpy.median(numpy.real(junkcspc_interf[mask_prof[ind[range(3*num_prof/4)]],:]))
-            median_imag = numpy.median(numpy.imag(junkcspc_interf[mask_prof[ind[range(3*num_prof/4)]],:]))
-            junkcspc_interf[comp_mask_prof,:] = numpy.complex(median_real, median_imag)
+            median_real = numpy.median(numpy.real(
+                junkcspc_interf[mask_prof[ind[range(3 * num_prof / 4)]], :]))
+            median_imag = numpy.median(numpy.imag(
+                junkcspc_interf[mask_prof[ind[range(3 * num_prof / 4)]], :]))
+            junkcspc_interf[comp_mask_prof, :] = numpy.complex(
+                median_real, median_imag)
 
             for iprof in range(num_prof):
-                ind = numpy.abs(junkcspc_interf[iprof,:]).ravel().argsort()
-                jcspc_interf[iprof] = junkcspc_interf[iprof, ind[nhei_interf/2]]
+                ind = numpy.abs(junkcspc_interf[iprof, :]).ravel().argsort()
+                jcspc_interf[iprof] = junkcspc_interf[iprof,
+                                                      ind[nhei_interf / 2]]
 
-            #Removiendo la Interferencia
-            jcspectra[ip,:,ind_hei] = jcspectra[ip,:,ind_hei] - jcspc_interf
+            # Removiendo la Interferencia
+            jcspectra[ip, :, ind_hei] = jcspectra[ip,
+                                                  :, ind_hei] - jcspc_interf
 
             ListAux = numpy.abs(jcspc_interf[mask_prof]).tolist()
             maxid = ListAux.index(max(ListAux))
 
-            ind = numpy.array([-2,-1,1,2])
-            xx = numpy.zeros([4,4])
+            ind = numpy.array([-2, -1, 1, 2])
+            xx = numpy.zeros([4, 4])
 
             for id1 in range(4):
-                xx[:,id1] = ind[id1]**numpy.asarray(range(4))
+                xx[:, id1] = ind[id1]**numpy.asarray(range(4))
 
             xx_inv = numpy.linalg.inv(xx)
-            xx = xx_inv[:,0]
+            xx = xx_inv[:, 0]
 
-            ind = (ind + maxid + num_mask_prof)%num_mask_prof
-            yy = jcspectra[ip,mask_prof[ind],:]
-            jcspectra[ip,mask_prof[maxid],:] = numpy.dot(yy.transpose(),xx)
+            ind = (ind + maxid + num_mask_prof) % num_mask_prof
+            yy = jcspectra[ip, mask_prof[ind], :]
+            jcspectra[ip, mask_prof[maxid], :] = numpy.dot(yy.transpose(), xx)
 
-        #Guardar Resultados
+        # Guardar Resultados
         self.dataOut.data_spc = jspectra
         self.dataOut.data_cspc = jcspectra
 
@@ -635,7 +676,7 @@ class SpectraProc(ProcessingUnit):
         return 1
 
     def getNoise(self, minHei=None, maxHei=None, minVel=None, maxVel=None):
-        #validacion de rango
+        # validacion de rango
         if minHei == None:
             minHei = self.dataOut.heightList[0]
 
@@ -643,13 +684,13 @@ class SpectraProc(ProcessingUnit):
             maxHei = self.dataOut.heightList[-1]
 
         if (minHei < self.dataOut.heightList[0]) or (minHei > maxHei):
-            print 'minHei: %.2f is out of the heights range'%(minHei)
-            print 'minHei is setting to %.2f'%(self.dataOut.heightList[0])
+            print 'minHei: %.2f is out of the heights range' % (minHei)
+            print 'minHei is setting to %.2f' % (self.dataOut.heightList[0])
             minHei = self.dataOut.heightList[0]
 
         if (maxHei > self.dataOut.heightList[-1]) or (maxHei < minHei):
-            print 'maxHei: %.2f is out of the heights range'%(maxHei)
-            print 'maxHei is setting to %.2f'%(self.dataOut.heightList[-1])
+            print 'maxHei: %.2f is out of the heights range' % (maxHei)
+            print 'maxHei is setting to %.2f' % (self.dataOut.heightList[-1])
             maxHei = self.dataOut.heightList[-1]
 
         # validacion de velocidades
@@ -662,13 +703,13 @@ class SpectraProc(ProcessingUnit):
             maxVel = velrange[-1]
 
         if (minVel < velrange[0]) or (minVel > maxVel):
-            print 'minVel: %.2f is out of the velocity range'%(minVel)
-            print 'minVel is setting to %.2f'%(velrange[0])
+            print 'minVel: %.2f is out of the velocity range' % (minVel)
+            print 'minVel is setting to %.2f' % (velrange[0])
             minVel = velrange[0]
 
         if (maxVel > velrange[-1]) or (maxVel < minVel):
-            print 'maxVel: %.2f is out of the velocity range'%(maxVel)
-            print 'maxVel is setting to %.2f'%(velrange[-1])
+            print 'maxVel: %.2f is out of the velocity range' % (maxVel)
+            print 'maxVel is setting to %.2f' % (velrange[-1])
             maxVel = velrange[-1]
 
         # seleccion de indices para rango
@@ -690,10 +731,11 @@ class SpectraProc(ProcessingUnit):
             maxIndex = len(heights)
 
         if (minIndex < 0) or (minIndex > maxIndex):
-            raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
+            raise ValueError, "some value in (%d,%d) is not valid" % (
+                minIndex, maxIndex)
 
         if (maxIndex >= self.dataOut.nHeights):
-            maxIndex = self.dataOut.nHeights-1
+            maxIndex = self.dataOut.nHeights - 1
 
         # seleccion de indices para velocidades
         indminvel = numpy.where(velrange >= minVel)
@@ -708,24 +750,25 @@ class SpectraProc(ProcessingUnit):
         except:
             maxIndexVel = len(velrange)
 
-        #seleccion del espectro
-        data_spc = self.dataOut.data_spc[:,minIndexVel:maxIndexVel+1,minIndex:maxIndex+1]
-        #estimacion de ruido
+        # seleccion del espectro
+        data_spc = self.dataOut.data_spc[:,
+                                         minIndexVel:maxIndexVel + 1, minIndex:maxIndex + 1]
+        # estimacion de ruido
         noise = numpy.zeros(self.dataOut.nChannels)
 
         for channel in range(self.dataOut.nChannels):
-            daux = data_spc[channel,:,:]
+            daux = data_spc[channel, :, :]
             noise[channel] = hildebrand_sekhon(daux, self.dataOut.nIncohInt)
 
         self.dataOut.noise_estimation = noise.copy()
 
         return 1
 
-class IncohInt(Operation):
 
+class IncohInt(Operation):
 
     __profIndex = 0
-    __withOverapping  = False
+    __withOverapping = False
 
     __byTime = False
     __initime = None
@@ -742,8 +785,6 @@ class IncohInt(Operation):
 
     n = None
 
-
-
     def __init__(self, **kwargs):
 
         Operation.__init__(self, **kwargs)
@@ -778,12 +819,12 @@ class IncohInt(Operation):
         if n is not None:
             self.n = int(n)
         else:
-            self.__integrationtime = int(timeInterval) #if (type(timeInterval)!=integer) -> change this line
+            # if (type(timeInterval)!=integer) -> change this line
+            self.__integrationtime = int(timeInterval)
             self.n = None
             self.__byTime = True
 
     def putData(self, data_spc, data_cspc, data_dc):
-
         """
         Add a profile to the __buffer_spc and increase in one the __profileIndex
 
@@ -866,7 +907,8 @@ class IncohInt(Operation):
             self.__initime = datatime
 
         if self.__byTime:
-            avgdata_spc, avgdata_cspc, avgdata_dc = self.byTime(datatime, *args)
+            avgdata_spc, avgdata_cspc, avgdata_dc = self.byTime(
+                datatime, *args)
         else:
             avgdata_spc, avgdata_cspc, avgdata_dc = self.byProfiles(*args)
 
@@ -876,7 +918,7 @@ class IncohInt(Operation):
         return self.__initime, avgdata_spc, avgdata_cspc, avgdata_dc
 
     def run(self, dataOut, n=None, timeInterval=None, overlapping=False):
-        if n==1:
+        if n == 1:
             return
 
         dataOut.flagNoData = True