schain Commit - r466:36935db8a2f5 · Jicamarca Repository

             '''
             $Author: murco $
             $Id: JRODataIO.py 169 2012-11-19 21:57:03Z murco $
             '''
             import os, sys
             import glob
             import time
             import numpy
             import fnmatch
             import time, datetime
             from 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()

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

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

13

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

14

try:

14

try:

15

import pyfits

15

import pyfits

16

except:

16

except:

17

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

17

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

18

19

from jrodata import *

19

from jrodata import *

20

from jroheaderIO import *

20

from jroheaderIO import *

21

from jroprocessing import *

21

from jroprocessing import *

22

23

LOCALTIME = True #-18000

23

LOCALTIME = True #-18000

24

25

def isNumber(str):

25

def isNumber(str):

26

"""

26

"""

27

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

27

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

28

29

Excepciones:

29

Excepciones:

30

Si un determinado string no puede ser convertido a numero

30

Si un determinado string no puede ser convertido a numero

31

Input:

31

Input:

32

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

32

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

33

34

Return:

34

Return:

35

True : si el string es uno numerico

35

True : si el string es uno numerico

36

False : no es un string numerico

36

False : no es un string numerico

37

"""

37

"""

38

try:

38

try:

39

float( str )

39

float( str )

40

return True

40

return True

41

except:

41

except:

42

return False

42

return False

43

44

def isThisFileinRange(filename, startUTSeconds, endUTSeconds):

44

def isThisFileinRange(filename, startUTSeconds, endUTSeconds):

45

"""

45

"""

46

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

46

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

47

48

Inputs:

48

Inputs:

49

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

49

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

50

51

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

51

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

52

segundos contados desde 01/01/1970.

52

segundos contados desde 01/01/1970.

53

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

53

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

54

segundos contados desde 01/01/1970.

54

segundos contados desde 01/01/1970.

55

56

Return:

56

Return:

57

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

57

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

58

fecha especificado, de lo contrario retorna False.

58

fecha especificado, de lo contrario retorna False.

59

60

Excepciones:

60

Excepciones:

61

Si el archivo no existe o no puede ser abierto

61

Si el archivo no existe o no puede ser abierto

62

Si la cabecera no puede ser leida.

62

Si la cabecera no puede ser leida.

63

64

"""

64

"""

65

basicHeaderObj = BasicHeader(LOCALTIME)

65

basicHeaderObj = BasicHeader(LOCALTIME)

66

67

try:

67

try:

68

fp = open(filename,'rb')

68

fp = open(filename,'rb')

69

except:

69

except:

70

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

70

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

71

72

sts = basicHeaderObj.read(fp)

72

sts = basicHeaderObj.read(fp)

73

fp.close()

73

fp.close()

74

75

if not(sts):

75

if not(sts):

76

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

76

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

77

return 0

77

return 0

78

79

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

79

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

80

return 0

80

return 0

81

82

return 1

82

return 1

83

84

def isFileinThisTime(filename, startTime, endTime):

84

def isFileinThisTime(filename, startTime, endTime):

85

"""

85

"""

86

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

86

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

87

88

Inputs:

88

Inputs:

89

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

89

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

90

91

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

91

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

92

93

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

93

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

94

95

Return:

95

Return:

96

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

96

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

97

fecha especificado, de lo contrario retorna False.

97

fecha especificado, de lo contrario retorna False.

98

99

Excepciones:

99

Excepciones:

100

Si el archivo no existe o no puede ser abierto

100

Si el archivo no existe o no puede ser abierto

101

Si la cabecera no puede ser leida.

101

Si la cabecera no puede ser leida.

102

103

"""

103

"""

104

105

106

try:

106

try:

107

fp = open(filename,'rb')

107

fp = open(filename,'rb')

108

except:

108

except:

109

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

109

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

110

111

basicHeaderObj = BasicHeader(LOCALTIME)

111

basicHeaderObj = BasicHeader(LOCALTIME)

112

sts = basicHeaderObj.read(fp)

112

sts = basicHeaderObj.read(fp)

113

fp.close()

113

fp.close()

114

115

thisDatetime = basicHeaderObj.datatime

115

thisDatetime = basicHeaderObj.datatime

116

thisTime = basicHeaderObj.datatime.time()

116

thisTime = basicHeaderObj.datatime.time()

117

118

if not(sts):

118

if not(sts):

119

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

119

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

120

return None

120

return None

121

122

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

122

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

123

return None

123

return None

124

125

return thisDatetime

125

return thisDatetime

126

127

def getFileFromSet(path,ext,set):

127

def getFileFromSet(path,ext,set):

128

validFilelist = []

128

validFilelist = []

129

fileList = os.listdir(path)

129

fileList = os.listdir(path)

130

131

# 0 1234 567 89A BCDE

131

# 0 1234 567 89A BCDE

132

# H YYYY DDD SSS .ext

132

# H YYYY DDD SSS .ext

133

134

for file in fileList:

134

for file in fileList:

135

try:

135

try:

136

year = int(file[1:5])

136

year = int(file[1:5])

137

doy = int(file[5:8])

137

doy = int(file[5:8])

138

139

140

except:

140

except:

141

continue

141

continue

142

143

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

143

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

144

continue

144

continue

145

146

validFilelist.append(file)

146

validFilelist.append(file)

147

148

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

148

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

149

150

if len(myfile)!= 0:

150

if len(myfile)!= 0:

151

return myfile[0]

151

return myfile[0]

152

else:

152

else:

153

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

153

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

154

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

154

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

155

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

155

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

156

157

if validFilelist:

157

if validFilelist:

158

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

158

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

159

return validFilelist[-1]

159

return validFilelist[-1]

160

161

return None

161

return None

162

163

164

def getlastFileFromPath(path, ext):

164

def getlastFileFromPath(path, ext):

165

"""

165

"""

166

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

166

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

167

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

167

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

168

169

Input:

169

Input:

170

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

170

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

171

ext : extension de los files contenidos en una carpeta

171

ext : extension de los files contenidos en una carpeta

172

173

Return:

173

Return:

174

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

174

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

175

"""

175

"""

176

validFilelist = []

176

validFilelist = []

177

fileList = os.listdir(path)

177

fileList = os.listdir(path)

178

179

# 0 1234 567 89A BCDE

179

# 0 1234 567 89A BCDE

180

# H YYYY DDD SSS .ext

180

# H YYYY DDD SSS .ext

181

182

for file in fileList:

182

for file in fileList:

183

try:

183

try:

184

year = int(file[1:5])

184

year = int(file[1:5])

185

doy = int(file[5:8])

185

doy = int(file[5:8])

186

187

188

except:

188

except:

189

continue

189

continue

190

191

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

191

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

192

continue

192

continue

193

194

validFilelist.append(file)

194

validFilelist.append(file)

195

196

if validFilelist:

196

if validFilelist:

197

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

197

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

198

return validFilelist[-1]

198

return validFilelist[-1]

199

200

return None

200

return None

201

202

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

202

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

203

"""

203

"""

204

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

204

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

205

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

205

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

206

el path exacto de un determinado file.

206

el path exacto de un determinado file.

207

208

Example :

208

Example :

209

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

209

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

210

211

Entonces la funcion prueba con las siguientes combinaciones

211

Entonces la funcion prueba con las siguientes combinaciones

212

.../.../y2009307367.ext

212

.../.../y2009307367.ext

213

.../.../Y2009307367.ext

213

.../.../Y2009307367.ext

214

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

214

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

215

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

215

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

216

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

216

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

217

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

217

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

218

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

218

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

219

220

Return:

220

Return:

221

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

221

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

222

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

222

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

223

para el filename

223

para el filename

224

"""

224

"""

225

fullfilename = None

225

fullfilename = None

226

find_flag = False

226

find_flag = False

227

filename = None

227

filename = None

228

229

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

229

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

230

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

230

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

231

prefixFileList = ['d','D']

231

prefixFileList = ['d','D']

232

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

232

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

233

prefixFileList = ['p','P']

233

prefixFileList = ['p','P']

234

else:

234

else:

235

return None, filename

235

return None, filename

236

237

#barrido por las combinaciones posibles

237

#barrido por las combinaciones posibles

238

for prefixDir in prefixDirList:

238

for prefixDir in prefixDirList:

239

thispath = path

239

thispath = path

240

if prefixDir != None:

240

if prefixDir != None:

241

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

241

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

242

if foldercounter == 0:

242

if foldercounter == 0:

243

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

243

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

244

else:

244

else:

245

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

245

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

246

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

246

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

247

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

247

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

248

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

248

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

249

250

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

250

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

251

find_flag = True

251

find_flag = True

252

break

252

break

253

if find_flag:

253

if find_flag:

254

break

254

break

255

256

if not(find_flag):

256

if not(find_flag):

257

return None, filename

257

return None, filename

258

259

return fullfilename, filename

259

return fullfilename, filename

260

261

def isDoyFolder(folder):

261

def isDoyFolder(folder):

262

try:

262

try:

263

year = int(folder[1:5])

263

year = int(folder[1:5])

264

except:

264

except:

265

return 0

265

return 0

266

267

try:

267

try:

268

doy = int(folder[5:8])

268

doy = int(folder[5:8])

269

except:

269

except:

270

return 0

270

return 0

271

272

return 1

272

return 1

273

274

class JRODataIO:

274

class JRODataIO:

275

276

c = 3E8

276

c = 3E8

277

278

isConfig = False

278

isConfig = False

279

280

basicHeaderObj = BasicHeader(LOCALTIME)

280

basicHeaderObj = BasicHeader(LOCALTIME)

281

282

systemHeaderObj = SystemHeader()

282

systemHeaderObj = SystemHeader()

283

284

radarControllerHeaderObj = RadarControllerHeader()

284

radarControllerHeaderObj = RadarControllerHeader()

285

286

processingHeaderObj = ProcessingHeader()

286

processingHeaderObj = ProcessingHeader()

287

288

online = 0

288

online = 0

289

290

dtype = None

290

dtype = None

291

292

pathList = []

292

pathList = []

293

294

filenameList = []

294

filenameList = []

295

296

filename = None

296

filename = None

297

298

ext = None

298

ext = None

299

300

flagIsNewFile = 1

300

flagIsNewFile = 1

301

302

flagTimeBlock = 0

302

flagTimeBlock = 0

303

304

flagIsNewBlock = 0

304

flagIsNewBlock = 0

305

306

fp = None

306

fp = None

307

308

firstHeaderSize = 0

308

firstHeaderSize = 0

309

310

basicHeaderSize = 24

310

basicHeaderSize = 24

311

312

versionFile = 1103

312

versionFile = 1103

313

314

fileSize = None

314

fileSize = None

315

316

ippSeconds = None

316

ippSeconds = None

317

318

fileSizeByHeader = None

318

fileSizeByHeader = None

319

320

fileIndex = None

320

fileIndex = None

321

322

profileIndex = None

322

profileIndex = None

323

324

blockIndex = None

324

blockIndex = None

325

326

nTotalBlocks = None

326

nTotalBlocks = None

327

328

maxTimeStep = 30

328

maxTimeStep = 30

329

330

lastUTTime = None

330

lastUTTime = None

331

332

datablock = None

332

datablock = None

333

334

dataOut = None

334

dataOut = None

335

336

blocksize = None

336

blocksize = None

337

338

def __init__(self):

338

def __init__(self):

339

340

raise ValueError, "Not implemented"

340

raise ValueError, "Not implemented"

341

342

def run(self):

342

def run(self):

343

344

raise ValueError, "Not implemented"

344

raise ValueError, "Not implemented"

345

346

def getOutput(self):

346

def getOutput(self):

347

348

return self.dataOut

348

return self.dataOut

349

350

class JRODataReader(JRODataIO, ProcessingUnit):

350

class JRODataReader(JRODataIO, ProcessingUnit):

351

352

nReadBlocks = 0

352

nReadBlocks = 0

353

354

delay = 10 #number of seconds waiting a new file

354

delay = 10 #number of seconds waiting a new file

355

356

nTries = 3 #quantity tries

356

nTries = 3 #quantity tries

357

358

nFiles = 3 #number of files for searching

358

nFiles = 3 #number of files for searching

359

360

path = None

360

path = None

361

362

foldercounter = 0

362

foldercounter = 0

363

364

flagNoMoreFiles = 0

364

flagNoMoreFiles = 0

365

366

datetimeList = []

366

datetimeList = []

367

368

__isFirstTimeOnline = 1

368

__isFirstTimeOnline = 1

369

370

__printInfo = True

370

__printInfo = True

371

372

profileIndex = None

372

profileIndex = None

373

374

def __init__(self):

374

def __init__(self):

375

376

"""

376

"""

377

378

"""

378

"""

379

380

raise ValueError, "This method has not been implemented"

380

raise ValueError, "This method has not been implemented"

381

382

383

def createObjByDefault(self):

383

def createObjByDefault(self):

384

"""

384

"""

385

386

"""

386

"""

387

raise ValueError, "This method has not been implemented"

387

raise ValueError, "This method has not been implemented"

388

389

def getBlockDimension(self):

389

def getBlockDimension(self):

390

391

raise ValueError, "No implemented"

391

raise ValueError, "No implemented"

392

393

def __searchFilesOffLine(self,

393

def __searchFilesOffLine(self,

394

path,

394

path,

395

startDate,

395

startDate,

396

endDate,

396

endDate,

397

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

397

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

398

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

398

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

399

set=None,

399

set=None,

400

expLabel='',

400

expLabel='',

401

ext='.r',

401

ext='.r',

402

walk=True):

402

walk=True):

403

404

pathList = []

404

pathList = []

405

406

if not walk:

406

if not walk:

407

#pathList.append(path)

407

#pathList.append(path)

408

multi_path = path.split(',')

408

multi_path = path.split(',')

409

for single_path in multi_path:

409

for single_path in multi_path:

410

pathList.append(single_path)

410

pathList.append(single_path)

411

412

else:

412

else:

413

#dirList = []

413

#dirList = []

414

multi_path = path.split(',')

414

multi_path = path.split(',')

415

for single_path in multi_path:

415

for single_path in multi_path:

416

dirList = []

416

dirList = []

417

for thisPath in os.listdir(single_path):

417

for thisPath in os.listdir(single_path):

418

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

418

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

419

continue

419

continue

420

if not isDoyFolder(thisPath):

420

if not isDoyFolder(thisPath):

421

continue

421

continue

422

423

dirList.append(thisPath)

423

dirList.append(thisPath)

424

425

if not(dirList):

425

if not(dirList):

426

return None, None

426

return None, None

427

428

thisDate = startDate

428

thisDate = startDate

429

430

while(thisDate <= endDate):

430

while(thisDate <= endDate):

431

year = thisDate.timetuple().tm_year

431

year = thisDate.timetuple().tm_year

432

doy = thisDate.timetuple().tm_yday

432

doy = thisDate.timetuple().tm_yday

433

434

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

434

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

435

if len(matchlist) == 0:

435

if len(matchlist) == 0:

436

thisDate += datetime.timedelta(1)

436

thisDate += datetime.timedelta(1)

437

continue

437

continue

438

for match in matchlist:

438

for match in matchlist:

439

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

439

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

440

441

thisDate += datetime.timedelta(1)

441

thisDate += datetime.timedelta(1)

442

443

if pathList == []:

443

if pathList == []:

444

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

444

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

445

return None, None

445

return None, None

446

447

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

447

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

448

449

filenameList = []

449

filenameList = []

450

datetimeList = []

450

datetimeList = []

451

pathDict = {}

451

pathDict = {}

452

filenameList_to_sort = []

452

filenameList_to_sort = []

453

454

for i in range(len(pathList)):

454

for i in range(len(pathList)):

455

456

thisPath = pathList[i]

456

thisPath = pathList[i]

457

458

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

458

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

459

fileList.sort()

459

fileList.sort()

460

pathDict.setdefault(fileList[0])

460

pathDict.setdefault(fileList[0])

461

pathDict[fileList[0]] = i

461

pathDict[fileList[0]] = i

462

filenameList_to_sort.append(fileList[0])

462

filenameList_to_sort.append(fileList[0])

463

464

filenameList_to_sort.sort()

464

filenameList_to_sort.sort()

465

466

for file in filenameList_to_sort:

466

for file in filenameList_to_sort:

467

thisPath = pathList[pathDict[file]]

467

thisPath = pathList[pathDict[file]]

468

469

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

469

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

470

fileList.sort()

470

fileList.sort()

471

472

for file in fileList:

472

for file in fileList:

473

474

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

474

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

475

thisDatetime = isFileinThisTime(filename, startTime, endTime)

475

thisDatetime = isFileinThisTime(filename, startTime, endTime)

476

477

if not(thisDatetime):

477

if not(thisDatetime):

478

continue

478

continue

479

480

filenameList.append(filename)

480

filenameList.append(filename)

481

datetimeList.append(thisDatetime)

481

datetimeList.append(thisDatetime)

482

483

if not(filenameList):

483

if not(filenameList):

484

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

484

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

485

return None, None

485

return None, None

486

487

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

487

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

488

print

488

print

489

490

for i in range(len(filenameList)):

490

for i in range(len(filenameList)):

491

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

491

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

492

493

self.filenameList = filenameList

493

self.filenameList = filenameList

494

self.datetimeList = datetimeList

494

self.datetimeList = datetimeList

495

496

return pathList, filenameList

496

return pathList, filenameList

497

498

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

498

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

499

500

"""

500

"""

501

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

501

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

502

devuelve el archivo encontrado ademas de otros datos.

502

devuelve el archivo encontrado ademas de otros datos.

503

504

Input:

504

Input:

505

path : carpeta donde estan contenidos los files que contiene data

505

path : carpeta donde estan contenidos los files que contiene data

506

507

expLabel : Nombre del subexperimento (subfolder)

507

expLabel : Nombre del subexperimento (subfolder)

508

509

ext : extension de los files

509

ext : extension de los files

510

511

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

511

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

512

513

Return:

513

Return:

514

directory : eL directorio donde esta el file encontrado

514

directory : eL directorio donde esta el file encontrado

515

filename : el ultimo file de una determinada carpeta

515

filename : el ultimo file de una determinada carpeta

516

year : el anho

516

year : el anho

517

doy : el numero de dia del anho

517

doy : el numero de dia del anho

518

set : el set del archivo

518

set : el set del archivo

519

520

521

"""

521

"""

522

dirList = []

522

dirList = []

523

524

if not walk:

524

if not walk:

525

fullpath = path

525

fullpath = path

526

foldercounter = 0

526

foldercounter = 0

527

else:

527

else:

528

#Filtra solo los directorios

528

#Filtra solo los directorios

529

for thisPath in os.listdir(path):

529

for thisPath in os.listdir(path):

530

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

530

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

531

continue

531

continue

532

if not isDoyFolder(thisPath):

532

if not isDoyFolder(thisPath):

533

continue

533

continue

534

535

dirList.append(thisPath)

535

dirList.append(thisPath)

536

537

if not(dirList):

537

if not(dirList):

538

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

538

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

539

540

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

540

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

541

542

doypath = dirList[-1]

542

doypath = dirList[-1]

543

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

543

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

544

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

544

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

545

546

547

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

547

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

548

549

if set == None:

549

if set == None:

550

filename = getlastFileFromPath(fullpath, ext)

550

filename = getlastFileFromPath(fullpath, ext)

551

else:

551

else:

552

filename = getFileFromSet(fullpath, ext, set)

552

filename = getFileFromSet(fullpath, ext, set)

553

554

if not(filename):

554

if not(filename):

555

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

555

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

556

557

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

557

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

558

559

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

559

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

560

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

560

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

561

562

year = int( filename[1:5] )

562

year = int( filename[1:5] )

563

doy = int( filename[5:8] )

563

doy = int( filename[5:8] )

564

set = int( filename[8:11] )

564

set = int( filename[8:11] )

565

566

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

566

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

567

568

def __setNextFileOffline(self):

568

def __setNextFileOffline(self):

569

570

idFile = self.fileIndex

570

idFile = self.fileIndex

571

572

while (True):

572

while (True):

573

idFile += 1

573

idFile += 1

574

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

574

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

575

self.flagNoMoreFiles = 1

575

self.flagNoMoreFiles = 1

576

print "No more Files"

576

print "No more Files"

577

return 0

577

return 0

578

579

filename = self.filenameList[idFile]

579

filename = self.filenameList[idFile]

580

581

if not(self.__verifyFile(filename)):

581

if not(self.__verifyFile(filename)):

582

continue

582

continue

583

584

fileSize = os.path.getsize(filename)

584

fileSize = os.path.getsize(filename)

585

fp = open(filename,'rb')

585

fp = open(filename,'rb')

586

break

586

break

587

588

self.flagIsNewFile = 1

588

self.flagIsNewFile = 1

589

self.fileIndex = idFile

589

self.fileIndex = idFile

590

self.filename = filename

590

self.filename = filename

591

self.fileSize = fileSize

591

self.fileSize = fileSize

592

self.fp = fp

592

self.fp = fp

593

594

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

594

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

595

596

return 1

596

return 1

597

598

def __setNextFileOnline(self):

598

def __setNextFileOnline(self):

599

"""

599

"""

600

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

600

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

601

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

601

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

602

siguientes.

602

siguientes.

603

604

Affected:

604

Affected:

605

self.flagIsNewFile

605

self.flagIsNewFile

