schain Commit - r333:99678d91f38e · Jicamarca Repository

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

1

'''

1

'''

2

3

$Author: murco $

3

$Author: murco $

4

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

4

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

5

'''

5

'''

6

7

import os, sys

7

import os, sys

8

import glob

8

import glob

9

import time

9

import time

10

import numpy

10

import numpy

11

import fnmatch

11

import fnmatch

12

import time, datetime

12

import time, datetime

13

14

from jrodata import *

14

from jrodata import *

15

from jroheaderIO import *

15

from jroheaderIO import *

16

from jroprocessing import *

16

from jroprocessing import *

17

18

LOCALTIME = -18000

18

LOCALTIME = -18000

19

20

def isNumber(str):

20

def isNumber(str):

21

"""

21

"""

22

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

22

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

23

24

Excepciones:

24

Excepciones:

25

Si un determinado string no puede ser convertido a numero

25

Si un determinado string no puede ser convertido a numero

26

Input:

26

Input:

27

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

27

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

28

29

Return:

29

Return:

30

True : si el string es uno numerico

30

True : si el string es uno numerico

31

False : no es un string numerico

31

False : no es un string numerico

32

"""

32

"""

33

try:

33

try:

34

float( str )

34

float( str )

35

return True

35

return True

36

except:

36

except:

37

return False

37

return False

38

39

def isThisFileinRange(filename, startUTSeconds, endUTSeconds):

39

def isThisFileinRange(filename, startUTSeconds, endUTSeconds):

40

"""

40

"""

41

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

41

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

42

43

Inputs:

43

Inputs:

44

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

44

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

45

46

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

46

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

47

segundos contados desde 01/01/1970.

47

segundos contados desde 01/01/1970.

48

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

48

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

49

segundos contados desde 01/01/1970.

49

segundos contados desde 01/01/1970.

50

51

Return:

51

Return:

52

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

52

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

53

fecha especificado, de lo contrario retorna False.

53

fecha especificado, de lo contrario retorna False.

54

55

Excepciones:

55

Excepciones:

56

Si el archivo no existe o no puede ser abierto

56

Si el archivo no existe o no puede ser abierto

57

Si la cabecera no puede ser leida.

57

Si la cabecera no puede ser leida.

58

59

"""

59

"""

60

basicHeaderObj = BasicHeader(LOCALTIME)

60

basicHeaderObj = BasicHeader(LOCALTIME)

61

62

try:

62

try:

63

fp = open(filename,'rb')

63

fp = open(filename,'rb')

64

except:

64

except:

65

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

65

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

66

67

sts = basicHeaderObj.read(fp)

67

sts = basicHeaderObj.read(fp)

68

fp.close()

68

fp.close()

69

70

if not(sts):

70

if not(sts):

71

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

71

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

72

return 0

72

return 0

73

74

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

74

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

75

return 0

75

return 0

76

77

return 1

77

return 1

78

79

def isFileinThisTime(filename, startTime, endTime):

79

def isFileinThisTime(filename, startTime, endTime):

80

"""

80

"""

81

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

81

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

82

83

Inputs:

83

Inputs:

84

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

84

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

85

86

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

86

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

87

88

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

88

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

89

90

Return:

90

Return:

91

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

91

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

92

fecha especificado, de lo contrario retorna False.

92

fecha especificado, de lo contrario retorna False.

93

94

Excepciones:

94

Excepciones:

95

Si el archivo no existe o no puede ser abierto

95

Si el archivo no existe o no puede ser abierto

96

Si la cabecera no puede ser leida.

96

Si la cabecera no puede ser leida.

97

98

"""

98

"""

99

100

101

try:

101

try:

102

fp = open(filename,'rb')

102

fp = open(filename,'rb')

103

except:

103

except:

104

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

104

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

105

106

basicHeaderObj = BasicHeader(LOCALTIME)

106

basicHeaderObj = BasicHeader(LOCALTIME)

107

sts = basicHeaderObj.read(fp)

107

sts = basicHeaderObj.read(fp)

108

fp.close()

108

fp.close()

109

110

thisDatetime = basicHeaderObj.datatime

110

thisDatetime = basicHeaderObj.datatime

111

thisTime = basicHeaderObj.datatime.time()

111

thisTime = basicHeaderObj.datatime.time()

112

113

if not(sts):

113

if not(sts):

114

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

114

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

115

return None

115

return None

116

117

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

117

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

118

return None

118

return None

119

120

return thisDatetime

120

return thisDatetime

121

122

def getlastFileFromPath(path, ext):

122

def getlastFileFromPath(path, ext):

123

"""

123

"""

124

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

124

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

125

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

125

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

126

127

Input:

127

Input:

128

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

128

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

129

ext : extension de los files contenidos en una carpeta

129

ext : extension de los files contenidos en una carpeta

130

131

Return:

131

Return:

132

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

132

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

133

"""

133

"""

134

validFilelist = []

134

validFilelist = []

135

fileList = os.listdir(path)

135

fileList = os.listdir(path)

136

137

# 0 1234 567 89A BCDE

137

# 0 1234 567 89A BCDE

138

# H YYYY DDD SSS .ext

138

# H YYYY DDD SSS .ext

139

140

for file in fileList:

140

for file in fileList:

141

try:

141

try:

142

year = int(file[1:5])

142

year = int(file[1:5])

143

doy = int(file[5:8])

143

doy = int(file[5:8])

144

145

146

except:

146

except:

147

continue

147

continue

148

149

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

149

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

150

continue

150

continue

151

152

validFilelist.append(file)

152

validFilelist.append(file)

153

154

if validFilelist:

154

if validFilelist:

155

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

155

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

156

return validFilelist[-1]

156

return validFilelist[-1]

157

158

return None

158

return None

159

160

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

160

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

161

"""

161

"""

162

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

162

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

163

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

163

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

164

el path exacto de un determinado file.

164

el path exacto de un determinado file.

165

166

Example :

166

Example :

167

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

167

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

168

169

Entonces la funcion prueba con las siguientes combinaciones

169

Entonces la funcion prueba con las siguientes combinaciones

170

.../.../y2009307367.ext

170

.../.../y2009307367.ext

171

.../.../Y2009307367.ext

171

.../.../Y2009307367.ext

172

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

172

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

173

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

173

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

174

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

174

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

175

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

175

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

176

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

176

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

177

178

Return:

178

Return:

179

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

179

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

180

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

180

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

181

para el filename

181

para el filename

182

"""

182

"""

183

fullfilename = None

183

fullfilename = None

184

find_flag = False

184

find_flag = False

185

filename = None

185

filename = None

186

187

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

187

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

188

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

188

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

189

prefixFileList = ['d','D']

189

prefixFileList = ['d','D']

190

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

190

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

191

prefixFileList = ['p','P']

191

prefixFileList = ['p','P']

192

else:

192

else:

193

return None, filename

193

return None, filename

194

195

#barrido por las combinaciones posibles

195

#barrido por las combinaciones posibles

196

for prefixDir in prefixDirList:

196

for prefixDir in prefixDirList:

197

thispath = path

197

thispath = path

198

if prefixDir != None:

198

if prefixDir != None:

199

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

199

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

200

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

200

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

201

202

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

202

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

203

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

203

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

204

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

204

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

205

206

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

206

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

207

find_flag = True

207

find_flag = True

208

break

208

break

209

if find_flag:

209

if find_flag:

210

break

210

break

211

212

if not(find_flag):

212

if not(find_flag):

213

return None, filename

213

return None, filename

214

215

return fullfilename, filename

215

return fullfilename, filename

216

217

def isDoyFolder(folder):

217

def isDoyFolder(folder):

218

try:

218

try:

219

year = int(folder[1:5])

219

year = int(folder[1:5])

220

except:

220

except:

221

return 0

221

return 0

222

223

try:

223

try:

224

doy = int(folder[5:8])

224

doy = int(folder[5:8])

225

except:

225

except:

226

return 0

226

return 0

227

228

return 1

228

return 1

229

230

class JRODataIO:

230

class JRODataIO:

231

232

c = 3E8

232

c = 3E8

233

234

isConfig = False

234

isConfig = False

235

236

basicHeaderObj = BasicHeader(LOCALTIME)

236

basicHeaderObj = BasicHeader(LOCALTIME)

237

238

systemHeaderObj = SystemHeader()

238

systemHeaderObj = SystemHeader()

239

240

radarControllerHeaderObj = RadarControllerHeader()

240

radarControllerHeaderObj = RadarControllerHeader()

241

242

processingHeaderObj = ProcessingHeader()

242

processingHeaderObj = ProcessingHeader()

243

244

online = 0

244

online = 0

245

246

dtype = None

246

dtype = None

247

248

pathList = []

248

pathList = []

249

250

filenameList = []

250

filenameList = []

251

252

filename = None

252

filename = None

253

254

ext = None

254

ext = None

255

256

flagIsNewFile = 1

256

flagIsNewFile = 1

257

258

flagTimeBlock = 0

258

flagTimeBlock = 0

259

260

flagIsNewBlock = 0

260

flagIsNewBlock = 0

261

262

fp = None

262

fp = None

263

264

firstHeaderSize = 0

264

firstHeaderSize = 0

265

266

basicHeaderSize = 24

266

basicHeaderSize = 24

267

268

versionFile = 1103

268

versionFile = 1103

269

270

fileSize = None

270

fileSize = None

271

272

ippSeconds = None

272

ippSeconds = None

273

274

fileSizeByHeader = None

274

fileSizeByHeader = None

275

276

fileIndex = None

276

fileIndex = None

277

278

profileIndex = None

278

profileIndex = None

279

280

blockIndex = None

280

blockIndex = None

281

282

nTotalBlocks = None

282

nTotalBlocks = None

283

284

maxTimeStep = 30

284

maxTimeStep = 30

285

286

lastUTTime = None

286

lastUTTime = None

287

288

datablock = None

288

datablock = None

289

290

dataOut = None

290

dataOut = None

291

292

blocksize = None

292

blocksize = None

293

294

def __init__(self):

294

def __init__(self):

295

296

raise ValueError, "Not implemented"

296

raise ValueError, "Not implemented"

297

298

def run(self):

298

def run(self):

299

300

raise ValueError, "Not implemented"

300

raise ValueError, "Not implemented"

301

302

def getOutput(self):

302

def getOutput(self):

303

304

return self.dataOut

304

return self.dataOut

305

306

class JRODataReader(JRODataIO, ProcessingUnit):

306

class JRODataReader(JRODataIO, ProcessingUnit):

307

308

nReadBlocks = 0

308

nReadBlocks = 0

309

310

delay = 10 #number of seconds waiting a new file

310

delay = 10 #number of seconds waiting a new file

311

312

nTries = 3 #quantity tries

312

nTries = 3 #quantity tries

313

314

nFiles = 3 #number of files for searching

314

nFiles = 3 #number of files for searching

315

316

flagNoMoreFiles = 0

316

flagNoMoreFiles = 0

317

318

datetimeList = []

318

datetimeList = []

319

320

__isFirstTimeOnline = 1

320

__isFirstTimeOnline = 1

321

322

__printInfo = True

322

__printInfo = True

323

324

def __init__(self):

324

def __init__(self):

325

326

"""

326

"""

327

328

"""

328

"""

329

330

raise ValueError, "This method has not been implemented"

330

raise ValueError, "This method has not been implemented"

331

332

333

def createObjByDefault(self):

333

def createObjByDefault(self):

334

"""

334

"""

335

336

"""

336

"""

337

raise ValueError, "This method has not been implemented"

337

raise ValueError, "This method has not been implemented"

338

339

def getBlockDimension(self):

339

def getBlockDimension(self):

340

341

raise ValueError, "No implemented"

341

raise ValueError, "No implemented"

342

343

def __searchFilesOffLine(self,

343

def __searchFilesOffLine(self,

344

path,

344

path,

345

startDate,

345

startDate,

346

endDate,

346

endDate,

347

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

347

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

348

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

348

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

349

set=None,

349

set=None,

350

expLabel='',

350

expLabel='',

351

ext='.r',

351

ext='.r',

352

walk=True):

352

walk=True):

353

354

pathList = []

354

pathList = []

355

356

if not walk:

356

if not walk:

357

pathList.append(path)

357

pathList.append(path)

358

359

else:

359

else:

360

dirList = []

360

dirList = []

361

for thisPath in os.listdir(path):

361

for thisPath in os.listdir(path):

362

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

362

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

363

continue

363

continue

364

if not isDoyFolder(thisPath):

364

if not isDoyFolder(thisPath):

365

continue

365

continue

366

367

dirList.append(thisPath)

367

dirList.append(thisPath)

368

369

if not(dirList):

369

if not(dirList):

370

return None, None

370

return None, None

371

372

thisDate = startDate

372

thisDate = startDate

373

374

while(thisDate <= endDate):

374

while(thisDate <= endDate):

375

year = thisDate.timetuple().tm_year

375

year = thisDate.timetuple().tm_year

376

doy = thisDate.timetuple().tm_yday

376

doy = thisDate.timetuple().tm_yday

377

378

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

378

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

379

if len(match) == 0:

379

if len(match) == 0:

380

thisDate += datetime.timedelta(1)

380

thisDate += datetime.timedelta(1)

381

continue

381

continue

382

383

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

383

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

384

385

thisDate += datetime.timedelta(1)

385

thisDate += datetime.timedelta(1)

386

387

if pathList == []:

387

if pathList == []:

388

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

388

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

389

return None, None

389

return None, None

390

391

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

391

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

392

393

filenameList = []

393

filenameList = []

394

datetimeList = []

394

datetimeList = []

395

396

for i in range(len(pathList)):

396

for i in range(len(pathList)):

397

398

thisPath = pathList[i]

398

thisPath = pathList[i]

399

400

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

400

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

401

fileList.sort()

401

