schain Commit - r218:a84a1beaf0cb · 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 *
             def isNumber(str):
                 """
                 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
                 Excepciones:
                     Si un determinado string no puede ser convertido a numero
                 Input:
                     str, string al cual se le analiza para determinar si convertible a un numero o no
                 Return:
                     True    :    si el string es uno numerico
                     False   :    no es un string numerico
                 """
                 try:
                     float( str )
                     return True
                 except:
                     return False
             def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
                 """
                 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                     startUTSeconds      :    fecha inicial del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                     endUTSeconds        :    fecha final del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no existe o no puede ser abierto
                     Si la cabecera no puede ser leida.
                 """
                 basicHeaderObj = BasicHeader()
                 try:
                     fp = open(filename,'rb')
                 except:
                     raise IOError, "The file %s can't be opened" %(filename)
                 sts = basicHeaderObj.read(fp)
                 fp.close()
                 if not(sts):
                     print "Skipping the file %s because it has not a valid header" %(filename)
                     return 0
                 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
                     return 0
                 return 1
             def getlastFileFromPath(path, ext):
                 """
                 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
                 al final de la depuracion devuelve el ultimo file de la lista que quedo.
                 Input:
                     fileList    :    lista conteniendo todos los files (sin path) que componen una determinada carpeta
                     ext         :    extension de los files contenidos en una carpeta
                 Return:
                     El ultimo file de una determinada carpeta, no se considera el path.
                 """
                 validFilelist = []
                 fileList = os.listdir(path)
                 # 0 1234 567 89A BCDE
                 # H YYYY DDD SSS .ext
                 for file in fileList:
                     try:
                         year = int(file[1:5])
                         doy  = int(file[5:8])
                         if (os.path.splitext(file)[-1].upper() != ext.upper()) : continue
                     except:
                         continue
                     validFilelist.append(file)
                 if validFilelist:
                     validFilelist = sorted( validFilelist, key=str.lower )
                     return validFilelist[-1]
                 return None
             def checkForRealPath(path, year, doy, set, ext):
                 """
                 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
                 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
                 el path exacto de un determinado file.
                 Example    :
                     nombre correcto del file es  .../.../D2009307/P2009307367.ext
                     Entonces la funcion prueba con las siguientes combinaciones
                         .../.../x2009307/y2009307367.ext
                         .../.../x2009307/Y2009307367.ext
                         .../.../X2009307/y2009307367.ext
                         .../.../X2009307/Y2009307367.ext
                     siendo para este caso, la ultima combinacion de letras, identica al file buscado
                 Return:
                     Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
                     caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
                     para el filename
                 """
                 filepath = None
                 find_flag = False
                 filename = None
                 if ext.lower() == ".r": #voltage
                     header1 = "dD"
                     header2 = "dD"
                 elif ext.lower() == ".pdata": #spectra
                     header1 = "dD"
                     header2 = "pP"
                 else:
                     return None, filename
                 for dir in header1: #barrido por las dos combinaciones posibles de "D"
                     for fil in header2: #barrido por las dos combinaciones posibles de "D"
                         doypath = "%s%04d%03d" % ( dir, year, doy ) #formo el nombre del directorio xYYYYDDD (x=d o x=D)
                         filename = "%s%04d%03d%03d%s" % ( fil, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext
                         filepath = os.path.join( path, doypath, filename ) #formo el path completo
                         if os.path.exists( filepath ): #verifico que exista
                             find_flag = True
                             break
                     if find_flag:
                         break
                 if not(find_flag):
                     return None, filename
                 return filepath, filename
             class JRODataIO:
                 c = 3E8
                 isConfig = False
                 basicHeaderObj = BasicHeader()
                 systemHeaderObj = SystemHeader()
                 radarControllerHeaderObj = RadarControllerHeader()
                 processingHeaderObj = ProcessingHeader()
                 online = 0
                 dtype = None
                 pathList = []
                 filenameList = []
                 filename = None
                 ext = None
                 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"):
                     dirList = []
                     for thisPath in os.listdir(path):
                         if os.path.isdir(os.path.join(path,thisPath)):
                             dirList.append(thisPath)
                     if not(dirList):
                         return None, None
                     pathList = []
                     dateList = []
                     thisDate = startDate
                     while(thisDate <= endDate):
                         year = thisDate.timetuple().tm_year
                         doy = thisDate.timetuple().tm_yday
                         match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
                         if len(match) == 0:
                             thisDate += datetime.timedelta(1)
                             continue
                         pathList.append(os.path.join(path,match[0],expLabel))
                         dateList.append(thisDate)
                         thisDate += datetime.timedelta(1)
                     filenameList = []
                     for index in range(len(pathList)):
                         thisPath = pathList[index]
                         fileList = glob.glob1(thisPath, "*%s" %ext)
                         fileList.sort()
                         #Busqueda de datos en el rango de horas indicados
                         thisDate = dateList[index]
                         startDT = datetime.datetime.combine(thisDate, startTime)
                         endDT = datetime.datetime.combine(thisDate, endTime)
                         startUtSeconds = time.mktime(startDT.timetuple())
                         endUtSeconds = time.mktime(endDT.timetuple())
                         for file in fileList:
                             filename = os.path.join(thisPath,file)
                             if isThisFileinRange(filename, startUtSeconds, endUtSeconds):
                                 filenameList.append(filename)
                     if not(filenameList):
                         return None, None
                     self.filenameList = filenameList
                     return pathList, filenameList
                 def __searchFilesOnLine(self, path, startDate=None, endDate=None, startTime=None, endTime=None, expLabel = "", ext = None):
                     """
                     Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
                     devuelve el archivo encontrado ademas de otros datos.
                     Input:
                         path           :    carpeta donde estan contenidos los files que contiene data
                         startDate      :    Fecha inicial. Rechaza todos los directorios donde
                                             file end time < startDate (obejto datetime.date)
                         endDate        :    Fecha final. Rechaza todos los directorios donde
                                             file start time > endDate (obejto datetime.date)
                         startTime      :    Tiempo inicial. Rechaza todos los archivos donde
                                             file end time < startTime (obejto datetime.time)
                         endTime        :    Tiempo final. Rechaza todos los archivos donde
                                             file start time > endTime (obejto datetime.time)
                         expLabel        :     Nombre del subexperimento (subfolder)
                         ext              :    extension de los files
                     Return:
                         directory   :    eL directorio donde esta el file encontrado
                         filename    :    el ultimo file de una determinada carpeta
                         year        :    el anho
                         doy         :    el numero de dia del anho
                         set         :    el set del archivo
                     """
                     dirList = []
                     pathList = []
                     directory = None
                     #Filtra solo los directorios
                     for thisPath in os.listdir(path):
                         if os.path.isdir(os.path.join(path, thisPath)):
                             dirList.append(thisPath)
                     if not(dirList):
                         return None, None, None, None, None
                     dirList = sorted( dirList, key=str.lower )
                     if startDate:
                         startDateTime = datetime.datetime.combine(startDate, startTime)
                         thisDateTime = startDateTime
                         if endDate == None: endDateTime = startDateTime
                         else: endDateTime = datetime.datetime.combine(endDate, endTime)
                         while(thisDateTime <= endDateTime):
                             year = thisDateTime.timetuple().tm_year
                             doy = thisDateTime.timetuple().tm_yday
                             match = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy))
                             if len(match) == 0:
                                 thisDateTime += datetime.timedelta(1)
                                 continue
                             pathList.append(os.path.join(path,match[0], expLabel))
                             thisDateTime += datetime.timedelta(1)
                         if not(pathList):
                             print "\tNo files in range: %s - %s" %(startDateTime.ctime(), endDateTime.ctime())
                             return None, None, None, None, None
                         directory = pathList[0]
                     else:
                         directory = dirList[-1]
                         directory = os.path.join(path,directory)
                     filename = getlastFileFromPath(directory, ext)
                     if not(filename):
                         return None, None, None, None, None
                     if not(self.__verifyFile(os.path.join(directory, filename))):
                         return None, None, None, None, None
                     year = int( filename[1:5] )
                     doy  = int( filename[5:8] )
                     set  = int( filename[8:11] )
                     return directory, filename, year, doy, set
                 def __setNextFileOffline(self):
                     idFile = self.fileIndex
                     while (True):
                         idFile += 1
                         if not(idFile < len(self.filenameList)):
                             self.flagNoMoreFiles = 1
                             print "No more Files"
                             return 0
                         filename = self.filenameList[idFile]
                         if not(self.__verifyFile(filename)):
                             continue
                         fileSize = os.path.getsize(filename)
                         fp = open(filename,'rb')
                         break
                     self.flagIsNewFile = 1
                     self.fileIndex = idFile
                     self.filename = filename
                     self.fileSize = fileSize
                     self.fp = fp
                     print "Setting the file: %s"%self.filename
                     return 1
                 def __setNextFileOnline(self):
                     """
                     Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
                     no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
                     siguientes.
                     Affected:
                         self.flagIsNewFile
                         self.filename
                         self.fileSize
                         self.fp
                         self.set
                         self.flagNoMoreFiles
                     Return:
 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
 : si el file fue abierto con exito y esta listo a ser leido
                     Excepciones:
                         Si un determinado file no puede ser abierto
                     """
                     nFiles = 0
                     fileOk_flag = False
                     firstTime_flag = True
                     self.set += 1
                     #busca el 1er file disponible
                     file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
                     if file:
                         if self.__verifyFile(file, False):
                             fileOk_flag = True
                     #si no encuentra un file entonces espera y vuelve a buscar
                     if not(fileOk_flag):
                         for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles
                             if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces
                                 tries = self.nTries
                             else:
                                 tries = 1 #si no es la 1era vez entonces solo lo hace una vez
                             for nTries in range( tries ):
                                 if firstTime_flag:
                                     print "\tWaiting %0.2f sec for the file \"%s\" , try %03d ..." % ( self.delay, filename, nTries+1 )
                                     time.sleep( self.delay )
                                 else:
                                     print "\tSearching next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
                                 file, filename = checkForRealPath( self.path, self.year, self.doy, self.set, self.ext )
                                 if file:
                                     if self.__verifyFile(file):
                                         fileOk_flag = True
                                         break
                             if fileOk_flag:
                                 break
                             firstTime_flag = False
                             print "\tSkipping the file \"%s\" due to this file doesn't exist" % filename
                             self.set += 1
                             if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
                                 self.set = 0
                                 self.doy += 1
                     if fileOk_flag:
                         self.fileSize = os.path.getsize( file )
                         self.filename = file
                         self.flagIsNewFile = 1
                         if self.fp != None: self.fp.close()
                         self.fp = open(file, 'rb')
                         self.flagNoMoreFiles = 0
                         print 'Setting the file: %s' % file
                     else:
                         self.fileSize = 0
                         self.filename = None
                         self.flagIsNewFile = 0
                         self.fp = None
                         self.flagNoMoreFiles = 1
                         print 'No more Files'
                     return fileOk_flag
                 def setNextFile(self):
                     if self.fp != None:
                         self.fp.close()
                     if self.online:
                         newFile = self.__setNextFileOnline()
                     else:
                         newFile = self.__setNextFileOffline()
                     if not(newFile):
                         return 0
                     self.__readFirstHeader()
                     self.nReadBlocks = 0
                     return 1
                 def __waitNewBlock(self):
                     #si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido
                     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()
                         systemHeaderObj = SystemHeader()
                         radarControllerHeaderObj = RadarControllerHeader()
                         processingHeaderObj = ProcessingHeader()
                         try:
-                            if not( basicHeaderObj.read(fp) ): raise ValueError
+                            if not( basicHeaderObj.read(fp) ): raise IOError
-                            if not( systemHeaderObj.read(fp) ): raise ValueError
+                            if not( systemHeaderObj.read(fp) ): raise IOError
-                            if not( radarControllerHeaderObj.read(fp) ): raise ValueError
+                            if not( radarControllerHeaderObj.read(fp) ): raise IOError
-                            if not( processingHeaderObj.read(fp) ): raise ValueError
+                            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):
                     if path == None:
                         raise ValueError, "The path is not valid"
                     if ext == None:
                         ext = self.ext
                     if online:
                         print "Searching files in online mode..."
                         doypath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext)
                         if not(doypath):
                             for nTries in range( self.nTries ):
                                 print '\tWaiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
                                 time.sleep( self.delay )
                                 doypath, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext)
                                 if doypath:
                                     break
                         if not(doypath):
                             print "There 'isn't valied files in %s" % path
                             return None
                         self.year = year
                         self.doy  = doy
                         self.set  = set - 1
                         self.path = path
                     else:
                         print "Searching files in offline mode ..."
                         pathList, filenameList = self.__searchFilesOffLine(path, startDate, endDate, startTime, endTime, set, expLabel, ext)
                         if not(pathList):
                             print "No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,
                                                                     datetime.datetime.combine(startDate,startTime).ctime(),
                                                                     datetime.datetime.combine(endDate,endTime).ctime())
                             sys.exit(-1)
                         self.fileIndex = -1
                         self.pathList = pathList
                         self.filenameList = filenameList
                     self.online = online
                     self.delay = delay
                     ext = ext.lower()
                     self.ext = ext
                     if not(self.setNextFile()):
                         if (startDate!=None) and (endDate!=None):
                             print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
                         elif startDate != None:
                             print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
                         else:
                             print "No files"
                         sys.exit(-1)
             #        self.updateDataHeader()
                     return self.dataOut
                 def 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 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.dataUtcTime)
                     subfolder = 'D%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
                     doypath = os.path.join( path, subfolder )
                     if not( os.path.exists(doypath) ):
                         os.mkdir(doypath)
                         self.setFile = -1 #inicializo mi contador de seteo
                     else:
                         filesList = os.listdir( doypath )
                         if len( filesList ) > 0:
                             filesList = sorted( filesList, key=str.lower )
                             filen = filesList[-1]
                             # el filename debera tener el siguiente formato
                             # 0 1234 567 89A BCDE (hex)
                             # x YYYY DDD SSS .ext
                             if isNumber( filen[8:11] ):
                                 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
                             else:
                                 self.setFile = -1
                         else:
                             self.setFile = -1 #inicializo mi contador de seteo
                     setFile = self.setFile
                     setFile += 1
                     file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
                                                     timeTuple.tm_year,
                                                     timeTuple.tm_yday,
                                                     setFile,
                                                     ext )
                     filename = os.path.join( path, subfolder, file )
                     fp = open( filename,'wb' )
                     self.blockIndex = 0
                     #guardando atributos
                     self.filename = filename
                     self.subfolder = subfolder
                     self.fp = fp
                     self.setFile = setFile
                     self.flagIsNewFile = 1
                     self.getDataHeader()
                     print 'Writing the file: %s'%self.filename
                     self.__writeFirstHeader()
                     return 1
                 def setup(self, dataOut, path, blocksPerFile, profilesPerBlock=None, set=0, ext=None):
                     """
                     Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
                     Inputs:
                         path      :    el path destino en el cual se escribiran los files a crear
                         format    :    formato en el cual sera salvado un file
                         set       :    el setebo del file
                     Return:
 :    Si no realizo un buen seteo
 :    Si realizo un buen seteo
                     """
                     if ext == None:
                         ext = self.ext
                     ext = ext.lower()
                     self.ext = ext
                     self.path = path
                     self.setFile = set - 1
                     self.blocksPerFile = blocksPerFile
                     self.profilesPerBlock = profilesPerBlock
                     self.dataOut = dataOut
                     if not(self.setNextFile()):
                         print "There isn't a next file"
                         return 0
                     self.setBlockDimension()
                     return 1
                 def run(self, dataOut, **kwargs):
                     if not(self.isConfig):
                         self.setup(dataOut, **kwargs)
                         self.isConfig = True
                     self.putData()
             class VoltageReader(JRODataReader):
                 """
                 Esta clase permite leer datos de voltage desde archivos en formato rawdata (.r). La lectura
                 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones:
                 perfiles*alturas*canales) son almacenados en la variable "buffer".
                                          perfiles * alturas * canales
                 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
                 RadarControllerHeader y Voltage. Los tres primeros se usan para almacenar informacion de la
                 cabecera de datos (metadata), y el cuarto (Voltage) para obtener y almacenar un perfil de
                 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
                 Example:
                     dpath = "/home/myuser/data"
                     startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
                     endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
                     readerObj = VoltageReader()
                     readerObj.setup(dpath, startTime, endTime)
                     while(True):
                         #to get one profile
                         profile =  readerObj.getData()
                         #print the profile
                         print profile
                         #If you want to see all datablock
                         print readerObj.datablock
                         if readerObj.flagNoMoreFiles:
                             break
                 """
                 ext = ".r"
                 optchar = "D"
                 dataOut = None
                 def __init__(self):
                     """
                     Inicializador de la clase VoltageReader para la lectura de datos de voltage.
                     Input:
                         dataOut    :    Objeto de la clase Voltage. Este objeto sera utilizado para
                                           almacenar un perfil de datos cada vez que se haga un requerimiento
                                           (getData). El perfil sera obtenido a partir del buffer de datos,
                                           si el buffer esta vacio se hara un nuevo proceso de lectura de un
                                           bloque de datos.
                                           Si este parametro no es pasado se creara uno internamente.
                     Variables afectadas:
                         self.dataOut
                     Return:
                         None
                     """
                     self.isConfig = False
                     self.datablock = None
                     self.utc = 0
                     self.ext = ".r"
                     self.optchar = "D"
                     self.basicHeaderObj = BasicHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                     self.online = 0
                     self.fp = None
                     self.idFile = None
                     self.dtype = None
                     self.fileSizeByHeader = None
                     self.filenameList = []
                     self.filename = None
                     self.fileSize = None
                     self.firstHeaderSize = 0
                     self.basicHeaderSize = 24
                     self.pathList = []
                     self.filenameList = []
                     self.lastUTTime = 0
                     self.maxTimeStep = 30
                     self.flagNoMoreFiles = 0
                     self.set = 0
                     self.path = None
                     self.profileIndex = 9999
                     self.delay  = 3   #seconds
                     self.nTries  = 3  #quantity tries
                     self.nFiles = 3   #number of files for searching
                     self.nReadBlocks = 0
                     self.flagIsNewFile = 1
                     self.ippSeconds = 0
                     self.flagTimeBlock = 0
                     self.flagIsNewBlock = 0
                     self.nTotalBlocks = 0
                     self.blocksize = 0
                     self.dataOut = self.createObjByDefault()
                 def createObjByDefault(self):
                     dataObj = Voltage()
                     return dataObj
                 def __hasNotDataInBuffer(self):
                     if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
                         return 1
                     return 0
                 def getBlockDimension(self):
                     """
                     Obtiene la cantidad de puntos a leer por cada bloque de datos
                     Affected:
                         self.blocksize
                     Return:
                         None
                     """
                     pts2read = self.processingHeaderObj.profilesPerBlock * self.processingHeaderObj.nHeights * self.systemHeaderObj.nChannels
                     self.blocksize = pts2read
                 def readBlock(self):
                     """
                     readBlock lee el bloque de datos desde la posicion actual del puntero del archivo
                     (self.fp) y actualiza todos los parametros relacionados al bloque de datos
                     (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
                     es seteado a 0
                     Inputs:
                         None
                     Return:
                         None
                     Affected:
                         self.profileIndex
                         self.datablock
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                     Exceptions:
                         Si un bloque leido no es un bloque valido
                     """
                     junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
                     try:
                         junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
                     except:
                         print "The read block (%3d) has not enough data" %self.nReadBlocks
                         return 0
                     junk = numpy.transpose(junk, (2,0,1))
                     self.datablock = junk['real'] + junk['imag']*1j
                     self.profileIndex = 0
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     return 1
                 def getData(self):
                     """
                     getData obtiene una unidad de datos del buffer de lectura y la copia a la clase "Voltage"
                     con todos los parametros asociados a este (metadata). cuando no hay datos en el buffer de
                     lectura es necesario hacer una nueva lectura de los bloques de datos usando "readNextBlock"
                     Ademas incrementa el contador del buffer en 1.
                     Return:
                         data    :    retorna un perfil de voltages (alturas * canales) copiados desde el
                                      buffer. Si no hay mas archivos a leer retorna None.
                     Variables afectadas:
                         self.dataOut
                         self.profileIndex
                     Affected:
                         self.dataOut
                         self.profileIndex
                         self.flagTimeBlock
                         self.flagIsNewBlock
                     """
                     if self.flagNoMoreFiles:
                         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.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.dtype = self.dtype
             #        self.dataOut.nChannels = self.systemHeaderObj.nChannels
             #        self.dataOut.nHeights = self.processingHeaderObj.nHeights
                     self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock
                     xf = self.processingHeaderObj.firstHeight + self.processingHeaderObj.nHeights*self.processingHeaderObj.deltaHeight
                     self.dataOut.heightList = numpy.arange(self.processingHeaderObj.firstHeight, xf, self.processingHeaderObj.deltaHeight)
                     self.dataOut.channelList = range(self.systemHeaderObj.nChannels)
             #        self.dataOut.channelIndexList = range(self.systemHeaderObj.nChannels)
                     self.dataOut.flagTimeBlock = self.flagTimeBlock
                     self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.ippSeconds
                     self.dataOut.ippSeconds = self.ippSeconds
                     self.dataOut.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt
                     self.dataOut.nCohInt = self.processingHeaderObj.nCohInt
                     self.dataOut.flagShiftFFT = False
                     if self.processingHeaderObj.code != None:
                         self.dataOut.nCode = self.processingHeaderObj.nCode
                         self.dataOut.nBaud = self.processingHeaderObj.nBaud
                         self.dataOut.code = self.processingHeaderObj.code
                     self.profileIndex += 1
                     self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
                     self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
                     self.dataOut.flagNoData = False
             #        print self.profileIndex, self.dataOut.utctime
             #        if self.profileIndex == 800:
             #            a=1
                     return self.dataOut.data
             class VoltageWriter(JRODataWriter):
                 """
                 Esta clase permite escribir datos de voltajes a archivos procesados (.r). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 ext = ".r"
                 optchar = "D"
                 shapeBuffer = None
                 def __init__(self):
                     """
                     Inicializador de la clase VoltageWriter para la escritura de datos de espectros.
                     Affected:
                         self.dataOut
                     Return: None
                     """
                     self.nTotalBlocks = 0
                     self.profileIndex = 0
                     self.isConfig = False
                     self.fp = None
                     self.flagIsNewFile = 1
                     self.nTotalBlocks = 0
                     self.flagIsNewBlock = 0
                     self.setFile = None
                     self.dtype = None
                     self.path = None
                     self.filename = None
                     self.basicHeaderObj = BasicHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                 def hasAllDataInBuffer(self):
                     if self.profileIndex >= self.processingHeaderObj.profilesPerBlock:
                         return 1
                     return 0
                 def setBlockDimension(self):
                     """
                     Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
                     Affected:
                         self.shape_spc_Buffer
                         self.shape_cspc_Buffer
                         self.shape_dc_Buffer
                     Return: None
                     """
                     self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,
                                         self.processingHeaderObj.nHeights,
                                         self.systemHeaderObj.nChannels)
                     self.datablock = numpy.zeros((self.systemHeaderObj.nChannels,
                                                  self.processingHeaderObj.profilesPerBlock,
                                                  self.processingHeaderObj.nHeights),
                                                  dtype=numpy.dtype('complex'))
                 def writeBlock(self):
                     """
                     Escribe el buffer en el file designado
                     Affected:
                         self.profileIndex
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.blockIndex
                     Return: None
                     """
                     data = numpy.zeros( self.shapeBuffer, self.dtype )
                     junk = numpy.transpose(self.datablock, (1,2,0))
                     data['real'] = junk.real
                     data['imag'] = junk.imag
                     data = data.reshape( (-1) )
                     data.tofile( self.fp )
                     self.datablock.fill(0)
                     self.profileIndex = 0
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.blockIndex += 1
                     self.nTotalBlocks += 1
                 def putData(self):
                     """
                     Setea un bloque de datos y luego los escribe en un file
                     Affected:
                         self.flagIsNewBlock
                         self.profileIndex
                     Return:
 :    Si no hay data o no hay mas files que puedan escribirse
 :    Si se escribio la data de un bloque en un file
                     """
                     if self.dataOut.flagNoData:
                         return 0
                     self.flagIsNewBlock = 0
                     if self.dataOut.flagTimeBlock:
                         self.datablock.fill(0)
                         self.profileIndex = 0
                         self.setNextFile()
                     if self.profileIndex == 0:
                         self.getBasicHeader()
                     self.datablock[:,self.profileIndex,:] = self.dataOut.data
                     self.profileIndex += 1
                     if self.hasAllDataInBuffer():
                         #if self.flagIsNewFile:
                         self.writeNextBlock()
             #            self.getDataHeader()
                     return 1
                 def __getProcessFlags(self):
                     processFlags = 0
                     dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
                     dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
                     dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
                     dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
                     dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
                     dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
                     dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
                     datatypeValueList =  [PROCFLAG.DATATYPE_CHAR,
                                        PROCFLAG.DATATYPE_SHORT,
                                        PROCFLAG.DATATYPE_LONG,
                                        PROCFLAG.DATATYPE_INT64,
                                        PROCFLAG.DATATYPE_FLOAT,
                                        PROCFLAG.DATATYPE_DOUBLE]
                     for index in range(len(dtypeList)):
                         if self.dataOut.dtype == dtypeList[index]:
                             dtypeValue = datatypeValueList[index]
                             break
                     processFlags += dtypeValue
                     if self.dataOut.flagDecodeData:
                         processFlags += PROCFLAG.DECODE_DATA
                     if self.dataOut.flagDeflipData:
                         processFlags += PROCFLAG.DEFLIP_DATA
                     if self.dataOut.code != None:
                         processFlags += PROCFLAG.DEFINE_PROCESS_CODE
                     if self.dataOut.nCohInt > 1:
                         processFlags += PROCFLAG.COHERENT_INTEGRATION
                     return processFlags
                 def __getBlockSize(self):
                     '''
                     Este metodos determina el cantidad de bytes para un bloque de datos de tipo Voltage
                     '''
                     dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
                     dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
                     dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
                     dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
                     dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
                     dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
                     dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
                     datatypeValueList = [1,2,4,8,4,8]
                     for index in range(len(dtypeList)):
                         if self.dataOut.dtype == dtypeList[index]:
                             datatypeValue = datatypeValueList[index]
                             break
                     blocksize = int(self.dataOut.nHeights * self.dataOut.nChannels * self.dataOut.nProfiles * datatypeValue * 2)
                     return blocksize
                 def getDataHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.dtype
                     Return:
                         None
                     """
                     self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
                     self.systemHeaderObj.nChannels = self.dataOut.nChannels
                     self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
                     self.getBasicHeader()
                     processingHeaderSize = 40 # bytes
                     self.processingHeaderObj.dtype = 0 # Voltage
                     self.processingHeaderObj.blockSize = self.__getBlockSize()
                     self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock
                     self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
                     self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
                     self.processingHeaderObj.processFlags = self.__getProcessFlags()
                     self.processingHeaderObj.nCohInt = self.dataOut.nCohInt
                     self.processingHeaderObj.nIncohInt = 1 # Cuando la data de origen es de tipo Voltage
                     self.processingHeaderObj.totalSpectra = 0 # Cuando la data de origen es de tipo Voltage
                     if self.dataOut.code != None:
                         self.processingHeaderObj.code = self.dataOut.code
                         self.processingHeaderObj.nCode = self.dataOut.nCode
                         self.processingHeaderObj.nBaud = self.dataOut.nBaud
                         codesize = int(8 + 4 * self.dataOut.nCode * self.dataOut.nBaud)
                         processingHeaderSize += codesize
                     if self.processingHeaderObj.nWindows != 0:
                         self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
                         self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
                         self.processingHeaderObj.nHeights = self.dataOut.nHeights
                         self.processingHeaderObj.samplesWin = self.dataOut.nHeights
                         processingHeaderSize += 12
                     self.processingHeaderObj.size = processingHeaderSize
             class SpectraReader(JRODataReader):
                 """
                 Esta clase permite leer datos de espectros desde archivos procesados (.pdata). La lectura
                 de los datos siempre se realiza por bloques. Los datos leidos (array de 3 dimensiones)
                 son almacenados en tres buffer's para el Self Spectra, el Cross Spectra y el DC Channel.
                                     paresCanalesIguales    * alturas * perfiles  (Self Spectra)
                                     paresCanalesDiferentes * alturas * perfiles  (Cross Spectra)
                                     canales * alturas                            (DC Channels)
                 Esta clase contiene instancias (objetos) de las clases BasicHeader, SystemHeader,
                 RadarControllerHeader y Spectra. Los tres primeros se usan para almacenar informacion de la
                 cabecera de datos (metadata), y el cuarto (Spectra) para obtener y almacenar un bloque de
                 datos desde el "buffer" cada vez que se ejecute el metodo "getData".
                 Example:
                     dpath = "/home/myuser/data"
                     startTime = datetime.datetime(2010,1,20,0,0,0,0,0,0)
                     endTime = datetime.datetime(2010,1,21,23,59,59,0,0,0)
                     readerObj = SpectraReader()
                     readerObj.setup(dpath, startTime, endTime)
                     while(True):
                         readerObj.getData()
                         print readerObj.data_spc
                         print readerObj.data_cspc
                         print readerObj.data_dc
                         if readerObj.flagNoMoreFiles:
                             break
                 """
                 pts2read_SelfSpectra = 0
                 pts2read_CrossSpectra = 0
                 pts2read_DCchannels = 0
                 ext = ".pdata"
                 optchar = "P"
                 dataOut = None
                 nRdChannels = None
                 nRdPairs = None
                 rdPairList = []
                 def __init__(self):
                     """
                     Inicializador de la clase SpectraReader para la lectura de datos de espectros.
                     Inputs:
                         dataOut    :    Objeto de la clase Spectra. Este objeto sera utilizado para
                                           almacenar un perfil de datos cada vez que se haga un requerimiento
                                           (getData). El perfil sera obtenido a partir del buffer de datos,
                                           si el buffer esta vacio se hara un nuevo proceso de lectura de un
                                           bloque de datos.
                                           Si este parametro no es pasado se creara uno internamente.
                     Affected:
                         self.dataOut
                     Return      : None
                     """
                     self.isConfig = False
                     self.pts2read_SelfSpectra = 0
                     self.pts2read_CrossSpectra = 0
                     self.pts2read_DCchannels = 0
                     self.datablock = None
                     self.utc = None
                     self.ext = ".pdata"
                     self.optchar = "P"
                     self.basicHeaderObj = BasicHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                     self.online = 0
                     self.fp = None
                     self.idFile = None
                     self.dtype = None
                     self.fileSizeByHeader = None
                     self.filenameList = []
                     self.filename = None
                     self.fileSize = None
                     self.firstHeaderSize = 0
                     self.basicHeaderSize = 24
                     self.pathList = []
                     self.lastUTTime = 0
                     self.maxTimeStep = 30
                     self.flagNoMoreFiles = 0
                     self.set = 0
                     self.path = None
                     self.delay  = 3   #seconds
                     self.nTries = 3  #quantity tries
                     self.nFiles = 3   #number of files for searching
                     self.nReadBlocks = 0
                     self.flagIsNewFile = 1
                     self.ippSeconds = 0
                     self.flagTimeBlock = 0
                     self.flagIsNewBlock = 0
                     self.nTotalBlocks = 0
                     self.blocksize = 0
                     self.dataOut = self.createObjByDefault()
                 def createObjByDefault(self):
                     dataObj = Spectra()
                     return dataObj
                 def __hasNotDataInBuffer(self):
                     return 1
                 def getBlockDimension(self):
                     """
                     Obtiene la cantidad de puntos a leer por cada bloque de datos
                     Affected:
                         self.nRdChannels
                         self.nRdPairs
                         self.pts2read_SelfSpectra
                         self.pts2read_CrossSpectra
                         self.pts2read_DCchannels
                         self.blocksize
                         self.dataOut.nChannels
                         self.dataOut.nPairs
                     Return:
                         None
                     """
                     self.nRdChannels = 0
                     self.nRdPairs = 0
                     self.rdPairList = []
                     for i in range(0, self.processingHeaderObj.totalSpectra*2, 2):
                         if self.processingHeaderObj.spectraComb[i] == self.processingHeaderObj.spectraComb[i+1]:
                             self.nRdChannels = self.nRdChannels + 1 #par de canales iguales
                         else:
                             self.nRdPairs = self.nRdPairs + 1 #par de canales diferentes
                             self.rdPairList.append((self.processingHeaderObj.spectraComb[i], self.processingHeaderObj.spectraComb[i+1]))
                     pts2read = self.processingHeaderObj.nHeights * self.processingHeaderObj.profilesPerBlock
                     self.pts2read_SelfSpectra = int(self.nRdChannels * pts2read)
                     self.blocksize = self.pts2read_SelfSpectra
                     if self.processingHeaderObj.flag_cspc:
                         self.pts2read_CrossSpectra = int(self.nRdPairs * pts2read)
                         self.blocksize += self.pts2read_CrossSpectra
                     if self.processingHeaderObj.flag_dc:
                         self.pts2read_DCchannels = int(self.systemHeaderObj.nChannels * self.processingHeaderObj.nHeights)
                         self.blocksize += self.pts2read_DCchannels
             #        self.blocksize = self.pts2read_SelfSpectra + self.pts2read_CrossSpectra + self.pts2read_DCchannels
                 def readBlock(self):
                     """
                     Lee el bloque de datos desde la posicion actual del puntero del archivo
                     (self.fp) y actualiza todos los parametros relacionados al bloque de datos
                     (metadata + data). La data leida es almacenada en el buffer y el contador del buffer
                     es seteado a 0
                     Return: None
                     Variables afectadas:
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                     Exceptions:
                         Si un bloque leido no es un bloque valido
                     """
                     blockOk_flag = False
                     fpointer = self.fp.tell()
                     spc = numpy.fromfile( self.fp, self.dtype[0], self.pts2read_SelfSpectra )
                     spc = spc.reshape( (self.nRdChannels, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
                     if self.processingHeaderObj.flag_cspc:
                         cspc = numpy.fromfile( self.fp, self.dtype, self.pts2read_CrossSpectra )
                         cspc = cspc.reshape( (self.nRdPairs, self.processingHeaderObj.nHeights, self.processingHeaderObj.profilesPerBlock) ) #transforma a un arreglo 3D
                     if self.processingHeaderObj.flag_dc:
                         dc = numpy.fromfile( self.fp, self.dtype, self.pts2read_DCchannels ) #int(self.processingHeaderObj.nHeights*self.systemHeaderObj.nChannels) )
                         dc = dc.reshape( (self.systemHeaderObj.nChannels, self.processingHeaderObj.nHeights) ) #transforma a un arreglo 2D
                     if not(self.processingHeaderObj.shif_fft):
                         #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 )
                     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 = 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.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft
             #        self.profileIndex += 1
                     self.dataOut.systemHeaderObj = self.systemHeaderObj.copy()
                     self.dataOut.radarControllerHeaderObj = self.radarControllerHeaderObj.copy()
                     return self.dataOut.data_spc
             class SpectraWriter(JRODataWriter):
                 """
                 Esta clase permite escribir datos de espectros a archivos procesados (.pdata). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 ext = ".pdata"
                 optchar = "P"
                 shape_spc_Buffer = None
                 shape_cspc_Buffer = None
                 shape_dc_Buffer = None
                 data_spc = None
                 data_cspc = None
                 data_dc = None
             #    dataOut = None
                 def __init__(self):
                     """
                     Inicializador de la clase SpectraWriter para la escritura de datos de espectros.
                     Affected:
                         self.dataOut
                         self.basicHeaderObj
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.processingHeaderObj
                     Return: None
                     """
                     self.isConfig = False
                     self.nTotalBlocks = 0
                     self.data_spc = None
                     self.data_cspc = None
                     self.data_dc = None
                     self.fp = None
                     self.flagIsNewFile = 1
                     self.nTotalBlocks = 0
                     self.flagIsNewBlock = 0
                     self.setFile = None
                     self.dtype = None
                     self.path = None
                     self.noMoreFiles = 0
                     self.filename = None
                     self.basicHeaderObj = BasicHeader()
                     self.systemHeaderObj = SystemHeader()
                     self.radarControllerHeaderObj = RadarControllerHeader()
                     self.processingHeaderObj = ProcessingHeader()
                 def hasAllDataInBuffer(self):
                     return 1
                 def setBlockDimension(self):
                     """
                     Obtiene las formas dimensionales del los subbloques de datos que componen un bloque
                     Affected:
                         self.shape_spc_Buffer
                         self.shape_cspc_Buffer
                         self.shape_dc_Buffer
                     Return: None
                     """
                     self.shape_spc_Buffer = (self.dataOut.nChannels,
                                              self.processingHeaderObj.nHeights,
                                              self.processingHeaderObj.profilesPerBlock)
                     self.shape_cspc_Buffer = (self.dataOut.nPairs,
                                               self.processingHeaderObj.nHeights,
                                               self.processingHeaderObj.profilesPerBlock)
                     self.shape_dc_Buffer = (self.dataOut.nChannels,
                                             self.processingHeaderObj.nHeights)
                 def writeBlock(self):
                     """
                     Escribe el buffer en el file designado
                     Affected:
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                         self.flagIsNewFile
                         self.flagIsNewBlock
                         self.nTotalBlocks
                         self.nWriteBlocks
                     Return: None
                     """
                     spc = numpy.transpose( self.data_spc, (0,2,1) )
                     if not( self.processingHeaderObj.shif_fft ):
                         spc = numpy.roll( spc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                     data = spc.reshape((-1))
                     data.tofile(self.fp)
                     if self.data_cspc != None:
                         data = numpy.zeros( self.shape_cspc_Buffer, self.dtype )
                         cspc = numpy.transpose( self.data_cspc, (0,2,1) )
                         if not( self.processingHeaderObj.shif_fft ):
                             cspc = numpy.roll( cspc, self.processingHeaderObj.profilesPerBlock/2, axis=2 ) #desplaza a la derecha en el eje 2 determinadas posiciones
                         data['real'] = cspc.real
                         data['imag'] = cspc.imag
                         data = data.reshape((-1))
                         data.tofile(self.fp)
                     if self.data_dc != None:
                         data = numpy.zeros( self.shape_dc_Buffer, self.dtype )
                         dc = self.data_dc
                         data['real'] = dc.real
                         data['imag'] = dc.imag
                         data = data.reshape((-1))
                         data.tofile(self.fp)
                     self.data_spc.fill(0)
                     self.data_dc.fill(0)
                     if self.data_cspc != None:
                         self.data_cspc.fill(0)
                     self.flagIsNewFile = 0
                     self.flagIsNewBlock = 1
                     self.nTotalBlocks += 1
                     self.nWriteBlocks += 1
                     self.blockIndex += 1
                 def putData(self):
                     """
                     Setea un bloque de datos y luego los escribe en un file
                     Affected:
                         self.data_spc
                         self.data_cspc
                         self.data_dc
                     Return:
 :    Si no hay data o no hay mas files que puedan escribirse
 :    Si se escribio la data de un bloque en un file
                     """
                     if self.dataOut.flagNoData:
                         return 0
                     self.flagIsNewBlock = 0
                     if self.dataOut.flagTimeBlock:
                         self.data_spc.fill(0)
                         self.data_cspc.fill(0)
                         self.data_dc.fill(0)
                         self.setNextFile()
                     if self.flagIsNewFile == 0:
                         self.getBasicHeader()
                     self.data_spc = self.dataOut.data_spc
                     self.data_cspc = self.dataOut.data_cspc
                     self.data_dc = self.dataOut.data_dc
                     # #self.processingHeaderObj.dataBlocksPerFile)
                     if self.hasAllDataInBuffer():
             #            self.getDataHeader()
                         self.writeNextBlock()
                     return 1
                 def __getProcessFlags(self):
                     processFlags = 0
                     dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
                     dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
                     dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
                     dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
                     dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
                     dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
                     dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
                     datatypeValueList =  [PROCFLAG.DATATYPE_CHAR,
                                        PROCFLAG.DATATYPE_SHORT,
                                        PROCFLAG.DATATYPE_LONG,
                                        PROCFLAG.DATATYPE_INT64,
                                        PROCFLAG.DATATYPE_FLOAT,
                                        PROCFLAG.DATATYPE_DOUBLE]
                     for index in range(len(dtypeList)):
                         if self.dataOut.dtype == dtypeList[index]:
                             dtypeValue = datatypeValueList[index]
                             break
                     processFlags += dtypeValue
                     if self.dataOut.flagDecodeData:
                         processFlags += PROCFLAG.DECODE_DATA
                     if self.dataOut.flagDeflipData:
                         processFlags += PROCFLAG.DEFLIP_DATA
                     if self.dataOut.code != None:
                         processFlags += PROCFLAG.DEFINE_PROCESS_CODE
                     if self.dataOut.nIncohInt > 1:
                         processFlags += PROCFLAG.INCOHERENT_INTEGRATION
                     if self.dataOut.data_dc != None:
                         processFlags += PROCFLAG.SAVE_CHANNELS_DC
                     return processFlags
                 def __getBlockSize(self):
                     '''
                     Este metodos determina el cantidad de bytes para un bloque de datos de tipo Spectra
                     '''
                     dtype0 = numpy.dtype([('real','<i1'),('imag','<i1')])
                     dtype1 = numpy.dtype([('real','<i2'),('imag','<i2')])
                     dtype2 = numpy.dtype([('real','<i4'),('imag','<i4')])
                     dtype3 = numpy.dtype([('real','<i8'),('imag','<i8')])
                     dtype4 = numpy.dtype([('real','<f4'),('imag','<f4')])
                     dtype5 = numpy.dtype([('real','<f8'),('imag','<f8')])
                     dtypeList = [dtype0, dtype1, dtype2, dtype3, dtype4, dtype5]
                     datatypeValueList = [1,2,4,8,4,8]
                     for index in range(len(dtypeList)):
                         if self.dataOut.dtype == dtypeList[index]:
                             datatypeValue = datatypeValueList[index]
                             break
                     pts2write = self.dataOut.nHeights * self.dataOut.nFFTPoints
                     pts2write_SelfSpectra = int(self.dataOut.nChannels * pts2write)
                     blocksize = (pts2write_SelfSpectra*datatypeValue)
                     if self.dataOut.data_cspc != None:
                         pts2write_CrossSpectra = int(self.dataOut.nPairs * pts2write)
                         blocksize += (pts2write_CrossSpectra*datatypeValue*2)
                     if self.dataOut.data_dc != None:
                         pts2write_DCchannels = int(self.dataOut.nChannels * self.dataOut.nHeights)
                         blocksize += (pts2write_DCchannels*datatypeValue*2)
                     blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO
                     return blocksize
                 def getDataHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.dtype
                     Return:
                         None
                     """
                     self.systemHeaderObj = self.dataOut.systemHeaderObj.copy()
                     self.systemHeaderObj.nChannels = self.dataOut.nChannels
                     self.radarControllerHeaderObj = self.dataOut.radarControllerHeaderObj.copy()
                     self.getBasicHeader()
                     processingHeaderSize = 40 # bytes
                     self.processingHeaderObj.dtype = 0 # Voltage
                     self.processingHeaderObj.blockSize = self.__getBlockSize()
                     self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints
                     self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
                     self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
                     self.processingHeaderObj.processFlags = self.__getProcessFlags()
                     self.processingHeaderObj.nCohInt = self.dataOut.nCohInt# Se requiere para determinar el valor de timeInterval
                     self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt
                     self.processingHeaderObj.totalSpectra = self.dataOut.nPairs + self.dataOut.nChannels
                     if self.processingHeaderObj.totalSpectra > 0:
                         channelList = []
                         for channel in range(self.dataOut.nChannels):
                             channelList.append(channel)
                             channelList.append(channel)
                         pairsList = []
                         for pair in self.dataOut.pairsList:
                             pairsList.append(pair[0])
                             pairsList.append(pair[1])
                         spectraComb = channelList + pairsList
                         spectraComb = numpy.array(spectraComb,dtype="u1")
                         self.processingHeaderObj.spectraComb = spectraComb
                         sizeOfSpcComb = len(spectraComb)
                         processingHeaderSize += sizeOfSpcComb
                     if self.dataOut.code != None:
                         self.processingHeaderObj.code = self.dataOut.code
                         self.processingHeaderObj.nCode = self.dataOut.nCode
                         self.processingHeaderObj.nBaud = self.dataOut.nBaud
                         nCodeSize = 4 # bytes
                         nBaudSize = 4 # bytes
                         codeSize = 4 # bytes
                         sizeOfCode = int(nCodeSize + nBaudSize + codeSize * self.dataOut.nCode * self.dataOut.nBaud)
                         processingHeaderSize += sizeOfCode
                     if self.processingHeaderObj.nWindows != 0:
                         self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
                         self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
                         self.processingHeaderObj.nHeights = self.dataOut.nHeights
                         self.processingHeaderObj.samplesWin = self.dataOut.nHeights
                         sizeOfFirstHeight = 4
                         sizeOfdeltaHeight = 4
                         sizeOfnHeights = 4
                         sizeOfWindows = (sizeOfFirstHeight + sizeOfdeltaHeight + sizeOfnHeights)*self.processingHeaderObj.nWindows
                         processingHeaderSize += sizeOfWindows
                     self.processingHeaderObj.size = processingHeaderSize
             class SpectraHeisWriter():
                 i=0
                 def __init__(self, dataOut):
                     self.wrObj = FITS()
                     self.dataOut = dataOut
                 def isNumber(str):
                     """
                     Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
                     Excepciones:
                     Si un determinado string no puede ser convertido a numero
                     Input:
                     str, string al cual se le analiza para determinar si convertible a un numero o no
                     Return:
                     True    :    si el string es uno numerico
                     False   :    no es un string numerico
                     """
                     try:
                         float( str )
                         return True
                     except:
                         return False
                 def setup(self, wrpath,):
                     if not(os.path.exists(wrpath)):
                         os.mkdir(wrpath)
                     self.wrpath = wrpath
                     self.setFile = 0
                 def putData(self):
                   # self.wrObj.writeHeader(nChannels=self.dataOut.nChannels, nFFTPoints=self.dataOut.nFFTPoints)
                     #name = self.dataOut.utctime
                     name= time.localtime( self.dataOut.utctime)
                     ext=".fits"
                     #folder='D%4.4d%3.3d'%(name.tm_year,name.tm_yday)
                     subfolder = 'D%4.4d%3.3d' % (name.tm_year,name.tm_yday)
                     doypath = os.path.join( self.wrpath, subfolder )
                     if not( os.path.exists(doypath) ):
                         os.mkdir(doypath)
                     self.setFile += 1
                     file = 'D%4.4d%3.3d%3.3d%s' % (name.tm_year,name.tm_yday,self.setFile,ext)
                     filename = os.path.join(self.wrpath,subfolder, file)
                    # print self.dataOut.ippSeconds
                     freq=numpy.arange(-1*self.dataOut.nHeights/2.,self.dataOut.nHeights/2.)/(2*self.dataOut.ippSeconds)
                     col1=self.wrObj.setColF(name="freq", format=str(self.dataOut.nFFTPoints)+'E', array=freq)
                     col2=self.wrObj.writeData(name="P_Ch1",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[0,:]))
                     col3=self.wrObj.writeData(name="P_Ch2",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[1,:]))
                     col4=self.wrObj.writeData(name="P_Ch3",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[2,:]))
                     col5=self.wrObj.writeData(name="P_Ch4",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[3,:]))
                     col6=self.wrObj.writeData(name="P_Ch5",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[4,:]))
                     col7=self.wrObj.writeData(name="P_Ch6",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[5,:]))
                     col8=self.wrObj.writeData(name="P_Ch7",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[6,:]))
                     col9=self.wrObj.writeData(name="P_Ch8",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[7,:]))
                     #n=numpy.arange((100))
                     n=self.dataOut.data_spc[6,:]
                     a=self.wrObj.cFImage(n)
                     b=self.wrObj.Ctable(col1,col2,col3,col4,col5,col6,col7,col8,col9)
                     self.wrObj.CFile(a,b)
                     self.wrObj.wFile(filename)
                     return 1
             class FITS:
                 name=None
                 format=None
                 array =None
                 data =None
                 thdulist=None
                 def __init__(self):
                     pass
                 def setColF(self,name,format,array):
                     self.name=name
                     self.format=format
                     self.array=array
                     a1=numpy.array([self.array],dtype=numpy.float32)
                     self.col1 = pyfits.Column(name=self.name, format=self.format, array=a1)
                     return self.col1
             #    def setColP(self,name,format,data):
             #        self.name=name
             #        self.format=format
             #        self.data=data
             #        a2=numpy.array([self.data],dtype=numpy.float32)
             #        self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
             #        return self.col2
                 def writeHeader(self,):
                     pass
                 def writeData(self,name,format,data):
                     self.name=name
                     self.format=format
                     self.data=data
                     a2=numpy.array([self.data],dtype=numpy.float32)
                     self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
                     return self.col2
                 def cFImage(self,n):
                     self.hdu= pyfits.PrimaryHDU(n)
                     return self.hdu
                 def Ctable(self,col1,col2,col3,col4,col5,col6,col7,col8,col9):
                     self.cols=pyfits.ColDefs( [col1,col2,col3,col4,col5,col6,col7,col8,col9])
                     self.tbhdu = pyfits.new_table(self.cols)
                     return self.tbhdu
                 def CFile(self,hdu,tbhdu):
                     self.thdulist=pyfits.HDUList([hdu,tbhdu])
                 def wFile(self,filename):
                     self.thdulist.writeto(filename)