606

self.filename

606

self.filename

607

self.fileSize

607

self.fileSize

608

self.fp

608

self.fp

609

self.set

609

self.set

610

self.flagNoMoreFiles

610

self.flagNoMoreFiles

611

612

Return:

612

Return:

613

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

613

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

614

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

614

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

615

616

Excepciones:

616

Excepciones:

617

Si un determinado file no puede ser abierto

617

Si un determinado file no puede ser abierto

618

"""

618

"""

619

nFiles = 0

619

nFiles = 0

620

fileOk_flag = False

620

fileOk_flag = False

621

firstTime_flag = True

621

firstTime_flag = True

622

623

self.set += 1

623

self.set += 1

624

625

if self.set > 999:

625

if self.set > 999:

626

self.set = 0

626

self.set = 0

627

self.foldercounter += 1

627

self.foldercounter += 1

628

629

#busca el 1er file disponible

629

#busca el 1er file disponible

630

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

630

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

631

if fullfilename:

631

if fullfilename:

632

if self.__verifyFile(fullfilename, False):

632

if self.__verifyFile(fullfilename, False):

633

fileOk_flag = True

633

fileOk_flag = True

634

635

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

635

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

636

if not(fileOk_flag):

636

if not(fileOk_flag):

637

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

637

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

638

639

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

639

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

640

tries = self.nTries

640

tries = self.nTries

641

else:

641

else:

642

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

642

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

643

644

for nTries in range( tries ):

644

for nTries in range( tries ):

645

if firstTime_flag:

645

if firstTime_flag:

646

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

646

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

647

time.sleep( self.delay )

647

time.sleep( self.delay )

648

else:

648

else:

649

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

649

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

650

651

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

651

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

652

if fullfilename:

652

if fullfilename:

653

if self.__verifyFile(fullfilename):

653

if self.__verifyFile(fullfilename):

654

fileOk_flag = True

654

fileOk_flag = True

655

break

655

break

656

657

if fileOk_flag:

657

if fileOk_flag:

658

break

658

break

659

660

firstTime_flag = False

660

firstTime_flag = False

661

662

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

662

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

663

self.set += 1

663

self.set += 1

664

665

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

665

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

666

self.set = 0

666

self.set = 0

667

self.doy += 1

667

self.doy += 1

668

self.foldercounter = 0

668

self.foldercounter = 0

669

670

if fileOk_flag:

670

if fileOk_flag:

671

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

671

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

672

self.filename = fullfilename

672

self.filename = fullfilename

673

self.flagIsNewFile = 1

673

self.flagIsNewFile = 1

674

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

674

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

675

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

675

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

676

self.flagNoMoreFiles = 0

676

self.flagNoMoreFiles = 0

677

print 'Setting the file: %s' % fullfilename

677

print 'Setting the file: %s' % fullfilename

678

else:

678

else:

679

self.fileSize = 0

679

self.fileSize = 0

680

self.filename = None

680

self.filename = None

681

self.flagIsNewFile = 0

681

self.flagIsNewFile = 0

682

self.fp = None

682

self.fp = None

683

self.flagNoMoreFiles = 1

683

self.flagNoMoreFiles = 1

684

print 'No more Files'

684

print 'No more Files'

685

686

return fileOk_flag

686

return fileOk_flag

687

688

689

def setNextFile(self):

689

def setNextFile(self):

690

if self.fp != None:

690

if self.fp != None:

691

self.fp.close()

691

self.fp.close()

692

693

if self.online:

693

if self.online:

694

newFile = self.__setNextFileOnline()

694

newFile = self.__setNextFileOnline()

695

else:

695

else:

696

newFile = self.__setNextFileOffline()

696

newFile = self.__setNextFileOffline()

697

698

if not(newFile):

698

if not(newFile):

699

return 0

699

return 0

700

701

self.__readFirstHeader()

701

self.__readFirstHeader()

702

self.nReadBlocks = 0

702

self.nReadBlocks = 0

703

return 1

703

return 1

704

705

def __waitNewBlock(self):

705

def __waitNewBlock(self):

706

"""

706

"""

707

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

707

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

708

709

Si el modo de lectura es OffLine siempre retorn 0

709

Si el modo de lectura es OffLine siempre retorn 0

710

"""

710

"""

711

if not self.online:

711

if not self.online:

712

return 0

712

return 0

713

714

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

714

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

715

return 0

715

return 0

716

717

currentPointer = self.fp.tell()

717

currentPointer = self.fp.tell()

718

719

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

719

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

720

721

for nTries in range( self.nTries ):

721

for nTries in range( self.nTries ):

722

723

self.fp.close()

723

self.fp.close()

724

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

724

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

725

self.fp.seek( currentPointer )

725

self.fp.seek( currentPointer )

726

727

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

727

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

728

currentSize = self.fileSize - currentPointer

728

currentSize = self.fileSize - currentPointer

729

730

if ( currentSize >= neededSize ):

730

if ( currentSize >= neededSize ):

731

self.__rdBasicHeader()

731

self.__rdBasicHeader()

732

return 1

732

return 1

733

734

if self.fileSize == self.fileSizeByHeader:

734

if self.fileSize == self.fileSizeByHeader:

735

# self.flagEoF = True

735

# self.flagEoF = True

736

return 0

736

return 0

737

738

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

738

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

739

time.sleep( self.delay )

739

time.sleep( self.delay )

740

741

742

return 0

742

return 0

743

744

def waitDataBlock(self,pointer_location):

744

def waitDataBlock(self,pointer_location):

745

746

currentPointer = pointer_location

746

currentPointer = pointer_location

747

748

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

748

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

749

750

for nTries in range( self.nTries ):

750

for nTries in range( self.nTries ):

751

self.fp.close()

751

self.fp.close()

752

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

752

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

753

self.fp.seek( currentPointer )

753

self.fp.seek( currentPointer )

754

755

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

755

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

756

currentSize = self.fileSize - currentPointer

756

currentSize = self.fileSize - currentPointer

757

758

if ( currentSize >= neededSize ):

758

if ( currentSize >= neededSize ):

759

return 1

759

return 1

760

761

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

761

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

762

time.sleep( self.delay )

762

time.sleep( self.delay )

763

764

return 0

764

return 0

765

766

767

def __jumpToLastBlock(self):

767

def __jumpToLastBlock(self):

768

769

if not(self.__isFirstTimeOnline):

769

if not(self.__isFirstTimeOnline):

770

return

770

return

771

772

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

772

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

773

blocksize = self.processingHeaderObj.blockSize

773

blocksize = self.processingHeaderObj.blockSize

774

775

#salta el primer bloque de datos

775

#salta el primer bloque de datos

776

if csize > self.processingHeaderObj.blockSize:

776

if csize > self.processingHeaderObj.blockSize:

777

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

777

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

778

else:

778

else:

779

return

779

return

780

781

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

781

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

782

neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize

782

neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize

783

while True:

783

while True:

784

785

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

785

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

786

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

786

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

787

else:

787

else:

788

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

788

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

789

break

789

break

790

791

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

791

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

792

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

792

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

793

# factor = int(csize/neededsize)

793

# factor = int(csize/neededsize)

794

# if factor > 0:

794

# if factor > 0:

795

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

795

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

796

797

self.flagIsNewFile = 0

797

self.flagIsNewFile = 0

798

self.__isFirstTimeOnline = 0

798

self.__isFirstTimeOnline = 0

799

800

801

def __setNewBlock(self):

801

def __setNewBlock(self):

802

803

if self.fp == None:

803

if self.fp == None:

804

return 0

804

return 0

805

806

if self.online:

806

if self.online:

807

self.__jumpToLastBlock()

807

self.__jumpToLastBlock()

808

809

if self.flagIsNewFile:

809

if self.flagIsNewFile:

810

return 1

810

return 1

811

812

self.lastUTTime = self.basicHeaderObj.utc

812

self.lastUTTime = self.basicHeaderObj.utc

813

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

813

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

814

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

814

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

815

816

if (currentSize >= neededSize):

816

if (currentSize >= neededSize):

817

self.__rdBasicHeader()

817

self.__rdBasicHeader()

818

return 1

818

return 1

819

820

if self.__waitNewBlock():

820

if self.__waitNewBlock():

821

return 1

821

return 1

822

823

if not(self.setNextFile()):

823

if not(self.setNextFile()):

824

return 0

824

return 0

825

826

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

826

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

827

828

self.flagTimeBlock = 0

828

self.flagTimeBlock = 0

829

830

if deltaTime > self.maxTimeStep:

830

if deltaTime > self.maxTimeStep:

831

self.flagTimeBlock = 1

831

self.flagTimeBlock = 1

832

833

return 1

833

return 1

834

835

836

def readNextBlock(self):

836

def readNextBlock(self):

837

if not(self.__setNewBlock()):

837

if not(self.__setNewBlock()):

838

return 0

838

return 0

839

840

if not(self.readBlock()):

840

if not(self.readBlock()):

841

return 0

841

return 0

842

843

return 1

843

return 1

844

845

def __rdProcessingHeader(self, fp=None):

845

def __rdProcessingHeader(self, fp=None):

846

if fp == None:

846

if fp == None:

847

fp = self.fp

847

fp = self.fp

848

849

self.processingHeaderObj.read(fp)

849

self.processingHeaderObj.read(fp)

850

851

def __rdRadarControllerHeader(self, fp=None):

851

def __rdRadarControllerHeader(self, fp=None):

852

if fp == None:

852

if fp == None:

853

fp = self.fp

853

fp = self.fp

854

855

self.radarControllerHeaderObj.read(fp)

855

self.radarControllerHeaderObj.read(fp)

856

857

def __rdSystemHeader(self, fp=None):

857

def __rdSystemHeader(self, fp=None):

858

if fp == None:

858

if fp == None:

859

fp = self.fp

859

fp = self.fp

860

861

self.systemHeaderObj.read(fp)

861

self.systemHeaderObj.read(fp)

862

863

def __rdBasicHeader(self, fp=None):

863

def __rdBasicHeader(self, fp=None):

864

if fp == None:

864

if fp == None:

865

fp = self.fp

865

fp = self.fp

866

867

self.basicHeaderObj.read(fp)

867

self.basicHeaderObj.read(fp)

868

869

870

def __readFirstHeader(self):

870

def __readFirstHeader(self):

871

self.__rdBasicHeader()

871

self.__rdBasicHeader()

872

self.__rdSystemHeader()

872

self.__rdSystemHeader()

873

self.__rdRadarControllerHeader()

873

self.__rdRadarControllerHeader()

874

self.__rdProcessingHeader()

874

self.__rdProcessingHeader()

875

876

self.firstHeaderSize = self.basicHeaderObj.size

876

self.firstHeaderSize = self.basicHeaderObj.size

877

878

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

878

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

879

if datatype == 0:

879

if datatype == 0:

880

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

880

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

881

elif datatype == 1:

881

elif datatype == 1:

882

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

882

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

883

elif datatype == 2:

883

elif datatype == 2:

884

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

884

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

885

elif datatype == 3:

885

elif datatype == 3:

886

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

886

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

887

elif datatype == 4:

887

elif datatype == 4:

888

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

888

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

889

elif datatype == 5:

889

elif datatype == 5:

890

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

890

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

891

else:

891

else:

892

raise ValueError, 'Data type was not defined'

892

raise ValueError, 'Data type was not defined'

893

894

self.dtype = datatype_str

894

self.dtype = datatype_str

895

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

895

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

896

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

896

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

897

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

897

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

898

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

898

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

899

self.getBlockDimension()

899

self.getBlockDimension()

900

901

902

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

902

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

903

msg = None

903

msg = None

904

try:

904

try:

905

fp = open(filename, 'rb')

905

fp = open(filename, 'rb')

906

currentPosition = fp.tell()

906

currentPosition = fp.tell()

907

except:

907

except:

908

if msgFlag:

908

if msgFlag:

909

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

909

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

910

return False

910

return False

911

912

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

912

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

913

914

if neededSize == 0:

914

if neededSize == 0:

915

basicHeaderObj = BasicHeader(LOCALTIME)

915

basicHeaderObj = BasicHeader(LOCALTIME)

916

systemHeaderObj = SystemHeader()

916

systemHeaderObj = SystemHeader()

917

radarControllerHeaderObj = RadarControllerHeader()

917

radarControllerHeaderObj = RadarControllerHeader()

918

processingHeaderObj = ProcessingHeader()

918

processingHeaderObj = ProcessingHeader()

919

920

try:

920

try:

921

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

921

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

922

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

922

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

923

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

923

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

924

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

924

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

925

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

925

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

926

927

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

927

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

928

929

except:

929

except:

930

if msgFlag:

930

if msgFlag:

931

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

931

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

932

933

fp.close()

933

fp.close()

934

return False

934

return False

935

else:

935

else:

936

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

936

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

937

938

fp.close()

938

fp.close()

939

fileSize = os.path.getsize(filename)

939

fileSize = os.path.getsize(filename)

940

currentSize = fileSize - currentPosition

940

currentSize = fileSize - currentPosition

941

if currentSize < neededSize:

941

if currentSize < neededSize:

942

if msgFlag and (msg != None):

942

if msgFlag and (msg != None):

943

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

943

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

944

return False

944

return False

945

946

return True

946

return True

947

948

def setup(self,

948

def setup(self,

949

path=None,

949

path=None,

950

startDate=None,

950

startDate=None,

951

endDate=None,

951

endDate=None,

952

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

952

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

953

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

953

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

954

set=None,

954

set=None,

955

expLabel = "",

955

expLabel = "",

956

ext = None,

956

ext = None,

957

online = False,

957

online = False,

958

delay = 60,

958

delay = 60,

959

walk = True):

959

walk = True):

960

961

if path == None:

961

if path == None:

962

raise ValueError, "The path is not valid"

962

raise ValueError, "The path is not valid"

963

964

if ext == None:

964

if ext == None:

965

ext = self.ext

965

ext = self.ext

966

967

if online:

967

if online:

968

print "Searching files in online mode..."

968

print "Searching files in online mode..."

969

970

for nTries in range( self.nTries ):

970

for nTries in range( self.nTries ):

971

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

971

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

972

973

if fullpath:

973

if fullpath:

974

break

974

break

975

976

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

976

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

977

time.sleep( self.delay )

977

time.sleep( self.delay )

978

979

if not(fullpath):

979

if not(fullpath):

980

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

980

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

981

return None

981

return None

982

983

self.year = year

983

self.year = year

984

self.doy = doy

984

self.doy = doy

985

self.set = set - 1

985

self.set = set - 1

986

self.path = path

986

self.path = path

987

self.foldercounter = foldercounter

987

self.foldercounter = foldercounter

988

last_set = None

988

last_set = None

989

990

else:

990

else:

991

print "Searching files in offline mode ..."

991

print "Searching files in offline mode ..."

992

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

992

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

993

startTime=startTime, endTime=endTime,

993

startTime=startTime, endTime=endTime,

994

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

994

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

995

walk=walk)

995

walk=walk)

996

997

if not(pathList):

997

if not(pathList):

998

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

998

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

999

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

999

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

1000

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

1000

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

1001

1002

sys.exit(-1)

1002

sys.exit(-1)

1003

1004

1005

self.fileIndex = -1

1005

self.fileIndex = -1

1006

self.pathList = pathList

1006

self.pathList = pathList

1007

self.filenameList = filenameList

1007

self.filenameList = filenameList

1008

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

1008

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

1009

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

1009

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

1010

last_set = int(basename[-3:])

1010

last_set = int(basename[-3:])

1011

1012

self.online = online

1012

self.online = online

1013

self.delay = delay

1013

self.delay = delay

1014

ext = ext.lower()

1014

ext = ext.lower()

1015

self.ext = ext

1015

self.ext = ext

1016

1017

if not(self.setNextFile()):

1017

if not(self.setNextFile()):

1018

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

1018

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

1019

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

1019

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

1020

elif startDate != None:

1020

elif startDate != None:

1021

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

1021

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

1022

else:

1022

else:

1023

print "No files"

1023

print "No files"

1024

1025

sys.exit(-1)

1025

sys.exit(-1)

1026

1027

# self.updateDataHeader()

1027

# self.updateDataHeader()

1028

if last_set != None:

1028

if last_set != None:

1029

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

1029

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

1030

return self.dataOut

1030

return self.dataOut

1031

1032

def getBasicHeader(self):

1032

def getBasicHeader(self):

1033

1034

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

1034

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

1035

1036

self.dataOut.flagTimeBlock = self.flagTimeBlock

1036

self.dataOut.flagTimeBlock = self.flagTimeBlock

1037

1038

self.dataOut.timeZone = self.basicHeaderObj.timeZone

1038

self.dataOut.timeZone = self.basicHeaderObj.timeZone

1039

1040

self.dataOut.dstFlag = self.basicHeaderObj.dstFlag

1040

self.dataOut.dstFlag = self.basicHeaderObj.dstFlag

1041

1042

self.dataOut.errorCount = self.basicHeaderObj.errorCount

1042

self.dataOut.errorCount = self.basicHeaderObj.errorCount

1043

1044

self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime

1044

self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime

1045

1046

def getFirstHeader(self):

1046

def getFirstHeader(self):

1047

1048

raise ValueError, "This method has not been implemented"

1048

raise ValueError, "This method has not been implemented"

1049

1050

def getData():

1050

def getData():

1051

1052

raise ValueError, "This method has not been implemented"

1052

raise ValueError, "This method has not been implemented"

1053

1054

def hasNotDataInBuffer():

1054

def hasNotDataInBuffer():

1055

1056

raise ValueError, "This method has not been implemented"

1056

raise ValueError, "This method has not been implemented"

1057

1058

def readBlock():

1058

def readBlock():

1059

1060

raise ValueError, "This method has not been implemented"

1060

raise ValueError, "This method has not been implemented"

1061

1062

def isEndProcess(self):

1062

def isEndProcess(self):

1063

1064

return self.flagNoMoreFiles

1064

return self.flagNoMoreFiles

1065

1066

def printReadBlocks(self):

1066

def printReadBlocks(self):

1067

1068

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

1068

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

1069

1070

def printTotalBlocks(self):

1070

def printTotalBlocks(self):

1071

1072

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

1072

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

1073

1074

def printNumberOfBlock(self):

1074

def printNumberOfBlock(self):

1075

1076

if self.flagIsNewBlock:

1076

if self.flagIsNewBlock:

1077

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

1077

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

1078

self.dataOut.blocknow = self.basicHeaderObj.dataBlock

1078

self.dataOut.blocknow = self.basicHeaderObj.dataBlock

1079

def printInfo(self):

1079

def printInfo(self):

1080

1081

if self.__printInfo == False:

1081

if self.__printInfo == False:

1082

return

1082

return

1083

1084

self.basicHeaderObj.printInfo()

1084

self.basicHeaderObj.printInfo()

1085

self.systemHeaderObj.printInfo()

1085

self.systemHeaderObj.printInfo()

1086

self.radarControllerHeaderObj.printInfo()

1086

self.radarControllerHeaderObj.printInfo()

1087

self.processingHeaderObj.printInfo()

1087

self.processingHeaderObj.printInfo()

1088

1089

self.__printInfo = False

1089

self.__printInfo = False

1090

1091

1092

def run(self, **kwargs):

1092

def run(self, **kwargs):

1093

1094

if not(self.isConfig):

1094

if not(self.isConfig):

1095

1096

# self.dataOut = dataOut

1096

# self.dataOut = dataOut

1097

self.setup(**kwargs)

1097

self.setup(**kwargs)

1098

self.isConfig = True

1098

self.isConfig = True

1099

1100

self.getData()

1100

self.getData()

1101

1102

class JRODataWriter(JRODataIO, Operation):

1102

class JRODataWriter(JRODataIO, Operation):

1103

1104

"""

1104

"""

1105

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

1105

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

1106

de los datos siempre se realiza por bloques.

1106

de los datos siempre se realiza por bloques.

1107

"""

1107

"""

1108

1109

blockIndex = 0

1109

blockIndex = 0

1110

1111

path = None

1111

path = None

1112

1113

setFile = None

1113

setFile = None

1114

1115

profilesPerBlock = None

1115

profilesPerBlock = None

1116

1117

blocksPerFile = None

1117

blocksPerFile = None

1118

1119

nWriteBlocks = 0

1119

nWriteBlocks = 0

1120

1121

def __init__(self, dataOut=None):

1121

def __init__(self, dataOut=None):

1122

raise ValueError, "Not implemented"

1122

raise ValueError, "Not implemented"

1123

1124

1125

def hasAllDataInBuffer(self):

1125

def hasAllDataInBuffer(self):

1126

raise ValueError, "Not implemented"

1126

raise ValueError, "Not implemented"

1127

1128

1129

def setBlockDimension(self):

1129

def setBlockDimension(self):

1130

raise ValueError, "Not implemented"

1130

raise ValueError, "Not implemented"

1131

1132

1133

def writeBlock(self):

1133

def writeBlock(self):

1134

raise ValueError, "No implemented"

1134

raise ValueError, "No implemented"

1135

1136

1137

def putData(self):

1137

def putData(self):

1138

raise ValueError, "No implemented"

1138

raise ValueError, "No implemented"

1139

1140

1141

def setBasicHeader(self):

1141

def setBasicHeader(self):

1142

1143

self.basicHeaderObj.size = self.basicHeaderSize #bytes

