schain-jc Commit - r191:58293a972ca2

             '''
             $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
                 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
                 dataOut = None
                 blocksize = None
                 def __init__(self):
                     raise ValueError, "Not implemented"
                 def run(self):
                     raise ValueError, "Not implemented"
+                def getOuput(self):
+                    return self.dataOut
             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,
                             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 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.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.dataOut.channelList = 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):
             #            self.dataOut = dataOut
                         self.setup(**kwargs)
                         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, 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.dataOut.utctime)
                     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.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.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, dataOut, 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
                     self.dataOut = dataOut
                     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):
                         self.setup(dataOut, **kwargs)
                         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"
                 dataOut = None
                 def __init__(self):
                     """
                     Inicializador de la clase VoltageReader para la lectura de datos de voltage.
                     Input:
                         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.dataOut
                     Return:
                         None
                     """
                     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
                     self.dataOut = self.createObjByDefault()
                 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.dataOut
                         self.profileIndex
                     Affected:
                         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.dataOut.flagNoData = True
                         return 0
                     self.dataOut.data = self.datablock[:,self.profileIndex,:]
                     self.dataOut.dtype = self.dtype
                     self.dataOut.nChannels = self.systemHeaderObj.nChannels
                     self.dataOut.nHeights = self.processingHeaderObj.nHeights
                     self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
                     xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
                     self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
                     self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
                     self.dataOut.channelIndexList = range(self.systemHeaderObj.nChannels)
                     self.dataOut.flagTimeBlock = self.flagTimeBlock
                     self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.ippSeconds
                     self.dataOut.ippSeconds = self.ippSeconds
                     self.dataOut.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt
                     self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
                     self.dataOut.flagShiftFFT = False
                     if self.processingHeaderObj.code != None:
                         self.dataOut.nCode = self.processingHeaderObj.nCode
                         self.dataOut.nBaud = self.processingHeaderObj.nBaud
                         self.dataOut.code = self.processingHeaderObj.code
                     self.profileIndex += 1
                     self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
                     self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
                     self.dataOut.flagNoData = False
             #        print self.profileIndex, self.dataOut.utctime
             #        if self.profileIndex == 800:
             #            a=1
                     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):
                     """
                     Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
                     Affected:
                         self.dataOut
                     Return: None
                     """
                     self.nTotalBlocks = 0
                     self.profileIndex = 0
                     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.dataOut.flagNoData:
                         return 0
                     self.flagIsNewBlock = 0
                     if self.dataOut.flagTimeBlock:
                         self.datablock.fill(0)
                         self.profileIndex = 0
                         self.setNextFile()
                     if self.profileIndex == 0:
                         self.getBasicHeader()
                     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.dataOut.dtype == dtypeList[index]:
                             dtypeValue = datatypeValueList[index]
                             break
                     processFlags += dtypeValue
                     if self.dataOut.flagDecodeData:
                         processFlags += PROCFLAG.DECODE_DATA
                     if self.dataOut.flagDeflipData:
                         processFlags += PROCFLAG.DEFLIP_DATA
                     if self.dataOut.code != None:
                         processFlags += PROCFLAG.DEFINE_PROCESS_CODE
                     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.dataOut.dtype == dtypeList[index]:
                             datatypeValue = datatypeValueList[index]
                             break
                     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.dataOut.systemHeaderObj.copy()
                     self.systemHeaderObj.nChannels = self.dataOut.nChannels
                     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.dataOut.processingHeaderObj.nWindows
                     self.processingHeaderObj.processFlags = self.__getProcessFlags()
                     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.dataOut.code != None:
                         self.processingHeaderObj.code = self.dataOut.code
                         self.processingHeaderObj.nCode = self.dataOut.nCode
                         self.processingHeaderObj.nBaud = self.dataOut.nBaud
                         codesize = int(8 + 4 * self.dataOut.nCode * self.dataOut.nBaud)
                         processingHeaderSize += codesize
                     if self.processingHeaderObj.nWindows != 0:
                         self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
                         self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
                         self.processingHeaderObj.nHeights = self.dataOut.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"
                 dataOut = None
                 nRdChannels = None
                 nRdPairs = None
                 rdPairList = []
                 def __init__(self):
                     """
                     Inicializador de la clase SpectraReader para la lectura de datos de espectros.
                     Inputs:
                         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.dataOut
                     Return      : None
                     """
                     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
                     self.dataOut = self.createObjByDefault()
                 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.dataOut.nChannels
                         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.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.dataOut.flagNoData = True
                         return 0
                     self.dataOut.data_spc = self.data_spc
                     self.dataOut.data_cspc = self.data_cspc
                     self.dataOut.data_dc = self.data_dc
                     self.dataOut.flagTimeBlock = self.flagTimeBlock
                     self.dataOut.flagNoData = False
                     self.dataOut.dtype = self.dtype
                     self.dataOut.nChannels = self.nRdChannels
                     self.dataOut.nPairs = self.nRdPairs
                     self.dataOut.pairsList = self.rdPairList
                     self.dataOut.nHeights = self.processingHeaderObj.nHeights
                     self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
                     self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock
                     self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt
                     xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
                     self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
                     self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
                     self.dataOut.channelIndexList = range(self.systemHeaderObj.nChannels)
                     self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000.#+ self.profileIndex * self.ippSeconds
                     self.dataOut.ippSeconds = self.ippSeconds
                     self.dataOut.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.dataOut.nFFTPoints
                     self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
             #        self.profileIndex += 1
                     self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
                     self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
                     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
             #    dataOut = None
                 def __init__(self):
                     """
                     Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
                     Affected:
                         self.dataOut
                         self.basicHeaderObj
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.processingHeaderObj
                     Return: None
                     """
                     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.dataOut.nChannels,
                                              self.processingHeaderObj.nHeights,
                                              self.processingHeaderObj.profilesPerBlock)
                     self.shape_cspc_Buffer = (self.dataOut.nPairs,
                                               self.processingHeaderObj.nHeights,
                                               self.processingHeaderObj.profilesPerBlock)
                     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.dataOut.flagNoData:
                         return 0
                     self.flagIsNewBlock = 0
                     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.dataOut.data_spc
                     self.data_cspc = self.dataOut.data_cspc
                     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.dataOut.dtype == dtypeList[index]:
                             dtypeValue = datatypeValueList[index]
                             break
                     processFlags += dtypeValue
                     if self.dataOut.flagDecodeData:
                         processFlags += PROCFLAG.DECODE_DATA
                     if self.dataOut.flagDeflipData:
                         processFlags += PROCFLAG.DEFLIP_DATA
                     if self.dataOut.code != None:
                         processFlags += PROCFLAG.DEFINE_PROCESS_CODE
                     if self.dataOut.nIncohInt > 1:
                         processFlags += PROCFLAG.INCOHERENT_INTEGRATION
                     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.dataOut.dtype == dtypeList[index]:
                             datatypeValue = datatypeValueList[index]
                             break
                     pts2write = self.dataOut.nHeights * self.dataOut.nFFTPoints
                     pts2write_SelfSpectra = int(self.dataOut.nChannels * pts2write)
                     blocksize = (pts2write_SelfSpectra*datatypeValue)
                     if self.dataOut.data_cspc != None:
                         pts2write_CrossSpectra = int(self.dataOut.nPairs * pts2write)
                         blocksize += (pts2write_CrossSpectra*datatypeValue*2)
                     if self.dataOut.data_dc != None:
                         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.dataOut.systemHeaderObj.copy()
                     self.systemHeaderObj.nChannels = self.dataOut.nChannels
                     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.dataOut.nFFTPoints
                     self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
                     self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
                     self.processingHeaderObj.processFlags = self.__getProcessFlags()
                     self.processingHeaderObj.nCohInt = self.dataOut.nCohInt# Se requiere para determinar el valor de timeInterval
                     self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt
                     self.processingHeaderObj.totalSpectra = self.dataOut.nPairs + self.dataOut.nChannels
                     if self.processingHeaderObj.totalSpectra > 0:
                         channelList = []
                         for channel in range(self.dataOut.nChannels):
                             channelList.append(channel)
                             channelList.append(channel)
                         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.dataOut.code != None:
                         self.processingHeaderObj.code = self.dataOut.code
                         self.processingHeaderObj.nCode = self.dataOut.nCode
                         self.processingHeaderObj.nBaud = self.dataOut.nBaud
                         nCodeSize = 4 # bytes
                         nBaudSize = 4 # bytes
                         codeSize = 4 # bytes
                         sizeOfCode = int(nCodeSize + nBaudSize + codeSize * self.dataOut.nCode * self.dataOut.nBaud)
                         processingHeaderSize += sizeOfCode
                     if self.processingHeaderObj.nWindows != 0:
                         self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
                         self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
                         self.processingHeaderObj.nHeights = self.dataOut.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, dataOut):
                     self.wrObj = FITS()
                     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.dataOut.nChannels, nFFTPoints=self.dataOut.nFFTPoints)
                     #name = self.dataOut.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.dataOut.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.dataOut.nFFTPoints)+'E', array=freq)
                     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.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[1,:]))
                     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.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[3,:]))
                     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.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[5,:]))
                     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.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[7,:]))
                     #n=numpy.arange((100))
                     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 = 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

def getOuput(self):

235

236

237

return self.dataOut

236

238

237

class JRODataReader(JRODataIO):

239

class JRODataReader(JRODataIO):

238

240

239

nReadBlocks = 0

241

nReadBlocks = 0

240

242

241

delay = 60 #number of seconds waiting a new file

243

delay = 60 #number of seconds waiting a new file

242

244

243

nTries = 3 #quantity tries

245

nTries = 3 #quantity tries

244

246

245

nFiles = 3 #number of files for searching

247

nFiles = 3 #number of files for searching

246

248

247

249

248

def __init__(self):

250

def __init__(self):

249

251

250

"""

252

"""

251

253

252

"""

254

"""

253

255

254

raise ValueError, "This method has not been implemented"

256

raise ValueError, "This method has not been implemented"

255

257

256

258

257

def createObjByDefault(self):

259

def createObjByDefault(self):

258

"""

260

"""

259

261

260

"""

262

"""

261

raise ValueError, "This method has not been implemented"

263

raise ValueError, "This method has not been implemented"

262

264

263

def getBlockDimension(self):

265

def getBlockDimension(self):

264

266

265

raise ValueError, "No implemented"

267

raise ValueError, "No implemented"

266

268

267

def __searchFilesOffLine(self,

269

def __searchFilesOffLine(self,

268

path,

270

path,

269

startDate,

271

startDate,

270

endDate,

272

endDate,

271

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

273

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

272

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

274

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

273

set=None,

275

set=None,

274

expLabel="",

276

expLabel="",

275

ext=".r"):

277

ext=".r"):

276

dirList = []

278

dirList = []

277

for thisPath in os.listdir(path):

279

for thisPath in os.listdir(path):

278

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

280

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

279

dirList.append(thisPath)

281

dirList.append(thisPath)

280

282

281

if not(dirList):

283

if not(dirList):

282

return None, None

284

return None, None

283

285

284

pathList = []

286

pathList = []

285

dateList = []

287

dateList = []

286

288

287

thisDate = startDate

289

thisDate = startDate

288

290

289

while(thisDate <= endDate):

291

while(thisDate <= endDate):

290

year = thisDate.timetuple().tm_year

292

year = thisDate.timetuple().tm_year

291

doy = thisDate.timetuple().tm_yday

293

doy = thisDate.timetuple().tm_yday

292

294

293

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

295

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

294

if len(match) == 0:

296

if len(match) == 0:

295

thisDate += datetime.timedelta(1)

297

thisDate += datetime.timedelta(1)

296

continue

298

continue

297

299

298

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

300

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

299

dateList.append(thisDate)

301

dateList.append(thisDate)

300

thisDate += datetime.timedelta(1)

302

thisDate += datetime.timedelta(1)

301

303

302

filenameList = []

304

filenameList = []

303

for index in range(len(pathList)):

305

for index in range(len(pathList)):

304

306

305

thisPath = pathList[index]

307

thisPath = pathList[index]

306

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

308

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

307

fileList.sort()

309

fileList.sort()

308

310

309

#Busqueda de datos en el rango de horas indicados

311

#Busqueda de datos en el rango de horas indicados

310

thisDate = dateList[index]

312

thisDate = dateList[index]

311

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

313

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

312

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

314

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

313

315

314

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

316

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

315

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

317

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

316

318

317

for file in fileList:

319

for file in fileList:

318

320

319

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

321

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

320

322

321

if isThisFileinRange(filename, startUtSeconds, endUtSeconds):

323

if isThisFileinRange(filename, startUtSeconds, endUtSeconds):

322

filenameList.append(filename)

324

filenameList.append(filename)

323

325

324

if not(filenameList):

326

if not(filenameList):

325

return None, None

327

return None, None

326

328

327

self.filenameList = filenameList

329

self.filenameList = filenameList

328

330

329

return pathList, filenameList

331

return pathList, filenameList

330

332

331

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

333

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

332

334

333

"""

335

"""

334

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

336

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

335

devuelve el archivo encontrado ademas de otros datos.

337

devuelve el archivo encontrado ademas de otros datos.

336

338

337

Input:

339

Input:

338

path : carpeta donde estan contenidos los files que contiene data

340

path : carpeta donde estan contenidos los files que contiene data

339

341

340

startDate : Fecha inicial. Rechaza todos los directorios donde

342

startDate : Fecha inicial. Rechaza todos los directorios donde

341

file end time < startDate (obejto datetime.date)

343

file end time < startDate (obejto datetime.date)

342

344

343

endDate : Fecha final. Rechaza todos los directorios donde

345

endDate : Fecha final. Rechaza todos los directorios donde

344

file start time > endDate (obejto datetime.date)

346

file start time > endDate (obejto datetime.date)

345

347

346

startTime : Tiempo inicial. Rechaza todos los archivos donde

348

startTime : Tiempo inicial. Rechaza todos los archivos donde

347

file end time < startTime (obejto datetime.time)

349

file end time < startTime (obejto datetime.time)

348

350

349

endTime : Tiempo final. Rechaza todos los archivos donde

351

endTime : Tiempo final. Rechaza todos los archivos donde

350

file start time > endTime (obejto datetime.time)

352

file start time > endTime (obejto datetime.time)

351

353

352

expLabel : Nombre del subexperimento (subfolder)

354

expLabel : Nombre del subexperimento (subfolder)

353

355

354

ext : extension de los files

356

ext : extension de los files

355

357

356

Return:

358

Return:

357

directory : eL directorio donde esta el file encontrado

359

directory : eL directorio donde esta el file encontrado

358

filename : el ultimo file de una determinada carpeta

360

filename : el ultimo file de una determinada carpeta

359

year : el anho

361

year : el anho

360

doy : el numero de dia del anho

362

doy : el numero de dia del anho

361

set : el set del archivo

363

set : el set del archivo

362

364

363

365

364

"""

366

"""

365

dirList = []

367

dirList = []

366

pathList = []

368

pathList = []

367

directory = None

369

directory = None

368

370

369

#Filtra solo los directorios

371

#Filtra solo los directorios

370

for thisPath in os.listdir(path):

372

for thisPath in os.listdir(path):

371

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

373

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

372

dirList.append(thisPath)

374

dirList.append(thisPath)

373

375

374

if not(dirList):

376

if not(dirList):

375

return None, None, None, None, None

377

return None, None, None, None, None

376

378

377

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

379

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

378

380

379

if startDate:

381

if startDate:

380

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

382

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

381

thisDateTime = startDateTime

383

thisDateTime = startDateTime

382

if endDate == None: endDateTime = startDateTime

384

if endDate == None: endDateTime = startDateTime

383

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

385

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

384

386

385

while(thisDateTime <= endDateTime):

387

while(thisDateTime <= endDateTime):

386

year = thisDateTime.timetuple().tm_year

388

year = thisDateTime.timetuple().tm_year

387

doy = thisDateTime.timetuple().tm_yday

389

doy = thisDateTime.timetuple().tm_yday

388

390

389

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

391

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

390

if len(match) == 0:

392

if len(match) == 0:

391

thisDateTime += datetime.timedelta(1)

393

thisDateTime += datetime.timedelta(1)

392

continue

394

continue

393

395

394

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

396

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

395

thisDateTime += datetime.timedelta(1)

397

thisDateTime += datetime.timedelta(1)

396

398

397

if not(pathList):

399

if not(pathList):

398

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

400

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

399

return None, None, None, None, None

401

return None, None, None, None, None

400

402

401

directory = pathList[0]

403

directory = pathList[0]

402

404

403

else:

405

else:

404

directory = dirList[-1]

406

directory = dirList[-1]

405

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

407

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

406

408

407

filename = getlastFileFromPath(directory, ext)

409

filename = getlastFileFromPath(directory, ext)

408

410

409

if not(filename):

411

if not(filename):

410

return None, None, None, None, None

412

return None, None, None, None, None

411

413

412

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

414

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

413

return None, None, None, None, None

415

return None, None, None, None, None

414

416

415

year = int( filename[1:5] )

417

year = int( filename[1:5] )

416

doy = int( filename[5:8] )

418

doy = int( filename[5:8] )

417

set = int( filename[8:11] )

419

set = int( filename[8:11] )

418

420

419

return directory, filename, year, doy, set

421

return directory, filename, year, doy, set

420

422

421

def setup(self,

423

def setup(self,

422

path=None,

424

path=None,

423

startDate=None,

425

startDate=None,

424

endDate=None,

426

endDate=None,

425

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

427

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

426

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

428

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

427

set=0,

429

set=0,

428

expLabel = "",

430

expLabel = "",

429

ext = None,

431

ext = None,

430

online = False,

432

online = False,

431

delay = 60):

433

delay = 60):

432

434

433

if path == None:

435

if path == None:

434

raise ValueError, "The path is not valid"

436

raise ValueError, "The path is not valid"

435

437

436

if ext == None:

438

if ext == None:

437

ext = self.ext

439

ext = self.ext

438

440

439

if online:

441

if online:

440

print "Searching files in online mode..."

442

print "Searching files in online mode..."

441

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

443

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

442

444

443

if not(doypath):

445

if not(doypath):

444

for nTries in range( self.nTries ):

446

for nTries in range( self.nTries ):

445

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

447

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

446

time.sleep( self.delay )

448

time.sleep( self.delay )

447

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

449

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

448

if doypath:

450

if doypath:

449

break

451

break

450

452

451

if not(doypath):

453

if not(doypath):

452

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

454

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

453

return None

455

return None

454

456

455

self.year = year

457

self.year = year

456

self.doy = doy

458

self.doy = doy

457

self.set = set - 1

459

self.set = set - 1

458

self.path = path

460

self.path = path

459

461

460

else:

462

else:

461

print "Searching files in offline mode ..."

463

print "Searching files in offline mode ..."

462

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

464

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

463

465

464

if not(pathList):

466

if not(pathList):

465

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

467

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

466

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

468

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

467

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

469

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

468

470

469

sys.exit(-1)

471

sys.exit(-1)

470

472

471

473

472

self.fileIndex = -1

474

self.fileIndex = -1

473

self.pathList = pathList

475

self.pathList = pathList

474

self.filenameList = filenameList

476

self.filenameList = filenameList

475

477

476

self.online = online

478

self.online = online

477

self.delay = delay

479

self.delay = delay

478

ext = ext.lower()

480

ext = ext.lower()

479

self.ext = ext

481

self.ext = ext

480

482

481

if not(self.setNextFile()):

483

if not(self.setNextFile()):

482

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

484

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

483

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

485

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

484

elif startDate != None:

486

elif startDate != None:

485

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

487

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

486

else:

488

else:

487

print "No files"

489

print "No files"

488

490

489

sys.exit(-1)

491

sys.exit(-1)

490

492

491

# self.updateDataHeader()

493

# self.updateDataHeader()

492

494

493

return self.dataOut

495

return self.dataOut

494

496

495

def __setNextFileOffline(self):

497

def __setNextFileOffline(self):

496

498

497

idFile = self.fileIndex

499

idFile = self.fileIndex

498

500

499

while (True):

501

while (True):

500

idFile += 1

502

idFile += 1

501

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

503

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

502

self.flagNoMoreFiles = 1

504

self.flagNoMoreFiles = 1

503

print "No more Files"

505

print "No more Files"

504

return 0

506

return 0

505

507

506

filename = self.filenameList[idFile]

508

filename = self.filenameList[idFile]

507

509

508

if not(self.__verifyFile(filename)):

510

if not(self.__verifyFile(filename)):

509

continue

511

continue

510

512

511

fileSize = os.path.getsize(filename)

513

fileSize = os.path.getsize(filename)

512

fp = open(filename,'rb')

514

fp = open(filename,'rb')

513

break

515

break

514

516

515

self.flagIsNewFile = 1

517

self.flagIsNewFile = 1

516

self.fileIndex = idFile

518

self.fileIndex = idFile

517

self.filename = filename

519

self.filename = filename

518

self.fileSize = fileSize

520

self.fileSize = fileSize

519

self.fp = fp

521

self.fp = fp

520

522

521

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

523

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

522

524

523

return 1

525

return 1

524

526

525

def __setNextFileOnline(self):

527

def __setNextFileOnline(self):

526

"""

528

"""

527

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

529

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

528

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

530

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

529

siguientes.

531

siguientes.

530

532

531

Affected:

533

Affected:

532

self.flagIsNewFile

534

self.flagIsNewFile

533

self.filename

535

self.filename

534

self.fileSize

536

self.fileSize

535

self.fp

537

self.fp

536

self.set

538

self.set

537

self.flagNoMoreFiles

539

self.flagNoMoreFiles

538

540

539

Return:

541

Return:

540

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

542

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

541

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

543

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

542

544

543

Excepciones:

545

Excepciones:

544

Si un determinado file no puede ser abierto

546

Si un determinado file no puede ser abierto

545

"""

547

"""

546

nFiles = 0

548

nFiles = 0

547

fileOk_flag = False

549

fileOk_flag = False

548

firstTime_flag = True

550

firstTime_flag = True

549

551

550

self.set += 1

552

self.set += 1

551

553

552

#busca el 1er file disponible

554

#busca el 1er file disponible

553

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

555

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

554

if file:

556

if file:

555

if self.__verifyFile(file, False):

557

if self.__verifyFile(file, False):

556

fileOk_flag = True

558

fileOk_flag = True

557

559

558

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

560

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

559

if not(fileOk_flag):

561

if not(fileOk_flag):

560

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

562

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

561

563

562

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

564

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

563

tries = self.nTries

565

tries = self.nTries

564

else:

566

else:

565

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

567

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

566

568

567

for nTries in range( tries ):

569

for nTries in range( tries ):

568

if firstTime_flag:

570

if firstTime_flag:

569

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

571

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

570

time.sleep( self.delay )

572

time.sleep( self.delay )

571

else:

573

else:

572

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

574

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

573

575

574

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

576

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

575

if file:

577

if file:

576

if self.__verifyFile(file):

578

if self.__verifyFile(file):

577

fileOk_flag = True

579

fileOk_flag = True

578

break

580

break

579

581

580

if fileOk_flag:

582

if fileOk_flag:

581

break

583

break

582

584

583

firstTime_flag = False

585

firstTime_flag = False

584

586

585

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

587

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

586

self.set += 1

588

self.set += 1

587

589

588

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

590

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

589

self.set = 0

591

self.set = 0

590

self.doy += 1

592

self.doy += 1

591

593

592

if fileOk_flag:

594

if fileOk_flag:

593

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

595

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

594

self.filename = file

596

self.filename = file

595

self.flagIsNewFile = 1

597

self.flagIsNewFile = 1

596

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

598

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

597

self.fp = open(file)

599

self.fp = open(file)

598

self.flagNoMoreFiles = 0

600

self.flagNoMoreFiles = 0

599

print 'Setting the file: %s' % file

601

print 'Setting the file: %s' % file

600

else:

602

else:

601

self.fileSize = 0

603

self.fileSize = 0

602

self.filename = None

604

self.filename = None

603

self.flagIsNewFile = 0

605

self.flagIsNewFile = 0

604

self.fp = None

606

self.fp = None

605

self.flagNoMoreFiles = 1

607

self.flagNoMoreFiles = 1

606

print 'No more Files'

608

print 'No more Files'

607

609

608

return fileOk_flag

610

return fileOk_flag

609

611

610

612

611

def setNextFile(self):

613

def setNextFile(self):

612

if self.fp != None:

614

if self.fp != None:

613

self.fp.close()

615

self.fp.close()

614

616

615

if self.online:

617

if self.online:

616

newFile = self.__setNextFileOnline()

618

newFile = self.__setNextFileOnline()

617

else:

619

else:

618

newFile = self.__setNextFileOffline()

620

newFile = self.__setNextFileOffline()

619

621

620

if not(newFile):

622

if not(newFile):

621

return 0

623

return 0

622

624

623

self.__readFirstHeader()

625

self.__readFirstHeader()

624

self.nReadBlocks = 0

626

self.nReadBlocks = 0

625

return 1

627

return 1

626

628

627

def __setNewBlock(self):

629

def __setNewBlock(self):

628

if self.fp == None:

630

if self.fp == None:

629

return 0

631

return 0

630

632

631

if self.flagIsNewFile:

633

if self.flagIsNewFile:

632

return 1

634

return 1

633

635

634

self.lastUTTime = self.basicHeaderObj.utc

636

self.lastUTTime = self.basicHeaderObj.utc

635

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

637

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

636

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

638

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

637

639

638

if (currentSize >= neededSize):

640

if (currentSize >= neededSize):

639

self.__rdBasicHeader()

641

self.__rdBasicHeader()

640

return 1

642

return 1

641

643

642

if not(self.setNextFile()):

644

if not(self.setNextFile()):

643

return 0

645

return 0

644

646

645

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

647

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

646

648

647

self.flagTimeBlock = 0

649

self.flagTimeBlock = 0

648

650

649

if deltaTime > self.maxTimeStep:

651

if deltaTime > self.maxTimeStep:

650

self.flagTimeBlock = 1

652

self.flagTimeBlock = 1

651

653

652

return 1

654

return 1

653

655

654

656

655

def readNextBlock(self):

657

def readNextBlock(self):

656

if not(self.__setNewBlock()):

658

if not(self.__setNewBlock()):

657

return 0

659

return 0

658

660

659

if not(self.readBlock()):

661

if not(self.readBlock()):

660

return 0

662

return 0

661

663

662

return 1

664

return 1

663

665

664

def __rdProcessingHeader(self, fp=None):

666

def __rdProcessingHeader(self, fp=None):

665

if fp == None:

667

if fp == None:

666

fp = self.fp

668

fp = self.fp

667

669

668

self.processingHeaderObj.read(fp)

670

self.processingHeaderObj.read(fp)

669

671

670

def __rdRadarControllerHeader(self, fp=None):

672

def __rdRadarControllerHeader(self, fp=None):

671

if fp == None:

673

if fp == None:

672

fp = self.fp

674

fp = self.fp

673

675

674

self.radarControllerHeaderObj.read(fp)

676

self.radarControllerHeaderObj.read(fp)

675

677

676

def __rdSystemHeader(self, fp=None):

678

def __rdSystemHeader(self, fp=None):

677

if fp == None:

679

if fp == None:

678

fp = self.fp

680

fp = self.fp

679

681

680

self.systemHeaderObj.read(fp)

682

self.systemHeaderObj.read(fp)

681

683

682

def __rdBasicHeader(self, fp=None):

684

def __rdBasicHeader(self, fp=None):

683

if fp == None:

685

if fp == None:

684

fp = self.fp

686

fp = self.fp

685

687

686

self.basicHeaderObj.read(fp)

688

self.basicHeaderObj.read(fp)

687

689

688

690

689

def __readFirstHeader(self):

691

def __readFirstHeader(self):

690

self.__rdBasicHeader()

692

self.__rdBasicHeader()

691

self.__rdSystemHeader()

693

self.__rdSystemHeader()

692

self.__rdRadarControllerHeader()

694

self.__rdRadarControllerHeader()

693

self.__rdProcessingHeader()

695

self.__rdProcessingHeader()

694

696

695

self.firstHeaderSize = self.basicHeaderObj.size

697

self.firstHeaderSize = self.basicHeaderObj.size

696

698

697

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

699

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

698

if datatype == 0:

700

if datatype == 0:

699

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

701

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

700

elif datatype == 1:

702

elif datatype == 1:

701

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

703

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

702

elif datatype == 2:

704

elif datatype == 2:

703

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

705

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

704

elif datatype == 3:

706

elif datatype == 3:

705

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

707

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

706

elif datatype == 4:

708

elif datatype == 4:

707

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

709

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

708

elif datatype == 5:

710

elif datatype == 5:

709

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

711

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

710

else:

712

else:

711

raise ValueError, 'Data type was not defined'

713

raise ValueError, 'Data type was not defined'

712

714

713

self.dtype = datatype_str

715

self.dtype = datatype_str

714

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

716

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

715

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

717

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

716

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

718

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

717

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

719

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

718

self.getBlockDimension()

720

self.getBlockDimension()

719

721

720

722

721

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

723

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

722

msg = None

724

msg = None

723

try:

725

try:

724

fp = open(filename, 'rb')

726

fp = open(filename, 'rb')

725

currentPosition = fp.tell()

727

currentPosition = fp.tell()

726

except:

728

except:

727

if msgFlag:

729

if msgFlag:

728

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

730

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

729

return False

731

return False

730

732

731

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

733

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

732

734

733

if neededSize == 0:

735

if neededSize == 0:

734

basicHeaderObj = BasicHeader()

736

basicHeaderObj = BasicHeader()

735

systemHeaderObj = SystemHeader()

737

systemHeaderObj = SystemHeader()

736

radarControllerHeaderObj = RadarControllerHeader()

738

radarControllerHeaderObj = RadarControllerHeader()

737

processingHeaderObj = ProcessingHeader()

739

processingHeaderObj = ProcessingHeader()

738

740

739

try:

741

try:

740

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

742

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

741

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

743

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

742

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

744

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

743

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

745

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

744

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

746

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

745

747

746

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

748

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

747

749

748

except:

750

except:

749

if msgFlag:

751

if msgFlag:

750

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

752

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

751

753

752

fp.close()

754

fp.close()

753

return False

755

return False

754

else:

756

else:

755

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

757

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

756

758

757

fp.close()

759

fp.close()

758

fileSize = os.path.getsize(filename)

760

fileSize = os.path.getsize(filename)

759

currentSize = fileSize - currentPosition

761

currentSize = fileSize - currentPosition

760

if currentSize < neededSize:

762

if currentSize < neededSize:

761

if msgFlag and (msg != None):

763

if msgFlag and (msg != None):

762

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

764

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

763

return False

765

return False

764

766

765

return True

767

return True

766

768

767

def getData():

769

def getData():

768

pass

770

pass

769

771

770

def hasNotDataInBuffer():

772

def hasNotDataInBuffer():

771

pass

773

pass

772

774

773

def readBlock():

775

def readBlock():

774

pass

776

pass

775

777

776

def run(self, **kwargs):

778

def run(self, **kwargs):

777

779

778

if not(self.isConfig):

780

if not(self.isConfig):

779

781

780

# self.dataOut = dataOut

782

# self.dataOut = dataOut

781

self.setup(**kwargs)

783

self.setup(**kwargs)

782

self.isConfig = True

784

self.isConfig = True

783

785

784

self.getData()

786

self.getData()

785

787

786

class JRODataWriter(JRODataIO):

788

class JRODataWriter(JRODataIO):

787

789

788

"""

790

"""

789

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

791

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

790

de los datos siempre se realiza por bloques.

792

de los datos siempre se realiza por bloques.

791

"""

793

"""

792

794

793

blockIndex = 0

795

blockIndex = 0

794

796

795

path = None

797

path = None

796

798

797

setFile = None

799

setFile = None

798

800

799

profilesPerBlock = None

801

profilesPerBlock = None

800

802

801

blocksPerFile = None

803

blocksPerFile = None

802

804

803

nWriteBlocks = 0

805

nWriteBlocks = 0

804

806

805

def __init__(self, dataOut=None):

807

def __init__(self, dataOut=None):

806

raise ValueError, "Not implemented"

808

raise ValueError, "Not implemented"

807

809

808

810

809

def hasAllDataInBuffer(self):

811

def hasAllDataInBuffer(self):

810

raise ValueError, "Not implemented"

812

raise ValueError, "Not implemented"

811

813

812

814

813

def setBlockDimension(self):

815

def setBlockDimension(self):

814

raise ValueError, "Not implemented"

816

raise ValueError, "Not implemented"

815

817

816

818

817

def writeBlock(self):

819

def writeBlock(self):

818

raise ValueError, "No implemented"

820

raise ValueError, "No implemented"

819

821

820

822

821

def putData(self):

823

def putData(self):

822

raise ValueError, "No implemented"

824

raise ValueError, "No implemented"

823

825

824

def getDataHeader(self):

826

def getDataHeader(self):

825

"""

827

"""

826

Obtiene una copia del First Header

828

Obtiene una copia del First Header

827

829

828

Affected:

830

Affected:

829

831

830

self.basicHeaderObj

832

self.basicHeaderObj

831

self.systemHeaderObj

833

self.systemHeaderObj

832

self.radarControllerHeaderObj

834

self.radarControllerHeaderObj

833

self.processingHeaderObj self.

835

self.processingHeaderObj self.

834

836

835

Return:

837

Return:

836

None

838

None

837

"""

839

"""

838

840

839

raise ValueError, "No implemented"

841

raise ValueError, "No implemented"

840

842

841

def getBasicHeader(self):

843

def getBasicHeader(self):

842

844

843

self.basicHeaderObj.size = self.basicHeaderSize #bytes

845

self.basicHeaderObj.size = self.basicHeaderSize #bytes

844

self.basicHeaderObj.version = self.versionFile

846

self.basicHeaderObj.version = self.versionFile

845

self.basicHeaderObj.dataBlock = self.nTotalBlocks

847

self.basicHeaderObj.dataBlock = self.nTotalBlocks

846

848

847

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

849

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

848

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

850

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

849

851

850

self.basicHeaderObj.utc = utc

852

self.basicHeaderObj.utc = utc

851

self.basicHeaderObj.miliSecond = milisecond

853

self.basicHeaderObj.miliSecond = milisecond

852

self.basicHeaderObj.timeZone = 0

854

self.basicHeaderObj.timeZone = 0

853

self.basicHeaderObj.dstFlag = 0

855

self.basicHeaderObj.dstFlag = 0

854

self.basicHeaderObj.errorCount = 0

856

self.basicHeaderObj.errorCount = 0

855

857

856

def __writeFirstHeader(self):

858

def __writeFirstHeader(self):

857

"""

859

"""

858

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

860

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

859

861

860

Affected:

862

Affected:

861

__dataType

863

__dataType

862

864

863

Return:

865

Return:

864

None

866

None

865

"""

867

"""

866

868

867

# CALCULAR PARAMETROS

869

# CALCULAR PARAMETROS

868

870

869

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

871

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

870

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

872

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

871

873

872

self.basicHeaderObj.write(self.fp)

874

self.basicHeaderObj.write(self.fp)

873

self.systemHeaderObj.write(self.fp)

875

self.systemHeaderObj.write(self.fp)

874

self.radarControllerHeaderObj.write(self.fp)

876

self.radarControllerHeaderObj.write(self.fp)

875

self.processingHeaderObj.write(self.fp)

877

self.processingHeaderObj.write(self.fp)

876

878

877

self.dtype = self.dataOut.dtype

879

self.dtype = self.dataOut.dtype

878

880

879

def __setNewBlock(self):

881

def __setNewBlock(self):

880

"""

882

"""

881

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

883

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

882

884

883

Return:

885

Return:

884

0 : si no pudo escribir nada

886

0 : si no pudo escribir nada

885

1 : Si escribio el Basic el First Header

887

1 : Si escribio el Basic el First Header

886

"""

888

"""

887

if self.fp == None:

889

if self.fp == None:

888

self.setNextFile()

890

self.setNextFile()

889

891

890

if self.flagIsNewFile:

892

if self.flagIsNewFile:

891

return 1

893

return 1

892

894

893

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

895

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

894

self.basicHeaderObj.write(self.fp)

896

self.basicHeaderObj.write(self.fp)

895

return 1

897

return 1

896

898

897

if not( self.setNextFile() ):

899

if not( self.setNextFile() ):

898

return 0

900

return 0

899

901

900

return 1

902

return 1

901

903

902

904

903

def writeNextBlock(self):

905

def writeNextBlock(self):

904

"""

906

"""

905

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

907

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

906

908

907

Return:

909

Return:

908

0 : Si no hizo pudo escribir el bloque de datos

910

0 : Si no hizo pudo escribir el bloque de datos

909

1 : Si no pudo escribir el bloque de datos

911

1 : Si no pudo escribir el bloque de datos

910

"""

912

"""

911

if not( self.__setNewBlock() ):

913

if not( self.__setNewBlock() ):

912

return 0

914

return 0

913

915

914

self.writeBlock()

916

self.writeBlock()

915

917

916

return 1

918

return 1

917

919

918

def setNextFile(self):

920

def setNextFile(self):

919

"""

921

"""

920

Determina el siguiente file que sera escrito

922

Determina el siguiente file que sera escrito

921

923

922

Affected:

924

Affected:

923

self.filename

925

self.filename

924

self.subfolder

926

self.subfolder

925

self.fp

927

self.fp

926

self.setFile

928

self.setFile

927

self.flagIsNewFile

929

self.flagIsNewFile

928

930

929

Return:

931

Return:

930

0 : Si el archivo no puede ser escrito

932

0 : Si el archivo no puede ser escrito

931

1 : Si el archivo esta listo para ser escrito

933

1 : Si el archivo esta listo para ser escrito

932

"""

934

"""

933

ext = self.ext

935

ext = self.ext

934

path = self.path

936

path = self.path

935

937

936

if self.fp != None:

938

if self.fp != None:

937

self.fp.close()

939

self.fp.close()

938

940

939

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

941

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

940

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

942

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

941

943

942

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

944

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

943

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

945

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

944

os.mkdir(doypath)

946

os.mkdir(doypath)

945

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

947

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

946

else:

948

else:

947

filesList = os.listdir( doypath )

949

filesList = os.listdir( doypath )

948

if len( filesList ) > 0:

950

if len( filesList ) > 0:

949

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

951

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

950

filen = filesList[-1]

952

filen = filesList[-1]

951

# el filename debera tener el siguiente formato

953

# el filename debera tener el siguiente formato

952

# 0 1234 567 89A BCDE (hex)

954

# 0 1234 567 89A BCDE (hex)

953

# x YYYY DDD SSS .ext

955

# x YYYY DDD SSS .ext

954

if isNumber( filen[8:11] ):

956

if isNumber( filen[8:11] ):

955

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

957

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

956

else:

958

else:

957

self.setFile = -1

959

self.setFile = -1

958

else:

960

else:

959

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

961

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

960

962

961

setFile = self.setFile

963

setFile = self.setFile

962

setFile += 1

964

setFile += 1

963

965

964

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

966

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

965

timeTuple.tm_year,

967

timeTuple.tm_year,

966

timeTuple.tm_yday,

968

timeTuple.tm_yday,

967

setFile,

969

setFile,

968

ext )

970

ext )

969

971

970

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

972

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

971

973

972

fp = open( filename,'wb' )

974

fp = open( filename,'wb' )

973

975

974

self.blockIndex = 0

976

self.blockIndex = 0

975

977

976

#guardando atributos

978

#guardando atributos

977

self.filename = filename

979

self.filename = filename

978

self.subfolder = subfolder

980

self.subfolder = subfolder

979

self.fp = fp

981

self.fp = fp

980

self.setFile = setFile

982

self.setFile = setFile

981

self.flagIsNewFile = 1

983

self.flagIsNewFile = 1

982

984

983

self.getDataHeader()

985

self.getDataHeader()

984

986

985

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

987

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

986

988

987

self.__writeFirstHeader()

989

self.__writeFirstHeader()

988

990

989

return 1

991

return 1

990

992

991

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

993

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

992

"""

994

"""

993

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

995

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

994

996

995

Inputs:

997

Inputs:

996

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

998

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

997

format : formato en el cual sera salvado un file

999

format : formato en el cual sera salvado un file

998

set : el setebo del file

1000

set : el setebo del file

999

1001

1000

Return:

1002

Return:

1001

0 : Si no realizo un buen seteo

1003

0 : Si no realizo un buen seteo

1002

1 : Si realizo un buen seteo

1004

1 : Si realizo un buen seteo

1003

"""

1005

"""

1004

1006

1005

if ext == None:

1007

if ext == None:

1006

ext = self.ext

1008

ext = self.ext

1007

1009

1008

ext = ext.lower()

1010

ext = ext.lower()

1009

1011

1010

self.ext = ext

1012

self.ext = ext

1011

1013

1012

self.path = path

1014

self.path = path

1013

1015

1014

self.setFile = set - 1

1016

self.setFile = set - 1

1015

1017

1016

self.blocksPerFile = blocksPerFile

1018

self.blocksPerFile = blocksPerFile

1017

1019

1018

self.profilesPerBlock = profilesPerBlock

1020

self.profilesPerBlock = profilesPerBlock

1019

1021

1020

self.dataOut = dataOut

1022

self.dataOut = dataOut

1021

1023

1022

if not(self.setNextFile()):

1024

if not(self.setNextFile()):

1023

print "There isn't a next file"

1025

print "There isn't a next file"

1024

return 0

1026

return 0

1025

1027

1026

self.setBlockDimension()

1028

self.setBlockDimension()

1027

1029

1028

return 1

1030

return 1

1029

1031

1030

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

1032

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

1031

1033

1032

if not(self.isConfig):

1034

if not(self.isConfig):

1033

1035

1034

self.setup(dataOut, **kwargs)

1036

self.setup(dataOut, **kwargs)

1035

self.isConfig = True

1037

self.isConfig = True

1036

1038

1037

self.putData()

1039

self.putData()

1038

1040

1039

class VoltageReader(JRODataReader):

1041

class VoltageReader(JRODataReader):

1040

"""

1042

"""

1041

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

1043

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

1042

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

1044

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

1043

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

1045

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

1044

1046

1045

perfiles * alturas * canales

1047

perfiles * alturas * canales

1046

1048

1047

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

1049

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

1048

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

1050

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

1049

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

1051

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

1050

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

1052

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

1051

1053

1052

Example:

1054

Example:

1053

1055

1054

dpath = "/home/myuser/data"

1056

dpath = "/home/myuser/data"

1055

1057

1056

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

1058

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

1057

1059

1058

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

1060

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

1059

1061

1060

readerObj = VoltageReader()

1062

readerObj = VoltageReader()

1061

1063

1062

readerObj.setup(dpath, startTime, endTime)

1064

readerObj.setup(dpath, startTime, endTime)

1063

1065

1064

while(True):

1066

while(True):

1065

1067

1066

#to get one profile

1068

#to get one profile

1067

profile = readerObj.getData()

1069

profile = readerObj.getData()

1068

1070

1069

#print the profile

1071

#print the profile

1070

print profile

1072

print profile

1071

1073

1072

#If you want to see all datablock

1074

#If you want to see all datablock

1073

print readerObj.datablock

1075

print readerObj.datablock

1074

1076

1075

if readerObj.flagNoMoreFiles:

1077

if readerObj.flagNoMoreFiles:

1076

break

1078

break

1077

1079

1078

"""

1080

"""

1079

1081

1080

ext = ".r"

1082

ext = ".r"

1081

1083

1082

optchar = "D"

1084

optchar = "D"

1083

dataOut = None

1085

dataOut = None

1084

1086

1085

1087

1086

def __init__(self):

1088

def __init__(self):

1087

"""

1089

"""

1088

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

1090

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

1089

1091

1090

Input:

1092

Input:

1091

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

1093

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

1092

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

1094

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

1093

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

1095

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

1094

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

1096

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

1095

bloque de datos.

1097

bloque de datos.

1096

Si este parametro no es pasado se creara uno internamente.

1098

Si este parametro no es pasado se creara uno internamente.

1097

1099

1098

Variables afectadas:

1100

Variables afectadas:

1099

self.dataOut

1101

self.dataOut

1100

1102

1101

Return:

1103

Return:

1102

None

1104

None

1103

"""

1105

"""

1104

1106

1105

self.isConfig = False

1107

self.isConfig = False

1106

1108

1107

self.datablock = None

1109

self.datablock = None

1108

1110

1109

self.utc = 0

1111

self.utc = 0

1110

1112

1111

self.ext = ".r"

1113

self.ext = ".r"

1112

1114

1113

self.optchar = "D"

1115

self.optchar = "D"

1114

1116

1115

self.basicHeaderObj = BasicHeader()

1117

self.basicHeaderObj = BasicHeader()

1116

1118

1117

self.systemHeaderObj = SystemHeader()

1119

self.systemHeaderObj = SystemHeader()

1118

1120

1119

self.radarControllerHeaderObj = RadarControllerHeader()

1121

self.radarControllerHeaderObj = RadarControllerHeader()

1120

1122

1121

self.processingHeaderObj = ProcessingHeader()

1123

self.processingHeaderObj = ProcessingHeader()

1122

1124

1123

self.online = 0

1125

self.online = 0

1124

1126

1125

self.fp = None

1127

self.fp = None

1126

1128

1127

self.idFile = None

1129

self.idFile = None

1128

1130

1129

self.dtype = None

1131

self.dtype = None

1130

1132

1131

self.fileSizeByHeader = None

1133

self.fileSizeByHeader = None

1132

1134

1133

self.filenameList = []

1135

self.filenameList = []

1134

1136

1135

self.filename = None

1137

self.filename = None

1136

1138

1137

self.fileSize = None

1139

self.fileSize = None

1138

1140

1139

self.firstHeaderSize = 0

1141

self.firstHeaderSize = 0

1140

1142

1141

self.basicHeaderSize = 24

1143

self.basicHeaderSize = 24

1142

1144

1143

self.pathList = []

1145

self.pathList = []

1144

1146

1145

self.filenameList = []

1147

self.filenameList = []

1146

1148

1147

self.lastUTTime = 0

1149

self.lastUTTime = 0

1148

1150

1149

self.maxTimeStep = 30

1151

self.maxTimeStep = 30

1150

1152

1151

self.flagNoMoreFiles = 0

1153

self.flagNoMoreFiles = 0

1152

1154

1153

self.set = 0

1155

self.set = 0

1154

1156

1155

self.path = None

1157

self.path = None

1156

1158

1157

self.profileIndex = 9999

1159

self.profileIndex = 9999

1158

1160

1159

self.delay = 3 #seconds

1161

self.delay = 3 #seconds

1160

1162

1161

self.nTries = 3 #quantity tries

1163

self.nTries = 3 #quantity tries

1162

1164

1163

self.nFiles = 3 #number of files for searching

1165

self.nFiles = 3 #number of files for searching

1164

1166

1165

self.nReadBlocks = 0

1167

self.nReadBlocks = 0

1166

1168

1167

self.flagIsNewFile = 1

1169

self.flagIsNewFile = 1

1168

1170

1169

self.ippSeconds = 0

1171

self.ippSeconds = 0

1170

1172

1171

self.flagTimeBlock = 0

1173

self.flagTimeBlock = 0

1172

1174

1173

self.flagIsNewBlock = 0

1175

self.flagIsNewBlock = 0

1174

1176

1175

self.nTotalBlocks = 0

1177

self.nTotalBlocks = 0

1176

1178

1177

self.blocksize = 0

1179

self.blocksize = 0

1178

1180

1179

self.dataOut = self.createObjByDefault()

1181

self.dataOut = self.createObjByDefault()

1180

1182

1181

def createObjByDefault(self):

1183

def createObjByDefault(self):

1182

1184

1183

dataObj = Voltage()

1185

dataObj = Voltage()

1184

1186

1185

return dataObj

1187

return dataObj

1186

1188

1187

def __hasNotDataInBuffer(self):

1189

def __hasNotDataInBuffer(self):

1188

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

1190

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

1189

return 1

1191

return 1

1190

return 0

1192

return 0

1191

1193

1192

1194

1193

def getBlockDimension(self):

1195

def getBlockDimension(self):

1194

"""

1196

"""

1195

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

1196

1198

1197

Affected:

1199

Affected:

1198

self.blocksize

1200

self.blocksize

1199

1201

1200

Return:

1202

Return:

1201

None

1203

None

1202

"""

1204

"""

1203

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

1205

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

1204

self.blocksize = pts2read

1206

self.blocksize = pts2read

1205

1207

1206

1208

1207

def readBlock(self):

1209

def readBlock(self):

1208

"""

1210

"""

1209

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

1210

(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

1211

(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

1212

es seteado a 0

1214

es seteado a 0

1213

1215

1214

Inputs:

1216

Inputs:

1215

None

1217

None

1216

1218

1217

Return:

1219

Return:

1218

None

1220

None

1219

1221

1220

Affected:

1222

Affected:

1221

self.profileIndex

1223

self.profileIndex

1222

self.datablock

1224

self.datablock

1223

self.flagIsNewFile

1225

self.flagIsNewFile

1224

self.flagIsNewBlock

1226

self.flagIsNewBlock

1225

self.nTotalBlocks

1227

self.nTotalBlocks

1226

1228

1227

Exceptions:

1229

Exceptions:

1228

Si un bloque leido no es un bloque valido

1230

Si un bloque leido no es un bloque valido

1229

"""

1231

"""

1230

1232

1231

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

1233

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

1232

1234

1233

try:

1235

try:

1234

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) )

1235

except:

1237

except:

1236

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

1238

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

1237

return 0

1239

return 0

1238

1240

1239

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

1241

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

1240

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

1242

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

1241

1243

1242

self.profileIndex = 0

1244

self.profileIndex = 0

1243

1245

1244

self.flagIsNewFile = 0

1246

self.flagIsNewFile = 0

1245

self.flagIsNewBlock = 1

1247

self.flagIsNewBlock = 1

1246

1248

1247

self.nTotalBlocks += 1

1249

self.nTotalBlocks += 1

1248

self.nReadBlocks += 1

1250

self.nReadBlocks += 1

1249

1251

1250

return 1

1252

return 1

1251

1253

1252

1254

1253

def getData(self):

1255

def getData(self):

1254

"""

1256

"""

1255

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"

1256

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

1257

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"

1258

1260

1259

Ademas incrementa el contador del buffer en 1.

1261

Ademas incrementa el contador del buffer en 1.

1260

1262

1261

Return:

1263

Return:

1262

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

1264

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

1263

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

1265

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

1264

1266

1265

Variables afectadas:

1267

Variables afectadas:

1266

self.dataOut

1268

self.dataOut

1267

self.profileIndex

1269

self.profileIndex

1268

1270

1269

Affected:

1271

Affected:

1270

self.dataOut

1272

self.dataOut

1271

self.profileIndex

1273

self.profileIndex

1272

self.flagTimeBlock

1274

self.flagTimeBlock

1273

self.flagIsNewBlock

1275

self.flagIsNewBlock

1274

"""

1276

"""

1275

if self.flagNoMoreFiles: return 0

1277

if self.flagNoMoreFiles: return 0

1276

1278

1277

self.flagTimeBlock = 0

1279

self.flagTimeBlock = 0

1278

self.flagIsNewBlock = 0

1280

self.flagIsNewBlock = 0

1279

1281

1280

if self.__hasNotDataInBuffer():

1282

if self.__hasNotDataInBuffer():

1281

1283

1282

if not( self.readNextBlock() ):

1284

if not( self.readNextBlock() ):

1283

return 0

1285

return 0

1284

1286

1285

# self.updateDataHeader()

1287

# self.updateDataHeader()

1286

1288

1287

if self.flagNoMoreFiles == 1:

1289

if self.flagNoMoreFiles == 1:

1288

print 'Process finished'

1290

print 'Process finished'

1289

return 0

1291

return 0

1290

1292

1291

#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)

1292

1294

1293

if self.datablock == None:

1295

if self.datablock == None:

1294

self.dataOut.flagNoData = True

1296

self.dataOut.flagNoData = True

1295

return 0

1297

return 0

1296

1298

1297

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

1299

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

1298

1300

1299

self.dataOut.dtype = self.dtype

1301

self.dataOut.dtype = self.dtype

1300

1302

1301

self.dataOut.nChannels = self.systemHeaderObj.nChannels

1303

self.dataOut.nChannels = self.systemHeaderObj.nChannels

1302

1304

1303

self.dataOut.nHeights = self.processingHeaderObj.nHeights

1305

self.dataOut.nHeights = self.processingHeaderObj.nHeights

1304

1306

1305

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1307

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1306

1308

1307

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

1309

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

1308

1310

1309

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

1311

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

1310

1312

1311

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

1313

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

1312

1314

1313

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

1315

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

1314

1316

1315

self.dataOut.flagTimeBlock = self.flagTimeBlock

1317

self.dataOut.flagTimeBlock = self.flagTimeBlock

1316

1318

1317

self.dataOut.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

1318

1320

1319

self.dataOut.ippSeconds = self.ippSeconds

1321

self.dataOut.ippSeconds = self.ippSeconds

1320

1322

1321

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

1323

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

1322

1324

1323

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1325

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1324

1326

1325

self.dataOut.flagShiftFFT = False

1327

self.dataOut.flagShiftFFT = False

1326

1328

1327

if self.processingHeaderObj.code != None:

1329

if self.processingHeaderObj.code != None:

1328

self.dataOut.nCode = self.processingHeaderObj.nCode

1330

self.dataOut.nCode = self.processingHeaderObj.nCode

1329

1331

1330

self.dataOut.nBaud = self.processingHeaderObj.nBaud

1332

self.dataOut.nBaud = self.processingHeaderObj.nBaud

1331

1333

1332

self.dataOut.code = self.processingHeaderObj.code

1334

self.dataOut.code = self.processingHeaderObj.code

1333

1335

1334

self.profileIndex += 1

1336

self.profileIndex += 1

1335

1337

1336

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

1338

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

1337

1339

1338

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

1340

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

1339

1341

1340

self.dataOut.flagNoData = False

1342

self.dataOut.flagNoData = False

1341

1343

1342

# print self.profileIndex, self.dataOut.utctime

1344

# print self.profileIndex, self.dataOut.utctime

1343

# if self.profileIndex == 800:

1345

# if self.profileIndex == 800:

1344

# a=1

1346

# a=1

1345

1347

1346

return self.dataOut.data

1348

return self.dataOut.data

1347

1349

1348

1350

1349

class VoltageWriter(JRODataWriter):

1351

class VoltageWriter(JRODataWriter):

1350

"""

1352

"""

1351

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

1352

de los datos siempre se realiza por bloques.

1354

de los datos siempre se realiza por bloques.

1353

"""

1355

"""

1354

1356

1355

ext = ".r"

1357

ext = ".r"

1356

1358

1357

optchar = "D"

1359

optchar = "D"

1358

1360

1359

shapeBuffer = None

1361

shapeBuffer = None

1360

1362

1361

1363

1362

def __init__(self):

1364

def __init__(self):

1363

"""

1365

"""

1364

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.

1365

1367

1366

Affected:

1368

Affected:

1367

self.dataOut

1369

self.dataOut

1368

1370

1369

Return: None

1371

Return: None

1370

"""

1372

"""

1371

1373

1372

self.nTotalBlocks = 0

1374

self.nTotalBlocks = 0

1373

1375

1374

self.profileIndex = 0

1376

self.profileIndex = 0

1375

1377

1376

self.isConfig = False

1378

self.isConfig = False

1377

1379

1378

self.fp = None

1380

self.fp = None

1379

1381

1380

self.flagIsNewFile = 1

1382

self.flagIsNewFile = 1

1381

1383

1382

self.nTotalBlocks = 0

1384

self.nTotalBlocks = 0

1383

1385

1384

self.flagIsNewBlock = 0

1386

self.flagIsNewBlock = 0

1385

1387

1386

self.flagNoMoreFiles = 0

1388

self.flagNoMoreFiles = 0

1387

1389

1388

self.setFile = None

1390

self.setFile = None

1389

1391

1390

self.dtype = None

1392

self.dtype = None

1391

1393

1392

self.path = None

1394

self.path = None

1393

1395

1394

self.noMoreFiles = 0

1396

self.noMoreFiles = 0

1395

1397

1396

self.filename = None

1398

self.filename = None

1397

1399

1398

self.basicHeaderObj = BasicHeader()

1400

self.basicHeaderObj = BasicHeader()

1399

1401

1400

self.systemHeaderObj = SystemHeader()

1402

self.systemHeaderObj = SystemHeader()

1401

1403

1402

self.radarControllerHeaderObj = RadarControllerHeader()

1404

self.radarControllerHeaderObj = RadarControllerHeader()

1403

1405

1404

self.processingHeaderObj = ProcessingHeader()

1406

self.processingHeaderObj = ProcessingHeader()

1405

1407

1406

def hasAllDataInBuffer(self):

1408

def hasAllDataInBuffer(self):

1407

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

1409

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

1408

return 1

1410

return 1

1409

return 0

1411

return 0

1410

1412

1411

1413

1412

def setBlockDimension(self):

1414

def setBlockDimension(self):

1413

"""

1415

"""

1414

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

1416

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

1415

1417

1416

Affected:

1418

Affected:

1417

self.shape_spc_Buffer

1419

self.shape_spc_Buffer

1418

self.shape_cspc_Buffer

1420

self.shape_cspc_Buffer

1419

self.shape_dc_Buffer

1421

self.shape_dc_Buffer

1420

1422

1421

Return: None

1423

Return: None

1422

"""

1424

"""

1423

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1425

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1424

self.processingHeaderObj.nHeights,

1426

self.processingHeaderObj.nHeights,

1425

self.systemHeaderObj.nChannels)

1427

self.systemHeaderObj.nChannels)

1426

1428

1427

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

1429

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

1428

self.processingHeaderObj.profilesPerBlock,

1430

self.processingHeaderObj.profilesPerBlock,

1429

self.processingHeaderObj.nHeights),

1431

self.processingHeaderObj.nHeights),

1430

dtype=numpy.dtype('complex'))

1432

dtype=numpy.dtype('complex'))

1431

1433

1432

1434

1433

def writeBlock(self):

1435

def writeBlock(self):

1434

"""

1436

"""

1435

Escribe el buffer en el file designado

1437

Escribe el buffer en el file designado

1436

1438

1437

Affected:

1439

Affected:

1438

self.profileIndex

1440

self.profileIndex

1439

self.flagIsNewFile

1441

self.flagIsNewFile

1440

self.flagIsNewBlock

1442

self.flagIsNewBlock

1441

self.nTotalBlocks

1443

self.nTotalBlocks

1442

self.blockIndex

1444

self.blockIndex

1443

1445

1444

Return: None

1446

Return: None

1445

"""

1447

"""

1446

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

1448

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

1447

1449

1448

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

1450

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

1449

1451

1450

data['real'] = junk.real

1452

data['real'] = junk.real

1451

data['imag'] = junk.imag

1453

data['imag'] = junk.imag

1452

1454

1453

data = data.reshape( (-1) )

1455

data = data.reshape( (-1) )

1454

1456

1455

data.tofile( self.fp )

1457

data.tofile( self.fp )

1456

1458

1457

self.datablock.fill(0)

1459

self.datablock.fill(0)

1458

1460

1459

self.profileIndex = 0

1461

self.profileIndex = 0

1460

self.flagIsNewFile = 0

1462

self.flagIsNewFile = 0

1461

self.flagIsNewBlock = 1

1463

self.flagIsNewBlock = 1

1462

1464

1463

self.blockIndex += 1

1465

self.blockIndex += 1

1464

self.nTotalBlocks += 1

1466

self.nTotalBlocks += 1

1465

1467

1466

def putData(self):

1468

def putData(self):

1467

"""

1469

"""

1468

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

1470

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

1469

1471

1470

Affected:

1472

Affected:

1471

self.flagIsNewBlock

1473

self.flagIsNewBlock

1472

self.profileIndex

1474

self.profileIndex

1473

1475

1474

Return:

1476

Return:

1475

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

1477

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

1476

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

1478

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

1477

"""

1479

"""

1478

if self.dataOut.flagNoData:

1480

if self.dataOut.flagNoData:

1479

return 0

1481

return 0

1480

1482

1481

self.flagIsNewBlock = 0

1483

self.flagIsNewBlock = 0

1482

1484

1483

if self.dataOut.flagTimeBlock:

1485

if self.dataOut.flagTimeBlock:

1484

1486

1485

self.datablock.fill(0)

1487

self.datablock.fill(0)

1486

self.profileIndex = 0

1488

self.profileIndex = 0

1487

self.setNextFile()

1489

self.setNextFile()

1488

1490

1489

if self.profileIndex == 0:

1491

if self.profileIndex == 0:

1490

self.getBasicHeader()

1492

self.getBasicHeader()

1491

1493

1492

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

1494

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

1493

1495

1494

self.profileIndex += 1

1496

self.profileIndex += 1

1495

1497

1496

if self.hasAllDataInBuffer():

1498

if self.hasAllDataInBuffer():

1497

#if self.flagIsNewFile:

1499

#if self.flagIsNewFile:

1498

self.writeNextBlock()

1500

self.writeNextBlock()

1499

# self.getDataHeader()

1501

# self.getDataHeader()

1500

1502

1501

if self.flagNoMoreFiles:

1503

if self.flagNoMoreFiles:

1502

#print 'Process finished'

1504

#print 'Process finished'

1503

return 0

1505

return 0

1504

1506

1505

return 1

1507

return 1

1506

1508

1507

def __getProcessFlags(self):

1509

def __getProcessFlags(self):

1508

1510

1509

processFlags = 0

1511

processFlags = 0

1510

1512

1511

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

1513

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

1512

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

1514

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

1513

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

1515

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

1514

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

1516

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

1515

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

1517

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

1516

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

1518

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

1517

1519

1518

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

1520

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

1519

1521

1520

1522

1521

1523

1522

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1524

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1523

PROCFLAG.DATATYPE_SHORT,

1525

PROCFLAG.DATATYPE_SHORT,

1524

PROCFLAG.DATATYPE_LONG,

1526

PROCFLAG.DATATYPE_LONG,

1525

PROCFLAG.DATATYPE_INT64,

1527

PROCFLAG.DATATYPE_INT64,

1526

PROCFLAG.DATATYPE_FLOAT,

1528

PROCFLAG.DATATYPE_FLOAT,

1527

PROCFLAG.DATATYPE_DOUBLE]

1529

PROCFLAG.DATATYPE_DOUBLE]

1528

1530

1529

1531

1530

for index in range(len(dtypeList)):

1532

for index in range(len(dtypeList)):

1531

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

1533

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

1532

dtypeValue = datatypeValueList[index]

1534

dtypeValue = datatypeValueList[index]

1533

break

1535

break

1534

1536

1535

processFlags += dtypeValue

1537

processFlags += dtypeValue

1536

1538

1537

if self.dataOut.flagDecodeData:

1539

if self.dataOut.flagDecodeData:

1538

processFlags += PROCFLAG.DECODE_DATA

1540

processFlags += PROCFLAG.DECODE_DATA

1539

1541

1540

if self.dataOut.flagDeflipData:

1542

if self.dataOut.flagDeflipData:

1541

processFlags += PROCFLAG.DEFLIP_DATA

1543

processFlags += PROCFLAG.DEFLIP_DATA

1542

1544

1543

if self.dataOut.code != None:

1545

if self.dataOut.code != None:

1544

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1546

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1545

1547

1546

if self.dataOut.nCohInt > 1:

1548

if self.dataOut.nCohInt > 1:

1547

processFlags += PROCFLAG.COHERENT_INTEGRATION

1549

processFlags += PROCFLAG.COHERENT_INTEGRATION

1548

1550

1549

return processFlags

1551

return processFlags

1550

1552

1551

1553

1552

def __getBlockSize(self):

1554

def __getBlockSize(self):

1553

'''