1

'''

1

'''

2

3

$Author: murco $

3

$Author: murco $

4

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

4

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

5

'''

5

'''

6

7

import os, sys

7

import os, sys

8

import glob

8

import glob

9

import time

9

import time

10

import numpy

10

import numpy

11

import fnmatch

11

import fnmatch

12

import time, datetime

12

import time, datetime

13

14

from jrodata import *

14

from jrodata import *

15

from jroheaderIO import *

15

from jroheaderIO import *

16

from jroprocessing import *

16

from jroprocessing import *

17

18

def isNumber(str):

18

def isNumber(str):

19

"""

19

"""

20

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

20

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

21

22

Excepciones:

22

Excepciones:

23

Si un determinado string no puede ser convertido a numero

23

Si un determinado string no puede ser convertido a numero

24

Input:

24

Input:

25

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

25

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

26

27

Return:

27

Return:

28

True : si el string es uno numerico

28

True : si el string es uno numerico

29

False : no es un string numerico

29

False : no es un string numerico

30

"""

30

"""

31

try:

31

try:

32

float( str )

32

float( str )

33

return True

33

return True

34

except:

34

except:

35

return False

35

return False

36

37

def isThisFileinRange(filename, startUTSeconds, endUTSeconds):

37

def isThisFileinRange(filename, startUTSeconds, endUTSeconds):

38

"""

38

"""

39

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

39

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

40

41

Inputs:

41

Inputs:

42

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

42

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

43

44

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

44

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

45

segundos contados desde 01/01/1970.

45

segundos contados desde 01/01/1970.

46

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

46

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

47

segundos contados desde 01/01/1970.

47

segundos contados desde 01/01/1970.

48

49

Return:

49

Return:

50

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

50

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

51

fecha especificado, de lo contrario retorna False.

51

fecha especificado, de lo contrario retorna False.

52

53

Excepciones:

53

Excepciones:

54

Si el archivo no existe o no puede ser abierto

54

Si el archivo no existe o no puede ser abierto

55

Si la cabecera no puede ser leida.

55

Si la cabecera no puede ser leida.

56

57

"""

57

"""

58

basicHeaderObj = BasicHeader()

58

basicHeaderObj = BasicHeader()

59

60

try:

60

try:

61

fp = open(filename,'rb')

61

fp = open(filename,'rb')

62

except:

62

except:

63

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

63

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

64

65

sts = basicHeaderObj.read(fp)

65

sts = basicHeaderObj.read(fp)

66

fp.close()

66

fp.close()

67

68

if not(sts):

68

if not(sts):

69

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

69

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

70

return 0

70

return 0

71

72

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

72

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

73

return 0

73

return 0

74

75

return 1

75

return 1

76

77

def getlastFileFromPath(path, ext):

77

def getlastFileFromPath(path, ext):

78

"""

78

"""

79

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

79

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

80

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

80

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

81

82

Input:

82

Input:

83

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

83

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

84

ext : extension de los files contenidos en una carpeta

84

ext : extension de los files contenidos en una carpeta

85

86

Return:

86

Return:

87

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

87

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

88

"""

88

"""

89

validFilelist = []

89

validFilelist = []

90

fileList = os.listdir(path)

90

fileList = os.listdir(path)

91

92

# 0 1234 567 89A BCDE

92

# 0 1234 567 89A BCDE

93

# H YYYY DDD SSS .ext

93

# H YYYY DDD SSS .ext

94

95

for file in fileList:

95

for file in fileList:

96

try:

96

try:

97

year = int(file[1:5])

97

year = int(file[1:5])

98

doy = int(file[5:8])

98

doy = int(file[5:8])

99

100

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

100

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

101

except:

101

except:

102

continue

102

continue

103

104

validFilelist.append(file)

104

validFilelist.append(file)

105

106

if validFilelist:

106

if validFilelist:

107

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

107

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

108

return validFilelist[-1]

108

return validFilelist[-1]

109

110

return None

110

return None

111

112

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

112

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

113

"""

113

"""

114

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

114

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

115

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

115

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

116

el path exacto de un determinado file.

116

el path exacto de un determinado file.

117

118

Example :

118

Example :

119

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

119

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

120

121

Entonces la funcion prueba con las siguientes combinaciones

121

Entonces la funcion prueba con las siguientes combinaciones

122

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

122

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

123

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

123

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

124

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

124

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

125

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

125

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

126

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

126

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

127

128

Return:

128

Return:

129

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

129

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

130

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

130

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

131

para el filename

131

para el filename

132

"""

132

"""

133

filepath = None

133

filepath = None

134

find_flag = False

134

find_flag = False

135

filename = None

135

filename = None

136

137

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

137

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

138

header1 = "dD"

138

header1 = "dD"

139

header2 = "dD"

139

header2 = "dD"

140

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

140

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

141

header1 = "dD"

141

header1 = "dD"

142

header2 = "pP"

142

header2 = "pP"

143

else:

143

else:

144

return None, filename

144

return None, filename

145

146

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

146

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

147

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

147

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

148

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

148

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

149

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

149

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

150

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

150

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

151

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

151

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

152

find_flag = True

152

find_flag = True

153

break

153

break

154

if find_flag:

154

if find_flag:

155

break

155

break

156

157

if not(find_flag):

157

if not(find_flag):

158

return None, filename

158

return None, filename

159

160

return filepath, filename

160

return filepath, filename

161

162

class JRODataIO:

162

class JRODataIO:

163

164

c = 3E8

164

c = 3E8

165

166

isConfig = False

166

isConfig = False

167

168

basicHeaderObj = BasicHeader()

168

basicHeaderObj = BasicHeader()

169

170

systemHeaderObj = SystemHeader()

170

systemHeaderObj = SystemHeader()

171

172

radarControllerHeaderObj = RadarControllerHeader()

172

radarControllerHeaderObj = RadarControllerHeader()

173

174

processingHeaderObj = ProcessingHeader()

174

processingHeaderObj = ProcessingHeader()

175

176

online = 0

176

online = 0

177

178

dtype = None

178

dtype = None

179

180

pathList = []

180

pathList = []

181

182

filenameList = []

182

filenameList = []

183

184

filename = None

184

filename = None

185

186

ext = None

186

ext = None

187

188

flagIsNewFile = 1

188

flagIsNewFile = 1

189

190

flagTimeBlock = 0

190

flagTimeBlock = 0

191

192

flagIsNewBlock = 0

192

flagIsNewBlock = 0

193

194

fp = None

194

fp = None

195

196

firstHeaderSize = 0

196

firstHeaderSize = 0

197

198

basicHeaderSize = 24

198

basicHeaderSize = 24

199

200

versionFile = 1103

200

versionFile = 1103

201

202

fileSize = None

202

fileSize = None

203

204

ippSeconds = None

204

ippSeconds = None

205

206

fileSizeByHeader = None

206

fileSizeByHeader = None

207

208

fileIndex = None

208

fileIndex = None

209

210

profileIndex = None

210

profileIndex = None

211

212

blockIndex = None

212

blockIndex = None

213

214

nTotalBlocks = None

214

nTotalBlocks = None

215

216

maxTimeStep = 30

216

maxTimeStep = 30

217

218

lastUTTime = None

218

lastUTTime = None

219

220

datablock = None

220

datablock = None

221

222

dataOut = None

222

dataOut = None

223

224

blocksize = None

224

blocksize = None

225

226

def __init__(self):

226

def __init__(self):

227

228

raise ValueError, "Not implemented"

228

raise ValueError, "Not implemented"

229

230

def run(self):

230

def run(self):

231

232

raise ValueError, "Not implemented"

232

raise ValueError, "Not implemented"

233

234

def getOutput(self):

234

def getOutput(self):

235

236

return self.dataOut

236

return self.dataOut

237

238

class JRODataReader(JRODataIO, ProcessingUnit):

238

class JRODataReader(JRODataIO, ProcessingUnit):

239

240

nReadBlocks = 0

240

nReadBlocks = 0

241

242

delay = 10 #number of seconds waiting a new file

242

delay = 10 #number of seconds waiting a new file

243

244

nTries = 3 #quantity tries

244

nTries = 3 #quantity tries

245

246

nFiles = 3 #number of files for searching

246

nFiles = 3 #number of files for searching

247

248

flagNoMoreFiles = 0

248

flagNoMoreFiles = 0

249

250

def __init__(self):

250

def __init__(self):

251

252

"""

252

"""

253

254

"""

254

"""

255

256

raise ValueError, "This method has not been implemented"

256

raise ValueError, "This method has not been implemented"

257

258

259

def createObjByDefault(self):

259

def createObjByDefault(self):

260

"""

260

"""

261

262

"""

262

"""

263

raise ValueError, "This method has not been implemented"

263

raise ValueError, "This method has not been implemented"

264

265

def getBlockDimension(self):

265

def getBlockDimension(self):

266

267

raise ValueError, "No implemented"

267

raise ValueError, "No implemented"

268

269

def __searchFilesOffLine(self,

269

def __searchFilesOffLine(self,

270

path,

270

path,

271

startDate,

271

startDate,

272

endDate,

272

endDate,

273

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

273

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

274

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

274

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

275

set=None,

275

set=None,

276

expLabel="",

276

expLabel="",

277

ext=".r"):

277

ext=".r"):

278

dirList = []

278

dirList = []

279

for thisPath in os.listdir(path):

279

for thisPath in os.listdir(path):

280

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

280

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

281

dirList.append(thisPath)

281

dirList.append(thisPath)

282

283

if not(dirList):

283

if not(dirList):

284

return None, None

284

return None, None

285

286

pathList = []

286

pathList = []

287

dateList = []

287

dateList = []

288

289

thisDate = startDate

289

thisDate = startDate

290

291

while(thisDate <= endDate):

291

while(thisDate <= endDate):

292

year = thisDate.timetuple().tm_year

292

year = thisDate.timetuple().tm_year

293

doy = thisDate.timetuple().tm_yday

293

doy = thisDate.timetuple().tm_yday

294

295

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

295

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

296

if len(match) == 0:

296

if len(match) == 0:

297

thisDate += datetime.timedelta(1)

297

thisDate += datetime.timedelta(1)

298

continue

298

continue

299

300

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

300

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

301

dateList.append(thisDate)

301

dateList.append(thisDate)

302

thisDate += datetime.timedelta(1)

302

thisDate += datetime.timedelta(1)

303

304

filenameList = []

304

filenameList = []

305

for index in range(len(pathList)):

305

for index in range(len(pathList)):

306

307

thisPath = pathList[index]

307

thisPath = pathList[index]

308

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

308

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

309

fileList.sort()

309

fileList.sort()

310

311

#Busqueda de datos en el rango de horas indicados

311

#Busqueda de datos en el rango de horas indicados

312

thisDate = dateList[index]

312

thisDate = dateList[index]

313

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

313

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

314

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

314

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

315

316

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

316

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

317

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

317

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

318

319

for file in fileList:

319

for file in fileList:

320

321

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

321

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

322

323

if isThisFileinRange(filename, startUtSeconds, endUtSeconds):

323

if isThisFileinRange(filename, startUtSeconds, endUtSeconds):

324

filenameList.append(filename)

324

filenameList.append(filename)

325

326

if not(filenameList):

326

if not(filenameList):

327

return None, None

327

return None, None

328

329

self.filenameList = filenameList

329

self.filenameList = filenameList

330

331

return pathList, filenameList

331

return pathList, filenameList

332

333

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

333

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

334

335

"""

335

"""

336

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

336

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

337

devuelve el archivo encontrado ademas de otros datos.

337

devuelve el archivo encontrado ademas de otros datos.

338

339

Input:

339

Input:

340

path : carpeta donde estan contenidos los files que contiene data

340

path : carpeta donde estan contenidos los files que contiene data

341

342

startDate : Fecha inicial. Rechaza todos los directorios donde

342

startDate : Fecha inicial. Rechaza todos los directorios donde

343

file end time < startDate (obejto datetime.date)

343

file end time < startDate (obejto datetime.date)

344

345

endDate : Fecha final. Rechaza todos los directorios donde

345

endDate : Fecha final. Rechaza todos los directorios donde

346

file start time > endDate (obejto datetime.date)

346

file start time > endDate (obejto datetime.date)

347

348

startTime : Tiempo inicial. Rechaza todos los archivos donde

348

startTime : Tiempo inicial. Rechaza todos los archivos donde

349

file end time < startTime (obejto datetime.time)

349

file end time < startTime (obejto datetime.time)

350

351

endTime : Tiempo final. Rechaza todos los archivos donde

351

endTime : Tiempo final. Rechaza todos los archivos donde

352

file start time > endTime (obejto datetime.time)

352

file start time > endTime (obejto datetime.time)

353

354

expLabel : Nombre del subexperimento (subfolder)

354

expLabel : Nombre del subexperimento (subfolder)

355

356

ext : extension de los files

356

ext : extension de los files

357

358

Return:

358

Return:

359

directory : eL directorio donde esta el file encontrado

359

directory : eL directorio donde esta el file encontrado

360

filename : el ultimo file de una determinada carpeta

360

filename : el ultimo file de una determinada carpeta

361

year : el anho

361

year : el anho