fileList.sort()

402

403

for file in fileList:

403

for file in fileList:

404

405

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

405

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

406

thisDatetime = isFileinThisTime(filename, startTime, endTime)

406

thisDatetime = isFileinThisTime(filename, startTime, endTime)

407

408

if not(thisDatetime):

408

if not(thisDatetime):

409

continue

409

continue

410

411

filenameList.append(filename)

411

filenameList.append(filename)

412

datetimeList.append(thisDatetime)

412

datetimeList.append(thisDatetime)

413

414

if not(filenameList):

414

if not(filenameList):

415

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

415

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

416

return None, None

416

return None, None

417

418

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

418

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

419

print

419

print

420

421

for i in range(len(filenameList)):

421

for i in range(len(filenameList)):

422

print "%s -> [%s]" %(filenameList[i], datetimeList[i].ctime())

422

print "%s -> [%s]" %(filenameList[i], datetimeList[i].ctime())

423

424

self.filenameList = filenameList

424

self.filenameList = filenameList

425

self.datetimeList = datetimeList

425

self.datetimeList = datetimeList

426

427

return pathList, filenameList

427

return pathList, filenameList

428

429

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

429

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

430

431

"""

431

"""

432

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

432

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

433

devuelve el archivo encontrado ademas de otros datos.

433

devuelve el archivo encontrado ademas de otros datos.

434

435

Input:

435

Input:

436

path : carpeta donde estan contenidos los files que contiene data

436

path : carpeta donde estan contenidos los files que contiene data

437

438

expLabel : Nombre del subexperimento (subfolder)

438

expLabel : Nombre del subexperimento (subfolder)

439

440

ext : extension de los files

440

ext : extension de los files

441

442

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

442

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

443

444

Return:

444

Return:

445

directory : eL directorio donde esta el file encontrado

445

directory : eL directorio donde esta el file encontrado

446

filename : el ultimo file de una determinada carpeta

446

filename : el ultimo file de una determinada carpeta

447

year : el anho

447

year : el anho

448

doy : el numero de dia del anho

448

doy : el numero de dia del anho

449

set : el set del archivo

449

set : el set del archivo

450

451

452

"""

452

"""

453

dirList = []

453

dirList = []

454

455

if not walk:

455

if not walk:

456

fullpath = path

456

fullpath = path

457

458

else:

458

else:

459

#Filtra solo los directorios

459

#Filtra solo los directorios

460

for thisPath in os.listdir(path):

460

for thisPath in os.listdir(path):

461

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

461

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

462

continue

462

continue

463

if not isDoyFolder(thisPath):

463

if not isDoyFolder(thisPath):

464

continue

464

continue

465

466

dirList.append(thisPath)

466

dirList.append(thisPath)

467

468

if not(dirList):

468

if not(dirList):

469

return None, None, None, None, None

469

return None, None, None, None, None

470

471

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

471

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

472

473

doypath = dirList[-1]

473

doypath = dirList[-1]

474

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

474

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

475

476

477

print "%s folder was found: " %(fullpath )

477

print "%s folder was found: " %(fullpath )

478

479

filename = getlastFileFromPath(fullpath, ext)

479

filename = getlastFileFromPath(fullpath, ext)

480

481

if not(filename):

481

if not(filename):

482

return None, None, None, None, None

482

return None, None, None, None, None

483

484

print "%s file was found" %(filename)

484

print "%s file was found" %(filename)

485

486

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

486

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

487

return None, None, None, None, None

487

return None, None, None, None, None

488

489

year = int( filename[1:5] )

489

year = int( filename[1:5] )

490

doy = int( filename[5:8] )

490

doy = int( filename[5:8] )

491

set = int( filename[8:11] )

491

set = int( filename[8:11] )

492

493

return fullpath, filename, year, doy, set

493

return fullpath, filename, year, doy, set

494

495

def __setNextFileOffline(self):

495

def __setNextFileOffline(self):

496

497

idFile = self.fileIndex

497

idFile = self.fileIndex

498

499

while (True):

499

while (True):

500

idFile += 1

500

idFile += 1

501

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

501

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

502

self.flagNoMoreFiles = 1

502

self.flagNoMoreFiles = 1

503

print "No more Files"

503

print "No more Files"

504

return 0

504

return 0

505

506

filename = self.filenameList[idFile]

506

filename = self.filenameList[idFile]

507

508

if not(self.__verifyFile(filename)):

508

if not(self.__verifyFile(filename)):

509

continue

509

continue

510

511

fileSize = os.path.getsize(filename)

511

fileSize = os.path.getsize(filename)

512

fp = open(filename,'rb')

512

fp = open(filename,'rb')

513

break

513

break

514

515

self.flagIsNewFile = 1

515

self.flagIsNewFile = 1

516

self.fileIndex = idFile

516

self.fileIndex = idFile

517

self.filename = filename

517

self.filename = filename

518

self.fileSize = fileSize

518

self.fileSize = fileSize

519

self.fp = fp

519

self.fp = fp

520

521

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

521

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

522

523

return 1

523

return 1

524

525

def __setNextFileOnline(self):

525

def __setNextFileOnline(self):

526

"""

526

"""

527

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

527

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

528

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

528

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

529

siguientes.

529

siguientes.

530

531

Affected:

531

Affected:

532

self.flagIsNewFile

532

self.flagIsNewFile

533

self.filename

533

self.filename

534

self.fileSize

534

self.fileSize

535

self.fp

535

self.fp

536

self.set

536

self.set

537

self.flagNoMoreFiles

537

self.flagNoMoreFiles

538

539

Return:

539

Return:

540

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

540

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

541

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

541

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

542

543

Excepciones:

543

Excepciones:

544

Si un determinado file no puede ser abierto

544

Si un determinado file no puede ser abierto

545

"""

545

"""

546

nFiles = 0

546

nFiles = 0

547

fileOk_flag = False

547

fileOk_flag = False

548

firstTime_flag = True

548

firstTime_flag = True

549

550

self.set += 1

550

self.set += 1

551

552

#busca el 1er file disponible

552

#busca el 1er file disponible

553

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

553

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

554

if fullfilename:

554

if fullfilename:

555

if self.__verifyFile(fullfilename, False):

555

if self.__verifyFile(fullfilename, False):

556

fileOk_flag = True

556

fileOk_flag = True

557

558

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

558

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

559

if not(fileOk_flag):

559

if not(fileOk_flag):

560

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

560

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

561

562

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

562

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

563

tries = self.nTries

563

tries = self.nTries

564

else:

564

else:

565

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

565

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

566

567

for nTries in range( tries ):

567

for nTries in range( tries ):

568

if firstTime_flag:

568

if firstTime_flag:

569

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

569

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

570

time.sleep( self.delay )

570

time.sleep( self.delay )

571

else:

571

else:

572

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

572

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

573

574

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

574

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

575

if fullfilename:

575

if fullfilename:

576

if self.__verifyFile(fullfilename):

576

if self.__verifyFile(fullfilename):

577

fileOk_flag = True

577

fileOk_flag = True

578

break

578

break

579

580

if fileOk_flag:

580

if fileOk_flag:

581

break

581

break

582

583

firstTime_flag = False

583

firstTime_flag = False

584

585

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

585

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

586

self.set += 1

586

self.set += 1

587

588

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

588

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

589

self.set = 0

589

self.set = 0

590

self.doy += 1

590

self.doy += 1

591

592

if fileOk_flag:

592

if fileOk_flag:

593

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

593

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

594

self.filename = fullfilename

594

self.filename = fullfilename

595

self.flagIsNewFile = 1

595

self.flagIsNewFile = 1

596

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

596

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

597

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

597

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

598

self.flagNoMoreFiles = 0

598

self.flagNoMoreFiles = 0

599

print 'Setting the file: %s' % fullfilename

599

print 'Setting the file: %s' % fullfilename

600

else:

600

else:

601

self.fileSize = 0

601

self.fileSize = 0

602

self.filename = None

602

self.filename = None

603

self.flagIsNewFile = 0

603

self.flagIsNewFile = 0

604

self.fp = None

604

self.fp = None

605

self.flagNoMoreFiles = 1

605

self.flagNoMoreFiles = 1

606

print 'No more Files'

606

print 'No more Files'

607

608

return fileOk_flag

608

return fileOk_flag

609

610

611

def setNextFile(self):

611

def setNextFile(self):

612

if self.fp != None:

612

if self.fp != None:

613

self.fp.close()

613

self.fp.close()

614

615

if self.online:

615

if self.online:

616

newFile = self.__setNextFileOnline()

616

newFile = self.__setNextFileOnline()

617

else:

617

else:

618

newFile = self.__setNextFileOffline()

618

newFile = self.__setNextFileOffline()

619

620

if not(newFile):

620

if not(newFile):

621

return 0

621

return 0

622

623

self.__readFirstHeader()

623

self.__readFirstHeader()

624

self.nReadBlocks = 0

624

self.nReadBlocks = 0

625

return 1

625

return 1

626

627

def __waitNewBlock(self):

627

def __waitNewBlock(self):

628

"""

628

"""

629

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

629

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

630

631

Si el modo de lectura es OffLine siempre retorn 0

631

Si el modo de lectura es OffLine siempre retorn 0

632

"""

632

"""

633

if not self.online:

633

if not self.online:

634

return 0

634

return 0

635

636

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

636

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

637

return 0

637

return 0

638

639

currentPointer = self.fp.tell()

639

currentPointer = self.fp.tell()

640

641

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

641

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

642

643

for nTries in range( self.nTries ):

643

for nTries in range( self.nTries ):

644

645

self.fp.close()

645

self.fp.close()

646

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

646

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

647

self.fp.seek( currentPointer )

647

self.fp.seek( currentPointer )

648

649

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

649

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

650

currentSize = self.fileSize - currentPointer

650

currentSize = self.fileSize - currentPointer

651

652

if ( currentSize >= neededSize ):

652

if ( currentSize >= neededSize ):

653

self.__rdBasicHeader()

653

self.__rdBasicHeader()

654

return 1

654

return 1

655

656

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

656

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

657

time.sleep( self.delay )

657

time.sleep( self.delay )

658

659

660

return 0

660

return 0

661

662

def __jumpToLastBlock(self):

662

def __jumpToLastBlock(self):

663

664

if not(self.__isFirstTimeOnline):

664

if not(self.__isFirstTimeOnline):

665

return

665

return

666

667

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

667

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

668

669

#sata el primer bloque de datos

669

#sata el primer bloque de datos

670

if csize > self.processingHeaderObj.blockSize:

670

if csize > self.processingHeaderObj.blockSize:

671

self.fp.seek(self.fp.tell() + self.processingHeaderObj.blockSize)

671

self.fp.seek(self.fp.tell() + self.processingHeaderObj.blockSize)

672

else:

672

else:

673

return

673

return

674

675

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

675

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

676

neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize

676

neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize

677

factor = int(csize/neededsize)

677

factor = int(csize/neededsize)

678

if factor > 0:

678

if factor > 0:

679

self.fp.seek(self.fp.tell() + factor*neededsize)

679

self.fp.seek(self.fp.tell() + factor*neededsize)

680

681

self.flagIsNewFile = 0

681

self.flagIsNewFile = 0

682

self.__isFirstTimeOnline = 0

682

self.__isFirstTimeOnline = 0

683

684

685

def __setNewBlock(self):

685

def __setNewBlock(self):

686

687

if self.fp == None:

687

if self.fp == None:

688

return 0

688

return 0

689

690

if self.online:

690

if self.online:

691

self.__jumpToLastBlock()

691

self.__jumpToLastBlock()

692

693

if self.flagIsNewFile:

693

if self.flagIsNewFile:

694

return 1

694

return 1

695

696

self.lastUTTime = self.basicHeaderObj.utc

696

self.lastUTTime = self.basicHeaderObj.utc

697

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

697

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

698

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

698

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

699

700

if (currentSize >= neededSize):

700

if (currentSize >= neededSize):

701

self.__rdBasicHeader()

701

self.__rdBasicHeader()

702

return 1

702

return 1

703

704

if self.__waitNewBlock():

704

if self.__waitNewBlock():

705

return 1

705

return 1

706

707

if not(self.setNextFile()):

707

if not(self.setNextFile()):

708

return 0

708

return 0

709

710

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

710

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

711

712

self.flagTimeBlock = 0

712

self.flagTimeBlock = 0

713

714

if deltaTime > self.maxTimeStep:

714

if deltaTime > self.maxTimeStep:

715

self.flagTimeBlock = 1

715

self.flagTimeBlock = 1

716

717

return 1

717

return 1

718

719

720

def readNextBlock(self):

720

def readNextBlock(self):

721

if not(self.__setNewBlock()):

721

if not(self.__setNewBlock()):

722

return 0

722

return 0

723

724

if not(self.readBlock()):

724

if not(self.readBlock()):

725

return 0

725

return 0

726

727

return 1

727

return 1

728

729

def __rdProcessingHeader(self, fp=None):

729

def __rdProcessingHeader(self, fp=None):

730

if fp == None:

730

if fp == None:

731

fp = self.fp

731

fp = self.fp

732

733

self.processingHeaderObj.read(fp)

733

self.processingHeaderObj.read(fp)

734

735

def __rdRadarControllerHeader(self, fp=None):

735

def __rdRadarControllerHeader(self, fp=None):

736

if fp == None:

736

if fp == None:

737

fp = self.fp

737

fp = self.fp

738

739

self.radarControllerHeaderObj.read(fp)

739

self.radarControllerHeaderObj.read(fp)

740

741

def __rdSystemHeader(self, fp=None):

741

def __rdSystemHeader(self, fp=None):

742

if fp == None:

742

if fp == None:

743

fp = self.fp

743

fp = self.fp

744

745

self.systemHeaderObj.read(fp)

745