1143

self.basicHeaderObj.size = self.basicHeaderSize #bytes

1144

self.basicHeaderObj.version = self.versionFile

1144

self.basicHeaderObj.version = self.versionFile

1145

self.basicHeaderObj.dataBlock = self.nTotalBlocks

1145

self.basicHeaderObj.dataBlock = self.nTotalBlocks

1146

1147

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

1147

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

1148

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

1148

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

1149

1150

self.basicHeaderObj.utc = utc

1150

self.basicHeaderObj.utc = utc

1151

self.basicHeaderObj.miliSecond = milisecond

1151

self.basicHeaderObj.miliSecond = milisecond

1152

self.basicHeaderObj.timeZone = self.dataOut.timeZone

1152

self.basicHeaderObj.timeZone = self.dataOut.timeZone

1153

self.basicHeaderObj.dstFlag = self.dataOut.dstFlag

1153

self.basicHeaderObj.dstFlag = self.dataOut.dstFlag

1154

self.basicHeaderObj.errorCount = self.dataOut.errorCount

1154

self.basicHeaderObj.errorCount = self.dataOut.errorCount

1155

1156

def setFirstHeader(self):

1156

def setFirstHeader(self):

1157

"""

1157

"""

1158

Obtiene una copia del First Header

1158

Obtiene una copia del First Header

1159

1160

Affected:

1160

Affected:

1161

1162

self.basicHeaderObj

1162

self.basicHeaderObj

1163

self.systemHeaderObj

1163

self.systemHeaderObj

1164

self.radarControllerHeaderObj

1164

self.radarControllerHeaderObj

1165

self.processingHeaderObj self.

1165

self.processingHeaderObj self.

1166

1167

Return:

1167

Return:

1168

None

1168

None

1169

"""

1169

"""

1170

1171

raise ValueError, "No implemented"

1171

raise ValueError, "No implemented"

1172

1173

def __writeFirstHeader(self):

1173

def __writeFirstHeader(self):

1174

"""

1174

"""

1175

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

1175

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

1176

1177

Affected:

1177

Affected:

1178

__dataType

1178

__dataType

1179

1180

Return:

1180

Return:

1181

None

1181

None

1182

"""

1182

"""

1183

1184

# CALCULAR PARAMETROS

1184

# CALCULAR PARAMETROS

1185

1186

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

1186

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

1187

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

1187

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

1188

1189

self.basicHeaderObj.write(self.fp)

1189

self.basicHeaderObj.write(self.fp)

1190

self.systemHeaderObj.write(self.fp)

1190

self.systemHeaderObj.write(self.fp)

1191

self.radarControllerHeaderObj.write(self.fp)

1191

self.radarControllerHeaderObj.write(self.fp)

1192

self.processingHeaderObj.write(self.fp)

1192

self.processingHeaderObj.write(self.fp)

1193

1194

self.dtype = self.dataOut.dtype

1194

self.dtype = self.dataOut.dtype

1195

1196

def __setNewBlock(self):

1196

def __setNewBlock(self):

1197

"""

1197

"""

1198

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

1198

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

1199

1200

Return:

1200

Return:

1201

0 : si no pudo escribir nada

1201

0 : si no pudo escribir nada

1202

1 : Si escribio el Basic el First Header

1202

1 : Si escribio el Basic el First Header

1203

"""

1203

"""

1204

if self.fp == None:

1204

if self.fp == None:

1205

self.setNextFile()

1205

self.setNextFile()

1206

1207

if self.flagIsNewFile:

1207

if self.flagIsNewFile:

1208

return 1

1208

return 1

1209

1210

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

1210

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

1211

self.basicHeaderObj.write(self.fp)

1211

self.basicHeaderObj.write(self.fp)

1212

return 1

1212

return 1

1213

1214

if not( self.setNextFile() ):

1214

if not( self.setNextFile() ):

1215

return 0

1215

return 0

1216

1217

return 1

1217

return 1

1218

1219

1220

def writeNextBlock(self):

1220

def writeNextBlock(self):

1221

"""

1221

"""

1222

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

1222

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

1223

1224

Return:

1224

Return:

1225

0 : Si no hizo pudo escribir el bloque de datos

1225

0 : Si no hizo pudo escribir el bloque de datos

1226

1 : Si no pudo escribir el bloque de datos

1226

1 : Si no pudo escribir el bloque de datos

1227

"""

1227

"""

1228

if not( self.__setNewBlock() ):

1228

if not( self.__setNewBlock() ):

1229

return 0

1229

return 0

1230

1231

self.writeBlock()

1231

self.writeBlock()

1232

1233

return 1

1233

return 1

1234

1235

def setNextFile(self):

1235

def setNextFile(self):

1236

"""

1236

"""

1237

Determina el siguiente file que sera escrito

1237

Determina el siguiente file que sera escrito

1238

1239

Affected:

1239

Affected:

1240

self.filename

1240

self.filename

1241

self.subfolder

1241

self.subfolder

1242

self.fp

1242

self.fp

1243

self.setFile

1243

self.setFile

1244

self.flagIsNewFile

1244

self.flagIsNewFile

1245

1246

Return:

1246

Return:

1247

0 : Si el archivo no puede ser escrito

1247

0 : Si el archivo no puede ser escrito

1248

1 : Si el archivo esta listo para ser escrito

1248

1 : Si el archivo esta listo para ser escrito

1249

"""

1249

"""

1250

ext = self.ext

1250

ext = self.ext

1251

path = self.path

1251

path = self.path

1252

1253

if self.fp != None:

1253

if self.fp != None:

1254

self.fp.close()

1254

self.fp.close()

1255

1256

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

1256

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

1257

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

1257

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

1258

1259

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

1259

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

1260

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

1260

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

1261

os.mkdir(fullpath)

1261

os.mkdir(fullpath)

1262

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

1262

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

1263

else:

1263

else:

1264

filesList = os.listdir( fullpath )

1264

filesList = os.listdir( fullpath )

1265

if len( filesList ) > 0:

1265

if len( filesList ) > 0:

1266

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

1266

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

1267

filen = filesList[-1]

1267

filen = filesList[-1]

1268

# el filename debera tener el siguiente formato

1268

# el filename debera tener el siguiente formato

1269

# 0 1234 567 89A BCDE (hex)

1269

# 0 1234 567 89A BCDE (hex)

1270

# x YYYY DDD SSS .ext

1270

# x YYYY DDD SSS .ext

1271

if isNumber( filen[8:11] ):

1271

if isNumber( filen[8:11] ):

1272

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

1272

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

1273

else:

1273

else:

1274

self.setFile = -1

1274

self.setFile = -1

1275

else:

1275

else:

1276

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

1276

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

1277

1278

setFile = self.setFile

1278

setFile = self.setFile

1279

setFile += 1

1279

setFile += 1

1280

1281

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

1281

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

1282

timeTuple.tm_year,

1282

timeTuple.tm_year,

1283

timeTuple.tm_yday,

1283

timeTuple.tm_yday,

1284

setFile,

1284

setFile,

1285

ext )

1285

ext )

1286

1287

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

1287

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

1288

1289

fp = open( filename,'wb' )

1289

fp = open( filename,'wb' )

1290

1291

self.blockIndex = 0

1291

self.blockIndex = 0

1292

1293

#guardando atributos

1293

#guardando atributos

1294

self.filename = filename

1294

self.filename = filename

1295

self.subfolder = subfolder

1295

self.subfolder = subfolder

1296

self.fp = fp

1296

self.fp = fp

1297

self.setFile = setFile

1297

self.setFile = setFile

1298

self.flagIsNewFile = 1

1298

self.flagIsNewFile = 1

1299

1300

self.setFirstHeader()

1300

self.setFirstHeader()

1301

1302

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

1302

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

1303

1304

self.__writeFirstHeader()

1304

self.__writeFirstHeader()

1305

1306

return 1

1306

return 1

1307

1308

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

1308

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

1309

"""

1309

"""

1310

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

1310

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

1311

1312

Inputs:

1312

Inputs:

1313

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

1313

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

1314

format : formato en el cual sera salvado un file

1314

format : formato en el cual sera salvado un file

1315

set : el setebo del file

1315

set : el setebo del file

1316

1317

Return:

1317

Return:

1318

0 : Si no realizo un buen seteo

1318

0 : Si no realizo un buen seteo

1319

1 : Si realizo un buen seteo

1319

1 : Si realizo un buen seteo

1320

"""

1320

"""

1321

1322

if ext == None:

1322

if ext == None:

1323

ext = self.ext

1323

ext = self.ext

1324

1325

ext = ext.lower()

1325

ext = ext.lower()

1326

1327

self.ext = ext

1327

self.ext = ext

1328

1329

self.path = path

1329

self.path = path

1330

1331

self.setFile = set - 1

1331

self.setFile = set - 1

1332

1333

self.blocksPerFile = blocksPerFile

1333

self.blocksPerFile = blocksPerFile

1334

1335

self.profilesPerBlock = profilesPerBlock

1335

self.profilesPerBlock = profilesPerBlock

1336

1337

self.dataOut = dataOut

1337

self.dataOut = dataOut

1338

1339

if not(self.setNextFile()):

1339

if not(self.setNextFile()):

1340

print "There isn't a next file"

1340

print "There isn't a next file"

1341

return 0

1341

return 0

1342

1343

self.setBlockDimension()

1343

self.setBlockDimension()

1344

1345

return 1

1345

return 1

1346

1347

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

1347

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

1348

1349

if not(self.isConfig):

1349

if not(self.isConfig):

1350

1351

self.setup(dataOut, **kwargs)

1351

self.setup(dataOut, **kwargs)

1352

self.isConfig = True

1352

self.isConfig = True

1353

1354

self.putData()

1354

self.putData()

1355

1356

class VoltageReader(JRODataReader):

1356

class VoltageReader(JRODataReader):

1357

"""

1357

"""

1358

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

1358

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

1359

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

1359

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

1360

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

1360

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

1361

1362

perfiles * alturas * canales

1362

perfiles * alturas * canales

1363

1364

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

1364

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

1365

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

1365

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

1366

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

1366

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

1367

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

1367

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

1368

1369

Example:

1369

Example:

1370

1371

dpath = "/home/myuser/data"

1371

dpath = "/home/myuser/data"

1372

1373

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

1373

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

1374

1375

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

1375

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

1376

1377

readerObj = VoltageReader()

1377

readerObj = VoltageReader()

1378

1379

readerObj.setup(dpath, startTime, endTime)

1379

readerObj.setup(dpath, startTime, endTime)

1380

1381

while(True):

1381

while(True):

1382

1383

#to get one profile

1383

#to get one profile

1384

profile = readerObj.getData()

1384

profile = readerObj.getData()

1385

1386

#print the profile

1386

#print the profile

1387

print profile

1387

print profile

1388

1389

#If you want to see all datablock

1389

#If you want to see all datablock

1390

print readerObj.datablock

1390

print readerObj.datablock

1391

1392

if readerObj.flagNoMoreFiles:

1392

if readerObj.flagNoMoreFiles:

1393

break

1393

break

1394

1395

"""

1395

"""

1396

1397

ext = ".r"

1397

ext = ".r"

1398

1399

optchar = "D"

1399

optchar = "D"

1400

dataOut = None

1400

dataOut = None

1401

1402

1403

def __init__(self):

1403

def __init__(self):

1404

"""

1404

"""

1405

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

1405

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

1406

1407

Input:

1407

Input:

1408

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

1408

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

1409

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

1409

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

1410

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

1410

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

1411

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

1411

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

1412

bloque de datos.

1412

bloque de datos.

1413

Si este parametro no es pasado se creara uno internamente.

1413

Si este parametro no es pasado se creara uno internamente.

1414

1415

Variables afectadas:

1415

Variables afectadas:

1416

self.dataOut

1416

self.dataOut

1417

1418

Return:

1418

Return:

1419

None

1419

None

1420

"""

1420

"""

1421

1422

self.isConfig = False

1422

self.isConfig = False

1423

1424

self.datablock = None

1424

self.datablock = None

1425

1426

self.utc = 0

1426

self.utc = 0

1427

1428

self.ext = ".r"

1428

self.ext = ".r"

1429

1430

self.optchar = "D"

1430

self.optchar = "D"

1431

1432

self.basicHeaderObj = BasicHeader(LOCALTIME)

1432

self.basicHeaderObj = BasicHeader(LOCALTIME)

1433

1434

self.systemHeaderObj = SystemHeader()

1434

self.systemHeaderObj = SystemHeader()

1435

1436

self.radarControllerHeaderObj = RadarControllerHeader()

1436

self.radarControllerHeaderObj = RadarControllerHeader()

1437

1438

self.processingHeaderObj = ProcessingHeader()

1438

self.processingHeaderObj = ProcessingHeader()

1439

1440

self.online = 0

1440

self.online = 0

1441

1442

self.fp = None

1442

self.fp = None

1443

1444

self.idFile = None

1444

self.idFile = None

1445

1446

self.dtype = None

1446

self.dtype = None

1447

1448

self.fileSizeByHeader = None

1448

self.fileSizeByHeader = None

1449

1450

self.filenameList = []

1450

self.filenameList = []

1451

1452

self.filename = None

1452

self.filename = None

1453

1454

self.fileSize = None

1454

self.fileSize = None

1455

1456

self.firstHeaderSize = 0

1456

self.firstHeaderSize = 0

1457

1458

self.basicHeaderSize = 24

1458

self.basicHeaderSize = 24

1459

1460

self.pathList = []

1460

self.pathList = []

1461

1462

self.filenameList = []

1462

self.filenameList = []

1463

1464

self.lastUTTime = 0

1464

self.lastUTTime = 0

1465

1466

self.maxTimeStep = 30

1466

self.maxTimeStep = 30

1467

1468

self.flagNoMoreFiles = 0

1468

self.flagNoMoreFiles = 0

1469

1470

self.set = 0

1470

self.set = 0

1471

1472

self.path = None

1472

self.path = None

1473

1474

self.profileIndex = 2**32-1

1474

self.profileIndex = 2**32-1

1475

1476

self.delay = 3 #seconds

1476

self.delay = 3 #seconds

1477

1478

self.nTries = 3 #quantity tries

1478

self.nTries = 3 #quantity tries

1479

1480

self.nFiles = 3 #number of files for searching

1480

self.nFiles = 3 #number of files for searching

1481

1482

self.nReadBlocks = 0

1482

self.nReadBlocks = 0

1483

1484

self.flagIsNewFile = 1

1484

self.flagIsNewFile = 1

1485

1486

self.__isFirstTimeOnline = 1

1486

self.__isFirstTimeOnline = 1

1487

1488

self.ippSeconds = 0

1488

self.ippSeconds = 0

1489

1490

self.flagTimeBlock = 0

1490

self.flagTimeBlock = 0

1491

1492

self.flagIsNewBlock = 0

1492

self.flagIsNewBlock = 0

1493

1494

self.nTotalBlocks = 0

1494

self.nTotalBlocks = 0

1495

1496

self.blocksize = 0

1496

self.blocksize = 0

1497

1498

self.dataOut = self.createObjByDefault()

1498

self.dataOut = self.createObjByDefault()

1499

1500

def createObjByDefault(self):

1500

def createObjByDefault(self):

1501

1502

dataObj = Voltage()

1502

dataObj = Voltage()

1503

1504

return dataObj

1504

return dataObj

1505

1506

def __hasNotDataInBuffer(self):

1506

def __hasNotDataInBuffer(self):

1507

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

1507

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

1508

return 1

1508

return 1

1509

return 0

1509

return 0

1510

1511

1512

def getBlockDimension(self):

1512

def getBlockDimension(self):

1513

"""

1513

"""

1514

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

1514

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

1515

1516

Affected:

1516

Affected:

1517

self.blocksize

1517

self.blocksize

1518

1519

Return:

1519

Return:

1520

None

1520

None

1521

"""

1521

"""

1522

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

1522

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

1523

self.blocksize = pts2read

1523

self.blocksize = pts2read

1524

1525

1526

def readBlock(self):

1526

def readBlock(self):

1527

"""

1527

"""

1528

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

1528

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

1529

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

1529

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

1530

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

1530

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

1531

es seteado a 0

1531

es seteado a 0

1532

1533

Inputs:

1533

Inputs:

1534

None

1534

None

1535

1536

Return:

1536

Return:

1537

None

1537

None

1538

1539

Affected:

1539

Affected:

1540

self.profileIndex

1540

self.profileIndex

1541

self.datablock

1541

self.datablock

1542

self.flagIsNewFile

1542

self.flagIsNewFile

1543

self.flagIsNewBlock

1543

self.flagIsNewBlock

1544

self.nTotalBlocks

1544

self.nTotalBlocks

1545

1546

Exceptions:

1546

Exceptions:

1547

Si un bloque leido no es un bloque valido

1547

Si un bloque leido no es un bloque valido

1548

"""

1548

"""

1549

current_pointer_location = self.fp.tell()

1549

current_pointer_location = self.fp.tell()

1550

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

1550

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

1551

1552

try:

1552

try:

1553

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

1553

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

1554

except:

1554

except:

1555

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

1555

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

1556

1557

if self.waitDataBlock(pointer_location=current_pointer_location):

1557

if self.waitDataBlock(pointer_location=current_pointer_location):

1558

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

1558

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

1559

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

1559

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

1560

# return 0

1560

# return 0

1561

1562

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

1562

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

1563

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

1563

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

1564

1565

self.profileIndex = 0

1565

self.profileIndex = 0

1566

1567

self.flagIsNewFile = 0

1567

self.flagIsNewFile = 0

1568

self.flagIsNewBlock = 1

1568

self.flagIsNewBlock = 1

1569

1570

self.nTotalBlocks += 1

1570

self.nTotalBlocks += 1

1571

self.nReadBlocks += 1

1571

self.nReadBlocks += 1

1572

1573

return 1

1573

return 1

1574

1575

def getFirstHeader(self):

1575

def getFirstHeader(self):

1576

1577

self.dataOut.dtype = self.dtype

1577

self.dataOut.dtype = self.dtype

1578

1579

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1579

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1580

1581

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

1581

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

1582

1583

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

1583

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

1584

1585

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

1585

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

1586

1587

self.dataOut.ippSeconds = self.ippSeconds

1587

self.dataOut.ippSeconds = self.ippSeconds

1588

1589

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

1589

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

1590

1591

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1591

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1592

1593

self.dataOut.flagShiftFFT = False

1593

self.dataOut.flagShiftFFT = False

1594

1595

if self.radarControllerHeaderObj.code != None:

1595

if self.radarControllerHeaderObj.code != None:

1596

1597

self.dataOut.nCode = self.radarControllerHeaderObj.nCode

1597

self.dataOut.nCode = self.radarControllerHeaderObj.nCode

1598

1599

self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud

1599

self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud

1600

1601

self.dataOut.code = self.radarControllerHeaderObj.code

1601

self.dataOut.code = self.radarControllerHeaderObj.code

1602

1603

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

1603

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

1604

1605

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

1605

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

1606

1607

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

1607

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

1608

1609

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

1609

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

1610

1611

self.dataOut.flagShiftFFT = False

1611

self.dataOut.flagShiftFFT = False

1612

1613

def getData(self):

1613

def getData(self):

1614

"""

1614

"""

1615

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

1615

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

1616

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

1616

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

1617

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

1617

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

1618

1619

Ademas incrementa el contador del buffer en 1.

1619

Ademas incrementa el contador del buffer en 1.

1620

1621

Return:

1621

Return:

1622

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

1622

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

1623

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

1623

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

1624

1625

Variables afectadas:

1625

Variables afectadas:

1626

self.dataOut

1626

self.dataOut

1627

self.profileIndex

1627

self.profileIndex

1628

1629

Affected:

1629

Affected:

1630

self.dataOut

1630

self.dataOut

1631

self.profileIndex

1631

self.profileIndex

1632

self.flagTimeBlock

1632

self.flagTimeBlock

1633

self.flagIsNewBlock

1633

self.flagIsNewBlock

1634

"""

1634

"""

1635

1636

if self.flagNoMoreFiles:

1636

if self.flagNoMoreFiles:

1637

self.dataOut.flagNoData = True

1637

self.dataOut.flagNoData = True

1638

print 'Process finished'

1638

print 'Process finished'

1639

return 0

1639

return 0

1640

1641

self.flagTimeBlock = 0

1641

self.flagTimeBlock = 0

1642

self.flagIsNewBlock = 0

1642

self.flagIsNewBlock = 0

1643

1644

if self.__hasNotDataInBuffer():

1644

if self.__hasNotDataInBuffer():

1645

1646

if not( self.readNextBlock() ):

1646

if not( self.readNextBlock() ):

1647

return 0

1647

return 0

1648

1649

self.getFirstHeader()

1649

self.getFirstHeader()

1650

1651

if self.datablock == None:

1651

if self.datablock == None:

1652

self.dataOut.flagNoData = True

1652

self.dataOut.flagNoData = True

1653

return 0

1653

return 0

1654

1655

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

1655

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

1656

1657

self.dataOut.flagNoData = False

1657

self.dataOut.flagNoData = False

1658

1659

self.getBasicHeader()

1659

self.getBasicHeader()

1660

1661

self.profileIndex += 1

1661

self.profileIndex += 1

1662

1663

self.dataOut.realtime = self.online

1663

self.dataOut.realtime = self.online

