From f6891cff9cbe01bbc0a4cb3320d79b521fd0fabb 2012-04-03 19:12:35
From: Victor Sarmiento <victor.sarmiento@jro.igp.gob.pe>
Date: 2012-04-03 19:12:35
Subject: [PATCH] VOTAJEIO.py:
 Clase para la lectura y escritura de data de espectros.
 Valentin Sarmiento /  martes 3 de abril de 2012

---

diff --git a/schainpy/IO/VoltageIO.py b/schainpy/IO/VoltageIO.py
index 56b4df2..666f491 100644
--- a/schainpy/IO/VoltageIO.py
+++ b/schainpy/IO/VoltageIO.py
@@ -21,7 +21,40 @@ from IO.DataIO import DataWriter
 from Model.Voltage import Voltage
 
 
-def getlastFileFromPath( pathList, ext ):
+def isFileOK(filename):
+    """
+    Determina si la cabecera de un archivo es valido o no, si lo es entonces seria un archivo que podria contener data,
+    si no seria un archivo invalido
+    
+    Return:
+        True    :    si es un archivo valido
+        False   :    si no es un archivo valido
+        
+    Exceptions:
+        Si al leer la cabecera esta no coincide con el tipo de las variables que la contienen entonces se dispara
+        una exception 
+    """
+    m_BasicHeader = BasicHeader()
+    m_ProcessingHeader = ProcessingHeader()
+    m_RadarControllerHeader = RadarControllerHeader()
+    m_SystemHeader = SystemHeader()
+    fp = None
+    
+    try:
+        fp = open( filename,'rb' ) #lectura binaria
+        m_BasicHeader.read(fp)
+        m_SystemHeader.read(fp)
+        m_RadarControllerHeader.read(fp)
+        m_ProcessingHeader.read(fp)
+        fp.close()
+    except:
+        if fp != None: fp.close()
+        return False
+
+    return True
+    
+    
+def getlastFileFromPath(pathList,ext):
     """
     Depura el pathList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
     al final de la depuracion devuelve el ultimo file de la lista que quedo.  
@@ -58,9 +91,9 @@ def getlastFileFromPath( pathList, ext ):
     return filename
     
 
-def checkForRealPath( path, year, doy, set, ext ):
+def checkForRealPath(path,year,doy,set,ext):
     """
-    Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
+    Por ser Linux Case Sensitive la funcion checkForRealPath encuentra el nombre correcto de un path,
     Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
     el path exacto de un determinado file.
     
@@ -68,14 +101,14 @@ def checkForRealPath( path, year, doy, set, ext ):
         nombre correcto del file es  ../RAWDATA/D2009307/P2009307367
         
         Entonces la funcion prueba con las siguientes combinaciones
-            ../RAWDATA/d2009307/p2009307367
-            ../RAWDATA/d2009307/P2009307367
-            ../RAWDATA/D2009307/p2009307367
-            ../RAWDATA/D2009307/P2009307367
+            ../.../d2009307/d2009307367
+            ../.../d2009307/D2009307367
+            ../.../D2009307/d2009307367
+            ../.../D2009307/D2009307367
         siendo para este caso, la ultima combinacion de letras, identica al file buscado 
         
     Return:
-        Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file 
+        Si encuentra la combinacion adecuada devuelve el path completo y el nombre del file 
         caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas 
         para el filename  
     """
@@ -100,7 +133,7 @@ def checkForRealPath( path, year, doy, set, ext ):
     return filepath, filename
 
 
-def isNumber( str ):
+def isNumber(str):
     """
     Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
 
@@ -120,7 +153,7 @@ def isNumber( str ):
         return False
 
 
-def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
+def isThisFileinRange(filename,startUTSeconds,endUTSeconds):
     """
     Esta funcion determina si un archivo de datos  en formato Jicamarca(.r) se encuentra
     o no dentro del rango de fecha especificado.
@@ -159,6 +192,7 @@ def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
     
     return 1
 
+
 class VoltageReader(DataReader):
     """
     Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
@@ -200,8 +234,9 @@ class VoltageReader(DataReader):
     
     #speed of light
     __c = 3E8
