schain Commit - r187:ddf8fff0f71b · Jicamarca Repository

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

1

'''

1

'''

2

3

$Author: murco $

3

$Author: murco $

4

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

4

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

5

'''

5

'''

6

7

import os, sys

7

import os, sys

8

import glob

8

import glob

9

import time

9

import time

10

import numpy

10

import numpy

11

import fnmatch

11

import fnmatch

12

import time, datetime

12

import time, datetime

13

14

from jrodata import *

14

from jrodata import *

15

from jroheaderIO import *

15

from jroheaderIO import *

16

17

def isNumber(str):

17

def isNumber(str):

18

"""

18

"""

19

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

19

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

20

21

Excepciones:

21

Excepciones:

22

Si un determinado string no puede ser convertido a numero

22

Si un determinado string no puede ser convertido a numero

23

Input:

23

Input:

24

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

24

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

25

26

Return:

26

Return:

27

True : si el string es uno numerico

27

True : si el string es uno numerico

28

False : no es un string numerico

28

False : no es un string numerico

29

"""

29

"""

30

try:

30

try:

31

float( str )

31

float( str )

32

return True

32

return True

33

except:

33

except:

34

return False

34

return False

35

36

def isThisFileinRange(filename, startUTSeconds, endUTSeconds):

36

def isThisFileinRange(filename, startUTSeconds, endUTSeconds):

37

"""

37

"""

38

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

38

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

39

40

Inputs:

40

Inputs:

41

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

41

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

42

43

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

43

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

44

segundos contados desde 01/01/1970.

44

segundos contados desde 01/01/1970.

45

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

45

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

46

segundos contados desde 01/01/1970.

46

segundos contados desde 01/01/1970.

47

48

Return:

48

Return:

49

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

49

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

50

fecha especificado, de lo contrario retorna False.

50

fecha especificado, de lo contrario retorna False.

51

52

Excepciones:

52

Excepciones:

53

Si el archivo no existe o no puede ser abierto

53

Si el archivo no existe o no puede ser abierto

54

Si la cabecera no puede ser leida.

54

Si la cabecera no puede ser leida.

55

56

"""

56

"""

57

basicHeaderObj = BasicHeader()

57

basicHeaderObj = BasicHeader()

58

59

try:

59

try:

60

fp = open(filename,'rb')

60

fp = open(filename,'rb')

61

except:

61

except:

62

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

62

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

63

64

sts = basicHeaderObj.read(fp)

64

sts = basicHeaderObj.read(fp)

65

fp.close()

65

fp.close()

66

67

if not(sts):

67

if not(sts):

68

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

68

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

69

return 0

69

return 0

70

71

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

71

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

72

return 0

72

return 0

73

74

return 1

74

return 1

75

76

def getlastFileFromPath(path, ext):

76

def getlastFileFromPath(path, ext):

77

"""

77

"""

78

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

78

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

79

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

79

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

80

81

Input:

81

Input:

82

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

82

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

83

ext : extension de los files contenidos en una carpeta

83

ext : extension de los files contenidos en una carpeta

84

85

Return:

85

Return:

86

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

86

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

87

"""

87

"""

88

validFilelist = []

88

validFilelist = []

89

fileList = os.listdir(path)

89

fileList = os.listdir(path)

90

91

# 0 1234 567 89A BCDE

91

# 0 1234 567 89A BCDE

92

# H YYYY DDD SSS .ext

92

# H YYYY DDD SSS .ext

93

94

for file in fileList:

94

for file in fileList:

95

try:

95

try:

96

year = int(file[1:5])

96

year = int(file[1:5])

97

doy = int(file[5:8])

97

doy = int(file[5:8])

98

99

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

99

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

100

except:

100

except:

101

continue

101

continue

102

103

validFilelist.append(file)

103

validFilelist.append(file)

104

105

if validFilelist:

105

if validFilelist:

106

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

106

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

107

return validFilelist[-1]

107

return validFilelist[-1]

108

109

return None

109

return None

110

111

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

111

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

112

"""

112

"""

113

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

113

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

114

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

114

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

115

el path exacto de un determinado file.

115

el path exacto de un determinado file.

116

117

Example :

117

Example :

118

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

118

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

119

120

Entonces la funcion prueba con las siguientes combinaciones

120

Entonces la funcion prueba con las siguientes combinaciones

121

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

121

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

122

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

122

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

123

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

123

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

124

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

124

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

125

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

125

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

126

127

Return:

127

Return:

128

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

128

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

129

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

129

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

130

para el filename

130

para el filename

131

"""

131

"""

132

filepath = None

132

filepath = None

133

find_flag = False

133

find_flag = False

134

filename = None

134

filename = None

135

136

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

136

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

137

header1 = "dD"

137

header1 = "dD"

138

header2 = "dD"

138

header2 = "dD"

139

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

139

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

140

header1 = "dD"

140

header1 = "dD"

141

header2 = "pP"

141

header2 = "pP"

142

else:

142

else:

143

return None, filename

143

return None, filename

144

145

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

145

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

146

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

146

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

147

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

147

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

148

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

148

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

149

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

149

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

150

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

150

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

151

find_flag = True

151

find_flag = True

152

break

152

break

153

if find_flag:

153

if find_flag:

154

break

154

break

155

156

if not(find_flag):

156

if not(find_flag):

157

return None, filename

157

return None, filename

158

159

return filepath, filename

159

return filepath, filename

160

161

class JRODataIO:

161

class JRODataIO:

162

163

c = 3E8

163

c = 3E8

164

165

isConfig = False

165

isConfig = False

166

167

basicHeaderObj = BasicHeader()

167

basicHeaderObj = BasicHeader()

168

169

systemHeaderObj = SystemHeader()

169

systemHeaderObj = SystemHeader()

170

171

radarControllerHeaderObj = RadarControllerHeader()

171

radarControllerHeaderObj = RadarControllerHeader()

172

173

processingHeaderObj = ProcessingHeader()

173

processingHeaderObj = ProcessingHeader()

174

175

online = 0

175

online = 0

176

177

dtype = None

177

dtype = None

178

179

pathList = []

179

pathList = []

180

181

filenameList = []

181

filenameList = []

182

183

filename = None

183

filename = None

184

185

ext = None

185

ext = None

186

187

flagNoMoreFiles = 0

187

flagNoMoreFiles = 0

188

189

flagIsNewFile = 1

189

flagIsNewFile = 1

190

191

flagTimeBlock = 0

191

flagTimeBlock = 0

192

193

flagIsNewBlock = 0

193

flagIsNewBlock = 0

194

195

fp = None

195

fp = None

196

197

firstHeaderSize = 0

197

firstHeaderSize = 0

198

199

basicHeaderSize = 24

199

basicHeaderSize = 24

200

201

versionFile = 1103

201

versionFile = 1103

202

203

fileSize = None

203

fileSize = None

204

205

ippSeconds = None

205

ippSeconds = None

206

207

fileSizeByHeader = None

207

fileSizeByHeader = None

208

209

fileIndex = None

209

fileIndex = None

210

211

profileIndex = None

211

profileIndex = None

212

213

blockIndex = None

213

blockIndex = None

214

215

nTotalBlocks = None

215

nTotalBlocks = None

216

217

maxTimeStep = 30

217

maxTimeStep = 30

218

219

lastUTTime = None

219

lastUTTime = None

220

221

datablock = None

221

datablock = None

222

223

dataOut = None

223

dataOut = None

224

225

blocksize = None

225

blocksize = None

226

227

def __init__(self):

227

def __init__(self):

228

229

raise ValueError, "Not implemented"

229

raise ValueError, "Not implemented"

230

231

def run(self):

231

def run(self):

232

233

raise ValueError, "Not implemented"

233

raise ValueError, "Not implemented"

234

235

236

237

class JRODataReader(JRODataIO):

237

class JRODataReader(JRODataIO):

238

239

nReadBlocks = 0

239

nReadBlocks = 0

240

241

delay = 60 #number of seconds waiting a new file

241

delay = 60 #number of seconds waiting a new file

242

243

nTries = 3 #quantity tries

243

nTries = 3 #quantity tries

244

245

nFiles = 3 #number of files for searching

245

nFiles = 3 #number of files for searching

246

247

248

def __init__(self):

248

def __init__(self):

249

250

"""

250

"""

251

252

"""

252

"""

253

254

raise ValueError, "This method has not been implemented"

254

raise ValueError, "This method has not been implemented"

255

256

257

def createObjByDefault(self):

257

def createObjByDefault(self):

258

"""

258

"""

259

260

"""

260

"""

261

raise ValueError, "This method has not been implemented"

261

raise ValueError, "This method has not been implemented"

262

263

def getBlockDimension(self):

263

def getBlockDimension(self):

264

265

raise ValueError, "No implemented"

265

raise ValueError, "No implemented"

266

267

def __searchFilesOffLine(self,

267

def __searchFilesOffLine(self,

268

path,

268

path,

269

startDate,

269

startDate,

270

endDate,

270

endDate,

271

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

271

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

272

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

272

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

273

set=None,

273

set=None,

274

expLabel="",

274

expLabel="",

275

ext=".r"):

275

ext=".r"):

276

dirList = []

276

dirList = []

277

for thisPath in os.listdir(path):

277

for thisPath in os.listdir(path):

278

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

278

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

279

dirList.append(thisPath)

279

dirList.append(thisPath)

280

281

if not(dirList):

281

if not(dirList):

282

return None, None

282

return None, None

283

284

pathList = []

284

pathList = []

285

dateList = []

285

dateList = []

286

287

thisDate = startDate

287

thisDate = startDate

288

289

while(thisDate <= endDate):

289

while(thisDate <= endDate):

290

year = thisDate.timetuple().tm_year

290

year = thisDate.timetuple().tm_year

291

doy = thisDate.timetuple().tm_yday

291

doy = thisDate.timetuple().tm_yday

292

293

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

293

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

294

if len(match) == 0:

294

if len(match) == 0:

295

thisDate += datetime.timedelta(1)

295

thisDate += datetime.timedelta(1)

296

continue

296

continue

297

298

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

298

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

299

dateList.append(thisDate)

299

dateList.append(thisDate)

300

thisDate += datetime.timedelta(1)

300

thisDate += datetime.timedelta(1)

301

302

filenameList = []

302

filenameList = []

303

for index in range(len(pathList)):

303

for index in range(len(pathList)):

304

305

thisPath = pathList[index]

305

thisPath = pathList[index]

306

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

306

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

307

fileList.sort()

307

fileList.sort()

308

309

#Busqueda de datos en el rango de horas indicados

309

#Busqueda de datos en el rango de horas indicados

310

thisDate = dateList[index]

310

thisDate = dateList[index]

311

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

311

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

312

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

312

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

313

314

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

314

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

315

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

315

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

316

317

for file in fileList:

317

for file in fileList:

318

319

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

319

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

320

321

if isThisFileinRange(filename, startUtSeconds, endUtSeconds):

321

if isThisFileinRange(filename, startUtSeconds, endUtSeconds):

322

filenameList.append(filename)

322

filenameList.append(filename)

323

324

if not(filenameList):

324

if not(filenameList):

325

return None, None

325

return None, None

326

327

self.filenameList = filenameList

327

self.filenameList = filenameList

328

329

return pathList, filenameList

329

return pathList, filenameList

330

331

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

331

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

332

333

"""

333

"""

334

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

334

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

335

devuelve el archivo encontrado ademas de otros datos.

335

devuelve el archivo encontrado ademas de otros datos.

336

337

Input:

337

Input:

338

path : carpeta donde estan contenidos los files que contiene data

338

path : carpeta donde estan contenidos los files que contiene data

339

340

startDate : Fecha inicial. Rechaza todos los directorios donde

340

startDate : Fecha inicial. Rechaza todos los directorios donde

341

file end time < startDate (obejto datetime.date)

341

file end time < startDate (obejto datetime.date)

342

343

endDate : Fecha final. Rechaza todos los directorios donde

343

endDate : Fecha final. Rechaza todos los directorios donde

344

file start time > endDate (obejto datetime.date)

344

file start time > endDate (obejto datetime.date)

345

346

startTime : Tiempo inicial. Rechaza todos los archivos donde

346

startTime : Tiempo inicial. Rechaza todos los archivos donde

347

file end time < startTime (obejto datetime.time)

347

file end time < startTime (obejto datetime.time)

348

349

endTime : Tiempo final. Rechaza todos los archivos donde

349

endTime : Tiempo final. Rechaza todos los archivos donde

350

file start time > endTime (obejto datetime.time)

350

file start time > endTime (obejto datetime.time)

351

352

expLabel : Nombre del subexperimento (subfolder)

352

expLabel : Nombre del subexperimento (subfolder)

353

354

ext : extension de los files

354

ext : extension de los files

355

356

Return:

356

Return:

357