1664

1665

return self.dataOut.data

1665

return self.dataOut.data

1666

1667

1668

class VoltageWriter(JRODataWriter):

1668

class VoltageWriter(JRODataWriter):

1669

"""

1669

"""

1670

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

1670

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

1671

de los datos siempre se realiza por bloques.

1671

de los datos siempre se realiza por bloques.

1672

"""

1672

"""

1673

1674

ext = ".r"

1674

ext = ".r"

1675

1676

optchar = "D"

1676

optchar = "D"

1677

1678

shapeBuffer = None

1678

shapeBuffer = None

1679

1680

1681

def __init__(self):

1681

def __init__(self):

1682

"""

1682

"""

1683

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

1683

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

1684

1685

Affected:

1685

Affected:

1686

self.dataOut

1686

self.dataOut

1687

1688

Return: None

1688

Return: None

1689

"""

1689

"""

1690

1691

self.nTotalBlocks = 0

1691

self.nTotalBlocks = 0

1692

1693

self.profileIndex = 0

1693

self.profileIndex = 0

1694

1695

self.isConfig = False

1695

self.isConfig = False

1696

1697

self.fp = None

1697

self.fp = None

1698

1699

self.flagIsNewFile = 1

1699

self.flagIsNewFile = 1

1700

1701

self.nTotalBlocks = 0

1701

self.nTotalBlocks = 0

1702

1703

self.flagIsNewBlock = 0

1703

self.flagIsNewBlock = 0

1704

1705

self.setFile = None

1705

self.setFile = None

1706

1707

self.dtype = None

1707

self.dtype = None

1708

1709

self.path = None

1709

self.path = None

1710

1711

self.filename = None

1711

self.filename = None

1712

1713

self.basicHeaderObj = BasicHeader(LOCALTIME)

1713

self.basicHeaderObj = BasicHeader(LOCALTIME)

1714

1715

self.systemHeaderObj = SystemHeader()

1715

self.systemHeaderObj = SystemHeader()

1716

1717

self.radarControllerHeaderObj = RadarControllerHeader()

1717

self.radarControllerHeaderObj = RadarControllerHeader()

1718

1719

self.processingHeaderObj = ProcessingHeader()

1719

self.processingHeaderObj = ProcessingHeader()

1720

1721

def hasAllDataInBuffer(self):

1721

def hasAllDataInBuffer(self):

1722

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

1722

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

1723

return 1

1723

return 1

1724

return 0

1724

return 0

1725

1726

1727

def setBlockDimension(self):

1727

def setBlockDimension(self):

1728

"""

1728

"""

1729

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

1729

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

1730

1731

Affected:

1731

Affected:

1732

self.shape_spc_Buffer

1732

self.shape_spc_Buffer

1733

self.shape_cspc_Buffer

1733

self.shape_cspc_Buffer

1734

self.shape_dc_Buffer

1734

self.shape_dc_Buffer

1735

1736

Return: None

1736

Return: None

1737

"""

1737

"""

1738

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1738

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1739

self.processingHeaderObj.nHeights,

1739

self.processingHeaderObj.nHeights,

1740

self.systemHeaderObj.nChannels)

1740

self.systemHeaderObj.nChannels)

1741

1742

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

1742

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

1743

self.processingHeaderObj.profilesPerBlock,

1743

self.processingHeaderObj.profilesPerBlock,

1744

self.processingHeaderObj.nHeights),

1744

self.processingHeaderObj.nHeights),

1745

dtype=numpy.dtype('complex64'))

1745

dtype=numpy.dtype('complex64'))

1746

1747

1748

def writeBlock(self):

1748

def writeBlock(self):

1749

"""

1749

"""

1750

Escribe el buffer en el file designado

1750

Escribe el buffer en el file designado

1751

1752

Affected:

1752

Affected:

1753

self.profileIndex

1753

self.profileIndex

1754

self.flagIsNewFile

1754

self.flagIsNewFile

1755

self.flagIsNewBlock

1755

self.flagIsNewBlock

1756

self.nTotalBlocks

1756

self.nTotalBlocks

1757

self.blockIndex

1757

self.blockIndex

1758

1759

Return: None

1759

Return: None

1760

"""

1760

"""

1761

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

1761

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

1762

1763

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

1763

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

1764

1765

data['real'] = junk.real

1765

data['real'] = junk.real

1766

data['imag'] = junk.imag

1766

data['imag'] = junk.imag

1767

1768

data = data.reshape( (-1) )

1768

data = data.reshape( (-1) )

1769

1770

data.tofile( self.fp )

1770

data.tofile( self.fp )

1771

1772

self.datablock.fill(0)

1772

self.datablock.fill(0)

1773

1774

self.profileIndex = 0

1774

self.profileIndex = 0

1775

self.flagIsNewFile = 0

1775

self.flagIsNewFile = 0

1776

self.flagIsNewBlock = 1

1776

self.flagIsNewBlock = 1

1777

1778

self.blockIndex += 1

1778

self.blockIndex += 1

1779

self.nTotalBlocks += 1

1779

self.nTotalBlocks += 1

1780

1781

def putData(self):

1781

def putData(self):

1782

"""

1782

"""

1783

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

1783

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

1784

1785

Affected:

1785

Affected:

1786

self.flagIsNewBlock

1786

self.flagIsNewBlock

1787

self.profileIndex

1787

self.profileIndex

1788

1789

Return:

1789

Return:

1790

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

1790

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

1791

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

1791

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

1792

"""

1792

"""

1793

if self.dataOut.flagNoData:

1793

if self.dataOut.flagNoData:

1794

return 0

1794

return 0

1795

1796

self.flagIsNewBlock = 0

1796

self.flagIsNewBlock = 0

1797

1798

if self.dataOut.flagTimeBlock:

1798

if self.dataOut.flagTimeBlock:

1799

1800

self.datablock.fill(0)

1800

self.datablock.fill(0)

1801

self.profileIndex = 0

1801

self.profileIndex = 0

1802

self.setNextFile()

1802

self.setNextFile()

1803

1804

if self.profileIndex == 0:

1804

if self.profileIndex == 0:

1805

self.setBasicHeader()

1805

self.setBasicHeader()

1806

1807

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

1807

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

1808

1809

self.profileIndex += 1

1809

self.profileIndex += 1

1810

1811

if self.hasAllDataInBuffer():

1811

if self.hasAllDataInBuffer():

1812

#if self.flagIsNewFile:

1812

#if self.flagIsNewFile:

1813

self.writeNextBlock()

1813

self.writeNextBlock()

1814

# self.setFirstHeader()

1814

# self.setFirstHeader()

1815

1816

return 1

1816

return 1

1817

1818

def __getProcessFlags(self):

1818

def __getProcessFlags(self):

1819

1820

processFlags = 0

1820

processFlags = 0

1821

1822

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

1822

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

1823

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

1823

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

1824

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

1824

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

1825

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

1825

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

1826

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

1826

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

1827

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

1827

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

1828

1829

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

1829

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

1830

1831

1832

1833

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1833

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1834

PROCFLAG.DATATYPE_SHORT,

1834

PROCFLAG.DATATYPE_SHORT,

1835

PROCFLAG.DATATYPE_LONG,

1835

PROCFLAG.DATATYPE_LONG,

1836

PROCFLAG.DATATYPE_INT64,

1836

PROCFLAG.DATATYPE_INT64,

1837

PROCFLAG.DATATYPE_FLOAT,

1837

PROCFLAG.DATATYPE_FLOAT,

1838

PROCFLAG.DATATYPE_DOUBLE]

1838

PROCFLAG.DATATYPE_DOUBLE]

1839

1840

1841

for index in range(len(dtypeList)):

1841

for index in range(len(dtypeList)):

1842

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

1842

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

1843

dtypeValue = datatypeValueList[index]

1843

dtypeValue = datatypeValueList[index]

1844

break

1844

break

1845

1846

processFlags += dtypeValue

1846

processFlags += dtypeValue

1847

1848

if self.dataOut.flagDecodeData:

1848

if self.dataOut.flagDecodeData:

1849

processFlags += PROCFLAG.DECODE_DATA

1849

processFlags += PROCFLAG.DECODE_DATA

1850

1851

if self.dataOut.flagDeflipData:

1851

if self.dataOut.flagDeflipData:

1852

processFlags += PROCFLAG.DEFLIP_DATA

1852

processFlags += PROCFLAG.DEFLIP_DATA

1853

1854

if self.dataOut.code != None:

1854

if self.dataOut.code != None:

1855

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1855

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1856

1857

if self.dataOut.nCohInt > 1:

1857

if self.dataOut.nCohInt > 1:

1858

processFlags += PROCFLAG.COHERENT_INTEGRATION

1858

processFlags += PROCFLAG.COHERENT_INTEGRATION

1859

1860

return processFlags

1860

return processFlags

1861

1862

1863

def __getBlockSize(self):

1863

def __getBlockSize(self):

1864

'''

1864

'''

1865

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

1865

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

1866

'''

1866

'''

1867

1868

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

1868

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

1869

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

1869

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

1870

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

1870

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

1871

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

1871

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

1872

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

1872

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

1873

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

1873

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

1874

1875

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

1875

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

1876

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

1876

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

1877

for index in range(len(dtypeList)):

1877

for index in range(len(dtypeList)):

1878

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

1878

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

1879

datatypeValue = datatypeValueList[index]

1879

datatypeValue = datatypeValueList[index]

1880

break

1880

break

1881

1882

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

1882

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

1883

1884

return blocksize

1884

return blocksize

1885

1886

def setFirstHeader(self):

1886

def setFirstHeader(self):

1887

1888

"""

1888

"""

1889

Obtiene una copia del First Header

1889

Obtiene una copia del First Header

1890

1891

Affected:

1891

Affected:

1892

self.systemHeaderObj

1892

self.systemHeaderObj

1893

self.radarControllerHeaderObj

1893

self.radarControllerHeaderObj

1894

self.dtype

1894

self.dtype

1895

1896

Return:

1896

Return:

1897

None

1897

None

1898

"""

1898

"""

1899

1900

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

1900

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

1901

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1901

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1902

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

1902

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

1903

1904

self.setBasicHeader()

1904

self.setBasicHeader()

1905

1906

processingHeaderSize = 40 # bytes

1906

processingHeaderSize = 40 # bytes

1907

self.processingHeaderObj.dtype = 0 # Voltage

1907

self.processingHeaderObj.dtype = 0 # Voltage

1908

self.processingHeaderObj.blockSize = self.__getBlockSize()

1908

self.processingHeaderObj.blockSize = self.__getBlockSize()

1909

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1909

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1910

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1910

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1911

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

1911

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

1912

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1912

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1913

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1913

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1914

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

1914

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

1915

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

1915

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

1916

1917

# if self.dataOut.code != None:

1917

# if self.dataOut.code != None:

1918

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

1918

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

1919

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

1919

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

1920

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

1920

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

1921

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

1921

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

1922

# processingHeaderSize += codesize

1922

# processingHeaderSize += codesize

1923

1924

if self.processingHeaderObj.nWindows != 0:

1924

if self.processingHeaderObj.nWindows != 0:

1925

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

1925

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

1926

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

1926

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

1927

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1927

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1928

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1928

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1929

processingHeaderSize += 12

1929

processingHeaderSize += 12

1930

1931

self.processingHeaderObj.size = processingHeaderSize

1931

self.processingHeaderObj.size = processingHeaderSize

1932

1933

class SpectraReader(JRODataReader):

1933

class SpectraReader(JRODataReader):

1934

"""

1934

"""

1935

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

1935

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

1936

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

1936

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

1937

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

1937

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

1938

1939

paresCanalesIguales * alturas * perfiles (Self Spectra)

1939

paresCanalesIguales * alturas * perfiles (Self Spectra)

1940

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1940

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1941

canales * alturas (DC Channels)

1941

canales * alturas (DC Channels)

1942

1943

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

1943

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

1944

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

1944

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

1945

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

1945

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

1946

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

1946

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

1947

1948

Example:

1948

Example:

1949

dpath = "/home/myuser/data"

1949

dpath = "/home/myuser/data"

1950

1951

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

1951

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

1952

1953

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

1953

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

1954

1955

readerObj = SpectraReader()

1955

readerObj = SpectraReader()

1956

1957

readerObj.setup(dpath, startTime, endTime)

1957

readerObj.setup(dpath, startTime, endTime)

1958

1959

while(True):

1959

while(True):

1960

1961

readerObj.getData()

1961

readerObj.getData()

1962

1963

print readerObj.data_spc

1963

print readerObj.data_spc

1964

1965

print readerObj.data_cspc

1965

print readerObj.data_cspc

1966

1967

print readerObj.data_dc

1967

print readerObj.data_dc

1968

1969

if readerObj.flagNoMoreFiles:

1969

if readerObj.flagNoMoreFiles:

1970

break

1970

break

1971

1972

"""

1972

"""

1973

1974

pts2read_SelfSpectra = 0

1974

pts2read_SelfSpectra = 0

1975

1976

pts2read_CrossSpectra = 0

1976

pts2read_CrossSpectra = 0

1977

1978

pts2read_DCchannels = 0

1978

pts2read_DCchannels = 0

1979

1980

ext = ".pdata"

1980

ext = ".pdata"

1981

1982

optchar = "P"

1982

optchar = "P"

1983

1984

dataOut = None

1984

dataOut = None

1985

1986

nRdChannels = None

1986

nRdChannels = None

1987

1988

nRdPairs = None

1988

nRdPairs = None

1989

1990

rdPairList = []

1990

rdPairList = []

1991

1992

def __init__(self):

1992

def __init__(self):

1993

"""

1993

"""

1994

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

1994

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

1995

1996

Inputs:

1996

Inputs:

1997

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

1997

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

1998

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

1998

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

1999

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

1999

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

2000

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

2000

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

2001

bloque de datos.

2001

bloque de datos.

2002

Si este parametro no es pasado se creara uno internamente.

2002

Si este parametro no es pasado se creara uno internamente.

2003

2004

Affected:

2004

Affected:

2005

self.dataOut

2005

self.dataOut

2006

2007

Return : None

2007

Return : None

2008

"""

2008

"""

2009

2010

self.isConfig = False

2010

self.isConfig = False

2011

2012

self.pts2read_SelfSpectra = 0

2012

self.pts2read_SelfSpectra = 0

2013

2014

self.pts2read_CrossSpectra = 0

2014

self.pts2read_CrossSpectra = 0

2015

2016

self.pts2read_DCchannels = 0

2016

self.pts2read_DCchannels = 0

2017

2018

self.datablock = None

2018

self.datablock = None

2019

2020

self.utc = None

2020

self.utc = None

2021

2022

self.ext = ".pdata"

2022

self.ext = ".pdata"

2023

2024

self.optchar = "P"

2024

self.optchar = "P"

2025

2026

self.basicHeaderObj = BasicHeader(LOCALTIME)

2026

self.basicHeaderObj = BasicHeader(LOCALTIME)

2027

2028

self.systemHeaderObj = SystemHeader()

2028

self.systemHeaderObj = SystemHeader()

2029

2030

self.radarControllerHeaderObj = RadarControllerHeader()

2030

self.radarControllerHeaderObj = RadarControllerHeader()

2031

2032

self.processingHeaderObj = ProcessingHeader()

2032

self.processingHeaderObj = ProcessingHeader()

2033

2034

self.online = 0

2034

self.online = 0

2035

2036

self.fp = None

2036

self.fp = None

2037

2038

self.idFile = None

2038

self.idFile = None

2039

2040

self.dtype = None

2040

self.dtype = None

2041

2042

self.fileSizeByHeader = None

2042

self.fileSizeByHeader = None

2043

2044

self.filenameList = []

2044

self.filenameList = []

2045

2046

self.filename = None

2046

self.filename = None

2047

2048

self.fileSize = None

2048

self.fileSize = None

2049

2050

self.firstHeaderSize = 0

2050

self.firstHeaderSize = 0

2051

2052

self.basicHeaderSize = 24

2052

self.basicHeaderSize = 24

2053

2054

self.pathList = []

2054

self.pathList = []

2055

2056

self.lastUTTime = 0

2056

self.lastUTTime = 0

2057

2058

self.maxTimeStep = 30

2058

self.maxTimeStep = 30

2059

2060

self.flagNoMoreFiles = 0

2060

self.flagNoMoreFiles = 0

2061

2062

self.set = 0

2062

self.set = 0

2063

2064

self.path = None

2064

self.path = None

2065

2066

self.delay = 60 #seconds

2066

self.delay = 60 #seconds

2067

2068

self.nTries = 3 #quantity tries

2068

self.nTries = 3 #quantity tries

2069

2070

self.nFiles = 3 #number of files for searching

2070

self.nFiles = 3 #number of files for searching

2071

2072

self.nReadBlocks = 0

2072

self.nReadBlocks = 0

2073

2074

self.flagIsNewFile = 1

2074

self.flagIsNewFile = 1

2075

2076

self.__isFirstTimeOnline = 1

2076

self.__isFirstTimeOnline = 1

2077

2078

self.ippSeconds = 0

2078

self.ippSeconds = 0

2079

2080

self.flagTimeBlock = 0

2080

self.flagTimeBlock = 0

2081

2082

self.flagIsNewBlock = 0

2082

self.flagIsNewBlock = 0

2083

2084

self.nTotalBlocks = 0

2084

self.nTotalBlocks = 0

2085

2086

self.blocksize = 0

2086

self.blocksize = 0

2087

2088

self.dataOut = self.createObjByDefault()

2088

self.dataOut = self.createObjByDefault()

2089

2090

self.profileIndex = 1 #Always

2090

self.profileIndex = 1 #Always

2091

2092

2093

def createObjByDefault(self):

2093

def createObjByDefault(self):

2094

2095

dataObj = Spectra()

2095

dataObj = Spectra()

2096

2097

return dataObj

2097

return dataObj

2098

2099

def __hasNotDataInBuffer(self):

2099

def __hasNotDataInBuffer(self):

2100

return 1

2100

return 1

2101

2102

2103

def getBlockDimension(self):

2103

def getBlockDimension(self):

2104

"""

2104

"""

2105

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

2105

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

2106

2107

Affected:

2107

Affected:

2108

self.nRdChannels

2108

self.nRdChannels

2109

self.nRdPairs

2109

self.nRdPairs

2110

self.pts2read_SelfSpectra

2110

self.pts2read_SelfSpectra

2111

self.pts2read_CrossSpectra

2111

self.pts2read_CrossSpectra

2112

self.pts2read_DCchannels

2112

self.pts2read_DCchannels

2113

self.blocksize

2113

self.blocksize

2114

self.dataOut.nChannels

2114

self.dataOut.nChannels

2115

self.dataOut.nPairs

2115

self.dataOut.nPairs

2116

2117

Return:

2117

Return:

2118

None

2118

None

2119

"""

2119

"""

2120

self.nRdChannels = 0

2120

self.nRdChannels = 0

2121

self.nRdPairs = 0

2121

self.nRdPairs = 0

2122

self.rdPairList = []

2122

self.rdPairList = []

2123

2124

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

2124

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

2125

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

2125

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

2126

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

2126

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

2127

else:

2127

else:

2128

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

2128

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

2129

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

2129

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

2130

2131

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

2131

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

2132

2133

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

2133

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

2134

self.blocksize = self.pts2read_SelfSpectra

2134

self.blocksize = self.pts2read_SelfSpectra

2135

2136

if self.processingHeaderObj.flag_cspc:

2136

if self.processingHeaderObj.flag_cspc:

2137

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

2137

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

2138

self.blocksize += self.pts2read_CrossSpectra

2138

self.blocksize += self.pts2read_CrossSpectra

2139

2140

if self.processingHeaderObj.flag_dc:

2140

if self.processingHeaderObj.flag_dc:

2141

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

2141

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

2142

self.blocksize += self.pts2read_DCchannels

2142

self.blocksize += self.pts2read_DCchannels

2143

2144

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

2144

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

2145

2146

2147

def readBlock(self):

2147

def readBlock(self):

2148

"""

2148

"""

2149

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

2149

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

2150

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

2150

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

2151

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

2151

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

2152

es seteado a 0

2152

es seteado a 0

2153

2154

Return: None

2154

Return: None

2155

2156

Variables afectadas:

2156

Variables afectadas:

2157

2158

self.flagIsNewFile

2158

self.flagIsNewFile

2159

self.flagIsNewBlock

2159

self.flagIsNewBlock

2160

self.nTotalBlocks

2160

self.nTotalBlocks

2161

self.data_spc

2161

self.data_spc

2162

self.data_cspc

2162

self.data_cspc

2163

self.data_dc

2163

self.data_dc

2164

2165

Exceptions:

2165

Exceptions:

2166

Si un bloque leido no es un bloque valido

2166

Si un bloque leido no es un bloque valido

2167

"""

2167

"""

2168

blockOk_flag = False

2168

blockOk_flag = False

2169

fpointer = self.fp.tell()

2169

fpointer = self.fp.tell()

2170

2171

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

2171

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

2172

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

2172

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

2173

2174

if self.processingHeaderObj.flag_cspc:

2174

if self.processingHeaderObj.flag_cspc:

2175

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

2175

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

2176

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

2176

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

2177

2178

if self.processingHeaderObj.flag_dc:

2178

if self.processingHeaderObj.flag_dc:

2179

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