+
     
-    def __init__(self, m_Voltage = None):
+    def __init__(self,m_Voltage=None):
         """
         Inicializador de la clase VoltageReader para la lectura de datos de voltage.
         
@@ -299,18 +334,23 @@ class VoltageReader(DataReader):
         self.__path = None
         self.__pts2read = 0
         self.__blocksize = 0
+        self.__utc = 0
+        self.nBlocks = 0
+
     
     def __rdSystemHeader(self,fp=None):
         if fp == None:
             fp = self.__fp
             
         self.m_SystemHeader.read(fp)
+
     
     def __rdRadarControllerHeader(self,fp=None):
         if fp == None:
             fp = self.__fp
             
         self.m_RadarControllerHeader.read(fp)
+
         
     def __rdProcessingHeader(self,fp=None):
         if fp == None:
@@ -318,15 +358,34 @@ class VoltageReader(DataReader):
             
         self.m_ProcessingHeader.read(fp)
 
-    def __rdBasicHeader(self, fp=None):
+
+    def __rdBasicHeader(self,fp=None):
         
         if fp == None:
             fp = self.__fp
             
         self.m_BasicHeader.read(fp)
+
     
     def __readFirstHeader(self):
-        
+        """ 
+        Lectura del First Header, es decir el Basic Header y el Long Header
+            
+        Affected:
+            self.m_BasicHeader
+            self.m_SystemHeader
+            self.m_RadarControllerHeader
+            self.m_ProcessingHeader
+            self.firstHeaderSize
+            self.__heights
+            self.__dataType
+            self.__fileSizeByHeader
+            self.__ippSeconds
+            self.__blocksize
+            self.__pts2read
+            
+        Return: None
+        """
         self.__rdBasicHeader()
         self.__rdSystemHeader()
         self.__rdRadarControllerHeader()
@@ -368,7 +427,7 @@ class VoltageReader(DataReader):
         self.__blocksize = self.__pts2read
 
         
-    def __setNextFileOnline( self ):
+    def __setNextFileOnline(self):
         """
         Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
         no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
@@ -392,12 +451,9 @@ class VoltageReader(DataReader):
         countFiles = 0
         countTries = 0
         
-        fileStatus = 0
         notFirstTime_flag = False
-        bChangeDir = False
-        
-        fileSize = 0
-        fp = None
+        fileOk_flag = False        
+        changeDir_flag = False
         
         self.__flagIsNewFile = 0
         
@@ -413,80 +469,73 @@ class VoltageReader(DataReader):
             if countFiles > self.__nFiles: #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
                 self.__set = 0
                 self.__doy += 1
-                bChangeDir = True 
+                changeDir_flag = True 
             
             file = None
             filename = None
+            fileOk_flag = False
+            
+            #busca el 1er file disponible
+            file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext )
+
+            if file == None:
+                if notFirstTime_flag: #si no es la primera vez que busca el file entonces no espera y busca for el siguiente file
+                    print "\tsearching next \"%s\" file ..." % ( filename )
+                    continue 
+                else: #si es la primera vez que busca el file entonces espera self.__nTries veces hasta encontrarlo o no 
+                    for nTries in range( self.__nTries ): 
+                        print "\twaiting new \"%s\" file, try %03d ..." % ( filename, nTries+1 ) 
+                        time.sleep( self.__delay )
+    
+                        file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext )
+                        if file != None:
+                            fileOk_flag = True
+                            break
+                        
+                    if not( fileOk_flag ): #no encontro ningun file valido a leer despues de haber esperado alguno
+                        notFirstTime_flag = True
+                        continue
+
+            #una vez que se obtuvo el 1er file valido se procede a checkear si si tamanho es suficiente para empezar a leerlo
+            currentSize = os.path.getsize( file )
+            neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
             
-            countTries = 0
+            #si el tamanho es suficiente entonces deja de buscar
+            if currentSize > neededSize:# and (neededSize != 0):
+                fileOk_flag = True
+                break
             
