schain Commit - r332:395575e10cc2 · 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 0
+                    return None
                 if not ((startTime <= thisTime) and (endTime > thisTime)):
-                    return 0
+                    return None
-                return thisTime
+                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 = []
-                    dateList = []
                     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))
-                            dateList.append(thisDate)
                             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]
-                        thisDate = dateList[i]
                         fileList = glob.glob1(thisPath, "*%s" %ext)
                         fileList.sort()
                         for file in fileList:
                             filename = os.path.join(thisPath,file)
-                            thisTime = isFileinThisTime(filename, startTime, endTime)
+                            thisDatetime = isFileinThisTime(filename, startTime, endTime)
-                            if thisTime == 0:
+                            if not(thisDatetime):
                                 continue
                             filenameList.append(filename)
-                            datetimeList.append(datetime.datetime.combine(thisDate,thisTime))
+                            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 walk:
+                    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)
-                    else:
-                        fullpath = path
                     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):
-                    print self.basicHeaderObj.printInfo()
+                    if self.__printInfo == False:
-                    print self.systemHeaderObj.printInfo()
+                        return
-                    print self.radarControllerHeaderObj.printInfo()
-                    print self.processingHeaderObj.printInfo()
+                    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.blockSize = self.__getBlockSize()
                     self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints
                     self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
                     self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
                     self.processingHeaderObj.processFlags = self.__getProcessFlags()
                     self.processingHeaderObj.nCohInt = self.dataOut.nCohInt# Se requiere para determinar el valor de timeInterval
                     self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt
                     self.processingHeaderObj.totalSpectra = self.dataOut.nPairs + self.dataOut.nChannels
                     if self.processingHeaderObj.totalSpectra > 0:
                         channelList = []
                         for channel in range(self.dataOut.nChannels):
                             channelList.append(channel)
                             channelList.append(channel)
                         pairsList = []
                         for pair in self.dataOut.pairsList:
                             pairsList.append(pair[0])
                             pairsList.append(pair[1])
                         spectraComb = channelList + pairsList
                         spectraComb = numpy.array(spectraComb,dtype="u1")
                         self.processingHeaderObj.spectraComb = spectraComb
                         sizeOfSpcComb = len(spectraComb)
                         processingHeaderSize += sizeOfSpcComb
                     if self.dataOut.code != None:
                         self.processingHeaderObj.code = self.dataOut.code
                         self.processingHeaderObj.nCode = self.dataOut.nCode
                         self.processingHeaderObj.nBaud = self.dataOut.nBaud
                         nCodeSize = 4 # bytes
                         nBaudSize = 4 # bytes
                         codeSize = 4 # bytes
                         sizeOfCode = int(nCodeSize + nBaudSize + codeSize * self.dataOut.nCode * self.dataOut.nBaud)
                         processingHeaderSize += sizeOfCode
                     if self.processingHeaderObj.nWindows != 0:
                         self.processingHeaderObj.firstHeight = self.dataOut.heightList[0]
                         self.processingHeaderObj.deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
                         self.processingHeaderObj.nHeights = self.dataOut.nHeights
                         self.processingHeaderObj.samplesWin = self.dataOut.nHeights
                         sizeOfFirstHeight = 4
                         sizeOfdeltaHeight = 4
                         sizeOfnHeights = 4
                         sizeOfWindows = (sizeOfFirstHeight + sizeOfdeltaHeight + sizeOfnHeights)*self.processingHeaderObj.nWindows
                         processingHeaderSize += sizeOfWindows
                     self.processingHeaderObj.size = processingHeaderSize
             class SpectraHeisWriter():
                 i=0
                 def __init__(self, dataOut):
                     self.wrObj = FITS()
                     self.dataOut = dataOut
                 def isNumber(str):
                     """
                     Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
                     Excepciones:
                     Si un determinado string no puede ser convertido a numero
                     Input:
                     str, string al cual se le analiza para determinar si convertible a un numero o no
                     Return:
                     True    :    si el string es uno numerico
                     False   :    no es un string numerico
                     """
                     try:
                         float( str )
                         return True
                     except:
                         return False
                 def setup(self, wrpath,):
                     if not(os.path.exists(wrpath)):
                         os.mkdir(wrpath)
                     self.wrpath = wrpath
                     self.setFile = 0
                 def putData(self):
                   # self.wrObj.writeHeader(nChannels=self.dataOut.nChannels, nFFTPoints=self.dataOut.nFFTPoints)
                     #name = self.dataOut.utctime
                     name= time.localtime( self.dataOut.utctime)
                     ext=".fits"
                     #folder='D%4.4d%3.3d'%(name.tm_year,name.tm_yday)
                     subfolder = 'D%4.4d%3.3d' % (name.tm_year,name.tm_yday)
                     fullpath = os.path.join( self.wrpath, subfolder )
                     if not( os.path.exists(fullpath) ):
                         os.mkdir(fullpath)
                     self.setFile += 1
                     file = 'D%4.4d%3.3d%3.3d%s' % (name.tm_year,name.tm_yday,self.setFile,ext)
                     filename = os.path.join(self.wrpath,subfolder, file)
                    # print self.dataOut.ippSeconds
                     freq=numpy.arange(-1*self.dataOut.nHeights/2.,self.dataOut.nHeights/2.)/(2*self.dataOut.ippSeconds)
                     col1=self.wrObj.setColF(name="freq", format=str(self.dataOut.nFFTPoints)+'E', array=freq)
                     col2=self.wrObj.writeData(name="P_Ch1",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[0,:]))
                     col3=self.wrObj.writeData(name="P_Ch2",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[1,:]))
                     col4=self.wrObj.writeData(name="P_Ch3",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[2,:]))
                     col5=self.wrObj.writeData(name="P_Ch4",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[3,:]))
                     col6=self.wrObj.writeData(name="P_Ch5",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[4,:]))
                     col7=self.wrObj.writeData(name="P_Ch6",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[5,:]))
                     col8=self.wrObj.writeData(name="P_Ch7",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[6,:]))
                     col9=self.wrObj.writeData(name="P_Ch8",format=str(self.dataOut.nFFTPoints)+'E',data=10*numpy.log10(self.dataOut.data_spc[7,:]))
                     #n=numpy.arange((100))
                     n=self.dataOut.data_spc[6,:]
                     a=self.wrObj.cFImage(n)
                     b=self.wrObj.Ctable(col1,col2,col3,col4,col5,col6,col7,col8,col9)
                     self.wrObj.CFile(a,b)
                     self.wrObj.wFile(filename)
                     return 1
             class FITS:
                 name=None
                 format=None
                 array =None
                 data =None
                 thdulist=None
                 def __init__(self):
                     pass
                 def setColF(self,name,format,array):
                     self.name=name
                     self.format=format
                     self.array=array
                     a1=numpy.array([self.array],dtype=numpy.float32)
                     self.col1 = pyfits.Column(name=self.name, format=self.format, array=a1)
                     return self.col1
             #    def setColP(self,name,format,data):
             #        self.name=name
             #        self.format=format
             #        self.data=data
             #        a2=numpy.array([self.data],dtype=numpy.float32)
             #        self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
             #        return self.col2
                 def writeHeader(self,):
                     pass
                 def writeData(self,name,format,data):
                     self.name=name
                     self.format=format
                     self.data=data
                     a2=numpy.array([self.data],dtype=numpy.float32)
                     self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
                     return self.col2
                 def cFImage(self,n):
                     self.hdu= pyfits.PrimaryHDU(n)
                     return self.hdu
                 def Ctable(self,col1,col2,col3,col4,col5,col6,col7,col8,col9):
                     self.cols=pyfits.ColDefs( [col1,col2,col3,col4,col5,col6,col7,col8,col9])
                     self.tbhdu = pyfits.new_table(self.cols)
                     return self.tbhdu
                 def CFile(self,hdu,tbhdu):
                     self.thdulist=pyfits.HDUList([hdu,tbhdu])
                 def wFile(self,filename):
                     self.thdulist.writeto(filename)

1

'''

1

'''

2

3

$Author: murco $

3

$Author: murco $

4

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

4

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

5

'''

5

'''

6

7

import os, sys

7

import os, sys

8

import glob

8

import glob

9

import time

9

import time

10

import numpy

10

import numpy

11

import fnmatch

11

import fnmatch

12

import time, datetime

12

import time, datetime

13

14

from jrodata import *

14

from jrodata import *

15

from jroheaderIO import *

15

from jroheaderIO import *

16

from jroprocessing import *

16

from jroprocessing import *

17

18

LOCALTIME = -18000

18

LOCALTIME = -18000

19

20

def isNumber(str):

20

def isNumber(str):

21

"""

21

"""

22

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

22

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

23

24

Excepciones:

24

Excepciones:

25

Si un determinado string no puede ser convertido a numero

25

Si un determinado string no puede ser convertido a numero

26

Input:

26

Input:

27

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

27

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

28

29

Return:

29

Return:

30

True : si el string es uno numerico

30

True : si el string es uno numerico

31

False : no es un string numerico

31

False : no es un string numerico

32

"""

32

"""

33

try:

33

try:

34

float( str )

34

float( str )

35

return True

35

return True

36

except:

36

except:

37

return False

37

return False

38

39

def isThisFileinRange(filename, startUTSeconds, endUTSeconds):

39

def isThisFileinRange(filename, startUTSeconds, endUTSeconds):

40

"""

40

"""

41

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

41

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

42

43

Inputs:

43

Inputs:

44

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

44

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

45

46

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

46

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

47

segundos contados desde 01/01/1970.

47

segundos contados desde 01/01/1970.

48

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

48

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

49

segundos contados desde 01/01/1970.

49

segundos contados desde 01/01/1970.

50

51

Return:

51

Return:

52

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

52

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

53

fecha especificado, de lo contrario retorna False.

53

fecha especificado, de lo contrario retorna False.

54

55

Excepciones:

55

Excepciones:

56

Si el archivo no existe o no puede ser abierto

56

Si el archivo no existe o no puede ser abierto

57

Si la cabecera no puede ser leida.

57

Si la cabecera no puede ser leida.

58

59

"""

59

"""

60

basicHeaderObj = BasicHeader(LOCALTIME)

60

basicHeaderObj = BasicHeader(LOCALTIME)

61

62

try:

62

try:

63

fp = open(filename,'rb')

63

fp = open(filename,'rb')

64

except:

64

except:

65

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

65

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

66

67

sts = basicHeaderObj.read(fp)

67

sts = basicHeaderObj.read(fp)

68

fp.close()

68

fp.close()

69

70

if not(sts):

70

if not(sts):

71

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

71

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

72

return 0

72

return 0

73

74

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

74

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

75

return 0

75

return 0

76

77

return 1

77

return 1

78

79

def isFileinThisTime(filename, startTime, endTime):

79

def isFileinThisTime(filename, startTime, endTime):

80

"""

80

"""

81

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

81

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

82

83

Inputs:

83

Inputs:

84

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

84

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

85

86

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

86

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

87

88

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

88

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

89

90

Return:

90

Return:

91

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

91

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

92

fecha especificado, de lo contrario retorna False.

92

fecha especificado, de lo contrario retorna False.

93

94

Excepciones:

94

Excepciones:

95

Si el archivo no existe o no puede ser abierto

95

Si el archivo no existe o no puede ser abierto

96

Si la cabecera no puede ser leida.

96

Si la cabecera no puede ser leida.

97

98

"""

98

"""

99

100

101

try:

101

try:

102

fp = open(filename,'rb')

102

fp = open(filename,'rb')

103

except:

103

except:

104

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

104

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

105

106

basicHeaderObj = BasicHeader(LOCALTIME)

106

basicHeaderObj = BasicHeader(LOCALTIME)

107

sts = basicHeaderObj.read(fp)

107

sts = basicHeaderObj.read(fp)

108

fp.close()

108

fp.close()

109

110

thisDatetime = basicHeaderObj.datatime

110

thisTime = basicHeaderObj.datatime.time()

111

thisTime = basicHeaderObj.datatime.time()

111

112

if not(sts):

113

if not(sts):

113

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)

114

return 0

115

return None

115

116

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

117

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

117

return 0

118

return None

118

119

return thisTime

120

return thisDatetime

120

121

def getlastFileFromPath(path, ext):

122

def getlastFileFromPath(path, ext):

122

"""

123

"""

123

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"

124

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.

125

126

Input:

127

Input:

127

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

128

ext : extension de los files contenidos en una carpeta

129

ext : extension de los files contenidos en una carpeta

129

130

Return:

131

Return:

131

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.

132

"""

133

"""

133

validFilelist = []

134

validFilelist = []

134

fileList = os.listdir(path)

135

fileList = os.listdir(path)

135

136

# 0 1234 567 89A BCDE

137

# 0 1234 567 89A BCDE

137

# H YYYY DDD SSS .ext

138

# H YYYY DDD SSS .ext

138

139

for file in fileList:

140

for file in fileList:

140

try:

141

try:

141

year = int(file[1:5])

142

year = int(file[1:5])

142

doy = int(file[5:8])

143

doy = int(file[5:8])

143

144

145

except:

146

except:

146

continue

147

continue

147

148

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

149

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

149

continue

150

continue

150

151

validFilelist.append(file)

152

validFilelist.append(file)

152

153

if validFilelist:

154

if validFilelist:

154

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

155

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

155

return validFilelist[-1]

156

return validFilelist[-1]

156

157

return None

158

return None

158

159

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

160

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

160

"""

161

"""

161

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,

162

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

163

el path exacto de un determinado file.

164

el path exacto de un determinado file.

164

165

Example :

166

Example :

166

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

167

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

167

168

Entonces la funcion prueba con las siguientes combinaciones

169

Entonces la funcion prueba con las siguientes combinaciones

169

.../.../y2009307367.ext

170

.../.../y2009307367.ext

170

.../.../Y2009307367.ext

171

.../.../Y2009307367.ext

171

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

172

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

172

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

173

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

173

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

174

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

174

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

175

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

175

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

176

177

Return:

178

Return:

178

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

179

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

180

para el filename

181

para el filename

181

"""

182

"""

182

fullfilename = None

183

fullfilename = None

183

find_flag = False

184

find_flag = False

184

filename = None

185

filename = None

185

186

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

187

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

187

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

188

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

188

prefixFileList = ['d','D']

189

prefixFileList = ['d','D']

189

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

190

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

190

prefixFileList = ['p','P']

191

prefixFileList = ['p','P']

191

else:

192

else:

192

return None, filename

193

return None, filename

193

194

#barrido por las combinaciones posibles

195