2179

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

2180

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

2180

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

2181

2182

2183

if not(self.processingHeaderObj.shif_fft):

2183

if not(self.processingHeaderObj.shif_fft):

2184

#desplaza a la derecha en el eje 2 determinadas posiciones

2184

#desplaza a la derecha en el eje 2 determinadas posiciones

2185

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

2185

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

2186

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

2186

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

2187

2188

if self.processingHeaderObj.flag_cspc:

2188

if self.processingHeaderObj.flag_cspc:

2189

#desplaza a la derecha en el eje 2 determinadas posiciones

2189

#desplaza a la derecha en el eje 2 determinadas posiciones

2190

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

2190

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

2191

2192

# self.processingHeaderObj.shif_fft = True

2192

# self.processingHeaderObj.shif_fft = True

2193

2194

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

2194

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

2195

self.data_spc = spc

2195

self.data_spc = spc

2196

2197

if self.processingHeaderObj.flag_cspc:

2197

if self.processingHeaderObj.flag_cspc:

2198

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

2198

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

2199

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

2199

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

2200

else:

2200

else:

2201

self.data_cspc = None

2201

self.data_cspc = None

2202

2203

if self.processingHeaderObj.flag_dc:

2203

if self.processingHeaderObj.flag_dc:

2204

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

2204

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

2205

else:

2205

else:

2206

self.data_dc = None

2206

self.data_dc = None

2207

2208

self.flagIsNewFile = 0

2208

self.flagIsNewFile = 0

2209

self.flagIsNewBlock = 1

2209

self.flagIsNewBlock = 1

2210

2211

self.nTotalBlocks += 1

2211

self.nTotalBlocks += 1

2212

self.nReadBlocks += 1

2212

self.nReadBlocks += 1

2213

2214

return 1

2214

return 1

2215

2216

def getFirstHeader(self):

2216

def getFirstHeader(self):

2217

2218

self.dataOut.dtype = self.dtype

2218

self.dataOut.dtype = self.dtype

2219

2220

self.dataOut.nPairs = self.nRdPairs

2220

self.dataOut.nPairs = self.nRdPairs

2221

2222

self.dataOut.pairsList = self.rdPairList

2222

self.dataOut.pairsList = self.rdPairList

2223

2224

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

2224

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

2225

2226

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

2226

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

2227

2228

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

2228

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

2229

2230

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

2230

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

2231

2232

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

2232

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

2233

2234

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

2234

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

2235

2236

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

2236

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

2237

2238

self.dataOut.ippSeconds = self.ippSeconds

2238

self.dataOut.ippSeconds = self.ippSeconds

2239

2240

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

2240

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

2241

2242

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

2242

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

2243

2244

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

2244

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

2245

2246

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

2246

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

2247

2248

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

2248

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

2249

2250

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

2250

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

2251

2252

if self.radarControllerHeaderObj.code != None:

2252

if self.radarControllerHeaderObj.code != None:

2253

2254

self.dataOut.nCode = self.radarControllerHeaderObj.nCode

2254

self.dataOut.nCode = self.radarControllerHeaderObj.nCode

2255

2256

self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud

2256

self.dataOut.nBaud = self.radarControllerHeaderObj.nBaud

2257

2258

self.dataOut.code = self.radarControllerHeaderObj.code

2258

self.dataOut.code = self.radarControllerHeaderObj.code

2259

2260

self.dataOut.flagDecodeData = True

2260

self.dataOut.flagDecodeData = True

2261

2262

def getData(self):

2262

def getData(self):

2263

"""

2263

"""

2264

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

2264

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

2265

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

2265

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

2266

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

2266

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

2267

2268

Return:

2268

Return:

2269

0 : Si no hay mas archivos disponibles

2269

0 : Si no hay mas archivos disponibles

2270

1 : Si hizo una buena copia del buffer

2270

1 : Si hizo una buena copia del buffer

2271

2272

Affected:

2272

Affected:

2273

self.dataOut

2273

self.dataOut

2274

2275

self.flagTimeBlock

2275

self.flagTimeBlock

2276

self.flagIsNewBlock

2276

self.flagIsNewBlock

2277

"""

2277

"""

2278

2279

if self.flagNoMoreFiles:

2279

if self.flagNoMoreFiles:

2280

self.dataOut.flagNoData = True

2280

self.dataOut.flagNoData = True

2281

print 'Process finished'

2281

print 'Process finished'

2282

return 0

2282

return 0

2283

2284

self.flagTimeBlock = 0

2284

self.flagTimeBlock = 0

2285

self.flagIsNewBlock = 0

2285

self.flagIsNewBlock = 0

2286

2287

if self.__hasNotDataInBuffer():

2287

if self.__hasNotDataInBuffer():

2288

2289

if not( self.readNextBlock() ):

2289

if not( self.readNextBlock() ):

2290

self.dataOut.flagNoData = True

2290

self.dataOut.flagNoData = True

2291

return 0

2291

return 0

2292

2293

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

2293

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

2294

2295

if self.data_dc == None:

2295

if self.data_dc == None:

2296

self.dataOut.flagNoData = True

2296

self.dataOut.flagNoData = True

2297

return 0

2297

return 0

2298

2299

self.getBasicHeader()

2299

self.getBasicHeader()

2300

2301

self.getFirstHeader()

2301

self.getFirstHeader()

2302

2303

self.dataOut.data_spc = self.data_spc

2303

self.dataOut.data_spc = self.data_spc

2304

2305

self.dataOut.data_cspc = self.data_cspc

2305

self.dataOut.data_cspc = self.data_cspc

2306

2307

self.dataOut.data_dc = self.data_dc

2307

self.dataOut.data_dc = self.data_dc

2308

2309

self.dataOut.flagNoData = False

2309

self.dataOut.flagNoData = False

2310

2311

self.dataOut.realtime = self.online

2311

self.dataOut.realtime = self.online

2312

2313

return self.dataOut.data_spc

2313

return self.dataOut.data_spc

2314

2315

2316

class SpectraWriter(JRODataWriter):

2316

class SpectraWriter(JRODataWriter):

2317

2318

"""

2318

"""

2319

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

2319

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

2320

de los datos siempre se realiza por bloques.

2320

de los datos siempre se realiza por bloques.

2321

"""

2321

"""

2322

2323

ext = ".pdata"

2323

ext = ".pdata"

2324

2325

optchar = "P"

2325

optchar = "P"

2326

2327

shape_spc_Buffer = None

2327

shape_spc_Buffer = None

2328

2329

shape_cspc_Buffer = None

2329

shape_cspc_Buffer = None

2330

2331

shape_dc_Buffer = None

2331

shape_dc_Buffer = None

2332

2333

data_spc = None

2333

data_spc = None

2334

2335

data_cspc = None

2335

data_cspc = None

2336

2337

data_dc = None

2337

data_dc = None

2338

2339

# dataOut = None

2339

# dataOut = None

2340

2341

def __init__(self):

2341

def __init__(self):

2342

"""

2342

"""

2343

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

2343

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

2344

2345

Affected:

2345

Affected:

2346

self.dataOut

2346

self.dataOut

2347

self.basicHeaderObj

2347

self.basicHeaderObj

2348

self.systemHeaderObj

2348

self.systemHeaderObj

2349

self.radarControllerHeaderObj

2349

self.radarControllerHeaderObj

2350

self.processingHeaderObj

2350

self.processingHeaderObj

2351

2352

Return: None

2352

Return: None

2353

"""

2353

"""

2354

2355

self.isConfig = False

2355

self.isConfig = False

2356

2357

self.nTotalBlocks = 0

2357

self.nTotalBlocks = 0

2358

2359

self.data_spc = None

2359

self.data_spc = None

2360

2361

self.data_cspc = None

2361

self.data_cspc = None

2362

2363

self.data_dc = None

2363

self.data_dc = None

2364

2365

self.fp = None

2365

self.fp = None

2366

2367

self.flagIsNewFile = 1

2367

self.flagIsNewFile = 1

2368

2369

self.nTotalBlocks = 0

2369

self.nTotalBlocks = 0

2370

2371

self.flagIsNewBlock = 0

2371

self.flagIsNewBlock = 0

2372

2373

self.setFile = None

2373

self.setFile = None

2374

2375

self.dtype = None

2375

self.dtype = None

2376

2377

self.path = None

2377

self.path = None

2378

2379

self.noMoreFiles = 0

2379

self.noMoreFiles = 0

2380

2381

self.filename = None

2381

self.filename = None

2382

2383

self.basicHeaderObj = BasicHeader(LOCALTIME)

2383

self.basicHeaderObj = BasicHeader(LOCALTIME)

2384

2385

self.systemHeaderObj = SystemHeader()

2385

self.systemHeaderObj = SystemHeader()

2386

2387

self.radarControllerHeaderObj = RadarControllerHeader()

2387

self.radarControllerHeaderObj = RadarControllerHeader()

2388

2389

self.processingHeaderObj = ProcessingHeader()

2389

self.processingHeaderObj = ProcessingHeader()

2390

2391

2392

def hasAllDataInBuffer(self):

2392

def hasAllDataInBuffer(self):

2393

return 1

2393

return 1

2394

2395

2396

def setBlockDimension(self):

2396

def setBlockDimension(self):

2397

"""

2397

"""

2398

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

2398

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

2399

2400

Affected:

2400

Affected:

2401

self.shape_spc_Buffer

2401

self.shape_spc_Buffer

2402

self.shape_cspc_Buffer

2402

self.shape_cspc_Buffer

2403

self.shape_dc_Buffer

2403

self.shape_dc_Buffer

2404

2405

Return: None

2405

Return: None

2406

"""

2406

"""

2407

self.shape_spc_Buffer = (self.dataOut.nChannels,

2407

self.shape_spc_Buffer = (self.dataOut.nChannels,

2408

self.processingHeaderObj.nHeights,

2408

self.processingHeaderObj.nHeights,

2409

self.processingHeaderObj.profilesPerBlock)

2409

self.processingHeaderObj.profilesPerBlock)

2410

2411

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2411

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2412

self.processingHeaderObj.nHeights,

2412

self.processingHeaderObj.nHeights,

2413

self.processingHeaderObj.profilesPerBlock)

2413

self.processingHeaderObj.profilesPerBlock)

2414

2415

self.shape_dc_Buffer = (self.dataOut.nChannels,

2415

self.shape_dc_Buffer = (self.dataOut.nChannels,

2416

self.processingHeaderObj.nHeights)

2416

self.processingHeaderObj.nHeights)

2417

2418

2419

def writeBlock(self):

2419

def writeBlock(self):

2420

"""

2420

"""

2421

Escribe el buffer en el file designado

2421

Escribe el buffer en el file designado

2422

2423

Affected:

2423

Affected:

2424

self.data_spc

2424

self.data_spc

2425

self.data_cspc

2425

self.data_cspc

2426

self.data_dc

2426

self.data_dc

2427

self.flagIsNewFile

2427

self.flagIsNewFile

2428

self.flagIsNewBlock

2428

self.flagIsNewBlock

2429

self.nTotalBlocks

2429

self.nTotalBlocks

2430

self.nWriteBlocks

2430

self.nWriteBlocks

2431

2432

Return: None

2432

Return: None

2433

"""

2433

"""

2434

2435

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

2435

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

2436

if not( self.processingHeaderObj.shif_fft ):

2436

if not( self.processingHeaderObj.shif_fft ):

2437

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

2437

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

2438

data = spc.reshape((-1))

2438

data = spc.reshape((-1))

2439

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

2439

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

2440

data.tofile(self.fp)

2440

data.tofile(self.fp)

2441

2442

if self.data_cspc != None:

2442

if self.data_cspc != None:

2443

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

2443

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

2444

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

2444

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

2445

if not( self.processingHeaderObj.shif_fft ):

2445

if not( self.processingHeaderObj.shif_fft ):

2446

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

2446

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

2447

data['real'] = cspc.real

2447

data['real'] = cspc.real

2448

data['imag'] = cspc.imag

2448

data['imag'] = cspc.imag

2449

data = data.reshape((-1))

2449

data = data.reshape((-1))

2450

data.tofile(self.fp)

2450

data.tofile(self.fp)

2451

2452

if self.data_dc != None:

2452

if self.data_dc != None:

2453

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

2453

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

2454

dc = self.data_dc

2454

dc = self.data_dc

2455

data['real'] = dc.real

2455

data['real'] = dc.real

2456

data['imag'] = dc.imag

2456

data['imag'] = dc.imag

2457

data = data.reshape((-1))

2457

data = data.reshape((-1))

2458

data.tofile(self.fp)

2458

data.tofile(self.fp)

2459

2460

self.data_spc.fill(0)

2460

self.data_spc.fill(0)

2461

2462

if self.data_dc != None:

2462

if self.data_dc != None:

2463

self.data_dc.fill(0)

2463

self.data_dc.fill(0)

2464

2465

if self.data_cspc != None:

2465

if self.data_cspc != None:

2466

self.data_cspc.fill(0)

2466

self.data_cspc.fill(0)

2467

2468

self.flagIsNewFile = 0

2468

self.flagIsNewFile = 0

2469

self.flagIsNewBlock = 1

2469

self.flagIsNewBlock = 1

2470

self.nTotalBlocks += 1

2470

self.nTotalBlocks += 1

2471

self.nWriteBlocks += 1

2471

self.nWriteBlocks += 1

2472

self.blockIndex += 1

2472

self.blockIndex += 1

2473

2474

2475

def putData(self):

2475

def putData(self):

2476

"""

2476

"""

2477

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

2477

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

2478

2479

Affected:

2479

Affected:

2480

self.data_spc

2480

self.data_spc

2481

self.data_cspc

2481

self.data_cspc

2482

self.data_dc

2482

self.data_dc

2483

2484

Return:

2484

Return:

2485

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

2485

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

2486

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

2486

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

2487

"""

2487

"""

2488

2489

if self.dataOut.flagNoData:

2489

if self.dataOut.flagNoData:

2490

return 0

2490

return 0

2491

2492

self.flagIsNewBlock = 0

2492

self.flagIsNewBlock = 0

2493

2494

if self.dataOut.flagTimeBlock:

2494

if self.dataOut.flagTimeBlock:

2495

self.data_spc.fill(0)

2495

self.data_spc.fill(0)

2496

self.data_cspc.fill(0)

2496

self.data_cspc.fill(0)

2497

self.data_dc.fill(0)

2497

self.data_dc.fill(0)

2498

self.setNextFile()

2498

self.setNextFile()

2499

2500

if self.flagIsNewFile == 0:

2500

if self.flagIsNewFile == 0:

2501

self.setBasicHeader()

2501

self.setBasicHeader()

2502

2503

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

2503

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

2504

if self.dataOut.data_cspc != None:

2504

if self.dataOut.data_cspc != None:

2505

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

2505

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

2506

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

2506

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

2507

2508

# #self.processingHeaderObj.dataBlocksPerFile)

2508

# #self.processingHeaderObj.dataBlocksPerFile)

2509

if self.hasAllDataInBuffer():

2509

if self.hasAllDataInBuffer():

2510

# self.setFirstHeader()

2510

# self.setFirstHeader()

2511

self.writeNextBlock()

2511

self.writeNextBlock()

2512

2513

return 1

2513

return 1

2514

2515

2516

def __getProcessFlags(self):

2516

def __getProcessFlags(self):

2517

2518

processFlags = 0

2518

processFlags = 0

2519

2520

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

2520

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

2521

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

2521

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

2522

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

2522

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

2523

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

2523

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

2524

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

2524

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

2525

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

2525

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

2526

2527

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

2527

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

2528

2529

2530

2531

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2531

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2532

PROCFLAG.DATATYPE_SHORT,

2532

PROCFLAG.DATATYPE_SHORT,

2533

PROCFLAG.DATATYPE_LONG,

2533

PROCFLAG.DATATYPE_LONG,

2534

PROCFLAG.DATATYPE_INT64,

2534

PROCFLAG.DATATYPE_INT64,

2535

PROCFLAG.DATATYPE_FLOAT,

2535

PROCFLAG.DATATYPE_FLOAT,

2536

PROCFLAG.DATATYPE_DOUBLE]

2536

PROCFLAG.DATATYPE_DOUBLE]

2537

2538

2539

for index in range(len(dtypeList)):

2539

for index in range(len(dtypeList)):

2540

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

2540

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

2541

dtypeValue = datatypeValueList[index]

2541

dtypeValue = datatypeValueList[index]

2542

break

2542

break

2543

2544

processFlags += dtypeValue

2544

processFlags += dtypeValue

2545

2546

if self.dataOut.flagDecodeData:

2546

if self.dataOut.flagDecodeData:

2547

processFlags += PROCFLAG.DECODE_DATA

2547

processFlags += PROCFLAG.DECODE_DATA

2548

2549

if self.dataOut.flagDeflipData:

2549

if self.dataOut.flagDeflipData:

2550

processFlags += PROCFLAG.DEFLIP_DATA

2550

processFlags += PROCFLAG.DEFLIP_DATA

2551

2552

if self.dataOut.code != None:

2552

if self.dataOut.code != None:

2553

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2553

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2554

2555

if self.dataOut.nIncohInt > 1:

2555

if self.dataOut.nIncohInt > 1:

2556

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2556

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2557

2558

if self.dataOut.data_dc != None:

2558

if self.dataOut.data_dc != None:

2559

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2559

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2560

2561

return processFlags

2561

return processFlags

2562

2563

2564

def __getBlockSize(self):

2564

def __getBlockSize(self):

2565

'''

2565

'''

2566

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

2566

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

2567

'''

2567

'''

2568

2569

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

2569

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

2570

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

2570

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

2571

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

2571

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

2572

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

2572

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

2573

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

2573

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

2574

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

2574

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

2575

2576

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

2576

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

2577

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

2577

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

2578

for index in range(len(dtypeList)):

2578

for index in range(len(dtypeList)):

2579

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

2579

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

2580

datatypeValue = datatypeValueList[index]

2580

datatypeValue = datatypeValueList[index]

2581

break

2581

break

2582

2583

2584

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

2584

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

2585

2586

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

2586

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

2587

blocksize = (pts2write_SelfSpectra*datatypeValue)

2587

blocksize = (pts2write_SelfSpectra*datatypeValue)

2588

2589

if self.dataOut.data_cspc != None:

2589

if self.dataOut.data_cspc != None:

2590

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

2590

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

2591

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2591

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2592

2593

if self.dataOut.data_dc != None:

2593

if self.dataOut.data_dc != None:

2594

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

2594

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

2595

blocksize += (pts2write_DCchannels*datatypeValue*2)

2595

blocksize += (pts2write_DCchannels*datatypeValue*2)

2596

2597

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2597

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2598

2599

return blocksize

2599

return blocksize

2600

2601

def setFirstHeader(self):

2601

def setFirstHeader(self):

2602

2603

"""

2603

"""

2604

Obtiene una copia del First Header

2604

Obtiene una copia del First Header

2605

2606

Affected:

2606

Affected:

2607

self.systemHeaderObj

2607

self.systemHeaderObj

2608

self.radarControllerHeaderObj

2608

self.radarControllerHeaderObj

2609

self.dtype

2609

self.dtype

2610

2611

Return:

2611

Return:

2612

None

2612

None

2613

"""

2613

"""

2614

2615

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

2615

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

2616

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2616

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2617

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

2617

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

2618

old_code_size = self.dataOut.radarControllerHeaderObj.code_size

2619

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

2620

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

2618

2621

2619

self.setBasicHeader()

2622

self.setBasicHeader()

2620

2623

2621

processingHeaderSize = 40 # bytes

2624

processingHeaderSize = 40 # bytes

2622

self.processingHeaderObj.dtype = 1 # Spectra

2625

self.processingHeaderObj.dtype = 1 # Spectra

2623

self.processingHeaderObj.blockSize = self.__getBlockSize()

2626

self.processingHeaderObj.blockSize = self.__getBlockSize()

2624

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2627

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2625

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2628

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2626

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

2629

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

2627

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2630

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2628

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

2631

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

2629

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2632

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2630

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

2633

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

2631

self.processingHeaderObj.shif_fft = self.dataOut.flagShiftFFT

2634

self.processingHeaderObj.shif_fft = self.dataOut.flagShiftFFT

2632

2635

2633

if self.processingHeaderObj.totalSpectra > 0:

2636

if self.processingHeaderObj.totalSpectra > 0:

2634

channelList = []

2637

channelList = []

2635

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

2638

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

2636

channelList.append(channel)

2639

channelList.append(channel)

2637

channelList.append(channel)

2640

channelList.append(channel)

2638

2641

2639

pairsList = []

2642

pairsList = []

2640

if self.dataOut.nPairs > 0:

2643

if self.dataOut.nPairs > 0:

2641

for pair in self.dataOut.pairsList:

2644

for pair in self.dataOut.pairsList:

2642

pairsList.append(pair[0])

2645

pairsList.append(pair[0])

2643

pairsList.append(pair[1])

2646

pairsList.append(pair[1])

2644

2647

2645

spectraComb = channelList + pairsList

2648

spectraComb = channelList + pairsList

2646

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

2649

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

2647

self.processingHeaderObj.spectraComb = spectraComb

2650

self.processingHeaderObj.spectraComb = spectraComb

2648

sizeOfSpcComb = len(spectraComb)

2651

sizeOfSpcComb = len(spectraComb)

2649