self.systemHeaderObj.read(fp)

746

747

def __rdBasicHeader(self, fp=None):

747

def __rdBasicHeader(self, fp=None):

748

if fp == None:

748

if fp == None:

749

fp = self.fp

749

fp = self.fp

750

751

self.basicHeaderObj.read(fp)

751

self.basicHeaderObj.read(fp)

752

753

754

def __readFirstHeader(self):

754

def __readFirstHeader(self):

755

self.__rdBasicHeader()

755

self.__rdBasicHeader()

756

self.__rdSystemHeader()

756

self.__rdSystemHeader()

757

self.__rdRadarControllerHeader()

757

self.__rdRadarControllerHeader()

758

self.__rdProcessingHeader()

758

self.__rdProcessingHeader()

759

760

self.firstHeaderSize = self.basicHeaderObj.size

760

self.firstHeaderSize = self.basicHeaderObj.size

761

762

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

762

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

763

if datatype == 0:

763

if datatype == 0:

764

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

764

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

765

elif datatype == 1:

765

elif datatype == 1:

766

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

766

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

767

elif datatype == 2:

767

elif datatype == 2:

768

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

768

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

769

elif datatype == 3:

769

elif datatype == 3:

770

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

770

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

771

elif datatype == 4:

771

elif datatype == 4:

772

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

772

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

773

elif datatype == 5:

773

elif datatype == 5:

774

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

774

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

775

else:

775

else:

776

raise ValueError, 'Data type was not defined'

776

raise ValueError, 'Data type was not defined'

777

778

self.dtype = datatype_str

778

self.dtype = datatype_str

779

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

779

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

780

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

780

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

781

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

781

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

782

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

782

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

783

self.getBlockDimension()

783

self.getBlockDimension()

784

785

786

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

786

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

787

msg = None

787

msg = None

788

try:

788

try:

789

fp = open(filename, 'rb')

789

fp = open(filename, 'rb')

790

currentPosition = fp.tell()

790

currentPosition = fp.tell()

791

except:

791

except:

792

if msgFlag:

792

if msgFlag:

793

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

793

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

794

return False

794

return False

795

796

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

796

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

797

798

if neededSize == 0:

798

if neededSize == 0:

799

basicHeaderObj = BasicHeader(LOCALTIME)

799

basicHeaderObj = BasicHeader(LOCALTIME)

800

systemHeaderObj = SystemHeader()

800

systemHeaderObj = SystemHeader()

801

radarControllerHeaderObj = RadarControllerHeader()

801

radarControllerHeaderObj = RadarControllerHeader()

802

processingHeaderObj = ProcessingHeader()

802

processingHeaderObj = ProcessingHeader()

803

804

try:

804

try:

805

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

805

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

806

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

806

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

807

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

807

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

808

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

808

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

809

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

809

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

810

811

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

811

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

812

813

except:

813

except:

814

if msgFlag:

814

if msgFlag:

815

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

815

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

816

817

fp.close()

817

fp.close()

818

return False

818

return False

819

else:

819

else:

820

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

820

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

821

822

fp.close()

822

fp.close()

823

fileSize = os.path.getsize(filename)

823

fileSize = os.path.getsize(filename)

824

currentSize = fileSize - currentPosition

824

currentSize = fileSize - currentPosition

825

if currentSize < neededSize:

825

if currentSize < neededSize:

826

if msgFlag and (msg != None):

826

if msgFlag and (msg != None):

827

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

827

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

828

return False

828

return False

829

830

return True

830

return True

831

832

def setup(self,

832

def setup(self,

833

path=None,

833

path=None,

834

startDate=None,

834

startDate=None,

835

endDate=None,

835

endDate=None,

836

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

836

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

837

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

837

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

838

set=0,

838

set=0,

839

expLabel = "",

839

expLabel = "",

840

ext = None,

840

ext = None,

841

online = False,

841

online = False,

842

delay = 60,

842

delay = 60,

843

walk = True):

843

walk = True):

844

845

if path == None:

845

if path == None:

846

raise ValueError, "The path is not valid"

846

raise ValueError, "The path is not valid"

847

848

if ext == None:

848

if ext == None:

849

ext = self.ext

849

ext = self.ext

850

851

if online:

851

if online:

852

print "Searching files in online mode..."

852

print "Searching files in online mode..."

853

854

for nTries in range( self.nTries ):

854

for nTries in range( self.nTries ):

855

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

855

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

856

857

if fullpath:

857

if fullpath:

858

break

858

break

859

860

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

860

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

861

time.sleep( self.delay )

861

time.sleep( self.delay )

862

863

if not(fullpath):

863

if not(fullpath):

864

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

864

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

865

return None

865

return None

866

867

self.year = year

867

self.year = year

868

self.doy = doy

868

self.doy = doy

869

self.set = set - 1

869

self.set = set - 1

870

self.path = path

870

self.path = path

871

872

else:

872

else:

873

print "Searching files in offline mode ..."

873

print "Searching files in offline mode ..."

874

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

874

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

875

startTime=startTime, endTime=endTime,

875

startTime=startTime, endTime=endTime,

876

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

876

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

877

walk=walk)

877

walk=walk)

878

879

if not(pathList):

879

if not(pathList):

880

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

880

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

881

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

881

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

882

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

882

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

883

884

sys.exit(-1)

884

sys.exit(-1)

885

886

887

self.fileIndex = -1

887

self.fileIndex = -1

888

self.pathList = pathList

888

self.pathList = pathList

889

self.filenameList = filenameList

889

self.filenameList = filenameList

890

891

self.online = online

891

self.online = online

892

self.delay = delay

892

self.delay = delay

893

ext = ext.lower()

893

ext = ext.lower()

894

self.ext = ext

894

self.ext = ext

895

896

if not(self.setNextFile()):

896

if not(self.setNextFile()):

897

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

897

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

898

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

898

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

899

elif startDate != None:

899

elif startDate != None:

900

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

900

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

901

else:

901

else:

902

print "No files"

902

print "No files"

903

904

sys.exit(-1)

904

sys.exit(-1)

905

906

# self.updateDataHeader()

906

# self.updateDataHeader()

907

908

return self.dataOut

908

return self.dataOut

909

910

def getData():

910

def getData():

911

912

raise ValueError, "This method has not been implemented"

912

raise ValueError, "This method has not been implemented"

913

914

def hasNotDataInBuffer():

914

def hasNotDataInBuffer():

915

916

raise ValueError, "This method has not been implemented"

916

raise ValueError, "This method has not been implemented"

917

918

def readBlock():

918

def readBlock():

919

920

raise ValueError, "This method has not been implemented"

920

raise ValueError, "This method has not been implemented"

921

922

def isEndProcess(self):

922

def isEndProcess(self):

923

924

return self.flagNoMoreFiles

924

return self.flagNoMoreFiles

925

926

def printReadBlocks(self):

926

def printReadBlocks(self):

927

928

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

928

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

929

930

def printTotalBlocks(self):

930

def printTotalBlocks(self):

931

932

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

932

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

933

934

def printNumberOfBlock(self):

934

def printNumberOfBlock(self):

935

936

if self.flagIsNewBlock:

936

if self.flagIsNewBlock:

937

print "Block No. %04d, Total blocks %04d -> %s" %(self.basicHeaderObj.dataBlock, self.nTotalBlocks, self.dataOut.datatime.ctime())

937

print "Block No. %04d, Total blocks %04d -> %s" %(self.basicHeaderObj.dataBlock, self.nTotalBlocks, self.dataOut.datatime.ctime())

938

939

def printInfo(self):

939

def printInfo(self):

940

941

if self.__printInfo == False:

941

if self.__printInfo == False:

942

return

942

return

943

944

self.basicHeaderObj.printInfo()

944

self.basicHeaderObj.printInfo()

945

self.systemHeaderObj.printInfo()

945

self.systemHeaderObj.printInfo()

946

self.radarControllerHeaderObj.printInfo()

946

self.radarControllerHeaderObj.printInfo()

947

self.processingHeaderObj.printInfo()

947

self.processingHeaderObj.printInfo()

948

949

self.__printInfo = False

949

self.__printInfo = False

950

951

952

def run(self, **kwargs):

952

def run(self, **kwargs):

953

954

if not(self.isConfig):

954

if not(self.isConfig):

955

956

# self.dataOut = dataOut

956

# self.dataOut = dataOut

957

self.setup(**kwargs)

957

self.setup(**kwargs)

958

self.isConfig = True

958

self.isConfig = True

959

960

self.getData()

960

self.getData()

961

962

class JRODataWriter(JRODataIO, Operation):

962

class JRODataWriter(JRODataIO, Operation):

963

964

"""

964

"""

965

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

965

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

966

de los datos siempre se realiza por bloques.

966

de los datos siempre se realiza por bloques.

967

"""

967

"""

968

969

blockIndex = 0

969

blockIndex = 0

970

971

path = None

971

path = None

972

973

setFile = None

973

setFile = None

974

975

profilesPerBlock = None

975

profilesPerBlock = None

976

977

blocksPerFile = None

977

blocksPerFile = None

978

979

nWriteBlocks = 0

979

nWriteBlocks = 0

980

981

def __init__(self, dataOut=None):

981

def __init__(self, dataOut=None):

982

raise ValueError, "Not implemented"

982

raise ValueError, "Not implemented"

983

984

985

def hasAllDataInBuffer(self):

985

def hasAllDataInBuffer(self):

986

raise ValueError, "Not implemented"

986

raise ValueError, "Not implemented"

987

988

989

def setBlockDimension(self):

989

def setBlockDimension(self):

990

raise ValueError, "Not implemented"

990

raise ValueError, "Not implemented"

991

992

993

def writeBlock(self):

993

def writeBlock(self):

994

raise ValueError, "No implemented"

994

raise ValueError, "No implemented"

995

996

997

def putData(self):

997

def putData(self):

998

raise ValueError, "No implemented"

998

raise ValueError, "No implemented"

999

1000

def getDataHeader(self):

1000

def getDataHeader(self):

1001

"""

1001

"""

1002

Obtiene una copia del First Header

1002

Obtiene una copia del First Header

1003

1004

Affected:

1004

Affected:

1005

1006

self.basicHeaderObj

1006

self.basicHeaderObj

1007

self.systemHeaderObj

1007

self.systemHeaderObj

1008

self.radarControllerHeaderObj

1008

self.radarControllerHeaderObj

1009

self.processingHeaderObj self.

1009

self.processingHeaderObj self.

1010

1011

Return:

1011

Return:

1012

None

1012

None

1013

"""

1013

"""

1014

1015

raise ValueError, "No implemented"

1015

raise ValueError, "No implemented"

1016

1017

def getBasicHeader(self):

1017

def getBasicHeader(self):

1018

1019

self.basicHeaderObj.size = self.basicHeaderSize #bytes

1019

self.basicHeaderObj.size = self.basicHeaderSize #bytes

1020

self.basicHeaderObj.version = self.versionFile

1020

self.basicHeaderObj.version = self.versionFile

1021

self.basicHeaderObj.dataBlock = self.nTotalBlocks

1021

self.basicHeaderObj.dataBlock = self.nTotalBlocks

1022

1023

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

1023

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

1024

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

1024

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

1025

1026

self.basicHeaderObj.utc = utc

1026

self.basicHeaderObj.utc = utc

1027

self.basicHeaderObj.miliSecond = milisecond

1027

self.basicHeaderObj.miliSecond = milisecond

1028

self.basicHeaderObj.timeZone = 0

1028

self.basicHeaderObj.timeZone = 0

1029

self.basicHeaderObj.dstFlag = 0

1029

self.basicHeaderObj.dstFlag = 0

1030

self.basicHeaderObj.errorCount = 0

1030

self.basicHeaderObj.errorCount = 0

1031

1032

def __writeFirstHeader(self):

1032

def __writeFirstHeader(self):

1033

"""

1033

"""

1034

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

1034

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

1035

1036

Affected:

1036

Affected:

1037

__dataType

1037

__dataType

1038

1039

Return:

1039

Return:

1040

None

1040

None

1041

"""

1041

"""

1042

1043

# CALCULAR PARAMETROS

1043

# CALCULAR PARAMETROS

1044

1045

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

1045

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

1046

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

1046

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

1047

1048

self.basicHeaderObj.write(self.fp)

1048

self.basicHeaderObj.write(self.fp)

1049

self.systemHeaderObj.write(self.fp)

1049

self.systemHeaderObj.write(self.fp)

1050

self.radarControllerHeaderObj.write(self.fp)

1050

self.radarControllerHeaderObj.write(self.fp)

1051

self.processingHeaderObj.write(self.fp)

1051

self.processingHeaderObj.write(self.fp)

1052

1053

self.dtype = self.dataOut.dtype

1053

self.dtype = self.dataOut.dtype

1054

1055

def __setNewBlock(self):

1055

def __setNewBlock(self):

1056

"""

1056

"""

1057

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

1057

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

1058

1059

Return:

1059

Return:

1060

0 : si no pudo escribir nada

1060

0 : si no pudo escribir nada

1061

1 : Si escribio el Basic el First Header

1061

1 : Si escribio el Basic el First Header

1062

"""

1062

"""

1063

if self.fp == None:

1063

if self.fp == None:

1064

self.setNextFile()

1064

self.setNextFile()

1065

1066

if self.flagIsNewFile:

1066

if self.flagIsNewFile:

1067

return 1

1067

return 1

1068

1069

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

1069

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

1070

self.basicHeaderObj.write(self.fp)

1070

self.basicHeaderObj.write(self.fp)

1071

return 1

1071

return 1

1072

1073

if not( self.setNextFile() ):

1073

if not( self.setNextFile() ):

1074

return 0

1074

return 0

1075

1076

return 1

1076

return 1

1077

1078

1079

def writeNextBlock(self):

1079

def writeNextBlock(self):