directory : eL directorio donde esta el file encontrado

357

directory : eL directorio donde esta el file encontrado

358

filename : el ultimo file de una determinada carpeta

358

filename : el ultimo file de una determinada carpeta

359

year : el anho

359

year : el anho

360

doy : el numero de dia del anho

360

doy : el numero de dia del anho

361

set : el set del archivo

361

set : el set del archivo

362

363

364

"""

364

"""

365

dirList = []

365

dirList = []

366

pathList = []

366

pathList = []

367

directory = None

367

directory = None

368

369

#Filtra solo los directorios

369

#Filtra solo los directorios

370

for thisPath in os.listdir(path):

370

for thisPath in os.listdir(path):

371

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

371

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

372

dirList.append(thisPath)

372

dirList.append(thisPath)

373

374

if not(dirList):

374

if not(dirList):

375

return None, None, None, None, None

375

return None, None, None, None, None

376

377

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

377

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

378

379

if startDate:

379

if startDate:

380

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

380

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

381

thisDateTime = startDateTime

381

thisDateTime = startDateTime

382

if endDate == None: endDateTime = startDateTime

382

if endDate == None: endDateTime = startDateTime

383

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

383

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

384

385

while(thisDateTime <= endDateTime):

385

while(thisDateTime <= endDateTime):

386

year = thisDateTime.timetuple().tm_year

386

year = thisDateTime.timetuple().tm_year

387

doy = thisDateTime.timetuple().tm_yday

387

doy = thisDateTime.timetuple().tm_yday

388

389

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

389

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

390

if len(match) == 0:

390

if len(match) == 0:

391

thisDateTime += datetime.timedelta(1)

391

thisDateTime += datetime.timedelta(1)

392

continue

392

continue

393

394

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

394

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

395

thisDateTime += datetime.timedelta(1)

395

thisDateTime += datetime.timedelta(1)

396

397

if not(pathList):

397

if not(pathList):

398

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

398

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

399

return None, None, None, None, None

399

return None, None, None, None, None

400

401

directory = pathList[0]

401

directory = pathList[0]

402

403

else:

403

else:

404

directory = dirList[-1]

404

directory = dirList[-1]

405

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

405

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

406

407

filename = getlastFileFromPath(directory, ext)

407

filename = getlastFileFromPath(directory, ext)

408

409

if not(filename):

409

if not(filename):

410

return None, None, None, None, None

410

return None, None, None, None, None

411

412

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

412

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

413

return None, None, None, None, None

413

return None, None, None, None, None

414

415

year = int( filename[1:5] )

415

year = int( filename[1:5] )

416

doy = int( filename[5:8] )

416

doy = int( filename[5:8] )

417

set = int( filename[8:11] )

417

set = int( filename[8:11] )

418

419

return directory, filename, year, doy, set

419

return directory, filename, year, doy, set

420

421

def setup(self,

421

def setup(self,

422

path=None,

422

path=None,

423

startDate=None,

423

startDate=None,

424

endDate=None,

424

endDate=None,

425

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

425

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

426

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

426

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

427

set=0,

427

set=0,

428

expLabel = "",

428

expLabel = "",

429

ext = None,

429

ext = None,

430

online = False,

430

online = False,

431

delay = 60):

431

delay = 60):

432

433

if path == None:

433

if path == None:

434

raise ValueError, "The path is not valid"

434

raise ValueError, "The path is not valid"

435

436

if ext == None:

436

if ext == None:

437

ext = self.ext

437

ext = self.ext

438

439

if dataOut != None:

439

if dataOut != None:

440

self.dataOut = dataOut

440

self.dataOut = dataOut

441

442

if online:

442

if online:

443

print "Searching files in online mode..."

443

print "Searching files in online mode..."

444

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

444

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

445

446

if not(doypath):

446

if not(doypath):

447

for nTries in range( self.nTries ):

447

for nTries in range( self.nTries ):

448

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

448

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

449

time.sleep( self.delay )

449

time.sleep( self.delay )

450

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

450

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

451

if doypath:

451

if doypath:

452

break

452

break

453

454

if not(doypath):

454

if not(doypath):

455

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

455

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

456

return None

456

return None

457

458

self.year = year

458

self.year = year

459

self.doy = doy

459

self.doy = doy

460

self.set = set - 1

460

self.set = set - 1

461

self.path = path

461

self.path = path

462

463

else:

463

else:

464

print "Searching files in offline mode ..."

464

print "Searching files in offline mode ..."

465

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

465

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

466

467

if not(pathList):

467

if not(pathList):

468

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

468

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

469

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

469

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

470

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

470

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

471

472

sys.exit(-1)

472

sys.exit(-1)

473

474

475

self.fileIndex = -1

475

self.fileIndex = -1

476

self.pathList = pathList

476

self.pathList = pathList

477

self.filenameList = filenameList

477

self.filenameList = filenameList

478

479

self.online = online

479

self.online = online

480

self.delay = delay

480

self.delay = delay

481

ext = ext.lower()

481

ext = ext.lower()

482

self.ext = ext

482

self.ext = ext

483

484

if not(self.setNextFile()):

484

if not(self.setNextFile()):

485

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

485

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

486

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

486

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

487

elif startDate != None:

487

elif startDate != None:

488

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

488

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

489

else:

489

else:

490

print "No files"

490

print "No files"

491

492

sys.exit(-1)

492

sys.exit(-1)

493

494

# self.updateDataHeader()

494

# self.updateDataHeader()

495

496

return self.dataOut

496

return self.dataOut

497

498

def __setNextFileOffline(self):

498

def __setNextFileOffline(self):

499

500

idFile = self.fileIndex

500

idFile = self.fileIndex

501

502

while (True):

502

while (True):

503

idFile += 1

503

idFile += 1

504

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

504

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

505

self.flagNoMoreFiles = 1

505

self.flagNoMoreFiles = 1

506

print "No more Files"

506

print "No more Files"

507

return 0

507

return 0

508

509

filename = self.filenameList[idFile]

509

filename = self.filenameList[idFile]

510

511

if not(self.__verifyFile(filename)):

511

if not(self.__verifyFile(filename)):

512

continue

512

continue

513

514

fileSize = os.path.getsize(filename)

514

fileSize = os.path.getsize(filename)

515

fp = open(filename,'rb')

515

fp = open(filename,'rb')

516

break

516

break

517

518

self.flagIsNewFile = 1

518

self.flagIsNewFile = 1

519

self.fileIndex = idFile

519

self.fileIndex = idFile

520

self.filename = filename

520

self.filename = filename

521

self.fileSize = fileSize

521

self.fileSize = fileSize

522

self.fp = fp

522

self.fp = fp

523

524

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

524

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

525

526

return 1

526

return 1

527

528

def __setNextFileOnline(self):

528

def __setNextFileOnline(self):

529

"""

529

"""

530

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

530

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

531

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

531

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

532

siguientes.

532

siguientes.

533

534

Affected:

534

Affected:

535

self.flagIsNewFile

535

self.flagIsNewFile

536

self.filename

536

self.filename

537

self.fileSize

537

self.fileSize

538

self.fp

538

self.fp

539

self.set

539

self.set

540

self.flagNoMoreFiles

540

self.flagNoMoreFiles

541

542

Return:

542

Return:

543

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

543

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

544

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

544

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

545

546

Excepciones:

546

Excepciones:

547

Si un determinado file no puede ser abierto

547

Si un determinado file no puede ser abierto

548

"""

548

"""

549

nFiles = 0

549

nFiles = 0

550

fileOk_flag = False

550

fileOk_flag = False

551

firstTime_flag = True

551

firstTime_flag = True

552

553

self.set += 1

553

self.set += 1

554

555

#busca el 1er file disponible

555

#busca el 1er file disponible

556

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

556

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

557

if file:

557

if file:

558

if self.__verifyFile(file, False):

558

if self.__verifyFile(file, False):

559

fileOk_flag = True

559

fileOk_flag = True

560

561

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

561

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

562

if not(fileOk_flag):

562

if not(fileOk_flag):

563

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

563

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

564

565

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

565

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

566

tries = self.nTries

566

tries = self.nTries

567

else:

567

else:

568

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

568

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

569

570

for nTries in range( tries ):

570

for nTries in range( tries ):

571

if firstTime_flag:

571

if firstTime_flag:

572

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

572

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

573

time.sleep( self.delay )

573

time.sleep( self.delay )

574

else:

574

else:

575

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

575

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

576

577

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

577

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

578

if file:

578

if file:

579

if self.__verifyFile(file):

579

if self.__verifyFile(file):

580

fileOk_flag = True

580

fileOk_flag = True

581

break

581

break

582

583

if fileOk_flag:

583

if fileOk_flag:

584

break

584

break

585

586

firstTime_flag = False

586

firstTime_flag = False

587

588

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

588

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

589

self.set += 1

589

self.set += 1

590

591

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

591

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

592

self.set = 0

592

self.set = 0

593

self.doy += 1

593

self.doy += 1

594

595

if fileOk_flag:

595

if fileOk_flag:

596

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

596

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

597

self.filename = file

597

self.filename = file

598

self.flagIsNewFile = 1

598

self.flagIsNewFile = 1

599

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

599

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

600

self.fp = open(file)

600

self.fp = open(file)

601

self.flagNoMoreFiles = 0

601

self.flagNoMoreFiles = 0

602

print 'Setting the file: %s' % file

602

print 'Setting the file: %s' % file

603

else:

603

else:

604

self.fileSize = 0

604

self.fileSize = 0

605

self.filename = None

605

self.filename = None

606

self.flagIsNewFile = 0

606

self.flagIsNewFile = 0

607

self.fp = None

607

self.fp = None

608

self.flagNoMoreFiles = 1

608

self.flagNoMoreFiles = 1

609

print 'No more Files'

609

print 'No more Files'

610

611

return fileOk_flag

611

return fileOk_flag

612

613

614

def setNextFile(self):

614

def setNextFile(self):

615

if self.fp != None:

615

if self.fp != None:

616

self.fp.close()

616

self.fp.close()

617

618

if self.online:

618

if self.online:

619

newFile = self.__setNextFileOnline()

619

newFile = self.__setNextFileOnline()

620

else:

620

else:

621

newFile = self.__setNextFileOffline()

621

newFile = self.__setNextFileOffline()

622

623

if not(newFile):

623

if not(newFile):

624

return 0

624

return 0

625

626

self.__readFirstHeader()

626

self.__readFirstHeader()

627

self.nReadBlocks = 0

627

self.nReadBlocks = 0

628

return 1

628

return 1

629

630

def __setNewBlock(self):

630

def __setNewBlock(self):

631

if self.fp == None:

631

if self.fp == None:

632

return 0

632

return 0

633

634

if self.flagIsNewFile:

634

if self.flagIsNewFile:

635

return 1

635

return 1

636

637

self.lastUTTime = self.basicHeaderObj.utc

637

self.lastUTTime = self.basicHeaderObj.utc

638

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

638

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

639

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

639

neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize

640

641

if (currentSize >= neededSize):

641

if (currentSize >= neededSize):

642

self.__rdBasicHeader()

642

self.__rdBasicHeader()

643

return 1

643

return 1

644

645

if not(self.setNextFile()):

645

if not(self.setNextFile()):

646

return 0

646

return 0

647

648

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

648

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

649

650

self.flagTimeBlock = 0

650

self.flagTimeBlock = 0

651

652

if deltaTime > self.maxTimeStep:

652

if deltaTime > self.maxTimeStep:

653

self.flagTimeBlock = 1

653

self.flagTimeBlock = 1

654

655

return 1

655

return 1

656

657

658

def readNextBlock(self):

658

def readNextBlock(self):

659

if not(self.__setNewBlock()):

659

if not(self.__setNewBlock()):

660

return 0

660

return 0

661

662

if not(self.readBlock()):

662

if not(self.readBlock()):

663

return 0

663

return 0

664

665

return 1

665

return 1

666

667

def __rdProcessingHeader(self, fp=None):

667

def __rdProcessingHeader(self, fp=None):

668

if fp == None:

668

if fp == None:

669

fp = self.fp

669

fp = self.fp

670

671

self.processingHeaderObj.read(fp)

671

self.processingHeaderObj.read(fp)

672

673

def __rdRadarControllerHeader(self, fp=None):

673

def __rdRadarControllerHeader(self, fp=None):

674

if fp == None:

674

if fp == None:

675

fp = self.fp

675

fp = self.fp

676

677

self.radarControllerHeaderObj.read(fp)

677

self.radarControllerHeaderObj.read(fp)

678

679

def __rdSystemHeader(self, fp=None):

679

def __rdSystemHeader(self, fp=None):

680

if fp == None:

680

if fp == None:

681

fp = self.fp

681

fp = self.fp

682

683

self.systemHeaderObj.read(fp)

683

self.systemHeaderObj.read(fp)