#barrido por las combinaciones posibles

195

for prefixDir in prefixDirList:

196

for prefixDir in prefixDirList:

196

thispath = path

197

thispath = path

197

if prefixDir != None:

198

if prefixDir != None:

198

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

199

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

199

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

200

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

200

201

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

202

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

202

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

203

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

203

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

204

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

204

205

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

206

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

206

find_flag = True

207

find_flag = True

207

break

208

break

208

if find_flag:

209

if find_flag:

209

break

210

break

210

211

if not(find_flag):

212

if not(find_flag):

212

return None, filename

213

return None, filename

213

214

return fullfilename, filename

215

return fullfilename, filename

215

216

def isDoyFolder(folder):

217

def isDoyFolder(folder):

217

try:

218

try:

218

year = int(folder[1:5])

219

year = int(folder[1:5])

219

except:

220

except:

220

return 0

221

return 0

221

222

try:

223

try:

223

doy = int(folder[5:8])

224

doy = int(folder[5:8])

224

except:

225

except:

225

return 0

226

return 0

226

227

return 1

228

return 1

228

229

class JRODataIO:

230

class JRODataIO:

230

231

c = 3E8

232

c = 3E8

232

233

isConfig = False

234

isConfig = False

234

235

basicHeaderObj = BasicHeader(LOCALTIME)

236

basicHeaderObj = BasicHeader(LOCALTIME)

236

237

systemHeaderObj = SystemHeader()

238

systemHeaderObj = SystemHeader()

238

239

radarControllerHeaderObj = RadarControllerHeader()

240

radarControllerHeaderObj = RadarControllerHeader()

240

241

processingHeaderObj = ProcessingHeader()

242

processingHeaderObj = ProcessingHeader()

242

243

online = 0

244

online = 0

244

245

dtype = None

246

dtype = None

246

247

pathList = []

248

pathList = []

248

249

filenameList = []

250

filenameList = []

250

251

filename = None

252

filename = None

252

253

ext = None

254

ext = None

254

255

flagIsNewFile = 1

256

flagIsNewFile = 1

256

257

flagTimeBlock = 0

258

flagTimeBlock = 0

258

259

flagIsNewBlock = 0

260

flagIsNewBlock = 0

260

261

fp = None

262

fp = None

262

263

firstHeaderSize = 0

264

firstHeaderSize = 0

264

265

basicHeaderSize = 24

266

basicHeaderSize = 24

266

267

versionFile = 1103

268

versionFile = 1103

268

269

fileSize = None

270

fileSize = None

270

271

ippSeconds = None

272

ippSeconds = None

272

273

fileSizeByHeader = None

274

fileSizeByHeader = None

274

275

fileIndex = None

276

fileIndex = None

276

277

profileIndex = None

278

profileIndex = None

278

279

blockIndex = None

280

blockIndex = None

280

281

nTotalBlocks = None

282

nTotalBlocks = None

282

283

maxTimeStep = 30

284

maxTimeStep = 30

284

285

lastUTTime = None

286

lastUTTime = None

286

287

datablock = None

288

datablock = None

288

289

dataOut = None

290

dataOut = None

290

291

blocksize = None

292

blocksize = None

292

293

def __init__(self):

294

def __init__(self):

294

295

raise ValueError, "Not implemented"

296

raise ValueError, "Not implemented"

296

297

def run(self):

298

def run(self):

298

299

raise ValueError, "Not implemented"

300

raise ValueError, "Not implemented"

300

301

def getOutput(self):

302

def getOutput(self):

302

303

return self.dataOut

304

return self.dataOut

304

305

class JRODataReader(JRODataIO, ProcessingUnit):

306

class JRODataReader(JRODataIO, ProcessingUnit):

306

307

nReadBlocks = 0

308

nReadBlocks = 0

308

309

delay = 10 #number of seconds waiting a new file

310

delay = 10 #number of seconds waiting a new file

310

311

nTries = 3 #quantity tries

312

nTries = 3 #quantity tries

312

313

nFiles = 3 #number of files for searching

314

nFiles = 3 #number of files for searching

314

315

flagNoMoreFiles = 0

316

flagNoMoreFiles = 0

316

317

datetimeList = []

318

datetimeList = []

318

319

__isFirstTimeOnline = 1

320

__isFirstTimeOnline = 1

320

321

322

__printInfo = True

323

321

def __init__(self):

324

def __init__(self):

322

325

323

"""

326

"""

324

327

325

"""

328

"""

326

329

327

raise ValueError, "This method has not been implemented"

330

raise ValueError, "This method has not been implemented"

328

331

329

332

330

def createObjByDefault(self):

333

def createObjByDefault(self):

331

"""

334

"""

332

335

333

"""

336

"""

334

raise ValueError, "This method has not been implemented"

337

raise ValueError, "This method has not been implemented"

335

338

336

def getBlockDimension(self):

339

def getBlockDimension(self):

337

340

338

raise ValueError, "No implemented"

341

raise ValueError, "No implemented"

339

342

340

def __searchFilesOffLine(self,

343

def __searchFilesOffLine(self,

341

path,

344

path,

342

startDate,

345

startDate,

343

endDate,

346

endDate,

344

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

347

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

345

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

348

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

346

set=None,

349

set=None,

347

expLabel='',

350

expLabel='',

348

ext='.r',

351

ext='.r',

349

walk=True):

352

walk=True):

350

353

351

pathList = []

354

pathList = []

352

dateList = []

353

355

354

if not walk:

356

if not walk:

355

pathList.append(path)

357

pathList.append(path)

356

358

357

else:

359

else:

358

dirList = []

360

dirList = []

359

for thisPath in os.listdir(path):

361

for thisPath in os.listdir(path):

360

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

362

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

361

continue

363

continue

362

if not isDoyFolder(thisPath):

364

if not isDoyFolder(thisPath):

363

continue

365

continue

364

366

365

dirList.append(thisPath)

367

dirList.append(thisPath)

366

368

367

if not(dirList):

369

if not(dirList):

368

return None, None

370

return None, None

369

371

370

thisDate = startDate

372

thisDate = startDate

371

373

372

while(thisDate <= endDate):

374

while(thisDate <= endDate):

373

year = thisDate.timetuple().tm_year

375

year = thisDate.timetuple().tm_year

374

doy = thisDate.timetuple().tm_yday

376

doy = thisDate.timetuple().tm_yday

375

377

376

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

378

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

377

if len(match) == 0:

379

if len(match) == 0:

378

thisDate += datetime.timedelta(1)

380

thisDate += datetime.timedelta(1)

379

continue

381

continue

380

382

381

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

383

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

382

dateList.append(thisDate)

383

384

thisDate += datetime.timedelta(1)

385

thisDate += datetime.timedelta(1)

385

386

if pathList == []:

387

if pathList == []:

387

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)

388

return None, None

389

return None, None

389

390

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)

391

392

filenameList = []

393

filenameList = []

393

datetimeList = []

394

datetimeList = []

394

395

for i in range(len(pathList)):

396

for i in range(len(pathList)):

396

397

thisPath = pathList[i]

398

thisPath = pathList[i]

398

thisDate = dateList[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

thisTime = isFileinThisTime(filename, startTime, endTime)

406

thisDatetime = isFileinThisTime(filename, startTime, endTime)

407

408

if ~~thisTime~~ == 0:

408

if not(thisDatetime):

409

continue

409

continue

410

411

filenameList.append(filename)

411

filenameList.append(filename)

412

datetimeList.append(~~datetime~~.~~datetime~~.~~combine~~(thisDate,t~~hisT~~ime))

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 walk:

455

if not walk:

456

fullpath = path

456

457

458

else:

457

#Filtra solo los directorios

459

#Filtra solo los directorios

458

for thisPath in os.listdir(path):

460

for thisPath in os.listdir(path):

459

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

461

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

460

continue

462

continue

461

if not isDoyFolder(thisPath):

463

if not isDoyFolder(thisPath):

462

continue

464

continue

463

465

464

dirList.append(thisPath)

466

dirList.append(thisPath)

465

467

466

if not(dirList):

468

if not(dirList):

467

return None, None, None, None, None

469

return None, None, None, None, None

468

470

469

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

471

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

470

472

471

doypath = dirList[-1]

473

doypath = dirList[-1]

472

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

474

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

473

475

474

else:

475

fullpath = path

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

496

497

def __setNextFileOffline(self):

495

def __setNextFileOffline(self):

498

496

499

idFile = self.fileIndex

497

idFile = self.fileIndex

500

498

501

while (True):

499

while (True):

502

idFile += 1

500

idFile += 1

503

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

501

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

504

self.flagNoMoreFiles = 1

502

self.flagNoMoreFiles = 1

505

print "No more Files"

503

print "No more Files"

506

return 0

504

return 0

507

505

508

filename = self.filenameList[idFile]

506

filename = self.filenameList[idFile]

509

507

510

if not(self.__verifyFile(filename)):

508

if not(self.__verifyFile(filename)):

511

continue

509

continue

512

510

513

fileSize = os.path.getsize(filename)

511

fileSize = os.path.getsize(filename)

514

fp = open(filename,'rb')

512

fp = open(filename,'rb')

515

break

513

break

516

514

517

self.flagIsNewFile = 1

515

self.flagIsNewFile = 1

518

self.fileIndex = idFile

516

self.fileIndex = idFile

519

self.filename = filename

517

self.filename = filename

520

self.fileSize = fileSize

518

self.fileSize = fileSize

521

self.fp = fp

519

self.fp = fp

522

520

523

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

521

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

524

522

525

return 1

523

return 1

526

524

527

def __setNextFileOnline(self):

525

def __setNextFileOnline(self):

528

"""

526

"""

529

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

530

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

531

siguientes.

529

siguientes.

532

530

533

Affected:

531

Affected:

534

self.flagIsNewFile

532

self.flagIsNewFile

535

self.filename

533

self.filename

536

self.fileSize

534

self.fileSize

537

self.fp

535

self.fp

538

self.set

536

self.set

539

self.flagNoMoreFiles

537

self.flagNoMoreFiles

540

538

541

Return:

539

Return:

542

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

543

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

544

542

545

Excepciones:

543

Excepciones:

546

Si un determinado file no puede ser abierto

544

Si un determinado file no puede ser abierto

547

"""

545

"""

548

nFiles = 0

546

nFiles = 0

549

fileOk_flag = False

547

fileOk_flag = False

550

firstTime_flag = True

548

firstTime_flag = True

551

549

552

self.set += 1

550

self.set += 1

553

551

554

#busca el 1er file disponible

552

#busca el 1er file disponible

555

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 )

556

if fullfilename:

554

if fullfilename:

557

if self.__verifyFile(fullfilename, False):

555

if self.__verifyFile(fullfilename, False):

558

fileOk_flag = True

556

fileOk_flag = True

559

557

560

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

558

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

561

if not(fileOk_flag):

559

if not(fileOk_flag):

562

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

563

561

564

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

565

tries = self.nTries

563

tries = self.nTries

566

else:

564

else:

567

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

568

566

569

for nTries in range( tries ):

567

for nTries in range( tries ):

570

if firstTime_flag:

568

if firstTime_flag:

571

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 )

572

time.sleep( self.delay )

570

time.sleep( self.delay )

573

else:

571

else:

574

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)

575

573

576

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 )

577

if fullfilename:

575

if fullfilename:

578

if self.__verifyFile(fullfilename):

576

if self.__verifyFile(fullfilename):

579

fileOk_flag = True

577

fileOk_flag = True

580

break

578

break

581

579

582

if fileOk_flag:

580

if fileOk_flag:

583

break

581

break

584

582

585

firstTime_flag = False

583

firstTime_flag = False

586

584

587

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

588

self.set += 1

586

self.set += 1

589

587

590

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

591

self.set = 0

589

self.set = 0

592

self.doy += 1

590

self.doy += 1

593

591

594

if fileOk_flag:

592

if fileOk_flag:

595

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

593

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

596

self.filename = fullfilename

594

self.filename = fullfilename

597

self.flagIsNewFile = 1

595

self.flagIsNewFile = 1

598

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

596

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

599

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

597

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

600

self.flagNoMoreFiles = 0

598

self.flagNoMoreFiles = 0

601

print 'Setting the file: %s' % fullfilename

599

print 'Setting the file: %s' % fullfilename

602

else:

600

else:

603

self.fileSize = 0

601

self.fileSize = 0

604

self.filename = None

602

self.filename = None

605

self.flagIsNewFile = 0

603

self.flagIsNewFile = 0

606

self.fp = None

604

self.fp = None

607

self.flagNoMoreFiles = 1

605

self.flagNoMoreFiles = 1

608

print 'No more Files'

606

print 'No more Files'

609

607

610

return fileOk_flag

608

return fileOk_flag

611

609

612

610

613

def setNextFile(self):

611

def setNextFile(self):

614

if self.fp != None:

612

if self.fp != None:

615

self.fp.close()

613

self.fp.close()

616

614

617

if self.online:

615

if self.online:

618

newFile = self.__setNextFileOnline()

616

newFile = self.__setNextFileOnline()

619

else:

617

else:

620

newFile = self.__setNextFileOffline()

618

newFile = self.__setNextFileOffline()

621

619

622

if not(newFile):

620

if not(newFile):

623

return 0

621

return 0

624

622

625

self.__readFirstHeader()

623

self.__readFirstHeader()

626

self.nReadBlocks = 0

624

self.nReadBlocks = 0

627

return 1

625

return 1

628

626

629

def __waitNewBlock(self):

627

def __waitNewBlock(self):

630

"""

628

"""

631

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.

632

630

633

Si el modo de lectura es OffLine siempre retorn 0

631

Si el modo de lectura es OffLine siempre retorn 0

634

"""

632

"""

635

if not self.online:

633

if not self.online:

636

return 0

634

return 0

637

635

638

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

636

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

639

return 0

637

return 0

640

638

641

currentPointer = self.fp.tell()

639

currentPointer = self.fp.tell()

642

640

643

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

641

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

644

642

645

for nTries in range( self.nTries ):

643

for nTries in range( self.nTries ):

646

644

647

self.fp.close()

645

self.fp.close()

648

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

646

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

649

self.fp.seek( currentPointer )

647

self.fp.seek( currentPointer )

650

648

651

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

649

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

652

currentSize = self.fileSize - currentPointer

650

currentSize = self.fileSize - currentPointer

653

651

654

if ( currentSize >= neededSize ):

652

if ( currentSize >= neededSize ):

655

self.__rdBasicHeader()

653

self.__rdBasicHeader()

656

return 1

654

return 1

657

