schain-jc Commit - r46:f6891cff9cbe · Jicamarca Repository

VOTAJEIO.py:...

Victor Sarmiento -

r46:f6891cff9cbe

parent child

Context file:

r46:f6891cff9cbe

Collapse all files

schainpy/IO/VoltageIO.py +248 -180

             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.
                 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.
                     nombre correcto del file es  ../RAWDATA/D2009307/P2009307367
                     Entonces la funcion prueba con las siguientes combinaciones
-                        ../RAWDATA/d2009307/p2009307367
+                        ../.../d2009307/d2009307367
-                        ../RAWDATA/d2009307/P2009307367
+                        ../.../d2009307/D2009307367
-                        ../RAWDATA/D2009307/p2009307367
+                        ../.../D2009307/d2009307367
-                        ../RAWDATA/D2009307/P2009307367
+                        ../.../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
                 """
                 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.
                     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.
                 return 1
             class VoltageReader(DataReader):
                 """
                 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
                 #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.
                     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:
                     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()
                     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
                     countFiles = 0
                     countTries = 0
-                    fileStatus = 0
                     notFirstTime_flag = False
-                    bChangeDir = False
+                    fileOk_flag = False
+                    changeDir_flag = False
-                    fileSize = 0
-                    fp = None
                     self.__flagIsNewFile = 0
                         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
+                        fileOk_flag = False
-                        while( True ):
+                        #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
-                            countTries += 1
+                        if changeDir_flag: #si al buscar un file cambie de directorio ya no espero y sigo con el siguiente file
-                            if( countTries >= self.__nTries ): #checkeo que no haya ido mas alla de la cantidad de intentos
+                            print "\tsearching next \"%s\" file ..." % filename
-                                break
+                            changeDir_flag = False
+                            continue
-                            file, filename = checkForRealPath( self.__path, self.__year, self.__doy, self.__set, self.__ext )
-                            if file != None:
+                        for nTries in range( self.__nTries ):
-                                break
+                            print "\twaiting for the First Header block of \"%s\" file, try %03d ..." % ( filename, nTries+1 )
-                            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
                             time.sleep( self.__delay )
-                        if countTries >= self.__nTries: #se realizaron n intentos y no hubo un file nuevo
+                            currentSize = os.path.getsize( file )
-                            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()
                             neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
                             if currentSize > neededSize:
-                                fileStatus = 1
+                                fileOk_flag = True
-                                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
                                 break
-                            print "\twaiting for block of \"%s\" file ..." % filename
+                        if fileOk_flag: #si encontro un file valido sale del bucle y deja de buscar
-                            time.sleep( self.__delay )
-                        if fileStatus == 1:
                             break
                         print "Skipping the file \"%s\" due to this files is empty" % filename
                         countFiles = 0
+                    if fileOk_flag:
-                    if fileStatus == 1:
+                        self.fileSize = os.path.getsize( file ) #fileSize
-                        self.fileSize = 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:
                         self.noMoreFiles = 1
                         print 'No more Files'
-                    return fileStatus
+                    return fileOk_flag
                 def __setNextFileOffline(self):
                         if not(idFile < len(self.filenameList)):
                             self.noMoreFiles = 1
+                            print 'No more Files'
                             return 0
                         filename = self.filenameList[idFile]
                     return 1