-            #espero hasta encontrar el 1er file disponible
-            while( True ):
-                
-                countTries += 1
-                if( countTries >= self.__nTries ): #checkeo que no haya ido mas alla de la cantidad de intentos
-                    break
-                
-                file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext )
-                if file != None:
-                    break
-                
-                if notFirstTime_flag: #este flag me sirve solo para esperar por el 1er file, en lo siguientes no espera solo checkea si existe o no
-                    countTries = self.__nTries
-                    print "\tsearching next \"%s\" file ..." % filename 
-                    break 
-                
-                print "\twaiting new \"%s\" file ..." % filename 
+            fileOk_flag = False
+            #si el file no tiene el tamanho necesario se espera una cierta cantidad de tiempo  
+            #por una cierta cantidad de veces hasta que el contenido del file sea valido
+            if changeDir_flag: #si al buscar un file cambie de directorio ya no espero y sigo con el siguiente file
+                print "\tsearching next \"%s\" file ..." % filename
+                changeDir_flag = False
+                continue
+
+            for nTries in range( self.__nTries ):
+                print "\twaiting for the First Header block of \"%s\" file, try %03d ..." % ( filename, nTries+1 ) 
                 time.sleep( self.__delay )
-                
-            if countTries >= self.__nTries: #se realizaron n intentos y no hubo un file nuevo 
-                notFirstTime_flag = True
-                continue #vuelvo al inico del while principal        
-            
-            countTries = 0
-            
-            #una vez que se obtuvo el 1er file valido se procede a checkear su contenido, y se espera una cierta cantidad
-            #de tiempo por una cierta cantidad de veces hasta que el contenido del file sea un contenido valido
-            while( True ):
-                countTries += 1
-                if countTries > self.__nTries:
-                    break
-                
-                try:
-                    fp = open(file)
-                except:
-                    print "The file \"%s\" can't be opened" % file
-                    break
-                
-                fileSize = os.path.getsize( file )
-                currentSize = fileSize - fp.tell()
+
+                currentSize = os.path.getsize( file )
                 neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
                 
                 if currentSize > neededSize:
-                    fileStatus = 1
-                    break
-                
-                fp.close()
-                
-                if bChangeDir: #si al buscar un file cambie de directorio ya no espero y salgo del bucle while
-                    print "\tsearching next \"%s\" file ..." % filename
+                    fileOk_flag = True
                     break
                 
-                print "\twaiting for block of \"%s\" file ..." % filename 
-                time.sleep( self.__delay )
-            
-            if fileStatus == 1:
+            if fileOk_flag: #si encontro un file valido sale del bucle y deja de buscar
                 break
             
             print "Skipping the file \"%s\" due to this files is empty" % filename
             countFiles = 0
         
-        
-        if fileStatus == 1:
-            self.fileSize = fileSize
+        if fileOk_flag:
+            self.fileSize = os.path.getsize( file ) #fileSize
             self.filename = file
             self.__flagIsNewFile = 1
-            self.__fp = fp
+            if self.__fp != None: self.__fp.close() 
+            self.__fp = open(file)
             self.noMoreFiles = 0
             print 'Setting the file: %s' % file
         else:
@@ -496,7 +545,7 @@ class VoltageReader(DataReader):
             self.noMoreFiles = 1
             print 'No more Files'
 
-        return fileStatus
+        return fileOk_flag
 
 
     def __setNextFileOffline(self):
@@ -508,6 +557,7 @@ class VoltageReader(DataReader):
             
             if not(idFile < len(self.filenameList)):
                 self.noMoreFiles = 1
+                print 'No more Files'
                 return 0
             
             filename = self.filenameList[idFile]
@@ -537,7 +587,8 @@ class VoltageReader(DataReader):
         
         return 1
 
-    def __setNextFile( self ):
+
+    def __setNextFile(self):
         """ 
         Determina el siguiente file a leer y si hay uno disponible lee el First Header
             
@@ -560,15 +611,18 @@ class VoltageReader(DataReader):
         else:
             newFile = self.__setNextFileOffline()
         
+        if self.noMoreFiles:
+            sys.exit(0)
+
         if not(newFile):
             return 0
-        
+
         self.__readFirstHeader()
-        
+        self.nBlocks = 0
         return 1
         
     
-    def __setNewBlock( self ):
+    def __setNewBlock(self):
         """ 
         Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
 