655

658

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)

659

time.sleep( self.delay )

657

time.sleep( self.delay )

660

658

661

659

662

return 0

660

return 0

663

661

664

def __jumpToLastBlock(self):

662

def __jumpToLastBlock(self):

665

663

666

if not(self.__isFirstTimeOnline):

664

if not(self.__isFirstTimeOnline):

667

return

665

return

668

666

669

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

667

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

670

668

671

#sata el primer bloque de datos

669

#sata el primer bloque de datos

672

if csize > self.processingHeaderObj.blockSize:

670

if csize > self.processingHeaderObj.blockSize:

673

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

671

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

674

else:

672

else:

675

return

673

return

676

674

677

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

675

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

678

neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize

676

neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize

679

factor = int(csize/neededsize)

677

factor = int(csize/neededsize)

680

if factor > 0:

678

if factor > 0:

681

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

679

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

682

680

683

self.flagIsNewFile = 0

681

self.flagIsNewFile = 0

684

self.__isFirstTimeOnline = 0

682

self.__isFirstTimeOnline = 0

685

683

686

684

687

def __setNewBlock(self):

685

def __setNewBlock(self):

688

686

689

if self.fp == None:

687

if self.fp == None:

690

return 0

688

return 0

691

689

692

if self.online:

690

if self.online:

693

self.__jumpToLastBlock()

691

self.__jumpToLastBlock()

694

692

695

if self.flagIsNewFile:

693

if self.flagIsNewFile:

696

return 1

694

return 1

697

695

698

self.lastUTTime = self.basicHeaderObj.utc

696

self.lastUTTime = self.basicHeaderObj.utc

699

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

697

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

700

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

698

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

701

699

702

if (currentSize >= neededSize):

700

if (currentSize >= neededSize):

703

self.__rdBasicHeader()

701

self.__rdBasicHeader()

704

return 1

702

return 1

705

703

706

if self.__waitNewBlock():

704

if self.__waitNewBlock():

707

return 1

705

return 1

708

706

709

if not(self.setNextFile()):

707

if not(self.setNextFile()):

710

return 0

708

return 0

711

709

712

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

710

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

713

711

714

self.flagTimeBlock = 0

712

self.flagTimeBlock = 0

715

713

716

if deltaTime > self.maxTimeStep:

714

if deltaTime > self.maxTimeStep:

717

self.flagTimeBlock = 1

715

self.flagTimeBlock = 1

718

716

719

return 1

717

return 1

720

718

721

719

722

def readNextBlock(self):

720

def readNextBlock(self):

723

if not(self.__setNewBlock()):

721

if not(self.__setNewBlock()):

724

return 0

722

return 0

725

723

726

if not(self.readBlock()):

724

if not(self.readBlock()):

727

return 0

725

return 0

728

726

729

return 1

727

return 1

730

728

731

def __rdProcessingHeader(self, fp=None):

729

def __rdProcessingHeader(self, fp=None):

732

if fp == None:

730

if fp == None:

733

fp = self.fp

731

fp = self.fp

734

732

735

self.processingHeaderObj.read(fp)

733

self.processingHeaderObj.read(fp)

736

734

737

def __rdRadarControllerHeader(self, fp=None):

735

def __rdRadarControllerHeader(self, fp=None):

738

if fp == None:

736

if fp == None:

739

fp = self.fp

737

fp = self.fp

740

738

741

self.radarControllerHeaderObj.read(fp)

739

self.radarControllerHeaderObj.read(fp)

742

740

743

def __rdSystemHeader(self, fp=None):

741

def __rdSystemHeader(self, fp=None):

744

if fp == None:

742

if fp == None:

745

fp = self.fp

743

fp = self.fp

746

744

747

self.systemHeaderObj.read(fp)

745

self.systemHeaderObj.read(fp)

748

746

749

def __rdBasicHeader(self, fp=None):

747

def __rdBasicHeader(self, fp=None):

750

if fp == None:

748

if fp == None:

751

fp = self.fp

749

fp = self.fp

752

750

753

self.basicHeaderObj.read(fp)

751

self.basicHeaderObj.read(fp)

754

752

755

753

756

def __readFirstHeader(self):

754

def __readFirstHeader(self):

757

self.__rdBasicHeader()

755

self.__rdBasicHeader()

758

self.__rdSystemHeader()

756

self.__rdSystemHeader()

759

self.__rdRadarControllerHeader()

757

self.__rdRadarControllerHeader()

760

self.__rdProcessingHeader()

758

self.__rdProcessingHeader()

761

759

762

self.firstHeaderSize = self.basicHeaderObj.size

760

self.firstHeaderSize = self.basicHeaderObj.size

763

761

764

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

765

if datatype == 0:

763

if datatype == 0:

766

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

764

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

767

elif datatype == 1:

765

elif datatype == 1:

768

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

766

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

769

elif datatype == 2:

767

elif datatype == 2:

770

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

768

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

771

elif datatype == 3:

769

elif datatype == 3:

772

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

770

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

773

elif datatype == 4:

771

elif datatype == 4:

774

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

772

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

775

elif datatype == 5:

773

elif datatype == 5:

776

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

774

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

777

else:

775

else:

778

raise ValueError, 'Data type was not defined'

776

raise ValueError, 'Data type was not defined'

779

777

780

self.dtype = datatype_str

778

self.dtype = datatype_str

781

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

779

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

782

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)

783

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

781

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

784

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

782

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

785

self.getBlockDimension()

783

self.getBlockDimension()

786

784

787

785

788

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

786

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

789

msg = None

787

msg = None

790

try:

788

try:

791

fp = open(filename, 'rb')

789

fp = open(filename, 'rb')

792

currentPosition = fp.tell()

790

currentPosition = fp.tell()

793

except:

791

except:

794

if msgFlag:

792

if msgFlag:

795

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

793

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

796

return False

794

return False

797

795

798

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

796

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

799

797

800

if neededSize == 0:

798

if neededSize == 0:

801

basicHeaderObj = BasicHeader(LOCALTIME)

799

basicHeaderObj = BasicHeader(LOCALTIME)

802

systemHeaderObj = SystemHeader()

800

systemHeaderObj = SystemHeader()

803

radarControllerHeaderObj = RadarControllerHeader()

801

radarControllerHeaderObj = RadarControllerHeader()

804

processingHeaderObj = ProcessingHeader()

802

processingHeaderObj = ProcessingHeader()

805

803

806

try:

804

try:

807

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

805

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

808

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

806

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

809

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

807

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

810

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

808

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

811

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

812

810

813

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

811

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

814

812

815

except:

813

except:

816

if msgFlag:

814

if msgFlag:

817

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

818

816

819

fp.close()

817

fp.close()

820

return False

818

return False

821

else:

819

else:

822

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

823

821

824

fp.close()

822

fp.close()

825

fileSize = os.path.getsize(filename)

823

fileSize = os.path.getsize(filename)

826

currentSize = fileSize - currentPosition

824

currentSize = fileSize - currentPosition

827

if currentSize < neededSize:

825

if currentSize < neededSize:

828

if msgFlag and (msg != None):

826

if msgFlag and (msg != None):

829

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

830

return False

828

return False

831

829

832

return True

830

return True

833

831

834

def setup(self,

832

def setup(self,

835

path=None,

833

path=None,

836

startDate=None,

834

startDate=None,

837

endDate=None,

835

endDate=None,

838

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

836

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

839

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

837

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

840

set=0,

838

set=0,

841

expLabel = "",

839

expLabel = "",

842

ext = None,

840

ext = None,

843

online = False,

841

online = False,

844

delay = 60,

842

delay = 60,

845

walk = True):

843

walk = True):

846

844

847

if path == None:

845

if path == None:

848

raise ValueError, "The path is not valid"

846

raise ValueError, "The path is not valid"

849

847

850

if ext == None:

848

if ext == None:

851

ext = self.ext

849

ext = self.ext

852

850

853

if online:

851

if online:

854

print "Searching files in online mode..."

852

print "Searching files in online mode..."

855

853

856

for nTries in range( self.nTries ):

854

for nTries in range( self.nTries ):

857

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)

858

856

859

if fullpath:

857

if fullpath:

860

break

858

break

861

859

862

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)

863

time.sleep( self.delay )

861

time.sleep( self.delay )

864

862

865

if not(fullpath):

863

if not(fullpath):

866

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

864

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

867

return None

865

return None

868

866

869

self.year = year

867

self.year = year

870

self.doy = doy

868

self.doy = doy

871

self.set = set - 1

869

self.set = set - 1

872

self.path = path

870

self.path = path

873

871

874

else:

872

else:

875

print "Searching files in offline mode ..."

873

print "Searching files in offline mode ..."

876

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

874

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

877

startTime=startTime, endTime=endTime,

875

startTime=startTime, endTime=endTime,

878

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

876

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

879

walk=walk)

877

walk=walk)

880

878

881

if not(pathList):

879

if not(pathList):

882

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,

883

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

881

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

884

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

882

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

885

883

886

sys.exit(-1)

884

sys.exit(-1)

887

885

888

886

889

self.fileIndex = -1

887

self.fileIndex = -1

890

self.pathList = pathList

888

self.pathList = pathList

891

self.filenameList = filenameList

889

self.filenameList = filenameList

892

890

893

self.online = online

891

self.online = online

894

self.delay = delay

892

self.delay = delay

895

ext = ext.lower()

893

ext = ext.lower()

896

self.ext = ext

894

self.ext = ext

897

895

898

if not(self.setNextFile()):

896

if not(self.setNextFile()):

899

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

897

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

900

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

901

elif startDate != None:

899

elif startDate != None:

902

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

903

else:

901

else:

904

print "No files"

902

print "No files"

905

903

906

sys.exit(-1)

904

sys.exit(-1)

907

905

908

# self.updateDataHeader()

906

# self.updateDataHeader()

909

907

910

return self.dataOut

908

return self.dataOut

911

909

912

def getData():

910

def getData():

913

911

914

raise ValueError, "This method has not been implemented"

912

raise ValueError, "This method has not been implemented"

915

913

916

def hasNotDataInBuffer():

914

def hasNotDataInBuffer():

917

915

918

raise ValueError, "This method has not been implemented"

916

raise ValueError, "This method has not been implemented"

919

917

920

def readBlock():

918

def readBlock():

921

919

922

raise ValueError, "This method has not been implemented"

920

raise ValueError, "This method has not been implemented"

923

921

924

def isEndProcess(self):

922

def isEndProcess(self):

925

923

926

return self.flagNoMoreFiles

924

return self.flagNoMoreFiles

927

925

928

def printReadBlocks(self):

926

def printReadBlocks(self):

929

927

930

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

928

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

931

929

932

def printTotalBlocks(self):

930

def printTotalBlocks(self):

933

931

934

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

932

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

935

933

936

def printNumberOfBlock(self):

934

def printNumberOfBlock(self):

937

935

938

if self.flagIsNewBlock:

936

if self.flagIsNewBlock:

939

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

940

938

941

def printInfo(self):

939

def printInfo(self):

942

940

943

print self.basicHeaderObj.printInfo()

941

if self.__printInfo == False:

944

print self.systemHeaderObj.printInfo()

942

return

945

print self.radarControllerHeaderObj.printInfo()

943

946

~~print~~ self.~~processing~~HeaderObj.printInfo()

944

self.basicHeaderObj.printInfo()

945

self.systemHeaderObj.printInfo()

946

self.radarControllerHeaderObj.printInfo()

947

self.processingHeaderObj.printInfo()

948

949

self.__printInfo = False

947

950

948

951

949

def run(self, **kwargs):

952

def run(self, **kwargs):

950

953

951

if not(self.isConfig):

954

if not(self.isConfig):

952

955

953

# self.dataOut = dataOut

956

# self.dataOut = dataOut

954

self.setup(**kwargs)

957

self.setup(**kwargs)

955

self.isConfig = True

958

self.isConfig = True

956

959

957

self.getData()

960

self.getData()

958

961

959

class JRODataWriter(JRODataIO, Operation):

962

class JRODataWriter(JRODataIO, Operation):

960

963

961

"""

964

"""

962

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

963

de los datos siempre se realiza por bloques.

966

de los datos siempre se realiza por bloques.

964

"""

967

"""

965

968

966

blockIndex = 0

969

blockIndex = 0

967

970

968

path = None

971

path = None

969

972

970

setFile = None

973

setFile = None

971

974

972

profilesPerBlock = None

975

profilesPerBlock = None

973

976

974

blocksPerFile = None

977

blocksPerFile = None

975

978

976

nWriteBlocks = 0

979

nWriteBlocks = 0

977

980

978

def __init__(self, dataOut=None):

981

def __init__(self, dataOut=None):

979

raise ValueError, "Not implemented"

982

raise ValueError, "Not implemented"

980

983

981

984

982

def hasAllDataInBuffer(self):

985

def hasAllDataInBuffer(self):

983

raise ValueError, "Not implemented"

986

raise ValueError, "Not implemented"

984

987

985

988

986

def setBlockDimension(self):

989

def setBlockDimension(self):

987

raise ValueError, "Not implemented"

990

raise ValueError, "Not implemented"

988

991

989

992

990

def writeBlock(self):

993

def writeBlock(self):

991

raise ValueError, "No implemented"

994

raise ValueError, "No implemented"

992

995

993

996

994

def putData(self):

997

def putData(self):

995

raise ValueError, "No implemented"

998

raise ValueError, "No implemented"

996

999

997

def getDataHeader(self):

1000

def getDataHeader(self):

998

"""

1001

"""

999

Obtiene una copia del First Header

1002

Obtiene una copia del First Header

1000

1003

1001

Affected:

1004

Affected:

1002

1005

1003

self.basicHeaderObj

1006

self.basicHeaderObj

1004

self.systemHeaderObj

1007

self.systemHeaderObj

1005

self.radarControllerHeaderObj

1008

self.radarControllerHeaderObj

1006

self.processingHeaderObj self.

1009

self.processingHeaderObj self.

1007

1010

1008

Return:

1011

Return:

1009

None

1012

None

1010

"""

1013

"""

1011

1014

1012

raise ValueError, "No implemented"

1015

raise ValueError, "No implemented"

1013

1016

1014

def getBasicHeader(self):

1017

def getBasicHeader(self):

1015

1018

1016

self.basicHeaderObj.size = self.basicHeaderSize #bytes

1019

self.basicHeaderObj.size = self.basicHeaderSize #bytes

1017

self.basicHeaderObj.version = self.versionFile

1020

self.basicHeaderObj.version = self.versionFile

1018

