schain Commit - r273:399567791378 · Jicamarca Repository

             '''
             $Author: murco $
             $Id: JRODataIO.py 169 2012-11-19 21:57:03Z murco $
             '''
             import os, sys
             import glob
             import time
             import numpy
             import fnmatch
             import time, datetime
             from jrodata import *
             from jroheaderIO import *
             from jroprocessing import *
             LOCALTIME = -18000
             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(LOCALTIME)
                 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 isFileinThisTime(filename, startTime, endTime):
                 """
                 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                     startTime          :    tiempo inicial del rango seleccionado en formato datetime.time
                     endTime            :    tiempo final del rango seleccionado en formato datetime.time
                 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.
                 """
                 try:
                     fp = open(filename,'rb')
                 except:
                     raise IOError, "The file %s can't be opened" %(filename)
                 basicHeaderObj = BasicHeader(LOCALTIME)
                 sts = basicHeaderObj.read(fp)
                 fp.close()
                 thisTime = basicHeaderObj.datatime.time()
                 if not(sts):
                     print "Skipping the file %s because it has not a valid header" %(filename)
                     return 0
                 if not ((startTime <= thisTime) and (endTime > thisTime)):
                     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])
                     except:
                         continue
                     if (os.path.splitext(file)[-1].lower() != ext.lower()):
                         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
                         .../.../y2009307367.ext
                         .../.../Y2009307367.ext
                         .../.../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
                 """
                 fullfilename = None
                 find_flag = False
                 filename = None
                 prefixDirList = [None,'d','D']
                 if ext.lower() == ".r": #voltage
                     prefixFileList = ['d','D']
                 elif ext.lower() == ".pdata": #spectra
                     prefixFileList = ['p','P']
                 else:
                     return None, filename
                 #barrido por las combinaciones posibles
                 for prefixDir in prefixDirList:
                     thispath = path
                     if prefixDir != None:
                         #formo el nombre del directorio xYYYYDDD (x=d o x=D)
                         thispath = os.path.join(path, "%s%04d%03d" % ( prefixDir, year, doy ))
                     for prefixFile in prefixFileList: #barrido por las dos combinaciones posibles de "D"
                         filename = "%s%04d%03d%03d%s" % ( prefixFile, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext
                         fullfilename = os.path.join( thispath, filename ) #formo el path completo
                         if os.path.exists( fullfilename ): #verifico que exista
                             find_flag = True
                             break
                     if find_flag:
                         break
                 if not(find_flag):
                     return None, filename
                 return fullfilename, filename
             class JRODataIO:
                 c = 3E8
                 isConfig = False
                 basicHeaderObj = BasicHeader(LOCALTIME)
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
                 processingHeaderObj = ProcessingHeader()
                 online = 0
                 dtype = None
                 pathList = []
                 filenameList = []
                 filename = None
                 ext = None
                 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 getOutput(self):
                     return self.dataOut
             class JRODataReader(JRODataIO, ProcessingUnit):
                 nReadBlocks = 0
                 delay  = 10   #number of seconds waiting a new file
                 nTries  = 3  #quantity tries
                 nFiles = 3   #number of files for searching
                 flagNoMoreFiles = 0
                 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',
                                         walk=True):
                     pathList = []
                     if not walk:
                         pathList.append(path)
                     else:
                         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
                         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))
                             thisDate += datetime.timedelta(1)
                     if pathList == []:
                         print "Any folder was found for the date range: %s-%s" %(startDate, endDate)
                         return None, None
                     print "%d folder(s) was(were) found for the date range: %s-%s" %(len(pathList), startDate, endDate)
                     filenameList = []
                     for thisPath in pathList:
                         fileList = glob.glob1(thisPath, "*%s" %ext)
                         fileList.sort()
                         for file in fileList:
                             filename = os.path.join(thisPath,file)
                             if isFileinThisTime(filename, startTime, endTime):
                                 filenameList.append(filename)
                     if not(filenameList):
                         print "Any file was found for the time range %s - %s" %(startTime, endTime)
                         return None, None
                     print "%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime)
                     self.filenameList = filenameList
                     return pathList, filenameList
                 def __searchFilesOnLine(self, path, expLabel = "", ext = None, walk=True):
                     """
                     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
                         expLabel        :     Nombre del subexperimento (subfolder)
                         ext              :    extension de los files
                         walk        :    Si es habilitado no realiza busquedas dentro de los ubdirectorios (doypath)
                     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 = []
                     if walk:
                         #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 )
                         doypath = dirList[-1]
                         fullpath = os.path.join(path, doypath, expLabel)
                     else:
                         fullpath = path
                     filename = getlastFileFromPath(fullpath, ext)
                     if not(filename):
                         return None, None, None, None, None
                     if not(self.__verifyFile(os.path.join(fullpath, filename))):
                         return None, None, None, None, None
                     year = int( filename[1:5] )
                     doy  = int( filename[5:8] )
                     set  = int( filename[8:11] )
                     return fullpath, filename, year, doy, set
                 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
                     fullfilename, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
                     if fullfilename:
                         if self.__verifyFile(fullfilename, 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)
                                 fullfilename, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
                                 if fullfilename:
                                     if self.__verifyFile(fullfilename):
                                         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( fullfilename )
                         self.filename = fullfilename
                         self.flagIsNewFile = 1
                         if self.fp != None: self.fp.close()
                         self.fp = open(fullfilename, 'rb')
                         self.flagNoMoreFiles = 0
                         print 'Setting the file: %s' % fullfilename
                     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 __waitNewBlock(self):
                     """
                     Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.
                     Si el modo de lectura es OffLine siempre retorn 0
                     """
                     if not self.online:
                         return 0
                     if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
                         return 0
                     currentPointer = self.fp.tell()
                     neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     for nTries in range( self.nTries ):
                         self.fp.close()
                         self.fp = open( self.filename, 'rb' )
                         self.fp.seek( currentPointer )
                         self.fileSize = os.path.getsize( self.filename )
                         currentSize = self.fileSize - currentPointer
                         if ( currentSize >= neededSize ):
                             self.__rdBasicHeader()
                             return 1
                         print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
                         time.sleep( self.delay )
                     return 0
                 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 self.__waitNewBlock():
                         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(LOCALTIME)
                         systemHeaderObj = SystemHeader()
                         radarControllerHeaderObj = RadarControllerHeader()
                         processingHeaderObj = ProcessingHeader()
                         try:
                             if not( basicHeaderObj.read(fp) ): raise IOError
                             if not( systemHeaderObj.read(fp) ): raise IOError
                             if not( radarControllerHeaderObj.read(fp) ): raise IOError
                             if not( processingHeaderObj.read(fp) ): raise IOError
                             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 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,
                             walk = True):
                     if path == None:
                         raise ValueError, "The path is not valid"
                     if ext == None:
                         ext = self.ext
                     if online:
                         print "Searching files in online mode..."
                         for nTries in range( self.nTries ):
                             fullpath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext, walk=walk)
                             if fullpath:
                                 break
                             print '\tWaiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
                             time.sleep( self.delay )
                         if not(fullpath):
                             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=startDate, endDate=endDate,
                                                                            startTime=startTime, endTime=endTime,
                                                                            set=set, expLabel=expLabel, ext=ext,
                                                                            walk=walk)
                         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 getData():
                     raise ValueError, "This method has not been implemented"
                 def hasNotDataInBuffer():
                     raise ValueError, "This method has not been implemented"
                 def readBlock():
                     raise ValueError, "This method has not been implemented"
                 def isEndProcess(self):
                     return self.flagNoMoreFiles
                 def printReadBlocks(self):
                     print "Number of read blocks per file %04d" %self.nReadBlocks
                 def printTotalBlocks(self):
                     print "Number of read blocks %04d" %self.nTotalBlocks
                 def printNumberOfBlock(self):
                     if self.flagIsNewBlock:
                         print "Block No. %04d, Total blocks %04d" %(self.basicHeaderObj.dataBlock, self.nTotalBlocks)
                 def printInfo(self):
                     print self.basicHeaderObj.printInfo()
                     print self.systemHeaderObj.printInfo()
                     print self.radarControllerHeaderObj.printInfo()
                     print self.processingHeaderObj.printInfo()
                 def run(self, **kwargs):
                     if not(self.isConfig):
             #            self.dataOut = dataOut
                         self.setup(**kwargs)
                         self.isConfig = True
                     self.getData()
             class JRODataWriter(JRODataIO, Operation):
                 """
                 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.utctime)
-                    subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
+                    subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
                     fullpath = os.path.join( path, subfolder )
                     if not( os.path.exists(fullpath) ):
                         os.mkdir(fullpath)
                         self.setFile = -1 #inicializo mi contador de seteo
                     else:
                         filesList = os.listdir( fullpath )
                         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(LOCALTIME)
                     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:
                         self.dataOut.flagNoData = True
                         print 'Process finished'
                         return 0
                     self.flagTimeBlock = 0
                     self.flagIsNewBlock = 0
                     if self.__hasNotDataInBuffer():
                         if not( self.readNextBlock() ):
                             return 0
                         self.dataOut.dtype = numpy.dtype([('real','<f8'),('imag','<f8')]) #self.dtype
                         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.flagTimeBlock = self.flagTimeBlock
                         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.radarControllerHeaderObj.code != None:
                             self.dataOut.nCode = self.radarControllerHeaderObj.nCode
                             self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud
                             self.dataOut.code = self.radarControllerHeaderObj.code
                         self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
                         self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
                         self.dataOut.flagDecodeData = False #asumo q la data no esta decodificada
                         self.dataOut.flagDeflipData = False #asumo q la data no esta sin flip
                         self.dataOut.flagShiftFFT = False
             #            self.updateDataHeader()
                     #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.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.ippSeconds
                     self.profileIndex += 1
                     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.setFile = None
                     self.dtype = None
                     self.path = None
                     self.filename = None
                     self.basicHeaderObj = BasicHeader(LOCALTIME)
                     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()
                     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(LOCALTIME)
                     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):
                         #desplaza a la derecha en el eje 2 determinadas posiciones
                         shift = int(self.processingHeaderObj.profilesPerBlock/2)
                         spc = numpy.roll( spc, shift , axis=2 )
                         if self.processingHeaderObj.flag_cspc:
                             #desplaza a la derecha en el eje 2 determinadas posiciones
                             cspc = numpy.roll( cspc, shift, axis=2 )
             #            self.processingHeaderObj.shif_fft = True
                     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:
                         self.dataOut.flagNoData = True
                         print 'Process finished'
                         return 0
                     self.flagTimeBlock = 0
                     self.flagIsNewBlock = 0
                     if self.__hasNotDataInBuffer():
                         if not( self.readNextBlock() ):
                             self.dataOut.flagNoData = True
                             return 0
             #            self.updateDataHeader()
                     #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 = numpy.dtype([('real','<f8'),('imag','<f8')])#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.nCohInt = self.processingHeaderObj.nCohInt
                     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.profileIndex += 1
                     self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
                     self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
                     self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
                     self.dataOut.flagDecodeData = False #asumo q la data no esta decodificada
                     self.dataOut.flagDeflipData = True #asumo q la data no esta sin flip
                     if self.processingHeaderObj.code != None:
                             self.dataOut.nCode = self.processingHeaderObj.nCode
                             self.dataOut.nBaud = self.processingHeaderObj.nBaud
                             self.dataOut.code = self.processingHeaderObj.code
                             self.dataOut.flagDecodeData = True
                     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.setFile = None
                     self.dtype = None
                     self.path = None
                     self.noMoreFiles = 0
                     self.filename = None
                     self.basicHeaderObj = BasicHeader(LOCALTIME)
                     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.copy()
                     self.data_cspc = self.dataOut.data_cspc.copy()
                     self.data_dc = self.dataOut.data_dc.copy()
                     # #self.processingHeaderObj.dataBlocksPerFile)
                     if self.hasAllDataInBuffer():
             #            self.getDataHeader()
                         self.writeNextBlock()
                     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)
                     fullpath = os.path.join( self.wrpath, subfolder )
                     if not( os.path.exists(fullpath) ):
                         os.mkdir(fullpath)
                     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

from jroprocessing import *

16

from jroprocessing import *

17

18

LOCALTIME = -18000

18

LOCALTIME = -18000

19

20

def isNumber(str):

20

def isNumber(str):

21

"""

21

"""

22

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

22

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

23

24

Excepciones:

24

Excepciones:

25

Si un determinado string no puede ser convertido a numero

25

Si un determinado string no puede ser convertido a numero

26

Input:

26

Input:

27

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

27

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

28

29

Return:

29

Return:

30

True : si el string es uno numerico

30

True : si el string es uno numerico

31

False : no es un string numerico

31

False : no es un string numerico

32

"""

32

"""

33

try:

33

try:

34

float( str )

34

float( str )

35

return True

35

return True

36

except:

36

except:

37

return False

37

return False

38

39

def isThisFileinRange(filename, startUTSeconds, endUTSeconds):

39

def isThisFileinRange(filename, startUTSeconds, endUTSeconds):

40

"""

40

"""

41

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

41

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

42

43

Inputs:

43

Inputs:

44

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

44

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

45

46

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

46

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

47

segundos contados desde 01/01/1970.

47

segundos contados desde 01/01/1970.

48

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

48

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

49

segundos contados desde 01/01/1970.

49

segundos contados desde 01/01/1970.

50

51

Return:

51

Return:

52

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

52

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

53

fecha especificado, de lo contrario retorna False.

53

fecha especificado, de lo contrario retorna False.

54

55

Excepciones:

55

Excepciones:

56

Si el archivo no existe o no puede ser abierto

56

Si el archivo no existe o no puede ser abierto

57

Si la cabecera no puede ser leida.

57

Si la cabecera no puede ser leida.

58

59

"""

59

"""

60

basicHeaderObj = BasicHeader(LOCALTIME)

60

basicHeaderObj = BasicHeader(LOCALTIME)

61

62

try:

62

try:

63

fp = open(filename,'rb')

63

fp = open(filename,'rb')

64

except:

64

except:

65

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

65

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

66

67

sts = basicHeaderObj.read(fp)

67

sts = basicHeaderObj.read(fp)

68

fp.close()

68

fp.close()

69

70

if not(sts):

70

if not(sts):

71

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

71

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

72

return 0

72

return 0

73

74

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

74

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

75

return 0

75

return 0

76

77

return 1

77

return 1

78

79

def isFileinThisTime(filename, startTime, endTime):

79

def isFileinThisTime(filename, startTime, endTime):

80

"""

80

"""

81

Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.

81

Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.

82

83

Inputs:

83

Inputs:

84

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

84

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

85

86

startTime : tiempo inicial del rango seleccionado en formato datetime.time

86

startTime : tiempo inicial del rango seleccionado en formato datetime.time

87

88

endTime : tiempo final del rango seleccionado en formato datetime.time

88

endTime : tiempo final del rango seleccionado en formato datetime.time

89

90

Return:

90

Return:

91

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

91

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

92

fecha especificado, de lo contrario retorna False.

92

fecha especificado, de lo contrario retorna False.

93

94

Excepciones:

94

Excepciones:

95

Si el archivo no existe o no puede ser abierto

95

Si el archivo no existe o no puede ser abierto

96

Si la cabecera no puede ser leida.

96

Si la cabecera no puede ser leida.

97

98

"""