362

doy : el numero de dia del anho

362

doy : el numero de dia del anho

363

set : el set del archivo

363

set : el set del archivo

364

365

366

"""

366

"""

367

dirList = []

367

dirList = []

368

pathList = []

368

pathList = []

369

directory = None

369

directory = None

370

371

#Filtra solo los directorios

371

#Filtra solo los directorios

372

for thisPath in os.listdir(path):

372

for thisPath in os.listdir(path):

373

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

373

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

374

dirList.append(thisPath)

374

dirList.append(thisPath)

375

376

if not(dirList):

376

if not(dirList):

377

return None, None, None, None, None

377

return None, None, None, None, None

378

379

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

379

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

380

381

if startDate:

381

if startDate:

382

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

382

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

383

thisDateTime = startDateTime

383

thisDateTime = startDateTime

384

if endDate == None: endDateTime = startDateTime

384

if endDate == None: endDateTime = startDateTime

385

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

385

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

386

387

while(thisDateTime <= endDateTime):

387

while(thisDateTime <= endDateTime):

388

year = thisDateTime.timetuple().tm_year

388

year = thisDateTime.timetuple().tm_year

389

doy = thisDateTime.timetuple().tm_yday

389

doy = thisDateTime.timetuple().tm_yday

390

391

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

391

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

392

if len(match) == 0:

392

if len(match) == 0:

393

thisDateTime += datetime.timedelta(1)

393

thisDateTime += datetime.timedelta(1)

394

continue

394

continue

395

396

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

396

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

397

thisDateTime += datetime.timedelta(1)

397

thisDateTime += datetime.timedelta(1)

398

399

if not(pathList):

399

if not(pathList):

400

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

400

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

401

return None, None, None, None, None

401

return None, None, None, None, None

402

403

directory = pathList[0]

403

directory = pathList[0]

404

405

else:

405

else:

406

directory = dirList[-1]

406

directory = dirList[-1]

407

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

407

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

408

409

filename = getlastFileFromPath(directory, ext)

409

filename = getlastFileFromPath(directory, ext)

410

411

if not(filename):

411

if not(filename):

412

return None, None, None, None, None

412

return None, None, None, None, None

413

414

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

414

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

415

return None, None, None, None, None

415

return None, None, None, None, None

416

417

year = int( filename[1:5] )

417

year = int( filename[1:5] )

418

doy = int( filename[5:8] )

418

doy = int( filename[5:8] )

419

set = int( filename[8:11] )

419

set = int( filename[8:11] )

420

421

return directory, filename, year, doy, set

421

return directory, filename, year, doy, set

422

423

424

425

def __setNextFileOffline(self):

425

def __setNextFileOffline(self):

426

427

idFile = self.fileIndex

427

idFile = self.fileIndex

428

429

while (True):

429

while (True):

430

idFile += 1

430

idFile += 1

431

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

431

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

432

self.flagNoMoreFiles = 1

432

self.flagNoMoreFiles = 1

433

print "No more Files"

433

print "No more Files"

434

return 0

434

return 0

435

436

filename = self.filenameList[idFile]

436

filename = self.filenameList[idFile]

437

438

if not(self.__verifyFile(filename)):

438

if not(self.__verifyFile(filename)):

439

continue

439

continue

440

441

fileSize = os.path.getsize(filename)

441

fileSize = os.path.getsize(filename)

442

fp = open(filename,'rb')

442

fp = open(filename,'rb')

443

break

443

break

444

445

self.flagIsNewFile = 1

445

self.flagIsNewFile = 1

446

self.fileIndex = idFile

446

self.fileIndex = idFile

447

self.filename = filename

447

self.filename = filename

448

self.fileSize = fileSize

448

self.fileSize = fileSize

449

self.fp = fp

449

self.fp = fp

450

451

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

451

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

452

453

return 1

453

return 1

454

455

def __setNextFileOnline(self):

455

def __setNextFileOnline(self):

456

"""

456

"""

457

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

457

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

458

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

458

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

459

siguientes.

459

siguientes.

460

461

Affected:

461

Affected:

462

self.flagIsNewFile

462

self.flagIsNewFile

463

self.filename

463

self.filename

464

self.fileSize

464

self.fileSize

465

self.fp

465

self.fp

466

self.set

466

self.set

467

self.flagNoMoreFiles

467

self.flagNoMoreFiles

468

469

Return:

469

Return:

470

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

470

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

471

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

471

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

472

473

Excepciones:

473

Excepciones:

474

Si un determinado file no puede ser abierto

474

Si un determinado file no puede ser abierto

475

"""

475

"""

476

nFiles = 0

476

nFiles = 0

477

fileOk_flag = False

477

fileOk_flag = False

478

firstTime_flag = True

478

firstTime_flag = True

479

480

self.set += 1

480

self.set += 1

481

482

#busca el 1er file disponible

482

#busca el 1er file disponible

483

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

483

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

484

if file:

484

if file:

485

if self.__verifyFile(file, False):

485

if self.__verifyFile(file, False):

486

fileOk_flag = True

486

fileOk_flag = True

487

488

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

488

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

489

if not(fileOk_flag):

489

if not(fileOk_flag):

490

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

490

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

491

492

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

492

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

493

tries = self.nTries

493

tries = self.nTries

494

else:

494

else:

495

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

495

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

496

497

for nTries in range( tries ):

497

for nTries in range( tries ):

498

if firstTime_flag:

498

if firstTime_flag:

499

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

499

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

500

time.sleep( self.delay )

500

time.sleep( self.delay )

501

else:

501

else:

502

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

502

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

503

504

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

504

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

505

if file:

505

if file:

506

if self.__verifyFile(file):

506

if self.__verifyFile(file):

507

fileOk_flag = True

507

fileOk_flag = True

508

break

508

break

509

510

if fileOk_flag:

510

if fileOk_flag:

511

break

511

break

512

513

firstTime_flag = False

513

firstTime_flag = False

514

515

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

515

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

516

self.set += 1

516

self.set += 1

517

518

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

518

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

519

self.set = 0

519

self.set = 0

520

self.doy += 1

520

self.doy += 1

521

522

if fileOk_flag:

522

if fileOk_flag:

523

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

523

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

524

self.filename = file

524

self.filename = file

525

self.flagIsNewFile = 1

525

self.flagIsNewFile = 1

526

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

526

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

527

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

527

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

528

self.flagNoMoreFiles = 0

528

self.flagNoMoreFiles = 0

529

print 'Setting the file: %s' % file

529

print 'Setting the file: %s' % file

530

else:

530

else:

531

self.fileSize = 0

531

self.fileSize = 0

532

self.filename = None

532

self.filename = None

533

self.flagIsNewFile = 0

533

self.flagIsNewFile = 0

534

self.fp = None

534

self.fp = None

535

self.flagNoMoreFiles = 1

535

self.flagNoMoreFiles = 1

536

print 'No more Files'

536

print 'No more Files'

537

538

return fileOk_flag

538

return fileOk_flag

539

540

541

def setNextFile(self):

541

def setNextFile(self):

542

if self.fp != None:

542

if self.fp != None:

543

self.fp.close()

543

self.fp.close()

544

545

if self.online:

545

if self.online:

546

newFile = self.__setNextFileOnline()

546

newFile = self.__setNextFileOnline()

547

else:

547

else:

548

newFile = self.__setNextFileOffline()

548

newFile = self.__setNextFileOffline()

549

550

if not(newFile):

550

if not(newFile):

551

return 0

551

return 0

552

553

self.__readFirstHeader()

553

self.__readFirstHeader()

554

self.nReadBlocks = 0

554

self.nReadBlocks = 0

555

return 1

555

return 1

556

557

def __waitNewBlock(self):

557

def __waitNewBlock(self):

558

#si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido

558

#si es OnLine y ademas aun no se han leido un bloque completo entonces se espera por uno valido

559

if not self.online:

559

if not self.online:

560

return 0

560

return 0

561

562

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

562

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

563

return 0

563

return 0

564

565

currentPointer = self.fp.tell()

565

currentPointer = self.fp.tell()

566

567

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

567

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

568

569

for nTries in range( self.nTries ):

569

for nTries in range( self.nTries ):

570

571

self.fp.close()

571

self.fp.close()

572

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

572

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

573

self.fp.seek( currentPointer )

573

self.fp.seek( currentPointer )

574

575

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

575

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

576

currentSize = self.fileSize - currentPointer

576

currentSize = self.fileSize - currentPointer

577

578

if ( currentSize >= neededSize ):

578

if ( currentSize >= neededSize ):

579

self.__rdBasicHeader()

579

self.__rdBasicHeader()

580

return 1

580

return 1

581

582

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

582

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

583

time.sleep( self.delay )

583

time.sleep( self.delay )

584

585

586

return 0

586

return 0

587

588

def __setNewBlock(self):

588

def __setNewBlock(self):

589

if self.fp == None:

589

if self.fp == None:

590

return 0

590

return 0

591

592

if self.flagIsNewFile:

592

if self.flagIsNewFile:

593

return 1

593

return 1

594

595

self.lastUTTime = self.basicHeaderObj.utc

595

self.lastUTTime = self.basicHeaderObj.utc

596

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

596

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

597

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

597

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

598

599

if (currentSize >= neededSize):

599

if (currentSize >= neededSize):

600

self.__rdBasicHeader()

600

self.__rdBasicHeader()

601

return 1

601

return 1

602

603

if self.__waitNewBlock():

603

if self.__waitNewBlock():

604

return 1

604

return 1

605

606

if not(self.setNextFile()):

606

if not(self.setNextFile()):

607

return 0

607

return 0

608

609

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

609

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

610

611

self.flagTimeBlock = 0

611

self.flagTimeBlock = 0

612

613

if deltaTime > self.maxTimeStep:

613

if deltaTime > self.maxTimeStep:

614

self.flagTimeBlock = 1

614

self.flagTimeBlock = 1

615

616

return 1

616

return 1

617

618

619

def readNextBlock(self):

619

def readNextBlock(self):

620

if not(self.__setNewBlock()):

620

if not(self.__setNewBlock()):

621

return 0

621

return 0

622

623

if not(self.readBlock()):

623

if not(self.readBlock()):

624

return 0

624

return 0

625

626

return 1

626

return 1

627

628

def __rdProcessingHeader(self, fp=None):

628

def __rdProcessingHeader(self, fp=None):

629

if fp == None:

629

if fp == None:

630

fp = self.fp

630

fp = self.fp

631

632

self.processingHeaderObj.read(fp)

632

self.processingHeaderObj.read(fp)

633

634

def __rdRadarControllerHeader(self, fp=None):

634

def __rdRadarControllerHeader(self, fp=None):

635

if fp == None:

635

if fp == None:

636

fp = self.fp

636

fp = self.fp

637

638

self.radarControllerHeaderObj.read(fp)

638

self.radarControllerHeaderObj.read(fp)

639

640

def __rdSystemHeader(self, fp=None):

640

def __rdSystemHeader(self, fp=None):

641

if fp == None:

641

if fp == None:

642

fp = self.fp

642

fp = self.fp

643

644

self.systemHeaderObj.read(fp)

644

self.systemHeaderObj.read(fp)

645

646

def __rdBasicHeader(self, fp=None):

646

def __rdBasicHeader(self, fp=None):

647

if fp == None:

647

if fp == None:

648

fp = self.fp

648

fp = self.fp

649

650

self.basicHeaderObj.read(fp)

650

self.basicHeaderObj.read(fp)

651

652

653

def __readFirstHeader(self):

653

def __readFirstHeader(self):

654

self.__rdBasicHeader()

654

self.__rdBasicHeader()

655

self.__rdSystemHeader()

655

self.__rdSystemHeader()

656

self.__rdRadarControllerHeader()

656

self.__rdRadarControllerHeader()

657

self.__rdProcessingHeader()

657

self.__rdProcessingHeader()

658

659

self.firstHeaderSize = self.basicHeaderObj.size

659

self.firstHeaderSize = self.basicHeaderObj.size

660

661

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

661

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

662

if datatype == 0:

662

if datatype == 0:

663

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

663

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

664

elif datatype == 1:

664

elif datatype == 1:

665

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

665

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

666

elif datatype == 2:

666

elif datatype == 2:

667

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

667

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

668

elif datatype == 3:

668

elif datatype == 3:

669

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

669

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

670

elif datatype == 4:

670

elif datatype == 4:

671

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

671

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

672

elif datatype == 5:

672

elif datatype == 5:

673

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

673

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

674

else:

674

else:

675

raise ValueError, 'Data type was not defined'

675

raise ValueError, 'Data type was not defined'

676

677

self.dtype = datatype_str

677

self.dtype = datatype_str

678

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

678

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

679

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

679

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

680

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

680

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

681

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

681

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

682

self.getBlockDimension()

682

self.getBlockDimension()

683

684

685

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

685

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

686

msg = None

686

msg = None

687

try:

687

try:

688

fp = open(filename, 'rb')

688

fp = open(filename, 'rb')

689

currentPosition = fp.tell()

689

currentPosition = fp.tell()

690

except:

690

except:

691

if msgFlag:

691

if msgFlag:

692

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

692

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

693

return False

693

return False

694

695

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

695

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

696

697

if neededSize == 0:

697

if neededSize == 0:

698

basicHeaderObj = BasicHeader()

698

basicHeaderObj = BasicHeader()

699

systemHeaderObj = SystemHeader()

699

systemHeaderObj = SystemHeader()

700

radarControllerHeaderObj = RadarControllerHeader()

700

radarControllerHeaderObj = RadarControllerHeader()

701

processingHeaderObj = ProcessingHeader()

701

processingHeaderObj = ProcessingHeader()

702

703

try:

703

try:

704

if not( basicHeaderObj.read(fp) ): raise ~~Value~~Error

704

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

705

if not( systemHeaderObj.read(fp) ): raise ~~Value~~Error

705

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

706

if not( radarControllerHeaderObj.read(fp) ): raise ~~Value~~Error

706

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

707

if not( processingHeaderObj.read(fp) ): raise ~~Value~~Error

707

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

708

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

708

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

709

710

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

710

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

711

712

except:

712

except:

713

if msgFlag:

713

if msgFlag:

714

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

714

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

715

716

fp.close()

716

fp.close()

717

return False

717

return False

718

else:

718

else:

719

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

719

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

720

721

fp.close()

721

fp.close()

722

fileSize = os.path.getsize(filename)

722

fileSize = os.path.getsize(filename)

723

currentSize = fileSize - currentPosition

723

currentSize = fileSize - currentPosition

724

if currentSize < neededSize:

724

if currentSize < neededSize:

725

if msgFlag and (msg != None):

725

if msgFlag and (msg != None):

726

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

726

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

727

return False

727

return False

728

729

return True

729

return True

730

731

def setup(self,

731

def setup(self,

732

path=None,

732

path=None,

733

startDate=None,

733

startDate=None,

734

endDate=None,

734

endDate=None,

735

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

735

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

736

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

736

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

737

set=0,

737

set=0,

738

expLabel = "",

738

expLabel = "",

739

ext = None,

739

ext = None,

740

online = False,

740

online = False,

741

delay = 60):

741

delay = 60):

742

743

if path == None:

743

if path == None:

744

raise ValueError, "The path is not valid"

744

raise ValueError, "The path is not valid"

745

746

if ext == None:

746

if ext == None:

747

ext = self.ext

747

ext = self.ext

748

749

if online:

749

if online:

750

print "Searching files in online mode..."

750

print "Searching files in online mode..."

751

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

751

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

752

753

if not(doypath):

753

if not(doypath):

754

for nTries in range( self.nTries ):

754

for nTries in range( self.nTries ):

755

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

755

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

756

time.sleep( self.delay )

756

time.sleep( self.delay )

757

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

757

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

758

if doypath:

758

if doypath:

759

break

759

break

760

761

if not(doypath):

761

if not(doypath):

762

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

762

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

763

return None

763

return None

764

765

self.year = year

765

self.year = year

766

self.doy = doy

766

self.doy = doy

767

self.set = set - 1

767

self.set = set - 1

768

self.path = path

768

self.path = path

769

770

else:

770

else:

771

print "Searching files in offline mode ..."

771

print "Searching files in offline mode ..."

772

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

772

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

773

774

if not(pathList):

774

if not(pathList):

775

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

775

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

776

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

776

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

777

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

777

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

778

779

sys.exit(-1)

779

sys.exit(-1)

780

781

782

self.fileIndex = -1

782

self.fileIndex = -1

783

self.pathList = pathList

783

self.pathList = pathList

784

self.filenameList = filenameList

784

self.filenameList = filenameList

785

786

self.online = online

786

self.online = online

787

self.delay = delay

787

self.delay = delay

788

ext = ext.lower()

788

ext = ext.lower()

789

self.ext = ext

789

self.ext = ext

790

791

if not(self.setNextFile()):

791

if not(self.setNextFile()):

792

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

792

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

793

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

793

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

794

elif startDate != None:

794

elif startDate != None:

795

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

795

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

796

else:

796

else:

797

print "No files"

797

print "No files"

798

799

sys.exit(-1)

799

sys.exit(-1)

800

801

# self.updateDataHeader()

801

# self.updateDataHeader()

802

803

return self.dataOut

803

return self.dataOut

804

805

def getData():

805

def getData():

806

807

raise ValueError, "This method has not been implemented"

807

raise ValueError, "This method has not been implemented"

808

809

def hasNotDataInBuffer():

809

def hasNotDataInBuffer():

810

811

raise ValueError, "This method has not been implemented"

811

raise ValueError, "This method has not been implemented"

812

813

def readBlock():

813

def readBlock():

814

815

raise ValueError, "This method has not been implemented"

815

raise ValueError, "This method has not been implemented"

816

817

def isEndProcess(self):

817

def isEndProcess(self):

818

819

return self.flagNoMoreFiles

819

return self.flagNoMoreFiles

820

821

def printReadBlocks(self):

821

def printReadBlocks(self):

822

823

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

823

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

824

825

def printTotalBlocks(self):

825

def printTotalBlocks(self):

826

827

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

827

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

828

829

def run(self, **kwargs):

829

def run(self, **kwargs):

830

831

if not(self.isConfig):

831

if not(self.isConfig):

832

833

# self.dataOut = dataOut

833

# self.dataOut = dataOut

834

self.setup(**kwargs)

834

self.setup(**kwargs)

835

self.isConfig = True

835

self.isConfig = True

836

837

self.getData()

837

self.getData()

838

839

class JRODataWriter(JRODataIO, Operation):

839

class JRODataWriter(JRODataIO, Operation):

840

841

"""

841

"""

842

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

842

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

843

de los datos siempre se realiza por bloques.

843

de los datos siempre se realiza por bloques.

844

"""

844

"""

845

846

blockIndex = 0

846

blockIndex = 0

847

848

path = None

848

path = None

849

850

setFile = None

850

setFile = None

851

852

profilesPerBlock = None

852

profilesPerBlock = None

853

854

blocksPerFile = None

854

blocksPerFile = None

855

856

nWriteBlocks = 0

856

nWriteBlocks = 0

857

858

def __init__(self, dataOut=None):

858

def __init__(self, dataOut=None):

859

raise ValueError, "Not implemented"

859

raise ValueError, "Not implemented"

860

861

862

def hasAllDataInBuffer(self):

862

def hasAllDataInBuffer(self):

863

raise ValueError, "Not implemented"

863

raise ValueError, "Not implemented"

864

865

866

def setBlockDimension(self):

866

def setBlockDimension(self):

867

raise ValueError, "Not implemented"

867

raise ValueError, "Not implemented"

868

869

870

def writeBlock(self):

870

def writeBlock(self):

871

raise ValueError, "No implemented"

871

raise ValueError, "No implemented"

872

873

874

def putData(self):

874

def putData(self):

875

raise ValueError, "No implemented"

875

raise ValueError, "No implemented"

876

877

def getDataHeader(self):

877

def getDataHeader(self):

878

"""

878

"""

879

Obtiene una copia del First Header

879

Obtiene una copia del First Header

880

881

Affected:

881

Affected:

882

883

self.basicHeaderObj

883

self.basicHeaderObj

884

self.systemHeaderObj

884

self.systemHeaderObj

885

self.radarControllerHeaderObj

885

self.radarControllerHeaderObj

886

self.processingHeaderObj self.

886

self.processingHeaderObj self.

887

888

Return:

888

Return:

889

None

889

None

890

"""

890

"""

891

892

raise ValueError, "No implemented"

892

raise ValueError, "No implemented"

893

894

def getBasicHeader(self):

894

def getBasicHeader(self):

895

896

self.basicHeaderObj.size = self.basicHeaderSize #bytes

896

self.basicHeaderObj.size = self.basicHeaderSize #bytes

897

self.basicHeaderObj.version = self.versionFile

897

self.basicHeaderObj.version = self.versionFile

898

self.basicHeaderObj.dataBlock = self.nTotalBlocks

898

self.basicHeaderObj.dataBlock = self.nTotalBlocks

899

900

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

900

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

901

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

901

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

902

903