1080

"""

1080

"""

1081

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

1081

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

1082

1083

Return:

1083

Return:

1084

0 : Si no hizo pudo escribir el bloque de datos

1084

0 : Si no hizo pudo escribir el bloque de datos

1085

1 : Si no pudo escribir el bloque de datos

1085

1 : Si no pudo escribir el bloque de datos

1086

"""

1086

"""

1087

if not( self.__setNewBlock() ):

1087

if not( self.__setNewBlock() ):

1088

return 0

1088

return 0

1089

1090

self.writeBlock()

1090

self.writeBlock()

1091

1092

return 1

1092

return 1

1093

1094

def setNextFile(self):

1094

def setNextFile(self):

1095

"""

1095

"""

1096

Determina el siguiente file que sera escrito

1096

Determina el siguiente file que sera escrito

1097

1098

Affected:

1098

Affected:

1099

self.filename

1099

self.filename

1100

self.subfolder

1100

self.subfolder

1101

self.fp

1101

self.fp

1102

self.setFile

1102

self.setFile

1103

self.flagIsNewFile

1103

self.flagIsNewFile

1104

1105

Return:

1105

Return:

1106

0 : Si el archivo no puede ser escrito

1106

0 : Si el archivo no puede ser escrito

1107

1 : Si el archivo esta listo para ser escrito

1107

1 : Si el archivo esta listo para ser escrito

1108

"""

1108

"""

1109

ext = self.ext

1109

ext = self.ext

1110

path = self.path

1110

path = self.path

1111

1112

if self.fp != None:

1112

if self.fp != None:

1113

self.fp.close()

1113

self.fp.close()

1114

1115

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

1115

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

1116

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

1116

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

1117

1118

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

1118

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

1119

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

1119

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

1120

os.mkdir(fullpath)

1120

os.mkdir(fullpath)

1121

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

1121

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

1122

else:

1122

else:

1123

filesList = os.listdir( fullpath )

1123

filesList = os.listdir( fullpath )

1124

if len( filesList ) > 0:

1124

if len( filesList ) > 0:

1125

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

1125

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

1126

filen = filesList[-1]

1126

filen = filesList[-1]

1127

# el filename debera tener el siguiente formato

1127

# el filename debera tener el siguiente formato

1128

# 0 1234 567 89A BCDE (hex)

1128

# 0 1234 567 89A BCDE (hex)

1129

# x YYYY DDD SSS .ext

1129

# x YYYY DDD SSS .ext

1130

if isNumber( filen[8:11] ):

1130

if isNumber( filen[8:11] ):

1131

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

1131

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

1132

else:

1132

else:

1133

self.setFile = -1

1133

self.setFile = -1

1134

else:

1134

else:

1135

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

1135

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

1136

1137

setFile = self.setFile

1137

setFile = self.setFile

1138

setFile += 1

1138

setFile += 1

1139

1140

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

1140

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

1141

timeTuple.tm_year,

1141

timeTuple.tm_year,

1142

timeTuple.tm_yday,

1142

timeTuple.tm_yday,

1143

setFile,

1143

setFile,

1144

ext )

1144

ext )

1145

1146

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

1146

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

1147

1148

fp = open( filename,'wb' )

1148

fp = open( filename,'wb' )

1149

1150

self.blockIndex = 0

1150

self.blockIndex = 0

1151

1152

#guardando atributos

1152

#guardando atributos

1153

self.filename = filename

1153

self.filename = filename

1154

self.subfolder = subfolder

1154

self.subfolder = subfolder

1155

self.fp = fp

1155

self.fp = fp

1156

self.setFile = setFile

1156

self.setFile = setFile

1157

self.flagIsNewFile = 1

1157

self.flagIsNewFile = 1

1158

1159

self.getDataHeader()

1159

self.getDataHeader()

1160

1161

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

1161

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

1162

1163

self.__writeFirstHeader()

1163

self.__writeFirstHeader()

1164

1165

return 1

1165

return 1

1166

1167

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

1167

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

1168

"""

1168

"""

1169

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

1169

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

1170

1171

Inputs:

1171

Inputs:

1172

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

1172

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

1173

format : formato en el cual sera salvado un file

1173

format : formato en el cual sera salvado un file

1174

set : el setebo del file

1174

set : el setebo del file

1175

1176

Return:

1176

Return:

1177

0 : Si no realizo un buen seteo

1177

0 : Si no realizo un buen seteo

1178

1 : Si realizo un buen seteo

1178

1 : Si realizo un buen seteo

1179

"""

1179

"""

1180

1181

if ext == None:

1181

if ext == None:

1182

ext = self.ext

1182

ext = self.ext

1183

1184

ext = ext.lower()

1184

ext = ext.lower()

1185

1186

self.ext = ext

1186

self.ext = ext

1187

1188

self.path = path

1188

self.path = path

1189

1190

self.setFile = set - 1

1190

self.setFile = set - 1

1191

1192

self.blocksPerFile = blocksPerFile

1192

self.blocksPerFile = blocksPerFile

1193

1194

self.profilesPerBlock = profilesPerBlock

1194

self.profilesPerBlock = profilesPerBlock

1195

1196

self.dataOut = dataOut

1196

self.dataOut = dataOut

1197

1198

if not(self.setNextFile()):

1198

if not(self.setNextFile()):

1199

print "There isn't a next file"

1199

print "There isn't a next file"

1200

return 0

1200

return 0

1201

1202

self.setBlockDimension()

1202

self.setBlockDimension()

1203

1204

return 1

1204

return 1

1205

1206

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

1206

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

1207

1208

if not(self.isConfig):

1208

if not(self.isConfig):

1209

1210

self.setup(dataOut, **kwargs)

1210

self.setup(dataOut, **kwargs)

1211

self.isConfig = True

1211

self.isConfig = True

1212

1213

self.putData()

1213

self.putData()

1214

1215

class VoltageReader(JRODataReader):

1215

class VoltageReader(JRODataReader):

1216

"""

1216

"""

1217

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

1217

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

1218

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

1218

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

1219

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

1219

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

1220

1221

perfiles * alturas * canales

1221

perfiles * alturas * canales

1222

1223

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

1223

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

1224

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

1224

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

1225

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

1225

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

1226

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

1226

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

1227

1228

Example:

1228

Example:

1229

1230

dpath = "/home/myuser/data"

1230

dpath = "/home/myuser/data"

1231

1232

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

1232

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

1233

1234

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

1234

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

1235

1236

readerObj = VoltageReader()

1236

readerObj = VoltageReader()

1237

1238

readerObj.setup(dpath, startTime, endTime)

1238

readerObj.setup(dpath, startTime, endTime)

1239

1240

while(True):

1240

while(True):

1241

1242

#to get one profile

1242

#to get one profile

1243

profile = readerObj.getData()

1243

profile = readerObj.getData()

1244

1245

#print the profile

1245

#print the profile

1246

print profile

1246

print profile

1247

1248

#If you want to see all datablock

1248

#If you want to see all datablock

1249

print readerObj.datablock

1249

print readerObj.datablock

1250

1251

if readerObj.flagNoMoreFiles:

1251

if readerObj.flagNoMoreFiles:

1252

break

1252

break

1253

1254

"""

1254

"""

1255

1256

ext = ".r"

1256

ext = ".r"

1257

1258

optchar = "D"

1258

optchar = "D"

1259

dataOut = None

1259

dataOut = None

1260

1261

1262

def __init__(self):

1262

def __init__(self):

1263

"""

1263

"""

1264

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

1264

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

1265

1266

Input:

1266

Input:

1267

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

1267

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

1268

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

1268

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

1269

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

1269

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

1270

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

1270

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

1271

bloque de datos.

1271

bloque de datos.

1272

Si este parametro no es pasado se creara uno internamente.

1272

Si este parametro no es pasado se creara uno internamente.

1273

1274

Variables afectadas:

1274

Variables afectadas:

1275

self.dataOut

1275

self.dataOut

1276

1277

Return:

1277

Return:

1278

None

1278

None

1279

"""

1279

"""

1280

1281

self.isConfig = False

1281

self.isConfig = False

1282

1283

self.datablock = None

1283

self.datablock = None

1284

1285

self.utc = 0

1285

self.utc = 0

1286

1287

self.ext = ".r"

1287

self.ext = ".r"

1288

1289

self.optchar = "D"

1289

self.optchar = "D"

1290

1291

self.basicHeaderObj = BasicHeader(LOCALTIME)

1291

self.basicHeaderObj = BasicHeader(LOCALTIME)

1292

1293

self.systemHeaderObj = SystemHeader()

1293

self.systemHeaderObj = SystemHeader()

1294

1295

self.radarControllerHeaderObj = RadarControllerHeader()

1295

self.radarControllerHeaderObj = RadarControllerHeader()

1296

1297

self.processingHeaderObj = ProcessingHeader()

1297

self.processingHeaderObj = ProcessingHeader()

1298

1299

self.online = 0

1299

self.online = 0

1300

1301

self.fp = None

1301

self.fp = None

1302

1303

self.idFile = None

1303

self.idFile = None

1304

1305

self.dtype = None

1305

self.dtype = None

1306

1307

self.fileSizeByHeader = None

1307

self.fileSizeByHeader = None

1308

1309

self.filenameList = []

1309

self.filenameList = []

1310

1311

self.filename = None

1311

self.filename = None

1312

1313

self.fileSize = None

1313

self.fileSize = None

1314

1315

self.firstHeaderSize = 0

1315

self.firstHeaderSize = 0

1316

1317

self.basicHeaderSize = 24

1317

self.basicHeaderSize = 24

1318

1319

self.pathList = []

1319

self.pathList = []

1320

1321

self.filenameList = []

1321

self.filenameList = []

1322

1323

self.lastUTTime = 0

1323

self.lastUTTime = 0

1324

1325

self.maxTimeStep = 30

1325

self.maxTimeStep = 30

1326

1327

self.flagNoMoreFiles = 0

1327

self.flagNoMoreFiles = 0

1328

1329

self.set = 0

1329

self.set = 0

1330

1331

self.path = None

1331

self.path = None

1332

1333

self.profileIndex = 2**32-1

1333

self.profileIndex = 2**32-1

1334

1335

self.delay = 3 #seconds

1335

self.delay = 3 #seconds

1336

1337

self.nTries = 3 #quantity tries

1337

self.nTries = 3 #quantity tries

1338

1339

self.nFiles = 3 #number of files for searching

1339

self.nFiles = 3 #number of files for searching

1340

1341

self.nReadBlocks = 0

1341

self.nReadBlocks = 0

1342

1343

self.flagIsNewFile = 1

1343

self.flagIsNewFile = 1

1344

1345

self.__isFirstTimeOnline = 1

1345

self.__isFirstTimeOnline = 1

1346

1347

self.ippSeconds = 0

1347

self.ippSeconds = 0

1348

1349

self.flagTimeBlock = 0

1349

self.flagTimeBlock = 0

1350

1351

self.flagIsNewBlock = 0

1351

self.flagIsNewBlock = 0

1352

1353

self.nTotalBlocks = 0

1353

self.nTotalBlocks = 0

1354

1355

self.blocksize = 0

1355

self.blocksize = 0

1356

1357

self.dataOut = self.createObjByDefault()

1357

self.dataOut = self.createObjByDefault()

1358

1359

def createObjByDefault(self):

1359

def createObjByDefault(self):

1360

1361

dataObj = Voltage()

1361

dataObj = Voltage()

1362

1363

return dataObj

1363

return dataObj

1364

1365

def __hasNotDataInBuffer(self):

1365

def __hasNotDataInBuffer(self):

1366

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

1366

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

1367

return 1

1367

return 1

1368

return 0

1368

return 0

1369

1370

1371

def getBlockDimension(self):

1371

def getBlockDimension(self):

1372

"""

1372

"""

1373

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

1373

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

1374

1375

Affected:

1375

Affected:

1376

self.blocksize

1376

self.blocksize

1377

1378

Return:

1378

Return:

1379

None

1379

None

1380

"""

1380

"""

1381

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

1381

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

1382

self.blocksize = pts2read

1382

self.blocksize = pts2read

1383

1384

1385

def readBlock(self):

1385

def readBlock(self):

1386

"""

1386

"""

1387

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

1387

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

1388

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

1388

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

1389

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

1389

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

1390

es seteado a 0

1390

es seteado a 0

1391

1392

Inputs:

1392

Inputs:

1393

None

1393

None

1394

1395

Return:

1395

Return:

1396

None

1396

None

1397

1398

Affected:

1398

Affected:

1399

self.profileIndex

1399

self.profileIndex

1400

self.datablock

1400

self.datablock

1401

self.flagIsNewFile

1401

self.flagIsNewFile

1402

self.flagIsNewBlock

1402

self.flagIsNewBlock

1403

self.nTotalBlocks

1403

self.nTotalBlocks

1404

1405

Exceptions:

1405

Exceptions:

1406

Si un bloque leido no es un bloque valido

1406

Si un bloque leido no es un bloque valido

1407

"""

1407

"""

1408

1409

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

1409

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

1410

1411

try:

1411

try:

1412

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

1412

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

1413

except:

1413

except:

1414

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

1414

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

1415

return 0

1415

return 0

1416

1417

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

1417

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

1418

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

1418

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

1419

1420

self.profileIndex = 0

1420

self.profileIndex = 0

1421

1422

self.flagIsNewFile = 0

1422

self.flagIsNewFile = 0

1423

self.flagIsNewBlock = 1

1423

self.flagIsNewBlock = 1

1424

1425

self.nTotalBlocks += 1

1425

self.nTotalBlocks += 1

1426

self.nReadBlocks += 1

1426

self.nReadBlocks += 1

1427

1428

return 1

1428

return 1

1429

1430

1431

def getData(self):

1431

def getData(self):

1432