684

685

def __rdBasicHeader(self, fp=None):

685

def __rdBasicHeader(self, fp=None):

686

if fp == None:

686

if fp == None:

687

fp = self.fp

687

fp = self.fp

688

689

self.basicHeaderObj.read(fp)

689

self.basicHeaderObj.read(fp)

690

691

692

def __readFirstHeader(self):

692

def __readFirstHeader(self):

693

self.__rdBasicHeader()

693

self.__rdBasicHeader()

694

self.__rdSystemHeader()

694

self.__rdSystemHeader()

695

self.__rdRadarControllerHeader()

695

self.__rdRadarControllerHeader()

696

self.__rdProcessingHeader()

696

self.__rdProcessingHeader()

697

698

self.firstHeaderSize = self.basicHeaderObj.size

698

self.firstHeaderSize = self.basicHeaderObj.size

699

700

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

700

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

701

if datatype == 0:

701

if datatype == 0:

702

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

702

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

703

elif datatype == 1:

703

elif datatype == 1:

704

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

704

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

705

elif datatype == 2:

705

elif datatype == 2:

706

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

706

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

707

elif datatype == 3:

707

elif datatype == 3:

708

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

708

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

709

elif datatype == 4:

709

elif datatype == 4:

710

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

710

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

711

elif datatype == 5:

711

elif datatype == 5:

712

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

712

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

713

else:

713

else:

714

raise ValueError, 'Data type was not defined'

714

raise ValueError, 'Data type was not defined'

715

716

self.dtype = datatype_str

716

self.dtype = datatype_str

717

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

717

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

718

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

718

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

719

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

719

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

720

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

720

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

721

self.getBlockDimension()

721

self.getBlockDimension()

722

723

724

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

724

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

725

msg = None

725

msg = None

726

try:

726

try:

727

fp = open(filename, 'rb')

727

fp = open(filename, 'rb')

728

currentPosition = fp.tell()

728

currentPosition = fp.tell()

729

except:

729

except:

730

if msgFlag:

730

if msgFlag:

731

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

731

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

732

return False

732

return False

733

734

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

734

neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize

735

736

if neededSize == 0:

736

if neededSize == 0:

737

basicHeaderObj = BasicHeader()

737

basicHeaderObj = BasicHeader()

738

systemHeaderObj = SystemHeader()

738

systemHeaderObj = SystemHeader()

739

radarControllerHeaderObj = RadarControllerHeader()

739

radarControllerHeaderObj = RadarControllerHeader()

740

processingHeaderObj = ProcessingHeader()

740

processingHeaderObj = ProcessingHeader()

741

742

try:

742

try:

743

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

743

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

744

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

744

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

745

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

745

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

746

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

746

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

747

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

747

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

748

749

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

749

neededSize = processingHeaderObj.blockSize + basicHeaderObj.size

750

751

except:

751

except:

752

if msgFlag:

752

if msgFlag:

753

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

753

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

754

755

fp.close()

755

fp.close()

756

return False

756

return False

757

else:

757

else:

758

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

758

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

759

760

fp.close()

760

fp.close()

761

fileSize = os.path.getsize(filename)

761

fileSize = os.path.getsize(filename)

762

currentSize = fileSize - currentPosition

762

currentSize = fileSize - currentPosition

763

if currentSize < neededSize:

763

if currentSize < neededSize:

764

if msgFlag and (msg != None):

764

if msgFlag and (msg != None):

765

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

765

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

766

return False

766

return False

767

768

return True

768

return True

769

770

def getData():

770

def getData():

771

pass

771

pass

772

773

def hasNotDataInBuffer():

773

def hasNotDataInBuffer():

774

pass

774

pass

775

776

def readBlock():

776

def readBlock():

777

pass

777

pass

778

779

def run(self, **kwargs):

779

def run(self, **kwargs):

780

781

if not(self.isConfig):

781

if not(self.isConfig):

782

783

# self.dataOut = dataOut

783

# self.dataOut = dataOut

784

self.setup(**kwargs)

784

self.setup(**kwargs)

785

self.isConfig = True

785

self.isConfig = True

786

787

self.getData()

787

self.getData()

788

789

class JRODataWriter(JRODataIO):

789

class JRODataWriter(JRODataIO):

790

791

"""

791

"""

792

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

792

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

793

de los datos siempre se realiza por bloques.

793

de los datos siempre se realiza por bloques.

794

"""

794

"""

795

796

blockIndex = 0

796

blockIndex = 0

797

798

path = None

798

path = None

799

800

setFile = None

800

setFile = None

801

802

profilesPerBlock = None

802

profilesPerBlock = None

803

804

blocksPerFile = None

804

blocksPerFile = None

805

806

nWriteBlocks = 0

806

nWriteBlocks = 0

807

808

def __init__(self, dataOut=None):

808

def __init__(self, dataOut=None):

809

raise ValueError, "Not implemented"

809

raise ValueError, "Not implemented"

810

811

812

def hasAllDataInBuffer(self):

812

def hasAllDataInBuffer(self):

813

raise ValueError, "Not implemented"

813

raise ValueError, "Not implemented"

814

815

816

def setBlockDimension(self):

816

def setBlockDimension(self):

817

raise ValueError, "Not implemented"

817

raise ValueError, "Not implemented"

818

819

820

def writeBlock(self):

820

def writeBlock(self):

821

raise ValueError, "No implemented"

821

raise ValueError, "No implemented"

822

823

824

def putData(self):

824

def putData(self):

825

raise ValueError, "No implemented"

825

raise ValueError, "No implemented"

826

827

def getDataHeader(self):

827

def getDataHeader(self):

828

"""

828

"""

829

Obtiene una copia del First Header

829

Obtiene una copia del First Header

830

831

Affected:

831

Affected:

832

833

self.basicHeaderObj

833

self.basicHeaderObj

834

self.systemHeaderObj

834

self.systemHeaderObj

835

self.radarControllerHeaderObj

835

self.radarControllerHeaderObj

836

self.processingHeaderObj self.

836

self.processingHeaderObj self.

837

838

Return:

838

Return:

839

None

839

None

840

"""

840

"""

841

842

raise ValueError, "No implemented"

842

raise ValueError, "No implemented"

843

844

def getBasicHeader(self):

844

def getBasicHeader(self):

845

846

self.basicHeaderObj.size = self.basicHeaderSize #bytes

846

self.basicHeaderObj.size = self.basicHeaderSize #bytes

847

self.basicHeaderObj.version = self.versionFile

847

self.basicHeaderObj.version = self.versionFile

848

self.basicHeaderObj.dataBlock = self.nTotalBlocks

848

self.basicHeaderObj.dataBlock = self.nTotalBlocks

849

850

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

850

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

851

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

851

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

852

853

self.basicHeaderObj.utc = utc

853

self.basicHeaderObj.utc = utc

854

self.basicHeaderObj.miliSecond = milisecond

854

self.basicHeaderObj.miliSecond = milisecond

855

self.basicHeaderObj.timeZone = 0

855

self.basicHeaderObj.timeZone = 0

856

self.basicHeaderObj.dstFlag = 0

856

self.basicHeaderObj.dstFlag = 0

857

self.basicHeaderObj.errorCount = 0

857

self.basicHeaderObj.errorCount = 0

858

859

def __writeFirstHeader(self):

859

def __writeFirstHeader(self):

860

"""

860

"""

861

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

861

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

862

863

Affected:

863

Affected:

864

__dataType

864

__dataType

865

866

Return:

866

Return:

867

None

867

None

868

"""

868

"""

869

870

# CALCULAR PARAMETROS

870

# CALCULAR PARAMETROS

871

872

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

872

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

873

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

873

self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader

874

875

self.basicHeaderObj.write(self.fp)

875

self.basicHeaderObj.write(self.fp)

876

self.systemHeaderObj.write(self.fp)

876

self.systemHeaderObj.write(self.fp)

877

self.radarControllerHeaderObj.write(self.fp)

877

self.radarControllerHeaderObj.write(self.fp)

878

self.processingHeaderObj.write(self.fp)

878

self.processingHeaderObj.write(self.fp)

879

880

self.dtype = self.dataOut.dtype

880

self.dtype = self.dataOut.dtype

881

882

def __setNewBlock(self):

882

def __setNewBlock(self):

883

"""

883

"""

884

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

884

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

885

886

Return:

886

Return:

887

0 : si no pudo escribir nada

887

0 : si no pudo escribir nada

888

1 : Si escribio el Basic el First Header

888

1 : Si escribio el Basic el First Header

889

"""

889

"""

890

if self.fp == None:

890

if self.fp == None:

891

self.setNextFile()

891

self.setNextFile()

892

893

if self.flagIsNewFile:

893

if self.flagIsNewFile:

894

return 1

894

return 1

895

896

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

896

if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:

897

self.basicHeaderObj.write(self.fp)

897

self.basicHeaderObj.write(self.fp)

898

return 1

898

return 1

899

900

if not( self.setNextFile() ):

900

if not( self.setNextFile() ):

901

return 0

901

return 0

902

903

return 1

903

return 1

904

905

906

def writeNextBlock(self):

906

def writeNextBlock(self):

907

"""

907

"""

908

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

908

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

909

910

Return:

910

Return:

911

0 : Si no hizo pudo escribir el bloque de datos

911

0 : Si no hizo pudo escribir el bloque de datos

912

1 : Si no pudo escribir el bloque de datos

912

1 : Si no pudo escribir el bloque de datos

913

"""

913

"""

914

if not( self.__setNewBlock() ):

914

if not( self.__setNewBlock() ):

915

return 0

915

return 0

916

917

self.writeBlock()

917

self.writeBlock()

918

919

return 1

919

return 1

920

921

def setNextFile(self):

921

def setNextFile(self):

922

"""

922

"""

923

Determina el siguiente file que sera escrito

923

Determina el siguiente file que sera escrito

924

925

Affected:

925

Affected:

926

self.filename

926

self.filename

927

self.subfolder

927

self.subfolder

928

self.fp

928

self.fp

929

self.setFile

929

self.setFile

930

self.flagIsNewFile

930

self.flagIsNewFile

931

932

Return:

932

Return:

933

0 : Si el archivo no puede ser escrito

933

0 : Si el archivo no puede ser escrito

934

1 : Si el archivo esta listo para ser escrito

934

1 : Si el archivo esta listo para ser escrito

935

"""

935

"""

936

ext = self.ext

936

ext = self.ext

937

path = self.path

937

path = self.path

938

939

if self.fp != None:

939

if self.fp != None:

940

self.fp.close()

940

self.fp.close()

941

942

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

942

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

943

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

943

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

944

945

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

945

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

946

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

946

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

947

os.mkdir(doypath)

947

os.mkdir(doypath)

948

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

948

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

949

else:

949

else:

950

filesList = os.listdir( doypath )

950

filesList = os.listdir( doypath )

951

if len( filesList ) > 0:

951

if len( filesList ) > 0:

952

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

952

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

953

filen = filesList[-1]

953

filen = filesList[-1]

954

# el filename debera tener el siguiente formato

954

# el filename debera tener el siguiente formato

955

# 0 1234 567 89A BCDE (hex)

955

# 0 1234 567 89A BCDE (hex)

956

# x YYYY DDD SSS .ext

956

# x YYYY DDD SSS .ext

957

if isNumber( filen[8:11] ):

957

if isNumber( filen[8:11] ):

958

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

958

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

959

else:

959

else:

960

self.setFile = -1

960

self.setFile = -1

961

else:

961

else:

962

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

962

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

963

964

setFile = self.setFile

964

setFile = self.setFile

965

setFile += 1

965

setFile += 1

966

967

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

967

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

968

timeTuple.tm_year,

968

timeTuple.tm_year,

969

timeTuple.tm_yday,

969

timeTuple.tm_yday,

970

setFile,

970

setFile,

971

ext )

971

ext )

972

973

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

973

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

974

975

fp = open( filename,'wb' )

975

fp = open( filename,'wb' )

976

977

self.blockIndex = 0

977

self.blockIndex = 0

978

979

#guardando atributos

979

#guardando atributos

980

self.filename = filename

980

self.filename = filename

981

self.subfolder = subfolder

981

self.subfolder = subfolder

982

self.fp = fp

982

self.fp = fp

983

self.setFile = setFile

983

self.setFile = setFile

984

self.flagIsNewFile = 1

984

self.flagIsNewFile = 1

985

986

self.getDataHeader()

986

self.getDataHeader()

987

988

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

988

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

989

990

self.__writeFirstHeader()

990

self.__writeFirstHeader()

991

992

return 1

992

return 1

993

994

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

994

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

995

"""

995

"""

996

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

996

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

997

998

Inputs:

998

Inputs:

999

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

999

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

1000

format : formato en el cual sera salvado un file

1000

format : formato en el cual sera salvado un file

1001