1555

'''

1554

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

1556

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

1555

'''

1557

'''

1556

1558

1557

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

1559

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

1558

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

1560

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

1559

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

1561

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

1560

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

1562

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

1561

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

1563

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

1562

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

1564

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

1563

1565

1564

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

1566

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

1565

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

1567

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

1566

for index in range(len(dtypeList)):

1568

for index in range(len(dtypeList)):

1567

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

1569

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

1568

datatypeValue = datatypeValueList[index]

1570

datatypeValue = datatypeValueList[index]

1569

break

1571

break

1570

1572

1571

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

1573

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

1572

1574

1573

return blocksize

1575

return blocksize

1574

1576

1575

def getDataHeader(self):

1577

def getDataHeader(self):

1576

1578

1577

"""

1579

"""

1578

Obtiene una copia del First Header

1580

Obtiene una copia del First Header

1579

1581

1580

Affected:

1582

Affected:

1581

self.systemHeaderObj

1583

self.systemHeaderObj

1582

self.radarControllerHeaderObj

1584

self.radarControllerHeaderObj

1583

self.dtype

1585

self.dtype

1584

1586

1585

Return:

1587

Return:

1586

None

1588

None

1587

"""

1589

"""

1588

1590

1589

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

1591

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

1590

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1592

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1591

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

1593

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

1592

1594

1593

self.getBasicHeader()

1595

self.getBasicHeader()

1594

1596

1595

processingHeaderSize = 40 # bytes

1597

processingHeaderSize = 40 # bytes

1596

self.processingHeaderObj.dtype = 0 # Voltage

1598

self.processingHeaderObj.dtype = 0 # Voltage

1597

self.processingHeaderObj.blockSize = self.__getBlockSize()

1599

self.processingHeaderObj.blockSize = self.__getBlockSize()

1598

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1600

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1599

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1601

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1600

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

1602

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

1601

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1603

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1602

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1604

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1603

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

1605

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

1604

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

1606

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

1605

1607

1606

if self.dataOut.code != None:

1608

if self.dataOut.code != None:

1607

self.processingHeaderObj.code = self.dataOut.code

1609

self.processingHeaderObj.code = self.dataOut.code

1608

self.processingHeaderObj.nCode = self.dataOut.nCode

1610

self.processingHeaderObj.nCode = self.dataOut.nCode

1609

self.processingHeaderObj.nBaud = self.dataOut.nBaud

1611

self.processingHeaderObj.nBaud = self.dataOut.nBaud

1610

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

1612

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

1611

processingHeaderSize += codesize

1613

processingHeaderSize += codesize

1612

1614

1613

if self.processingHeaderObj.nWindows != 0:

1615

if self.processingHeaderObj.nWindows != 0:

1614

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

1616

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

1615

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

1617

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

1616

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1618

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1617

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1619

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1618

processingHeaderSize += 12

1620

processingHeaderSize += 12

1619

1621

1620

self.processingHeaderObj.size = processingHeaderSize

1622

self.processingHeaderObj.size = processingHeaderSize

1621

1623

1622

class SpectraReader(JRODataReader):

1624

class SpectraReader(JRODataReader):

1623

"""

1625

"""

1624

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

1626

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

1625

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

1627

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

1626

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

1628

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

1627

1629

1628

paresCanalesIguales * alturas * perfiles (Self Spectra)

1630

paresCanalesIguales * alturas * perfiles (Self Spectra)

1629

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1631

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1630

canales * alturas (DC Channels)

1632

canales * alturas (DC Channels)

1631

1633

1632

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

1634

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

1633

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

1635

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

1634

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

1636

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

1635

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

1637

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

1636

1638

1637

Example:

1639

Example:

1638

dpath = "/home/myuser/data"

1640

dpath = "/home/myuser/data"

1639

1641

1640

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

1642

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

1641

1643

1642

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

1644

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

1643

1645

1644

readerObj = SpectraReader()

1646

readerObj = SpectraReader()

1645

1647

1646

readerObj.setup(dpath, startTime, endTime)

1648

readerObj.setup(dpath, startTime, endTime)

1647

1649

1648

while(True):

1650

while(True):

1649

1651

1650

readerObj.getData()

1652

readerObj.getData()

1651

1653

1652

print readerObj.data_spc

1654

print readerObj.data_spc

1653

1655

1654

print readerObj.data_cspc

1656

print readerObj.data_cspc

1655

1657

1656

print readerObj.data_dc

1658

print readerObj.data_dc

1657

1659

1658

if readerObj.flagNoMoreFiles:

1660

if readerObj.flagNoMoreFiles:

1659

break

1661

break

1660

1662

1661

"""

1663

"""

1662

1664

1663

pts2read_SelfSpectra = 0

1665

pts2read_SelfSpectra = 0

1664

1666

1665

pts2read_CrossSpectra = 0

1667

pts2read_CrossSpectra = 0

1666

1668

1667

pts2read_DCchannels = 0

1669

pts2read_DCchannels = 0

1668

1670

1669

ext = ".pdata"

1671

ext = ".pdata"

1670

1672

1671

optchar = "P"

1673

optchar = "P"

1672

1674

1673

dataOut = None

1675

dataOut = None

1674

1676

1675

nRdChannels = None

1677

nRdChannels = None

1676

1678

1677

nRdPairs = None

1679

nRdPairs = None

1678

1680

1679

rdPairList = []

1681

rdPairList = []

1680

1682

1681

1683

1682

def __init__(self):

1684

def __init__(self):

1683

"""

1685

"""

1684

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

1686

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

1685

1687

1686

Inputs:

1688

Inputs:

1687

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

1689

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

1688

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

1690

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

1689

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

1691

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

1690

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

1692

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

1691

bloque de datos.

1693

bloque de datos.

1692

Si este parametro no es pasado se creara uno internamente.

1694

Si este parametro no es pasado se creara uno internamente.

1693

1695

1694

Affected:

1696

Affected:

1695

self.dataOut

1697

self.dataOut

1696

1698

1697

Return : None

1699

Return : None

1698

"""

1700

"""

1699

1701

1700

self.isConfig = False

1702

self.isConfig = False

1701

1703

1702

self.pts2read_SelfSpectra = 0

1704

self.pts2read_SelfSpectra = 0

1703

1705

1704

self.pts2read_CrossSpectra = 0

1706

self.pts2read_CrossSpectra = 0

1705

1707

1706

self.pts2read_DCchannels = 0

1708

self.pts2read_DCchannels = 0

1707

1709

1708

self.datablock = None

1710

self.datablock = None

1709

1711

1710

self.utc = None

1712

self.utc = None

1711

1713

1712

self.ext = ".pdata"

1714

self.ext = ".pdata"

1713

1715

1714

self.optchar = "P"

1716

self.optchar = "P"

1715

1717

1716

self.basicHeaderObj = BasicHeader()

1718

self.basicHeaderObj = BasicHeader()

1717

1719

1718

self.systemHeaderObj = SystemHeader()

1720

self.systemHeaderObj = SystemHeader()

1719

1721

1720

self.radarControllerHeaderObj = RadarControllerHeader()

1722

self.radarControllerHeaderObj = RadarControllerHeader()

1721

1723

1722

self.processingHeaderObj = ProcessingHeader()

1724

self.processingHeaderObj = ProcessingHeader()

1723

1725

1724

self.online = 0

1726

self.online = 0

1725

1727

1726

self.fp = None

1728

self.fp = None

1727

1729

1728

self.idFile = None

1730

self.idFile = None

1729

1731

1730

self.dtype = None

1732

self.dtype = None

1731

1733

1732

self.fileSizeByHeader = None

1734

self.fileSizeByHeader = None

1733

1735

1734

self.filenameList = []

1736

self.filenameList = []

1735

1737

1736

self.filename = None

1738

self.filename = None

1737

1739

1738

self.fileSize = None

1740

self.fileSize = None

1739

1741

1740

self.firstHeaderSize = 0

1742

self.firstHeaderSize = 0

1741

1743

1742

self.basicHeaderSize = 24

1744

self.basicHeaderSize = 24

1743

1745

1744

self.pathList = []

1746

self.pathList = []

1745

1747

1746

self.lastUTTime = 0

1748

self.lastUTTime = 0

1747

1749

1748

self.maxTimeStep = 30

1750

self.maxTimeStep = 30

1749

1751

1750

self.flagNoMoreFiles = 0

1752

self.flagNoMoreFiles = 0

1751

1753

1752

self.set = 0

1754

self.set = 0

1753

1755

1754

self.path = None

1756

self.path = None

1755

1757

1756

self.delay = 3 #seconds

1758

self.delay = 3 #seconds

1757

1759

1758

self.nTries = 3 #quantity tries

1760

self.nTries = 3 #quantity tries

1759

1761

1760

self.nFiles = 3 #number of files for searching

1762

self.nFiles = 3 #number of files for searching

1761

1763

1762

self.nReadBlocks = 0

1764

self.nReadBlocks = 0

1763

1765

1764

self.flagIsNewFile = 1

1766

self.flagIsNewFile = 1

1765

1767

1766

self.ippSeconds = 0

1768

self.ippSeconds = 0

1767

1769

1768

self.flagTimeBlock = 0

1770

self.flagTimeBlock = 0

1769

1771

1770

self.flagIsNewBlock = 0

1772

self.flagIsNewBlock = 0

1771

1773

1772

self.nTotalBlocks = 0

1774

self.nTotalBlocks = 0

1773

1775

1774

self.blocksize = 0

1776

self.blocksize = 0

1775

1777

1776

self.dataOut = self.createObjByDefault()

1778

self.dataOut = self.createObjByDefault()

1777

1779

1778

1780

1779

def createObjByDefault(self):

1781

def createObjByDefault(self):

1780

1782

1781

dataObj = Spectra()

1783

dataObj = Spectra()

1782

1784

1783

return dataObj

1785

return dataObj

1784

1786

1785

def __hasNotDataInBuffer(self):

1787

def __hasNotDataInBuffer(self):

1786

return 1

1788

return 1

1787

1789

1788

1790

1789

def getBlockDimension(self):

1791

def getBlockDimension(self):

1790

"""

1792

"""

1791

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

1793

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

1792

1794

1793

Affected:

1795

Affected:

1794

self.nRdChannels

1796

self.nRdChannels

1795

self.nRdPairs

1797

self.nRdPairs

1796

self.pts2read_SelfSpectra

1798

self.pts2read_SelfSpectra

1797

self.pts2read_CrossSpectra

1799

self.pts2read_CrossSpectra

1798

self.pts2read_DCchannels

1800

self.pts2read_DCchannels

1799

self.blocksize

1801

self.blocksize

1800

self.dataOut.nChannels

1802

self.dataOut.nChannels

1801

self.dataOut.nPairs

1803

self.dataOut.nPairs

1802

1804

1803

Return:

1805

Return:

1804

None

1806

None

1805

"""

1807

"""

1806

self.nRdChannels = 0

1808

self.nRdChannels = 0

1807

self.nRdPairs = 0

1809

self.nRdPairs = 0

1808

self.rdPairList = []

1810

self.rdPairList = []

1809

1811

1810

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

1812

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

1811

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

1813

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

1812

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

1814

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

1813

else:

1815

else:

1814

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

1816

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

1815

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

1817

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

1816

1818

1817

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

1819

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

1818

1820

1819

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

1821

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

1820

self.blocksize = self.pts2read_SelfSpectra

1822

self.blocksize = self.pts2read_SelfSpectra

1821

1823

1822

if self.processingHeaderObj.flag_cspc:

1824

if self.processingHeaderObj.flag_cspc:

1823

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

1825

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

1824

self.blocksize += self.pts2read_CrossSpectra

1826

self.blocksize += self.pts2read_CrossSpectra

1825

1827

1826

if self.processingHeaderObj.flag_dc:

1828

if self.processingHeaderObj.flag_dc:

1827

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

1829

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

1828

self.blocksize += self.pts2read_DCchannels

1830

self.blocksize += self.pts2read_DCchannels

1829

1831

1830

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

1832

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

1831

1833

1832

1834

1833

def readBlock(self):

1835

def readBlock(self):

1834

"""

1836

"""

1835

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

1837

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

1836

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

1838

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

1837

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

1839

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

1838

es seteado a 0

1840

es seteado a 0

1839

1841

1840

Return: None

1842

Return: None

1841

1843

1842

Variables afectadas:

1844

Variables afectadas:

1843

1845

1844

self.flagIsNewFile

1846

self.flagIsNewFile

1845

self.flagIsNewBlock

1847

self.flagIsNewBlock

1846

self.nTotalBlocks

1848

self.nTotalBlocks

1847

self.data_spc

1849

self.data_spc

1848

self.data_cspc

1850

self.data_cspc

1849

self.data_dc

1851

self.data_dc

1850

1852

1851

Exceptions:

1853

Exceptions:

1852

Si un bloque leido no es un bloque valido

1854

Si un bloque leido no es un bloque valido

1853

"""

1855

"""

1854

blockOk_flag = False

1856

blockOk_flag = False

1855

fpointer = self.fp.tell()

1857

fpointer = self.fp.tell()

1856

1858

1857

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

1859

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

1858

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

1860

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

1859

1861

1860

if self.processingHeaderObj.flag_cspc:

1862

if self.processingHeaderObj.flag_cspc:

1861

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

1863

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

1862

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

1864

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

1863

1865

1864

if self.processingHeaderObj.flag_dc:

1866

if self.processingHeaderObj.flag_dc:

1865

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

1867

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

1866

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

1868

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

1867

1869

1868

1870

1869

if not(self.processingHeaderObj.shif_fft):

1871

if not(self.processingHeaderObj.shif_fft):

1870

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

1872

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

1871

1873

1872

if self.processingHeaderObj.flag_cspc:

1874

if self.processingHeaderObj.flag_cspc:

1873

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

1875

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

1874

1876

1875

1877

1876

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

1878

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

1877

self.data_spc = spc

1879

self.data_spc = spc

1878

1880

1879

if self.processingHeaderObj.flag_cspc:

1881

if self.processingHeaderObj.flag_cspc:

1880

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

1882

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

1881

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

1883

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

1882

else:

1884

else:

1883

self.data_cspc = None

1885

self.data_cspc = None

1884

1886

1885

if self.processingHeaderObj.flag_dc:

1887

if self.processingHeaderObj.flag_dc:

1886

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

1888

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

1887

else:

1889

else:

1888

self.data_dc = None

1890

self.data_dc = None

1889

1891

1890

self.flagIsNewFile = 0

1892

self.flagIsNewFile = 0

1891

self.flagIsNewBlock = 1

1893

self.flagIsNewBlock = 1

1892

1894

1893

self.nTotalBlocks += 1

1895

self.nTotalBlocks += 1

1894

self.nReadBlocks += 1

1896

self.nReadBlocks += 1

1895

1897

1896

return 1

1898

return 1

1897

1899

1898

1900

1899

def getData(self):

1901

def getData(self):

1900

"""

1902

"""

1901

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

1903

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

1902

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

1904

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

1903

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

1905

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

1904

1906

1905

Return:

1907

Return:

1906

0 : Si no hay mas archivos disponibles

1908

0 : Si no hay mas archivos disponibles

1907

1 : Si hizo una buena copia del buffer

1909

1 : Si hizo una buena copia del buffer

1908

1910

1909

Affected:

1911

Affected:

1910

self.dataOut

1912

self.dataOut

1911

1913

1912

self.flagTimeBlock

1914

self.flagTimeBlock

1913

self.flagIsNewBlock

1915

self.flagIsNewBlock

1914

"""

1916

"""

1915

1917

1916

if self.flagNoMoreFiles: return 0

1918

if self.flagNoMoreFiles: return 0

1917

1919

1918

self.flagTimeBlock = 0

1920

self.flagTimeBlock = 0

1919

self.flagIsNewBlock = 0

1921

self.flagIsNewBlock = 0

1920

1922

1921

if self.__hasNotDataInBuffer():

1923

if self.__hasNotDataInBuffer():

1922

1924

1923

if not( self.readNextBlock() ):

1925

if not( self.readNextBlock() ):

1924

return 0

1926

return 0

1925

1927

1926

# self.updateDataHeader()

1928

# self.updateDataHeader()

1927

1929

1928

if self.flagNoMoreFiles == 1:

1930

if self.flagNoMoreFiles == 1:

1929

print 'Process finished'

1931

print 'Process finished'

1930

return 0

1932

return 0

1931

1933

1932

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

1934

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

1933

1935

1934

if self.data_dc == None:

1936

if self.data_dc == None:

1935

self.dataOut.flagNoData = True

1937

self.dataOut.flagNoData = True

1936

return 0

1938

return 0

1937

1939

1938

1940

1939

self.dataOut.data_spc = self.data_spc

1941

self.dataOut.data_spc = self.data_spc

1940

1942

1941

self.dataOut.data_cspc = self.data_cspc

1943

self.dataOut.data_cspc = self.data_cspc

1942

1944

1943

self.dataOut.data_dc = self.data_dc

1945

self.dataOut.data_dc = self.data_dc

1944

1946

1945

self.dataOut.flagTimeBlock = self.flagTimeBlock

1947

self.dataOut.flagTimeBlock = self.flagTimeBlock

1946

1948

1947

self.dataOut.flagNoData = False

1949

self.dataOut.flagNoData = False

1948

1950

1949

self.dataOut.dtype = self.dtype

1951

self.dataOut.dtype = self.dtype

1950

1952

1951

self.dataOut.nChannels = self.nRdChannels

1953

self.dataOut.nChannels = self.nRdChannels

1952

1954

1953

self.dataOut.nPairs = self.nRdPairs

1955

self.dataOut.nPairs = self.nRdPairs

1954

1956

1955

self.dataOut.pairsList = self.rdPairList

1957

self.dataOut.pairsList = self.rdPairList

1956

1958

1957

self.dataOut.nHeights = self.processingHeaderObj.nHeights

1959

self.dataOut.nHeights = self.processingHeaderObj.nHeights

1958

1960

1959

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1961

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1960

1962

1961

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

1963

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

1962

1964

1963

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

1965

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

1964

1966

1965

1967

1966

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

1968

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

1967

1969

1968

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

1970

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

1969

1971

1970

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

1972

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

1971

1973

1972

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

1974

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

1973

1975

1974

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

1976

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

1975

1977

1976

self.dataOut.ippSeconds = self.ippSeconds

1978

self.dataOut.ippSeconds = self.ippSeconds

1977

1979

1978

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

1980

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

1979

1981

1980

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

1982

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

1981

1983

1982

# self.profileIndex += 1

1984

# self.profileIndex += 1

1983

1985

1984

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

1986

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

1985

1987

1986

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

1988

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

1987

1989

1988

return self.dataOut.data_spc

1990

return self.dataOut.data_spc

1989

1991

1990

1992

1991

class SpectraWriter(JRODataWriter):

1993

class SpectraWriter(JRODataWriter):

1992

1994

1993

"""

1995

"""

1994

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

1996

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

1995

de los datos siempre se realiza por bloques.

1997

de los datos siempre se realiza por bloques.

1996

"""

1998

"""

1997

1999

1998

ext = ".pdata"

2000

ext = ".pdata"

1999

2001

2000

optchar = "P"

2002

optchar = "P"

2001

2003

2002

shape_spc_Buffer = None

2004

shape_spc_Buffer = None

2003

2005

2004

shape_cspc_Buffer = None

2006

shape_cspc_Buffer = None

2005

2007

2006

shape_dc_Buffer = None

2008

shape_dc_Buffer = None

2007

2009

2008

data_spc = None

2010

data_spc = None

2009

2011

2010

data_cspc = None

2012

data_cspc = None

2011

2013

2012

data_dc = None

2014

data_dc = None

2013

2015

2014

# dataOut = None

2016

# dataOut = None

2015

2017

2016

def __init__(self):

2018

def __init__(self):

2017

"""

2019

"""

2018

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

2020

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

2019

2021

2020

Affected:

2022

Affected:

2021

self.dataOut

2023

self.dataOut

2022

self.basicHeaderObj

2024

self.basicHeaderObj

2023

self.systemHeaderObj

2025

self.systemHeaderObj

2024

self.radarControllerHeaderObj

2026

self.radarControllerHeaderObj

2025

self.processingHeaderObj

2027

self.processingHeaderObj

2026

2028

2027

Return: None

2029

Return: None

2028

"""

2030

"""

2029

2031

2030

self.isConfig = False

2032

self.isConfig = False

2031

2033

2032

self.nTotalBlocks = 0

2034

self.nTotalBlocks = 0

2033

2035

2034

self.data_spc = None

2036

self.data_spc = None

2035

2037

2036

self.data_cspc = None

2038

self.data_cspc = None

2037

2039

2038

self.data_dc = None

2040

self.data_dc = None

2039

2041

2040

self.fp = None

2042

self.fp = None

2041

2043

2042

self.flagIsNewFile = 1

2044

self.flagIsNewFile = 1

2043

2045

2044

self.nTotalBlocks = 0

2046

self.nTotalBlocks = 0

2045

2047

2046

self.flagIsNewBlock = 0

2048

self.flagIsNewBlock = 0

2047

2049

2048

self.flagNoMoreFiles = 0

2050

self.flagNoMoreFiles = 0

2049

2051

2050

self.setFile = None

2052

self.setFile = None

2051

2053

2052

self.dtype = None

2054

self.dtype = None

2053

2055

2054

self.path = None

2056

self.path = None

2055

2057

2056

self.noMoreFiles = 0

2058

self.noMoreFiles = 0

2057

2059

2058

self.filename = None

2060

self.filename = None

2059

2061

2060

self.basicHeaderObj = BasicHeader()

2062

self.basicHeaderObj = BasicHeader()

2061

2063

2062

self.systemHeaderObj = SystemHeader()

2064

self.systemHeaderObj = SystemHeader()

2063

2065

2064

self.radarControllerHeaderObj = RadarControllerHeader()

2066

self.radarControllerHeaderObj = RadarControllerHeader()

2065

2067

2066

self.processingHeaderObj = ProcessingHeader()

2068

self.processingHeaderObj = ProcessingHeader()

2067

2069

2068

2070

2069

def hasAllDataInBuffer(self):

2071

def hasAllDataInBuffer(self):

2070

return 1

2072

return 1

2071

2073

2072

2074

2073

def setBlockDimension(self):

2075

def setBlockDimension(self):

2074

"""

2076

"""

2075

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

2077

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

2076

2078

2077

Affected:

2079

Affected:

2078

self.shape_spc_Buffer

2080

self.shape_spc_Buffer

2079

self.shape_cspc_Buffer

2081

self.shape_cspc_Buffer

2080

self.shape_dc_Buffer

2082

self.shape_dc_Buffer

2081

2083

2082

Return: None

2084

Return: None

2083

"""

2085

"""

2084

self.shape_spc_Buffer = (self.dataOut.nChannels,

2086

self.shape_spc_Buffer = (self.dataOut.nChannels,

2085

self.processingHeaderObj.nHeights,

2087

self.processingHeaderObj.nHeights,

2086

self.processingHeaderObj.profilesPerBlock)

2088

self.processingHeaderObj.profilesPerBlock)

2087

2089

2088

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2090

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2089

self.processingHeaderObj.nHeights,

2091

self.processingHeaderObj.nHeights,

2090

self.processingHeaderObj.profilesPerBlock)

2092

self.processingHeaderObj.profilesPerBlock)

2091

2093

2092

self.shape_dc_Buffer = (self.dataOut.nChannels,

2094

self.shape_dc_Buffer = (self.dataOut.nChannels,

2093

self.processingHeaderObj.nHeights)

2095

self.processingHeaderObj.nHeights)

2094

2096

2095

2097

2096

def writeBlock(self):

2098

def writeBlock(self):

2097

"""

2099

"""

2098

Escribe el buffer en el file designado

2100

Escribe el buffer en el file designado

2099

2101

2100

Affected:

2102

Affected:

2101

self.data_spc

2103

self.data_spc

2102

self.data_cspc

2104

self.data_cspc

2103

self.data_dc

2105

self.data_dc

2104

self.flagIsNewFile

2106

self.flagIsNewFile

2105

self.flagIsNewBlock

2107

self.flagIsNewBlock

2106

self.nTotalBlocks

2108

self.nTotalBlocks

2107

self.nWriteBlocks

2109

self.nWriteBlocks

2108

2110

2109

Return: None

2111

Return: None

2110

"""

2112

"""

2111

2113

2112

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

2114

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

2113

if not( self.processingHeaderObj.shif_fft ):

2115

if not( self.processingHeaderObj.shif_fft ):

2114

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

2116

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

2115

data = spc.reshape((-1))

2117

data = spc.reshape((-1))

2116

data.tofile(self.fp)

2118

data.tofile(self.fp)

2117

2119

2118

if self.data_cspc != None:

2120

if self.data_cspc != None:

2119

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

2121

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

2120

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

2122

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

2121

if not( self.processingHeaderObj.shif_fft ):

2123

if not( self.processingHeaderObj.shif_fft ):

2122

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

2124

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

2123

data['real'] = cspc.real

2125

data['real'] = cspc.real

2124

data['imag'] = cspc.imag

2126

data['imag'] = cspc.imag

2125

data = data.reshape((-1))

2127

data = data.reshape((-1))

2126

data.tofile(self.fp)

2128

data.tofile(self.fp)

2127

2129

2128

if self.data_dc != None:

2130

if self.data_dc != None:

2129

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

2131

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

2130

dc = self.data_dc

2132

dc = self.data_dc

2131

data['real'] = dc.real

2133

data['real'] = dc.real

2132

data['imag'] = dc.imag

2134

data['imag'] = dc.imag

2133

data = data.reshape((-1))

2135

data = data.reshape((-1))

2134

data.tofile(self.fp)

2136

data.tofile(self.fp)

2135

2137

2136

self.data_spc.fill(0)

2138

self.data_spc.fill(0)

2137

self.data_dc.fill(0)

2139

self.data_dc.fill(0)

2138

if self.data_cspc != None:

2140

if self.data_cspc != None:

2139

self.data_cspc.fill(0)

2141

self.data_cspc.fill(0)

2140

2142

2141

self.flagIsNewFile = 0

2143

self.flagIsNewFile = 0

2142

self.flagIsNewBlock = 1

2144

self.flagIsNewBlock = 1

2143

self.nTotalBlocks += 1

2145

self.nTotalBlocks += 1

2144

self.nWriteBlocks += 1

2146

self.nWriteBlocks += 1

2145

self.blockIndex += 1

2147

self.blockIndex += 1

2146

2148

2147

2149

2148

def putData(self):

2150

def putData(self):

2149

"""

2151

"""

2150

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

2152

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

2151

2153

2152

Affected:

2154

Affected:

2153

self.data_spc

2155

self.data_spc

2154

self.data_cspc

2156

self.data_cspc

2155

self.data_dc

2157

self.data_dc

2156

2158

2157

Return:

2159

Return:

2158

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

2160

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

2159

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

2161

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

2160

"""

2162

"""

2161

2163

2162

if self.dataOut.flagNoData:

2164

if self.dataOut.flagNoData:

2163

return 0

2165

return 0

2164

2166

2165

self.flagIsNewBlock = 0

2167

self.flagIsNewBlock = 0

2166

2168

2167

if self.dataOut.flagTimeBlock:

2169

if self.dataOut.flagTimeBlock:

2168

self.data_spc.fill(0)

2170

self.data_spc.fill(0)

2169

self.data_cspc.fill(0)

2171

self.data_cspc.fill(0)

2170

self.data_dc.fill(0)

2172

self.data_dc.fill(0)

2171

self.setNextFile()

2173

self.setNextFile()

2172

2174

2173

if self.flagIsNewFile == 0:

2175

if self.flagIsNewFile == 0:

2174

self.getBasicHeader()

2176

self.getBasicHeader()

2175

2177

2176

self.data_spc = self.dataOut.data_spc

2178

self.data_spc = self.dataOut.data_spc

2177

self.data_cspc = self.dataOut.data_cspc

2179

self.data_cspc = self.dataOut.data_cspc

2178

self.data_dc = self.dataOut.data_dc

2180

self.data_dc = self.dataOut.data_dc

2179

2181

2180

# #self.processingHeaderObj.dataBlocksPerFile)

2182

# #self.processingHeaderObj.dataBlocksPerFile)

2181

if self.hasAllDataInBuffer():

2183

if self.hasAllDataInBuffer():

2182

# self.getDataHeader()

2184

# self.getDataHeader()

2183

self.writeNextBlock()

2185

self.writeNextBlock()

2184

2186

2185

if self.flagNoMoreFiles:

2187

if self.flagNoMoreFiles:

2186

#print 'Process finished'

2188

#print 'Process finished'

2187

return 0

2189

return 0

2188

2190

2189

return 1

2191

return 1

2190

2192

2191

2193

2192

def __getProcessFlags(self):

2194

def __getProcessFlags(self):

2193

2195

2194

processFlags = 0

2196

processFlags = 0

2195

2197

2196

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

2198

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

2197

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

2199

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

2198

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

2200

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

2199

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

2201

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

2200

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

2202

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

2201

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

2203

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

2202

2204

2203

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

2205

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

2204

2206

2205

2207

2206

2208

2207

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2209

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2208

PROCFLAG.DATATYPE_SHORT,

2210

PROCFLAG.DATATYPE_SHORT,

2209

PROCFLAG.DATATYPE_LONG,

2211

PROCFLAG.DATATYPE_LONG,

2210

PROCFLAG.DATATYPE_INT64,

2212

PROCFLAG.DATATYPE_INT64,

2211

PROCFLAG.DATATYPE_FLOAT,

2213

PROCFLAG.DATATYPE_FLOAT,

2212

PROCFLAG.DATATYPE_DOUBLE]

2214

PROCFLAG.DATATYPE_DOUBLE]

2213

2215

2214

2216

2215

for index in range(len(dtypeList)):

2217

for index in range(len(dtypeList)):

2216

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

2218

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

2217

dtypeValue = datatypeValueList[index]

2219

dtypeValue = datatypeValueList[index]

2218

break

2220

break

2219

2221

2220

processFlags += dtypeValue

2222

processFlags += dtypeValue

2221

2223

2222

if self.dataOut.flagDecodeData:

2224

if self.dataOut.flagDecodeData:

2223

processFlags += PROCFLAG.DECODE_DATA

2225

processFlags += PROCFLAG.DECODE_DATA

2224

2226

2225

if self.dataOut.flagDeflipData:

2227

if self.dataOut.flagDeflipData:

2226

processFlags += PROCFLAG.DEFLIP_DATA

2228

processFlags += PROCFLAG.DEFLIP_DATA

2227

2229

2228

if self.dataOut.code != None:

2230

if self.dataOut.code != None:

2229

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2231

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2230

2232

2231

if self.dataOut.nIncohInt > 1:

2233

if self.dataOut.nIncohInt > 1:

2232

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2234

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2233

2235

2234

if self.dataOut.data_dc != None:

2236

if self.dataOut.data_dc != None:

2235

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2237

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2236

2238

2237

return processFlags

2239

return processFlags

2238

2240

2239

2241

2240

def __getBlockSize(self):

2242

def __getBlockSize(self):

2241

'''