self.basicHeaderObj.utc = utc

903

self.basicHeaderObj.utc = utc

904

self.basicHeaderObj.miliSecond = milisecond

904

self.basicHeaderObj.miliSecond = milisecond

905

self.basicHeaderObj.timeZone = 0

905

self.basicHeaderObj.timeZone = 0

906

self.basicHeaderObj.dstFlag = 0

906

self.basicHeaderObj.dstFlag = 0

907

self.basicHeaderObj.errorCount = 0

907

self.basicHeaderObj.errorCount = 0

908

909

def __writeFirstHeader(self):

909

def __writeFirstHeader(self):

910

"""

910

"""

911

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

911

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

912

913

Affected:

913

Affected:

914

__dataType

914

__dataType

915

916

Return:

916

Return:

917

None

917

None

918

"""

918

"""

919

920

# CALCULAR PARAMETROS

920

# CALCULAR PARAMETROS

921

922

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

922

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

923

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

923

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

924

925

self.basicHeaderObj.write(self.fp)

925

self.basicHeaderObj.write(self.fp)

926

self.systemHeaderObj.write(self.fp)

926

self.systemHeaderObj.write(self.fp)

927

self.radarControllerHeaderObj.write(self.fp)

927

self.radarControllerHeaderObj.write(self.fp)

928

self.processingHeaderObj.write(self.fp)

928

self.processingHeaderObj.write(self.fp)

929

930

self.dtype = self.dataOut.dtype

930

self.dtype = self.dataOut.dtype

931

932

def __setNewBlock(self):

932

def __setNewBlock(self):

933

"""

933

"""

934

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

934

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

935

936

Return:

936

Return:

937

0 : si no pudo escribir nada

937

0 : si no pudo escribir nada

938

1 : Si escribio el Basic el First Header

938

1 : Si escribio el Basic el First Header

939

"""

939

"""

940

if self.fp == None:

940

if self.fp == None:

941

self.setNextFile()

941

self.setNextFile()

942

943

if self.flagIsNewFile:

943

if self.flagIsNewFile:

944

return 1

944

return 1

945

946

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

946

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

947

self.basicHeaderObj.write(self.fp)

947

self.basicHeaderObj.write(self.fp)

948

return 1

948

return 1

949

950

if not( self.setNextFile() ):

950

if not( self.setNextFile() ):

951

return 0

951

return 0

952

953

return 1

953

return 1

954

955

956

def writeNextBlock(self):

956

def writeNextBlock(self):

957

"""

957

"""

958

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

958

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

959

960

Return:

960

Return:

961

0 : Si no hizo pudo escribir el bloque de datos

961

0 : Si no hizo pudo escribir el bloque de datos

962

1 : Si no pudo escribir el bloque de datos

962

1 : Si no pudo escribir el bloque de datos

963

"""

963

"""

964

if not( self.__setNewBlock() ):

964

if not( self.__setNewBlock() ):

965

return 0

965

return 0

966

967

self.writeBlock()

967

self.writeBlock()

968

969

return 1

969

return 1

970

971

def setNextFile(self):

971

def setNextFile(self):

972

"""

972

"""

973

Determina el siguiente file que sera escrito

973

Determina el siguiente file que sera escrito

974

975

Affected:

975

Affected:

976

self.filename

976

self.filename

977

self.subfolder

977

self.subfolder

978

self.fp

978

self.fp

979

self.setFile

979

self.setFile

980

self.flagIsNewFile

980

self.flagIsNewFile

981

982

Return:

982

Return:

983

0 : Si el archivo no puede ser escrito

983

0 : Si el archivo no puede ser escrito

984

1 : Si el archivo esta listo para ser escrito

984

1 : Si el archivo esta listo para ser escrito

985

"""

985

"""

986

ext = self.ext

986

ext = self.ext

987

path = self.path

987

path = self.path

988

989

if self.fp != None:

989

if self.fp != None:

990

self.fp.close()

990

self.fp.close()

991

992

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

992

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

993

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

993

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

994

995

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

995

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

996

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

996

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

997

os.mkdir(doypath)

997

os.mkdir(doypath)

998

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

998

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

999

else:

999

else:

1000

filesList = os.listdir( doypath )

1000

filesList = os.listdir( doypath )

1001

if len( filesList ) > 0:

1001

if len( filesList ) > 0:

1002

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

1002

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

1003

filen = filesList[-1]

1003

filen = filesList[-1]

1004

# el filename debera tener el siguiente formato

1004

# el filename debera tener el siguiente formato

1005

# 0 1234 567 89A BCDE (hex)

1005

# 0 1234 567 89A BCDE (hex)

1006

# x YYYY DDD SSS .ext

1006

# x YYYY DDD SSS .ext

1007

if isNumber( filen[8:11] ):

1007

if isNumber( filen[8:11] ):

1008

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

1008

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

1009

else:

1009

else:

1010

self.setFile = -1

1010

self.setFile = -1

1011

else:

1011

else:

1012

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

1012

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

1013

1014

setFile = self.setFile

1014

setFile = self.setFile

1015

setFile += 1

1015

setFile += 1

1016

1017

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

1017

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

1018

timeTuple.tm_year,

1018

timeTuple.tm_year,

1019

timeTuple.tm_yday,

1019

timeTuple.tm_yday,

1020

setFile,

1020

setFile,

1021

ext )

1021

ext )

1022

1023

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

1023

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

1024

1025

fp = open( filename,'wb' )

1025

fp = open( filename,'wb' )

1026

1027

self.blockIndex = 0

1027

self.blockIndex = 0

1028

1029

#guardando atributos

1029

#guardando atributos

1030

self.filename = filename

1030

self.filename = filename

1031

self.subfolder = subfolder

1031

self.subfolder = subfolder

1032

self.fp = fp

1032

self.fp = fp

1033

self.setFile = setFile

1033

self.setFile = setFile

1034

self.flagIsNewFile = 1

1034

self.flagIsNewFile = 1

1035

1036

self.getDataHeader()

1036

self.getDataHeader()

1037

1038

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

1038

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

1039

1040

self.__writeFirstHeader()

1040

self.__writeFirstHeader()

1041

1042

return 1

1042

return 1

1043

1044

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

1044

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

1045

"""

1045

"""

1046

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

1046

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

1047

1048

Inputs:

1048

Inputs:

1049

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

1049

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

1050

format : formato en el cual sera salvado un file

1050

format : formato en el cual sera salvado un file

1051

set : el setebo del file

1051

set : el setebo del file

1052

1053

Return:

1053

Return:

1054

0 : Si no realizo un buen seteo

1054

0 : Si no realizo un buen seteo

1055

1 : Si realizo un buen seteo

1055

1 : Si realizo un buen seteo

1056

"""

1056

"""

1057

1058

if ext == None:

1058

if ext == None:

1059

ext = self.ext

1059

ext = self.ext

1060

1061

ext = ext.lower()

1061

ext = ext.lower()

1062

1063

self.ext = ext

1063

self.ext = ext

1064

1065

self.path = path

1065

self.path = path

1066

1067

self.setFile = set - 1

1067

self.setFile = set - 1

1068

1069

self.blocksPerFile = blocksPerFile

1069

self.blocksPerFile = blocksPerFile

1070

1071

self.profilesPerBlock = profilesPerBlock

1071

self.profilesPerBlock = profilesPerBlock

1072

1073

self.dataOut = dataOut

1073

self.dataOut = dataOut

1074

1075

if not(self.setNextFile()):

1075

if not(self.setNextFile()):

1076

print "There isn't a next file"

1076

print "There isn't a next file"

1077

return 0

1077

return 0

1078

1079

self.setBlockDimension()

1079

self.setBlockDimension()

1080

1081

return 1

1081

return 1

1082

1083

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

1083

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

1084

1085

if not(self.isConfig):

1085

if not(self.isConfig):

1086

1087

self.setup(dataOut, **kwargs)

1087

self.setup(dataOut, **kwargs)

1088

self.isConfig = True

1088

self.isConfig = True

1089

1090

self.putData()

1090

self.putData()

1091

1092

class VoltageReader(JRODataReader):

1092

class VoltageReader(JRODataReader):

1093

"""

1093

"""

1094

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

1094

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

1095

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

1095

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

1096

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

1096

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

1097

1098

perfiles * alturas * canales

1098

perfiles * alturas * canales

1099

1100

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

1100

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

1101

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

1101

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

1102

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

1102

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

1103

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

1103

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

1104

1105

Example:

1105

Example:

1106

1107

dpath = "/home/myuser/data"

1107

dpath = "/home/myuser/data"

1108

1109

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

1109

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

1110

1111

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

1111

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

1112

1113

readerObj = VoltageReader()

1113

readerObj = VoltageReader()

1114

1115

readerObj.setup(dpath, startTime, endTime)

1115

readerObj.setup(dpath, startTime, endTime)

1116

1117

while(True):

1117

while(True):

1118

1119

#to get one profile

1119

#to get one profile

1120

profile = readerObj.getData()

1120

profile = readerObj.getData()

1121

1122

#print the profile

1122

#print the profile

1123

print profile

1123

print profile

1124

1125

#If you want to see all datablock

1125

#If you want to see all datablock

1126

print readerObj.datablock

1126

print readerObj.datablock

1127

1128

if readerObj.flagNoMoreFiles:

1128

if readerObj.flagNoMoreFiles:

1129

break

1129

break

1130

1131

"""

1131

"""

1132

1133

ext = ".r"

1133

ext = ".r"

1134

1135

optchar = "D"

1135

optchar = "D"

1136

dataOut = None

1136

dataOut = None

1137

1138

1139

def __init__(self):

1139

def __init__(self):

1140

"""

1140

"""

1141

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

1141

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

1142

1143

Input:

1143

Input:

1144

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

1144

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

1145

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

1145

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

1146

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

1146

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

1147

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

1147

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

1148

bloque de datos.

1148

bloque de datos.

1149

Si este parametro no es pasado se creara uno internamente.

1149

Si este parametro no es pasado se creara uno internamente.

1150

1151

Variables afectadas:

1151

Variables afectadas:

1152

self.dataOut

1152

self.dataOut

1153

1154

Return:

1154

Return:

1155

None

1155

None

1156

"""

1156

"""

1157

1158

self.isConfig = False

1158

self.isConfig = False

1159

1160

self.datablock = None

1160

self.datablock = None

1161

1162

self.utc = 0

1162

self.utc = 0

1163

1164

self.ext = ".r"

1164

self.ext = ".r"

1165

1166

self.optchar = "D"

1166

self.optchar = "D"

1167

1168

self.basicHeaderObj = BasicHeader()

1168

self.basicHeaderObj = BasicHeader()

1169

1170

self.systemHeaderObj = SystemHeader()

1170

self.systemHeaderObj = SystemHeader()

1171

1172

self.radarControllerHeaderObj = RadarControllerHeader()

1172

self.radarControllerHeaderObj = RadarControllerHeader()

1173

1174

self.processingHeaderObj = ProcessingHeader()

1174

self.processingHeaderObj = ProcessingHeader()

1175

1176

self.online = 0

1176

self.online = 0

1177

1178

self.fp = None

1178

self.fp = None

1179

1180

self.idFile = None

1180

self.idFile = None

1181

1182

self.dtype = None

1182

self.dtype = None

1183

1184

self.fileSizeByHeader = None

1184

self.fileSizeByHeader = None

1185

1186

self.filenameList = []

1186

self.filenameList = []

1187

1188

self.filename = None

1188

self.filename = None

1189

1190

self.fileSize = None

1190

self.fileSize = None

1191

1192

self.firstHeaderSize = 0

1192

self.firstHeaderSize = 0

1193

1194

self.basicHeaderSize = 24

1194

self.basicHeaderSize = 24

1195

1196

self.pathList = []

1196

self.pathList = []

1197

1198

self.filenameList = []

1198

self.filenameList = []

1199

1200

self.lastUTTime = 0

1200

self.lastUTTime = 0

1201

1202

self.maxTimeStep = 30

1202

self.maxTimeStep = 30

1203

1204

self.flagNoMoreFiles = 0

1204

self.flagNoMoreFiles = 0

1205

1206

self.set = 0

1206

self.set = 0

1207

1208

self.path = None

1208

self.path = None

1209

1210

self.profileIndex = 9999

1210

self.profileIndex = 9999

1211

1212

self.delay = 3 #seconds

1212

self.delay = 3 #seconds

1213

1214

self.nTries = 3 #quantity tries

1214

self.nTries = 3 #quantity tries

1215

1216

self.nFiles = 3 #number of files for searching

1216

self.nFiles = 3 #number of files for searching

1217

1218

self.nReadBlocks = 0

1218

self.nReadBlocks = 0

1219

1220

self.flagIsNewFile = 1

1220

self.flagIsNewFile = 1

1221

1222

self.ippSeconds = 0

1222

self.ippSeconds = 0

1223

1224

self.flagTimeBlock = 0

1224

self.flagTimeBlock = 0

1225

1226

self.flagIsNewBlock = 0

1226

self.flagIsNewBlock = 0

1227

1228

self.nTotalBlocks = 0

1228

self.nTotalBlocks = 0

1229

1230

self.blocksize = 0

1230

self.blocksize = 0

1231

1232

self.dataOut = self.createObjByDefault()

1232

self.dataOut = self.createObjByDefault()

1233

1234

def createObjByDefault(self):

1234

def createObjByDefault(self):

1235

1236

dataObj = Voltage()

1236

dataObj = Voltage()

1237

1238

return dataObj

1238

return dataObj

1239

1240

def __hasNotDataInBuffer(self):

1240

def __hasNotDataInBuffer(self):

1241

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

1241

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

1242

return 1

1242

return 1

1243

return 0

1243

return 0

1244

1245

1246

def getBlockDimension(self):

1246

def getBlockDimension(self):

1247

"""

1247

"""

1248

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

1248

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

1249

1250

Affected:

1250

Affected:

1251

self.blocksize

1251

self.blocksize

1252

1253

Return:

1253

Return:

1254

None

1254

None

1255

"""

1255

"""

1256

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

1256

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

1257

self.blocksize = pts2read

1257

self.blocksize = pts2read

1258

1259

1260

def readBlock(self):

1260

def readBlock(self):

1261

"""

1261

"""

1262

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

1262

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

1263

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

1263

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

1264

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

1264

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

1265

es seteado a 0

1265

es seteado a 0

1266

1267

Inputs:

1267

Inputs:

1268

None

1268

None

1269

1270

Return:

1270

Return:

1271

None

1271

None

1272

1273

Affected:

1273

Affected:

1274

self.profileIndex

1274

self.profileIndex

1275

self.datablock

1275

self.datablock

1276

self.flagIsNewFile

1276

self.flagIsNewFile

1277

self.flagIsNewBlock

1277

self.flagIsNewBlock

1278

self.nTotalBlocks

1278

self.nTotalBlocks

1279

1280

Exceptions:

1280

Exceptions:

1281

Si un bloque leido no es un bloque valido

1281

Si un bloque leido no es un bloque valido

1282

"""

1282

"""

1283

1284

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

1284

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

1285

1286

try:

1286

try:

1287

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

1287

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

1288

except:

1288

except:

1289

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

1289

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

1290

return 0

1290

return 0

1291

1292

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

1292

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

1293

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

1293

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

1294

1295

self.profileIndex = 0

1295

self.profileIndex = 0

1296

1297

self.flagIsNewFile = 0

1297

self.flagIsNewFile = 0

1298

self.flagIsNewBlock = 1

1298

self.flagIsNewBlock = 1

1299

1300

self.nTotalBlocks += 1

1300

self.nTotalBlocks += 1

1301

self.nReadBlocks += 1

1301

self.nReadBlocks += 1

1302

1303

return 1

1303

return 1

1304

1305

1306

def getData(self):

1306

def getData(self):

1307

"""

1307

"""

1308

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

1308

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

1309

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

1309

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

1310

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

1310

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

1311

1312

Ademas incrementa el contador del buffer en 1.

1312

Ademas incrementa el contador del buffer en 1.

1313

1314

Return:

1314

Return:

1315

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

1315

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

1316

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

1316

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

1317

1318

Variables afectadas:

1318

Variables afectadas:

1319

self.dataOut

1319

self.dataOut

1320

self.profileIndex

1320

self.profileIndex

1321

1322

Affected:

1322

Affected:

1323

self.dataOut

1323

self.dataOut

1324

self.profileIndex

1324

self.profileIndex

1325

self.flagTimeBlock

1325

self.flagTimeBlock

1326

self.flagIsNewBlock

1326

self.flagIsNewBlock

1327

"""

1327

"""

1328

1329

if self.flagNoMoreFiles:

1329

if self.flagNoMoreFiles:

1330

self.dataOut.flagNoData = True

1330

self.dataOut.flagNoData = True

1331

print 'Process finished'

1331

print 'Process finished'

1332

return 0

1332

return 0

1333

1334

self.flagTimeBlock = 0

1334

self.flagTimeBlock = 0

1335

self.flagIsNewBlock = 0

1335

self.flagIsNewBlock = 0

1336

1337

if self.__hasNotDataInBuffer():

1337

if self.__hasNotDataInBuffer():

1338

1339

if not( self.readNextBlock() ):

1339

if not( self.readNextBlock() ):

1340

return 0

1340

return 0

1341

1342

# self.updateDataHeader()

1342

# self.updateDataHeader()

1343

1344

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

1344

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

1345

1346

if self.datablock == None:

1346

if self.datablock == None:

1347

self.dataOut.flagNoData = True

1347

self.dataOut.flagNoData = True

1348

return 0

1348

return 0

1349

1350

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

1350

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

1351

1352

self.dataOut.dtype = self.dtype

1352

self.dataOut.dtype = self.dtype

1353

1354

# self.dataOut.nChannels = self.systemHeaderObj.nChannels

1354

# self.dataOut.nChannels = self.systemHeaderObj.nChannels

1355

1356

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

1356

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

1357

1358

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1358

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1359

1360

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

1360

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

1361

1362

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

1362

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

1363

1364

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

1364

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

1365

1366

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

1366

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

1367

1368

self.dataOut.flagTimeBlock = self.flagTimeBlock

1368

self.dataOut.flagTimeBlock = self.flagTimeBlock

1369

1370

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

1370

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

1371

1372

self.dataOut.ippSeconds = self.ippSeconds

1372

self.dataOut.ippSeconds = self.ippSeconds

1373

1374

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

1374

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

1375

1376

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1376

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1377

1378

self.dataOut.flagShiftFFT = False

1378

self.dataOut.flagShiftFFT = False

1379

1380

if self.processingHeaderObj.code != None:

1380

if self.processingHeaderObj.code != None:

1381

self.dataOut.nCode = self.processingHeaderObj.nCode

1381

self.dataOut.nCode = self.processingHeaderObj.nCode

1382

1383

self.dataOut.nBaud = self.processingHeaderObj.nBaud

1383

self.dataOut.nBaud = self.processingHeaderObj.nBaud

1384

1385

self.dataOut.code = self.processingHeaderObj.code

1385

self.dataOut.code = self.processingHeaderObj.code

1386

1387

self.profileIndex += 1

1387

self.profileIndex += 1

1388

1389

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

1389

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

1390

1391

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

1391

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

1392

1393

self.dataOut.flagNoData = False

1393

self.dataOut.flagNoData = False

1394

1395

# print self.profileIndex, self.dataOut.utctime

1395

# print self.profileIndex, self.dataOut.utctime

1396

# if self.profileIndex == 800:

1396

# if self.profileIndex == 800:

1397

# a=1

1397

# a=1

1398

1399

return self.dataOut.data

1399

return self.dataOut.data

1400

1401

1402

class VoltageWriter(JRODataWriter):

1402

class VoltageWriter(JRODataWriter):

1403

"""

1403

"""

1404

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

1404

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

1405

de los datos siempre se realiza por bloques.

1405

de los datos siempre se realiza por bloques.

1406

"""

1406

"""

1407

1408

ext = ".r"

1408

ext = ".r"

1409

1410

optchar = "D"

1410

optchar = "D"

1411

1412

shapeBuffer = None

1412

shapeBuffer = None

1413

1414

1415

def __init__(self):

1415

def __init__(self):

1416

"""

1416

"""

1417

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

1417

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

1418

1419

Affected:

1419

Affected:

1420

self.dataOut

1420

self.dataOut

1421

1422

Return: None

1422

Return: None

1423

"""

1423

"""

1424

1425

self.nTotalBlocks = 0

1425

self.nTotalBlocks = 0

1426

1427

self.profileIndex = 0

1427

self.profileIndex = 0

1428

1429

self.isConfig = False

1429

self.isConfig = False

1430

1431

self.fp = None

1431

self.fp = None

1432

1433

self.flagIsNewFile = 1

1433

self.flagIsNewFile = 1

1434

1435

self.nTotalBlocks = 0

1435

self.nTotalBlocks = 0

1436

1437

self.flagIsNewBlock = 0

1437

self.flagIsNewBlock = 0

1438

1439

self.setFile = None

1439

self.setFile = None

1440

1441

self.dtype = None