-                def __setNextFile( self ):
+                def __setNextFile(self):
                     """
                     Determina el siguiente file a leer y si hay uno disponible lee el First Header
                     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
                     if ( currentSize >= neededSize ):
                         self.__rdBasicHeader()
                         return 1
-                    elif self.online:
-                        nTries = 0
+                    #si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido
-                        while( nTries < self.__nTries ):
+                    elif (self.nBlocks != self.m_ProcessingHeader.dataBlocksPerFile) and self.online:
-                            nTries += 1
+                        for nTries in range( self.__nTries ):
-                            print "Waiting for the next block, try %03d ..." % 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)
+                            self.__fp = open( self.filename, 'rb' )
-                            currentSize = fileSize - self.__fp.tell()
+                            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
                     if deltaTime > self.__maxTimeStep:
                         self.flagResetProcessing = 1
-                        self.nReadBlocks = 0
+                        #self.nReadBlocks = 0
                     return 1
                 def __readBlock(self):
                     """
                     (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
                     """
+                    blockOk_flag = False
-                    #pts2read = self.m_ProcessingHeader.profilesPerBlock*self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels
                     fpointer = self.__fp.tell()
                     junk = numpy.fromfile( self.__fp, self.__dataType, self.__pts2read )
                     if self.online:
                         if junk.size != self.__blocksize:
-                            nTries = 0
+                            for nTries in range( self.__nTries ):
-                            while( nTries < self.__nTries ):
+                                print "\tWaiting for the next block, try %03d ..." % (nTries+1)
-                                nTries += 1
-                                print "Waiting for the next block, try %03d ..." % nTries
                                 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.
                         filename    :    el ultimo file de una determinada carpeta
                         directory   :    eL directorio donde esta el file encontrado
                     """
                     print "Searching files ..."
                     dirList = []
                         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
                     Excepciones:
                     """
                     print "Searching files ..."
                     dirList = []
                     file = os.path.join( path, dirfilename, filename )
-                    nTries = 0
+                    for nTries in range( self.__nTries+1 ):
-                    while(True):
-                        nTries += 1
-                        if nTries > self.__nTries:
-                            break
                         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)
                             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 )
+                        if nTries >= self.__nTries: #si ya espero la cantidad de veces necesarias entonces ya no vuelve a esperar
-                        time.sleep( self.__delay)
+                            break
+                        print '\twaiting for new block: try %02d' % ( nTries )
+                        time.sleep( self.__delay )
                     if m_BasicHeader.size <= 24:
                         return 0
                         self.online
                     """
                     if online:
-                        nTries = 0
+                        fileOK_flag = False
-                        while( nTries < self.__nTries ):
+                        subfolder = "D%04d%03d" % ( startDateTime.timetuple().tm_year, startDateTime.timetuple().tm_yday )
-                           nTries += 1
+                        file = os.path.join( path, subfolder )
-                           subfolder = "D%04d%03d" % ( startDateTime.timetuple().tm_year, startDateTime.timetuple().tm_yday )
+                        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 )
+                           if filename != None:
-                               print "Searching first file in \"%s\", try %03d ..." % ( file, nTries )
+                               if isFileOK( os.path.join( path,dirfilename,filename ) ):
-                               time.sleep( self.__delay )
+                                   fileOK_flag = True
-                           else:
+                                   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:
+                        if not( fileOK_flag ): #filename == None:
-                            print "No files  On Line"
+                            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
                     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.
                     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
                         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()
                     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
                     #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.
                     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)
                     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
                     self.m_BasicHeader.write(fp)
-                def __wrSystemHeader( self, fp=None ):
+                def __wrSystemHeader(self,fp=None):
                     """
                     Escribe solo el System header en el file creado
                     self.m_SystemHeader.write(fp)
-                def __wrRadarControllerHeader( self, fp=None ):
+                def __wrRadarControllerHeader(self,fp=None):
                     """
                     Escribe solo el RadarController header en el file creado
                     self.m_RadarControllerHeader.write(fp)
-                def __wrProcessingHeader( self, fp=None ):
+                def __wrProcessingHeader(self,fp=None):
                     """
                     Escribe solo el Processing header en el file creado
                     self.m_ProcessingHeader.write(fp)
-                def __setNextFile( self ):
+                def __setNextFile(self):
                     """
                     Determina el siguiente file que sera escrito
                     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)
                         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)
                     return 1
-                def __setNewBlock( self ):
+                def __setNewBlock(self):
                     """
                     Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
                     return 1
-                def __writeBlock( self ):
+                def __writeBlock(self):
                     """
                     Escribe el buffer en el file designado
                     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
                         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
                     if self.m_Voltage.flagResetProcessing:
                         self.datablock.fill(0)
                         self.__datablockIndex = 0
                         self.__setNextFile()
                     self.__datablockIndex += 1
                     if self.__hasAllDataInBuffer():
                         self.__getHeader()
                         self.writeNextBlock()
                     return 1
-                def __getHeader( self ):
+                def __getHeader(self):
                     """
                     Obtiene una copia del First Header
                     self.__dataType = self.m_Voltage.dataType
-                def __setHeaderByFile( self ):
+                def __setHeaderByFile(self):
                     format = self.__format
                     header = ['Basic','System','RadarController','Processing']
                         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
                     self.datablock = numpy.zeros(self.__shapeBuffer, numpy.dtype('complex'))
-            #        if not(self.__setNextFile()):
+                    if not( self.__setNextFile() ):
-            #            return 0
+                        return 0
                     return 1

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages