schain Commit - r179:e4faab4afbdd · Jicamarca Repository

             '''
             $Author: murco $
             $Id: JRODataIO.py 169 2012-11-19 21:57:03Z murco $
             '''
             import os, sys
             import glob
             import time
             import numpy
             import fnmatch
             import time, datetime
             from jrodata import *
             from jroheaderIO import *
             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.
                 """
                 basicHeaderObj = BasicHeader()
                 try:
                     fp = open(filename,'rb')
                 except:
                     raise IOError, "The file %s can't be opened" %(filename)
                 sts = basicHeaderObj.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 <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.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
             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
             class JRODataIO:
                 c = 3E8
-                __isConfig = False
+                isConfig = False
                 basicHeaderObj = BasicHeader()
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
                 processingHeaderObj = ProcessingHeader()
                 online = 0
                 dtype = None
                 pathList = []
                 filenameList = []
                 filename = None
                 ext = None
                 flagNoMoreFiles = 0
                 flagIsNewFile = 1
                 flagTimeBlock = 0
                 flagIsNewBlock = 0
                 fp = None
                 firstHeaderSize = 0
                 basicHeaderSize = 24
                 versionFile = 1103
                 fileSize = None
                 ippSeconds = None
                 fileSizeByHeader = None
                 fileIndex = None
                 profileIndex = None
                 blockIndex = None
                 nTotalBlocks = None
                 maxTimeStep = 30
                 lastUTTime = None
                 datablock = None
-                dataOutObj = None
+                dataOut = None
                 blocksize = None
                 def __init__(self):
                     raise ValueError, "Not implemented"
                 def run(self):
                     raise ValueError, "Not implemented"
             class JRODataReader(JRODataIO):
                 nReadBlocks = 0
                 delay  = 60   #number of seconds waiting a new file
                 nTries  = 3  #quantity tries
                 nFiles = 3   #number of files for searching
                 def __init__(self):
                     """
                     """
                     raise ValueError, "This method has not been implemented"
                 def createObjByDefault(self):
                     """
                     """
                     raise ValueError, "This method has not been implemented"
                 def getBlockDimension(self):
                     raise ValueError, "No implemented"
                 def __searchFilesOffLine(self,
                                         path,
                                         startDate,
                                         endDate,
                                         startTime=datetime.time(0,0,0),
                                         endTime=datetime.time(23,59,59),
                                         set=None,
                                         expLabel="",
                                         ext=".r"):
                     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 = []
                     dateList = []
                     thisDate = startDate
                     while(thisDate <= endDate):
                         year = thisDate.timetuple().tm_year
                         doy = thisDate.timetuple().tm_yday
                         match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
                         if len(match) == 0:
                             thisDate += datetime.timedelta(1)
                             continue
                         pathList.append(os.path.join(path,match[0],expLabel))
                         dateList.append(thisDate)
                         thisDate += datetime.timedelta(1)
                     filenameList = []
                     for index in range(len(pathList)):
                         thisPath = pathList[index]
                         fileList = glob.glob1(thisPath, "*%s" %ext)
                         fileList.sort()
                         #Busqueda de datos en el rango de horas indicados
                         thisDate = dateList[index]
                         startDT = datetime.datetime.combine(thisDate, startTime)
                         endDT = datetime.datetime.combine(thisDate, endTime)
                         startUtSeconds = time.mktime(startDT.timetuple())
                         endUtSeconds = time.mktime(endDT.timetuple())
                         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 __searchFilesOnLine(self, path, startDate=None, endDate=None, startTime=None, endTime=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
                         startDate      :    Fecha inicial. Rechaza todos los directorios donde
                                             file end time < startDate (obejto datetime.date)
                         endDate        :    Fecha final. Rechaza todos los directorios donde
                                             file start time > endDate (obejto datetime.date)
                         startTime      :    Tiempo inicial. Rechaza todos los archivos donde
                                             file end time < startTime (obejto datetime.time)
                         endTime        :    Tiempo final. Rechaza todos los archivos donde
                                             file start time > endTime (obejto datetime.time)
                         expLabel        :     Nombre del subexperimento (subfolder)
                         ext              :    extension de los files
                     Return:
                         directory   :    eL directorio donde esta el file encontrado
                         filename    :    el ultimo file de una determinada carpeta
                         year        :    el anho
                         doy         :    el numero de dia del anho
                         set         :    el set del archivo
                     """
                     dirList = []
                     pathList = []
                     directory = None
                     #Filtra solo los directorios
                     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 startDate:
                         startDateTime = datetime.datetime.combine(startDate, startTime)
                         thisDateTime = startDateTime
                         if endDate == None: endDateTime = startDateTime
                         else: endDateTime = datetime.datetime.combine(endDate, endTime)
                         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 setup(self,dataOutObj=None,
+                def setup(self,dataOut=None,
                             path=None,
                             startDate=None,
                             endDate=None,
                             startTime=datetime.time(0,0,0),
                             endTime=datetime.time(23,59,59),
                             set=0,
                             expLabel = "",
                             ext = None,
                             online = False,
                             delay = 60):
                     if path == None:
                         raise ValueError, "The path is not valid"
                     if ext == None:
                         ext = self.ext
-                    if dataOutObj == None:
+                    if dataOut == None:
-                        dataOutObj = self.createObjByDefault()
+                        dataOut = self.createObjByDefault()
-                    self.dataOutObj = dataOutObj
+                    self.dataOut = dataOut
                     if online:
                         print "Searching files in online mode..."
                         doypath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext)
                         if not(doypath):
                             for nTries in range( self.nTries ):
                                 print '\tWaiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
                                 time.sleep( self.delay )
                                 doypath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=exp)
                                 if doypath:
                                     break
                         if not(doypath):
                             print "There 'isn't valied files in %s" % path
                             return None
                         self.year = year
                         self.doy  = doy
                         self.set  = set - 1
                         self.path = path
                     else:
                         print "Searching files in offline mode ..."
                         pathList, filenameList = self.__searchFilesOffLine(path, startDate, endDate, startTime, endTime, set, expLabel, ext)
                         if not(pathList):
                             print "No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,
                                                                     datetime.datetime.combine(startDate,startTime).ctime(),
                                                                     datetime.datetime.combine(endDate,endTime).ctime())
                             sys.exit(-1)
                         self.fileIndex = -1
                         self.pathList = pathList
                         self.filenameList = filenameList
                     self.online = online
                     self.delay = delay
                     ext = ext.lower()
                     self.ext = ext
                     if not(self.setNextFile()):
                         if (startDate!=None) and (endDate!=None):
                             print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
                         elif startDate != None:
                             print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
                         else:
                             print "No files"
                         sys.exit(-1)
             #        self.updateDataHeader()
-                    return self.dataOutObj
+                    return self.dataOut
                 def __setNextFileOffline(self):
                     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 __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 the file \"%s\" , 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" % 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 setNextFile(self):
                     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 __setNewBlock(self):
                     if self.fp == None:
                         return 0
                     if self.flagIsNewFile:
                         return 1
                     self.lastUTTime = self.basicHeaderObj.utc
                     currentSize = self.fileSize - self.fp.tell()
                     neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     if (currentSize >= neededSize):
                         self.__rdBasicHeader()
                         return 1
                     if not(self.setNextFile()):
                         return 0
                     deltaTime = self.basicHeaderObj.utc - self.lastUTTime #
                     self.flagTimeBlock = 0
                     if deltaTime > self.maxTimeStep:
                         self.flagTimeBlock = 1
                     return 1
                 def readNextBlock(self):
                     if not(self.__setNewBlock()):
                         return 0
                     if not(self.readBlock()):
                         return 0
                     return 1
                 def __rdProcessingHeader(self, fp=None):
                     if fp == None:
                         fp = self.fp
                     self.processingHeaderObj.read(fp)
                 def __rdRadarControllerHeader(self, fp=None):
                     if fp == None:
                         fp = self.fp
                     self.radarControllerHeaderObj.read(fp)
                 def __rdSystemHeader(self, fp=None):
                     if fp == None:
                         fp = self.fp
                     self.systemHeaderObj.read(fp)
                 def __rdBasicHeader(self, fp=None):
                     if fp == None:
                         fp = self.fp
                     self.basicHeaderObj.read(fp)
                 def __readFirstHeader(self):
                     self.__rdBasicHeader()
                     self.__rdSystemHeader()
                     self.__rdRadarControllerHeader()
                     self.__rdProcessingHeader()
                     self.firstHeaderSize = self.basicHeaderObj.size
                     datatype = int(numpy.log2((self.processingHeaderObj.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.dtype = datatype_str
                     self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
                     self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
-            #        self.dataOutObj.channelList = numpy.arange(self.systemHeaderObj.numChannels)
+            #        self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
-            #        self.dataOutObj.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
+            #        self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
                     self.getBlockDimension()
                 def __verifyFile(self, filename, msgFlag=True):
                     msg = None
                     try:
                         fp = open(filename, 'rb')
                         currentPosition = fp.tell()
                     except:
                         if msgFlag:
                             print "The file %s can't be opened" % (filename)
                         return False
                     neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
                     if neededSize == 0:
                         basicHeaderObj = BasicHeader()
                         systemHeaderObj = SystemHeader()
                         radarControllerHeaderObj = RadarControllerHeader()
                         processingHeaderObj = ProcessingHeader()
                         try:
                             if not( basicHeaderObj.read(fp) ): raise ValueError
                             if not( systemHeaderObj.read(fp) ): raise ValueError
                             if not( radarControllerHeaderObj.read(fp) ): raise ValueError
                             if not( processingHeaderObj.read(fp) ): raise ValueError
                             data_type = int(numpy.log2((processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
                             neededSize = processingHeaderObj.blockSize + basicHeaderObj.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 getData():
                     pass
                 def hasNotDataInBuffer():
                     pass
                 def readBlock():
                     pass
                 def run(self, **kwargs):
-                    if not(self.__isConfig):
+                    if not(self.isConfig):
-                        self.dataOutObj = dataOut
+            #            self.dataOut = dataOut
                         self.setup(**kwargs)
-                        self.__isConfig = True
+                        self.isConfig = True
                     self.getData()
             class JRODataWriter(JRODataIO):
                 """
                 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 blockIndex = 0
                 path = None
                 setFile = None
                 profilesPerBlock = None
                 blocksPerFile = None
                 nWriteBlocks = 0
-                def __init__(self, dataOutObj=None):
+                def __init__(self, dataOut=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 getDataHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.basicHeaderObj
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.processingHeaderObj self.
                     Return:
                         None
                     """
                     raise ValueError, "No implemented"
                 def getBasicHeader(self):
                     self.basicHeaderObj.size = self.basicHeaderSize #bytes
                     self.basicHeaderObj.version = self.versionFile
                     self.basicHeaderObj.dataBlock = self.nTotalBlocks
-                    utc = numpy.floor(self.dataOutObj.utctime)
+                    utc = numpy.floor(self.dataOut.utctime)
-                    milisecond  = (self.dataOutObj.utctime - utc)* 1000.0
+                    milisecond  = (self.dataOut.utctime - utc)* 1000.0
                     self.basicHeaderObj.utc = utc
                     self.basicHeaderObj.miliSecond = milisecond
                     self.basicHeaderObj.timeZone = 0
                     self.basicHeaderObj.dstFlag = 0
                     self.basicHeaderObj.errorCount = 0
                 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
                     """
             #        CALCULAR PARAMETROS
                     sizeLongHeader = self.systemHeaderObj.size + self.radarControllerHeaderObj.size + self.processingHeaderObj.size
                     self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader
                     self.basicHeaderObj.write(self.fp)
                     self.systemHeaderObj.write(self.fp)
                     self.radarControllerHeaderObj.write(self.fp)
                     self.processingHeaderObj.write(self.fp)
-                    self.dtype = self.dataOutObj.dtype
+                    self.dtype = self.dataOut.dtype
                 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.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
                         self.basicHeaderObj.write(self.fp)
                         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 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.dataOutObj.dataUtcTime)
+                    timeTuple = time.localtime( self.dataOut.dataUtcTime)
                     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.blockIndex = 0
                     #guardando atributos
                     self.filename = filename
                     self.subfolder = subfolder
                     self.fp = fp
                     self.setFile = setFile
                     self.flagIsNewFile = 1
                     self.getDataHeader()
                     print 'Writing the file: %s'%self.filename
                     self.__writeFirstHeader()
                     return 1
                 def setup(self, path, blocksPerFile, profilesPerBlock=None, 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.ext = ext
                     self.path = path
                     self.setFile = set - 1
                     self.blocksPerFile = blocksPerFile
                     self.profilesPerBlock = profilesPerBlock
                     if not(self.setNextFile()):
                         print "There isn't a next file"
                         return 0
                     self.setBlockDimension()
                     return 1
                 def run(self, dataOut, **kwargs):
-                    if not(self.__isConfig):
+                    if not(self.isConfig):
-                        self.dataOutObj = dataOut
+                        self.dataOut = dataOut
                         self.setup(**kwargs)
-                        self.__isConfig = True
+                        self.isConfig = True
                     self.putData()
             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
                 """
                 ext = ".r"
                 optchar = "D"
-                dataOutObj = None
+                dataOut = None
-                def __init__(self, dataOutObj=None):
+                def __init__(self, dataOut=None):
                     """
                     Inicializador de la clase VoltageReader para la lectura de datos de voltage.
                     Input:
-                        dataOutObj    :    Objeto de la clase Voltage. Este objeto sera utilizado para
+                        dataOut    :    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.dataOutObj
+                        self.dataOut
                     Return:
                         None
                     """
-                    self.__isConfig = False
+                    self.isConfig = False
                     self.datablock = None
                     self.utc = 0
                     self.ext = ".r"
                     self.optchar = "D"
                     self.basicHeaderObj = BasicHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                     self.online = 0
                     self.fp = None
                     self.idFile = None
                     self.dtype = 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.flagTimeBlock = 0
                     self.flagIsNewBlock = 0
                     self.nTotalBlocks = 0
                     self.blocksize = 0
                 def createObjByDefault(self):
                     dataObj = Voltage()
                     return dataObj
                 def __hasNotDataInBuffer(self):
                     if self.profileIndex >= self.processingHeaderObj.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.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
                     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.dtype, self.blocksize )
                     try:
                         junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
                     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.dataOutObj
+                        self.dataOut
                         self.profileIndex
                     Affected:
-                        self.dataOutObj
+                        self.dataOut
                         self.profileIndex
                         self.flagTimeBlock
                         self.flagIsNewBlock
                     """
                     if self.flagNoMoreFiles: return 0
                     self.flagTimeBlock = 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.dataOutObj.flagNoData = True
+                        self.dataOut.flagNoData = True
                         return 0
-                    self.dataOutObj.data = self.datablock[:,self.profileIndex,:]
+                    self.dataOut.data = self.datablock[:,self.profileIndex,:]
-                    self.dataOutObj.dtype = self.dtype
+                    self.dataOut.dtype = self.dtype
-                    self.dataOutObj.nChannels = self.systemHeaderObj.nChannels
+                    self.dataOut.nChannels = self.systemHeaderObj.nChannels
-                    self.dataOutObj.nHeights = self.processingHeaderObj.nHeights
+                    self.dataOut.nHeights = self.processingHeaderObj.nHeights
-                    self.dataOutObj.nProfiles = self.processingHeaderObj.profilesPerBlock
+                    self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
                     xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
-                    self.dataOutObj.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
+                    self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
-                    self.dataOutObj.channelList = range(self.systemHeaderObj.nChannels)
+                    self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
-                    self.dataOutObj.channelIndexList = range(self.systemHeaderObj.nChannels)
+                    self.dataOut.channelIndexList = range(self.systemHeaderObj.nChannels)
-                    self.dataOutObj.flagTimeBlock = self.flagTimeBlock
+                    self.dataOut.flagTimeBlock = self.flagTimeBlock
-                    self.dataOutObj.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.ippSeconds
+                    self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.ippSeconds
-                    self.dataOutObj.ippSeconds = self.ippSeconds
+                    self.dataOut.ippSeconds = self.ippSeconds
-                    self.dataOutObj.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt
+                    self.dataOut.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt
-                    self.dataOutObj.nCohInt = self.processingHeaderObj.nCohInt
+                    self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
-                    self.dataOutObj.flagShiftFFT = False
+                    self.dataOut.flagShiftFFT = False
                     if self.processingHeaderObj.code != None:
-                        self.dataOutObj.nCode = self.processingHeaderObj.nCode
+                        self.dataOut.nCode = self.processingHeaderObj.nCode
-                        self.dataOutObj.nBaud = self.processingHeaderObj.nBaud
+                        self.dataOut.nBaud = self.processingHeaderObj.nBaud
-                        self.dataOutObj.code = self.processingHeaderObj.code
+                        self.dataOut.code = self.processingHeaderObj.code
                     self.profileIndex += 1
-                    self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
+                    self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
-                    self.dataOutObj.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
+                    self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
-                    self.dataOutObj.flagNoData = False
+                    self.dataOut.flagNoData = False
-            #        print self.profileIndex, self.dataOutObj.utctime
+            #        print self.profileIndex, self.dataOut.utctime
             #        if self.profileIndex == 800:
             #            a=1
-                    return self.dataOutObj.data
+                    return self.dataOut.data
             class VoltageWriter(JRODataWriter):
                 """
                 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 ext = ".r"
                 optchar = "D"
                 shapeBuffer = None
-                def __init__(self, dataOutObj=None):
+                def __init__(self, dataOut=None):
                     """
                     Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
                     Affected:
-                        self.dataOutObj
+                        self.dataOut
                     Return: None
                     """
-                    if dataOutObj == None:
+                    if dataOut == None:
-                        dataOutObj = Voltage()
+                        dataOut = Voltage()
-                    if not( isinstance(dataOutObj, Voltage) ):
+                    if not( isinstance(dataOut, Voltage) ):
-                        raise ValueError, "in VoltageReader, dataOutObj must be an Spectra class object"
+                        raise ValueError, "in VoltageReader, dataOut must be an Spectra class object"
-                    self.dataOutObj = dataOutObj
+                    self.dataOut = dataOut
                     self.nTotalBlocks = 0
                     self.profileIndex = 0
-                    self.__isConfig = False
+                    self.isConfig = False
                     self.fp = None
                     self.flagIsNewFile = 1
                     self.nTotalBlocks = 0
                     self.flagIsNewBlock = 0
                     self.flagNoMoreFiles = 0
                     self.setFile = None
                     self.dtype = None
                     self.path = None
                     self.noMoreFiles = 0
                     self.filename = None
                     self.basicHeaderObj = BasicHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                 def hasAllDataInBuffer(self):
                     if self.profileIndex >= self.processingHeaderObj.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.processingHeaderObj.profilesPerBlock,
                                         self.processingHeaderObj.nHeights,
                                         self.systemHeaderObj.nChannels)
                     self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,
                                                  self.processingHeaderObj.profilesPerBlock,
                                                  self.processingHeaderObj.nHeights),
                                                  dtype=numpy.dtype('complex'))
                 def writeBlock(self):
                     """
                     Escribe el buffer en el file designado
                     Affected:
                         self.profileIndex
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.blockIndex
                     Return: None
                     """
                     data = numpy.zeros( self.shapeBuffer, self.dtype )
                     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.blockIndex += 1
                     self.nTotalBlocks += 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
                     """
-                    if self.dataOutObj.flagNoData:
+                    if self.dataOut.flagNoData:
                         return 0
                     self.flagIsNewBlock = 0
-                    if self.dataOutObj.flagTimeBlock:
+                    if self.dataOut.flagTimeBlock:
                         self.datablock.fill(0)
                         self.profileIndex = 0
                         self.setNextFile()
                     if self.profileIndex == 0:
                         self.getBasicHeader()
-                    self.datablock[:,self.profileIndex,:] = self.dataOutObj.data
+                    self.datablock[:,self.profileIndex,:] = self.dataOut.data
                     self.profileIndex += 1
                     if self.hasAllDataInBuffer():
                         #if self.flagIsNewFile:
                         self.writeNextBlock()
             #            self.getDataHeader()
                     if self.flagNoMoreFiles:
                         #print 'Process finished'
                         return 0
                     return 1
                 def __getProcessFlags(self):
                     processFlags = 0
                     dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
                     dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
                     dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
                     dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
                     dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
                     dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
                     dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
                     datatypeValueList =  [PROCFLAG.DATATYPE_CHAR,
                                        PROCFLAG.DATATYPE_SHORT,
                                        PROCFLAG.DATATYPE_LONG,
                                        PROCFLAG.DATATYPE_INT64,
                                        PROCFLAG.DATATYPE_FLOAT,
                                        PROCFLAG.DATATYPE_DOUBLE]
                     for index in range(len(dtypeList)):
-                        if self.dataOutObj.dtype == dtypeList[index]:
+                        if self.dataOut.dtype == dtypeList[index]:
                             dtypeValue = datatypeValueList[index]
                             break
                     processFlags += dtypeValue
-                    if self.dataOutObj.flagDecodeData:
+                    if self.dataOut.flagDecodeData:
                         processFlags += PROCFLAG.DECODE_DATA
-                    if self.dataOutObj.flagDeflipData:
+                    if self.dataOut.flagDeflipData:
                         processFlags += PROCFLAG.DEFLIP_DATA
-                    if self.dataOutObj.code != None:
+                    if self.dataOut.code != None:
                         processFlags += PROCFLAG.DEFINE_PROCESS_CODE
-                    if self.dataOutObj.nCohInt > 1:
+                    if self.dataOut.nCohInt > 1:
                         processFlags += PROCFLAG.COHERENT_INTEGRATION
                     return processFlags
                 def __getBlockSize(self):
                     '''
                     Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage
                     '''
                     dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
                     dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
                     dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
                     dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
                     dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
                     dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
                     dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
                     datatypeValueList = [1,2,4,8,4,8]
                     for index in range(len(dtypeList)):
-                        if self.dataOutObj.dtype == dtypeList[index]:
+                        if self.dataOut.dtype == dtypeList[index]:
                             datatypeValue = datatypeValueList[index]
                             break
-                    blocksize = int(self.dataOutObj.nHeights * self.dataOutObj.nChannels * self.dataOutObj.nProfiles * datatypeValue * 2)
+                    blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels * self.dataOut.nProfiles * datatypeValue * 2)
                     return blocksize
                 def getDataHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.dtype
                     Return:
                         None
                     """
-                    self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
+                    self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
-                    self.systemHeaderObj.nChannels = self.dataOutObj.nChannels
+                    self.systemHeaderObj.nChannels = self.dataOut.nChannels
-                    self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
+                    self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
                     self.getBasicHeader()
                     processingHeaderSize = 40 # bytes
                     self.processingHeaderObj.dtype = 0 # Voltage
                     self.processingHeaderObj.blockSize = self.__getBlockSize()
                     self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
                     self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
-                    self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOutObj.processingHeaderObj.nWindows
+                    self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
                     self.processingHeaderObj.processFlags = self.__getProcessFlags()
-                    self.processingHeaderObj.nCohInt = self.dataOutObj.nCohInt
+                    self.processingHeaderObj.nCohInt = self.dataOut.nCohInt
                     self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage
                     self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage
-                    if self.dataOutObj.code != None:
+                    if self.dataOut.code != None:
-                        self.processingHeaderObj.code = self.dataOutObj.code
+                        self.processingHeaderObj.code = self.dataOut.code
-                        self.processingHeaderObj.nCode = self.dataOutObj.nCode
+                        self.processingHeaderObj.nCode = self.dataOut.nCode
-                        self.processingHeaderObj.nBaud = self.dataOutObj.nBaud
+                        self.processingHeaderObj.nBaud = self.dataOut.nBaud
-                        codesize = int(8 + 4 * self.dataOutObj.nCode * self.dataOutObj.nBaud)
+                        codesize = int(8 + 4 * self.dataOut.nCode * self.dataOut.nBaud)
                         processingHeaderSize += codesize
                     if self.processingHeaderObj.nWindows != 0:
-                        self.processingHeaderObj.firstHeight = self.dataOutObj.heightList[0]
+                        self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
-                        self.processingHeaderObj.deltaHeight = self.dataOutObj.heightList[1] - self.dataOutObj.heightList[0]
+                        self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
-                        self.processingHeaderObj.nHeights = self.dataOutObj.nHeights
+                        self.processingHeaderObj.nHeights = self.dataOut.nHeights
-                        self.processingHeaderObj.samplesWin = self.dataOutObj.nHeights
+                        self.processingHeaderObj.samplesWin = self.dataOut.nHeights
                         processingHeaderSize += 12
                     self.processingHeaderObj.size = processingHeaderSize
             class SpectraReader(JRODataReader):
                 """
                 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
                 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
                 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
                                     paresCanalesIguales    * alturas * perfiles  (Self Spectra)
                                     paresCanalesDiferentes * alturas * perfiles  (Cross Spectra)
                                     canales * alturas                            (DC Channels)
                 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
                 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
                 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque 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 = SpectraReader()
                     readerObj.setup(dpath, startTime, endTime)
                     while(True):
                         readerObj.getData()
                         print readerObj.data_spc
                         print readerObj.data_cspc
                         print readerObj.data_dc
                         if readerObj.flagNoMoreFiles:
                             break
                 """
                 pts2read_SelfSpectra = 0
                 pts2read_CrossSpectra = 0
                 pts2read_DCchannels = 0
                 ext = ".pdata"
                 optchar = "P"
-                dataOutObj = None
+                dataOut = None
                 nRdChannels = None
                 nRdPairs = None
                 rdPairList = []
-                def __init__(self, dataOutObj=None):
+                def __init__(self, dataOut=None):
                     """
                     Inicializador de la clase SpectraReader para la lectura de datos de espectros.
                     Inputs:
-                        dataOutObj    :    Objeto de la clase Spectra. Este objeto sera utilizado para
+                        dataOut    :    Objeto de la clase Spectra. 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.
                     Affected:
-                        self.dataOutObj
+                        self.dataOut
                     Return      : None
                     """
-                    self.__isConfig = False
+                    self.isConfig = False
                     self.pts2read_SelfSpectra = 0
                     self.pts2read_CrossSpectra = 0
                     self.pts2read_DCchannels = 0
                     self.datablock = None
                     self.utc = None
                     self.ext = ".pdata"
                     self.optchar = "P"
                     self.basicHeaderObj = BasicHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                     self.online = 0
                     self.fp = None
                     self.idFile = None
                     self.dtype = None
                     self.fileSizeByHeader = None
                     self.filenameList = []
                     self.filename = None
                     self.fileSize = None
                     self.firstHeaderSize = 0
                     self.basicHeaderSize = 24
                     self.pathList = []
                     self.lastUTTime = 0
                     self.maxTimeStep = 30
                     self.flagNoMoreFiles = 0
                     self.set = 0
                     self.path = None
                     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.flagTimeBlock = 0
                     self.flagIsNewBlock = 0
                     self.nTotalBlocks = 0
                     self.blocksize = 0
                 def createObjByDefault(self):
                     dataObj = Spectra()
                     return dataObj
                 def __hasNotDataInBuffer(self):
                     return 1
                 def getBlockDimension(self):
                     """
                     Obtiene la cantidad de puntos a leer por cada bloque de datos
                     Affected:
                         self.nRdChannels
                         self.nRdPairs
                         self.pts2read_SelfSpectra
                         self.pts2read_CrossSpectra
                         self.pts2read_DCchannels
                         self.blocksize
-                        self.dataOutObj.nChannels
+                        self.dataOut.nChannels
-                        self.dataOutObj.nPairs
+                        self.dataOut.nPairs
                     Return:
                         None
                     """
                     self.nRdChannels = 0
                     self.nRdPairs = 0
                     self.rdPairList = []
                     for i in range(0, self.processingHeaderObj.totalSpectra*2, 2):
                         if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
                             self.nRdChannels = self.nRdChannels + 1 #par de canales iguales
                         else:
                             self.nRdPairs = self.nRdPairs + 1 #par de canales diferentes
                             self.rdPairList.append((self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]))
                     pts2read = self.processingHeaderObj.nHeights * self.processingHeaderObj.profilesPerBlock
                     self.pts2read_SelfSpectra = int(self.nRdChannels * pts2read)
                     self.blocksize = self.pts2read_SelfSpectra
                     if self.processingHeaderObj.flag_cspc:
                         self.pts2read_CrossSpectra = int(self.nRdPairs * pts2read)
                         self.blocksize += self.pts2read_CrossSpectra
                     if self.processingHeaderObj.flag_dc:
                         self.pts2read_DCchannels = int(self.systemHeaderObj.nChannels * self.processingHeaderObj.nHeights)
                         self.blocksize += self.pts2read_DCchannels
             #        self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
                 def readBlock(self):
                     """
                     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
                     Return: None
                     Variables afectadas:
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                     Exceptions:
                         Si un bloque leido no es un bloque valido
                     """
                     blockOk_flag = False
                     fpointer = self.fp.tell()
                     spc = numpy.fromfile( self.fp, self.dtype[0], self.pts2read_SelfSpectra )
                     spc = spc.reshape( (self.nRdChannels, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
                     if self.processingHeaderObj.flag_cspc:
                         cspc = numpy.fromfile( self.fp, self.dtype, self.pts2read_CrossSpectra )
                         cspc = cspc.reshape( (self.nRdPairs, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
                     if self.processingHeaderObj.flag_dc:
                         dc = numpy.fromfile( self.fp, self.dtype, self.pts2read_DCchannels ) #int(self.processingHeaderObj.nHeights*self.systemHeaderObj.nChannels) )
                         dc = dc.reshape( (self.systemHeaderObj.nChannels, self.processingHeaderObj.nHeights) ) #transforma a un arreglo 2D
                     if not(self.processingHeaderObj.shif_fft):
                         spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                         if self.processingHeaderObj.flag_cspc:
                             cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                     spc = numpy.transpose( spc, (0,2,1) )
                     self.data_spc = spc
                     if self.processingHeaderObj.flag_cspc:
                         cspc = numpy.transpose( cspc, (0,2,1) )
                         self.data_cspc = cspc['real'] + cspc['imag']*1j
                     else:
                         self.data_cspc = None
                     if self.processingHeaderObj.flag_dc:
                         self.data_dc = dc['real'] + dc['imag']*1j
                     else:
                         self.data_dc = None
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     return 1
                 def getData(self):
                     """
                     Copia el buffer de lectura a la clase "Spectra",
                     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"
                     Return:
 :    Si no hay mas archivos disponibles
 :    Si hizo una buena copia del buffer
                     Affected:
-                        self.dataOutObj
+                        self.dataOut
                         self.flagTimeBlock
                         self.flagIsNewBlock
                     """
                     if self.flagNoMoreFiles: return 0
                     self.flagTimeBlock = 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.data_dc == None:
-                        self.dataOutObj.flagNoData = True
+                        self.dataOut.flagNoData = True
                         return 0
-                    self.dataOutObj.data_spc = self.data_spc
+                    self.dataOut.data_spc = self.data_spc
-                    self.dataOutObj.data_cspc = self.data_cspc
+                    self.dataOut.data_cspc = self.data_cspc
-                    self.dataOutObj.data_dc = self.data_dc
+                    self.dataOut.data_dc = self.data_dc
-                    self.dataOutObj.flagTimeBlock = self.flagTimeBlock
+                    self.dataOut.flagTimeBlock = self.flagTimeBlock
-                    self.dataOutObj.flagNoData = False
+                    self.dataOut.flagNoData = False
-                    self.dataOutObj.dtype = self.dtype
+                    self.dataOut.dtype = self.dtype
-                    self.dataOutObj.nChannels = self.nRdChannels
+                    self.dataOut.nChannels = self.nRdChannels
-                    self.dataOutObj.nPairs = self.nRdPairs
+                    self.dataOut.nPairs = self.nRdPairs
-                    self.dataOutObj.pairsList = self.rdPairList
+                    self.dataOut.pairsList = self.rdPairList
-                    self.dataOutObj.nHeights = self.processingHeaderObj.nHeights
+                    self.dataOut.nHeights = self.processingHeaderObj.nHeights
-                    self.dataOutObj.nProfiles = self.processingHeaderObj.profilesPerBlock
+                    self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
-                    self.dataOutObj.nFFTPoints = self.processingHeaderObj.profilesPerBlock
+                    self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock
-                    self.dataOutObj.nIncohInt = self.processingHeaderObj.nIncohInt
+                    self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt
                     xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
-                    self.dataOutObj.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
+                    self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
-                    self.dataOutObj.channelList = range(self.systemHeaderObj.nChannels)
+                    self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
-                    self.dataOutObj.channelIndexList = range(self.systemHeaderObj.nChannels)
+                    self.dataOut.channelIndexList = range(self.systemHeaderObj.nChannels)
-                    self.dataOutObj.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000.#+ self.profileIndex * self.ippSeconds
+                    self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000.#+ self.profileIndex * self.ippSeconds
-                    self.dataOutObj.ippSeconds = self.ippSeconds
+                    self.dataOut.ippSeconds = self.ippSeconds
-                    self.dataOutObj.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.dataOutObj.nFFTPoints
+                    self.dataOut.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.dataOut.nFFTPoints
-                    self.dataOutObj.flagShiftFFT = self.processingHeaderObj.shif_fft
+                    self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
             #        self.profileIndex += 1
-                    self.dataOutObj.systemHeaderObj = self.systemHeaderObj.copy()
+                    self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
-                    self.dataOutObj.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
+                    self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
-                    return self.dataOutObj.data_spc
+                    return self.dataOut.data_spc
             class SpectraWriter(JRODataWriter):
                 """
                 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 ext = ".pdata"
                 optchar = "P"
                 shape_spc_Buffer = None
                 shape_cspc_Buffer = None
                 shape_dc_Buffer = None
                 data_spc = None
                 data_cspc = None
                 data_dc = None
-            #    dataOutObj = None
+            #    dataOut = None
-                def __init__(self, dataOutObj=None):
+                def __init__(self, dataOut=None):
                     """
                     Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
                     Affected:
-                        self.dataOutObj
+                        self.dataOut
                         self.basicHeaderObj
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.processingHeaderObj
                     Return: None
                     """
-                    if dataOutObj == None:
+                    if dataOut == None:
-                        dataOutObj = Spectra()
+                        dataOut = Spectra()
-                    if not( isinstance(dataOutObj, Spectra) ):
+                    if not( isinstance(dataOut, Spectra) ):
-                        raise ValueError, "in SpectraReader, dataOutObj must be an Spectra class object"
+                        raise ValueError, "in SpectraReader, dataOut must be an Spectra class object"
-                    self.dataOutObj = dataOutObj
+                    self.dataOut = dataOut
-                    self.__isConfig = False
+                    self.isConfig = False
                     self.nTotalBlocks = 0
                     self.data_spc = None
                     self.data_cspc = None
                     self.data_dc = None
                     self.fp = None
                     self.flagIsNewFile = 1
                     self.nTotalBlocks = 0
                     self.flagIsNewBlock = 0
                     self.flagNoMoreFiles = 0
                     self.setFile = None
                     self.dtype = None
                     self.path = None
                     self.noMoreFiles = 0
                     self.filename = None
                     self.basicHeaderObj = BasicHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                 def hasAllDataInBuffer(self):
                     return 1
                 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.shape_spc_Buffer = (self.dataOutObj.nChannels,
+                    self.shape_spc_Buffer = (self.dataOut.nChannels,
                                              self.processingHeaderObj.nHeights,
                                              self.processingHeaderObj.profilesPerBlock)
-                    self.shape_cspc_Buffer = (self.dataOutObj.nPairs,
+                    self.shape_cspc_Buffer = (self.dataOut.nPairs,
                                               self.processingHeaderObj.nHeights,
                                               self.processingHeaderObj.profilesPerBlock)
-                    self.shape_dc_Buffer = (self.dataOutObj.nChannels,
+                    self.shape_dc_Buffer = (self.dataOut.nChannels,
                                             self.processingHeaderObj.nHeights)
                 def writeBlock(self):
                     """
                     Escribe el buffer en el file designado
                     Affected:
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.nWriteBlocks
                     Return: None
                     """
                     spc = numpy.transpose( self.data_spc, (0,2,1) )
                     if not( self.processingHeaderObj.shif_fft ):
                         spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                     data = spc.reshape((-1))
                     data.tofile(self.fp)
                     if self.data_cspc != None:
                         data = numpy.zeros( self.shape_cspc_Buffer, self.dtype )
                         cspc = numpy.transpose( self.data_cspc, (0,2,1) )
                         if not( self.processingHeaderObj.shif_fft ):
                             cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                         data['real'] = cspc.real
                         data['imag'] = cspc.imag
                         data = data.reshape((-1))
                         data.tofile(self.fp)
                     if self.data_dc != None:
                         data = numpy.zeros( self.shape_dc_Buffer, self.dtype )
                         dc = self.data_dc
                         data['real'] = dc.real
                         data['imag'] = dc.imag
                         data = data.reshape((-1))
                         data.tofile(self.fp)
                     self.data_spc.fill(0)
                     self.data_dc.fill(0)
                     if self.data_cspc != None:
                         self.data_cspc.fill(0)
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nWriteBlocks += 1
                     self.blockIndex += 1
                 def putData(self):
                     """
                     Setea un bloque de datos y luego los escribe en un file
                     Affected:
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                     Return:
 :    Si no hay data o no hay mas files que puedan escribirse
 :    Si se escribio la data de un bloque en un file
                     """
-                    if self.dataOutObj.flagNoData:
+                    if self.dataOut.flagNoData:
                         return 0
                     self.flagIsNewBlock = 0
-                    if self.dataOutObj.flagTimeBlock:
+                    if self.dataOut.flagTimeBlock:
                         self.data_spc.fill(0)
                         self.data_cspc.fill(0)
                         self.data_dc.fill(0)
                         self.setNextFile()
                     if self.flagIsNewFile == 0:
                         self.getBasicHeader()
-                    self.data_spc = self.dataOutObj.data_spc
+                    self.data_spc = self.dataOut.data_spc
-                    self.data_cspc = self.dataOutObj.data_cspc
+                    self.data_cspc = self.dataOut.data_cspc
-                    self.data_dc = self.dataOutObj.data_dc
+                    self.data_dc = self.dataOut.data_dc
                     # #self.processingHeaderObj.dataBlocksPerFile)
                     if self.hasAllDataInBuffer():
             #            self.getDataHeader()
                         self.writeNextBlock()
                     if self.flagNoMoreFiles:
                         #print 'Process finished'
                         return 0
                     return 1
                 def __getProcessFlags(self):
                     processFlags = 0
                     dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
                     dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
                     dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
                     dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
                     dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
                     dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
                     dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
                     datatypeValueList =  [PROCFLAG.DATATYPE_CHAR,
                                        PROCFLAG.DATATYPE_SHORT,
                                        PROCFLAG.DATATYPE_LONG,
                                        PROCFLAG.DATATYPE_INT64,
                                        PROCFLAG.DATATYPE_FLOAT,
                                        PROCFLAG.DATATYPE_DOUBLE]
                     for index in range(len(dtypeList)):
-                        if self.dataOutObj.dtype == dtypeList[index]:
+                        if self.dataOut.dtype == dtypeList[index]:
                             dtypeValue = datatypeValueList[index]
                             break
                     processFlags += dtypeValue
-                    if self.dataOutObj.flagDecodeData:
+                    if self.dataOut.flagDecodeData:
                         processFlags += PROCFLAG.DECODE_DATA
-                    if self.dataOutObj.flagDeflipData:
+                    if self.dataOut.flagDeflipData:
                         processFlags += PROCFLAG.DEFLIP_DATA
-                    if self.dataOutObj.code != None:
+                    if self.dataOut.code != None:
                         processFlags += PROCFLAG.DEFINE_PROCESS_CODE
-                    if self.dataOutObj.nIncohInt > 1:
+                    if self.dataOut.nIncohInt > 1:
                         processFlags += PROCFLAG.INCOHERENT_INTEGRATION
-                    if self.dataOutObj.data_dc != None:
+                    if self.dataOut.data_dc != None:
                         processFlags += PROCFLAG.SAVE_CHANNELS_DC
                     return processFlags
                 def __getBlockSize(self):
                     '''
                     Este metodos determina el cantidad de bytes para un bloque de datos de tipo Spectra
                     '''
                     dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
                     dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
                     dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
                     dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
                     dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
                     dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
                     dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
                     datatypeValueList = [1,2,4,8,4,8]
                     for index in range(len(dtypeList)):
-                        if self.dataOutObj.dtype == dtypeList[index]:
+                        if self.dataOut.dtype == dtypeList[index]:
                             datatypeValue = datatypeValueList[index]
                             break
-                    pts2write = self.dataOutObj.nHeights * self.dataOutObj.nFFTPoints
+                    pts2write = self.dataOut.nHeights * self.dataOut.nFFTPoints
-                    pts2write_SelfSpectra = int(self.dataOutObj.nChannels * pts2write)
+                    pts2write_SelfSpectra = int(self.dataOut.nChannels * pts2write)
                     blocksize = (pts2write_SelfSpectra*datatypeValue)
-                    if self.dataOutObj.data_cspc != None:
+                    if self.dataOut.data_cspc != None:
-                        pts2write_CrossSpectra = int(self.dataOutObj.nPairs * pts2write)
+                        pts2write_CrossSpectra = int(self.dataOut.nPairs * pts2write)
                         blocksize += (pts2write_CrossSpectra*datatypeValue*2)
-                    if self.dataOutObj.data_dc != None:
+                    if self.dataOut.data_dc != None:
-                        pts2write_DCchannels = int(self.dataOutObj.nChannels * self.dataOutObj.nHeights)
+                        pts2write_DCchannels = int(self.dataOut.nChannels * self.dataOut.nHeights)
                         blocksize += (pts2write_DCchannels*datatypeValue*2)
                     blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO
                     return blocksize
                 def getDataHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.dtype
                     Return:
                         None
                     """
-                    self.systemHeaderObj = self.dataOutObj.systemHeaderObj.copy()
+                    self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
-                    self.systemHeaderObj.nChannels = self.dataOutObj.nChannels
+                    self.systemHeaderObj.nChannels = self.dataOut.nChannels
-                    self.radarControllerHeaderObj = self.dataOutObj.radarControllerHeaderObj.copy()
+                    self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
                     self.getBasicHeader()
                     processingHeaderSize = 40 # bytes
                     self.processingHeaderObj.dtype = 0 # Voltage
                     self.processingHeaderObj.blockSize = self.__getBlockSize()
-                    self.processingHeaderObj.profilesPerBlock = self.dataOutObj.nFFTPoints
+                    self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints
                     self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
-                    self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOutObj.processingHeaderObj.nWindows
+                    self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
                     self.processingHeaderObj.processFlags = self.__getProcessFlags()
-                    self.processingHeaderObj.nCohInt = self.dataOutObj.nCohInt# Se requiere para determinar el valor de timeInterval
+                    self.processingHeaderObj.nCohInt = self.dataOut.nCohInt# Se requiere para determinar el valor de timeInterval
-                    self.processingHeaderObj.nIncohInt = self.dataOutObj.nIncohInt
+                    self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt
-                    self.processingHeaderObj.totalSpectra = self.dataOutObj.nPairs + self.dataOutObj.nChannels
+                    self.processingHeaderObj.totalSpectra = self.dataOut.nPairs + self.dataOut.nChannels
                     if self.processingHeaderObj.totalSpectra > 0:
                         channelList = []
-                        for channel in range(self.dataOutObj.nChannels):
+                        for channel in range(self.dataOut.nChannels):
                             channelList.append(channel)
                             channelList.append(channel)
                         pairsList = []
-                        for pair in self.dataOutObj.pairsList:
+                        for pair in self.dataOut.pairsList:
                             pairsList.append(pair[0])
                             pairsList.append(pair[1])
                         spectraComb = channelList + pairsList
                         spectraComb = numpy.array(spectraComb,dtype="u1")
                         self.processingHeaderObj.spectraComb = spectraComb
                         sizeOfSpcComb = len(spectraComb)
                         processingHeaderSize += sizeOfSpcComb
-                    if self.dataOutObj.code != None:
+                    if self.dataOut.code != None:
-                        self.processingHeaderObj.code = self.dataOutObj.code
+                        self.processingHeaderObj.code = self.dataOut.code
-                        self.processingHeaderObj.nCode = self.dataOutObj.nCode
+                        self.processingHeaderObj.nCode = self.dataOut.nCode
-                        self.processingHeaderObj.nBaud = self.dataOutObj.nBaud
+                        self.processingHeaderObj.nBaud = self.dataOut.nBaud
                         nCodeSize = 4 # bytes
                         nBaudSize = 4 # bytes
                         codeSize = 4 # bytes
-                        sizeOfCode = int(nCodeSize + nBaudSize + codeSize * self.dataOutObj.nCode * self.dataOutObj.nBaud)
+                        sizeOfCode = int(nCodeSize + nBaudSize + codeSize * self.dataOut.nCode * self.dataOut.nBaud)
                         processingHeaderSize += sizeOfCode
                     if self.processingHeaderObj.nWindows != 0:
-                        self.processingHeaderObj.firstHeight = self.dataOutObj.heightList[0]
+                        self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
-                        self.processingHeaderObj.deltaHeight = self.dataOutObj.heightList[1] - self.dataOutObj.heightList[0]
+                        self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
-                        self.processingHeaderObj.nHeights = self.dataOutObj.nHeights
+                        self.processingHeaderObj.nHeights = self.dataOut.nHeights
-                        self.processingHeaderObj.samplesWin = self.dataOutObj.nHeights
+                        self.processingHeaderObj.samplesWin = self.dataOut.nHeights
                         sizeOfFirstHeight = 4
                         sizeOfdeltaHeight = 4
                         sizeOfnHeights = 4
                         sizeOfWindows = (sizeOfFirstHeight + sizeOfdeltaHeight + sizeOfnHeights)*self.processingHeaderObj.nWindows
                         processingHeaderSize += sizeOfWindows
                     self.processingHeaderObj.size = processingHeaderSize
             class SpectraHeisWriter():
                 i=0
-                def __init__(self, dataOutObj):
+                def __init__(self, dataOut):
                     self.wrObj = FITS()
-                    self.dataOutObj = dataOutObj
+                    self.dataOut = dataOut
                 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 setup(self, wrpath,):
                     if not(os.path.exists(wrpath)):
                         os.mkdir(wrpath)
                     self.wrpath = wrpath
                     self.setFile = 0
                 def putData(self):
-                  # self.wrObj.writeHeader(nChannels=self.dataOutObj.nChannels, nFFTPoints=self.dataOutObj.nFFTPoints)
+                  # self.wrObj.writeHeader(nChannels=self.dataOut.nChannels, nFFTPoints=self.dataOut.nFFTPoints)
-                    #name = self.dataOutObj.utctime
+                    #name = self.dataOut.utctime
-                    name= time.localtime( self.dataOutObj.utctime)
+                    name= time.localtime( self.dataOut.utctime)
                     ext=".fits"
                     #folder='D%4.4d%3.3d'%(name.tm_year,name.tm_yday)
                     subfolder = 'D%4.4d%3.3d' % (name.tm_year,name.tm_yday)
                     doypath = os.path.join( self.wrpath, subfolder )
                     if not( os.path.exists(doypath) ):
                         os.mkdir(doypath)
                     self.setFile += 1
                     file = 'D%4.4d%3.3d%3.3d%s' % (name.tm_year,name.tm_yday,self.setFile,ext)
                     filename = os.path.join(self.wrpath,subfolder, file)
-                   # print self.dataOutObj.ippSeconds
+                   # print self.dataOut.ippSeconds
-                    freq=numpy.arange(-1*self.dataOutObj.nHeights/2.,self.dataOutObj.nHeights/2.)/(2*self.dataOutObj.ippSeconds)
+                    freq=numpy.arange(-1*self.dataOut.nHeights/2.,self.dataOut.nHeights/2.)/(2*self.dataOut.ippSeconds)
-                    col1=self.wrObj.setColF(name="freq", format=str(self.dataOutObj.nFFTPoints)+'E', array=freq)
+                    col1=self.wrObj.setColF(name="freq", format=str(self.dataOut.nFFTPoints)+'E', array=freq)
-                    col2=self.wrObj.writeData(name="P_Ch1",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[0,:]))
+                    col2=self.wrObj.writeData(name="P_Ch1",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[0,:]))
-                    col3=self.wrObj.writeData(name="P_Ch2",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[1,:]))
+                    col3=self.wrObj.writeData(name="P_Ch2",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[1,:]))
-                    col4=self.wrObj.writeData(name="P_Ch3",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[2,:]))
+                    col4=self.wrObj.writeData(name="P_Ch3",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[2,:]))
-                    col5=self.wrObj.writeData(name="P_Ch4",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[3,:]))
+                    col5=self.wrObj.writeData(name="P_Ch4",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[3,:]))
-                    col6=self.wrObj.writeData(name="P_Ch5",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[4,:]))
+                    col6=self.wrObj.writeData(name="P_Ch5",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[4,:]))
-                    col7=self.wrObj.writeData(name="P_Ch6",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[5,:]))
+                    col7=self.wrObj.writeData(name="P_Ch6",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[5,:]))
-                    col8=self.wrObj.writeData(name="P_Ch7",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[6,:]))
+                    col8=self.wrObj.writeData(name="P_Ch7",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[6,:]))
-                    col9=self.wrObj.writeData(name="P_Ch8",format=str(self.dataOutObj.nFFTPoints)+'E',data=10*numpy.log10(self.dataOutObj.data_spc[7,:]))
+                    col9=self.wrObj.writeData(name="P_Ch8",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[7,:]))
                     #n=numpy.arange((100))
-                    n=self.dataOutObj.data_spc[6,:]
+                    n=self.dataOut.data_spc[6,:]
                     a=self.wrObj.cFImage(n)
                     b=self.wrObj.Ctable(col1,col2,col3,col4,col5,col6,col7,col8,col9)
                     self.wrObj.CFile(a,b)
                     self.wrObj.wFile(filename)
                     return 1
             class FITS:
                 name=None
                 format=None
                 array =None
                 data =None
                 thdulist=None
                 def __init__(self):
                     pass
                 def setColF(self,name,format,array):
                     self.name=name
                     self.format=format
                     self.array=array
                     a1=numpy.array([self.array],dtype=numpy.float32)
                     self.col1 = pyfits.Column(name=self.name, format=self.format, array=a1)
                     return self.col1
             #    def setColP(self,name,format,data):
             #        self.name=name
             #        self.format=format
             #        self.data=data
             #        a2=numpy.array([self.data],dtype=numpy.float32)
             #        self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
             #        return self.col2
                 def writeHeader(self,):
                     pass
                 def writeData(self,name,format,data):
                     self.name=name
                     self.format=format
                     self.data=data
                     a2=numpy.array([self.data],dtype=numpy.float32)
                     self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
                     return self.col2
                 def cFImage(self,n):
                     self.hdu= pyfits.PrimaryHDU(n)
                     return self.hdu
                 def Ctable(self,col1,col2,col3,col4,col5,col6,col7,col8,col9):
                     self.cols=pyfits.ColDefs( [col1,col2,col3,col4,col5,col6,col7,col8,col9])
                     self.tbhdu = pyfits.new_table(self.cols)
                     return self.tbhdu
                 def CFile(self,hdu,tbhdu):
                     self.thdulist=pyfits.HDUList([hdu,tbhdu])
                 def wFile(self,filename):
                     self.thdulist.writeto(filename)

1

'''

1

'''

2

3

$Author: murco $

3

$Author: murco $

4

$Id: JRODataIO.py 169 2012-11-19 21:57:03Z murco $

4

$Id: JRODataIO.py 169 2012-11-19 21:57:03Z murco $

5

'''

5

'''

6

7

import os, sys

7

import os, sys

8

import glob

8

import glob

9

import time

9

import time

10

import numpy

10

import numpy

11

import fnmatch

11

import fnmatch

12

import time, datetime

12

import time, datetime

13

14

from jrodata import *

14

from jrodata import *

15

from jroheaderIO import *

15

from jroheaderIO import *

16

17

def isNumber(str):

17

def isNumber(str):

18

"""

18

"""

19

Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.

19

Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.

20

21

Excepciones:

21

Excepciones:

22

Si un determinado string no puede ser convertido a numero

22

Si un determinado string no puede ser convertido a numero

23

Input:

23

Input:

24

str, string al cual se le analiza para determinar si convertible a un numero o no

24

str, string al cual se le analiza para determinar si convertible a un numero o no

25

26

Return:

26

Return:

27

True : si el string es uno numerico

27

True : si el string es uno numerico

28

False : no es un string numerico

28

False : no es un string numerico

29

"""

29

"""

30

try:

30

try:

31

float( str )

31

float( str )

32

return True

32

return True

33

except:

33

except:

34

return False

34

return False

35

36

def isThisFileinRange(filename, startUTSeconds, endUTSeconds):

36

def isThisFileinRange(filename, startUTSeconds, endUTSeconds):

37

"""

37

"""

38

Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.

38

Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.

39

40

Inputs:

40

Inputs:

41

filename : nombre completo del archivo de datos en formato Jicamarca (.r)

41

filename : nombre completo del archivo de datos en formato Jicamarca (.r)

42

43

startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en

43

startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en

44

segundos contados desde 01/01/1970.

44

segundos contados desde 01/01/1970.

45

endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en

45

endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en

46

segundos contados desde 01/01/1970.

46

segundos contados desde 01/01/1970.

47

48

Return:

48

Return:

49

Boolean : Retorna True si el archivo de datos contiene datos en el rango de

49

Boolean : Retorna True si el archivo de datos contiene datos en el rango de

50

fecha especificado, de lo contrario retorna False.

50

fecha especificado, de lo contrario retorna False.

51

52

Excepciones:

52

Excepciones:

53

Si el archivo no existe o no puede ser abierto

53

Si el archivo no existe o no puede ser abierto

54

Si la cabecera no puede ser leida.

54

Si la cabecera no puede ser leida.

55

56

"""

56

"""

57

basicHeaderObj = BasicHeader()

57

basicHeaderObj = BasicHeader()

58

59

try:

59

try:

60

fp = open(filename,'rb')

60

fp = open(filename,'rb')

61

except:

61

except:

62

raise IOError, "The file %s can't be opened" %(filename)

62

raise IOError, "The file %s can't be opened" %(filename)

63

64

sts = basicHeaderObj.read(fp)

64

sts = basicHeaderObj.read(fp)

65

fp.close()

65

fp.close()

66

67

if not(sts):

67

if not(sts):

68

print "Skipping the file %s because it has not a valid header" %(filename)

68

print "Skipping the file %s because it has not a valid header" %(filename)

69

return 0

69

return 0

70

71

if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):

71

if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):

72

return 0

72

return 0

73

74

return 1

74

return 1

75

76

def getlastFileFromPath(path, ext):

76

def getlastFileFromPath(path, ext):

77

"""

77

"""

78

Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"

78

Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"

79

al final de la depuracion devuelve el ultimo file de la lista que quedo.

79

al final de la depuracion devuelve el ultimo file de la lista que quedo.

80

81

Input:

81

Input:

82

fileList : lista conteniendo todos los files (sin path) que componen una determinada carpeta

82

fileList : lista conteniendo todos los files (sin path) que componen una determinada carpeta

83

ext : extension de los files contenidos en una carpeta

83

ext : extension de los files contenidos en una carpeta

84

85

Return:

85

Return:

86

El ultimo file de una determinada carpeta, no se considera el path.

86

El ultimo file de una determinada carpeta, no se considera el path.

87

"""

87

"""

88

validFilelist = []

88

validFilelist = []

89

fileList = os.listdir(path)

89

fileList = os.listdir(path)

90

91

# 0 1234 567 89A BCDE

91

# 0 1234 567 89A BCDE

92

# H YYYY DDD SSS .ext

92

# H YYYY DDD SSS .ext

93

94

for file in fileList:

94

for file in fileList:

95

try:

95

try:

96

year = int(file[1:5])

96

year = int(file[1:5])

97

doy = int(file[5:8])

97

doy = int(file[5:8])

98

99

if (os.path.splitext(file)[-1].upper() != ext.upper()) : continue

99

if (os.path.splitext(file)[-1].upper() != ext.upper()) : continue

100

except:

100

except:

101

continue

101

continue

102

103

validFilelist.append(file)

103

validFilelist.append(file)

104

105

if validFilelist:

105

if validFilelist:

106

validFilelist = sorted( validFilelist, key=str.lower )

106

validFilelist = sorted( validFilelist, key=str.lower )

107

return validFilelist[-1]

107

return validFilelist[-1]

108

109

return None

109

return None

110

111

def checkForRealPath(path, year, doy, set, ext):

111

def checkForRealPath(path, year, doy, set, ext):

112

"""

112

"""

113

Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,

113

Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,

114

Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar

114

Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar

115

el path exacto de un determinado file.

115

el path exacto de un determinado file.

116

117

Example :

117

Example :

118

nombre correcto del file es .../.../D2009307/P2009307367.ext

118

nombre correcto del file es .../.../D2009307/P2009307367.ext

119

120

Entonces la funcion prueba con las siguientes combinaciones

120

Entonces la funcion prueba con las siguientes combinaciones

121

.../.../x2009307/y2009307367.ext

121

.../.../x2009307/y2009307367.ext

122

.../.../x2009307/Y2009307367.ext

122

.../.../x2009307/Y2009307367.ext

123

.../.../X2009307/y2009307367.ext

123

.../.../X2009307/y2009307367.ext

124

.../.../X2009307/Y2009307367.ext

124

.../.../X2009307/Y2009307367.ext

125

siendo para este caso, la ultima combinacion de letras, identica al file buscado

125

siendo para este caso, la ultima combinacion de letras, identica al file buscado

126

127

Return:

127

Return:

128

Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file

128

Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file

129

caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas

129

caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas

130

para el filename

130

para el filename

131

"""

131

"""

132

filepath = None

132

filepath = None

133

find_flag = False

133

find_flag = False

134

filename = None

134

filename = None

135

136

if ext.lower() == ".r": #voltage

136

if ext.lower() == ".r": #voltage

137

header1 = "dD"

137

header1 = "dD"

138

header2 = "dD"

138

header2 = "dD"

139

elif ext.lower() == ".pdata": #spectra

139

elif ext.lower() == ".pdata": #spectra

140

header1 = "dD"

140

header1 = "dD"

141

header2 = "pP"

141

header2 = "pP"

142

else:

142

else:

143

return None, filename

143

return None, filename

144

145

for dir in header1: #barrido por las dos combinaciones posibles de "D"

145

for dir in header1: #barrido por las dos combinaciones posibles de "D"

146

for fil in header2: #barrido por las dos combinaciones posibles de "D"

146

for fil in header2: #barrido por las dos combinaciones posibles de "D"

147

doypath = "%s%04d%03d" % ( dir, year, doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D)

147

doypath = "%s%04d%03d" % ( dir, year, doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D)

148

filename = "%s%04d%03d%03d%s" % ( fil, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext

148

filename = "%s%04d%03d%03d%s" % ( fil, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext

149

filepath = os.path.join( path, doypath, filename ) #formo el path completo

149

filepath = os.path.join( path, doypath, filename ) #formo el path completo

150

if os.path.exists( filepath ): #verifico que exista

150

if os.path.exists( filepath ): #verifico que exista

151

find_flag = True

151

find_flag = True

152

break

152

break

153

if find_flag:

153

if find_flag:

154

break

154

break

155

156

if not(find_flag):

156

if not(find_flag):

157

return None, filename

157

return None, filename

158

159

return filepath, filename

159

return filepath, filename

160

161

class JRODataIO:

161

class JRODataIO:

162

163

c = 3E8

163

c = 3E8

164

165

__isConfig = False

165

isConfig = False

166

167

basicHeaderObj = BasicHeader()

167

basicHeaderObj = BasicHeader()

168

169

systemHeaderObj = SystemHeader()

169

systemHeaderObj = SystemHeader()

170

171

radarControllerHeaderObj = RadarControllerHeader()

171

radarControllerHeaderObj = RadarControllerHeader()

172

173

processingHeaderObj = ProcessingHeader()

173

processingHeaderObj = ProcessingHeader()

174

175

online = 0

175

online = 0

176

177

dtype = None

177

dtype = None

178

179

pathList = []

179

pathList = []

180

181

filenameList = []

181

filenameList = []

182

183

filename = None

183

filename = None

184

185

ext = None

185

ext = None

186

187

flagNoMoreFiles = 0

187

flagNoMoreFiles = 0

188

189

flagIsNewFile = 1

189

flagIsNewFile = 1

190

191

flagTimeBlock = 0

191

flagTimeBlock = 0

192

193

flagIsNewBlock = 0

193

flagIsNewBlock = 0

194

195

fp = None

195

fp = None

196

197

firstHeaderSize = 0

197

firstHeaderSize = 0

198

199

basicHeaderSize = 24

199

basicHeaderSize = 24

200

201

versionFile = 1103

201

versionFile = 1103

202

203

fileSize = None

203

fileSize = None

204

205

ippSeconds = None

205

ippSeconds = None

206

207

fileSizeByHeader = None

207

fileSizeByHeader = None

208

209

fileIndex = None

209

fileIndex = None

210

211

profileIndex = None

211

profileIndex = None

212

213

blockIndex = None

213

blockIndex = None

214

215

nTotalBlocks = None

215

nTotalBlocks = None

216

217

maxTimeStep = 30

217

maxTimeStep = 30

218

219

lastUTTime = None

219

lastUTTime = None

220

221

datablock = None

221

datablock = None

222

223

dataOut~~Obj~~ = None

223

dataOut = None

224

225

blocksize = None

225

blocksize = None

226

227

def __init__(self):

227

def __init__(self):

228

229

raise ValueError, "Not implemented"

229

raise ValueError, "Not implemented"

230

231

def run(self):

231

def run(self):

232

233

raise ValueError, "Not implemented"

233

raise ValueError, "Not implemented"

234

235

236

237

class JRODataReader(JRODataIO):

237

class JRODataReader(JRODataIO):

238

239

nReadBlocks = 0

239

nReadBlocks = 0

240

241

delay = 60 #number of seconds waiting a new file

241

delay = 60 #number of seconds waiting a new file

242

243

nTries = 3 #quantity tries

243

nTries = 3 #quantity tries

244

245

nFiles = 3 #number of files for searching

245

nFiles = 3 #number of files for searching

246

247

248

def __init__(self):

248

def __init__(self):

249

250

"""

250

"""

251

252

"""

252

"""

253

254

raise ValueError, "This method has not been implemented"

254

raise ValueError, "This method has not been implemented"

255

256

257

def createObjByDefault(self):

257

def createObjByDefault(self):

258

"""

258

"""

259

260

"""

260

"""

261

raise ValueError, "This method has not been implemented"

261

raise ValueError, "This method has not been implemented"

262

263

def getBlockDimension(self):

263

def getBlockDimension(self):

264

265

raise ValueError, "No implemented"

265

raise ValueError, "No implemented"

266

267

def __searchFilesOffLine(self,

267

def __searchFilesOffLine(self,

268

path,

268

path,

269

startDate,

269

startDate,

270

endDate,

270

endDate,

271

startTime=datetime.time(0,0,0),

271

startTime=datetime.time(0,0,0),

272

endTime=datetime.time(23,59,59),

272

endTime=datetime.time(23,59,59),

273

set=None,

273

set=None,

274

expLabel="",

274

expLabel="",

275

ext=".r"):

275

ext=".r"):

276

dirList = []

276

dirList = []

277

for thisPath in os.listdir(path):

277

for thisPath in os.listdir(path):

278

if os.path.isdir(os.path.join(path,thisPath)):

278

if os.path.isdir(os.path.join(path,thisPath)):

279

dirList.append(thisPath)

279

dirList.append(thisPath)

280

281

if not(dirList):

281

if not(dirList):

282

return None, None

282

return None, None

283

284

pathList = []

284

pathList = []

285

dateList = []

285

dateList = []

286

287

thisDate = startDate

287

thisDate = startDate

288

289

while(thisDate <= endDate):

289

while(thisDate <= endDate):

290

year = thisDate.timetuple().tm_year

290

year = thisDate.timetuple().tm_year

291

doy = thisDate.timetuple().tm_yday

291

doy = thisDate.timetuple().tm_yday

292

293

match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))

293

match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))

294

if len(match) == 0:

294

if len(match) == 0:

295

thisDate += datetime.timedelta(1)

295

thisDate += datetime.timedelta(1)

296

continue

296

continue

297

298

pathList.append(os.path.join(path,match[0],expLabel))

298

pathList.append(os.path.join(path,match[0],expLabel))

299

dateList.append(thisDate)

299

dateList.append(thisDate)

300

thisDate += datetime.timedelta(1)

300

thisDate += datetime.timedelta(1)

301

302

filenameList = []

302

filenameList = []

303

for index in range(len(pathList)):

303

for index in range(len(pathList)):

304

305

thisPath = pathList[index]

305

thisPath = pathList[index]

306

fileList = glob.glob1(thisPath, "*%s" %ext)

306

fileList = glob.glob1(thisPath, "*%s" %ext)

307

fileList.sort()

307

fileList.sort()

308

309

#Busqueda de datos en el rango de horas indicados

309

#Busqueda de datos en el rango de horas indicados

310

thisDate = dateList[index]

310

thisDate = dateList[index]

311

startDT = datetime.datetime.combine(thisDate, startTime)

311

startDT = datetime.datetime.combine(thisDate, startTime)

312

endDT = datetime.datetime.combine(thisDate, endTime)

312

endDT = datetime.datetime.combine(thisDate, endTime)

313

314

startUtSeconds = time.mktime(startDT.timetuple())

314

startUtSeconds = time.mktime(startDT.timetuple())

315

endUtSeconds = time.mktime(endDT.timetuple())

315

endUtSeconds = time.mktime(endDT.timetuple())

316

317

for file in fileList:

317

for file in fileList:

318

319

filename = os.path.join(thisPath,file)

319

filename = os.path.join(thisPath,file)

320

321

if isThisFileinRange(filename, startUtSeconds, endUtSeconds):

321

if isThisFileinRange(filename, startUtSeconds, endUtSeconds):

322

filenameList.append(filename)

322

filenameList.append(filename)

323

324

if not(filenameList):

324

if not(filenameList):

325

return None, None

325

return None, None

326

327

self.filenameList = filenameList

327

self.filenameList = filenameList

328

329

return pathList, filenameList

329

return pathList, filenameList

330

331

def __searchFilesOnLine(self, path, startDate=None, endDate=None, startTime=None, endTime=None, expLabel = "", ext = None):

331

def __searchFilesOnLine(self, path, startDate=None, endDate=None, startTime=None, endTime=None, expLabel = "", ext = None):

332

333

"""

333

"""

334

Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y

334

Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y

335

devuelve el archivo encontrado ademas de otros datos.

335

devuelve el archivo encontrado ademas de otros datos.

336

337

Input:

337

Input:

338

path : carpeta donde estan contenidos los files que contiene data

338

path : carpeta donde estan contenidos los files que contiene data

339

340

startDate : Fecha inicial. Rechaza todos los directorios donde

340

startDate : Fecha inicial. Rechaza todos los directorios donde

341

file end time < startDate (obejto datetime.date)

341

file end time < startDate (obejto datetime.date)

342

343

endDate : Fecha final. Rechaza todos los directorios donde

343

endDate : Fecha final. Rechaza todos los directorios donde

344

file start time > endDate (obejto datetime.date)

344

file start time > endDate (obejto datetime.date)

345

346

startTime : Tiempo inicial. Rechaza todos los archivos donde

346

startTime : Tiempo inicial. Rechaza todos los archivos donde

347

file end time < startTime (obejto datetime.time)

347

file end time < startTime (obejto datetime.time)

348

349

endTime : Tiempo final. Rechaza todos los archivos donde

349

endTime : Tiempo final. Rechaza todos los archivos donde

350

file start time > endTime (obejto datetime.time)

350

file start time > endTime (obejto datetime.time)

351

352

expLabel : Nombre del subexperimento (subfolder)

352

expLabel : Nombre del subexperimento (subfolder)

353

354

ext : extension de los files

354

ext : extension de los files

355

356

Return:

356

Return:

357

directory : eL directorio donde esta el file encontrado

357

directory : eL directorio donde esta el file encontrado

358

filename : el ultimo file de una determinada carpeta

358

filename : el ultimo file de una determinada carpeta

359

year : el anho

359

year : el anho

360

doy : el numero de dia del anho

360

doy : el numero de dia del anho

361

set : el set del archivo

361

set : el set del archivo

362

363

364

"""

364

"""

365

dirList = []

365

dirList = []

366

pathList = []

366

pathList = []

367

directory = None

367

directory = None

368

369

#Filtra solo los directorios

369

#Filtra solo los directorios

370

for thisPath in os.listdir(path):

370

for thisPath in os.listdir(path):

371

if os.path.isdir(os.path.join(path, thisPath)):

371

if os.path.isdir(os.path.join(path, thisPath)):

372

dirList.append(thisPath)

372

dirList.append(thisPath)

373

374

if not(dirList):

374

if not(dirList):

375

return None, None, None, None, None

375

return None, None, None, None, None

376

377

dirList = sorted( dirList, key=str.lower )

377

dirList = sorted( dirList, key=str.lower )

378

379

if startDate:

379

if startDate:

380

startDateTime = datetime.datetime.combine(startDate, startTime)

380

startDateTime = datetime.datetime.combine(startDate, startTime)

381

thisDateTime = startDateTime

381

thisDateTime = startDateTime

382

if endDate == None: endDateTime = startDateTime

382

if endDate == None: endDateTime = startDateTime

383

else: endDateTime = datetime.datetime.combine(endDate, endTime)

383

else: endDateTime = datetime.datetime.combine(endDate, endTime)

384

385

while(thisDateTime <= endDateTime):

385

while(thisDateTime <= endDateTime):

386

year = thisDateTime.timetuple().tm_year

386

year = thisDateTime.timetuple().tm_year

387

doy = thisDateTime.timetuple().tm_yday

387

doy = thisDateTime.timetuple().tm_yday

388

389

match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))

389

match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))

390

if len(match) == 0:

390

if len(match) == 0:

391

thisDateTime += datetime.timedelta(1)

391

thisDateTime += datetime.timedelta(1)

392

continue

392

continue

393

394

pathList.append(os.path.join(path,match[0], expLabel))

394

pathList.append(os.path.join(path,match[0], expLabel))

395

thisDateTime += datetime.timedelta(1)

395

thisDateTime += datetime.timedelta(1)

396

397

if not(pathList):

397

if not(pathList):

398

print "\tNo files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())

398

print "\tNo files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())

399

return None, None, None, None, None

399

return None, None, None, None, None

400

401

directory = pathList[0]

401

directory = pathList[0]

402

403

else:

403

else:

404

directory = dirList[-1]

404

directory = dirList[-1]

405

directory = os.path.join(path,directory)

405

directory = os.path.join(path,directory)

406

407

filename = getlastFileFromPath(directory, ext)

407

filename = getlastFileFromPath(directory, ext)

408

409

if not(filename):

409

if not(filename):

410

return None, None, None, None, None

410

return None, None, None, None, None

411

412

if not(self.__verifyFile(os.path.join(directory, filename))):

412

if not(self.__verifyFile(os.path.join(directory, filename))):

413

return None, None, None, None, None

413

return None, None, None, None, None

414

415

year = int( filename[1:5] )

415

year = int( filename[1:5] )

416

doy = int( filename[5:8] )

416

doy = int( filename[5:8] )

417

set = int( filename[8:11] )

417

set = int( filename[8:11] )

418

419

return directory, filename, year, doy, set

419

return directory, filename, year, doy, set

420

421

def setup(self,dataOut~~Obj~~=None,

421

def setup(self,dataOut=None,

422

path=None,

422

path=None,

423

startDate=None,

423

startDate=None,

424

endDate=None,

424

endDate=None,

425

startTime=datetime.time(0,0,0),

425

startTime=datetime.time(0,0,0),

426

endTime=datetime.time(23,59,59),

426

endTime=datetime.time(23,59,59),

427

set=0,

427

set=0,

428

expLabel = "",

428

expLabel = "",

429

ext = None,

429

ext = None,

430

online = False,

430

online = False,

431

delay = 60):

431

delay = 60):

432

433

if path == None:

433

if path == None:

434

raise ValueError, "The path is not valid"

434

raise ValueError, "The path is not valid"

435

436

if ext == None:

436

if ext == None:

437

ext = self.ext

437

ext = self.ext

438

439

if dataOut~~Obj~~ == None:

439

if dataOut == None:

440

dataOut~~Obj~~ = self.createObjByDefault()

440

dataOut = self.createObjByDefault()

441

442

self.dataOut~~Obj~~ = dataOut~~Obj~~

442

self.dataOut = dataOut

443

444

if online:

444

if online:

445

print "Searching files in online mode..."

445

print "Searching files in online mode..."

446

doypath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext)

446

doypath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext)

447

448

if not(doypath):

448

if not(doypath):

449

for nTries in range( self.nTries ):

449

for nTries in range( self.nTries ):

450

print '\tWaiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1)

450

print '\tWaiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1)

451

time.sleep( self.delay )

451

time.sleep( self.delay )

452

doypath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=exp)

452

doypath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=exp)

453

if doypath:

453

if doypath:

454

break

454

break

455

456

if not(doypath):

456

if not(doypath):

457

print "There 'isn't valied files in %s" % path

457

print "There 'isn't valied files in %s" % path

458

return None

458

return None

459

460

self.year = year

460

self.year = year

461

self.doy = doy

461

self.doy = doy

462

self.set = set - 1

462

self.set = set - 1

463

self.path = path

463

self.path = path

464

465

else:

465

else:

466

print "Searching files in offline mode ..."

466

print "Searching files in offline mode ..."

467

pathList, filenameList = self.__searchFilesOffLine(path, startDate, endDate, startTime, endTime, set, expLabel, ext)

467

pathList, filenameList = self.__searchFilesOffLine(path, startDate, endDate, startTime, endTime, set, expLabel, ext)

468

469

if not(pathList):

469

if not(pathList):

470

print "No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,

470

print "No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,

471

datetime.datetime.combine(startDate,startTime).ctime(),

471

datetime.datetime.combine(startDate,startTime).ctime(),

472

datetime.datetime.combine(endDate,endTime).ctime())

472

datetime.datetime.combine(endDate,endTime).ctime())

473

474

sys.exit(-1)

474

sys.exit(-1)

475

476

477

self.fileIndex = -1

477

self.fileIndex = -1

478

self.pathList = pathList

478

self.pathList = pathList

479

self.filenameList = filenameList

479

self.filenameList = filenameList

480

481

self.online = online

481

self.online = online

482

self.delay = delay

482

self.delay = delay

483

ext = ext.lower()

483

ext = ext.lower()

484

self.ext = ext

484

self.ext = ext

485

486

if not(self.setNextFile()):

486

if not(self.setNextFile()):

487

if (startDate!=None) and (endDate!=None):

487

if (startDate!=None) and (endDate!=None):

488

print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())

488

print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())

489

elif startDate != None:

489

elif startDate != None:

490

print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())

490

print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())

491

else:

491

else:

492

print "No files"

492

print "No files"

493

494

sys.exit(-1)

494

sys.exit(-1)

495

496

# self.updateDataHeader()

496

# self.updateDataHeader()

497

498

return self.dataOut~~Obj~~

498

return self.dataOut

499

500

def __setNextFileOffline(self):

500

def __setNextFileOffline(self):

501

502

idFile = self.fileIndex

502

idFile = self.fileIndex

503

504

while (True):

504

while (True):

505

idFile += 1

505

idFile += 1

506

if not(idFile < len(self.filenameList)):

506

if not(idFile < len(self.filenameList)):

507

self.flagNoMoreFiles = 1

507

self.flagNoMoreFiles = 1

508

print "No more Files"

508

print "No more Files"

509

return 0

509

return 0

510

511

filename = self.filenameList[idFile]

511

filename = self.filenameList[idFile]

512

513

if not(self.__verifyFile(filename)):

513

if not(self.__verifyFile(filename)):

514

continue

514

continue

515

516

fileSize = os.path.getsize(filename)

516

fileSize = os.path.getsize(filename)

517

fp = open(filename,'rb')

517

fp = open(filename,'rb')

518

break

518

break

519

520

self.flagIsNewFile = 1

520

self.flagIsNewFile = 1

521

self.fileIndex = idFile

521

self.fileIndex = idFile

522

self.filename = filename

522

self.filename = filename

523

self.fileSize = fileSize

523

self.fileSize = fileSize

524

self.fp = fp

524

self.fp = fp

525

526

print "Setting the file: %s"%self.filename

526

print "Setting the file: %s"%self.filename

527

528

return 1

528

return 1

529

530

def __setNextFileOnline(self):

530

def __setNextFileOnline(self):

531

"""

531

"""

532

Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si

532

Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si

533

no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files

533

no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files

534

siguientes.

534

siguientes.

535

536

Affected:

536

Affected:

537

self.flagIsNewFile

537

self.flagIsNewFile

538

self.filename

538

self.filename

539

self.fileSize

539

self.fileSize

540

self.fp

540

self.fp

541

self.set

541

self.set

542

self.flagNoMoreFiles

542

self.flagNoMoreFiles

543

544

Return:

544

Return:

545

0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado

545

0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado

546

1 : si el file fue abierto con exito y esta listo a ser leido

546

1 : si el file fue abierto con exito y esta listo a ser leido

547

548

Excepciones:

548

Excepciones:

549

Si un determinado file no puede ser abierto

549

Si un determinado file no puede ser abierto

550

"""

550

"""

551

nFiles = 0

551

nFiles = 0

552

fileOk_flag = False

552

fileOk_flag = False

553

firstTime_flag = True

553

firstTime_flag = True

554

555

self.set += 1

555

self.set += 1

556

557

#busca el 1er file disponible

557

#busca el 1er file disponible

558

file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )

558

file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )

559

if file:

559

if file:

560

if self.__verifyFile(file, False):

560

if self.__verifyFile(file, False):

561

fileOk_flag = True

561

fileOk_flag = True

562

563

#si no encuentra un file entonces espera y vuelve a buscar

563

#si no encuentra un file entonces espera y vuelve a buscar

564

if not(fileOk_flag):

564

if not(fileOk_flag):

565

for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles

565

for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles

566

567

if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces

567

if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces

568

tries = self.nTries

568

tries = self.nTries

569

else:

569

else:

570

tries = 1 #si no es la 1era vez entonces solo lo hace una vez

570

tries = 1 #si no es la 1era vez entonces solo lo hace una vez

571

572

for nTries in range( tries ):

572

for nTries in range( tries ):

573

if firstTime_flag:

573

if firstTime_flag:

574

print "\tWaiting %0.2f sec for the file \"%s\" , try %03d ..." % ( self.delay, filename, nTries+1 )

574

print "\tWaiting %0.2f sec for the file \"%s\" , try %03d ..." % ( self.delay, filename, nTries+1 )

575

time.sleep( self.delay )

575

time.sleep( self.delay )

576

else:

576

else:

577

print "\tSearching next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)

577

print "\tSearching next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)

578

579

file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )

579

file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )

580

if file:

580

if file:

581

if self.__verifyFile(file):

581

if self.__verifyFile(file):

582

fileOk_flag = True

582

fileOk_flag = True

583

break

583

break

584

585

if fileOk_flag:

585

if fileOk_flag:

586

break

586

break

587

588

firstTime_flag = False

588

firstTime_flag = False

589

590

print "\tSkipping the file \"%s\" due to this file doesn't exist" % filename

590

print "\tSkipping the file \"%s\" due to this file doesn't exist" % filename

591

self.set += 1

591

self.set += 1

592

593

if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta

593

if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta

594

self.set = 0

594

self.set = 0

595

self.doy += 1

595

self.doy += 1

596

597

if fileOk_flag:

597

if fileOk_flag:

598

self.fileSize = os.path.getsize( file )

598

self.fileSize = os.path.getsize( file )

599

self.filename = file

599

self.filename = file

600

self.flagIsNewFile = 1

600

self.flagIsNewFile = 1

601

if self.fp != None: self.fp.close()

601

if self.fp != None: self.fp.close()

602

self.fp = open(file)

602

self.fp = open(file)

603

self.flagNoMoreFiles = 0

603

self.flagNoMoreFiles = 0

604

print 'Setting the file: %s' % file

604

print 'Setting the file: %s' % file

605

else:

605

else:

606

self.fileSize = 0

606

self.fileSize = 0

607

self.filename = None

607

self.filename = None

608

self.flagIsNewFile = 0

608

self.flagIsNewFile = 0

609

self.fp = None

609

self.fp = None

610

self.flagNoMoreFiles = 1

610

self.flagNoMoreFiles = 1

611

print 'No more Files'

611

print 'No more Files'

612

613

return fileOk_flag

613

return fileOk_flag

614

615

616

def setNextFile(self):

616

def setNextFile(self):

617

if self.fp != None:

617

if self.fp != None:

618

self.fp.close()

618

self.fp.close()

619

620

if self.online:

620

if self.online:

621

newFile = self.__setNextFileOnline()

621

newFile = self.__setNextFileOnline()

622

else:

622

else:

623

newFile = self.__setNextFileOffline()

623

newFile = self.__setNextFileOffline()

624

625

if not(newFile):

625

if not(newFile):

626

return 0

626

return 0

627

628

self.__readFirstHeader()

628

self.__readFirstHeader()

629

self.nReadBlocks = 0

629

self.nReadBlocks = 0

630

return 1

630

return 1

631

632

def __setNewBlock(self):

632

def __setNewBlock(self):

633

if self.fp == None:

633

if self.fp == None:

634

return 0

634

return 0

635

636

if self.flagIsNewFile:

636

if self.flagIsNewFile:

637

return 1

637

return 1

638

639

self.lastUTTime = self.basicHeaderObj.utc

639

self.lastUTTime = self.basicHeaderObj.utc

640

currentSize = self.fileSize - self.fp.tell()

640

currentSize = self.fileSize - self.fp.tell()

641

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

641

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

642

643

if (currentSize >= neededSize):

643

if (currentSize >= neededSize):

644

self.__rdBasicHeader()

644

self.__rdBasicHeader()

645

return 1

645

return 1

646

647

if not(self.setNextFile()):

647

if not(self.setNextFile()):

648

return 0

648

return 0

649

650

deltaTime = self.basicHeaderObj.utc - self.lastUTTime #

650

deltaTime = self.basicHeaderObj.utc - self.lastUTTime #

651

652

self.flagTimeBlock = 0

652

self.flagTimeBlock = 0

653

654

if deltaTime > self.maxTimeStep:

654

if deltaTime > self.maxTimeStep:

655

self.flagTimeBlock = 1

655

self.flagTimeBlock = 1

656

657

return 1

657

return 1

658

659

660

def readNextBlock(self):

660

def readNextBlock(self):

661

if not(self.__setNewBlock()):

661

if not(self.__setNewBlock()):

662

return 0

662

return 0

663

664

if not(self.readBlock()):

664

if not(self.readBlock()):

665

return 0

665

return 0

666

667

return 1

667

return 1

668

669

def __rdProcessingHeader(self, fp=None):

669

def __rdProcessingHeader(self, fp=None):

670

if fp == None:

670

if fp == None:

671

fp = self.fp

671

fp = self.fp

672

673

self.processingHeaderObj.read(fp)

673

self.processingHeaderObj.read(fp)

674

675

def __rdRadarControllerHeader(self, fp=None):

675

def __rdRadarControllerHeader(self, fp=None):

676

if fp == None:

676

if fp == None:

677

fp = self.fp

677

fp = self.fp

678

679

self.radarControllerHeaderObj.read(fp)

679

self.radarControllerHeaderObj.read(fp)

680

681

def __rdSystemHeader(self, fp=None):

681

def __rdSystemHeader(self, fp=None):

682

if fp == None:

682

if fp == None:

683

fp = self.fp

683

fp = self.fp

684

685

self.systemHeaderObj.read(fp)

685

self.systemHeaderObj.read(fp)

686

687

def __rdBasicHeader(self, fp=None):

687

def __rdBasicHeader(self, fp=None):

688

if fp == None:

688

if fp == None:

689

fp = self.fp

689

fp = self.fp

690

691

self.basicHeaderObj.read(fp)

691

self.basicHeaderObj.read(fp)

692

693

694

def __readFirstHeader(self):

694

def __readFirstHeader(self):

695

self.__rdBasicHeader()

695

self.__rdBasicHeader()

696

self.__rdSystemHeader()

696

self.__rdSystemHeader()

697

self.__rdRadarControllerHeader()

697

self.__rdRadarControllerHeader()

698

self.__rdProcessingHeader()

698

self.__rdProcessingHeader()

699

700

self.firstHeaderSize = self.basicHeaderObj.size

700

self.firstHeaderSize = self.basicHeaderObj.size

701

702

datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))

702

datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))

703

if datatype == 0:

703

if datatype == 0:

704

datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])

704

datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])

705

elif datatype == 1:

705

elif datatype == 1:

706

datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])

706

datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])

707

elif datatype == 2:

707

elif datatype == 2:

708

datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])

708

datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])

709

elif datatype == 3:

709

elif datatype == 3:

710

datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])

710

datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])

711

elif datatype == 4:

711

elif datatype == 4:

712

datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])

712

datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])

713

elif datatype == 5:

713

elif datatype == 5:

714

datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])

714

datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])

715

else:

715

else:

716

raise ValueError, 'Data type was not defined'

716

raise ValueError, 'Data type was not defined'

717

718

self.dtype = datatype_str

718

self.dtype = datatype_str

719

self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c

719

self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c

720

self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)

720

self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)

721

# self.dataOut~~Obj~~.channelList = numpy.arange(self.systemHeaderObj.numChannels)

721

# self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)

722

# self.dataOut~~Obj~~.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)

722

# self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)

723

self.getBlockDimension()

723

self.getBlockDimension()

724

725

726

def __verifyFile(self, filename, msgFlag=True):

726

def __verifyFile(self, filename, msgFlag=True):

727

msg = None

727

msg = None

728

try:

728

try:

729

fp = open(filename, 'rb')

729

fp = open(filename, 'rb')

730

currentPosition = fp.tell()

730

currentPosition = fp.tell()

731

except:

731

except:

732

if msgFlag:

732

if msgFlag:

733

print "The file %s can't be opened" % (filename)

733

print "The file %s can't be opened" % (filename)

734

return False

734

return False

735

736

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

736

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

737

738

if neededSize == 0:

738

if neededSize == 0:

739

basicHeaderObj = BasicHeader()

739

basicHeaderObj = BasicHeader()

740

systemHeaderObj = SystemHeader()

740

systemHeaderObj = SystemHeader()

741

radarControllerHeaderObj = RadarControllerHeader()

741

radarControllerHeaderObj = RadarControllerHeader()

742

processingHeaderObj = ProcessingHeader()

742

processingHeaderObj = ProcessingHeader()

743

744

try:

744

try:

745

if not( basicHeaderObj.read(fp) ): raise ValueError

745

if not( basicHeaderObj.read(fp) ): raise ValueError

746

if not( systemHeaderObj.read(fp) ): raise ValueError

746

if not( systemHeaderObj.read(fp) ): raise ValueError

747

if not( radarControllerHeaderObj.read(fp) ): raise ValueError

747

if not( radarControllerHeaderObj.read(fp) ): raise ValueError

748

if not( processingHeaderObj.read(fp) ): raise ValueError

748

if not( processingHeaderObj.read(fp) ): raise ValueError

749

data_type = int(numpy.log2((processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))

749

data_type = int(numpy.log2((processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))

750

751

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

751

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

752

753

except:

753

except:

754

if msgFlag:

754

if msgFlag:

755

print "\tThe file %s is empty or it hasn't enough data" % filename

755

print "\tThe file %s is empty or it hasn't enough data" % filename

756

757

fp.close()

757

fp.close()

758

return False

758

return False

759

else:

759

else:

760

msg = "\tSkipping the file %s due to it hasn't enough data" %filename

760

msg = "\tSkipping the file %s due to it hasn't enough data" %filename

761

762

fp.close()

762

fp.close()

763

fileSize = os.path.getsize(filename)

763

fileSize = os.path.getsize(filename)

764

currentSize = fileSize - currentPosition

764

currentSize = fileSize - currentPosition

765

if currentSize < neededSize:

765

if currentSize < neededSize:

766

if msgFlag and (msg != None):

766

if msgFlag and (msg != None):

767

print msg #print"\tSkipping the file %s due to it hasn't enough data" %filename

767

print msg #print"\tSkipping the file %s due to it hasn't enough data" %filename

768

return False

768

return False

769

770

return True

770

return True

771

772

def getData():

772

def getData():

773

pass

773

pass

774

775

def hasNotDataInBuffer():

775

def hasNotDataInBuffer():

776

pass

776

pass

777

778

def readBlock():

778

def readBlock():

779

pass

779

pass

780

781

def run(self, **kwargs):

781

def run(self, **kwargs):

782

783

if not(self.__isConfig):

783

if not(self.isConfig):

784

785

self.dataOut~~Obj~~ = dataOut

785

# self.dataOut = dataOut

786

self.setup(**kwargs)

786

self.setup(**kwargs)

787

self.__isConfig = True

787

self.isConfig = True

788

789

self.getData()

789

self.getData()

790

791

class JRODataWriter(JRODataIO):

791

class JRODataWriter(JRODataIO):

792

793

"""

793

"""

794

Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura

794

Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura

795

de los datos siempre se realiza por bloques.

795

de los datos siempre se realiza por bloques.

796

"""

796

"""

797

798

blockIndex = 0

798

blockIndex = 0

799

800

path = None

800

path = None

801

802

setFile = None

802

setFile = None

803

804

profilesPerBlock = None

804

profilesPerBlock = None

805

806

blocksPerFile = None

806

blocksPerFile = None

807

808

nWriteBlocks = 0

808

nWriteBlocks = 0

809

810

def __init__(self, dataOut~~Obj~~=None):

810

def __init__(self, dataOut=None):

811

raise ValueError, "Not implemented"

811

raise ValueError, "Not implemented"

812

813

814

def hasAllDataInBuffer(self):

814

def hasAllDataInBuffer(self):

815

raise ValueError, "Not implemented"

815

raise ValueError, "Not implemented"

816

817

818

def setBlockDimension(self):

818

def setBlockDimension(self):

819

raise ValueError, "Not implemented"

819

raise ValueError, "Not implemented"

820

821

822

def writeBlock(self):

822

def writeBlock(self):

823

raise ValueError, "No implemented"

823

raise ValueError, "No implemented"

824

825

826

def putData(self):

826

def putData(self):

827

raise ValueError, "No implemented"

827

raise ValueError, "No implemented"

828

829

def getDataHeader(self):

829

def getDataHeader(self):

830

"""

830

"""

831

Obtiene una copia del First Header

831

Obtiene una copia del First Header

832

833

Affected:

833

Affected:

834

835

self.basicHeaderObj

835

self.basicHeaderObj

836

self.systemHeaderObj

836

self.systemHeaderObj

837

self.radarControllerHeaderObj

837

self.radarControllerHeaderObj

838

self.processingHeaderObj self.

838

self.processingHeaderObj self.

839

840

Return:

840

Return:

841

None

841

None

842

"""

842

"""

843

844

raise ValueError, "No implemented"

844

raise ValueError, "No implemented"

845

846

def getBasicHeader(self):

846

def getBasicHeader(self):

847

848

self.basicHeaderObj.size = self.basicHeaderSize #bytes

848

self.basicHeaderObj.size = self.basicHeaderSize #bytes

849

self.basicHeaderObj.version = self.versionFile

849

self.basicHeaderObj.version = self.versionFile

850

self.basicHeaderObj.dataBlock = self.nTotalBlocks

850

self.basicHeaderObj.dataBlock = self.nTotalBlocks

851

852

utc = numpy.floor(self.dataOut~~Obj~~.utctime)

852

utc = numpy.floor(self.dataOut.utctime)

853

milisecond = (self.dataOut~~Obj~~.utctime - utc)* 1000.0

853

milisecond = (self.dataOut.utctime - utc)* 1000.0

854

855

self.basicHeaderObj.utc = utc

855

self.basicHeaderObj.utc = utc

856

self.basicHeaderObj.miliSecond = milisecond

856

self.basicHeaderObj.miliSecond = milisecond

857

self.basicHeaderObj.timeZone = 0

857

self.basicHeaderObj.timeZone = 0

858

self.basicHeaderObj.dstFlag = 0

858

self.basicHeaderObj.dstFlag = 0

859

self.basicHeaderObj.errorCount = 0

859

self.basicHeaderObj.errorCount = 0

860

861

def __writeFirstHeader(self):

861

def __writeFirstHeader(self):

862

"""

862

"""

863

Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)

863

Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)

864

865

Affected:

865

Affected:

866

__dataType

866

__dataType

867

868

Return:

868

Return:

869

None

869

None

870

"""

870

"""

871

872

# CALCULAR PARAMETROS

872

# CALCULAR PARAMETROS

873

874

sizeLongHeader = self.systemHeaderObj.size + self.radarControllerHeaderObj.size + self.processingHeaderObj.size

874

sizeLongHeader = self.systemHeaderObj.size + self.radarControllerHeaderObj.size + self.processingHeaderObj.size

875

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

875

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

876

877

self.basicHeaderObj.write(self.fp)

877

self.basicHeaderObj.write(self.fp)

878

self.systemHeaderObj.write(self.fp)

878

self.systemHeaderObj.write(self.fp)

879

self.radarControllerHeaderObj.write(self.fp)

879

self.radarControllerHeaderObj.write(self.fp)

880

self.processingHeaderObj.write(self.fp)

880

self.processingHeaderObj.write(self.fp)

881

882

self.dtype = self.dataOut~~Obj~~.dtype

882

self.dtype = self.dataOut.dtype

883

884

def __setNewBlock(self):

884

def __setNewBlock(self):

885

"""

885

"""

886

Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header

886

Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header

887

888

Return:

888

Return:

889

0 : si no pudo escribir nada

889

0 : si no pudo escribir nada

890

1 : Si escribio el Basic el First Header

890

1 : Si escribio el Basic el First Header

891

"""

891

"""

892

if self.fp == None:

892

if self.fp == None:

893

self.setNextFile()

893

self.setNextFile()

894

895

if self.flagIsNewFile:

895

if self.flagIsNewFile:

896

return 1

896

return 1

897

898

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

898

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

899

self.basicHeaderObj.write(self.fp)

899

self.basicHeaderObj.write(self.fp)

900

return 1

900

return 1

901

902

if not( self.setNextFile() ):

902

if not( self.setNextFile() ):

903

return 0

903

return 0

904

905

return 1

905

return 1

906

907

908

def writeNextBlock(self):

908

def writeNextBlock(self):

909

"""

909

"""

910

Selecciona el bloque siguiente de datos y los escribe en un file

910

Selecciona el bloque siguiente de datos y los escribe en un file

911

912

Return:

912

Return:

913

0 : Si no hizo pudo escribir el bloque de datos

913

0 : Si no hizo pudo escribir el bloque de datos

914

1 : Si no pudo escribir el bloque de datos

914

1 : Si no pudo escribir el bloque de datos

915

"""

915

"""

916

if not( self.__setNewBlock() ):

916

if not( self.__setNewBlock() ):

917

return 0

917

return 0

918

919

self.writeBlock()

919

self.writeBlock()

920

921

return 1

921

return 1

922

923

def setNextFile(self):

923

def setNextFile(self):

924

"""

924

"""

925

Determina el siguiente file que sera escrito

925

Determina el siguiente file que sera escrito

926

927

Affected:

927

Affected:

928

self.filename

928

self.filename

929

self.subfolder

929

self.subfolder

930

self.fp

930

self.fp

931

self.setFile

931

self.setFile

932

self.flagIsNewFile

932

self.flagIsNewFile

933

934

Return:

934

Return:

935

0 : Si el archivo no puede ser escrito

935

0 : Si el archivo no puede ser escrito

936

1 : Si el archivo esta listo para ser escrito

936

1 : Si el archivo esta listo para ser escrito

937

"""

937

"""

938

ext = self.ext

938

ext = self.ext

939

path = self.path

939

path = self.path

940

941

if self.fp != None:

941

if self.fp != None:

942

self.fp.close()

942

self.fp.close()

943

944

timeTuple = time.localtime( self.dataOut~~Obj~~.dataUtcTime)

944

timeTuple = time.localtime( self.dataOut.dataUtcTime)

945

subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)

945

subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)

946

947

doypath = os.path.join( path, subfolder )

947

doypath = os.path.join( path, subfolder )

948

if not( os.path.exists(doypath) ):

948

if not( os.path.exists(doypath) ):

949

os.mkdir(doypath)

949

os.mkdir(doypath)

950

self.setFile = -1 #inicializo mi contador de seteo

950

self.setFile = -1 #inicializo mi contador de seteo

951

else:

951

else:

952

filesList = os.listdir( doypath )

952

filesList = os.listdir( doypath )

953

if len( filesList ) > 0:

953

if len( filesList ) > 0:

954

filesList = sorted( filesList, key=str.lower )

954

filesList = sorted( filesList, key=str.lower )

955

filen = filesList[-1]

955

filen = filesList[-1]

956

# el filename debera tener el siguiente formato

956

# el filename debera tener el siguiente formato

957

# 0 1234 567 89A BCDE (hex)

957

# 0 1234 567 89A BCDE (hex)

958

# x YYYY DDD SSS .ext

958

# x YYYY DDD SSS .ext

959

if isNumber( filen[8:11] ):

959

if isNumber( filen[8:11] ):

960

self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file

960

self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file

961

else:

961

else:

962

self.setFile = -1

962

self.setFile = -1

963

else:

963

else:

964

self.setFile = -1 #inicializo mi contador de seteo

964

self.setFile = -1 #inicializo mi contador de seteo

965

966

setFile = self.setFile

966

setFile = self.setFile

967

setFile += 1

967

setFile += 1

968

969

file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,

969

file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,

970

timeTuple.tm_year,

970

timeTuple.tm_year,

971

timeTuple.tm_yday,

971

timeTuple.tm_yday,

972

setFile,

972

setFile,

973

ext )

973

ext )

974

975

filename = os.path.join( path, subfolder, file )

975

filename = os.path.join( path, subfolder, file )

976

977

fp = open( filename,'wb' )

977

fp = open( filename,'wb' )

978

979

self.blockIndex = 0

979

self.blockIndex = 0

980

981

#guardando atributos

981

#guardando atributos

982

self.filename = filename

982

self.filename = filename

983

self.subfolder = subfolder

983

self.subfolder = subfolder

984

self.fp = fp

984

self.fp = fp

985

self.setFile = setFile

985

self.setFile = setFile

986

self.flagIsNewFile = 1

986

self.flagIsNewFile = 1

987

988

self.getDataHeader()

988

self.getDataHeader()

989

990

print 'Writing the file: %s'%self.filename

990

print 'Writing the file: %s'%self.filename

991

992

self.__writeFirstHeader()

992

self.__writeFirstHeader()

993

994

return 1

994

return 1

995

996

def setup(self, path, blocksPerFile, profilesPerBlock=None, set=0, ext=None):

996

def setup(self, path, blocksPerFile, profilesPerBlock=None, set=0, ext=None):

997

"""

997

"""

998

Setea el tipo de formato en la cual sera guardada la data y escribe el First Header

998

Setea el tipo de formato en la cual sera guardada la data y escribe el First Header

999

1000

Inputs:

1000

Inputs:

1001

path : el path destino en el cual se escribiran los files a crear

1001

path : el path destino en el cual se escribiran los files a crear

1002

format : formato en el cual sera salvado un file

1002

format : formato en el cual sera salvado un file

1003

set : el setebo del file

1003

set : el setebo del file

1004

1005

Return:

1005

Return:

1006

0 : Si no realizo un buen seteo

1006

0 : Si no realizo un buen seteo

1007

1 : Si realizo un buen seteo

1007

1 : Si realizo un buen seteo

1008

"""

1008

"""

1009

1010

if ext == None:

1010

if ext == None:

1011

ext = self.ext

1011

ext = self.ext

1012

1013

ext = ext.lower()

1013

ext = ext.lower()

1014

1015

self.ext = ext

1015

self.ext = ext

1016

1017

self.path = path

1017

self.path = path

1018

1019

self.setFile = set - 1

1019

self.setFile = set - 1

1020

1021

self.blocksPerFile = blocksPerFile

1021

self.blocksPerFile = blocksPerFile

1022

1023

self.profilesPerBlock = profilesPerBlock

1023

self.profilesPerBlock = profilesPerBlock

1024

1025

if not(self.setNextFile()):

1025

if not(self.setNextFile()):

1026

print "There isn't a next file"

1026

print "There isn't a next file"

1027

return 0

1027

return 0

1028

1029

self.setBlockDimension()

1029

self.setBlockDimension()

1030

1031

return 1

1031

return 1

1032

1033

def run(self, dataOut, **kwargs):

1033

def run(self, dataOut, **kwargs):

1034

1035

if not(self.__isConfig):

1035

if not(self.isConfig):

1036

1037

self.dataOut~~Obj~~ = dataOut

1037

self.dataOut = dataOut

1038

self.setup(**kwargs)

1038

self.setup(**kwargs)

1039

self.__isConfig = True

1039

self.isConfig = True

1040

1041

self.putData()

1041

self.putData()

1042

1043

class VoltageReader(JRODataReader):

1043

class VoltageReader(JRODataReader):

1044

"""

1044

"""

1045

Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura

1045

Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura

1046

de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:

1046

de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:

1047

perfiles*alturas*canales) son almacenados en la variable "buffer".

1047

perfiles*alturas*canales) son almacenados en la variable "buffer".

1048

1049

perfiles * alturas * canales

1049

perfiles * alturas * canales

1050

1051

Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,

1051

Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,

1052

RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la

1052

RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la

1053

cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de

1053

cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de

1054

datos desde el "buffer" cada vez que se ejecute el metodo "getData".

1054

datos desde el "buffer" cada vez que se ejecute el metodo "getData".

1055

1056

Example:

1056

Example:

1057

1058

dpath = "/home/myuser/data"

1058

dpath = "/home/myuser/data"

1059

1060

startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)

1060

startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)

1061

1062

endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)

1062

endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)

1063

1064

readerObj = VoltageReader()

1064

readerObj = VoltageReader()

1065

1066

readerObj.setup(dpath, startTime, endTime)

1066

readerObj.setup(dpath, startTime, endTime)

1067

1068

while(True):

1068

while(True):

1069

1070

#to get one profile

1070

#to get one profile

1071

profile = readerObj.getData()

1071

profile = readerObj.getData()

1072

1073

#print the profile

1073

#print the profile

1074

print profile

1074

print profile

1075

1076

#If you want to see all datablock

1076

#If you want to see all datablock

1077

print readerObj.datablock

1077

print readerObj.datablock

1078

1079

if readerObj.flagNoMoreFiles:

1079

if readerObj.flagNoMoreFiles:

1080

break

1080

break

1081

1082

"""

1082

"""

1083

1084

ext = ".r"

1084

ext = ".r"

1085

1086

optchar = "D"

1086

optchar = "D"

1087

dataOut~~Obj~~ = None

1087

dataOut = None

1088

1089

1090

def __init__(self, dataOut~~Obj~~=None):

1090

def __init__(self, dataOut=None):

1091

"""

1091

"""

1092

Inicializador de la clase VoltageReader para la lectura de datos de voltage.

1092

Inicializador de la clase VoltageReader para la lectura de datos de voltage.

1093

1094

Input:

1094

Input:

1095

dataOut~~Obj~~ : Objeto de la clase Voltage. Este objeto sera utilizado para

1095

dataOut : Objeto de la clase Voltage. Este objeto sera utilizado para

1096

almacenar un perfil de datos cada vez que se haga un requerimiento

1096

almacenar un perfil de datos cada vez que se haga un requerimiento

1097

(getData). El perfil sera obtenido a partir del buffer de datos,

1097

(getData). El perfil sera obtenido a partir del buffer de datos,

1098

si el buffer esta vacio se hara un nuevo proceso de lectura de un

1098

si el buffer esta vacio se hara un nuevo proceso de lectura de un

1099

bloque de datos.

1099

bloque de datos.

1100

Si este parametro no es pasado se creara uno internamente.

1100

Si este parametro no es pasado se creara uno internamente.

1101

1102

Variables afectadas:

1102

Variables afectadas:

1103

self.dataOut~~Obj~~

1103

self.dataOut

1104

1105

Return:

1105

Return:

1106

None

1106

None

1107

"""

1107

"""

1108

1109

self.__isConfig = False

1109

self.isConfig = False

1110

1111

self.datablock = None

1111

self.datablock = None

1112

1113

self.utc = 0

1113

self.utc = 0

1114

1115

self.ext = ".r"

1115

self.ext = ".r"

1116

1117

self.optchar = "D"

1117

self.optchar = "D"

1118

1119

self.basicHeaderObj = BasicHeader()

1119

self.basicHeaderObj = BasicHeader()

1120

1121

self.systemHeaderObj = SystemHeader()

1121

self.systemHeaderObj = SystemHeader()

1122

1123

self.radarControllerHeaderObj = RadarControllerHeader()

1123

self.radarControllerHeaderObj = RadarControllerHeader()

1124

1125

self.processingHeaderObj = ProcessingHeader()

1125

self.processingHeaderObj = ProcessingHeader()

1126

1127

self.online = 0

1127

self.online = 0

1128

1129

self.fp = None

1129

self.fp = None

1130

1131

self.idFile = None

1131

self.idFile = None

1132

1133

self.dtype = None

1133

self.dtype = None

1134

1135

self.fileSizeByHeader = None

1135

self.fileSizeByHeader = None

1136

1137

self.filenameList = []

1137

self.filenameList = []

1138

1139

self.filename = None

1139

self.filename = None

1140

1141

self.fileSize = None

1141

self.fileSize = None

1142

1143

self.firstHeaderSize = 0

1143

self.firstHeaderSize = 0

1144

1145

self.basicHeaderSize = 24

1145

self.basicHeaderSize = 24

1146

1147

self.pathList = []

1147

self.pathList = []

1148

1149

self.filenameList = []

1149

self.filenameList = []

1150

1151

self.lastUTTime = 0

1151

self.lastUTTime = 0

1152

1153

self.maxTimeStep = 30

1153

self.maxTimeStep = 30

1154

1155

self.flagNoMoreFiles = 0

1155

self.flagNoMoreFiles = 0

1156

1157

self.set = 0

1157

self.set = 0

1158

1159

self.path = None

1159

self.path = None

1160

1161

self.profileIndex = 9999

1161

self.profileIndex = 9999

1162

1163

self.delay = 3 #seconds

1163

self.delay = 3 #seconds

1164

1165

self.nTries = 3 #quantity tries

1165

self.nTries = 3 #quantity tries

1166

1167

self.nFiles = 3 #number of files for searching

1167

self.nFiles = 3 #number of files for searching

1168

1169

self.nReadBlocks = 0

1169

self.nReadBlocks = 0

1170

1171

self.flagIsNewFile = 1

1171

self.flagIsNewFile = 1

1172

1173

self.ippSeconds = 0

1173

self.ippSeconds = 0

1174

1175

self.flagTimeBlock = 0

1175

self.flagTimeBlock = 0

1176

1177

self.flagIsNewBlock = 0

1177

self.flagIsNewBlock = 0

1178

1179

self.nTotalBlocks = 0

1179

self.nTotalBlocks = 0

1180

1181

self.blocksize = 0

1181

self.blocksize = 0

1182

1183

def createObjByDefault(self):

1183

def createObjByDefault(self):

1184

1185

dataObj = Voltage()

1185

dataObj = Voltage()

1186

1187

return dataObj

1187

return dataObj

1188

1189

def __hasNotDataInBuffer(self):

1189

def __hasNotDataInBuffer(self):

1190

if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:

1190

if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:

1191

return 1

1191

return 1

1192

return 0

1192

return 0

1193

1194

1195

def getBlockDimension(self):

1195

def getBlockDimension(self):

1196

"""

1196

"""

1197

Obtiene la cantidad de puntos a leer por cada bloque de datos

1197

Obtiene la cantidad de puntos a leer por cada bloque de datos

1198

1199

Affected:

1199

Affected:

1200

self.blocksize

1200

self.blocksize

1201

1202

Return:

1202

Return:

1203

None

1203

None

1204

"""

1204

"""

1205

pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels

1205

pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels

1206

self.blocksize = pts2read

1206

self.blocksize = pts2read

1207

1208

1209

def readBlock(self):

1209

def readBlock(self):

1210

"""

1210

"""

1211

readBlock lee el bloque de datos desde la posicion actual del puntero del archivo

1211

readBlock lee el bloque de datos desde la posicion actual del puntero del archivo

1212

(self.fp) y actualiza todos los parametros relacionados al bloque de datos

1212

(self.fp) y actualiza todos los parametros relacionados al bloque de datos

1213

(metadata + data). La data leida es almacenada en el buffer y el contador del buffer

1213

(metadata + data). La data leida es almacenada en el buffer y el contador del buffer

1214

es seteado a 0

1214

es seteado a 0

1215

1216

Inputs:

1216

Inputs:

1217

None

1217

None

1218

1219

Return:

1219

Return:

1220

None

1220

None

1221

1222

Affected:

1222

Affected:

1223

self.profileIndex

1223

self.profileIndex

1224

self.datablock

1224

self.datablock

1225

self.flagIsNewFile

1225

self.flagIsNewFile

1226

self.flagIsNewBlock

1226

self.flagIsNewBlock

1227

self.nTotalBlocks

1227

self.nTotalBlocks

1228

1229

Exceptions:

1229

Exceptions:

1230

Si un bloque leido no es un bloque valido

1230

Si un bloque leido no es un bloque valido

1231

"""

1231

"""

1232

1233

junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )

1233

junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )

1234

1235

try:

1235

try:

1236

junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )

1236

junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )

1237

except:

1237

except:

1238

print "The read block (%3d) has not enough data" %self.nReadBlocks

1238

print "The read block (%3d) has not enough data" %self.nReadBlocks

1239

return 0

1239

return 0

1240

1241

junk = numpy.transpose(junk, (2,0,1))

1241

junk = numpy.transpose(junk, (2,0,1))

1242

self.datablock = junk['real'] + junk['imag']*1j

1242

self.datablock = junk['real'] + junk['imag']*1j

1243

1244

self.profileIndex = 0

1244

self.profileIndex = 0

1245

1246

self.flagIsNewFile = 0

1246

self.flagIsNewFile = 0

1247

self.flagIsNewBlock = 1

1247

self.flagIsNewBlock = 1

1248

1249

self.nTotalBlocks += 1

1249

self.nTotalBlocks += 1

1250

self.nReadBlocks += 1

1250

self.nReadBlocks += 1

1251

1252

return 1

1252

return 1

1253

1254

1255

def getData(self):

1255

def getData(self):

1256

"""

1256

"""

1257

getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"

1257

getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"

1258

con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de

1258

con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de

1259

lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"

1259

lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"

1260

1261

Ademas incrementa el contador del buffer en 1.

1261

Ademas incrementa el contador del buffer en 1.

1262

1263

Return:

1263

Return:

1264

data : retorna un perfil de voltages (alturas * canales) copiados desde el

1264

data : retorna un perfil de voltages (alturas * canales) copiados desde el

1265

buffer. Si no hay mas archivos a leer retorna None.

1265

buffer. Si no hay mas archivos a leer retorna None.

1266

1267

Variables afectadas:

1267

Variables afectadas:

1268

self.dataOut~~Obj~~

1268

self.dataOut

1269

self.profileIndex

1269

self.profileIndex

1270

1271

Affected:

1271

Affected:

1272

self.dataOut~~Obj~~

1272

self.dataOut

1273

self.profileIndex

1273

self.profileIndex

1274

self.flagTimeBlock

1274

self.flagTimeBlock

1275

self.flagIsNewBlock

1275

self.flagIsNewBlock

1276

"""

1276

"""

1277

if self.flagNoMoreFiles: return 0

1277

if self.flagNoMoreFiles: return 0

1278

1279

self.flagTimeBlock = 0

1279

self.flagTimeBlock = 0

1280

self.flagIsNewBlock = 0

1280

self.flagIsNewBlock = 0

1281

1282

if self.__hasNotDataInBuffer():

1282

if self.__hasNotDataInBuffer():

1283

1284

if not( self.readNextBlock() ):

1284

if not( self.readNextBlock() ):

1285

return 0

1285

return 0

1286

1287

# self.updateDataHeader()

1287

# self.updateDataHeader()

1288

1289

if self.flagNoMoreFiles == 1:

1289

if self.flagNoMoreFiles == 1:

1290

print 'Process finished'

1290

print 'Process finished'

1291

return 0

1291

return 0

1292

1293

#data es un numpy array de 3 dmensiones (perfiles, alturas y canales)

1293

#data es un numpy array de 3 dmensiones (perfiles, alturas y canales)

1294

1295

if self.datablock == None:

1295

if self.datablock == None:

1296

self.dataOut~~Obj~~.flagNoData = True

1296

self.dataOut.flagNoData = True

1297

return 0

1297

return 0

1298

1299

self.dataOut~~Obj~~.data = self.datablock[:,self.profileIndex,:]

1299

self.dataOut.data = self.datablock[:,self.profileIndex,:]

1300

1301

self.dataOut~~Obj~~.dtype = self.dtype

1301

self.dataOut.dtype = self.dtype

1302

1303

self.dataOut~~Obj~~.nChannels = self.systemHeaderObj.nChannels

1303

self.dataOut.nChannels = self.systemHeaderObj.nChannels

1304

1305

self.dataOut~~Obj~~.nHeights = self.processingHeaderObj.nHeights

1305

self.dataOut.nHeights = self.processingHeaderObj.nHeights

1306

1307

self.dataOut~~Obj~~.nProfiles = self.processingHeaderObj.profilesPerBlock

1307

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1308

1309

xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight

1309

xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight

1310

1311

self.dataOut~~Obj~~.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)

1311

self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)

1312

1313

self.dataOut~~Obj~~.channelList = range(self.systemHeaderObj.nChannels)

1313

self.dataOut.channelList = range(self.systemHeaderObj.nChannels)

1314

1315

self.dataOut~~Obj~~.channelIndexList = range(self.systemHeaderObj.nChannels)

1315

self.dataOut.channelIndexList = range(self.systemHeaderObj.nChannels)

1316

1317

self.dataOut~~Obj~~.flagTimeBlock = self.flagTimeBlock

1317

self.dataOut.flagTimeBlock = self.flagTimeBlock

1318

1319

self.dataOut~~Obj~~.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.ippSeconds

1319

self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.ippSeconds

1320

1321

self.dataOut~~Obj~~.ippSeconds = self.ippSeconds

1321

self.dataOut.ippSeconds = self.ippSeconds

1322

1323

self.dataOut~~Obj~~.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt

1323

self.dataOut.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt

1324

1325

self.dataOut~~Obj~~.nCohInt = self.processingHeaderObj.nCohInt

1325

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1326

1327

self.dataOut~~Obj~~.flagShiftFFT = False

1327

self.dataOut.flagShiftFFT = False

1328

1329

if self.processingHeaderObj.code != None:

1329

if self.processingHeaderObj.code != None:

1330

self.dataOut~~Obj~~.nCode = self.processingHeaderObj.nCode

1330

self.dataOut.nCode = self.processingHeaderObj.nCode

1331

1332

self.dataOut~~Obj~~.nBaud = self.processingHeaderObj.nBaud

1332

self.dataOut.nBaud = self.processingHeaderObj.nBaud

1333

1334

self.dataOut~~Obj~~.code = self.processingHeaderObj.code

1334

self.dataOut.code = self.processingHeaderObj.code

1335

1336

self.profileIndex += 1

1336

self.profileIndex += 1

1337

1338

self.dataOut~~Obj~~.systemHeaderObj = self.systemHeaderObj.copy()

1338

self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()

1339

1340

self.dataOut~~Obj~~.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()

1340

self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()

1341

1342

self.dataOut~~Obj~~.flagNoData = False

1342

self.dataOut.flagNoData = False

1343

1344

# print self.profileIndex, self.dataOut~~Obj~~.utctime

1344

# print self.profileIndex, self.dataOut.utctime

1345

# if self.profileIndex == 800:

1345

# if self.profileIndex == 800:

1346

# a=1

1346

# a=1

1347

1348

return self.dataOut~~Obj~~.data

1348

return self.dataOut.data

1349

1350

1351

class VoltageWriter(JRODataWriter):

1351

class VoltageWriter(JRODataWriter):

1352

"""

1352

"""

1353

Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura

1353

Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura

1354

de los datos siempre se realiza por bloques.

1354

de los datos siempre se realiza por bloques.

1355

"""

1355

"""

1356

1357

ext = ".r"

1357

ext = ".r"

1358

1359

optchar = "D"

1359

optchar = "D"

1360

1361

shapeBuffer = None

1361

shapeBuffer = None

1362

1363

1364

def __init__(self, dataOut~~Obj~~=None):

1364

def __init__(self, dataOut=None):

1365

"""

1365

"""

1366

Inicializador de la clase VoltageWriter para la escritura de datos de espectros.

1366

Inicializador de la clase VoltageWriter para la escritura de datos de espectros.

1367

1368

Affected:

1368

Affected:

1369

self.dataOut~~Obj~~

1369

self.dataOut

1370

1371

Return: None

1371

Return: None

1372

"""

1372

"""

1373

if dataOut~~Obj~~ == None:

1373

if dataOut == None:

1374

dataOut~~Obj~~ = Voltage()

1374

dataOut = Voltage()

1375

1376

if not( isinstance(dataOut~~Obj~~, Voltage) ):

1376

if not( isinstance(dataOut, Voltage) ):

1377

raise ValueError, "in VoltageReader, dataOut~~Obj~~ must be an Spectra class object"

1377

raise ValueError, "in VoltageReader, dataOut must be an Spectra class object"

1378

1379

self.dataOut~~Obj~~ = dataOut~~Obj~~

1379

self.dataOut = dataOut

1380

1381

self.nTotalBlocks = 0

1381

self.nTotalBlocks = 0

1382

1383

self.profileIndex = 0

1383

self.profileIndex = 0

1384

1385

self.__isConfig = False

1385

self.isConfig = False

1386

1387

self.fp = None

1387

self.fp = None

1388

1389

self.flagIsNewFile = 1

1389

self.flagIsNewFile = 1

1390

1391

self.nTotalBlocks = 0

1391

self.nTotalBlocks = 0

1392

1393

self.flagIsNewBlock = 0

1393

self.flagIsNewBlock = 0

1394

1395

self.flagNoMoreFiles = 0

1395

self.flagNoMoreFiles = 0

1396

1397

self.setFile = None

1397

self.setFile = None

1398

1399

self.dtype = None

1399

self.dtype = None

1400

1401

self.path = None

1401

self.path = None

1402

1403

self.noMoreFiles = 0

1403

self.noMoreFiles = 0

1404

1405

self.filename = None

1405

self.filename = None

1406

1407

self.basicHeaderObj = BasicHeader()

1407

self.basicHeaderObj = BasicHeader()

1408

1409

self.systemHeaderObj = SystemHeader()

1409

self.systemHeaderObj = SystemHeader()

1410

1411

self.radarControllerHeaderObj = RadarControllerHeader()

1411

self.radarControllerHeaderObj = RadarControllerHeader()

1412

1413

self.processingHeaderObj = ProcessingHeader()

1413

self.processingHeaderObj = ProcessingHeader()

1414

1415

def hasAllDataInBuffer(self):

1415

def hasAllDataInBuffer(self):

1416

if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:

1416

if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:

1417

return 1

1417

return 1

1418

return 0

1418

return 0

1419

1420

1421

def setBlockDimension(self):

1421

def setBlockDimension(self):

1422

"""

1422

"""

1423

Obtiene las formas dimensionales del los subbloques de datos que componen un bloque

1423

Obtiene las formas dimensionales del los subbloques de datos que componen un bloque

1424

1425

Affected:

1425

Affected:

1426

self.shape_spc_Buffer

1426

self.shape_spc_Buffer

1427

self.shape_cspc_Buffer

1427

self.shape_cspc_Buffer

1428

self.shape_dc_Buffer

1428

self.shape_dc_Buffer

1429

1430

Return: None

1430

Return: None

1431

"""

1431

"""

1432

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1432

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1433

self.processingHeaderObj.nHeights,

1433

self.processingHeaderObj.nHeights,

1434

self.systemHeaderObj.nChannels)

1434

self.systemHeaderObj.nChannels)

1435

1436

self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,

1436

self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,

1437

self.processingHeaderObj.profilesPerBlock,

1437

self.processingHeaderObj.profilesPerBlock,

1438

self.processingHeaderObj.nHeights),

1438

self.processingHeaderObj.nHeights),

1439

dtype=numpy.dtype('complex'))

1439

dtype=numpy.dtype('complex'))

1440

1441

1442

def writeBlock(self):

1442

def writeBlock(self):

1443

"""

1443

"""

1444

Escribe el buffer en el file designado

1444

Escribe el buffer en el file designado

1445

1446

Affected:

1446

Affected:

1447

self.profileIndex

1447

self.profileIndex

1448

self.flagIsNewFile

1448

self.flagIsNewFile

1449

self.flagIsNewBlock

1449

self.flagIsNewBlock

1450

self.nTotalBlocks

1450

self.nTotalBlocks

1451

self.blockIndex

1451

self.blockIndex

1452

1453

Return: None

1453

Return: None

1454

"""

1454

"""

1455

data = numpy.zeros( self.shapeBuffer, self.dtype )

1455

data = numpy.zeros( self.shapeBuffer, self.dtype )

1456

1457

junk = numpy.transpose(self.datablock, (1,2,0))

1457

junk = numpy.transpose(self.datablock, (1,2,0))

1458

1459

data['real'] = junk.real

1459

data['real'] = junk.real

1460

data['imag'] = junk.imag

1460

data['imag'] = junk.imag

1461

1462

data = data.reshape( (-1) )

1462

data = data.reshape( (-1) )

1463

1464

data.tofile( self.fp )

1464

data.tofile( self.fp )

1465

1466

self.datablock.fill(0)

1466

self.datablock.fill(0)

1467

1468

self.profileIndex = 0

1468

self.profileIndex = 0

1469

self.flagIsNewFile = 0

1469

self.flagIsNewFile = 0

1470

self.flagIsNewBlock = 1

1470

self.flagIsNewBlock = 1

1471

1472

self.blockIndex += 1

1472

self.blockIndex += 1

1473

self.nTotalBlocks += 1

1473

self.nTotalBlocks += 1

1474

1475

def putData(self):

1475

def putData(self):

1476

"""

1476

"""

1477

Setea un bloque de datos y luego los escribe en un file

1477

Setea un bloque de datos y luego los escribe en un file

1478

1479

Affected:

1479

Affected:

1480

self.flagIsNewBlock

1480

self.flagIsNewBlock

1481

self.profileIndex

1481

self.profileIndex

1482

1483

Return:

1483

Return:

1484

0 : Si no hay data o no hay mas files que puedan escribirse

1484

0 : Si no hay data o no hay mas files que puedan escribirse

1485

1 : Si se escribio la data de un bloque en un file

1485

1 : Si se escribio la data de un bloque en un file

1486

"""

1486

"""

1487

if self.dataOut~~Obj~~.flagNoData:

1487

if self.dataOut.flagNoData:

1488

return 0

1488

return 0

1489

1490

self.flagIsNewBlock = 0

1490

self.flagIsNewBlock = 0

1491

1492

if self.dataOut~~Obj~~.flagTimeBlock:

1492

if self.dataOut.flagTimeBlock:

1493

1494

self.datablock.fill(0)

1494

self.datablock.fill(0)

1495

self.profileIndex = 0

1495

self.profileIndex = 0

1496

self.setNextFile()

1496

self.setNextFile()

1497

1498

if self.profileIndex == 0:

1498

if self.profileIndex == 0:

1499

self.getBasicHeader()

1499

self.getBasicHeader()

1500

1501

self.datablock[:,self.profileIndex,:] = self.dataOut~~Obj~~.data

1501

self.datablock[:,self.profileIndex,:] = self.dataOut.data

1502

1503

self.profileIndex += 1

1503

self.profileIndex += 1

1504

1505

if self.hasAllDataInBuffer():

1505

if self.hasAllDataInBuffer():

1506

#if self.flagIsNewFile:

1506

#if self.flagIsNewFile:

1507

self.writeNextBlock()

1507

self.writeNextBlock()

1508

# self.getDataHeader()

1508

# self.getDataHeader()

1509

1510

if self.flagNoMoreFiles:

1510

if self.flagNoMoreFiles:

1511

#print 'Process finished'

1511

#print 'Process finished'

1512

return 0

1512

return 0

1513

1514

return 1

1514

return 1

1515

1516

def __getProcessFlags(self):

1516

def __getProcessFlags(self):

1517

1518

processFlags = 0

1518

processFlags = 0

1519

1520

dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])

1520

dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])

1521

dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])

1521

dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])

1522

dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])

1522

dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])

1523

dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])

1523

dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])

1524

dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])

1524

dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])

1525

dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])

1525

dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])

1526

1527

dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]

1527

dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]

1528

1529

1530

1531

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1531

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1532

PROCFLAG.DATATYPE_SHORT,

1532

PROCFLAG.DATATYPE_SHORT,

1533

PROCFLAG.DATATYPE_LONG,

1533

PROCFLAG.DATATYPE_LONG,

1534

PROCFLAG.DATATYPE_INT64,

1534

PROCFLAG.DATATYPE_INT64,

1535

PROCFLAG.DATATYPE_FLOAT,

1535

PROCFLAG.DATATYPE_FLOAT,

1536

PROCFLAG.DATATYPE_DOUBLE]

1536

PROCFLAG.DATATYPE_DOUBLE]

1537

1538

1539

for index in range(len(dtypeList)):

1539

for index in range(len(dtypeList)):

1540

if self.dataOut~~Obj~~.dtype == dtypeList[index]:

1540

if self.dataOut.dtype == dtypeList[index]:

1541

dtypeValue = datatypeValueList[index]

1541

dtypeValue = datatypeValueList[index]

1542

break

1542

break

1543

1544

processFlags += dtypeValue

1544

processFlags += dtypeValue

1545

1546

if self.dataOut~~Obj~~.flagDecodeData:

1546

if self.dataOut.flagDecodeData:

1547

processFlags += PROCFLAG.DECODE_DATA

1547

processFlags += PROCFLAG.DECODE_DATA

1548

1549

if self.dataOut~~Obj~~.flagDeflipData:

1549

if self.dataOut.flagDeflipData:

1550

processFlags += PROCFLAG.DEFLIP_DATA

1550

processFlags += PROCFLAG.DEFLIP_DATA

1551

1552

if self.dataOut~~Obj~~.code != None:

1552

if self.dataOut.code != None:

1553

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1553

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1554

1555

if self.dataOut~~Obj~~.nCohInt > 1:

1555

if self.dataOut.nCohInt > 1:

1556

processFlags += PROCFLAG.COHERENT_INTEGRATION

1556

processFlags += PROCFLAG.COHERENT_INTEGRATION

1557

1558

return processFlags

1558

return processFlags

1559

1560

1561

def __getBlockSize(self):

1561

def __getBlockSize(self):

1562

'''

1562

'''

1563

Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage

1563

Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage

1564

'''

1564

'''

1565

1566

dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])

1566

dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])

1567

dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])

1567

dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])

1568

dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])

1568

dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])

1569

dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])

1569

dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])

1570

dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])

1570

dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])

1571

dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])

1571

dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])

1572

1573

dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]

1573

dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]

1574

datatypeValueList = [1,2,4,8,4,8]

1574

datatypeValueList = [1,2,4,8,4,8]

1575

for index in range(len(dtypeList)):

1575

for index in range(len(dtypeList)):

1576

if self.dataOut~~Obj~~.dtype == dtypeList[index]:

1576

if self.dataOut.dtype == dtypeList[index]:

1577

datatypeValue = datatypeValueList[index]

1577

datatypeValue = datatypeValueList[index]

1578

break

1578

break

1579

1580

blocksize = int(self.dataOut~~Obj~~.nHeights * self.dataOut~~Obj~~.nChannels * self.dataOut~~Obj~~.nProfiles * datatypeValue * 2)

1580

blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels * self.dataOut.nProfiles * datatypeValue * 2)

1581

1582

return blocksize

1582

return blocksize

1583

1584

def getDataHeader(self):

1584

def getDataHeader(self):

1585

1586

"""

1586

"""

1587

Obtiene una copia del First Header

1587

Obtiene una copia del First Header

1588

1589

Affected:

1589

Affected:

1590

self.systemHeaderObj

1590

self.systemHeaderObj

1591

self.radarControllerHeaderObj

1591

self.radarControllerHeaderObj

1592

self.dtype

1592

self.dtype

1593

1594

Return:

1594

Return:

1595

None

1595

None

1596

"""

1596

"""

1597

1598

self.systemHeaderObj = self.dataOut~~Obj~~.systemHeaderObj.copy()

1598

self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()

1599

self.systemHeaderObj.nChannels = self.dataOut~~Obj~~.nChannels

1599

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1600

self.radarControllerHeaderObj = self.dataOut~~Obj~~.radarControllerHeaderObj.copy()

1600

self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()

1601

1602

self.getBasicHeader()

1602

self.getBasicHeader()

1603

1604

processingHeaderSize = 40 # bytes

1604

processingHeaderSize = 40 # bytes

1605

self.processingHeaderObj.dtype = 0 # Voltage

1605

self.processingHeaderObj.dtype = 0 # Voltage

1606

self.processingHeaderObj.blockSize = self.__getBlockSize()

1606

self.processingHeaderObj.blockSize = self.__getBlockSize()

1607

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1607

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1608

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1608

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1609

self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut~~Obj~~.processingHeaderObj.nWindows

1609

self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows

1610

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1610

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1611

self.processingHeaderObj.nCohInt = self.dataOut~~Obj~~.nCohInt

1611

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1612

self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage

1612

self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage

1613

self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage

1613

self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage

1614

1615

if self.dataOut~~Obj~~.code != None:

1615

if self.dataOut.code != None:

1616

self.processingHeaderObj.code = self.dataOut~~Obj~~.code

1616

self.processingHeaderObj.code = self.dataOut.code

1617

self.processingHeaderObj.nCode = self.dataOut~~Obj~~.nCode

1617

self.processingHeaderObj.nCode = self.dataOut.nCode

1618

self.processingHeaderObj.nBaud = self.dataOut~~Obj~~.nBaud

1618

self.processingHeaderObj.nBaud = self.dataOut.nBaud

1619

codesize = int(8 + 4 * self.dataOut~~Obj~~.nCode * self.dataOut~~Obj~~.nBaud)

1619

codesize = int(8 + 4 * self.dataOut.nCode * self.dataOut.nBaud)

1620

processingHeaderSize += codesize

1620

processingHeaderSize += codesize

1621

1622

if self.processingHeaderObj.nWindows != 0:

1622

if self.processingHeaderObj.nWindows != 0:

1623

self.processingHeaderObj.firstHeight = self.dataOut~~Obj~~.heightList[0]

1623

self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]

1624

self.processingHeaderObj.deltaHeight = self.dataOut~~Obj~~.heightList[1] - self.dataOut~~Obj~~.heightList[0]

1624

self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]

1625

self.processingHeaderObj.nHeights = self.dataOut~~Obj~~.nHeights

1625

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1626

self.processingHeaderObj.samplesWin = self.dataOut~~Obj~~.nHeights

1626

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1627

processingHeaderSize += 12

1627

processingHeaderSize += 12

1628

1629

self.processingHeaderObj.size = processingHeaderSize

1629

self.processingHeaderObj.size = processingHeaderSize

1630

1631

class SpectraReader(JRODataReader):

1631

class SpectraReader(JRODataReader):

1632

"""

1632

"""

1633

Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura

1633

Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura

1634

de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)

1634

de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)

1635

son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.

1635

son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.

1636

1637

paresCanalesIguales * alturas * perfiles (Self Spectra)

1637

paresCanalesIguales * alturas * perfiles (Self Spectra)

1638

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1638

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1639

canales * alturas (DC Channels)

1639

canales * alturas (DC Channels)

1640

1641

Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,

1641

Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,

1642

RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la

1642

RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la

1643

cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de

1643

cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de

1644

datos desde el "buffer" cada vez que se ejecute el metodo "getData".

1644

datos desde el "buffer" cada vez que se ejecute el metodo "getData".

1645

1646

Example:

1646

Example:

1647

dpath = "/home/myuser/data"

1647

dpath = "/home/myuser/data"

1648

1649

startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)

1649

startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)

1650

1651

endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)

1651

endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)

1652

1653

readerObj = SpectraReader()

1653

readerObj = SpectraReader()

1654

1655

readerObj.setup(dpath, startTime, endTime)

1655

readerObj.setup(dpath, startTime, endTime)

1656

1657

while(True):

1657

while(True):

1658

1659

readerObj.getData()

1659

readerObj.getData()

1660

1661

print readerObj.data_spc

1661

print readerObj.data_spc

1662

1663

print readerObj.data_cspc

1663

print readerObj.data_cspc

1664

1665

print readerObj.data_dc

1665

print readerObj.data_dc

1666

1667

if readerObj.flagNoMoreFiles:

1667

if readerObj.flagNoMoreFiles:

1668

break

1668

break

1669

1670

"""

1670

"""

1671

1672

pts2read_SelfSpectra = 0

1672

pts2read_SelfSpectra = 0

1673

1674

pts2read_CrossSpectra = 0

1674

pts2read_CrossSpectra = 0

1675

1676

pts2read_DCchannels = 0

1676

pts2read_DCchannels = 0

1677

1678

ext = ".pdata"

1678

ext = ".pdata"

1679

1680

optchar = "P"

1680

optchar = "P"

1681

1682

dataOut~~Obj~~ = None

1682

dataOut = None

1683

1684

nRdChannels = None

1684

nRdChannels = None

1685

1686

nRdPairs = None

1686

nRdPairs = None

1687

1688

rdPairList = []

1688

rdPairList = []

1689

1690

1691

def __init__(self, dataOut~~Obj~~=None):

1691

def __init__(self, dataOut=None):

1692

"""

1692

"""

1693

Inicializador de la clase SpectraReader para la lectura de datos de espectros.

1693

Inicializador de la clase SpectraReader para la lectura de datos de espectros.

1694

1695

Inputs:

1695

Inputs:

1696

dataOut~~Obj~~ : Objeto de la clase Spectra. Este objeto sera utilizado para

1696

dataOut : Objeto de la clase Spectra. Este objeto sera utilizado para

1697

almacenar un perfil de datos cada vez que se haga un requerimiento

1697

almacenar un perfil de datos cada vez que se haga un requerimiento

1698

(getData). El perfil sera obtenido a partir del buffer de datos,

1698

(getData). El perfil sera obtenido a partir del buffer de datos,

1699

si el buffer esta vacio se hara un nuevo proceso de lectura de un

1699

si el buffer esta vacio se hara un nuevo proceso de lectura de un

1700

bloque de datos.

1700

bloque de datos.

1701

Si este parametro no es pasado se creara uno internamente.

1701

Si este parametro no es pasado se creara uno internamente.

1702

1703

Affected:

1703

Affected:

1704

self.dataOut~~Obj~~

1704

self.dataOut

1705

1706

Return : None

1706

Return : None

1707

"""

1707

"""

1708

1709

self.__isConfig = False

1709

self.isConfig = False

1710

1711

self.pts2read_SelfSpectra = 0

1711

self.pts2read_SelfSpectra = 0

1712

1713

self.pts2read_CrossSpectra = 0

1713

self.pts2read_CrossSpectra = 0

1714

1715

self.pts2read_DCchannels = 0

1715

self.pts2read_DCchannels = 0

1716

1717

self.datablock = None

1717

self.datablock = None

1718

1719

self.utc = None

1719

self.utc = None

1720

1721

self.ext = ".pdata"

1721

self.ext = ".pdata"

1722

1723

self.optchar = "P"

1723

self.optchar = "P"

1724

1725

self.basicHeaderObj = BasicHeader()

1725

self.basicHeaderObj = BasicHeader()

1726

1727

self.systemHeaderObj = SystemHeader()

1727

self.systemHeaderObj = SystemHeader()

1728

1729

self.radarControllerHeaderObj = RadarControllerHeader()

1729

self.radarControllerHeaderObj = RadarControllerHeader()

1730

1731

self.processingHeaderObj = ProcessingHeader()

1731

self.processingHeaderObj = ProcessingHeader()

1732

1733

self.online = 0

1733

self.online = 0

1734

1735

self.fp = None

1735

self.fp = None

1736

1737

self.idFile = None

1737

self.idFile = None

1738

1739

self.dtype = None

1739

self.dtype = None

1740

1741

self.fileSizeByHeader = None

1741

self.fileSizeByHeader = None

1742

1743

self.filenameList = []

1743

self.filenameList = []

1744

1745

self.filename = None

1745

self.filename = None

1746

1747

self.fileSize = None

1747

self.fileSize = None

1748

1749

self.firstHeaderSize = 0

1749

self.firstHeaderSize = 0

1750

1751

self.basicHeaderSize = 24

1751

self.basicHeaderSize = 24

1752

1753

self.pathList = []

1753

self.pathList = []

1754

1755

self.lastUTTime = 0

1755

self.lastUTTime = 0

1756

1757

self.maxTimeStep = 30

1757

self.maxTimeStep = 30

1758

1759

self.flagNoMoreFiles = 0

1759

self.flagNoMoreFiles = 0

1760

1761

self.set = 0

1761

self.set = 0

1762

1763

self.path = None

1763

self.path = None

1764

1765

self.delay = 3 #seconds

1765

self.delay = 3 #seconds

1766

1767

self.nTries = 3 #quantity tries

1767

self.nTries = 3 #quantity tries

1768

1769

self.nFiles = 3 #number of files for searching

1769

self.nFiles = 3 #number of files for searching

1770

1771

self.nReadBlocks = 0

1771

self.nReadBlocks = 0

1772

1773

self.flagIsNewFile = 1

1773

self.flagIsNewFile = 1

1774

1775

self.ippSeconds = 0

1775

self.ippSeconds = 0

1776

1777

self.flagTimeBlock = 0

1777

self.flagTimeBlock = 0

1778

1779

self.flagIsNewBlock = 0

1779

self.flagIsNewBlock = 0

1780

1781

self.nTotalBlocks = 0

1781

self.nTotalBlocks = 0

1782

1783

self.blocksize = 0

1783

self.blocksize = 0

1784

1785

1786

def createObjByDefault(self):

1786

def createObjByDefault(self):

1787

1788

dataObj = Spectra()

1788

dataObj = Spectra()

1789

1790

return dataObj

1790

return dataObj

1791

1792

def __hasNotDataInBuffer(self):

1792

def __hasNotDataInBuffer(self):

1793

return 1

1793

return 1

1794

1795

1796

def getBlockDimension(self):

1796

def getBlockDimension(self):

1797

"""

1797

"""

1798

Obtiene la cantidad de puntos a leer por cada bloque de datos

1798

Obtiene la cantidad de puntos a leer por cada bloque de datos

1799

1800

Affected:

1800

Affected:

1801

self.nRdChannels

1801

self.nRdChannels

1802

self.nRdPairs

1802

self.nRdPairs

1803

self.pts2read_SelfSpectra

1803

self.pts2read_SelfSpectra

1804

self.pts2read_CrossSpectra

1804

self.pts2read_CrossSpectra

1805

self.pts2read_DCchannels

1805

self.pts2read_DCchannels

1806

self.blocksize

1806

self.blocksize

1807

self.dataOut~~Obj~~.nChannels

1807

self.dataOut.nChannels

1808

self.dataOut~~Obj~~.nPairs

1808

self.dataOut.nPairs

1809

1810

Return:

1810

Return:

1811

None

1811

None

1812

"""

1812

"""

1813

self.nRdChannels = 0

1813

self.nRdChannels = 0

1814

self.nRdPairs = 0

1814

self.nRdPairs = 0

1815

self.rdPairList = []

1815

self.rdPairList = []

1816

1817

for i in range(0, self.processingHeaderObj.totalSpectra*2, 2):

1817

for i in range(0, self.processingHeaderObj.totalSpectra*2, 2):

1818

if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:

1818

if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:

1819

self.nRdChannels = self.nRdChannels + 1 #par de canales iguales

1819

self.nRdChannels = self.nRdChannels + 1 #par de canales iguales

1820

else:

1820

else:

1821

self.nRdPairs = self.nRdPairs + 1 #par de canales diferentes

1821

self.nRdPairs = self.nRdPairs + 1 #par de canales diferentes

1822

self.rdPairList.append((self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]))

1822

self.rdPairList.append((self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]))

1823

1824

pts2read = self.processingHeaderObj.nHeights * self.processingHeaderObj.profilesPerBlock

1824

pts2read = self.processingHeaderObj.nHeights * self.processingHeaderObj.profilesPerBlock

1825

1826

self.pts2read_SelfSpectra = int(self.nRdChannels * pts2read)

1826

self.pts2read_SelfSpectra = int(self.nRdChannels * pts2read)

1827

self.blocksize = self.pts2read_SelfSpectra

1827

self.blocksize = self.pts2read_SelfSpectra

1828

1829

if self.processingHeaderObj.flag_cspc:

1829

if self.processingHeaderObj.flag_cspc:

1830

self.pts2read_CrossSpectra = int(self.nRdPairs * pts2read)

1830

self.pts2read_CrossSpectra = int(self.nRdPairs * pts2read)

1831

self.blocksize += self.pts2read_CrossSpectra

1831

self.blocksize += self.pts2read_CrossSpectra

1832

1833

if self.processingHeaderObj.flag_dc:

1833

if self.processingHeaderObj.flag_dc:

1834

self.pts2read_DCchannels = int(self.systemHeaderObj.nChannels * self.processingHeaderObj.nHeights)

1834

self.pts2read_DCchannels = int(self.systemHeaderObj.nChannels * self.processingHeaderObj.nHeights)

1835

self.blocksize += self.pts2read_DCchannels

1835

self.blocksize += self.pts2read_DCchannels

1836

1837

# self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels

1837

# self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels

1838

1839

1840

def readBlock(self):

1840

def readBlock(self):

1841

"""

1841

"""

1842

Lee el bloque de datos desde la posicion actual del puntero del archivo

1842

Lee el bloque de datos desde la posicion actual del puntero del archivo

1843

(self.fp) y actualiza todos los parametros relacionados al bloque de datos

1843

(self.fp) y actualiza todos los parametros relacionados al bloque de datos

1844

(metadata + data). La data leida es almacenada en el buffer y el contador del buffer

1844

(metadata + data). La data leida es almacenada en el buffer y el contador del buffer

1845

es seteado a 0

1845

es seteado a 0

1846

1847

Return: None

1847

Return: None

1848

1849

Variables afectadas:

1849

Variables afectadas:

1850

1851

self.flagIsNewFile

1851

self.flagIsNewFile

1852

self.flagIsNewBlock

1852

self.flagIsNewBlock

1853

self.nTotalBlocks

1853

self.nTotalBlocks

1854

self.data_spc

1854

self.data_spc

1855

self.data_cspc

1855

self.data_cspc

1856

self.data_dc

1856

self.data_dc

1857

1858

Exceptions:

1858

Exceptions:

1859

Si un bloque leido no es un bloque valido

1859

Si un bloque leido no es un bloque valido

1860

"""

1860

"""

1861

blockOk_flag = False

1861

blockOk_flag = False

1862

fpointer = self.fp.tell()

1862

fpointer = self.fp.tell()

1863

1864

spc = numpy.fromfile( self.fp, self.dtype[0], self.pts2read_SelfSpectra )

1864

spc = numpy.fromfile( self.fp, self.dtype[0], self.pts2read_SelfSpectra )

1865

spc = spc.reshape( (self.nRdChannels, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D

1865

spc = spc.reshape( (self.nRdChannels, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D

1866

1867

if self.processingHeaderObj.flag_cspc:

1867

if self.processingHeaderObj.flag_cspc:

1868

cspc = numpy.fromfile( self.fp, self.dtype, self.pts2read_CrossSpectra )

1868

cspc = numpy.fromfile( self.fp, self.dtype, self.pts2read_CrossSpectra )

1869

cspc = cspc.reshape( (self.nRdPairs, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D

1869

cspc = cspc.reshape( (self.nRdPairs, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D

1870

1871

if self.processingHeaderObj.flag_dc:

1871

if self.processingHeaderObj.flag_dc:

1872

dc = numpy.fromfile( self.fp, self.dtype, self.pts2read_DCchannels ) #int(self.processingHeaderObj.nHeights*self.systemHeaderObj.nChannels) )

1872

dc = numpy.fromfile( self.fp, self.dtype, self.pts2read_DCchannels ) #int(self.processingHeaderObj.nHeights*self.systemHeaderObj.nChannels) )

1873

dc = dc.reshape( (self.systemHeaderObj.nChannels, self.processingHeaderObj.nHeights) ) #transforma a un arreglo 2D

1873

dc = dc.reshape( (self.systemHeaderObj.nChannels, self.processingHeaderObj.nHeights) ) #transforma a un arreglo 2D

1874

1875

1876

if not(self.processingHeaderObj.shif_fft):

1876

if not(self.processingHeaderObj.shif_fft):

1877

spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones

1877

spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones

1878

1879

if self.processingHeaderObj.flag_cspc:

1879

if self.processingHeaderObj.flag_cspc:

1880

cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones

1880

cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones

1881

1882

1883

spc = numpy.transpose( spc, (0,2,1) )

1883

spc = numpy.transpose( spc, (0,2,1) )

1884

self.data_spc = spc

1884

self.data_spc = spc

1885

1886

if self.processingHeaderObj.flag_cspc:

1886

if self.processingHeaderObj.flag_cspc:

1887

cspc = numpy.transpose( cspc, (0,2,1) )

1887

cspc = numpy.transpose( cspc, (0,2,1) )

1888

self.data_cspc = cspc['real'] + cspc['imag']*1j

1888

self.data_cspc = cspc['real'] + cspc['imag']*1j

1889

else:

1889

else:

1890

self.data_cspc = None

1890

self.data_cspc = None

1891

1892

if self.processingHeaderObj.flag_dc:

1892

if self.processingHeaderObj.flag_dc:

1893

self.data_dc = dc['real'] + dc['imag']*1j

1893

self.data_dc = dc['real'] + dc['imag']*1j

1894

else:

1894

else:

1895

self.data_dc = None

1895

self.data_dc = None

1896

1897

self.flagIsNewFile = 0

1897

self.flagIsNewFile = 0

1898

self.flagIsNewBlock = 1

1898

self.flagIsNewBlock = 1

1899

1900

self.nTotalBlocks += 1

1900

self.nTotalBlocks += 1

1901

self.nReadBlocks += 1

1901

self.nReadBlocks += 1

1902

1903

return 1

1903

return 1

1904

1905

1906

def getData(self):

1906

def getData(self):

1907

"""

1907

"""

1908

Copia el buffer de lectura a la clase "Spectra",

1908

Copia el buffer de lectura a la clase "Spectra",

1909

con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de

1909

con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de

1910

lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"

1910

lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"

1911

1912

Return:

1912

Return:

1913

0 : Si no hay mas archivos disponibles

1913

0 : Si no hay mas archivos disponibles

1914

1 : Si hizo una buena copia del buffer

1914

1 : Si hizo una buena copia del buffer

1915

1916

Affected:

1916

Affected:

1917

self.dataOut~~Obj~~

1917

self.dataOut

1918

1919

self.flagTimeBlock

1919

self.flagTimeBlock

1920

self.flagIsNewBlock

1920

self.flagIsNewBlock

1921

"""

1921

"""

1922

1923

if self.flagNoMoreFiles: return 0

1923

if self.flagNoMoreFiles: return 0

1924

1925

self.flagTimeBlock = 0

1925

self.flagTimeBlock = 0

1926

self.flagIsNewBlock = 0

1926

self.flagIsNewBlock = 0

1927

1928

if self.__hasNotDataInBuffer():

1928

if self.__hasNotDataInBuffer():

1929

1930

if not( self.readNextBlock() ):

1930

if not( self.readNextBlock() ):

1931

return 0

1931

return 0

1932

1933

# self.updateDataHeader()

1933

# self.updateDataHeader()

1934

1935

if self.flagNoMoreFiles == 1:

1935

if self.flagNoMoreFiles == 1:

1936

print 'Process finished'

1936

print 'Process finished'

1937

return 0

1937

return 0

1938

1939

#data es un numpy array de 3 dmensiones (perfiles, alturas y canales)

1939

#data es un numpy array de 3 dmensiones (perfiles, alturas y canales)

1940

1941

if self.data_dc == None:

1941

if self.data_dc == None:

1942

self.dataOut~~Obj~~.flagNoData = True

1942

self.dataOut.flagNoData = True

1943

return 0

1943

return 0

1944

1945

1946

self.dataOut~~Obj~~.data_spc = self.data_spc

1946

self.dataOut.data_spc = self.data_spc

1947

1948

self.dataOut~~Obj~~.data_cspc = self.data_cspc

1948

self.dataOut.data_cspc = self.data_cspc

1949

1950

self.dataOut~~Obj~~.data_dc = self.data_dc

1950

self.dataOut.data_dc = self.data_dc

1951

1952

self.dataOut~~Obj~~.flagTimeBlock = self.flagTimeBlock

1952

self.dataOut.flagTimeBlock = self.flagTimeBlock

1953

1954

self.dataOut~~Obj~~.flagNoData = False

1954

self.dataOut.flagNoData = False

1955

1956

self.dataOut~~Obj~~.dtype = self.dtype

1956

self.dataOut.dtype = self.dtype

1957

1958

self.dataOut~~Obj~~.nChannels = self.nRdChannels

1958

self.dataOut.nChannels = self.nRdChannels

1959

1960

self.dataOut~~Obj~~.nPairs = self.nRdPairs

1960

self.dataOut.nPairs = self.nRdPairs

1961

1962

self.dataOut~~Obj~~.pairsList = self.rdPairList

1962

self.dataOut.pairsList = self.rdPairList

1963

1964

self.dataOut~~Obj~~.nHeights = self.processingHeaderObj.nHeights

1964

self.dataOut.nHeights = self.processingHeaderObj.nHeights

1965

1966

self.dataOut~~Obj~~.nProfiles = self.processingHeaderObj.profilesPerBlock

1966

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1967

1968

self.dataOut~~Obj~~.nFFTPoints = self.processingHeaderObj.profilesPerBlock

1968

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

1969

1970

self.dataOut~~Obj~~.nIncohInt = self.processingHeaderObj.nIncohInt

1970

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

1971

1972

1973

xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight

1973

xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight

1974

1975

self.dataOut~~Obj~~.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)

1975

self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)

1976

1977

self.dataOut~~Obj~~.channelList = range(self.systemHeaderObj.nChannels)

1977

self.dataOut.channelList = range(self.systemHeaderObj.nChannels)

1978

1979

self.dataOut~~Obj~~.channelIndexList = range(self.systemHeaderObj.nChannels)

1979

self.dataOut.channelIndexList = range(self.systemHeaderObj.nChannels)

1980

1981

self.dataOut~~Obj~~.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000.#+ self.profileIndex * self.ippSeconds

1981

self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000.#+ self.profileIndex * self.ippSeconds

1982

1983

self.dataOut~~Obj~~.ippSeconds = self.ippSeconds

1983

self.dataOut.ippSeconds = self.ippSeconds

1984

1985

self.dataOut~~Obj~~.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.dataOut~~Obj~~.nFFTPoints

1985

self.dataOut.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.dataOut.nFFTPoints

1986

1987

self.dataOut~~Obj~~.flagShiftFFT = self.processingHeaderObj.shif_fft

1987

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

1988

1989

# self.profileIndex += 1

1989

# self.profileIndex += 1

1990

1991

self.dataOut~~Obj~~.systemHeaderObj = self.systemHeaderObj.copy()

1991

self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()

1992

1993

self.dataOut~~Obj~~.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()

1993

self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()

1994

1995

return self.dataOut~~Obj~~.data_spc

1995

return self.dataOut.data_spc

1996

1997

1998

class SpectraWriter(JRODataWriter):

1998

class SpectraWriter(JRODataWriter):

1999

2000

"""

2000

"""

2001

Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura

2001

Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura

2002

de los datos siempre se realiza por bloques.

2002

de los datos siempre se realiza por bloques.

2003

"""

2003

"""

2004

2005

ext = ".pdata"

2005

ext = ".pdata"

2006

2007

optchar = "P"

2007

optchar = "P"

2008

2009

shape_spc_Buffer = None

2009

shape_spc_Buffer = None

2010

2011

shape_cspc_Buffer = None

2011

shape_cspc_Buffer = None

2012

2013

shape_dc_Buffer = None

2013

shape_dc_Buffer = None

2014

2015

data_spc = None

2015

data_spc = None

2016

2017

data_cspc = None

2017

data_cspc = None

2018

2019

data_dc = None

2019

data_dc = None

2020

2021

# dataOut~~Obj~~ = None

2021

# dataOut = None

2022

2023

def __init__(self, dataOut~~Obj~~=None):

2023

def __init__(self, dataOut=None):

2024

"""

2024

"""

2025

Inicializador de la clase SpectraWriter para la escritura de datos de espectros.

2025

Inicializador de la clase SpectraWriter para la escritura de datos de espectros.

2026

2027

Affected:

2027

Affected:

2028

self.dataOut~~Obj~~

2028

self.dataOut

2029

self.basicHeaderObj

2029

self.basicHeaderObj

2030

self.systemHeaderObj

2030

self.systemHeaderObj

2031

self.radarControllerHeaderObj

2031

self.radarControllerHeaderObj

2032

self.processingHeaderObj

2032

self.processingHeaderObj

2033

2034

Return: None

2034

Return: None

2035

"""

2035

"""

2036

if dataOut~~Obj~~ == None:

2036

if dataOut == None:

2037

dataOut~~Obj~~ = Spectra()

2037

dataOut = Spectra()

2038

2039

if not( isinstance(dataOut~~Obj~~, Spectra) ):

2039

if not( isinstance(dataOut, Spectra) ):

2040

raise ValueError, "in SpectraReader, dataOut~~Obj~~ must be an Spectra class object"

2040

raise ValueError, "in SpectraReader, dataOut must be an Spectra class object"

2041

2042

self.dataOut~~Obj~~ = dataOut~~Obj~~

2042

self.dataOut = dataOut

2043

2044

self.__isConfig = False

2044

self.isConfig = False

2045

2046

self.nTotalBlocks = 0

2046

self.nTotalBlocks = 0

2047

2048

self.data_spc = None

2048

self.data_spc = None

2049

2050

self.data_cspc = None

2050

self.data_cspc = None

2051

2052

self.data_dc = None

2052

self.data_dc = None

2053

2054

self.fp = None

2054

self.fp = None

2055

2056

self.flagIsNewFile = 1

2056

self.flagIsNewFile = 1

2057

2058

self.nTotalBlocks = 0

2058

self.nTotalBlocks = 0

2059

2060

self.flagIsNewBlock = 0

2060

self.flagIsNewBlock = 0

2061

2062

self.flagNoMoreFiles = 0

2062

self.flagNoMoreFiles = 0

2063

2064

self.setFile = None

2064

self.setFile = None

2065

2066

self.dtype = None

2066

self.dtype = None

2067

2068

self.path = None

2068

self.path = None

2069

2070

self.noMoreFiles = 0

2070

self.noMoreFiles = 0

2071

2072

self.filename = None

2072

self.filename = None

2073

2074

self.basicHeaderObj = BasicHeader()

2074

self.basicHeaderObj = BasicHeader()

2075

2076

self.systemHeaderObj = SystemHeader()

2076

self.systemHeaderObj = SystemHeader()

2077

2078

self.radarControllerHeaderObj = RadarControllerHeader()

2078

self.radarControllerHeaderObj = RadarControllerHeader()

2079

2080

self.processingHeaderObj = ProcessingHeader()

2080

self.processingHeaderObj = ProcessingHeader()

2081

2082

2083

def hasAllDataInBuffer(self):

2083

def hasAllDataInBuffer(self):

2084

return 1

2084

return 1

2085

2086

2087

def setBlockDimension(self):

2087

def setBlockDimension(self):

2088

"""

2088

"""

2089

Obtiene las formas dimensionales del los subbloques de datos que componen un bloque

2089

Obtiene las formas dimensionales del los subbloques de datos que componen un bloque

2090

2091

Affected:

2091

Affected:

2092

self.shape_spc_Buffer

2092

self.shape_spc_Buffer

2093

self.shape_cspc_Buffer

2093

self.shape_cspc_Buffer

2094

self.shape_dc_Buffer

2094

self.shape_dc_Buffer

2095

2096

Return: None

2096

Return: None

2097

"""

2097

"""

2098

self.shape_spc_Buffer = (self.dataOut~~Obj~~.nChannels,

2098

self.shape_spc_Buffer = (self.dataOut.nChannels,

2099

self.processingHeaderObj.nHeights,

2099

self.processingHeaderObj.nHeights,

2100

self.processingHeaderObj.profilesPerBlock)

2100

self.processingHeaderObj.profilesPerBlock)

2101

2102

self.shape_cspc_Buffer = (self.dataOut~~Obj~~.nPairs,

2102

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2103

self.processingHeaderObj.nHeights,

2103

self.processingHeaderObj.nHeights,

2104

self.processingHeaderObj.profilesPerBlock)

2104

self.processingHeaderObj.profilesPerBlock)

2105

2106

self.shape_dc_Buffer = (self.dataOut~~Obj~~.nChannels,

2106

self.shape_dc_Buffer = (self.dataOut.nChannels,

2107

self.processingHeaderObj.nHeights)

2107

self.processingHeaderObj.nHeights)

2108

2109

2110

def writeBlock(self):

2110

def writeBlock(self):

2111

"""

2111

"""

2112

Escribe el buffer en el file designado

2112

Escribe el buffer en el file designado

2113

2114

Affected:

2114

Affected:

2115

self.data_spc

2115

self.data_spc

2116

self.data_cspc

2116

self.data_cspc

2117

self.data_dc

2117

self.data_dc

2118

self.flagIsNewFile

2118

self.flagIsNewFile

2119

self.flagIsNewBlock

2119

self.flagIsNewBlock

2120

self.nTotalBlocks

2120

self.nTotalBlocks

2121

self.nWriteBlocks

2121

self.nWriteBlocks

2122

2123

Return: None

2123

Return: None

2124

"""

2124

"""

2125

2126

spc = numpy.transpose( self.data_spc, (0,2,1) )

2126

spc = numpy.transpose( self.data_spc, (0,2,1) )

2127

if not( self.processingHeaderObj.shif_fft ):

2127

if not( self.processingHeaderObj.shif_fft ):

2128

spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones

2128

spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones

2129

data = spc.reshape((-1))

2129

data = spc.reshape((-1))

2130

data.tofile(self.fp)

2130

data.tofile(self.fp)

2131

2132

if self.data_cspc != None:

2132

if self.data_cspc != None:

2133

data = numpy.zeros( self.shape_cspc_Buffer, self.dtype )

2133

data = numpy.zeros( self.shape_cspc_Buffer, self.dtype )

2134

cspc = numpy.transpose( self.data_cspc, (0,2,1) )

2134

cspc = numpy.transpose( self.data_cspc, (0,2,1) )

2135

if not( self.processingHeaderObj.shif_fft ):

2135

if not( self.processingHeaderObj.shif_fft ):

2136

cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones

2136

cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones

2137

data['real'] = cspc.real

2137

data['real'] = cspc.real

2138

data['imag'] = cspc.imag

2138

data['imag'] = cspc.imag

2139

data = data.reshape((-1))

2139

data = data.reshape((-1))

2140

data.tofile(self.fp)

2140

data.tofile(self.fp)

2141

2142

if self.data_dc != None:

2142

if self.data_dc != None:

2143

data = numpy.zeros( self.shape_dc_Buffer, self.dtype )

2143

data = numpy.zeros( self.shape_dc_Buffer, self.dtype )

2144

dc = self.data_dc

2144

dc = self.data_dc

2145

data['real'] = dc.real

2145

data['real'] = dc.real

2146

data['imag'] = dc.imag

2146

data['imag'] = dc.imag

2147

data = data.reshape((-1))

2147

data = data.reshape((-1))

2148

data.tofile(self.fp)

2148

data.tofile(self.fp)

2149

2150

self.data_spc.fill(0)

2150

self.data_spc.fill(0)

2151

self.data_dc.fill(0)

2151

self.data_dc.fill(0)

2152

if self.data_cspc != None:

2152

if self.data_cspc != None:

2153

self.data_cspc.fill(0)

2153

self.data_cspc.fill(0)

2154

2155

self.flagIsNewFile = 0

2155

self.flagIsNewFile = 0

2156

self.flagIsNewBlock = 1

2156

self.flagIsNewBlock = 1

2157

self.nTotalBlocks += 1

2157

self.nTotalBlocks += 1

2158

self.nWriteBlocks += 1

2158

self.nWriteBlocks += 1

2159

self.blockIndex += 1

2159

self.blockIndex += 1

2160

2161

2162

def putData(self):

2162

def putData(self):

2163

"""

2163

"""

2164

Setea un bloque de datos y luego los escribe en un file

2164

Setea un bloque de datos y luego los escribe en un file

2165

2166

Affected:

2166

Affected:

2167

self.data_spc

2167

self.data_spc

2168

self.data_cspc

2168

self.data_cspc

2169

self.data_dc

2169

self.data_dc

2170

2171

Return:

2171

Return:

2172

0 : Si no hay data o no hay mas files que puedan escribirse

2172

0 : Si no hay data o no hay mas files que puedan escribirse

2173

1 : Si se escribio la data de un bloque en un file

2173

1 : Si se escribio la data de un bloque en un file

2174

"""

2174

"""

2175

2176

if self.dataOut~~Obj~~.flagNoData:

2176

if self.dataOut.flagNoData:

2177

return 0

2177

return 0

2178

2179

self.flagIsNewBlock = 0

2179

self.flagIsNewBlock = 0

2180

2181

if self.dataOut~~Obj~~.flagTimeBlock:

2181

if self.dataOut.flagTimeBlock:

2182

self.data_spc.fill(0)

2182

self.data_spc.fill(0)

2183

self.data_cspc.fill(0)

2183

self.data_cspc.fill(0)

2184

self.data_dc.fill(0)

2184

self.data_dc.fill(0)

2185

self.setNextFile()

2185

self.setNextFile()

2186

2187

if self.flagIsNewFile == 0:

2187

if self.flagIsNewFile == 0:

2188

self.getBasicHeader()

2188

self.getBasicHeader()

2189

2190

self.data_spc = self.dataOut~~Obj~~.data_spc

2190

self.data_spc = self.dataOut.data_spc

2191

self.data_cspc = self.dataOut~~Obj~~.data_cspc

2191

self.data_cspc = self.dataOut.data_cspc

2192

self.data_dc = self.dataOut~~Obj~~.data_dc

2192

self.data_dc = self.dataOut.data_dc

2193

2194

# #self.processingHeaderObj.dataBlocksPerFile)

2194

# #self.processingHeaderObj.dataBlocksPerFile)

2195

if self.hasAllDataInBuffer():

2195

if self.hasAllDataInBuffer():

2196

# self.getDataHeader()

2196

# self.getDataHeader()

2197

self.writeNextBlock()

2197

self.writeNextBlock()

2198

2199

if self.flagNoMoreFiles:

2199

if self.flagNoMoreFiles:

2200

#print 'Process finished'

2200

#print 'Process finished'

2201

return 0

2201

return 0

2202

2203

return 1

2203

return 1

2204

2205

2206

def __getProcessFlags(self):

2206

def __getProcessFlags(self):

2207

2208

processFlags = 0

2208

processFlags = 0

2209

2210

dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])

2210

dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])

2211

dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])

2211

dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])

2212

dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])

2212

dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])

2213

dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])

2213

dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])

2214

dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])

2214

dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])

2215

dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])

2215

dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])

2216

2217

dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]

2217

dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]

2218

2219

2220

2221

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2221

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2222

PROCFLAG.DATATYPE_SHORT,

2222

PROCFLAG.DATATYPE_SHORT,

2223

PROCFLAG.DATATYPE_LONG,

2223

PROCFLAG.DATATYPE_LONG,

2224

PROCFLAG.DATATYPE_INT64,

2224

PROCFLAG.DATATYPE_INT64,

2225

PROCFLAG.DATATYPE_FLOAT,

2225

PROCFLAG.DATATYPE_FLOAT,

2226

PROCFLAG.DATATYPE_DOUBLE]

2226

PROCFLAG.DATATYPE_DOUBLE]

2227

2228

2229

for index in range(len(dtypeList)):

2229

for index in range(len(dtypeList)):

2230

if self.dataOut~~Obj~~.dtype == dtypeList[index]:

2230

if self.dataOut.dtype == dtypeList[index]:

2231

dtypeValue = datatypeValueList[index]

2231

dtypeValue = datatypeValueList[index]

2232

break

2232

break

2233

2234

processFlags += dtypeValue

2234

processFlags += dtypeValue

2235

2236

if self.dataOut~~Obj~~.flagDecodeData:

2236

if self.dataOut.flagDecodeData:

2237

processFlags += PROCFLAG.DECODE_DATA

2237

processFlags += PROCFLAG.DECODE_DATA

2238

2239

if self.dataOut~~Obj~~.flagDeflipData:

2239

if self.dataOut.flagDeflipData:

2240

processFlags += PROCFLAG.DEFLIP_DATA

2240

processFlags += PROCFLAG.DEFLIP_DATA

2241

2242

if self.dataOut~~Obj~~.code != None:

2242

if self.dataOut.code != None:

2243

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2243

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2244

2245

if self.dataOut~~Obj~~.nIncohInt > 1:

2245

if self.dataOut.nIncohInt > 1:

2246

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2246

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2247

2248

if self.dataOut~~Obj~~.data_dc != None:

2248

if self.dataOut.data_dc != None:

2249

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2249

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2250

2251

return processFlags

2251

return processFlags

2252

2253

2254

def __getBlockSize(self):

2254

def __getBlockSize(self):

2255

'''

2255

'''

2256

Este metodos determina el cantidad de bytes para un bloque de datos de tipo Spectra

2256

Este metodos determina el cantidad de bytes para un bloque de datos de tipo Spectra

2257

'''

2257

'''

2258

2259

dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])

2259

dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])

2260

dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])

2260

dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])

2261

dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])

2261

dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])

2262

dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])

2262

dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])

2263

dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])

2263

dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])

2264

dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])

2264

dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])

2265

2266

dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]

2266

dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]

2267

datatypeValueList = [1,2,4,8,4,8]

2267

datatypeValueList = [1,2,4,8,4,8]

2268

for index in range(len(dtypeList)):

2268

for index in range(len(dtypeList)):

2269

if self.dataOut~~Obj~~.dtype == dtypeList[index]:

2269

if self.dataOut.dtype == dtypeList[index]:

2270

datatypeValue = datatypeValueList[index]

2270

datatypeValue = datatypeValueList[index]

2271

break

2271

break

2272

2273

2274

pts2write = self.dataOut~~Obj~~.nHeights * self.dataOut~~Obj~~.nFFTPoints

2274

pts2write = self.dataOut.nHeights * self.dataOut.nFFTPoints

2275

2276

pts2write_SelfSpectra = int(self.dataOut~~Obj~~.nChannels * pts2write)

2276

pts2write_SelfSpectra = int(self.dataOut.nChannels * pts2write)

2277

blocksize = (pts2write_SelfSpectra*datatypeValue)

2277

blocksize = (pts2write_SelfSpectra*datatypeValue)

2278

2279

if self.dataOut~~Obj~~.data_cspc != None:

2279

if self.dataOut.data_cspc != None:

2280

pts2write_CrossSpectra = int(self.dataOut~~Obj~~.nPairs * pts2write)

2280

pts2write_CrossSpectra = int(self.dataOut.nPairs * pts2write)

2281

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2281

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2282

2283

if self.dataOut~~Obj~~.data_dc != None:

2283

if self.dataOut.data_dc != None:

2284

pts2write_DCchannels = int(self.dataOut~~Obj~~.nChannels * self.dataOut~~Obj~~.nHeights)

2284

pts2write_DCchannels = int(self.dataOut.nChannels * self.dataOut.nHeights)

2285

blocksize += (pts2write_DCchannels*datatypeValue*2)

2285

blocksize += (pts2write_DCchannels*datatypeValue*2)

2286

2287

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2287

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2288

2289

return blocksize

2289

return blocksize

2290

2291

def getDataHeader(self):

2291

def getDataHeader(self):

2292

2293

"""

2293

"""

2294

Obtiene una copia del First Header

2294

Obtiene una copia del First Header

2295

2296

Affected:

2296

Affected:

2297

self.systemHeaderObj

2297

self.systemHeaderObj

2298

self.radarControllerHeaderObj

2298

self.radarControllerHeaderObj

2299

self.dtype

2299

self.dtype

2300

2301

Return:

2301

Return:

2302

None

2302

None

2303

"""

2303

"""

2304

2305

self.systemHeaderObj = self.dataOut~~Obj~~.systemHeaderObj.copy()

2305

self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()

2306

self.systemHeaderObj.nChannels = self.dataOut~~Obj~~.nChannels

2306

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2307

self.radarControllerHeaderObj = self.dataOut~~Obj~~.radarControllerHeaderObj.copy()

2307

self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()

2308

2309

self.getBasicHeader()

2309

self.getBasicHeader()

2310

2311

processingHeaderSize = 40 # bytes

2311

processingHeaderSize = 40 # bytes

2312

self.processingHeaderObj.dtype = 0 # Voltage

2312

self.processingHeaderObj.dtype = 0 # Voltage

2313

self.processingHeaderObj.blockSize = self.__getBlockSize()

2313

self.processingHeaderObj.blockSize = self.__getBlockSize()

2314

self.processingHeaderObj.profilesPerBlock = self.dataOut~~Obj~~.nFFTPoints

2314

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2315

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2315

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2316

self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut~~Obj~~.processingHeaderObj.nWindows

2316

self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows

2317

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2317

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2318

self.processingHeaderObj.nCohInt = self.dataOut~~Obj~~.nCohInt# Se requiere para determinar el valor de timeInterval

2318

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt# Se requiere para determinar el valor de timeInterval

2319

self.processingHeaderObj.nIncohInt = self.dataOut~~Obj~~.nIncohInt

2319

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2320

self.processingHeaderObj.totalSpectra = self.dataOut~~Obj~~.nPairs + self.dataOut~~Obj~~.nChannels

2320

self.processingHeaderObj.totalSpectra = self.dataOut.nPairs + self.dataOut.nChannels

2321

2322

if self.processingHeaderObj.totalSpectra > 0:

2322

if self.processingHeaderObj.totalSpectra > 0:

2323

channelList = []

2323

channelList = []

2324

for channel in range(self.dataOut~~Obj~~.nChannels):

2324

for channel in range(self.dataOut.nChannels):

2325

channelList.append(channel)

2325

channelList.append(channel)

2326

channelList.append(channel)

2326

channelList.append(channel)

2327

2328

pairsList = []

2328

pairsList = []

2329

for pair in self.dataOut~~Obj~~.pairsList:

2329

for pair in self.dataOut.pairsList:

2330

pairsList.append(pair[0])

2330

pairsList.append(pair[0])

2331

pairsList.append(pair[1])

2331

pairsList.append(pair[1])

2332

spectraComb = channelList + pairsList

2332

spectraComb = channelList + pairsList

2333

spectraComb = numpy.array(spectraComb,dtype="u1")

2333

spectraComb = numpy.array(spectraComb,dtype="u1")

2334

self.processingHeaderObj.spectraComb = spectraComb

2334

self.processingHeaderObj.spectraComb = spectraComb

2335

sizeOfSpcComb = len(spectraComb)

2335

sizeOfSpcComb = len(spectraComb)

2336

processingHeaderSize += sizeOfSpcComb

2336

processingHeaderSize += sizeOfSpcComb

2337

2338

if self.dataOut~~Obj~~.code != None:

2338

if self.dataOut.code != None:

2339

self.processingHeaderObj.code = self.dataOut~~Obj~~.code

2339

self.processingHeaderObj.code = self.dataOut.code

2340

self.processingHeaderObj.nCode = self.dataOut~~Obj~~.nCode

2340