98

"""

99

100

101

try:

101

try:

102

fp = open(filename,'rb')

102

fp = open(filename,'rb')

103

except:

103

except:

104

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

104

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

105

106

basicHeaderObj = BasicHeader(LOCALTIME)

106

basicHeaderObj = BasicHeader(LOCALTIME)

107

sts = basicHeaderObj.read(fp)

107

sts = basicHeaderObj.read(fp)

108

fp.close()

108

fp.close()

109

110

thisTime = basicHeaderObj.datatime.time()

110

thisTime = basicHeaderObj.datatime.time()

111

112

if not(sts):

112

if not(sts):

113

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

113

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

114

return 0

114

return 0

115

116

if not ((startTime <= thisTime) and (endTime > thisTime)):

116

if not ((startTime <= thisTime) and (endTime > thisTime)):

117

return 0

117

return 0

118

119

return 1

119

return 1

120

121

def getlastFileFromPath(path, ext):

121

def getlastFileFromPath(path, ext):

122

"""

122

"""

123

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

123

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

124

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

124

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

125

126

Input:

126

Input:

127

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

127

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

128

ext : extension de los files contenidos en una carpeta

128

ext : extension de los files contenidos en una carpeta

129

130

Return:

130

Return:

131

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

131

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

132

"""

132

"""

133

validFilelist = []

133

validFilelist = []

134

fileList = os.listdir(path)

134

fileList = os.listdir(path)

135

136

# 0 1234 567 89A BCDE

136

# 0 1234 567 89A BCDE

137

# H YYYY DDD SSS .ext

137

# H YYYY DDD SSS .ext

138

139

for file in fileList:

139

for file in fileList:

140

try:

140

try:

141

year = int(file[1:5])

141

year = int(file[1:5])

142

doy = int(file[5:8])

142

doy = int(file[5:8])

143

144

145

except:

145

except:

146

continue

146

continue

147

148

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

148

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

149

continue

149

continue

150

151

validFilelist.append(file)

151

validFilelist.append(file)

152

153

if validFilelist:

153

if validFilelist:

154

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

154

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

155

return validFilelist[-1]

155

return validFilelist[-1]

156

157

return None

157

return None

158

159

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

159

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

160

"""

160

"""

161

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

161

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

162

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

162

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

163

el path exacto de un determinado file.

163

el path exacto de un determinado file.

164

165

Example :

165

Example :

166

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

166

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

167

168

Entonces la funcion prueba con las siguientes combinaciones

168

Entonces la funcion prueba con las siguientes combinaciones

169

.../.../y2009307367.ext

169

.../.../y2009307367.ext

170

.../.../Y2009307367.ext

170

.../.../Y2009307367.ext

171

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

171

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

172

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

172

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

173

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

173

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

174

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

174

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

175

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

175

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

176

177

Return:

177

Return:

178

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

178

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

179

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

179

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

180

para el filename

180

para el filename

181

"""

181

"""

182

fullfilename = None

182

fullfilename = None

183

find_flag = False

183

find_flag = False

184

filename = None

184

filename = None

185

186

prefixDirList = [None,'d','D']

186

prefixDirList = [None,'d','D']

187

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

187

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

188

prefixFileList = ['d','D']

188

prefixFileList = ['d','D']

189

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

189

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

190

prefixFileList = ['p','P']

190

prefixFileList = ['p','P']

191

else:

191

else:

192

return None, filename

192

return None, filename

193

194

#barrido por las combinaciones posibles

194

#barrido por las combinaciones posibles

195

for prefixDir in prefixDirList:

195

for prefixDir in prefixDirList:

196

thispath = path

196

thispath = path

197

if prefixDir != None:

197

if prefixDir != None:

198

#formo el nombre del directorio xYYYYDDD (x=d o x=D)

198

#formo el nombre del directorio xYYYYDDD (x=d o x=D)

199

thispath = os.path.join(path, "%s%04d%03d" % ( prefixDir, year, doy ))

199

thispath = os.path.join(path, "%s%04d%03d" % ( prefixDir, year, doy ))

200

201

for prefixFile in prefixFileList: #barrido por las dos combinaciones posibles de "D"

201

for prefixFile in prefixFileList: #barrido por las dos combinaciones posibles de "D"

202

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

202

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

203

fullfilename = os.path.join( thispath, filename ) #formo el path completo

203

fullfilename = os.path.join( thispath, filename ) #formo el path completo

204

205

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

205

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

206

find_flag = True

206

find_flag = True

207

break

207

break

208

if find_flag:

208

if find_flag:

209

break

209

break

210

211

if not(find_flag):

211

if not(find_flag):

212

return None, filename

212

return None, filename

213

214

return fullfilename, filename

214

return fullfilename, filename

215

216

class JRODataIO:

216

class JRODataIO:

217

218

c = 3E8

218

c = 3E8

219

220

isConfig = False

220

isConfig = False

221

222

basicHeaderObj = BasicHeader(LOCALTIME)

222

basicHeaderObj = BasicHeader(LOCALTIME)

223

224

systemHeaderObj = SystemHeader()

224

systemHeaderObj = SystemHeader()

225

226

radarControllerHeaderObj = RadarControllerHeader()

226

radarControllerHeaderObj = RadarControllerHeader()

227

228

processingHeaderObj = ProcessingHeader()

228

processingHeaderObj = ProcessingHeader()

229

230

online = 0

230

online = 0

231

232

dtype = None

232

dtype = None

233

234

pathList = []

234

pathList = []

235

236

filenameList = []

236

filenameList = []

237

238

filename = None

238

filename = None

239

240

ext = None

240

ext = None

241

242

flagIsNewFile = 1

242

flagIsNewFile = 1

243

244

flagTimeBlock = 0

244

flagTimeBlock = 0

245

246

flagIsNewBlock = 0

246

flagIsNewBlock = 0

247

248

fp = None

248

fp = None

249

250

firstHeaderSize = 0

250

firstHeaderSize = 0

251

252

basicHeaderSize = 24

252

basicHeaderSize = 24

253

254

versionFile = 1103

254

versionFile = 1103

255

256

fileSize = None

256

fileSize = None

257

258

ippSeconds = None

258

ippSeconds = None

259

260

fileSizeByHeader = None

260

fileSizeByHeader = None

261

262

fileIndex = None

262

fileIndex = None

263

264

profileIndex = None

264

profileIndex = None

265

266

blockIndex = None

266

blockIndex = None

267

268

nTotalBlocks = None

268

nTotalBlocks = None

269

270

maxTimeStep = 30

270

maxTimeStep = 30

271

272

lastUTTime = None

272

lastUTTime = None

273

274

datablock = None

274

datablock = None

275

276

dataOut = None

276

dataOut = None

277

278

blocksize = None

278

blocksize = None

279

280

def __init__(self):

280

def __init__(self):

281

282

raise ValueError, "Not implemented"

282

raise ValueError, "Not implemented"

283

284

def run(self):

284

def run(self):

285

286

raise ValueError, "Not implemented"

286

raise ValueError, "Not implemented"

287

288

def getOutput(self):

288

def getOutput(self):

289

290

return self.dataOut

290

return self.dataOut

291

292

class JRODataReader(JRODataIO, ProcessingUnit):

292

class JRODataReader(JRODataIO, ProcessingUnit):

293

294

nReadBlocks = 0

294

nReadBlocks = 0

295

296

delay = 10 #number of seconds waiting a new file

296

delay = 10 #number of seconds waiting a new file

297

298

nTries = 3 #quantity tries

298

nTries = 3 #quantity tries

299

300

nFiles = 3 #number of files for searching

300

nFiles = 3 #number of files for searching

301

302

flagNoMoreFiles = 0

302

flagNoMoreFiles = 0

303

304

def __init__(self):

304

def __init__(self):

305

306

"""

306

"""

307

308

"""

308

"""

309

310

raise ValueError, "This method has not been implemented"

310

raise ValueError, "This method has not been implemented"

311

312

313

def createObjByDefault(self):

313

def createObjByDefault(self):

314

"""

314

"""

315

316

"""

316

"""

317

raise ValueError, "This method has not been implemented"

317

raise ValueError, "This method has not been implemented"

318

319

def getBlockDimension(self):

319

def getBlockDimension(self):

320

321

raise ValueError, "No implemented"

321

raise ValueError, "No implemented"

322

323

def __searchFilesOffLine(self,

323

def __searchFilesOffLine(self,

324

path,

324

path,

325

startDate,

325

startDate,

326

endDate,

326

endDate,

327

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

327

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

328

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

328

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

329

set=None,

329

set=None,

330

expLabel='',

330

expLabel='',

331

ext='.r',

331

ext='.r',

332

walk=True):

332

walk=True):

333

334

pathList = []

334

pathList = []

335

336

if not walk:

336

if not walk:

337

pathList.append(path)

337

pathList.append(path)

338

339

else:

339

else:

340

dirList = []

340

dirList = []

341

for thisPath in os.listdir(path):

341

for thisPath in os.listdir(path):

342

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

342

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

343

dirList.append(thisPath)

343

dirList.append(thisPath)

344

345

if not(dirList):

345

if not(dirList):

346

return None, None

346

return None, None

347

348

thisDate = startDate

348

thisDate = startDate

349

350

while(thisDate <= endDate):

350

while(thisDate <= endDate):

351

year = thisDate.timetuple().tm_year

351

year = thisDate.timetuple().tm_year

352

doy = thisDate.timetuple().tm_yday

352

doy = thisDate.timetuple().tm_yday

353

354

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

354

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

355

if len(match) == 0:

355

if len(match) == 0:

356

thisDate += datetime.timedelta(1)

356

thisDate += datetime.timedelta(1)

357

continue

357

continue

358

359

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

359

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

360

thisDate += datetime.timedelta(1)

360

thisDate += datetime.timedelta(1)

361

362

if pathList == []:

362

if pathList == []:

363

print "Any folder was found for the date range: %s-%s" %(startDate, endDate)

363

print "Any folder was found for the date range: %s-%s" %(startDate, endDate)

364

return None, None

364

return None, None

365

366

print "%d folder(s) was(were) found for the date range: %s-%s" %(len(pathList), startDate, endDate)

366

print "%d folder(s) was(were) found for the date range: %s-%s" %(len(pathList), startDate, endDate)

367

368

filenameList = []

368

filenameList = []

369

for thisPath in pathList:

369

for thisPath in pathList:

370

371

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

371

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

372

fileList.sort()

372

fileList.sort()

373

374

for file in fileList:

374

for file in fileList:

375

376

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

376

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

377

378

if isFileinThisTime(filename, startTime, endTime):

378

if isFileinThisTime(filename, startTime, endTime):

379

filenameList.append(filename)

379

filenameList.append(filename)

380

381

if not(filenameList):

381

if not(filenameList):

382

print "Any file was found for the time range %s - %s" %(startTime, endTime)

382

print "Any file was found for the time range %s - %s" %(startTime, endTime)

383

return None, None

383

return None, None

384

385

print "%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime)

385

print "%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime)

386

387

self.filenameList = filenameList

387

self.filenameList = filenameList

388

389

return pathList, filenameList

389

return pathList, filenameList

390

391

def __searchFilesOnLine(self, path, expLabel = "", ext = None, walk=True):

391

def __searchFilesOnLine(self, path, expLabel = "", ext = None, walk=True):

392

393

"""

393

"""

394

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

394

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

395

devuelve el archivo encontrado ademas de otros datos.

395

devuelve el archivo encontrado ademas de otros datos.

396

397

Input:

397

Input:

398

path : carpeta donde estan contenidos los files que contiene data

398

path : carpeta donde estan contenidos los files que contiene data

399

400

expLabel : Nombre del subexperimento (subfolder)

400

expLabel : Nombre del subexperimento (subfolder)

401

402

ext : extension de los files

402

ext : extension de los files

403

404

walk : Si es habilitado no realiza busquedas dentro de los ubdirectorios (doypath)

404

walk : Si es habilitado no realiza busquedas dentro de los ubdirectorios (doypath)

405

406

Return:

406

Return:

407

directory : eL directorio donde esta el file encontrado

407

directory : eL directorio donde esta el file encontrado

408

filename : el ultimo file de una determinada carpeta

408

filename : el ultimo file de una determinada carpeta

409

year : el anho

409

year : el anho

410

doy : el numero de dia del anho

410

doy : el numero de dia del anho

411

set : el set del archivo

411

set : el set del archivo

412

413

414

"""

414

"""

415

dirList = []

415

dirList = []

416

417

if walk:

417

if walk:

418

419

#Filtra solo los directorios

419

#Filtra solo los directorios

420

for thisPath in os.listdir(path):

420

for thisPath in os.listdir(path):

421

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

421

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

422

dirList.append(thisPath)

422

dirList.append(thisPath)

423

424

if not(dirList):

424

if not(dirList):

425

return None, None, None, None, None

425

return None, None, None, None, None

426

427

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

427

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

428

429

doypath = dirList[-1]

429

doypath = dirList[-1]

430

fullpath = os.path.join(path, doypath, expLabel)

430

fullpath = os.path.join(path, doypath, expLabel)

431

432

else:

432

else:

433

fullpath = path

433

fullpath = path

434

435

filename = getlastFileFromPath(fullpath, ext)

435

filename = getlastFileFromPath(fullpath, ext)

436

437

if not(filename):

437

if not(filename):

438

return None, None, None, None, None

438

return None, None, None, None, None

439

440

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

440

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

441

return None, None, None, None, None

441

return None, None, None, None, None

442

443

year = int( filename[1:5] )

443

year = int( filename[1:5] )

444

doy = int( filename[5:8] )

444

doy = int( filename[5:8] )

445

set = int( filename[8:11] )

445

set = int( filename[8:11] )

446

447

return fullpath, filename, year, doy, set

447

return fullpath, filename, year, doy, set

448

449

450

451

def __setNextFileOffline(self):

451

def __setNextFileOffline(self):

452

453

idFile = self.fileIndex

453

idFile = self.fileIndex

454

455

while (True):

455

while (True):

456

idFile += 1

456

idFile += 1

457

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

457

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

458

self.flagNoMoreFiles = 1

458

self.flagNoMoreFiles = 1

459

print "No more Files"

459

print "No more Files"

460

return 0

460

return 0

461

462

filename = self.filenameList[idFile]

462

filename = self.filenameList[idFile]

463

464

if not(self.__verifyFile(filename)):

464

if not(self.__verifyFile(filename)):

465

continue

465

continue

466

467

fileSize = os.path.getsize(filename)

467

fileSize = os.path.getsize(filename)

468

fp = open(filename,'rb')

468

fp = open(filename,'rb')

469

break

469

break

470

471

self.flagIsNewFile = 1

471

self.flagIsNewFile = 1

472

self.fileIndex = idFile

472

self.fileIndex = idFile

473

self.filename = filename

473

self.filename = filename

474

self.fileSize = fileSize

474

self.fileSize = fileSize

475

self.fp = fp

475

self.fp = fp

476

477

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

477

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

478

479

return 1

479

return 1

480

481

def __setNextFileOnline(self):

481

def __setNextFileOnline(self):

482

"""