set : el setebo del file

1001

set : el setebo del file

1002

1003

Return:

1003

Return:

1004

0 : Si no realizo un buen seteo

1004

0 : Si no realizo un buen seteo

1005

1 : Si realizo un buen seteo

1005

1 : Si realizo un buen seteo

1006

"""

1006

"""

1007

1008

if ext == None:

1008

if ext == None:

1009

ext = self.ext

1009

ext = self.ext

1010

1011

ext = ext.lower()

1011

ext = ext.lower()

1012

1013

self.ext = ext

1013

self.ext = ext

1014

1015

self.path = path

1015

self.path = path

1016

1017

self.setFile = set - 1

1017

self.setFile = set - 1

1018

1019

self.blocksPerFile = blocksPerFile

1019

self.blocksPerFile = blocksPerFile

1020

1021

self.profilesPerBlock = profilesPerBlock

1021

self.profilesPerBlock = profilesPerBlock

1022

1023

self.dataOut = dataOut

1023

self.dataOut = dataOut

1024

1025

if not(self.setNextFile()):

1025

if not(self.setNextFile()):

1026

print "There isn't a next file"

1026

print "There isn't a next file"

1027

return 0

1027

return 0

1028

1029

self.setBlockDimension()

1029

self.setBlockDimension()

1030

1031

return 1

1031

return 1

1032

1033

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

1033

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

1034

1035

if not(self.isConfig):

1035

if not(self.isConfig):

1036

1037

self.setup(dataOut, **kwargs)

1037

self.setup(dataOut, **kwargs)

1038

self.isConfig = True

1038

self.isConfig = True

1039

1040

self.putData()

1040

self.putData()

1041

1042

class VoltageReader(JRODataReader):

1042

class VoltageReader(JRODataReader):

1043

"""

1043

"""

1044

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

1044

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

1045

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

1045

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

1046

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

1046

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

1047

1048

perfiles * alturas * canales

1048

perfiles * alturas * canales

1049

1050

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

1050

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

1051

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

1051

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

1052

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

1052

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

1053

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

1053

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

1054

1055

Example:

1055

Example:

1056

1057

dpath = "/home/myuser/data"

1057

dpath = "/home/myuser/data"

1058

1059

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

1059

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

1060

1061

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

1061

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

1062

1063

readerObj = VoltageReader()

1063

readerObj = VoltageReader()

1064

1065

readerObj.setup(dpath, startTime, endTime)

1065

readerObj.setup(dpath, startTime, endTime)

1066

1067

while(True):

1067

while(True):

1068

1069

#to get one profile

1069

#to get one profile

1070

profile = readerObj.getData()

1070

profile = readerObj.getData()

1071

1072

#print the profile

1072

#print the profile

1073

print profile

1073

print profile

1074

1075

#If you want to see all datablock

1075

#If you want to see all datablock

1076

print readerObj.datablock

1076

print readerObj.datablock

1077

1078

if readerObj.flagNoMoreFiles:

1078

if readerObj.flagNoMoreFiles:

1079

break

1079

break

1080

1081

"""

1081

"""

1082

1083

ext = ".r"

1083

ext = ".r"

1084

1085

optchar = "D"

1085

optchar = "D"

1086

dataOut = None

1086

dataOut = None

1087

1088

1089

def __init__(self):

1089

def __init__(self):

1090

"""

1090

"""

1091

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

1091

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

1092

1093

Input:

1093

Input:

1094

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

1094

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

1095

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

1095

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

1096

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

1096

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

1097

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

1097

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

1098

bloque de datos.

1098

bloque de datos.

1099

Si este parametro no es pasado se creara uno internamente.

1099

Si este parametro no es pasado se creara uno internamente.

1100

1101

Variables afectadas:

1101

Variables afectadas:

1102

self.dataOut

1102

self.dataOut

1103

1104

Return:

1104

Return:

1105

None

1105

None

1106

"""

1106

"""

1107

1108

self.isConfig = False

1108

self.isConfig = False

1109

1110

self.datablock = None

1110

self.datablock = None

1111

1112

self.utc = 0

1112

self.utc = 0

1113

1114

self.ext = ".r"

1114

self.ext = ".r"

1115

1116

self.optchar = "D"

1116

self.optchar = "D"

1117

1118

self.basicHeaderObj = BasicHeader()

1118

self.basicHeaderObj = BasicHeader()

1119

1120

self.systemHeaderObj = SystemHeader()

1120

self.systemHeaderObj = SystemHeader()

1121

1122

self.radarControllerHeaderObj = RadarControllerHeader()

1122

self.radarControllerHeaderObj = RadarControllerHeader()

1123

1124

self.processingHeaderObj = ProcessingHeader()

1124

self.processingHeaderObj = ProcessingHeader()

1125

1126

self.online = 0

1126

self.online = 0

1127

1128

self.fp = None

1128

self.fp = None

1129

1130

self.idFile = None

1130

self.idFile = None

1131

1132

self.dtype = None

1132

self.dtype = None

1133

1134

self.fileSizeByHeader = None

1134

self.fileSizeByHeader = None

1135

1136

self.filenameList = []

1136

self.filenameList = []

1137

1138

self.filename = None

1138

self.filename = None

1139

1140

self.fileSize = None

1140

self.fileSize = None

1141

1142

self.firstHeaderSize = 0

1142

self.firstHeaderSize = 0

1143

1144

self.basicHeaderSize = 24

1144

self.basicHeaderSize = 24

1145

1146

self.pathList = []

1146

self.pathList = []

1147

1148

self.filenameList = []

1148

self.filenameList = []

1149

1150

self.lastUTTime = 0

1150

self.lastUTTime = 0

1151

1152

self.maxTimeStep = 30

1152

self.maxTimeStep = 30

1153

1154

self.flagNoMoreFiles = 0

1154

self.flagNoMoreFiles = 0

1155

1156

self.set = 0

1156

self.set = 0

1157

1158

self.path = None

1158

self.path = None

1159

1160

self.profileIndex = 9999

1160

self.profileIndex = 9999

1161

1162

self.delay = 3 #seconds

1162

self.delay = 3 #seconds

1163

1164

self.nTries = 3 #quantity tries

1164

self.nTries = 3 #quantity tries

1165

1166

self.nFiles = 3 #number of files for searching

1166

self.nFiles = 3 #number of files for searching

1167

1168

self.nReadBlocks = 0

1168

self.nReadBlocks = 0

1169

1170

self.flagIsNewFile = 1

1170

self.flagIsNewFile = 1

1171

1172

self.ippSeconds = 0

1172

self.ippSeconds = 0

1173

1174

self.flagTimeBlock = 0

1174

self.flagTimeBlock = 0

1175

1176

self.flagIsNewBlock = 0

1176

self.flagIsNewBlock = 0

1177

1178

self.nTotalBlocks = 0

1178

self.nTotalBlocks = 0

1179

1180

self.blocksize = 0

1180

self.blocksize = 0

1181

1182

dataOut = self.createObjByDefault()

1182

self.dataOut = self.createObjByDefault()

1183

1184

def createObjByDefault(self):

1184

def createObjByDefault(self):

1185

1186

dataObj = Voltage()

1186

dataObj = Voltage()

1187

1188

return dataObj

1188

return dataObj

1189

1190

def __hasNotDataInBuffer(self):

1190

def __hasNotDataInBuffer(self):

1191

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

1191

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

1192

return 1

1192

return 1

1193

return 0

1193

return 0

1194

1195

1196

def getBlockDimension(self):

1196

def getBlockDimension(self):

1197

"""

1197

"""

1198

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

1198

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

1199

1200

Affected:

1200

Affected:

1201

self.blocksize

1201

self.blocksize

1202

1203

Return:

1203

Return:

1204

None

1204

None

1205

"""

1205

"""

1206

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

1206

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

1207

self.blocksize = pts2read

1207

self.blocksize = pts2read

1208

1209

1210

def readBlock(self):

1210

def readBlock(self):

1211

"""

1211

"""

1212

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

1212

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

1213

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

1213

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

1214

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

1214

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

1215

es seteado a 0

1215

es seteado a 0

1216

1217

Inputs:

1217

Inputs:

1218

None

1218

None

1219

1220

Return:

1220

Return:

1221

None

1221

None

1222

1223

Affected:

1223

Affected:

1224

self.profileIndex

1224

self.profileIndex

1225

self.datablock

1225

self.datablock

1226

self.flagIsNewFile

1226

self.flagIsNewFile

1227

self.flagIsNewBlock

1227

self.flagIsNewBlock

1228

self.nTotalBlocks

1228

self.nTotalBlocks

1229

1230

Exceptions:

1230

Exceptions:

1231

Si un bloque leido no es un bloque valido

1231

Si un bloque leido no es un bloque valido

1232

"""

1232

"""

1233

1234

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

1234

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

1235

1236

try:

1236

try:

1237

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

1237

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

1238

except:

1238

except:

1239

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

1239

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

1240

return 0

1240

return 0

1241

1242

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

1242

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

1243

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

1243

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

1244

1245

self.profileIndex = 0

1245

self.profileIndex = 0

1246

1247

self.flagIsNewFile = 0

1247

self.flagIsNewFile = 0

1248

self.flagIsNewBlock = 1

1248

self.flagIsNewBlock = 1

1249

1250

self.nTotalBlocks += 1

1250

self.nTotalBlocks += 1

1251

self.nReadBlocks += 1

1251

self.nReadBlocks += 1

1252

1253

return 1

1253

return 1

1254

1255

1256

def getData(self):

1256

def getData(self):

1257

"""

1257

"""

1258

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

1258

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

1259

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

1259

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

1260

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

1260

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

1261

1262

Ademas incrementa el contador del buffer en 1.

1262

Ademas incrementa el contador del buffer en 1.

1263

1264

Return:

1264

Return:

1265

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

1265

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

1266

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

1266

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

1267

1268

Variables afectadas:

1268

Variables afectadas:

1269

self.dataOut

1269

self.dataOut

1270

self.profileIndex

1270

self.profileIndex

1271

1272

Affected:

1272

Affected:

1273

self.dataOut

1273

self.dataOut

1274

self.profileIndex

1274

self.profileIndex

1275

self.flagTimeBlock

1275

self.flagTimeBlock

1276

self.flagIsNewBlock

1276

self.flagIsNewBlock

1277

"""

1277

"""

1278

if self.flagNoMoreFiles: return 0

1278

if self.flagNoMoreFiles: return 0

1279

1280

self.flagTimeBlock = 0

1280

self.flagTimeBlock = 0

1281

self.flagIsNewBlock = 0

1281

self.flagIsNewBlock = 0

1282

1283

if self.__hasNotDataInBuffer():

1283

if self.__hasNotDataInBuffer():

1284

1285

if not( self.readNextBlock() ):

1285

if not( self.readNextBlock() ):

1286

return 0

1286

return 0

1287

1288

# self.updateDataHeader()

1288

# self.updateDataHeader()

1289

1290

if self.flagNoMoreFiles == 1:

1290

if self.flagNoMoreFiles == 1:

1291

print 'Process finished'

1291

print 'Process finished'

1292

return 0

1292

return 0

1293

1294

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

1294

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

1295

1296

if self.datablock == None:

1296

if self.datablock == None:

1297

self.dataOut.flagNoData = True

1297

self.dataOut.flagNoData = True

1298

return 0

1298

return 0

1299

1300

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

1300

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

1301

1302

self.dataOut.dtype = self.dtype

1302

self.dataOut.dtype = self.dtype

1303

1304

self.dataOut.nChannels = self.systemHeaderObj.nChannels

1304

self.dataOut.nChannels = self.systemHeaderObj.nChannels

1305

1306

self.dataOut.nHeights = self.processingHeaderObj.nHeights

1306

self.dataOut.nHeights = self.processingHeaderObj.nHeights

1307

1308

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1308

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1309

1310

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

1310

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

1311

1312

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

1312

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

1313

1314

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

1314

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

1315

1316

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

1316

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

1317

1318

self.dataOut.flagTimeBlock = self.flagTimeBlock

1318

self.dataOut.flagTimeBlock = self.flagTimeBlock

1319

1320

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

1320

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

1321

1322

self.dataOut.ippSeconds = self.ippSeconds

1322

self.dataOut.ippSeconds = self.ippSeconds

1323

1324

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

1324

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

1325

1326

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1326

self.dataOut.nCohInt = self.processingHeaderObj.nCohInt

1327

1328

self.dataOut.flagShiftFFT = False

1328

self.dataOut.flagShiftFFT = False

1329

1330

if self.processingHeaderObj.code != None:

1330

if self.processingHeaderObj.code != None:

1331

self.dataOut.nCode = self.processingHeaderObj.nCode

1331

self.dataOut.nCode = self.processingHeaderObj.nCode

1332

1333

self.dataOut.nBaud = self.processingHeaderObj.nBaud