self.basicHeaderObj.dataBlock = self.nTotalBlocks

1021

self.basicHeaderObj.dataBlock = self.nTotalBlocks

1019

1022

1020

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

1023

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

1021

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

1024

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

1022

1025

1023

self.basicHeaderObj.utc = utc

1026

self.basicHeaderObj.utc = utc

1024

self.basicHeaderObj.miliSecond = milisecond

1027

self.basicHeaderObj.miliSecond = milisecond

1025

self.basicHeaderObj.timeZone = 0

1028

self.basicHeaderObj.timeZone = 0

1026

self.basicHeaderObj.dstFlag = 0

1029

self.basicHeaderObj.dstFlag = 0

1027

self.basicHeaderObj.errorCount = 0

1030

self.basicHeaderObj.errorCount = 0

1028

1031

1029

def __writeFirstHeader(self):

1032

def __writeFirstHeader(self):

1030

"""

1033

"""

1031

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)

1032

1035

1033

Affected:

1036

Affected:

1034

__dataType

1037

__dataType

1035

1038

1036

Return:

1039

Return:

1037

None

1040

None

1038

"""

1041

"""

1039

1042

1040

# CALCULAR PARAMETROS

1043

# CALCULAR PARAMETROS

1041

1044

1042

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

1045

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

1043

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

1046

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

1044

1047

1045

self.basicHeaderObj.write(self.fp)

1048

self.basicHeaderObj.write(self.fp)

1046

self.systemHeaderObj.write(self.fp)

1049

self.systemHeaderObj.write(self.fp)

1047

self.radarControllerHeaderObj.write(self.fp)

1050

self.radarControllerHeaderObj.write(self.fp)

1048

self.processingHeaderObj.write(self.fp)

1051

self.processingHeaderObj.write(self.fp)

1049

1052

1050

self.dtype = self.dataOut.dtype

1053

self.dtype = self.dataOut.dtype

1051

1054

1052

def __setNewBlock(self):

1055

def __setNewBlock(self):

1053

"""

1056

"""

1054

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

1055

1058

1056

Return:

1059

Return:

1057

0 : si no pudo escribir nada

1060

0 : si no pudo escribir nada

1058

1 : Si escribio el Basic el First Header

1061

1 : Si escribio el Basic el First Header

1059

"""

1062

"""

1060

if self.fp == None:

1063

if self.fp == None:

1061

self.setNextFile()

1064

self.setNextFile()

1062

1065

1063

if self.flagIsNewFile:

1066

if self.flagIsNewFile:

1064

return 1

1067

return 1

1065

1068

1066

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

1069

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

1067

self.basicHeaderObj.write(self.fp)

1070

self.basicHeaderObj.write(self.fp)

1068

return 1

1071

return 1

1069

1072

1070

if not( self.setNextFile() ):

1073

if not( self.setNextFile() ):

1071

return 0

1074

return 0

1072

1075

1073

return 1

1076

return 1

1074

1077

1075

1078

1076

def writeNextBlock(self):

1079

def writeNextBlock(self):

1077

"""

1080

"""

1078

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

1079

1082

1080

Return:

1083

Return:

1081

0 : Si no hizo pudo escribir el bloque de datos

1084

0 : Si no hizo pudo escribir el bloque de datos

1082

1 : Si no pudo escribir el bloque de datos

1085

1 : Si no pudo escribir el bloque de datos

1083

"""

1086

"""

1084

if not( self.__setNewBlock() ):

1087

if not( self.__setNewBlock() ):

1085

return 0

1088

return 0

1086

1089

1087

self.writeBlock()

1090

self.writeBlock()

1088

1091

1089

return 1

1092

return 1

1090

1093

1091

def setNextFile(self):

1094

def setNextFile(self):

1092

"""

1095

"""

1093

Determina el siguiente file que sera escrito

1096

Determina el siguiente file que sera escrito

1094

1097

1095

Affected:

1098

Affected:

1096

self.filename

1099

self.filename

1097

self.subfolder

1100

self.subfolder

1098

self.fp

1101

self.fp

1099

self.setFile

1102

self.setFile

1100

self.flagIsNewFile

1103

self.flagIsNewFile

1101

1104

1102

Return:

1105

Return:

1103

0 : Si el archivo no puede ser escrito

1106

0 : Si el archivo no puede ser escrito

1104

1 : Si el archivo esta listo para ser escrito

1107

1 : Si el archivo esta listo para ser escrito

1105

"""

1108

"""

1106

ext = self.ext

1109

ext = self.ext

1107

path = self.path

1110

path = self.path

1108

1111

1109

if self.fp != None:

1112

if self.fp != None:

1110

self.fp.close()

1113

self.fp.close()

1111

1114

1112

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

1115

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

1113

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)

1114

1117

1115

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

1118

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

1116

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

1119

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

1117

os.mkdir(fullpath)

1120

os.mkdir(fullpath)

1118

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

1121

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

1119

else:

1122

else:

1120

filesList = os.listdir( fullpath )

1123

filesList = os.listdir( fullpath )

1121

if len( filesList ) > 0:

1124

if len( filesList ) > 0:

1122

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

1125

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

1123

filen = filesList[-1]

1126

filen = filesList[-1]

1124

# el filename debera tener el siguiente formato

1127

# el filename debera tener el siguiente formato

1125

# 0 1234 567 89A BCDE (hex)

1128

# 0 1234 567 89A BCDE (hex)

1126

# x YYYY DDD SSS .ext

1129

# x YYYY DDD SSS .ext

1127

if isNumber( filen[8:11] ):

1130

if isNumber( filen[8:11] ):

1128

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

1129

else:

1132

else:

1130

self.setFile = -1

1133

self.setFile = -1

1131

else:

1134

else:

1132

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

1135

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

1133

1136

1134

setFile = self.setFile

1137

setFile = self.setFile

1135

setFile += 1

1138

setFile += 1

1136

1139

1137

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

1140

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

1138

timeTuple.tm_year,

1141

timeTuple.tm_year,

1139

timeTuple.tm_yday,

1142

timeTuple.tm_yday,

1140

setFile,

1143

setFile,

1141

ext )

1144

ext )

1142

1145

1143

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

1146

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

1144

1147

1145

fp = open( filename,'wb' )

1148

fp = open( filename,'wb' )

1146

1149

1147

self.blockIndex = 0

1150

self.blockIndex = 0

1148

1151

1149

#guardando atributos

1152

#guardando atributos

1150

self.filename = filename

1153

self.filename = filename

1151

self.subfolder = subfolder

1154

self.subfolder = subfolder

1152

self.fp = fp

1155

self.fp = fp

1153

self.setFile = setFile

1156

self.setFile = setFile

1154

self.flagIsNewFile = 1

1157

self.flagIsNewFile = 1

1155

1158

1156

self.getDataHeader()

1159

self.getDataHeader()

1157

1160

1158

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

1161

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

1159

1162

1160

self.__writeFirstHeader()

1163

self.__writeFirstHeader()

1161

1164

1162

return 1

1165

return 1

1163

1166

1164

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

1165

"""

1168

"""

1166

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

1167

1170

1168

Inputs:

1171

Inputs:

1169

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

1170

format : formato en el cual sera salvado un file

1173

format : formato en el cual sera salvado un file

1171

set : el setebo del file

1174

set : el setebo del file

1172

1175

1173

Return:

1176

Return:

1174

0 : Si no realizo un buen seteo

1177

0 : Si no realizo un buen seteo

1175

1 : Si realizo un buen seteo

1178

1 : Si realizo un buen seteo

1176

"""

1179

"""

1177

1180

1178

if ext == None:

1181

if ext == None:

1179

ext = self.ext

1182

ext = self.ext

1180

1183

1181

ext = ext.lower()

1184

ext = ext.lower()

1182

1185

1183

self.ext = ext

1186

self.ext = ext

1184

1187

1185

self.path = path

1188

self.path = path

1186

1189

1187

self.setFile = set - 1

1190

self.setFile = set - 1

1188

1191

1189

self.blocksPerFile = blocksPerFile

1192

self.blocksPerFile = blocksPerFile

1190

1193

1191

self.profilesPerBlock = profilesPerBlock

1194

self.profilesPerBlock = profilesPerBlock

1192

1195

1193

self.dataOut = dataOut

1196

self.dataOut = dataOut

1194

1197

1195

if not(self.setNextFile()):

1198

if not(self.setNextFile()):

1196

print "There isn't a next file"

1199

print "There isn't a next file"

1197

return 0

1200

return 0

1198

1201

1199

self.setBlockDimension()

1202

self.setBlockDimension()

1200

1203

1201

return 1

1204

return 1

1202

1205

1203

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

1206

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

1204

1207

1205

if not(self.isConfig):

1208

if not(self.isConfig):

1206

1209

1207

self.setup(dataOut, **kwargs)

1210

self.setup(dataOut, **kwargs)

1208

self.isConfig = True

1211

self.isConfig = True

1209

1212

1210

self.putData()

1213

self.putData()

1211

1214

1212

class VoltageReader(JRODataReader):

1215

class VoltageReader(JRODataReader):

1213

"""

1216

"""

1214

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

1215

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:

1216

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

1219

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

1217

1220

1218

perfiles * alturas * canales

1221

perfiles * alturas * canales

1219

1222

1220

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

1223

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

1221

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

1222

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

1223

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".

1224

1227

1225

Example:

1228

Example:

1226

1229

1227

dpath = "/home/myuser/data"

1230

dpath = "/home/myuser/data"

1228

1231

1229

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)

1230

1233

1231

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)

1232

1235

1233

readerObj = VoltageReader()

1236

readerObj = VoltageReader()

1234

1237

1235

readerObj.setup(dpath, startTime, endTime)

1238

readerObj.setup(dpath, startTime, endTime)

1236

1239

1237

while(True):

1240

while(True):

1238

1241

1239

#to get one profile

1242

#to get one profile

1240

profile = readerObj.getData()

1243

profile = readerObj.getData()

1241

1244

1242

#print the profile

1245

#print the profile

1243

print profile

1246

print profile

1244

1247

1245

#If you want to see all datablock

1248

#If you want to see all datablock

1246

print readerObj.datablock

1249

print readerObj.datablock

1247

1250

1248

if readerObj.flagNoMoreFiles:

1251

if readerObj.flagNoMoreFiles:

1249

break

1252

break

1250

1253

1251

"""

1254

"""

1252

1255

1253

ext = ".r"

1256

ext = ".r"

1254

1257

1255

optchar = "D"

1258

optchar = "D"

1256

dataOut = None

1259

dataOut = None

1257

1260

1258

1261

1259

def __init__(self):

1262

def __init__(self):

1260

"""

1263

"""

1261

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.

1262

1265

1263

Input:

1266

Input:

1264

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

1267

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

1265

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

1266

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

1269

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

1267

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

1268

bloque de datos.

1271

bloque de datos.

1269

Si este parametro no es pasado se creara uno internamente.

1272

Si este parametro no es pasado se creara uno internamente.

1270

1273

1271

Variables afectadas:

1274

Variables afectadas:

1272

self.dataOut

1275

self.dataOut

1273

1276

1274

Return:

1277

Return:

1275

None

1278

None

1276

"""

1279

"""

1277

1280

1278

self.isConfig = False

1281

self.isConfig = False

1279

1282

1280

self.datablock = None

1283

self.datablock = None

1281

1284

1282

self.utc = 0

1285

self.utc = 0

1283

1286

1284

self.ext = ".r"

1287

self.ext = ".r"

1285

1288

1286

self.optchar = "D"

1289

self.optchar = "D"

1287

1290

1288

self.basicHeaderObj = BasicHeader(LOCALTIME)

1291

self.basicHeaderObj = BasicHeader(LOCALTIME)

1289

1292

1290

self.systemHeaderObj = SystemHeader()

1293

self.systemHeaderObj = SystemHeader()

1291

1294

1292

self.radarControllerHeaderObj = RadarControllerHeader()

1295

self.radarControllerHeaderObj = RadarControllerHeader()

1293

1296

1294

self.processingHeaderObj = ProcessingHeader()

1297

self.processingHeaderObj = ProcessingHeader()

1295

1298

1296

self.online = 0

1299

self.online = 0

1297

1300

1298

self.fp = None

1301

self.fp = None

1299

1302

1300

self.idFile = None

1303

self.idFile = None

1301

1304

1302

self.dtype = None

1305

self.dtype = None

1303

1306

1304

self.fileSizeByHeader = None

1307

self.fileSizeByHeader = None

1305

1308

1306

self.filenameList = []

1309

self.filenameList = []

1307

1310

1308

self.filename = None

1311

self.filename = None

1309

1312

1310

self.fileSize = None

1313

self.fileSize = None

1311

1314

1312

self.firstHeaderSize = 0

1315

self.firstHeaderSize = 0

1313

1316

1314

self.basicHeaderSize = 24

1317

self.basicHeaderSize = 24

1315

1318

1316

self.pathList = []

1319

self.pathList = []

1317

1320

1318

self.filenameList = []

1321

self.filenameList = []

1319

1322

1320

self.lastUTTime = 0

1323

self.lastUTTime = 0

1321

1324

1322

self.maxTimeStep = 30

1325

self.maxTimeStep = 30

1323

1326

1324

self.flagNoMoreFiles = 0

1327

self.flagNoMoreFiles = 0

1325

1328

1326

self.set = 0

1329

self.set = 0

1327

1330

1328

self.path = None

1331

self.path = None

1329

1332

1330

self.profileIndex = 2**32-1

1333

self.profileIndex = 2**32-1

1331

1334

1332

self.delay = 3 #seconds

1335

self.delay = 3 #seconds

1333

1336

1334

self.nTries = 3 #quantity tries

1337

self.nTries = 3 #quantity tries

1335

1338

1336

self.nFiles = 3 #number of files for searching

1339

self.nFiles = 3 #number of files for searching

1337

1340

1338

self.nReadBlocks = 0

1341

self.nReadBlocks = 0

1339

1342

1340

self.flagIsNewFile = 1

1343

self.flagIsNewFile = 1

1341

1344

1342

self.__isFirstTimeOnline = 1

1345

self.__isFirstTimeOnline = 1

1343

1346

1344

self.ippSeconds = 0

1347

self.ippSeconds = 0

1345

1348

1346

self.flagTimeBlock = 0

1349

self.flagTimeBlock = 0

1347

1350

1348

self.flagIsNewBlock = 0

1351

self.flagIsNewBlock = 0

1349

1352

1350

self.nTotalBlocks = 0

1353

self.nTotalBlocks = 0

1351

1354

1352

self.blocksize = 0

1355

self.blocksize = 0

1353

1356

1354

self.dataOut = self.createObjByDefault()

1357

self.dataOut = self.createObjByDefault()

1355

1358

1356

def createObjByDefault(self):

1359

def createObjByDefault(self):

1357

1360

1358

dataObj = Voltage()

1361

dataObj = Voltage()

1359

1362

1360

return dataObj

1363

return dataObj

1361

1364

1362

def __hasNotDataInBuffer(self):

1365

def __hasNotDataInBuffer(self):

1363

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

1366

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

1364

return 1

1367

return 1

1365

return 0

1368

return 0

1366

1369

1367

1370

1368

def getBlockDimension(self):

1371

def getBlockDimension(self):

1369

"""

1372

"""

1370

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

1371

1374

1372

Affected:

1375

Affected:

1373

self.blocksize

1376

self.blocksize

1374

1377

1375

Return:

1378

Return:

1376

None

1379

None

1377

"""

1380

"""

1378

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

1381

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

1379

self.blocksize = pts2read

1382

self.blocksize = pts2read

1380

1383

1381

1384

1382

def readBlock(self):

1385

def readBlock(self):

1383

"""

1386

"""

1384

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

1385

(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

1386

(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

1387

es seteado a 0

1390

es seteado a 0

1388

1391

1389

Inputs:

1392

Inputs:

1390

None

1393

None

1391

1394

1392

Return:

1395

Return:

1393

None

1396

None

1394

1397

1395

Affected:

1398

Affected:

1396

self.profileIndex

1399

self.profileIndex

1397

self.datablock

1400

self.datablock

1398

self.flagIsNewFile

1401

self.flagIsNewFile

1399

self.flagIsNewBlock

1402

self.flagIsNewBlock

1400

self.nTotalBlocks

1403

self.nTotalBlocks

1401

1404

1402

Exceptions:

1405

Exceptions:

1403

Si un bloque leido no es un bloque valido

1406

Si un bloque leido no es un bloque valido

1404

"""

1407

"""

1405

1408

1406

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

1409

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

1407

1410

1408

try:

1411

try:

1409

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

1410

except:

1413

except:

1411

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

1414

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

1412

return 0

1415

return 0

1413

1416

1414

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

1417

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

1415

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

1418

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

1416

1419

1417

self.profileIndex = 0

1420

self.profileIndex = 0

1418

1421

1419

self.flagIsNewFile = 0

1422

self.flagIsNewFile = 0

1420

self.flagIsNewBlock = 1

1423

self.flagIsNewBlock = 1

1421

1424

1422

self.nTotalBlocks += 1

1425

self.nTotalBlocks += 1

1423

self.nReadBlocks += 1

1426

self.nReadBlocks += 1

1424

1427

1425

return 1

1428

return 1

1426

1429

1427

1430

1428

def getData(self):

1431

def getData(self):

1429

"""

1432

"""

1430

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"

1431

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

1432

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"

1433

1436

1434

Ademas incrementa el contador del buffer en 1.

1437

Ademas incrementa el contador del buffer en 1.

1435

1438

1436

Return:

1439

Return:

1437

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

1440

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

1438

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

1441

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

1439

1442

1440

Variables afectadas:

1443

Variables afectadas:

1441

self.dataOut

1444

self.dataOut

1442

self.profileIndex

1445

self.profileIndex

1443

1446

1444

Affected:

1447

Affected:

1445

self.dataOut

1448

self.dataOut

1446

self.profileIndex

1449

self.profileIndex

1447

self.flagTimeBlock

1450

self.flagTimeBlock

1448

self.flagIsNewBlock

1451

self.flagIsNewBlock

1449

"""

1452

"""

1450

1453

1451

if self.flagNoMoreFiles:

1454

if self.flagNoMoreFiles:

1452

self.dataOut.flagNoData = True

1455

self.dataOut.flagNoData = True

1453

print 'Process finished'

1456

print 'Process finished'

1454

return 0

1457

return 0

1455

1458

1456

self.flagTimeBlock = 0

1459

self.flagTimeBlock = 0

1457

self.flagIsNewBlock = 0

1460

self.flagIsNewBlock = 0

1458

1461

1459

if self.__hasNotDataInBuffer():

1462

if self.__hasNotDataInBuffer():

1460

1463

1461

if not( self.readNextBlock() ):

1464

if not( self.readNextBlock() ):

1462

return 0

1465

return 0

1463

1466

1464

self.dataOut.dtype = self.dtype

1467

self.dataOut.dtype = self.dtype

1465

1468

1466

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1469

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1467

1470

1468

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

1471

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

1469

1472

1470

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)

1471

1474

1472

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

1475

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

1473

1476

1474

self.dataOut.flagTimeBlock = self.flagTimeBlock

1477

self.dataOut.flagTimeBlock = self.flagTimeBlock

1475

1478

1476

self.dataOut.ippSeconds = self.ippSeconds

1479

self.dataOut.ippSeconds = self.ippSeconds

1477

1480

1478

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

1481

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

1479

1482

1480

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1483

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1481

1484

1482

self.dataOut.flagShiftFFT = False

1485

self.dataOut.flagShiftFFT = False

1483

1486

1484

if self.radarControllerHeaderObj.code != None:

1487

if self.radarControllerHeaderObj.code != None:

1485

1488

1486

self.dataOut.nCode = self.radarControllerHeaderObj.nCode

1489

self.dataOut.nCode = self.radarControllerHeaderObj.nCode

1487

1490

1488

self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud

1491

self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud

1489

1492

1490

self.dataOut.code = self.radarControllerHeaderObj.code

1493

self.dataOut.code = self.radarControllerHeaderObj.code

1491

1494

1492

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

1495

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

1493

1496

1494

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

1497

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

1495

1498

1496

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

1499

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

1497

1500

1498

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

1499

1502

1500

self.dataOut.flagShiftFFT = False

1503

self.dataOut.flagShiftFFT = False

1501

1504

1502

1505

1503

# self.updateDataHeader()

1506

# self.updateDataHeader()

1504

1507

1505

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

1506

1509

1507

if self.datablock == None:

1510

if self.datablock == None:

1508

self.dataOut.flagNoData = True

1511

self.dataOut.flagNoData = True

1509

return 0

1512

return 0

1510

1513

1511

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

1514

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

1512

1515

1513

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

1514

1517

1515

self.profileIndex += 1

1518

self.profileIndex += 1

1516

1519

1517

self.dataOut.flagNoData = False

1520

self.dataOut.flagNoData = False

1518

1521

1519

# print self.profileIndex, self.dataOut.utctime

1522

# print self.profileIndex, self.dataOut.utctime

1520

# if self.profileIndex == 800:

1523

# if self.profileIndex == 800:

1521

# a=1

1524

# a=1

1522

1525

1523

1526

1524

return self.dataOut.data

1527

return self.dataOut.data

1525

1528

1526

1529

1527

class VoltageWriter(JRODataWriter):

1530

class VoltageWriter(JRODataWriter):

1528

"""

1531

"""

1529

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

1530

de los datos siempre se realiza por bloques.

1533

de los datos siempre se realiza por bloques.

1531

"""

1534

"""

1532

1535

1533

ext = ".r"

1536

ext = ".r"

1534

1537

1535

optchar = "D"

1538

optchar = "D"

1536

1539

1537

shapeBuffer = None

1540

shapeBuffer = None

1538

1541

1539

1542

1540

def __init__(self):

1543

def __init__(self):

1541

"""

1544

"""

1542

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.

1543

1546

1544

Affected:

1547

Affected:

1545

self.dataOut

1548

self.dataOut

1546

1549

1547

Return: None

1550

Return: None

1548

"""

1551

"""

1549

1552

1550

self.nTotalBlocks = 0

1553

self.nTotalBlocks = 0

1551

1554

1552

self.profileIndex = 0

1555

self.profileIndex = 0

1553

1556

1554

self.isConfig = False

1557

self.isConfig = False

1555

1558

1556

self.fp = None

1559

self.fp = None

1557

1560

1558

self.flagIsNewFile = 1

1561

self.flagIsNewFile = 1

1559

1562

1560

self.nTotalBlocks = 0

1563

self.nTotalBlocks = 0

1561

1564

1562

self.flagIsNewBlock = 0

1565

self.flagIsNewBlock = 0

1563

1566

1564

self.setFile = None

1567

self.setFile = None

1565

1568

1566

self.dtype = None

1569

self.dtype = None

1567

1570

1568

self.path = None

1571

self.path = None

1569

1572

1570

self.filename = None

1573

self.filename = None

1571

1574

1572

self.basicHeaderObj = BasicHeader(LOCALTIME)

1575

self.basicHeaderObj = BasicHeader(LOCALTIME)

1573

1576

1574

self.systemHeaderObj = SystemHeader()

1577

self.systemHeaderObj = SystemHeader()

1575

1578

1576

self.radarControllerHeaderObj = RadarControllerHeader()

1579

self.radarControllerHeaderObj = RadarControllerHeader()

1577

1580

1578

self.processingHeaderObj = ProcessingHeader()

1581

self.processingHeaderObj = ProcessingHeader()

1579

1582

1580

def hasAllDataInBuffer(self):

1583

def hasAllDataInBuffer(self):

1581

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

1584

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

1582

return 1

1585

return 1

1583

return 0

1586

return 0

1584

1587

1585

1588

1586

def setBlockDimension(self):

1589

def setBlockDimension(self):

1587

"""

1590

"""

1588

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

1589

1592

1590

Affected:

1593

Affected:

1591

self.shape_spc_Buffer

1594

self.shape_spc_Buffer

1592

self.shape_cspc_Buffer

1595

self.shape_cspc_Buffer

1593

self.shape_dc_Buffer

1596

self.shape_dc_Buffer

1594

1597

1595

Return: None

1598

Return: None

1596

"""

1599

"""

1597

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1600

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1598

self.processingHeaderObj.nHeights,

1601

self.processingHeaderObj.nHeights,

1599

self.systemHeaderObj.nChannels)

1602

self.systemHeaderObj.nChannels)

1600

1603

1601

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

1604

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

1602

self.processingHeaderObj.profilesPerBlock,

1605

self.processingHeaderObj.profilesPerBlock,

1603

self.processingHeaderObj.nHeights),

1606

self.processingHeaderObj.nHeights),

1604

dtype=numpy.dtype('complex64'))

1607

dtype=numpy.dtype('complex64'))

1605

1608

1606

1609

1607

def writeBlock(self):

1610

def writeBlock(self):

1608

"""

1611

"""

1609

Escribe el buffer en el file designado

1612

Escribe el buffer en el file designado

1610

1613

1611

Affected:

1614

Affected:

1612

self.profileIndex

1615

self.profileIndex

1613

self.flagIsNewFile

1616

self.flagIsNewFile

1614

self.flagIsNewBlock

1617

self.flagIsNewBlock

1615

self.nTotalBlocks

1618

self.nTotalBlocks

1616

self.blockIndex

1619

self.blockIndex

1617

1620

1618

Return: None

1621

Return: None

1619

"""

1622

"""

1620

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

1623

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

1621

1624

1622

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

1625

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

1623

1626

1624

data['real'] = junk.real

1627

data['real'] = junk.real

1625

data['imag'] = junk.imag

1628

data['imag'] = junk.imag

1626

1629

1627

data = data.reshape( (-1) )

1630

data = data.reshape( (-1) )

1628

1631

1629

data.tofile( self.fp )

1632

data.tofile( self.fp )

1630

1633

1631

self.datablock.fill(0)

1634

self.datablock.fill(0)

1632

1635

1633

self.profileIndex = 0

1636

self.profileIndex = 0

1634

self.flagIsNewFile = 0

1637

self.flagIsNewFile = 0

1635

self.flagIsNewBlock = 1

1638

self.flagIsNewBlock = 1

1636

1639

1637

self.blockIndex += 1

1640

self.blockIndex += 1

1638

self.nTotalBlocks += 1

1641

self.nTotalBlocks += 1

1639

1642

1640

def putData(self):

1643

def putData(self):

1641

"""

1644

"""

1642

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

1643

1646

1644

Affected:

1647

Affected:

1645

self.flagIsNewBlock

1648

self.flagIsNewBlock

1646

self.profileIndex

1649

self.profileIndex

1647

1650

1648

Return:

1651

Return:

1649

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

1650

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

1651

"""

1654

"""

1652

if self.dataOut.flagNoData:

1655

if self.dataOut.flagNoData:

1653

return 0

1656

return 0

1654

1657

1655

self.flagIsNewBlock = 0

1658

self.flagIsNewBlock = 0

1656

1659

1657

if self.dataOut.flagTimeBlock:

1660

if self.dataOut.flagTimeBlock:

1658

1661

1659

self.datablock.fill(0)

1662

self.datablock.fill(0)

1660

self.profileIndex = 0

1663

self.profileIndex = 0

1661

self.setNextFile()

1664

self.setNextFile()

1662

1665

1663

if self.profileIndex == 0:

1666

if self.profileIndex == 0:

1664

self.getBasicHeader()

1667

self.getBasicHeader()

1665

1668

1666

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

1669

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

1667

1670

1668

self.profileIndex += 1

1671

self.profileIndex += 1

1669

1672

1670

if self.hasAllDataInBuffer():

1673

if self.hasAllDataInBuffer():

1671

#if self.flagIsNewFile:

1674

#if self.flagIsNewFile:

1672

self.writeNextBlock()

1675

self.writeNextBlock()

1673

# self.getDataHeader()

1676

# self.getDataHeader()

1674

1677

1675

return 1

1678

return 1

1676

1679

1677

def __getProcessFlags(self):

1680

def __getProcessFlags(self):

1678

1681

1679

processFlags = 0

1682

processFlags = 0

1680

1683

1681

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

1684

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

1682

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

1685

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

1683

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

1686

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

1684

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

1687

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

1685

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

1688

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

1686

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

1689

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

1687

1690

1688

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

1691

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

1689

1692

1690

1693

1691

1694

1692

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1695

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1693

PROCFLAG.DATATYPE_SHORT,

1696

PROCFLAG.DATATYPE_SHORT,

1694

PROCFLAG.DATATYPE_LONG,

1697

PROCFLAG.DATATYPE_LONG,

1695

PROCFLAG.DATATYPE_INT64,

1698

PROCFLAG.DATATYPE_INT64,

1696

PROCFLAG.DATATYPE_FLOAT,

1699

PROCFLAG.DATATYPE_FLOAT,

1697

PROCFLAG.DATATYPE_DOUBLE]