482

"""

483

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

483

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

484

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

484

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

485

siguientes.

485

siguientes.

486

487

Affected:

487

Affected:

488

self.flagIsNewFile

488

self.flagIsNewFile

489

self.filename

489

self.filename

490

self.fileSize

490

self.fileSize

491

self.fp

491

self.fp

492

self.set

492

self.set

493

self.flagNoMoreFiles

493

self.flagNoMoreFiles

494

495

Return:

495

Return:

496

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

496

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

497

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

497

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

498

499

Excepciones:

499

Excepciones:

500

Si un determinado file no puede ser abierto

500

Si un determinado file no puede ser abierto

501

"""

501

"""

502

nFiles = 0

502

nFiles = 0

503

fileOk_flag = False

503

fileOk_flag = False

504

firstTime_flag = True

504

firstTime_flag = True

505

506

self.set += 1

506

self.set += 1

507

508

#busca el 1er file disponible

508

#busca el 1er file disponible

509

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

509

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

510

if fullfilename:

510

if fullfilename:

511

if self.__verifyFile(fullfilename, False):

511

if self.__verifyFile(fullfilename, False):

512

fileOk_flag = True

512

fileOk_flag = True

513

514

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

514

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

515

if not(fileOk_flag):

515

if not(fileOk_flag):

516

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

516

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

517

518

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

518

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

519

tries = self.nTries

519

tries = self.nTries

520

else:

520

else:

521

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

521

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

522

523

for nTries in range( tries ):

523

for nTries in range( tries ):

524

if firstTime_flag:

524

if firstTime_flag:

525

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

525

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

526

time.sleep( self.delay )

526

time.sleep( self.delay )

527

else:

527

else:

528

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

528

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

529

530

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

530

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

531

if fullfilename:

531

if fullfilename:

532

if self.__verifyFile(fullfilename):

532

if self.__verifyFile(fullfilename):

533

fileOk_flag = True

533

fileOk_flag = True

534

break

534

break

535

536

if fileOk_flag:

536

if fileOk_flag:

537

break

537

break

538

539

firstTime_flag = False

539

firstTime_flag = False

540

541

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

541

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

542

self.set += 1

542

self.set += 1

543

544

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

544

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

545

self.set = 0

545

self.set = 0

546

self.doy += 1

546

self.doy += 1

547

548

if fileOk_flag:

548

if fileOk_flag:

549

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

549

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

550

self.filename = fullfilename

550

self.filename = fullfilename

551

self.flagIsNewFile = 1

551

self.flagIsNewFile = 1

552

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

552

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

553

self.fp = open(fullfilename, 'rb')

553

self.fp = open(fullfilename, 'rb')

554

self.flagNoMoreFiles = 0

554

self.flagNoMoreFiles = 0

555

print 'Setting the file: %s' % fullfilename

555

print 'Setting the file: %s' % fullfilename

556

else:

556

else:

557

self.fileSize = 0

557

self.fileSize = 0

558

self.filename = None

558

self.filename = None

559

self.flagIsNewFile = 0

559

self.flagIsNewFile = 0

560

self.fp = None

560

self.fp = None

561

self.flagNoMoreFiles = 1

561

self.flagNoMoreFiles = 1

562

print 'No more Files'

562

print 'No more Files'

563

564

return fileOk_flag

564

return fileOk_flag

565

566

567

def setNextFile(self):

567

def setNextFile(self):

568

if self.fp != None:

568

if self.fp != None:

569

self.fp.close()

569

self.fp.close()

570

571

if self.online:

571

if self.online:

572

newFile = self.__setNextFileOnline()

572

newFile = self.__setNextFileOnline()

573

else:

573

else:

574

newFile = self.__setNextFileOffline()

574

newFile = self.__setNextFileOffline()

575

576

if not(newFile):

576

if not(newFile):

577

return 0

577

return 0

578

579

self.__readFirstHeader()

579

self.__readFirstHeader()

580

self.nReadBlocks = 0

580

self.nReadBlocks = 0

581

return 1

581

return 1

582

583

def __waitNewBlock(self):

583

def __waitNewBlock(self):

584

"""

584

"""

585

Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.

585

Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.

586

587

Si el modo de lectura es OffLine siempre retorn 0

587

Si el modo de lectura es OffLine siempre retorn 0

588

"""

588

"""

589

if not self.online:

589

if not self.online:

590

return 0

590

return 0

591

592

if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):

592

if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):

593

return 0

593

return 0

594

595

currentPointer = self.fp.tell()

595

currentPointer = self.fp.tell()

596

597

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

597

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

598

599

for nTries in range( self.nTries ):

599

for nTries in range( self.nTries ):

600

601

self.fp.close()

601

self.fp.close()

602

self.fp = open( self.filename, 'rb' )

602

self.fp = open( self.filename, 'rb' )

603

self.fp.seek( currentPointer )

603

self.fp.seek( currentPointer )

604

605

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

605

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

606

currentSize = self.fileSize - currentPointer

606

currentSize = self.fileSize - currentPointer

607

608

if ( currentSize >= neededSize ):

608

if ( currentSize >= neededSize ):

609

self.__rdBasicHeader()

609

self.__rdBasicHeader()

610

return 1

610

return 1

611

612

print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)

612

print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)

613

time.sleep( self.delay )

613

time.sleep( self.delay )

614

615

616

return 0

616

return 0

617

618

def __setNewBlock(self):

618

def __setNewBlock(self):

619

620

if self.fp == None:

620

if self.fp == None:

621

return 0

621

return 0

622

623

if self.flagIsNewFile:

623

if self.flagIsNewFile:

624

return 1

624

return 1

625

626

self.lastUTTime = self.basicHeaderObj.utc

626

self.lastUTTime = self.basicHeaderObj.utc

627

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

627

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

628

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

628

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

629

630

if (currentSize >= neededSize):

630

if (currentSize >= neededSize):

631

self.__rdBasicHeader()

631

self.__rdBasicHeader()

632

return 1

632

return 1

633

634

if self.__waitNewBlock():

634

if self.__waitNewBlock():

635

return 1

635

return 1

636

637

if not(self.setNextFile()):

637

if not(self.setNextFile()):

638

return 0

638

return 0

639

640

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

640

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

641

642

self.flagTimeBlock = 0

642

self.flagTimeBlock = 0

643

644

if deltaTime > self.maxTimeStep:

644

if deltaTime > self.maxTimeStep:

645

self.flagTimeBlock = 1

645

self.flagTimeBlock = 1

646

647

return 1

647

return 1

648

649

650

def readNextBlock(self):

650

def readNextBlock(self):

651

if not(self.__setNewBlock()):

651

if not(self.__setNewBlock()):

652

return 0

652

return 0

653

654

if not(self.readBlock()):

654

if not(self.readBlock()):

655

return 0

655

return 0

656

657

return 1

657

return 1

658

659

def __rdProcessingHeader(self, fp=None):

659

def __rdProcessingHeader(self, fp=None):

660

if fp == None:

660

if fp == None:

661

fp = self.fp

661

fp = self.fp

662

663

self.processingHeaderObj.read(fp)

663

self.processingHeaderObj.read(fp)

664

665

def __rdRadarControllerHeader(self, fp=None):

665

def __rdRadarControllerHeader(self, fp=None):

666

if fp == None:

666

if fp == None:

667

fp = self.fp

667

fp = self.fp

668

669

self.radarControllerHeaderObj.read(fp)

669

self.radarControllerHeaderObj.read(fp)

670

671

def __rdSystemHeader(self, fp=None):

671

def __rdSystemHeader(self, fp=None):

672

if fp == None:

672

if fp == None:

673

fp = self.fp

673

fp = self.fp

674

675

self.systemHeaderObj.read(fp)

675

self.systemHeaderObj.read(fp)

676

677

def __rdBasicHeader(self, fp=None):

677

def __rdBasicHeader(self, fp=None):

678

if fp == None:

678

if fp == None:

679

fp = self.fp

679

fp = self.fp

680

681

self.basicHeaderObj.read(fp)

681

self.basicHeaderObj.read(fp)

682

683

684

def __readFirstHeader(self):

684

def __readFirstHeader(self):

685

self.__rdBasicHeader()

685

self.__rdBasicHeader()

686

self.__rdSystemHeader()

686

self.__rdSystemHeader()

687

self.__rdRadarControllerHeader()

687

self.__rdRadarControllerHeader()

688

self.__rdProcessingHeader()

688

self.__rdProcessingHeader()

689

690

self.firstHeaderSize = self.basicHeaderObj.size

690

self.firstHeaderSize = self.basicHeaderObj.size

691

692

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

692

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

693

if datatype == 0:

693

if datatype == 0:

694

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

694

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

695

elif datatype == 1:

695

elif datatype == 1:

696

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

696

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

697

elif datatype == 2:

697

elif datatype == 2:

698

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

698

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

699

elif datatype == 3:

699

elif datatype == 3:

700

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

700

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

701

elif datatype == 4:

701

elif datatype == 4:

702

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

702

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

703

elif datatype == 5:

703

elif datatype == 5:

704

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

704

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

705

else:

705

else:

706

raise ValueError, 'Data type was not defined'

706

raise ValueError, 'Data type was not defined'

707

708

self.dtype = datatype_str

708

self.dtype = datatype_str

709

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

709

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

710

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

710

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

711

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

711

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

712

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

712

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

713

self.getBlockDimension()

713

self.getBlockDimension()

714

715

716

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

716

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

717

msg = None

717

msg = None

718

try:

718

try:

719

fp = open(filename, 'rb')

719

fp = open(filename, 'rb')

720

currentPosition = fp.tell()

720

currentPosition = fp.tell()

721

except:

721

except:

722

if msgFlag:

722

if msgFlag:

723

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

723

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

724

return False

724

return False

725

726

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

726

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

727

728

if neededSize == 0:

728

if neededSize == 0:

729

basicHeaderObj = BasicHeader(LOCALTIME)

729

basicHeaderObj = BasicHeader(LOCALTIME)

730

systemHeaderObj = SystemHeader()

730

systemHeaderObj = SystemHeader()

731

radarControllerHeaderObj = RadarControllerHeader()

731

radarControllerHeaderObj = RadarControllerHeader()

732

processingHeaderObj = ProcessingHeader()

732

processingHeaderObj = ProcessingHeader()

733

734

try:

734

try:

735

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

735

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

736

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

736

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

737

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

737

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

738

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

738

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

739

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

739

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

740

741

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

741

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

742

743

except:

743

except:

744

if msgFlag:

744

if msgFlag:

745

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

745

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

746

747

fp.close()

747

fp.close()

748

return False

748

return False

749

else:

749

else:

750

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

750

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

751

752

fp.close()

752

fp.close()

753

fileSize = os.path.getsize(filename)

753

fileSize = os.path.getsize(filename)

754

currentSize = fileSize - currentPosition

754

currentSize = fileSize - currentPosition

755

if currentSize < neededSize:

755

if currentSize < neededSize:

756

if msgFlag and (msg != None):

756

if msgFlag and (msg != None):

757

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

757

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

758

return False

758

return False

759

760

return True

760

return True

761

762

def setup(self,

762

def setup(self,

763

path=None,

763

path=None,

764

startDate=None,

764

startDate=None,

765

endDate=None,

765

endDate=None,

766

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

766

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

767

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

767

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

768

set=0,

768

set=0,

769

expLabel = "",

769

expLabel = "",

770

ext = None,

770

ext = None,

771

online = False,

771

online = False,

772

delay = 60,

772

delay = 60,

773

walk = True):

773

walk = True):

774

775

if path == None:

775

if path == None:

776

raise ValueError, "The path is not valid"

776

raise ValueError, "The path is not valid"

777

778

if ext == None:

778

if ext == None:

779

ext = self.ext

779

ext = self.ext

780

781

if online:

781

if online:

782

print "Searching files in online mode..."

782

print "Searching files in online mode..."

783

784

for nTries in range( self.nTries ):

784

for nTries in range( self.nTries ):

785

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

785

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

786

787

if fullpath:

787

if fullpath:

788

break

788

break

789

790

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

790

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

791

time.sleep( self.delay )

791

time.sleep( self.delay )

792

793

if not(fullpath):

793

if not(fullpath):

794

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

794

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

795

return None

795

return None

796

797

self.year = year

797

self.year = year

798

self.doy = doy

798

self.doy = doy

799

self.set = set - 1

799

self.set = set - 1

800

self.path = path

800

self.path = path

801

802

else:

802

else:

803

print "Searching files in offline mode ..."

803

print "Searching files in offline mode ..."

804

pathList, filenameList = self.__searchFilesOffLine(path, startDate=startDate, endDate=endDate,

804

pathList, filenameList = self.__searchFilesOffLine(path, startDate=startDate, endDate=endDate,

805

startTime=startTime, endTime=endTime,

805

startTime=startTime, endTime=endTime,

806

set=set, expLabel=expLabel, ext=ext,

806

set=set, expLabel=expLabel, ext=ext,

807

walk=walk)

807

walk=walk)

808

809

if not(pathList):

809

if not(pathList):

810

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

810

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

811

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

811

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

812

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

812

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

813

814

sys.exit(-1)

814

sys.exit(-1)

815

816

817

self.fileIndex = -1

817

self.fileIndex = -1

818

self.pathList = pathList

818

self.pathList = pathList

819

self.filenameList = filenameList

819

self.filenameList = filenameList

820

821

self.online = online

821

self.online = online

822

self.delay = delay

822

self.delay = delay

823

ext = ext.lower()

823

ext = ext.lower()

824

self.ext = ext

824

self.ext = ext

825

826

if not(self.setNextFile()):

826

if not(self.setNextFile()):

827

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

827

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

828

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

828

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

829

elif startDate != None:

829

elif startDate != None:

830

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

830

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

831

else:

831

else:

832

print "No files"

832

print "No files"

833

834

sys.exit(-1)

834

sys.exit(-1)

835

836

# self.updateDataHeader()

836

# self.updateDataHeader()

837

838

return self.dataOut

838

return self.dataOut

839

840

def getData():

840

def getData():

841

842

raise ValueError, "This method has not been implemented"

842

raise ValueError, "This method has not been implemented"

843

844

def hasNotDataInBuffer():

844

def hasNotDataInBuffer():

845

846

raise ValueError, "This method has not been implemented"

846

raise ValueError, "This method has not been implemented"

847

848

def readBlock():

848

def readBlock():

849

850

raise ValueError, "This method has not been implemented"

850

raise ValueError, "This method has not been implemented"

851

852

def isEndProcess(self):

852

def isEndProcess(self):

853

854

return self.flagNoMoreFiles

854

return self.flagNoMoreFiles

855

856

def printReadBlocks(self):

856

def printReadBlocks(self):

857

858

print "Number of read blocks per file %04d" %self.nReadBlocks

858

print "Number of read blocks per file %04d" %self.nReadBlocks

859

860

def printTotalBlocks(self):

860

def printTotalBlocks(self):

861

862

print "Number of read blocks %04d" %self.nTotalBlocks

862

print "Number of read blocks %04d" %self.nTotalBlocks

863

864

def printNumberOfBlock(self):

864

def printNumberOfBlock(self):

865

866

if self.flagIsNewBlock:

866

if self.flagIsNewBlock:

867

print "Block No. %04d, Total blocks %04d" %(self.basicHeaderObj.dataBlock, self.nTotalBlocks)

867

print "Block No. %04d, Total blocks %04d" %(self.basicHeaderObj.dataBlock, self.nTotalBlocks)

868

869

def printInfo(self):

869

def printInfo(self):

870

871

print self.basicHeaderObj.printInfo()

871

print self.basicHeaderObj.printInfo()

872

print self.systemHeaderObj.printInfo()

872

print self.systemHeaderObj.printInfo()

873

print self.radarControllerHeaderObj.printInfo()

873

print self.radarControllerHeaderObj.printInfo()

874

print self.processingHeaderObj.printInfo()

874

print self.processingHeaderObj.printInfo()

875

876

877

def run(self, **kwargs):

877

def run(self, **kwargs):

878

879

if not(self.isConfig):

879

if not(self.isConfig):

880

881

# self.dataOut = dataOut

881

# self.dataOut = dataOut

882

self.setup(**kwargs)

882

self.setup(**kwargs)

883

self.isConfig = True

883

self.isConfig = True

884

885

self.getData()

885

self.getData()

886

887

class JRODataWriter(JRODataIO, Operation):

887

class JRODataWriter(JRODataIO, Operation):

888

889

"""