1333

self.dataOut.nBaud = self.processingHeaderObj.nBaud

1334

1335

self.dataOut.code = self.processingHeaderObj.code

1335

self.dataOut.code = self.processingHeaderObj.code

1336

1337

self.profileIndex += 1

1337

self.profileIndex += 1

1338

1339

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

1339

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

1340

1341

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

1341

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

1342

1343

self.dataOut.flagNoData = False

1343

self.dataOut.flagNoData = False

1344

1345

# print self.profileIndex, self.dataOut.utctime

1345

# print self.profileIndex, self.dataOut.utctime

1346

# if self.profileIndex == 800:

1346

# if self.profileIndex == 800:

1347

# a=1

1347

# a=1

1348

1349

return self.dataOut.data

1349

return self.dataOut.data

1350

1351

1352

class VoltageWriter(JRODataWriter):

1352

class VoltageWriter(JRODataWriter):

1353

"""

1353

"""

1354

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

1354

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

1355

de los datos siempre se realiza por bloques.

1355

de los datos siempre se realiza por bloques.

1356

"""

1356

"""

1357

1358

ext = ".r"

1358

ext = ".r"

1359

1360

optchar = "D"

1360

optchar = "D"

1361

1362

shapeBuffer = None

1362

shapeBuffer = None

1363

1364

1365

def __init__(self):

1365

def __init__(self):

1366

"""

1366

"""

1367

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

1367

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

1368

1369

Affected:

1369

Affected:

1370

self.dataOut

1370

self.dataOut

1371

1372

Return: None

1372

Return: None

1373

"""

1373

"""

1374

1375

self.nTotalBlocks = 0

1375

self.nTotalBlocks = 0

1376

1377

self.profileIndex = 0

1377

self.profileIndex = 0

1378

1379

self.isConfig = False

1379

self.isConfig = False

1380

1381

self.fp = None

1381

self.fp = None

1382

1383

self.flagIsNewFile = 1

1383

self.flagIsNewFile = 1

1384

1385

self.nTotalBlocks = 0

1385

self.nTotalBlocks = 0

1386

1387

self.flagIsNewBlock = 0

1387

self.flagIsNewBlock = 0

1388

1389

self.flagNoMoreFiles = 0

1389

self.flagNoMoreFiles = 0

1390

1391

self.setFile = None

1391

self.setFile = None

1392

1393

self.dtype = None

1393

self.dtype = None

1394

1395

self.path = None

1395

self.path = None

1396

1397

self.noMoreFiles = 0

1397

self.noMoreFiles = 0

1398

1399

self.filename = None

1399

self.filename = None

1400

1401

self.basicHeaderObj = BasicHeader()

1401

self.basicHeaderObj = BasicHeader()

1402

1403

self.systemHeaderObj = SystemHeader()

1403

self.systemHeaderObj = SystemHeader()

1404

1405

self.radarControllerHeaderObj = RadarControllerHeader()

1405

self.radarControllerHeaderObj = RadarControllerHeader()

1406

1407

self.processingHeaderObj = ProcessingHeader()

1407

self.processingHeaderObj = ProcessingHeader()

1408

1409

def hasAllDataInBuffer(self):

1409

def hasAllDataInBuffer(self):

1410

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

1410

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

1411

return 1

1411

return 1

1412

return 0

1412

return 0

1413

1414

1415

def setBlockDimension(self):

1415

def setBlockDimension(self):

1416

"""

1416

"""

1417

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

1417

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

1418

1419

Affected:

1419

Affected:

1420

self.shape_spc_Buffer

1420

self.shape_spc_Buffer

1421

self.shape_cspc_Buffer

1421

self.shape_cspc_Buffer

1422

self.shape_dc_Buffer

1422

self.shape_dc_Buffer

1423

1424

Return: None

1424

Return: None

1425

"""

1425

"""

1426

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1426

self.shapeBuffer = (self.processingHeaderObj.profilesPerBlock,

1427

self.processingHeaderObj.nHeights,

1427

self.processingHeaderObj.nHeights,

1428

self.systemHeaderObj.nChannels)

1428

self.systemHeaderObj.nChannels)

1429

1430

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

1430

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

1431

self.processingHeaderObj.profilesPerBlock,

1431

self.processingHeaderObj.profilesPerBlock,

1432

self.processingHeaderObj.nHeights),

1432

self.processingHeaderObj.nHeights),

1433

dtype=numpy.dtype('complex'))

1433

dtype=numpy.dtype('complex'))

1434

1435

1436

def writeBlock(self):

1436

def writeBlock(self):

1437

"""

1437

"""

1438

Escribe el buffer en el file designado

1438

Escribe el buffer en el file designado

1439

1440

Affected:

1440

Affected:

1441

self.profileIndex

1441

self.profileIndex

1442

self.flagIsNewFile

1442

self.flagIsNewFile

1443

self.flagIsNewBlock

1443

self.flagIsNewBlock

1444

self.nTotalBlocks

1444

self.nTotalBlocks

1445

self.blockIndex

1445

self.blockIndex

1446

1447

Return: None

1447

Return: None

1448

"""

1448

"""

1449

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

1449

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

1450

1451

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

1451

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

1452

1453

data['real'] = junk.real

1453

data['real'] = junk.real

1454

data['imag'] = junk.imag

1454

data['imag'] = junk.imag

1455

1456

data = data.reshape( (-1) )

1456

data = data.reshape( (-1) )

1457

1458

data.tofile( self.fp )

1458

data.tofile( self.fp )

1459

1460

self.datablock.fill(0)

1460

self.datablock.fill(0)

1461

1462

self.profileIndex = 0

1462

self.profileIndex = 0

1463

self.flagIsNewFile = 0

1463

self.flagIsNewFile = 0

1464

self.flagIsNewBlock = 1

1464

self.flagIsNewBlock = 1

1465

1466

self.blockIndex += 1

1466

self.blockIndex += 1

1467

self.nTotalBlocks += 1

1467

self.nTotalBlocks += 1

1468

1469

def putData(self):

1469

def putData(self):

1470

"""

1470

"""

1471

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

1471

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

1472

1473

Affected:

1473

Affected:

1474

self.flagIsNewBlock

1474

self.flagIsNewBlock

1475

self.profileIndex

1475

self.profileIndex

1476

1477

Return:

1477

Return:

1478

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

1478

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

1479

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

1479

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

1480

"""

1480

"""

1481

if self.dataOut.flagNoData:

1481

if self.dataOut.flagNoData:

1482

return 0

1482

return 0

1483

1484

self.flagIsNewBlock = 0

1484

self.flagIsNewBlock = 0

1485

1486

if self.dataOut.flagTimeBlock:

1486

if self.dataOut.flagTimeBlock:

1487

1488

self.datablock.fill(0)

1488

self.datablock.fill(0)

1489

self.profileIndex = 0

1489

self.profileIndex = 0

1490

self.setNextFile()

1490

self.setNextFile()

1491

1492

if self.profileIndex == 0:

1492

if self.profileIndex == 0:

1493

self.getBasicHeader()

1493

self.getBasicHeader()

1494

1495

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

1495

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

1496

1497

self.profileIndex += 1

1497

self.profileIndex += 1

1498

1499

if self.hasAllDataInBuffer():

1499

if self.hasAllDataInBuffer():

1500

#if self.flagIsNewFile:

1500

#if self.flagIsNewFile:

1501

self.writeNextBlock()

1501

self.writeNextBlock()

1502

# self.getDataHeader()

1502

# self.getDataHeader()

1503

1504

if self.flagNoMoreFiles:

1504

if self.flagNoMoreFiles:

1505

#print 'Process finished'

1505

#print 'Process finished'

1506

return 0

1506

return 0

1507

1508

return 1

1508

return 1

1509

1510

def __getProcessFlags(self):

1510

def __getProcessFlags(self):

1511

1512

processFlags = 0

1512

processFlags = 0

1513

1514

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

1514

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

1515

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

1515

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

1516

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

1516

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

1517

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

1517

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

1518

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

1518

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

1519

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

1519

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

1520

1521

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

1521

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

1522

1523

1524

1525

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1525

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

1526

PROCFLAG.DATATYPE_SHORT,

1526

PROCFLAG.DATATYPE_SHORT,

1527

PROCFLAG.DATATYPE_LONG,

1527

PROCFLAG.DATATYPE_LONG,

1528

PROCFLAG.DATATYPE_INT64,

1528

PROCFLAG.DATATYPE_INT64,

1529

PROCFLAG.DATATYPE_FLOAT,

1529

PROCFLAG.DATATYPE_FLOAT,

1530

PROCFLAG.DATATYPE_DOUBLE]

1530

PROCFLAG.DATATYPE_DOUBLE]

1531

1532

1533

for index in range(len(dtypeList)):

1533

for index in range(len(dtypeList)):

1534

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

1534

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

1535

dtypeValue = datatypeValueList[index]

1535

dtypeValue = datatypeValueList[index]

1536

break

1536

break

1537

1538

processFlags += dtypeValue

1538

processFlags += dtypeValue

1539

1540

if self.dataOut.flagDecodeData:

1540

if self.dataOut.flagDecodeData:

1541

processFlags += PROCFLAG.DECODE_DATA

1541

processFlags += PROCFLAG.DECODE_DATA

1542

1543

if self.dataOut.flagDeflipData:

1543

if self.dataOut.flagDeflipData:

1544

processFlags += PROCFLAG.DEFLIP_DATA

1544

processFlags += PROCFLAG.DEFLIP_DATA

1545

1546

if self.dataOut.code != None:

1546

if self.dataOut.code != None:

1547

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1547

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

1548

1549

if self.dataOut.nCohInt > 1:

1549

if self.dataOut.nCohInt > 1:

1550

processFlags += PROCFLAG.COHERENT_INTEGRATION

1550

processFlags += PROCFLAG.COHERENT_INTEGRATION

1551

1552

return processFlags

1552

return processFlags

1553

1554

1555

def __getBlockSize(self):

1555

def __getBlockSize(self):

1556

'''

1556

'''

1557

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

1557

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

1558

'''

1558

'''

1559

1560

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

1560

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

1561

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

1561

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

1562

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

1562

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

1563

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

1563

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

1564

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

1564

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

1565

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

1565

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

1566

1567

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

1567

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

1568

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

1568

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

1569

for index in range(len(dtypeList)):

1569

for index in range(len(dtypeList)):

1570

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

1570

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

1571

datatypeValue = datatypeValueList[index]

1571

datatypeValue = datatypeValueList[index]

1572

break

1572

break

1573

1574

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

1574

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

1575

1576

return blocksize

1576

return blocksize

1577

1578

def getDataHeader(self):

1578

def getDataHeader(self):

1579

1580

"""

1580

"""

1581

Obtiene una copia del First Header

1581

Obtiene una copia del First Header

1582

1583

Affected:

1583

Affected:

1584

self.systemHeaderObj

1584

self.systemHeaderObj

1585

self.radarControllerHeaderObj

1585

self.radarControllerHeaderObj

1586

self.dtype

1586

self.dtype

1587

1588

Return:

1588

Return:

1589

None

1589

None

1590

"""

1590

"""

1591

1592

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

1592

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

1593

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1593

self.systemHeaderObj.nChannels = self.dataOut.nChannels

1594

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

1594

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

1595

1596

self.getBasicHeader()

1596

self.getBasicHeader()

1597

1598

processingHeaderSize = 40 # bytes

1598

processingHeaderSize = 40 # bytes

1599

self.processingHeaderObj.dtype = 0 # Voltage

1599

self.processingHeaderObj.dtype = 0 # Voltage

1600

self.processingHeaderObj.blockSize = self.__getBlockSize()

1600

self.processingHeaderObj.blockSize = self.__getBlockSize()

1601

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1601

self.processingHeaderObj.profilesPerBlock = self.profilesPerBlock

1602

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1602

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

1603

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

1603

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

1604

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1604

self.processingHeaderObj.processFlags = self.__getProcessFlags()

1605

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1605

self.processingHeaderObj.nCohInt = self.dataOut.nCohInt

1606

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

1606

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

1607

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

1607

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

1608

1609

if self.dataOut.code != None:

1609

if self.dataOut.code != None:

1610

self.processingHeaderObj.code = self.dataOut.code

1610

self.processingHeaderObj.code = self.dataOut.code

1611

self.processingHeaderObj.nCode = self.dataOut.nCode

1611

self.processingHeaderObj.nCode = self.dataOut.nCode

1612

self.processingHeaderObj.nBaud = self.dataOut.nBaud

1612

self.processingHeaderObj.nBaud = self.dataOut.nBaud

1613

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

1613

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

1614

processingHeaderSize += codesize

1614

processingHeaderSize += codesize

1615

1616

if self.processingHeaderObj.nWindows != 0:

1616