"""

1432

"""

1433

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

1433

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

1434

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

1434

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

1435

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

1435

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

1436

1437

Ademas incrementa el contador del buffer en 1.

1437

Ademas incrementa el contador del buffer en 1.

1438

1439

Return:

1439

Return:

1440

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

1440

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

1441

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

1441

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

1442

1443

Variables afectadas:

1443

Variables afectadas:

1444

self.dataOut

1444

self.dataOut

1445

self.profileIndex

1445

self.profileIndex

1446

1447

Affected:

1447

Affected:

1448

self.dataOut

1448

self.dataOut

1449

self.profileIndex

1449

self.profileIndex

1450

self.flagTimeBlock

1450

self.flagTimeBlock

1451

self.flagIsNewBlock

1451

self.flagIsNewBlock

1452

"""

1452

"""

1453

1454

if self.flagNoMoreFiles:

1454

if self.flagNoMoreFiles:

1455

self.dataOut.flagNoData = True

1455

self.dataOut.flagNoData = True

1456

print 'Process finished'

1456

print 'Process finished'

1457

return 0

1457

return 0

1458

1459

self.flagTimeBlock = 0

1459

self.flagTimeBlock = 0

1460

self.flagIsNewBlock = 0

1460

self.flagIsNewBlock = 0

1461

1462

if self.__hasNotDataInBuffer():

1462

if self.__hasNotDataInBuffer():

1463

1464

if not( self.readNextBlock() ):

1464

if not( self.readNextBlock() ):

1465

return 0

1465

return 0

1466

1467

self.dataOut.dtype = self.dtype

1467

self.dataOut.dtype = self.dtype

1468

1469

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1469

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1470

1471

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

1471

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

1472

1473

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

1473

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

1474

1475

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

1475

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

1476

1477

self.dataOut.flagTimeBlock = self.flagTimeBlock

1477

self.dataOut.flagTimeBlock = self.flagTimeBlock

1478

1479

self.dataOut.ippSeconds = self.ippSeconds

1479

self.dataOut.ippSeconds = self.ippSeconds

1480

1481

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

1481

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

1482

1483

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1483

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1484

1485

self.dataOut.flagShiftFFT = False

1485

self.dataOut.flagShiftFFT = False

1486

1487

if self.radarControllerHeaderObj.code != None:

1487

if self.radarControllerHeaderObj.code != None:

1488

1489

self.dataOut.nCode = self.radarControllerHeaderObj.nCode

1489

self.dataOut.nCode = self.radarControllerHeaderObj.nCode

1490

1491

self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud

1491

self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud

1492

1493

self.dataOut.code = self.radarControllerHeaderObj.code

1493

self.dataOut.code = self.radarControllerHeaderObj.code

1494

1495

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

1495

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

1496

1497

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

1497

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

1498

1499

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

1499

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

1500

1501

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

1501

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

1502

1503

self.dataOut.flagShiftFFT = False

1503

self.dataOut.flagShiftFFT = False

1504

1505

1506

# self.updateDataHeader()

1506

# self.updateDataHeader()

1507

1508

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

1508

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

1509

1510

if self.datablock == None:

1510

if self.datablock == None:

1511

self.dataOut.flagNoData = True

1511

self.dataOut.flagNoData = True

1512

return 0

1512

return 0

1513

1514

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

1514

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

1515

1516

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

1516

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

1517

1518

self.profileIndex += 1

1518

self.profileIndex += 1

1519

1520

self.dataOut.flagNoData = False

1520

self.dataOut.flagNoData = False

1521

1522

# print self.profileIndex, self.dataOut.utctime

1522

# print self.profileIndex, self.dataOut.utctime

1523

# if self.profileIndex == 800:

1523

# if self.profileIndex == 800:

1524

# a=1

1524

# a=1

1525

1526

1527

return self.dataOut.data

1527

return self.dataOut.data

1528

1529

1530

class VoltageWriter(JRODataWriter):

1530

class VoltageWriter(JRODataWriter):

1531

"""

1531

"""

1532

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

1532

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

1533

de los datos siempre se realiza por bloques.

1533

de los datos siempre se realiza por bloques.

1534

"""

1534

"""

1535

1536

ext = ".r"

1536

ext = ".r"

1537

1538

optchar = "D"

1538

optchar = "D"

1539

1540

shapeBuffer = None

1540

shapeBuffer = None

1541

1542

1543

def __init__(self):

1543

def __init__(self):

1544

"""

1544

"""

1545

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

1545

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

1546

1547

Affected:

1547

Affected:

1548

self.dataOut

1548

self.dataOut

1549

1550

Return: None

1550

Return: None

1551

"""

1551

"""

1552

1553

self.nTotalBlocks = 0

1553

self.nTotalBlocks = 0

1554

1555

self.profileIndex = 0

1555

self.profileIndex = 0

1556

1557

self.isConfig = False

1557

self.isConfig = False

1558

1559

self.fp = None

1559

self.fp = None

1560

1561

self.flagIsNewFile = 1

1561

self.flagIsNewFile = 1

1562

1563

self.nTotalBlocks = 0

1563

self.nTotalBlocks = 0

1564

1565

self.flagIsNewBlock = 0

1565

self.flagIsNewBlock = 0

1566

1567

self.setFile = None

1567

self.setFile = None

1568

1569

self.dtype = None

1569

self.dtype = None

1570

1571

self.path = None

1571

self.path = None

1572

1573

self.filename = None

1573

self.filename = None

1574

1575

self.basicHeaderObj = BasicHeader(LOCALTIME)

1575

self.basicHeaderObj = BasicHeader(LOCALTIME)

1576

1577

self.systemHeaderObj = SystemHeader()

1577

self.systemHeaderObj = SystemHeader()

1578

1579

self.radarControllerHeaderObj = RadarControllerHeader()

1579

self.radarControllerHeaderObj = RadarControllerHeader()

1580

1581

self.processingHeaderObj = ProcessingHeader()

1581

self.processingHeaderObj = ProcessingHeader()

1582

1583

def hasAllDataInBuffer(self):

1583

def hasAllDataInBuffer(self):

1584

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

1584

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

1585

return 1

1585

return 1

1586

return 0

1586

return 0

1587

1588

1589

def setBlockDimension(self):

1589

def setBlockDimension(self):

1590

"""

1590

"""

1591

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

1591

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

1592

1593

Affected:

1593

Affected:

1594

self.shape_spc_Buffer

1594

self.shape_spc_Buffer

1595

self.shape_cspc_Buffer

1595

self.shape_cspc_Buffer

1596

self.shape_dc_Buffer

1596

self.shape_dc_Buffer

1597

1598

Return: None

1598

Return: None

1599

"""

1599

"""

1600

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1600

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1601

self.processingHeaderObj.nHeights,

1601

self.processingHeaderObj.nHeights,

1602

self.systemHeaderObj.nChannels)

1602

self.systemHeaderObj.nChannels)

1603

1604

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

1604

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

1605

self.processingHeaderObj.profilesPerBlock,

1605

self.processingHeaderObj.profilesPerBlock,

1606

self.processingHeaderObj.nHeights),

1606

self.processingHeaderObj.nHeights),

1607

dtype=numpy.dtype('complex64'))

1607

dtype=numpy.dtype('complex64'))

1608

1609

1610

def writeBlock(self):

1610

def writeBlock(self):

1611

"""

1611

"""

1612

Escribe el buffer en el file designado

1612

Escribe el buffer en el file designado

1613

1614

Affected:

1614

Affected:

1615

self.profileIndex

1615

self.profileIndex

1616

self.flagIsNewFile

1616

self.flagIsNewFile

1617

self.flagIsNewBlock

1617

self.flagIsNewBlock

1618

self.nTotalBlocks

1618

self.nTotalBlocks

1619

self.blockIndex

1619

self.blockIndex

1620

1621

Return: None

1621

Return: None

1622

"""

1622

"""

1623

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

1623

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

1624

1625

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

1625

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

1626

1627

data['real'] = junk.real

1627

data['real'] = junk.real

1628

data['imag'] = junk.imag

1628

data['imag'] = junk.imag

1629

1630

data = data.reshape( (-1) )

1630

data = data.reshape( (-1) )

1631

1632

data.tofile( self.fp )

1632

data.tofile( self.fp )

1633

1634

self.datablock.fill(0)

1634

self.datablock.fill(0)

1635

1636

self.profileIndex = 0

1636

self.profileIndex = 0

1637

self.flagIsNewFile = 0

1637

self.flagIsNewFile = 0

1638

self.flagIsNewBlock = 1

1638

self.flagIsNewBlock = 1

1639

1640

self.blockIndex += 1

1640

self.blockIndex += 1

1641

self.nTotalBlocks += 1

1641

self.nTotalBlocks += 1

1642

1643

def putData(self):

1643

def putData(self):

1644

"""

1644

"""

1645

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

1645

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

1646

1647

Affected:

1647

Affected:

1648

self.flagIsNewBlock

1648

self.flagIsNewBlock

1649

self.profileIndex

1649

self.profileIndex

1650

1651

Return:

1651

Return:

1652

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

1652

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

1653

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

1653

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

1654

"""

1654

"""

1655

if self.dataOut.flagNoData:

1655

if self.dataOut.flagNoData:

1656

return 0

1656

return 0

1657

1658

self.flagIsNewBlock = 0

1658

self.flagIsNewBlock = 0

1659

1660

if self.dataOut.flagTimeBlock:

1660

if self.dataOut.flagTimeBlock:

1661

1662

self.datablock.fill(0)

1662

self.datablock.fill(0)

1663

self.profileIndex = 0

1663

self.profileIndex = 0

1664

self.setNextFile()

1664

self.setNextFile()

1665

1666

if self.profileIndex == 0:

1666

if self.profileIndex == 0:

1667

self.getBasicHeader()

1667

self.getBasicHeader()

1668

1669

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

1669

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

1670

1671

self.profileIndex += 1

1671

self.profileIndex += 1

1672

1673

if self.hasAllDataInBuffer():

1673

if self.hasAllDataInBuffer():

1674

#if self.flagIsNewFile:

1674

#if self.flagIsNewFile:

1675

self.writeNextBlock()

1675

self.writeNextBlock()

1676

# self.getDataHeader()

1676

# self.getDataHeader()

1677

1678

return 1

1678

return 1

1679

1680

def __getProcessFlags(self):

1680

def __getProcessFlags(self):

1681

1682

processFlags = 0

1682

processFlags = 0

1683

1684

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

1684

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

1685

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

1685

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

1686

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

1686

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

1687

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

1687

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

1688

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

1688

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

1689

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

1689

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

1690

1691

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

1691

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

1692

1693

1694

1695

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1695

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1696

PROCFLAG.DATATYPE_SHORT,

1696

PROCFLAG.DATATYPE_SHORT,

1697

PROCFLAG.DATATYPE_LONG,

1697

PROCFLAG.DATATYPE_LONG,

1698

PROCFLAG.DATATYPE_INT64,

1698

PROCFLAG.DATATYPE_INT64,

1699

PROCFLAG.DATATYPE_FLOAT,

1699

PROCFLAG.DATATYPE_FLOAT,

1700

PROCFLAG.DATATYPE_DOUBLE]

1700

PROCFLAG.DATATYPE_DOUBLE]

1701

1702

1703

for index in range(len(dtypeList)):

1703

for index in range(len(dtypeList)):

1704

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

1704

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

1705

dtypeValue = datatypeValueList[index]

1705

dtypeValue = datatypeValueList[index]

1706

break

1706

break

1707

1708

processFlags += dtypeValue

1708

processFlags += dtypeValue

1709

1710

if self.dataOut.flagDecodeData:

1710

if self.dataOut.flagDecodeData:

1711

processFlags += PROCFLAG.DECODE_DATA

1711

processFlags += PROCFLAG.DECODE_DATA

1712

1713

if self.dataOut.flagDeflipData:

1713

if self.dataOut.flagDeflipData:

1714

processFlags += PROCFLAG.DEFLIP_DATA

1714

processFlags += PROCFLAG.DEFLIP_DATA

1715

1716

if self.dataOut.code != None:

1716

if self.dataOut.code != None:

1717

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1717

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1718

1719

if self.dataOut.nCohInt > 1:

1719

if self.dataOut.nCohInt > 1:

1720

processFlags += PROCFLAG.COHERENT_INTEGRATION

1720

processFlags += PROCFLAG.COHERENT_INTEGRATION

1721

1722

return processFlags

1722

return processFlags

1723

1724

1725

def __getBlockSize(self):

1725

def __getBlockSize(self):

1726

'''

1726

'''

1727

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

1727

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

1728

'''

1728

'''

1729

1730

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

1730

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

1731

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

1731

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

1732

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

1732

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

1733

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

1733

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

1734

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

1734

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

1735

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

1735

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

1736

1737

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

1737

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

1738

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

1738

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

1739

for index in range(len(dtypeList)):

1739

for index in range(len(dtypeList)):

1740

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

1740

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

1741

datatypeValue = datatypeValueList[index]

1741

datatypeValue = datatypeValueList[index]

1742

break

1742

break

1743

1744

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

1744

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

1745

1746

return blocksize

1746

return blocksize

1747

1748

def getDataHeader(self):

1748

def getDataHeader(self):

1749

1750

"""

1750

"""

1751

Obtiene una copia del First Header

1751

Obtiene una copia del First Header

1752

1753

Affected:

1753

Affected:

1754

self.systemHeaderObj

1754

self.systemHeaderObj

1755

self.radarControllerHeaderObj

1755

self.radarControllerHeaderObj

1756

self.dtype

1756

self.dtype

1757

1758

Return:

1758

Return:

1759

None

1759

None

1760

"""

1760

"""

1761

1762

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

1762

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

1763

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1763

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1764

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

1764

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

1765

1766

self.getBasicHeader()