889

"""

890

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

890

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

891

de los datos siempre se realiza por bloques.

891

de los datos siempre se realiza por bloques.

892

"""

892

"""

893

894

blockIndex = 0

894

blockIndex = 0

895

896

path = None

896

path = None

897

898

setFile = None

898

setFile = None

899

900

profilesPerBlock = None

900

profilesPerBlock = None

901

902

blocksPerFile = None

902

blocksPerFile = None

903

904

nWriteBlocks = 0

904

nWriteBlocks = 0

905

906

def __init__(self, dataOut=None):

906

def __init__(self, dataOut=None):

907

raise ValueError, "Not implemented"

907

raise ValueError, "Not implemented"

908

909

910

def hasAllDataInBuffer(self):

910

def hasAllDataInBuffer(self):

911

raise ValueError, "Not implemented"

911

raise ValueError, "Not implemented"

912

913

914

def setBlockDimension(self):

914

def setBlockDimension(self):

915

raise ValueError, "Not implemented"

915

raise ValueError, "Not implemented"

916

917

918

def writeBlock(self):

918

def writeBlock(self):

919

raise ValueError, "No implemented"

919

raise ValueError, "No implemented"

920

921

922

def putData(self):

922

def putData(self):

923

raise ValueError, "No implemented"

923

raise ValueError, "No implemented"

924

925

def getDataHeader(self):

925

def getDataHeader(self):

926

"""

926

"""

927

Obtiene una copia del First Header

927

Obtiene una copia del First Header

928

929

Affected:

929

Affected:

930

931

self.basicHeaderObj

931

self.basicHeaderObj

932

self.systemHeaderObj

932

self.systemHeaderObj

933

self.radarControllerHeaderObj

933

self.radarControllerHeaderObj

934

self.processingHeaderObj self.

934

self.processingHeaderObj self.

935

936

Return:

936

Return:

937

None

937

None

938

"""

938

"""

939

940

raise ValueError, "No implemented"

940

raise ValueError, "No implemented"

941

942

def getBasicHeader(self):

942

def getBasicHeader(self):

943

944

self.basicHeaderObj.size = self.basicHeaderSize #bytes

944

self.basicHeaderObj.size = self.basicHeaderSize #bytes

945

self.basicHeaderObj.version = self.versionFile

945

self.basicHeaderObj.version = self.versionFile

946

self.basicHeaderObj.dataBlock = self.nTotalBlocks

946

self.basicHeaderObj.dataBlock = self.nTotalBlocks

947

948

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

948

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

949

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

949

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

950

951

self.basicHeaderObj.utc = utc

951

self.basicHeaderObj.utc = utc

952

self.basicHeaderObj.miliSecond = milisecond

952

self.basicHeaderObj.miliSecond = milisecond

953

self.basicHeaderObj.timeZone = 0

953

self.basicHeaderObj.timeZone = 0

954

self.basicHeaderObj.dstFlag = 0

954

self.basicHeaderObj.dstFlag = 0

955

self.basicHeaderObj.errorCount = 0

955

self.basicHeaderObj.errorCount = 0

956

957

def __writeFirstHeader(self):

957

def __writeFirstHeader(self):

958

"""

958

"""

959

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

959

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

960

961

Affected:

961

Affected:

962

__dataType

962

__dataType

963

964

Return:

964

Return:

965

None

965

None

966

"""

966

"""

967

968

# CALCULAR PARAMETROS

968

# CALCULAR PARAMETROS

969

970

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

970

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

971

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

971

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

972

973

self.basicHeaderObj.write(self.fp)

973

self.basicHeaderObj.write(self.fp)

974

self.systemHeaderObj.write(self.fp)

974

self.systemHeaderObj.write(self.fp)

975

self.radarControllerHeaderObj.write(self.fp)

975

self.radarControllerHeaderObj.write(self.fp)

976

self.processingHeaderObj.write(self.fp)

976

self.processingHeaderObj.write(self.fp)

977

978

self.dtype = self.dataOut.dtype

978

self.dtype = self.dataOut.dtype

979

980

def __setNewBlock(self):

980

def __setNewBlock(self):

981

"""

981

"""

982

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

982

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

983

984

Return:

984

Return:

985

0 : si no pudo escribir nada

985

0 : si no pudo escribir nada

986

1 : Si escribio el Basic el First Header

986

1 : Si escribio el Basic el First Header

987

"""

987

"""

988

if self.fp == None:

988

if self.fp == None:

989

self.setNextFile()

989

self.setNextFile()

990

991

if self.flagIsNewFile:

991

if self.flagIsNewFile:

992

return 1

992

return 1

993

994

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

994

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

995

self.basicHeaderObj.write(self.fp)

995

self.basicHeaderObj.write(self.fp)

996

return 1

996

return 1

997

998

if not( self.setNextFile() ):

998

if not( self.setNextFile() ):

999

return 0

999

return 0

1000

1001

return 1

1001

return 1

1002

1003

1004

def writeNextBlock(self):

1004

def writeNextBlock(self):

1005

"""

1005

"""

1006

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

1006

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

1007

1008

Return:

1008

Return:

1009

0 : Si no hizo pudo escribir el bloque de datos

1009

0 : Si no hizo pudo escribir el bloque de datos

1010

1 : Si no pudo escribir el bloque de datos

1010

1 : Si no pudo escribir el bloque de datos

1011

"""

1011

"""

1012

if not( self.__setNewBlock() ):

1012

if not( self.__setNewBlock() ):

1013

return 0

1013

return 0

1014

1015

self.writeBlock()

1015

self.writeBlock()

1016

1017

return 1

1017

return 1

1018

1019

def setNextFile(self):

1019

def setNextFile(self):

1020

"""

1020

"""

1021

Determina el siguiente file que sera escrito

1021

Determina el siguiente file que sera escrito

1022

1023

Affected:

1023

Affected:

1024

self.filename

1024

self.filename

1025

self.subfolder

1025

self.subfolder

1026

self.fp

1026

self.fp

1027

self.setFile

1027

self.setFile

1028

self.flagIsNewFile

1028

self.flagIsNewFile

1029

1030

Return:

1030

Return:

1031

0 : Si el archivo no puede ser escrito

1031

0 : Si el archivo no puede ser escrito

1032

1 : Si el archivo esta listo para ser escrito

1032

1 : Si el archivo esta listo para ser escrito

1033

"""

1033

"""

1034

ext = self.ext

1034

ext = self.ext

1035

path = self.path

1035

path = self.path

1036

1037

if self.fp != None:

1037

if self.fp != None:

1038

self.fp.close()

1038

self.fp.close()

1039

1040

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

1040

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

1041

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

1041

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

1042

1043

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

1043

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

1044

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

1044

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

1045

os.mkdir(fullpath)

1045

os.mkdir(fullpath)

1046

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

1046

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

1047

else:

1047

else:

1048

filesList = os.listdir( fullpath )

1048

filesList = os.listdir( fullpath )

1049

if len( filesList ) > 0:

1049

if len( filesList ) > 0:

1050

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

1050

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

1051

filen = filesList[-1]

1051

filen = filesList[-1]

1052

# el filename debera tener el siguiente formato

1052

# el filename debera tener el siguiente formato

1053

# 0 1234 567 89A BCDE (hex)

1053

# 0 1234 567 89A BCDE (hex)

1054

# x YYYY DDD SSS .ext

1054

# x YYYY DDD SSS .ext

1055

if isNumber( filen[8:11] ):

1055

if isNumber( filen[8:11] ):

1056

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

1056

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

1057

else:

1057

else:

1058

self.setFile = -1

1058

self.setFile = -1

1059

else:

1059

else:

1060

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

1060

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

1061

1062

setFile = self.setFile

1062

setFile = self.setFile

1063

setFile += 1

1063

setFile += 1

1064

1065

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

1065

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

1066

timeTuple.tm_year,

1066

timeTuple.tm_year,

1067

timeTuple.tm_yday,

1067

timeTuple.tm_yday,

1068

setFile,

1068

setFile,

1069

ext )

1069

ext )

1070

1071

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

1071

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

1072

1073

fp = open( filename,'wb' )

1073

fp = open( filename,'wb' )

1074

1075

self.blockIndex = 0

1075

self.blockIndex = 0

1076

1077

#guardando atributos

1077

#guardando atributos

1078

self.filename = filename

1078

self.filename = filename

1079

self.subfolder = subfolder

1079

self.subfolder = subfolder

1080

self.fp = fp

1080

self.fp = fp

1081

self.setFile = setFile

1081

self.setFile = setFile

1082

self.flagIsNewFile = 1

1082

self.flagIsNewFile = 1

1083

1084

self.getDataHeader()

1084

self.getDataHeader()

1085

1086

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

1086

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

1087

1088

self.__writeFirstHeader()

1088

self.__writeFirstHeader()

1089

1090

return 1

1090

return 1

1091

1092

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

1092

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

1093

"""

1093

"""

1094

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

1094

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

1095

1096

Inputs:

1096

Inputs:

1097

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

1097

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

1098

format : formato en el cual sera salvado un file

1098

format : formato en el cual sera salvado un file

1099

set : el setebo del file

1099

set : el setebo del file

1100

1101

Return:

1101

Return:

1102

0 : Si no realizo un buen seteo

1102

0 : Si no realizo un buen seteo

1103

1 : Si realizo un buen seteo

1103

1 : Si realizo un buen seteo

1104

"""

1104

"""

1105

1106

if ext == None:

1106

if ext == None:

1107

ext = self.ext

1107

ext = self.ext

1108

1109

ext = ext.lower()

1109

ext = ext.lower()

1110

1111

self.ext = ext

1111

self.ext = ext

1112

1113

self.path = path

1113

self.path = path

1114

1115

self.setFile = set - 1

1115

self.setFile = set - 1

1116

1117

self.blocksPerFile = blocksPerFile

1117

self.blocksPerFile = blocksPerFile

1118

1119

self.profilesPerBlock = profilesPerBlock

1119

self.profilesPerBlock = profilesPerBlock

1120

1121

self.dataOut = dataOut

1121

self.dataOut = dataOut

1122

1123

if not(self.setNextFile()):

1123

if not(self.setNextFile()):

1124

print "There isn't a next file"

1124

print "There isn't a next file"

1125

return 0

1125

return 0

1126

1127

self.setBlockDimension()

1127

self.setBlockDimension()

1128

1129

return 1

1129

return 1

1130

1131

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

1131

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

1132

1133

if not(self.isConfig):

1133

if not(self.isConfig):

1134

1135

self.setup(dataOut, **kwargs)

1135

self.setup(dataOut, **kwargs)

1136

self.isConfig = True

1136

self.isConfig = True

1137

1138

self.putData()

1138

self.putData()

1139

1140

class VoltageReader(JRODataReader):

1140

class VoltageReader(JRODataReader):

1141

"""

1141

"""

1142

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

1142

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

1143

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

1143

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

1144

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

1144

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

1145

1146

perfiles * alturas * canales

1146

perfiles * alturas * canales

1147

1148

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

1148

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

1149

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

1149

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

1150

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

1150

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

1151

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

1151

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

1152

1153

Example:

1153

Example:

1154

1155

dpath = "/home/myuser/data"

1155

dpath = "/home/myuser/data"

1156

1157

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

1157

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

1158

1159

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

1159

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

1160

1161

readerObj = VoltageReader()

1161

readerObj = VoltageReader()

1162

1163

readerObj.setup(dpath, startTime, endTime)

1163

readerObj.setup(dpath, startTime, endTime)

1164

1165

while(True):

1165

while(True):

1166

1167

#to get one profile

1167

#to get one profile

1168

profile = readerObj.getData()

1168

profile = readerObj.getData()

1169

1170

#print the profile

1170

#print the profile

1171

print profile

1171

print profile

1172

1173

#If you want to see all datablock

1173

#If you want to see all datablock

1174

print readerObj.datablock

1174

print readerObj.datablock

1175

1176

if readerObj.flagNoMoreFiles:

1176

if readerObj.flagNoMoreFiles:

1177

break

1177

break

1178

1179

"""

1179

"""

1180

1181

ext = ".r"

1181

ext = ".r"

1182

1183

optchar = "D"

1183

optchar = "D"

1184

dataOut = None

1184

dataOut = None

1185

1186

1187

def __init__(self):

1187

def __init__(self):

1188

"""

1188

"""

1189

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

1189

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

1190

1191

Input:

1191

Input:

1192

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

1192

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

1193

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

1193

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

1194

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

1194

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

1195

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

1195

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

1196

bloque de datos.

1196

bloque de datos.

1197

Si este parametro no es pasado se creara uno internamente.

1197

Si este parametro no es pasado se creara uno internamente.

1198

1199

Variables afectadas:

1199

Variables afectadas:

1200

self.dataOut

1200

self.dataOut

1201

1202

Return:

1202

Return:

1203

None

1203

None

1204

"""

1204