if self.processingHeaderObj.nWindows != 0:

1617

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

1617

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

1618

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

1618

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

1619

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1619

self.processingHeaderObj.nHeights = self.dataOut.nHeights

1620

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1620

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

1621

processingHeaderSize += 12

1621

processingHeaderSize += 12

1622

1623

self.processingHeaderObj.size = processingHeaderSize

1623

self.processingHeaderObj.size = processingHeaderSize

1624

1625

class SpectraReader(JRODataReader):

1625

class SpectraReader(JRODataReader):

1626

"""

1626

"""

1627

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

1627

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

1628

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

1628

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

1629

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

1629

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

1630

1631

paresCanalesIguales * alturas * perfiles (Self Spectra)

1631

paresCanalesIguales * alturas * perfiles (Self Spectra)

1632

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1632

paresCanalesDiferentes * alturas * perfiles (Cross Spectra)

1633

canales * alturas (DC Channels)

1633

canales * alturas (DC Channels)

1634

1635

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

1635

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

1636

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

1636

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

1637

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

1637

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

1638

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

1638

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

1639

1640

Example:

1640

Example:

1641

dpath = "/home/myuser/data"

1641

dpath = "/home/myuser/data"

1642

1643

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

1643

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

1644

1645

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

1645

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

1646

1647

readerObj = SpectraReader()

1647

readerObj = SpectraReader()

1648

1649

readerObj.setup(dpath, startTime, endTime)

1649

readerObj.setup(dpath, startTime, endTime)

1650

1651

while(True):

1651

while(True):

1652

1653

readerObj.getData()

1653

readerObj.getData()

1654

1655

print readerObj.data_spc

1655

print readerObj.data_spc

1656

1657

print readerObj.data_cspc

1657

print readerObj.data_cspc

1658

1659

print readerObj.data_dc

1659

print readerObj.data_dc

1660

1661

if readerObj.flagNoMoreFiles:

1661

if readerObj.flagNoMoreFiles:

1662

break

1662

break

1663

1664

"""

1664

"""

1665

1666

pts2read_SelfSpectra = 0

1666

pts2read_SelfSpectra = 0

1667

1668

pts2read_CrossSpectra = 0

1668

pts2read_CrossSpectra = 0

1669

1670

pts2read_DCchannels = 0

1670

pts2read_DCchannels = 0

1671

1672

ext = ".pdata"

1672

ext = ".pdata"

1673

1674

optchar = "P"

1674

optchar = "P"

1675

1676

dataOut = None

1676

dataOut = None

1677

1678

nRdChannels = None

1678

nRdChannels = None

1679

1680

nRdPairs = None

1680

nRdPairs = None

1681

1682

rdPairList = []

1682

rdPairList = []

1683

1684

1685

def __init__(self):

1685

def __init__(self):

1686

"""

1686

"""

1687

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

1687

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

1688

1689

Inputs:

1689

Inputs:

1690

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

1690

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

1691

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

1691

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

1692

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

1692

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

1693

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

1693

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

1694

bloque de datos.

1694

bloque de datos.

1695

Si este parametro no es pasado se creara uno internamente.

1695

Si este parametro no es pasado se creara uno internamente.

1696

1697

Affected:

1697

Affected:

1698

self.dataOut

1698

self.dataOut

1699

1700

Return : None

1700

Return : None

1701

"""

1701

"""

1702

1703

self.isConfig = False

1703

self.isConfig = False

1704

1705

self.pts2read_SelfSpectra = 0

1705

self.pts2read_SelfSpectra = 0

1706

1707

self.pts2read_CrossSpectra = 0

1707

self.pts2read_CrossSpectra = 0

1708

1709

self.pts2read_DCchannels = 0

1709

self.pts2read_DCchannels = 0

1710

1711

self.datablock = None

1711

self.datablock = None

1712

1713

self.utc = None

1713

self.utc = None

1714

1715

self.ext = ".pdata"

1715

self.ext = ".pdata"

1716

1717

self.optchar = "P"

1717

self.optchar = "P"

1718

1719

self.basicHeaderObj = BasicHeader()

1719

self.basicHeaderObj = BasicHeader()

1720

1721

self.systemHeaderObj = SystemHeader()

1721

self.systemHeaderObj = SystemHeader()

1722

1723

self.radarControllerHeaderObj = RadarControllerHeader()

1723

self.radarControllerHeaderObj = RadarControllerHeader()

1724

1725

self.processingHeaderObj = ProcessingHeader()

1725

self.processingHeaderObj = ProcessingHeader()

1726

1727

self.online = 0

1727

self.online = 0

1728

1729

self.fp = None

1729

self.fp = None

1730

1731

self.idFile = None

1731

self.idFile = None

1732

1733

self.dtype = None

1733

self.dtype = None

1734

1735

self.fileSizeByHeader = None

1735

self.fileSizeByHeader = None

1736

1737

self.filenameList = []

1737

self.filenameList = []

1738

1739

self.filename = None

1739

self.filename = None

1740

1741

self.fileSize = None

1741

self.fileSize = None

1742

1743

self.firstHeaderSize = 0

1743

self.firstHeaderSize = 0

1744

1745

self.basicHeaderSize = 24

1745

self.basicHeaderSize = 24

1746

1747

self.pathList = []

1747

self.pathList = []

1748

1749

self.lastUTTime = 0

1749

self.lastUTTime = 0

1750

1751

self.maxTimeStep = 30

1751

self.maxTimeStep = 30

1752

1753

self.flagNoMoreFiles = 0

1753

self.flagNoMoreFiles = 0

1754

1755

self.set = 0

1755

self.set = 0

1756

1757

self.path = None

1757

self.path = None

1758

1759

self.delay = 3 #seconds

1759

self.delay = 3 #seconds

1760

1761

self.nTries = 3 #quantity tries

1761

self.nTries = 3 #quantity tries

1762

1763

self.nFiles = 3 #number of files for searching

1763

self.nFiles = 3 #number of files for searching

1764

1765

self.nReadBlocks = 0

1765

self.nReadBlocks = 0

1766

1767

self.flagIsNewFile = 1

1767

self.flagIsNewFile = 1

1768

1769

self.ippSeconds = 0

1769

self.ippSeconds = 0

1770

1771

self.flagTimeBlock = 0

1771

self.flagTimeBlock = 0

1772

1773

self.flagIsNewBlock = 0

1773

self.flagIsNewBlock = 0

1774

1775

self.nTotalBlocks = 0

1775

self.nTotalBlocks = 0

1776

1777

self.blocksize = 0

1777

self.blocksize = 0

1778

1779

dataOut = self.createObjByDefault()

1779

self.dataOut = self.createObjByDefault()

1780

1781

1782

def createObjByDefault(self):

1782

def createObjByDefault(self):

1783

1784

dataObj = Spectra()

1784

dataObj = Spectra()

1785

1786

return dataObj

1786

return dataObj

1787

1788

def __hasNotDataInBuffer(self):

1788

def __hasNotDataInBuffer(self):

1789

return 1

1789

return 1

1790

1791

1792

def getBlockDimension(self):

1792

def getBlockDimension(self):

1793

"""

1793

"""

1794

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

1794

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

1795

1796

Affected:

1796

Affected:

1797

self.nRdChannels

1797

self.nRdChannels

1798

self.nRdPairs

1798

self.nRdPairs

1799

self.pts2read_SelfSpectra

1799

self.pts2read_SelfSpectra

1800

self.pts2read_CrossSpectra

1800

self.pts2read_CrossSpectra

1801

self.pts2read_DCchannels

1801

self.pts2read_DCchannels

1802

self.blocksize

1802

self.blocksize

1803

self.dataOut.nChannels

1803

self.dataOut.nChannels

1804

self.dataOut.nPairs

1804

self.dataOut.nPairs

1805

1806

Return:

1806

Return:

1807

None

1807

None

1808

"""

1808

"""

1809

self.nRdChannels = 0

1809

self.nRdChannels = 0

1810

self.nRdPairs = 0

1810

self.nRdPairs = 0

1811

self.rdPairList = []

1811

self.rdPairList = []

1812

1813

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

1813

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

1814

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

1814

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

1815

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

1815

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

1816

else:

1816

else:

1817

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

1817

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

1818

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

1818

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

1819

1820

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

1820

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

1821

1822

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

1822

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

1823

self.blocksize = self.pts2read_SelfSpectra

1823

self.blocksize = self.pts2read_SelfSpectra

1824

1825

if self.processingHeaderObj.flag_cspc:

1825

if self.processingHeaderObj.flag_cspc:

1826

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

1826

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

1827

self.blocksize += self.pts2read_CrossSpectra

1827

self.blocksize += self.pts2read_CrossSpectra

1828

1829

if self.processingHeaderObj.flag_dc:

1829

if self.processingHeaderObj.flag_dc:

1830

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

1830

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

1831

self.blocksize += self.pts2read_DCchannels

1831

self.blocksize += self.pts2read_DCchannels

1832

1833

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

1833

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

1834

1835

1836

def readBlock(self):

1836

def readBlock(self):

1837

"""

1837

"""

1838

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

1838

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

1839

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

1839

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

1840

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

1840

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

1841

es seteado a 0

1841

es seteado a 0

1842

1843

Return: None

1843

Return: None

1844

1845

Variables afectadas:

1845

Variables afectadas:

1846

1847

self.flagIsNewFile

1847

self.flagIsNewFile

1848

self.flagIsNewBlock

1848

self.flagIsNewBlock

1849

self.nTotalBlocks

1849

self.nTotalBlocks

1850

self.data_spc

1850

self.data_spc

1851

self.data_cspc

1851

self.data_cspc

1852

self.data_dc

1852

self.data_dc

1853

1854

Exceptions:

1854

Exceptions:

1855

Si un bloque leido no es un bloque valido

1855

Si un bloque leido no es un bloque valido

1856

"""

1856

"""

1857

blockOk_flag = False

1857

blockOk_flag = False

1858

fpointer = self.fp.tell()

1858

fpointer = self.fp.tell()

1859

1860

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

1860

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

1861

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

1861

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

1862

1863

if self.processingHeaderObj.flag_cspc:

1863

if self.processingHeaderObj.flag_cspc:

1864

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

1864

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

1865

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

1865

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

1866

1867

if self.processingHeaderObj.flag_dc:

1867

if self.processingHeaderObj.flag_dc:

1868

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

1868

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

1869

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

1869

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

1870

1871

1872

if not(self.processingHeaderObj.shif_fft):

1872

if not(self.processingHeaderObj.shif_fft):

1873

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

1873

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

1874

1875

if self.processingHeaderObj.flag_cspc:

1875

if self.processingHeaderObj.flag_cspc:

1876

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

1876

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

1877

1878

1879

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

1879

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

1880

self.data_spc = spc

1880

self.data_spc = spc

1881

1882

if self.processingHeaderObj.flag_cspc:

1882

if self.processingHeaderObj.flag_cspc:

1883

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

1883

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

1884

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

1884

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

1885

else:

1885

else:

1886

self.data_cspc = None

1886

self.data_cspc = None

1887

1888

if self.processingHeaderObj.flag_dc:

1888

if self.processingHeaderObj.flag_dc:

1889

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

1889

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

1890

else:

1890

else:

1891

self.data_dc = None

1891

self.data_dc = None

1892

1893

self.flagIsNewFile = 0

1893

self.flagIsNewFile = 0

1894

self.flagIsNewBlock = 1

1894

self.flagIsNewBlock = 1

1895

1896

self.nTotalBlocks += 1

1896

self.nTotalBlocks += 1

1897

self.nReadBlocks += 1

1897

self.nReadBlocks += 1

1898

1899

return 1

1899

return 1

1900

1901

1902

def getData(self):

1902

def getData(self):

1903

"""

1903

"""

1904

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

1904

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

1905

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

1905

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

1906

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

1906

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

1907

1908

Return:

1908

Return:

1909

0 : Si no hay mas archivos disponibles

1909

0 : Si no hay mas archivos disponibles

1910

1 : Si hizo una buena copia del buffer

1910

1 : Si hizo una buena copia del buffer

1911

1912

Affected:

1912

Affected:

1913

self.dataOut

1913

self.dataOut

1914

1915

self.flagTimeBlock

1915

self.flagTimeBlock

1916

self.flagIsNewBlock

1916

self.flagIsNewBlock

1917

"""

1917

"""

1918

1919

if self.flagNoMoreFiles: return 0

1919

if self.flagNoMoreFiles: return 0

1920

1921

self.flagTimeBlock = 0

1921

self.flagTimeBlock = 0

1922

self.flagIsNewBlock = 0

1922

self.flagIsNewBlock = 0

1923

1924

if self.__hasNotDataInBuffer():

1924

if self.__hasNotDataInBuffer():

1925

1926

if not( self.readNextBlock() ):

1926

if not( self.readNextBlock() ):