processingHeaderSize += sizeOfSpcComb

2652

processingHeaderSize += sizeOfSpcComb

2650

2653

2651

# The processing header should not have information about code

2654

# The processing header should not have information about code

2652

# if self.dataOut.code != None:

2655

# if self.dataOut.code != None:

2653

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

2656

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

2654

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

2657

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

2655

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

2658

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

2656

# nCodeSize = 4 # bytes

2659

# nCodeSize = 4 # bytes

2657

# nBaudSize = 4 # bytes

2660

# nBaudSize = 4 # bytes

2658

# codeSize = 4 # bytes

2661

# codeSize = 4 # bytes

2659

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

2662

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

2660

# processingHeaderSize += sizeOfCode

2663

# processingHeaderSize += sizeOfCode

2661

2664

2662

if self.processingHeaderObj.nWindows != 0:

2665

if self.processingHeaderObj.nWindows != 0:

2663

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

2666

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

2664

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

2667

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

2665

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2668

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2666

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2669

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2667

sizeOfFirstHeight = 4

2670

sizeOfFirstHeight = 4

2668

sizeOfdeltaHeight = 4

2671

sizeOfdeltaHeight = 4

2669

sizeOfnHeights = 4

2672

sizeOfnHeights = 4

2670

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

2673

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

2671

processingHeaderSize += sizeOfWindows

2674

processingHeaderSize += sizeOfWindows

2672

2675

2673

self.processingHeaderObj.size = processingHeaderSize

2676

self.processingHeaderObj.size = processingHeaderSize

2674

2677

2675

class SpectraHeisWriter(Operation):

2678

class SpectraHeisWriter(Operation):

2676

# set = None

2679

# set = None

2677

setFile = None

2680

setFile = None

2678

idblock = None

2681

idblock = None

2679

doypath = None

2682

doypath = None

2680

subfolder = None

2683

subfolder = None

2681

2684

2682

def __init__(self):

2685

def __init__(self):

2683

self.wrObj = FITS()

2686

self.wrObj = FITS()

2684

# self.dataOut = dataOut

2687

# self.dataOut = dataOut

2685

self.nTotalBlocks=0

2688

self.nTotalBlocks=0

2686

# self.set = None

2689

# self.set = None

2687

self.setFile = None

2690

self.setFile = None

2688

self.idblock = 0

2691

self.idblock = 0

2689

self.wrpath = None

2692

self.wrpath = None

2690

self.doypath = None

2693

self.doypath = None

2691

self.subfolder = None

2694

self.subfolder = None

2692

self.isConfig = False

2695

self.isConfig = False

2693

2696

2694

def isNumber(str):

2697

def isNumber(str):

2695

"""

2698

"""

2696

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

2699

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

2697

2700

2698

Excepciones:

2701

Excepciones:

2699

Si un determinado string no puede ser convertido a numero

2702

Si un determinado string no puede ser convertido a numero

2700

Input:

2703

Input:

2701

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

2704

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

2702

2705

2703

Return:

2706

Return:

2704

True : si el string es uno numerico

2707

True : si el string es uno numerico

2705

False : no es un string numerico

2708

False : no es un string numerico

2706

"""

2709

"""

2707

try:

2710

try:

2708

float( str )

2711

float( str )

2709

return True

2712

return True

2710

except:

2713

except:

2711

return False

2714

return False

2712

2715

2713

def setup(self, dataOut, wrpath):

2716

def setup(self, dataOut, wrpath):

2714

2717

2715

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

2718

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

2716

os.mkdir(wrpath)

2719

os.mkdir(wrpath)

2717

2720

2718

self.wrpath = wrpath

2721

self.wrpath = wrpath

2719

# self.setFile = 0

2722

# self.setFile = 0

2720

self.dataOut = dataOut

2723

self.dataOut = dataOut

2721

2724

2722

def putData(self):

2725

def putData(self):

2723

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

2726

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

2724

ext=".fits"

2727

ext=".fits"

2725

2728

2726

if self.doypath == None:

2729

if self.doypath == None:

2727

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

2730

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

2728

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

2731

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

2729

os.mkdir(self.doypath)

2732

os.mkdir(self.doypath)

2730

2733

2731

if self.setFile == None:

2734

if self.setFile == None:

2732

# self.set = self.dataOut.set

2735

# self.set = self.dataOut.set

2733

self.setFile = 0

2736

self.setFile = 0

2734

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

2737

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

2735

## self.set = self.dataOut.set

2738

## self.set = self.dataOut.set

2736

# self.setFile = 0

2739

# self.setFile = 0

2737

2740

2738

#make the filename

2741

#make the filename

2739

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

2742

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

2740

2743

2741

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

2744

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

2742

2745

2743

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

2746

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

2744

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

2747

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

2745

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

2748

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

2746

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

2749

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

2747

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

2750

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

2748

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

2751

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

2749

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

2752

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

2750

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

2753

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

2751

2754

2752

c=3E8

2755

c=3E8

2753

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

2756

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

2754

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

2757

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

2755

2758

2756

colList = []

2759

colList = []

2757

2760

2758

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

2761

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

2759

2762

2760

colList.append(colFreq)

2763

colList.append(colFreq)

2761

2764

2762

nchannel=self.dataOut.nChannels

2765

nchannel=self.dataOut.nChannels

2763

2766

2764

for i in range(nchannel):

2767

for i in range(nchannel):

2765

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

2768

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

2766

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

2769

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

2767

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

2770

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

2768

2771

2769

colList.append(col)

2772

colList.append(col)

2770

2773

2771

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

2774

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

2772

2775

2773

self.wrObj.CFile(header,data)

2776

self.wrObj.CFile(header,data)

2774

2777

2775

self.wrObj.wFile(filename)

2778

self.wrObj.wFile(filename)

2776

2779

2777

#update the setFile

2780

#update the setFile

2778

self.setFile += 1

2781

self.setFile += 1

2779

self.idblock += 1

2782

self.idblock += 1

2780

2783

2781

return 1

2784

return 1

2782

2785

2783

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

2786

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

2784

2787

2785

if not(self.isConfig):

2788

if not(self.isConfig):

2786

2789

2787

self.setup(dataOut, **kwargs)

2790

self.setup(dataOut, **kwargs)

2788

self.isConfig = True

2791

self.isConfig = True

2789

2792

2790

self.putData()

2793

self.putData()

2791

2794

2792

2795

2793

2796

2794

class ParameterConf:

2797

class ParameterConf:

2795

ELEMENTNAME = 'Parameter'

2798

ELEMENTNAME = 'Parameter'

2796

def __init__(self):

2799

def __init__(self):

2797

self.name = ''

2800

self.name = ''

2798

self.value = ''

2801

self.value = ''

2799

2802

2800

def readXml(self, parmElement):

2803

def readXml(self, parmElement):

2801

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

2804

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

2802

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

2805

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

2803

2806

2804

def getElementName(self):

2807

def getElementName(self):

2805

return self.ELEMENTNAME

2808

return self.ELEMENTNAME

2806

2809

2807

class Metadata:

2810

class Metadata:

2808

2811

2809

def __init__(self, filename):

2812

def __init__(self, filename):

2810

self.parmConfObjList = []

2813

self.parmConfObjList = []

2811

self.readXml(filename)

2814

self.readXml(filename)

2812

2815

2813

def readXml(self, filename):

2816

def readXml(self, filename):

2814

self.projectElement = None

2817

self.projectElement = None

2815

self.procUnitConfObjDict = {}

2818

self.procUnitConfObjDict = {}

2816

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

2819

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

2817

self.project = self.projectElement.tag

2820

self.project = self.projectElement.tag

2818

2821

2819

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

2822

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

2820

2823

2821

for parmElement in parmElementList:

2824

for parmElement in parmElementList:

2822

parmConfObj = ParameterConf()

2825

parmConfObj = ParameterConf()

2823

parmConfObj.readXml(parmElement)

2826

parmConfObj.readXml(parmElement)

2824

self.parmConfObjList.append(parmConfObj)

2827

self.parmConfObjList.append(parmConfObj)

2825

2828

2826

class FitsWriter(Operation):

2829

class FitsWriter(Operation):

2827

2830

2828

def __init__(self):

2831

def __init__(self):

2829

self.isConfig = False

2832

self.isConfig = False

2830

self.dataBlocksPerFile = None

2833

self.dataBlocksPerFile = None

2831

self.blockIndex = 0

2834

self.blockIndex = 0

2832

self.flagIsNewFile = 1

2835

self.flagIsNewFile = 1

2833

self.fitsObj = None

2836

self.fitsObj = None

2834

self.optchar = 'P'

2837

self.optchar = 'P'

2835

self.ext = '.fits'

2838

self.ext = '.fits'

2836

self.setFile = 0

2839

self.setFile = 0

2837

2840

2838

def setFitsHeader(self, dataOut, metadatafile):

2841

def setFitsHeader(self, dataOut, metadatafile):

2839

2842

2840

header_data = pyfits.PrimaryHDU()

2843

header_data = pyfits.PrimaryHDU()

2841

2844

2842

metadata4fits = Metadata(metadatafile)

2845

metadata4fits = Metadata(metadatafile)

2843

for parameter in metadata4fits.parmConfObjList:

2846

for parameter in metadata4fits.parmConfObjList:

2844

parm_name = parameter.name

2847

parm_name = parameter.name

2845

parm_value = parameter.value

2848

parm_value = parameter.value

2846

2849

2847

# if parm_value == 'fromdatadatetime':

2850

# if parm_value == 'fromdatadatetime':

2848

# value = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())

2851

# value = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())

2849

# elif parm_value == 'fromdataheights':

2852

# elif parm_value == 'fromdataheights':

2850

# value = dataOut.nHeights

2853

# value = dataOut.nHeights

2851

# elif parm_value == 'fromdatachannel':

2854

# elif parm_value == 'fromdatachannel':

2852

# value = dataOut.nChannels

2855

# value = dataOut.nChannels

2853

# elif parm_value == 'fromdatasamples':

2856

# elif parm_value == 'fromdatasamples':

2854

# value = dataOut.nFFTPoints

2857

# value = dataOut.nFFTPoints

2855

# else:

2858

# else:

2856

# value = parm_value

2859

# value = parm_value

2857

2860

2858

header_data.header[parm_name] = parm_value

2861

header_data.header[parm_name] = parm_value

2859

2862

2860

2863

2861

header_data.header['DATETIME'] = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())

2864

header_data.header['DATETIME'] = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())

2862

header_data.header['CHANNELLIST'] = str(dataOut.channelList)

2865

header_data.header['CHANNELLIST'] = str(dataOut.channelList)

2863

header_data.header['NCHANNELS'] = dataOut.nChannels

2866

header_data.header['NCHANNELS'] = dataOut.nChannels

2864

#header_data.header['HEIGHTS'] = dataOut.heightList

2867

#header_data.header['HEIGHTS'] = dataOut.heightList

2865

header_data.header['NHEIGHTS'] = dataOut.nHeights

2868

header_data.header['NHEIGHTS'] = dataOut.nHeights

2866

2869

2867

header_data.header['IPPSECONDS'] = dataOut.ippSeconds

2870

header_data.header['IPPSECONDS'] = dataOut.ippSeconds

2868

header_data.header['NCOHINT'] = dataOut.nCohInt

2871

header_data.header['NCOHINT'] = dataOut.nCohInt

2869

header_data.header['NINCOHINT'] = dataOut.nIncohInt

2872

header_data.header['NINCOHINT'] = dataOut.nIncohInt

2870

header_data.header['TIMEZONE'] = dataOut.timeZone

2873

header_data.header['TIMEZONE'] = dataOut.timeZone

2871

header_data.header['NBLOCK'] = self.blockIndex

2874

header_data.header['NBLOCK'] = self.blockIndex

2872

2875

2873

header_data.writeto(self.filename)

2876

header_data.writeto(self.filename)

2874

2877

2875

self.addExtension(dataOut.heightList,'HEIGHTLIST')

2878

self.addExtension(dataOut.heightList,'HEIGHTLIST')

2876

2879

2877

2880

2878

def setup(self, dataOut, path, dataBlocksPerFile, metadatafile):

2881

def setup(self, dataOut, path, dataBlocksPerFile, metadatafile):

2879

2882

2880

self.path = path

2883

self.path = path

2881

self.dataOut = dataOut

2884

self.dataOut = dataOut

2882

self.metadatafile = metadatafile

2885

self.metadatafile = metadatafile

2883

self.dataBlocksPerFile = dataBlocksPerFile

2886

self.dataBlocksPerFile = dataBlocksPerFile

2884

2887

2885

def open(self):

2888

def open(self):

2886

self.fitsObj = pyfits.open(self.filename, mode='update')

2889

self.fitsObj = pyfits.open(self.filename, mode='update')

2887

2890

2888

2891

2889

def addExtension(self, data, tagname):

2892

def addExtension(self, data, tagname):

2890

self.open()

2893

self.open()

2891

extension = pyfits.ImageHDU(data=data, name=tagname)

2894

extension = pyfits.ImageHDU(data=data, name=tagname)

2892

#extension.header['TAG'] = tagname

2895

#extension.header['TAG'] = tagname

2893

self.fitsObj.append(extension)

2896

self.fitsObj.append(extension)

2894

self.write()

2897

self.write()

2895

2898

2896

def addData(self, data):

2899

def addData(self, data):

2897

self.open()

2900

self.open()

2898

extension = pyfits.ImageHDU(data=data, name=self.fitsObj[0].header['DATATYPE'])

2901

extension = pyfits.ImageHDU(data=data, name=self.fitsObj[0].header['DATATYPE'])

2899

extension.header['UTCTIME'] = self.dataOut.utctime

2902

extension.header['UTCTIME'] = self.dataOut.utctime

2900

self.fitsObj.append(extension)

2903

self.fitsObj.append(extension)

2901

self.blockIndex += 1

2904

self.blockIndex += 1

2902

self.fitsObj[0].header['NBLOCK'] = self.blockIndex

2905

self.fitsObj[0].header['NBLOCK'] = self.blockIndex

2903

2906

2904

self.write()

2907

self.write()

2905

2908

2906

def write(self):

2909

def write(self):

2907

2910

2908

self.fitsObj.flush(verbose=True)

2911

self.fitsObj.flush(verbose=True)

2909

self.fitsObj.close()

2912

self.fitsObj.close()

2910

2913

2911

2914

2912

def setNextFile(self):

2915

def setNextFile(self):

2913

2916

2914

ext = self.ext

2917

ext = self.ext

2915

path = self.path

2918

path = self.path

2916

2919

2917

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

2920

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

2918

subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)

2921

subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)

2919

2922

2920

fullpath = os.path.join( path, subfolder )

2923

fullpath = os.path.join( path, subfolder )

2921

if not( os.path.exists(fullpath) ):

2924

if not( os.path.exists(fullpath) ):

2922

os.mkdir(fullpath)

2925

os.mkdir(fullpath)

2923

self.setFile = -1 #inicializo mi contador de seteo

2926

self.setFile = -1 #inicializo mi contador de seteo

2924

else:

2927

else:

2925

filesList = os.listdir( fullpath )

2928

filesList = os.listdir( fullpath )

2926

if len( filesList ) > 0:

2929

if len( filesList ) > 0:

2927

filesList = sorted( filesList, key=str.lower )

2930

filesList = sorted( filesList, key=str.lower )

2928

filen = filesList[-1]

2931

filen = filesList[-1]

2929

2932

2930

if isNumber( filen[8:11] ):

2933

if isNumber( filen[8:11] ):

2931

self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file

2934

self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file

2932

else:

2935

else:

2933

self.setFile = -1

2936

self.setFile = -1

2934

else:

2937

else:

2935

self.setFile = -1 #inicializo mi contador de seteo

2938

self.setFile = -1 #inicializo mi contador de seteo

2936

2939

2937

setFile = self.setFile

2940

setFile = self.setFile

2938

setFile += 1

2941

setFile += 1

2939

2942

2940

file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,

2943

file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,

2941

timeTuple.tm_year,

2944

timeTuple.tm_year,

2942

timeTuple.tm_yday,

2945

timeTuple.tm_yday,

2943

setFile,

2946

setFile,

2944

ext )

2947

ext )

2945

2948

2946

filename = os.path.join( path, subfolder, file )

2949

filename = os.path.join( path, subfolder, file )

2947

2950

2948

self.blockIndex = 0

2951

self.blockIndex = 0

2949

self.filename = filename

2952

self.filename = filename

2950

self.setFile = setFile

2953

self.setFile = setFile

2951

self.flagIsNewFile = 1

2954

self.flagIsNewFile = 1

2952

2955

2953

print 'Writing the file: %s'%self.filename

2956

print 'Writing the file: %s'%self.filename

2954

2957

2955

self.setFitsHeader(self.dataOut, self.metadatafile)

2958

self.setFitsHeader(self.dataOut, self.metadatafile)

2956

2959

2957

return 1

2960

return 1

2958

2961

2959

def writeBlock(self):

2962

def writeBlock(self):

2960

self.addData(self.dataOut.data_spc)

2963

self.addData(self.dataOut.data_spc)

2961

self.flagIsNewFile = 0

2964

self.flagIsNewFile = 0

2962

2965

2963

2966

2964

def __setNewBlock(self):

2967

def __setNewBlock(self):

2965

2968

2966

if self.flagIsNewFile:

2969

if self.flagIsNewFile:

2967

return 1

2970

return 1

2968

2971

2969

if self.blockIndex < self.dataBlocksPerFile:

2972

if self.blockIndex < self.dataBlocksPerFile:

2970

return 1

2973

return 1

2971

2974

2972

if not( self.setNextFile() ):

2975

if not( self.setNextFile() ):

2973

return 0

2976

return 0

2974

2977

2975

return 1

2978

return 1

2976

2979

2977

def writeNextBlock(self):

2980

def writeNextBlock(self):

2978

if not( self.__setNewBlock() ):

2981

if not( self.__setNewBlock() ):

2979

return 0

2982

return 0

2980

self.writeBlock()

2983

self.writeBlock()

2981

return 1

2984

return 1

2982

2985

2983

def putData(self):

2986

def putData(self):

2984

if self.flagIsNewFile:

2987

if self.flagIsNewFile:

2985

self.setNextFile()

2988

self.setNextFile()

2986

self.writeNextBlock()

2989

self.writeNextBlock()

2987

2990

2988

def run(self, dataOut, **kwargs):

2991

def run(self, dataOut, **kwargs):

2989

if not(self.isConfig):

2992

if not(self.isConfig):

2990

self.setup(dataOut, **kwargs)

2993

self.setup(dataOut, **kwargs)

2991

self.isConfig = True

2994

self.isConfig = True

2992

self.putData()

2995

self.putData()

2993

2996

2994

2997

2995

class FitsReader(ProcessingUnit):

2998

class FitsReader(ProcessingUnit):

2996

2999

2997

# __TIMEZONE = time.timezone

3000

# __TIMEZONE = time.timezone

2998

3001

2999

expName = None

3002

expName = None

3000

datetimestr = None

3003

datetimestr = None

3001

utc = None

3004

utc = None

3002

nChannels = None

3005

nChannels = None

3003

nSamples = None

3006

nSamples = None

3004

dataBlocksPerFile = None

3007

dataBlocksPerFile = None

3005

comments = None

3008

comments = None

3006

lastUTTime = None

3009

lastUTTime = None

3007

header_dict = None

3010

header_dict = None

3008

data = None

3011

data = None

3009

data_header_dict = None

3012

data_header_dict = None

3010

3013

3011

def __init__(self):

3014

def __init__(self):

3012

self.isConfig = False

3015

self.isConfig = False

3013

self.ext = '.fits'

3016

self.ext = '.fits'

3014

self.setFile = 0

3017

self.setFile = 0

3015

self.flagNoMoreFiles = 0

3018

self.flagNoMoreFiles = 0

3016

self.flagIsNewFile = 1

3019

self.flagIsNewFile = 1

3017

self.flagTimeBlock = None

3020

self.flagTimeBlock = None

3018

self.fileIndex = None

3021

self.fileIndex = None

3019

self.filename = None

3022

self.filename = None

3020

self.fileSize = None

3023

self.fileSize = None

3021

self.fitsObj = None

3024

self.fitsObj = None

3022

self.timeZone = None

3025

self.timeZone = None

3023

self.nReadBlocks = 0

3026

self.nReadBlocks = 0

3024

self.nTotalBlocks = 0

3027

self.nTotalBlocks = 0

3025

self.dataOut = self.createObjByDefault()

3028

self.dataOut = self.createObjByDefault()

3026

self.maxTimeStep = 10# deberia ser definido por el usuario usando el metodo setup()

3029

self.maxTimeStep = 10# deberia ser definido por el usuario usando el metodo setup()

3027

self.blockIndex = 1

3030

self.blockIndex = 1

3028

3031

3029

def createObjByDefault(self):

3032

def createObjByDefault(self):

3030

3033

3031

dataObj = Fits()

3034

dataObj = Fits()

3032

3035

3033

return dataObj

3036

return dataObj

3034

3037

3035

def isFileinThisTime(self, filename, startTime, endTime, useLocalTime=False):

3038

def isFileinThisTime(self, filename, startTime, endTime, useLocalTime=False):

3036

try:

3039

try:

3037

fitsObj = pyfits.open(filename,'readonly')

3040