"""

1205

1206

self.isConfig = False

1206

self.isConfig = False

1207

1208

self.datablock = None

1208

self.datablock = None

1209

1210

self.utc = 0

1210

self.utc = 0

1211

1212

self.ext = ".r"

1212

self.ext = ".r"

1213

1214

self.optchar = "D"

1214

self.optchar = "D"

1215

1216

self.basicHeaderObj = BasicHeader(LOCALTIME)

1216

self.basicHeaderObj = BasicHeader(LOCALTIME)

1217

1218

self.systemHeaderObj = SystemHeader()

1218

self.systemHeaderObj = SystemHeader()

1219

1220

self.radarControllerHeaderObj = RadarControllerHeader()

1220

self.radarControllerHeaderObj = RadarControllerHeader()

1221

1222

self.processingHeaderObj = ProcessingHeader()

1222

self.processingHeaderObj = ProcessingHeader()

1223

1224

self.online = 0

1224

self.online = 0

1225

1226

self.fp = None

1226

self.fp = None

1227

1228

self.idFile = None

1228

self.idFile = None

1229

1230

self.dtype = None

1230

self.dtype = None

1231

1232

self.fileSizeByHeader = None

1232

self.fileSizeByHeader = None

1233

1234

self.filenameList = []

1234

self.filenameList = []

1235

1236

self.filename = None

1236

self.filename = None

1237

1238

self.fileSize = None

1238

self.fileSize = None

1239

1240

self.firstHeaderSize = 0

1240

self.firstHeaderSize = 0

1241

1242

self.basicHeaderSize = 24

1242

self.basicHeaderSize = 24

1243

1244

self.pathList = []

1244

self.pathList = []

1245

1246

self.filenameList = []

1246

self.filenameList = []

1247

1248

self.lastUTTime = 0

1248

self.lastUTTime = 0

1249

1250

self.maxTimeStep = 30

1250

self.maxTimeStep = 30

1251

1252

self.flagNoMoreFiles = 0

1252

self.flagNoMoreFiles = 0

1253

1254

self.set = 0

1254

self.set = 0

1255

1256

self.path = None

1256

self.path = None

1257

1258

self.profileIndex = 9999

1258

self.profileIndex = 9999

1259

1260

self.delay = 3 #seconds

1260

self.delay = 3 #seconds

1261

1262

self.nTries = 3 #quantity tries

1262

self.nTries = 3 #quantity tries

1263

1264

self.nFiles = 3 #number of files for searching

1264

self.nFiles = 3 #number of files for searching

1265

1266

self.nReadBlocks = 0

1266

self.nReadBlocks = 0

1267

1268

self.flagIsNewFile = 1

1268

self.flagIsNewFile = 1

1269

1270

self.ippSeconds = 0

1270

self.ippSeconds = 0

1271

1272

self.flagTimeBlock = 0

1272

self.flagTimeBlock = 0

1273

1274

self.flagIsNewBlock = 0

1274

self.flagIsNewBlock = 0

1275

1276

self.nTotalBlocks = 0

1276

self.nTotalBlocks = 0

1277

1278

self.blocksize = 0

1278

self.blocksize = 0

1279

1280

self.dataOut = self.createObjByDefault()

1280

self.dataOut = self.createObjByDefault()

1281

1282

def createObjByDefault(self):

1282

def createObjByDefault(self):

1283

1284

dataObj = Voltage()

1284

dataObj = Voltage()

1285

1286

return dataObj

1286

return dataObj

1287

1288

def __hasNotDataInBuffer(self):

1288

def __hasNotDataInBuffer(self):

1289

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

1289

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

1290

return 1

1290

return 1

1291

return 0

1291

return 0

1292

1293

1294

def getBlockDimension(self):

1294

def getBlockDimension(self):

1295

"""

1295

"""

1296

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

1296

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

1297

1298

Affected:

1298

Affected:

1299

self.blocksize

1299

self.blocksize

1300

1301

Return:

1301

Return:

1302

None

1302

None

1303

"""

1303

"""

1304

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

1304

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

1305

self.blocksize = pts2read

1305

self.blocksize = pts2read

1306

1307

1308

def readBlock(self):

1308

def readBlock(self):

1309

"""

1309

"""

1310

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

1310

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

1311

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

1311

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

1312

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

1312

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

1313

es seteado a 0

1313

es seteado a 0

1314

1315

Inputs:

1315

Inputs:

1316

None

1316

None

1317

1318

Return:

1318

Return:

1319

None

1319

None

1320

1321

Affected:

1321

Affected:

1322

self.profileIndex

1322

self.profileIndex

1323

self.datablock

1323

self.datablock

1324

self.flagIsNewFile

1324

self.flagIsNewFile

1325

self.flagIsNewBlock

1325

self.flagIsNewBlock

1326

self.nTotalBlocks

1326

self.nTotalBlocks

1327

1328

Exceptions:

1328

Exceptions:

1329

Si un bloque leido no es un bloque valido

1329

Si un bloque leido no es un bloque valido

1330

"""

1330

"""

1331

1332

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

1332

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

1333

1334

try:

1334

try:

1335

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

1335

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

1336

except:

1336

except:

1337

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

1337

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

1338

return 0

1338

return 0

1339

1340

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

1340

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

1341

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

1341

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

1342

1343

self.profileIndex = 0

1343

self.profileIndex = 0

1344

1345

self.flagIsNewFile = 0

1345

self.flagIsNewFile = 0

1346

self.flagIsNewBlock = 1

1346

self.flagIsNewBlock = 1

1347

1348

self.nTotalBlocks += 1

1348

self.nTotalBlocks += 1

1349

self.nReadBlocks += 1

1349

self.nReadBlocks += 1

1350

1351

return 1

1351

return 1

1352

1353

1354

def getData(self):

1354

def getData(self):

1355

"""

1355

"""

1356

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

1356

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

1357

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

1357

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

1358

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

1358

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

1359

1360

Ademas incrementa el contador del buffer en 1.

1360

Ademas incrementa el contador del buffer en 1.

1361

1362

Return:

1362

Return:

1363

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

1363

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

1364

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

1364

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

1365

1366

Variables afectadas:

1366

Variables afectadas:

1367

self.dataOut

1367

self.dataOut

1368

self.profileIndex

1368

self.profileIndex

1369

1370

Affected:

1370

Affected:

1371

self.dataOut

1371

self.dataOut

1372

self.profileIndex

1372

self.profileIndex

1373

self.flagTimeBlock

1373

self.flagTimeBlock

1374

self.flagIsNewBlock

1374

self.flagIsNewBlock

1375

"""

1375

"""

1376

1377

if self.flagNoMoreFiles:

1377

if self.flagNoMoreFiles:

1378

self.dataOut.flagNoData = True

1378

self.dataOut.flagNoData = True

1379

print 'Process finished'

1379

print 'Process finished'

1380

return 0

1380

return 0

1381

1382

self.flagTimeBlock = 0

1382

self.flagTimeBlock = 0

1383

self.flagIsNewBlock = 0

1383

self.flagIsNewBlock = 0

1384

1385

if self.__hasNotDataInBuffer():

1385

if self.__hasNotDataInBuffer():

1386

1387

if not( self.readNextBlock() ):

1387

if not( self.readNextBlock() ):

1388

return 0

1388

return 0

1389

1390

self.dataOut.dtype = numpy.dtype([('real','<f8'),('imag','<f8')]) #self.dtype

1390

self.dataOut.dtype = numpy.dtype([('real','<f8'),('imag','<f8')]) #self.dtype

1391

1392

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1392

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1393

1394

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

1394

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

1395

1396

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

1396

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

1397

1398

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

1398

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

1399

1400

self.dataOut.flagTimeBlock = self.flagTimeBlock

1400

self.dataOut.flagTimeBlock = self.flagTimeBlock

1401

1402

self.dataOut.ippSeconds = self.ippSeconds

1402

self.dataOut.ippSeconds = self.ippSeconds

1403

1404

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

1404

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

1405

1406

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1406

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1407

1408

self.dataOut.flagShiftFFT = False

1408

self.dataOut.flagShiftFFT = False

1409

1410

if self.radarControllerHeaderObj.code != None:

1410

if self.radarControllerHeaderObj.code != None:

1411

1412

self.dataOut.nCode = self.radarControllerHeaderObj.nCode

1412

self.dataOut.nCode = self.radarControllerHeaderObj.nCode

1413

1414

self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud

1414

self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud

1415

1416

self.dataOut.code = self.radarControllerHeaderObj.code

1416

self.dataOut.code = self.radarControllerHeaderObj.code

1417

1418

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

1418

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

1419

1420

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

1420

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

1421

1422

self.dataOut.flagDecodeData = False #asumo q la data no esta decodificada

1422

self.dataOut.flagDecodeData = False #asumo q la data no esta decodificada

1423

1424

self.dataOut.flagDeflipData = False #asumo q la data no esta sin flip

1424

self.dataOut.flagDeflipData = False #asumo q la data no esta sin flip

1425

1426

self.dataOut.flagShiftFFT = False

1426

self.dataOut.flagShiftFFT = False

1427

1428

1429

# self.updateDataHeader()

1429

# self.updateDataHeader()

1430

1431

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

1431

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

1432

1433

if self.datablock == None:

1433

if self.datablock == None:

1434

self.dataOut.flagNoData = True

1434

self.dataOut.flagNoData = True

1435

return 0

1435

return 0

1436

1437

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

1437

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

1438

1439

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

1439

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

1440

1441

self.profileIndex += 1

1441

self.profileIndex += 1

1442

1443

self.dataOut.flagNoData = False

1443

self.dataOut.flagNoData = False

1444

1445

# print self.profileIndex, self.dataOut.utctime

1445

# print self.profileIndex, self.dataOut.utctime

1446

# if self.profileIndex == 800:

1446

# if self.profileIndex == 800:

1447

# a=1

1447

# a=1

1448

1449

1450

return self.dataOut.data

1450

return self.dataOut.data

1451

1452

1453

class VoltageWriter(JRODataWriter):

1453

class VoltageWriter(JRODataWriter):

1454

"""

1454

"""

1455

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

1455

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

1456

de los datos siempre se realiza por bloques.

1456

de los datos siempre se realiza por bloques.

1457

"""

1457

"""

1458

1459

ext = ".r"

1459

ext = ".r"

1460

1461

optchar = "D"

1461

optchar = "D"

1462

1463

shapeBuffer = None

1463

shapeBuffer = None

1464

1465

1466

def __init__(self):

1466

def __init__(self):

1467

"""

1467

"""

1468

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

1468

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

1469

1470

Affected:

1470

Affected:

1471

self.dataOut

1471

self.dataOut

1472

1473

Return: None

1473

Return: None

1474

"""

1474

"""

1475

1476

self.nTotalBlocks = 0

1476

self.nTotalBlocks = 0

1477

1478

self.profileIndex = 0

1478

self.profileIndex = 0

1479

1480

self.isConfig = False

1480

self.isConfig = False

1481

1482

self.fp = None

1482

self.fp = None

1483

1484

self.flagIsNewFile = 1

1484

self.flagIsNewFile = 1

1485

1486

self.nTotalBlocks = 0

1486

self.nTotalBlocks = 0

1487

1488

self.flagIsNewBlock = 0

1488

self.flagIsNewBlock = 0

1489

1490

self.setFile = None

1490

self.setFile = None

1491

1492

self.dtype = None

1492

self.dtype = None

1493

1494

self.path = None

1494

self.path = None

1495

1496

self.filename = None

1496

self.filename = None

1497

1498

self.basicHeaderObj = BasicHeader(LOCALTIME)

1498

self.basicHeaderObj = BasicHeader(LOCALTIME)

1499

1500

self.systemHeaderObj = SystemHeader()

1500

self.systemHeaderObj = SystemHeader()

1501

1502

self.radarControllerHeaderObj = RadarControllerHeader()

1502

self.radarControllerHeaderObj = RadarControllerHeader()

1503

1504

self.processingHeaderObj = ProcessingHeader()

1504

self.processingHeaderObj = ProcessingHeader()

1505

1506

def hasAllDataInBuffer(self):

1506

def hasAllDataInBuffer(self):

1507

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

1507

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

1508

return 1

1508

return 1

1509

return 0

1509

return 0

1510

1511

1512

def setBlockDimension(self):

1512

def setBlockDimension(self):

1513

"""

1513

"""

1514

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

1514

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

1515

1516

Affected:

1516

Affected:

1517

self.shape_spc_Buffer

1517

self.shape_spc_Buffer

1518

self.shape_cspc_Buffer

1518

self.shape_cspc_Buffer

1519

self.shape_dc_Buffer

1519

self.shape_dc_Buffer

1520

1521

Return: None

1521

Return: None

1522

"""

1522

"""

1523

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1523

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1524

self.processingHeaderObj.nHeights,

1524

self.processingHeaderObj.nHeights,

1525

self.systemHeaderObj.nChannels)

1525

self.systemHeaderObj.nChannels)

1526

1527

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

1527

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

1528

self.processingHeaderObj.profilesPerBlock,

1528

self.processingHeaderObj.profilesPerBlock,

1529

self.processingHeaderObj.nHeights),

1529

self.processingHeaderObj.nHeights),

1530

dtype=numpy.dtype('complex'))

1530

dtype=numpy.dtype('complex'))

1531

1532

1533

def writeBlock(self):

1533

def writeBlock(self):

1534

"""

1534

"""

1535

Escribe el buffer en el file designado

1535

Escribe el buffer en el file designado

1536

1537

Affected:

1537

Affected:

1538

self.profileIndex

1538

self.profileIndex

1539

self.flagIsNewFile

1539

self.flagIsNewFile

1540

self.flagIsNewBlock

1540

self.flagIsNewBlock

1541

self.nTotalBlocks

1541

self.nTotalBlocks

1542

self.blockIndex

1542

self.blockIndex

1543

1544

Return: None

1544

Return: None

1545

"""

1545

"""

1546

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

1546

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

1547

1548

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

1548

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

1549

1550

data['real'] = junk.real

1550

data['real'] = junk.real

1551

data['imag'] = junk.imag

1551

data['imag'] = junk.imag

1552

1553

data = data.reshape( (-1) )

1553

data = data.reshape( (-1) )

1554

1555

data.tofile( self.fp )

1555

data.tofile( self.fp )

1556

1557

self.datablock.fill(0)

1557

self.datablock.fill(0)

1558

1559

self.profileIndex = 0

1559

self.profileIndex = 0

1560

self.flagIsNewFile = 0

1560

self.flagIsNewFile = 0

1561

self.flagIsNewBlock = 1

1561

self.flagIsNewBlock = 1

1562

1563

self.blockIndex += 1

1563

self.blockIndex += 1

1564

self.nTotalBlocks += 1

1564

self.nTotalBlocks += 1

1565

1566

def putData(self):

1566

def putData(self):

1567

"""

1567

"""

1568

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

1568

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

1569

1570

Affected:

1570

Affected:

1571

self.flagIsNewBlock

1571

self.flagIsNewBlock

1572

self.profileIndex

1572

self.profileIndex

1573

1574

Return:

1574

Return:

1575

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

1575

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

1576

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

1576

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

1577

"""

