schain Commit - r480:e41d165c9f5f · 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
             import h5py
             import re
             from xml.etree.ElementTree import Element, SubElement, ElementTree
             try:
                 import pyfits
             except:
                 print "pyfits module has not been imported, it should be installed to save files in fits format"
             from jrodata import *
             from jroheaderIO import *
             from jroprocessing import *
             LOCALTIME = True #-18000
             def isNumber(str):
                 """
                 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
                 Excepciones:
                     Si un determinado string no puede ser convertido a numero
                 Input:
                     str, string al cual se le analiza para determinar si convertible a un numero o no
                 Return:
                     True    :    si el string es uno numerico
                     False   :    no es un string numerico
                 """
                 try:
                     float( str )
                     return True
                 except:
                     return False
             def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
                 """
                 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                     startUTSeconds      :    fecha inicial del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                     endUTSeconds        :    fecha final del rango seleccionado. La fecha esta dada en
                                              segundos contados desde 01/01/1970.
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no existe o no puede ser abierto
                     Si la cabecera no puede ser leida.
                 """
                 basicHeaderObj = BasicHeader(LOCALTIME)
                 try:
                     fp = open(filename,'rb')
                 except:
                     raise IOError, "The file %s can't be opened" %(filename)
                 sts = basicHeaderObj.read(fp)
                 fp.close()
                 if not(sts):
                     print "Skipping the file %s because it has not a valid header" %(filename)
                     return 0
                 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
                     return 0
                 return 1
             def isFileinThisTime(filename, startTime, endTime):
                 """
                 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
                 Inputs:
                     filename            :    nombre completo del archivo de datos en formato Jicamarca (.r)
                     startTime          :    tiempo inicial del rango seleccionado en formato datetime.time
                     endTime            :    tiempo final del rango seleccionado en formato datetime.time
                 Return:
                     Boolean    :    Retorna True si el archivo de datos contiene datos en el rango de
                                     fecha especificado, de lo contrario retorna False.
                 Excepciones:
                     Si el archivo no existe o no puede ser abierto
                     Si la cabecera no puede ser leida.
                 """
                 try:
                     fp = open(filename,'rb')
                 except:
                     raise IOError, "The file %s can't be opened" %(filename)
                 basicHeaderObj = BasicHeader(LOCALTIME)
                 sts = basicHeaderObj.read(fp)
                 fp.close()
                 thisDatetime = basicHeaderObj.datatime
                 thisTime = basicHeaderObj.datatime.time()
                 if not(sts):
                     print "Skipping the file %s because it has not a valid header" %(filename)
                     return None
                 if not ((startTime <= thisTime) and (endTime > thisTime)):
                     return None
                 return thisDatetime
             def getFileFromSet(path,ext,set):
                 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)
                 myfile = fnmatch.filter(validFilelist,'*%4.4d%3.3d%3.3d*'%(year,doy,set))
                 if len(myfile)!= 0:
                     return myfile[0]
                 else:
                     filename = '*%4.4d%3.3d%3.3d%s'%(year,doy,set,ext.lower())
                     print 'the filename %s does not exist'%filename
                     print '...going to the last file: '
                 if validFilelist:
                     validFilelist = sorted( validFilelist, key=str.lower )
                     return validFilelist[-1]
                 return None
             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, foldercounter, 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)
                         if foldercounter == 0:
                             thispath = os.path.join(path, "%s%04d%03d" % ( prefixDir, year, doy ))
                         else:
                             thispath = os.path.join(path, "%s%04d%03d_%02d" % ( prefixDir, year, doy , foldercounter))
                     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
                 path = None
                 foldercounter = 0
                 flagNoMoreFiles = 0
                 datetimeList = []
                 __isFirstTimeOnline = 1
                 __printInfo = True
                 profileIndex = None
                 def __init__(self):
                     """
                     """
                     raise ValueError, "This method has not been implemented"
                 def createObjByDefault(self):
                     """
                     """
                     raise ValueError, "This method has not been implemented"
                 def getBlockDimension(self):
                     raise ValueError, "No implemented"
                 def __searchFilesOffLine(self,
                                         path,
                                         startDate,
                                         endDate,
                                         startTime=datetime.time(0,0,0),
                                         endTime=datetime.time(23,59,59),
                                         set=None,
                                         expLabel='',
                                         ext='.r',
                                         walk=True):
                     pathList = []
                     if not walk:
                         #pathList.append(path)
                         multi_path = path.split(',')
                         for single_path in multi_path:
                             pathList.append(single_path)
                     else:
                         #dirList = []
                         multi_path = path.split(',')
                         for single_path in multi_path:
                             dirList = []
                             for thisPath in os.listdir(single_path):
                                 if not os.path.isdir(os.path.join(single_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
                                 matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy) + '*')
                                 if len(matchlist) == 0:
                                     thisDate += datetime.timedelta(1)
                                     continue
                                 for match in matchlist:
                                     pathList.append(os.path.join(single_path,match,expLabel))
                                 thisDate += datetime.timedelta(1)
                     if pathList == []:
                         print "Any folder was found for the date range: %s-%s" %(startDate, endDate)
                         return None, None
                     print "%d folder(s) was(were) found for the date range: %s - %s" %(len(pathList), startDate, endDate)
                     filenameList = []
                     datetimeList = []
                     pathDict = {}
                     filenameList_to_sort = []
                     for i in range(len(pathList)):
                         thisPath = pathList[i]
                         fileList = glob.glob1(thisPath, "*%s" %ext)
                         fileList.sort()
                         pathDict.setdefault(fileList[0])
                         pathDict[fileList[0]] = i
                         filenameList_to_sort.append(fileList[0])
                     filenameList_to_sort.sort()
                     for file in filenameList_to_sort:
                         thisPath = pathList[pathDict[file]]
                         fileList = glob.glob1(thisPath, "*%s" %ext)
                         fileList.sort()
                         for file in fileList:
                             filename = os.path.join(thisPath,file)
                             thisDatetime = isFileinThisTime(filename, startTime, endTime)
                             if not(thisDatetime):
                                 continue
                             filenameList.append(filename)
                             datetimeList.append(thisDatetime)
                     if not(filenameList):
                         print "Any file was found for the time range %s - %s" %(startTime, endTime)
                         return None, None
                     print "%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime)
                     print
                     for i in range(len(filenameList)):
                         print "%s -> [%s]" %(filenameList[i], datetimeList[i].ctime())
                     self.filenameList = filenameList
                     self.datetimeList = datetimeList
                     return pathList, filenameList
                 def __searchFilesOnLine(self, path, expLabel = "", ext = None, walk=True, set=None):
                     """
                     Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
                     devuelve el archivo encontrado ademas de otros datos.
                     Input:
                         path           :    carpeta donde estan contenidos los files que contiene data
                         expLabel        :     Nombre del subexperimento (subfolder)
                         ext              :    extension de los files
                         walk        :    Si es habilitado no realiza busquedas dentro de los ubdirectorios (doypath)
                     Return:
                         directory   :    eL directorio donde esta el file encontrado
                         filename    :    el ultimo file de una determinada carpeta
                         year        :    el anho
                         doy         :    el numero de dia del anho
                         set         :    el set del archivo
                     """
                     dirList = []
                     if not walk:
                         fullpath = path
                         foldercounter = 0
                     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, None
                         dirList = sorted( dirList, key=str.lower )
                         doypath = dirList[-1]
                         foldercounter = int(doypath.split('_')[1]) if len(doypath.split('_'))>1 else 0
                         fullpath = os.path.join(path, doypath, expLabel)
                     print "%s folder was found: " %(fullpath )
                     if set == None:
                         filename = getlastFileFromPath(fullpath, ext)
                     else:
                         filename = getFileFromSet(fullpath, ext, set)
                     if not(filename):
                         return None, 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, None
                     year = int( filename[1:5] )
                     doy  = int( filename[5:8] )
                     set  = int( filename[8:11] )
                     return fullpath, foldercounter, 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
                     if self.set > 999:
                         self.set = 0
                         self.foldercounter += 1
                     #busca el 1er file disponible
                     fullfilename, filename = checkForRealPath( self.path, self.foldercounter, 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.foldercounter, 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
                                 self.foldercounter = 0
                     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
                         if self.fileSize == self.fileSizeByHeader:
             #                self.flagEoF = True
                             return 0
                         print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
                         time.sleep( self.delay )
                     return 0
                 def waitDataBlock(self,pointer_location):
                     currentPointer = pointer_location
                     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 ):
                             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()
                     blocksize = self.processingHeaderObj.blockSize
                     #salta el primer bloque de datos
                     if csize > self.processingHeaderObj.blockSize:
                         self.fp.seek(self.fp.tell() + blocksize)
                     else:
                         return
                     csize = self.fileSize - self.fp.tell()
                     neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     while True:
                         if self.fp.tell()<self.fileSize:
                             self.fp.seek(self.fp.tell() + neededsize)
                         else:
                             self.fp.seek(self.fp.tell() - neededsize)
                             break
             #        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=None,
                             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, foldercounter, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext, walk=walk, set=set)
                             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
                         self.foldercounter = foldercounter
                         last_set = None
                     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
                         file_name = os.path.basename(filenameList[-1])
                         basename, ext = os.path.splitext(file_name)
                         last_set = int(basename[-3:])
                     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()
                     if last_set != None:
                         self.dataOut.last_block = last_set * self.processingHeaderObj.dataBlocksPerFile + self.basicHeaderObj.dataBlock
                     return self.dataOut
                 def getBasicHeader(self):
                     self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.ippSeconds
                     self.dataOut.flagTimeBlock = self.flagTimeBlock
                     self.dataOut.timeZone = self.basicHeaderObj.timeZone
                     self.dataOut.dstFlag = self.basicHeaderObj.dstFlag
                     self.dataOut.errorCount = self.basicHeaderObj.errorCount
                     self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
                 def getFirstHeader(self):
                     raise ValueError, "This method has not been implemented"
                 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())
                         self.dataOut.blocknow = self.basicHeaderObj.dataBlock
                 def printInfo(self):
                     if self.__printInfo == False:
                         return
                     self.basicHeaderObj.printInfo()
                     self.systemHeaderObj.printInfo()
                     self.radarControllerHeaderObj.printInfo()
                     self.processingHeaderObj.printInfo()
                     self.__printInfo = False
                 def run(self, **kwargs):
                     if not(self.isConfig):
             #            self.dataOut = dataOut
                         self.setup(**kwargs)
                         self.isConfig = True
                     self.getData()
             class JRODataWriter(JRODataIO, Operation):
                 """
                 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
                 de los datos siempre se realiza por bloques.
                 """
                 blockIndex = 0
                 path = None
                 setFile = None
                 profilesPerBlock = None
                 blocksPerFile = None
                 nWriteBlocks = 0
                 def __init__(self, dataOut=None):
                     raise ValueError, "Not implemented"
                 def hasAllDataInBuffer(self):
                     raise ValueError, "Not implemented"
                 def setBlockDimension(self):
                     raise ValueError, "Not implemented"
                 def writeBlock(self):
                     raise ValueError, "No implemented"
                 def putData(self):
                     raise ValueError, "No implemented"
                 def setBasicHeader(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 = self.dataOut.timeZone
                     self.basicHeaderObj.dstFlag = self.dataOut.dstFlag
                     self.basicHeaderObj.errorCount = self.dataOut.errorCount
                 def setFirstHeader(self):
                     """
                     Obtiene una copia del First Header
                     Affected:
                         self.basicHeaderObj
                         self.systemHeaderObj
                         self.radarControllerHeaderObj
                         self.processingHeaderObj self.
                     Return:
                         None
                     """
                     raise ValueError, "No implemented"
                 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.setFirstHeader()
                     print 'Writing the file: %s'%self.filename
                     self.__writeFirstHeader()
                     return 1
                 def setup(self, dataOut, path, blocksPerFile, profilesPerBlock=64, 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
                     """
                     current_pointer_location = self.fp.tell()
                     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
                         if self.waitDataBlock(pointer_location=current_pointer_location):
                             junk = numpy.fromfile( self.fp, self.dtype, self.blocksize )
                             junk = junk.reshape( (self.processingHeaderObj.profilesPerBlock, self.processingHeaderObj.nHeights, self.systemHeaderObj.nChannels) )
             #             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 getFirstHeader(self):
                     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.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
                 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.getFirstHeader()
                     if self.datablock == None:
                         self.dataOut.flagNoData = True
                         return 0
                     self.dataOut.data = self.datablock[:,self.profileIndex,:]
                     self.dataOut.flagNoData = False
                     self.getBasicHeader()
                     self.profileIndex += 1
                     self.dataOut.realtime = self.online
                     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.setBasicHeader()
                     self.datablock[:,self.profileIndex,:] = self.dataOut.data
                     self.profileIndex += 1
                     if self.hasAllDataInBuffer():
                         #if self.flagIsNewFile:
                         self.writeNextBlock()
             #            self.setFirstHeader()
                     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.profilesPerBlock * datatypeValue * 2)
                     return blocksize
                 def setFirstHeader(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.setBasicHeader()
                     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()
                     self.profileIndex = 1 #Always
                 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 getFirstHeader(self):
                     self.dataOut.dtype = self.dtype
                     self.dataOut.nPairs = self.nRdPairs
                     self.dataOut.pairsList = self.rdPairList
                     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.ippSeconds = self.ippSeconds
                     self.dataOut.timeInterval = self.ippSeconds * self.processingHeaderObj.nCohInt * self.processingHeaderObj.nIncohInt * self.dataOut.nFFTPoints
                     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.radarControllerHeaderObj.code != None:
                         self.dataOut.nCode = self.radarControllerHeaderObj.nCode
                         self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud
                         self.dataOut.code = self.radarControllerHeaderObj.code
                         self.dataOut.flagDecodeData = True
                 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
                     #data es un numpy array de 3 dmensiones (perfiles, alturas y canales)
                     if self.data_dc == None:
                         self.dataOut.flagNoData = True
                         return 0
                     self.getBasicHeader()
                     self.getFirstHeader()
                     self.dataOut.data_spc = self.data_spc
                     self.dataOut.data_cspc = self.data_cspc
                     self.dataOut.data_dc = self.data_dc
                     self.dataOut.flagNoData = False
                     self.dataOut.realtime = self.online
                     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)
                     if self.data_dc != None:
                         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.setBasicHeader()
                     self.data_spc = self.dataOut.data_spc.copy()
                     if self.dataOut.data_cspc != None:
                         self.data_cspc = self.dataOut.data_cspc.copy()
                     self.data_dc = self.dataOut.data_dc.copy()
                     # #self.processingHeaderObj.dataBlocksPerFile)
                     if self.hasAllDataInBuffer():
             #            self.setFirstHeader()
                         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 setFirstHeader(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()
                     old_code_size = self.dataOut.radarControllerHeaderObj.code_size
                     new_code_size = int(numpy.ceil(self.dataOut.nBaud/32.))*self.dataOut.nCode*4
                     self.radarControllerHeaderObj.size = self.radarControllerHeaderObj.size - old_code_size + new_code_size
                     self.setBasicHeader()
                     processingHeaderSize = 40 # bytes
                     self.processingHeaderObj.dtype = 1 # Spectra
                     self.processingHeaderObj.blockSize = self.__getBlockSize()
                     self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints
                     self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile
                     self.processingHeaderObj.nWindows = 1 #podria ser 1 o self.dataOut.processingHeaderObj.nWindows
                     self.processingHeaderObj.processFlags = self.__getProcessFlags()
                     self.processingHeaderObj.nCohInt = self.dataOut.nCohInt# Se requiere para determinar el valor de timeInterval
                     self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt
                     self.processingHeaderObj.totalSpectra = self.dataOut.nPairs + self.dataOut.nChannels
                     self.processingHeaderObj.shif_fft = self.dataOut.flagShiftFFT
                     if self.processingHeaderObj.totalSpectra > 0:
                         channelList = []
                         for channel in range(self.dataOut.nChannels):
                             channelList.append(channel)
                             channelList.append(channel)
                         pairsList = []
                         if self.dataOut.nPairs > 0:
                             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
             #        The processing header should not have information about code
             #        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(Operation):
             #    set = None
                 setFile = None
                 idblock = None
                 doypath = None
                 subfolder = None
                 def __init__(self):
                     self.wrObj = FITS()
             #        self.dataOut = dataOut
                     self.nTotalBlocks=0
             #        self.set = None
                     self.setFile = None
                     self.idblock = 0
                     self.wrpath = None
                     self.doypath = None
                     self.subfolder = None
                     self.isConfig = False
                 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, dataOut, wrpath):
                     if not(os.path.exists(wrpath)):
                         os.mkdir(wrpath)
                     self.wrpath = wrpath
             #        self.setFile = 0
                     self.dataOut = dataOut
                 def putData(self):
                     name= time.localtime( self.dataOut.utctime)
                     ext=".fits"
                     if self.doypath == None:
                        self.subfolder = 'F%4.4d%3.3d_%d' % (name.tm_year,name.tm_yday,time.mktime(datetime.datetime.now().timetuple()))
                        self.doypath = os.path.join( self.wrpath, self.subfolder )
                        os.mkdir(self.doypath)
                     if self.setFile == None:
             #           self.set = self.dataOut.set
                        self.setFile = 0
             #        if self.set != self.dataOut.set:
             ##            self.set = self.dataOut.set
             #            self.setFile = 0
                     #make the filename
                     file = 'D%4.4d%3.3d_%3.3d%s' % (name.tm_year,name.tm_yday,self.setFile,ext)
                     filename = os.path.join(self.wrpath,self.subfolder, file)
                     idblock = numpy.array([self.idblock],dtype="int64")
                     header=self.wrObj.cFImage(idblock=idblock,
                                             year=time.gmtime(self.dataOut.utctime).tm_year,
                                             month=time.gmtime(self.dataOut.utctime).tm_mon,
                                             day=time.gmtime(self.dataOut.utctime).tm_mday,
                                             hour=time.gmtime(self.dataOut.utctime).tm_hour,
                                             minute=time.gmtime(self.dataOut.utctime).tm_min,
                                             second=time.gmtime(self.dataOut.utctime).tm_sec)
                     c=3E8
                     deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
                     freq=numpy.arange(-1*self.dataOut.nHeights/2.,self.dataOut.nHeights/2.)*(c/(2*deltaHeight*1000))
                     colList = []
                     colFreq=self.wrObj.setColF(name="freq", format=str(self.dataOut.nFFTPoints)+'E', array=freq)
                     colList.append(colFreq)
                     nchannel=self.dataOut.nChannels
                     for i in range(nchannel):
                         col = self.wrObj.writeData(name="PCh"+str(i+1),
                                                      format=str(self.dataOut.nFFTPoints)+'E',
                                                       data=10*numpy.log10(self.dataOut.data_spc[i,:]))
                         colList.append(col)
                     data=self.wrObj.Ctable(colList=colList)
                     self.wrObj.CFile(header,data)
                     self.wrObj.wFile(filename)
                     #update the setFile
                     self.setFile += 1
                     self.idblock += 1
                     return 1
                 def run(self, dataOut, **kwargs):
                     if not(self.isConfig):
                         self.setup(dataOut, **kwargs)
                         self.isConfig = True
                     self.putData()
             class ParameterConf:
                 ELEMENTNAME = 'Parameter'
                 def __init__(self):
                     self.name = ''
                     self.value = ''
                 def readXml(self, parmElement):
                     self.name = parmElement.get('name')
                     self.value = parmElement.get('value')
                 def getElementName(self):
                     return self.ELEMENTNAME
             class Metadata:
                 def __init__(self, filename):
                     self.parmConfObjList = []
                     self.readXml(filename)
                 def readXml(self, filename):
                     self.projectElement = None
                     self.procUnitConfObjDict = {}
                     self.projectElement = ElementTree().parse(filename)
                     self.project = self.projectElement.tag
                     parmElementList = self.projectElement.getiterator(ParameterConf().getElementName())
                     for parmElement in parmElementList:
                         parmConfObj = ParameterConf()
                         parmConfObj.readXml(parmElement)
                         self.parmConfObjList.append(parmConfObj)
             class FitsWriter(Operation):
                 def __init__(self):
                     self.isConfig = False
                     self.dataBlocksPerFile = None
                     self.blockIndex = 0
                     self.flagIsNewFile = 1
                     self.fitsObj = None
                     self.optchar = 'P'
                     self.ext = '.fits'
                     self.setFile = 0
                 def setFitsHeader(self, dataOut, metadatafile):
                     header_data = pyfits.PrimaryHDU()
                     metadata4fits = Metadata(metadatafile)
                     for parameter in metadata4fits.parmConfObjList:
                         parm_name = parameter.name
                         parm_value = parameter.value
             #             if parm_value == 'fromdatadatetime':
             #                 value = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())
             #             elif parm_value == 'fromdataheights':
             #                 value = dataOut.nHeights
             #             elif parm_value == 'fromdatachannel':
             #                 value = dataOut.nChannels
             #             elif parm_value == 'fromdatasamples':
             #                 value = dataOut.nFFTPoints
             #             else:
             #                 value = parm_value
                         header_data.header[parm_name] = parm_value
                     header_data.header['DATETIME'] = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())
                     header_data.header['CHANNELLIST'] = str(dataOut.channelList)
                     header_data.header['NCHANNELS'] = dataOut.nChannels
                     #header_data.header['HEIGHTS'] = dataOut.heightList
                     header_data.header['NHEIGHTS'] = dataOut.nHeights
                     header_data.header['IPPSECONDS'] = dataOut.ippSeconds
                     header_data.header['NCOHINT'] = dataOut.nCohInt
                     header_data.header['NINCOHINT'] = dataOut.nIncohInt
                     header_data.header['TIMEZONE'] = dataOut.timeZone
                     header_data.header['NBLOCK'] = self.blockIndex
                     header_data.writeto(self.filename)
                     self.addExtension(dataOut.heightList,'HEIGHTLIST')
                 def setup(self, dataOut, path, dataBlocksPerFile, metadatafile):
                     self.path = path
                     self.dataOut = dataOut
                     self.metadatafile = metadatafile
                     self.dataBlocksPerFile = dataBlocksPerFile
                 def open(self):
                     self.fitsObj = pyfits.open(self.filename, mode='update')
                 def addExtension(self, data, tagname):
                     self.open()
                     extension = pyfits.ImageHDU(data=data, name=tagname)
                     #extension.header['TAG'] = tagname
                     self.fitsObj.append(extension)
                     self.write()
                 def addData(self, data):
                     self.open()
                     extension = pyfits.ImageHDU(data=data, name=self.fitsObj[0].header['DATATYPE'])
                     extension.header['UTCTIME'] = self.dataOut.utctime
                     self.fitsObj.append(extension)
                     self.blockIndex += 1
                     self.fitsObj[0].header['NBLOCK'] = self.blockIndex
                     self.write()
                 def write(self):
                     self.fitsObj.flush(verbose=True)
                     self.fitsObj.close()
                 def setNextFile(self):
                     ext = self.ext
                     path = self.path
                     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]
                             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 )
                     self.blockIndex = 0
                     self.filename = filename
                     self.setFile = setFile
                     self.flagIsNewFile = 1
                     print 'Writing the file: %s'%self.filename
                     self.setFitsHeader(self.dataOut, self.metadatafile)
                     return 1
                 def writeBlock(self):
                     self.addData(self.dataOut.data_spc)
                     self.flagIsNewFile = 0
                 def __setNewBlock(self):
                     if self.flagIsNewFile:
                         return 1
                     if self.blockIndex < self.dataBlocksPerFile:
                         return 1
                     if not( self.setNextFile() ):
                         return 0
                     return 1
                 def writeNextBlock(self):
                     if not( self.__setNewBlock() ):
                         return 0
                     self.writeBlock()
                     return 1
                 def putData(self):
                     if self.flagIsNewFile:
                         self.setNextFile()
                     self.writeNextBlock()
                 def run(self, dataOut, **kwargs):
                     if not(self.isConfig):
                         self.setup(dataOut, **kwargs)
                         self.isConfig = True
                     self.putData()
             class FitsReader(ProcessingUnit):
             #     __TIMEZONE = time.timezone
                 expName = None
                 datetimestr = None
                 utc = None
                 nChannels = None
                 nSamples = None
                 dataBlocksPerFile = None
                 comments = None
                 lastUTTime = None
                 header_dict = None
                 data = None
                 data_header_dict = None
                 def __init__(self):
                     self.isConfig = False
                     self.ext = '.fits'
                     self.setFile = 0
                     self.flagNoMoreFiles = 0
                     self.flagIsNewFile = 1
                     self.flagTimeBlock = None
                     self.fileIndex = None
                     self.filename = None
                     self.fileSize = None
                     self.fitsObj = None
                     self.timeZone = None
                     self.nReadBlocks = 0
                     self.nTotalBlocks = 0
                     self.dataOut = self.createObjByDefault()
                     self.maxTimeStep = 10# deberia ser definido por el usuario usando el metodo setup()
                     self.blockIndex = 1
                 def createObjByDefault(self):
                     dataObj = Fits()
                     return dataObj
                 def isFileinThisTime(self, filename, startTime, endTime, useLocalTime=False):
                     try:
                         fitsObj = pyfits.open(filename,'readonly')
                     except:
                         raise IOError, "The file %s can't be opened" %(filename)
                     header = fitsObj[0].header
                     struct_time = time.strptime(header['DATETIME'], "%b %d %Y %H:%M:%S")
                     utc = time.mktime(struct_time) - time.timezone #TIMEZONE debe ser un parametro del header FITS
                     ltc = utc
                     if useLocalTime:
                         ltc -= time.timezone
                     thisDatetime = datetime.datetime.utcfromtimestamp(ltc)
                     thisTime = thisDatetime.time()
                     if not ((startTime <= thisTime) and (endTime > thisTime)):
                         return None
                     return thisDatetime
                 def __setNextFileOnline(self):
                     raise ValueError, "No implemented"
                 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)
                         fitsObj = pyfits.open(filename,'readonly')
                         break
                     self.flagIsNewFile = 1
                     self.fileIndex = idFile
                     self.filename = filename
                     self.fileSize = fileSize
                     self.fitsObj = fitsObj
                     self.blockIndex = 0
                     print "Setting the file: %s"%self.filename
                     return 1
                 def readHeader(self):
                     headerObj = self.fitsObj[0]
                     self.header_dict = headerObj.header
                     if 'EXPNAME' in headerObj.header.keys():
                         self.expName = headerObj.header['EXPNAME']
                     if 'DATATYPE' in headerObj.header.keys():
                         self.dataType = headerObj.header['DATATYPE']
                     self.datetimestr = headerObj.header['DATETIME']
                     channelList = headerObj.header['CHANNELLIST']
                     channelList = channelList.split('[')
                     channelList = channelList[1].split(']')
                     channelList = channelList[0].split(',')
                     channelList = [int(ch) for ch in channelList]
                     self.channelList = channelList
                     self.nChannels = headerObj.header['NCHANNELS']
                     self.nHeights = headerObj.header['NHEIGHTS']
                     self.ippSeconds = headerObj.header['IPPSECONDS']
                     self.nCohInt = headerObj.header['NCOHINT']
                     self.nIncohInt = headerObj.header['NINCOHINT']
                     self.dataBlocksPerFile = headerObj.header['NBLOCK']
                     self.timeZone = headerObj.header['TIMEZONE']
                     self.timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
                     if 'COMMENT' in headerObj.header.keys():
                         self.comments = headerObj.header['COMMENT']
                     self.readHeightList()
                 def readHeightList(self):
                     self.blockIndex = self.blockIndex + 1
                     obj = self.fitsObj[self.blockIndex]
                     self.heightList = obj.data
                     self.blockIndex = self.blockIndex + 1
                 def readExtension(self):
                     obj = self.fitsObj[self.blockIndex]
                     self.heightList = obj.data
                     self.blockIndex = self.blockIndex + 1
                 def setNextFile(self):
                     if self.online:
                         newFile = self.__setNextFileOnline()
                     else:
                         newFile = self.__setNextFileOffline()
                     if not(newFile):
                         return 0
                     self.readHeader()
                     self.nReadBlocks = 0
             #         self.blockIndex = 1
                     return 1
                 def __searchFilesOffLine(self,
                                         path,
                                         startDate,
                                         endDate,
                                         startTime=datetime.time(0,0,0),
                                         endTime=datetime.time(23,59,59),
                                         set=None,
                                         expLabel='',
                                         ext='.fits',
                                         walk=True):
                     pathList = []
                     if not walk:
                         pathList.append(path)
                     else:
                         dirList = []
                         for thisPath in os.listdir(path):
                             if not os.path.isdir(os.path.join(path,thisPath)):
                                 continue
                             if not isDoyFolder(thisPath):
                                 continue
                             dirList.append(thisPath)
                         if not(dirList):
                             return None, None
                         thisDate = startDate
                         while(thisDate <= endDate):
                             year = thisDate.timetuple().tm_year
                             doy = thisDate.timetuple().tm_yday
                             matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy) + '*')
                             if len(matchlist) == 0:
                                 thisDate += datetime.timedelta(1)
                                 continue
                             for match in matchlist:
                                 pathList.append(os.path.join(path,match,expLabel))
                             thisDate += datetime.timedelta(1)
                     if pathList == []:
                         print "Any folder was found for the date range: %s-%s" %(startDate, endDate)
                         return None, None
                     print "%d folder(s) was(were) found for the date range: %s - %s" %(len(pathList), startDate, endDate)
                     filenameList = []
                     datetimeList = []
                     for i in range(len(pathList)):
                         thisPath = pathList[i]
                         fileList = glob.glob1(thisPath, "*%s" %ext)
                         fileList.sort()
                         for file in fileList:
                             filename = os.path.join(thisPath,file)
                             thisDatetime = self.isFileinThisTime(filename, startTime, endTime)
                             if not(thisDatetime):
                                 continue
                             filenameList.append(filename)
                             datetimeList.append(thisDatetime)
                     if not(filenameList):
                         print "Any file was found for the time range %s - %s" %(startTime, endTime)
                         return None, None
                     print "%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime)
                     print
                     for i in range(len(filenameList)):
                         print "%s -> [%s]" %(filenameList[i], datetimeList[i].ctime())
                     self.filenameList = filenameList
                     self.datetimeList = datetimeList
                     return pathList, filenameList
                 def 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 not(online):
                         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)
                 def readBlock(self):
                     dataObj = self.fitsObj[self.blockIndex]
                     self.data = dataObj.data
                     self.data_header_dict = dataObj.header
                     self.utc = self.data_header_dict['UTCTIME']
                     self.flagIsNewFile = 0
                     self.blockIndex += 1
                     self.nTotalBlocks += 1
                     self.nReadBlocks += 1
                     return 1
                 def __jumpToLastBlock(self):
                     raise ValueError, "No implemented"
                 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.dataBlocksPerFile):
                         return 0
                     currentPointer = self.fp.tell()
                     neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
                     for nTries in range( self.nTries ):
                         self.fp.close()
                         self.fp = open( self.filename, 'rb' )
                         self.fp.seek( currentPointer )
                         self.fileSize = os.path.getsize( self.filename )
                         currentSize = self.fileSize - currentPointer
                         if ( currentSize >= neededSize ):
                             self.__rdBasicHeader()
                             return 1
                         print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
                         time.sleep( self.delay )
                     return 0
                 def __setNewBlock(self):
                     if self.online:
                         self.__jumpToLastBlock()
                     if self.flagIsNewFile:
                         return 1
                     self.lastUTTime = self.utc
                     if self.online:
                         if self.__waitNewBlock():
                             return 1
                     if self.nReadBlocks < self.dataBlocksPerFile:
                         return 1
                     if not(self.setNextFile()):
                         return 0
                     deltaTime = self.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 getData(self):
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
                         print 'Process finished'
                         return 0
                     self.flagTimeBlock = 0
                     self.flagIsNewBlock = 0
                     if not(self.readNextBlock()):
                         return 0
                     if self.data == None:
                         self.dataOut.flagNoData = True
                         return 0
                     self.dataOut.data = self.data
                     self.dataOut.data_header = self.data_header_dict
                     self.dataOut.utctime = self.utc
                     self.dataOut.header = self.header_dict
                     self.dataOut.expName = self.expName
                     self.dataOut.nChannels = self.nChannels
                     self.dataOut.timeZone = self.timeZone
                     self.dataOut.dataBlocksPerFile = self.dataBlocksPerFile
                     self.dataOut.comments = self.comments
                     self.dataOut.timeInterval = self.timeInterval
                     self.dataOut.channelList = self.channelList
                     self.dataOut.heightList = self.heightList
                     self.dataOut.flagNoData = False
                     return self.dataOut.data
                 def run(self, **kwargs):
                     if not(self.isConfig):
                         self.setup(**kwargs)
                         self.isConfig = True
                     self.getData()
             class RadacHeader():
                 def __init__(self, fp):
                     header = 'Raw11/Data/RadacHeader'
                     self.beamCodeByPulse = fp.get(header+'/BeamCode')
                     self.beamCode = fp.get('Raw11/Data/Beamcodes')
                     self.code = fp.get(header+'/Code')
                     self.frameCount = fp.get(header+'/FrameCount')
                     self.modeGroup = fp.get(header+'/ModeGroup')
                     self.nsamplesPulse = fp.get(header+'/NSamplesPulse')
                     self.pulseCount = fp.get(header+'/PulseCount')
                     self.radacTime = fp.get(header+'/RadacTime')
                     self.timeCount = fp.get(header+'/TimeCount')
                     self.timeStatus = fp.get(header+'/TimeStatus')
                     self.nrecords = self.pulseCount.shape[0] #numero de bloques
                     self.npulses = self.pulseCount.shape[1] #numero de perfiles
                     self.nsamples = self.nsamplesPulse[0,0] #numero de alturas
                     self.nbeams = self.beamCode.shape[1] #numero de beams
                 def getIndexRangeToPulse(self, idrecord=0):
                     indexToZero = numpy.where(self.pulseCount.value[idrecord,:]==0)
                     startPulseCountId = indexToZero[0][0]
                     endPulseCountId = startPulseCountId - 1
                     range1 = numpy.arange(startPulseCountId,self.npulses,1)
                     range2 = numpy.arange(0,startPulseCountId,1)
                     return range1, range2
             class AMISRReader(ProcessingUnit):
                 path = None
                 startDate = None
                 endDate = None
                 startTime = None
                 endTime = None
                 walk = None
                 isConfig = False
                 def __init__(self):
                     self.set = None
                     self.subset = None
                     self.extension_file = '.h5'
                     self.dtc_str = 'dtc'
                     self.dtc_id = 0
                     self.status = True
                     self.isConfig = False
                     self.dirnameList = []
                     self.filenameList = []
                     self.fileIndex = None
                     self.flagNoMoreFiles = False
                     self.flagIsNewFile = 0
                     self.filename = ''
                     self.amisrFilePointer = None
                     self.radacHeaderObj = None
                     self.dataOut = self.__createObjByDefault()
                     self.datablock = None
                     self.rest_datablock = None
                     self.range = None
                     self.idrecord_count = 0
                     self.profileIndex = 0
                     self.idpulse_range1 = None
                     self.idpulse_range2 = None
                     self.beamCodeByFrame = None
                     self.radacTimeByFrame = None
                     #atributos originales tal y como esta en el archivo de datos
                     self.beamCodesFromFile = None
                     self.radacTimeFromFile = None
                     self.rangeFromFile = None
                     self.dataByFrame = None
                     self.dataset = None
                     self.beamCodeDict = {}
                     self.beamRangeDict = {}
                     #experiment cgf file
                     self.npulsesint_fromfile = None
                     self.recordsperfile_fromfile = None
                     self.nbeamcodes_fromfile = None
                     self.ngates_fromfile = None
                     self.ippSeconds_fromfile = None
                     self.frequency_h5file = None
+                    self.__firstFile = True
+                    self.buffer_radactime = None
                 def __createObjByDefault(self):
                     dataObj = AMISR()
                     return dataObj
                 def __setParameters(self,path,startDate,endDate,startTime,endTime,walk):
                     self.path = path
                     self.startDate = startDate
                     self.endDate = endDate
                     self.startTime = startTime
                     self.endTime = endTime
                     self.walk = walk
                 def __checkPath(self):
                     if os.path.exists(self.path):
                         self.status = 1
                     else:
                         self.status = 0
                         print 'Path:%s does not exists'%self.path
                     return
                 def __selDates(self, amisr_dirname_format):
                     try:
                         year = int(amisr_dirname_format[0:4])
                         month = int(amisr_dirname_format[4:6])
                         dom = int(amisr_dirname_format[6:8])
                         thisDate = datetime.date(year,month,dom)
                         if (thisDate>=self.startDate and thisDate <= self.endDate):
                             return amisr_dirname_format
                     except:
                         return None
                 def __findDataForDates(self):
                     if not(self.status):
                         return None
                     pat = '\d+.\d+'
                     dirnameList = [re.search(pat,x) for x in os.listdir(self.path)]
                     dirnameList = filter(lambda x:x!=None,dirnameList)
                     dirnameList = [x.string for x in dirnameList]
                     dirnameList = [self.__selDates(x) for x in dirnameList]
                     dirnameList = filter(lambda x:x!=None,dirnameList)
                     if len(dirnameList)>0:
                         self.status = 1
                         self.dirnameList = dirnameList
                         self.dirnameList.sort()
                     else:
                         self.status = 0
                         return None
                 def __getTimeFromData(self):
                     pass
                 def __filterByGlob1(self, dirName):
                     filter_files = glob.glob1(dirName, '*.*%s'%self.extension_file)
                     filterDict = {}
                     filterDict.setdefault(dirName)
                     filterDict[dirName] = filter_files
                     return filterDict
                 def __getFilenameList(self, fileListInKeys, dirList):
                     for value in fileListInKeys:
                         dirName = value.keys()[0]
                         for file in value[dirName]:
                             filename = os.path.join(dirName, file)
                             self.filenameList.append(filename)
                 def __selectDataForTimes(self):
                     #aun no esta implementado el filtro for tiempo
                     if not(self.status):
                         return None
                     dirList = [os.path.join(self.path,x) for x in self.dirnameList]
                     fileListInKeys = [self.__filterByGlob1(x) for x in dirList]
                     self.__getFilenameList(fileListInKeys, dirList)
                     if len(self.filenameList)>0:
                         self.status = 1
                         self.filenameList.sort()
                     else:
                         self.status = 0
                         return None
                 def __searchFilesOffline(self,
                                         path,
                                         startDate,
                                         endDate,
                                         startTime=datetime.time(0,0,0),
                                         endTime=datetime.time(23,59,59),
                                         walk=True):
                     self.__setParameters(path, startDate, endDate, startTime, endTime, walk)
                     self.__checkPath()
                     self.__findDataForDates()
                     self.__selectDataForTimes()
                     for i in range(len(self.filenameList)):
                         print "%s" %(self.filenameList[i])
                     return
                 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]
                         amisrFilePointer = h5py.File(filename,'r')
                         break
                     self.flagIsNewFile = 1
                     self.fileIndex = idFile
                     self.filename = filename
                     self.amisrFilePointer = amisrFilePointer
                     print "Setting the file: %s"%self.filename
                     return 1
                 def __readHeader(self):
                     self.radacHeaderObj = RadacHeader(self.amisrFilePointer)
                     #update values from experiment cfg file
-                    self.radacHeaderObj.nrecords = self.recordsperfile_fromfile
+                    if self.radacHeaderObj.nrecords == self.recordsperfile_fromfile:
+                        self.radacHeaderObj.nrecords = self.recordsperfile_fromfile
                     self.radacHeaderObj.nbeams = self.nbeamcodes_fromfile
                     self.radacHeaderObj.npulses = self.npulsesint_fromfile
                     self.radacHeaderObj.nsamples = self.ngates_fromfile
                     #get tuning frequency
                     frequency_h5file_dataset = self.amisrFilePointer.get('Rx'+'/TuningFrequency')
                     self.frequency_h5file = frequency_h5file_dataset[0,0]
                     self.flagIsNewFile = 1
                 def __getBeamCode(self):
                     self.beamCodeDict = {}
                     self.beamRangeDict = {}
                     for i in range(len(self.radacHeaderObj.beamCode[0,:])):
                         self.beamCodeDict.setdefault(i)
                         self.beamRangeDict.setdefault(i)
                         self.beamCodeDict[i] = self.radacHeaderObj.beamCode[0,i]
                     just4record0 = self.radacHeaderObj.beamCodeByPulse[0,:]
                     for i in range(len(self.beamCodeDict.values())):
                         xx = numpy.where(just4record0==self.beamCodeDict.values()[i])
                         self.beamRangeDict[i] = xx[0]
                 def __getExpParameters(self):
                     if not(self.status):
                         return None
                     experimentCfgPath = os.path.join(self.path, self.dirnameList[0], 'Setup')
                     expFinder = glob.glob1(experimentCfgPath,'*.exp')
                     if len(expFinder)== 0:
                         self.status = 0
                         return None
                     experimentFilename = os.path.join(experimentCfgPath,expFinder[0])
                     f = open(experimentFilename)
                     lines = f.readlines()
                     f.close()
                     parmsList = ['npulsesint*','recordsperfile*','nbeamcodes*','ngates*']
                     filterList = [fnmatch.filter(lines, x) for x in parmsList]
                     values = [re.sub(r'\D',"",x[0]) for x in filterList]
                     self.npulsesint_fromfile = int(values[0])
                     self.recordsperfile_fromfile = int(values[1])
                     self.nbeamcodes_fromfile = int(values[2])
                     self.ngates_fromfile = int(values[3])
                     tufileFinder = fnmatch.filter(lines, 'tufile=*')
                     tufile = tufileFinder[0].split('=')[1].split('\n')[0]
                     tufilename = os.path.join(experimentCfgPath,tufile)
                     f = open(tufilename)
                     lines = f.readlines()
                     f.close()
                     self.ippSeconds_fromfile = float(lines[1].split()[2])/1E6
                     self.status = 1
+                def __setIdsAndArrays(self):
+                    self.dataByFrame = self.__setDataByFrame()
+                    self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[0, :]
+                    self.readRanges()
+                    self.idpulse_range1, self.idpulse_range2 = self.radacHeaderObj.getIndexRangeToPulse(0)
+                    self.radacTimeByFrame = numpy.zeros(self.radacHeaderObj.npulses)
+                    self.buffer_radactime = numpy.zeros_like(self.radacTimeByFrame)
                 def __setNextFile(self):
                     newFile = self.__setNextFileOffline()
                     if not(newFile):
                         return 0
                     self.__readHeader()
+                    if self.__firstFile:
+                        self.__setIdsAndArrays()
+                        self.__firstFile = False
                     self.__getBeamCode()
                     self.readDataBlock()
                 def setup(self,path=None,
                                 startDate=None,
                                 endDate=None,
                                 startTime=datetime.time(0,0,0),
                                 endTime=datetime.time(23,59,59),
                                 walk=True):
                     #Busqueda de archivos offline
                     self.__searchFilesOffline(path, startDate, endDate, startTime, endTime, walk)
                     if not(self.filenameList):
                         print "There is no files into the folder: %s"%(path)
                         sys.exit(-1)
                     self.__getExpParameters()
                     self.fileIndex = -1
                     self.__setNextFile()
                 def readRanges(self):
                     dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Range')
                     #self.rangeFromFile = dataset.value
                     self.rangeFromFile = numpy.reshape(dataset.value,(-1))
                     return range
                 def readRadacTime(self,idrecord, range1, range2):
                     self.radacTimeFromFile = self.radacHeaderObj.radacTime.value
                     radacTimeByFrame = numpy.zeros((self.radacHeaderObj.npulses))
                     #radacTimeByFrame = dataset[idrecord - 1,range1]
                     #radacTimeByFrame = dataset[idrecord,range2]
                     return radacTimeByFrame
                 def readBeamCode(self, idrecord, range1, range2):
                     dataset = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode')
                     beamcodeByFrame = numpy.zeros((self.radacHeaderObj.npulses))
                     self.beamCodesFromFile = dataset.value
                     #beamcodeByFrame[range1] = dataset[idrecord - 1, range1]
                     #beamcodeByFrame[range2] = dataset[idrecord, range2]
                     beamcodeByFrame[range1] = dataset[idrecord, range1]
                     beamcodeByFrame[range2] = dataset[idrecord, range2]
                     return beamcodeByFrame
                 def __setDataByFrame(self):
                     ndata = 2 # porque es complejo
                     dataByFrame = numpy.zeros((self.radacHeaderObj.npulses, self.radacHeaderObj.nsamples, ndata))
                     return dataByFrame
                 def __readDataSet(self):
                     dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Data')
                     return dataset
                 def __setDataBlock(self,):
                     real = self.dataByFrame[:,:,0] #asumo que 0 es real
                     imag = self.dataByFrame[:,:,1] #asumo que 1 es imaginario
                     datablock = real + imag*1j #armo el complejo
                     return datablock
                 def readSamples_version1(self,idrecord):
                     #estas tres primeras lineas solo se deben ejecutar una vez
                     if self.flagIsNewFile:
-                        self.idpulse_range1, self.idpulse_range2 = self.radacHeaderObj.getIndexRangeToPulse(0)
-                        self.dataByFrame = self.__setDataByFrame()
-                        self.beamCodeByFrame = self.readBeamCode(idrecord, self.idpulse_range1, self.idpulse_range2)
-                        self.radacTimeByFrame = self.readRadacTime(idrecord, self.idpulse_range1, self.idpulse_range2)
                         #reading dataset
                         self.dataset = self.__readDataSet()
+                        self.flagIsNewFile = 0
                     if idrecord == 0:
+                        #if self.buffer_last_record == None:
+                        selectorById = self.radacHeaderObj.pulseCount[0,self.idpulse_range2]
-                        if len(numpy.where(self.dataByFrame!=0.0)[0]) or len(numpy.where(self.dataByFrame!=0.0)[1]) or len(numpy.where(self.dataByFrame!=0.0)[2]):
+                        self.dataByFrame[selectorById,:,:] = self.dataset[0, self.idpulse_range2,:,:]
-                            #falta agregar una condicion para datos discontinuos
-                            #por defecto une los datos del record anterior
+                        self.radacTimeByFrame[selectorById] = self.radacHeaderObj.radacTime[0, self.idpulse_range2]
-                            self.dataByFrame[self.idpulse_range2, :, :] = self.dataset[idrecord, self.idpulse_range2, :, :]
-                            #timepulse
+                        selectorById = self.radacHeaderObj.pulseCount[0,self.idpulse_range1]
-                            self.radacTimeByFrame[self.idpulse_range2] = self.radacHeaderObj.radacTime[idrecord, self.idpulse_range2]
-                        else:
+                        self.radacTimeByFrame[selectorById] = self.buffer_radactime[selectorById]
-                            self.dataByFrame[self.idpulse_range1, :, :] = self.dataset[idrecord, self.idpulse_range1, :, :]
-                            self.radacTimeByFrame[self.idpulse_range1] = self.radacHeaderObj.radacTime[idrecord, self.idpulse_range1]
                         datablock = self.__setDataBlock()
                         return datablock
+                    selectorById = self.radacHeaderObj.pulseCount[idrecord-1,self.idpulse_range1]
+                    self.dataByFrame[selectorById,:,:] = self.dataset[idrecord-1, self.idpulse_range1, :, :]
+                    self.radacTimeByFrame[selectorById] = self.radacHeaderObj.radacTime[idrecord-1, self.idpulse_range1]
-                    self.dataByFrame[self.idpulse_range1, :, :] = self.dataset[idrecord - 1,self.idpulse_range1, :, :]
+                    selectorById = self.radacHeaderObj.pulseCount[idrecord,self.idpulse_range2]#data incompleta ultimo archivo de carpeta, verifica el record real segun la dimension del arreglo de datos
-                    self.dataByFrame[self.idpulse_range2, :, :] = self.dataset[idrecord, self.idpulse_range2, :, :]
+                    self.dataByFrame[selectorById,:,:] = self.dataset[idrecord, self.idpulse_range2, :, :]
-                    datablock = self.__setDataBlock()
+                    self.radacTimeByFrame[selectorById] = self.radacHeaderObj.radacTime[idrecord, self.idpulse_range2]
-                    self.flagIsNewFile = 0
-                    self.dataByFrame[self.idpulse_range1, :, :] = self.dataset[idrecord, self.idpulse_range1, :, :]
+                    datablock = self.__setDataBlock()
+                    selectorById = self.radacHeaderObj.pulseCount[idrecord,self.idpulse_range1]
+                    self.dataByFrame[selectorById,:,:] = self.dataset[idrecord, self.idpulse_range1, :, :]
+                    self.buffer_radactime[selectorById] = self.radacHeaderObj.radacTime[idrecord, self.idpulse_range1]
                     return datablock
                 def readSamples(self,idrecord):
                     if self.flagIsNewFile:
                         self.dataByFrame = self.__setDataByFrame()
                         self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[idrecord, :]
                         #reading ranges
                         self.readRanges()
                         #reading dataset
                         self.dataset = self.__readDataSet()
                     self.flagIsNewFile = 0
                     self.radacTimeByFrame = self.radacHeaderObj.radacTime.value[idrecord, :]
                     self.dataByFrame = self.dataset[idrecord, :, :, :]
                     datablock = self.__setDataBlock()
                     return datablock
                 def readDataBlock(self):
+                    self.datablock = self.readSamples_version1(self.idrecord_count)
                     #self.datablock = self.readSamples(self.idrecord_count)
-                    self.datablock = self.readSamples(self.idrecord_count)
                     #print 'record:', self.idrecord_count
                     self.idrecord_count += 1
                     self.profileIndex = 0
                     if self.idrecord_count >= self.radacHeaderObj.nrecords:
                         self.idrecord_count = 0
                         self.flagIsNewFile = 1
                 def readNextBlock(self):
                     self.readDataBlock()
                     if self.flagIsNewFile:
                         self.__setNextFile()
                     pass
                 def __hasNotDataInBuffer(self):
                     #self.radacHeaderObj.npulses debe ser otra variable para considerar el numero de pulsos a tomar en el primer y ultimo record
                     if self.profileIndex >= self.radacHeaderObj.npulses:
                         return 1
                     return 0
                 def printUTC(self):
                     print self.dataOut.utctime
                     print ''
                 def setObjProperties(self):
                     self.dataOut.heightList = self.rangeFromFile/1000.0 #km
                     self.dataOut.nProfiles = self.radacHeaderObj.npulses
                     self.dataOut.nRecords = self.radacHeaderObj.nrecords
                     self.dataOut.nBeams = self.radacHeaderObj.nbeams
                     self.dataOut.ippSeconds = self.ippSeconds_fromfile
                     self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
                     self.dataOut.frequency = self.frequency_h5file
                     self.dataOut.nBaud = None
                     self.dataOut.nCode = None
                     self.dataOut.code = None
                     self.dataOut.beamCodeDict = self.beamCodeDict
                     self.dataOut.beamRangeDict = self.beamRangeDict
                 def getData(self):
                     if self.flagNoMoreFiles:
                         self.dataOut.flagNoData = True
                         print 'Process finished'
                         return 0
                     if self.__hasNotDataInBuffer():
                         self.readNextBlock()
-            #             if not( self.readNextBlock() ):
-            #                 return 0
-            #             self.getFirstHeader()
                     if self.datablock == None: # setear esta condicion cuando no hayan datos por leers
                         self.dataOut.flagNoData = True
                         return 0
                     self.dataOut.data = numpy.reshape(self.datablock[self.profileIndex,:],(1,-1))
                     self.dataOut.utctime = self.radacTimeByFrame[self.profileIndex]
                     self.dataOut.flagNoData = False
                     self.profileIndex += 1
                     return self.dataOut.data
                 def run(self, **kwargs):
                     if not(self.isConfig):
                         self.setup(**kwargs)
                         self.setObjProperties()
                         self.isConfig = True
                     self.getData()

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

import h5py

13

import h5py

14

import re

14

import re

15

from xml.etree.ElementTree import Element, SubElement, ElementTree

15

from xml.etree.ElementTree import Element, SubElement, ElementTree

16

try:

16

try:

17

import pyfits

17

import pyfits

18

except:

18

except:

19

print "pyfits module has not been imported, it should be installed to save files in fits format"

19

print "pyfits module has not been imported, it should be installed to save files in fits format"

20

21

from jrodata import *

21

from jrodata import *

22

from jroheaderIO import *

22

from jroheaderIO import *

23

from jroprocessing import *

23

from jroprocessing import *

24

25

LOCALTIME = True #-18000

25

LOCALTIME = True #-18000

26

27

def isNumber(str):

27

def isNumber(str):

28

"""

28

"""

29

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

29

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

30

31

Excepciones:

31

Excepciones:

32

Si un determinado string no puede ser convertido a numero

32

Si un determinado string no puede ser convertido a numero

33

Input:

33

Input:

34

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

34

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

35

36

Return:

36

Return:

37

True : si el string es uno numerico

37

True : si el string es uno numerico

38

False : no es un string numerico

38

False : no es un string numerico

39

"""

39

"""

40

try:

40

try:

41

float( str )

41

float( str )

42

return True

42

return True

43

except:

43

except:

44

return False

44

return False

45

46

def isThisFileinRange(filename, startUTSeconds, endUTSeconds):

46

def isThisFileinRange(filename, startUTSeconds, endUTSeconds):

47

"""

47

"""

48

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

48

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

49

50

Inputs:

50

Inputs:

51

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

51

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

52

53

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

53

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

54

segundos contados desde 01/01/1970.

54

segundos contados desde 01/01/1970.

55

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

55

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

56

segundos contados desde 01/01/1970.

56

segundos contados desde 01/01/1970.

57

58

Return:

58

Return:

59

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

59

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

60

fecha especificado, de lo contrario retorna False.

60

fecha especificado, de lo contrario retorna False.

61

62

Excepciones:

62

Excepciones:

63

Si el archivo no existe o no puede ser abierto

63

Si el archivo no existe o no puede ser abierto

64

Si la cabecera no puede ser leida.

64

Si la cabecera no puede ser leida.

65

66

"""

66

"""

67

basicHeaderObj = BasicHeader(LOCALTIME)

67

basicHeaderObj = BasicHeader(LOCALTIME)

68

69

try:

69

try:

70

fp = open(filename,'rb')

70

fp = open(filename,'rb')

71

except:

71

except:

72

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

72

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

73

74

sts = basicHeaderObj.read(fp)

74

sts = basicHeaderObj.read(fp)

75

fp.close()

75

fp.close()

76

77

if not(sts):

77

if not(sts):

78

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

78

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

79

return 0

79

return 0

80

81

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

81

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

82

return 0

82

return 0

83

84

return 1

84

return 1

85

86

def isFileinThisTime(filename, startTime, endTime):

86

def isFileinThisTime(filename, startTime, endTime):

87

"""

87

"""

88

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

88

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

89

90

Inputs:

90

Inputs:

91

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

91

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

92

93

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

93

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

94

95

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

95

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

96

97

Return:

97

Return:

98

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

98

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

99

fecha especificado, de lo contrario retorna False.

99

fecha especificado, de lo contrario retorna False.

100

101

Excepciones:

101

Excepciones:

102

Si el archivo no existe o no puede ser abierto

102

Si el archivo no existe o no puede ser abierto

103

Si la cabecera no puede ser leida.

103

Si la cabecera no puede ser leida.

104

105

"""

105

"""

106

107

108

try:

108

try:

109

fp = open(filename,'rb')

109

fp = open(filename,'rb')

110

except:

110

except:

111

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

111

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

112

113

basicHeaderObj = BasicHeader(LOCALTIME)

113

basicHeaderObj = BasicHeader(LOCALTIME)

114

sts = basicHeaderObj.read(fp)

114

sts = basicHeaderObj.read(fp)

115

fp.close()

115

fp.close()

116

117

thisDatetime = basicHeaderObj.datatime

117

thisDatetime = basicHeaderObj.datatime

118

thisTime = basicHeaderObj.datatime.time()

118

thisTime = basicHeaderObj.datatime.time()

119

120

if not(sts):

120

if not(sts):

121

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

121

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

122

return None

122

return None

123

124

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

124

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

125

return None

125

return None

126

127

return thisDatetime

127

return thisDatetime

128

129

def getFileFromSet(path,ext,set):

129

def getFileFromSet(path,ext,set):

130

validFilelist = []

130

validFilelist = []

131

fileList = os.listdir(path)

131

fileList = os.listdir(path)

132

133

# 0 1234 567 89A BCDE

133

# 0 1234 567 89A BCDE

134

# H YYYY DDD SSS .ext

134

# H YYYY DDD SSS .ext

135

136

for file in fileList:

136

for file in fileList:

137

try:

137

try:

138

year = int(file[1:5])

138

year = int(file[1:5])

139

doy = int(file[5:8])

139

doy = int(file[5:8])

140

141

142

except:

142

except:

143

continue

143

continue

144

145

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

145

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

146

continue

146

continue

147

148

validFilelist.append(file)

148

validFilelist.append(file)

149

150

myfile = fnmatch.filter(validFilelist,'*%4.4d%3.3d%3.3d*'%(year,doy,set))

150

myfile = fnmatch.filter(validFilelist,'*%4.4d%3.3d%3.3d*'%(year,doy,set))

151

152

if len(myfile)!= 0:

152

if len(myfile)!= 0:

153

return myfile[0]

153

return myfile[0]

154

else:

154

else:

155

filename = '*%4.4d%3.3d%3.3d%s'%(year,doy,set,ext.lower())

155

filename = '*%4.4d%3.3d%3.3d%s'%(year,doy,set,ext.lower())

156

print 'the filename %s does not exist'%filename

156

print 'the filename %s does not exist'%filename

157

print '...going to the last file: '

157

print '...going to the last file: '

158

159

if validFilelist:

159

if validFilelist:

160

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

160

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

161

return validFilelist[-1]

161

return validFilelist[-1]

162

163

return None

163

return None

164

165

166

def getlastFileFromPath(path, ext):

166

def getlastFileFromPath(path, ext):

167

"""

167

"""

168

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

168

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

169

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

169

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

170

171

Input:

171

Input:

172

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

172

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

173

ext : extension de los files contenidos en una carpeta

173

ext : extension de los files contenidos en una carpeta

174

175

Return:

175

Return:

176

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

176

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

177

"""

177

"""

178

validFilelist = []

178

validFilelist = []

179

fileList = os.listdir(path)

179

fileList = os.listdir(path)

180

181

# 0 1234 567 89A BCDE

181

# 0 1234 567 89A BCDE

182

# H YYYY DDD SSS .ext

182

# H YYYY DDD SSS .ext

183

184

for file in fileList:

184

for file in fileList:

185

try:

185

try:

186

year = int(file[1:5])

186

year = int(file[1:5])

187

doy = int(file[5:8])

187

doy = int(file[5:8])

188

189

190

except:

190

except:

191

continue

191

continue

192

193

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

193

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

194

continue

194

continue

195

196

validFilelist.append(file)

196

validFilelist.append(file)

197

198

if validFilelist:

198

if validFilelist:

199

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

199

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

200

return validFilelist[-1]

200

return validFilelist[-1]

201

202

return None

202

return None

203

204

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

204

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

205

"""

205

"""

206

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

206

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

207

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

207

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

208

el path exacto de un determinado file.

208

el path exacto de un determinado file.

209

210

Example :

210

Example :

211

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

211

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

212

213

Entonces la funcion prueba con las siguientes combinaciones

213

Entonces la funcion prueba con las siguientes combinaciones

214

.../.../y2009307367.ext

214

.../.../y2009307367.ext

215

.../.../Y2009307367.ext

215

.../.../Y2009307367.ext

216

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

216

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

217

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

217

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

218

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

218

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

219

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

219

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

220

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

220

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

221

222

Return:

222

Return:

223

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

223

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

224

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

224

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

225

para el filename

225

para el filename

226

"""

226

"""

227

fullfilename = None

227

fullfilename = None

228

find_flag = False

228

find_flag = False

229

filename = None

229

filename = None

230

231

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

231

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

232

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

232

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

233

prefixFileList = ['d','D']

233

prefixFileList = ['d','D']

234

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

234

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

235

prefixFileList = ['p','P']

235

prefixFileList = ['p','P']

236

else:

236

else:

237

return None, filename

237

return None, filename

238

239

#barrido por las combinaciones posibles

239

#barrido por las combinaciones posibles

240

for prefixDir in prefixDirList:

240

for prefixDir in prefixDirList:

241

thispath = path

241

thispath = path

242

if prefixDir != None:

242

if prefixDir != None:

243

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

243

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

244

if foldercounter == 0:

244

if foldercounter == 0:

245

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

245

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

246

else:

246

else:

247

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

247

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

248

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

248

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

249

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

249

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

250

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

250

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

251

252

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

252

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

253

find_flag = True

253

find_flag = True

254

break

254

break

255

if find_flag:

255

if find_flag:

256

break

256

break

257

258

if not(find_flag):

258

if not(find_flag):

259

return None, filename

259

return None, filename

260

261

return fullfilename, filename

261

return fullfilename, filename

262

263

def isDoyFolder(folder):

263

def isDoyFolder(folder):

264

try:

264

try:

265

year = int(folder[1:5])

265

year = int(folder[1:5])

266

except:

266

except:

267

return 0

267

return 0

268

269

try:

269

try:

270

doy = int(folder[5:8])

270

doy = int(folder[5:8])

271

except:

271

except:

272

return 0

272

return 0

273

274

return 1

274

return 1

275

276

class JRODataIO:

276

class JRODataIO:

277

278

c = 3E8

278

c = 3E8

279

280

isConfig = False

280

isConfig = False

281

282

basicHeaderObj = BasicHeader(LOCALTIME)

282

basicHeaderObj = BasicHeader(LOCALTIME)

283

284

systemHeaderObj = SystemHeader()

284

systemHeaderObj = SystemHeader()

285

286

radarControllerHeaderObj = RadarControllerHeader()

286

radarControllerHeaderObj = RadarControllerHeader()

287

288

processingHeaderObj = ProcessingHeader()

288

processingHeaderObj = ProcessingHeader()

289

290

online = 0

290

online = 0

291

292

dtype = None

292

dtype = None

293

294

pathList = []

294

pathList = []

295

296

filenameList = []

296

filenameList = []

297

298

filename = None

298

filename = None

299

300

ext = None

300

ext = None

301

302

flagIsNewFile = 1

302

flagIsNewFile = 1

303

304

flagTimeBlock = 0

304

flagTimeBlock = 0

305

306

flagIsNewBlock = 0

306

flagIsNewBlock = 0

307

308

fp = None

308

fp = None

309

310

firstHeaderSize = 0

310

firstHeaderSize = 0

311

312

basicHeaderSize = 24

312

basicHeaderSize = 24

313

314

versionFile = 1103

314

versionFile = 1103

315

316

fileSize = None

316

fileSize = None

317

318

ippSeconds = None

318

ippSeconds = None

319

320

fileSizeByHeader = None

320

fileSizeByHeader = None

321

322

fileIndex = None

322

fileIndex = None

323

324

profileIndex = None

324

profileIndex = None

325

326

blockIndex = None

326

blockIndex = None

327

328

nTotalBlocks = None

328

nTotalBlocks = None

329

330

maxTimeStep = 30

330

maxTimeStep = 30

331

332

lastUTTime = None

332

lastUTTime = None

333

334

datablock = None

334

datablock = None

335

336

dataOut = None

336

dataOut = None

337

338

blocksize = None

338

blocksize = None

339

340

def __init__(self):

340

def __init__(self):

341

342

raise ValueError, "Not implemented"

342

raise ValueError, "Not implemented"

343

344

def run(self):

344

def run(self):

345

346

raise ValueError, "Not implemented"

346

raise ValueError, "Not implemented"

347

348

def getOutput(self):

348

def getOutput(self):

349

350

return self.dataOut

350

return self.dataOut

351

352

class JRODataReader(JRODataIO, ProcessingUnit):

352

class JRODataReader(JRODataIO, ProcessingUnit):

353

354

nReadBlocks = 0

354

nReadBlocks = 0

355

356

delay = 10 #number of seconds waiting a new file

356

delay = 10 #number of seconds waiting a new file

357

358

nTries = 3 #quantity tries

358

nTries = 3 #quantity tries

359

360

nFiles = 3 #number of files for searching

360

nFiles = 3 #number of files for searching

361

362

path = None

362

path = None

363

364

foldercounter = 0

364

foldercounter = 0

365

366

flagNoMoreFiles = 0

366

flagNoMoreFiles = 0

367

368

datetimeList = []

368

datetimeList = []

369

370

__isFirstTimeOnline = 1

370

__isFirstTimeOnline = 1

371

372

__printInfo = True

372

__printInfo = True

373

374

profileIndex = None

374

profileIndex = None

375

376

def __init__(self):

376

def __init__(self):

377

378

"""

378

"""

379

380

"""

380

"""

381

382

raise ValueError, "This method has not been implemented"

382

raise ValueError, "This method has not been implemented"

383

384

385

def createObjByDefault(self):

385

def createObjByDefault(self):

386

"""

386

"""

387

388

"""

388

"""

389

raise ValueError, "This method has not been implemented"

389

raise ValueError, "This method has not been implemented"

390

391

def getBlockDimension(self):

391

def getBlockDimension(self):

392

393

raise ValueError, "No implemented"

393

raise ValueError, "No implemented"

394

395

def __searchFilesOffLine(self,

395

def __searchFilesOffLine(self,

396

path,

396

path,

397

startDate,

397

startDate,

398

endDate,

398

endDate,

399

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

399

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

400

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

400

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

401

set=None,

401

set=None,

402

expLabel='',

402

expLabel='',

403

ext='.r',

403

ext='.r',

404

walk=True):

404

walk=True):

405

406

pathList = []

406

pathList = []

407

408

if not walk:

408

if not walk:

409

#pathList.append(path)

409

#pathList.append(path)

410

multi_path = path.split(',')

410

multi_path = path.split(',')

411

for single_path in multi_path:

411

for single_path in multi_path:

412

pathList.append(single_path)

412

pathList.append(single_path)

413

414

else:

414

else:

415

#dirList = []

415

#dirList = []

416

multi_path = path.split(',')

416

multi_path = path.split(',')

417

for single_path in multi_path:

417

for single_path in multi_path:

418

dirList = []

418

dirList = []

419

for thisPath in os.listdir(single_path):

419

for thisPath in os.listdir(single_path):

420

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

420

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

421

continue

421

continue

422

if not isDoyFolder(thisPath):

422

if not isDoyFolder(thisPath):

423

continue

423

continue

424

425

dirList.append(thisPath)

425

dirList.append(thisPath)

426

427

if not(dirList):

427

if not(dirList):

428

return None, None

428

return None, None

429

430

thisDate = startDate

430

thisDate = startDate

431

432

while(thisDate <= endDate):

432

while(thisDate <= endDate):

433

year = thisDate.timetuple().tm_year

433

year = thisDate.timetuple().tm_year

434

doy = thisDate.timetuple().tm_yday

434

doy = thisDate.timetuple().tm_yday

435

436

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

436

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

437

if len(matchlist) == 0:

437

if len(matchlist) == 0:

438

thisDate += datetime.timedelta(1)

438

thisDate += datetime.timedelta(1)

439

continue

439

continue

440

for match in matchlist:

440

for match in matchlist:

441

pathList.append(os.path.join(single_path,match,expLabel))

441

pathList.append(os.path.join(single_path,match,expLabel))

442

443

thisDate += datetime.timedelta(1)

443

thisDate += datetime.timedelta(1)

444

445

if pathList == []:

445

if pathList == []:

446

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

446

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

447

return None, None

447

return None, None

448

449

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

449

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

450

451

filenameList = []

451

filenameList = []

452

datetimeList = []

452

datetimeList = []

453

pathDict = {}

453

pathDict = {}

454

filenameList_to_sort = []

454

filenameList_to_sort = []

455

456

for i in range(len(pathList)):

456

for i in range(len(pathList)):

457

458

thisPath = pathList[i]

458

thisPath = pathList[i]

459

460

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

460

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

461

fileList.sort()

461

fileList.sort()

462

pathDict.setdefault(fileList[0])

462

pathDict.setdefault(fileList[0])

463

pathDict[fileList[0]] = i

463

pathDict[fileList[0]] = i

464

filenameList_to_sort.append(fileList[0])

464

filenameList_to_sort.append(fileList[0])

465

466

filenameList_to_sort.sort()

466

filenameList_to_sort.sort()

467

468

for file in filenameList_to_sort:

468

for file in filenameList_to_sort:

469

thisPath = pathList[pathDict[file]]

469

thisPath = pathList[pathDict[file]]

470

471

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

471

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

472

fileList.sort()

472

fileList.sort()

473

474

for file in fileList:

474

for file in fileList:

475

476

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

476

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

477

thisDatetime = isFileinThisTime(filename, startTime, endTime)

477

thisDatetime = isFileinThisTime(filename, startTime, endTime)

478

479

if not(thisDatetime):

479

if not(thisDatetime):

480

continue

480

continue

481

482

filenameList.append(filename)

482

filenameList.append(filename)

483

datetimeList.append(thisDatetime)

483

datetimeList.append(thisDatetime)

484

485

if not(filenameList):

485

if not(filenameList):

486

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

486

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

487

return None, None

487

return None, None

488

489

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

489

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

490

print

490

print

491

492

for i in range(len(filenameList)):

492

for i in range(len(filenameList)):

493

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

493

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

494

495

self.filenameList = filenameList

495

self.filenameList = filenameList

496

self.datetimeList = datetimeList

496

self.datetimeList = datetimeList

497

498

return pathList, filenameList

498

return pathList, filenameList

499

500

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

500

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

501

502

"""

502

"""

503

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

503

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

504

devuelve el archivo encontrado ademas de otros datos.

504

devuelve el archivo encontrado ademas de otros datos.

505

506

Input:

506

Input:

507

path : carpeta donde estan contenidos los files que contiene data

507

path : carpeta donde estan contenidos los files que contiene data

508

509

expLabel : Nombre del subexperimento (subfolder)

509

expLabel : Nombre del subexperimento (subfolder)

510

511

ext : extension de los files

511

ext : extension de los files

512

513

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

513

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

514

515

Return:

515

Return:

516

directory : eL directorio donde esta el file encontrado

516

directory : eL directorio donde esta el file encontrado

517

filename : el ultimo file de una determinada carpeta

517

filename : el ultimo file de una determinada carpeta

518

year : el anho

518

year : el anho

519

doy : el numero de dia del anho

519

doy : el numero de dia del anho

520

set : el set del archivo

520

set : el set del archivo

521

522

523

"""

523

"""

524

dirList = []

524

dirList = []

525

526

if not walk:

526

if not walk:

527

fullpath = path

527

fullpath = path

528

foldercounter = 0

528

foldercounter = 0

529

else:

529

else:

530

#Filtra solo los directorios

530

#Filtra solo los directorios

531

for thisPath in os.listdir(path):

531

for thisPath in os.listdir(path):

532

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

532

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

533

continue

533

continue

534

if not isDoyFolder(thisPath):

534

if not isDoyFolder(thisPath):

535

continue

535

continue

536

537

dirList.append(thisPath)

537

dirList.append(thisPath)

538

539

if not(dirList):

539

if not(dirList):

540

return None, None, None, None, None, None

540

return None, None, None, None, None, None

541

542

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

542

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

543

544

doypath = dirList[-1]

544

doypath = dirList[-1]

545

foldercounter = int(doypath.split('_')[1]) if len(doypath.split('_'))>1 else 0

545

foldercounter = int(doypath.split('_')[1]) if len(doypath.split('_'))>1 else 0

546

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

546

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

547

548

549

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

549

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

550

551

if set == None:

551

if set == None:

552

filename = getlastFileFromPath(fullpath, ext)

552

filename = getlastFileFromPath(fullpath, ext)

553

else:

553

else:

554

filename = getFileFromSet(fullpath, ext, set)

554

filename = getFileFromSet(fullpath, ext, set)

555

556

if not(filename):

556

if not(filename):

557

return None, None, None, None, None, None

557

return None, None, None, None, None, None

558

559

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

559

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

560

561

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

561

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

562

return None, None, None, None, None, None

562

return None, None, None, None, None, None

563

564

year = int( filename[1:5] )

564

year = int( filename[1:5] )

565

doy = int( filename[5:8] )

565

doy = int( filename[5:8] )

566

set = int( filename[8:11] )

566

set = int( filename[8:11] )

567

568

return fullpath, foldercounter, filename, year, doy, set

568

return fullpath, foldercounter, filename, year, doy, set

569

570

def __setNextFileOffline(self):

570

def __setNextFileOffline(self):

571

572

idFile = self.fileIndex

572

idFile = self.fileIndex

573

574

while (True):

574

while (True):

575

idFile += 1

575

idFile += 1

576

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

576

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

577

self.flagNoMoreFiles = 1

577

self.flagNoMoreFiles = 1

578

print "No more Files"

578

print "No more Files"

579

return 0

579

return 0

580

581

filename = self.filenameList[idFile]

581

filename = self.filenameList[idFile]

582

583

if not(self.__verifyFile(filename)):

583

if not(self.__verifyFile(filename)):

584

continue

584

continue

585

586

fileSize = os.path.getsize(filename)

586

fileSize = os.path.getsize(filename)

587

fp = open(filename,'rb')

587

fp = open(filename,'rb')

588

break

588

break

589

590

self.flagIsNewFile = 1

590

self.flagIsNewFile = 1

591

self.fileIndex = idFile

591

self.fileIndex = idFile

592

self.filename = filename

592

self.filename = filename

593

self.fileSize = fileSize

593

self.fileSize = fileSize

594

self.fp = fp

594

self.fp = fp

595

596

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

596

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

597

598

return 1

598

return 1

599

600

def __setNextFileOnline(self):

600

def __setNextFileOnline(self):

601

"""

601

"""

602

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

602

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

603

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

603

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

604

siguientes.

604

siguientes.

605

606

Affected:

606

Affected:

607

self.flagIsNewFile

607

self.flagIsNewFile

608

self.filename

608

self.filename

609

self.fileSize

609

self.fileSize

610

self.fp

610

self.fp

611

self.set

611

self.set

612

self.flagNoMoreFiles

612

self.flagNoMoreFiles

613

614

Return:

614

Return:

615

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

615

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

616

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

616

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

617

618

Excepciones:

618

Excepciones:

619

Si un determinado file no puede ser abierto

619

Si un determinado file no puede ser abierto

620

"""

620

"""

621

nFiles = 0

621

nFiles = 0

622

fileOk_flag = False

622

fileOk_flag = False

623

firstTime_flag = True

623

firstTime_flag = True

624

625

self.set += 1

625

self.set += 1

626

627

if self.set > 999:

627

if self.set > 999:

628

self.set = 0

628

self.set = 0

629

self.foldercounter += 1

629

self.foldercounter += 1

630

631

#busca el 1er file disponible

631

#busca el 1er file disponible

632

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

632

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

633

if fullfilename:

633

if fullfilename:

634

if self.__verifyFile(fullfilename, False):

634

if self.__verifyFile(fullfilename, False):

635

fileOk_flag = True

635

fileOk_flag = True

636

637

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

637

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

638

if not(fileOk_flag):

638

if not(fileOk_flag):

639

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

639

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

640

641

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

641

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

642

tries = self.nTries

642

tries = self.nTries

643

else:

643

else:

644

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

644

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

645

646

for nTries in range( tries ):

646

for nTries in range( tries ):

647

if firstTime_flag:

647

if firstTime_flag:

648

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

648

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

649

time.sleep( self.delay )

649

time.sleep( self.delay )

650

else:

650

else:

651

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

651

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

652

653

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

653

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

654

if fullfilename:

654

if fullfilename:

655

if self.__verifyFile(fullfilename):

655

if self.__verifyFile(fullfilename):

656

fileOk_flag = True

656

fileOk_flag = True

657

break

657

break

658

659

if fileOk_flag:

659

if fileOk_flag:

660

break

660

break

661

662

firstTime_flag = False

662

firstTime_flag = False

663

664

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

664

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

665

self.set += 1

665

self.set += 1

666

667

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

667

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

668

self.set = 0

668

self.set = 0

669

self.doy += 1

669

self.doy += 1

670

self.foldercounter = 0

670

self.foldercounter = 0

671

672

if fileOk_flag:

672

if fileOk_flag:

673

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

673

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

674

self.filename = fullfilename

674

self.filename = fullfilename

675

self.flagIsNewFile = 1

675

self.flagIsNewFile = 1

676

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

676

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

677

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

677

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

678

self.flagNoMoreFiles = 0

678

self.flagNoMoreFiles = 0

679

print 'Setting the file: %s' % fullfilename

679

print 'Setting the file: %s' % fullfilename

680

else:

680

else:

681

self.fileSize = 0

681

self.fileSize = 0

682

self.filename = None

682

self.filename = None

683

self.flagIsNewFile = 0

683

self.flagIsNewFile = 0

684

self.fp = None

684

self.fp = None

685

self.flagNoMoreFiles = 1

685

self.flagNoMoreFiles = 1

686

print 'No more Files'

686

print 'No more Files'

687

688

return fileOk_flag

688

return fileOk_flag

689

690

691

def setNextFile(self):

691

def setNextFile(self):

692

if self.fp != None:

692

if self.fp != None:

693

self.fp.close()

693

self.fp.close()

694

695

if self.online:

695

if self.online:

696

newFile = self.__setNextFileOnline()

696

newFile = self.__setNextFileOnline()

697

else:

697

else:

698

newFile = self.__setNextFileOffline()

698

newFile = self.__setNextFileOffline()

699

700

if not(newFile):

700

if not(newFile):

701

return 0

701

return 0

702

703

self.__readFirstHeader()

703

self.__readFirstHeader()

704

self.nReadBlocks = 0

704

self.nReadBlocks = 0

705

return 1

705

return 1

706

707

def __waitNewBlock(self):

707

def __waitNewBlock(self):

708

"""

708

"""

709

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

709

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

710

711

Si el modo de lectura es OffLine siempre retorn 0

711

Si el modo de lectura es OffLine siempre retorn 0

712

"""

712

"""

713

if not self.online:

713

if not self.online:

714

return 0

714

return 0

715

716

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

716

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

717

return 0

717

return 0

718

719

currentPointer = self.fp.tell()

719

currentPointer = self.fp.tell()

720

721

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

721

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

722

723

for nTries in range( self.nTries ):

723

for nTries in range( self.nTries ):

724

725

self.fp.close()

725

self.fp.close()

726

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

726

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

727

self.fp.seek( currentPointer )

727

self.fp.seek( currentPointer )

728

729

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

729

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

730

currentSize = self.fileSize - currentPointer

730

currentSize = self.fileSize - currentPointer

731

732

if ( currentSize >= neededSize ):

732

if ( currentSize >= neededSize ):

733

self.__rdBasicHeader()

733

self.__rdBasicHeader()

734

return 1

734

return 1

735

736

if self.fileSize == self.fileSizeByHeader:

736

if self.fileSize == self.fileSizeByHeader:

737

# self.flagEoF = True

737

# self.flagEoF = True

738

return 0

738

return 0

739

740

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

740

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

741

time.sleep( self.delay )

741

time.sleep( self.delay )

742

743

744

return 0

744

return 0

745

746

def waitDataBlock(self,pointer_location):

746

def waitDataBlock(self,pointer_location):

747

748

currentPointer = pointer_location

748

currentPointer = pointer_location

749

750

neededSize = self.processingHeaderObj.blockSize #+ self.basicHeaderSize

750

neededSize = self.processingHeaderObj.blockSize #+ self.basicHeaderSize

751

752

for nTries in range( self.nTries ):

752

for nTries in range( self.nTries ):

753

self.fp.close()

753

self.fp.close()

754

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

754

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

755

self.fp.seek( currentPointer )

755

self.fp.seek( currentPointer )

756

757

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

757

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

758

currentSize = self.fileSize - currentPointer

758

currentSize = self.fileSize - currentPointer

759

760

if ( currentSize >= neededSize ):

760

if ( currentSize >= neededSize ):

761

return 1

761

return 1

762

763

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

763

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

764

time.sleep( self.delay )

764

time.sleep( self.delay )

765

766

return 0

766

return 0

767

768

769

def __jumpToLastBlock(self):

769

def __jumpToLastBlock(self):

770

771

if not(self.__isFirstTimeOnline):

771

if not(self.__isFirstTimeOnline):

772

return

772

return

773

774

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

774

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

775

blocksize = self.processingHeaderObj.blockSize

775

blocksize = self.processingHeaderObj.blockSize

776

777

#salta el primer bloque de datos

777

#salta el primer bloque de datos

778

if csize > self.processingHeaderObj.blockSize:

778

if csize > self.processingHeaderObj.blockSize:

779

self.fp.seek(self.fp.tell() + blocksize)

779

self.fp.seek(self.fp.tell() + blocksize)

780

else:

780

else:

781

return

781

return

782

783

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

783

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

784

neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize

784

neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize

785

while True:

785

while True:

786

787

if self.fp.tell()<self.fileSize:

787

if self.fp.tell()<self.fileSize:

788

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

788

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

789

else:

789

else:

790

self.fp.seek(self.fp.tell() - neededsize)

790

self.fp.seek(self.fp.tell() - neededsize)

791

break

791

break

792

793

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

793

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

794

# neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize

794

# neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize

795

# factor = int(csize/neededsize)

795

# factor = int(csize/neededsize)

796

# if factor > 0:

796

# if factor > 0:

797

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

797

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

798

799

self.flagIsNewFile = 0

799

self.flagIsNewFile = 0

800

self.__isFirstTimeOnline = 0

800

self.__isFirstTimeOnline = 0

801

802

803

def __setNewBlock(self):

803

def __setNewBlock(self):

804

805

if self.fp == None:

805

if self.fp == None:

806

return 0

806

return 0

807

808

if self.online:

808

if self.online:

809

self.__jumpToLastBlock()

809

self.__jumpToLastBlock()

810

811

if self.flagIsNewFile:

811

if self.flagIsNewFile:

812

return 1

812

return 1

813

814

self.lastUTTime = self.basicHeaderObj.utc

814

self.lastUTTime = self.basicHeaderObj.utc

815

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

815

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

816

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

816

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

817

818

if (currentSize >= neededSize):

818

if (currentSize >= neededSize):

819

self.__rdBasicHeader()

819

self.__rdBasicHeader()

820

return 1

820

return 1

821

822

if self.__waitNewBlock():

822

if self.__waitNewBlock():

823

return 1

823

return 1

824

825

if not(self.setNextFile()):

825

if not(self.setNextFile()):

826

return 0

826

return 0

827

828

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

828

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

829

830

self.flagTimeBlock = 0

830

self.flagTimeBlock = 0

831

832

if deltaTime > self.maxTimeStep:

832

if deltaTime > self.maxTimeStep:

833

self.flagTimeBlock = 1

833

self.flagTimeBlock = 1

834

835

return 1

835

return 1

836

837

838

def readNextBlock(self):

838

def readNextBlock(self):

839

if not(self.__setNewBlock()):

839

if not(self.__setNewBlock()):

840

return 0

840

return 0

841

842

if not(self.readBlock()):

842

if not(self.readBlock()):

843

return 0

843

return 0

844

845

return 1

845

return 1

846

847

def __rdProcessingHeader(self, fp=None):

847

def __rdProcessingHeader(self, fp=None):

848

if fp == None:

848

if fp == None:

849

fp = self.fp

849

fp = self.fp

850

851

self.processingHeaderObj.read(fp)

851

self.processingHeaderObj.read(fp)

852

853

def __rdRadarControllerHeader(self, fp=None):

853

def __rdRadarControllerHeader(self, fp=None):

854

if fp == None:

854

if fp == None:

855

fp = self.fp

855

fp = self.fp

856

857

self.radarControllerHeaderObj.read(fp)

857

self.radarControllerHeaderObj.read(fp)

858

859

def __rdSystemHeader(self, fp=None):

859

def __rdSystemHeader(self, fp=None):

860

if fp == None:

860

if fp == None:

861

fp = self.fp

861

fp = self.fp

862

863

self.systemHeaderObj.read(fp)

863

self.systemHeaderObj.read(fp)

864

865

def __rdBasicHeader(self, fp=None):

865

def __rdBasicHeader(self, fp=None):

866

if fp == None:

866

if fp == None:

867

fp = self.fp

867

fp = self.fp

868

869

self.basicHeaderObj.read(fp)

869

self.basicHeaderObj.read(fp)

870

871

872

def __readFirstHeader(self):

872

def __readFirstHeader(self):

873

self.__rdBasicHeader()

873

self.__rdBasicHeader()

874

self.__rdSystemHeader()

874

self.__rdSystemHeader()

875

self.__rdRadarControllerHeader()

875

self.__rdRadarControllerHeader()

876

self.__rdProcessingHeader()

876

self.__rdProcessingHeader()

877

878

self.firstHeaderSize = self.basicHeaderObj.size

878

self.firstHeaderSize = self.basicHeaderObj.size

879

880

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

880

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

881

if datatype == 0:

881

if datatype == 0:

882

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

882

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

883

elif datatype == 1:

883

elif datatype == 1:

884

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

884

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

885

elif datatype == 2:

885

elif datatype == 2:

886

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

886

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

887

elif datatype == 3:

887

elif datatype == 3:

888

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

888

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

889

elif datatype == 4:

889

elif datatype == 4:

890

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

890

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

891

elif datatype == 5:

891

elif datatype == 5:

892

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

892

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

893

else:

893

else:

894

raise ValueError, 'Data type was not defined'

894

raise ValueError, 'Data type was not defined'

895

896

self.dtype = datatype_str

896

self.dtype = datatype_str

897

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

897

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

898

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

898

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

899

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

899

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

900

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

900

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

901

self.getBlockDimension()

901

self.getBlockDimension()

902

903

904

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

904

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

905

msg = None

905

msg = None

906

try:

906

try:

907

fp = open(filename, 'rb')

907

fp = open(filename, 'rb')

908

currentPosition = fp.tell()

908

currentPosition = fp.tell()

909

except:

909

except:

910

if msgFlag:

910

if msgFlag:

911

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

911

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

912

return False

912

return False

913

914

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

914

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

915

916

if neededSize == 0:

916

if neededSize == 0:

917

basicHeaderObj = BasicHeader(LOCALTIME)

917

basicHeaderObj = BasicHeader(LOCALTIME)

918

systemHeaderObj = SystemHeader()

918

systemHeaderObj = SystemHeader()

919

radarControllerHeaderObj = RadarControllerHeader()

919

radarControllerHeaderObj = RadarControllerHeader()

920

processingHeaderObj = ProcessingHeader()

920

processingHeaderObj = ProcessingHeader()

921

922

try:

922

try:

923

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

923

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

924

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

924

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

925

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

925

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

926

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

926

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

927

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

927

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

928

929

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

929

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

930

931

except:

931

except:

932

if msgFlag:

932

if msgFlag:

933

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

933

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

934

935

fp.close()

935

fp.close()

936

return False

936

return False

937

else:

937

else:

938

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

938

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

939

940

fp.close()

940

fp.close()

941

fileSize = os.path.getsize(filename)

941

fileSize = os.path.getsize(filename)

942

currentSize = fileSize - currentPosition

942

currentSize = fileSize - currentPosition

943

if currentSize < neededSize:

943

if currentSize < neededSize:

944

if msgFlag and (msg != None):

944

if msgFlag and (msg != None):

945

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

945

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

946

return False

946

return False

947

948

return True

948

return True

949

950

def setup(self,

950

def setup(self,

951

path=None,

951

path=None,

952

startDate=None,

952

startDate=None,

953

endDate=None,

953

endDate=None,

954

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

954

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

955

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

955

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

956

set=None,

956

set=None,

957

expLabel = "",

957

expLabel = "",

958

ext = None,

958

ext = None,

959

online = False,

959

online = False,

960

delay = 60,

960

delay = 60,

961

walk = True):

961

walk = True):

962

963

if path == None:

963

if path == None:

964

raise ValueError, "The path is not valid"

964

raise ValueError, "The path is not valid"

965

966

if ext == None:

966

if ext == None:

967

ext = self.ext

967

ext = self.ext

968

969

if online:

969

if online:

970

print "Searching files in online mode..."

970

print "Searching files in online mode..."

971

972

for nTries in range( self.nTries ):

972

for nTries in range( self.nTries ):

973

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

973

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

974

975

if fullpath:

975

if fullpath:

976

break

976

break

977

978

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

978

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

979

time.sleep( self.delay )

979

time.sleep( self.delay )

980

981

if not(fullpath):

981

if not(fullpath):

982

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

982

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

983

return None

983

return None

984

985

self.year = year

985

self.year = year

986

self.doy = doy

986

self.doy = doy

987

self.set = set - 1

987

self.set = set - 1

988

self.path = path

988

self.path = path

989

self.foldercounter = foldercounter

989

self.foldercounter = foldercounter

990

last_set = None

990

last_set = None

991

992

else:

992

else:

993

print "Searching files in offline mode ..."

993

print "Searching files in offline mode ..."

994

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

994

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

995

startTime=startTime, endTime=endTime,

995

startTime=startTime, endTime=endTime,

996

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

996

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

997

walk=walk)

997

walk=walk)

998

999

if not(pathList):

999

if not(pathList):

1000

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

1000

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

1001

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

1001

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

1002

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

1002

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

1003

1004

sys.exit(-1)

1004

sys.exit(-1)

1005

1006

1007

self.fileIndex = -1

1007

self.fileIndex = -1

1008

self.pathList = pathList

1008

self.pathList = pathList

1009

self.filenameList = filenameList

1009

self.filenameList = filenameList

1010

file_name = os.path.basename(filenameList[-1])

1010

file_name = os.path.basename(filenameList[-1])

1011

basename, ext = os.path.splitext(file_name)

1011

basename, ext = os.path.splitext(file_name)

1012

last_set = int(basename[-3:])

1012

last_set = int(basename[-3:])

1013

1014

self.online = online

1014

self.online = online

1015

self.delay = delay

1015

self.delay = delay

1016

ext = ext.lower()

1016

ext = ext.lower()

1017

self.ext = ext

1017

self.ext = ext

1018

1019

if not(self.setNextFile()):

1019

if not(self.setNextFile()):

1020

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

1020

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

1021

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

1021

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

1022

elif startDate != None:

1022

elif startDate != None:

1023

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

1023

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

1024

else:

1024

else:

1025

print "No files"

1025

print "No files"

1026

1027

sys.exit(-1)

1027

sys.exit(-1)

1028

1029

# self.updateDataHeader()

1029

# self.updateDataHeader()

1030

if last_set != None:

1030

if last_set != None:

1031

self.dataOut.last_block = last_set * self.processingHeaderObj.dataBlocksPerFile + self.basicHeaderObj.dataBlock

1031

self.dataOut.last_block = last_set * self.processingHeaderObj.dataBlocksPerFile + self.basicHeaderObj.dataBlock

1032

return self.dataOut

1032

return self.dataOut

1033

1034

def getBasicHeader(self):

1034

def getBasicHeader(self):

1035

1036

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

1036

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

1037

1038

self.dataOut.flagTimeBlock = self.flagTimeBlock

1038

self.dataOut.flagTimeBlock = self.flagTimeBlock

1039

1040

self.dataOut.timeZone = self.basicHeaderObj.timeZone

1040

self.dataOut.timeZone = self.basicHeaderObj.timeZone

1041

1042

self.dataOut.dstFlag = self.basicHeaderObj.dstFlag

1042

self.dataOut.dstFlag = self.basicHeaderObj.dstFlag

1043

1044

self.dataOut.errorCount = self.basicHeaderObj.errorCount

1044

self.dataOut.errorCount = self.basicHeaderObj.errorCount

1045

1046

self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime

1046

self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime

1047

1048

def getFirstHeader(self):

1048

def getFirstHeader(self):

1049

1050

raise ValueError, "This method has not been implemented"

1050

raise ValueError, "This method has not been implemented"

1051

1052

def getData():

1052

def getData():

1053

1054

raise ValueError, "This method has not been implemented"

1054

raise ValueError, "This method has not been implemented"

1055

1056

def hasNotDataInBuffer():

1056

def hasNotDataInBuffer():

1057

1058

raise ValueError, "This method has not been implemented"

1058

raise ValueError, "This method has not been implemented"

1059

1060

def readBlock():

1060

def readBlock():

1061

1062

raise ValueError, "This method has not been implemented"

1062

raise ValueError, "This method has not been implemented"

1063

1064

def isEndProcess(self):

1064

def isEndProcess(self):

1065

1066

return self.flagNoMoreFiles

1066

return self.flagNoMoreFiles

1067

1068

def printReadBlocks(self):

1068

def printReadBlocks(self):

1069

1070

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

1070

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

1071

1072

def printTotalBlocks(self):

1072

def printTotalBlocks(self):

1073

1074

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

1074

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

1075

1076

def printNumberOfBlock(self):

1076

def printNumberOfBlock(self):

1077

1078

if self.flagIsNewBlock:

1078

if self.flagIsNewBlock:

1079

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

1079

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

1080

self.dataOut.blocknow = self.basicHeaderObj.dataBlock

1080

self.dataOut.blocknow = self.basicHeaderObj.dataBlock

1081

def printInfo(self):

1081

def printInfo(self):

1082

1083

if self.__printInfo == False:

1083

if self.__printInfo == False:

1084

return

1084

return

1085

1086

self.basicHeaderObj.printInfo()

1086

self.basicHeaderObj.printInfo()

1087

self.systemHeaderObj.printInfo()

1087

self.systemHeaderObj.printInfo()

1088

self.radarControllerHeaderObj.printInfo()

1088

self.radarControllerHeaderObj.printInfo()

1089

self.processingHeaderObj.printInfo()

1089

self.processingHeaderObj.printInfo()

1090

1091

self.__printInfo = False

1091

self.__printInfo = False

1092

1093

1094

def run(self, **kwargs):

1094

def run(self, **kwargs):

1095

1096

if not(self.isConfig):

1096

if not(self.isConfig):

1097

1098

# self.dataOut = dataOut

1098

# self.dataOut = dataOut

1099

self.setup(**kwargs)

1099

self.setup(**kwargs)

1100

self.isConfig = True

1100

self.isConfig = True

1101

1102

self.getData()

1102

self.getData()

1103

1104

class JRODataWriter(JRODataIO, Operation):

1104

class JRODataWriter(JRODataIO, Operation):

1105

1106

"""

1106

"""

1107

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

1107

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

1108

de los datos siempre se realiza por bloques.

1108

de los datos siempre se realiza por bloques.

1109

"""

1109

"""

1110

1111

blockIndex = 0

1111

blockIndex = 0

1112

1113

path = None

1113

path = None

1114

1115

setFile = None

1115

setFile = None

1116

1117

profilesPerBlock = None

1117

profilesPerBlock = None

1118

1119

blocksPerFile = None

1119

blocksPerFile = None

1120

1121

nWriteBlocks = 0

1121

nWriteBlocks = 0

1122

1123

def __init__(self, dataOut=None):

1123

def __init__(self, dataOut=None):

1124

raise ValueError, "Not implemented"

1124

raise ValueError, "Not implemented"

1125

1126

1127

def hasAllDataInBuffer(self):

1127

def hasAllDataInBuffer(self):

1128

raise ValueError, "Not implemented"

1128

raise ValueError, "Not implemented"

1129

1130

1131

def setBlockDimension(self):

1131

def setBlockDimension(self):

1132

raise ValueError, "Not implemented"

1132

raise ValueError, "Not implemented"

1133

1134

1135

def writeBlock(self):

1135

def writeBlock(self):

1136

raise ValueError, "No implemented"

1136

raise ValueError, "No implemented"

1137

1138

1139

def putData(self):

1139

def putData(self):

1140

raise ValueError, "No implemented"

1140

raise ValueError, "No implemented"

1141

1142

1143

def setBasicHeader(self):

1143

def setBasicHeader(self):

1144

1145

self.basicHeaderObj.size = self.basicHeaderSize #bytes

1145

self.basicHeaderObj.size = self.basicHeaderSize #bytes

1146

self.basicHeaderObj.version = self.versionFile

1146

self.basicHeaderObj.version = self.versionFile

1147

self.basicHeaderObj.dataBlock = self.nTotalBlocks

1147

self.basicHeaderObj.dataBlock = self.nTotalBlocks

1148

1149

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

1149

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

1150

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

1150

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

1151

1152

self.basicHeaderObj.utc = utc

1152

self.basicHeaderObj.utc = utc

1153

self.basicHeaderObj.miliSecond = milisecond

1153

self.basicHeaderObj.miliSecond = milisecond

1154

self.basicHeaderObj.timeZone = self.dataOut.timeZone

1154

self.basicHeaderObj.timeZone = self.dataOut.timeZone

1155

self.basicHeaderObj.dstFlag = self.dataOut.dstFlag

1155

self.basicHeaderObj.dstFlag = self.dataOut.dstFlag

1156

self.basicHeaderObj.errorCount = self.dataOut.errorCount

1156

self.basicHeaderObj.errorCount = self.dataOut.errorCount

1157

1158

def setFirstHeader(self):

1158

def setFirstHeader(self):

1159

"""

1159

"""

1160

Obtiene una copia del First Header

1160

Obtiene una copia del First Header

1161

1162

Affected:

1162

Affected:

1163

1164

self.basicHeaderObj

1164

self.basicHeaderObj

1165

self.systemHeaderObj

1165

self.systemHeaderObj

1166

self.radarControllerHeaderObj

1166

self.radarControllerHeaderObj

1167

self.processingHeaderObj self.

1167

self.processingHeaderObj self.

1168

1169

Return:

1169

Return:

1170

None

1170

None

1171

"""

1171

"""

1172

1173

raise ValueError, "No implemented"

1173

raise ValueError, "No implemented"

1174

1175

def __writeFirstHeader(self):

1175

def __writeFirstHeader(self):

1176

"""

1176

"""

1177

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

1177

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

1178

1179

Affected:

1179

Affected:

1180

__dataType

1180

__dataType

1181

1182

Return:

1182

Return:

1183

None

1183

None

1184

"""

1184

"""

1185

1186

# CALCULAR PARAMETROS

1186

# CALCULAR PARAMETROS

1187

1188

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

1188

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

1189

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

1189

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

1190

1191

self.basicHeaderObj.write(self.fp)

1191

self.basicHeaderObj.write(self.fp)

1192

self.systemHeaderObj.write(self.fp)

1192

self.systemHeaderObj.write(self.fp)

1193

self.radarControllerHeaderObj.write(self.fp)

1193

self.radarControllerHeaderObj.write(self.fp)

1194

self.processingHeaderObj.write(self.fp)

1194

self.processingHeaderObj.write(self.fp)

1195

1196

self.dtype = self.dataOut.dtype

1196

self.dtype = self.dataOut.dtype

1197

1198

def __setNewBlock(self):

1198

def __setNewBlock(self):

1199

"""

1199

"""

1200

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

1200

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

1201

1202

Return:

1202

Return:

1203

0 : si no pudo escribir nada

1203

0 : si no pudo escribir nada

1204

1 : Si escribio el Basic el First Header

1204

1 : Si escribio el Basic el First Header

1205

"""

1205

"""

1206

if self.fp == None:

1206

if self.fp == None:

1207

self.setNextFile()

1207

self.setNextFile()

1208

1209

if self.flagIsNewFile:

1209

if self.flagIsNewFile:

1210

return 1

1210

return 1

1211

1212

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

1212

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

1213

self.basicHeaderObj.write(self.fp)

1213

self.basicHeaderObj.write(self.fp)

1214

return 1

1214

return 1

1215

1216

if not( self.setNextFile() ):

1216

if not( self.setNextFile() ):

1217

return 0

1217

return 0

1218

1219

return 1

1219

return 1

1220

1221

1222

def writeNextBlock(self):

1222

def writeNextBlock(self):

1223

"""

1223

"""

1224

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

1224

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

1225

1226

Return:

1226

Return:

1227

0 : Si no hizo pudo escribir el bloque de datos

1227

0 : Si no hizo pudo escribir el bloque de datos

1228

1 : Si no pudo escribir el bloque de datos

1228

1 : Si no pudo escribir el bloque de datos

1229

"""

1229

"""

1230

if not( self.__setNewBlock() ):

1230

if not( self.__setNewBlock() ):

1231

return 0

1231

return 0

1232

1233

self.writeBlock()

1233

self.writeBlock()

1234

1235

return 1

1235

return 1

1236

1237

def setNextFile(self):

1237

def setNextFile(self):

1238

"""

1238

"""

1239

Determina el siguiente file que sera escrito

1239

Determina el siguiente file que sera escrito

1240

1241

Affected:

1241

Affected:

1242

self.filename

1242

self.filename

1243

self.subfolder

1243

self.subfolder

1244

self.fp

1244

self.fp

1245

self.setFile

1245

self.setFile

1246

self.flagIsNewFile

1246

self.flagIsNewFile

1247

1248

Return:

1248

Return:

1249

0 : Si el archivo no puede ser escrito

1249

0 : Si el archivo no puede ser escrito

1250

1 : Si el archivo esta listo para ser escrito

1250

1 : Si el archivo esta listo para ser escrito

1251

"""

1251

"""

1252

ext = self.ext

1252

ext = self.ext

1253

path = self.path

1253

path = self.path

1254

1255

if self.fp != None:

1255

if self.fp != None:

1256

self.fp.close()

1256

self.fp.close()

1257

1258

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

1258

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

1259

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

1259

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

1260

1261

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

1261

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

1262

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

1262

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

1263

os.mkdir(fullpath)

1263

os.mkdir(fullpath)

1264

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

1264

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

1265

else:

1265

else:

1266

filesList = os.listdir( fullpath )

1266

filesList = os.listdir( fullpath )

1267

if len( filesList ) > 0:

1267

if len( filesList ) > 0:

1268

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

1268

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

1269

filen = filesList[-1]

1269

filen = filesList[-1]

1270

# el filename debera tener el siguiente formato

1270

# el filename debera tener el siguiente formato

1271

# 0 1234 567 89A BCDE (hex)

1271

# 0 1234 567 89A BCDE (hex)

1272

# x YYYY DDD SSS .ext

1272

# x YYYY DDD SSS .ext

1273

if isNumber( filen[8:11] ):

1273

if isNumber( filen[8:11] ):

1274

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

1274

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

1275

else:

1275

else:

1276

self.setFile = -1

1276

self.setFile = -1

1277

else:

1277

else:

1278

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

1278

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

1279

1280

setFile = self.setFile

1280

setFile = self.setFile

1281

setFile += 1

1281

setFile += 1

1282

1283

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

1283

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

1284

timeTuple.tm_year,

1284

timeTuple.tm_year,

1285

timeTuple.tm_yday,

1285

timeTuple.tm_yday,

1286

setFile,

1286

setFile,

1287

ext )

1287

ext )

1288

1289

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

1289

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

1290

1291

fp = open( filename,'wb' )

1291

fp = open( filename,'wb' )

1292

1293

self.blockIndex = 0

1293

self.blockIndex = 0

1294

1295

#guardando atributos

1295

#guardando atributos

1296

self.filename = filename

1296

self.filename = filename

1297

self.subfolder = subfolder

1297

self.subfolder = subfolder

1298

self.fp = fp

1298

self.fp = fp

1299

self.setFile = setFile

1299

self.setFile = setFile

1300

self.flagIsNewFile = 1

1300

self.flagIsNewFile = 1

1301

1302

self.setFirstHeader()

1302

self.setFirstHeader()

1303

1304

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

1304

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

1305

1306

self.__writeFirstHeader()

1306

self.__writeFirstHeader()

1307

1308

return 1

1308

return 1

1309

1310

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

1310

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

1311

"""

1311

"""

1312

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

1312

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

1313

1314

Inputs:

1314

Inputs:

1315

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

1315

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

1316

format : formato en el cual sera salvado un file

1316

format : formato en el cual sera salvado un file

1317

set : el setebo del file

1317

set : el setebo del file

1318

1319

Return:

1319

Return:

1320

0 : Si no realizo un buen seteo

1320

0 : Si no realizo un buen seteo

1321

1 : Si realizo un buen seteo

1321

1 : Si realizo un buen seteo

1322

"""

1322

"""

1323

1324

if ext == None:

1324

if ext == None:

1325

ext = self.ext

1325

ext = self.ext

1326

1327

ext = ext.lower()

1327

ext = ext.lower()

1328

1329

self.ext = ext

1329

self.ext = ext

1330

1331

self.path = path

1331

self.path = path

1332

1333

self.setFile = set - 1

1333

self.setFile = set - 1

1334

1335

self.blocksPerFile = blocksPerFile

1335

self.blocksPerFile = blocksPerFile

1336

1337

self.profilesPerBlock = profilesPerBlock

1337

self.profilesPerBlock = profilesPerBlock

1338

1339

self.dataOut = dataOut

1339

self.dataOut = dataOut

1340

1341

if not(self.setNextFile()):

1341

if not(self.setNextFile()):

1342

print "There isn't a next file"

1342

print "There isn't a next file"

1343

return 0

1343

return 0

1344

1345

self.setBlockDimension()

1345

self.setBlockDimension()

1346

1347

return 1

1347

return 1

1348

1349

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

1349

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

1350

1351

if not(self.isConfig):

1351

if not(self.isConfig):

1352

1353

self.setup(dataOut, **kwargs)

1353

self.setup(dataOut, **kwargs)

1354

self.isConfig = True

1354

self.isConfig = True

1355

1356

self.putData()

1356

self.putData()

1357

1358

class VoltageReader(JRODataReader):

1358

class VoltageReader(JRODataReader):

1359

"""

1359

"""

1360

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

1360

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

1361

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

1361

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

1362

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

1362

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

1363

1364

perfiles * alturas * canales

1364

perfiles * alturas * canales

1365

1366

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

1366

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

1367

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

1367

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

1368

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

1368

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

1369

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

1369

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

1370

1371

Example:

1371

Example:

1372

1373

dpath = "/home/myuser/data"

1373

dpath = "/home/myuser/data"

1374

1375

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

1375

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

1376

1377

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

1377

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

1378

1379

readerObj = VoltageReader()

1379

readerObj = VoltageReader()

1380

1381

readerObj.setup(dpath, startTime, endTime)

1381

readerObj.setup(dpath, startTime, endTime)

1382

1383

while(True):

1383

while(True):

1384

1385

#to get one profile

1385

#to get one profile

1386

profile = readerObj.getData()

1386

profile = readerObj.getData()

1387

1388

#print the profile

1388

#print the profile

1389

print profile

1389

print profile

1390

1391

#If you want to see all datablock

1391

#If you want to see all datablock

1392

print readerObj.datablock

1392

print readerObj.datablock

1393

1394

if readerObj.flagNoMoreFiles:

1394

if readerObj.flagNoMoreFiles:

1395

break

1395

break

1396

1397

"""

1397

"""

1398

1399

ext = ".r"

1399

ext = ".r"

1400

1401

optchar = "D"

1401

optchar = "D"

1402

dataOut = None

1402

dataOut = None

1403

1404

1405

def __init__(self):

1405

def __init__(self):

1406

"""

1406

"""

1407

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

1407

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

1408

1409

Input:

1409

Input:

1410

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

1410

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

1411

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

1411

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

1412

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

1412

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

1413

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

1413

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

1414

bloque de datos.

1414

bloque de datos.

1415

Si este parametro no es pasado se creara uno internamente.

1415

Si este parametro no es pasado se creara uno internamente.

1416

1417

Variables afectadas:

1417

Variables afectadas:

1418

self.dataOut

1418

self.dataOut

1419

1420

Return:

1420

Return:

1421

None

1421

None

1422

"""

1422

"""

1423

1424

self.isConfig = False

1424

self.isConfig = False

1425

1426

self.datablock = None

1426

self.datablock = None

1427

1428

self.utc = 0

1428

self.utc = 0

1429

1430

self.ext = ".r"

1430

self.ext = ".r"

1431

1432

self.optchar = "D"

1432

self.optchar = "D"

1433

1434

self.basicHeaderObj = BasicHeader(LOCALTIME)

1434

self.basicHeaderObj = BasicHeader(LOCALTIME)

1435

1436

self.systemHeaderObj = SystemHeader()

1436

self.systemHeaderObj = SystemHeader()

1437

1438

self.radarControllerHeaderObj = RadarControllerHeader()

1438

self.radarControllerHeaderObj = RadarControllerHeader()

1439

1440

self.processingHeaderObj = ProcessingHeader()

1440

self.processingHeaderObj = ProcessingHeader()

1441

1442

self.online = 0

1442

self.online = 0

1443

1444

self.fp = None

1444

self.fp = None

1445

1446

self.idFile = None

1446

self.idFile = None

1447

1448

self.dtype = None

1448

self.dtype = None

1449

1450

self.fileSizeByHeader = None

1450

self.fileSizeByHeader = None

1451

1452

self.filenameList = []

1452

self.filenameList = []

1453

1454

self.filename = None

1454

self.filename = None

1455

1456

self.fileSize = None

1456

self.fileSize = None

1457

1458

self.firstHeaderSize = 0

1458

self.firstHeaderSize = 0

1459

1460

self.basicHeaderSize = 24

1460

self.basicHeaderSize = 24

1461

1462

self.pathList = []

1462

self.pathList = []

1463

1464

self.filenameList = []

1464

self.filenameList = []

1465

1466

self.lastUTTime = 0

1466

self.lastUTTime = 0

1467

1468

self.maxTimeStep = 30

1468

self.maxTimeStep = 30

1469

1470

self.flagNoMoreFiles = 0

1470

self.flagNoMoreFiles = 0

1471

1472

self.set = 0

1472

self.set = 0

1473

1474

self.path = None

1474

self.path = None

1475

1476

self.profileIndex = 2**32-1

1476

self.profileIndex = 2**32-1

1477

1478

self.delay = 3 #seconds

1478

self.delay = 3 #seconds

1479

1480

self.nTries = 3 #quantity tries

1480

self.nTries = 3 #quantity tries

1481

1482

self.nFiles = 3 #number of files for searching

1482

self.nFiles = 3 #number of files for searching

1483

1484

self.nReadBlocks = 0

1484

self.nReadBlocks = 0

1485

1486

self.flagIsNewFile = 1

1486

self.flagIsNewFile = 1

1487

1488

self.__isFirstTimeOnline = 1

1488

self.__isFirstTimeOnline = 1

1489

1490

self.ippSeconds = 0

1490

self.ippSeconds = 0

1491

1492

self.flagTimeBlock = 0

1492

self.flagTimeBlock = 0

1493

1494

self.flagIsNewBlock = 0

1494

self.flagIsNewBlock = 0

1495

1496

self.nTotalBlocks = 0

1496

self.nTotalBlocks = 0

1497

1498

self.blocksize = 0

1498

self.blocksize = 0

1499

1500

self.dataOut = self.createObjByDefault()

1500

self.dataOut = self.createObjByDefault()

1501

1502

def createObjByDefault(self):

1502

def createObjByDefault(self):

1503

1504

dataObj = Voltage()

1504

dataObj = Voltage()

1505

1506

return dataObj

1506

return dataObj

1507

1508

def __hasNotDataInBuffer(self):

1508

def __hasNotDataInBuffer(self):

1509

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

1509

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

1510

return 1

1510

return 1

1511

return 0

1511

return 0

1512

1513

1514

def getBlockDimension(self):

1514

def getBlockDimension(self):

1515

"""

1515

"""

1516

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

1516

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

1517

1518

Affected:

1518

Affected:

1519

self.blocksize

1519

self.blocksize

1520

1521

Return:

1521

Return:

1522

None

1522

None

1523

"""

1523

"""

1524

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

1524

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

1525

self.blocksize = pts2read

1525

self.blocksize = pts2read

1526

1527

1528

def readBlock(self):

1528

def readBlock(self):

1529

"""

1529

"""

1530

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

1530

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

1531

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

1531

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

1532

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

1532

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

1533

es seteado a 0

1533

es seteado a 0

1534

1535

Inputs:

1535

Inputs:

1536

None

1536

None

1537

1538

Return:

1538

Return:

1539

None

1539

None

1540

1541

Affected:

1541

Affected:

1542

self.profileIndex

1542

self.profileIndex

1543

self.datablock

1543

self.datablock

1544

self.flagIsNewFile

1544

self.flagIsNewFile

1545

self.flagIsNewBlock

1545

self.flagIsNewBlock

1546

self.nTotalBlocks

1546

self.nTotalBlocks

1547

1548

Exceptions:

1548

Exceptions:

1549

Si un bloque leido no es un bloque valido

1549

Si un bloque leido no es un bloque valido

1550

"""

1550

"""

1551

current_pointer_location = self.fp.tell()

1551

current_pointer_location = self.fp.tell()

1552

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

1552

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

1553

1554

try:

1554

try:

1555

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

1555

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

1556

except:

1556

except:

1557

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

1557

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

1558

1559

if self.waitDataBlock(pointer_location=current_pointer_location):

1559

if self.waitDataBlock(pointer_location=current_pointer_location):

1560

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

1560

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

1561

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

1561

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

1562

# return 0

1562

# return 0

1563

1564

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

1564

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

1565

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

1565

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

1566

1567

self.profileIndex = 0

1567

self.profileIndex = 0

1568

1569

self.flagIsNewFile = 0

1569

self.flagIsNewFile = 0

1570

self.flagIsNewBlock = 1

1570

self.flagIsNewBlock = 1

1571

1572

self.nTotalBlocks += 1

1572

self.nTotalBlocks += 1

1573

self.nReadBlocks += 1

1573

self.nReadBlocks += 1

1574

1575

return 1

1575

return 1

1576

1577

def getFirstHeader(self):

1577

def getFirstHeader(self):

1578

1579

self.dataOut.dtype = self.dtype

1579

self.dataOut.dtype = self.dtype

1580

1581

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1581

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1582

1583

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

1583

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

1584

1585

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

1585

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

1586

1587

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

1587

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

1588

1589

self.dataOut.ippSeconds = self.ippSeconds

1589

self.dataOut.ippSeconds = self.ippSeconds

1590

1591

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

1591

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

1592

1593

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1593

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1594

1595

self.dataOut.flagShiftFFT = False

1595

self.dataOut.flagShiftFFT = False

1596

1597

if self.radarControllerHeaderObj.code != None:

1597

if self.radarControllerHeaderObj.code != None:

1598

1599

self.dataOut.nCode = self.radarControllerHeaderObj.nCode

1599

self.dataOut.nCode = self.radarControllerHeaderObj.nCode

1600

1601

self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud

1601

self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud

1602

1603

self.dataOut.code = self.radarControllerHeaderObj.code

1603

self.dataOut.code = self.radarControllerHeaderObj.code

1604

1605

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

1605

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

1606

1607

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

1607

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

1608

1609

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

1609

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

1610

1611

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

1611

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

1612

1613

self.dataOut.flagShiftFFT = False

1613

self.dataOut.flagShiftFFT = False

1614

1615

def getData(self):

1615

def getData(self):

1616

"""

1616

"""

1617

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

1617

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

1618

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

1618

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

1619

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

1619

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

1620

1621

Ademas incrementa el contador del buffer en 1.

1621

Ademas incrementa el contador del buffer en 1.

1622

1623

Return:

1623

Return:

1624

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

1624

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

1625

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

1625

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

1626

1627

Variables afectadas:

1627

Variables afectadas:

1628

self.dataOut

1628

self.dataOut

1629

self.profileIndex

1629

self.profileIndex

1630

1631

Affected:

1631

Affected:

1632

self.dataOut

1632

self.dataOut

1633

self.profileIndex

1633

self.profileIndex

1634

self.flagTimeBlock

1634

self.flagTimeBlock

1635

self.flagIsNewBlock

1635

self.flagIsNewBlock

1636

"""

1636

"""

1637

1638

if self.flagNoMoreFiles:

1638

if self.flagNoMoreFiles:

1639

self.dataOut.flagNoData = True

1639

self.dataOut.flagNoData = True

1640

print 'Process finished'

1640

print 'Process finished'

1641

return 0

1641

return 0

1642

1643

self.flagTimeBlock = 0

1643

self.flagTimeBlock = 0

1644

self.flagIsNewBlock = 0

1644

self.flagIsNewBlock = 0

1645

1646

if self.__hasNotDataInBuffer():

1646

if self.__hasNotDataInBuffer():

1647

1648

if not( self.readNextBlock() ):

1648

if not( self.readNextBlock() ):

1649

return 0

1649

return 0

1650

1651

self.getFirstHeader()

1651

self.getFirstHeader()

1652

1653

if self.datablock == None:

1653

if self.datablock == None:

1654

self.dataOut.flagNoData = True

1654

self.dataOut.flagNoData = True

1655

return 0

1655

return 0

1656

1657

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

1657

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

1658

1659

self.dataOut.flagNoData = False

1659

self.dataOut.flagNoData = False

1660

1661

self.getBasicHeader()

1661

self.getBasicHeader()

1662

1663

self.profileIndex += 1

1663

self.profileIndex += 1

1664

1665

self.dataOut.realtime = self.online

1665

self.dataOut.realtime = self.online

1666

1667

return self.dataOut.data

1667

return self.dataOut.data

1668

1669

1670

class VoltageWriter(JRODataWriter):

1670

class VoltageWriter(JRODataWriter):

1671

"""

1671

"""

1672

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

1672

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

1673

de los datos siempre se realiza por bloques.

1673

de los datos siempre se realiza por bloques.

1674

"""

1674

"""

1675

1676

ext = ".r"

1676

ext = ".r"

1677

1678

optchar = "D"

1678

optchar = "D"

1679

1680

shapeBuffer = None

1680

shapeBuffer = None

1681

1682

1683

def __init__(self):

1683

def __init__(self):

1684

"""

1684

"""

1685

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

1685

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

1686

1687

Affected:

1687

Affected:

1688

self.dataOut

1688

self.dataOut

1689

1690

Return: None

1690

Return: None

1691

"""

1691

"""

1692

1693

self.nTotalBlocks = 0

1693

self.nTotalBlocks = 0

1694

1695

self.profileIndex = 0

1695

self.profileIndex = 0

1696

1697

self.isConfig = False

1697

self.isConfig = False

1698

1699

self.fp = None

1699

self.fp = None

1700

1701

self.flagIsNewFile = 1

1701

self.flagIsNewFile = 1

1702

1703

self.nTotalBlocks = 0

1703

self.nTotalBlocks = 0

1704

1705

self.flagIsNewBlock = 0

1705

self.flagIsNewBlock = 0

1706

1707

self.setFile = None

1707

self.setFile = None

1708

1709

self.dtype = None

1709

self.dtype = None

1710

1711

self.path = None

1711

self.path = None

1712

1713

self.filename = None

1713

self.filename = None

1714

1715

self.basicHeaderObj = BasicHeader(LOCALTIME)

1715

self.basicHeaderObj = BasicHeader(LOCALTIME)

1716

1717

self.systemHeaderObj = SystemHeader()

1717

self.systemHeaderObj = SystemHeader()

1718

1719

self.radarControllerHeaderObj = RadarControllerHeader()

1719

self.radarControllerHeaderObj = RadarControllerHeader()

1720

1721

self.processingHeaderObj = ProcessingHeader()

1721

self.processingHeaderObj = ProcessingHeader()

1722

1723

def hasAllDataInBuffer(self):

1723

def hasAllDataInBuffer(self):

1724

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

1724

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

1725

return 1

1725

return 1

1726

return 0

1726

return 0

1727

1728

1729

def setBlockDimension(self):

1729

def setBlockDimension(self):

1730

"""

1730

"""

1731

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

1731

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

1732

1733

Affected:

1733

Affected:

1734

self.shape_spc_Buffer

1734

self.shape_spc_Buffer

1735

self.shape_cspc_Buffer

1735

self.shape_cspc_Buffer

1736

self.shape_dc_Buffer

1736

self.shape_dc_Buffer

1737

1738

Return: None

1738

Return: None

1739

"""

1739

"""

1740

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1740

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1741

self.processingHeaderObj.nHeights,

1741

self.processingHeaderObj.nHeights,

1742

self.systemHeaderObj.nChannels)

1742

self.systemHeaderObj.nChannels)

1743

1744

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

1744

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

1745

self.processingHeaderObj.profilesPerBlock,

1745

self.processingHeaderObj.profilesPerBlock,

1746

self.processingHeaderObj.nHeights),

1746

self.processingHeaderObj.nHeights),

1747

dtype=numpy.dtype('complex64'))

1747

dtype=numpy.dtype('complex64'))

1748

1749

1750

def writeBlock(self):

1750

def writeBlock(self):

1751

"""

1751

"""

1752

Escribe el buffer en el file designado

1752

Escribe el buffer en el file designado

1753

1754

Affected:

1754

Affected:

1755

self.profileIndex

1755

self.profileIndex

1756

self.flagIsNewFile

1756

self.flagIsNewFile

1757

self.flagIsNewBlock

1757

self.flagIsNewBlock

1758

self.nTotalBlocks

1758

self.nTotalBlocks

1759

self.blockIndex

1759

self.blockIndex

1760

1761

Return: None

1761

Return: None

1762

"""

1762

"""

1763

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

1763

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

1764

1765

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

1765

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

1766

1767

data['real'] = junk.real

1767

data['real'] = junk.real

1768

data['imag'] = junk.imag

1768

data['imag'] = junk.imag

1769

1770

data = data.reshape( (-1) )

1770

data = data.reshape( (-1) )

1771

1772

data.tofile( self.fp )

1772

data.tofile( self.fp )

1773

1774

self.datablock.fill(0)

1774

self.datablock.fill(0)

1775

1776

self.profileIndex = 0

1776

self.profileIndex = 0

1777

self.flagIsNewFile = 0

1777

self.flagIsNewFile = 0

1778

self.flagIsNewBlock = 1

1778

self.flagIsNewBlock = 1

1779

1780

self.blockIndex += 1

1780

self.blockIndex += 1

1781

self.nTotalBlocks += 1

1781

self.nTotalBlocks += 1

1782

1783

def putData(self):

1783

def putData(self):

1784

"""

1784

"""

1785

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

1785

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

1786

1787

Affected:

1787

Affected:

1788

self.flagIsNewBlock

1788

self.flagIsNewBlock

1789

self.profileIndex

1789

self.profileIndex

1790

1791

Return:

1791

Return:

1792

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

1792

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

1793

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

1793

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

1794

"""

1794

"""

1795

if self.dataOut.flagNoData:

1795

if self.dataOut.flagNoData:

1796

return 0

1796

return 0

1797

1798

self.flagIsNewBlock = 0

1798

self.flagIsNewBlock = 0

1799

1800

if self.dataOut.flagTimeBlock:

1800

if self.dataOut.flagTimeBlock:

1801

1802

self.datablock.fill(0)

1802

self.datablock.fill(0)

1803

self.profileIndex = 0

1803

self.profileIndex = 0

1804

self.setNextFile()

1804

self.setNextFile()

1805

1806

if self.profileIndex == 0:

1806

if self.profileIndex == 0:

1807

self.setBasicHeader()

1807

self.setBasicHeader()

1808

1809

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

1809

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

1810

1811

self.profileIndex += 1

1811

self.profileIndex += 1

1812

1813

if self.hasAllDataInBuffer():

1813

if self.hasAllDataInBuffer():

1814

#if self.flagIsNewFile:

1814

#if self.flagIsNewFile:

1815

self.writeNextBlock()

1815

self.writeNextBlock()

1816

# self.setFirstHeader()

1816

# self.setFirstHeader()

1817

1818

return 1

1818

return 1

1819

1820

def __getProcessFlags(self):

1820

def __getProcessFlags(self):

1821

1822

processFlags = 0

1822

processFlags = 0

1823

1824

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

1824

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

1825

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

1825

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

1826

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

1826

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

1827

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

1827

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

1828

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

1828

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

1829

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

1829

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

1830

1831

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

1831

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

1832

1833

1834

1835

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1835

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1836

PROCFLAG.DATATYPE_SHORT,

1836

PROCFLAG.DATATYPE_SHORT,

1837

PROCFLAG.DATATYPE_LONG,

1837

PROCFLAG.DATATYPE_LONG,

1838

PROCFLAG.DATATYPE_INT64,

1838

PROCFLAG.DATATYPE_INT64,

1839

PROCFLAG.DATATYPE_FLOAT,

1839

PROCFLAG.DATATYPE_FLOAT,

1840

PROCFLAG.DATATYPE_DOUBLE]

1840

PROCFLAG.DATATYPE_DOUBLE]

1841

1842

1843

for index in range(len(dtypeList)):

1843

for index in range(len(dtypeList)):

1844

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

1844

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

1845

dtypeValue = datatypeValueList[index]

1845

dtypeValue = datatypeValueList[index]

1846

break

1846

break

1847

1848

processFlags += dtypeValue

1848

processFlags += dtypeValue

1849

1850

if self.dataOut.flagDecodeData:

1850

if self.dataOut.flagDecodeData:

1851

processFlags += PROCFLAG.DECODE_DATA

1851

processFlags += PROCFLAG.DECODE_DATA

1852

1853

if self.dataOut.flagDeflipData:

1853

if self.dataOut.flagDeflipData:

1854

processFlags += PROCFLAG.DEFLIP_DATA

1854

processFlags += PROCFLAG.DEFLIP_DATA

1855

1856

if self.dataOut.code != None:

1856

if self.dataOut.code != None:

1857

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1857

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1858

1859

if self.dataOut.nCohInt > 1:

1859

if self.dataOut.nCohInt > 1:

1860

processFlags += PROCFLAG.COHERENT_INTEGRATION

1860

processFlags += PROCFLAG.COHERENT_INTEGRATION

1861

1862

return processFlags

1862

return processFlags

1863

1864

1865

def __getBlockSize(self):

1865

def __getBlockSize(self):

1866

'''

1866

'''

1867

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

1867

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

1868

'''

1868

'''

1869

1870

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

1870

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

1871

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

1871

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

1872

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

1872

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

1873

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

1873

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

1874

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

1874

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

1875

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

1875

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

1876

1877

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

1877

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

1878

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

1878

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

1879

for index in range(len(dtypeList)):

1879

for index in range(len(dtypeList)):

1880

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

1880

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

1881

datatypeValue = datatypeValueList[index]

1881

datatypeValue = datatypeValueList[index]

1882

break

1882

break

1883

1884

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

1884

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

1885

1886

return blocksize

1886

return blocksize

1887

1888

def setFirstHeader(self):

1888

def setFirstHeader(self):

1889

1890

"""

1890

"""

1891

Obtiene una copia del First Header

1891

Obtiene una copia del First Header

1892

1893

Affected:

1893

Affected:

1894

self.systemHeaderObj

1894

self.systemHeaderObj

1895

self.radarControllerHeaderObj

1895

self.radarControllerHeaderObj

1896

self.dtype

1896

self.dtype

1897

1898

Return:

1898

Return:

1899

None

1899

None

1900

"""

1900

"""

1901

1902

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

1902

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

1903

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1903

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1904

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

1904

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

1905

1906

self.setBasicHeader()

1906

self.setBasicHeader()

1907

1908

processingHeaderSize = 40 # bytes

1908

processingHeaderSize = 40 # bytes

1909

self.processingHeaderObj.dtype = 0 # Voltage

1909

self.processingHeaderObj.dtype = 0 # Voltage

1910

self.processingHeaderObj.blockSize = self.__getBlockSize()

1910

self.processingHeaderObj.blockSize = self.__getBlockSize()

1911

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1911

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1912

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1912

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1913

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

1913

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

1914

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1914

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1915

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1915

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1916

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

1916

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

1917

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

1917

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

1918

1919

# if self.dataOut.code != None:

1919

# if self.dataOut.code != None:

1920

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

1920

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

1921

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

1921

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

1922

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

1922

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

1923

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

1923

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

1924

# processingHeaderSize += codesize

1924

# processingHeaderSize += codesize

1925

1926

if self.processingHeaderObj.nWindows != 0:

1926

if self.processingHeaderObj.nWindows != 0:

1927

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

1927

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

1928

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

1928

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

1929

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1929

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1930

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1930

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1931

processingHeaderSize += 12

1931

processingHeaderSize += 12

1932

1933

self.processingHeaderObj.size = processingHeaderSize

1933

self.processingHeaderObj.size = processingHeaderSize

1934

1935

class SpectraReader(JRODataReader):

1935

class SpectraReader(JRODataReader):

1936

"""

1936

"""

1937

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

1937

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

1938

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

1938

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

1939

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

1939

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

1940

1941

paresCanalesIguales * alturas * perfiles (Self Spectra)

1941

paresCanalesIguales * alturas * perfiles (Self Spectra)

1942

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1942

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1943

canales * alturas (DC Channels)

1943

canales * alturas (DC Channels)

1944

1945

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

1945

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

1946

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

1946

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

1947

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

1947

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

1948

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

1948

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

1949

1950

Example:

1950

Example:

1951

dpath = "/home/myuser/data"

1951

dpath = "/home/myuser/data"

1952

1953

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

1953

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

1954

1955

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

1955

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

1956

1957

readerObj = SpectraReader()

1957

readerObj = SpectraReader()

1958

1959

readerObj.setup(dpath, startTime, endTime)

1959

readerObj.setup(dpath, startTime, endTime)

1960

1961

while(True):

1961

while(True):

1962

1963

readerObj.getData()

1963

readerObj.getData()

1964

1965

print readerObj.data_spc

1965

print readerObj.data_spc

1966

1967

print readerObj.data_cspc

1967

print readerObj.data_cspc

1968

1969

print readerObj.data_dc

1969

print readerObj.data_dc

1970

1971

if readerObj.flagNoMoreFiles:

1971

if readerObj.flagNoMoreFiles:

1972

break

1972

break

1973

1974

"""

1974

"""

1975

1976

pts2read_SelfSpectra = 0

1976

pts2read_SelfSpectra = 0

1977

1978

pts2read_CrossSpectra = 0

1978

pts2read_CrossSpectra = 0

1979

1980

pts2read_DCchannels = 0

1980

pts2read_DCchannels = 0

1981

1982

ext = ".pdata"

1982

ext = ".pdata"

1983

1984

optchar = "P"

1984

optchar = "P"

1985

1986

dataOut = None

1986

dataOut = None

1987

1988

nRdChannels = None

1988

nRdChannels = None

1989

1990

nRdPairs = None

1990

nRdPairs = None

1991

1992

rdPairList = []

1992

rdPairList = []

1993

1994

def __init__(self):

1994

def __init__(self):

1995

"""

1995

"""

1996

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

1996

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

1997

1998

Inputs:

1998

Inputs:

1999

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

1999

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

2000

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

2000

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

2001

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

2001

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

2002

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

2002

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

2003

bloque de datos.

2003

bloque de datos.

2004

Si este parametro no es pasado se creara uno internamente.

2004

Si este parametro no es pasado se creara uno internamente.

2005

2006

Affected:

2006

Affected:

2007

self.dataOut

2007

self.dataOut

2008

2009

Return : None

2009

Return : None

2010

"""

2010

"""

2011

2012

self.isConfig = False

2012

self.isConfig = False

2013

2014

self.pts2read_SelfSpectra = 0

2014

self.pts2read_SelfSpectra = 0

2015

2016

self.pts2read_CrossSpectra = 0

2016

self.pts2read_CrossSpectra = 0

2017

2018

self.pts2read_DCchannels = 0

2018

self.pts2read_DCchannels = 0

2019

2020

self.datablock = None

2020

self.datablock = None

2021

2022

self.utc = None

2022

self.utc = None

2023

2024

self.ext = ".pdata"

2024

self.ext = ".pdata"

2025

2026

self.optchar = "P"

2026

self.optchar = "P"

2027

2028

self.basicHeaderObj = BasicHeader(LOCALTIME)

2028

self.basicHeaderObj = BasicHeader(LOCALTIME)

2029

2030

self.systemHeaderObj = SystemHeader()

2030

self.systemHeaderObj = SystemHeader()

2031

2032

self.radarControllerHeaderObj = RadarControllerHeader()

2032

self.radarControllerHeaderObj = RadarControllerHeader()

2033

2034

self.processingHeaderObj = ProcessingHeader()

2034

self.processingHeaderObj = ProcessingHeader()

2035

2036

self.online = 0

2036

self.online = 0

2037

2038

self.fp = None

2038

self.fp = None

2039

2040

self.idFile = None

2040

self.idFile = None

2041

2042

self.dtype = None

2042

self.dtype = None

2043

2044

self.fileSizeByHeader = None

2044

self.fileSizeByHeader = None

2045

2046

self.filenameList = []

2046

self.filenameList = []

2047

2048

self.filename = None

2048

self.filename = None

2049

2050

self.fileSize = None

2050

self.fileSize = None

2051

2052

self.firstHeaderSize = 0

2052

self.firstHeaderSize = 0

2053

2054

self.basicHeaderSize = 24

2054

self.basicHeaderSize = 24

2055

2056

self.pathList = []

2056

self.pathList = []

2057

2058

self.lastUTTime = 0

2058

self.lastUTTime = 0

2059

2060

self.maxTimeStep = 30

2060

self.maxTimeStep = 30

2061

2062

self.flagNoMoreFiles = 0

2062

self.flagNoMoreFiles = 0

2063

2064

self.set = 0

2064

self.set = 0

2065

2066

self.path = None

2066

self.path = None

2067

2068

self.delay = 60 #seconds

2068

self.delay = 60 #seconds

2069

2070

self.nTries = 3 #quantity tries

2070

self.nTries = 3 #quantity tries

2071

2072

self.nFiles = 3 #number of files for searching

2072

self.nFiles = 3 #number of files for searching

2073

2074

self.nReadBlocks = 0

2074

self.nReadBlocks = 0

2075

2076

self.flagIsNewFile = 1

2076

self.flagIsNewFile = 1

2077

2078

self.__isFirstTimeOnline = 1

2078

self.__isFirstTimeOnline = 1

2079

2080

self.ippSeconds = 0

2080

self.ippSeconds = 0

2081

2082

self.flagTimeBlock = 0

2082

self.flagTimeBlock = 0

2083

2084

self.flagIsNewBlock = 0

2084

self.flagIsNewBlock = 0

2085

2086

self.nTotalBlocks = 0

2086

self.nTotalBlocks = 0

2087

2088

self.blocksize = 0

2088

self.blocksize = 0

2089

2090

self.dataOut = self.createObjByDefault()

2090

self.dataOut = self.createObjByDefault()

2091

2092

self.profileIndex = 1 #Always

2092

self.profileIndex = 1 #Always

2093

2094

2095

def createObjByDefault(self):

2095

def createObjByDefault(self):

2096

2097

dataObj = Spectra()

2097

dataObj = Spectra()

2098

2099

return dataObj

2099

return dataObj

2100

2101

def __hasNotDataInBuffer(self):

2101

def __hasNotDataInBuffer(self):

2102

return 1

2102

return 1

2103

2104

2105

def getBlockDimension(self):

2105

def getBlockDimension(self):

2106

"""

2106

"""

2107

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

2107

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

2108

2109

Affected:

2109

Affected:

2110

self.nRdChannels

2110

self.nRdChannels

2111

self.nRdPairs

2111

self.nRdPairs

2112

self.pts2read_SelfSpectra

2112

self.pts2read_SelfSpectra

2113

self.pts2read_CrossSpectra

2113

self.pts2read_CrossSpectra

2114

self.pts2read_DCchannels

2114

self.pts2read_DCchannels

2115

self.blocksize

2115

self.blocksize

2116

self.dataOut.nChannels

2116

self.dataOut.nChannels

2117

self.dataOut.nPairs

2117

self.dataOut.nPairs

2118

2119

Return:

2119

Return:

2120

None

2120

None

2121

"""

2121

"""

2122

self.nRdChannels = 0

2122

self.nRdChannels = 0

2123

self.nRdPairs = 0

2123

self.nRdPairs = 0

2124

self.rdPairList = []

2124

self.rdPairList = []

2125

2126

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

2126

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

2127

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

2127

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

2128

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

2128

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

2129

else:

2129

else:

2130

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

2130

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

2131

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

2131

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

2132

2133

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

2133

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

2134

2135

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

2135

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

2136

self.blocksize = self.pts2read_SelfSpectra

2136

self.blocksize = self.pts2read_SelfSpectra

2137

2138

if self.processingHeaderObj.flag_cspc:

2138

if self.processingHeaderObj.flag_cspc:

2139

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

2139

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

2140

self.blocksize += self.pts2read_CrossSpectra

2140

self.blocksize += self.pts2read_CrossSpectra

2141

2142

if self.processingHeaderObj.flag_dc:

2142

if self.processingHeaderObj.flag_dc:

2143

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

2143

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

2144

self.blocksize += self.pts2read_DCchannels

2144

self.blocksize += self.pts2read_DCchannels

2145

2146

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

2146

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

2147

2148

2149

def readBlock(self):

2149

def readBlock(self):

2150

"""

2150

"""

2151

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

2151

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

2152

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

2152

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

2153

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

2153

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

2154

es seteado a 0

2154

es seteado a 0

2155

2156

Return: None

2156

Return: None

2157

2158

Variables afectadas:

2158

Variables afectadas:

2159

2160

self.flagIsNewFile

2160

self.flagIsNewFile

2161

self.flagIsNewBlock

2161

self.flagIsNewBlock

2162

self.nTotalBlocks

2162

self.nTotalBlocks

2163

self.data_spc

2163

self.data_spc

2164

self.data_cspc

2164

self.data_cspc

2165

self.data_dc

2165

self.data_dc

2166

2167

Exceptions:

2167

Exceptions:

2168

Si un bloque leido no es un bloque valido

2168

Si un bloque leido no es un bloque valido

2169

"""

2169

"""

2170

blockOk_flag = False

2170

blockOk_flag = False

2171

fpointer = self.fp.tell()

2171

fpointer = self.fp.tell()

2172

2173

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

2173

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

2174

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

2174

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

2175

2176

if self.processingHeaderObj.flag_cspc:

2176

if self.processingHeaderObj.flag_cspc:

2177

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

2177

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

2178

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

2178

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

2179

2180

if self.processingHeaderObj.flag_dc:

2180

if self.processingHeaderObj.flag_dc:

2181

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

2181

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

2182

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

2182

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

2183

2184

2185

if not(self.processingHeaderObj.shif_fft):

2185

if not(self.processingHeaderObj.shif_fft):

2186

#desplaza a la derecha en el eje 2 determinadas posiciones

2186

#desplaza a la derecha en el eje 2 determinadas posiciones

2187

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

2187

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

2188

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

2188

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

2189

2190

if self.processingHeaderObj.flag_cspc:

2190

if self.processingHeaderObj.flag_cspc:

2191

#desplaza a la derecha en el eje 2 determinadas posiciones

2191

#desplaza a la derecha en el eje 2 determinadas posiciones

2192

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

2192

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

2193

2194

# self.processingHeaderObj.shif_fft = True

2194

# self.processingHeaderObj.shif_fft = True

2195

2196

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

2196

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

2197

self.data_spc = spc

2197

self.data_spc = spc

2198

2199

if self.processingHeaderObj.flag_cspc:

2199

if self.processingHeaderObj.flag_cspc:

2200

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

2200

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

2201

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

2201

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

2202

else:

2202

else:

2203

self.data_cspc = None

2203

self.data_cspc = None

2204

2205

if self.processingHeaderObj.flag_dc:

2205

if self.processingHeaderObj.flag_dc:

2206

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

2206

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

2207

else:

2207

else:

2208

self.data_dc = None

2208

self.data_dc = None

2209

2210

self.flagIsNewFile = 0

2210

self.flagIsNewFile = 0

2211

self.flagIsNewBlock = 1

2211

self.flagIsNewBlock = 1

2212

2213

self.nTotalBlocks += 1

2213

self.nTotalBlocks += 1

2214

self.nReadBlocks += 1

2214

self.nReadBlocks += 1

2215

2216

return 1

2216

return 1

2217

2218

def getFirstHeader(self):

2218

def getFirstHeader(self):

2219

2220

self.dataOut.dtype = self.dtype

2220

self.dataOut.dtype = self.dtype

2221

2222

self.dataOut.nPairs = self.nRdPairs

2222

self.dataOut.nPairs = self.nRdPairs

2223

2224

self.dataOut.pairsList = self.rdPairList

2224

self.dataOut.pairsList = self.rdPairList

2225

2226

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

2226

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

2227

2228

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

2228

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

2229

2230

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

2230

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

2231

2232

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

2232

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

2233

2234

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

2234

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

2235

2236

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

2236

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

2237

2238

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

2238

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

2239

2240

self.dataOut.ippSeconds = self.ippSeconds

2240

self.dataOut.ippSeconds = self.ippSeconds

2241

2242

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

2242

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

2243

2244

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

2244

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

2245

2246

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

2246

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

2247

2248

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

2248

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

2249

2250

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

2250

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

2251

2252

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

2252

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

2253

2254

if self.radarControllerHeaderObj.code != None:

2254

if self.radarControllerHeaderObj.code != None:

2255

2256

self.dataOut.nCode = self.radarControllerHeaderObj.nCode

2256

self.dataOut.nCode = self.radarControllerHeaderObj.nCode

2257

2258

self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud

2258

self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud

2259

2260

self.dataOut.code = self.radarControllerHeaderObj.code

2260

self.dataOut.code = self.radarControllerHeaderObj.code

2261

2262

self.dataOut.flagDecodeData = True

2262

self.dataOut.flagDecodeData = True

2263

2264

def getData(self):

2264

def getData(self):

2265

"""

2265

"""

2266

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

2266

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

2267

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

2267

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

2268

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

2268

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

2269

2270

Return:

2270

Return:

2271

0 : Si no hay mas archivos disponibles

2271

0 : Si no hay mas archivos disponibles

2272

1 : Si hizo una buena copia del buffer

2272

1 : Si hizo una buena copia del buffer

2273

2274

Affected:

2274

Affected:

2275

self.dataOut

2275

self.dataOut

2276

2277

self.flagTimeBlock

2277

self.flagTimeBlock

2278

self.flagIsNewBlock

2278

self.flagIsNewBlock

2279

"""

2279

"""

2280

2281

if self.flagNoMoreFiles:

2281

if self.flagNoMoreFiles:

2282

self.dataOut.flagNoData = True

2282

self.dataOut.flagNoData = True

2283

print 'Process finished'

2283

print 'Process finished'

2284

return 0

2284

return 0

2285

2286

self.flagTimeBlock = 0

2286

self.flagTimeBlock = 0

2287

self.flagIsNewBlock = 0

2287

self.flagIsNewBlock = 0

2288

2289

if self.__hasNotDataInBuffer():

2289

if self.__hasNotDataInBuffer():

2290

2291

if not( self.readNextBlock() ):

2291

if not( self.readNextBlock() ):

2292

self.dataOut.flagNoData = True

2292

self.dataOut.flagNoData = True

2293

return 0

2293

return 0

2294

2295

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

2295

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

2296

2297

if self.data_dc == None:

2297

if self.data_dc == None:

2298

self.dataOut.flagNoData = True

2298

self.dataOut.flagNoData = True

2299

return 0

2299

return 0

2300

2301

self.getBasicHeader()

2301

self.getBasicHeader()

2302

2303

self.getFirstHeader()

2303

self.getFirstHeader()

2304

2305

self.dataOut.data_spc = self.data_spc

2305

self.dataOut.data_spc = self.data_spc

2306

2307

self.dataOut.data_cspc = self.data_cspc

2307

self.dataOut.data_cspc = self.data_cspc

2308

2309

self.dataOut.data_dc = self.data_dc

2309

self.dataOut.data_dc = self.data_dc

2310

2311

self.dataOut.flagNoData = False

2311

self.dataOut.flagNoData = False

2312

2313

self.dataOut.realtime = self.online

2313

self.dataOut.realtime = self.online

2314

2315

return self.dataOut.data_spc

2315

return self.dataOut.data_spc

2316

2317

2318

class SpectraWriter(JRODataWriter):

2318

class SpectraWriter(JRODataWriter):

2319

2320

"""

2320

"""

2321

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

2321

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

2322

de los datos siempre se realiza por bloques.

2322

de los datos siempre se realiza por bloques.

2323

"""

2323

"""

2324

2325

ext = ".pdata"

2325

ext = ".pdata"

2326

2327

optchar = "P"

2327

optchar = "P"

2328

2329

shape_spc_Buffer = None

2329

shape_spc_Buffer = None

2330

2331

shape_cspc_Buffer = None

2331

shape_cspc_Buffer = None

2332

2333

shape_dc_Buffer = None

2333

shape_dc_Buffer = None

2334

2335

data_spc = None

2335

data_spc = None

2336

2337

data_cspc = None

2337

data_cspc = None

2338

2339

data_dc = None

2339

data_dc = None

2340

2341

# dataOut = None

2341

# dataOut = None

2342

2343

def __init__(self):

2343

def __init__(self):

2344

"""

2344

"""

2345

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

2345

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

2346

2347

Affected:

2347

Affected:

2348

self.dataOut

2348

self.dataOut

2349

self.basicHeaderObj

2349

self.basicHeaderObj

2350

self.systemHeaderObj

2350

self.systemHeaderObj

2351

self.radarControllerHeaderObj

2351

self.radarControllerHeaderObj

2352

self.processingHeaderObj

2352

self.processingHeaderObj

2353

2354

Return: None

2354

Return: None

2355

"""

2355

"""

2356

2357

self.isConfig = False

2357

self.isConfig = False

2358

2359

self.nTotalBlocks = 0

2359

self.nTotalBlocks = 0

2360

2361

self.data_spc = None

2361

self.data_spc = None

2362

2363

self.data_cspc = None

2363

self.data_cspc = None

2364

2365

self.data_dc = None

2365

self.data_dc = None

2366

2367

self.fp = None

2367

self.fp = None

2368

2369

self.flagIsNewFile = 1

2369

self.flagIsNewFile = 1

2370

2371

self.nTotalBlocks = 0

2371

self.nTotalBlocks = 0

2372

2373

self.flagIsNewBlock = 0

2373

self.flagIsNewBlock = 0

2374

2375

self.setFile = None

2375

self.setFile = None

2376

2377

self.dtype = None

2377

self.dtype = None

2378

2379

self.path = None

2379

self.path = None

2380

2381

self.noMoreFiles = 0

2381

self.noMoreFiles = 0

2382

2383

self.filename = None

2383

self.filename = None

2384

2385

self.basicHeaderObj = BasicHeader(LOCALTIME)

2385

self.basicHeaderObj = BasicHeader(LOCALTIME)

2386

2387

self.systemHeaderObj = SystemHeader()

2387

self.systemHeaderObj = SystemHeader()

2388

2389

self.radarControllerHeaderObj = RadarControllerHeader()

2389

self.radarControllerHeaderObj = RadarControllerHeader()

2390

2391

self.processingHeaderObj = ProcessingHeader()

2391

self.processingHeaderObj = ProcessingHeader()

2392

2393

2394

def hasAllDataInBuffer(self):

2394

def hasAllDataInBuffer(self):

2395

return 1

2395

return 1

2396

2397

2398

def setBlockDimension(self):

2398

def setBlockDimension(self):

2399

"""

2399

"""

2400

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

2400

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

2401

2402

Affected:

2402

Affected:

2403

self.shape_spc_Buffer

2403

self.shape_spc_Buffer

2404

self.shape_cspc_Buffer

2404

self.shape_cspc_Buffer

2405

self.shape_dc_Buffer

2405

self.shape_dc_Buffer

2406

2407

Return: None

2407

Return: None

2408

"""

2408

"""

2409

self.shape_spc_Buffer = (self.dataOut.nChannels,

2409

self.shape_spc_Buffer = (self.dataOut.nChannels,

2410

self.processingHeaderObj.nHeights,

2410

self.processingHeaderObj.nHeights,

2411

self.processingHeaderObj.profilesPerBlock)

2411

self.processingHeaderObj.profilesPerBlock)

2412

2413

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2413

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2414

self.processingHeaderObj.nHeights,

2414

self.processingHeaderObj.nHeights,

2415

self.processingHeaderObj.profilesPerBlock)

2415

self.processingHeaderObj.profilesPerBlock)

2416

2417

self.shape_dc_Buffer = (self.dataOut.nChannels,

2417

self.shape_dc_Buffer = (self.dataOut.nChannels,

2418

self.processingHeaderObj.nHeights)

2418

self.processingHeaderObj.nHeights)

2419

2420

2421

def writeBlock(self):

2421

def writeBlock(self):

2422

"""

2422

"""

2423

Escribe el buffer en el file designado

2423

Escribe el buffer en el file designado

2424

2425

Affected:

2425

Affected:

2426

self.data_spc

2426

self.data_spc

2427

self.data_cspc

2427

self.data_cspc

2428

self.data_dc

2428

self.data_dc

2429

self.flagIsNewFile

2429

self.flagIsNewFile

2430

self.flagIsNewBlock

2430

self.flagIsNewBlock

2431

self.nTotalBlocks

2431

self.nTotalBlocks

2432

self.nWriteBlocks

2432

self.nWriteBlocks

2433

2434

Return: None

2434

Return: None

2435

"""

2435

"""

2436

2437

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

2437

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

2438

if not( self.processingHeaderObj.shif_fft ):

2438

if not( self.processingHeaderObj.shif_fft ):

2439

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

2439

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

2440

data = spc.reshape((-1))

2440

data = spc.reshape((-1))

2441

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

2441

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

2442

data.tofile(self.fp)

2442

data.tofile(self.fp)

2443

2444

if self.data_cspc != None:

2444

if self.data_cspc != None:

2445

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

2445

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

2446

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

2446

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

2447

if not( self.processingHeaderObj.shif_fft ):

2447

if not( self.processingHeaderObj.shif_fft ):

2448

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

2448

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

2449

data['real'] = cspc.real

2449

data['real'] = cspc.real

2450

data['imag'] = cspc.imag

2450

data['imag'] = cspc.imag

2451

data = data.reshape((-1))

2451

data = data.reshape((-1))

2452

data.tofile(self.fp)

2452

data.tofile(self.fp)

2453

2454

if self.data_dc != None:

2454

if self.data_dc != None:

2455

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

2455

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

2456

dc = self.data_dc

2456

dc = self.data_dc

2457

data['real'] = dc.real

2457

data['real'] = dc.real

2458

data['imag'] = dc.imag

2458

data['imag'] = dc.imag

2459

data = data.reshape((-1))

2459

data = data.reshape((-1))

2460

data.tofile(self.fp)

2460

data.tofile(self.fp)

2461

2462

self.data_spc.fill(0)

2462

self.data_spc.fill(0)

2463

2464

if self.data_dc != None:

2464

if self.data_dc != None:

2465

self.data_dc.fill(0)

2465

self.data_dc.fill(0)

2466

2467

if self.data_cspc != None:

2467

if self.data_cspc != None:

2468

self.data_cspc.fill(0)

2468

self.data_cspc.fill(0)

2469

2470

self.flagIsNewFile = 0

2470

self.flagIsNewFile = 0

2471

self.flagIsNewBlock = 1

2471

self.flagIsNewBlock = 1

2472

self.nTotalBlocks += 1

2472

self.nTotalBlocks += 1

2473

self.nWriteBlocks += 1

2473

self.nWriteBlocks += 1

2474

self.blockIndex += 1

2474

self.blockIndex += 1

2475

2476

2477

def putData(self):

2477

def putData(self):

2478

"""

2478

"""

2479

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

2479

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

2480

2481

Affected:

2481

Affected:

2482

self.data_spc

2482

self.data_spc

2483

self.data_cspc

2483

self.data_cspc

2484

self.data_dc

2484

self.data_dc

2485

2486

Return:

2486

Return:

2487

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

2487

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

2488

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

2488

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

2489

"""

2489

"""

2490

2491

if self.dataOut.flagNoData:

2491

if self.dataOut.flagNoData:

2492

return 0

2492

return 0

2493

2494

self.flagIsNewBlock = 0

2494

self.flagIsNewBlock = 0

2495

2496

if self.dataOut.flagTimeBlock:

2496

if self.dataOut.flagTimeBlock:

2497

self.data_spc.fill(0)

2497

self.data_spc.fill(0)

2498

self.data_cspc.fill(0)

2498

self.data_cspc.fill(0)

2499

self.data_dc.fill(0)

2499

self.data_dc.fill(0)

2500

self.setNextFile()

2500

self.setNextFile()

2501

2502

if self.flagIsNewFile == 0:

2502

if self.flagIsNewFile == 0:

2503

self.setBasicHeader()

2503

self.setBasicHeader()

2504

2505

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

2505

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

2506

if self.dataOut.data_cspc != None:

2506

if self.dataOut.data_cspc != None:

2507

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

2507

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

2508

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

2508

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

2509

2510

# #self.processingHeaderObj.dataBlocksPerFile)

2510

# #self.processingHeaderObj.dataBlocksPerFile)

2511

if self.hasAllDataInBuffer():

2511

if self.hasAllDataInBuffer():

2512

# self.setFirstHeader()

2512

# self.setFirstHeader()

2513

self.writeNextBlock()

2513

self.writeNextBlock()

2514

2515

return 1

2515

return 1

2516

2517

2518

def __getProcessFlags(self):

2518

def __getProcessFlags(self):

2519

2520

processFlags = 0

2520

processFlags = 0

2521

2522

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

2522

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

2523

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

2523

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

2524

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

2524

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

2525

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

2525

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

2526

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

2526

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

2527

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

2527

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

2528

2529

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

2529

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

2530

2531

2532

2533

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2533

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2534

PROCFLAG.DATATYPE_SHORT,

2534

PROCFLAG.DATATYPE_SHORT,

2535

PROCFLAG.DATATYPE_LONG,

2535

PROCFLAG.DATATYPE_LONG,

2536

PROCFLAG.DATATYPE_INT64,

2536

PROCFLAG.DATATYPE_INT64,

2537

PROCFLAG.DATATYPE_FLOAT,

2537

PROCFLAG.DATATYPE_FLOAT,

2538

PROCFLAG.DATATYPE_DOUBLE]

2538

PROCFLAG.DATATYPE_DOUBLE]

2539

2540

2541

for index in range(len(dtypeList)):

2541

for index in range(len(dtypeList)):

2542

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

2542

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

2543

dtypeValue = datatypeValueList[index]

2543

dtypeValue = datatypeValueList[index]

2544

break

2544

break

2545

2546

processFlags += dtypeValue

2546

processFlags += dtypeValue

2547

2548

if self.dataOut.flagDecodeData:

2548

if self.dataOut.flagDecodeData:

2549

processFlags += PROCFLAG.DECODE_DATA

2549

processFlags += PROCFLAG.DECODE_DATA

2550

2551

if self.dataOut.flagDeflipData:

2551

if self.dataOut.flagDeflipData:

2552

processFlags += PROCFLAG.DEFLIP_DATA

2552

processFlags += PROCFLAG.DEFLIP_DATA

2553

2554

if self.dataOut.code != None:

2554

if self.dataOut.code != None:

2555

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2555

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2556

2557

if self.dataOut.nIncohInt > 1:

2557

if self.dataOut.nIncohInt > 1:

2558

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2558

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2559

2560

if self.dataOut.data_dc != None:

2560

if self.dataOut.data_dc != None:

2561

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2561

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2562

2563

return processFlags

2563

return processFlags

2564

2565

2566

def __getBlockSize(self):

2566

def __getBlockSize(self):

2567

'''

2567

'''

2568

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

2568

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

2569

'''

2569

'''

2570

2571

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

2571

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

2572

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

2572

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

2573

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

2573

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

2574

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

2574

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

2575

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

2575

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

2576

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

2576

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

2577

2578

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

2578

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

2579

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

2579

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

2580

for index in range(len(dtypeList)):

2580

for index in range(len(dtypeList)):

2581

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

2581

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

2582

datatypeValue = datatypeValueList[index]

2582

datatypeValue = datatypeValueList[index]

2583

break

2583

break

2584

2585

2586

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

2586

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

2587

2588

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

2588

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

2589

blocksize = (pts2write_SelfSpectra*datatypeValue)

2589

blocksize = (pts2write_SelfSpectra*datatypeValue)

2590

2591

if self.dataOut.data_cspc != None:

2591

if self.dataOut.data_cspc != None:

2592

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

2592

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

2593

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2593

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2594

2595

if self.dataOut.data_dc != None:

2595

if self.dataOut.data_dc != None:

2596

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

2596

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

2597

blocksize += (pts2write_DCchannels*datatypeValue*2)

2597

blocksize += (pts2write_DCchannels*datatypeValue*2)

2598

2599

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2599

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2600

2601

return blocksize

2601

return blocksize

2602

2603

def setFirstHeader(self):

2603

def setFirstHeader(self):

2604

2605

"""

2605

"""

2606

Obtiene una copia del First Header

2606

Obtiene una copia del First Header

2607

2608

Affected:

2608

Affected:

2609

self.systemHeaderObj

2609

self.systemHeaderObj

2610

self.radarControllerHeaderObj

2610

self.radarControllerHeaderObj

2611

self.dtype

2611

self.dtype

2612

2613

Return:

2613

Return:

2614

None

2614

None

2615

"""

2615

"""

2616

2617

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

2617

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

2618

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2618

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2619

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

2619

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

2620

old_code_size = self.dataOut.radarControllerHeaderObj.code_size

2620

old_code_size = self.dataOut.radarControllerHeaderObj.code_size

2621

new_code_size = int(numpy.ceil(self.dataOut.nBaud/32.))*self.dataOut.nCode*4

2621

new_code_size = int(numpy.ceil(self.dataOut.nBaud/32.))*self.dataOut.nCode*4

2622

self.radarControllerHeaderObj.size = self.radarControllerHeaderObj.size - old_code_size + new_code_size

2622

self.radarControllerHeaderObj.size = self.radarControllerHeaderObj.size - old_code_size + new_code_size

2623

2624

self.setBasicHeader()

2624

self.setBasicHeader()

2625

2626

processingHeaderSize = 40 # bytes

2626

processingHeaderSize = 40 # bytes

2627

self.processingHeaderObj.dtype = 1 # Spectra

2627

self.processingHeaderObj.dtype = 1 # Spectra

2628

self.processingHeaderObj.blockSize = self.__getBlockSize()

2628

self.processingHeaderObj.blockSize = self.__getBlockSize()

2629

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2629

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2630

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2630

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2631

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

2631

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

2632

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2632

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2633

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

2633

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

2634

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2634

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2635

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

2635

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

2636

self.processingHeaderObj.shif_fft = self.dataOut.flagShiftFFT

2636

self.processingHeaderObj.shif_fft = self.dataOut.flagShiftFFT

2637

2638

if self.processingHeaderObj.totalSpectra > 0:

2638

if self.processingHeaderObj.totalSpectra > 0:

2639

channelList = []

2639

channelList = []

2640

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

2640

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

2641

channelList.append(channel)

2641

channelList.append(channel)

2642

channelList.append(channel)

2642

channelList.append(channel)

2643

2644

pairsList = []

2644

pairsList = []

2645

if self.dataOut.nPairs > 0:

2645

if self.dataOut.nPairs > 0:

2646

for pair in self.dataOut.pairsList:

2646

for pair in self.dataOut.pairsList:

2647

pairsList.append(pair[0])

2647

pairsList.append(pair[0])

2648

pairsList.append(pair[1])

2648

pairsList.append(pair[1])

2649

2650

spectraComb = channelList + pairsList

2650

spectraComb = channelList + pairsList

2651

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

2651

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

2652

self.processingHeaderObj.spectraComb = spectraComb

2652

self.processingHeaderObj.spectraComb = spectraComb

2653

sizeOfSpcComb = len(spectraComb)

2653

sizeOfSpcComb = len(spectraComb)

2654

processingHeaderSize += sizeOfSpcComb

2654

processingHeaderSize += sizeOfSpcComb

2655

2656

# The processing header should not have information about code

2656

# The processing header should not have information about code

2657

# if self.dataOut.code != None:

2657

# if self.dataOut.code != None:

2658

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

2658

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

2659

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

2659

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

2660

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

2660

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

2661

# nCodeSize = 4 # bytes

2661

# nCodeSize = 4 # bytes

2662

# nBaudSize = 4 # bytes

2662

# nBaudSize = 4 # bytes

2663

# codeSize = 4 # bytes

2663

# codeSize = 4 # bytes

2664

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

2664

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

2665

# processingHeaderSize += sizeOfCode

2665

# processingHeaderSize += sizeOfCode

2666

2667

if self.processingHeaderObj.nWindows != 0:

2667

if self.processingHeaderObj.nWindows != 0:

2668

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

2668

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

2669

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

2669

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

2670

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2670

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2671

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2671

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2672

sizeOfFirstHeight = 4

2672

sizeOfFirstHeight = 4

2673

sizeOfdeltaHeight = 4

2673

sizeOfdeltaHeight = 4

2674

sizeOfnHeights = 4

2674

sizeOfnHeights = 4

2675

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

2675

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

2676

processingHeaderSize += sizeOfWindows

2676

processingHeaderSize += sizeOfWindows

2677

2678

self.processingHeaderObj.size = processingHeaderSize

2678

self.processingHeaderObj.size = processingHeaderSize

2679

2680

class SpectraHeisWriter(Operation):

2680

class SpectraHeisWriter(Operation):

2681

# set = None

2681

# set = None

2682

setFile = None

2682

setFile = None

2683

idblock = None

2683

idblock = None

2684

doypath = None

2684

doypath = None

2685

subfolder = None

2685

subfolder = None

2686

2687

def __init__(self):

2687

def __init__(self):

2688

self.wrObj = FITS()

2688

self.wrObj = FITS()

2689

# self.dataOut = dataOut

2689

# self.dataOut = dataOut

2690

self.nTotalBlocks=0

2690

self.nTotalBlocks=0

2691

# self.set = None

2691

# self.set = None

2692

self.setFile = None

2692

self.setFile = None

2693

self.idblock = 0

2693

self.idblock = 0

2694

self.wrpath = None

2694

self.wrpath = None

2695

self.doypath = None

2695

self.doypath = None

2696

self.subfolder = None

2696

self.subfolder = None

2697

self.isConfig = False

2697

self.isConfig = False

2698

2699

def isNumber(str):

2699

def isNumber(str):

2700

"""

2700

"""

2701

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

2701

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

2702

2703

Excepciones:

2703

Excepciones:

2704

Si un determinado string no puede ser convertido a numero

2704

Si un determinado string no puede ser convertido a numero

2705

Input:

2705

Input:

2706

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

2706

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

2707

2708

Return:

2708

Return:

2709

True : si el string es uno numerico

2709

True : si el string es uno numerico

2710

False : no es un string numerico

2710

False : no es un string numerico

2711

"""

2711

"""

2712

try:

2712

try:

2713

float( str )

2713

float( str )

2714

return True

2714

return True

2715

except:

2715

except:

2716

return False

2716

return False

2717

2718

def setup(self, dataOut, wrpath):

2718

def setup(self, dataOut, wrpath):

2719

2720

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

2720

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

2721

os.mkdir(wrpath)

2721

os.mkdir(wrpath)

2722

2723

self.wrpath = wrpath

2723

self.wrpath = wrpath

2724

# self.setFile = 0

2724

# self.setFile = 0

2725

self.dataOut = dataOut

2725

self.dataOut = dataOut

2726

2727

def putData(self):

2727

def putData(self):

2728

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

2728

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

2729

ext=".fits"

2729

ext=".fits"

2730

2731

if self.doypath == None:

2731

if self.doypath == None:

2732

self.subfolder = 'F%4.4d%3.3d_%d' % (name.tm_year,name.tm_yday,time.mktime(datetime.datetime.now().timetuple()))

2732

self.subfolder = 'F%4.4d%3.3d_%d' % (name.tm_year,name.tm_yday,time.mktime(datetime.datetime.now().timetuple()))

2733

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

2733

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

2734

os.mkdir(self.doypath)

2734

os.mkdir(self.doypath)

2735

2736

if self.setFile == None:

2736

if self.setFile == None:

2737

# self.set = self.dataOut.set

2737

# self.set = self.dataOut.set

2738

self.setFile = 0

2738

self.setFile = 0

2739

# if self.set != self.dataOut.set:

2739

# if self.set != self.dataOut.set:

2740

## self.set = self.dataOut.set

2740

## self.set = self.dataOut.set

2741

# self.setFile = 0

2741

# self.setFile = 0

2742

2743

#make the filename

2743

#make the filename

2744

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

2744

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

2745

2746

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

2746

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

2747

2748

idblock = numpy.array([self.idblock],dtype="int64")

2748

idblock = numpy.array([self.idblock],dtype="int64")

2749

header=self.wrObj.cFImage(idblock=idblock,

2749

header=self.wrObj.cFImage(idblock=idblock,

2750

year=time.gmtime(self.dataOut.utctime).tm_year,

2750

year=time.gmtime(self.dataOut.utctime).tm_year,

2751

month=time.gmtime(self.dataOut.utctime).tm_mon,

2751

month=time.gmtime(self.dataOut.utctime).tm_mon,

2752

day=time.gmtime(self.dataOut.utctime).tm_mday,

2752

day=time.gmtime(self.dataOut.utctime).tm_mday,

2753

hour=time.gmtime(self.dataOut.utctime).tm_hour,

2753

hour=time.gmtime(self.dataOut.utctime).tm_hour,

2754

minute=time.gmtime(self.dataOut.utctime).tm_min,

2754

minute=time.gmtime(self.dataOut.utctime).tm_min,

2755

second=time.gmtime(self.dataOut.utctime).tm_sec)

2755

second=time.gmtime(self.dataOut.utctime).tm_sec)

2756

2757

c=3E8

2757

c=3E8

2758

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

2758

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

2759

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

2759

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

2760

2761

colList = []

2761

colList = []

2762

2763

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

2763

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

2764

2765

colList.append(colFreq)

2765

colList.append(colFreq)

2766

2767

nchannel=self.dataOut.nChannels

2767

nchannel=self.dataOut.nChannels

2768

2769

for i in range(nchannel):

2769

for i in range(nchannel):

2770

col = self.wrObj.writeData(name="PCh"+str(i+1),

2770

col = self.wrObj.writeData(name="PCh"+str(i+1),

2771

format=str(self.dataOut.nFFTPoints)+'E',

2771

format=str(self.dataOut.nFFTPoints)+'E',

2772

data=10*numpy.log10(self.dataOut.data_spc[i,:]))

2772

data=10*numpy.log10(self.dataOut.data_spc[i,:]))

2773

2774

colList.append(col)

2774

colList.append(col)

2775

2776

data=self.wrObj.Ctable(colList=colList)

2776

data=self.wrObj.Ctable(colList=colList)

2777

2778

self.wrObj.CFile(header,data)

2778

self.wrObj.CFile(header,data)

2779

2780

self.wrObj.wFile(filename)

2780

self.wrObj.wFile(filename)

2781

2782

#update the setFile

2782

#update the setFile

2783

self.setFile += 1

2783

self.setFile += 1

2784

self.idblock += 1

2784

self.idblock += 1

2785

2786

return 1

2786

return 1

2787

2788

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

2788

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

2789

2790

if not(self.isConfig):

2790

if not(self.isConfig):

2791

2792

self.setup(dataOut, **kwargs)

2792

self.setup(dataOut, **kwargs)

2793

self.isConfig = True

2793

self.isConfig = True

2794

2795

self.putData()

2795

self.putData()

2796

2797

2798

2799

class ParameterConf:

2799

class ParameterConf:

2800

ELEMENTNAME = 'Parameter'

2800

ELEMENTNAME = 'Parameter'

2801

def __init__(self):

2801

def __init__(self):

2802

self.name = ''

2802

self.name = ''

2803

self.value = ''

2803

self.value = ''

2804

2805

def readXml(self, parmElement):

2805

def readXml(self, parmElement):

2806

self.name = parmElement.get('name')

2806

self.name = parmElement.get('name')

2807

self.value = parmElement.get('value')

2807

self.value = parmElement.get('value')

2808

2809

def getElementName(self):

2809

def getElementName(self):

2810

return self.ELEMENTNAME

2810

return self.ELEMENTNAME

2811

2812

class Metadata:

2812

class Metadata:

2813

2814

def __init__(self, filename):

2814

def __init__(self, filename):

2815

self.parmConfObjList = []

2815

self.parmConfObjList = []

2816

self.readXml(filename)

2816

self.readXml(filename)

2817

2818

def readXml(self, filename):

2818

def readXml(self, filename):

2819

self.projectElement = None

2819

self.projectElement = None

2820

self.procUnitConfObjDict = {}

2820

self.procUnitConfObjDict = {}

2821

self.projectElement = ElementTree().parse(filename)

2821

self.projectElement = ElementTree().parse(filename)

2822

self.project = self.projectElement.tag

2822

self.project = self.projectElement.tag

2823

2824

parmElementList = self.projectElement.getiterator(ParameterConf().getElementName())

2824

parmElementList = self.projectElement.getiterator(ParameterConf().getElementName())

2825

2826

for parmElement in parmElementList:

2826

for parmElement in parmElementList:

2827

parmConfObj = ParameterConf()

2827

parmConfObj = ParameterConf()

2828

parmConfObj.readXml(parmElement)

2828

parmConfObj.readXml(parmElement)

2829

self.parmConfObjList.append(parmConfObj)

2829

self.parmConfObjList.append(parmConfObj)

2830

2831

class FitsWriter(Operation):

2831

class FitsWriter(Operation):

2832

2833

def __init__(self):

2833

def __init__(self):

2834

self.isConfig = False

2834

self.isConfig = False

2835

self.dataBlocksPerFile = None

2835

self.dataBlocksPerFile = None

2836

self.blockIndex = 0

2836

self.blockIndex = 0

2837

self.flagIsNewFile = 1

2837

self.flagIsNewFile = 1

2838

self.fitsObj = None

2838

self.fitsObj = None

2839

self.optchar = 'P'

2839

self.optchar = 'P'

2840

self.ext = '.fits'

2840

self.ext = '.fits'

2841

self.setFile = 0

2841

self.setFile = 0

2842

2843

def setFitsHeader(self, dataOut, metadatafile):

2843

def setFitsHeader(self, dataOut, metadatafile):

2844

2845

header_data = pyfits.PrimaryHDU()

2845

header_data = pyfits.PrimaryHDU()

2846

2847

metadata4fits = Metadata(metadatafile)

2847

metadata4fits = Metadata(metadatafile)

2848

for parameter in metadata4fits.parmConfObjList:

2848

for parameter in metadata4fits.parmConfObjList:

2849

parm_name = parameter.name

2849

parm_name = parameter.name

2850

parm_value = parameter.value

2850

parm_value = parameter.value

2851

2852

# if parm_value == 'fromdatadatetime':

2852

# if parm_value == 'fromdatadatetime':

2853

# value = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())

2853

# value = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())

2854

# elif parm_value == 'fromdataheights':

2854

# elif parm_value == 'fromdataheights':

2855

# value = dataOut.nHeights

2855

# value = dataOut.nHeights

2856

# elif parm_value == 'fromdatachannel':

2856

# elif parm_value == 'fromdatachannel':

2857

# value = dataOut.nChannels

2857

# value = dataOut.nChannels

2858

# elif parm_value == 'fromdatasamples':

2858

# elif parm_value == 'fromdatasamples':

2859

# value = dataOut.nFFTPoints

2859

# value = dataOut.nFFTPoints

2860

# else:

2860

# else:

2861

# value = parm_value

2861

# value = parm_value

2862

2863

header_data.header[parm_name] = parm_value

2863

header_data.header[parm_name] = parm_value

2864

2865

2866

header_data.header['DATETIME'] = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())

2866

header_data.header['DATETIME'] = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())

2867

header_data.header['CHANNELLIST'] = str(dataOut.channelList)

2867

header_data.header['CHANNELLIST'] = str(dataOut.channelList)

2868

header_data.header['NCHANNELS'] = dataOut.nChannels

2868

header_data.header['NCHANNELS'] = dataOut.nChannels

2869

#header_data.header['HEIGHTS'] = dataOut.heightList

2869

#header_data.header['HEIGHTS'] = dataOut.heightList

2870

header_data.header['NHEIGHTS'] = dataOut.nHeights

2870

header_data.header['NHEIGHTS'] = dataOut.nHeights

2871

2872

header_data.header['IPPSECONDS'] = dataOut.ippSeconds

2872

header_data.header['IPPSECONDS'] = dataOut.ippSeconds

2873

header_data.header['NCOHINT'] = dataOut.nCohInt

2873

header_data.header['NCOHINT'] = dataOut.nCohInt

2874

header_data.header['NINCOHINT'] = dataOut.nIncohInt

2874

header_data.header['NINCOHINT'] = dataOut.nIncohInt

2875

header_data.header['TIMEZONE'] = dataOut.timeZone

2875

header_data.header['TIMEZONE'] = dataOut.timeZone

2876

header_data.header['NBLOCK'] = self.blockIndex

2876

header_data.header['NBLOCK'] = self.blockIndex

2877

2878

header_data.writeto(self.filename)

2878

header_data.writeto(self.filename)

2879

2880

self.addExtension(dataOut.heightList,'HEIGHTLIST')

2880

self.addExtension(dataOut.heightList,'HEIGHTLIST')

2881

2882

2883

def setup(self, dataOut, path, dataBlocksPerFile, metadatafile):

2883

def setup(self, dataOut, path, dataBlocksPerFile, metadatafile):

2884

2885

self.path = path

2885

self.path = path

2886

self.dataOut = dataOut

2886

self.dataOut = dataOut

2887

self.metadatafile = metadatafile

2887

self.metadatafile = metadatafile

2888

self.dataBlocksPerFile = dataBlocksPerFile

2888

self.dataBlocksPerFile = dataBlocksPerFile

2889

2890

def open(self):

2890

def open(self):

2891

self.fitsObj = pyfits.open(self.filename, mode='update')

2891

self.fitsObj = pyfits.open(self.filename, mode='update')

2892

2893

2894

def addExtension(self, data, tagname):

2894

def addExtension(self, data, tagname):

2895

self.open()

2895

self.open()

2896

extension = pyfits.ImageHDU(data=data, name=tagname)

2896

extension = pyfits.ImageHDU(data=data, name=tagname)

2897

#extension.header['TAG'] = tagname

2897

#extension.header['TAG'] = tagname

2898

self.fitsObj.append(extension)

2898

self.fitsObj.append(extension)

2899

self.write()

2899

self.write()

2900

2901

def addData(self, data):

2901

def addData(self, data):

2902

self.open()

2902

self.open()

2903

extension = pyfits.ImageHDU(data=data, name=self.fitsObj[0].header['DATATYPE'])

2903

extension = pyfits.ImageHDU(data=data, name=self.fitsObj[0].header['DATATYPE'])

2904

extension.header['UTCTIME'] = self.dataOut.utctime

2904

extension.header['UTCTIME'] = self.dataOut.utctime

2905

self.fitsObj.append(extension)

2905

self.fitsObj.append(extension)

2906

self.blockIndex += 1

2906

self.blockIndex += 1

2907

self.fitsObj[0].header['NBLOCK'] = self.blockIndex

2907

self.fitsObj[0].header['NBLOCK'] = self.blockIndex

2908

2909

self.write()

2909

self.write()

2910

2911

def write(self):

2911

def write(self):

2912

2913

self.fitsObj.flush(verbose=True)

2913

self.fitsObj.flush(verbose=True)

2914

self.fitsObj.close()

2914

self.fitsObj.close()

2915

2916

2917

def setNextFile(self):

2917

def setNextFile(self):

2918

2919

ext = self.ext

2919

ext = self.ext

2920

path = self.path

2920

path = self.path

2921

2922

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

2922

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

2923

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

2923

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

2924

2925

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

2925

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

2926

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

2926

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

2927

os.mkdir(fullpath)

2927

os.mkdir(fullpath)

2928

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

2928

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

2929

else:

2929

else:

2930

filesList = os.listdir( fullpath )

2930

filesList = os.listdir( fullpath )

2931

if len( filesList ) > 0:

2931

if len( filesList ) > 0:

2932

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

2932

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

2933

filen = filesList[-1]

2933

filen = filesList[-1]

2934

2935

if isNumber( filen[8:11] ):

2935

if isNumber( filen[8:11] ):

2936

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

2936

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

2937

else:

2937

else:

2938

self.setFile = -1

2938

self.setFile = -1

2939

else:

2939

else:

2940

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

2940

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

2941

2942

setFile = self.setFile

2942

setFile = self.setFile

2943

setFile += 1

2943

setFile += 1

2944

2945

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

2945

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

2946

timeTuple.tm_year,

2946

timeTuple.tm_year,

2947

timeTuple.tm_yday,

2947

timeTuple.tm_yday,

2948

setFile,

2948

setFile,

2949

ext )

2949

ext )

2950

2951

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

2951

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

2952

2953

self.blockIndex = 0

2953

self.blockIndex = 0

2954

self.filename = filename

2954

self.filename = filename

2955

self.setFile = setFile

2955

self.setFile = setFile

2956

self.flagIsNewFile = 1

2956

self.flagIsNewFile = 1

2957

2958

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

2958

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

2959

2960

self.setFitsHeader(self.dataOut, self.metadatafile)

2960

self.setFitsHeader(self.dataOut, self.metadatafile)

2961

2962

return 1

2962

return 1

2963

2964

def writeBlock(self):

2964

def writeBlock(self):

2965

self.addData(self.dataOut.data_spc)

2965

self.addData(self.dataOut.data_spc)

2966

self.flagIsNewFile = 0

2966

self.flagIsNewFile = 0

2967

2968

2969

def __setNewBlock(self):

2969

def __setNewBlock(self):

2970

2971

if self.flagIsNewFile:

2971

if self.flagIsNewFile:

2972

return 1

2972

return 1

2973

2974

if self.blockIndex < self.dataBlocksPerFile:

2974

if self.blockIndex < self.dataBlocksPerFile:

2975

return 1

2975

return 1

2976

2977

if not( self.setNextFile() ):

2977

if not( self.setNextFile() ):

2978

return 0

2978

return 0

2979

2980

return 1

2980

return 1

2981

2982

def writeNextBlock(self):

2982

def writeNextBlock(self):

2983

if not( self.__setNewBlock() ):

2983

if not( self.__setNewBlock() ):

2984

return 0

2984

return 0

2985

self.writeBlock()

2985

self.writeBlock()

2986

return 1

2986

return 1

2987

2988

def putData(self):

2988

def putData(self):

2989

if self.flagIsNewFile:

2989

if self.flagIsNewFile:

2990

self.setNextFile()

2990

self.setNextFile()

2991

self.writeNextBlock()

2991

self.writeNextBlock()

2992

2993

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

2993

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

2994

if not(self.isConfig):

2994

if not(self.isConfig):

2995

self.setup(dataOut, **kwargs)

2995

self.setup(dataOut, **kwargs)

2996

self.isConfig = True

2996

self.isConfig = True

2997

self.putData()

2997

self.putData()

2998

2999

3000

class FitsReader(ProcessingUnit):

3000

class FitsReader(ProcessingUnit):

3001

3002

# __TIMEZONE = time.timezone

3002

# __TIMEZONE = time.timezone

3003

3004

expName = None

3004

expName = None

3005

datetimestr = None

3005

datetimestr = None

3006

utc = None

3006

utc = None

3007

nChannels = None

3007

nChannels = None

3008

nSamples = None

3008

nSamples = None

3009

dataBlocksPerFile = None

3009

dataBlocksPerFile = None

3010

comments = None

3010

comments = None

3011

lastUTTime = None

3011

lastUTTime = None

3012

header_dict = None

3012

header_dict = None

3013

data = None

3013

data = None

3014

data_header_dict = None

3014

data_header_dict = None

3015

3016

def __init__(self):

3016

def __init__(self):

3017

self.isConfig = False

3017

self.isConfig = False

3018

self.ext = '.fits'

3018

self.ext = '.fits'

3019

self.setFile = 0

3019

self.setFile = 0

3020

self.flagNoMoreFiles = 0

3020

self.flagNoMoreFiles = 0

3021

self.flagIsNewFile = 1

3021

self.flagIsNewFile = 1

3022

self.flagTimeBlock = None

3022

self.flagTimeBlock = None

3023

self.fileIndex = None

3023

self.fileIndex = None

3024

self.filename = None

3024

self.filename = None

3025

self.fileSize = None

3025

self.fileSize = None

3026

self.fitsObj = None

3026

self.fitsObj = None

3027

self.timeZone = None

3027

self.timeZone = None

3028

self.nReadBlocks = 0

3028

self.nReadBlocks = 0

3029

self.nTotalBlocks = 0

3029

self.nTotalBlocks = 0

3030

self.dataOut = self.createObjByDefault()

3030

self.dataOut = self.createObjByDefault()

3031

self.maxTimeStep = 10# deberia ser definido por el usuario usando el metodo setup()

3031

self.maxTimeStep = 10# deberia ser definido por el usuario usando el metodo setup()

3032

self.blockIndex = 1

3032

self.blockIndex = 1

3033

3034

def createObjByDefault(self):

3034

def createObjByDefault(self):

3035

3036

dataObj = Fits()

3036

dataObj = Fits()

3037

3038

return dataObj

3038

return dataObj

3039

3040

def isFileinThisTime(self, filename, startTime, endTime, useLocalTime=False):

3040

def isFileinThisTime(self, filename, startTime, endTime, useLocalTime=False):

3041

try:

3041

try:

3042

fitsObj = pyfits.open(filename,'readonly')

3042

fitsObj = pyfits.open(filename,'readonly')

3043

except:

3043

except:

3044

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

3044

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

3045

3046

header = fitsObj[0].header

3046

header = fitsObj[0].header

3047

struct_time = time.strptime(header['DATETIME'], "%b %d %Y %H:%M:%S")

3047

struct_time = time.strptime(header['DATETIME'], "%b %d %Y %H:%M:%S")

3048

utc = time.mktime(struct_time) - time.timezone #TIMEZONE debe ser un parametro del header FITS

3048

utc = time.mktime(struct_time) - time.timezone #TIMEZONE debe ser un parametro del header FITS

3049

3050

ltc = utc

3050

ltc = utc

3051

if useLocalTime:

3051

if useLocalTime:

3052

ltc -= time.timezone

3052

ltc -= time.timezone

3053

thisDatetime = datetime.datetime.utcfromtimestamp(ltc)

3053

thisDatetime = datetime.datetime.utcfromtimestamp(ltc)

3054

thisTime = thisDatetime.time()

3054

thisTime = thisDatetime.time()

3055

3056

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

3056

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

3057

return None

3057

return None

3058

3059

return thisDatetime

3059

return thisDatetime

3060

3061

def __setNextFileOnline(self):

3061

def __setNextFileOnline(self):

3062

raise ValueError, "No implemented"

3062

raise ValueError, "No implemented"

3063

3064

def __setNextFileOffline(self):

3064

def __setNextFileOffline(self):

3065

idFile = self.fileIndex

3065

idFile = self.fileIndex

3066

3067

while (True):

3067

while (True):

3068

idFile += 1

3068

idFile += 1

3069

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

3069

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

3070

self.flagNoMoreFiles = 1

3070

self.flagNoMoreFiles = 1

3071

print "No more Files"

3071

print "No more Files"

3072

return 0

3072

return 0

3073

3074

filename = self.filenameList[idFile]

3074

filename = self.filenameList[idFile]

3075

3076

# if not(self.__verifyFile(filename)):

3076

# if not(self.__verifyFile(filename)):

3077

# continue

3077

# continue

3078

3079

fileSize = os.path.getsize(filename)

3079

fileSize = os.path.getsize(filename)

3080

fitsObj = pyfits.open(filename,'readonly')

3080

fitsObj = pyfits.open(filename,'readonly')

3081

break

3081

break

3082

3083

self.flagIsNewFile = 1

3083

self.flagIsNewFile = 1

3084

self.fileIndex = idFile

3084

self.fileIndex = idFile

3085

self.filename = filename

3085

self.filename = filename

3086

self.fileSize = fileSize

3086

self.fileSize = fileSize

3087

self.fitsObj = fitsObj

3087

self.fitsObj = fitsObj

3088

self.blockIndex = 0

3088

self.blockIndex = 0

3089

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

3089

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

3090

3091

return 1

3091

return 1

3092

3093

def readHeader(self):

3093

def readHeader(self):

3094

headerObj = self.fitsObj[0]

3094

headerObj = self.fitsObj[0]

3095

3096

self.header_dict = headerObj.header

3096

self.header_dict = headerObj.header

3097

if 'EXPNAME' in headerObj.header.keys():

3097

if 'EXPNAME' in headerObj.header.keys():

3098

self.expName = headerObj.header['EXPNAME']

3098

self.expName = headerObj.header['EXPNAME']

3099

3100

if 'DATATYPE' in headerObj.header.keys():

3100

if 'DATATYPE' in headerObj.header.keys():

3101

self.dataType = headerObj.header['DATATYPE']

3101

self.dataType = headerObj.header['DATATYPE']

3102

3103

self.datetimestr = headerObj.header['DATETIME']

3103

self.datetimestr = headerObj.header['DATETIME']

3104

channelList = headerObj.header['CHANNELLIST']

3104

channelList = headerObj.header['CHANNELLIST']

3105

channelList = channelList.split('[')

3105

channelList = channelList.split('[')

3106

channelList = channelList[1].split(']')

3106

channelList = channelList[1].split(']')

3107

channelList = channelList[0].split(',')

3107

channelList = channelList[0].split(',')

3108

channelList = [int(ch) for ch in channelList]

3108

channelList = [int(ch) for ch in channelList]

3109

self.channelList = channelList

3109

self.channelList = channelList

3110

self.nChannels = headerObj.header['NCHANNELS']

3110

self.nChannels = headerObj.header['NCHANNELS']

3111

self.nHeights = headerObj.header['NHEIGHTS']

3111

self.nHeights = headerObj.header['NHEIGHTS']

3112

self.ippSeconds = headerObj.header['IPPSECONDS']

3112

self.ippSeconds = headerObj.header['IPPSECONDS']

3113

self.nCohInt = headerObj.header['NCOHINT']

3113

self.nCohInt = headerObj.header['NCOHINT']

3114

self.nIncohInt = headerObj.header['NINCOHINT']

3114

self.nIncohInt = headerObj.header['NINCOHINT']

3115

self.dataBlocksPerFile = headerObj.header['NBLOCK']

3115

self.dataBlocksPerFile = headerObj.header['NBLOCK']

3116

self.timeZone = headerObj.header['TIMEZONE']

3116

self.timeZone = headerObj.header['TIMEZONE']

3117

3118

self.timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt

3118

self.timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt

3119

3120

if 'COMMENT' in headerObj.header.keys():

3120

if 'COMMENT' in headerObj.header.keys():

3121

self.comments = headerObj.header['COMMENT']

3121

self.comments = headerObj.header['COMMENT']

3122

3123

self.readHeightList()

3123

self.readHeightList()

3124

3125

def readHeightList(self):

3125

def readHeightList(self):

3126

self.blockIndex = self.blockIndex + 1

3126

self.blockIndex = self.blockIndex + 1

3127

obj = self.fitsObj[self.blockIndex]

3127

obj = self.fitsObj[self.blockIndex]

3128

self.heightList = obj.data

3128

self.heightList = obj.data

3129

self.blockIndex = self.blockIndex + 1

3129

self.blockIndex = self.blockIndex + 1

3130

3131

def readExtension(self):

3131

def readExtension(self):

3132

obj = self.fitsObj[self.blockIndex]

3132

obj = self.fitsObj[self.blockIndex]

3133

self.heightList = obj.data

3133

self.heightList = obj.data

3134

self.blockIndex = self.blockIndex + 1

3134

self.blockIndex = self.blockIndex + 1

3135

3136

def setNextFile(self):

3136

def setNextFile(self):

3137

3138

if self.online:

3138

if self.online:

3139

newFile = self.__setNextFileOnline()

3139

newFile = self.__setNextFileOnline()

3140

else:

3140

else:

3141

newFile = self.__setNextFileOffline()

3141

newFile = self.__setNextFileOffline()

3142

3143

if not(newFile):

3143

if not(newFile):

3144

return 0

3144

return 0

3145

3146

self.readHeader()

3146

self.readHeader()

3147

3148

self.nReadBlocks = 0

3148

self.nReadBlocks = 0

3149

# self.blockIndex = 1

3149

# self.blockIndex = 1

3150

return 1

3150

return 1

3151

3152

def __searchFilesOffLine(self,

3152

def __searchFilesOffLine(self,

3153

path,

3153

path,

3154

startDate,

3154

startDate,

3155

endDate,

3155

endDate,

3156

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

3156

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

3157

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

3157

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

3158

set=None,

3158

set=None,

3159

expLabel='',

3159

expLabel='',

3160

ext='.fits',

3160

ext='.fits',

3161

walk=True):

3161

walk=True):

3162

3163

pathList = []

3163

pathList = []

3164

3165

if not walk:

3165

if not walk:

3166

pathList.append(path)

3166

pathList.append(path)

3167

3168

else:

3168

else:

3169

dirList = []

3169

dirList = []

3170

for thisPath in os.listdir(path):

3170

for thisPath in os.listdir(path):

3171

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

3171

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

3172

continue

3172

continue

3173

if not isDoyFolder(thisPath):

3173

if not isDoyFolder(thisPath):

3174

continue

3174

continue

3175

3176

dirList.append(thisPath)

3176

dirList.append(thisPath)

3177

3178

if not(dirList):

3178

if not(dirList):

3179

return None, None

3179

return None, None

3180

3181

thisDate = startDate

3181

thisDate = startDate

3182

3183

while(thisDate <= endDate):

3183

while(thisDate <= endDate):

3184

year = thisDate.timetuple().tm_year

3184

year = thisDate.timetuple().tm_year

3185

doy = thisDate.timetuple().tm_yday

3185

doy = thisDate.timetuple().tm_yday

3186

3187

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

3187

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

3188

if len(matchlist) == 0:

3188

if len(matchlist) == 0:

3189

thisDate += datetime.timedelta(1)

3189

thisDate += datetime.timedelta(1)

3190

continue

3190

continue

3191

for match in matchlist:

3191

for match in matchlist:

3192

pathList.append(os.path.join(path,match,expLabel))

3192

pathList.append(os.path.join(path,match,expLabel))

3193

3194

thisDate += datetime.timedelta(1)

3194

thisDate += datetime.timedelta(1)

3195

3196

if pathList == []:

3196

if pathList == []:

3197

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

3197

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

3198

return None, None

3198

return None, None

3199

3200

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

3200

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

3201

3202

filenameList = []

3202

filenameList = []

3203

datetimeList = []

3203

datetimeList = []

3204

3205

for i in range(len(pathList)):

3205

for i in range(len(pathList)):

3206

3207

thisPath = pathList[i]

3207

thisPath = pathList[i]

3208

3209

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

3209

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

3210

fileList.sort()

3210

fileList.sort()

3211

3212

for file in fileList:

3212

for file in fileList:

3213

3214

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

3214

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

3215

thisDatetime = self.isFileinThisTime(filename, startTime, endTime)

3215

thisDatetime = self.isFileinThisTime(filename, startTime, endTime)

3216

3217

if not(thisDatetime):

3217

if not(thisDatetime):

3218

continue

3218

continue

3219

3220

filenameList.append(filename)

3220

filenameList.append(filename)

3221

datetimeList.append(thisDatetime)

3221

datetimeList.append(thisDatetime)

3222

3223

if not(filenameList):

3223

if not(filenameList):

3224

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

3224

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

3225

return None, None

3225

return None, None

3226

3227

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

3227

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

3228

print

3228

print

3229

3230

for i in range(len(filenameList)):

3230

for i in range(len(filenameList)):

3231

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

3231

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

3232

3233

self.filenameList = filenameList

3233

self.filenameList = filenameList

3234

self.datetimeList = datetimeList

3234

self.datetimeList = datetimeList

3235

3236

return pathList, filenameList

3236

return pathList, filenameList

3237

3238

def setup(self, path=None,

3238

def setup(self, path=None,

3239

startDate=None,

3239

startDate=None,

3240

endDate=None,

3240

endDate=None,

3241

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

3241

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

3242

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

3242

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

3243

set=0,

3243

set=0,

3244

expLabel = "",

3244

expLabel = "",

3245

ext = None,

3245

ext = None,

3246

online = False,

3246

online = False,

3247

delay = 60,

3247

delay = 60,

3248

walk = True):

3248

walk = True):

3249

3250

if path == None:

3250

if path == None:

3251

raise ValueError, "The path is not valid"

3251

raise ValueError, "The path is not valid"

3252

3253

if ext == None:

3253

if ext == None:

3254

ext = self.ext

3254

ext = self.ext

3255

3256

if not(online):

3256

if not(online):

3257

print "Searching files in offline mode ..."

3257

print "Searching files in offline mode ..."

3258

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

3258

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

3259

startTime=startTime, endTime=endTime,

3259

startTime=startTime, endTime=endTime,

3260

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

3260

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

3261

walk=walk)

3261

walk=walk)

3262

3263

if not(pathList):

3263

if not(pathList):

3264

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

3264

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

3265

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

3265

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

3266

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

3266

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

3267

3268

sys.exit(-1)

3268

sys.exit(-1)

3269

3270

self.fileIndex = -1

3270

self.fileIndex = -1

3271

self.pathList = pathList

3271

self.pathList = pathList

3272

self.filenameList = filenameList

3272

self.filenameList = filenameList

3273

3274

self.online = online

3274

self.online = online

3275

self.delay = delay

3275

self.delay = delay

3276

ext = ext.lower()

3276

ext = ext.lower()

3277

self.ext = ext

3277

self.ext = ext

3278

3279

if not(self.setNextFile()):

3279

if not(self.setNextFile()):

3280

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

3280

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

3281

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

3281

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

3282

elif startDate != None:

3282

elif startDate != None:

3283

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

3283

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

3284

else:

3284

else:

3285

print "No files"

3285

print "No files"

3286

3287

sys.exit(-1)

3287

sys.exit(-1)

3288

3289

3290

3291

def readBlock(self):

3291

def readBlock(self):

3292

dataObj = self.fitsObj[self.blockIndex]

3292

dataObj = self.fitsObj[self.blockIndex]

3293

3294

self.data = dataObj.data

3294

self.data = dataObj.data

3295

self.data_header_dict = dataObj.header

3295

self.data_header_dict = dataObj.header

3296

self.utc = self.data_header_dict['UTCTIME']

3296

self.utc = self.data_header_dict['UTCTIME']

3297

3298

self.flagIsNewFile = 0

3298

self.flagIsNewFile = 0

3299

self.blockIndex += 1

3299

self.blockIndex += 1

3300

self.nTotalBlocks += 1

3300

self.nTotalBlocks += 1

3301

self.nReadBlocks += 1

3301

self.nReadBlocks += 1

3302

3303

return 1

3303

return 1

3304

3305

def __jumpToLastBlock(self):

3305

def __jumpToLastBlock(self):

3306

raise ValueError, "No implemented"

3306

raise ValueError, "No implemented"

3307

3308

def __waitNewBlock(self):

3308

def __waitNewBlock(self):

3309

"""

3309

"""

3310

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

3310

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

3311

3312

Si el modo de lectura es OffLine siempre retorn 0

3312

Si el modo de lectura es OffLine siempre retorn 0

3313

"""

3313

"""

3314

if not self.online:

3314

if not self.online:

3315

return 0

3315

return 0

3316

3317

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

3317

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

3318

return 0

3318

return 0

3319

3320

currentPointer = self.fp.tell()

3320

currentPointer = self.fp.tell()

3321

3322

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

3322

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

3323

3324

for nTries in range( self.nTries ):

3324

for nTries in range( self.nTries ):

3325

3326

self.fp.close()

3326

self.fp.close()

3327

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

3327

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

3328

self.fp.seek( currentPointer )

3328

self.fp.seek( currentPointer )

3329

3330

self.fileSize = os.path.getsize( self.filename )

3330

self.fileSize = os.path.getsize( self.filename )

3331

currentSize = self.fileSize - currentPointer

3331

currentSize = self.fileSize - currentPointer

3332

3333

if ( currentSize >= neededSize ):

3333

if ( currentSize >= neededSize ):

3334

self.__rdBasicHeader()

3334

self.__rdBasicHeader()

3335

return 1

3335

return 1

3336

3337

print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)

3337

print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)

3338

time.sleep( self.delay )

3338

time.sleep( self.delay )

3339

3340

3341

return 0

3341

return 0

3342

3343

def __setNewBlock(self):

3343

def __setNewBlock(self):

3344

3345

if self.online:

3345

if self.online:

3346

self.__jumpToLastBlock()

3346

self.__jumpToLastBlock()

3347

3348

if self.flagIsNewFile:

3348

if self.flagIsNewFile:

3349

return 1

3349

return 1

3350

3351

self.lastUTTime = self.utc

3351

self.lastUTTime = self.utc

3352

3353

if self.online:

3353

if self.online:

3354

if self.__waitNewBlock():

3354

if self.__waitNewBlock():

3355

return 1

3355

return 1

3356

3357

if self.nReadBlocks < self.dataBlocksPerFile:

3357

if self.nReadBlocks < self.dataBlocksPerFile:

3358

return 1

3358

return 1

3359

3360

if not(self.setNextFile()):

3360

if not(self.setNextFile()):

3361

return 0

3361

return 0

3362

3363

deltaTime = self.utc - self.lastUTTime

3363

deltaTime = self.utc - self.lastUTTime

3364

3365

self.flagTimeBlock = 0

3365

self.flagTimeBlock = 0

3366

3367

if deltaTime > self.maxTimeStep:

3367

if deltaTime > self.maxTimeStep:

3368

self.flagTimeBlock = 1

3368

self.flagTimeBlock = 1

3369

3370

return 1

3370

return 1

3371

3372

3373

def readNextBlock(self):

3373

def readNextBlock(self):

3374

if not(self.__setNewBlock()):

3374

if not(self.__setNewBlock()):

3375

return 0

3375

return 0

3376

3377

if not(self.readBlock()):

3377

if not(self.readBlock()):

3378

return 0

3378

return 0

3379

3380

return 1

3380

return 1

3381

3382

3383

def getData(self):

3383

def getData(self):

3384

3385

if self.flagNoMoreFiles:

3385

if self.flagNoMoreFiles:

3386

self.dataOut.flagNoData = True

3386

self.dataOut.flagNoData = True

3387

print 'Process finished'

3387

print 'Process finished'

3388

return 0

3388

return 0

3389

3390

self.flagTimeBlock = 0

3390

self.flagTimeBlock = 0

3391

self.flagIsNewBlock = 0

3391

self.flagIsNewBlock = 0

3392

3393

if not(self.readNextBlock()):

3393

if not(self.readNextBlock()):

3394

return 0

3394

return 0

3395

3396

if self.data == None:

3396

if self.data == None:

3397

self.dataOut.flagNoData = True

3397

self.dataOut.flagNoData = True

3398

return 0

3398

return 0

3399

3400

self.dataOut.data = self.data

3400

self.dataOut.data = self.data

3401

self.dataOut.data_header = self.data_header_dict

3401

self.dataOut.data_header = self.data_header_dict

3402

self.dataOut.utctime = self.utc

3402

self.dataOut.utctime = self.utc

3403

3404

self.dataOut.header = self.header_dict

3404

self.dataOut.header = self.header_dict

3405

self.dataOut.expName = self.expName

3405

self.dataOut.expName = self.expName

3406

self.dataOut.nChannels = self.nChannels

3406

self.dataOut.nChannels = self.nChannels

3407

self.dataOut.timeZone = self.timeZone

3407

self.dataOut.timeZone = self.timeZone

3408

self.dataOut.dataBlocksPerFile = self.dataBlocksPerFile

3408

self.dataOut.dataBlocksPerFile = self.dataBlocksPerFile

3409

self.dataOut.comments = self.comments

3409

self.dataOut.comments = self.comments

3410

self.dataOut.timeInterval = self.timeInterval

3410

self.dataOut.timeInterval = self.timeInterval

3411

self.dataOut.channelList = self.channelList

3411

self.dataOut.channelList = self.channelList

3412

self.dataOut.heightList = self.heightList

3412

self.dataOut.heightList = self.heightList

3413

self.dataOut.flagNoData = False

3413

self.dataOut.flagNoData = False

3414

3415

return self.dataOut.data

3415

return self.dataOut.data

3416

3417

def run(self, **kwargs):

3417

def run(self, **kwargs):

3418

3419

if not(self.isConfig):

3419

if not(self.isConfig):

3420

self.setup(**kwargs)

3420

self.setup(**kwargs)

3421

self.isConfig = True

3421

self.isConfig = True

3422

3423

self.getData()

3423

self.getData()

3424

3425

3426

class RadacHeader():

3426

class RadacHeader():

3427

def __init__(self, fp):

3427

def __init__(self, fp):

3428

header = 'Raw11/Data/RadacHeader'

3428

header = 'Raw11/Data/RadacHeader'

3429

self.beamCodeByPulse = fp.get(header+'/BeamCode')

3429

self.beamCodeByPulse = fp.get(header+'/BeamCode')

3430

self.beamCode = fp.get('Raw11/Data/Beamcodes')

3430

self.beamCode = fp.get('Raw11/Data/Beamcodes')

3431

self.code = fp.get(header+'/Code')

3431

self.code = fp.get(header+'/Code')

3432

self.frameCount = fp.get(header+'/FrameCount')

3432

self.frameCount = fp.get(header+'/FrameCount')

3433

self.modeGroup = fp.get(header+'/ModeGroup')

3433

self.modeGroup = fp.get(header+'/ModeGroup')

3434

self.nsamplesPulse = fp.get(header+'/NSamplesPulse')

3434

self.nsamplesPulse = fp.get(header+'/NSamplesPulse')

3435

self.pulseCount = fp.get(header+'/PulseCount')

3435

self.pulseCount = fp.get(header+'/PulseCount')

3436

self.radacTime = fp.get(header+'/RadacTime')

3436

self.radacTime = fp.get(header+'/RadacTime')

3437

self.timeCount = fp.get(header+'/TimeCount')

3437

self.timeCount = fp.get(header+'/TimeCount')

3438

self.timeStatus = fp.get(header+'/TimeStatus')

3438

self.timeStatus = fp.get(header+'/TimeStatus')

3439

3440

self.nrecords = self.pulseCount.shape[0] #numero de bloques

3440

self.nrecords = self.pulseCount.shape[0] #numero de bloques

3441

self.npulses = self.pulseCount.shape[1] #numero de perfiles

3441

self.npulses = self.pulseCount.shape[1] #numero de perfiles

3442

self.nsamples = self.nsamplesPulse[0,0] #numero de alturas

3442

self.nsamples = self.nsamplesPulse[0,0] #numero de alturas

3443

self.nbeams = self.beamCode.shape[1] #numero de beams

3443

self.nbeams = self.beamCode.shape[1] #numero de beams

3444

3445

3446

def getIndexRangeToPulse(self, idrecord=0):

3446

def getIndexRangeToPulse(self, idrecord=0):

3447

indexToZero = numpy.where(self.pulseCount.value[idrecord,:]==0)

3447

indexToZero = numpy.where(self.pulseCount.value[idrecord,:]==0)

3448

startPulseCountId = indexToZero[0][0]

3448

startPulseCountId = indexToZero[0][0]

3449

endPulseCountId = startPulseCountId - 1

3449

endPulseCountId = startPulseCountId - 1

3450

range1 = numpy.arange(startPulseCountId,self.npulses,1)

3450

range1 = numpy.arange(startPulseCountId,self.npulses,1)

3451

range2 = numpy.arange(0,startPulseCountId,1)

3451

range2 = numpy.arange(0,startPulseCountId,1)

3452

return range1, range2

3452

return range1, range2

3453

3454

3455

class AMISRReader(ProcessingUnit):

3455

class AMISRReader(ProcessingUnit):

3456

3457

path = None

3457

path = None

3458

startDate = None

3458

startDate = None

3459

endDate = None

3459

endDate = None

3460

startTime = None

3460

startTime = None

3461

endTime = None

3461

endTime = None

3462

walk = None

3462

walk = None

3463

isConfig = False

3463

isConfig = False

3464

3465

def __init__(self):

3465

def __init__(self):

3466

self.set = None

3466

self.set = None

3467

self.subset = None

3467

self.subset = None

3468

self.extension_file = '.h5'

3468

self.extension_file = '.h5'

3469

self.dtc_str = 'dtc'

3469

self.dtc_str = 'dtc'

3470

self.dtc_id = 0

3470

self.dtc_id = 0

3471

self.status = True

3471

self.status = True

3472

self.isConfig = False

3472

self.isConfig = False

3473

self.dirnameList = []

3473

self.dirnameList = []

3474

self.filenameList = []

3474

self.filenameList = []

3475

self.fileIndex = None

3475

self.fileIndex = None

3476

self.flagNoMoreFiles = False

3476

self.flagNoMoreFiles = False

3477

self.flagIsNewFile = 0

3477

self.flagIsNewFile = 0

3478

self.filename = ''

3478

self.filename = ''

3479

self.amisrFilePointer = None

3479

self.amisrFilePointer = None

3480

self.radacHeaderObj = None

3480

self.radacHeaderObj = None

3481

self.dataOut = self.__createObjByDefault()

3481

self.dataOut = self.__createObjByDefault()

3482

self.datablock = None

3482

self.datablock = None

3483

self.rest_datablock = None

3483

self.rest_datablock = None

3484

self.range = None

3484

self.range = None

3485

self.idrecord_count = 0

3485

self.idrecord_count = 0

3486

self.profileIndex = 0

3486

self.profileIndex = 0

3487

self.idpulse_range1 = None

3487

self.idpulse_range1 = None

3488

self.idpulse_range2 = None

3488

self.idpulse_range2 = None

3489

self.beamCodeByFrame = None

3489

self.beamCodeByFrame = None

3490

self.radacTimeByFrame = None

3490

self.radacTimeByFrame = None

3491

#atributos originales tal y como esta en el archivo de datos

3491

#atributos originales tal y como esta en el archivo de datos

3492

self.beamCodesFromFile = None

3492

self.beamCodesFromFile = None

3493

self.radacTimeFromFile = None

3493

self.radacTimeFromFile = None

3494

self.rangeFromFile = None

3494

self.rangeFromFile = None

3495

self.dataByFrame = None

3495

self.dataByFrame = None

3496

self.dataset = None

3496

self.dataset = None

3497

3498

self.beamCodeDict = {}

3498

self.beamCodeDict = {}

3499

self.beamRangeDict = {}

3499

self.beamRangeDict = {}

3500

3501

#experiment cgf file

3501

#experiment cgf file

3502

self.npulsesint_fromfile = None

3502

self.npulsesint_fromfile = None

3503

self.recordsperfile_fromfile = None

3503

self.recordsperfile_fromfile = None

3504

self.nbeamcodes_fromfile = None

3504

self.nbeamcodes_fromfile = None

3505

self.ngates_fromfile = None

3505

self.ngates_fromfile = None

3506

self.ippSeconds_fromfile = None

3506

self.ippSeconds_fromfile = None

3507

self.frequency_h5file = None

3507

self.frequency_h5file = None

3508

3509

3510

self.__firstFile = True

3511

self.buffer_radactime = None

3512

3510

def __createObjByDefault(self):

3513

def __createObjByDefault(self):

3511

3514

3512

dataObj = AMISR()

3515

dataObj = AMISR()

3513

3516

3514

return dataObj

3517

return dataObj

3515

3518

3516

def __setParameters(self,path,startDate,endDate,startTime,endTime,walk):

3519

def __setParameters(self,path,startDate,endDate,startTime,endTime,walk):

3517

self.path = path

3520

self.path = path

3518

self.startDate = startDate

3521

self.startDate = startDate

3519

self.endDate = endDate

3522

self.endDate = endDate

3520

self.startTime = startTime

3523

self.startTime = startTime

3521

self.endTime = endTime

3524

self.endTime = endTime

3522

self.walk = walk

3525

self.walk = walk

3523

3526

3524

def __checkPath(self):

3527

def __checkPath(self):

3525

if os.path.exists(self.path):

3528

if os.path.exists(self.path):

3526

self.status = 1

3529

self.status = 1

3527

else:

3530

else:

3528

self.status = 0

3531

self.status = 0

3529

print 'Path:%s does not exists'%self.path

3532

print 'Path:%s does not exists'%self.path

3530

3533

3531

return

3534

return

3532

3535

3533

def __selDates(self, amisr_dirname_format):

3536

def __selDates(self, amisr_dirname_format):

3534

try:

3537

try:

3535

year = int(amisr_dirname_format[0:4])

3538

year = int(amisr_dirname_format[0:4])

3536

month = int(amisr_dirname_format[4:6])

3539

month = int(amisr_dirname_format[4:6])

3537

dom = int(amisr_dirname_format[6:8])

3540

dom = int(amisr_dirname_format[6:8])

3538

thisDate = datetime.date(year,month,dom)

3541

thisDate = datetime.date(year,month,dom)

3539

3542

3540

if (thisDate>=self.startDate and thisDate <= self.endDate):

3543

if (thisDate>=self.startDate and thisDate <= self.endDate):

3541

return amisr_dirname_format

3544

return amisr_dirname_format

3542

except:

3545

except:

3543

return None

3546

return None

3544

3547

3545

def __findDataForDates(self):

3548

def __findDataForDates(self):

3546

3549

3547

3550

3548

3551

3549

if not(self.status):

3552

if not(self.status):

3550

return None

3553

return None

3551

3554

3552

pat = '\d+.\d+'

3555

pat = '\d+.\d+'

3553

dirnameList = [re.search(pat,x) for x in os.listdir(self.path)]

3556

dirnameList = [re.search(pat,x) for x in os.listdir(self.path)]

3554

dirnameList = filter(lambda x:x!=None,dirnameList)

3557

dirnameList = filter(lambda x:x!=None,dirnameList)

3555

dirnameList = [x.string for x in dirnameList]

3558

dirnameList = [x.string for x in dirnameList]

3556

dirnameList = [self.__selDates(x) for x in dirnameList]

3559

dirnameList = [self.__selDates(x) for x in dirnameList]

3557

dirnameList = filter(lambda x:x!=None,dirnameList)

3560

dirnameList = filter(lambda x:x!=None,dirnameList)

3558

if len(dirnameList)>0:

3561

if len(dirnameList)>0:

3559

self.status = 1

3562

self.status = 1

3560

self.dirnameList = dirnameList

3563

self.dirnameList = dirnameList

3561

self.dirnameList.sort()

3564

self.dirnameList.sort()

3562

else:

3565

else:

3563

self.status = 0

3566

self.status = 0

3564

return None

3567

return None

3565

3568

3566

def __getTimeFromData(self):

3569

def __getTimeFromData(self):

3567

pass

3570

pass

3568

3571

3569

def __filterByGlob1(self, dirName):

3572

def __filterByGlob1(self, dirName):

3570

filter_files = glob.glob1(dirName, '*.*%s'%self.extension_file)

3573

filter_files = glob.glob1(dirName, '*.*%s'%self.extension_file)

3571

filterDict = {}

3574

filterDict = {}

3572

filterDict.setdefault(dirName)

3575

filterDict.setdefault(dirName)

3573

filterDict[dirName] = filter_files

3576

filterDict[dirName] = filter_files

3574

return filterDict

3577

return filterDict

3575

3578

3576

def __getFilenameList(self, fileListInKeys, dirList):

3579

def __getFilenameList(self, fileListInKeys, dirList):

3577

for value in fileListInKeys:

3580

for value in fileListInKeys:

3578

dirName = value.keys()[0]

3581

dirName = value.keys()[0]

3579

for file in value[dirName]:

3582

for file in value[dirName]:

3580

filename = os.path.join(dirName, file)

3583

filename = os.path.join(dirName, file)

3581

self.filenameList.append(filename)

3584

self.filenameList.append(filename)

3582

3585

3583

3586

3584

def __selectDataForTimes(self):

3587

def __selectDataForTimes(self):

3585

#aun no esta implementado el filtro for tiempo

3588

#aun no esta implementado el filtro for tiempo

3586

if not(self.status):

3589

if not(self.status):

3587

return None

3590

return None

3588

3591

3589

dirList = [os.path.join(self.path,x) for x in self.dirnameList]

3592

dirList = [os.path.join(self.path,x) for x in self.dirnameList]

3590

3593

3591

fileListInKeys = [self.__filterByGlob1(x) for x in dirList]

3594

fileListInKeys = [self.__filterByGlob1(x) for x in dirList]

3592

3595

3593

self.__getFilenameList(fileListInKeys, dirList)

3596

self.__getFilenameList(fileListInKeys, dirList)

3594

3597

3595

if len(self.filenameList)>0:

3598

if len(self.filenameList)>0:

3596

self.status = 1

3599

self.status = 1

3597

self.filenameList.sort()

3600

self.filenameList.sort()

3598

else:

3601

else:

3599

self.status = 0

3602

self.status = 0

3600

return None

3603

return None

3601

3604

3602

3605

3603

def __searchFilesOffline(self,

3606

def __searchFilesOffline(self,

3604

path,

3607

path,

3605

startDate,

3608

startDate,

3606

endDate,

3609

endDate,

3607

startTime=datetime.time(0,0,0),

3610

startTime=datetime.time(0,0,0),

3608

endTime=datetime.time(23,59,59),

3611

endTime=datetime.time(23,59,59),

3609

walk=True):

3612

walk=True):

3610

3613

3611

self.__setParameters(path, startDate, endDate, startTime, endTime, walk)

3614

self.__setParameters(path, startDate, endDate, startTime, endTime, walk)

3612

3615

3613

self.__checkPath()

3616

self.__checkPath()

3614

3617

3615

self.__findDataForDates()

3618

self.__findDataForDates()

3616

3619

3617

self.__selectDataForTimes()

3620

self.__selectDataForTimes()

3618

3621

3619

for i in range(len(self.filenameList)):

3622

for i in range(len(self.filenameList)):

3620

print "%s" %(self.filenameList[i])

3623

print "%s" %(self.filenameList[i])

3621

3624

3622

return

3625

return

3623

3626

3624

def __setNextFileOffline(self):

3627

def __setNextFileOffline(self):

3625

idFile = self.fileIndex

3628

idFile = self.fileIndex

3626

3629

3627

while (True):

3630

while (True):

3628

idFile += 1

3631

idFile += 1

3629

if not(idFile < len(self.filenameList)):

3632

if not(idFile < len(self.filenameList)):

3630

self.flagNoMoreFiles = 1

3633

self.flagNoMoreFiles = 1

3631

print "No more Files"

3634

print "No more Files"

3632

return 0

3635

return 0

3633

3636

3634

filename = self.filenameList[idFile]

3637

filename = self.filenameList[idFile]

3635

3638

3636

amisrFilePointer = h5py.File(filename,'r')

3639

amisrFilePointer = h5py.File(filename,'r')

3637

3640

3638

break

3641

break

3639

3642

3640

self.flagIsNewFile = 1

3643

self.flagIsNewFile = 1

3641

self.fileIndex = idFile

3644

self.fileIndex = idFile

3642

self.filename = filename

3645

self.filename = filename

3643

3646

3644

self.amisrFilePointer = amisrFilePointer

3647

self.amisrFilePointer = amisrFilePointer

3645

3648

3646

print "Setting the file: %s"%self.filename

3649

print "Setting the file: %s"%self.filename

3647

3650

3648

return 1

3651

return 1

3649

3652

3650

def __readHeader(self):

3653

def __readHeader(self):

3651

self.radacHeaderObj = RadacHeader(self.amisrFilePointer)

3654

self.radacHeaderObj = RadacHeader(self.amisrFilePointer)

3652

3655

3653

#update values from experiment cfg file

3656

#update values from experiment cfg file

3654

self.radacHeaderObj.nrecords = self.recordsperfile_fromfile

3657

if self.radacHeaderObj.nrecords == self.recordsperfile_fromfile:

3658

self.radacHeaderObj.nrecords = self.recordsperfile_fromfile

3655

self.radacHeaderObj.nbeams = self.nbeamcodes_fromfile

3659

self.radacHeaderObj.nbeams = self.nbeamcodes_fromfile

3656

self.radacHeaderObj.npulses = self.npulsesint_fromfile

3660

self.radacHeaderObj.npulses = self.npulsesint_fromfile

3657

self.radacHeaderObj.nsamples = self.ngates_fromfile

3661

self.radacHeaderObj.nsamples = self.ngates_fromfile

3658

3662

3659

#get tuning frequency

3663

#get tuning frequency

3660

frequency_h5file_dataset = self.amisrFilePointer.get('Rx'+'/TuningFrequency')

3664

frequency_h5file_dataset = self.amisrFilePointer.get('Rx'+'/TuningFrequency')

3661

self.frequency_h5file = frequency_h5file_dataset[0,0]

3665

self.frequency_h5file = frequency_h5file_dataset[0,0]

3662

3666

3663

self.flagIsNewFile = 1

3667

self.flagIsNewFile = 1

3664

3668

3665

def __getBeamCode(self):

3669

def __getBeamCode(self):

3666

self.beamCodeDict = {}

3670

self.beamCodeDict = {}

3667

self.beamRangeDict = {}

3671

self.beamRangeDict = {}

3668

3672

3669

for i in range(len(self.radacHeaderObj.beamCode[0,:])):

3673

for i in range(len(self.radacHeaderObj.beamCode[0,:])):

3670

self.beamCodeDict.setdefault(i)

3674

self.beamCodeDict.setdefault(i)

3671

self.beamRangeDict.setdefault(i)

3675

self.beamRangeDict.setdefault(i)

3672

self.beamCodeDict[i] = self.radacHeaderObj.beamCode[0,i]

3676

self.beamCodeDict[i] = self.radacHeaderObj.beamCode[0,i]

3673

3677

3674

3678

3675

just4record0 = self.radacHeaderObj.beamCodeByPulse[0,:]

3679

just4record0 = self.radacHeaderObj.beamCodeByPulse[0,:]

3676

3680

3677

for i in range(len(self.beamCodeDict.values())):

3681

for i in range(len(self.beamCodeDict.values())):

3678

xx = numpy.where(just4record0==self.beamCodeDict.values()[i])

3682

xx = numpy.where(just4record0==self.beamCodeDict.values()[i])

3679

self.beamRangeDict[i] = xx[0]

3683

self.beamRangeDict[i] = xx[0]

3680

3684

3681

def __getExpParameters(self):

3685

def __getExpParameters(self):

3682

if not(self.status):

3686

if not(self.status):

3683

return None

3687

return None

3684

3688

3685

experimentCfgPath = os.path.join(self.path, self.dirnameList[0], 'Setup')

3689

experimentCfgPath = os.path.join(self.path, self.dirnameList[0], 'Setup')

3686

3690

3687

expFinder = glob.glob1(experimentCfgPath,'*.exp')

3691

expFinder = glob.glob1(experimentCfgPath,'*.exp')

3688

if len(expFinder)== 0:

3692

if len(expFinder)== 0:

3689

self.status = 0

3693

self.status = 0

3690

return None

3694

return None

3691

3695

3692

experimentFilename = os.path.join(experimentCfgPath,expFinder[0])

3696

experimentFilename = os.path.join(experimentCfgPath,expFinder[0])

3693

3697

3694

f = open(experimentFilename)

3698

f = open(experimentFilename)

3695

lines = f.readlines()

3699

lines = f.readlines()

3696

f.close()

3700

f.close()

3697

3701

3698

parmsList = ['npulsesint*','recordsperfile*','nbeamcodes*','ngates*']

3702

parmsList = ['npulsesint*','recordsperfile*','nbeamcodes*','ngates*']

3699

filterList = [fnmatch.filter(lines, x) for x in parmsList]

3703

filterList = [fnmatch.filter(lines, x) for x in parmsList]

3700

3704

3701

3705

3702

values = [re.sub(r'\D',"",x[0]) for x in filterList]

3706

values = [re.sub(r'\D',"",x[0]) for x in filterList]

3703

3707

3704

self.npulsesint_fromfile = int(values[0])

3708

self.npulsesint_fromfile = int(values[0])

3705

self.recordsperfile_fromfile = int(values[1])

3709

self.recordsperfile_fromfile = int(values[1])

3706

self.nbeamcodes_fromfile = int(values[2])

3710

self.nbeamcodes_fromfile = int(values[2])

3707

self.ngates_fromfile = int(values[3])

3711

self.ngates_fromfile = int(values[3])

3708

3712

3709

tufileFinder = fnmatch.filter(lines, 'tufile=*')

3713

tufileFinder = fnmatch.filter(lines, 'tufile=*')

3710

tufile = tufileFinder[0].split('=')[1].split('\n')[0]

3714

tufile = tufileFinder[0].split('=')[1].split('\n')[0]

3711

tufilename = os.path.join(experimentCfgPath,tufile)

3715

tufilename = os.path.join(experimentCfgPath,tufile)

3712

3716

3713

f = open(tufilename)

3717

f = open(tufilename)

3714

lines = f.readlines()

3718

lines = f.readlines()

3715

f.close()

3719

f.close()

3716

self.ippSeconds_fromfile = float(lines[1].split()[2])/1E6

3720

self.ippSeconds_fromfile = float(lines[1].split()[2])/1E6

3717

3721

3718

3722

3719

self.status = 1

3723

self.status = 1

3720

3724

3725

def __setIdsAndArrays(self):

3726

self.dataByFrame = self.__setDataByFrame()

3727

self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[0, :]

3728

self.readRanges()

3729

self.idpulse_range1, self.idpulse_range2 = self.radacHeaderObj.getIndexRangeToPulse(0)

3730

self.radacTimeByFrame = numpy.zeros(self.radacHeaderObj.npulses)

3731

self.buffer_radactime = numpy.zeros_like(self.radacTimeByFrame)

3732

3733

3721

def __setNextFile(self):

3734

def __setNextFile(self):

3722

3735

3723

newFile = self.__setNextFileOffline()

3736

newFile = self.__setNextFileOffline()

3724

3737

3725

if not(newFile):

3738

if not(newFile):

3726

return 0

3739

return 0

3727

3740

3728

self.__readHeader()

3741

self.__readHeader()

3742

3743

if self.__firstFile:

3744

self.__setIdsAndArrays()

3745

self.__firstFile = False

3746

3729

self.__getBeamCode()

3747

self.__getBeamCode()

3730

self.readDataBlock()

3748

self.readDataBlock()

3731

3749

3732

3750

3733

def setup(self,path=None,

3751

def setup(self,path=None,

3734

startDate=None,

3752

startDate=None,

3735

endDate=None,

3753

endDate=None,

3736

startTime=datetime.time(0,0,0),

3754

startTime=datetime.time(0,0,0),

3737

endTime=datetime.time(23,59,59),

3755

endTime=datetime.time(23,59,59),

3738

walk=True):

3756

walk=True):

3739

3757

3740

#Busqueda de archivos offline

3758

#Busqueda de archivos offline

3741

self.__searchFilesOffline(path, startDate, endDate, startTime, endTime, walk)

3759

self.__searchFilesOffline(path, startDate, endDate, startTime, endTime, walk)

3742

3760

3743

if not(self.filenameList):

3761

if not(self.filenameList):

3744

print "There is no files into the folder: %s"%(path)

3762

print "There is no files into the folder: %s"%(path)

3745

3763

3746

sys.exit(-1)

3764

sys.exit(-1)

3747

3765

3748

self.__getExpParameters()

3766

self.__getExpParameters()

3749

3767

3750

self.fileIndex = -1

3768

self.fileIndex = -1

3751

3769

3752

self.__setNextFile()

3770

self.__setNextFile()

3753

3771

3754

def readRanges(self):

3772

def readRanges(self):

3755

dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Range')

3773

dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Range')

3756

#self.rangeFromFile = dataset.value

3774

#self.rangeFromFile = dataset.value

3757

self.rangeFromFile = numpy.reshape(dataset.value,(-1))

3775

self.rangeFromFile = numpy.reshape(dataset.value,(-1))

3758

return range

3776

return range

3759

3777

3760

3778

3761

def readRadacTime(self,idrecord, range1, range2):

3779

def readRadacTime(self,idrecord, range1, range2):

3762

self.radacTimeFromFile = self.radacHeaderObj.radacTime.value

3780

self.radacTimeFromFile = self.radacHeaderObj.radacTime.value

3763

3781

3764

radacTimeByFrame = numpy.zeros((self.radacHeaderObj.npulses))

3782

radacTimeByFrame = numpy.zeros((self.radacHeaderObj.npulses))

3765

#radacTimeByFrame = dataset[idrecord - 1,range1]

3783

#radacTimeByFrame = dataset[idrecord - 1,range1]

3766

#radacTimeByFrame = dataset[idrecord,range2]

3784

#radacTimeByFrame = dataset[idrecord,range2]

3767

3785

3768

return radacTimeByFrame

3786

return radacTimeByFrame

3769

3787

3770

def readBeamCode(self, idrecord, range1, range2):

3788

def readBeamCode(self, idrecord, range1, range2):

3771

dataset = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode')

3789

dataset = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode')

3772

beamcodeByFrame = numpy.zeros((self.radacHeaderObj.npulses))

3790

beamcodeByFrame = numpy.zeros((self.radacHeaderObj.npulses))

3773

self.beamCodesFromFile = dataset.value

3791

self.beamCodesFromFile = dataset.value

3774

3792

3775

#beamcodeByFrame[range1] = dataset[idrecord - 1, range1]

3793

#beamcodeByFrame[range1] = dataset[idrecord - 1, range1]

3776

#beamcodeByFrame[range2] = dataset[idrecord, range2]

3794

#beamcodeByFrame[range2] = dataset[idrecord, range2]

3777

beamcodeByFrame[range1] = dataset[idrecord, range1]

3795

beamcodeByFrame[range1] = dataset[idrecord, range1]

3778

beamcodeByFrame[range2] = dataset[idrecord, range2]

3796

beamcodeByFrame[range2] = dataset[idrecord, range2]

3779

3797

3780

return beamcodeByFrame

3798

return beamcodeByFrame

3781

3799

3782

3800

3783

def __setDataByFrame(self):

3801

def __setDataByFrame(self):

3784

ndata = 2 # porque es complejo

3802

ndata = 2 # porque es complejo

3785

dataByFrame = numpy.zeros((self.radacHeaderObj.npulses, self.radacHeaderObj.nsamples, ndata))

3803

dataByFrame = numpy.zeros((self.radacHeaderObj.npulses, self.radacHeaderObj.nsamples, ndata))

3786

return dataByFrame

3804

return dataByFrame

3787

3805

3788

def __readDataSet(self):

3806

def __readDataSet(self):

3789

dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Data')

3807

dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Data')

3790

return dataset

3808

return dataset

3791

3809

3792

def __setDataBlock(self,):

3810

def __setDataBlock(self,):

3793

real = self.dataByFrame[:,:,0] #asumo que 0 es real

3811

real = self.dataByFrame[:,:,0] #asumo que 0 es real

3794

imag = self.dataByFrame[:,:,1] #asumo que 1 es imaginario

3812

imag = self.dataByFrame[:,:,1] #asumo que 1 es imaginario

3795

datablock = real + imag*1j #armo el complejo

3813

datablock = real + imag*1j #armo el complejo

3796

return datablock

3814

return datablock

3797

3815

3798

def readSamples_version1(self,idrecord):

3816

def readSamples_version1(self,idrecord):

3799

#estas tres primeras lineas solo se deben ejecutar una vez

3817

#estas tres primeras lineas solo se deben ejecutar una vez

3800

if self.flagIsNewFile:

3818

if self.flagIsNewFile:

3801

self.idpulse_range1, self.idpulse_range2 = self.radacHeaderObj.getIndexRangeToPulse(0)

3802

self.dataByFrame = self.__setDataByFrame()

3803

self.beamCodeByFrame = self.readBeamCode(idrecord, self.idpulse_range1, self.idpulse_range2)

3804

self.radacTimeByFrame = self.readRadacTime(idrecord, self.idpulse_range1, self.idpulse_range2)

3805

#reading dataset

3819

#reading dataset

3806

self.dataset = self.__readDataSet()

3820

self.dataset = self.__readDataSet()

3821

self.flagIsNewFile = 0

3807

3822

3808

if idrecord == 0:

3823

if idrecord == 0:

3824

#if self.buffer_last_record == None:

3825

selectorById = self.radacHeaderObj.pulseCount[0,self.idpulse_range2]

3809

3826

3810

if len(numpy.where(self.dataByFrame!=0.0)[0]) or len(numpy.where(self.dataByFrame!=0.0)[1]) or len(numpy.where(self.dataByFrame!=0.0)[2]):

3827

self.dataByFrame[selectorById,:,:] = self.dataset[0, self.idpulse_range2,:,:]

3811

#falta agregar una condicion para datos discontinuos

3828

3812

#por defecto une los datos del record anterior

3829

self.radacTimeByFrame[selectorById] = self.radacHeaderObj.radacTime[0, self.idpulse_range2]

3813

self.dataByFrame[self.idpulse_range2, :, :] = self.dataset[idrecord, self.idpulse_range2, :, :]

3830

3814

#timepulse

3831

selectorById = self.radacHeaderObj.pulseCount[0,self.idpulse_range1]

3815

self.radacTimeByFrame[self.idpulse_range2] = self.radacHeaderObj.radacTime[idrecord, self.idpulse_range2]

3832

3816

else:

3833

self.radacTimeByFrame[selectorById] = self.buffer_radactime[selectorById]

3817

self.dataByFrame[self.idpulse_range1, :, :] = self.dataset[idrecord, self.idpulse_range1, :, :]

3818

3819

self.radacTimeByFrame[self.idpulse_range1] = self.radacHeaderObj.radacTime[idrecord, self.idpulse_range1]

3820

3834

3821

datablock = self.__setDataBlock()

3835

datablock = self.__setDataBlock()

3822

3836

3823

return datablock

3837

return datablock

3838

3839

selectorById = self.radacHeaderObj.pulseCount[idrecord-1,self.idpulse_range1]

3840

self.dataByFrame[selectorById,:,:] = self.dataset[idrecord-1, self.idpulse_range1, :, :]

3841

self.radacTimeByFrame[selectorById] = self.radacHeaderObj.radacTime[idrecord-1, self.idpulse_range1]

3824

3842

3825

self.dataByFrame[self.idpulse_range1, :, :] = self.dataset[idrecord - 1,self.idpulse_range1, :, :]

3843

selectorById = self.radacHeaderObj.pulseCount[idrecord,self.idpulse_range2]#data incompleta ultimo archivo de carpeta, verifica el record real segun la dimension del arreglo de datos

3826

self.dataByFrame[self.~~idpulse_range2~~, :, :] = self.dataset[idrecord, self.idpulse_range2, :, :]

3844

self.dataByFrame[selectorById,:,:] = self.dataset[idrecord, self.idpulse_range2, :, :]

3827

datablock = self.__setDataBlock()

3845

self.radacTimeByFrame[selectorById] = self.radacHeaderObj.radacTime[idrecord, self.idpulse_range2]

3828

self.flagIsNewFile = 0

3829

3830

self.dataByFrame[self.idpulse_range1, :, :] = self.dataset[idrecord, self.idpulse_range1, :, :]

3831

3846

3847

datablock = self.__setDataBlock()

3848

3849

selectorById = self.radacHeaderObj.pulseCount[idrecord,self.idpulse_range1]

3850

self.dataByFrame[selectorById,:,:] = self.dataset[idrecord, self.idpulse_range1, :, :]

3851

self.buffer_radactime[selectorById] = self.radacHeaderObj.radacTime[idrecord, self.idpulse_range1]

3832

3852

3833

return datablock

3853

return datablock

3834

3854

3835

3855

3836

def readSamples(self,idrecord):

3856

def readSamples(self,idrecord):

3837

if self.flagIsNewFile:

3857

if self.flagIsNewFile:

3838

self.dataByFrame = self.__setDataByFrame()

3858

self.dataByFrame = self.__setDataByFrame()

3839

self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[idrecord, :]

3859

self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[idrecord, :]

3840

3860

3841

#reading ranges

3861

#reading ranges

3842

self.readRanges()

3862

self.readRanges()

3843

#reading dataset

3863

#reading dataset

3844

self.dataset = self.__readDataSet()

3864

self.dataset = self.__readDataSet()

3845

3865

3846

self.flagIsNewFile = 0

3866

self.flagIsNewFile = 0

3847

self.radacTimeByFrame = self.radacHeaderObj.radacTime.value[idrecord, :]

3867

self.radacTimeByFrame = self.radacHeaderObj.radacTime.value[idrecord, :]

3848

self.dataByFrame = self.dataset[idrecord, :, :, :]

3868

self.dataByFrame = self.dataset[idrecord, :, :, :]

3849

datablock = self.__setDataBlock()

3869

datablock = self.__setDataBlock()

3850

return datablock

3870

return datablock

3851

3871

3852

3872

3853

def readDataBlock(self):

3873

def readDataBlock(self):

3854

3874

3875

self.datablock = self.readSamples_version1(self.idrecord_count)

3855

#self.datablock = self.readSamples(self.idrecord_count)

3876

#self.datablock = self.readSamples(self.idrecord_count)

3856

self.datablock = self.readSamples(self.idrecord_count)

3857

#print 'record:', self.idrecord_count

3877

#print 'record:', self.idrecord_count

3858

3878

3859

self.idrecord_count += 1

3879

self.idrecord_count += 1

3860

self.profileIndex = 0

3880

self.profileIndex = 0

3861

3881

3862

if self.idrecord_count >= self.radacHeaderObj.nrecords:

3882

if self.idrecord_count >= self.radacHeaderObj.nrecords:

3863

self.idrecord_count = 0

3883

self.idrecord_count = 0

3864

self.flagIsNewFile = 1

3884

self.flagIsNewFile = 1

3865

3885

3866

def readNextBlock(self):

3886

def readNextBlock(self):

3867

3887

3868

self.readDataBlock()

3888

self.readDataBlock()

3869

3889

3870

if self.flagIsNewFile:

3890

if self.flagIsNewFile:

3871

self.__setNextFile()

3891

self.__setNextFile()

3872

pass

3892

pass

3873

3893

3874

def __hasNotDataInBuffer(self):

3894

def __hasNotDataInBuffer(self):

3875

#self.radacHeaderObj.npulses debe ser otra variable para considerar el numero de pulsos a tomar en el primer y ultimo record

3895

#self.radacHeaderObj.npulses debe ser otra variable para considerar el numero de pulsos a tomar en el primer y ultimo record

3876

if self.profileIndex >= self.radacHeaderObj.npulses:

3896

if self.profileIndex >= self.radacHeaderObj.npulses:

3877

return 1

3897

return 1

3878

return 0

3898

return 0

3879

3899

3880

def printUTC(self):

3900

def printUTC(self):

3881

print self.dataOut.utctime

3901

print self.dataOut.utctime

3882

print ''

3902

print ''

3883

3903

3884

def setObjProperties(self):

3904

def setObjProperties(self):

3885

self.dataOut.heightList = self.rangeFromFile/1000.0 #km

3905

self.dataOut.heightList = self.rangeFromFile/1000.0 #km

3886

self.dataOut.nProfiles = self.radacHeaderObj.npulses

3906

self.dataOut.nProfiles = self.radacHeaderObj.npulses

3887

self.dataOut.nRecords = self.radacHeaderObj.nrecords

3907

self.dataOut.nRecords = self.radacHeaderObj.nrecords

3888

self.dataOut.nBeams = self.radacHeaderObj.nbeams

3908

self.dataOut.nBeams = self.radacHeaderObj.nbeams

3889

self.dataOut.ippSeconds = self.ippSeconds_fromfile

3909

self.dataOut.ippSeconds = self.ippSeconds_fromfile

3890

self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt

3910

self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt

3891

self.dataOut.frequency = self.frequency_h5file

3911

self.dataOut.frequency = self.frequency_h5file

3892

self.dataOut.nBaud = None

3912

self.dataOut.nBaud = None

3893

self.dataOut.nCode = None

3913

self.dataOut.nCode = None

3894

self.dataOut.code = None

3914

self.dataOut.code = None

3895

3915

3896

self.dataOut.beamCodeDict = self.beamCodeDict

3916

self.dataOut.beamCodeDict = self.beamCodeDict

3897

self.dataOut.beamRangeDict = self.beamRangeDict

3917

self.dataOut.beamRangeDict = self.beamRangeDict

3898

3918

3899

def getData(self):

3919

def getData(self):

3900

3920

3901

if self.flagNoMoreFiles:

3921

if self.flagNoMoreFiles:

3902

self.dataOut.flagNoData = True

3922

self.dataOut.flagNoData = True

3903

print 'Process finished'

3923

print 'Process finished'

3904

return 0

3924

return 0

3905

3925

3906

if self.__hasNotDataInBuffer():

3926

if self.__hasNotDataInBuffer():

3907

self.readNextBlock()

3927

self.readNextBlock()

3908

# if not( self.readNextBlock() ):

3928

3909

# return 0

3910

# self.getFirstHeader()

3911

3929

3912

if self.datablock == None: # setear esta condicion cuando no hayan datos por leers

3930

if self.datablock == None: # setear esta condicion cuando no hayan datos por leers

3913

self.dataOut.flagNoData = True

3931

self.dataOut.flagNoData = True

3914

return 0

3932

return 0

3915

3933

3916

self.dataOut.data = numpy.reshape(self.datablock[self.profileIndex,:],(1,-1))

3934

self.dataOut.data = numpy.reshape(self.datablock[self.profileIndex,:],(1,-1))

3917

3935

3918

self.dataOut.utctime = self.radacTimeByFrame[self.profileIndex]

3936

self.dataOut.utctime = self.radacTimeByFrame[self.profileIndex]

3919

3937

3920

self.dataOut.flagNoData = False

3938

self.dataOut.flagNoData = False

3921

3939

3922

self.profileIndex += 1

3940

self.profileIndex += 1

3923

3941

3924

return self.dataOut.data

3942

return self.dataOut.data

3925

3943

3926

3944

3927

def run(self, **kwargs):

3945

def run(self, **kwargs):

3928

if not(self.isConfig):

3946

if not(self.isConfig):

3929

self.setup(**kwargs)

3947

self.setup(**kwargs)

3930

self.setObjProperties()

3948

self.setObjProperties()

3931

self.isConfig = True

3949

self.isConfig = True

3932

3950

3933

self.getData()

3951

self.getData()

	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