@@ -594,21 +648,28 @@ class VoltageReader(DataReader):
         if ( currentSize >= neededSize ):
             self.__rdBasicHeader()
             return 1
-        elif self.online:
-            nTries = 0
-            while( nTries < self.__nTries ):
-                nTries += 1 
-                print "Waiting for the next block, try %03d ..." % nTries
+        
+        #si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido
+        elif (self.nBlocks != self.m_ProcessingHeader.dataBlocksPerFile) and self.online:
+            for nTries in range( self.__nTries ):
+
+                fpointer = self.__fp.tell()
+                self.__fp.close()
+
+                print "\tWaiting for the next block, try %03d ..." % (nTries+1)
                 time.sleep( self.__delay )
-                
-                fileSize = os.path.getsize(self.filename)
-                currentSize = fileSize - self.__fp.tell()
+
+                self.__fp = open( self.filename, 'rb' )
+                self.__fp.seek( fpointer )
+
+                self.fileSize = os.path.getsize( self.filename )
+                currentSize = self.fileSize - self.__fp.tell()
                 neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
 
                 if ( currentSize >= neededSize ):
                     self.__rdBasicHeader()
                     return 1
-        
+                
         #Setting new file 
         if not( self.__setNextFile() ):
             return 0
@@ -619,9 +680,10 @@ class VoltageReader(DataReader):
         
         if deltaTime > self.__maxTimeStep:
             self.flagResetProcessing = 1
-            self.nReadBlocks = 0
+            #self.nReadBlocks = 0
             
         return 1
+
     
     def __readBlock(self):
         """
@@ -630,75 +692,70 @@ class VoltageReader(DataReader):
         (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
         es seteado a 0
         
-        
         Inputs:
             None
             
         Return:
             None
         
-        Variables afectadas:
-        
+        Affected:
             self.__datablockIndex
-            
             self.datablock
-            
             self.__flagIsNewFile
-            
             self.idProfile
-            
             self.flagIsNewBlock
-            
             self.nReadBlocks
             
+        Exceptions: 
+            Si un bloque leido no es un bloque valido
         """
-        
-        #pts2read = self.m_ProcessingHeader.profilesPerBlock*self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels
-        
+        blockOk_flag = False
         fpointer = self.__fp.tell()
         
         junk = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read )
         
         if self.online:
             if junk.size != self.__blocksize:
-                nTries = 0
-                while( nTries < self.__nTries ):
-                    nTries += 1 
-                    print "Waiting for the next block, try %03d ..." % nTries
+                for nTries in range( self.__nTries ):
+                    print "\tWaiting for the next block, try %03d ..." % (nTries+1)
                     time.sleep( self.__delay )
                     self.__fp.seek( fpointer )
                     fpointer = self.__fp.tell() 
                     junk = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read )
                     if junk.size == self.__blocksize:
-                        nTries = 0
+                        blockOk_flag = True
                         break
-                if nTries > 0:
-                    return
+                
+                if not( blockOk_flag ):
+                    return 0
         
-        junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
+        try:
+            junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
+        except:
+            print "Data file %s is invalid" % self.filename
+            return 0
         
-        data = junk['real'] + junk['imag']*1j
+        #data = junk['real'] + junk['imag']*1j
+        self.datablock = junk['real'] + junk['imag']*1j
         
         self.__datablockIndex = 0
-        
-        self.datablock = data
-        
         self.__flagIsNewFile = 0
-        
         self.idProfile = 0
-        
         self.flagIsNewBlock = 1
-        
+
         self.nReadBlocks += 1
+        self.nBlocks += 1
+          
+        return 1
+    
  
     def __hasNotDataInBuffer(self):
         if self.__datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
             return 1
-        
         return 0
 
 
-    def __searchFilesOnLine( self, path, startDateTime=None, ext = ".r" ):
+    def __searchFilesOnLine(self, path, startDateTime=None, ext = ".r"):
         """
         Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
         devuelve el archivo encontrado ademas de otros datos.
@@ -715,7 +772,6 @@ class VoltageReader(DataReader):
             filename    :    el ultimo file de una determinada carpeta
             directory   :    eL directorio donde esta el file encontrado
         """