1577

"""

1578

if self.dataOut.flagNoData:

1578

if self.dataOut.flagNoData:

1579

return 0

1579

return 0

1580

1581

self.flagIsNewBlock = 0

1581

self.flagIsNewBlock = 0

1582

1583

if self.dataOut.flagTimeBlock:

1583

if self.dataOut.flagTimeBlock:

1584

1585

self.datablock.fill(0)

1585

self.datablock.fill(0)

1586

self.profileIndex = 0

1586

self.profileIndex = 0

1587

self.setNextFile()

1587

self.setNextFile()

1588

1589

if self.profileIndex == 0:

1589

if self.profileIndex == 0:

1590

self.getBasicHeader()

1590

self.getBasicHeader()

1591

1592

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

1592

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

1593

1594

self.profileIndex += 1

1594

self.profileIndex += 1

1595

1596

if self.hasAllDataInBuffer():

1596

if self.hasAllDataInBuffer():

1597

#if self.flagIsNewFile:

1597

#if self.flagIsNewFile:

1598

self.writeNextBlock()

1598

self.writeNextBlock()

1599

# self.getDataHeader()

1599

# self.getDataHeader()

1600

1601

return 1

1601

return 1

1602

1603

def __getProcessFlags(self):

1603

def __getProcessFlags(self):

1604

1605

processFlags = 0

1605

processFlags = 0

1606

1607

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

1607

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

1608

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

1608

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

1609

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

1609

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

1610

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

1610

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

1611

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

1611

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

1612

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

1612

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

1613

1614

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

1614

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

1615

1616

1617

1618

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1618

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1619

PROCFLAG.DATATYPE_SHORT,

1619

PROCFLAG.DATATYPE_SHORT,

1620

PROCFLAG.DATATYPE_LONG,

1620

PROCFLAG.DATATYPE_LONG,

1621

PROCFLAG.DATATYPE_INT64,

1621

PROCFLAG.DATATYPE_INT64,

1622

PROCFLAG.DATATYPE_FLOAT,

1622

PROCFLAG.DATATYPE_FLOAT,

1623

PROCFLAG.DATATYPE_DOUBLE]

1623

PROCFLAG.DATATYPE_DOUBLE]

1624

1625

1626

for index in range(len(dtypeList)):

1626

for index in range(len(dtypeList)):

1627

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

1627

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

1628

dtypeValue = datatypeValueList[index]

1628

dtypeValue = datatypeValueList[index]

1629

break

1629

break

1630

1631

processFlags += dtypeValue

1631

processFlags += dtypeValue

1632

1633

if self.dataOut.flagDecodeData:

1633

if self.dataOut.flagDecodeData:

1634

processFlags += PROCFLAG.DECODE_DATA

1634

processFlags += PROCFLAG.DECODE_DATA

1635

1636

if self.dataOut.flagDeflipData:

1636

if self.dataOut.flagDeflipData:

1637

processFlags += PROCFLAG.DEFLIP_DATA

1637

processFlags += PROCFLAG.DEFLIP_DATA

1638

1639

if self.dataOut.code != None:

1639

if self.dataOut.code != None:

1640

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1640

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1641

1642

if self.dataOut.nCohInt > 1:

1642

if self.dataOut.nCohInt > 1:

1643

processFlags += PROCFLAG.COHERENT_INTEGRATION

1643

processFlags += PROCFLAG.COHERENT_INTEGRATION

1644

1645

return processFlags

1645

return processFlags

1646

1647

1648

def __getBlockSize(self):

1648

def __getBlockSize(self):

1649

'''

1649

'''

1650

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

1650

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

1651

'''

1651

'''

1652

1653

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

1653

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

1654

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

1654

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

1655

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

1655

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

1656

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

1656

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

1657

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

1657

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

1658

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

1658

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

1659

1660

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

1660

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

1661

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

1661

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

1662

for index in range(len(dtypeList)):

1662

for index in range(len(dtypeList)):

1663

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

1663

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

1664

datatypeValue = datatypeValueList[index]

1664

datatypeValue = datatypeValueList[index]

1665

break

1665

break

1666

1667

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

1667

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

1668

1669

return blocksize

1669

return blocksize

1670

1671

def getDataHeader(self):

1671

def getDataHeader(self):

1672

1673

"""

1673

"""

1674

Obtiene una copia del First Header

1674

Obtiene una copia del First Header

1675

1676

Affected:

1676

Affected:

1677

self.systemHeaderObj

1677

self.systemHeaderObj

1678

self.radarControllerHeaderObj

1678

self.radarControllerHeaderObj

1679

self.dtype

1679

self.dtype

1680

1681

Return:

1681

Return:

1682

None

1682

None

1683

"""

1683

"""

1684

1685

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

1685

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

1686

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1686

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1687

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

1687

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

1688

1689

self.getBasicHeader()

1689

self.getBasicHeader()

1690

1691

processingHeaderSize = 40 # bytes

1691

processingHeaderSize = 40 # bytes

1692

self.processingHeaderObj.dtype = 0 # Voltage

1692

self.processingHeaderObj.dtype = 0 # Voltage

1693

self.processingHeaderObj.blockSize = self.__getBlockSize()

1693

self.processingHeaderObj.blockSize = self.__getBlockSize()

1694

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1694

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1695

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1695

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1696

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

1696

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

1697

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1697

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1698

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1698

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1699

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

1699

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

1700

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

1700

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

1701

1702

if self.dataOut.code != None:

1702

if self.dataOut.code != None:

1703

self.processingHeaderObj.code = self.dataOut.code

1703

self.processingHeaderObj.code = self.dataOut.code

1704

self.processingHeaderObj.nCode = self.dataOut.nCode

1704

self.processingHeaderObj.nCode = self.dataOut.nCode

1705

self.processingHeaderObj.nBaud = self.dataOut.nBaud

1705

self.processingHeaderObj.nBaud = self.dataOut.nBaud

1706

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

1706

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

1707

processingHeaderSize += codesize

1707

processingHeaderSize += codesize

1708

1709

if self.processingHeaderObj.nWindows != 0:

1709

if self.processingHeaderObj.nWindows != 0:

1710

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

1710

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

1711

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

1711

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

1712

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1712

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1713

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1713

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1714

processingHeaderSize += 12

1714

processingHeaderSize += 12

1715

1716

self.processingHeaderObj.size = processingHeaderSize

1716

self.processingHeaderObj.size = processingHeaderSize

1717

1718

class SpectraReader(JRODataReader):

1718

class SpectraReader(JRODataReader):

1719

"""

1719

"""

1720

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

1720

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

1721

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

1721

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

1722

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

1722

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

1723

1724

paresCanalesIguales * alturas * perfiles (Self Spectra)

1724

paresCanalesIguales * alturas * perfiles (Self Spectra)

1725

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1725

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1726

canales * alturas (DC Channels)

1726

canales * alturas (DC Channels)

1727

1728

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

1728

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

1729

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

1729

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

1730

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

1730

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

1731

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

1731

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

1732

1733

Example:

1733

Example:

1734

dpath = "/home/myuser/data"

1734

dpath = "/home/myuser/data"

1735

1736

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

1736

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

1737

1738

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

1738

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

1739

1740

readerObj = SpectraReader()

1740

readerObj = SpectraReader()

1741

1742

readerObj.setup(dpath, startTime, endTime)

1742

readerObj.setup(dpath, startTime, endTime)

1743

1744

while(True):

1744

while(True):

1745

1746

readerObj.getData()

1746

readerObj.getData()

1747

1748

print readerObj.data_spc

1748

print readerObj.data_spc

1749

1750

print readerObj.data_cspc

1750

print readerObj.data_cspc

1751

1752

print readerObj.data_dc

1752

print readerObj.data_dc

1753

1754

if readerObj.flagNoMoreFiles:

1754

if readerObj.flagNoMoreFiles:

1755

break

1755

break

1756

1757

"""

1757

"""

1758

1759

pts2read_SelfSpectra = 0

1759

pts2read_SelfSpectra = 0

1760

1761

pts2read_CrossSpectra = 0

1761

pts2read_CrossSpectra = 0

1762

1763

pts2read_DCchannels = 0

1763

pts2read_DCchannels = 0

1764

1765

ext = ".pdata"

1765

ext = ".pdata"

1766

1767

optchar = "P"

1767

optchar = "P"

1768

1769

dataOut = None

1769

dataOut = None

1770

1771

nRdChannels = None

1771

nRdChannels = None

1772

1773

nRdPairs = None

1773

nRdPairs = None

1774

1775

rdPairList = []

1775

rdPairList = []

1776

1777

1778

def __init__(self):

1778

def __init__(self):

1779

"""

1779

"""

1780

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

1780

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

1781

1782

Inputs:

1782

Inputs:

1783

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

1783

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

1784

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

1784

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

1785

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

1785

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

1786

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

1786

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

1787

bloque de datos.

1787

bloque de datos.

1788

Si este parametro no es pasado se creara uno internamente.

1788

Si este parametro no es pasado se creara uno internamente.

1789

1790

Affected:

1790

Affected:

1791

self.dataOut

1791

self.dataOut

1792

1793

Return : None

1793

Return : None

1794

"""

1794

"""

1795

1796

self.isConfig = False

1796

self.isConfig = False

1797

1798

self.pts2read_SelfSpectra = 0

1798

self.pts2read_SelfSpectra = 0

1799

1800

self.pts2read_CrossSpectra = 0

1800

self.pts2read_CrossSpectra = 0

1801

1802

self.pts2read_DCchannels = 0

1802

self.pts2read_DCchannels = 0

1803

1804

self.datablock = None

1804

self.datablock = None

1805

1806

self.utc = None

1806

self.utc = None

1807

1808

self.ext = ".pdata"

1808

self.ext = ".pdata"

1809

1810

self.optchar = "P"

1810

self.optchar = "P"

1811

1812

self.basicHeaderObj = BasicHeader(LOCALTIME)

1812

self.basicHeaderObj = BasicHeader(LOCALTIME)

1813

1814

self.systemHeaderObj = SystemHeader()

1814

self.systemHeaderObj = SystemHeader()

1815

1816

self.radarControllerHeaderObj = RadarControllerHeader()

1816

self.radarControllerHeaderObj = RadarControllerHeader()

1817

1818

self.processingHeaderObj = ProcessingHeader()

1818

self.processingHeaderObj = ProcessingHeader()

1819

1820

self.online = 0

1820

self.online = 0

1821

1822

self.fp = None

1822

self.fp = None

1823

1824

self.idFile = None

1824

self.idFile = None

1825

1826

self.dtype = None

1826

self.dtype = None

1827

1828

self.fileSizeByHeader = None

1828

self.fileSizeByHeader = None

1829

1830

self.filenameList = []

1830

self.filenameList = []

1831

1832

self.filename = None

1832

self.filename = None

1833

1834

self.fileSize = None

1834

self.fileSize = None

1835

1836

self.firstHeaderSize = 0

1836

self.firstHeaderSize = 0

1837

1838

self.basicHeaderSize = 24

1838

self.basicHeaderSize = 24

1839

1840

self.pathList = []

1840

self.pathList = []

1841

1842

self.lastUTTime = 0

1842

self.lastUTTime = 0

1843

1844

self.maxTimeStep = 30

1844

self.maxTimeStep = 30

1845

1846

self.flagNoMoreFiles = 0

1846

self.flagNoMoreFiles = 0

1847

1848

self.set = 0

1848

self.set = 0

1849

1850

self.path = None

1850

self.path = None

1851

1852

self.delay = 3 #seconds

1852

self.delay = 3 #seconds

1853

1854

self.nTries = 3 #quantity tries

1854

self.nTries = 3 #quantity tries

1855

1856

self.nFiles = 3 #number of files for searching

1856

self.nFiles = 3 #number of files for searching

1857

1858

self.nReadBlocks = 0

1858

self.nReadBlocks = 0

1859

1860

self.flagIsNewFile = 1

1860

self.flagIsNewFile = 1

1861

1862

self.ippSeconds = 0

1862

self.ippSeconds = 0

1863

1864

self.flagTimeBlock = 0

1864

self.flagTimeBlock = 0

1865

1866

self.flagIsNewBlock = 0

1866

self.flagIsNewBlock = 0

1867

1868

self.nTotalBlocks = 0

1868

self.nTotalBlocks = 0

1869

1870

self.blocksize = 0

1870

self.blocksize = 0

1871

1872

self.dataOut = self.createObjByDefault()

1872

self.dataOut = self.createObjByDefault()

1873

1874

1875

def createObjByDefault(self):

1875

def createObjByDefault(self):

1876

1877

dataObj = Spectra()

1877

dataObj = Spectra()

1878

1879

return dataObj

1879

return dataObj

1880

1881

def __hasNotDataInBuffer(self):

1881

def __hasNotDataInBuffer(self):

1882

return 1

1882

return 1

1883

1884

1885

def getBlockDimension(self):

1885

def getBlockDimension(self):

1886

"""

1886

"""

1887

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

1887

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

1888

1889

Affected:

1889

Affected:

1890

self.nRdChannels

1890

self.nRdChannels

1891

self.nRdPairs

1891

self.nRdPairs

1892

self.pts2read_SelfSpectra

1892

self.pts2read_SelfSpectra

1893

self.pts2read_CrossSpectra

1893

self.pts2read_CrossSpectra

1894

self.pts2read_DCchannels

1894

self.pts2read_DCchannels

1895

self.blocksize

1895

self.blocksize

1896

self.dataOut.nChannels

1896

self.dataOut.nChannels

1897

self.dataOut.nPairs

1897

self.dataOut.nPairs

1898

1899

Return:

1899

Return:

1900

None

1900

None

1901

"""

1901

"""

1902

self.nRdChannels = 0

1902

self.nRdChannels = 0

1903

self.nRdPairs = 0

1903

self.nRdPairs = 0

1904

self.rdPairList = []

1904

self.rdPairList = []

1905

1906

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

1906

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

1907

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

1907

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

1908

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

1908

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

1909

else:

1909

else:

1910

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

1910

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

1911

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

1911

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

1912

1913

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

1913

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

1914

1915

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

1915

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

1916

self.blocksize = self.pts2read_SelfSpectra

1916

self.blocksize = self.pts2read_SelfSpectra

1917

1918

if self.processingHeaderObj.flag_cspc:

1918

if self.processingHeaderObj.flag_cspc:

1919

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

1919

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

1920

self.blocksize += self.pts2read_CrossSpectra

1920

self.blocksize += self.pts2read_CrossSpectra

1921

1922

if self.processingHeaderObj.flag_dc:

1922

if self.processingHeaderObj.flag_dc:

1923

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

1923

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

1924

self.blocksize += self.pts2read_DCchannels

1924

self.blocksize += self.pts2read_DCchannels

1925

1926

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

1926

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

1927

1928

1929

def readBlock(self):

1929

def readBlock(self):

1930

"""