fitsObj = pyfits.open(filename,'readonly')

3038

except:

3041

except:

3039

raise IOError, "The file %s can't be opened" %(filename)

3042

raise IOError, "The file %s can't be opened" %(filename)

3040

3043

3041

header = fitsObj[0].header

3044

header = fitsObj[0].header

3042

struct_time = time.strptime(header['DATETIME'], "%b %d %Y %H:%M:%S")

3045

struct_time = time.strptime(header['DATETIME'], "%b %d %Y %H:%M:%S")

3043

utc = time.mktime(struct_time) - time.timezone #TIMEZONE debe ser un parametro del header FITS

3046

utc = time.mktime(struct_time) - time.timezone #TIMEZONE debe ser un parametro del header FITS

3044

3047

3045

ltc = utc

3048

ltc = utc

3046

if useLocalTime:

3049

if useLocalTime:

3047

ltc -= time.timezone

3050

ltc -= time.timezone

3048

thisDatetime = datetime.datetime.utcfromtimestamp(ltc)

3051

thisDatetime = datetime.datetime.utcfromtimestamp(ltc)

3049

thisTime = thisDatetime.time()

3052

thisTime = thisDatetime.time()

3050

3053

3051

if not ((startTime <= thisTime) and (endTime > thisTime)):

3054

if not ((startTime <= thisTime) and (endTime > thisTime)):

3052

return None

3055

return None

3053

3056

3054

return thisDatetime

3057

return thisDatetime

3055

3058

3056

def __setNextFileOnline(self):

3059

def __setNextFileOnline(self):

3057

raise ValueError, "No implemented"

3060

raise ValueError, "No implemented"

3058

3061

3059

def __setNextFileOffline(self):

3062

def __setNextFileOffline(self):

3060

idFile = self.fileIndex

3063

idFile = self.fileIndex

3061

3064

3062

while (True):

3065

while (True):

3063

idFile += 1

3066

idFile += 1

3064

if not(idFile < len(self.filenameList)):

3067

if not(idFile < len(self.filenameList)):

3065

self.flagNoMoreFiles = 1

3068

self.flagNoMoreFiles = 1

3066

print "No more Files"

3069

print "No more Files"

3067

return 0

3070

return 0

3068

3071

3069

filename = self.filenameList[idFile]

3072

filename = self.filenameList[idFile]

3070

3073

3071

# if not(self.__verifyFile(filename)):

3074

# if not(self.__verifyFile(filename)):

3072

# continue

3075

# continue

3073

3076

3074

fileSize = os.path.getsize(filename)

3077

fileSize = os.path.getsize(filename)

3075

fitsObj = pyfits.open(filename,'readonly')

3078

fitsObj = pyfits.open(filename,'readonly')

3076

break

3079

break

3077

3080

3078

self.flagIsNewFile = 1

3081

self.flagIsNewFile = 1

3079

self.fileIndex = idFile

3082

self.fileIndex = idFile

3080

self.filename = filename

3083

self.filename = filename

3081

self.fileSize = fileSize

3084

self.fileSize = fileSize

3082

self.fitsObj = fitsObj

3085

self.fitsObj = fitsObj

3083

self.blockIndex = 0

3086

self.blockIndex = 0

3084

print "Setting the file: %s"%self.filename

3087

print "Setting the file: %s"%self.filename

3085

3088

3086

return 1

3089

return 1

3087

3090

3088

def readHeader(self):

3091

def readHeader(self):

3089

headerObj = self.fitsObj[0]

3092

headerObj = self.fitsObj[0]

3090

3093

3091

self.header_dict = headerObj.header

3094

self.header_dict = headerObj.header

3092

if 'EXPNAME' in headerObj.header.keys():

3095

if 'EXPNAME' in headerObj.header.keys():

3093

self.expName = headerObj.header['EXPNAME']

3096

self.expName = headerObj.header['EXPNAME']

3094

3097

3095

if 'DATATYPE' in headerObj.header.keys():

3098

if 'DATATYPE' in headerObj.header.keys():

3096

self.dataType = headerObj.header['DATATYPE']

3099

self.dataType = headerObj.header['DATATYPE']

3097

3100

3098

self.datetimestr = headerObj.header['DATETIME']

3101

self.datetimestr = headerObj.header['DATETIME']

3099

channelList = headerObj.header['CHANNELLIST']

3102

channelList = headerObj.header['CHANNELLIST']

3100

channelList = channelList.split('[')

3103

channelList = channelList.split('[')

3101

channelList = channelList[1].split(']')

3104

channelList = channelList[1].split(']')

3102

channelList = channelList[0].split(',')

3105

channelList = channelList[0].split(',')

3103

channelList = [int(ch) for ch in channelList]

3106

channelList = [int(ch) for ch in channelList]

3104

self.channelList = channelList

3107

self.channelList = channelList

3105

self.nChannels = headerObj.header['NCHANNELS']

3108

self.nChannels = headerObj.header['NCHANNELS']

3106

self.nHeights = headerObj.header['NHEIGHTS']

3109

self.nHeights = headerObj.header['NHEIGHTS']

3107

self.ippSeconds = headerObj.header['IPPSECONDS']

3110

self.ippSeconds = headerObj.header['IPPSECONDS']

3108

self.nCohInt = headerObj.header['NCOHINT']

3111

self.nCohInt = headerObj.header['NCOHINT']

3109

self.nIncohInt = headerObj.header['NINCOHINT']

3112

self.nIncohInt = headerObj.header['NINCOHINT']

3110

self.dataBlocksPerFile = headerObj.header['NBLOCK']

3113

self.dataBlocksPerFile = headerObj.header['NBLOCK']

3111

self.timeZone = headerObj.header['TIMEZONE']

3114

self.timeZone = headerObj.header['TIMEZONE']

3112

3115

3113

self.timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt

3116

self.timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt

3114

3117

3115

if 'COMMENT' in headerObj.header.keys():

3118

if 'COMMENT' in headerObj.header.keys():

3116

self.comments = headerObj.header['COMMENT']

3119

self.comments = headerObj.header['COMMENT']

3117

3120

3118

self.readHeightList()

3121

self.readHeightList()

3119

3122

3120

def readHeightList(self):

3123

def readHeightList(self):

3121

self.blockIndex = self.blockIndex + 1

3124

self.blockIndex = self.blockIndex + 1

3122

obj = self.fitsObj[self.blockIndex]

3125

obj = self.fitsObj[self.blockIndex]

3123

self.heightList = obj.data

3126

self.heightList = obj.data

3124

self.blockIndex = self.blockIndex + 1

3127

self.blockIndex = self.blockIndex + 1

3125

3128

3126

def readExtension(self):

3129

def readExtension(self):

3127

obj = self.fitsObj[self.blockIndex]

3130

obj = self.fitsObj[self.blockIndex]

3128

self.heightList = obj.data

3131

self.heightList = obj.data

3129

self.blockIndex = self.blockIndex + 1

3132

self.blockIndex = self.blockIndex + 1

3130

3133

3131

def setNextFile(self):

3134

def setNextFile(self):

3132

3135

3133

if self.online:

3136

if self.online:

3134

newFile = self.__setNextFileOnline()

3137

newFile = self.__setNextFileOnline()

3135

else:

3138

else:

3136

newFile = self.__setNextFileOffline()

3139

newFile = self.__setNextFileOffline()

3137

3140

3138

if not(newFile):

3141

if not(newFile):

3139

return 0

3142

return 0

3140

3143

3141

self.readHeader()

3144

self.readHeader()

3142

3145

3143

self.nReadBlocks = 0

3146

self.nReadBlocks = 0

3144

# self.blockIndex = 1

3147

# self.blockIndex = 1

3145

return 1

3148

return 1

3146

3149

3147

def __searchFilesOffLine(self,

3150

def __searchFilesOffLine(self,

3148

path,

3151

path,

3149

startDate,

3152

startDate,

3150

endDate,

3153

endDate,

3151

startTime=datetime.time(0,0,0),

3154

startTime=datetime.time(0,0,0),

3152

endTime=datetime.time(23,59,59),

3155

endTime=datetime.time(23,59,59),

3153

set=None,

3156

set=None,

3154

expLabel='',

3157

expLabel='',

3155

ext='.fits',

3158

ext='.fits',

3156

walk=True):

3159

walk=True):

3157

3160

3158

pathList = []

3161

pathList = []

3159

3162

3160

if not walk:

3163

if not walk:

3161

pathList.append(path)

3164

pathList.append(path)

3162

3165

3163

else:

3166

else:

3164

dirList = []

3167

dirList = []

3165

for thisPath in os.listdir(path):

3168

for thisPath in os.listdir(path):

3166

if not os.path.isdir(os.path.join(path,thisPath)):

3169

if not os.path.isdir(os.path.join(path,thisPath)):

3167

continue

3170

continue

3168

if not isDoyFolder(thisPath):

3171

if not isDoyFolder(thisPath):

3169

continue

3172

continue

3170

3173

3171

dirList.append(thisPath)

3174

dirList.append(thisPath)

3172

3175

3173

if not(dirList):

3176

if not(dirList):

3174

return None, None

3177

return None, None

3175

3178

3176

thisDate = startDate

3179

thisDate = startDate

3177

3180

3178

while(thisDate <= endDate):

3181

while(thisDate <= endDate):

3179

year = thisDate.timetuple().tm_year

3182

year = thisDate.timetuple().tm_year

3180

doy = thisDate.timetuple().tm_yday

3183

doy = thisDate.timetuple().tm_yday

3181

3184

3182

matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy) + '*')

3185

matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy) + '*')

3183

if len(matchlist) == 0:

3186

if len(matchlist) == 0:

3184

thisDate += datetime.timedelta(1)

3187

thisDate += datetime.timedelta(1)

3185

continue

3188

continue

3186

for match in matchlist:

3189

for match in matchlist:

3187

pathList.append(os.path.join(path,match,expLabel))

3190

pathList.append(os.path.join(path,match,expLabel))

3188

3191

3189

thisDate += datetime.timedelta(1)

3192

thisDate += datetime.timedelta(1)

3190

3193

3191

if pathList == []:

3194

if pathList == []:

3192

print "Any folder was found for the date range: %s-%s" %(startDate, endDate)

3195

print "Any folder was found for the date range: %s-%s" %(startDate, endDate)

3193

return None, None

3196

return None, None

3194

3197

3195

print "%d folder(s) was(were) found for the date range: %s - %s" %(len(pathList), startDate, endDate)

3198

print "%d folder(s) was(were) found for the date range: %s - %s" %(len(pathList), startDate, endDate)

3196

3199

3197

filenameList = []

3200

filenameList = []

3198

datetimeList = []

3201

datetimeList = []

3199

3202

3200

for i in range(len(pathList)):

3203

for i in range(len(pathList)):

3201

3204

3202

thisPath = pathList[i]

3205

thisPath = pathList[i]

3203

3206

3204

fileList = glob.glob1(thisPath, "*%s" %ext)

3207

fileList = glob.glob1(thisPath, "*%s" %ext)

3205

fileList.sort()

3208

fileList.sort()

3206

3209

3207

for file in fileList:

3210

for file in fileList:

3208

3211

3209

filename = os.path.join(thisPath,file)

3212

filename = os.path.join(thisPath,file)

3210

thisDatetime = self.isFileinThisTime(filename, startTime, endTime)

3213

thisDatetime = self.isFileinThisTime(filename, startTime, endTime)

3211

3214

3212

if not(thisDatetime):

3215

if not(thisDatetime):

3213

continue

3216

continue

3214

3217

3215

filenameList.append(filename)

3218

filenameList.append(filename)

3216

datetimeList.append(thisDatetime)

3219

datetimeList.append(thisDatetime)

3217

3220

3218

if not(filenameList):

3221

if not(filenameList):

3219

print "Any file was found for the time range %s - %s" %(startTime, endTime)

3222

print "Any file was found for the time range %s - %s" %(startTime, endTime)

3220

return None, None

3223

return None, None

3221

3224

3222

print "%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime)

3225

print "%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime)

3223

print

3226

print

3224

3227

3225

for i in range(len(filenameList)):

3228

for i in range(len(filenameList)):

3226

print "%s -> [%s]" %(filenameList[i], datetimeList[i].ctime())

3229

print "%s -> [%s]" %(filenameList[i], datetimeList[i].ctime())

3227

3230

3228

self.filenameList = filenameList

3231

self.filenameList = filenameList

3229

self.datetimeList = datetimeList

3232

self.datetimeList = datetimeList

3230

3233

3231

return pathList, filenameList

3234

return pathList, filenameList

3232

3235

3233

def setup(self, path=None,

3236

def setup(self, path=None,

3234

startDate=None,

3237

startDate=None,

3235

endDate=None,

3238

endDate=None,

3236

startTime=datetime.time(0,0,0),

3239

startTime=datetime.time(0,0,0),

3237

endTime=datetime.time(23,59,59),

3240

endTime=datetime.time(23,59,59),

3238

set=0,

3241

set=0,

3239

expLabel = "",

3242

expLabel = "",

3240

ext = None,

3243

ext = None,

3241

online = False,

3244

online = False,

3242

delay = 60,

3245

delay = 60,

3243

walk = True):

3246

walk = True):

3244

3247

3245

if path == None:

3248

if path == None:

3246

raise ValueError, "The path is not valid"

3249

raise ValueError, "The path is not valid"

3247

3250

3248

if ext == None:

3251

if ext == None:

3249

ext = self.ext

3252

ext = self.ext

3250

3253

3251

if not(online):

3254

if not(online):

3252

print "Searching files in offline mode ..."

3255

print "Searching files in offline mode ..."

3253

pathList, filenameList = self.__searchFilesOffLine(path, startDate=startDate, endDate=endDate,

3256

pathList, filenameList = self.__searchFilesOffLine(path, startDate=startDate, endDate=endDate,

3254

startTime=startTime, endTime=endTime,

3257

startTime=startTime, endTime=endTime,

3255

set=set, expLabel=expLabel, ext=ext,

3258

set=set, expLabel=expLabel, ext=ext,

3256

walk=walk)

3259

walk=walk)

3257

3260

3258

if not(pathList):

3261

if not(pathList):

3259

print "No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,

3262

print "No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,

3260

datetime.datetime.combine(startDate,startTime).ctime(),

3263

datetime.datetime.combine(startDate,startTime).ctime(),

3261

datetime.datetime.combine(endDate,endTime).ctime())

3264

datetime.datetime.combine(endDate,endTime).ctime())

3262

3265

3263

sys.exit(-1)

3266

sys.exit(-1)

3264

3267

3265

self.fileIndex = -1

3268

self.fileIndex = -1

3266

self.pathList = pathList

3269

self.pathList = pathList

3267

self.filenameList = filenameList

3270

self.filenameList = filenameList

3268

3271

3269

self.online = online

3272

self.online = online

3270

self.delay = delay

3273

self.delay = delay

3271

ext = ext.lower()

3274

ext = ext.lower()

3272

self.ext = ext

3275

self.ext = ext

3273

3276

3274

if not(self.setNextFile()):

3277

if not(self.setNextFile()):

3275

if (startDate!=None) and (endDate!=None):

3278

if (startDate!=None) and (endDate!=None):

3276

print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())

3279

print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())

3277

elif startDate != None:

3280

elif startDate != None:

3278

print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())

3281

print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())

3279

else:

3282

else:

3280

print "No files"

3283

print "No files"

3281

3284

3282

sys.exit(-1)

3285

sys.exit(-1)

3283

3286

3284

3287

3285

3288

3286

def readBlock(self):

3289

def readBlock(self):

3287

dataObj = self.fitsObj[self.blockIndex]

3290

dataObj = self.fitsObj[self.blockIndex]

3288

3291

3289

self.data = dataObj.data

3292

self.data = dataObj.data

3290

self.data_header_dict = dataObj.header

3293

self.data_header_dict = dataObj.header

3291

self.utc = self.data_header_dict['UTCTIME']

3294

self.utc = self.data_header_dict['UTCTIME']

3292

3295

3293

self.flagIsNewFile = 0

3296

self.flagIsNewFile = 0

3294

self.blockIndex += 1

3297

self.blockIndex += 1

3295

self.nTotalBlocks += 1

3298

self.nTotalBlocks += 1

3296

self.nReadBlocks += 1

3299

self.nReadBlocks += 1

3297

3300

3298

return 1

3301

return 1

3299

3302

3300

def __jumpToLastBlock(self):

3303

def __jumpToLastBlock(self):

3301

raise ValueError, "No implemented"

3304

raise ValueError, "No implemented"

3302

3305

3303

def __waitNewBlock(self):

3306

def __waitNewBlock(self):

3304

"""

3307

"""

3305

Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.

3308

Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.

3306

3309

3307

Si el modo de lectura es OffLine siempre retorn 0

3310

Si el modo de lectura es OffLine siempre retorn 0

3308

"""

3311

"""

3309

if not self.online:

3312

if not self.online:

3310

return 0

3313

return 0

3311

3314

3312

if (self.nReadBlocks >= self.dataBlocksPerFile):

3315

if (self.nReadBlocks >= self.dataBlocksPerFile):

3313

return 0

3316

return 0

3314

3317

3315

currentPointer = self.fp.tell()

3318

currentPointer = self.fp.tell()

3316

3319

3317

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

3320

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

3318

3321

3319

for nTries in range( self.nTries ):

3322

for nTries in range( self.nTries ):

3320

3323

3321

self.fp.close()

3324

self.fp.close()

3322

self.fp = open( self.filename, 'rb' )

3325

self.fp = open( self.filename, 'rb' )

3323

self.fp.seek( currentPointer )

3326

self.fp.seek( currentPointer )

3324

3327

3325

self.fileSize = os.path.getsize( self.filename )

3328

self.fileSize = os.path.getsize( self.filename )

3326

currentSize = self.fileSize - currentPointer

3329

currentSize = self.fileSize - currentPointer

3327

3330

3328

if ( currentSize >= neededSize ):

3331

if ( currentSize >= neededSize ):

3329

self.__rdBasicHeader()

3332

self.__rdBasicHeader()

3330

return 1

3333

return 1

3331

3334

3332

print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)

3335

print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)

3333

time.sleep( self.delay )

3336

time.sleep( self.delay )

3334

3337

3335

3338

3336

return 0

3339

return 0

3337

3340

3338

def __setNewBlock(self):

3341

def __setNewBlock(self):

3339

3342

3340

if self.online:

3343

if self.online:

3341

self.__jumpToLastBlock()

3344

self.__jumpToLastBlock()

3342

3345

3343

if self.flagIsNewFile:

3346

if self.flagIsNewFile:

3344

return 1

3347

return 1

3345

3348

3346

self.lastUTTime = self.utc

3349

self.lastUTTime = self.utc

3347

3350

3348

if self.online:

3351

if self.online:

3349

if self.__waitNewBlock():

3352

if self.__waitNewBlock():

3350

return 1

3353

return 1

3351

3354

3352

if self.nReadBlocks < self.dataBlocksPerFile:

3355

if self.nReadBlocks < self.dataBlocksPerFile:

3353

return 1

3356

return 1

3354

3357

3355

if not(self.setNextFile()):

3358

if not(self.setNextFile()):

3356

return 0

3359

return 0

3357

3360

3358

deltaTime = self.utc - self.lastUTTime

3361

deltaTime = self.utc - self.lastUTTime

3359

3362

3360

self.flagTimeBlock = 0

3363

self.flagTimeBlock = 0

3361

3364

3362

if deltaTime > self.maxTimeStep:

3365

if deltaTime > self.maxTimeStep:

3363

self.flagTimeBlock = 1

3366

self.flagTimeBlock = 1

3364

3367

3365

return 1

3368

return 1

3366

3369

3367

3370

3368

def readNextBlock(self):

3371

def readNextBlock(self):

3369

if not(self.__setNewBlock()):

3372

if not(self.__setNewBlock()):

3370

return 0

3373

return 0

3371

3374

3372

if not(self.readBlock()):

3375

if not(self.readBlock()):

3373

return 0

3376

return 0

3374

3377

3375

return 1

3378

return 1

3376

3379

3377

3380

3378

def getData(self):

3381

def getData(self):

3379

3382

3380

if self.flagNoMoreFiles:

3383

if self.flagNoMoreFiles:

3381

self.dataOut.flagNoData = True

3384

self.dataOut.flagNoData = True

3382

print 'Process finished'

3385

print 'Process finished'

3383

return 0

3386

return 0

3384

3387

3385

self.flagTimeBlock = 0

3388

self.flagTimeBlock = 0

3386

self.flagIsNewBlock = 0

3389

self.flagIsNewBlock = 0

3387

3390

3388

if not(self.readNextBlock()):

3391

if not(self.readNextBlock()):

3389

return 0

3392

return 0

3390

3393

3391

if self.data == None:

3394

if self.data == None:

3392

self.dataOut.flagNoData = True

3395

self.dataOut.flagNoData = True

3393

return 0

3396

return 0

3394

3397

3395

self.dataOut.data = self.data

3398

self.dataOut.data = self.data

3396

self.dataOut.data_header = self.data_header_dict

3399

self.dataOut.data_header = self.data_header_dict

3397

self.dataOut.utctime = self.utc

3400

self.dataOut.utctime = self.utc

3398

3401

3399

self.dataOut.header = self.header_dict

3402

self.dataOut.header = self.header_dict

3400