1700

PROCFLAG.DATATYPE_DOUBLE]

1698

1701

1699

1702

1700

for index in range(len(dtypeList)):

1703

for index in range(len(dtypeList)):

1701

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

1704

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

1702

dtypeValue = datatypeValueList[index]

1705

dtypeValue = datatypeValueList[index]

1703

break

1706

break

1704

1707

1705

processFlags += dtypeValue

1708

processFlags += dtypeValue

1706

1709

1707

if self.dataOut.flagDecodeData:

1710

if self.dataOut.flagDecodeData:

1708

processFlags += PROCFLAG.DECODE_DATA

1711

processFlags += PROCFLAG.DECODE_DATA

1709

1712

1710

if self.dataOut.flagDeflipData:

1713

if self.dataOut.flagDeflipData:

1711

processFlags += PROCFLAG.DEFLIP_DATA

1714

processFlags += PROCFLAG.DEFLIP_DATA

1712

1715

1713

if self.dataOut.code != None:

1716

if self.dataOut.code != None:

1714

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1717

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1715

1718

1716

if self.dataOut.nCohInt > 1:

1719

if self.dataOut.nCohInt > 1:

1717

processFlags += PROCFLAG.COHERENT_INTEGRATION

1720

processFlags += PROCFLAG.COHERENT_INTEGRATION

1718

1721

1719

return processFlags

1722

return processFlags

1720

1723

1721

1724

1722

def __getBlockSize(self):

1725

def __getBlockSize(self):

1723

'''

1726

'''

1724

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

1725

'''

1728

'''

1726

1729

1727

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

1730

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

1728

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

1731

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

1729

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

1732

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

1730

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

1733

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

1731

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

1734

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

1732

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

1735

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

1733

1736

1734

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

1737

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

1735

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

1738

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

1736

for index in range(len(dtypeList)):

1739

for index in range(len(dtypeList)):

1737

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

1740

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

1738

datatypeValue = datatypeValueList[index]

1741

datatypeValue = datatypeValueList[index]

1739

break

1742

break

1740

1743

1741

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)

1742

1745

1743

return blocksize

1746

return blocksize

1744

1747

1745

def getDataHeader(self):

1748

def getDataHeader(self):

1746

1749

1747

"""

1750

"""

1748

Obtiene una copia del First Header

1751

Obtiene una copia del First Header

1749

1752

1750

Affected:

1753

Affected:

1751

self.systemHeaderObj

1754

self.systemHeaderObj

1752

self.radarControllerHeaderObj

1755

self.radarControllerHeaderObj

1753

self.dtype

1756

self.dtype

1754

1757

1755

Return:

1758

Return:

1756

None

1759

None

1757

"""

1760

"""

1758

1761

1759

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

1762

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

1760

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1763

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1761

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

1764

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

1762

1765

1763

self.getBasicHeader()

1766

self.getBasicHeader()

1764

1767

1765

processingHeaderSize = 40 # bytes

1768

processingHeaderSize = 40 # bytes

1766

self.processingHeaderObj.dtype = 0 # Voltage

1769

self.processingHeaderObj.dtype = 0 # Voltage

1767

self.processingHeaderObj.blockSize = self.__getBlockSize()

1770

self.processingHeaderObj.blockSize = self.__getBlockSize()

1768

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1771

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1769

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1772

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1770

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

1771

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1774

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1772

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1775

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1773

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

1774

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

1775

1778

1776

if self.dataOut.code != None:

1779

if self.dataOut.code != None:

1777

self.processingHeaderObj.code = self.dataOut.code

1780

self.processingHeaderObj.code = self.dataOut.code

1778

self.processingHeaderObj.nCode = self.dataOut.nCode

1781

self.processingHeaderObj.nCode = self.dataOut.nCode

1779

self.processingHeaderObj.nBaud = self.dataOut.nBaud

1782

self.processingHeaderObj.nBaud = self.dataOut.nBaud

1780

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

1783

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

1781

processingHeaderSize += codesize

1784

processingHeaderSize += codesize

1782

1785

1783

if self.processingHeaderObj.nWindows != 0:

1786

if self.processingHeaderObj.nWindows != 0:

1784

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

1787

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

1785

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

1788

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

1786

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1789

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1787

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1790

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1788

processingHeaderSize += 12

1791

processingHeaderSize += 12

1789

1792

1790

self.processingHeaderObj.size = processingHeaderSize

1793

self.processingHeaderObj.size = processingHeaderSize

1791

1794

1792

class SpectraReader(JRODataReader):

1795

class SpectraReader(JRODataReader):

1793

"""

1796

"""

1794

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

1795

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)

1796

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.

1797

1800

1798

paresCanalesIguales * alturas * perfiles (Self Spectra)

1801

paresCanalesIguales * alturas * perfiles (Self Spectra)

1799

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1802

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1800

canales * alturas (DC Channels)

1803

canales * alturas (DC Channels)

1801

1804

1802

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

1805

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

1803

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

1804

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

1805

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".

1806

1809

1807

Example:

1810

Example:

1808

dpath = "/home/myuser/data"

1811

dpath = "/home/myuser/data"

1809

1812

1810

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)

1811

1814

1812

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)

1813

1816

1814

readerObj = SpectraReader()

1817

readerObj = SpectraReader()

1815

1818

1816

readerObj.setup(dpath, startTime, endTime)

1819

readerObj.setup(dpath, startTime, endTime)

1817

1820

1818

while(True):

1821

while(True):

1819

1822

1820

readerObj.getData()

1823

readerObj.getData()

1821

1824

1822

print readerObj.data_spc

1825

print readerObj.data_spc

1823

1826

1824

print readerObj.data_cspc

1827

print readerObj.data_cspc

1825

1828

1826

print readerObj.data_dc

1829

print readerObj.data_dc

1827

1830

1828

if readerObj.flagNoMoreFiles:

1831

if readerObj.flagNoMoreFiles:

1829

break

1832

break

1830

1833

1831

"""

1834

"""

1832

1835

1833

pts2read_SelfSpectra = 0

1836

pts2read_SelfSpectra = 0

1834

1837

1835

pts2read_CrossSpectra = 0

1838

pts2read_CrossSpectra = 0

1836

1839

1837

pts2read_DCchannels = 0

1840

pts2read_DCchannels = 0

1838

1841

1839

ext = ".pdata"

1842

ext = ".pdata"

1840

1843

1841

optchar = "P"

1844

optchar = "P"

1842

1845

1843

dataOut = None

1846

dataOut = None

1844

1847

1845

nRdChannels = None

1848

nRdChannels = None

1846

1849

1847

nRdPairs = None

1850

nRdPairs = None

1848

1851

1849

rdPairList = []

1852

rdPairList = []

1850

1853

1851

1854

1852

def __init__(self):

1855

def __init__(self):

1853

"""

1856

"""

1854

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.

1855

1858

1856

Inputs:

1859

Inputs:

1857

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

1860

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

1858

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

1859

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

1862

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

1860

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

1861

bloque de datos.

1864

bloque de datos.

1862

Si este parametro no es pasado se creara uno internamente.

1865

Si este parametro no es pasado se creara uno internamente.

1863

1866

1864

Affected:

1867

Affected:

1865

self.dataOut

1868

self.dataOut

1866

1869

1867

Return : None

1870

Return : None

1868

"""

1871

"""

1869

1872

1870

self.isConfig = False

1873

self.isConfig = False

1871

1874

1872

self.pts2read_SelfSpectra = 0

1875

self.pts2read_SelfSpectra = 0

1873

1876

1874

self.pts2read_CrossSpectra = 0

1877

self.pts2read_CrossSpectra = 0

1875

1878

1876

self.pts2read_DCchannels = 0

1879

self.pts2read_DCchannels = 0

1877

1880

1878

self.datablock = None

1881

self.datablock = None

1879

1882

1880

self.utc = None

1883

self.utc = None

1881

1884

1882

self.ext = ".pdata"

1885

self.ext = ".pdata"

1883

1886

1884

self.optchar = "P"

1887

self.optchar = "P"

1885

1888

1886

self.basicHeaderObj = BasicHeader(LOCALTIME)

1889

self.basicHeaderObj = BasicHeader(LOCALTIME)

1887

1890

1888

self.systemHeaderObj = SystemHeader()

1891

self.systemHeaderObj = SystemHeader()

1889

1892

1890

self.radarControllerHeaderObj = RadarControllerHeader()

1893

self.radarControllerHeaderObj = RadarControllerHeader()

1891

1894

1892

self.processingHeaderObj = ProcessingHeader()

1895

self.processingHeaderObj = ProcessingHeader()

1893

1896

1894

self.online = 0

1897

self.online = 0

1895

1898

1896

self.fp = None

1899

self.fp = None

1897

1900

1898

self.idFile = None

1901

self.idFile = None

1899

1902

1900

self.dtype = None

1903

self.dtype = None

1901

1904

1902

self.fileSizeByHeader = None

1905

self.fileSizeByHeader = None

1903

1906

1904

self.filenameList = []

1907

self.filenameList = []

1905

1908

1906

self.filename = None

1909

self.filename = None

1907

1910

1908

self.fileSize = None

1911

self.fileSize = None

1909

1912

1910

self.firstHeaderSize = 0

1913

self.firstHeaderSize = 0

1911

1914

1912

self.basicHeaderSize = 24

1915

self.basicHeaderSize = 24

1913

1916

1914

self.pathList = []

1917

self.pathList = []

1915

1918

1916

self.lastUTTime = 0

1919

self.lastUTTime = 0

1917

1920

1918

self.maxTimeStep = 30

1921

self.maxTimeStep = 30

1919

1922

1920

self.flagNoMoreFiles = 0

1923

self.flagNoMoreFiles = 0

1921

1924

1922

self.set = 0

1925

self.set = 0

1923

1926

1924

self.path = None

1927

self.path = None

1925

1928

1926

self.delay = 60 #seconds

1929

self.delay = 60 #seconds

1927

1930

1928

self.nTries = 3 #quantity tries

1931

self.nTries = 3 #quantity tries

1929

1932

1930

self.nFiles = 3 #number of files for searching

1933

self.nFiles = 3 #number of files for searching

1931

1934

1932

self.nReadBlocks = 0

1935

self.nReadBlocks = 0

1933

1936

1934

self.flagIsNewFile = 1

1937

self.flagIsNewFile = 1

1935

1938

1936

self.__isFirstTimeOnline = 1

1939

self.__isFirstTimeOnline = 1

1937

1940

1938

self.ippSeconds = 0

1941

self.ippSeconds = 0

1939

1942

1940

self.flagTimeBlock = 0

1943

self.flagTimeBlock = 0

1941

1944

1942

self.flagIsNewBlock = 0

1945

self.flagIsNewBlock = 0

1943

1946

1944

self.nTotalBlocks = 0

1947

self.nTotalBlocks = 0

1945

1948

1946

self.blocksize = 0

1949

self.blocksize = 0

1947

1950

1948

self.dataOut = self.createObjByDefault()

1951

self.dataOut = self.createObjByDefault()

1949

1952

1950

1953

1951

def createObjByDefault(self):

1954

def createObjByDefault(self):

1952

1955

1953

dataObj = Spectra()

1956

dataObj = Spectra()

1954

1957

1955

return dataObj

1958

return dataObj

1956

1959

1957

def __hasNotDataInBuffer(self):

1960

def __hasNotDataInBuffer(self):

1958

return 1

1961

return 1

1959

1962

1960

1963

1961

def getBlockDimension(self):

1964

def getBlockDimension(self):

1962

"""

1965

"""

1963

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

1964

1967

1965

Affected:

1968

Affected:

1966

self.nRdChannels

1969

self.nRdChannels

1967

self.nRdPairs

1970

self.nRdPairs

1968

self.pts2read_SelfSpectra

1971

self.pts2read_SelfSpectra

1969

self.pts2read_CrossSpectra

1972

self.pts2read_CrossSpectra

1970

self.pts2read_DCchannels

1973

self.pts2read_DCchannels

1971

self.blocksize

1974

self.blocksize

1972

self.dataOut.nChannels

1975

self.dataOut.nChannels

1973

self.dataOut.nPairs

1976

self.dataOut.nPairs

1974

1977

1975

Return:

1978

Return:

1976

None

1979

None

1977

"""

1980

"""

1978

self.nRdChannels = 0

1981

self.nRdChannels = 0

1979

self.nRdPairs = 0

1982

self.nRdPairs = 0

1980

self.rdPairList = []

1983

self.rdPairList = []

1981

1984

1982

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

1985

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

1983

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

1986

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

1984

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

1987

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

1985

else:

1988

else:

1986

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

1989

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

1987

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

1988

1991

1989

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

1992

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

1990

1993

1991

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

1994

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

1992

self.blocksize = self.pts2read_SelfSpectra

1995

self.blocksize = self.pts2read_SelfSpectra

1993

1996

1994

if self.processingHeaderObj.flag_cspc:

1997

if self.processingHeaderObj.flag_cspc:

1995

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

1998

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

1996

self.blocksize += self.pts2read_CrossSpectra

1999

self.blocksize += self.pts2read_CrossSpectra

1997

2000

1998

if self.processingHeaderObj.flag_dc:

2001

if self.processingHeaderObj.flag_dc:

1999

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

2002

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

2000

self.blocksize += self.pts2read_DCchannels

2003

self.blocksize += self.pts2read_DCchannels

2001

2004

2002

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

2005

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

2003

2006

2004

2007

2005

def readBlock(self):

2008

def readBlock(self):

2006

"""

2009

"""

2007

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

2008