1930

"""

1931

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

1931

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

1932

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

1932

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

1933

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

1933

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

1934

es seteado a 0

1934

es seteado a 0

1935

1936

Return: None

1936

Return: None

1937

1938

Variables afectadas:

1938

Variables afectadas:

1939

1940

self.flagIsNewFile

1940

self.flagIsNewFile

1941

self.flagIsNewBlock

1941

self.flagIsNewBlock

1942

self.nTotalBlocks

1942

self.nTotalBlocks

1943

self.data_spc

1943

self.data_spc

1944

self.data_cspc

1944

self.data_cspc

1945

self.data_dc

1945

self.data_dc

1946

1947

Exceptions:

1947

Exceptions:

1948

Si un bloque leido no es un bloque valido

1948

Si un bloque leido no es un bloque valido

1949

"""

1949

"""

1950

blockOk_flag = False

1950

blockOk_flag = False

1951

fpointer = self.fp.tell()

1951

fpointer = self.fp.tell()

1952

1953

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

1953

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

1954

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

1954

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

1955

1956

if self.processingHeaderObj.flag_cspc:

1956

if self.processingHeaderObj.flag_cspc:

1957

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

1957

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

1958

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

1958

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

1959

1960

if self.processingHeaderObj.flag_dc:

1960

if self.processingHeaderObj.flag_dc:

1961

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

1961

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

1962

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

1962

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

1963

1964

1965

if not(self.processingHeaderObj.shif_fft):

1965

if not(self.processingHeaderObj.shif_fft):

1966

#desplaza a la derecha en el eje 2 determinadas posiciones

1966

#desplaza a la derecha en el eje 2 determinadas posiciones

1967

shift = int(self.processingHeaderObj.profilesPerBlock/2)

1967

shift = int(self.processingHeaderObj.profilesPerBlock/2)

1968

spc = numpy.roll( spc, shift , axis=2 )

1968

spc = numpy.roll( spc, shift , axis=2 )

1969

1970

if self.processingHeaderObj.flag_cspc:

1970

if self.processingHeaderObj.flag_cspc:

1971

#desplaza a la derecha en el eje 2 determinadas posiciones

1971

#desplaza a la derecha en el eje 2 determinadas posiciones

1972

cspc = numpy.roll( cspc, shift, axis=2 )

1972

cspc = numpy.roll( cspc, shift, axis=2 )

1973

1974

# self.processingHeaderObj.shif_fft = True

1974

# self.processingHeaderObj.shif_fft = True

1975

1976

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

1976

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

1977

self.data_spc = spc

1977

self.data_spc = spc

1978

1979

if self.processingHeaderObj.flag_cspc:

1979

if self.processingHeaderObj.flag_cspc:

1980

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

1980

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

1981

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

1981

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

1982

else:

1982

else:

1983

self.data_cspc = None

1983

self.data_cspc = None

1984

1985

if self.processingHeaderObj.flag_dc:

1985

if self.processingHeaderObj.flag_dc:

1986

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

1986

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

1987

else:

1987

else:

1988

self.data_dc = None

1988

self.data_dc = None

1989

1990

self.flagIsNewFile = 0

1990

self.flagIsNewFile = 0

1991

self.flagIsNewBlock = 1

1991

self.flagIsNewBlock = 1

1992

1993

self.nTotalBlocks += 1

1993

self.nTotalBlocks += 1

1994

self.nReadBlocks += 1

1994

self.nReadBlocks += 1

1995

1996

return 1

1996

return 1

1997

1998

1999

def getData(self):

1999

def getData(self):

2000

"""

2000

"""

2001

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

2001

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

2002

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

2002

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

2003

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

2003

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

2004

2005

Return:

2005

Return:

2006

0 : Si no hay mas archivos disponibles

2006

0 : Si no hay mas archivos disponibles

2007

1 : Si hizo una buena copia del buffer

2007

1 : Si hizo una buena copia del buffer

2008

2009

Affected:

2009

Affected:

2010

self.dataOut

2010

self.dataOut

2011

2012

self.flagTimeBlock

2012

self.flagTimeBlock

2013

self.flagIsNewBlock

2013

self.flagIsNewBlock

2014

"""

2014

"""

2015

2016

if self.flagNoMoreFiles:

2016

if self.flagNoMoreFiles:

2017

self.dataOut.flagNoData = True

2017

self.dataOut.flagNoData = True

2018

print 'Process finished'

2018

print 'Process finished'

2019

return 0

2019

return 0

2020

2021

self.flagTimeBlock = 0

2021

self.flagTimeBlock = 0

2022

self.flagIsNewBlock = 0

2022

self.flagIsNewBlock = 0

2023

2024

if self.__hasNotDataInBuffer():

2024

if self.__hasNotDataInBuffer():

2025

2026

if not( self.readNextBlock() ):

2026

if not( self.readNextBlock() ):

2027

self.dataOut.flagNoData = True

2027

self.dataOut.flagNoData = True

2028

return 0

2028

return 0

2029

2030

# self.updateDataHeader()

2030

# self.updateDataHeader()

2031

2032

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

2032

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

2033

2034

if self.data_dc == None:

2034

if self.data_dc == None:

2035

self.dataOut.flagNoData = True

2035

self.dataOut.flagNoData = True

2036

return 0

2036

return 0

2037

2038

self.dataOut.data_spc = self.data_spc

2038

self.dataOut.data_spc = self.data_spc

2039

2040

self.dataOut.data_cspc = self.data_cspc

2040

self.dataOut.data_cspc = self.data_cspc

2041

2042

self.dataOut.data_dc = self.data_dc

2042

self.dataOut.data_dc = self.data_dc

2043

2044

self.dataOut.flagTimeBlock = self.flagTimeBlock

2044

self.dataOut.flagTimeBlock = self.flagTimeBlock

2045

2046

self.dataOut.flagNoData = False

2046

self.dataOut.flagNoData = False

2047

2048

self.dataOut.dtype = numpy.dtype([('real','<f8'),('imag','<f8')])#self.dtype

2048

self.dataOut.dtype = numpy.dtype([('real','<f8'),('imag','<f8')])#self.dtype

2049

2050

# self.dataOut.nChannels = self.nRdChannels

2050

# self.dataOut.nChannels = self.nRdChannels

2051

2052

self.dataOut.nPairs = self.nRdPairs

2052

self.dataOut.nPairs = self.nRdPairs

2053

2054

self.dataOut.pairsList = self.rdPairList

2054

self.dataOut.pairsList = self.rdPairList

2055

2056

# self.dataOut.nHeights = self.processingHeaderObj.nHeights

2056

# self.dataOut.nHeights = self.processingHeaderObj.nHeights

2057

2058

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

2058

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

2059

2060

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

2060

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

2061

2062

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

2062

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

2063

2064

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

2064

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

2065

2066

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

2066

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

2067

2068

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

2068

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

2069

2070

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

2070

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

2071

2072

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

2072

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

2073

2074

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

2074

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

2075

2076

self.dataOut.ippSeconds = self.ippSeconds

2076

self.dataOut.ippSeconds = self.ippSeconds

2077

2078

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

2078

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

2079

2080

# self.profileIndex += 1

2080

# self.profileIndex += 1

2081

2082

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

2082

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

2083

2084

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

2084

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

2085

2086

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

2086

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

2087

2088

self.dataOut.flagDecodeData = False #asumo q la data no esta decodificada

2088

self.dataOut.flagDecodeData = False #asumo q la data no esta decodificada

2089

2090

self.dataOut.flagDeflipData = True #asumo q la data no esta sin flip

2090

self.dataOut.flagDeflipData = True #asumo q la data no esta sin flip

2091

2092

if self.processingHeaderObj.code != None:

2092

if self.processingHeaderObj.code != None:

2093

2094

self.dataOut.nCode = self.processingHeaderObj.nCode

2094

self.dataOut.nCode = self.processingHeaderObj.nCode

2095

2096

self.dataOut.nBaud = self.processingHeaderObj.nBaud

2096

self.dataOut.nBaud = self.processingHeaderObj.nBaud

2097

2098

self.dataOut.code = self.processingHeaderObj.code

2098

self.dataOut.code = self.processingHeaderObj.code

2099

2100

self.dataOut.flagDecodeData = True

2100

self.dataOut.flagDecodeData = True

2101

2102

return self.dataOut.data_spc

2102

return self.dataOut.data_spc

2103

2104

2105

class SpectraWriter(JRODataWriter):

2105

class SpectraWriter(JRODataWriter):

2106

2107

"""

2107

"""

2108

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

2108

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

2109

de los datos siempre se realiza por bloques.

2109

de los datos siempre se realiza por bloques.

2110

"""

2110

"""

2111

2112

ext = ".pdata"

2112

ext = ".pdata"

2113

2114

optchar = "P"

2114

optchar = "P"

2115

2116

shape_spc_Buffer = None

2116

shape_spc_Buffer = None

2117

2118

shape_cspc_Buffer = None

2118

shape_cspc_Buffer = None

2119

2120

shape_dc_Buffer = None

2120

shape_dc_Buffer = None

2121

2122

data_spc = None

2122

data_spc = None

2123

2124

data_cspc = None

2124

data_cspc = None

2125

2126

data_dc = None

2126

data_dc = None

2127

2128

# dataOut = None

2128

# dataOut = None

2129

2130

def __init__(self):

2130

def __init__(self):

2131

"""

2131

"""

2132

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

2132

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

2133

2134

Affected:

2134

Affected:

2135

self.dataOut

2135

self.dataOut

2136

self.basicHeaderObj

2136

self.basicHeaderObj

2137

self.systemHeaderObj

2137

self.systemHeaderObj

2138

self.radarControllerHeaderObj

2138

self.radarControllerHeaderObj

2139

self.processingHeaderObj

2139

self.processingHeaderObj

2140

2141

Return: None

2141

Return: None

2142

"""

2142

"""

2143

2144

self.isConfig = False

2144

self.isConfig = False

2145

2146

self.nTotalBlocks = 0

2146

self.nTotalBlocks = 0

2147

2148

self.data_spc = None

2148

self.data_spc = None

2149

2150

self.data_cspc = None

2150

self.data_cspc = None

2151

2152

self.data_dc = None

2152

self.data_dc = None

2153

2154

self.fp = None

2154

self.fp = None

2155

2156

self.flagIsNewFile = 1

2156

self.flagIsNewFile = 1

2157

2158

self.nTotalBlocks = 0

2158

self.nTotalBlocks = 0

2159

2160

self.flagIsNewBlock = 0

2160

self.flagIsNewBlock = 0

2161

2162

self.setFile = None

2162

self.setFile = None

2163

2164

self.dtype = None

2164

self.dtype = None

2165

2166

self.path = None

2166

self.path = None

2167

2168

self.noMoreFiles = 0

2168

self.noMoreFiles = 0

2169

2170

self.filename = None

2170

self.filename = None

2171

2172

self.basicHeaderObj = BasicHeader(LOCALTIME)

2172

self.basicHeaderObj = BasicHeader(LOCALTIME)

2173

2174

self.systemHeaderObj = SystemHeader()

2174

self.systemHeaderObj = SystemHeader()

2175

2176

self.radarControllerHeaderObj = RadarControllerHeader()

2176

self.radarControllerHeaderObj = RadarControllerHeader()

2177

2178

self.processingHeaderObj = ProcessingHeader()

2178

self.processingHeaderObj = ProcessingHeader()

2179

2180

2181

def hasAllDataInBuffer(self):

2181

def hasAllDataInBuffer(self):

2182

return 1

2182

return 1

2183

2184

2185

def setBlockDimension(self):

2185

def setBlockDimension(self):

2186

"""

2186

"""

2187

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

2187

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

2188

2189

Affected:

2189

Affected:

2190

self.shape_spc_Buffer

2190

self.shape_spc_Buffer

2191

self.shape_cspc_Buffer

2191

self.shape_cspc_Buffer

2192

self.shape_dc_Buffer

2192

self.shape_dc_Buffer

2193

2194

Return: None

2194

Return: None

2195

"""

2195

"""

2196

self.shape_spc_Buffer = (self.dataOut.nChannels,

2196

self.shape_spc_Buffer = (self.dataOut.nChannels,

2197

self.processingHeaderObj.nHeights,

2197

self.processingHeaderObj.nHeights,

2198

self.processingHeaderObj.profilesPerBlock)

2198

self.processingHeaderObj.profilesPerBlock)

2199

2200

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2200

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2201

self.processingHeaderObj.nHeights,

2201

self.processingHeaderObj.nHeights,

2202

self.processingHeaderObj.profilesPerBlock)

2202

self.processingHeaderObj.profilesPerBlock)

2203

2204

self.shape_dc_Buffer = (self.dataOut.nChannels,

2204

self.shape_dc_Buffer = (self.dataOut.nChannels,

2205

self.processingHeaderObj.nHeights)

2205

self.processingHeaderObj.nHeights)

2206

2207

2208

def writeBlock(self):

2208

def writeBlock(self):

2209

"""

2209

"""

2210

Escribe el buffer en el file designado

2210

Escribe el buffer en el file designado

2211

2212

Affected:

2212

Affected:

2213

self.data_spc

2213

self.data_spc

2214

self.data_cspc

2214

self.data_cspc

2215

self.data_dc

2215

self.data_dc

2216

self.flagIsNewFile

2216

self.flagIsNewFile

2217

self.flagIsNewBlock

2217

self.flagIsNewBlock

2218

self.nTotalBlocks

2218

self.nTotalBlocks

2219

self.nWriteBlocks

2219

self.nWriteBlocks

2220

2221

Return: None

2221

Return: None

2222

"""

2222

"""

2223

2224

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

2224

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

2225

if not( self.processingHeaderObj.shif_fft ):

2225

if not( self.processingHeaderObj.shif_fft ):

2226

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

2226

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

2227

data = spc.reshape((-1))

2227

data = spc.reshape((-1))

2228

data.tofile(self.fp)

2228

data.tofile(self.fp)

2229

2230

if self.data_cspc != None:

2230

if self.data_cspc != None:

2231

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

2231

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

2232

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

2232

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

2233

if not( self.processingHeaderObj.shif_fft ):

2233

if not( self.processingHeaderObj.shif_fft ):

2234

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

2234

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

2235

data['real'] = cspc.real

2235

data['real'] = cspc.real

2236

data['imag'] = cspc.imag

2236

data['imag'] = cspc.imag

2237

data = data.reshape((-1))

2237

data = data.reshape((-1))

2238

data.tofile(self.fp)

2238

data.tofile(self.fp)

2239

2240

if self.data_dc != None:

2240

if self.data_dc != None:

2241

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

2241

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

2242

dc = self.data_dc

2242

dc = self.data_dc

2243

data['real'] = dc.real

2243

data['real'] = dc.real

2244

data['imag'] = dc.imag

2244

data['imag'] = dc.imag

2245

data = data.reshape((-1))

2245

data = data.reshape((-1))

2246

data.tofile(self.fp)

2246

data.tofile(self.fp)

2247

2248

self.data_spc.fill(0)

2248

self.data_spc.fill(0)

2249

self.data_dc.fill(0)

2249

self.data_dc.fill(0)

2250

if self.data_cspc != None:

2250

if self.data_cspc != None:

2251

self.data_cspc.fill(0)

2251

self.data_cspc.fill(0)

2252

2253

self.flagIsNewFile = 0

2253

self.flagIsNewFile = 0

2254

self.flagIsNewBlock = 1

2254

self.flagIsNewBlock = 1

2255

self.nTotalBlocks += 1

2255

self.nTotalBlocks += 1

2256

self.nWriteBlocks += 1

2256

self.nWriteBlocks += 1

2257

self.blockIndex += 1

2257

self.blockIndex += 1

2258

2259

2260

def putData(self):

2260

def putData(self):

2261

"""