self.dataOut.expName = self.expName

3403

self.dataOut.expName = self.expName

3401

self.dataOut.nChannels = self.nChannels

3404

self.dataOut.nChannels = self.nChannels

3402

self.dataOut.timeZone = self.timeZone

3405

self.dataOut.timeZone = self.timeZone

3403

self.dataOut.dataBlocksPerFile = self.dataBlocksPerFile

3406

self.dataOut.dataBlocksPerFile = self.dataBlocksPerFile

3404

self.dataOut.comments = self.comments

3407

self.dataOut.comments = self.comments

3405

self.dataOut.timeInterval = self.timeInterval

3408

self.dataOut.timeInterval = self.timeInterval

3406

self.dataOut.channelList = self.channelList

3409

self.dataOut.channelList = self.channelList

3407

self.dataOut.heightList = self.heightList

3410

self.dataOut.heightList = self.heightList

3408

self.dataOut.flagNoData = False

3411

self.dataOut.flagNoData = False

3409

3412

3410

return self.dataOut.data

3413

return self.dataOut.data

3411

3414

3412

def run(self, **kwargs):

3415

def run(self, **kwargs):

3413

3416

3414

if not(self.isConfig):

3417

if not(self.isConfig):

3415

self.setup(**kwargs)

3418

self.setup(**kwargs)

3416

self.isConfig = True

3419

self.isConfig = True

3417

3420

3418

self.getData() No newline at end of file

3421

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

             '''
             $Author: murco $
             $Id: JROHeaderIO.py 151 2012-10-31 19:00:51Z murco $
             '''
             import sys
             import numpy
             import copy
             import datetime
             class Header:
                 def __init__(self):
                     raise
                 def copy(self):
                     return copy.deepcopy(self)
                 def read():
                     pass
                 def write():
                     pass
                 def printInfo(self):
                     print "#"*100
                     print self.__class__.__name__.upper()
                     print "#"*100
                     for key in self.__dict__.keys():
                         print "%s = %s" %(key, self.__dict__[key])
             class BasicHeader(Header):
                 size = None
                 version = None
                 dataBlock = None
                 utc = None
                 ltc = None
                 miliSecond = None
                 timeZone = None
                 dstFlag = None
                 errorCount = None
                 struct = None
                 datatime = None
                 __LOCALTIME = None
                 def __init__(self, useLocalTime=True):
                     self.size = 0
                     self.version = 0
                     self.dataBlock = 0
                     self.utc = 0
                     self.miliSecond = 0
                     self.timeZone = 0
                     self.dstFlag = 0
                     self.errorCount = 0
                     self.struct = numpy.dtype([
                                           ('nSize','<u4'),
                                           ('nVersion','<u2'),
                                           ('nDataBlockId','<u4'),
                                           ('nUtime','<u4'),
                                           ('nMilsec','<u2'),
                                           ('nTimezone','<i2'),
                                           ('nDstflag','<i2'),
                                           ('nErrorCount','<u4')
                                           ])
                     self.useLocalTime = useLocalTime
                 def read(self, fp):
                     try:
                         header = numpy.fromfile(fp, self.struct,1)
                         self.size = int(header['nSize'][0])
                         self.version = int(header['nVersion'][0])
                         self.dataBlock = int(header['nDataBlockId'][0])
                         self.utc = int(header['nUtime'][0])
                         self.miliSecond = int(header['nMilsec'][0])
                         self.timeZone = int(header['nTimezone'][0])
                         self.dstFlag = int(header['nDstflag'][0])
                         self.errorCount = int(header['nErrorCount'][0])
                         self.ltc = self.utc
                         if self.useLocalTime:
                             self.ltc -= self.timeZone*60
                         self.datatime = datetime.datetime.utcfromtimestamp(self.ltc)
                     except Exception, e:
                         print "BasicHeader: "
                         print e
                         return 0
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size,self.version,self.dataBlock,self.utc,self.miliSecond,self.timeZone,self.dstFlag,self.errorCount)
                     header = numpy.array(headerTuple,self.struct)
                     header.tofile(fp)
                     return 1
             class SystemHeader(Header):
                 size = None
                 nSamples = None
                 nProfiles = None
                 nChannels = None
                 adcResolution = None
                 pciDioBusWidth = None
                 struct = None
                 def __init__(self):
                     self.size = 0
                     self.nSamples = 0
                     self.nProfiles = 0
                     self.nChannels = 0
                     self.adcResolution = 0
                     self.pciDioBusWidth = 0
                     self.struct = numpy.dtype([
                                         ('nSize','<u4'),
                                         ('nNumSamples','<u4'),
                                         ('nNumProfiles','<u4'),
                                         ('nNumChannels','<u4'),
                                         ('nADCResolution','<u4'),
                                         ('nPCDIOBusWidth','<u4'),
                                         ])
                 def read(self, fp):
                     try:
                         header = numpy.fromfile(fp,self.struct,1)
                         self.size = header['nSize'][0]
                         self.nSamples = header['nNumSamples'][0]
                         self.nProfiles = header['nNumProfiles'][0]
                         self.nChannels = header['nNumChannels'][0]
                         self.adcResolution = header['nADCResolution'][0]
                         self.pciDioBusWidth = header['nPCDIOBusWidth'][0]
                     except Exception, e:
                         print "SystemHeader: " + e
                         return 0
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size,self.nSamples,self.nProfiles,self.nChannels,self.adcResolution,self.pciDioBusWidth)
                     header = numpy.array(headerTuple,self.struct)
                     header.tofile(fp)
                     return 1
             class RadarControllerHeader(Header):
                 size = None
                 expType = None
                 nTx = None
                 ipp = None
                 txA = None
                 txB = None
                 nWindows = None
                 numTaus = None
                 codeType = None
                 line6Function = None
                 line5Function = None
                 fClock = None
                 prePulseBefore = None
                 prePulserAfter = None
                 rangeIpp = None
                 rangeTxA = None
                 rangeTxB = None
                 struct = None
                 def __init__(self):
                     self.size = 0
                     self.expType = 0
                     self.nTx = 0
                     self.ipp = 0
                     self.txA = 0
                     self.txB = 0
                     self.nWindows = 0
                     self.numTaus = 0
                     self.codeType = 0
                     self.line6Function = 0
                     self.line5Function = 0
                     self.fClock = 0
                     self.prePulseBefore = 0
                     self.prePulserAfter = 0
                     self.rangeIpp = 0
                     self.rangeTxA = 0
                     self.rangeTxB = 0
                     self.struct = numpy.dtype([
                                          ('nSize','<u4'),
                                          ('nExpType','<u4'),
                                          ('nNTx','<u4'),
                                          ('fIpp','<f4'),
                                          ('fTxA','<f4'),
                                          ('fTxB','<f4'),
                                          ('nNumWindows','<u4'),
                                          ('nNumTaus','<u4'),
                                          ('nCodeType','<u4'),
                                          ('nLine6Function','<u4'),
                                          ('nLine5Function','<u4'),
                                          ('fClock','<f4'),
                                          ('nPrePulseBefore','<u4'),
                                          ('nPrePulseAfter','<u4'),
                                          ('sRangeIPP','<a20'),
                                          ('sRangeTxA','<a20'),
                                          ('sRangeTxB','<a20'),
                                          ])
                     self.samplingWindowStruct = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
                     self.samplingWindow = None
                     self.nHeights = None
                     self.firstHeight = None
                     self.deltaHeight = None
                     self.samplesWin = None
                     self.nCode = None
                     self.nBaud = None
                     self.code = None
                     self.flip1 = None
                     self.flip2 = None
                     self.dynamic = numpy.array([],numpy.dtype('byte'))
                 def read(self, fp):
                     try:
                         startFp = fp.tell()
                         header = numpy.fromfile(fp,self.struct,1)
                         self.size = int(header['nSize'][0])
                         self.expType = int(header['nExpType'][0])
                         self.nTx = int(header['nNTx'][0])
                         self.ipp = float(header['fIpp'][0])
                         self.txA = float(header['fTxA'][0])
                         self.txB = float(header['fTxB'][0])
                         self.nWindows = int(header['nNumWindows'][0])
                         self.numTaus = int(header['nNumTaus'][0])
                         self.codeType = int(header['nCodeType'][0])
                         self.line6Function = int(header['nLine6Function'][0])
                         self.line5Function = int(header['nLine5Function'][0])
                         self.fClock = float(header['fClock'][0])
                         self.prePulseBefore = int(header['nPrePulseBefore'][0])
                         self.prePulserAfter = int(header['nPrePulseAfter'][0])
                         self.rangeIpp = header['sRangeIPP'][0]
                         self.rangeTxA = header['sRangeTxA'][0]
                         self.rangeTxB = header['sRangeTxB'][0]
                         # jump Dynamic Radar Controller Header
                         jumpFp =  self.size - 116
                         self.dynamic = numpy.fromfile(fp,numpy.dtype('byte'),jumpFp)
                         #pointer backward to dynamic header and read
                         backFp = fp.tell() - jumpFp
                         fp.seek(backFp)
                         self.samplingWindow = numpy.fromfile(fp,self.samplingWindowStruct,self.nWindows)
                         self.nHeights = int(numpy.sum(self.samplingWindow['nsa']))
                         self.firstHeight = self.samplingWindow['h0']
                         self.deltaHeight = self.samplingWindow['dh']
                         self.samplesWin = self.samplingWindow['nsa']
                         self.Taus = numpy.fromfile(fp,'<f4',self.numTaus)
                         if self.codeType != 0:
                             self.nCode = int(numpy.fromfile(fp,'<u4',1))
                             self.nBaud = int(numpy.fromfile(fp,'<u4',1))
                             self.code = numpy.empty([self.nCode,self.nBaud],dtype='u1')
                             for ic in range(self.nCode):
                                 temp = numpy.fromfile(fp,'u4',int(numpy.ceil(self.nBaud/32.)))
                                 for ib in range(self.nBaud-1,-1,-1):
                                     self.code[ic,ib] = temp[ib/32]%2
                                     temp[ib/32] = temp[ib/32]/2
                             self.code = 2.0*self.code - 1.0
+                            self.code_size = int(numpy.ceil(self.nBaud/32.))*self.nCode*4
                         if self.line5Function == RCfunction.FLIP:
                             self.flip1 = numpy.fromfile(fp,'<u4',1)
                         if self.line6Function == RCfunction.FLIP:
                             self.flip2 = numpy.fromfile(fp,'<u4',1)
                         endFp = self.size + startFp
                         jumpFp =  endFp - fp.tell()
                         if jumpFp > 0:
                             fp.seek(jumpFp)
                     except Exception, e:
                         print "RadarControllerHeader: " + e
                         return 0
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size,
                                    self.expType,
                                    self.nTx,
                                    self.ipp,
                                    self.txA,
                                    self.txB,
                                    self.nWindows,
                                    self.numTaus,
                                    self.codeType,
                                    self.line6Function,
                                    self.line5Function,
                                    self.fClock,
                                    self.prePulseBefore,
                                    self.prePulserAfter,
                                    self.rangeIpp,
                                    self.rangeTxA,
                                    self.rangeTxB)
                     header = numpy.array(headerTuple,self.struct)
                     header.tofile(fp)
-                    dynamic = self.dynamic
+                    #dynamic = self.dynamic
-                    dynamic.tofile(fp)
+                    #dynamic.tofile(fp)
+                    samplingWindow = self.samplingWindow
+                    samplingWindow.tofile(fp)
+                    if self.numTaus > 0:
+                        self.Taus.tofile(fp)
+                    nCode = numpy.array(self.nCode, '<u4')
+                    nCode.tofile(fp)
+                    nBaud = numpy.array(self.nBaud, '<u4')
+                    nBaud.tofile(fp)
+                    code1 = (self.code + 1.0)/2.
+                    for ic in range(self.nCode):
+                        tempx = numpy.zeros(numpy.ceil(self.nBaud/32.))
+                        start = 0
+                        end = 32
+                        for i in range(len(tempx)):
+                            code_selected = code1[ic,start:end]
+                            for j in range(len(code_selected)-1,-1,-1):
+                                if code_selected[j] == 1:
+                                    tempx[i] = tempx[i] + 2**(len(code_selected)-1-j)
+                            start = start + 32
+                            end = end + 32
+                        tempx = tempx.astype('u4')
+                        tempx.tofile(fp)
+                    if self.line5Function == RCfunction.FLIP:
+                        self.flip1.tofile(fp)
+                    if self.line6Function == RCfunction.FLIP:
+                        self.flip2.tofile(fp)
                     return 1
             class ProcessingHeader(Header):
                 size = None
                 dtype = None
                 blockSize = None
                 profilesPerBlock = None
                 dataBlocksPerFile = None
                 nWindows = None
                 processFlags = None
                 nCohInt = None
                 nIncohInt = None
                 totalSpectra = None
                 struct = None
                 flag_dc = None
                 flag_cspc = None
                 def __init__(self):
                     self.size = 0
                     self.dtype = 0
                     self.blockSize = 0
                     self.profilesPerBlock = 0
                     self.dataBlocksPerFile = 0
                     self.nWindows = 0
                     self.processFlags = 0
                     self.nCohInt = 0
                     self.nIncohInt = 0
                     self.totalSpectra = 0
                     self.struct = numpy.dtype([
                                            ('nSize','<u4'),
                                            ('nDataType','<u4'),
                                            ('nSizeOfDataBlock','<u4'),
                                            ('nProfilesperBlock','<u4'),
                                            ('nDataBlocksperFile','<u4'),
                                            ('nNumWindows','<u4'),
                                            ('nProcessFlags','<u4'),
                                            ('nCoherentIntegrations','<u4'),
                                            ('nIncoherentIntegrations','<u4'),
                                            ('nTotalSpectra','<u4')
                                            ])
                     self.samplingWindow = 0
                     self.structSamplingWindow = numpy.dtype([('h0','<f4'),('dh','<f4'),('nsa','<u4')])
                     self.nHeights = 0
                     self.firstHeight = 0
                     self.deltaHeight = 0
                     self.samplesWin = 0
                     self.spectraComb = 0
             #         self.nCode = None
             #         self.code = None
             #         self.nBaud = None
                     self.shif_fft = False
                     self.flag_dc = False
                     self.flag_cspc = False
                 def read(self, fp):
             #        try:
                     header = numpy.fromfile(fp,self.struct,1)
                     self.size = int(header['nSize'][0])
                     self.dtype = int(header['nDataType'][0])
                     self.blockSize = int(header['nSizeOfDataBlock'][0])
                     self.profilesPerBlock = int(header['nProfilesperBlock'][0])
                     self.dataBlocksPerFile = int(header['nDataBlocksperFile'][0])
                     self.nWindows = int(header['nNumWindows'][0])
                     self.processFlags = header['nProcessFlags']
                     self.nCohInt = int(header['nCoherentIntegrations'][0])
                     self.nIncohInt = int(header['nIncoherentIntegrations'][0])
                     self.totalSpectra = int(header['nTotalSpectra'][0])
                     self.samplingWindow = numpy.fromfile(fp,self.structSamplingWindow,self.nWindows)
                     self.nHeights = int(numpy.sum(self.samplingWindow['nsa']))
                     self.firstHeight = float(self.samplingWindow['h0'][0])
                     self.deltaHeight = float(self.samplingWindow['dh'][0])
                     self.samplesWin = self.samplingWindow['nsa']
                     self.spectraComb = numpy.fromfile(fp,'u1',2*self.totalSpectra)
             #        if ((self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE) == PROCFLAG.DEFINE_PROCESS_CODE):
             #            self.nCode = int(numpy.fromfile(fp,'<u4',1))
             #            self.nBaud = int(numpy.fromfile(fp,'<u4',1))
             #            self.code = numpy.fromfile(fp,'<f4',self.nCode*self.nBaud).reshape(self.nCode,self.nBaud)
                     if ((self.processFlags & PROCFLAG.SHIFT_FFT_DATA) == PROCFLAG.SHIFT_FFT_DATA):
                         self.shif_fft = True
                     else:
                         self.shif_fft = False
                     if ((self.processFlags & PROCFLAG.SAVE_CHANNELS_DC) == PROCFLAG.SAVE_CHANNELS_DC):
                         self.flag_dc = True
                     nChannels = 0
                     nPairs = 0
                     pairList = []
                     for i in range( 0, self.totalSpectra*2, 2 ):
                         if self.spectraComb[i] == self.spectraComb[i+1]:
                             nChannels = nChannels + 1   #par de canales iguales
                         else:
                             nPairs = nPairs + 1 #par de canales diferentes
                             pairList.append( (self.spectraComb[i], self.spectraComb[i+1]) )
                     self.flag_cspc = False
                     if nPairs > 0:
                         self.flag_cspc = True
             #        except Exception, e:
             #            print "Error ProcessingHeader: "
             #            return 0
                     return 1
                 def write(self, fp):
                     headerTuple = (self.size,
                                    self.dtype,
                                    self.blockSize,
                                    self.profilesPerBlock,
                                    self.dataBlocksPerFile,
                                    self.nWindows,
                                    self.processFlags,
                                    self.nCohInt,
                                    self.nIncohInt,
                                    self.totalSpectra)
                     header = numpy.array(headerTuple,self.struct)
                     header.tofile(fp)
                     if self.nWindows != 0:
                         sampleWindowTuple = (self.firstHeight,self.deltaHeight,self.samplesWin)
                         samplingWindow = numpy.array(sampleWindowTuple,self.structSamplingWindow)
                         samplingWindow.tofile(fp)
                     if self.totalSpectra != 0:
                         spectraComb = numpy.array([],numpy.dtype('u1'))
                         spectraComb = self.spectraComb
                         spectraComb.tofile(fp)
             #        if self.processFlags & PROCFLAG.DEFINE_PROCESS_CODE == PROCFLAG.DEFINE_PROCESS_CODE:
             #            nCode = numpy.array([self.nCode], numpy.dtype('u4')) #Probar con un dato que almacene codigo, hasta el momento no se hizo la prueba
             #            nCode.tofile(fp)
             #
             #            nBaud = numpy.array([self.nBaud], numpy.dtype('u4'))
             #            nBaud.tofile(fp)
             #
             #            code = self.code.reshape(self.nCode*self.nBaud)
             #            code = code.astype(numpy.dtype('<f4'))
             #            code.tofile(fp)
                     return 1
             class RCfunction:
                 NONE=0
                 FLIP=1
                 CODE=2
                 SAMPLING=3
                 LIN6DIV256=4
                 SYNCHRO=5
             class nCodeType:
                 NONE=0
                 USERDEFINE=1
                 BARKER2=2
                 BARKER3=3
                 BARKER4=4
                 BARKER5=5
                 BARKER7=6
                 BARKER11=7
                 BARKER13=8
                 AC128=9
                 COMPLEMENTARYCODE2=10
                 COMPLEMENTARYCODE4=11
                 COMPLEMENTARYCODE8=12
                 COMPLEMENTARYCODE16=13
                 COMPLEMENTARYCODE32=14
                 COMPLEMENTARYCODE64=15
                 COMPLEMENTARYCODE128=16
                 CODE_BINARY28=17
             class PROCFLAG:
                 COHERENT_INTEGRATION = numpy.uint32(0x00000001)
                 DECODE_DATA = numpy.uint32(0x00000002)
                 SPECTRA_CALC = numpy.uint32(0x00000004)
                 INCOHERENT_INTEGRATION = numpy.uint32(0x00000008)
                 POST_COHERENT_INTEGRATION = numpy.uint32(0x00000010)
                 SHIFT_FFT_DATA = numpy.uint32(0x00000020)
                 DATATYPE_CHAR = numpy.uint32(0x00000040)
                 DATATYPE_SHORT = numpy.uint32(0x00000080)
                 DATATYPE_LONG = numpy.uint32(0x00000100)
                 DATATYPE_INT64 = numpy.uint32(0x00000200)
                 DATATYPE_FLOAT = numpy.uint32(0x00000400)
                 DATATYPE_DOUBLE = numpy.uint32(0x00000800)
                 DATAARRANGE_CONTIGUOUS_CH = numpy.uint32(0x00001000)
                 DATAARRANGE_CONTIGUOUS_H = numpy.uint32(0x00002000)
                 DATAARRANGE_CONTIGUOUS_P = numpy.uint32(0x00004000)
                 SAVE_CHANNELS_DC = numpy.uint32(0x00008000)
                 DEFLIP_DATA = numpy.uint32(0x00010000)
                 DEFINE_PROCESS_CODE = numpy.uint32(0x00020000)
                 ACQ_SYS_NATALIA = numpy.uint32(0x00040000)
                 ACQ_SYS_ECHOTEK = numpy.uint32(0x00080000)
                 ACQ_SYS_ADRXD = numpy.uint32(0x000C0000)
                 ACQ_SYS_JULIA = numpy.uint32(0x00100000)
                 ACQ_SYS_XXXXXX = numpy.uint32(0x00140000)
                 EXP_NAME_ESP = numpy.uint32(0x00200000)
                 CHANNEL_NAMES_ESP = numpy.uint32(0x00400000)
                 OPERATION_MASK = numpy.uint32(0x0000003F)
                 DATATYPE_MASK = numpy.uint32(0x00000FC0)
                 DATAARRANGE_MASK = numpy.uint32(0x00007000)
                 ACQ_SYS_MASK = numpy.uint32(0x001C0000)