1441

self.dtype = None

1442

1443

self.path = None

1443

self.path = None

1444

1445

self.filename = None

1445

self.filename = None

1446

1447

self.basicHeaderObj = BasicHeader()

1447

self.basicHeaderObj = BasicHeader()

1448

1449

self.systemHeaderObj = SystemHeader()

1449

self.systemHeaderObj = SystemHeader()

1450

1451

self.radarControllerHeaderObj = RadarControllerHeader()

1451

self.radarControllerHeaderObj = RadarControllerHeader()

1452

1453

self.processingHeaderObj = ProcessingHeader()

1453

self.processingHeaderObj = ProcessingHeader()

1454

1455

def hasAllDataInBuffer(self):

1455

def hasAllDataInBuffer(self):

1456

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

1456

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

1457

return 1

1457

return 1

1458

return 0

1458

return 0

1459

1460

1461

def setBlockDimension(self):

1461

def setBlockDimension(self):

1462

"""

1462

"""

1463

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

1463

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

1464

1465

Affected:

1465

Affected:

1466

self.shape_spc_Buffer

1466

self.shape_spc_Buffer

1467

self.shape_cspc_Buffer

1467

self.shape_cspc_Buffer

1468

self.shape_dc_Buffer

1468

self.shape_dc_Buffer

1469

1470

Return: None

1470

Return: None

1471

"""

1471

"""

1472

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1472

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1473

self.processingHeaderObj.nHeights,

1473

self.processingHeaderObj.nHeights,

1474

self.systemHeaderObj.nChannels)

1474

self.systemHeaderObj.nChannels)

1475

1476

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

1476

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

1477

self.processingHeaderObj.profilesPerBlock,

1477

self.processingHeaderObj.profilesPerBlock,

1478

self.processingHeaderObj.nHeights),

1478

self.processingHeaderObj.nHeights),

1479

dtype=numpy.dtype('complex'))

1479

dtype=numpy.dtype('complex'))

1480

1481

1482

def writeBlock(self):

1482

def writeBlock(self):

1483

"""

1483

"""

1484

Escribe el buffer en el file designado

1484

Escribe el buffer en el file designado

1485

1486

Affected:

1486

Affected:

1487

self.profileIndex

1487

self.profileIndex

1488

self.flagIsNewFile

1488

self.flagIsNewFile

1489

self.flagIsNewBlock

1489

self.flagIsNewBlock

1490

self.nTotalBlocks

1490

self.nTotalBlocks

1491

self.blockIndex

1491

self.blockIndex

1492

1493

Return: None

1493

Return: None

1494

"""

1494

"""

1495

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

1495

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

1496

1497

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

1497

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

1498

1499

data['real'] = junk.real

1499

data['real'] = junk.real

1500

data['imag'] = junk.imag

1500

data['imag'] = junk.imag

1501

1502

data = data.reshape( (-1) )

1502

data = data.reshape( (-1) )

1503

1504

data.tofile( self.fp )

1504

data.tofile( self.fp )

1505

1506

self.datablock.fill(0)

1506

self.datablock.fill(0)

1507

1508

self.profileIndex = 0

1508

self.profileIndex = 0

1509

self.flagIsNewFile = 0

1509

self.flagIsNewFile = 0

1510

self.flagIsNewBlock = 1

1510

self.flagIsNewBlock = 1

1511

1512

self.blockIndex += 1

1512

self.blockIndex += 1

1513

self.nTotalBlocks += 1

1513

self.nTotalBlocks += 1

1514

1515

def putData(self):

1515

def putData(self):

1516

"""

1516

"""

1517

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

1517

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

1518

1519

Affected:

1519

Affected:

1520

self.flagIsNewBlock

1520

self.flagIsNewBlock

1521

self.profileIndex

1521

self.profileIndex

1522

1523

Return:

1523

Return:

1524

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

1524

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

1525

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

1525

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

1526

"""

1526

"""

1527

if self.dataOut.flagNoData:

1527

if self.dataOut.flagNoData:

1528

return 0

1528

return 0

1529

1530

self.flagIsNewBlock = 0

1530

self.flagIsNewBlock = 0

1531

1532

if self.dataOut.flagTimeBlock:

1532

if self.dataOut.flagTimeBlock:

1533

1534

self.datablock.fill(0)

1534

self.datablock.fill(0)

1535

self.profileIndex = 0

1535

self.profileIndex = 0

1536

self.setNextFile()

1536

self.setNextFile()

1537

1538

if self.profileIndex == 0:

1538

if self.profileIndex == 0:

1539

self.getBasicHeader()

1539

self.getBasicHeader()

1540

1541

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

1541

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

1542

1543

self.profileIndex += 1

1543

self.profileIndex += 1

1544

1545

if self.hasAllDataInBuffer():

1545

if self.hasAllDataInBuffer():

1546

#if self.flagIsNewFile:

1546

#if self.flagIsNewFile:

1547

self.writeNextBlock()

1547

self.writeNextBlock()

1548

# self.getDataHeader()

1548

# self.getDataHeader()

1549

1550

return 1

1550

return 1

1551

1552

def __getProcessFlags(self):

1552

def __getProcessFlags(self):

1553

1554

processFlags = 0

1554

processFlags = 0

1555

1556

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

1556

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

1557

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

1557

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

1558

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

1558

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

1559

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

1559

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

1560

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

1560

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

1561

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

1561

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

1562

1563

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

1563

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

1564

1565

1566

1567

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1567

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1568

PROCFLAG.DATATYPE_SHORT,

1568

PROCFLAG.DATATYPE_SHORT,

1569

PROCFLAG.DATATYPE_LONG,

1569

PROCFLAG.DATATYPE_LONG,

1570

PROCFLAG.DATATYPE_INT64,

1570

PROCFLAG.DATATYPE_INT64,

1571

PROCFLAG.DATATYPE_FLOAT,

1571

PROCFLAG.DATATYPE_FLOAT,

1572

PROCFLAG.DATATYPE_DOUBLE]

1572

PROCFLAG.DATATYPE_DOUBLE]

1573

1574

1575

for index in range(len(dtypeList)):

1575

for index in range(len(dtypeList)):

1576

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

1576

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

1577

dtypeValue = datatypeValueList[index]

1577

dtypeValue = datatypeValueList[index]

1578

break

1578

break

1579

1580

processFlags += dtypeValue

1580

processFlags += dtypeValue

1581

1582

if self.dataOut.flagDecodeData:

1582

if self.dataOut.flagDecodeData:

1583

processFlags += PROCFLAG.DECODE_DATA

1583

processFlags += PROCFLAG.DECODE_DATA

1584

1585

if self.dataOut.flagDeflipData:

1585

if self.dataOut.flagDeflipData:

1586

processFlags += PROCFLAG.DEFLIP_DATA

1586

processFlags += PROCFLAG.DEFLIP_DATA

1587

1588

if self.dataOut.code != None:

1588

if self.dataOut.code != None:

1589

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1589

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1590

1591

if self.dataOut.nCohInt > 1:

1591

if self.dataOut.nCohInt > 1:

1592

processFlags += PROCFLAG.COHERENT_INTEGRATION

1592

processFlags += PROCFLAG.COHERENT_INTEGRATION

1593

1594

return processFlags

1594

return processFlags

1595

1596

1597

def __getBlockSize(self):

1597

def __getBlockSize(self):

1598

'''

1598

'''

1599

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

1599

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

1600

'''

1600

'''

1601

1602

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

1602

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

1603

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

1603

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

1604

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

1604

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

1605

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

1605

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

1606

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

1606

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

1607

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

1607

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

1608

1609

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

1609

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

1610

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

1610

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

1611

for index in range(len(dtypeList)):

1611

for index in range(len(dtypeList)):

1612

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

1612

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

1613

datatypeValue = datatypeValueList[index]

1613

datatypeValue = datatypeValueList[index]

1614

break

1614

break

1615

1616

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

1616

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

1617

1618

return blocksize

1618

return blocksize

1619

1620

def getDataHeader(self):

1620

def getDataHeader(self):

1621

1622

"""

1622

"""

1623

Obtiene una copia del First Header

1623

Obtiene una copia del First Header

1624

1625

Affected:

1625

Affected:

1626

self.systemHeaderObj

1626

self.systemHeaderObj

1627

self.radarControllerHeaderObj

1627

self.radarControllerHeaderObj

1628

self.dtype

1628

self.dtype

1629

1630

Return:

1630

Return:

1631

None

1631

None

1632

"""

1632

"""

1633

1634

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

1634

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

1635

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1635

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1636

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

1636

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

1637

1638

self.getBasicHeader()

1638

self.getBasicHeader()

1639

1640

processingHeaderSize = 40 # bytes

1640

processingHeaderSize = 40 # bytes

1641

self.processingHeaderObj.dtype = 0 # Voltage

1641

self.processingHeaderObj.dtype = 0 # Voltage

1642

self.processingHeaderObj.blockSize = self.__getBlockSize()

1642

self.processingHeaderObj.blockSize = self.__getBlockSize()

1643

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1643

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1644

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1644

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1645

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

1645

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

1646

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1646

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1647

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1647

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1648

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

1648

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

1649

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

1649

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

1650

1651

if self.dataOut.code != None:

1651

if self.dataOut.code != None:

1652

self.processingHeaderObj.code = self.dataOut.code

1652

self.processingHeaderObj.code = self.dataOut.code

1653

self.processingHeaderObj.nCode = self.dataOut.nCode

1653

self.processingHeaderObj.nCode = self.dataOut.nCode

1654

self.processingHeaderObj.nBaud = self.dataOut.nBaud

1654

self.processingHeaderObj.nBaud = self.dataOut.nBaud

1655

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

1655

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

1656

processingHeaderSize += codesize

1656

processingHeaderSize += codesize

1657

1658

if self.processingHeaderObj.nWindows != 0:

1658

if self.processingHeaderObj.nWindows != 0:

1659

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

1659

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

1660

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

1660

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

1661

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1661

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1662

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1662

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1663

processingHeaderSize += 12

1663

processingHeaderSize += 12

1664

1665

self.processingHeaderObj.size = processingHeaderSize

1665

self.processingHeaderObj.size = processingHeaderSize

1666

1667

class SpectraReader(JRODataReader):

1667

class SpectraReader(JRODataReader):

1668

"""

1668

"""

1669

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

1669

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

1670

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

1670

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

1671

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

1671

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

1672

1673

paresCanalesIguales * alturas * perfiles (Self Spectra)

1673

paresCanalesIguales * alturas * perfiles (Self Spectra)

1674

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1674

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1675

canales * alturas (DC Channels)

1675

canales * alturas (DC Channels)

1676

1677

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

1677

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

1678

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

1678

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

1679

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

1679

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

1680

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

1680

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

1681

1682

Example:

1682

Example:

1683

dpath = "/home/myuser/data"

1683

dpath = "/home/myuser/data"

1684

1685

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

1685

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

1686

1687

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

1687

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

1688

1689

readerObj = SpectraReader()

1689

readerObj = SpectraReader()

1690

1691

readerObj.setup(dpath, startTime, endTime)

1691

readerObj.setup(dpath, startTime, endTime)

1692

1693

while(True):

1693

while(True):

1694

1695

readerObj.getData()

1695

readerObj.getData()

1696

1697

print readerObj.data_spc

1697

print readerObj.data_spc

1698

1699

print readerObj.data_cspc

1699

print readerObj.data_cspc

1700

1701

print readerObj.data_dc

1701

print readerObj.data_dc

1702

1703

if readerObj.flagNoMoreFiles:

1703

if readerObj.flagNoMoreFiles:

1704

break

1704

break

1705

1706

"""

1706

"""

1707

1708

pts2read_SelfSpectra = 0

1708

pts2read_SelfSpectra = 0

1709

1710

pts2read_CrossSpectra = 0

1710

pts2read_CrossSpectra = 0

1711

1712

pts2read_DCchannels = 0

1712

pts2read_DCchannels = 0

1713

1714

ext = ".pdata"

1714

ext = ".pdata"

1715

1716

optchar = "P"

1716

optchar = "P"

1717

1718

dataOut = None

1718

dataOut = None

1719

1720

nRdChannels = None

1720

nRdChannels = None

1721

1722

nRdPairs = None

1722

nRdPairs = None

1723

1724

rdPairList = []

1724

rdPairList = []

1725

1726

1727

def __init__(self):

1727

def __init__(self):

1728

"""

1728

"""

1729

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

1729

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

1730

1731

Inputs:

1731

Inputs:

1732

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

1732

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

1733

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

1733

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

1734

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

1734

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

1735

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

1735

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

1736

bloque de datos.

1736

bloque de datos.

1737

Si este parametro no es pasado se creara uno internamente.

1737

Si este parametro no es pasado se creara uno internamente.

1738

1739

Affected:

1739

Affected:

1740

self.dataOut

1740

self.dataOut

1741

1742

Return : None

1742

Return : None

1743

"""

1743

"""

1744

1745

self.isConfig = False

1745

self.isConfig = False

1746

1747

self.pts2read_SelfSpectra = 0

1747

self.pts2read_SelfSpectra = 0

1748

1749

self.pts2read_CrossSpectra = 0

1749

self.pts2read_CrossSpectra = 0

1750

1751

self.pts2read_DCchannels = 0

1751

self.pts2read_DCchannels = 0

1752

1753

self.datablock = None

1753

self.datablock = None

1754

1755

self.utc = None

1755

self.utc = None

1756

1757

self.ext = ".pdata"

1757

self.ext = ".pdata"

1758

1759

self.optchar = "P"

1759

self.optchar = "P"

1760

1761

self.basicHeaderObj = BasicHeader()

1761

self.basicHeaderObj = BasicHeader()

1762

1763

self.systemHeaderObj = SystemHeader()

1763

self.systemHeaderObj = SystemHeader()

1764

1765

self.radarControllerHeaderObj = RadarControllerHeader()

1765

self.radarControllerHeaderObj = RadarControllerHeader()

1766

1767

self.processingHeaderObj = ProcessingHeader()

1767

self.processingHeaderObj = ProcessingHeader()

1768

1769

self.online = 0

1769

self.online = 0

1770

1771

self.fp = None

1771

self.fp = None

1772

1773

self.idFile = None

1773

self.idFile = None

1774

1775

self.dtype = None

1775

self.dtype = None

1776

1777

self.fileSizeByHeader = None

1777

self.fileSizeByHeader = None

1778

1779

self.filenameList = []

1779

self.filenameList = []

1780

1781

self.filename = None

1781

self.filename = None

1782

1783

self.fileSize = None

1783

self.fileSize = None

1784

1785

self.firstHeaderSize = 0

1785

self.firstHeaderSize = 0

1786

1787

self.basicHeaderSize = 24

1787

self.basicHeaderSize = 24

1788

1789

self.pathList = []

1789

self.pathList = []

1790

1791

self.lastUTTime = 0

1791

self.lastUTTime = 0

1792

1793

self.maxTimeStep = 30

1793

self.maxTimeStep = 30

1794

1795

self.flagNoMoreFiles = 0

1795

self.flagNoMoreFiles = 0

1796

1797

self.set = 0

1797

self.set = 0

1798

1799

self.path = None

1799

self.path = None

1800

1801

self.delay = 3 #seconds

1801

self.delay = 3 #seconds

1802

1803

self.nTries = 3 #quantity tries

1803

self.nTries = 3 #quantity tries

1804

1805

self.nFiles = 3 #number of files for searching

1805

self.nFiles = 3 #number of files for searching

1806

1807

self.nReadBlocks = 0

1807

self.nReadBlocks = 0

1808

1809

self.flagIsNewFile = 1

1809

self.flagIsNewFile = 1

1810

1811

self.ippSeconds = 0

1811

self.ippSeconds = 0

1812

1813

self.flagTimeBlock = 0

1813

self.flagTimeBlock = 0

1814

1815

self.flagIsNewBlock = 0

1815

self.flagIsNewBlock = 0

1816

1817

self.nTotalBlocks = 0

1817

self.nTotalBlocks = 0

1818

1819

self.blocksize = 0

1819

self.blocksize = 0

1820

1821

self.dataOut = self.createObjByDefault()

1821

self.dataOut = self.createObjByDefault()

1822

1823

1824

def createObjByDefault(self):

1824

def createObjByDefault(self):

1825

1826

dataObj = Spectra()

1826

dataObj = Spectra()

1827

1828

return dataObj

1828

return dataObj

1829

1830

def __hasNotDataInBuffer(self):

1830

def __hasNotDataInBuffer(self):

1831

return 1

1831

return 1

1832

1833

1834

def getBlockDimension(self):

1834

def getBlockDimension(self):

1835

"""

1835

"""

1836

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

1836

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

1837

1838

Affected:

1838

Affected:

1839

self.nRdChannels

1839

self.nRdChannels

1840

self.nRdPairs

1840

self.nRdPairs

1841

self.pts2read_SelfSpectra

1841

self.pts2read_SelfSpectra

1842

self.pts2read_CrossSpectra

1842

self.pts2read_CrossSpectra

1843

self.pts2read_DCchannels

1843

self.pts2read_DCchannels

1844

self.blocksize

1844

self.blocksize

1845

self.dataOut.nChannels

1845

self.dataOut.nChannels

1846

self.dataOut.nPairs

1846

self.dataOut.nPairs

1847

1848

Return:

1848

Return:

1849

None

1849

None

1850

"""

1850

"""

1851

self.nRdChannels = 0

1851

self.nRdChannels = 0

1852

self.nRdPairs = 0

1852

self.nRdPairs = 0

1853

self.rdPairList = []

1853

self.rdPairList = []

1854

1855

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

1855

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

1856

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

1856

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

1857

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

1857

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

1858

else:

1858

else:

1859

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

1859

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

1860

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

1860

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

1861

1862

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

1862

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

1863

1864

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

1864

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

1865

self.blocksize = self.pts2read_SelfSpectra

1865

self.blocksize = self.pts2read_SelfSpectra

1866

1867

if self.processingHeaderObj.flag_cspc:

1867

if self.processingHeaderObj.flag_cspc:

1868

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

1868

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

1869

self.blocksize += self.pts2read_CrossSpectra

1869

self.blocksize += self.pts2read_CrossSpectra

1870

1871

if self.processingHeaderObj.flag_dc:

1871

if self.processingHeaderObj.flag_dc:

1872

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

1872

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

1873

self.blocksize += self.pts2read_DCchannels

1873

self.blocksize += self.pts2read_DCchannels

1874

1875

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

1875

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

1876

1877

1878

def readBlock(self):

1878

def readBlock(self):

1879

"""

1879

"""

1880

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

1880

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

1881

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

1881

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

1882

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

1882

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

1883

es seteado a 0

1883

es seteado a 0

1884

1885

Return: None

1885

Return: None

1886

1887

Variables afectadas:

1887

Variables afectadas:

1888

1889

self.flagIsNewFile

1889

self.flagIsNewFile

1890

self.flagIsNewBlock

1890

self.flagIsNewBlock

1891

self.nTotalBlocks

1891

self.nTotalBlocks

1892

self.data_spc

1892

self.data_spc

1893

self.data_cspc

1893

self.data_cspc

1894

self.data_dc

1894

self.data_dc

1895

1896

Exceptions:

1896

Exceptions:

1897

Si un bloque leido no es un bloque valido

1897

Si un bloque leido no es un bloque valido

1898

"""

1898

"""

1899

blockOk_flag = False

1899

blockOk_flag = False

1900

fpointer = self.fp.tell()

1900

fpointer = self.fp.tell()

1901

1902

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

1902

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

1903

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

1903

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

1904

1905

if self.processingHeaderObj.flag_cspc:

1905

if self.processingHeaderObj.flag_cspc:

1906

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

1906

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

1907

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

1907

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

1908

1909

if self.processingHeaderObj.flag_dc:

1909

if self.processingHeaderObj.flag_dc:

1910

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

1910

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

1911

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

1911

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

1912

1913

1914

if not(self.processingHeaderObj.shif_fft):

1914

if not(self.processingHeaderObj.shif_fft):

1915

#desplaza a la derecha en el eje 2 determinadas posiciones

1915

#desplaza a la derecha en el eje 2 determinadas posiciones

1916

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

1916

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

1917

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

1917

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

1918

1919

if self.processingHeaderObj.flag_cspc:

1919

if self.processingHeaderObj.flag_cspc:

1920

#desplaza a la derecha en el eje 2 determinadas posiciones

1920

#desplaza a la derecha en el eje 2 determinadas posiciones

1921

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

1921

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

1922

1923

1924

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

1924

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

1925

self.data_spc = spc

1925

self.data_spc = spc

1926

1927

if self.processingHeaderObj.flag_cspc:

1927

if self.processingHeaderObj.flag_cspc:

1928

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

1928

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

1929

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

1929

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

1930

else:

1930

else:

1931

self.data_cspc = None

1931

self.data_cspc = None

1932

1933

if self.processingHeaderObj.flag_dc:

1933

if self.processingHeaderObj.flag_dc:

1934

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

1934

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

1935

else:

1935

else:

1936

self.data_dc = None

1936

self.data_dc = None

1937

1938

self.flagIsNewFile = 0

1938

self.flagIsNewFile = 0

1939

self.flagIsNewBlock = 1

1939

self.flagIsNewBlock = 1

1940

1941

self.nTotalBlocks += 1

1941

self.nTotalBlocks += 1

1942

self.nReadBlocks += 1

1942

self.nReadBlocks += 1

1943

1944

return 1

1944

return 1

1945

1946

1947

def getData(self):

1947

def getData(self):

1948

"""

1948

"""

1949

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

1949

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

1950

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

1950

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

1951

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

1951

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

1952

1953

Return:

1953

Return:

1954

0 : Si no hay mas archivos disponibles

1954

0 : Si no hay mas archivos disponibles

1955

1 : Si hizo una buena copia del buffer

1955

1 : Si hizo una buena copia del buffer

1956

1957

Affected:

1957

Affected:

1958

self.dataOut

1958

self.dataOut

1959

1960

self.flagTimeBlock

1960

self.flagTimeBlock

1961

self.flagIsNewBlock

1961

self.flagIsNewBlock

1962

"""

1962

"""

1963

1964

if self.flagNoMoreFiles:

1964

if self.flagNoMoreFiles:

1965

self.dataOut.flagNoData = True

1965

self.dataOut.flagNoData = True

1966

print 'Process finished'

1966

print 'Process finished'

1967

return 0

1967

return 0

1968

1969

self.flagTimeBlock = 0

1969

self.flagTimeBlock = 0

1970

self.flagIsNewBlock = 0

1970

self.flagIsNewBlock = 0

1971

1972

if self.__hasNotDataInBuffer():

1972

if self.__hasNotDataInBuffer():

1973

1974

if not( self.readNextBlock() ):

1974

if not( self.readNextBlock() ):

1975

self.dataOut.flagNoData = True

1975

self.dataOut.flagNoData = True

1976

return 0

1976

return 0

1977

1978

# self.updateDataHeader()

1978

# self.updateDataHeader()

1979

1980

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

1980

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

1981

1982

if self.data_dc == None:

1982

if self.data_dc == None:

1983

self.dataOut.flagNoData = True

1983

self.dataOut.flagNoData = True

1984

return 0

1984

return 0

1985

1986

self.dataOut.data_spc = self.data_spc

1986

self.dataOut.data_spc = self.data_spc

1987

1988

self.dataOut.data_cspc = self.data_cspc

1988

self.dataOut.data_cspc = self.data_cspc

1989

1990

self.dataOut.data_dc = self.data_dc

1990

self.dataOut.data_dc = self.data_dc

1991

1992

self.dataOut.flagTimeBlock = self.flagTimeBlock

1992

self.dataOut.flagTimeBlock = self.flagTimeBlock

1993

1994

self.dataOut.flagNoData = False

1994

self.dataOut.flagNoData = False

1995

1996

self.dataOut.dtype = self.dtype

1996

self.dataOut.dtype = self.dtype

1997

1998

# self.dataOut.nChannels = self.nRdChannels

1998

# self.dataOut.nChannels = self.nRdChannels

1999

2000

self.dataOut.nPairs = self.nRdPairs

2000

self.dataOut.nPairs = self.nRdPairs

2001

2002

self.dataOut.pairsList = self.rdPairList

2002

self.dataOut.pairsList = self.rdPairList

2003

2004

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

2004

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

2005

2006

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

2006

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

2007

2008

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

2008

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

2009

2010

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

2010

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

2011

2012

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

2012

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

2013

2014

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

2014

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

2015

2016

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

2016

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

2017

2018

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

2018

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

2019

2020

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

2020

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

2021

2022

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

2022

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

2023

2024

self.dataOut.ippSeconds = self.ippSeconds

2024

self.dataOut.ippSeconds = self.ippSeconds

2025

2026

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

2026

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

2027

2028

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

2028

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

2029

2030

# self.profileIndex += 1

2030

# self.profileIndex += 1

2031

2032

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

2032

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

2033

2034

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

2034

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

2035

2036

return self.dataOut.data_spc

2036

return self.dataOut.data_spc

2037

2038

2039

class SpectraWriter(JRODataWriter):

2039

class SpectraWriter(JRODataWriter):

2040

2041

"""

2041

"""

2042

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

2042

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

2043

de los datos siempre se realiza por bloques.

2043

de los datos siempre se realiza por bloques.

2044

"""

2044

"""

2045

2046

ext = ".pdata"

2046

ext = ".pdata"

2047

2048

optchar = "P"

2048

optchar = "P"

2049

2050

shape_spc_Buffer = None

2050

shape_spc_Buffer = None

2051

2052

shape_cspc_Buffer = None

2052

shape_cspc_Buffer = None

2053

2054

shape_dc_Buffer = None

2054

shape_dc_Buffer = None

2055

2056

data_spc = None

2056

data_spc = None

2057

2058

data_cspc = None

2058

data_cspc = None

2059

2060

data_dc = None

2060

data_dc = None

2061

2062

# dataOut = None

2062

# dataOut = None

2063

2064

def __init__(self):

2064

def __init__(self):

2065

"""

2065

"""

2066

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

2066

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

2067

2068

Affected:

2068

Affected:

2069

self.dataOut

2069

self.dataOut

2070

self.basicHeaderObj

2070

self.basicHeaderObj

2071

self.systemHeaderObj

2071

self.systemHeaderObj

2072

self.radarControllerHeaderObj

2072

self.radarControllerHeaderObj

2073

self.processingHeaderObj

2073

self.processingHeaderObj

2074

2075

Return: None

2075

Return: None

2076

"""

2076

"""

2077

2078

self.isConfig = False

2078

self.isConfig = False

2079

2080

self.nTotalBlocks = 0

2080

self.nTotalBlocks = 0

2081

2082

self.data_spc = None

2082

self.data_spc = None

2083

2084

self.data_cspc = None

2084

self.data_cspc = None

2085

2086

self.data_dc = None

2086

self.data_dc = None

2087

2088

self.fp = None

2088

self.fp = None

2089

2090

self.flagIsNewFile = 1

2090

self.flagIsNewFile = 1

2091

2092

self.nTotalBlocks = 0

2092

self.nTotalBlocks = 0

2093

2094

self.flagIsNewBlock = 0

2094

self.flagIsNewBlock = 0

2095

2096

self.setFile = None

2096

self.setFile = None

2097

2098

self.dtype = None

2098

self.dtype = None

2099

2100

self.path = None

2100

self.path = None

2101

2102

self.noMoreFiles = 0

2102

self.noMoreFiles = 0

2103

2104

self.filename = None

2104

self.filename = None

2105

2106

self.basicHeaderObj = BasicHeader()

2106

self.basicHeaderObj = BasicHeader()

2107

2108

self.systemHeaderObj = SystemHeader()

2108

self.systemHeaderObj = SystemHeader()

2109

2110

self.radarControllerHeaderObj = RadarControllerHeader()

2110

self.radarControllerHeaderObj = RadarControllerHeader()

2111

2112

self.processingHeaderObj = ProcessingHeader()

2112

self.processingHeaderObj = ProcessingHeader()

2113

2114

2115

def hasAllDataInBuffer(self):

2115

def hasAllDataInBuffer(self):

2116

return 1

2116

return 1

2117

2118

2119

def setBlockDimension(self):

2119

def setBlockDimension(self):

2120

"""

2120

"""

2121

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

2121

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

2122

2123

Affected:

2123

Affected:

2124

self.shape_spc_Buffer

2124

self.shape_spc_Buffer

2125

self.shape_cspc_Buffer

2125

self.shape_cspc_Buffer

2126

self.shape_dc_Buffer

2126

self.shape_dc_Buffer

2127

2128

Return: None

2128

Return: None

2129

"""

2129

"""

2130

self.shape_spc_Buffer = (self.dataOut.nChannels,

2130

self.shape_spc_Buffer = (self.dataOut.nChannels,

2131

self.processingHeaderObj.nHeights,

2131

self.processingHeaderObj.nHeights,

2132

self.processingHeaderObj.profilesPerBlock)

2132

self.processingHeaderObj.profilesPerBlock)

2133

2134

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2134

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2135

self.processingHeaderObj.nHeights,

2135

self.processingHeaderObj.nHeights,

2136

self.processingHeaderObj.profilesPerBlock)

2136

self.processingHeaderObj.profilesPerBlock)

2137

2138

self.shape_dc_Buffer = (self.dataOut.nChannels,

2138

self.shape_dc_Buffer = (self.dataOut.nChannels,

2139

self.processingHeaderObj.nHeights)

2139

self.processingHeaderObj.nHeights)

2140

2141

2142

def writeBlock(self):

2142

def writeBlock(self):

2143

"""

2143

"""

2144

Escribe el buffer en el file designado

2144

Escribe el buffer en el file designado

2145

2146

Affected:

2146

Affected:

2147

self.data_spc

2147

self.data_spc

2148

self.data_cspc

2148

self.data_cspc

2149

self.data_dc

2149

self.data_dc

2150

self.flagIsNewFile

2150

self.flagIsNewFile

2151

self.flagIsNewBlock

2151

self.flagIsNewBlock

2152

self.nTotalBlocks

2152

self.nTotalBlocks

2153

self.nWriteBlocks

2153

self.nWriteBlocks

2154

2155

Return: None

2155

Return: None

2156

"""

2156

"""

2157

2158

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

2158

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

2159

if not( self.processingHeaderObj.shif_fft ):

2159

if not( self.processingHeaderObj.shif_fft ):

2160

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

2160

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

2161

data = spc.reshape((-1))

2161

data = spc.reshape((-1))

2162

data.tofile(self.fp)

2162

data.tofile(self.fp)

2163

2164

if self.data_cspc != None:

2164

if self.data_cspc != None:

2165

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

2165

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

2166

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

2166

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

2167

if not( self.processingHeaderObj.shif_fft ):

2167

if not( self.processingHeaderObj.shif_fft ):

2168

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

2168

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

2169

data['real'] = cspc.real

2169

data['real'] = cspc.real

2170

data['imag'] = cspc.imag

2170

data['imag'] = cspc.imag

2171

data = data.reshape((-1))

2171

data = data.reshape((-1))

2172

data.tofile(self.fp)

2172

data.tofile(self.fp)

2173

2174

if self.data_dc != None:

2174

if self.data_dc != None:

2175

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

2175

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

2176

dc = self.data_dc

2176

dc = self.data_dc

2177

data['real'] = dc.real

2177

data['real'] = dc.real

2178

data['imag'] = dc.imag

2178

data['imag'] = dc.imag

2179

data = data.reshape((-1))

2179

data = data.reshape((-1))

2180

data.tofile(self.fp)

2180

data.tofile(self.fp)

2181

2182

self.data_spc.fill(0)

2182

self.data_spc.fill(0)

2183

self.data_dc.fill(0)

2183

self.data_dc.fill(0)

2184

if self.data_cspc != None:

2184

if self.data_cspc != None:

2185

self.data_cspc.fill(0)

2185

self.data_cspc.fill(0)

2186

2187

self.flagIsNewFile = 0

2187

self.flagIsNewFile = 0

2188

self.flagIsNewBlock = 1

2188

self.flagIsNewBlock = 1

2189

self.nTotalBlocks += 1

2189

self.nTotalBlocks += 1

2190

self.nWriteBlocks += 1

2190

self.nWriteBlocks += 1

2191

self.blockIndex += 1

2191

self.blockIndex += 1

2192

2193

2194

def putData(self):

2194

def putData(self):

2195

"""

2195

"""

2196

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

2196

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

2197

2198

Affected:

2198

Affected:

2199

self.data_spc

2199

self.data_spc

2200

self.data_cspc

2200

self.data_cspc

2201

self.data_dc

2201

self.data_dc

2202

2203

Return:

2203

Return:

2204

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

2204

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

2205

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

2205

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

2206

"""

2206

"""

2207

2208

if self.dataOut.flagNoData:

2208

if self.dataOut.flagNoData:

2209

return 0

2209

return 0

2210

2211

self.flagIsNewBlock = 0

2211

self.flagIsNewBlock = 0

2212

2213

if self.dataOut.flagTimeBlock:

2213

if self.dataOut.flagTimeBlock:

2214

self.data_spc.fill(0)

2214

self.data_spc.fill(0)

2215

self.data_cspc.fill(0)

2215

self.data_cspc.fill(0)

2216

self.data_dc.fill(0)

2216

self.data_dc.fill(0)

2217

self.setNextFile()

2217

self.setNextFile()

2218

2219

if self.flagIsNewFile == 0:

2219

if self.flagIsNewFile == 0:

2220

self.getBasicHeader()

2220

self.getBasicHeader()

2221

2222

self.data_spc = self.dataOut.data_spc

2222

self.data_spc = self.dataOut.data_spc

2223

self.data_cspc = self.dataOut.data_cspc

2223

self.data_cspc = self.dataOut.data_cspc

2224

self.data_dc = self.dataOut.data_dc

2224

self.data_dc = self.dataOut.data_dc

2225

2226

# #self.processingHeaderObj.dataBlocksPerFile)

2226

# #self.processingHeaderObj.dataBlocksPerFile)

2227

if self.hasAllDataInBuffer():

2227

if self.hasAllDataInBuffer():

2228

# self.getDataHeader()

2228

# self.getDataHeader()

2229

self.writeNextBlock()

2229

self.writeNextBlock()

2230

2231

return 1

2231

return 1

2232

2233

2234

def __getProcessFlags(self):

2234

def __getProcessFlags(self):

2235

2236

processFlags = 0

2236

processFlags = 0

2237

2238

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

2238

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

2239

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

2239

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

2240

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

2240

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

2241

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

2241

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

2242

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

2242

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

2243

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

2243

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

2244

2245

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

2245

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

2246

2247

2248

2249

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2249

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2250

PROCFLAG.DATATYPE_SHORT,

2250

PROCFLAG.DATATYPE_SHORT,

2251

PROCFLAG.DATATYPE_LONG,

2251

PROCFLAG.DATATYPE_LONG,

2252

PROCFLAG.DATATYPE_INT64,

2252

PROCFLAG.DATATYPE_INT64,

2253

PROCFLAG.DATATYPE_FLOAT,

2253

PROCFLAG.DATATYPE_FLOAT,

2254

PROCFLAG.DATATYPE_DOUBLE]

2254

PROCFLAG.DATATYPE_DOUBLE]

2255

2256

2257

for index in range(len(dtypeList)):

2257

for index in range(len(dtypeList)):

2258

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

2258

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

2259

dtypeValue = datatypeValueList[index]

2259

dtypeValue = datatypeValueList[index]

2260

break

2260

break

2261

2262

processFlags += dtypeValue

2262

processFlags += dtypeValue

2263

2264

if self.dataOut.flagDecodeData:

2264

if self.dataOut.flagDecodeData:

2265

processFlags += PROCFLAG.DECODE_DATA

2265

processFlags += PROCFLAG.DECODE_DATA

2266

2267

if self.dataOut.flagDeflipData:

2267

if self.dataOut.flagDeflipData:

2268

processFlags += PROCFLAG.DEFLIP_DATA

2268

processFlags += PROCFLAG.DEFLIP_DATA

2269

2270

if self.dataOut.code != None:

2270

if self.dataOut.code != None:

2271

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2271

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2272

2273

if self.dataOut.nIncohInt > 1:

2273

if self.dataOut.nIncohInt > 1:

2274

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2274

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2275

2276

if self.dataOut.data_dc != None:

2276

if self.dataOut.data_dc != None:

2277

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2277

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2278

2279

return processFlags

2279

return processFlags

2280

2281

2282

def __getBlockSize(self):

2282

def __getBlockSize(self):

2283

'''

2283

'''

2284

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

2284

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

2285

'''

2285

'''

2286

2287

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

2287

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

2288

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

2288

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

2289

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

2289

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

2290

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

2290

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

2291

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

2291

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

2292

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

2292

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

2293

2294

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

2294

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

2295

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

2295

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

2296

for index in range(len(dtypeList)):

2296

for index in range(len(dtypeList)):

2297

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

2297

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

2298

datatypeValue = datatypeValueList[index]

2298

datatypeValue = datatypeValueList[index]

2299

break

2299

break

2300

2301

2302

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

2302

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

2303

2304

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

2304

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

2305

blocksize = (pts2write_SelfSpectra*datatypeValue)

2305

blocksize = (pts2write_SelfSpectra*datatypeValue)

2306

2307

if self.dataOut.data_cspc != None:

2307

if self.dataOut.data_cspc != None:

2308

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

2308

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

2309

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2309

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2310

2311

if self.dataOut.data_dc != None:

2311

if self.dataOut.data_dc != None:

2312

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

2312

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

2313

blocksize += (pts2write_DCchannels*datatypeValue*2)

2313

blocksize += (pts2write_DCchannels*datatypeValue*2)

2314

2315

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2315

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2316

2317

return blocksize

2317

return blocksize

2318

2319

def getDataHeader(self):

2319

def getDataHeader(self):

2320

2321

"""

2321

"""

2322

Obtiene una copia del First Header

2322

Obtiene una copia del First Header

2323

2324

Affected:

2324

Affected:

2325

self.systemHeaderObj

2325

self.systemHeaderObj

2326

self.radarControllerHeaderObj

2326

self.radarControllerHeaderObj

2327

self.dtype

2327

self.dtype

2328

2329

Return:

2329

Return:

2330

None

2330

None

2331

"""

2331

"""

2332

2333

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

2333

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

2334

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2334

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2335

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

2335

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

2336

2337

self.getBasicHeader()

2337

self.getBasicHeader()

2338

2339

processingHeaderSize = 40 # bytes

2339

processingHeaderSize = 40 # bytes

2340

self.processingHeaderObj.dtype = 0 # Voltage

2340

self.processingHeaderObj.dtype = 0 # Voltage

2341

self.processingHeaderObj.blockSize = self.__getBlockSize()

2341

self.processingHeaderObj.blockSize = self.__getBlockSize()

2342

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2342

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2343

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2343

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2344

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

2344

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

2345

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2345

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2346

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

2346

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

2347

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2347

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2348

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

2348

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

2349

2350

if self.processingHeaderObj.totalSpectra > 0:

2350

if self.processingHeaderObj.totalSpectra > 0:

2351

channelList = []

2351

channelList = []

2352

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

2352

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

2353

channelList.append(channel)

2353

channelList.append(channel)

2354

channelList.append(channel)

2354

channelList.append(channel)

2355

2356

pairsList = []

2356

pairsList = []

2357

for pair in self.dataOut.pairsList:

2357

for pair in self.dataOut.pairsList:

2358

pairsList.append(pair[0])

2358

pairsList.append(pair[0])

2359

pairsList.append(pair[1])

2359

pairsList.append(pair[1])

2360

spectraComb = channelList + pairsList

2360

spectraComb = channelList + pairsList

2361

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

2361

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

2362

self.processingHeaderObj.spectraComb = spectraComb

2362

self.processingHeaderObj.spectraComb = spectraComb

2363

sizeOfSpcComb = len(spectraComb)

2363

sizeOfSpcComb = len(spectraComb)

2364

processingHeaderSize += sizeOfSpcComb

2364

processingHeaderSize += sizeOfSpcComb

2365

2366

if self.dataOut.code != None:

2366

if self.dataOut.code != None:

2367

self.processingHeaderObj.code = self.dataOut.code

2367

self.processingHeaderObj.code = self.dataOut.code

2368

self.processingHeaderObj.nCode = self.dataOut.nCode

2368

self.processingHeaderObj.nCode = self.dataOut.nCode

2369

self.processingHeaderObj.nBaud = self.dataOut.nBaud

2369

self.processingHeaderObj.nBaud = self.dataOut.nBaud

2370

nCodeSize = 4 # bytes

2370

nCodeSize = 4 # bytes

2371

nBaudSize = 4 # bytes

2371

nBaudSize = 4 # bytes

2372

codeSize = 4 # bytes

2372

codeSize = 4 # bytes

2373

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

2373

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

2374

processingHeaderSize += sizeOfCode

2374

processingHeaderSize += sizeOfCode

2375

2376

if self.processingHeaderObj.nWindows != 0:

2376

if self.processingHeaderObj.nWindows != 0:

2377

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

2377

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

2378

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

2378

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

2379

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2379

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2380

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2380

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2381

sizeOfFirstHeight = 4

2381

sizeOfFirstHeight = 4

2382

sizeOfdeltaHeight = 4

2382

sizeOfdeltaHeight = 4

2383

sizeOfnHeights = 4

2383

sizeOfnHeights = 4

2384

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

2384

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

2385

processingHeaderSize += sizeOfWindows

2385

processingHeaderSize += sizeOfWindows

2386

2387

self.processingHeaderObj.size = processingHeaderSize

2387

self.processingHeaderObj.size = processingHeaderSize

2388

2389

class SpectraHeisWriter():

2389

class SpectraHeisWriter():

2390

2391

i=0

2391

i=0

2392

2393

def __init__(self, dataOut):