(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

2009

(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

2010

es seteado a 0

2013

es seteado a 0

2011

2014

2012

Return: None

2015

Return: None

2013

2016

2014

Variables afectadas:

2017

Variables afectadas:

2015

2018

2016

self.flagIsNewFile

2019

self.flagIsNewFile

2017

self.flagIsNewBlock

2020

self.flagIsNewBlock

2018

self.nTotalBlocks

2021

self.nTotalBlocks

2019

self.data_spc

2022

self.data_spc

2020

self.data_cspc

2023

self.data_cspc

2021

self.data_dc

2024

self.data_dc

2022

2025

2023

Exceptions:

2026

Exceptions:

2024

Si un bloque leido no es un bloque valido

2027

Si un bloque leido no es un bloque valido

2025

"""

2028

"""

2026

blockOk_flag = False

2029

blockOk_flag = False

2027

fpointer = self.fp.tell()

2030

fpointer = self.fp.tell()

2028

2031

2029

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

2032

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

2030

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

2031

2034

2032

if self.processingHeaderObj.flag_cspc:

2035

if self.processingHeaderObj.flag_cspc:

2033

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

2036

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

2034

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

2035

2038

2036

if self.processingHeaderObj.flag_dc:

2039

if self.processingHeaderObj.flag_dc:

2037

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

2038

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

2039

2042

2040

2043

2041

if not(self.processingHeaderObj.shif_fft):

2044

if not(self.processingHeaderObj.shif_fft):

2042

#desplaza a la derecha en el eje 2 determinadas posiciones

2045

#desplaza a la derecha en el eje 2 determinadas posiciones

2043

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

2046

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

2044

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

2047

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

2045

2048

2046

if self.processingHeaderObj.flag_cspc:

2049

if self.processingHeaderObj.flag_cspc:

2047

#desplaza a la derecha en el eje 2 determinadas posiciones

2050

#desplaza a la derecha en el eje 2 determinadas posiciones

2048

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

2051

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

2049

2052

2050

# self.processingHeaderObj.shif_fft = True

2053

# self.processingHeaderObj.shif_fft = True

2051

2054

2052

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

2055

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

2053

self.data_spc = spc

2056

self.data_spc = spc

2054

2057

2055

if self.processingHeaderObj.flag_cspc:

2058

if self.processingHeaderObj.flag_cspc:

2056

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

2059

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

2057

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

2060

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

2058

else:

2061

else:

2059

self.data_cspc = None

2062

self.data_cspc = None

2060

2063

2061

if self.processingHeaderObj.flag_dc:

2064

if self.processingHeaderObj.flag_dc:

2062

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

2065

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

2063

else:

2066

else:

2064

self.data_dc = None

2067

self.data_dc = None

2065

2068

2066

self.flagIsNewFile = 0

2069

self.flagIsNewFile = 0

2067

self.flagIsNewBlock = 1

2070

self.flagIsNewBlock = 1

2068

2071

2069

self.nTotalBlocks += 1

2072

self.nTotalBlocks += 1

2070

self.nReadBlocks += 1

2073

self.nReadBlocks += 1

2071

2074

2072

return 1

2075

return 1

2073

2076

2074

2077

2075

def getData(self):

2078

def getData(self):

2076

"""

2079

"""

2077

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

2080

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

2078

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

2079

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"

2080

2083

2081

Return:

2084

Return:

2082

0 : Si no hay mas archivos disponibles

2085

0 : Si no hay mas archivos disponibles

2083

1 : Si hizo una buena copia del buffer

2086

1 : Si hizo una buena copia del buffer

2084

2087

2085

Affected:

2088

Affected:

2086

self.dataOut

2089

self.dataOut

2087

2090

2088

self.flagTimeBlock

2091

self.flagTimeBlock

2089

self.flagIsNewBlock

2092

self.flagIsNewBlock

2090

"""

2093

"""

2091

2094

2092

if self.flagNoMoreFiles:

2095

if self.flagNoMoreFiles:

2093

self.dataOut.flagNoData = True

2096

self.dataOut.flagNoData = True

2094

print 'Process finished'

2097

print 'Process finished'

2095

return 0

2098

return 0

2096

2099

2097

self.flagTimeBlock = 0

2100

self.flagTimeBlock = 0

2098

self.flagIsNewBlock = 0

2101

self.flagIsNewBlock = 0

2099

2102

2100

if self.__hasNotDataInBuffer():

2103

if self.__hasNotDataInBuffer():

2101

2104

2102

if not( self.readNextBlock() ):

2105

if not( self.readNextBlock() ):

2103

self.dataOut.flagNoData = True

2106

self.dataOut.flagNoData = True

2104

return 0

2107

return 0

2105

2108

2106

# self.updateDataHeader()

2109

# self.updateDataHeader()

2107

2110

2108

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

2109

2112

2110

if self.data_dc == None:

2113

if self.data_dc == None:

2111

self.dataOut.flagNoData = True

2114

self.dataOut.flagNoData = True

2112

return 0

2115

return 0

2113

2116

2114

self.dataOut.data_spc = self.data_spc

2117

self.dataOut.data_spc = self.data_spc

2115

2118

2116

self.dataOut.data_cspc = self.data_cspc

2119

self.dataOut.data_cspc = self.data_cspc

2117

2120

2118

self.dataOut.data_dc = self.data_dc

2121

self.dataOut.data_dc = self.data_dc

2119

2122

2120

self.dataOut.flagTimeBlock = self.flagTimeBlock

2123

self.dataOut.flagTimeBlock = self.flagTimeBlock

2121

2124

2122

self.dataOut.flagNoData = False

2125

self.dataOut.flagNoData = False

2123

2126

2124

self.dataOut.dtype = self.dtype

2127

self.dataOut.dtype = self.dtype

2125

2128

2126

# self.dataOut.nChannels = self.nRdChannels

2129

# self.dataOut.nChannels = self.nRdChannels

2127

2130

2128

self.dataOut.nPairs = self.nRdPairs

2131

self.dataOut.nPairs = self.nRdPairs

2129

2132

2130

self.dataOut.pairsList = self.rdPairList

2133

self.dataOut.pairsList = self.rdPairList

2131

2134

2132

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

2135

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

2133

2136

2134

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

2137

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

2135

2138

2136

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

2139

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

2137

2140

2138

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

2141

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

2139

2142

2140

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

2143

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

2141

2144

2142

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

2145

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

2143

2146

2144

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)

2145

2148

2146

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

2149

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

2147

2150

2148

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

2151

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

2149

2152

2150

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

2151

2154

2152

self.dataOut.ippSeconds = self.ippSeconds

2155

self.dataOut.ippSeconds = self.ippSeconds

2153

2156

2154

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

2155

2158

2156

# self.profileIndex += 1

2159

# self.profileIndex += 1

2157

2160

2158

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

2161

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

2159

2162

2160

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

2163

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

2161

2164

2162

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

2165

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

2163

2166

2164

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

2167

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

2165

2168

2166

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

2167

2170

2168

if self.processingHeaderObj.code != None:

2171

if self.processingHeaderObj.code != None:

2169

2172

2170

self.dataOut.nCode = self.processingHeaderObj.nCode

2173

self.dataOut.nCode = self.processingHeaderObj.nCode

2171

2174

2172

self.dataOut.nBaud = self.processingHeaderObj.nBaud

2175

self.dataOut.nBaud = self.processingHeaderObj.nBaud

2173

2176

2174

self.dataOut.code = self.processingHeaderObj.code

2177

self.dataOut.code = self.processingHeaderObj.code

2175

2178

2176

self.dataOut.flagDecodeData = True

2179

self.dataOut.flagDecodeData = True

2177

2180

2178

return self.dataOut.data_spc

2181

return self.dataOut.data_spc

2179

2182

2180

2183

2181

class SpectraWriter(JRODataWriter):

2184

class SpectraWriter(JRODataWriter):

2182

2185

2183

"""

2186

"""

2184

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

2185

de los datos siempre se realiza por bloques.

2188

de los datos siempre se realiza por bloques.

2186

"""

2189

"""

2187

2190

2188

ext = ".pdata"

2191

ext = ".pdata"

2189

2192

2190

optchar = "P"

2193

optchar = "P"

2191

2194

2192

shape_spc_Buffer = None

2195

shape_spc_Buffer = None

2193

2196

2194

shape_cspc_Buffer = None

2197

shape_cspc_Buffer = None

2195

2198

2196

shape_dc_Buffer = None

2199

shape_dc_Buffer = None

2197

2200

2198

data_spc = None

2201

data_spc = None

2199

2202

2200

data_cspc = None

2203

data_cspc = None

2201

2204

2202

data_dc = None

2205

data_dc = None

2203

2206

2204

# dataOut = None

2207

# dataOut = None

2205

2208

2206

def __init__(self):

2209

def __init__(self):

2207

"""

2210

"""

2208

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.

2209

2212

2210

Affected:

2213

Affected:

2211

self.dataOut

2214

self.dataOut

2212

self.basicHeaderObj

2215

self.basicHeaderObj

2213

self.systemHeaderObj

2216

self.systemHeaderObj

2214

self.radarControllerHeaderObj

2217

self.radarControllerHeaderObj

2215

self.processingHeaderObj

2218

self.processingHeaderObj

2216

2219

2217

Return: None

2220

Return: None

2218

"""

2221

"""

2219

2222

2220

self.isConfig = False

2223

self.isConfig = False

2221

2224

2222

self.nTotalBlocks = 0

2225

self.nTotalBlocks = 0

2223

2226

2224

self.data_spc = None

2227

self.data_spc = None

2225

2228

2226

self.data_cspc = None

2229

self.data_cspc = None

2227

2230

2228

self.data_dc = None

2231

self.data_dc = None

2229

2232

2230

self.fp = None

2233

self.fp = None

2231

2234

2232

self.flagIsNewFile = 1

2235

self.flagIsNewFile = 1

2233

2236

2234

self.nTotalBlocks = 0

2237

self.nTotalBlocks = 0

2235

2238

2236

self.flagIsNewBlock = 0

2239

self.flagIsNewBlock = 0

2237

2240

2238

self.setFile = None

2241

self.setFile = None

2239

2242

2240

self.dtype = None

2243

self.dtype = None

2241

2244

2242

self.path = None

2245

self.path = None

2243

2246

2244

self.noMoreFiles = 0

2247

self.noMoreFiles = 0

2245

2248

2246

self.filename = None

2249

self.filename = None

2247

2250

2248

self.basicHeaderObj = BasicHeader(LOCALTIME)

2251

self.basicHeaderObj = BasicHeader(LOCALTIME)

2249

2252

2250

self.systemHeaderObj = SystemHeader()

2253

self.systemHeaderObj = SystemHeader()

2251

2254

2252

self.radarControllerHeaderObj = RadarControllerHeader()

2255

self.radarControllerHeaderObj = RadarControllerHeader()

2253

2256

2254

self.processingHeaderObj = ProcessingHeader()

2257

self.processingHeaderObj = ProcessingHeader()

2255

2258

2256

2259

2257

def hasAllDataInBuffer(self):

2260

def hasAllDataInBuffer(self):

2258

return 1

2261

return 1

2259

2262

2260

2263

2261

def setBlockDimension(self):

2264

def setBlockDimension(self):

2262

"""

2265

"""

2263

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

2264

2267

2265

Affected:

2268

Affected:

2266

self.shape_spc_Buffer

2269

self.shape_spc_Buffer

2267

self.shape_cspc_Buffer

2270

self.shape_cspc_Buffer

2268

self.shape_dc_Buffer

2271

self.shape_dc_Buffer

2269

2272

2270

Return: None

2273

Return: None

2271

"""

2274

"""

2272

self.shape_spc_Buffer = (self.dataOut.nChannels,

2275

self.shape_spc_Buffer = (self.dataOut.nChannels,

2273

self.processingHeaderObj.nHeights,

2276

self.processingHeaderObj.nHeights,

2274

self.processingHeaderObj.profilesPerBlock)

2277

self.processingHeaderObj.profilesPerBlock)

2275

2278

2276

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2279

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2277

self.processingHeaderObj.nHeights,

2280

self.processingHeaderObj.nHeights,

2278

self.processingHeaderObj.profilesPerBlock)

2281

self.processingHeaderObj.profilesPerBlock)

2279

2282

2280

self.shape_dc_Buffer = (self.dataOut.nChannels,

2283

self.shape_dc_Buffer = (self.dataOut.nChannels,

2281

self.processingHeaderObj.nHeights)

2284

self.processingHeaderObj.nHeights)

2282

2285

2283

2286

2284

def writeBlock(self):

2287

def writeBlock(self):

2285

"""

2288

"""

2286

Escribe el buffer en el file designado

2289

Escribe el buffer en el file designado

2287

2290

2288

Affected:

2291

Affected:

2289

self.data_spc

2292

self.data_spc

2290

self.data_cspc

2293

self.data_cspc

2291

self.data_dc

2294

self.data_dc

2292

self.flagIsNewFile

2295

self.flagIsNewFile

2293

self.flagIsNewBlock

2296

self.flagIsNewBlock

2294

self.nTotalBlocks

2297

self.nTotalBlocks

2295

self.nWriteBlocks

2298

self.nWriteBlocks

2296

2299

2297

Return: None

2300

Return: None

2298

"""

2301

"""

2299

2302

2300

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

2303

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

2301

if not( self.processingHeaderObj.shif_fft ):

2304

if not( self.processingHeaderObj.shif_fft ):

2302

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

2303

data = spc.reshape((-1))

2306

data = spc.reshape((-1))

2304

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

2307

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

2305

data.tofile(self.fp)

2308

data.tofile(self.fp)

2306

2309

2307

if self.data_cspc != None:

2310

if self.data_cspc != None:

2308

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

2311

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

2309

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

2312

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

2310

if not( self.processingHeaderObj.shif_fft ):

2313

if not( self.processingHeaderObj.shif_fft ):

2311

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

2312

data['real'] = cspc.real

2315

data['real'] = cspc.real

2313

data['imag'] = cspc.imag

2316

data['imag'] = cspc.imag

2314

data = data.reshape((-1))

2317

data = data.reshape((-1))

2315

data.tofile(self.fp)

2318

data.tofile(self.fp)

2316

2319

2317

if self.data_dc != None:

2320

if self.data_dc != None:

2318

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

2321

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

2319

dc = self.data_dc

2322

dc = self.data_dc

2320

data['real'] = dc.real

2323

data['real'] = dc.real

2321

data['imag'] = dc.imag

2324

data['imag'] = dc.imag

2322

data = data.reshape((-1))

2325

data = data.reshape((-1))

2323

data.tofile(self.fp)

2326

data.tofile(self.fp)

2324

2327

2325

self.data_spc.fill(0)

2328

self.data_spc.fill(0)

2326

self.data_dc.fill(0)

2329

self.data_dc.fill(0)

2327

if self.data_cspc != None:

2330

if self.data_cspc != None:

2328

self.data_cspc.fill(0)

2331

self.data_cspc.fill(0)

2329

2332

2330

self.flagIsNewFile = 0

2333

self.flagIsNewFile = 0

2331

self.flagIsNewBlock = 1

2334

self.flagIsNewBlock = 1

2332

self.nTotalBlocks += 1

2335

self.nTotalBlocks += 1

2333

self.nWriteBlocks += 1

2336

self.nWriteBlocks += 1

2334

self.blockIndex += 1

2337

self.blockIndex += 1

2335

2338

2336

2339

2337

def putData(self):

2340

def putData(self):

2338