-
         print "Searching files ..."
 
         dirList = []
@@ -728,7 +784,7 @@ class VoltageReader(DataReader):
 
             dirList = sorted( dirList, key=str.lower ) #para que quede ordenado al margen de si el nombre esta en mayusculas o minusculas, utilizo la funcion sorted 
             if len(dirList) > 0 :
-                directory = dirList[-1]
+                directory = dirList[-1] #me quedo con el ultimo directorio de una carpeta
         else:
             year = startDateTime.timetuple().tm_year
             doy = startDateTime.timetuple().tm_yday
@@ -804,7 +860,6 @@ class VoltageReader(DataReader):
         Excepciones:
         
         """
-        
         print "Searching files ..."
         
         dirList = []
@@ -863,17 +918,11 @@ class VoltageReader(DataReader):
     
         file = os.path.join( path, dirfilename, filename )
         
-        nTries = 0
-        while(True):
-            
-            nTries += 1
-            if nTries > self.__nTries:
-                break
-            
+        for nTries in range( self.__nTries+1 ):
             try:
                 fp = open( file,'rb' ) #lectura binaria
             except:
-                raise IOError, "The file %s can't be opened" %(file)
+                raise IOError, "The file %s can't be opened" % (file)
             
             try:
                 m_BasicHeader.read(fp)
@@ -881,13 +930,17 @@ class VoltageReader(DataReader):
                 print "The file %s is empty" % filename
             
             fp.close()
+            fp = None
             
             if m_BasicHeader.size > 24:
                 break
             
-            print 'waiting for new block: try %02d' % ( nTries )
-            time.sleep( self.__delay)
-            
+            if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar
+                break
+
+            print '\twaiting for new block: try %02d' % ( nTries )
+            time.sleep( self.__delay )
+
         if m_BasicHeader.size <= 24:
             return 0
         
@@ -938,24 +991,30 @@ class VoltageReader(DataReader):
             self.online
         """
         if online:
-            nTries = 0 
-            while( nTries < self.__nTries ):
-               nTries += 1 
-               subfolder = "D%04d%03d" % ( startDateTime.timetuple().tm_year, startDateTime.timetuple().tm_yday )
+            fileOK_flag = False
+            subfolder = "D%04d%03d" % ( startDateTime.timetuple().tm_year, startDateTime.timetuple().tm_yday )
+            file = os.path.join( path, subfolder )
+
+            for nTries in range( self.__nTries+1 ): #espera por el 1er file
                year, doy, set, filename, dirfilename = self.__searchFilesOnLine( path, startDateTime, ext )
-               if filename == None:
-                   file = os.path.join( path, subfolder )
-                   print "Searching first file in \"%s\", try %03d ..." % ( file, nTries ) 
-                   time.sleep( self.__delay )
-               else:
+               
+               if filename != None:
+                   if isFileOK( os.path.join( path,dirfilename,filename ) ): 
+                       fileOK_flag = True
+                       break
+               
+               if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar 
                    break
+               
+               print "Searching first file in \"%s\", try %03d ..." % ( file, nTries+1 ) 
+               time.sleep( self.__delay )
 
-            if filename == None:
-                print "No files  On Line"
+            if not( fileOK_flag ): #filename == None:
+                print "No files on line or invalid first file"
                 return 0
 
             if self.__initFilesOnline( path, dirfilename, filename ) == 0:
-                print "The file %s hasn't enough data"
+                print "The file %s hasn't enough data" % filename
                 return 0            
 
             self.__year = year
@@ -1001,7 +1060,7 @@ class VoltageReader(DataReader):
         return 1 
 
     
-    def readNextBlock( self ):
+    def readNextBlock(self):
         """ 
         Establece un nuevo bloque de datos a leer y los lee, si es que no existiese
         mas bloques disponibles en el archivo actual salta al siguiente.
@@ -1014,14 +1073,15 @@ class VoltageReader(DataReader):
         if not(self.__setNewBlock()):
             return 0
              
-        self.__readBlock()
+        if not( self.__readBlock() ):
+            return 0
         
         self.__lastUTTime = self.m_BasicHeader.utc
         
         return 1
 
     
-    def getData( self ):
+    def getData(self):
         """
         getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
         con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
@@ -1045,12 +1105,16 @@ class VoltageReader(DataReader):
             self.flagIsNewBlock
             self.idProfile
         """
+        if self.noMoreFiles: return 0
+         
         self.flagResetProcessing = 0
         self.flagIsNewBlock = 0
         
         if self.__hasNotDataInBuffer():
 
-            self.readNextBlock()
+            if not( self.readNextBlock() ):
+                self.__setNextFile()
+                return 0
             
             self.m_Voltage.m_BasicHeader = self.m_BasicHeader.copy()
             self.m_Voltage.m_ProcessingHeader = self.m_ProcessingHeader.copy()
@@ -1061,12 +1125,17 @@ class VoltageReader(DataReader):
             
         if self.noMoreFiles == 1:
             print 'Process finished'
-            return None
+            return 0
         
         #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
         
+        if self.datablock == None:
+            self.m_Voltage.flagNoData = True
+            return 0
+
         time = self.m_BasicHeader.utc + self.__datablockIndex * self.__ippSeconds
-        self.m_Voltage.m_BasicHeader.utc = time  
+        self.__utc = time
+        #self.m_Voltage.m_BasicHeader.utc = time  
         
         self.m_Voltage.flagNoData = False
         self.m_Voltage.flagResetProcessing = self.flagResetProcessing
@@ -1079,17 +1148,17 @@ class VoltageReader(DataReader):
         
         #call setData - to Data Object
     
-        return self.m_Voltage.data
+        return 1 #self.m_Voltage.data
 
 
-class VoltageWriter( DataWriter ):
+class VoltageWriter(DataWriter):
     """ 
     Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
     de los datos siempre se realiza por bloques. 
     """
     __configHeaderFile = 'wrSetHeadet.txt'
     
-    def __init__( self, m_Voltage = None ):
+    def __init__(self,m_Voltage=None):
         """ 
         Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
          
@@ -1146,7 +1215,7 @@ class VoltageWriter( DataWriter ):
         self.m_ProcessingHeader = ProcessingHeader()
 
     
-    def __writeFirstHeader( self ):
+    def __writeFirstHeader(self):
         """
         Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
         
@@ -1163,7 +1232,7 @@ class VoltageWriter( DataWriter ):
         self.__dataType = self.m_Voltage.dataType
 
     
-    def __writeBasicHeader( self, fp=None ):
+    def __writeBasicHeader(self,fp=None):
         """
         Escribe solo el Basic header en el file creado
 
@@ -1176,7 +1245,7 @@ class VoltageWriter( DataWriter ):
         self.m_BasicHeader.write(fp)
 
     
-    def __wrSystemHeader( self, fp=None ):
+    def __wrSystemHeader(self,fp=None):
         """
         Escribe solo el System header en el file creado
 
@@ -1189,7 +1258,7 @@ class VoltageWriter( DataWriter ):
         self.m_SystemHeader.write(fp)
 
     
-    def __wrRadarControllerHeader( self, fp=None ):
+    def __wrRadarControllerHeader(self,fp=None):
         """
         Escribe solo el RadarController header en el file creado
 
@@ -1202,7 +1271,7 @@ class VoltageWriter( DataWriter ):
         self.m_RadarControllerHeader.write(fp)
 
         
-    def __wrProcessingHeader( self, fp=None ):
+    def __wrProcessingHeader(self,fp=None):
         """
         Escribe solo el Processing header en el file creado
 
@@ -1214,7 +1283,8 @@ class VoltageWriter( DataWriter ):
             
         self.m_ProcessingHeader.write(fp)
     
-    def __setNextFile( self ):
+    
+    def __setNextFile(self):
         """ 
         Determina el siguiente file que sera escrito
 
@@ -1238,7 +1308,7 @@ class VoltageWriter( DataWriter ):
         if self.__fp != None:
             self.__fp.close()
         