2393

def __init__(self, dataOut):

2394

2395

self.wrObj = FITS()

2395

self.wrObj = FITS()

2396

self.dataOut = dataOut

2396

self.dataOut = dataOut

2397

2398

def isNumber(str):

2398

def isNumber(str):

2399

"""

2399

"""

2400

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

2400

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

2401

2402

Excepciones:

2402

Excepciones:

2403

Si un determinado string no puede ser convertido a numero

2403

Si un determinado string no puede ser convertido a numero

2404

Input:

2404

Input:

2405

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

2405

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

2406

2407

Return:

2407

Return:

2408

True : si el string es uno numerico

2408

True : si el string es uno numerico

2409

False : no es un string numerico

2409

False : no es un string numerico

2410

"""

2410

"""

2411

try:

2411

try:

2412

float( str )

2412

float( str )

2413

return True

2413

return True

2414

except:

2414

except:

2415

return False

2415

return False

2416

2417

def setup(self, wrpath,):

2417

def setup(self, wrpath,):

2418

2419

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

2419

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

2420

os.mkdir(wrpath)

2420

os.mkdir(wrpath)

2421

2422

self.wrpath = wrpath

2422

self.wrpath = wrpath

2423

self.setFile = 0

2423

self.setFile = 0

2424

2425

def putData(self):

2425

def putData(self):

2426

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

2426

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

2427

#name = self.dataOut.utctime

2427

#name = self.dataOut.utctime

2428

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

2428

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

2429

ext=".fits"

2429

ext=".fits"

2430

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

2430

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

2431

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

2431

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

2432

2433

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

2433

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

2434

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

2434

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

2435

os.mkdir(doypath)

2435

os.mkdir(doypath)

2436

self.setFile += 1

2436

self.setFile += 1

2437

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

2437

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

2438

2439

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

2439

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

2440

2441

# print self.dataOut.ippSeconds

2441

# print self.dataOut.ippSeconds

2442

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

2442

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

2443

2444

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

2444

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

2445

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

2445

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

2446

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

2446

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

2447

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

2447

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

2448

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

2448

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

2449

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

2449

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

2450

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

2450

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

2451

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

2451

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

2452

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

2452

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

2453

#n=numpy.arange((100))

2453

#n=numpy.arange((100))

2454

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

2454

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

2455

a=self.wrObj.cFImage(n)

2455

a=self.wrObj.cFImage(n)

2456

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

2456

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

2457

self.wrObj.CFile(a,b)

2457

self.wrObj.CFile(a,b)

2458

self.wrObj.wFile(filename)

2458

self.wrObj.wFile(filename)

2459

return 1

2459

return 1

2460

2461

class FITS:

2461

class FITS:

2462

2463

name=None

2463

name=None

2464

format=None

2464

format=None

2465

array =None

2465

array =None

2466

data =None

2466

data =None

2467

thdulist=None

2467

thdulist=None

2468

2469

def __init__(self):

2469

def __init__(self):

2470

2471

pass

2471

pass

2472

2473

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

2473

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

2474

self.name=name

2474

self.name=name

2475

self.format=format

2475

self.format=format

2476

self.array=array

2476

self.array=array

2477

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

2477

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

2478

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

2478

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

2479

return self.col1

2479

return self.col1

2480

2481

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

2481

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

2482

# self.name=name

2482

# self.name=name

2483

# self.format=format

2483

# self.format=format

2484

# self.data=data

2484

# self.data=data

2485

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

2485

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

2486

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

2486

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

2487

# return self.col2

2487

# return self.col2

2488

2489

def writeHeader(self,):

2489

def writeHeader(self,):

2490

pass

2490

pass

2491

2492

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

2492

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

2493

self.name=name

2493

self.name=name

2494

self.format=format

2494

self.format=format

2495

self.data=data

2495

self.data=data

2496

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

2496

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

2497

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

2497

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

2498

return self.col2

2498

return self.col2

2499

2500

def cFImage(self,n):

2500

def cFImage(self,n):

2501

self.hdu= pyfits.PrimaryHDU(n)

2501

self.hdu= pyfits.PrimaryHDU(n)

2502

return self.hdu

2502

return self.hdu

2503

2504

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

2504

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

2505

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

2505

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

2506

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

2506

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

2507

return self.tbhdu

2507

return self.tbhdu

2508

2509

def CFile(self,hdu,tbhdu):

2509

def CFile(self,hdu,tbhdu):

2510

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

2510

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

2511

2512

def wFile(self,filename):

2512

def wFile(self,filename):

2513

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

2513

self.thdulist.writeto(filename)

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

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

             '''
             $Author: murco $
             $Id: JROHeaderIO.py 151 2012-10-31 19:00:51Z murco $
             '''
+            import sys
             import numpy
             import copy
             class Header:
                 def __init__(self):
                     raise
                 def copy(self):
                     return copy.deepcopy(self)
                 def read():
                     pass
                 def write():
                     pass
             class BasicHeader(Header):
                 size = None
                 version = None
                 dataBlock = None
                 utc = None
                 miliSecond = None
                 timeZone = None
                 dstFlag = None
                 errorCount = None
                 struct = None
                 def __init__(self):
                     self.size = 0
                     self.version = 0
                     self.dataBlock = 0
                     self.utc = 0
                     self.miliSecond = 0
                     self.timeZone = 0
                     self.dstFlag = 0
                     self.errorCount = 0
                     self.struct = numpy.dtype([
                                           ('nSize','<u4'),
                                           ('nVersion','<u2'),
                                           ('nDataBlockId','<u4'),
                                           ('nUtime','<u4'),
                                           ('nMilsec','<u2'),
                                           ('nTimezone','<i2'),
                                           ('nDstflag','<i2'),
                                           ('nErrorCount','<u4')
                                           ])
                 def read(self, fp):
                     try:
                         header = numpy.fromfile(fp, self.struct,1)
                         self.size = int(header['nSize'][0])
                         self.version = int(header['nVersion'][0])
                         self.dataBlock = int(header['nDataBlockId'][0])
                         self.utc = int(header['nUtime'][0])
                         self.miliSecond = int(header['nMilsec'][0])
                         self.timeZone = int(header['nTimezone'][0])
                         self.dstFlag = int(header['nDstflag'][0])
                         self.errorCount = int(header['nErrorCount'][0])
-                    except:
+                    except Exception, e:
+                        print "BasicHeader: " + e
                         return 0
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount)
                     header = numpy.array(headerTuple,self.struct)
                     header.tofile(fp)
                     return 1
             class SystemHeader(Header):
                 size = None
                 nSamples = None
                 nProfiles = None
                 nChannels = None
                 adcResolution = None
                 pciDioBusWidth = None
                 struct = None
                 def __init__(self):
                     self.size = 0
                     self.nSamples = 0
                     self.nProfiles = 0
                     self.nChannels = 0
                     self.adcResolution = 0
                     self.pciDioBusWidth = 0
                     self.struct = numpy.dtype([
                                         ('nSize','<u4'),
                                         ('nNumSamples','<u4'),
                                         ('nNumProfiles','<u4'),
                                         ('nNumChannels','<u4'),
                                         ('nADCResolution','<u4'),
                                         ('nPCDIOBusWidth','<u4'),
                                         ])
                 def read(self, fp):
                     try:
                         header = numpy.fromfile(fp,self.struct,1)
                         self.size = header['nSize'][0]
                         self.nSamples = header['nNumSamples'][0]
                         self.nProfiles = header['nNumProfiles'][0]
                         self.nChannels = header['nNumChannels'][0]
                         self.adcResolution = header['nADCResolution'][0]
                         self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
-                    except:
+                    except Exception, e:
+                        print "SystemHeader: " + e
                         return 0
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size,self.nSamples,self.nProfiles,self.nChannels,self.adcResolution,self.pciDioBusWidth)
                     header = numpy.array(headerTuple,self.struct)
                     header.tofile(fp)
                     return 1
             class RadarControllerHeader(Header):
                 size = None
                 expType = None
                 nTx = None
                 ipp = None
                 txA = None
                 txB = None
                 nWindows = None
                 numTaus = None
                 codeType = None
                 line6Function = None
                 line5Function = None
                 fClock = None
                 prePulseBefore = None
                 prePulserAfter = None
                 rangeIpp = None
                 rangeTxA = None
                 rangeTxB = None
                 struct = None
                 def __init__(self):
                     self.size = 0
                     self.expType = 0
                     self.nTx = 0
                     self.ipp = 0
                     self.txA = 0
                     self.txB = 0
                     self.nWindows = 0
                     self.numTaus = 0
                     self.codeType = 0
                     self.line6Function = 0
                     self.line5Function = 0
                     self.fClock = 0
                     self.prePulseBefore = 0
                     self.prePulserAfter = 0
                     self.rangeIpp = 0
                     self.rangeTxA = 0
                     self.rangeTxB = 0
                     self.struct = numpy.dtype([
                                          ('nSize','<u4'),
                                          ('nExpType','<u4'),
                                          ('nNTx','<u4'),
                                          ('fIpp','<f4'),
                                          ('fTxA','<f4'),
                                          ('fTxB','<f4'),
                                          ('nNumWindows','<u4'),
                                          ('nNumTaus','<u4'),
                                          ('nCodeType','<u4'),
                                          ('nLine6Function','<u4'),
                                          ('nLine5Function','<u4'),
                                          ('fClock','<f4'),
                                          ('nPrePulseBefore','<u4'),
                                          ('nPrePulseAfter','<u4'),
                                          ('sRangeIPP','<a20'),
                                          ('sRangeTxA','<a20'),
                                          ('sRangeTxB','<a20'),
                                          ])
                     self.samplingWindowStruct = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
                     self.samplingWindow = None
                     self.nHeights = None
                     self.firstHeight = None
                     self.deltaHeight = None
                     self.samplesWin = None
                     self.nCode = None
                     self.nBaud = None
                     self.code = None
                     self.flip1 = None
                     self.flip2 = None
                     self.dynamic = numpy.array([],numpy.dtype('byte'))
                 def read(self, fp):
                     try:
                         startFp = fp.tell()
                         header = numpy.fromfile(fp,self.struct,1)
                         self.size = int(header['nSize'][0])
                         self.expType = int(header['nExpType'][0])
                         self.nTx = int(header['nNTx'][0])
                         self.ipp = float(header['fIpp'][0])
                         self.txA = float(header['fTxA'][0])
                         self.txB = float(header['fTxB'][0])
                         self.nWindows = int(header['nNumWindows'][0])
                         self.numTaus = int(header['nNumTaus'][0])
                         self.codeType = int(header['nCodeType'][0])
                         self.line6Function = int(header['nLine6Function'][0])
                         self.line5Function = int(header['nLine5Function'][0])
                         self.fClock = float(header['fClock'][0])
                         self.prePulseBefore = int(header['nPrePulseBefore'][0])
                         self.prePulserAfter = int(header['nPrePulseAfter'][0])
                         self.rangeIpp = header['sRangeIPP'][0]
                         self.rangeTxA = header['sRangeTxA'][0]
                         self.rangeTxB = header['sRangeTxB'][0]
                         # jump Dynamic Radar Controller Header
                         jumpFp =  self.size - 116
                         self.dynamic = numpy.fromfile(fp,numpy.dtype('byte'),jumpFp)
                         #pointer backward to dynamic header and read
                         backFp = fp.tell() - jumpFp
                         fp.seek(backFp)
                         self.samplingWindow = numpy.fromfile(fp,self.samplingWindowStruct,self.nWindows)
                         self.nHeights = int(numpy.sum(self.samplingWindow['nsa']))
                         self.firstHeight = self.samplingWindow['h0']
                         self.deltaHeight = self.samplingWindow['dh']
                         self.samplesWin = self.samplingWindow['nsa']
                         self.Taus = numpy.fromfile(fp,'<f4',self.numTaus)
                         if self.codeType != 0:
                             self.nCode = int(numpy.fromfile(fp,'<u4',1))
                             self.nBaud = int(numpy.fromfile(fp,'<u4',1))
                             self.code = numpy.empty([self.nCode,self.nBaud],dtype='u1')
                             tempList = []
                             for ic in range(self.nCode):
-                                temp = numpy.fromfile(fp,'u1',4*numpy.ceil(self.nBaud/32.))
+                                temp = numpy.fromfile(fp,'u1',4*int(numpy.ceil(self.nBaud/32.)))
                                 tempList.append(temp)
                                 self.code[ic] = numpy.unpackbits(temp[::-1])[-1*self.nBaud:]
                             self.code = 2.0*self.code - 1.0
                         if self.line5Function == RCfunction.FLIP:
                             self.flip1 = numpy.fromfile(fp,'<u4',1)
                         if self.line6Function == RCfunction.FLIP:
                             self.flip2 = numpy.fromfile(fp,'<u4',1)
                         endFp = self.size + startFp
                         jumpFp =  endFp - fp.tell()
                         if jumpFp > 0:
                             fp.seek(jumpFp)
-                    except:
+                    except Exception, e:
+                        print "RadarControllerHeader: " + e
                         return 0
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size,
                                    self.expType,
                                    self.nTx,
                                    self.ipp,
                                    self.txA,
                                    self.txB,
                                    self.nWindows,
                                    self.numTaus,
                                    self.codeType,
                                    self.line6Function,
                                    self.line5Function,
                                    self.fClock,
                                    self.prePulseBefore,
                                    self.prePulserAfter,
                                    self.rangeIpp,
                                    self.rangeTxA,
                                    self.rangeTxB)
                     header = numpy.array(headerTuple,self.struct)
                     header.tofile(fp)
                     dynamic = self.dynamic
                     dynamic.tofile(fp)
                     return 1
             class ProcessingHeader(Header):
                 size = None
                 dtype = None
                 blockSize = None
                 profilesPerBlock = None
                 dataBlocksPerFile = None
                 nWindows = None
                 processFlags = None
                 nCohInt = None
                 nIncohInt = None
                 totalSpectra = None
                 struct = None
                 flag_dc = None
                 flag_cspc = None
                 def __init__(self):
                     self.size = 0
                     self.dtype = 0
                     self.blockSize = 0
                     self.profilesPerBlock = 0
                     self.dataBlocksPerFile = 0
                     self.nWindows = 0
                     self.processFlags = 0
                     self.nCohInt = 0
                     self.nIncohInt = 0
                     self.totalSpectra = 0
                     self.struct = numpy.dtype([
                                            ('nSize','<u4'),
                                            ('nDataType','<u4'),
                                            ('nSizeOfDataBlock','<u4'),
                                            ('nProfilesperBlock','<u4'),
                                            ('nDataBlocksperFile','<u4'),
                                            ('nNumWindows','<u4'),
                                            ('nProcessFlags','<u4'),
                                            ('nCoherentIntegrations','<u4'),
                                            ('nIncoherentIntegrations','<u4'),
                                            ('nTotalSpectra','<u4')
                                            ])
                     self.samplingWindow = 0
                     self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
                     self.nHeights = 0
                     self.firstHeight = 0
                     self.deltaHeight = 0
                     self.samplesWin = 0
                     self.spectraComb = 0
                     self.nCode = None
                     self.code = None
                     self.nBaud = None
                     self.shif_fft = False
                     self.flag_dc = False
                     self.flag_cspc = False
                 def read(self, fp):
                     try:
                         header = numpy.fromfile(fp,self.struct,1)
                         self.size = int(header['nSize'][0])
                         self.dtype = int(header['nDataType'][0])
                         self.blockSize = int(header['nSizeOfDataBlock'][0])
                         self.profilesPerBlock = int(header['nProfilesperBlock'][0])
                         self.dataBlocksPerFile = int(header['nDataBlocksperFile'][0])
                         self.nWindows = int(header['nNumWindows'][0])
                         self.processFlags = int(header['nProcessFlags'])
                         self.nCohInt = int(header['nCoherentIntegrations'][0])
                         self.nIncohInt = int(header['nIncoherentIntegrations'][0])
                         self.totalSpectra = int(header['nTotalSpectra'][0])
                         self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.nWindows)
                         self.nHeights = int(numpy.sum(self.samplingWindow['nsa']))
                         self.firstHeight = int(self.samplingWindow['h0'][0])
                         self.deltaHeight = int(self.samplingWindow['dh'][0])
                         self.samplesWin = self.samplingWindow['nsa']
                         self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
                         if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
                             self.nCode = int(numpy.fromfile(fp,'<u4',1))
                             self.nBaud = int(numpy.fromfile(fp,'<u4',1))
                             self.code = numpy.fromfile(fp,'<f4',self.nCode*self.nBaud).reshape(self.nBaud,self.nCode)
                         if ((self.processFlags & PROCFLAG.SHIFT_FFT_DATA) == PROCFLAG.SHIFT_FFT_DATA):
                             self.shif_fft = True
                         else:
                             self.shif_fft = False
                         if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC):
                             self.flag_dc = True
                         nChannels = 0
                         nPairs = 0
                         pairList = []
                         for i in range( 0, self.totalSpectra*2, 2 ):
                             if self.spectraComb[i] == self.spectraComb[i+1]:
                                 nChannels = nChannels + 1   #par de canales iguales
                             else:
                                 nPairs = nPairs + 1 #par de canales diferentes
                                 pairList.append( (self.spectraComb[i], self.spectraComb[i+1]) )
                         self.flag_cspc = False
                         if nPairs > 0:
                             self.flag_cspc = True
-                    except:
+                    except Exception, e:
+                        print "ProcessingHeader: " + e
                         return 0
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size,
                                    self.dtype,
                                    self.blockSize,
                                    self.profilesPerBlock,
                                    self.dataBlocksPerFile,
                                    self.nWindows,
                                    self.processFlags,
                                    self.nCohInt,
                                    self.nIncohInt,
                                    self.totalSpectra)
                     header = numpy.array(headerTuple,self.struct)
                     header.tofile(fp)
                     if self.nWindows != 0:
                         sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
                         samplingWindow = numpy.array(sampleWindowTuple,self.structSamplingWindow)
                         samplingWindow.tofile(fp)
                     if self.totalSpectra != 0:
                         spectraComb = numpy.array([],numpy.dtype('u1'))
                         spectraComb = self.spectraComb
                         spectraComb.tofile(fp)
                     if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
                         nCode = self.nCode #Probar con un dato que almacene codigo, hasta el momento no se hizo la prueba
                         nCode.tofile(fp)
                         nBaud = self.nBaud
                         nBaud.tofile(fp)
                         code = self.code.reshape(nCode*nBaud)
                         code.tofile(fp)
                     return 1
             class RCfunction:
                 NONE=0
                 FLIP=1
                 CODE=2
                 SAMPLING=3
                 LIN6DIV256=4
                 SYNCHRO=5
             class nCodeType:
                 NONE=0
                 USERDEFINE=1
                 BARKER2=2
                 BARKER3=3
                 BARKER4=4
                 BARKER5=5
                 BARKER7=6
                 BARKER11=7
                 BARKER13=8
                 AC128=9
                 COMPLEMENTARYCODE2=10
                 COMPLEMENTARYCODE4=11
                 COMPLEMENTARYCODE8=12
                 COMPLEMENTARYCODE16=13
                 COMPLEMENTARYCODE32=14
                 COMPLEMENTARYCODE64=15
                 COMPLEMENTARYCODE128=16
                 CODE_BINARY28=17
             class PROCFLAG:
                 COHERENT_INTEGRATION = numpy.uint32(0x00000001)
                 DECODE_DATA = numpy.uint32(0x00000002)
                 SPECTRA_CALC = numpy.uint32(0x00000004)
                 INCOHERENT_INTEGRATION = numpy.uint32(0x00000008)
                 POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
                 SHIFT_FFT_DATA = numpy.uint32(0x00000020)
                 DATATYPE_CHAR = numpy.uint32(0x00000040)
                 DATATYPE_SHORT = numpy.uint32(0x00000080)
                 DATATYPE_LONG = numpy.uint32(0x00000100)
                 DATATYPE_INT64 = numpy.uint32(0x00000200)
                 DATATYPE_FLOAT = numpy.uint32(0x00000400)
                 DATATYPE_DOUBLE = numpy.uint32(0x00000800)
                 DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000)
                 DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000)
                 DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000)
                 SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
                 DEFLIP_DATA = numpy.uint32(0x00010000)
                 DEFINE_PROCESS_CODE = numpy.uint32(0x00020000)
                 ACQ_SYS_NATALIA = numpy.uint32(0x00040000)
                 ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000)
                 ACQ_SYS_ADRXD = numpy.uint32(0x000C0000)
                 ACQ_SYS_JULIA = numpy.uint32(0x00100000)
                 ACQ_SYS_XXXXXX = numpy.uint32(0x00140000)
                 EXP_NAME_ESP = numpy.uint32(0x00200000)
                 CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
                 OPERATION_MASK = numpy.uint32(0x0000003F)
                 DATATYPE_MASK = numpy.uint32(0x00000FC0)
                 DATAARRANGE_MASK = numpy.uint32(0x00007000)
                 ACQ_SYS_MASK = numpy.uint32(0x001C0000)