schain Commit - r98:e2f0a078c091 · Jicamarca Repository

Miguel Valdez -

r98:e2f0a078c091

parent child

Context file:

r98:e2f0a078c091

schainpy/IO/CorrelationIO.py +5 -10

             '''
             Created on 23/01/2012
             @author $Author$
             @version $Id$
             '''
-            from DataIO import DataReader
+            from JRODataIO import JRODataIO
-            from DataIO import DataWriter
-            class CorrelationReader(DataReader):
+            class CorrelationReader(JRODataIO):
                 def __init__(self):
                     pass
-            class CorrelationWriter(DataWriter):
+            class CorrelationWriter(JRODataIO):
                 def __init__(self):
                     pass
-                def puData(self):
+                def putData(self):
                     pass
                 def writeBlock(self):
-                    pass
+                    pass
  No newline at end of file
-  No newline at end of file

schainpy/IO/JRODataIO.py +1 -1

             '''
             Created on 23/01/2012
             @author $Author$
             @version $Id$
             @version $Id$
             '''
             import os, sys
             import glob
             import time
             import numpy
             import fnmatch
             import time, datetime
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Model.JROHeader import *
             from Model.JROData import JROData
             def checkForRealPath(path, year, doy, set, ext):
                 """
                 Por ser Linux Case Sensitive entonces 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.
                 Example    :
                     nombre correcto del file es  .../.../D2009307/P2009307367.ext
                     Entonces la funcion prueba con las siguientes combinaciones
                         .../.../x2009307/y2009307367.ext
                         .../.../x2009307/Y2009307367.ext
                         .../.../X2009307/y2009307367.ext
                         .../.../X2009307/Y2009307367.ext
                     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
                     caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
                     para el filename
                 """
                 filepath = None
                 find_flag = False
                 filename = None
                 if ext.lower() == ".r": #voltage
                     header1 = "dD"
                     header2 = "dD"
                 elif ext.lower() == ".pdata": #spectra
                     header1 = "dD"
                     header2 = "pP"
                 else:
                     return None, filename
                 for dir in header1: #barrido por las dos combinaciones posibles de "D"
                     for fil in header2: #barrido por las dos combinaciones posibles de "D"
                         doypath = "%s%04d%03d" % ( dir, year, doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D)
                         filename = "%s%04d%03d%03d%s" % ( fil, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext
                         filepath = os.path.join( path, doypath, filename ) #formo el path completo
                         if os.path.exists( filepath ): #verifico que exista
                             find_flag = True
                             break
                     if find_flag:
                         break
                 if not(find_flag):
                     return None, filename
                 return filepath, filename
             def isNumber(str):
                 """
                 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
                 Excepciones:
                     Si un determinado string no puede ser convertido a numero
                 Input:
                     str, string al cual se le analiza para determinar si convertible a un numero o no
                 Return:
                     True    :    si el string es uno numerico
                     False   :    no es un string numerico
                 """
                 try:
                     float( str )
                     return True
                 except:
                     return False
             def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
                 """
                 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                     startUTSeconds      :    fecha inicial del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                     endUTSeconds        :    fecha final del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no existe o no puede ser abierto
                     Si la cabecera no puede ser leida.
                 """
                 m_BasicHeader = BasicHeader()
                 try:
                     fp = open(filename,'rb')
                 except:
                     raise IOError, "The file %s can't be opened" %(filename)
                 sts = m_BasicHeader.read(fp)
                 fp.close()
                 if not(sts):
                     print "Skipping the file %s because it has not a valid header" %(filename)
                     return 0
                 if not ((startUTSeconds <= m_BasicHeader.utc) and (endUTSeconds > m_BasicHeader.utc)):
                     return 0
                 return 1
             def getlastFileFromPath(path, ext):
                 """
                 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
                 al final de la depuracion devuelve el ultimo file de la lista que quedo.
                 Input:
                     fileList    :    lista conteniendo todos los files (sin path) que componen una determinada carpeta
                     ext         :    extension de los files contenidos en una carpeta
                 Return:
                     El ultimo file de una determinada carpeta, no se considera el path.
                 """
                 validFilelist = []
                 fileList = os.listdir(path)
                 # 0 1234 567 89A BCDE
                 # H YYYY DDD SSS .ext
                 for file in fileList:
                     try:
                         year = int(file[1:5])
                         doy  = int(file[5:8])
                         if (os.path.splitext(file)[-1].upper() != ext.upper()) : continue
                     except:
                         continue
                     validFilelist.append(file)
                 if validFilelist:
                     validFilelist = sorted( validFilelist, key=str.lower )
                     return validFilelist[-1]
                 return None
-            class JRODataIO():
+            class JRODataIO:
                 #speed of light
                 c = 3E8
                 m_BasicHeader = BasicHeader()
                 m_SystemHeader = SystemHeader()
                 m_RadarControllerHeader = RadarControllerHeader()
                 m_ProcessingHeader = ProcessingHeader()
                 m_DataObj = None
                 online = 0
                 fp = None
                 dataType = None
                 fileSizeByHeader = None
                 filenameList = []
                 filename = None
                 fileSize = None
                 firstHeaderSize = 0
                 basicHeaderSize = 24
                 nTotalBlocks = 0
                 ippSeconds = 0
                 blocksize = 0
                 set = 0
                 ext = None
                 path = None
                 maxTimeStep = 30
                 delay  = 3   #seconds
                 nTries  = 3  #quantity tries
                 nFiles = 3   #number of files for searching
                 flagNoMoreFiles = 0
                 flagIsNewFile = 1
                 flagResetProcessing = 0
                 flagIsNewBlock = 0
                 def __init__(self):
                     pass
             class JRODataReader(JRODataIO):
                 """
                 Esta clase es usada como la clase padre de las clases VoltageReader y SpectraReader.
                 Contiene todos lo metodos necesarios para leer datos desde archivos en formato
                 jicamarca o pdata (.r o .pdata). La lectura de los datos siempre se realiza por bloques. Los datos
                 leidos son array de 3 dimensiones:
                                   Para Voltajes  -  perfiles * alturas * canales
                                   Para Spectra   -  paresCanalesIguales    * alturas * perfiles  (Self Spectra)
                                                     paresCanalesDiferentes * alturas * perfiles  (Cross Spectra)
                                                     canales * alturas                            (DC Channels)
                 y son almacenados en su buffer respectivo.
                 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
                 RadarControllerHeader y DataObj. Los tres primeros se usan para almacenar informacion de la
                 cabecera de datos (metadata), y el cuarto (DataObj) para obtener y almacenar los datos desde
                 el buffer de datos cada vez que se ejecute el metodo "getData".
                 """
                 nReadBlocks = 0
                 def __init__(self, m_DataObj=None):
                     raise ValueError, "This class can't be instanced"
                 def hasNotDataInBuffer(self):
                     raise ValueError, "Not implemented"
                 def getBlockDimension(self):
                     raise ValueError, "No implemented"
                 def readBlock(self):
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     raise ValueError, "This method has not been implemented"
                 def getData( self ):
                     raise ValueError, "This method has not been implemented"
                 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:
                         fp = self.fp
                     self.m_ProcessingHeader.read(fp)
                 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.dataType
                         self.fileSizeByHeader
                         self.ippSeconds
                     Return:
                         None
                     """
                     self.__rdBasicHeader()
                     self.__rdSystemHeader()
                     self.__rdRadarControllerHeader()
                     self.__rdProcessingHeader()
                     self.firstHeaderSize = self.m_BasicHeader.size
                     datatype = int(numpy.log2((self.m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
                     if datatype == 0:
                         datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
                     elif datatype == 1:
                         datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
                     elif datatype == 2:
                         datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
                     elif datatype == 3:
                         datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
                     elif datatype == 4:
                         datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
                     elif datatype == 5:
                         datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
                     else:
                         raise ValueError, 'Data type was not defined'
                     self.dataType = datatype_str
                     self.ippSeconds = 2 * 1000 * self.m_RadarControllerHeader.ipp / self.c
                     self.fileSizeByHeader = self.m_ProcessingHeader.dataBlocksPerFile * self.m_ProcessingHeader.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.m_ProcessingHeader.dataBlocksPerFile - 1)
                     self.getBlockDimension()
                 def __setNewBlock(self):
                     """
                     Lee el Basic Header y posiciona le file pointer en la posicion inicial del bloque a leer
                     Affected:
                         self.m_BasicHeader
                         self.flagNoContinuousBlock
                         self.ns
                     Return:
 :    Si el file no tiene un Basic Header que pueda ser leido
 :    Si se pudo leer el Basic Header
                     """
                     if self.fp == None:
                         return 0
                     if self.flagIsNewFile:
                         return 1
                     self.lastUTTime = self.m_BasicHeader.utc
                     currentSize = self.fileSize - self.fp.tell()
                     neededSize = self.m_ProcessingHeader.blockSize + self.basicHeaderSize
                     #If there is enough data setting new data block
                     if ( currentSize >= neededSize ):
                         self.__rdBasicHeader()
                         return 1
                     #si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido
                     if self.online and (self.nReadBlocks < self.m_ProcessingHeader.dataBlocksPerFile):
                         fpointer = self.fp.tell()
                         for nTries in range( self.nTries ):
                             #self.fp.close()
                             print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
                             time.sleep( self.delay )
                             #self.fp = open( self.filename, 'rb' )
                             #self.fp.seek( fpointer )
                             self.fileSize = os.path.getsize( self.filename )
                             currentSize = self.fileSize - fpointer
                             if ( currentSize >= neededSize ):
                                 self.__rdBasicHeader()
                                 return 1
                     #Setting new file
                     if not( self.setNextFile() ):
                         return 0
                     deltaTime = self.m_BasicHeader.utc - self.lastUTTime # check this
                     self.flagResetProcessing = 0
                     if deltaTime > self.maxTimeStep:
                         self.flagResetProcessing = 1
                     return 1
                 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.
                     Affected:
                         self.lastUTTime
                     Return: None
                     """
                     if not(self.__setNewBlock()):
                         return 0
                     if not(self.readBlock()):
                         return 0
                     return 1
                 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
                     siguientes.
                     Affected:
                         self.flagIsNewFile
                         self.filename
                         self.fileSize
                         self.fp
                         self.set
                         self.flagNoMoreFiles
                     Return:
 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
 : si el file fue abierto con exito y esta listo a ser leido
                     Excepciones:
                         Si un determinado file no puede ser abierto
                     """
                     nFiles = 0
                     fileOk_flag = False
                     firstTime_flag = True
                     self.set += 1
                     #busca el 1er file disponible
                     file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
                     if file:
                         if self.__verifyFile(file, False):
                             fileOk_flag = True
                     #si no encuentra un file entonces espera y vuelve a buscar
                     if not(fileOk_flag):
                         for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles
                             if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces
                                 tries = self.nTries
                             else:
                                 tries = 1 #si no es la 1era vez entonces solo lo hace una vez
                             for nTries in range( tries ):
                                 if firstTime_flag:
                                     print "\tWaiting %0.2f sec for new \"%s\" file, try %03d ..." % ( self.delay, filename, nTries+1 )
                                     time.sleep( self.delay )
                                 else:
                                     print "\tSearching next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
                                 file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
                                 if file:
                                     if self.__verifyFile(file):
                                         fileOk_flag = True
                                         break
                             if fileOk_flag:
                                 break
                             firstTime_flag = False
                             print "\tSkipping the file \"%s\" due to this file doesn't exist yet" % filename
                             self.set += 1
                             if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
                                 self.set = 0
                                 self.doy += 1
                     if fileOk_flag:
                         self.fileSize = os.path.getsize( file )
                         self.filename = file
                         self.flagIsNewFile = 1
                         if self.fp != None: self.fp.close()
                         self.fp = open(file)
                         self.flagNoMoreFiles = 0
                         print 'Setting the file: %s' % file
                     else:
                         self.fileSize = 0
                         self.filename = None
                         self.flagIsNewFile = 0
                         self.fp = None
                         self.flagNoMoreFiles = 1
                         print 'No more Files'
                     return fileOk_flag
                 def __setNextFileOffline(self):
                     """
                     Busca el siguiente file dentro de un folder que tenga suficiente data para ser leida
                     Affected:
                         self.flagIsNewFile
                         self.fileIndex
                         self.filename
                         self.fileSize
                         self.fp
                     Return:
 : si un determinado file no puede ser abierto
 : si el file fue abierto con exito
                     Excepciones:
                         Si un determinado file no puede ser abierto
                     """
                     idFile = self.fileIndex
                     while(True):
                         idFile += 1
                         if not(idFile < len(self.filenameList)):
                             self.flagNoMoreFiles = 1
                             print 'No more Files'
                             return 0
                         filename = self.filenameList[idFile]
                         if not(self.__verifyFile(filename)):
                             continue
                         fileSize = os.path.getsize(filename)
                         fp = open(filename,'rb')
                         break
                     self.flagIsNewFile = 1
                     self.fileIndex = idFile
                     self.filename = filename
                     self.fileSize = fileSize
                     self.fp = fp
                     print 'Setting the file: %s'%self.filename
                     return 1
                 def setNextFile(self):
                     """
                     Determina el siguiente file a leer y si hay uno disponible lee el First Header
                     Affected:
                         self.m_BasicHeader
                         self.m_SystemHeader
                         self.m_RadarControllerHeader
                         self.m_ProcessingHeader
                         self.firstHeaderSize
                     Return:
 :    Si no hay files disponibles
 :    Si hay mas files disponibles
                     """
                     if self.fp != None:
                         self.fp.close()
                     if self.online:
                         newFile = self.__setNextFileOnline()
                     else:
                         newFile = self.__setNextFileOffline()
                     if not(newFile):
                         return 0
                     self.__readFirstHeader()
                     self.nReadBlocks = 0
                     return 1
                 def __searchFilesOnLine(self, path, startDateTime=None, endDateTime=None, expLabel = "", ext = None):
                     """
                     Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
                     devuelve el archivo encontrado ademas de otros datos.
                     Input:
                         path             :    carpeta donde estan contenidos los files que contiene data
                         startDateTime    :    punto especifico en el tiempo del cual se requiere la data
                         ext              :    extension de los files
                     Return:
                         year        :    el anho
                         doy         :    el numero de dia del anho
                         set         :    el set del archivo
                         filename    :    el ultimo file de una determinada carpeta
                         directory   :    eL directorio donde esta el file encontrado
                     """
                     dirList = []
                     pathList = []
                     directory = None
                     for thisPath in os.listdir(path):
                         if os.path.isdir(os.path.join(path,thisPath)):
                             dirList.append(thisPath)
                     if not(dirList):
                         return None, None, None, None, None
                     dirList = sorted( dirList, key=str.lower )
                     if startDateTime:
                         thisDateTime = startDateTime
                         if endDateTime == None: endDateTime = startDateTime
                         while(thisDateTime <= endDateTime):
                             year = thisDateTime.timetuple().tm_year
                             doy = thisDateTime.timetuple().tm_yday
                             match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
                             if len(match) == 0:
                                 thisDateTime += datetime.timedelta(1)
                                 continue
                             pathList.append(os.path.join(path,match[0], expLabel))
                             thisDateTime += datetime.timedelta(1)
                         if not(pathList):
                             print "\tNo files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
                             return None, None, None, None, None
                         directory = pathList[0]
                     else:
                         directory = dirList[-1]
                         directory = os.path.join(path,directory)
                     filename = getlastFileFromPath(directory, ext)
                     if not(filename):
                         return None, None, None, None, None
                     if not(self.__verifyFile(os.path.join(directory, filename))):
                         return None, None, None, None, None
                     year = int( filename[1:5] )
                     doy  = int( filename[5:8] )
                     set  = int( filename[8:11] )
                     return directory, filename, year, doy, set
                 def __searchFilesOffLine(self, path, startDateTime, endDateTime, set=None, expLabel = "", ext = ".r"):
                     """
                     Realiza una busqueda de los archivos que coincidan con los parametros
                     especificados y se encuentren ubicados en el path indicado. Para realizar una busqueda
                     correcta la estructura de directorios debe ser la siguiente:
                     ...path/D[yyyy][ddd]/expLabel/D[yyyy][ddd][sss].ext
                     [yyyy]: anio
                     [ddd] : dia del anio
                     [sss] : set del archivo
                     Inputs:
                         path           :    Directorio de datos donde se realizara la busqueda. Todos los
                                             ficheros que concidan con el criterio de busqueda seran
                                             almacenados en una lista y luego retornados.
                         startDateTime  :    Fecha inicial. Rechaza todos los archivos donde
                                             file end time < startDateTime (obejto datetime.datetime)
                         endDateTime    :    Fecha final. Rechaza todos los archivos donde
                                             file start time > endDateTime (obejto datetime.datetime)
                         set            :    Set del primer archivo a leer. Por defecto None
                         expLabel       :    Nombre del subdirectorio de datos.  Por defecto ""
                         ext            :    Extension de los archivos a leer. Por defecto .r
                     Return:
                         (pathList, filenameList)
                         pathList        :    Lista de directorios donde se encontraron archivos dentro
                                              de los parametros especificados
                         filenameList    :    Lista de archivos (ruta completa) que coincidieron con los
                                              parametros especificados.
                     Variables afectadas:
                         self.filenameList:    Lista de archivos (ruta completa) que la clase utiliza
                                               como fuente para leer los bloque de datos, si se termina
                                               de leer todos los bloques de datos de un determinado
                                               archivo se pasa al siguiente archivo de la lista.
                     Excepciones:
                     """
                     print "Searching files ..."
                     dirList = []
                     for thisPath in os.listdir(path):
                         if os.path.isdir(os.path.join(path,thisPath)):
                             dirList.append(thisPath)
                     if not(dirList):
                         return None, None
                     pathList = []
                     thisDateTime = startDateTime
                     while(thisDateTime <= endDateTime):
                         year = thisDateTime.timetuple().tm_year
                         doy = thisDateTime.timetuple().tm_yday
                         match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
                         if len(match) == 0:
                             thisDateTime += datetime.timedelta(1)
                             continue
                         pathList.append(os.path.join(path,match[0],expLabel))
                         thisDateTime += datetime.timedelta(1)
                     startUtSeconds = time.mktime(startDateTime.timetuple())
                     endUtSeconds = time.mktime(endDateTime.timetuple())
                     filenameList = []
                     for thisPath in pathList:
                         fileList = glob.glob1(thisPath, "*%s" %ext)
                         fileList.sort()
                         for file in fileList:
                             filename = os.path.join(thisPath,file)
                             if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
                                 filenameList.append(filename)
                     if not(filenameList):
                         return None, None
                     self.filenameList = filenameList
                     return pathList, filenameList
                 def __verifyFile(self, filename, msgFlag=True):
                     """
                     Verifica que el filename tenga data valida, para ello leo el FirstHeader del file
                     Return:
 :    file no valido para ser leido
 :    file valido para ser leido
                     """
                     msg = None
                     try:
                         fp = open( filename,'rb' ) #lectura binaria
                         currentPosition = fp.tell()
                     except:
                         if msgFlag:
                             print "The file %s can't be opened" % (filename)
                         return False
                     neededSize = self.m_ProcessingHeader.blockSize + self.firstHeaderSize
                     if neededSize == 0:
                         m_BasicHeader = BasicHeader()
                         m_SystemHeader = SystemHeader()
                         m_RadarControllerHeader = RadarControllerHeader()
                         m_ProcessingHeader = ProcessingHeader()
                         try:
                             if not( m_BasicHeader.read(fp) ): raise ValueError
                             if not( m_SystemHeader.read(fp) ): raise ValueError
                             if not( m_RadarControllerHeader.read(fp) ): raise ValueError
                             if not( m_ProcessingHeader.read(fp) ): raise ValueError
                             data_type = int(numpy.log2((m_ProcessingHeader.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
                             neededSize = m_ProcessingHeader.blockSize + m_BasicHeader.size
                         except:
                             if msgFlag:
                                 print "\tThe file %s is empty or it hasn't enough data" % filename
                             fp.close()
                             return False
                     else:
                         msg = "\tSkipping the file %s due to it hasn't enough data" %filename
                     fp.close()
                     fileSize = os.path.getsize(filename)
                     currentSize = fileSize - currentPosition
                     if currentSize < neededSize:
                         if msgFlag and (msg != None):
                             print msg #print"\tSkipping the file %s due to it hasn't enough data" %filename
                         return False
                     return True
                 def updateDataHeader(self):
                     self.m_DataObj.m_BasicHeader = self.m_BasicHeader.copy()
                     self.m_DataObj.m_ProcessingHeader = self.m_ProcessingHeader.copy()
                     self.m_DataObj.m_RadarControllerHeader = self.m_RadarControllerHeader.copy()
                     self.m_DataObj.m_SystemHeader = self.m_SystemHeader.copy()
                     self.m_DataObj.dataType = self.dataType
                     self.m_DataObj.updateObjFromHeader()
                 def setup(self, path, startDateTime=None, endDateTime=None, set=0, expLabel = "", ext = None, online = 0):
                     """
                     setup configura los parametros de lectura de la clase DataReader.
                     Si el modo de lectura es offline, primero se realiza una busqueda de todos los archivos
                     que coincidan con los parametros especificados; esta lista de archivos son almacenados en
                     self.filenameList.
                     Input:
                         path                :    Directorios donde se ubican los datos a leer. Dentro de este
                                                  directorio deberia de estar subdirectorios de la forma:
                                                  path/D[yyyy][ddd]/expLabel/P[yyyy][ddd][sss][ext]
                         startDateTime       :    Fecha inicial. Rechaza todos los archivos donde
                                                  file end time < startDatetime (obejto datetime.datetime)
                         endDateTime         :    Fecha final. Si no es None, rechaza todos los archivos donde
                                                  file end time < startDatetime (obejto datetime.datetime)
                         set                 :    Set del primer archivo a leer. Por defecto None
                         expLabel            :    Nombre del subdirectorio de datos.  Por defecto ""
                         ext                 :    Extension de los archivos a leer. Por defecto .r
                         online              :    Si es == a 0 entonces busca files que cumplan con las condiciones dadas
                     Return:
 :    Si no encuentra files que cumplan con las condiciones dadas
 :    Si encuentra files que cumplan con las condiciones dadas
                     Affected:
                         self.startUTCSeconds
                         self.endUTCSeconds
                         self.startYear
                         self.endYear
                         self.startDoy
                         self.endDoy
                         self.pathList
                         self.filenameList
                         self.online
                     """
                     if ext == None:
                         ext = self.ext
                     if online:
                         print "Searching files ..."
                         doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext)
                         if not(doypath):
                             for nTries in range( self.nTries ):
                                 print '\tWaiting %0.2f sec for valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
                                 time.sleep( self.delay )
                                 doypath, file, year, doy, set = self.__searchFilesOnLine(path, startDateTime, endDateTime, expLabel, ext)
                                 if doypath:
                                     break
                         if not(doypath):
                             print "There 'isn't valied files in %s" % path
                             return 0
                         self.year = year
                         self.doy  = doy
                         self.set  = set - 1
                         self.path = path
                     else: # offline
                         pathList, filenameList = self.__searchFilesOffLine(path, startDateTime, endDateTime, set, expLabel, ext)
                         if not(pathList):
                             print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
                             return 0
                         self.fileIndex = -1
                         self.pathList = pathList
                         self.filenameList = filenameList
                     self.online = online
                     self.ext = ext
                     ext = ext.lower()
                     if not( self.setNextFile() ):
                         if (startDateTime != None) and (endDateTime != None):
                             print "No files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
                         elif startDateTime != None:
                             print "No files in : %s" % startDateTime.ctime()
                         else:
                             print "No files"
                         return 0
                     if startDateTime != None:
                         self.startUTCSeconds = time.mktime(startDateTime.timetuple())
                         self.startYear = startDateTime.timetuple().tm_year
                         self.startDoy = startDateTime.timetuple().tm_yday
                     if endDateTime != None:
                         self.endUTCSeconds = time.mktime(endDateTime.timetuple())
                         self.endYear = endDateTime.timetuple().tm_year
                         self.endDoy = endDateTime.timetuple().tm_yday
                     #call fillHeaderValues() - to Data Object
                     self.updateDataHeader()
                     return 1
             class JRODataWriter(JRODataIO):
                 """
                 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 nWriteBlocks = 0
                 setFile = None
                 def __init__(self, m_DataObj=None):
                     raise ValueError, "Not implemented"
                 def hasAllDataInBuffer(self):
                     raise ValueError, "Not implemented"
                 def setBlockDimension(self):
                     raise ValueError, "Not implemented"
                 def writeBlock(self):
                     raise ValueError, "No implemented"
                 def putData(self):
                     raise ValueError, "No implemented"
                 def __writeFirstHeader(self):
                     """
                     Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
                     Affected:
                         __dataType
                     Return:
                         None
                     """
                     self.__writeBasicHeader()
                     self.__wrSystemHeader()
                     self.__wrRadarControllerHeader()
                     self.__wrProcessingHeader()
                     self.dataType = self.m_DataObj.dataType
                 def __writeBasicHeader(self, fp=None):
                     """
                     Escribe solo el Basic header en el file creado
                     Return:
                         None
                     """
                     if fp == None:
                         fp = self.fp
                     self.m_DataObj.m_BasicHeader.write(fp)
                 def __wrSystemHeader(self, fp=None):
                     """
                     Escribe solo el System header en el file creado
                     Return:
                         None
                     """
                     if fp == None:
                         fp = self.fp
                     self.m_DataObj.m_SystemHeader.write(fp)
                 def __wrRadarControllerHeader(self, fp=None):
                     """
                     Escribe solo el RadarController header en el file creado
                     Return:
                         None
                     """
                     if fp == None:
                         fp = self.fp
                     self.m_DataObj.m_RadarControllerHeader.write(fp)
                 def __wrProcessingHeader(self, fp=None):
                     """
                     Escribe solo el Processing header en el file creado
                     Return:
                         None
                     """
                     if fp == None:
                         fp = self.fp
                     self.m_DataObj.m_ProcessingHeader.write(fp)
                 def setNextFile(self):
                     """
                     Determina el siguiente file que sera escrito
                     Affected:
                         self.filename
                         self.subfolder
                         self.fp
                         self.setFile
                         self.flagIsNewFile
                     Return:
 :    Si el archivo no puede ser escrito
 :    Si el archivo esta listo para ser escrito
                     """
                     ext = self.ext
                     path = self.path
                     if self.fp != None:
                         self.fp.close()
                     timeTuple = time.localtime( self.m_DataObj.m_BasicHeader.utc )
                     subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
                     doypath = os.path.join( path, subfolder )
                     if not( os.path.exists(doypath) ):
                         os.mkdir(doypath)
                         self.setFile = -1 #inicializo mi contador de seteo
                     else:
                         filesList = os.listdir( doypath )
                         if len( filesList ) > 0:
                             filesList = sorted( filesList, key=str.lower )
                             filen = filesList[-1]
                             # el filename debera tener el siguiente formato
                             # 0 1234 567 89A BCDE (hex)
                             # x YYYY DDD SSS .ext
                             if isNumber( filen[8:11] ):
                                 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
                             else:
                                 self.setFile = -1
                         else:
                             self.setFile = -1 #inicializo mi contador de seteo
                     setFile = self.setFile
                     setFile += 1
                     file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
                                                     timeTuple.tm_year,
                                                     timeTuple.tm_yday,
                                                     setFile,
                                                     ext )
                     filename = os.path.join( path, subfolder, file )
                     fp = open( filename,'wb' )
                     self.nWriteBlocks = 0
                     #guardando atributos
                     self.filename = filename
                     self.subfolder = subfolder
                     self.fp = fp
                     self.setFile = setFile
                     self.flagIsNewFile = 1
                     print 'Writing the file: %s'%self.filename
                     self.__writeFirstHeader()
                     return 1
                 def __setNewBlock(self):
                     """
                     Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
                     Return:
 :    si no pudo escribir nada
 :    Si escribio el Basic el First Header
                     """
                     if self.fp == None:
                         self.setNextFile()
                     if self.flagIsNewFile:
                         return 1
                     if self.nWriteBlocks < self.m_ProcessingHeader.dataBlocksPerFile:
                         self.__writeBasicHeader()
                         return 1
                     if not( self.setNextFile() ):
                         return 0
                     return 1
                 def writeNextBlock(self):
                     """
                     Selecciona el bloque siguiente de datos y los escribe en un file
                     Return:
 :    Si no hizo pudo escribir el bloque de datos
 :    Si no pudo escribir el bloque de datos
                     """
                     if not( self.__setNewBlock() ):
                         return 0
                     self.writeBlock()
                     return 1
                 def getDataHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.m_BasicHeader
                         self.m_SystemHeader
                         self.m_RadarControllerHeader
                         self.m_ProcessingHeader
                         self.dataType
                     Return:
                         None
                     """
                     self.m_DataObj.updateHeaderFromObj()
                     self.m_BasicHeader = self.m_DataObj.m_BasicHeader.copy()
                     self.m_SystemHeader = self.m_DataObj.m_SystemHeader.copy()
                     self.m_RadarControllerHeader = self.m_DataObj.m_RadarControllerHeader.copy()
                     self.m_ProcessingHeader = self.m_DataObj.m_ProcessingHeader.copy()
                     self.dataType = self.m_DataObj.dataType
                 def setup(self, path, set=0, ext=None):
                     """
                     Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
                     Inputs:
                         path      :    el path destino en el cual se escribiran los files a crear
                         format    :    formato en el cual sera salvado un file
                         set       :    el setebo del file
                     Return:
 :    Si no realizo un buen seteo
 :    Si realizo un buen seteo
                     """
                     if ext == None:
                         ext = self.ext
                     ext = ext.lower()
                     self.path = path
                     self.setFile = set - 1
                     self.ext = ext
                     #self.format = format
                     self.getDataHeader()
                     self.setBlockDimension()
                     if not( self.setNextFile() ):
                         print "There isn't a next file"
                         return 0
                     return 1

schainpy/IO/SpectraIO.py +540 -535

This diff has been collapsed as it changes many lines, (1075 lines changed) Show them Hide them
	@@ -1,536 +1,541
	1	'''	1	'''
	2	File: SpectraIO.py	2	File: SpectraIO.py
	3	Created on 20/02/2012	3	Created on 20/02/2012
	4		4
	5	@author $Author$	5	@author $Author$
	6	@version $Id$	6	@version $Id$
	7	'''	7	'''
	8		8
	9	import os, sys	9	import os, sys
	10	import numpy	10	import numpy
	11	import glob	11	import glob
	12	import fnmatch	12	import fnmatch
	13	import time, datetime	13	import time, datetime
	14		14
	15	path = os.path.split(os.getcwd())[0]	15	path = os.path.split(os.getcwd())[0]
	16	sys.path.append(path)	16	sys.path.append(path)
	17		17
	18	from Model.JROHeader import *	18	from Model.JROHeader import *
	19	from Model.Spectra import Spectra	19	from Model.Spectra import Spectra
	20		20
	21	from JRODataIO import JRODataReader	21	from JRODataIO import JRODataReader
	22	from JRODataIO import JRODataWriter	22	from JRODataIO import JRODataWriter
	23	from JRODataIO import isNumber	23	from JRODataIO import isNumber
	24		24
	25		25
	26	class SpectraReader( JRODataReader ):	26	class SpectraReader(JRODataReader):
	27	"""	27	"""
	28	Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura	28	Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
	29	de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)	29	de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
	30	son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.	30	son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
	31		31
	32	paresCanalesIguales * alturas * perfiles (Self Spectra)	32	paresCanalesIguales * alturas * perfiles (Self Spectra)
	33	paresCanalesDiferentes * alturas * perfiles (Cross Spectra)	33	paresCanalesDiferentes * alturas * perfiles (Cross Spectra)
	34	canales * alturas (DC Channels)	34	canales * alturas (DC Channels)
	35		35
	36	Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,	36	Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
	37	RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la	37	RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
	38	cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de	38	cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
	39	datos desde el "buffer" cada vez que se ejecute el metodo "getData".	39	datos desde el "buffer" cada vez que se ejecute el metodo "getData".
	40		40
	41	Example:	41	Example:
	42	dpath = "/home/myuser/data"	42	dpath = "/home/myuser/data"
	43		43
	44	startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)	44	startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
	45		45
	46	endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)	46	endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
	47		47
	48	readerObj = SpectraReader()	48	readerObj = SpectraReader()
	49		49
	50	readerObj.setup(dpath, startTime, endTime)	50	readerObj.setup(dpath, startTime, endTime)
	51		51
	52	while(True):	52	while(True):
	53		53
	54	readerObj.getData()	54	readerObj.getData()
	55		55
	56	print readerObj.m_Spectra.data	56	print readerObj.m_Spectra.data
	57		57
	58	if readerObj.flagNoMoreFiles:	58	if readerObj.flagNoMoreFiles:
	59	break	59	break
	60		60
	61	"""	61	"""
	62	m_DataObj = None	62	m_DataObj = None
	63		63
	64	data_spc = None	64	data_spc = None
	65	data_cspc = None	65	data_cspc = None
	66	data_dc = None	66	data_dc = None
	67		67
	68	pts2read_SelfSpectra = 0	68	pts2read_SelfSpectra = 0
	69	pts2read_CrossSpectra = 0	69	pts2read_CrossSpectra = 0
	70	pts2read_DCchannels = 0	70	pts2read_DCchannels = 0
	71		71
	72	nChannels = 0	72	nChannels = 0
	73		73
	74	nPairs = 0	74	nPairs = 0
	75		75
	76	#pairList = None	76	#pairList = None
	77		77
	78	channelList = None	78	channelList = None
	79		79
	80	def __init__(self, m_Spectra=None):	80	def __init__(self, m_Spectra=None):
	81	"""	81	"""
	82	Inicializador de la clase SpectraReader para la lectura de datos de espectros.	82	Inicializador de la clase SpectraReader para la lectura de datos de espectros.
	83		83
	84	Inputs:	84	Inputs:
	85	m_Spectra : Objeto de la clase Spectra. Este objeto sera utilizado para	85	m_Spectra : Objeto de la clase Spectra. Este objeto sera utilizado para
	86	almacenar un perfil de datos cada vez que se haga un requerimiento	86	almacenar un perfil de datos cada vez que se haga un requerimiento
	87	(getData). El perfil sera obtenido a partir del buffer de datos,	87	(getData). El perfil sera obtenido a partir del buffer de datos,
	88	si el buffer esta vacio se hara un nuevo proceso de lectura de un	88	si el buffer esta vacio se hara un nuevo proceso de lectura de un
	89	bloque de datos.	89	bloque de datos.
	90	Si este parametro no es pasado se creara uno internamente.	90	Si este parametro no es pasado se creara uno internamente.
	91		91
	92	Affected:	92	Affected:
	93	self.m_DataObj	93	self.m_DataObj
	94		94
	95	Return : None	95	Return : None
	96	"""	96	"""
	97	if m_Spectra == None:	97	if m_Spectra == None:
	98	m_Spectra = Spectra()	98	m_Spectra = Spectra()
	99		99
	100	if not( isinstance(m_Spectra, Spectra) ):	100	if not( isinstance(m_Spectra, Spectra) ):
	101	raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"	101	raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
	102		102
	103	self.m_DataObj = m_Spectra	103	self.m_DataObj = m_Spectra
	104		104
	105	self.data_spc = None	105	self.data_spc = None
	106	self.data_cspc = None	106	self.data_cspc = None
	107	self.data_dc = None	107	self.data_dc = None
	108		108
	109	self.pts2read_SelfSpectra = 0	109	self.pts2read_SelfSpectra = 0
	110	self.pts2read_CrossSpectra = 0	110	self.pts2read_CrossSpectra = 0
	111	self.pts2read_DCs = 0	111	self.pts2read_DCs = 0
	112		112
	113	self.nChannels = 0	113	self.nChannels = 0
	114		114
	115	self.nPairs = 0	115	self.nPairs = 0
	116		116
	117	self.ext = ".pdata"	117	self.ext = ".pdata"
	118		118
	119	self.optchar = "P"	119	self.optchar = "P"
	120		120
	121	######################	121	######################
	122		122
	123	self.m_BasicHeader = BasicHeader()	123	self.m_BasicHeader = BasicHeader()
	124		124
	125	self.m_SystemHeader = SystemHeader()	125	self.m_SystemHeader = SystemHeader()
	126		126
	127	self.m_RadarControllerHeader = RadarControllerHeader()	127	self.m_RadarControllerHeader = RadarControllerHeader()
	128		128
	129	self.m_ProcessingHeader = ProcessingHeader()	129	self.m_ProcessingHeader = ProcessingHeader()
	130		130
	131	self.online = 0	131	self.online = 0
	132		132
	133	self.fp = None	133	self.fp = None
	134		134
	135	self.fileSizeByHeader = None	135	self.fileSizeByHeader = None
	136		136
	137	self.filenameList = []	137	self.filenameList = []
	138		138
	139	self.filename = None	139	self.filename = None
	140		140
	141	self.fileSize = None	141	self.fileSize = None
	142		142
	143	self.firstHeaderSize = 0	143	self.firstHeaderSize = 0
	144		144
	145	self.basicHeaderSize = 24	145	self.basicHeaderSize = 24
	146		146
	147	self.dataType = None	147	self.dataType = None
	148		148
	149	self.maxTimeStep = 30	149	self.maxTimeStep = 30
	150		150
	151	self.flagNoMoreFiles = 0	151	self.flagNoMoreFiles = 0
	152		152
	153	self.set = 0	153	self.set = 0
	154		154
	155	self.path = None	155	self.path = None
	156		156
	157	self.delay = 3 #seconds	157	self.delay = 3 #seconds
	158		158
	159	self.nTries = 3 #quantity tries	159	self.nTries = 3 #quantity tries
	160		160
	161	self.nFiles = 3 #number of files for searching	161	self.nFiles = 3 #number of files for searching
	162		162
	163	self.nReadBlocks = 0	163	self.nReadBlocks = 0
	164		164
	165	self.flagIsNewFile = 1	165	self.flagIsNewFile = 1
	166		166
	167	self.ippSeconds = 0	167	self.ippSeconds = 0
	168		168
	169	self.flagResetProcessing = 0	169	self.flagResetProcessing = 0
	170		170
	171	self.flagIsNewBlock = 0	171	self.flagIsNewBlock = 0
	172		172
	173	self.nTotalBlocks = 0	173	self.nTotalBlocks = 0
	174		174
	175	self.blocksize = 0	175	self.blocksize = 0
	176		176
	177	#pairList = None	177	#pairList = None
	178		178
	179	channelList = None	179	channelList = None
	180		180
	181		181
	182	def __hasNotDataInBuffer(self):	182	def __hasNotDataInBuffer(self):
	183	return 1	183	return 1
	184		184
	185		185
	186	def getBlockDimension(self):	186	def getBlockDimension(self):
	187	"""	187	"""
	188	Obtiene la cantidad de puntos a leer por cada bloque de datos	188	Obtiene la cantidad de puntos a leer por cada bloque de datos
	189		189
	190	Affected:	190	Affected:
	191	self.nChannels	191	self.nChannels
	192	self.nPairs	192	self.nPairs
	193	self.pts2read_SelfSpectra	193	self.pts2read_SelfSpectra
	194	self.pts2read_CrossSpectra	194	self.pts2read_CrossSpectra
	195	self.pts2read_DCchannels	195	self.pts2read_DCchannels
	196	self.blocksize	196	self.blocksize
	197	self.m_DataObj.nChannels	197	self.m_DataObj.nChannels
	198	self.m_DataObj.nPairs	198	self.m_DataObj.nPairs
	199		199
	200	Return:	200	Return:
	201	None	201	None
	202	"""	202	"""
	203	self.nChannels = 0	203	self.nChannels = 0
	204	self.nPairs = 0	204	self.nPairs = 0
	205	self.pairList = []	205	self.pairList = []
	206		206
	207	for i in range( 0, self.m_ProcessingHeader.totalSpectra*2, 2 ):	207	for i in range( 0, self.m_ProcessingHeader.totalSpectra*2, 2 ):
	208	if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]:	208	if self.m_ProcessingHeader.spectraComb[i] == self.m_ProcessingHeader.spectraComb[i+1]:
	209	self.nChannels = self.nChannels + 1 #par de canales iguales	209	self.nChannels = self.nChannels + 1 #par de canales iguales
	210	else:	210	else:
	211	self.nPairs = self.nPairs + 1 #par de canales diferentes	211	self.nPairs = self.nPairs + 1 #par de canales diferentes
	212	self.pairList.append( (self.m_ProcessingHeader.spectraComb[i], self.m_ProcessingHeader.spectraComb[i+1]) )	212	self.pairList.append( (self.m_ProcessingHeader.spectraComb[i], self.m_ProcessingHeader.spectraComb[i+1]) )
	213		213
	214	pts2read = self.m_ProcessingHeader.numHeights * self.m_ProcessingHeader.profilesPerBlock	214	pts2read = self.m_ProcessingHeader.numHeights * self.m_ProcessingHeader.profilesPerBlock
	215		215
	216	self.pts2read_SelfSpectra = int( self.nChannels * pts2read )	216	self.pts2read_SelfSpectra = int( self.nChannels * pts2read )
	217	self.pts2read_CrossSpectra = int( self.nPairs * pts2read )	217	self.pts2read_CrossSpectra = int( self.nPairs * pts2read )
	218	self.pts2read_DCchannels = int( self.m_SystemHeader.numChannels * self.m_ProcessingHeader.numHeights )	218	self.pts2read_DCchannels = int( self.m_SystemHeader.numChannels * self.m_ProcessingHeader.numHeights )
	219		219
	220	self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels	220	self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
	221		221
	222	self.channelList = numpy.arange( self.nChannels )	222	self.channelList = numpy.arange( self.nChannels )
	223		223
	224		224
	225	def readBlock(self):	225	def readBlock(self):
	226	"""	226	"""
	227	Lee el bloque de datos desde la posicion actual del puntero del archivo	227	Lee el bloque de datos desde la posicion actual del puntero del archivo
	228	(self.fp) y actualiza todos los parametros relacionados al bloque de datos	228	(self.fp) y actualiza todos los parametros relacionados al bloque de datos
	229	(metadata + data). La data leida es almacenada en el buffer y el contador del buffer	229	(metadata + data). La data leida es almacenada en el buffer y el contador del buffer
	230	es seteado a 0	230	es seteado a 0
	231		231
	232	Return: None	232	Return: None
	233		233
	234	Variables afectadas:	234	Variables afectadas:
	235	self.datablockIndex	235	self.datablockIndex
	236	self.flagIsNewFile	236	self.flagIsNewFile
	237	self.flagIsNewBlock	237	self.flagIsNewBlock
	238	self.nTotalBlocks	238	self.nTotalBlocks
	239	self.data_spc	239	self.data_spc
	240	self.data_cspc	240	self.data_cspc
	241	self.data_dc	241	self.data_dc
	242		242
	243	Exceptions:	243	Exceptions:
	244	Si un bloque leido no es un bloque valido	244	Si un bloque leido no es un bloque valido
	245	"""	245	"""
	246	blockOk_flag = False	246	blockOk_flag = False
	247	fpointer = self.fp.tell()	247	fpointer = self.fp.tell()
	248		248
	249	spc = numpy.fromfile( self.fp, self.dataType[0], self.pts2read_SelfSpectra )	249	spc = numpy.fromfile( self.fp, self.dataType[0], self.pts2read_SelfSpectra )
	250	cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra )	250	cspc = numpy.fromfile( self.fp, self.dataType, self.pts2read_CrossSpectra )
	251	dc = numpy.fromfile( self.fp, self.dataType, self.pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )	251	dc = numpy.fromfile( self.fp, self.dataType, self.pts2read_DCchannels ) #int(self.m_ProcessingHeader.numHeights*self.m_SystemHeader.numChannels) )
	252		252
	253	try:	253	try:
	254	spc = spc.reshape( (self.nChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D	254	spc = spc.reshape( (self.nChannels, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
	255	if self.nPairs != 0:	255	if self.nPairs != 0:
	256	cspc = cspc.reshape( (self.nPairs, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D	256	cspc = cspc.reshape( (self.nPairs, self.m_ProcessingHeader.numHeights, self.m_ProcessingHeader.profilesPerBlock) ) #transforma a un arreglo 3D
	257	else:	257	else:
	258	cspc = None	258	cspc = None
	259	dc = dc.reshape( (self.m_SystemHeader.numChannels, self.m_ProcessingHeader.numHeights) ) #transforma a un arreglo 2D	259	dc = dc.reshape( (self.m_SystemHeader.numChannels, self.m_ProcessingHeader.numHeights) ) #transforma a un arreglo 2D
	260	except:	260	except:
	261	print "Data file %s is invalid" % self.filename	261	print "Data file %s is invalid" % self.filename
	262	return 0	262	return 0
	263		263
	264	if not( self.m_ProcessingHeader.shif_fft ):	264	if not( self.m_ProcessingHeader.shif_fft ):
	265	spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones	265	spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
	266	if ~~cspc~~ != ~~None~~:	266
	267	cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones	267	if cspc != None:
	268		268	cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
	269	spc = numpy.transpose( spc, (0,2,1) )	269
	270	if ~~cspc~~ != ~~None~~: cspc = numpy.transpose( cspc, (0,2,1) )	270	spc = numpy.transpose( spc, (0,2,1) )
	271		271
	272	self.data_spc = spc	272	if cspc != None:
	273	if cspc != None:	273	cspc = numpy.transpose( cspc, (0,2,1) )
	274	self.data_cspc = cspc['real'] + cspc['imag']*1j	274
	275	~~else~~:	275
	276	~~self~~.~~data_cspc~~ = None	276	if cspc != None:
	277	self.data_dc = dc['real'] + dc['imag']*1j	277	self.data_cspc = cspc['real'] + cspc['imag']*1j
	278		278	else:
	279	self.data~~blockIndex~~ = 0	279	self.data_cspc = None
	280	self.flagIsNewFile = 0	280
	281	self.~~flagIsNewBlock~~ = 1	281	self.data_spc = spc
	282		282	self.data_dc = dc['real'] + dc['imag']*1j
	283	self.nTotalBlocks += 1	283
	284	self.~~nReadBlocks~~ += 1	284	self.datablockIndex = 0
	285		285	self.flagIsNewFile = 0
	286	return 1	286	self.flagIsNewBlock = 1
	287		287
	288		288	self.nTotalBlocks += 1
	289	def getData(self):	289	self.nReadBlocks += 1
	290	"""	290
	291	Copia el buffer de lectura a la clase "Spectra",	291	return 1
	292	con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de	292
	293	lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"	293
	294		294	def getData(self):
	295	~~Return:~~	295	"""
	296	0 : Si no hay mas archivos disponibles	296	Copia el buffer de lectura a la clase "Spectra",
	297	1 : Si hizo una buena copia del buffer	297	con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
	298		298	lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
	299	~~Affected:~~	299
	300	self.m_DataObj	300	Return:
	301	self.datablockIndex	301	0 : Si no hay mas archivos disponibles
	302	self.flagResetProcessing	302	1 : Si hizo una buena copia del buffer
	303	self.flagIsNewBlock	303
	304	"""	304	Affected:
	305		305	self.m_DataObj
	306	if self.flagNoMoreFiles: return 0	306	self.datablockIndex
	307		307	self.flagResetProcessing
	308	self.flagResetProcessing = 0	308	self.flagIsNewBlock
	309	self.flagIsNewBlock = 0	309	"""
	310		310
	311	if self.__hasNotDataInBuffer():	311	if self.flagNoMoreFiles: return 0
	312		312
	313	if not( self.readNextBlock() ):	313	self.flagResetProcessing = 0
	314	return 0	314	self.flagIsNewBlock = 0
	315		315
	316	self.updateDataHeader()	316	if self.__hasNotDataInBuffer():
	317		317
	318	if self.flagNoMoreFiles == 1:	318	if not( self.readNextBlock() ):
	319	print 'Process finished'	319	return 0
	320	~~return~~ 0	320
	321		321	self.updateDataHeader()
	322	#data es un numpy array de 3 dmensiones (perfiles, alturas y canales)	322
	323		323	if self.flagNoMoreFiles == 1:
	324	if self.data_dc == None:	324	print 'Process finished'
	325	self.m_DataObj.flagNoData = True	325	return 0
	326	return 0	326
	327		327	#data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
	328	self.m_DataObj.flagNoData = False	328
	329	self.m_DataObj.flagResetProcessing = self.flagResetProcessing	329	if self.data_dc == None:
	330		330	self.m_DataObj.flagNoData = True
	331	self.m_DataObj.data_spc = self.data_spc	331	return 0
	332	self.m_DataObj.data_cspc = self.data_cspc	332
	333	self.m_DataObj.~~data_dc~~ = self.~~data_dc~~	333	self.m_DataObj.flagNoData = False
	334		334	self.m_DataObj.flagResetProcessing = self.flagResetProcessing
	335	~~return~~ 1	335
	336		336	self.m_DataObj.data_spc = self.data_spc
	337		337	self.m_DataObj.data_cspc = self.data_cspc
	338	class SpectraWriter(JRODataWriter):	338	self.m_DataObj.data_dc = self.data_dc
	339		339
	340	"""	340	return 1
	341	Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura	341
	342	de los datos siempre se realiza por bloques.	342
	343	"""	343	class SpectraWriter(JRODataWriter):
	344		344
	345	m_DataObj = None	345	"""
	346		346	Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
	347	shape_spc_Buffer = None	347	de los datos siempre se realiza por bloques.
	348	shape_cspc_Buffer = None	348	"""
	349	shape_dc_Buffer = None	349
	350		350	m_DataObj = None
	351	data_spc = None	351
	352	~~data_cspc~~ = None	352	shape_spc_Buffer = None
	353	~~data_dc~~ = None	353	shape_cspc_Buffer = None
	354		354	shape_dc_Buffer = None
	355		355
	356	def __init__(self, m_Spectra=None):	356	data_spc = None
	357	"""	357	data_cspc = None
	358	Inicializador de la clase SpectraWriter para la escritura de datos de espectros.	358	data_dc = None
	359		359
	360	Affected:	360
	361	self.m_DataObj	361	def __init__(self, m_Spectra=None):
	362	self.m_BasicHeader	362	"""
	363	self.m_SystemHeader	363	Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
	364	self.m_RadarControllerHeader	364
	365	self.m_ProcessingHeader	365	Affected:
	366		366	self.m_DataObj
	367	Return: None	367	self.m_BasicHeader
	368	"""	368	self.m_SystemHeader
	369	if m_Spectra == None:	369	self.m_RadarControllerHeader
	370	m_Spectra = Spectra()	370	self.m_ProcessingHeader
	371		371
	372	if not( isinstance(m_Spectra, Spectra) ):	372	Return: None
	373	raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"	373	"""
	374		374	if m_Spectra == None:
	375	self.m_DataObj = m_Spectra	375	m_Spectra = Spectra()
	376		376
	377	self.ext = ".pdata"	377	if not( isinstance(m_Spectra, Spectra) ):
	378		378	raise ValueError, "in SpectraReader, m_Spectra must be an Spectra class object"
	379	self.optchar = "P"	379
	380		380	self.m_DataObj = m_Spectra
	381	self.shape_spc_Buffer = None	381
	382	self.shape_cspc_Buffer = None	382	self.ext = ".pdata"
	383	self.shape_dc_Buffer = None	383
	384		384	self.optchar = "P"
	385	self.data_spc = None	385
	386	self.~~data_cspc~~ = None	386	self.shape_spc_Buffer = None
	387	self.~~data_dc~~ = None	387	self.shape_cspc_Buffer = None
	388		388	self.shape_dc_Buffer = None
	389	####################################	389
	390		390	self.data_spc = None
	391	self.fp = None	391	self.data_cspc = None
	392		392	self.data_dc = None
	393	self.nWriteBlocks = 0	393
	394		394	####################################
	395	self.flagIsNewFile = 1	395
	396		396	self.fp = None
	397	self.nTotalBlocks = 0	397
	398		398	self.nWriteBlocks = 0
	399	self.flagIsNewBlock = 0	399
	400		400	self.flagIsNewFile = 1
	401	self.flagNoMoreFiles = 0	401
	402		402	self.nTotalBlocks = 0
	403	self.setFile = None	403
	404		404	self.flagIsNewBlock = 0
	405	self.dataType = None	405
	406		406	self.flagNoMoreFiles = 0
	407	self.path = None	407
	408		408	self.setFile = None
	409	self.noMoreFiles = 0	409
	410		410	self.dataType = None
	411	self.filename = None	411
	412		412	self.path = None
	413	self.m_BasicHeader= BasicHeader()	413
	414		414	self.noMoreFiles = 0
	415	self.m_SystemHeader = SystemHeader()	415
	416		416	self.filename = None
	417	self.m_RadarControllerHeader = RadarControllerHeader()	417
	418		418	self.m_BasicHeader= BasicHeader()
	419	self.m_ProcessingHeader = ProcessingHeader()	419
	420		420	self.m_SystemHeader = SystemHeader()
	421		421
	422	def hasAllDataInBuffer(self):	422	self.m_RadarControllerHeader = RadarControllerHeader()
	423	return 1	423
	424		424	self.m_ProcessingHeader = ProcessingHeader()
	425		425
	426	def setBlockDimension(self):	426
	427	"""	427	def hasAllDataInBuffer(self):
	428	Obtiene las formas dimensionales del los subbloques de datos que componen un bloque	428	return 1
	429		429
	430	Affected:	430
	431	self.shape_spc_Buffer	431	def setBlockDimension(self):
	432	self.shape_cspc_Buffer	432	"""
	433	self.shape_dc_Buffer	433	Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
	434		434
	435	Return: None	435	Affected:
	436	"""	436	self.shape_spc_Buffer
	437	self.shape_spc_Buffer = (~~self~~.~~m_DataObj~~.~~nChannels~~,	437	self.shape_cspc_Buffer
	438	self.m_ProcessingHeader.numHeights,	438	self.shape_dc_Buffer
	439	self.m_ProcessingHeader.profilesPerBlock)	439
	440		440	Return: None
	441	self.shape_cspc_Buffer = (self.m_DataObj.nPairs,	441	"""
	442	self.m_ProcessingHeader.numHeights,	442	self.shape_spc_Buffer = (self.m_DataObj.nChannels,
	443	self.m_ProcessingHeader.~~profilesPerBlock~~)	443	self.m_ProcessingHeader.numHeights,
	444		444	self.m_ProcessingHeader.profilesPerBlock)
	445	self.shape_dc_Buffer = (self.m_SystemHeader.numChannels,	445
	446	self.m_ProcessingHeader.numHeights)	446	self.shape_cspc_Buffer = (self.m_DataObj.nPairs,
	447		447	self.m_ProcessingHeader.numHeights,
	448		448	self.m_ProcessingHeader.profilesPerBlock)
	449	def writeBlock(self):	449
	450	"""	450	self.shape_dc_Buffer = (self.m_SystemHeader.numChannels,
	451	Escribe el buffer en el file designado	451	self.m_ProcessingHeader.numHeights)
	452		452
	453	Affected:	453
	454	self.data_spc	454	def writeBlock(self):
	455	self.data_cspc	455	"""
	456	self.data_dc	456	Escribe el buffer en el file designado
	457	self.flagIsNewFile	457
	458	self.flagIsNewBlock	458	Affected:
	459	self.~~nTotalBlocks~~	459	self.data_spc
	460	self.~~nWriteBlocks~~	460	self.data_cspc
	461		461	self.data_dc
	462	Return: None	462	self.flagIsNewFile
	463	"""	463	self.flagIsNewBlock
	464		464	self.nTotalBlocks
	465	spc = numpy.transpose( self.data_spc, (0,2,1) )	465	self.nWriteBlocks
	466	if not( self.m_ProcessingHeader.shif_fft ):	466
	467	spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones	467	Return: None
	468	data = spc.reshape((-1))	468	"""
	469	data.tofile(self.fp)	469
	470		470	spc = numpy.transpose( self.data_spc, (0,2,1) )
	471	if self.data_cspc != None:	471	if not( self.m_ProcessingHeader.shif_fft ):
	472	data = numpy.zeros( self.shape_cspc_Buffer, self.dataType )	472	spc = numpy.roll( spc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
	473	cspc = numpy.transpose( self.data_cspc, (0,2,1) )	473	data = spc.reshape((-1))
	474	if not( self.m_ProcessingHeader.shif_fft ):	474	data.tofile(self.fp)
	475	cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones	475
	476	data['real'] = cspc.real	476	if self.data_cspc != None:
	477	data['imag'] = cspc.imag	477	data = numpy.zeros( self.shape_cspc_Buffer, self.dataType )
	478	data = data.reshape((-1))	478	cspc = numpy.transpose( self.data_cspc, (0,2,1) )
	479	data.tofile(self.fp)	479	if not( self.m_ProcessingHeader.shif_fft ):
	480		480	cspc = numpy.roll( cspc, self.m_ProcessingHeader.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
	481	data = numpy.zeros( self.shape_dc_Buffer, self.dataType )	481	data['real'] = cspc.real
	482	dc = self.data_dc	482	data['imag'] = cspc.imag
	483	data['real'] = dc.real	483	data = data.reshape((-1))
	484	data['imag'] = dc.imag	484	data.tofile(self.fp)
	485	data = data.reshape((-1))	485
	486	data.tofile(self.fp)	486	data = numpy.zeros( self.shape_dc_Buffer, self.dataType )
	487		487	dc = self.data_dc
	488	self.data_spc.fill(0)	488	data['real'] = dc.real
	489	self.data_dc.fill(0)	489	data['imag'] = dc.imag
	490	if self.data_cspc != None:	490	data = data.reshape((-1))
	491	self.data_cspc.fill(0)	491	data.tofile(self.fp)
	492		492
	493	self.flagIsNewFile = 0	493	self.data_spc.fill(0)
	494	self.flagIsNewBlock = 1	494	self.data_dc.fill(0)
	495	self.~~nTotalBlocks~~ += 1	495	if self.data_cspc != None:
	496	self.nWriteBlocks += 1	496	self.data_cspc.fill(0)
	497		497
	498		498	self.flagIsNewFile = 0
	499	def putData(self):	499	self.flagIsNewBlock = 1
	500	"""	500	self.nTotalBlocks += 1
	501	Setea un bloque de datos y luego los escribe en un file	501	self.nWriteBlocks += 1
	502		502
	503	~~Affected:~~	503
	504	self.data_spc	504	def putData(self):
	505	self.data_cspc	505	"""
	506	self.data_dc	506	Setea un bloque de datos y luego los escribe en un file
	507		507
	508	~~Return:~~	508	Affected:
	509	0 : Si no hay data o no hay mas files que puedan escribirse	509	self.data_spc
	510	1 : Si se escribio la data de un bloque en un file	510	self.data_cspc
	511	"""	511	self.data_dc
	512	self.flagIsNewBlock = 0	512
	513		513	Return:
	514	if self.m_DataObj.flagNoData:	514	0 : Si no hay data o no hay mas files que puedan escribirse
	515	return 0	515	1 : Si se escribio la data de un bloque en un file
	516		516	"""
	517	if self.m_DataObj.flagResetProcessing:	517	self.flagIsNewBlock = 0
	518	self.data_spc.fill(0)	518
	519	self.data_cspc.fill(0)	519	if self.m_DataObj.flagNoData:
	520	self.data_dc.fill(0)	520	return 0
	521	self.setNextFile()	521
	522		522	if self.m_DataObj.flagResetProcessing:
	523	self.data_spc = self.m_DataObj.data_spc	523	self.data_spc.fill(0)
	524	self.data_cspc = self.m_DataObj.data_cspc	524	self.data_cspc.fill(0)
	525	self.data_dc = self.m_DataObj.data_dc	525	self.data_dc.fill(0)
	526		526	self.setNextFile()
	527	# #self.m_ProcessingHeader.dataBlocksPerFile)	527
	528	if self.hasAllDataInBuffer():	528	self.data_spc = self.m_DataObj.data_spc
	529	self.getDataHeader()	529	self.data_cspc = self.m_DataObj.data_cspc
	530	self.writeNextBlock()	530	self.data_dc = self.m_DataObj.data_dc
	531		531
	532	if self.flagNoMoreFiles:	532	# #self.m_ProcessingHeader.dataBlocksPerFile)
	533	#print 'Process finished'	533	if self.hasAllDataInBuffer():
	534	return 0	534	self.getDataHeader()
	535		535	self.writeNextBlock()
			536
			537	if self.flagNoMoreFiles:
			538	#print 'Process finished'
			539	return 0
			540
	536	return 1 No newline at end of file	541	return 1

schainpy/IO/TestIO.py +56 -56

@@ -1,57 +1,57
1	'''	1	'''
2	Created on 23/01/2012	2	Created on 23/01/2012
3		3
4	@author $Author$	4	@author $Author$
5	@version $Id$	5	@version $Id$
6	'''	6	'''
7	import os	7	import os
8	import sys	8	import sys
9	import datetime	9	import datetime
10	import time	10	import time
11		11
12	class TestIO():	12	class TestIO:
13		13
14	def __init__(self):	14	def __init__(self):
15	self.setValues()	15	self.setValues()
16	self.createVoltageObjects()	16	self.createVoltageObjects()
17	self.testReadVoltage()	17	self.testReadVoltage()
18	pass	18	pass
19		19
20	def setValues(self):	20	def setValues(self):
21		21
22		22
23	self.path = '/Users/danielangelsuarezmunoz/Documents/Projects/testWR'	23	self.path = '/Users/danielangelsuarezmunoz/Documents/Projects/testWR'
24	self.startDateTime = datetime.datetime(2007,5,1,17,49,0)	24	self.startDateTime = datetime.datetime(2007,5,1,17,49,0)
25	self.endDateTime = datetime.datetime(2007,5,1,18,15,0)	25	self.endDateTime = datetime.datetime(2007,5,1,18,15,0)
26		26
27	def createVoltageObjects(self):	27	def createVoltageObjects(self):
28	path = os.path.split(os.getcwd())[0]	28	path = os.path.split(os.getcwd())[0]
29	sys.path.append(path)	29	sys.path.append(path)
30		30
31	from IO.VoltageIO import VoltageReader	31	from IO.VoltageIO import VoltageReader
32	from IO.VoltageIO import VoltageWriter	32	from IO.VoltageIO import VoltageWriter
33	from Model.Voltage import Voltage	33	from Model.Voltage import Voltage
34		34
35	self.voltageModelObj = Voltage()	35	self.voltageModelObj = Voltage()
36	self.voltageReaderObj = VoltageReader(self.voltageModelObj)	36	self.voltageReaderObj = VoltageReader(self.voltageModelObj)
37	self.voltageReaderObj.setup(self.path, self.startDateTime, self.endDateTime)	37	self.voltageReaderObj.setup(self.path, self.startDateTime, self.endDateTime)
38		38
39	# self.voltageWriterObj = VoltageWriter(self.voltageModelObj)	39	# self.voltageWriterObj = VoltageWriter(self.voltageModelObj)
40	# self.voltageWriterObj.setup('/Users/danielangelsuarezmunoz/Documents/Projects/testWR')	40	# self.voltageWriterObj.setup('/Users/danielangelsuarezmunoz/Documents/Projects/testWR')
41		41
42		42
43	def testReadVoltage(self):	43	def testReadVoltage(self):
44	while(not(self.voltageReaderObj.noMoreFiles)):	44	while(not(self.voltageReaderObj.noMoreFiles)):
45		45
46	self.voltageReaderObj.getData()	46	self.voltageReaderObj.getData()
47	if self.voltageReaderObj.flagResetProcessing:	47	if self.voltageReaderObj.flagResetProcessing:
48	print 'jump'	48	print 'jump'
49		49
50	if self.voltageReaderObj.flagIsNewBlock:	50	if self.voltageReaderObj.flagIsNewBlock:
51	print 'Block No %04d, Time: %s'%(self.voltageReaderObj.nTotalBlocks,	51	print 'Block No %04d, Time: %s'%(self.voltageReaderObj.nTotalBlocks,
52	datetime.datetime.fromtimestamp(self.voltageReaderObj.m_BasicHeader.utc))	52	datetime.datetime.fromtimestamp(self.voltageReaderObj.m_BasicHeader.utc))
53		53
54	# self.voltageWriterObj.putData()	54	# self.voltageWriterObj.putData()
55		55
56	if __name__ == '__main__':	56	if __name__ == '__main__':
57	TestIO() No newline at end of file	57	TestIO()

schainpy/IO/VoltageIO.py +1 -1

             '''
             Created on 23/01/2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             import numpy
             import glob
             import fnmatch
             import time, datetime
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Model.JROHeader import *
             from Model.Voltage import Voltage
             from IO.JRODataIO import JRODataReader
             from IO.JRODataIO import JRODataWriter
             class VoltageReader(JRODataReader):
                 """
                 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
                 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
                 perfiles*alturas*canales) son almacenados en la variable "buffer".
                                          perfiles * alturas * canales
                 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
                 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
                 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
                 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
                 Example:
                     dpath = "/home/myuser/data"
                     startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
                     endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
                     readerObj = VoltageReader()
                     readerObj.setup(dpath, startTime, endTime)
                     while(True):
                         #to get one profile
                         profile =  readerObj.getData()
                         #print the profile
                         print profile
                         #If you want to see all datablock
                         print readerObj.datablock
                         if readerObj.flagNoMoreFiles:
                             break
                 """
                 m_DataObj = None
                 datablock = None
                 ext = ".r"
                 optchar = "D"
                 def __init__(self, m_Voltage=None):
                     """
                     Inicializador de la clase VoltageReader para la lectura de datos de voltage.
                     Input:
                         m_Voltage    :    Objeto de la clase Voltage. Este objeto sera utilizado para
                                           almacenar un perfil de datos cada vez que se haga un requerimiento
                                           (getData). El perfil sera obtenido a partir del buffer de datos,
                                           si el buffer esta vacio se hara un nuevo proceso de lectura de un
                                           bloque de datos.
                                           Si este parametro no es pasado se creara uno internamente.
                     Variables afectadas:
                         self.m_DataObj
                     Return:
                         None
                     """
                     if m_Voltage == None:
                         m_Voltage = Voltage()
                     if not(isinstance(m_Voltage, Voltage)):
                         raise ValueError, "in VoltageReader, m_Voltage must be an Voltage class object"
                     self.m_DataObj = m_Voltage
                     self.datablock = None
                     self.utc = 0
                     self.ext = ".r"
                     self.optchar = "D"
                     self.m_BasicHeader = BasicHeader()
                     self.m_SystemHeader = SystemHeader()
                     self.m_RadarControllerHeader = RadarControllerHeader()
                     self.m_ProcessingHeader = ProcessingHeader()
                     self.online = 0
                     self.fp = None
                     self.idFile = None
                     self.startDateTime = None
                     self.endDateTime = None
                     self.dataType = None
                     self.fileSizeByHeader = None
                     self.filenameList = []
                     self.filename = None
                     self.fileSize = None
                     self.firstHeaderSize = 0
                     self.basicHeaderSize = 24
                     self.pathList = []
                     self.filenameList = []
                     self.lastUTTime = 0
                     self.maxTimeStep = 30
                     self.flagNoMoreFiles = 0
                     self.set = 0
                     self.path = None
                     self.profileIndex = 9999
                     self.delay  = 3   #seconds
                     self.nTries  = 3  #quantity tries
                     self.nFiles = 3   #number of files for searching
                     self.nReadBlocks = 0
                     self.flagIsNewFile = 1
                     self.ippSeconds = 0
                     self.flagResetProcessing = 0
                     self.flagIsNewBlock = 0
                     self.nTotalBlocks = 0
                     self.blocksize = 0
                 def __hasNotDataInBuffer(self):
                     if self.profileIndex >= self.m_ProcessingHeader.profilesPerBlock:
                         return 1
                     return 0
                 def getBlockDimension(self):
                     """
                     Obtiene la cantidad de puntos a leer por cada bloque de datos
                     Affected:
                         self.blocksize
                     Return:
                         None
                     """
                     pts2read = self.m_ProcessingHeader.profilesPerBlock * self.m_ProcessingHeader.numHeights * self.m_SystemHeader.numChannels
                     self.blocksize = pts2read
                 def readBlock(self):
                     """
                     readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
                     (self.fp) y actualiza todos los parametros relacionados al bloque de datos
                     (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
                     es seteado a 0
                     Inputs:
                         None
                     Return:
                         None
                     Affected:
                         self.profileIndex
                         self.datablock
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                     Exceptions:
                         Si un bloque leido no es un bloque valido
                     """
                     junk = numpy.fromfile( self.fp, self.dataType, self.blocksize )
                     try:
                         junk = junk.reshape( (self.m_ProcessingHeader.profilesPerBlock, self.m_ProcessingHeader.numHeights, self.m_SystemHeader.numChannels) )
                     except:
                         print "The read block (%3d) has not enough data" %self.nReadBlocks
                         return 0
                     junk = numpy.transpose(junk, (2,0,1))
                     self.datablock = junk['real'] + junk['imag']*1j
                     self.profileIndex = 0
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     return 1
                 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
                     lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
                     Ademas incrementa el contador del buffer en 1.
                     Return:
                         data    :    retorna un perfil de voltages (alturas * canales) copiados desde el
                                      buffer. Si no hay mas archivos a leer retorna None.
                     Variables afectadas:
                         self.m_DataObj
                         self.profileIndex
                     Affected:
                         self.m_DataObj
                         self.profileIndex
                         self.flagResetProcessing
                         self.flagIsNewBlock
                     """
                     if self.flagNoMoreFiles: return 0
                     self.flagResetProcessing = 0
                     self.flagIsNewBlock = 0
                     if self.__hasNotDataInBuffer():
                         if not( self.readNextBlock() ):
                             return 0
                         self.updateDataHeader()
                     if self.flagNoMoreFiles == 1:
                         print 'Process finished'
                         return 0
                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     if self.datablock == None:
                         self.m_DataObj.flagNoData = True
                         return 0
                     time = self.m_BasicHeader.utc + self.profileIndex * self.ippSeconds
                     self.m_DataObj.m_BasicHeader.utc = time
                     self.m_DataObj.flagNoData = False
                     self.m_DataObj.flagResetProcessing = self.flagResetProcessing
                     self.m_DataObj.data = self.datablock[:,self.profileIndex,:]
                     self.profileIndex += 1
                     #call setData - to Data Object
                     return 1 #self.m_DataObj.data
-            class VoltageWriter( JRODataWriter ):
+            class VoltageWriter(JRODataWriter):
                 """
                 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 __configHeaderFile = 'wrSetHeadet.txt'
                 m_DataObj = None
                 ext = ".r"
                 optchar = "D"
                 datablock = None
                 profileIndex = 0
                 shapeBuffer = None
                 def __init__(self, m_Voltage=None):
                     """
                     Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
                     Affected:
                         self.m_DataObj
                     Return: None
                     """
                     if m_Voltage == None:
                         m_Voltage = Voltage()
                     if not( isinstance(m_Voltage, Voltage) ):
                         raise ValueError, "in VoltageReader, m_Voltage must be an Spectra class object"
                     self.m_DataObj = m_Voltage
                 def hasAllDataInBuffer(self):
                     if self.profileIndex >= self.m_ProcessingHeader.profilesPerBlock:
                         return 1
                     return 0
                 def setBlockDimension(self):
                     """
                     Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
                     Affected:
                         self.shape_spc_Buffer
                         self.shape_cspc_Buffer
                         self.shape_dc_Buffer
                     Return: None
                     """
                     self.shapeBuffer = (self.m_ProcessingHeader.profilesPerBlock,
                                         self.m_ProcessingHeader.numHeights,
                                         self.m_SystemHeader.numChannels )
                     self.datablock = numpy.zeros((self.m_SystemHeader.numChannels,
                                                  self.m_ProcessingHeader.profilesPerBlock,
                                                  self.m_ProcessingHeader.numHeights),
                                                  dtype=numpy.dtype('complex'))
                 def writeBlock(self):
                     """
                     Escribe el buffer en el file designado
                     Affected:
                         self.profileIndex
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.nWriteBlocks
                     Return: None
                     """
                     data = numpy.zeros( self.shapeBuffer, self.dataType )
                     junk = numpy.transpose(self.datablock, (1,2,0))
                     data['real'] = junk.real
                     data['imag'] = junk.imag
                     data = data.reshape( (-1) )
                     data.tofile( self.fp )
                     self.datablock.fill(0)
                     self.profileIndex = 0
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nWriteBlocks += 1
                 def putData(self):
                     """
                     Setea un bloque de datos y luego los escribe en un file
                     Affected:
                         self.flagIsNewBlock
                         self.profileIndex
                     Return:
 :    Si no hay data o no hay mas files que puedan escribirse
 :    Si se escribio la data de un bloque en un file
                     """
                     self.flagIsNewBlock = 0
                     if self.m_DataObj.flagNoData:
                         return 0
                     if self.m_DataObj.flagResetProcessing:
                         self.datablock.fill(0)
                         self.profileIndex = 0
                         self.setNextFile()
                     self.datablock[:,self.profileIndex,:] = self.m_DataObj.data
                     self.profileIndex += 1
                     if self.hasAllDataInBuffer():
                         #if self.flagIsNewFile:
                         self.getDataHeader()
                         self.writeNextBlock()
                     if self.flagNoMoreFiles:
                         #print 'Process finished'
                         return 0
                     return 1
   No newline at end of file

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