1927

return 0

1927

return 0

1928

1929

# self.updateDataHeader()

1929

# self.updateDataHeader()

1930

1931

if self.flagNoMoreFiles == 1:

1931

if self.flagNoMoreFiles == 1:

1932

print 'Process finished'

1932

print 'Process finished'

1933

return 0

1933

return 0

1934

1935

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

1935

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

1936

1937

if self.data_dc == None:

1937

if self.data_dc == None:

1938

self.dataOut.flagNoData = True

1938

self.dataOut.flagNoData = True

1939

return 0

1939

return 0

1940

1941

1942

self.dataOut.data_spc = self.data_spc

1942

self.dataOut.data_spc = self.data_spc

1943

1944

self.dataOut.data_cspc = self.data_cspc

1944

self.dataOut.data_cspc = self.data_cspc

1945

1946

self.dataOut.data_dc = self.data_dc

1946

self.dataOut.data_dc = self.data_dc

1947

1948

self.dataOut.flagTimeBlock = self.flagTimeBlock

1948

self.dataOut.flagTimeBlock = self.flagTimeBlock

1949

1950

self.dataOut.flagNoData = False

1950

self.dataOut.flagNoData = False

1951

1952

self.dataOut.dtype = self.dtype

1952

self.dataOut.dtype = self.dtype

1953

1954

self.dataOut.nChannels = self.nRdChannels

1954

self.dataOut.nChannels = self.nRdChannels

1955

1956

self.dataOut.nPairs = self.nRdPairs

1956

self.dataOut.nPairs = self.nRdPairs

1957

1958

self.dataOut.pairsList = self.rdPairList

1958

self.dataOut.pairsList = self.rdPairList

1959

1960

self.dataOut.nHeights = self.processingHeaderObj.nHeights

1960

self.dataOut.nHeights = self.processingHeaderObj.nHeights

1961

1962

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1962

self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock

1963

1964

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

1964

self.dataOut.nFFTPoints = self.processingHeaderObj.profilesPerBlock

1965

1966

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

1966

self.dataOut.nIncohInt = self.processingHeaderObj.nIncohInt

1967

1968

1969

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

1969

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

1970

1971

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

1971

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

1972

1973

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

1973

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

1974

1975

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

1975

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

1976

1977

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

1977

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

1978

1979

self.dataOut.ippSeconds = self.ippSeconds

1979

self.dataOut.ippSeconds = self.ippSeconds

1980

1981

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

1981

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

1982

1983

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

1983

self.dataOut.flagShiftFFT = self.processingHeaderObj.shif_fft

1984

1985

# self.profileIndex += 1

1985

# self.profileIndex += 1

1986

1987

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

1987

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

1988

1989

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

1989

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

1990

1991

return self.dataOut.data_spc

1991

return self.dataOut.data_spc

1992

1993

1994

class SpectraWriter(JRODataWriter):

1994

class SpectraWriter(JRODataWriter):

1995

1996

"""

1996

"""

1997

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

1997

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

1998

de los datos siempre se realiza por bloques.

1998

de los datos siempre se realiza por bloques.

1999

"""

1999

"""

2000

2001

ext = ".pdata"

2001

ext = ".pdata"

2002

2003

optchar = "P"

2003

optchar = "P"

2004

2005

shape_spc_Buffer = None

2005

shape_spc_Buffer = None

2006

2007

shape_cspc_Buffer = None

2007

shape_cspc_Buffer = None

2008

2009

shape_dc_Buffer = None

2009

shape_dc_Buffer = None

2010

2011

data_spc = None

2011

data_spc = None

2012

2013

data_cspc = None

2013

data_cspc = None

2014

2015

data_dc = None

2015

data_dc = None

2016

2017

# dataOut = None

2017

# dataOut = None

2018

2019

def __init__(self):

2019

def __init__(self):

2020

"""

2020

"""

2021

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

2021

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

2022

2023

Affected:

2023

Affected:

2024

self.dataOut

2024

self.dataOut

2025

self.basicHeaderObj

2025

self.basicHeaderObj

2026

self.systemHeaderObj

2026

self.systemHeaderObj

2027

self.radarControllerHeaderObj

2027

self.radarControllerHeaderObj

2028

self.processingHeaderObj

2028

self.processingHeaderObj

2029

2030

Return: None

2030

Return: None

2031

"""

2031

"""

2032

2033

self.isConfig = False

2033

self.isConfig = False

2034

2035

self.nTotalBlocks = 0

2035

self.nTotalBlocks = 0

2036

2037

self.data_spc = None

2037

self.data_spc = None

2038

2039

self.data_cspc = None

2039

self.data_cspc = None

2040

2041

self.data_dc = None

2041

self.data_dc = None

2042

2043

self.fp = None

2043

self.fp = None

2044

2045

self.flagIsNewFile = 1

2045

self.flagIsNewFile = 1

2046

2047

self.nTotalBlocks = 0

2047

self.nTotalBlocks = 0

2048

2049

self.flagIsNewBlock = 0

2049

self.flagIsNewBlock = 0

2050

2051

self.flagNoMoreFiles = 0

2051

self.flagNoMoreFiles = 0

2052

2053

self.setFile = None

2053

self.setFile = None

2054

2055

self.dtype = None

2055

self.dtype = None

2056

2057

self.path = None

2057

self.path = None

2058

2059

self.noMoreFiles = 0

2059

self.noMoreFiles = 0

2060

2061

self.filename = None

2061

self.filename = None

2062

2063

self.basicHeaderObj = BasicHeader()

2063

self.basicHeaderObj = BasicHeader()

2064

2065

self.systemHeaderObj = SystemHeader()

2065

self.systemHeaderObj = SystemHeader()

2066

2067

self.radarControllerHeaderObj = RadarControllerHeader()

2067

self.radarControllerHeaderObj = RadarControllerHeader()

2068

2069

self.processingHeaderObj = ProcessingHeader()

2069

self.processingHeaderObj = ProcessingHeader()

2070

2071

2072

def hasAllDataInBuffer(self):

2072

def hasAllDataInBuffer(self):

2073

return 1

2073

return 1

2074

2075

2076

def setBlockDimension(self):

2076

def setBlockDimension(self):

2077

"""

2077

"""

2078

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

2078

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

2079

2080

Affected:

2080

Affected:

2081

self.shape_spc_Buffer

2081

self.shape_spc_Buffer

2082

self.shape_cspc_Buffer

2082

self.shape_cspc_Buffer

2083

self.shape_dc_Buffer

2083

self.shape_dc_Buffer

2084

2085

Return: None

2085

Return: None

2086

"""

2086

"""

2087

self.shape_spc_Buffer = (self.dataOut.nChannels,

2087

self.shape_spc_Buffer = (self.dataOut.nChannels,

2088

self.processingHeaderObj.nHeights,

2088

self.processingHeaderObj.nHeights,

2089

self.processingHeaderObj.profilesPerBlock)

2089

self.processingHeaderObj.profilesPerBlock)

2090

2091

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2091

self.shape_cspc_Buffer = (self.dataOut.nPairs,

2092

self.processingHeaderObj.nHeights,

2092

self.processingHeaderObj.nHeights,

2093

self.processingHeaderObj.profilesPerBlock)

2093

self.processingHeaderObj.profilesPerBlock)

2094

2095

self.shape_dc_Buffer = (self.dataOut.nChannels,

2095

self.shape_dc_Buffer = (self.dataOut.nChannels,

2096

self.processingHeaderObj.nHeights)

2096

self.processingHeaderObj.nHeights)

2097

2098

2099

def writeBlock(self):

2099

def writeBlock(self):

2100

"""

2100

"""

2101

Escribe el buffer en el file designado

2101

Escribe el buffer en el file designado

2102

2103

Affected:

2103

Affected:

2104

self.data_spc

2104

self.data_spc

2105

self.data_cspc

2105

self.data_cspc

2106

self.data_dc

2106

self.data_dc

2107

self.flagIsNewFile

2107

self.flagIsNewFile

2108

self.flagIsNewBlock

2108

self.flagIsNewBlock

2109

self.nTotalBlocks

2109

self.nTotalBlocks

2110

self.nWriteBlocks

2110

self.nWriteBlocks

2111

2112

Return: None

2112

Return: None

2113

"""

2113

"""

2114

2115

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

2115

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

2116

if not( self.processingHeaderObj.shif_fft ):

2116

if not( self.processingHeaderObj.shif_fft ):

2117

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

2117

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

2118

data = spc.reshape((-1))

2118

data = spc.reshape((-1))

2119

data.tofile(self.fp)

2119

data.tofile(self.fp)

2120

2121

if self.data_cspc != None:

2121

if self.data_cspc != None:

2122

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

2122

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

2123

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

2123

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

2124

if not( self.processingHeaderObj.shif_fft ):

2124

if not( self.processingHeaderObj.shif_fft ):

2125

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

2125

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

2126

data['real'] = cspc.real

2126

data['real'] = cspc.real

2127

data['imag'] = cspc.imag

2127

data['imag'] = cspc.imag

2128

data = data.reshape((-1))

2128

data = data.reshape((-1))

2129

data.tofile(self.fp)

2129

data.tofile(self.fp)

2130

2131

if self.data_dc != None:

2131

if self.data_dc != None:

2132

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

2132

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

2133

dc = self.data_dc

2133

dc = self.data_dc

2134

data['real'] = dc.real

2134

data['real'] = dc.real

2135

data['imag'] = dc.imag

2135

data['imag'] = dc.imag

2136

data = data.reshape((-1))

2136

data = data.reshape((-1))

2137

data.tofile(self.fp)

2137

data.tofile(self.fp)

2138

2139

self.data_spc.fill(0)

2139

self.data_spc.fill(0)

2140

self.data_dc.fill(0)

2140

self.data_dc.fill(0)

2141

if self.data_cspc != None:

2141

if self.data_cspc != None:

2142

self.data_cspc.fill(0)

2142

self.data_cspc.fill(0)

2143

2144

self.flagIsNewFile = 0

2144

self.flagIsNewFile = 0

2145

self.flagIsNewBlock = 1

2145

self.flagIsNewBlock = 1

2146

self.nTotalBlocks += 1

2146

self.nTotalBlocks += 1

2147

self.nWriteBlocks += 1

2147

self.nWriteBlocks += 1

2148

self.blockIndex += 1

2148

self.blockIndex += 1

2149

2150

2151

def putData(self):

2151

def putData(self):

2152

"""

2152

"""

2153

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

2153

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

2154

2155

Affected:

2155

Affected:

2156

self.data_spc

2156

self.data_spc

2157

self.data_cspc

2157

self.data_cspc

2158

self.data_dc

2158

self.data_dc

2159

2160

Return:

2160

Return:

2161

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

2161

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

2162

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

2162

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

2163

"""

2163

"""

2164

2165

if self.dataOut.flagNoData:

2165

if self.dataOut.flagNoData:

2166

return 0

2166

return 0

2167

2168

self.flagIsNewBlock = 0

2168

self.flagIsNewBlock = 0

2169

2170

if self.dataOut.flagTimeBlock:

2170

if self.dataOut.flagTimeBlock:

2171

self.data_spc.fill(0)

2171

self.data_spc.fill(0)

2172

self.data_cspc.fill(0)

2172

self.data_cspc.fill(0)

2173

self.data_dc.fill(0)

2173

self.data_dc.fill(0)

2174

self.setNextFile()

2174

self.setNextFile()

2175

2176

if self.flagIsNewFile == 0:

2176

if self.flagIsNewFile == 0:

2177

self.getBasicHeader()

2177

self.getBasicHeader()

2178

2179

self.data_spc = self.dataOut.data_spc

2179

self.data_spc = self.dataOut.data_spc

2180

self.data_cspc = self.dataOut.data_cspc

2180

self.data_cspc = self.dataOut.data_cspc

2181

self.data_dc = self.dataOut.data_dc

2181

self.data_dc = self.dataOut.data_dc

2182

2183

# #self.processingHeaderObj.dataBlocksPerFile)

2183

# #self.processingHeaderObj.dataBlocksPerFile)

2184

if self.hasAllDataInBuffer():

2184

if self.hasAllDataInBuffer():

2185

# self.getDataHeader()

2185

# self.getDataHeader()

2186

self.writeNextBlock()

2186

self.writeNextBlock()

2187

2188

if self.flagNoMoreFiles:

2188

if self.flagNoMoreFiles:

2189

#print 'Process finished'

2189

#print 'Process finished'

2190

return 0

2190

return 0

2191

2192

return 1

2192

return 1

2193

2194

2195

def __getProcessFlags(self):

2195

def __getProcessFlags(self):

2196

2197

processFlags = 0

2197

processFlags = 0

2198

2199

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

2199

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

2200

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

2200

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

2201

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

2201

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

2202

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

2202

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

2203

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

2203

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

2204

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

2204

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

2205

2206

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

2206

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

2207

2208

2209

2210

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2210

datatypeValueList = [PROCFLAG.DATATYPE_CHAR,

2211

PROCFLAG.DATATYPE_SHORT,

2211

PROCFLAG.DATATYPE_SHORT,

2212

PROCFLAG.DATATYPE_LONG,

2212

PROCFLAG.DATATYPE_LONG,

2213

PROCFLAG.DATATYPE_INT64,

2213

PROCFLAG.DATATYPE_INT64,

2214

PROCFLAG.DATATYPE_FLOAT,

2214

PROCFLAG.DATATYPE_FLOAT,

2215

PROCFLAG.DATATYPE_DOUBLE]

2215

PROCFLAG.DATATYPE_DOUBLE]

2216

2217

2218

for index in range(len(dtypeList)):

2218

for index in range(len(dtypeList)):

2219

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

2219

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

2220

dtypeValue = datatypeValueList[index]

2220

dtypeValue = datatypeValueList[index]

2221

break

2221

break

2222

2223

processFlags += dtypeValue

2223

processFlags += dtypeValue

2224

2225

if self.dataOut.flagDecodeData:

2225

if self.dataOut.flagDecodeData:

2226

processFlags += PROCFLAG.DECODE_DATA

2226

processFlags += PROCFLAG.DECODE_DATA

2227

2228

if self.dataOut.flagDeflipData:

2228

if self.dataOut.flagDeflipData:

2229

processFlags += PROCFLAG.DEFLIP_DATA

2229

processFlags += PROCFLAG.DEFLIP_DATA

2230

2231

if self.dataOut.code != None:

2231

if self.dataOut.code != None:

2232

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2232

processFlags += PROCFLAG.DEFINE_PROCESS_CODE

2233

2234

if self.dataOut.nIncohInt > 1:

2234

if self.dataOut.nIncohInt > 1:

2235

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2235

processFlags += PROCFLAG.INCOHERENT_INTEGRATION

2236

2237

if self.dataOut.data_dc != None:

2237

if self.dataOut.data_dc != None:

2238

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2238

processFlags += PROCFLAG.SAVE_CHANNELS_DC

2239

2240

return processFlags

2240

return processFlags

2241

2242

2243

def __getBlockSize(self):

2243

def __getBlockSize(self):

2244

'''

2244

'''

2245

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

2245

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

2246

'''

2246

'''

2247

2248

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

2248

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

2249

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

2249

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

2250

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

2250

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

2251

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

2251

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

2252

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

2252

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

2253

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

2253

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

2254

2255

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

2255

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

2256

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

2256

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

2257

for index in range(len(dtypeList)):

2257

for index in range(len(dtypeList)):

2258

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

2258

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

2259

datatypeValue = datatypeValueList[index]

2259

datatypeValue = datatypeValueList[index]

2260

break

2260

break

2261

2262

2263

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

2263

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

2264

2265

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

2265

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

2266

blocksize = (pts2write_SelfSpectra*datatypeValue)

2266

blocksize = (pts2write_SelfSpectra*datatypeValue)

2267

2268

if self.dataOut.data_cspc != None:

2268

if self.dataOut.data_cspc != None:

2269

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

2269

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

2270

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2270

blocksize += (pts2write_CrossSpectra*datatypeValue*2)

2271

2272

if self.dataOut.data_dc != None:

2272

if self.dataOut.data_dc != None:

2273

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

2273

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

2274

blocksize += (pts2write_DCchannels*datatypeValue*2)

2274

blocksize += (pts2write_DCchannels*datatypeValue*2)

2275

2276

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2276

blocksize = blocksize #* datatypeValue * 2 #CORREGIR ESTO

2277

2278

return blocksize

2278

return blocksize

2279

2280

def getDataHeader(self):

2280

def getDataHeader(self):

2281

2282

"""

2282

"""

2283

Obtiene una copia del First Header

2283

Obtiene una copia del First Header

2284

2285

Affected:

2285

Affected:

2286

self.systemHeaderObj

2286

self.systemHeaderObj

2287

self.radarControllerHeaderObj

2287

self.radarControllerHeaderObj

2288

self.dtype

2288

self.dtype

2289

2290

Return:

2290

Return:

2291

None

2291

None

2292

"""

2292

"""

2293

2294

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

2294

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

2295

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2295

self.systemHeaderObj.nChannels = self.dataOut.nChannels

2296

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

2296

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

2297

2298

self.getBasicHeader()

2298

self.getBasicHeader()

2299

2300

processingHeaderSize = 40 # bytes

2300

processingHeaderSize = 40 # bytes

2301

self.processingHeaderObj.dtype = 0 # Voltage

2301

self.processingHeaderObj.dtype = 0 # Voltage

2302

self.processingHeaderObj.blockSize = self.__getBlockSize()

2302

self.processingHeaderObj.blockSize = self.__getBlockSize()

2303

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2303

self.processingHeaderObj.profilesPerBlock = self.dataOut.nFFTPoints

2304

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2304

self.processingHeaderObj.dataBlocksPerFile = self.blocksPerFile

2305

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

2305

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

2306

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2306

self.processingHeaderObj.processFlags = self.__getProcessFlags()

2307

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

2307

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

2308

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2308

self.processingHeaderObj.nIncohInt = self.dataOut.nIncohInt

2309

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

2309

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

2310

2311

if self.processingHeaderObj.totalSpectra > 0:

2311

if self.processingHeaderObj.totalSpectra > 0:

2312

channelList = []

2312

channelList = []

2313

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

2313

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

2314

channelList.append(channel)

2314

channelList.append(channel)

2315

channelList.append(channel)

2315

channelList.append(channel)

2316

2317

pairsList = []

2317

pairsList = []

2318

for pair in self.dataOut.pairsList:

2318

for pair in self.dataOut.pairsList:

2319

pairsList.append(pair[0])

2319

pairsList.append(pair[0])

2320

pairsList.append(pair[1])

2320

pairsList.append(pair[1])

2321

spectraComb = channelList + pairsList

2321

spectraComb = channelList + pairsList

2322

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

2322

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

2323

self.processingHeaderObj.spectraComb = spectraComb

2323

self.processingHeaderObj.spectraComb = spectraComb

2324

sizeOfSpcComb = len(spectraComb)

2324

sizeOfSpcComb = len(spectraComb)

2325

processingHeaderSize += sizeOfSpcComb

2325

processingHeaderSize += sizeOfSpcComb

2326

2327

if self.dataOut.code != None:

2327

if self.dataOut.code != None:

2328

self.processingHeaderObj.code = self.dataOut.code

2328

self.processingHeaderObj.code = self.dataOut.code

2329

self.processingHeaderObj.nCode = self.dataOut.nCode

2329

self.processingHeaderObj.nCode = self.dataOut.nCode

2330

self.processingHeaderObj.nBaud = self.dataOut.nBaud

2330

self.processingHeaderObj.nBaud = self.dataOut.nBaud

2331

nCodeSize = 4 # bytes

2331

nCodeSize = 4 # bytes

2332

nBaudSize = 4 # bytes

2332

nBaudSize = 4 # bytes

2333

codeSize = 4 # bytes

2333

codeSize = 4 # bytes

2334

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

2334

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

2335

processingHeaderSize += sizeOfCode

2335

processingHeaderSize += sizeOfCode

2336

2337

if self.processingHeaderObj.nWindows != 0:

2337

if self.processingHeaderObj.nWindows != 0:

2338

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

2338

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

2339

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

2339

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

2340

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2340

self.processingHeaderObj.nHeights = self.dataOut.nHeights

2341

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2341

self.processingHeaderObj.samplesWin = self.dataOut.nHeights

2342

sizeOfFirstHeight = 4

2342

sizeOfFirstHeight = 4

2343

sizeOfdeltaHeight = 4

2343

sizeOfdeltaHeight = 4

2344

sizeOfnHeights = 4

2344

sizeOfnHeights = 4

2345

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

2345

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

2346

processingHeaderSize += sizeOfWindows

2346

processingHeaderSize += sizeOfWindows

2347

2348

self.processingHeaderObj.size = processingHeaderSize

2348

self.processingHeaderObj.size = processingHeaderSize

2349

2350

class SpectraHeisWriter():

2350

class SpectraHeisWriter():

2351

2352

i=0

2352

i=0

2353

2354

def __init__(self, dataOut):

2354

def __init__(self, dataOut):

2355

2356

self.wrObj = FITS()

2356

self.wrObj = FITS()

2357

self.dataOut = dataOut

2357

self.dataOut = dataOut

2358

2359

def isNumber(str):

2359

def isNumber(str):

2360

"""

2360

"""

2361

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

2361

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

2362

2363

Excepciones:

2363

Excepciones:

2364

Si un determinado string no puede ser convertido a numero

2364

Si un determinado string no puede ser convertido a numero

2365

Input:

2365

Input:

2366

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

2366

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

2367

2368

Return:

2368

Return:

2369

True : si el string es uno numerico

2369

True : si el string es uno numerico

2370

False : no es un string numerico

2370

False : no es un string numerico

2371

"""

2371

"""

2372

try:

2372

try:

2373

float( str )

2373

float( str )

2374

return True

2374

return True

2375

except:

2375

except:

2376

return False

2376

return False

2377

2378

def setup(self, wrpath,):

2378

def setup(self, wrpath,):

2379

2380

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

2380

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

2381

os.mkdir(wrpath)

2381

os.mkdir(wrpath)

2382

2383

self.wrpath = wrpath

2383

self.wrpath = wrpath

2384

self.setFile = 0

2384

self.setFile = 0

2385

2386

def putData(self):

2386

def putData(self):

2387

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

2387

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

2388

#name = self.dataOut.utctime

2388

#name = self.dataOut.utctime

2389

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

2389

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

2390

ext=".fits"

2390

ext=".fits"

2391

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

2391

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

2392

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

2392

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

2393

2394

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

2394

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

2395

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

2395

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

2396

os.mkdir(doypath)

2396

os.mkdir(doypath)

2397

self.setFile += 1

2397

self.setFile += 1

2398

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

2398

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

2399

2400

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

2400

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

2401

2402

# print self.dataOut.ippSeconds

2402

# print self.dataOut.ippSeconds

2403

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

2403

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

2404

2405

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

2405

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

2406

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

2406

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

2407

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

2407

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

2408

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

2408

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

2409

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

2409

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

2410

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

2410

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

2411

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

2411

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

2412

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

2412

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

2413

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

2413

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

2414

#n=numpy.arange((100))

2414

#n=numpy.arange((100))

2415

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

2415

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

2416

a=self.wrObj.cFImage(n)

2416

a=self.wrObj.cFImage(n)

2417

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

2417

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

2418

self.wrObj.CFile(a,b)

2418

self.wrObj.CFile(a,b)

2419

self.wrObj.wFile(filename)

2419

self.wrObj.wFile(filename)

2420

return 1

2420

return 1

2421

2422

class FITS:

2422

class FITS:

2423

2424

name=None

2424

name=None

2425

format=None

2425

format=None

2426

array =None

2426

array =None

2427

data =None

2427

data =None

2428

thdulist=None

2428

thdulist=None

2429

2430

def __init__(self):

2430

def __init__(self):

2431

2432

pass

2432

pass

2433

2434

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

2434

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

2435

self.name=name

2435

self.name=name

2436

self.format=format

2436

self.format=format

2437

self.array=array

2437

self.array=array

2438

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

2438

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

2439

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

2439

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

2440

return self.col1

2440

return self.col1

2441

2442

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

2442

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

2443

# self.name=name

2443

# self.name=name

2444

# self.format=format

2444

# self.format=format

2445

# self.data=data

2445

# self.data=data

2446

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

2446

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

2447

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

2447

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

2448

# return self.col2

2448

# return self.col2

2449

2450

def writeHeader(self,):

2450

def writeHeader(self,):

2451

pass

2451

pass

2452

2453

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

2453

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

2454

self.name=name

2454

self.name=name

2455

self.format=format

2455

self.format=format

2456

self.data=data

2456

self.data=data

2457

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

2457

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

2458

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

2458

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

2459

return self.col2

2459

return self.col2

2460

2461

def cFImage(self,n):

2461

def cFImage(self,n):

2462

self.hdu= pyfits.PrimaryHDU(n)

2462

self.hdu= pyfits.PrimaryHDU(n)

2463

return self.hdu

2463

return self.hdu

2464

2465

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

2465

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

2466

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

2466

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

2467

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

2467

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

2468

return self.tbhdu

2468

return self.tbhdu

2469

2470

def CFile(self,hdu,tbhdu):

2470

def CFile(self,hdu,tbhdu):

2471

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

2471

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

2472

2473

def wFile(self,filename):

2473

def wFile(self,filename):

2474

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

2474

self.thdulist.writeto(filename)

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

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