"""

2341

"""

2339

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

2340

2343

2341

Affected:

2344

Affected:

2342

self.data_spc

2345

self.data_spc

2343

self.data_cspc

2346

self.data_cspc

2344

self.data_dc

2347

self.data_dc

2345

2348

2346

Return:

2349

Return:

2347

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

2348

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

2349

"""

2352

"""

2350

2353

2351

if self.dataOut.flagNoData:

2354

if self.dataOut.flagNoData:

2352

return 0

2355

return 0

2353

2356

2354

self.flagIsNewBlock = 0

2357

self.flagIsNewBlock = 0

2355

2358

2356

if self.dataOut.flagTimeBlock:

2359

if self.dataOut.flagTimeBlock:

2357

self.data_spc.fill(0)

2360

self.data_spc.fill(0)

2358

self.data_cspc.fill(0)

2361

self.data_cspc.fill(0)

2359

self.data_dc.fill(0)

2362

self.data_dc.fill(0)

2360

self.setNextFile()

2363

self.setNextFile()

2361

2364

2362

if self.flagIsNewFile == 0:

2365

if self.flagIsNewFile == 0:

2363

self.getBasicHeader()

2366

self.getBasicHeader()

2364

2367

2365

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

2368

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

2366

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

2369

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

2367

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

2370

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

2368

2371

2369

# #self.processingHeaderObj.dataBlocksPerFile)

2372

# #self.processingHeaderObj.dataBlocksPerFile)

2370

if self.hasAllDataInBuffer():

2373

if self.hasAllDataInBuffer():

2371

# self.getDataHeader()

2374

# self.getDataHeader()

2372

self.writeNextBlock()

2375

self.writeNextBlock()

2373

2376

2374

return 1

2377

return 1

2375

2378

2376

2379

2377

def __getProcessFlags(self):

2380

def __getProcessFlags(self):

2378

2381

2379

processFlags = 0

2382

processFlags = 0

2380

2383

2381

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

2384

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

2382

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

2385

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

2383

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

2386

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

2384

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

2387

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

2385

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

2388

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

2386

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

2389

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

2387

2390

2388

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

2391

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

2389

2392

2390

2393

2391

2394

2392

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2395

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2393

PROCFLAG.DATATYPE_SHORT,

2396

PROCFLAG.DATATYPE_SHORT,

2394

PROCFLAG.DATATYPE_LONG,

2397

PROCFLAG.DATATYPE_LONG,

2395

PROCFLAG.DATATYPE_INT64,

2398

PROCFLAG.DATATYPE_INT64,

2396

PROCFLAG.DATATYPE_FLOAT,

2399

PROCFLAG.DATATYPE_FLOAT,

2397

PROCFLAG.DATATYPE_DOUBLE]

2400

PROCFLAG.DATATYPE_DOUBLE]

2398

2401

2399

2402

2400

for index in range(len(dtypeList)):

2403

for index in range(len(dtypeList)):

2401

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

2404

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

2402

dtypeValue = datatypeValueList[index]

2405

dtypeValue = datatypeValueList[index]

2403

break

2406

break

2404

2407

2405

processFlags += dtypeValue

2408

processFlags += dtypeValue

2406

2409

2407

if self.dataOut.flagDecodeData:

2410

if self.dataOut.flagDecodeData:

2408

processFlags += PROCFLAG.DECODE_DATA

2411

processFlags += PROCFLAG.DECODE_DATA

2409

2412

2410

if self.dataOut.flagDeflipData:

2413

if self.dataOut.flagDeflipData:

2411

processFlags += PROCFLAG.DEFLIP_DATA

2414

processFlags += PROCFLAG.DEFLIP_DATA

2412

2415

2413

if self.dataOut.code != None:

2416

if self.dataOut.code != None:

2414

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2417

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2415

2418

2416

if self.dataOut.nIncohInt > 1:

2419

if self.dataOut.nIncohInt > 1:

2417

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2420

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2418

2421

2419

if self.dataOut.data_dc != None:

2422

if self.dataOut.data_dc != None:

2420

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2423

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2421

2424

2422

return processFlags

2425

return processFlags

2423

2426

2424

2427

2425

def __getBlockSize(self):

2428

def __getBlockSize(self):

2426

'''

2429

'''

2427

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

2428

'''

2431

'''

2429

2432

2430

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

2433

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

2431

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

2434

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

2432

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

2435

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

2433

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

2436

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

2434

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

2437

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

2435

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

2438

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

2436

2439

2437

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

2440

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

2438

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

2441

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

2439

for index in range(len(dtypeList)):

2442

for index in range(len(dtypeList)):

2440

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

2443

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

2441

datatypeValue = datatypeValueList[index]

2444

datatypeValue = datatypeValueList[index]

2442

break

2445

break

2443

2446

2444

2447

2445

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

2448

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

2446

2449

2447

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

2450

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

2448

blocksize = (pts2write_SelfSpectra*datatypeValue)

2451

blocksize = (pts2write_SelfSpectra*datatypeValue)

2449

2452

2450

if self.dataOut.data_cspc != None:

2453

if self.dataOut.data_cspc != None:

2451

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

2454

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

2452

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2455

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2453

2456

2454

if self.dataOut.data_dc != None:

2457

if self.dataOut.data_dc != None:

2455

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

2458

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

2456

blocksize += (pts2write_DCchannels*datatypeValue*2)

2459

blocksize += (pts2write_DCchannels*datatypeValue*2)

2457

2460

2458

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2461

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2459

2462

2460

return blocksize

2463

return blocksize

2461

2464

2462

def getDataHeader(self):

2465

def getDataHeader(self):

2463

2466

2464

"""

2467

"""

2465

Obtiene una copia del First Header

2468

Obtiene una copia del First Header

2466

2469

2467

Affected:

2470

Affected:

2468

self.systemHeaderObj

2471

self.systemHeaderObj

2469

self.radarControllerHeaderObj

2472

self.radarControllerHeaderObj

2470

self.dtype

2473

self.dtype

2471

2474

2472

Return:

2475

Return:

2473

None

2476

None

2474

"""

2477

"""

2475

2478

2476

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

2479

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

2477

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2480

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2478

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

2481

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

2479

2482

2480

self.getBasicHeader()

2483

self.getBasicHeader()

2481

2484

2482

processingHeaderSize = 40 # bytes

2485

processingHeaderSize = 40 # bytes

2483

self.processingHeaderObj.dtype = 0 # Voltage

2486

self.processingHeaderObj.dtype = 0 # Voltage

2484

self.processingHeaderObj.blockSize = self.__getBlockSize()

2487

self.processingHeaderObj.blockSize = self.__getBlockSize()

2485

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2488

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2486

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2489

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2487

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

2488

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2491

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2489

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

2490

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2493

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2491

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

2494

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

2492

2495

2493

if self.processingHeaderObj.totalSpectra > 0:

2496

if self.processingHeaderObj.totalSpectra > 0:

2494

channelList = []

2497

channelList = []

2495

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

2498

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

2496

channelList.append(channel)

2499

channelList.append(channel)

2497

channelList.append(channel)

2500

channelList.append(channel)

2498

2501

2499

pairsList = []

2502

pairsList = []

2500

for pair in self.dataOut.pairsList:

2503

for pair in self.dataOut.pairsList:

2501

pairsList.append(pair[0])

2504

pairsList.append(pair[0])

2502

pairsList.append(pair[1])

2505

pairsList.append(pair[1])

2503

spectraComb = channelList + pairsList

2506

spectraComb = channelList + pairsList

2504

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

2507

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

2505

self.processingHeaderObj.spectraComb = spectraComb

2508

self.processingHeaderObj.spectraComb = spectraComb

2506

sizeOfSpcComb = len(spectraComb)

2509

sizeOfSpcComb = len(spectraComb)

2507

processingHeaderSize += sizeOfSpcComb

2510

processingHeaderSize += sizeOfSpcComb

2508

2511

2509

if self.dataOut.code != None:

2512

if self.dataOut.code != None:

2510

self.processingHeaderObj.code = self.dataOut.code

2513

self.processingHeaderObj.code = self.dataOut.code

2511

self.processingHeaderObj.nCode = self.dataOut.nCode

2514

self.processingHeaderObj.nCode = self.dataOut.nCode

2512

self.processingHeaderObj.nBaud = self.dataOut.nBaud

2515

self.processingHeaderObj.nBaud = self.dataOut.nBaud

2513

nCodeSize = 4 # bytes

2516

nCodeSize = 4 # bytes

2514

nBaudSize = 4 # bytes

2517

nBaudSize = 4 # bytes

2515

codeSize = 4 # bytes

2518

codeSize = 4 # bytes

2516

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

2519

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

2517

processingHeaderSize += sizeOfCode

2520

processingHeaderSize += sizeOfCode

2518

2521

2519

if self.processingHeaderObj.nWindows != 0:

2522

if self.processingHeaderObj.nWindows != 0:

2520

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

2523

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

2521

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

2524

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

2522

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2525

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2523

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2526

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2524

sizeOfFirstHeight = 4

2527

sizeOfFirstHeight = 4

2525

sizeOfdeltaHeight = 4

2528

sizeOfdeltaHeight = 4

2526

sizeOfnHeights = 4

2529

sizeOfnHeights = 4

2527

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

2530

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

2528

processingHeaderSize += sizeOfWindows

2531

processingHeaderSize += sizeOfWindows

2529

2532

2530

self.processingHeaderObj.size = processingHeaderSize

2533

self.processingHeaderObj.size = processingHeaderSize

2531

2534

2532

class SpectraHeisWriter():

2535

class SpectraHeisWriter():

2533

2536

2534

i=0

2537

i=0

2535

2538

2536

def __init__(self, dataOut):

2539

def __init__(self, dataOut):

2537

2540

2538

self.wrObj = FITS()

2541

self.wrObj = FITS()

2539

self.dataOut = dataOut

2542

self.dataOut = dataOut

2540

2543

2541

def isNumber(str):

2544

def isNumber(str):

2542

"""

2545

"""

2543

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

2546

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

2544

2547

2545

Excepciones:

2548

Excepciones:

2546

Si un determinado string no puede ser convertido a numero

2549

Si un determinado string no puede ser convertido a numero

2547

Input:

2550

Input:

2548

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

2551

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

2549

2552

2550

Return:

2553

Return:

2551

True : si el string es uno numerico

2554

True : si el string es uno numerico

2552

False : no es un string numerico

2555

False : no es un string numerico

2553

"""

2556

"""

2554

try:

2557

try:

2555

float( str )

2558

float( str )

2556

return True

2559

return True

2557

except:

2560

except:

2558

return False

2561

return False

2559

2562

2560

def setup(self, wrpath,):

2563

def setup(self, wrpath,):

2561

2564

2562

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

2565

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

2563

os.mkdir(wrpath)

2566

os.mkdir(wrpath)

2564

2567

2565

self.wrpath = wrpath

2568

self.wrpath = wrpath

2566

self.setFile = 0

2569

self.setFile = 0

2567

2570

2568

def putData(self):

2571

def putData(self):

2569

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

2572

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

2570

#name = self.dataOut.utctime

2573

#name = self.dataOut.utctime

2571

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

2574

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

2572

ext=".fits"

2575

ext=".fits"

2573

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

2576

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

2574

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

2577

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

2575

2578

2576

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

2579

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

2577

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

2580

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

2578

os.mkdir(fullpath)

2581

os.mkdir(fullpath)

2579

self.setFile += 1

2582

self.setFile += 1

2580

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

2583

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

2581

2584

2582

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

2585

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

2583

2586

2584

# print self.dataOut.ippSeconds

2587

# print self.dataOut.ippSeconds

2585

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

2588

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

2586

2589

2587

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

2590

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

2588

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

2591

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

2589

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

2592

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

2590

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

2593

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

2591

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

2594

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

2592

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

2595

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

2593

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

2596

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

2594

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

2597

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

2595

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

2598

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

2596

#n=numpy.arange((100))

2599

#n=numpy.arange((100))

2597

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

2600

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

2598

a=self.wrObj.cFImage(n)

2601

a=self.wrObj.cFImage(n)

2599

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

2602

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

2600

self.wrObj.CFile(a,b)

2603

self.wrObj.CFile(a,b)

2601

self.wrObj.wFile(filename)

2604

self.wrObj.wFile(filename)

2602

return 1

2605

return 1

2603

2606

2604

class FITS:

2607

class FITS:

2605

2608

2606

name=None

2609

name=None

2607

format=None

2610

format=None

2608

array =None

2611

array =None

2609

data =None

2612

data =None

2610

thdulist=None

2613

thdulist=None

2611

2614

2612

def __init__(self):

2615

def __init__(self):

2613

2616

2614

pass

2617

pass

2615

2618

2616

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

2619

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

2617

self.name=name

2620

self.name=name

2618

self.format=format

2621

self.format=format

2619

self.array=array

2622

self.array=array

2620

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

2623

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

2621

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

2624

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

2622

return self.col1

2625

return self.col1

2623

2626

2624

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

2627

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

2625

# self.name=name

2628

# self.name=name

2626

# self.format=format

2629

# self.format=format

2627

# self.data=data

2630

# self.data=data

2628

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

2631

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

2629

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

2632

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

2630

# return self.col2

2633

# return self.col2

2631

2634

2632

def writeHeader(self,):

2635

def writeHeader(self,):

2633

pass

2636

pass

2634

2637

2635

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

2638

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

2636

self.name=name

2639

self.name=name

2637

self.format=format

2640

self.format=format

2638

self.data=data

2641

self.data=data

2639

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

2642

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

2640

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

2643

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

2641

return self.col2

2644

return self.col2

2642

2645

2643

def cFImage(self,n):

2646

def cFImage(self,n):

2644

self.hdu= pyfits.PrimaryHDU(n)

2647

self.hdu= pyfits.PrimaryHDU(n)

2645

return self.hdu

2648

return self.hdu

2646

2649

2647

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

2650

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

2648

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

2651

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

2649

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

2652

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

2650

return self.tbhdu

2653

return self.tbhdu

2651

2654

2652

def CFile(self,hdu,tbhdu):

2655

def CFile(self,hdu,tbhdu):

2653

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

2656

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

2654

2657

2655

def wFile(self,filename):

2658

def wFile(self,filename):

2656

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

2659

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:
                         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)
                         nBaud = numpy.array([self.nBaud], numpy.dtype('u4'))
                         nBaud.tofile(fp)
                         code = self.code.reshape(self.nCode*self.nBaud)
                         code = code.astype(numpy.dtype('<f4'))
                         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)