1766

self.getBasicHeader()

1767

1768

processingHeaderSize = 40 # bytes

1768

processingHeaderSize = 40 # bytes

1769

self.processingHeaderObj.dtype = 0 # Voltage

1769

self.processingHeaderObj.dtype = 0 # Voltage

1770

self.processingHeaderObj.blockSize = self.__getBlockSize()

1770

self.processingHeaderObj.blockSize = self.__getBlockSize()

1771

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1771

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1772

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1772

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1773

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

1773

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

1774

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1774

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1775

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1775

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1776

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

1776

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

1777

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

1777

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

1778

1779

if self.dataOut.code != None:

1779

if self.dataOut.code != None:

1780

self.processingHeaderObj.code = self.dataOut.code

1780

self.processingHeaderObj.code = self.dataOut.code

1781

self.processingHeaderObj.nCode = self.dataOut.nCode

1781

self.processingHeaderObj.nCode = self.dataOut.nCode

1782

self.processingHeaderObj.nBaud = self.dataOut.nBaud

1782

self.processingHeaderObj.nBaud = self.dataOut.nBaud

1783

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

1783

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

1784

processingHeaderSize += codesize

1784

processingHeaderSize += codesize

1785

1786

if self.processingHeaderObj.nWindows != 0:

1786

if self.processingHeaderObj.nWindows != 0:

1787

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

1787

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

1788

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

1788

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

1789

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1789

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1790

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1790

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1791

processingHeaderSize += 12

1791

processingHeaderSize += 12

1792

1793

self.processingHeaderObj.size = processingHeaderSize

1793

self.processingHeaderObj.size = processingHeaderSize

1794

1795

class SpectraReader(JRODataReader):

1795

class SpectraReader(JRODataReader):

1796

"""

1796

"""

1797

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

1797

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

1798

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

1798

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

1799

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

1799

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

1800

1801

paresCanalesIguales * alturas * perfiles (Self Spectra)

1801

paresCanalesIguales * alturas * perfiles (Self Spectra)

1802

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1802

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1803

canales * alturas (DC Channels)

1803

canales * alturas (DC Channels)

1804

1805

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

1805

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

1806

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

1806

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

1807

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

1807

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

1808

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

1808

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

1809

1810

Example:

1810

Example:

1811

dpath = "/home/myuser/data"

1811

dpath = "/home/myuser/data"

1812

1813

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

1813

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

1814

1815

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

1815

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

1816

1817

readerObj = SpectraReader()

1817

readerObj = SpectraReader()

1818

1819

readerObj.setup(dpath, startTime, endTime)

1819

readerObj.setup(dpath, startTime, endTime)

1820

1821

while(True):

1821

while(True):

1822

1823

readerObj.getData()

1823

readerObj.getData()

1824

1825

print readerObj.data_spc

1825

print readerObj.data_spc

1826

1827

print readerObj.data_cspc

1827

print readerObj.data_cspc

1828

1829

print readerObj.data_dc

1829

print readerObj.data_dc

1830

1831

if readerObj.flagNoMoreFiles:

1831

if readerObj.flagNoMoreFiles:

1832

break

1832

break

1833

1834

"""

1834

"""

1835

1836

pts2read_SelfSpectra = 0

1836

pts2read_SelfSpectra = 0

1837

1838

pts2read_CrossSpectra = 0

1838

pts2read_CrossSpectra = 0

1839

1840

pts2read_DCchannels = 0

1840

pts2read_DCchannels = 0

1841

1842

ext = ".pdata"

1842

ext = ".pdata"

1843

1844

optchar = "P"

1844

optchar = "P"

1845

1846

dataOut = None

1846

dataOut = None

1847

1848

nRdChannels = None

1848

nRdChannels = None

1849

1850

nRdPairs = None

1850

nRdPairs = None

1851

1852

rdPairList = []

1852

rdPairList = []

1853

1854

1855

def __init__(self):

1855

def __init__(self):

1856

"""

1856

"""

1857

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

1857

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

1858

1859

Inputs:

1859

Inputs:

1860

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

1860

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

1861

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

1861

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

1862

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

1862

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

1863

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

1863

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

1864

bloque de datos.

1864

bloque de datos.

1865

Si este parametro no es pasado se creara uno internamente.

1865

Si este parametro no es pasado se creara uno internamente.

1866

1867

Affected:

1867

Affected:

1868

self.dataOut

1868

self.dataOut

1869

1870

Return : None

1870

Return : None

1871

"""

1871

"""

1872

1873

self.isConfig = False

1873

self.isConfig = False

1874

1875

self.pts2read_SelfSpectra = 0

1875

self.pts2read_SelfSpectra = 0

1876

1877

self.pts2read_CrossSpectra = 0

1877

self.pts2read_CrossSpectra = 0

1878

1879

self.pts2read_DCchannels = 0

1879

self.pts2read_DCchannels = 0

1880

1881

self.datablock = None

1881

self.datablock = None

1882

1883

self.utc = None

1883

self.utc = None

1884

1885

self.ext = ".pdata"

1885

self.ext = ".pdata"

1886

1887

self.optchar = "P"

1887

self.optchar = "P"

1888

1889

self.basicHeaderObj = BasicHeader(LOCALTIME)

1889

self.basicHeaderObj = BasicHeader(LOCALTIME)

1890

1891

self.systemHeaderObj = SystemHeader()

1891

self.systemHeaderObj = SystemHeader()

1892

1893

self.radarControllerHeaderObj = RadarControllerHeader()

1893

self.radarControllerHeaderObj = RadarControllerHeader()

1894

1895

self.processingHeaderObj = ProcessingHeader()

1895

self.processingHeaderObj = ProcessingHeader()

1896

1897

self.online = 0

1897

self.online = 0

1898

1899

self.fp = None

1899

self.fp = None

1900

1901

self.idFile = None

1901

self.idFile = None

1902

1903

self.dtype = None

1903

self.dtype = None

1904

1905

self.fileSizeByHeader = None

1905

self.fileSizeByHeader = None

1906

1907

self.filenameList = []

1907

self.filenameList = []

1908

1909

self.filename = None

1909

self.filename = None

1910

1911

self.fileSize = None

1911

self.fileSize = None

1912

1913

self.firstHeaderSize = 0

1913

self.firstHeaderSize = 0

1914

1915

self.basicHeaderSize = 24

1915

self.basicHeaderSize = 24

1916

1917

self.pathList = []

1917

self.pathList = []

1918

1919

self.lastUTTime = 0

1919

self.lastUTTime = 0

1920

1921

self.maxTimeStep = 30

1921

self.maxTimeStep = 30

1922

1923

self.flagNoMoreFiles = 0

1923

self.flagNoMoreFiles = 0

1924

1925

self.set = 0

1925

self.set = 0

1926

1927

self.path = None

1927

self.path = None

1928

1929

self.delay = 60 #seconds

1929

self.delay = 60 #seconds

1930

1931

self.nTries = 3 #quantity tries

1931

self.nTries = 3 #quantity tries

1932

1933

self.nFiles = 3 #number of files for searching

1933

self.nFiles = 3 #number of files for searching

1934

1935

self.nReadBlocks = 0

1935

self.nReadBlocks = 0

1936

1937

self.flagIsNewFile = 1

1937

self.flagIsNewFile = 1

1938

1939

self.__isFirstTimeOnline = 1

1939

self.__isFirstTimeOnline = 1

1940

1941

self.ippSeconds = 0

1941

self.ippSeconds = 0

1942

1943

self.flagTimeBlock = 0

1943

self.flagTimeBlock = 0

1944

1945

self.flagIsNewBlock = 0

1945

self.flagIsNewBlock = 0

1946

1947

self.nTotalBlocks = 0

1947

self.nTotalBlocks = 0

1948

1949

self.blocksize = 0

1949

self.blocksize = 0

1950

1951

self.dataOut = self.createObjByDefault()

1951

self.dataOut = self.createObjByDefault()

1952

1953

1954

def createObjByDefault(self):

1954

def createObjByDefault(self):

1955

1956

dataObj = Spectra()

1956

dataObj = Spectra()

1957

1958

return dataObj

1958

return dataObj

1959

1960

def __hasNotDataInBuffer(self):

1960

def __hasNotDataInBuffer(self):

1961

return 1

1961

return 1

1962

1963

1964

def getBlockDimension(self):

1964

def getBlockDimension(self):

1965

"""

1965

"""

1966

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

1966

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

1967

1968

Affected:

1968

Affected:

1969

self.nRdChannels

1969

self.nRdChannels

1970

self.nRdPairs

1970

self.nRdPairs

1971

self.pts2read_SelfSpectra

1971

self.pts2read_SelfSpectra

1972

self.pts2read_CrossSpectra

1972

self.pts2read_CrossSpectra

1973

self.pts2read_DCchannels

1973

self.pts2read_DCchannels

1974

self.blocksize

1974

self.blocksize

1975

self.dataOut.nChannels

1975

self.dataOut.nChannels

1976

self.dataOut.nPairs

1976

self.dataOut.nPairs

1977

1978

Return:

1978

Return:

1979

None

1979

None

1980

"""

1980

"""

1981

self.nRdChannels = 0

1981

self.nRdChannels = 0

1982

self.nRdPairs = 0

1982

self.nRdPairs = 0

1983

self.rdPairList = []

1983

self.rdPairList = []

1984

1985

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

1985

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

1986

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

1986

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

1987

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

1987

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

1988

else:

1988

else:

1989

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

1989

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

1990

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

1990

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

1991

1992

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

1992

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

1993

1994

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

1994

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

1995

self.blocksize = self.pts2read_SelfSpectra

1995

self.blocksize = self.pts2read_SelfSpectra

1996

1997

if self.processingHeaderObj.flag_cspc:

1997

if self.processingHeaderObj.flag_cspc:

1998

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

1998

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

1999

self.blocksize += self.pts2read_CrossSpectra

1999

self.blocksize += self.pts2read_CrossSpectra

2000

2001

if self.processingHeaderObj.flag_dc:

2001

if self.processingHeaderObj.flag_dc:

2002

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

2002

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

2003

self.blocksize += self.pts2read_DCchannels

2003

self.blocksize += self.pts2read_DCchannels

2004

2005

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

2005

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

2006

2007

2008

def readBlock(self):

2008

def readBlock(self):

2009

"""

2009

"""

2010

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

2010

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

2011

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

2011

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

2012

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

2012

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

2013

es seteado a 0

2013

es seteado a 0

2014

2015

Return: None

2015

Return: None

2016

2017

Variables afectadas:

2017

Variables afectadas:

2018

2019

self.flagIsNewFile

2019

self.flagIsNewFile

2020

self.flagIsNewBlock

2020

self.flagIsNewBlock

2021

self.nTotalBlocks

2021

self.nTotalBlocks

2022

self.data_spc

2022

self.data_spc

2023

self.data_cspc

2023

self.data_cspc

2024

self.data_dc

2024

self.data_dc

2025

2026

Exceptions:

2026

Exceptions:

2027

Si un bloque leido no es un bloque valido

2027

Si un bloque leido no es un bloque valido

2028

"""

2028

"""

2029

blockOk_flag = False

2029

blockOk_flag = False

2030

fpointer = self.fp.tell()

2030

fpointer = self.fp.tell()

2031

2032

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

2032

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

2033

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

2033

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

2034

2035

if self.processingHeaderObj.flag_cspc:

2035

if self.processingHeaderObj.flag_cspc:

2036

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

2036

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

2037

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

2037

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

2038

2039

if self.processingHeaderObj.flag_dc:

2039

if self.processingHeaderObj.flag_dc:

2040

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

2040

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

2041

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

2041

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

2042

2043

2044

if not(self.processingHeaderObj.shif_fft):

2044

if not(self.processingHeaderObj.shif_fft):

2045

#desplaza a la derecha en el eje 2 determinadas posiciones

2045

#desplaza a la derecha en el eje 2 determinadas posiciones

2046

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

2046

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

2047

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

2047

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

2048

2049

if self.processingHeaderObj.flag_cspc:

2049

if self.processingHeaderObj.flag_cspc:

2050

#desplaza a la derecha en el eje 2 determinadas posiciones

2050

#desplaza a la derecha en el eje 2 determinadas posiciones

2051

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

2051

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

2052

2053

# self.processingHeaderObj.shif_fft = True

2053

# self.processingHeaderObj.shif_fft = True

2054

2055

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

2055

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

2056

self.data_spc = spc

2056

self.data_spc = spc

2057

2058

if self.processingHeaderObj.flag_cspc:

2058

if self.processingHeaderObj.flag_cspc:

2059

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

2059

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

2060

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

2060

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

2061

else:

2061

else:

2062

self.data_cspc = None

2062

self.data_cspc = None

2063

2064

if self.processingHeaderObj.flag_dc:

2064

if self.processingHeaderObj.flag_dc:

2065

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

2065

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

2066

else:

2066

else:

2067

self.data_dc = None

2067

self.data_dc = None

2068

2069

self.flagIsNewFile = 0

2069

self.flagIsNewFile = 0

2070

self.flagIsNewBlock = 1

2070

self.flagIsNewBlock = 1

2071

2072

self.nTotalBlocks += 1

2072

self.nTotalBlocks += 1

2073

self.nReadBlocks += 1

2073

self.nReadBlocks += 1

2074

2075

return 1

2075

return 1

2076

2077

2078

def getData(self):

2078

def getData(self):

2079

"""

2079

"""

2080

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

2080

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

2081

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

2081

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

2082

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

2082

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

2083

2084

Return:

2084

Return:

2085

0 : Si no hay mas archivos disponibles

2085

0 : Si no hay mas archivos disponibles

2086

1 : Si hizo una buena copia del buffer

2086

1 : Si hizo una buena copia del buffer

2087

2088

Affected:

2088

Affected:

2089

self.dataOut

2089

self.dataOut

2090

2091

self.flagTimeBlock

2091

self.flagTimeBlock

2092

self.flagIsNewBlock

2092

self.flagIsNewBlock

2093

"""

2093

"""

2094

2095

if self.flagNoMoreFiles:

2095

if self.flagNoMoreFiles:

2096

self.dataOut.flagNoData = True

2096

self.dataOut.flagNoData = True

2097

print 'Process finished'

2097

print 'Process finished'

2098

return 0

2098

return 0

2099

2100

self.flagTimeBlock = 0

2100

self.flagTimeBlock = 0

2101

self.flagIsNewBlock = 0

2101

self.flagIsNewBlock = 0

2102

2103

if self.__hasNotDataInBuffer():

2103

if self.__hasNotDataInBuffer():

2104

2105

if not( self.readNextBlock() ):

2105

if not( self.readNextBlock() ):

2106

self.dataOut.flagNoData = True

2106

self.dataOut.flagNoData = True

2107

return 0

2107

return 0

2108

2109

# self.updateDataHeader()

2109

# self.updateDataHeader()

2110

2111

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

2111

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

2112

2113

if self.data_dc == None:

2113

if self.data_dc == None:

2114

self.dataOut.flagNoData = True

2114

self.dataOut.flagNoData = True

2115

return 0

2115

return 0

2116

2117

self.dataOut.data_spc = self.data_spc

2117

self.dataOut.data_spc = self.data_spc

2118

2119

self.dataOut.data_cspc = self.data_cspc

2119

self.dataOut.data_cspc = self.data_cspc

2120

2121

self.dataOut.data_dc = self.data_dc

2121

self.dataOut.data_dc = self.data_dc

2122

2123

self.dataOut.flagTimeBlock = self.flagTimeBlock

2123

self.dataOut.flagTimeBlock = self.flagTimeBlock

2124

2125

self.dataOut.flagNoData = False

2125

self.dataOut.flagNoData = False

2126

2127

self.dataOut.dtype = self.dtype

2127

self.dataOut.dtype = self.dtype

2128

2129

# self.dataOut.nChannels = self.nRdChannels

2129

# self.dataOut.nChannels = self.nRdChannels

2130

2131

self.dataOut.nPairs = self.nRdPairs

2131

self.dataOut.nPairs = self.nRdPairs

2132

2133

self.dataOut.pairsList = self.rdPairList

2133

self.dataOut.pairsList = self.rdPairList

2134

2135

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

2135

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

2136

2137

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

2137

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

2138

2139

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

2139

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

2140

2141

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

2141

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

2142

2143

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

2143

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

2144

2145

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

2145

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

2146

2147

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

2147

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

2148

2149

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

2149

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

2150

2151

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

2151

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

2152

2153

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

2153

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

2154

2155

self.dataOut.ippSeconds = self.ippSeconds

2155

self.dataOut.ippSeconds = self.ippSeconds

2156

2157

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

2157

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

2158

2159

# self.profileIndex += 1

2159

# self.profileIndex += 1

2160

2161

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

2161

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

2162

2163

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

2163

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

2164

2165

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

2165

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

2166

2167

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

2167

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

2168

2169

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

2169

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

2170

2171

if self.processingHeaderObj.code != None:

2171

if self.processingHeaderObj.code != None:

2172

2173

self.dataOut.nCode = self.processingHeaderObj.nCode

2173

self.dataOut.nCode = self.processingHeaderObj.nCode

2174

2175

self.dataOut.nBaud = self.processingHeaderObj.nBaud

2175

self.dataOut.nBaud = self.processingHeaderObj.nBaud

2176

2177

self.dataOut.code = self.processingHeaderObj.code

2177

self.dataOut.code = self.processingHeaderObj.code

2178

2179

self.dataOut.flagDecodeData = True

2179

self.dataOut.flagDecodeData = True

2180

2181

return self.dataOut.data_spc

2181

return self.dataOut.data_spc

2182

2183

2184

class SpectraWriter(JRODataWriter):

2184

class SpectraWriter(JRODataWriter):

2185

2186

"""

2186

"""

2187

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

2187

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

2188

de los datos siempre se realiza por bloques.

2188

de los datos siempre se realiza por bloques.

2189

"""

2189

"""

2190

2191

ext = ".pdata"

2191

ext = ".pdata"

2192

2193

optchar = "P"

2193

optchar = "P"

2194

2195

shape_spc_Buffer = None

2195

shape_spc_Buffer = None

2196

2197

shape_cspc_Buffer = None

2197

shape_cspc_Buffer = None

2198

2199

shape_dc_Buffer = None

2199

shape_dc_Buffer = None

2200

2201

data_spc = None

2201

data_spc = None

2202

2203

data_cspc = None

2203

data_cspc = None

2204

2205

data_dc = None

2205

data_dc = None

2206

2207

# dataOut = None

2207

# dataOut = None

2208

2209

def __init__(self):

2209

def __init__(self):

2210

"""

2210

"""

2211

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

2211

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

2212

2213

Affected:

2213

Affected:

2214

self.dataOut

2214

self.dataOut

2215

self.basicHeaderObj

2215

self.basicHeaderObj

2216

self.systemHeaderObj

2216

self.systemHeaderObj

2217

self.radarControllerHeaderObj

2217

self.radarControllerHeaderObj

2218

self.processingHeaderObj

2218

self.processingHeaderObj

2219

2220

Return: None

2220

Return: None

2221

"""

2221

"""

2222

2223

self.isConfig = False

2223

self.isConfig = False

2224

2225

self.nTotalBlocks = 0

2225

self.nTotalBlocks = 0

2226

2227

self.data_spc = None

2227

self.data_spc = None

2228

2229

self.data_cspc = None

2229

self.data_cspc = None

2230

2231

self.data_dc = None

2231

self.data_dc = None

2232

2233

self.fp = None

2233

self.fp = None

2234

2235

self.flagIsNewFile = 1

2235

self.flagIsNewFile = 1

2236

2237

self.nTotalBlocks = 0

2237

self.nTotalBlocks = 0

2238

2239

self.flagIsNewBlock = 0

2239

self.flagIsNewBlock = 0

2240

2241

self.setFile = None

2241

self.setFile = None

2242

2243

self.dtype = None

2243

self.dtype = None

2244

2245

self.path = None

2245

self.path = None

2246

2247

self.noMoreFiles = 0

2247

self.noMoreFiles = 0

2248

2249

self.filename = None

2249

self.filename = None

2250

2251

self.basicHeaderObj = BasicHeader(LOCALTIME)

2251

self.basicHeaderObj = BasicHeader(LOCALTIME)

2252

2253

self.systemHeaderObj = SystemHeader()

2253

self.systemHeaderObj = SystemHeader()

2254

2255

self.radarControllerHeaderObj = RadarControllerHeader()

2255

self.radarControllerHeaderObj = RadarControllerHeader()

2256

2257

self.processingHeaderObj = ProcessingHeader()

2257

self.processingHeaderObj = ProcessingHeader()

2258

2259

2260

def hasAllDataInBuffer(self):

2260

def hasAllDataInBuffer(self):

2261

return 1

2261

return 1

2262

2263

2264

def setBlockDimension(self):

2264

def setBlockDimension(self):

2265

"""

2265

"""

2266

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

2266

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

2267

2268

Affected:

2268

Affected:

2269

self.shape_spc_Buffer

2269

self.shape_spc_Buffer

2270

self.shape_cspc_Buffer

2270

self.shape_cspc_Buffer

2271

self.shape_dc_Buffer

2271

self.shape_dc_Buffer

2272

2273

Return: None

2273

Return: None

2274

"""

2274

"""

2275

self.shape_spc_Buffer = (self.dataOut.nChannels,

2275

self.shape_spc_Buffer = (self.dataOut.nChannels,

2276

self.processingHeaderObj.nHeights,

2276

self.processingHeaderObj.nHeights,

2277

self.processingHeaderObj.profilesPerBlock)

2277

self.processingHeaderObj.profilesPerBlock)

2278

2279

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2279

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2280

self.processingHeaderObj.nHeights,

2280

self.processingHeaderObj.nHeights,

2281

self.processingHeaderObj.profilesPerBlock)

2281

self.processingHeaderObj.profilesPerBlock)

2282

2283

self.shape_dc_Buffer = (self.dataOut.nChannels,

2283

self.shape_dc_Buffer = (self.dataOut.nChannels,

2284

self.processingHeaderObj.nHeights)

2284

self.processingHeaderObj.nHeights)

2285

2286

2287

def writeBlock(self):

2287

def writeBlock(self):

2288

"""

2288

"""

2289

Escribe el buffer en el file designado

2289

Escribe el buffer en el file designado

2290

2291

Affected:

2291

Affected:

2292

self.data_spc

2292

self.data_spc

2293

self.data_cspc

2293

self.data_cspc

2294

self.data_dc

2294

self.data_dc

2295

self.flagIsNewFile

2295

self.flagIsNewFile

2296

self.flagIsNewBlock

2296

self.flagIsNewBlock

2297

self.nTotalBlocks

2297

self.nTotalBlocks

2298

self.nWriteBlocks

2298

self.nWriteBlocks

2299

2300

Return: None

2300

Return: None

2301

"""

2301

"""

2302

2303

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

2303

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

2304

if not( self.processingHeaderObj.shif_fft ):

2304

if not( self.processingHeaderObj.shif_fft ):

2305

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

2305

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

2306

data = spc.reshape((-1))

2306

data = spc.reshape((-1))

2307

data = data.astype(self.dtype[0])

2307

data = data.astype(self.dtype[0])

2308

data.tofile(self.fp)

2308

data.tofile(self.fp)

2309

2310

if self.data_cspc != None:

2310

if self.data_cspc != None:

2311

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

2311

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

2312

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

2312

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

2313

if not( self.processingHeaderObj.shif_fft ):

2313

if not( self.processingHeaderObj.shif_fft ):

2314

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

2314

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

2315

data['real'] = cspc.real

2315

data['real'] = cspc.real

2316

data['imag'] = cspc.imag

2316

data['imag'] = cspc.imag

2317

data = data.reshape((-1))

2317

data = data.reshape((-1))

2318

data.tofile(self.fp)

2318

data.tofile(self.fp)

2319

2320

if self.data_dc != None:

2320

if self.data_dc != None:

2321

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

2321

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

2322

dc = self.data_dc

2322

dc = self.data_dc

2323

data['real'] = dc.real

2323

data['real'] = dc.real

2324

data['imag'] = dc.imag

2324

data['imag'] = dc.imag

2325

data = data.reshape((-1))

2325

data = data.reshape((-1))

2326

data.tofile(self.fp)

2326

data.tofile(self.fp)

2327

2328

self.data_spc.fill(0)

2328

self.data_spc.fill(0)

2329

self.data_dc.fill(0)

2329

self.data_dc.fill(0)

2330

if self.data_cspc != None:

2330

if self.data_cspc != None:

2331

self.data_cspc.fill(0)

2331

self.data_cspc.fill(0)

2332

2333

self.flagIsNewFile = 0

2333

self.flagIsNewFile = 0

2334

self.flagIsNewBlock = 1

2334

self.flagIsNewBlock = 1

2335

self.nTotalBlocks += 1

2335

self.nTotalBlocks += 1

2336

self.nWriteBlocks += 1

2336

self.nWriteBlocks += 1

2337

self.blockIndex += 1

2337

self.blockIndex += 1

2338

2339

2340

def putData(self):

2340

def putData(self):

2341

"""

2341

"""

2342

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

2342

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

2343

2344

Affected:

2344

Affected:

2345

self.data_spc

2345

self.data_spc

2346

self.data_cspc

2346

self.data_cspc

2347

self.data_dc

2347

self.data_dc

2348

2349

Return:

2349

Return:

2350

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

2350

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

2351

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

2351

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

2352

"""

2352

"""

2353

2354

if self.dataOut.flagNoData:

2354

if self.dataOut.flagNoData:

2355

return 0

2355

return 0

2356

2357

self.flagIsNewBlock = 0

2357

self.flagIsNewBlock = 0

2358

2359

if self.dataOut.flagTimeBlock:

2359

if self.dataOut.flagTimeBlock:

2360

self.data_spc.fill(0)

2360

self.data_spc.fill(0)

2361

self.data_cspc.fill(0)

2361

self.data_cspc.fill(0)

2362

self.data_dc.fill(0)

2362

self.data_dc.fill(0)

2363

self.setNextFile()

2363

self.setNextFile()

2364

2365

if self.flagIsNewFile == 0:

2365

if self.flagIsNewFile == 0:

2366

self.getBasicHeader()

2366

self.getBasicHeader()

2367

2368

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

2368

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

2369

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

2369

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

2370

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

2370

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

2371

2372

# #self.processingHeaderObj.dataBlocksPerFile)

2372

# #self.processingHeaderObj.dataBlocksPerFile)

2373

if self.hasAllDataInBuffer():

2373

if self.hasAllDataInBuffer():

2374

# self.getDataHeader()

2374

# self.getDataHeader()

2375

self.writeNextBlock()

2375

self.writeNextBlock()

2376

2377

return 1

2377

return 1

2378

2379

2380

def __getProcessFlags(self):

2380

def __getProcessFlags(self):

2381

2382

processFlags = 0

2382

processFlags = 0

2383

2384

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

2384

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

2385

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

2385

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

2386

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

2386

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

2387

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

2387

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

2388

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

2388

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

2389

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

2389

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

2390

2391

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

2391

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

2392

2393

2394

2395

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2395

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2396

PROCFLAG.DATATYPE_SHORT,

2396

PROCFLAG.DATATYPE_SHORT,

2397

PROCFLAG.DATATYPE_LONG,

2397

PROCFLAG.DATATYPE_LONG,

2398