self.processingHeaderObj.nCode = self.dataOut.nCode

2341

self.processingHeaderObj.nBaud = self.dataOut~~Obj~~.nBaud

2341

self.processingHeaderObj.nBaud = self.dataOut.nBaud

2342

nCodeSize = 4 # bytes

2342

nCodeSize = 4 # bytes

2343

nBaudSize = 4 # bytes

2343

nBaudSize = 4 # bytes

2344

codeSize = 4 # bytes

2344

codeSize = 4 # bytes

2345

sizeOfCode = int(nCodeSize + nBaudSize + codeSize * self.dataOut~~Obj~~.nCode * self.dataOut~~Obj~~.nBaud)

2345

sizeOfCode = int(nCodeSize + nBaudSize + codeSize * self.dataOut.nCode * self.dataOut.nBaud)

2346

processingHeaderSize += sizeOfCode

2346

processingHeaderSize += sizeOfCode

2347

2348

if self.processingHeaderObj.nWindows != 0:

2348

if self.processingHeaderObj.nWindows != 0:

2349

self.processingHeaderObj.firstHeight = self.dataOut~~Obj~~.heightList[0]

2349

self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]

2350

self.processingHeaderObj.deltaHeight = self.dataOut~~Obj~~.heightList[1] - self.dataOut~~Obj~~.heightList[0]

2350

self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]

2351

self.processingHeaderObj.nHeights = self.dataOut~~Obj~~.nHeights

2351

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2352

self.processingHeaderObj.samplesWin = self.dataOut~~Obj~~.nHeights

2352

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2353

sizeOfFirstHeight = 4

2353

sizeOfFirstHeight = 4

2354

sizeOfdeltaHeight = 4

2354

sizeOfdeltaHeight = 4

2355

sizeOfnHeights = 4

2355

sizeOfnHeights = 4

2356

sizeOfWindows = (sizeOfFirstHeight + sizeOfdeltaHeight + sizeOfnHeights)*self.processingHeaderObj.nWindows

2356

sizeOfWindows = (sizeOfFirstHeight + sizeOfdeltaHeight + sizeOfnHeights)*self.processingHeaderObj.nWindows

2357

processingHeaderSize += sizeOfWindows

2357

processingHeaderSize += sizeOfWindows

2358

2359

self.processingHeaderObj.size = processingHeaderSize

2359

self.processingHeaderObj.size = processingHeaderSize

2360

2361

class SpectraHeisWriter():

2361

class SpectraHeisWriter():

2362

2363

i=0

2363

i=0

2364

2365

def __init__(self, dataOut~~Obj~~):

2365

def __init__(self, dataOut):

2366

2367

self.wrObj = FITS()

2367

self.wrObj = FITS()

2368

self.dataOut~~Obj~~ = dataOut~~Obj~~

2368

self.dataOut = dataOut

2369

2370

def isNumber(str):

2370

def isNumber(str):

2371

"""

2371

"""

2372

Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.

2372

Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.

2373

2374

Excepciones:

2374

Excepciones:

2375

Si un determinado string no puede ser convertido a numero

2375

Si un determinado string no puede ser convertido a numero

2376

Input:

2376

Input:

2377

str, string al cual se le analiza para determinar si convertible a un numero o no

2377

str, string al cual se le analiza para determinar si convertible a un numero o no

2378

2379

Return:

2379

Return:

2380

True : si el string es uno numerico

2380

True : si el string es uno numerico

2381

False : no es un string numerico

2381

False : no es un string numerico

2382

"""

2382

"""

2383

try:

2383

try:

2384

float( str )

2384

float( str )

2385

return True

2385

return True

2386

except:

2386

except:

2387

return False

2387

return False

2388

2389

def setup(self, wrpath,):

2389

def setup(self, wrpath,):

2390

2391

if not(os.path.exists(wrpath)):

2391

if not(os.path.exists(wrpath)):

2392

os.mkdir(wrpath)

2392

os.mkdir(wrpath)

2393

2394

self.wrpath = wrpath

2394

self.wrpath = wrpath

2395

self.setFile = 0

2395

self.setFile = 0

2396

2397

def putData(self):

2397

def putData(self):

2398

# self.wrObj.writeHeader(nChannels=self.dataOut~~Obj~~.nChannels, nFFTPoints=self.dataOut~~Obj~~.nFFTPoints)

2398

# self.wrObj.writeHeader(nChannels=self.dataOut.nChannels, nFFTPoints=self.dataOut.nFFTPoints)

2399

#name = self.dataOut~~Obj~~.utctime

2399

#name = self.dataOut.utctime

2400

name= time.localtime( self.dataOut~~Obj~~.utctime)

2400

name= time.localtime( self.dataOut.utctime)

2401

ext=".fits"

2401

ext=".fits"

2402

#folder='D%4.4d%3.3d'%(name.tm_year,name.tm_yday)

2402

#folder='D%4.4d%3.3d'%(name.tm_year,name.tm_yday)

2403

subfolder = 'D%4.4d%3.3d' % (name.tm_year,name.tm_yday)

2403

subfolder = 'D%4.4d%3.3d' % (name.tm_year,name.tm_yday)

2404

2405

doypath = os.path.join( self.wrpath, subfolder )

2405

doypath = os.path.join( self.wrpath, subfolder )

2406

if not( os.path.exists(doypath) ):

2406

if not( os.path.exists(doypath) ):

2407

os.mkdir(doypath)

2407

os.mkdir(doypath)

2408

self.setFile += 1

2408

self.setFile += 1

2409

file = 'D%4.4d%3.3d%3.3d%s' % (name.tm_year,name.tm_yday,self.setFile,ext)

2409

file = 'D%4.4d%3.3d%3.3d%s' % (name.tm_year,name.tm_yday,self.setFile,ext)

2410

2411

filename = os.path.join(self.wrpath,subfolder, file)

2411

filename = os.path.join(self.wrpath,subfolder, file)

2412

2413

# print self.dataOut~~Obj~~.ippSeconds

2413

# print self.dataOut.ippSeconds

2414

freq=numpy.arange(-1*self.dataOut~~Obj~~.nHeights/2.,self.dataOut~~Obj~~.nHeights/2.)/(2*self.dataOut~~Obj~~.ippSeconds)

2414

freq=numpy.arange(-1*self.dataOut.nHeights/2.,self.dataOut.nHeights/2.)/(2*self.dataOut.ippSeconds)

2415

2416

col1=self.wrObj.setColF(name="freq", format=str(self.dataOut~~Obj~~.nFFTPoints)+'E', array=freq)

2416

col1=self.wrObj.setColF(name="freq", format=str(self.dataOut.nFFTPoints)+'E', array=freq)

2417

col2=self.wrObj.writeData(name="P_Ch1",format=str(self.dataOut~~Obj~~.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut~~Obj~~.data_spc[0,:]))

2417

col2=self.wrObj.writeData(name="P_Ch1",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[0,:]))

2418

col3=self.wrObj.writeData(name="P_Ch2",format=str(self.dataOut~~Obj~~.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut~~Obj~~.data_spc[1,:]))

2418

col3=self.wrObj.writeData(name="P_Ch2",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[1,:]))

2419

col4=self.wrObj.writeData(name="P_Ch3",format=str(self.dataOut~~Obj~~.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut~~Obj~~.data_spc[2,:]))

2419

col4=self.wrObj.writeData(name="P_Ch3",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[2,:]))

2420

col5=self.wrObj.writeData(name="P_Ch4",format=str(self.dataOut~~Obj~~.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut~~Obj~~.data_spc[3,:]))

2420

col5=self.wrObj.writeData(name="P_Ch4",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[3,:]))

2421

col6=self.wrObj.writeData(name="P_Ch5",format=str(self.dataOut~~Obj~~.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut~~Obj~~.data_spc[4,:]))

2421

col6=self.wrObj.writeData(name="P_Ch5",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[4,:]))

2422

col7=self.wrObj.writeData(name="P_Ch6",format=str(self.dataOut~~Obj~~.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut~~Obj~~.data_spc[5,:]))

2422

col7=self.wrObj.writeData(name="P_Ch6",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[5,:]))

2423

col8=self.wrObj.writeData(name="P_Ch7",format=str(self.dataOut~~Obj~~.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut~~Obj~~.data_spc[6,:]))

2423

col8=self.wrObj.writeData(name="P_Ch7",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[6,:]))

2424

col9=self.wrObj.writeData(name="P_Ch8",format=str(self.dataOut~~Obj~~.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut~~Obj~~.data_spc[7,:]))

2424

col9=self.wrObj.writeData(name="P_Ch8",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[7,:]))

2425

#n=numpy.arange((100))

2425

#n=numpy.arange((100))

2426

n=self.dataOut~~Obj~~.data_spc[6,:]

2426

n=self.dataOut.data_spc[6,:]

2427

a=self.wrObj.cFImage(n)

2427

a=self.wrObj.cFImage(n)

2428

b=self.wrObj.Ctable(col1,col2,col3,col4,col5,col6,col7,col8,col9)

2428

b=self.wrObj.Ctable(col1,col2,col3,col4,col5,col6,col7,col8,col9)

2429

self.wrObj.CFile(a,b)

2429

self.wrObj.CFile(a,b)

2430

self.wrObj.wFile(filename)

2430

self.wrObj.wFile(filename)

2431

return 1

2431

return 1

2432

2433

class FITS:

2433

class FITS:

2434

2435

name=None

2435

name=None

2436

format=None

2436

format=None

2437

array =None

2437

array =None

2438

data =None

2438

data =None

2439

thdulist=None

2439

thdulist=None

2440

2441

def __init__(self):

2441

def __init__(self):

2442

2443

pass

2443

pass

2444

2445

def setColF(self,name,format,array):

2445

def setColF(self,name,format,array):

2446

self.name=name

2446

self.name=name

2447

self.format=format

2447

self.format=format

2448

self.array=array

2448

self.array=array

2449

a1=numpy.array([self.array],dtype=numpy.float32)

2449

a1=numpy.array([self.array],dtype=numpy.float32)

2450

self.col1 = pyfits.Column(name=self.name, format=self.format, array=a1)

2450

self.col1 = pyfits.Column(name=self.name, format=self.format, array=a1)

2451

return self.col1

2451

return self.col1

2452

2453

# def setColP(self,name,format,data):

2453

# def setColP(self,name,format,data):

2454

# self.name=name

2454

# self.name=name

2455

# self.format=format

2455

# self.format=format

2456

# self.data=data

2456

# self.data=data

2457

# a2=numpy.array([self.data],dtype=numpy.float32)

2457

# a2=numpy.array([self.data],dtype=numpy.float32)

2458

# self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)

2458

# self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)

2459

# return self.col2

2459

# return self.col2

2460

2461

def writeHeader(self,):

2461

def writeHeader(self,):

2462

pass

2462

pass

2463

2464

def writeData(self,name,format,data):

2464

def writeData(self,name,format,data):

2465

self.name=name

2465

self.name=name

2466

self.format=format

2466

self.format=format

2467

self.data=data

2467

self.data=data

2468

a2=numpy.array([self.data],dtype=numpy.float32)

2468

a2=numpy.array([self.data],dtype=numpy.float32)

2469

self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)

2469

self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)

2470

return self.col2

2470

return self.col2

2471

2472

def cFImage(self,n):

2472

def cFImage(self,n):

2473

self.hdu= pyfits.PrimaryHDU(n)

2473

self.hdu= pyfits.PrimaryHDU(n)

2474

return self.hdu

2474

return self.hdu

2475

2476

def Ctable(self,col1,col2,col3,col4,col5,col6,col7,col8,col9):

2476

def Ctable(self,col1,col2,col3,col4,col5,col6,col7,col8,col9):

2477

self.cols=pyfits.ColDefs( [col1,col2,col3,col4,col5,col6,col7,col8,col9])

2477

self.cols=pyfits.ColDefs( [col1,col2,col3,col4,col5,col6,col7,col8,col9])

2478

self.tbhdu = pyfits.new_table(self.cols)

2478

self.tbhdu = pyfits.new_table(self.cols)

2479

return self.tbhdu

2479

return self.tbhdu

2480

2481

def CFile(self,hdu,tbhdu):

2481

def CFile(self,hdu,tbhdu):

2482

self.thdulist=pyfits.HDUList([hdu,tbhdu])

2482

self.thdulist=pyfits.HDUList([hdu,tbhdu])

2483

2484

def wFile(self,filename):

2484

def wFile(self,filename):

2485

self.thdulist.writeto(filename) No newline at end of file

2485

self.thdulist.writeto(filename)

@@ -0,0 +1,3
	1	import jrodata
	2	import jrodataIO
	3	import jroprocessing

	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

             '''
             $Author: dsuarez $
             $Id: Processor.py 1 2012-11-12 18:56:07Z dsuarez $
             '''
             import os
             import numpy
             import datetime
             import time
             from jrodata import *
             from jrodataIO import *
             from jroplot import *
             class ProcessingUnit:
                 """
                 Esta es la clase base para el procesamiento de datos.
                 Contiene el metodo "call" para llamar operaciones. Las operaciones pueden ser:
                     - Metodos internos (callMethod)
                     - Objetos del tipo Operation (callObject). Antes de ser llamados, estos objetos
                       tienen que ser agreagados con el metodo "add".
                 """
                 # objeto de datos de entrada (Voltage, Spectra o Correlation)
                 dataIn = None
                 # objeto de datos de entrada (Voltage, Spectra o Correlation)
                 dataOut = None
                 objectDict = None
                 def __init__(self):
                     self.objectDict = {}
                 def addOperation(self, object, objId):
                     """
                     Agrega el objeto "object" a la lista de objetos "self.objectList" y retorna el
                     identificador asociado a este objeto.
                     Input:
                         object    :    objeto de la clase "Operation"
                     Return:
                         objId    :    identificador del objeto, necesario para ejecutar la operacion
                     """
-                    self.object[objId] = object
+                    self.objectDict[objId] = object
                     return objId
                 def operation(self, **kwargs):
                     """
                     Operacion directa sobre la data (dataout.data). Es necesario actualizar los valores de los
                     atributos del objeto dataOut
                     Input:
                         **kwargs    :    Diccionario de argumentos de la funcion a ejecutar
                     """
                     if self.dataIn.isEmpty():
                         return None
                     raise ValueError, "ImplementedError"
                 def callMethod(self, name, **kwargs):
                     """
                     Ejecuta el metodo con el nombre "name" y con argumentos **kwargs de la propia clase.
                     Input:
                         name        :    nombre del metodo a ejecutar
                         **kwargs     :    diccionario con los nombres y valores de la funcion a ejecutar.
                     """
                     if self.dataIn.isEmpty():
                         return None
                     methodToCall = getattr(self, name)
                     methodToCall(**kwargs)
                 def callObject(self, objId, **kwargs):
                     """
                     Ejecuta la operacion asociada al identificador del objeto "objId"
                     Input:
                         objId        :    identificador del objeto a ejecutar
                         **kwargs    :    diccionario con los nombres y valores de la funcion a ejecutar.
                     Return:
                         None
                     """
                     if self.dataIn.isEmpty():
                         return None
                     object = self.objectList[objId]
                     object.run(self.dataOut, **kwargs)
                 def call(self, operation, **kwargs):
                     """
                     Ejecuta la operacion "operation" con los argumentos "**kwargs". La operacion puede
                     ser de dos tipos:
 . Un metodo propio de esta clase:
                             operation.type = "self"
 . El metodo "run" de un objeto del tipo Operation o de un derivado de ella:
                             operation.type = "other".
                            Este objeto de tipo Operation debe de haber sido agregado antes con el metodo:
                            "addOperation" e identificado con el operation.id
                     con el id de la operacion.
                     """
                     if self.dataIn.isEmpty():
                         return None
                     if operation.type == 'self':
                         self.callMethod(operation.name, **kwargs)
                         return
                     if operation.type == 'other':
                         self.callObject(operation.id, **kwargs)
                         return
             class Operation():
                 """
                 Clase base para definir las operaciones adicionales que se pueden agregar a la clase ProcessingUnit
-                y necesiten acumular información previa de los datos a procesar. De preferencia usar un buffer de
+                y necesiten acumular informacion previa de los datos a procesar. De preferencia usar un buffer de
                 acumulacion dentro de esta clase
-                Ejemplo: Integraciones coherentes, necesita la información previa de los n perfiles anteriores (bufffer)
+                Ejemplo: Integraciones coherentes, necesita la informacion previa de los n perfiles anteriores (bufffer)
                 """
                 __buffer = None
                 __isConfig = False
                 def __init__(self):
                     pass
                 def run(self, dataIn, **kwargs):
                     """
                     Realiza las operaciones necesarias sobre la dataIn.data y actualiza los atributos del objeto dataIn.
                     Input:
                         dataIn    :    objeto del tipo JROData
                     Return:
                         None
                     Affected:
                         __buffer    :    buffer de recepcion de datos.
                     """
                     raise ValueError, "ImplementedError"
             class VoltageProc(ProcessingUnit):
                 def __init__(self):
+                    self.objectDict = {}
                     pass
-                def setup(self, dataInObj=None, dataOutObj=None):
+                def setup(self, dataIn=None, dataOut=None):
-                    self.dataInObj = dataInObj
+                    self.dataIn = dataIn
-                    if self.dataOutObj == None:
+                    if self.dataOut == None:
-                        dataOutObj = Voltage()
+                        dataOut = Voltage()
-                    self.dataOutObj = dataOutObj
+                    self.dataOut = dataOut
-                    return self.dataOutObj
+                    return self.dataOut
                 def init(self):
-                    if self.dataInObj.isEmpty():
+                    if self.dataIn.isEmpty():
                         return 0
-                    self.dataOutObj.copy(self.dataInObj)
+                    self.dataOut.copy(self.dataIn)
-                    # No necesita copiar en cada init() los atributos de dataInObj
+                    # No necesita copiar en cada init() los atributos de dataIn
                     # la copia deberia hacerse por cada nuevo bloque de datos
                 def selectChannels(self, channelList):
-                    if self.dataInObj.isEmpty():
+                    if self.dataIn.isEmpty():
                         return 0
                     self.selectChannelsByIndex(channelList)
                 def selectChannelsByIndex(self, channelIndexList):
                     """
                     Selecciona un bloque de datos en base a canales segun el channelIndexList
                     Input:
                         channelIndexList    :    lista sencilla de canales a seleccionar por ej. [2,3,7]
                     Affected:
-                        self.dataOutObj.data
+                        self.dataOut.data
-                        self.dataOutObj.channelIndexList
+                        self.dataOut.channelIndexList
-                        self.dataOutObj.nChannels
+                        self.dataOut.nChannels
-                        self.dataOutObj.m_ProcessingHeader.totalSpectra
+                        self.dataOut.m_ProcessingHeader.totalSpectra
-                        self.dataOutObj.systemHeaderObj.numChannels
+                        self.dataOut.systemHeaderObj.numChannels
-                        self.dataOutObj.m_ProcessingHeader.blockSize
+                        self.dataOut.m_ProcessingHeader.blockSize
                     Return:
                         None
                     """
                     for channel in channelIndexList:
-                        if channel not in self.dataOutObj.channelIndexList:
+                        if channel not in self.dataOut.channelIndexList:
                             raise ValueError, "The value %d in channelIndexList is not valid" %channel
                     nChannels = len(channelIndexList)
-                    data = self.dataOutObj.data[channelIndexList,:]
+                    data = self.dataOut.data[channelIndexList,:]
-                    self.dataOutObj.data = data
+                    self.dataOut.data = data
-                    self.dataOutObj.channelIndexList = channelIndexList
+                    self.dataOut.channelIndexList = channelIndexList
-                    self.dataOutObj.channelList = [self.dataOutObj.channelList[i] for i in channelIndexList]
+                    self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
-                    self.dataOutObj.nChannels = nChannels
+                    self.dataOut.nChannels = nChannels
                     return 1
             class CohInt(Operation):
                 __profIndex = 0
                 __withOverapping  = False
                 __byTime = False
                 __initime = None
                 __lastdatatime = None
                 __integrationtime = None
                 __buffer = None
                 __dataReady = False
                 nCohInt = None
                 def __init__(self):
                     self.__isConfig = False
                 def setup(self, nCohInt=None, timeInterval=None, overlapping=False):
                     """
                     Set the parameters of the integration class.
                     Inputs:
                         nCohInt        :    Number of coherent integrations
                         timeInterval   :    Time of integration. If the parameter "nCohInt" is selected this one does not work
                         overlapping    :
                     """
                     self.__initime = None
                     self.__lastdatatime = 0
                     self.__buffer = None
                     self.__dataReady = False
                     if nCohInt == None and timeInterval == None:
                         raise ValueError, "nCohInt or timeInterval should be specified ..."
                     if nCohInt != None:
                         self.nCohInt = nCohInt
                         self.__byTime = False
                     else:
                         self.__integrationtime = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
                         self.nCohInt = 9999
                         self.__byTime = True
                     if overlapping:
                         self.__withOverapping = True
                         self.__buffer = None
                     else:
                         self.__withOverapping = False
                         self.__buffer = 0
                     self.__profIndex = 0
                 def putData(self, data):
                     """
                     Add a profile to the __buffer and increase in one the __profileIndex
                     """
                     if not self.__withOverapping:
                         self.__buffer += data
                         self.__profIndex += 1
                         return
                     #Overlapping data
                     nChannels, nHeis = data.shape
                     data = numpy.reshape(data, (1, nChannels, nHeis))
                     #If the buffer is empty then it takes the data value
                     if self.__buffer == None:
                         self.__buffer = data
                         self.__profIndex += 1
                         return
                     #If the buffer length is lower than nCohInt then stakcing the data value
                     if self.__profIndex < self.nCohInt:
                         self.__buffer = numpy.vstack((self.__buffer, data))
                         self.__profIndex += 1
                         return
                     #If the buffer length is equal to nCohInt then replacing the last buffer value with the data value
                     self.__buffer = numpy.roll(self.__buffer, -1, axis=0)
                     self.__buffer[self.nCohInt-1] = data
                     self.__profIndex = self.nCohInt
                     return
                 def pushData(self):
                     """
                     Return the sum of the last profiles and the profiles used in the sum.
                     Affected:
                     self.__profileIndex
                     """
                     if not self.__withOverapping:
                         data = self.__buffer
                         nCohInt = self.__profIndex
                         self.__buffer = 0
                         self.__profIndex = 0
                         return data, nCohInt
                     #Integration with Overlapping
                     data = numpy.sum(self.__buffer, axis=0)
                     nCohInt = self.__profIndex
                     return data, nCohInt
                 def byProfiles(self, data):
                     self.__dataReady = False
                     avg_data = None
                     nCohInt = None
                     self.putData(data)
                     if self.__profIndex == self.nCohInt:
                         avgdata, nCohInt = self.pushData()
                         self.__dataReady = True
                     return avgdata, nCohInt
                 def byTime(self, data, datatime):
                     self.__dataReady = False
                     avg_data = None
                     nCohInt = None
                     self.putData(data)
                     if (datatime - self.__initime) >= self.__integrationtime:
                         avgdata, nCohInt = self.pushData()
                         self.nCohInt = nCohInt
                         self.__dataReady = True
                     return avgdata, nCohInt
                 def integrate(self, data, datatime=None):
                     if self.__initime == None:
                         self.__initime = datatime
                     if self.__byTime:
                         avgdata = self.byTime(data, datatime)
                     else:
                         avgdata = self.byProfiles(data)
                     self.__lastdatatime = datatime
                     if avgdata == None:
                         return None
                     avgdatatime = self.__initime
                     deltatime = datatime -self.__lastdatatime
                     if not self.__withOverapping:
                         self.__initime = datatime
                     else:
                         self.__initime += deltatime
-                return avgdata, avgdatatime
+                    return avgdata, avgdatatime
                 def run(self, dataOut, nCohInt=None, timeInterval=None, overlapping=False):
                     if not self.__isConfig:
                         self.setup(nCohInt, timeInterval, overlapping)
                         self.__isConfig = True
                     avgdata, avgdatatime = self.integrate(dataOut.data, dataOut.utctime)
-            #        self.dataOutObj.timeInterval *= nCohInt
+            #        self.dataOut.timeInterval *= nCohInt
-                    self.dataOutObj.flagNoData = True
+                    self.dataOut.flagNoData = True
                     if self.__dataReady:
-                        dataOutObj.data = avgdata
+                        dataOut.data = avgdata
-                        dataOutObj.timeInterval *= self.nCohInt
+                        dataOut.timeInterval *= self.nCohInt
-                        dataOutObj.nCohInt *= self.nCohInt
+                        dataOut.nCohInt *= self.nCohInt
-                        dataOutObj.utctime = avgdatatime
+                        dataOut.utctime = avgdatatime
-                        dataOutObj.flagNoData = False
  No newline at end of file
+                        dataOut.flagNoData = False
  No newline at end of file