2261

"""

2262

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

2262

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

2263

2264

Affected:

2264

Affected:

2265

self.data_spc

2265

self.data_spc

2266

self.data_cspc

2266

self.data_cspc

2267

self.data_dc

2267

self.data_dc

2268

2269

Return:

2269

Return:

2270

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

2270

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

2271

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

2271

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

2272

"""

2272

"""

2273

2274

if self.dataOut.flagNoData:

2274

if self.dataOut.flagNoData:

2275

return 0

2275

return 0

2276

2277

self.flagIsNewBlock = 0

2277

self.flagIsNewBlock = 0

2278

2279

if self.dataOut.flagTimeBlock:

2279

if self.dataOut.flagTimeBlock:

2280

self.data_spc.fill(0)

2280

self.data_spc.fill(0)

2281

self.data_cspc.fill(0)

2281

self.data_cspc.fill(0)

2282

self.data_dc.fill(0)

2282

self.data_dc.fill(0)

2283

self.setNextFile()

2283

self.setNextFile()

2284

2285

if self.flagIsNewFile == 0:

2285

if self.flagIsNewFile == 0:

2286

self.getBasicHeader()

2286

self.getBasicHeader()

2287

2288

self.data_spc = self.dataOut.data_spc.copy()

2288

self.data_spc = self.dataOut.data_spc.copy()

2289

self.data_cspc = self.dataOut.data_cspc.copy()

2289

self.data_cspc = self.dataOut.data_cspc.copy()

2290

self.data_dc = self.dataOut.data_dc.copy()

2290

self.data_dc = self.dataOut.data_dc.copy()

2291

2292

# #self.processingHeaderObj.dataBlocksPerFile)

2292

# #self.processingHeaderObj.dataBlocksPerFile)

2293

if self.hasAllDataInBuffer():

2293

if self.hasAllDataInBuffer():

2294

# self.getDataHeader()

2294

# self.getDataHeader()

2295

self.writeNextBlock()

2295

self.writeNextBlock()

2296

2297

return 1

2297

return 1

2298

2299

2300

def __getProcessFlags(self):

2300

def __getProcessFlags(self):

2301

2302

processFlags = 0

2302

processFlags = 0

2303

2304

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

2304

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

2305

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

2305

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

2306

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

2306

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

2307

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

2307

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

2308

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

2308

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

2309

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

2309

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

2310

2311

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

2311

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

2312

2313

2314

2315

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2315

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2316

PROCFLAG.DATATYPE_SHORT,

2316

PROCFLAG.DATATYPE_SHORT,

2317

PROCFLAG.DATATYPE_LONG,

2317

PROCFLAG.DATATYPE_LONG,

2318

PROCFLAG.DATATYPE_INT64,

2318

PROCFLAG.DATATYPE_INT64,

2319

PROCFLAG.DATATYPE_FLOAT,

2319

PROCFLAG.DATATYPE_FLOAT,

2320

PROCFLAG.DATATYPE_DOUBLE]

2320

PROCFLAG.DATATYPE_DOUBLE]

2321

2322

2323

for index in range(len(dtypeList)):

2323

for index in range(len(dtypeList)):

2324

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

2324

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

2325

dtypeValue = datatypeValueList[index]

2325

dtypeValue = datatypeValueList[index]

2326

break

2326

break

2327

2328

processFlags += dtypeValue

2328

processFlags += dtypeValue

2329

2330

if self.dataOut.flagDecodeData:

2330

if self.dataOut.flagDecodeData:

2331

processFlags += PROCFLAG.DECODE_DATA

2331

processFlags += PROCFLAG.DECODE_DATA

2332

2333

if self.dataOut.flagDeflipData:

2333

if self.dataOut.flagDeflipData:

2334

processFlags += PROCFLAG.DEFLIP_DATA

2334

processFlags += PROCFLAG.DEFLIP_DATA

2335

2336

if self.dataOut.code != None:

2336

if self.dataOut.code != None:

2337

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2337

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2338

2339

if self.dataOut.nIncohInt > 1:

2339

if self.dataOut.nIncohInt > 1:

2340

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2340

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2341

2342

if self.dataOut.data_dc != None:

2342

if self.dataOut.data_dc != None:

2343

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2343

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2344

2345

return processFlags

2345

return processFlags

2346

2347

2348

def __getBlockSize(self):

2348

def __getBlockSize(self):

2349

'''

2349

'''

2350

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

2350

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

2351

'''

2351

'''

2352

2353

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

2353

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

2354

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

2354

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

2355

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

2355

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

2356

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

2356

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

2357

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

2357

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

2358

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

2358

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

2359

2360

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

2360

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

2361

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

2361

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

2362

for index in range(len(dtypeList)):

2362

for index in range(len(dtypeList)):

2363

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

2363

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

2364

datatypeValue = datatypeValueList[index]

2364

datatypeValue = datatypeValueList[index]

2365

break

2365

break

2366

2367

2368

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

2368

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

2369

2370

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

2370

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

2371

blocksize = (pts2write_SelfSpectra*datatypeValue)

2371

blocksize = (pts2write_SelfSpectra*datatypeValue)

2372

2373

if self.dataOut.data_cspc != None:

2373

if self.dataOut.data_cspc != None:

2374

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

2374

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

2375

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2375

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2376

2377

if self.dataOut.data_dc != None:

2377

if self.dataOut.data_dc != None:

2378

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

2378

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

2379

blocksize += (pts2write_DCchannels*datatypeValue*2)

2379

blocksize += (pts2write_DCchannels*datatypeValue*2)

2380

2381

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2381

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2382

2383

return blocksize

2383

return blocksize

2384

2385

def getDataHeader(self):

2385

def getDataHeader(self):

2386

2387

"""

2387

"""

2388

Obtiene una copia del First Header

2388

Obtiene una copia del First Header

2389

2390

Affected:

2390

Affected:

2391

self.systemHeaderObj

2391

self.systemHeaderObj

2392

self.radarControllerHeaderObj

2392

self.radarControllerHeaderObj

2393

self.dtype

2393

self.dtype

2394

2395

Return:

2395

Return:

2396

None

2396

None

2397

"""

2397

"""

2398

2399

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

2399

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

2400

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2400

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2401

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

2401

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

2402

2403

self.getBasicHeader()

2403

self.getBasicHeader()

2404

2405

processingHeaderSize = 40 # bytes

2405

processingHeaderSize = 40 # bytes

2406

self.processingHeaderObj.dtype = 0 # Voltage

2406

self.processingHeaderObj.dtype = 0 # Voltage

2407

self.processingHeaderObj.blockSize = self.__getBlockSize()

2407

self.processingHeaderObj.blockSize = self.__getBlockSize()

2408

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2408

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2409

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2409

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2410

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

2410

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

2411

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2411

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2412

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

2412

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

2413

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2413

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2414

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

2414

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

2415

2416

if self.processingHeaderObj.totalSpectra > 0:

2416

if self.processingHeaderObj.totalSpectra > 0:

2417

channelList = []

2417

channelList = []

2418

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

2418

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

2419

channelList.append(channel)

2419

channelList.append(channel)

2420

channelList.append(channel)

2420

channelList.append(channel)

2421

2422

pairsList = []

2422

pairsList = []

2423

for pair in self.dataOut.pairsList:

2423

for pair in self.dataOut.pairsList:

2424

pairsList.append(pair[0])

2424

pairsList.append(pair[0])

2425

pairsList.append(pair[1])

2425

pairsList.append(pair[1])

2426

spectraComb = channelList + pairsList

2426

spectraComb = channelList + pairsList

2427

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

2427

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

2428

self.processingHeaderObj.spectraComb = spectraComb

2428

self.processingHeaderObj.spectraComb = spectraComb

2429

sizeOfSpcComb = len(spectraComb)

2429

sizeOfSpcComb = len(spectraComb)

2430

processingHeaderSize += sizeOfSpcComb

2430

processingHeaderSize += sizeOfSpcComb

2431

2432

if self.dataOut.code != None:

2432

if self.dataOut.code != None:

2433

self.processingHeaderObj.code = self.dataOut.code

2433

self.processingHeaderObj.code = self.dataOut.code

2434

self.processingHeaderObj.nCode = self.dataOut.nCode

2434

self.processingHeaderObj.nCode = self.dataOut.nCode

2435

self.processingHeaderObj.nBaud = self.dataOut.nBaud

2435

self.processingHeaderObj.nBaud = self.dataOut.nBaud

2436

nCodeSize = 4 # bytes

2436

nCodeSize = 4 # bytes

2437

nBaudSize = 4 # bytes

2437

nBaudSize = 4 # bytes

2438

codeSize = 4 # bytes

2438

codeSize = 4 # bytes

2439

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

2439

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

2440

processingHeaderSize += sizeOfCode

2440

processingHeaderSize += sizeOfCode

2441

2442

if self.processingHeaderObj.nWindows != 0:

2442

if self.processingHeaderObj.nWindows != 0:

2443

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

2443

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

2444

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

2444

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

2445

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2445

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2446

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2446

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2447

sizeOfFirstHeight = 4

2447

sizeOfFirstHeight = 4

2448

sizeOfdeltaHeight = 4

2448

sizeOfdeltaHeight = 4

2449

sizeOfnHeights = 4

2449

sizeOfnHeights = 4

2450

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

2450

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

2451

processingHeaderSize += sizeOfWindows

2451

processingHeaderSize += sizeOfWindows

2452

2453

self.processingHeaderObj.size = processingHeaderSize

2453

self.processingHeaderObj.size = processingHeaderSize

2454

2455

class SpectraHeisWriter():

2455

class SpectraHeisWriter():

2456

2457

i=0

2457

i=0

2458

2459

def __init__(self, dataOut):

2459

def __init__(self, dataOut):

2460

2461

self.wrObj = FITS()

2461

self.wrObj = FITS()

2462

self.dataOut = dataOut

2462

self.dataOut = dataOut

2463

2464

def isNumber(str):

2464

def isNumber(str):

2465

"""

2465

"""

2466

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

2466

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

2467

2468

Excepciones:

2468

Excepciones:

2469

Si un determinado string no puede ser convertido a numero

2469

Si un determinado string no puede ser convertido a numero

2470

Input:

2470

Input:

2471

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

2471

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

2472

2473

Return:

2473

Return:

2474

True : si el string es uno numerico

2474

True : si el string es uno numerico

2475

False : no es un string numerico

2475

False : no es un string numerico

2476

"""

2476

"""

2477

try:

2477

try:

2478

float( str )

2478

float( str )

2479

return True

2479

return True

2480

except:

2480

except:

2481

return False

2481

return False

2482

2483

def setup(self, wrpath,):

2483

def setup(self, wrpath,):

2484

2485

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

2485

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

2486

os.mkdir(wrpath)

2486

os.mkdir(wrpath)

2487

2488

self.wrpath = wrpath

2488

self.wrpath = wrpath

2489

self.setFile = 0

2489

self.setFile = 0

2490

2491

def putData(self):

2491

def putData(self):

2492

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

2492

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

2493

#name = self.dataOut.utctime

2493

#name = self.dataOut.utctime

2494

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

2494

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

2495

ext=".fits"

2495

ext=".fits"

2496

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

2496

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

2497

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

2497

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

2498

2499

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

2499

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

2500

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

2500

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

2501

os.mkdir(fullpath)

2501

os.mkdir(fullpath)

2502

self.setFile += 1

2502

self.setFile += 1

2503

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

2503

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

2504

2505

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

2505

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

2506

2507

# print self.dataOut.ippSeconds

2507

# print self.dataOut.ippSeconds

2508

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

2508

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

2509

2510

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

2510

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

2511

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

2511

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

2512

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

2512

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

2513

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

2513

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

2514

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

2514

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

2515

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

2515

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

2516

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

2516

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

2517

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

2517

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

2518

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

2518

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

2519

#n=numpy.arange((100))

2519

#n=numpy.arange((100))

2520

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

2520

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

2521

a=self.wrObj.cFImage(n)

2521

a=self.wrObj.cFImage(n)

2522

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

2522

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

2523

self.wrObj.CFile(a,b)

2523

self.wrObj.CFile(a,b)

2524

self.wrObj.wFile(filename)

2524

self.wrObj.wFile(filename)

2525

return 1

2525

return 1

2526

2527

class FITS:

2527

class FITS:

2528

2529

name=None

2529

name=None

2530

format=None

2530

format=None

2531

array =None

2531

array =None

2532

data =None

2532

data =None

2533

thdulist=None

2533

thdulist=None

2534

2535

def __init__(self):

2535

def __init__(self):

2536

2537

pass

2537

pass

2538

2539

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

2539

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

2540

self.name=name

2540

self.name=name

2541

self.format=format

2541

self.format=format

2542

self.array=array

2542

self.array=array

2543

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

2543

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

2544

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

2544

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

2545

return self.col1

2545

return self.col1

2546

2547

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

2547

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

2548

# self.name=name

2548

# self.name=name

2549

# self.format=format

2549

# self.format=format

2550

# self.data=data

2550

# self.data=data

2551

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

2551

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

2552

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

2552

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

2553

# return self.col2

2553

# return self.col2

2554

2555

def writeHeader(self,):

2555

def writeHeader(self,):

2556

pass

2556

pass

2557

2558

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

2558

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

2559

self.name=name

2559

self.name=name

2560

self.format=format

2560

self.format=format

2561

self.data=data

2561

self.data=data

2562

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

2562

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

2563

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

2563

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

2564

return self.col2

2564

return self.col2

2565

2566

def cFImage(self,n):

2566

def cFImage(self,n):

2567

self.hdu= pyfits.PrimaryHDU(n)

2567

self.hdu= pyfits.PrimaryHDU(n)

2568

return self.hdu

2568

return self.hdu

2569

2570

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

2570

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

2571

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

2571

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

2572

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

2572

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

2573

return self.tbhdu

2573

return self.tbhdu

2574

2575

def CFile(self,hdu,tbhdu):

2575

def CFile(self,hdu,tbhdu):

2576

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

2576

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

2577

2578

def wFile(self,filename):

2578

def wFile(self,filename):

2579

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

2579

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