PROCFLAG.DATATYPE_INT64,

2398

PROCFLAG.DATATYPE_INT64,

2399

PROCFLAG.DATATYPE_FLOAT,

2399

PROCFLAG.DATATYPE_FLOAT,

2400

PROCFLAG.DATATYPE_DOUBLE]

2400

PROCFLAG.DATATYPE_DOUBLE]

2401

2402

2403

for index in range(len(dtypeList)):

2403

for index in range(len(dtypeList)):

2404

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

2404

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

2405

dtypeValue = datatypeValueList[index]

2405

dtypeValue = datatypeValueList[index]

2406

break

2406

break

2407

2408

processFlags += dtypeValue

2408

processFlags += dtypeValue

2409

2410

if self.dataOut.flagDecodeData:

2410

if self.dataOut.flagDecodeData:

2411

processFlags += PROCFLAG.DECODE_DATA

2411

processFlags += PROCFLAG.DECODE_DATA

2412

2413

if self.dataOut.flagDeflipData:

2413

if self.dataOut.flagDeflipData:

2414

processFlags += PROCFLAG.DEFLIP_DATA

2414

processFlags += PROCFLAG.DEFLIP_DATA

2415

2416

if self.dataOut.code != None:

2416

if self.dataOut.code != None:

2417

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2417

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2418

2419

if self.dataOut.nIncohInt > 1:

2419

if self.dataOut.nIncohInt > 1:

2420

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2420

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2421

2422

if self.dataOut.data_dc != None:

2422

if self.dataOut.data_dc != None:

2423

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2423

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2424

2425

return processFlags

2425

return processFlags

2426

2427

2428

def __getBlockSize(self):

2428

def __getBlockSize(self):

2429

'''

2429

'''

2430

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

2430

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

2431

'''

2431

'''

2432

2433

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

2433

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

2434

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

2434

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

2435

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

2435

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

2436

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

2436

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

2437

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

2437

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

2438

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

2438

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

2439

2440

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

2440

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

2441

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

2441

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

2442

for index in range(len(dtypeList)):

2442

for index in range(len(dtypeList)):

2443

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

2443

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

2444

datatypeValue = datatypeValueList[index]

2444

datatypeValue = datatypeValueList[index]

2445

break

2445

break

2446

2447

2448

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

2448

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

2449

2450

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

2450

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

2451

blocksize = (pts2write_SelfSpectra*datatypeValue)

2451

blocksize = (pts2write_SelfSpectra*datatypeValue)

2452

2453

if self.dataOut.data_cspc != None:

2453

if self.dataOut.data_cspc != None:

2454

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

2454

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

2455

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2455

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2456

2457

if self.dataOut.data_dc != None:

2457

if self.dataOut.data_dc != None:

2458

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

2458

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

2459

blocksize += (pts2write_DCchannels*datatypeValue*2)

2459

blocksize += (pts2write_DCchannels*datatypeValue*2)

2460

2461

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2461

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2462

2463

return blocksize

2463

return blocksize

2464

2465

def getDataHeader(self):

2465

def getDataHeader(self):

2466

2467

"""

2467

"""

2468

Obtiene una copia del First Header

2468

Obtiene una copia del First Header

2469

2470

Affected:

2470

Affected:

2471

self.systemHeaderObj

2471

self.systemHeaderObj

2472

self.radarControllerHeaderObj

2472

self.radarControllerHeaderObj

2473

self.dtype

2473

self.dtype

2474

2475

Return:

2475

Return:

2476

None

2476

None

2477

"""

2477

"""

2478

2479

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

2479

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

2480

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2480

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2481

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

2481

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

2482

2483

self.getBasicHeader()

2483

self.getBasicHeader()

2484

2485

processingHeaderSize = 40 # bytes

2485

processingHeaderSize = 40 # bytes

2486

self.processingHeaderObj.dtype = 0 # ~~Voltage~~

2486

self.processingHeaderObj.dtype = 1 # Spectra

2487

self.processingHeaderObj.blockSize = self.__getBlockSize()

2487

self.processingHeaderObj.blockSize = self.__getBlockSize()

2488

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2488

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2489

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2489

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2490

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

2490

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

2491

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2491

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2492

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

2492

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

2493

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2493

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2494

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

2494

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

2495

2496

if self.processingHeaderObj.totalSpectra > 0:

2496

if self.processingHeaderObj.totalSpectra > 0:

2497

channelList = []

2497

channelList = []

2498

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

2498

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

2499

channelList.append(channel)

2499

channelList.append(channel)

2500

channelList.append(channel)

2500

channelList.append(channel)

2501

2502

pairsList = []

2502

pairsList = []

2503

for pair in self.dataOut.pairsList:

2503

for pair in self.dataOut.pairsList:

2504

pairsList.append(pair[0])

2504

pairsList.append(pair[0])

2505

pairsList.append(pair[1])

2505

pairsList.append(pair[1])

2506

spectraComb = channelList + pairsList

2506

spectraComb = channelList + pairsList

2507

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

2507

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

2508

self.processingHeaderObj.spectraComb = spectraComb

2508

self.processingHeaderObj.spectraComb = spectraComb

2509

sizeOfSpcComb = len(spectraComb)

2509

sizeOfSpcComb = len(spectraComb)

2510

processingHeaderSize += sizeOfSpcComb

2510

processingHeaderSize += sizeOfSpcComb

2511

2512

if self.dataOut.code != None:

2512

# The processing header should not have information about code

2513

self.processingHeaderObj.code = self.dataOut.code

2513

# if self.dataOut.code != None:

2514

self.processingHeaderObj.nCode = self.dataOut.nCode

2514

# self.processingHeaderObj.code = self.dataOut.code

2515

self.processingHeaderObj.n~~Baud~~ = self.dataOut.n~~Baud~~

2515

# self.processingHeaderObj.nCode = self.dataOut.nCode

2516

nCodeSize = 4 # bytes

2516

# self.processingHeaderObj.nBaud = self.dataOut.nBaud

2517

n~~Baud~~Size = 4 # bytes

2517

# nCodeSize = 4 # bytes

2518

~~code~~Size = 4 # bytes

2518

# nBaudSize = 4 # bytes

2519

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

2519

# codeSize = 4 # bytes

2520

processingHeaderSize += sizeOfCode

2520

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

2521

# processingHeaderSize += sizeOfCode

2521

2522

if self.processingHeaderObj.nWindows != 0:

2523

if self.processingHeaderObj.nWindows != 0:

2523

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

2524

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

2524

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

2525

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

2525

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2526

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2526

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2527

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2527

sizeOfFirstHeight = 4

2528

sizeOfFirstHeight = 4

2528

sizeOfdeltaHeight = 4

2529

sizeOfdeltaHeight = 4

2529

sizeOfnHeights = 4

2530

sizeOfnHeights = 4

2530

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

2531

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

2531

processingHeaderSize += sizeOfWindows

2532

processingHeaderSize += sizeOfWindows

2532

2533

self.processingHeaderObj.size = processingHeaderSize

2534

self.processingHeaderObj.size = processingHeaderSize

2534

2535

class SpectraHeisWriter():

2536

class SpectraHeisWriter():

2536

2537

i=0

2538

i=0

2538

2539

def __init__(self, dataOut):

2540

def __init__(self, dataOut):

2540

2541

self.wrObj = FITS()

2542

self.wrObj = FITS()

2542

self.dataOut = dataOut

2543

self.dataOut = dataOut

2543

2544

def isNumber(str):

2545

def isNumber(str):

2545

"""

2546

"""

2546

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

2547

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

2547

2548

Excepciones:

2549

Excepciones:

2549

Si un determinado string no puede ser convertido a numero

2550

Si un determinado string no puede ser convertido a numero

2550

Input:

2551

Input:

2551

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

2552

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

2552

2553

Return:

2554

Return:

2554

True : si el string es uno numerico

2555

True : si el string es uno numerico

2555

False : no es un string numerico

2556

False : no es un string numerico

2556

"""

2557

"""

2557

try:

2558

try:

2558

float( str )

2559

float( str )

2559

return True

2560

return True

2560

except:

2561

except:

2561

return False

2562

return False

2562

2563

def setup(self, wrpath,):

2564

def setup(self, wrpath,):

2564

2565

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

2566

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

2566

os.mkdir(wrpath)

2567

os.mkdir(wrpath)

2567

2568

self.wrpath = wrpath

2569

self.wrpath = wrpath

2569

self.setFile = 0

2570

self.setFile = 0

2570

2571

def putData(self):

2572

def putData(self):

2572

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

2573

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

2573

#name = self.dataOut.utctime

2574

#name = self.dataOut.utctime

2574

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

2575

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

2575

ext=".fits"

2576

ext=".fits"

2576

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

2577

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

2577

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

2578

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

2578

2579

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

2580

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

2580

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

2581

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

2581

os.mkdir(fullpath)

2582

os.mkdir(fullpath)

2582

self.setFile += 1

2583

self.setFile += 1

2583

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

2584

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

2584

2585

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

2586

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

2586

2587

# print self.dataOut.ippSeconds

2588

# print self.dataOut.ippSeconds

2588

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

2589

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

2589

2590

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

2591

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

2591

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

2592

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

2592

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

2593

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

2593

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

2594

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

2594

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

2595

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

2595

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

2596

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

2596

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

2597

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

2597

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

2598

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

2598

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

2599

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

2599

#n=numpy.arange((100))

2600

#n=numpy.arange((100))

2600

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

2601

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

2601

a=self.wrObj.cFImage(n)

2602

a=self.wrObj.cFImage(n)

2602

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

2603

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

2603

self.wrObj.CFile(a,b)

2604

self.wrObj.CFile(a,b)

2604

self.wrObj.wFile(filename)

2605

self.wrObj.wFile(filename)

2605

return 1

2606

return 1

2606

2607

class FITS:

2608

class FITS:

2608

2609

name=None

2610

name=None

2610

format=None

2611

format=None

2611

array =None

2612

array =None

2612

data =None

2613

data =None

2613

thdulist=None

2614

thdulist=None

2614

2615

def __init__(self):

2616

def __init__(self):

2616

2617

pass

2618

pass

2618

2619

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

2620

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

2620

self.name=name

2621

self.name=name

2621

self.format=format

2622

self.format=format

2622

self.array=array

2623

self.array=array

2623

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

2624

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

2624

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

2625

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

2625

return self.col1

2626

return self.col1

2626

2627

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

2628

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

2628

# self.name=name

2629

# self.name=name

2629

# self.format=format

2630

# self.format=format

2630

# self.data=data

2631

# self.data=data

2631

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

2632

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

2632

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

2633

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

2633

# return self.col2

2634

# return self.col2

2634

2635

def writeHeader(self,):

2636

def writeHeader(self,):

2636

pass

2637

pass

2637

2638

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

2639

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

2639

self.name=name

2640

self.name=name

2640

self.format=format

2641

self.format=format

2641

self.data=data

2642

self.data=data

2642

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

2643

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

2643

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

2644

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

2644

return self.col2

2645

return self.col2

2645

2646

def cFImage(self,n):

2647

def cFImage(self,n):

2647

self.hdu= pyfits.PrimaryHDU(n)

2648

self.hdu= pyfits.PrimaryHDU(n)

2648

return self.hdu

2649

return self.hdu

2649

2650

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

2651

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

2651

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

2652

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

2652

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

2653

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

2653

return self.tbhdu

2654

return self.tbhdu

2654

2655

def CFile(self,hdu,tbhdu):

2656

def CFile(self,hdu,tbhdu):

2656

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

2657

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

2657

2658

def wFile(self,filename):

2659

def wFile(self,filename):

2659

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

2660

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
             import datetime
             class Header:
                 def __init__(self):
                     raise
                 def copy(self):
                     return copy.deepcopy(self)
                 def read():
                     pass
                 def write():
                     pass
                 def printInfo(self):
                     print "#"*100
                     print self.__class__.__name__.upper()
                     print "#"*100
                     for key in self.__dict__.keys():
                         print "%s = %s" %(key, self.__dict__[key])
             class BasicHeader(Header):
                 size = None
                 version = None
                 dataBlock = None
                 utc = None
                 miliSecond = None
                 timeZone = None
                 dstFlag = None
                 errorCount = None
                 struct = None
                 datatime = None
                 __LOCALTIME = None
                 def __init__(self, localtime=0):
                     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')
                                           ])
                     self.__LOCALTIME = localtime
                 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])
                         self.utc += self.__LOCALTIME
                         self.datatime = datetime.datetime.utcfromtimestamp(self.utc)
                     except Exception, e:
                         print "BasicHeader: "
                         print e
                         return 0
                     return 1
                 def write(self, fp):
                     self.utc -= self.__LOCALTIME
                     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 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*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 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 = 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 = float(self.samplingWindow['h0'][0])
                         self.deltaHeight = float(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.nCode,self.nBaud)
                         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 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:
-                    if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
+            #            nCode = numpy.array([self.nCode], numpy.dtype('u4')) #Probar con un dato que almacene codigo, hasta el momento no se hizo la prueba
-                        nCode = numpy.array([self.nCode], numpy.dtype('u4')) #Probar con un dato que almacene codigo, hasta el momento no se hizo la prueba
+            #            nCode.tofile(fp)
-                        nCode.tofile(fp)
+            #            nBaud = numpy.array([self.nBaud], numpy.dtype('u4'))
-                        nBaud = numpy.array([self.nBaud], numpy.dtype('u4'))
+            #            nBaud.tofile(fp)
-                        nBaud.tofile(fp)
+            #            code = self.code.reshape(self.nCode*self.nBaud)
-                        code = self.code.reshape(self.nCode*self.nBaud)
+            #            code = code.astype(numpy.dtype('<f4'))
-                        code = code.astype(numpy.dtype('<f4'))
+            #            code.tofile(fp)
-                        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)