-        """        
+        """
         timeTuple = time.localtime(self.m_Voltage.m_BasicHeader.utc) # utc from m_Voltage
         file = 'D%4.4d%3.3d%3.3d%s' % (timeTuple.tm_year,timeTuple.tm_yday,setFile,ext)
         subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday) 
@@ -1247,7 +1317,12 @@ class VoltageWriter( DataWriter ):
             os.mkdir(tmp)
         """
         ##################################
-        if self.m_BasicHeader.size <= 24: return 0 #no existe la suficiente data para ser escrita
+        """
+        if self.m_BasicHeader.size <= 24:
+            self.__fp.close()
+            self.__fp = None 
+            return 0 #no existe la suficiente data para ser escrita
+        """
         
         timeTuple = time.localtime( self.m_Voltage.m_BasicHeader.utc ) # utc from m_Voltage
         subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
@@ -1296,7 +1371,7 @@ class VoltageWriter( DataWriter ):
         return 1
 
     
-    def __setNewBlock( self ):
+    def __setNewBlock(self):
         """
         Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
         
@@ -1319,7 +1394,8 @@ class VoltageWriter( DataWriter ):
         
         return 1
     
-    def __writeBlock( self ):
+
+    def __writeBlock(self):
         """
         Escribe el buffer en el file designado
             
@@ -1342,19 +1418,14 @@ class VoltageWriter( DataWriter ):
         data.tofile( self.__fp )
         
         self.datablock.fill(0)
-        
         self.__datablockIndex = 0 
-        
         self.__flagIsNewFile = 0
-        
         self.flagIsNewBlock = 1
-        
         self.nWriteBlocks += 1
-        
         self.__blocksCounter += 1
     
 
-    def writeNextBlock( self ):
+    def writeNextBlock(self):
         """
         Selecciona el bloque siguiente de datos y los escribe en un file
             
@@ -1366,18 +1437,16 @@ class VoltageWriter( DataWriter ):
             return 0
         
         self.__writeBlock()
-        
         return 1
 
 
-    def __hasAllDataInBuffer( self ):
+    def __hasAllDataInBuffer(self):
         if self.__datablockIndex >= self.m_ProcessingHeader.profilesPerBlock:
             return 1
-        
         return 0
     
 
-    def putData( self ):
+    def putData(self):
         """
         Setea un bloque de datos y luego los escribe en un file 
             
@@ -1397,7 +1466,6 @@ class VoltageWriter( DataWriter ):
         if self.m_Voltage.flagResetProcessing:
             
             self.datablock.fill(0)
-            
             self.__datablockIndex = 0
             self.__setNextFile()
         
@@ -1406,7 +1474,6 @@ class VoltageWriter( DataWriter ):
         self.__datablockIndex += 1
         
         if self.__hasAllDataInBuffer():
-                     
             self.__getHeader()
             self.writeNextBlock()
         
@@ -1417,7 +1484,7 @@ class VoltageWriter( DataWriter ):
         return 1
 
 
-    def __getHeader( self ):
+    def __getHeader(self):
         """
         Obtiene una copia del First Header
          
@@ -1438,7 +1505,7 @@ class VoltageWriter( DataWriter ):
         self.__dataType = self.m_Voltage.dataType
 
             
-    def __setHeaderByFile( self ): 
+    def __setHeaderByFile(self): 
          
         format = self.__format
         header = ['Basic','System','RadarController','Processing']                       
@@ -1518,7 +1585,7 @@ class VoltageWriter( DataWriter ):
             sys.exit(0)
 
 
-    def setup( self, path, set=0, format='rawdata' ):
+    def setup(self,path,set=0,format='rawdata'):
         """
         Setea el tipo de formato en la cual sera guardada la data y escribe el First Header 
             
@@ -1556,8 +1623,9 @@ class VoltageWriter( DataWriter ):
             
         self.datablock = numpy.zeros(self.__shapeBuffer, numpy.dtype('complex'))
         
-#        if not(self.__setNextFile()):
-#            return 0
+        if not( self.__setNextFile() ):
+            return 0
+
         return 1