2243

'''

2242

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

2244

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

2243

'''

2245

'''

2244

2246

2245

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

2247

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

2246

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

2248

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

2247

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

2249

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

2248

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

2250

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

2249

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

2251

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

2250

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

2252

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

2251

2253

2252

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

2254

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

2253

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

2255

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

2254

for index in range(len(dtypeList)):

2256

for index in range(len(dtypeList)):

2255

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

2257

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

2256

datatypeValue = datatypeValueList[index]

2258

datatypeValue = datatypeValueList[index]

2257

break

2259

break

2258

2260

2259

2261

2260

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

2262

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

2261

2263

2262

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

2264

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

2263

blocksize = (pts2write_SelfSpectra*datatypeValue)

2265

blocksize = (pts2write_SelfSpectra*datatypeValue)

2264

2266

2265

if self.dataOut.data_cspc != None:

2267

if self.dataOut.data_cspc != None:

2266

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

2268

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

2267

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2269

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2268

2270

2269

if self.dataOut.data_dc != None:

2271

if self.dataOut.data_dc != None:

2270

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

2272

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

2271

blocksize += (pts2write_DCchannels*datatypeValue*2)

2273

blocksize += (pts2write_DCchannels*datatypeValue*2)

2272

2274

2273

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2275

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2274

2276

2275

return blocksize

2277

return blocksize

2276

2278

2277

def getDataHeader(self):

2279

def getDataHeader(self):

2278

2280

2279

"""

2281

"""

2280

Obtiene una copia del First Header

2282

Obtiene una copia del First Header

2281

2283

2282

Affected:

2284

Affected:

2283

self.systemHeaderObj

2285

self.systemHeaderObj

2284

self.radarControllerHeaderObj

2286

self.radarControllerHeaderObj

2285

self.dtype

2287

self.dtype

2286

2288

2287

Return:

2289

Return:

2288

None

2290

None

2289

"""

2291

"""

2290

2292

2291

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

2293

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

2292

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2294

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2293

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

2295

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

2294

2296

2295

self.getBasicHeader()

2297

self.getBasicHeader()

2296

2298

2297

processingHeaderSize = 40 # bytes

2299

processingHeaderSize = 40 # bytes

2298

self.processingHeaderObj.dtype = 0 # Voltage

2300

self.processingHeaderObj.dtype = 0 # Voltage

2299

self.processingHeaderObj.blockSize = self.__getBlockSize()

2301

self.processingHeaderObj.blockSize = self.__getBlockSize()

2300

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2302

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2301

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2303

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2302

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

2304

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

2303

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2305

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2304

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

2306

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

2305

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2307

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2306

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

2308

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

2307

2309

2308

if self.processingHeaderObj.totalSpectra > 0:

2310

if self.processingHeaderObj.totalSpectra > 0:

2309

channelList = []

2311

channelList = []

2310

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

2312

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

2311

channelList.append(channel)

2313

channelList.append(channel)

2312

channelList.append(channel)

2314

channelList.append(channel)

2313

2315

2314

pairsList = []

2316

pairsList = []

2315

for pair in self.dataOut.pairsList:

2317

for pair in self.dataOut.pairsList:

2316

pairsList.append(pair[0])

2318

pairsList.append(pair[0])

2317

pairsList.append(pair[1])

2319

pairsList.append(pair[1])

2318

spectraComb = channelList + pairsList

2320

spectraComb = channelList + pairsList

2319

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

2321

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

2320

self.processingHeaderObj.spectraComb = spectraComb

2322

self.processingHeaderObj.spectraComb = spectraComb

2321

sizeOfSpcComb = len(spectraComb)

2323

sizeOfSpcComb = len(spectraComb)

2322

processingHeaderSize += sizeOfSpcComb

2324

processingHeaderSize += sizeOfSpcComb

2323

2325

2324

if self.dataOut.code != None:

2326

if self.dataOut.code != None:

2325

self.processingHeaderObj.code = self.dataOut.code

2327

self.processingHeaderObj.code = self.dataOut.code

2326

self.processingHeaderObj.nCode = self.dataOut.nCode

2328

self.processingHeaderObj.nCode = self.dataOut.nCode

2327

self.processingHeaderObj.nBaud = self.dataOut.nBaud

2329

self.processingHeaderObj.nBaud = self.dataOut.nBaud

2328

nCodeSize = 4 # bytes

2330

nCodeSize = 4 # bytes

2329

nBaudSize = 4 # bytes

2331

nBaudSize = 4 # bytes

2330

codeSize = 4 # bytes

2332

codeSize = 4 # bytes

2331

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

2333

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

2332

processingHeaderSize += sizeOfCode

2334

processingHeaderSize += sizeOfCode

2333

2335

2334

if self.processingHeaderObj.nWindows != 0:

2336

if self.processingHeaderObj.nWindows != 0:

2335

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

2337

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

2336

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

2338

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

2337

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2339

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2338

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2340

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2339

sizeOfFirstHeight = 4

2341

sizeOfFirstHeight = 4

2340

sizeOfdeltaHeight = 4

2342

sizeOfdeltaHeight = 4

2341

sizeOfnHeights = 4

2343

sizeOfnHeights = 4

2342

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

2344

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

2343

processingHeaderSize += sizeOfWindows

2345

processingHeaderSize += sizeOfWindows

2344

2346

2345

self.processingHeaderObj.size = processingHeaderSize

2347

self.processingHeaderObj.size = processingHeaderSize

2346

2348

2347

class SpectraHeisWriter():

2349

class SpectraHeisWriter():

2348

2350

2349

i=0

2351

i=0

2350

2352

2351

def __init__(self, dataOut):

2353

def __init__(self, dataOut):

2352

2354

2353

self.wrObj = FITS()

2355

self.wrObj = FITS()

2354

self.dataOut = dataOut

2356

self.dataOut = dataOut

2355

2357

2356

def isNumber(str):

2358

def isNumber(str):

2357

"""

2359

"""

2358

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

2360

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

2359

2361

2360

Excepciones:

2362

Excepciones:

2361

Si un determinado string no puede ser convertido a numero

2363

Si un determinado string no puede ser convertido a numero

2362

Input:

2364

Input:

2363

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

2365

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

2364

2366

2365

Return:

2367

Return:

2366

True : si el string es uno numerico

2368

True : si el string es uno numerico

2367

False : no es un string numerico

2369

False : no es un string numerico

2368

"""

2370

"""

2369

try:

2371

try:

2370

float( str )

2372

float( str )

2371

return True

2373

return True

2372

except:

2374

except:

2373

return False

2375

return False

2374

2376

2375

def setup(self, wrpath,):

2377

def setup(self, wrpath,):

2376

2378

2377

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

2379

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

2378

os.mkdir(wrpath)

2380

os.mkdir(wrpath)

2379

2381

2380

self.wrpath = wrpath

2382

self.wrpath = wrpath

2381

self.setFile = 0

2383

self.setFile = 0

2382

2384

2383

def putData(self):

2385

def putData(self):

2384

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

2386

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

2385

#name = self.dataOut.utctime

2387

#name = self.dataOut.utctime

2386

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

2388

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

2387

ext=".fits"

2389

ext=".fits"

2388

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

2390

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

2389

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

2391

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

2390

2392

2391

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

2393

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

2392

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

2394

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

2393

os.mkdir(doypath)

2395

os.mkdir(doypath)

2394

self.setFile += 1

2396

self.setFile += 1

2395

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

2397

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

2396

2398

2397

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

2399

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

2398

2400

2399

# print self.dataOut.ippSeconds

2401

# print self.dataOut.ippSeconds

2400

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

2402

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

2401

2403

2402

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

2404

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

2403

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

2405

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

2404

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

2406

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

2405

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

2407

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

2406

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

2408

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

2407

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

2409

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

2408

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

2410

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

2409

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

2411

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

2410

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

2412

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

2411

#n=numpy.arange((100))

2413

#n=numpy.arange((100))

2412

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

2414

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

2413

a=self.wrObj.cFImage(n)

2415

a=self.wrObj.cFImage(n)

2414

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

2416

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

2415

self.wrObj.CFile(a,b)

2417

self.wrObj.CFile(a,b)

2416

self.wrObj.wFile(filename)

2418

self.wrObj.wFile(filename)

2417

return 1

2419

return 1

2418

2420

2419

class FITS:

2421

class FITS:

2420

2422

2421

name=None

2423

name=None

2422

format=None

2424

format=None

2423

array =None

2425

array =None

2424

data =None

2426

data =None

2425

thdulist=None

2427

thdulist=None

2426

2428

2427

def __init__(self):

2429

def __init__(self):

2428

2430

2429

pass

2431

pass

2430

2432

2431

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

2433

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

2432

self.name=name

2434

self.name=name

2433

self.format=format

2435

self.format=format

2434

self.array=array

2436

self.array=array

2435

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

2437

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

2436

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

2438

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

2437

return self.col1

2439

return self.col1

2438

2440

2439

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

2441

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

2440

# self.name=name

2442

# self.name=name

2441

# self.format=format

2443

# self.format=format

2442

# self.data=data

2444

# self.data=data

2443

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

2445

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

2444

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

2446

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

2445

# return self.col2

2447

# return self.col2

2446

2448

2447

def writeHeader(self,):

2449

def writeHeader(self,):

2448

pass

2450

pass

2449

2451

2450

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

2452

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

2451

self.name=name

2453

self.name=name

2452

self.format=format

2454

self.format=format

2453

self.data=data

2455

self.data=data

2454

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

2456

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

2455

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

2457

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

2456

return self.col2

2458

return self.col2

2457

2459

2458

def cFImage(self,n):

2460

def cFImage(self,n):

2459

self.hdu= pyfits.PrimaryHDU(n)

2461

self.hdu= pyfits.PrimaryHDU(n)

2460

return self.hdu

2462

return self.hdu

2461

2463

2462

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

2464

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

2463

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

2465

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

2464

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

2466

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

2465

return self.tbhdu

2467

return self.tbhdu

2466

2468

2467

def CFile(self,hdu,tbhdu):

2469

def CFile(self,hdu,tbhdu):

2468

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

2470

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

2469

2471

2470

def wFile(self,filename):

2472

def wFile(self,filename):

2471

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

2473

self.thdulist.writeto(filename)

	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.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
                     """
                     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.
                     """
                     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
                     """
                     object = self.objectDict[objId]
                     object.run(self.dataOut, **kwargs)
                 def call(self, operationConf, **kwargs):
                     """
                     Ejecuta la operacion "operationConf.name" 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.
                     Input:
                         Operation    :    Objeto del tipo operacion con los atributos: name, type y id.
                     """
                     if self.dataIn.isEmpty():
                         return None
                     if operationConf.type == 'self':
                         self.callMethod(operationConf.name, **kwargs)
                         return
                     if operationConf.type == 'other':
                         self.callObject(operationConf.id, **kwargs)
                         return
+                def setInput(self, dataIn):
+                    self.dataIn = dataIn
+                def getOutput(self):
+                    return self.dataOut
             class Operation():
                 """
                 Clase base para definir las operaciones adicionales que se pueden agregar a la clase ProcessingUnit
                 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 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 = {}
                     self.dataOut = Voltage()
-                def setup(self, dataIn=None, dataOut=None):
-                    self.dataIn = dataIn
-                    if self.dataOut == None:
-                        dataOut = Voltage()
-                    self.dataOut = dataOut
-                    return self.dataOut
                 def init(self):
                     self.dataOut.copy(self.dataIn)
                     # 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.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.dataOut.data
                         self.dataOut.channelIndexList
                         self.dataOut.nChannels
                         self.dataOut.m_ProcessingHeader.totalSpectra
                         self.dataOut.systemHeaderObj.numChannels
                         self.dataOut.m_ProcessingHeader.blockSize
                     Return:
                         None
                     """
                     for channel in channelIndexList:
                         if channel not in self.dataOut.channelIndexList:
                             raise ValueError, "The value %d in channelIndexList is not valid" %channel
                     nChannels = len(channelIndexList)
                     data = self.dataOut.data[channelIndexList,:]
                     self.dataOut.data = data
                     self.dataOut.channelIndexList = channelIndexList
                     self.dataOut.channelList = [self.dataOut.channelList[i] for i in channelIndexList]
                     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
                     avgdata = None
                     nCohInt = None
                     self.putData(data)
                     if self.__profIndex == self.nCohInt:
                         avgdata, nCohInt = self.pushData()
                         self.__dataReady = True
                     return avgdata
                 def byTime(self, data, datatime):
                     self.__dataReady = False
                     avgdata = None
                     nCohInt = None
                     self.putData(data)
                     if (datatime - self.__initime) >= self.__integrationtime:
                         avgdata, nCohInt = self.pushData()
                         self.nCohInt = nCohInt
                         self.__dataReady = True
                     return avgdata
                 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, None
                     avgdatatime = self.__initime
                     deltatime = datatime -self.__lastdatatime
                     if not self.__withOverapping:
                         self.__initime = datatime
                     else:
                         self.__initime += deltatime
                     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)
             #        dataOut.timeInterval *= nCohInt
                     dataOut.flagNoData = True
                     if self.__dataReady:
                         dataOut.data = avgdata
                         dataOut.timeInterval *= self.nCohInt
                         dataOut.nCohInt *= self.nCohInt
                         dataOut.utctime = avgdatatime
                         dataOut.flagNoData = False